fix(hooks): sync routed tracked worktree branches

Author: ScriptedAlchemy

src/daemon.rs

@@ -2428,7 +2428,7 @@ mod tests {
                 let (stream, _addr) = listener.accept().await.expect("accept daemon client");
                 let engine = engine.clone();
                 tasks.push(tokio::spawn(async move {
-                    super::serve_socket_client(stream, engine)
+                    Box::pin(super::serve_socket_client(stream, engine))
                         .await
                         .expect("serve proxied client");
                 }));

src/mcp/hook_events.rs

@@ -52,8 +52,15 @@ pub(crate) struct HookEvent {
 pub(crate) enum HookEventPlan {
     SyncFiles(Vec<String>),
     AddBranch(String),
-    AddBranchAt { root: PathBuf, branch: String },
-    SyncCurrentBranch { branch: String, agent: HookAgent },
+    AddBranchAt {
+        root: PathBuf,
+        branch: String,
+        agent: HookAgent,
+    },
+    SyncCurrentBranch {
+        branch: String,
+        agent: HookAgent,
+    },
     DebouncedIncrementalSync(HookAgent),
     Noop,
 }
@@ -153,14 +160,15 @@ fn plan_shell_hook_event(
     };
     match crate::hooks::cursor_shell_sync_plan_with_current_branch(command, current_branch) {
         crate::hooks::CursorShellSyncPlan::BranchAdd(branch) => {
-            branch_plan_for_root(project_root, hook_project_root, branch)
+            branch_plan_for_root(project_root, hook_project_root, branch, event.agent)
         }
         crate::hooks::CursorShellSyncPlan::WorktreeBranchAdd {
             branch,
             worktree_path,
         } => HookEventPlan::AddBranchAt {
             root: crate::hooks::resolve_worktree_add_root(command, cwd, &worktree_path),
             branch,
+            agent: event.agent,
         },
         crate::hooks::CursorShellSyncPlan::IncrementalSync => {
             HookEventPlan::DebouncedIncrementalSync(event.agent)
@@ -175,6 +183,7 @@ fn plan_shell_hook_event(
                 HookEventPlan::AddBranchAt {
                     root: hook_project_root,
                     branch,
+                    agent: event.agent,
                 }
             }
         }
@@ -203,13 +212,15 @@ fn branch_plan_for_root(
     project_root: &Path,
     hook_project_root: PathBuf,
     branch: String,
+    agent: HookAgent,
 ) -> HookEventPlan {
     if paths_same(&hook_project_root, project_root) {
         HookEventPlan::AddBranch(branch)
     } else {
         HookEventPlan::AddBranchAt {
             root: hook_project_root,
             branch,
+            agent,
         }
     }
 }
@@ -320,14 +331,20 @@ mod tests {
     }
 
     fn assert_add_branch_at(plan: HookEventPlan, expected_root: &Path, expected_branch: &str) {
-        let HookEventPlan::AddBranchAt { root, branch } = plan else {
+        let HookEventPlan::AddBranchAt {
+            root,
+            branch,
+            agent,
+        } = plan
+        else {
             panic!("expected AddBranchAt plan, got {plan:?}");
         };
         assert!(
             super::paths_same(&root, expected_root),
             "planned root {root:?} should match expected root {expected_root:?}"
         );
         assert_eq!(branch, expected_branch);
+        assert_eq!(agent, HookAgent::Codex);
     }
 
     fn write_project_marker(root: &Path) {
@@ -543,6 +560,7 @@ mod tests {
             HookEventPlan::AddBranchAt {
                 root: Path::new("/tmp/wt").to_path_buf(),
                 branch: "feature/daemon-hooks".to_string(),
+                agent: HookAgent::Codex,
             }
         );
     }
@@ -576,6 +594,7 @@ mod tests {
             HookEventPlan::AddBranchAt {
                 root: base_root.join("wt"),
                 branch: "feature/daemon-hooks".to_string(),
+                agent: HookAgent::Codex,
             }
         );
     }

src/mcp/server.rs

@@ -1708,14 +1708,29 @@ impl McpServer {
                     Err(e) => eprintln!("[tracedecay] hook branch tracking failed: {e}"),
                 }
             }
-            HookEventPlan::AddBranchAt { root, branch } => {
-                // The new worktree root is not this server's checkout, so no
-                // reopen or token-map refresh applies here (unlike AddBranch);
-                // branch tracking against the shared store is the whole job.
+            HookEventPlan::AddBranchAt {
+                root,
+                branch,
+                agent,
+            } => {
+                // The routed worktree root is not this server's checkout, so
+                // reopen/token-map refresh only applies after opening that root.
                 match self.add_hook_branch_tracking(&root, &branch, &cg).await {
+                    Ok(crate::branch::BranchAddOutcome::AlreadyTracked) => {
+                        match TraceDecay::open_with_options(&root, cg.open_options()).await {
+                            Ok(worktree_cg) => {
+                                self.run_hook_incremental_sync(Arc::new(worktree_cg), agent)
+                                    .await;
+                            }
+                            Err(e) => {
+                                eprintln!(
+                                    "[tracedecay] hook worktree branch sync open failed: {e}"
+                                );
+                            }
+                        }
+                    }
                     Ok(
                         crate::branch::BranchAddOutcome::Added
-                        | crate::branch::BranchAddOutcome::AlreadyTracked
                         | crate::branch::BranchAddOutcome::Deferred
                         | crate::branch::BranchAddOutcome::NotIndexed,
                     ) => {}