@team-agent/installer 0.5.44 → 0.5.46

package/crates/team-agent/src/provider/session/capture.rs

@@ -8,6 +8,7 @@ use crate::provider::{
     CaptureSessionContext, CapturedSession, CapturedSessionCandidate, Provider, ProviderAdapter,
     ProviderError, SessionId,
 };
+use crate::state::identity_keys::SessionAttributionKey;
 
 pub const SESSION_CAPTURE_CONVERGENCE_DEADLINE_MS: u64 = 12_000;
 pub const SESSION_CAPTURE_CONVERGENCE_POLL_MS: u64 = 250;
@@ -638,6 +639,7 @@ pub fn incomplete_interacted_resumable_agent_ids(state: &Value) -> Vec<String> {
 struct PendingSessionCapture {
     agent_id: String,
     provider: Provider,
+    team_key: String,
     context: CaptureSessionContext,
 }
 
@@ -673,6 +675,13 @@ where
     Some(PendingSessionCapture {
         agent_id: agent_id.to_string(),
         provider,
+        team_key: agent
+            .get("owner_team_id")
+            .or_else(|| agent.get("team_key"))
+            .and_then(Value::as_str)
+            .filter(|s| !s.is_empty())
+            .unwrap_or("current")
+            .to_string(),
         context: CaptureSessionContext {
             agent_id: agent_id.to_string(),
             spawn_cwd: PathBuf::from(spawn_cwd),
@@ -883,14 +892,14 @@ fn allocate_session_candidates(
                     .as_ref()
                     .is_some_and(|sid| sid.as_str() == expected.as_str())
             })
-            .filter(|candidate| !candidate_keys_collide(candidate, claimed))
+            .filter(|candidate| !candidate_keys_collide(item, candidate, claimed))
             .collect();
         // Uniqueness requirement: only assign when the expected id maps to
         // exactly one available candidate. Multiple matches or a colliding
         // single match leave the agent for the ambiguity path below.
         if exact_matches.len() == 1 {
             let candidate = exact_matches[0].clone();
-            claimed.extend(captured_provider_session_keys(&candidate.captured));
+            claimed.extend(captured_provider_session_keys(item, &candidate.captured));
             assignments.insert(item.agent_id.clone(), candidate);
         }
     }
@@ -903,8 +912,9 @@ fn allocate_session_candidates(
             candidates_by_agent.get(&item.agent_id),
             claimed,
             CandidateMatchKind::PositiveAgentId,
+            item,
         ) {
-            claimed.extend(captured_provider_session_keys(&candidate.captured));
+            claimed.extend(captured_provider_session_keys(item, &candidate.captured));
             assignments.insert(item.agent_id.clone(), candidate);
         }
     }
@@ -916,8 +926,9 @@ fn allocate_session_candidates(
             candidates_by_agent.get(&item.agent_id),
             claimed,
             CandidateMatchKind::PathAgentId,
+            item,
         ) {
-            claimed.extend(captured_provider_session_keys(&candidate.captured));
+            claimed.extend(captured_provider_session_keys(item, &candidate.captured));
             assignments.insert(item.agent_id.clone(), candidate);
         }
     }
