feat(forgecode): v3 — :reparent/:cwd commands, sort UI, cwd+message_count migration

crates/forge_api/src/api.rs

@@ -122,6 +122,24 @@ pub trait API: Sync + Send {
     /// disk footprint. Safe to call at any time; safe to call repeatedly.
     async fn optimize_fts_index(&self) -> Result<()>;
 
+    /// Re-binds a subagent conversation to a different parent. Pass `None`
+    /// for `new_parent_id` to detach (promotes the subagent to a top-level
+    /// session). Atomic single-row update; does not recurse into descendants.
+    async fn update_parent_id(
+        &self,
+        conversation_id: &ConversationId,
+        new_parent_id: Option<&ConversationId>,
+    ) -> Result<()>;
+
+    /// Retrieves conversations whose `cwd` column matches the given path
+    /// exactly. Used by the session viewer to filter by current working
+    /// directory (per-project scoping).
+    async fn get_conversations_by_cwd(
+        &self,
+        cwd: &str,
+        limit: Option<usize>,
+    ) -> Result<Option<Vec<Conversation>>>;
+
     /// Renames a conversation by setting its title
     ///
     /// # Arguments

crates/forge_api/src/forge_api.rs

@@ -242,6 +242,24 @@ impl<
         self.services.optimize_fts_index().await
     }
 
+    async fn update_parent_id(
+        &self,
+        conversation_id: &ConversationId,
+        new_parent_id: Option<&ConversationId>,
+    ) -> Result<()> {
+        self.services
+            .update_parent_id(conversation_id, new_parent_id)
+            .await
+    }
+
+    async fn get_conversations_by_cwd(
+        &self,
+        cwd: &str,
+        limit: Option<usize>,
+    ) -> Result<Option<Vec<Conversation>>> {
+        self.services.get_conversations_by_cwd(cwd, limit).await
+    }
+
     async fn rename_conversation(
         &self,
         conversation_id: &ConversationId,

crates/forge_app/src/services.rs

@@ -298,6 +298,24 @@ pub trait ConversationService: Send + Sync {
     /// back into a single segment, reducing query-time shadow-walk cost and
     /// disk footprint. Safe to call at any time; safe to call repeatedly.
     async fn optimize_fts_index(&self) -> anyhow::Result<()>;
+
+    /// Re-binds a subagent conversation to a different parent. Pass `None`
+    /// for `new_parent_id` to detach (promotes the subagent to a top-level
+    /// session). Atomic single-row update; does not recurse into descendants.
+    async fn update_parent_id(
+        &self,
+        conversation_id: &ConversationId,
+        new_parent_id: Option<&ConversationId>,
+    ) -> anyhow::Result<()>;
+
+    /// Retrieves conversations whose `cwd` column matches the given path
+    /// exactly. Used by the session viewer to filter by current working
+    /// directory (per-project scoping).
+    async fn get_conversations_by_cwd(
+        &self,
+        cwd: &str,
+        limit: Option<usize>,
+    ) -> anyhow::Result<Option<Vec<Conversation>>>;
 }
 
 #[async_trait::async_trait]
@@ -723,6 +741,26 @@ impl<I: Services> ConversationService for I {
     async fn optimize_fts_index(&self) -> anyhow::Result<()> {
         self.conversation_service().optimize_fts_index().await
     }
+
+    async fn update_parent_id(
+        &self,
+        conversation_id: &ConversationId,
+        new_parent_id: Option<&ConversationId>,
+    ) -> anyhow::Result<()> {
+        self.conversation_service()
+            .update_parent_id(conversation_id, new_parent_id)
+            .await
+    }
+
+    async fn get_conversations_by_cwd(
+        &self,
+        cwd: &str,
+        limit: Option<usize>,
+    ) -> anyhow::Result<Option<Vec<Conversation>>> {
+        self.conversation_service()
+            .get_conversations_by_cwd(cwd, limit)
+            .await
+    }
 }
 #[async_trait::async_trait]
 impl<I: Services> ProviderService for I {

crates/forge_domain/src/conversation.rs

@@ -48,6 +48,18 @@ pub struct Conversation {
     pub metadata: MetaData,
     pub parent_id: Option<ConversationId>,
     pub source: Option<String>,
+    /// Working directory of the agent when the conversation was created.
+    /// Used for grouping / filtering in the session selector and for FTS5
+    /// search so a user can find sessions by cwd fragment (e.g. "forgecode").
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cwd: Option<String>,
+    /// Number of message entries in `context.messages` at the time of the
+    /// last write. Used to display a turn count in the session selector
+    /// and as a stable secondary sort key when the user picks "by turns".
+    /// Kept as a column (not a derived getter) so the selector does not
+    /// have to deserialize the full Context blob for every row.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message_count: Option<i32>,
 }
 
 #[derive(Debug, Setters, Serialize, Deserialize, Clone)]
@@ -75,6 +87,8 @@ impl Conversation {
             context: None,
             parent_id: None,
             source: None,
+            cwd: None,
+            message_count: None,
         }
     }
     /// Creates a new conversation with a new conversation ID.

crates/forge_domain/src/repo.rs

@@ -182,6 +182,47 @@ pub trait ConversationRepository: Send + Sync {
     /// # Errors
     /// Returns an error if the optimize statement fails to execute.
     async fn optimize_fts_index(&self) -> Result<()>;
+
+    /// Re-binds a subagent conversation to a different parent. Pass `None`
+    /// for `new_parent_id` to detach the conversation entirely (promotes it
+    /// to a top-level session).
+    ///
+    /// The existing `parent_id` (if any) is replaced atomically; no other
+    /// columns are touched. This does not recurse into descendants —
+    /// subagents of the reparented conversation remain linked to *this*
+    /// conversation.
+    ///
+    /// # Arguments
+    /// * `conversation_id` - The conversation to reparent.
+    /// * `new_parent_id` - The new parent, or `None` to detach.
+    ///
+    /// # Errors
+    /// Returns an error if the update fails or the conversation does not
+    /// exist.
+    async fn update_parent_id(
+        &self,
+        conversation_id: &ConversationId,
+        new_parent_id: Option<&ConversationId>,
+    ) -> Result<()>;
+
+    /// Retrieves conversations by working directory (cwd).
+    ///
+    /// Used by the session viewer to scope by cwd (per-project filtering).
+    /// The match is an exact equality on the `cwd` column, not a fuzzy
+    /// search — combine with [`Self::search_conversations`] for substring
+    /// matching.
+    ///
+    /// # Arguments
+    /// * `cwd` - Exact cwd to match.
+    /// * `limit` - Optional cap on returned rows.
+    ///
+    /// # Errors
+    /// Returns an error if the query fails.
+    async fn get_conversations_by_cwd(
+        &self,
+        cwd: &str,
+        limit: Option<usize>,
+    ) -> Result<Option<Vec<Conversation>>>;
 }
 
 #[async_trait::async_trait]

crates/forge_main/src/model.rs

@@ -689,6 +689,29 @@ pub enum AppCommand {
     #[command(alias = "p")]
     Parent,
 
+    /// Re-bind the current (subagent) conversation to a different parent.
+    /// Usage: `:reparent <parent_id>` or `:reparent --detach` to promote to a
+    /// top-level session.
+    #[strum(props(usage = "Re-parent the current session. Usage: :reparent <id>|--detach"))]
+    #[command(alias = "rp")]
+    Reparent {
+        /// New parent conversation ID, or `--detach` to promote this
+        /// session to top-level.
+        #[arg(trailing_var_arg = true, num_args = 0..)]
+        target: Vec<String>,
+    },
+
+    /// Filter conversations by working directory. Usage: `:cwd <path>` or
+    /// `:cwd --current` to scope to the current shell cwd.
+    #[strum(props(usage = "Filter conversations by cwd. Usage: :cwd <path>|--current"))]
+    #[command(alias = "cw")]
+    Cwd {
+        /// Cwd to filter by (exact match), or `--current` to use the
+        /// current shell working directory.
+        #[arg(trailing_var_arg = true, num_args = 0..)]
+        target: Vec<String>,
+    },
+
     /// Full-text search over conversation titles and contents (FTS5 BM25).
     /// Usage: `:search <query>` or `:search "rust refactor"`.
     #[strum(props(usage = "Search conversation history. Usage: :search <query>"))]
@@ -787,6 +810,8 @@ impl AppCommand {
             AppCommand::Goal { .. } => "goal",
             AppCommand::Loop { .. } => "loop",
             AppCommand::Parent => "parent",
+            AppCommand::Reparent { .. } => "reparent",
+            AppCommand::Cwd { .. } => "cwd",
             AppCommand::Search { .. } => "search",
             AppCommand::Delete => "delete",
             AppCommand::Rename { .. } => "rename",

crates/forge_main/src/state.rs

@@ -14,6 +14,10 @@ pub struct UIState {
     pub goal: Option<String>,
     pub loop_enabled: bool,
     pub last_activity: Instant,
+    /// CWD filter for the conversation selector. When set, the selector
+    /// scopes its results to conversations whose `cwd` column matches.
+    /// This is the "filter by project directory" UX.
+    pub cwd_filter: Option<String>,
 }
 
 impl Default for UIState {
@@ -24,12 +28,20 @@ impl Default for UIState {
             goal: None,
             loop_enabled: false,
             last_activity: Instant::now(),
+            cwd_filter: None,
         }
     }
 }
 
 impl UIState {
     pub fn new(env: Environment) -> Self {
-        Self { cwd: env.cwd, conversation_id: Default::default(), goal: None, loop_enabled: false, last_activity: Instant::now() }
+        Self {
+            cwd: env.cwd,
+            conversation_id: Default::default(),
+            goal: None,
+            loop_enabled: false,
+            last_activity: Instant::now(),
+            cwd_filter: None,
+        }
     }
 }

crates/forge_main/src/ui.rs

@@ -2328,6 +2328,101 @@ impl<A: API + ConsoleWriter + 'static, F: Fn(ForgeConfig) -> A + Send + Sync> UI
         Ok(())
     }
 
+    /// Re-binds the current (subagent) conversation to a different parent.
+    /// Usage:
+    ///   - `:reparent <parent_id>`  → attach to the given parent
+    ///   - `:reparent --detach`     → promote this session to top-level
+    ///   - `:reparent`              → no-arg; shows usage hint
+    async fn handle_reparent(&mut self, target: Vec<String>) -> anyhow::Result<()> {
+        let conversation_id = match self.state.conversation_id {
+            Some(id) => id,
+            None => {
+                self.writeln_title(TitleFormat::error(
+                    "No active session. Start a conversation first.",
+                ))?;
+                return Ok(());
+            }
+        };
+
+        if target.is_empty() {
+            self.writeln_title(TitleFormat::info(
+                "Usage: :reparent <parent_id> | :reparent --detach",
+            ))?;
+            return Ok(());
+        }
+
+        // `:reparent --detach` → detach (None)
+        // `:reparent <anything else>` → parse as a ConversationId
+        let new_parent_id = if target.iter().any(|t| t == "--detach") {
+            None
+        } else {
+            let raw = target.join(" ").trim().to_string();
+            match ConversationId::parse(&raw) {
+                Ok(id) => Some(id),
+                Err(err) => {
+                    self.writeln_title(TitleFormat::error(format!(
+                        "Invalid parent ID {raw:?}: {err}"
+                    )))?;
+                    return Ok(());
+                }
+            }
+        };
+
+        self.api
+            .update_parent_id(&conversation_id, new_parent_id.as_ref())
+            .await?;
+
+        let msg = match new_parent_id {
+            Some(pid) => format!(
+                "Re-parented current session to {}.",
+                pid.into_string().bold()
+            ),
+            None => "Detached current session — promoted to top-level.".to_string(),
+        };
+        self.writeln_title(TitleFormat::info(msg))?;
+        Ok(())
+    }
+
+    /// Filters the conversation list by working directory. Usage:
+    ///   - `:cwd <path>`       → exact-match cwd filter
+    ///   - `:cwd --current`    → use the current shell working directory
+    ///   - `:cwd --clear`      → clear the cwd filter
+    async fn handle_cwd(&mut self, target: Vec<String>) -> anyhow::Result<()> {
+        if target.is_empty() || target.iter().any(|t| t == "--help" || t == "-h") {
+            self.writeln_title(TitleFormat::info(
+                "Usage: :cwd <path> | :cwd --current | :cwd --clear",
+            ))?;
+            return Ok(());
+        }
+
+        if target.iter().any(|t| t == "--clear") {
+            self.state.cwd_filter = None;
+            self.writeln_title(TitleFormat::info("Cleared cwd filter."))?;
+            return Ok(());
+        }
+
+        let cwd = if target.iter().any(|t| t == "--current") {
+            match std::env::current_dir() {
+                Ok(p) => p.to_string_lossy().to_string(),
+                Err(err) => {
+                    self.writeln_title(TitleFormat::error(format!(
+                        "Failed to read current dir: {err}"
+                    )))?;
+                    return Ok(());
+                }
+            }
+        } else {
+            target.join(" ").trim().to_string()
+        };
+
+        self.state.cwd_filter = Some(cwd.clone());
+        self.writeln_title(TitleFormat::info(format!(
+            "Cwd filter set to {}",
+            cwd.bold()
+        )))?;
+        Ok(())
+    }
+
     fn user_initiated_conversations(conversations: Vec<Conversation>) -> Vec<Conversation> {
         let related_ids: HashSet<ConversationId> = conversations
             .iter()
@@ -2382,6 +2477,12 @@ impl<A: API + ConsoleWriter + 'static, F: Fn(ForgeConfig) -> A + Send + Sync> UI
             AppCommand::Parent => {
                 self.handle_parent().await?;
             }
+            AppCommand::Reparent { target } => {
+                self.handle_reparent(target).await?;
+            }
+            AppCommand::Cwd { target } => {
+                self.handle_cwd(target).await?;
+            }
             AppCommand::Search { query } => {
                 self.handle_search(query).await?;
             }