@@ -953,9 +964,10 @@ fn allocate_session_candidates(
             candidates_by_agent.get(&item.agent_id),
             claimed,
             CandidateMatchKind::Any,
+            item,
         ) {
             Some(candidate) => {
-                claimed.extend(captured_provider_session_keys(&candidate.captured));
+                claimed.extend(captured_provider_session_keys(item, &candidate.captured));
                 assignments.insert(item.agent_id.clone(), candidate);
             }
             None => {
@@ -995,11 +1007,14 @@ fn allocate_global_one_to_one(
         let Some(agent_candidates) = candidates_by_agent.get(agent_id) else {
             return;
         };
+        let Some(owner) = pending.iter().find(|item| item.agent_id == *agent_id) else {
+            continue;
+        };
         for candidate in agent_candidates {
-            if candidate_keys_collide(candidate, claimed) {
+            if candidate_keys_collide(owner, candidate, claimed) {
                 continue;
             }
-            let key = candidate_key(candidate);
+            let key = candidate_key(owner, candidate);
             if key.is_empty() {
                 continue;
             }
@@ -1010,7 +1025,9 @@ fn allocate_global_one_to_one(
         return;
     }
     for (agent_id, candidate) in remaining_agents.into_iter().zip(candidates.into_values()) {
-        claimed.extend(captured_provider_session_keys(&candidate.captured));
+        if let Some(item) = pending.iter().find(|item| item.agent_id == agent_id) {
+            claimed.extend(captured_provider_session_keys(item, &candidate.captured));
+        }
         assignments.insert(agent_id, candidate);
     }
 }
@@ -1035,6 +1052,7 @@ fn unique_available_candidate(
     candidates: Option<&Vec<CapturedSessionCandidate>>,
     claimed: &BTreeSet<String>,
     match_kind: CandidateMatchKind,
+    owner: &PendingSessionCapture,
 ) -> Option<CapturedSessionCandidate> {
     let matches = candidates?
         .iter()
@@ -1043,7 +1061,7 @@ fn unique_available_candidate(
             CandidateMatchKind::PathAgentId => candidate.agent_path_match,
             CandidateMatchKind::Any => true,
         })
-        .filter(|candidate| !candidate_keys_collide(candidate, claimed))
+        .filter(|candidate| !candidate_keys_collide(owner, candidate, claimed))
         .cloned()
         .collect::<Vec<_>>();
     if matches.len() == 1 {
@@ -1061,16 +1079,17 @@ enum CandidateMatchKind {
 }
 
 fn candidate_keys_collide(
+    owner: &PendingSessionCapture,
     candidate: &CapturedSessionCandidate,
     claimed: &BTreeSet<String>,
 ) -> bool {
-    captured_provider_session_keys(&candidate.captured)
+    captured_provider_session_keys(owner, &candidate.captured)
         .iter()
         .any(|key| claimed.contains(key))
 }
 
-fn candidate_key(candidate: &CapturedSessionCandidate) -> String {
-    captured_provider_session_keys(&candidate.captured)
+fn candidate_key(owner: &PendingSessionCapture, candidate: &CapturedSessionCandidate) -> String {
+    captured_provider_session_keys(owner, &candidate.captured)
         .into_iter()
         .collect::<Vec<_>>()
         .join("|")
@@ -1130,12 +1149,13 @@ fn claimed_provider_session_keys(
     pending_ids: &BTreeSet<String>,
 ) -> BTreeSet<String> {
     let mut keys = BTreeSet::new();
+    let team_key = crate::state::projection::team_state_key(state);
     // 1. Non-pending worker sessions (existing behaviour).
     for (agent_id, agent) in agents {
         if pending_ids.contains(agent_id) {
             continue;
         }
-        push_provider_session_keys(&mut keys, agent);
+        push_provider_session_keys(&mut keys, &team_key, agent_id, agent);
     }
     // 2. P0 (lane-046-capture-gap): leader anchor sessions. The leader's
     //    own provider transcript must never be attributed to a worker. Scan
@@ -1152,14 +1172,39 @@ fn claimed_provider_session_keys(
     keys
 }
 
-fn push_provider_session_keys(keys: &mut BTreeSet<String>, value: &Value) {
+fn push_provider_session_keys(
+    keys: &mut BTreeSet<String>,
+    fallback_team_key: &str,
+    fallback_agent_id: &str,
+    value: &Value,
+) {
+    let provider = value
+        .get("provider")
+        .and_then(Value::as_str)
+        .and_then(parse_provider)
+        .unwrap_or(Provider::Fake);
+    let team_key = value
+        .get("owner_team_id")
+        .or_else(|| value.get("team_key"))
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .unwrap_or(fallback_team_key);
+    let agent_id = value
+        .get("agent_id")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .unwrap_or(fallback_agent_id);
     for field in ["session_id", "provider_session_id"] {
         if let Some(session_id) = value
             .get(field)
             .and_then(Value::as_str)
             .filter(|s| !s.is_empty())
         {
-            keys.insert(format!("session:{session_id}"));
+            if let Some(key) = SessionAttributionKey::new(provider, team_key, agent_id, session_id)
+            {
+                keys.insert(session_attribution_key_string(&key));
+            }
+            keys.insert(global_session_attribution_key_string(session_id));
         }
     }
     for field in ["rollout_path", "transcript_path"] {
@@ -1168,7 +1213,10 @@ fn push_provider_session_keys(keys: &mut BTreeSet<String>, value: &Value) {
             .and_then(Value::as_str)
             .filter(|s| !s.is_empty())
         {
-            keys.insert(format!("rollout:{path}"));
+            keys.insert(transcript_attribution_key_string(
+                provider, team_key, agent_id, path,
+            ));
+            keys.insert(global_transcript_attribution_key_string(path));
         }
     }
 }
@@ -1176,25 +1224,68 @@ fn push_provider_session_keys(keys: &mut BTreeSet<String>, value: &Value) {
 fn push_leader_provider_session_keys(keys: &mut BTreeSet<String>, scope: &Value) {
     for anchor in ["leader_receiver", "team_owner"] {
         if let Some(node) = scope.get(anchor) {
-            push_provider_session_keys(keys, node);
+            push_provider_session_keys(keys, "leader", "leader", node);
         }
     }
 }
 
-fn captured_provider_session_keys(captured: &CapturedSession) -> BTreeSet<String> {
+fn captured_provider_session_keys(
+    owner: &PendingSessionCapture,
+    captured: &CapturedSession,
+) -> BTreeSet<String> {
     let mut keys = BTreeSet::new();
+    let team_key = owner.team_key.as_str();
     if let Some(session_id) = &captured.session_id {
-        keys.insert(format!("session:{}", session_id.as_str()));
+        if let Some(key) = SessionAttributionKey::new(
+            owner.provider,
+            team_key,
+            owner.agent_id.as_str(),
+            session_id.as_str(),
+        ) {
+            keys.insert(session_attribution_key_string(&key));
+        }
+        keys.insert(global_session_attribution_key_string(session_id.as_str()));
     }
     if let Some(rollout_path) = &captured.rollout_path {
-        keys.insert(format!(
-            "rollout:{}",
-            rollout_path.as_path().to_string_lossy()
+        let path = rollout_path.as_path().to_string_lossy();
+        keys.insert(transcript_attribution_key_string(
+            owner.provider,
+            team_key,
+            owner.agent_id.as_str(),
+            &path,
         ));
+        keys.insert(global_transcript_attribution_key_string(&path));
     }
     keys
 }
 
+fn session_attribution_key_string(key: &SessionAttributionKey) -> String {
+    format!(
+        "SessionAttributionKey(provider={:?},team={},agent={},session={})",
+        key.provider(),
+        key.team_key(),
+        key.agent_id(),
+        key.session_id()
+    )
+}
+
+fn transcript_attribution_key_string(
+    provider: Provider,
+    team_key: &str,
+    agent_id: &str,
+    path: &str,
+) -> String {
+    format!("TranscriptAttributionKey(provider={provider:?},team={team_key},agent={agent_id},path={path})")
+}
+
+fn global_session_attribution_key_string(session_id: &str) -> String {
+    format!("GlobalSessionAttributionKey(session={session_id})")
+}
+
+fn global_transcript_attribution_key_string(path: &str) -> String {
+    format!("GlobalTranscriptAttributionKey(path={path})")
+}
+
 #[cfg(test)]
 pub(crate) mod test_support {
     use super::*;

package/crates/team-agent/src/provider/session_scan/codex.rs

@@ -14,10 +14,13 @@ pub(super) fn apply_spawned_at_filter(
             Some(p) => p.as_path(),
             None => return false,
         };
-        std::fs::metadata(path)
-            .and_then(|meta| meta.modified())
-            .map(|mtime| mtime >= cutoff)
-            .unwrap_or(false)
+        match codex_rollout_created_at(path) {
+            Some(created_at) => created_at >= cutoff,
+            None => std::fs::metadata(path)
+                .and_then(|meta| meta.modified())
+                .map(|mtime| mtime >= cutoff)
+                .unwrap_or(false),
+        }
     });
 }
 
@@ -27,6 +30,50 @@ pub(super) fn parse_spawned_at(raw: &str) -> Option<std::time::SystemTime> {
         .map(|dt| std::time::SystemTime::from(dt.with_timezone(&chrono::Utc)))
 }
 
+fn codex_rollout_created_at(path: &std::path::Path) -> Option<std::time::SystemTime> {
+    created_at_from_rollout_head(path).or_else(|| created_at_from_rollout_filename(path))
+}
+
+fn created_at_from_rollout_head(path: &std::path::Path) -> Option<std::time::SystemTime> {
+    let text = super::common::read_head_text(path, super::common::CAPTURE_HEAD_BYTES).ok()?;
+    super::common::parse_session_records(&text)
+        .iter()
+        .find_map(record_created_at)
+        .and_then(|raw| parse_spawned_at(&raw))
+}
+
+fn record_created_at(record: &serde_json::Value) -> Option<String> {
+    record
+        .get("created_at")
+        .and_then(serde_json::Value::as_str)
+        .or_else(|| {
+            record
+                .get("session_meta")
+                .and_then(|v| v.get("payload"))
+                .or_else(|| record.get("payload"))
+                .and_then(|v| v.get("created_at"))
+                .and_then(serde_json::Value::as_str)
+        })
+        .map(ToString::to_string)
+}
+
+fn created_at_from_rollout_filename(path: &std::path::Path) -> Option<std::time::SystemTime> {
+    let name = path.file_name()?.to_str()?;
+    let start = name.find("rollout-")? + "rollout-".len();
+    let stamp = name.get(start..start + 19)?;
+    if stamp.as_bytes().get(10).copied() != Some(b'T') {
+        return None;
+    }
+    let raw = format!(
+        "{}T{}:{}:{}+00:00",
+        &stamp[0..10],
+        &stamp[11..13],
+        &stamp[14..16],
+        &stamp[17..19]
+    );
+    parse_spawned_at(&raw)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/crates/team-agent/src/tmux_backend/tests.rs

@@ -39,6 +39,36 @@ struct MockCommandRunner {
     default: MockResp,
 }
 
+/// Models the real build-before-destroy overlap: the spawn command creates `%new`, while a
+/// name-based lookup still resolves the same-named old window `%old`.
+struct SameNameSpawnRunner {
+    recorded: RecordedArgv,
+}
+
+impl CommandRunner for SameNameSpawnRunner {
+    fn run(&self, argv: &[String]) -> Result<CommandOutput, std::io::Error> {
+        self.recorded.lock().unwrap().push(argv.to_vec());
+        let output = match argv.get(1).map(String::as_str) {
+            Some("new-window") => ok("%new\n"),
+            Some("display-message") => ok("%old\n"),
+            Some("list-panes") => ok(
+                "%old\tteamsess\t0\tdeveloper\t0\t/dev/ttys001\tnode\t1\t/work/dir\t1\t0\t101\n\
+                 %new\tteamsess\t1\tdeveloper\t0\t/dev/ttys002\tnode\t1\t/work/dir\t1\t0\t202\n",
+            ),
+            _ => fail(64, "unexpected scripted tmux command"),
+        };
+        Ok(output)
+    }
+
+    fn run_with_stdin(
+        &self,
+        argv: &[String],
+        _stdin: &str,
+    ) -> Result<CommandOutput, std::io::Error> {
+        self.run(argv)
+    }
+}
+
 impl CommandRunner for MockCommandRunner {
     fn run(&self, argv: &[String]) -> Result<CommandOutput, std::io::Error> {
         self.recorded.lock().unwrap().push(argv.to_vec());
@@ -366,8 +396,7 @@ fn spawn_first_frames_via_new_session_builder_and_parses_pane_id() {
     let (be, rec) = backend_with(
         MockResp::Out(ok("")),
         vec![
-            MockResp::Out(ok("")),
-            MockResp::Out(ok("%3")),
+            MockResp::Out(ok("%3\n")),
             MockResp::Out(ok(pane_inventory)),
         ],
     );
@@ -383,7 +412,8 @@ fn spawn_first_frames_via_new_session_builder_and_parses_pane_id() {
             &env,
         )
         .expect("spawn_first");
-    let argv = rec.lock().unwrap()[0].clone();
+    let calls = rec.lock().unwrap().clone();
+    let argv = calls[0].clone();
     let cmd = argv.last().expect("the sh -lc command string").clone();
     assert_eq!(
         argv,
@@ -400,6 +430,12 @@ fn spawn_first_frames_via_new_session_builder_and_parses_pane_id() {
         "SpawnResult.pane_id must parse from the tmux output"
     );
     assert_eq!(result.child_pid, Some(123));
+    assert!(
+        calls
+            .iter()
+            .all(|call| call.get(1).is_none_or(|arg| arg != "display-message")),
+        "spawn_first identity must come from new-session stdout, never a display-message lookup; calls={calls:?}"
+    );
 }
 
 #[test]
@@ -408,8 +444,7 @@ fn spawn_into_frames_via_new_window_builder() {
     let (be, rec) = backend_with(
         MockResp::Out(ok("")),
         vec![
-            MockResp::Out(ok("")),
-            MockResp::Out(ok("%4")),
+            MockResp::Out(ok("%4\n")),
             MockResp::Out(ok(pane_inventory)),
         ],
     );
@@ -424,7 +459,8 @@ fn spawn_into_frames_via_new_window_builder() {
             &BTreeMap::new(),
         )
         .expect("spawn_into");
-    let argv = rec.lock().unwrap()[0].clone();
+    let calls = rec.lock().unwrap().clone();
+    let argv = calls[0].clone();
     let cmd = argv.last().expect("the sh -lc command string").clone();
     assert_eq!(
             argv,
@@ -432,16 +468,58 @@ fn spawn_into_frames_via_new_window_builder() {
             "spawn_into must frame via tmux_spawn_argv first=false (new-window -t <s> -n <w> sh -lc <cmd>)"
         );
     assert_eq!(result.pane_id.as_str(), "%4");
+    assert!(
+        calls
+            .iter()
+            .all(|call| call.get(1).is_none_or(|arg| arg != "display-message")),
+        "spawn_into identity must come from new-window stdout, never a display-message lookup; calls={calls:?}"
+    );
+}
+
+#[test]
+fn spawn_into_same_named_replacement_returns_identity_created_by_spawn_command() {
+    let recorded = Arc::new(Mutex::new(Vec::new()));
+    let be = TmuxBackend::with_runner(Box::new(SameNameSpawnRunner {
+        recorded: Arc::clone(&recorded),
+    }));
+
+    let result = be
+        .spawn_into(
+            &SessionName::new("teamsess"),
+            &WindowName::new("developer"),
+            &svec(&["provider-bin"]),
+            Path::new("/work/dir"),
+            &BTreeMap::new(),
+        )
+        .expect("same-name replacement spawn");
+    let calls = recorded.lock().unwrap().clone();
+    let name_based_identity_lookup = calls.iter().any(|call| {
+        call.get(1).is_some_and(|arg| arg == "display-message")
+            && call
+                .iter()
+                .position(|arg| arg == "-t")
+                .and_then(|index| call.get(index + 1))
+                .is_some_and(|target| target == "teamsess:developer")
+    });
+
+    assert_eq!(
+        result.pane_id.as_str(),
+        "%new",
+        "spawn_into must return the pane identity atomically emitted by this new-window command, not the same-named old window; calls={calls:?}"
+    );
+    assert!(
+        !name_based_identity_lookup,
+        "spawn identity must not be re-derived through ambiguous session:window display-message; calls={calls:?}"
+    );
 }
 
 #[test]
-fn spawn_with_command_refuses_display_message_pane_owned_by_other_window() {
+fn spawn_with_command_refuses_spawn_pane_owned_by_other_window() {
     let pane_inventory = "%5\tteamsess\t1\tw2\t0\t/dev/ttys005\tnode\t1\t/work/dir\t1\t0\t125\n";
     let (be, _rec) = backend_with(
         MockResp::Out(ok("")),
         vec![
-            MockResp::Out(ok("")),
-            MockResp::Out(ok("%5")),
+            MockResp::Out(ok("%5\n")),
             MockResp::Out(ok(pane_inventory)),
         ],
     );
@@ -453,7 +531,7 @@ fn spawn_with_command_refuses_display_message_pane_owned_by_other_window() {
             Path::new("/work/dir"),
             &BTreeMap::new(),
         )
-        .expect_err("display-message fallback to w2 pane must fail closed");
+        .expect_err("spawn stdout pane owned by w2 must fail closed");
     let msg = err.to_string();
     assert!(
         msg.contains("requested=teamsess:w1")
@@ -463,6 +541,34 @@ fn spawn_with_command_refuses_display_message_pane_owned_by_other_window() {
     );
 }
 
+#[test]
+fn spawn_with_command_empty_stdout_fails_closed_without_identity_fallback() {
+    let (be, rec) = backend_with(MockResp::Out(ok("")), vec![MockResp::Out(ok(""))]);
+    let err = be
+        .spawn_into(
+            &SessionName::new("teamsess"),
+            &WindowName::new("developer"),
+            &svec(&["provider-bin"]),
+            Path::new("/work/dir"),
+            &BTreeMap::new(),
+        )
+        .expect_err("empty new-window stdout must fail closed");
+    let msg = err.to_string().to_ascii_lowercase();
+    let calls = rec.lock().unwrap().clone();
+    let used_identity_fallback = calls
+        .iter()
+        .any(|call| call.get(1).is_some_and(|arg| arg == "display-message"));
+
+    assert!(
+        msg.contains("spawn") && (msg.contains("empty") || msg.contains("no pane id")),
+        "empty spawn stdout error must name the missing spawn identity; error={err}; calls={calls:?}"
+    );
+    assert!(
+        !used_identity_fallback,
+        "empty spawn stdout must not fall back to ambiguous display-message identity lookup; calls={calls:?}"
+    );
+}
+
 #[test]
 fn spawn_split_selects_even_horizontal_not_tiled() {
     let (be, rec) = backend_with(

package/crates/team-agent/src/tmux_backend.rs

@@ -765,25 +765,14 @@ impl TmuxBackend {
         first: bool,
     ) -> Result<SpawnResult, TransportError> {
         let spawn_argv = tmux_spawn_argv(session, window, command, first);
-        self.run_spawn(&spawn_argv)?;
-        let pane_argv = vec![
-            "tmux".to_string(),
-            "display-message".to_string(),
-            "-p".to_string(),
-            "-t".to_string(),
-            format!("{}:{}", session.as_str(), window.as_str()),
-            "#{pane_id}".to_string(),
-        ];
-        let output = self.run_spawn(&pane_argv)?;
+        let output = self.run_spawn(&spawn_argv)?;
         let pane = output.stdout.trim();
-        // T3-5 (harvest §1): never fabricate a `%0` pane id on an empty reply — a fake
-        // pane id mis-addresses every later inject/capture/kill. Surface the miss.
         if pane.is_empty() {
             return Err(TransportError::Subprocess {
-                argv: pane_argv,
+                argv: spawn_argv,
                 code: output.code,
                 stderr: format!(
-                    "tmux display-message returned no pane id for {}:{}",
+                    "tmux spawn returned no pane id for {}:{}",
                     session.as_str(),
                     window.as_str()
                 ),
@@ -822,10 +811,10 @@ impl TmuxBackend {
             })
             .unwrap_or_else(|| "<missing-from-list-targets>".to_string());
         Err(TransportError::Subprocess {
-            argv: pane_argv,
+            argv: spawn_argv,
             code: output.code,
             stderr: format!(
-                "tmux spawn pane ownership mismatch: requested={}:{} observed_pane={} observed={}",
+                "tmux spawn pane identity mismatch: requested={}:{} observed_pane={} observed={}",
                 session.as_str(),
                 window.as_str(),
                 pane_id.as_str(),

package/crates/team-agent/src/transport/tests/wire.rs

@@ -238,6 +238,9 @@ fn spawn_first_returns_stable_addressable_target_then_reachable() {
             "tmux",
             "new-session",
             "-d",
+            "-P",
+            "-F",
+            "#{pane_id}",
             "-s",
             "team-sess",
             "-n",
@@ -287,6 +290,9 @@ fn spawn_into_then_list_targets_enumerates_it() {
             "tmux",
             "new-window",
             "-d",
+            "-P",
+            "-F",
+            "#{pane_id}",
             "-t",
             "team-sess",
             "-n",

package/crates/team-agent/src/transport.rs

@@ -918,8 +918,8 @@ pub fn tmux_query_argv(pane: &PaneId, field: PaneField) -> Vec<String> {
 
 /// spawn argv:首个 session 用 new-session,后续 worker 用 new-window。
 /// golden(terminal.py:44-45 / runtime.py:1019-1020):
-///   first → `new-session -d -s <s> -n <w> sh -lc <cmd>`
-///   into  → `new-window -t <s> -n <w> sh -lc <cmd>`
+///   first → `new-session -d -P -F #{pane_id} -s <s> -n <w> sh -lc <cmd>`
+///   into  → `new-window -d -P -F #{pane_id} -t <s> -n <w> sh -lc <cmd>`
 /// `argv` 被组装成单条 `sh -lc` 命令字符串(provider 启动行)。
 pub fn tmux_spawn_argv(
     session: &SessionName,
@@ -932,6 +932,9 @@ pub fn tmux_spawn_argv(
             "tmux".to_string(),
             "new-session".to_string(),
             "-d".to_string(),
+            "-P".to_string(),
+            "-F".to_string(),
+            "#{pane_id}".to_string(),
             "-s".to_string(),
             session.as_str().to_string(),
             "-n".to_string(),
@@ -952,6 +955,9 @@ pub fn tmux_spawn_argv(
             "tmux".to_string(),
             "new-window".to_string(),
             "-d".to_string(),
+            "-P".to_string(),
+            "-F".to_string(),
+            "#{pane_id}".to_string(),
             "-t".to_string(),
             session.as_str().to_string(),
             "-n".to_string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.44",
+  "version": "0.5.46",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.44",
-    "@team-agent/cli-darwin-x64": "0.5.44",
-    "@team-agent/cli-linux-x64": "0.5.44"
+    "@team-agent/cli-darwin-arm64": "0.5.46",
+    "@team-agent/cli-darwin-x64": "0.5.46",
+    "@team-agent/cli-linux-x64": "0.5.46"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",