@team-agent/installer 0.3.3 → 0.3.5

package/crates/team-agent/src/provider/classify.rs

@@ -50,7 +50,9 @@ pub fn latest_explicit_error_fact(provider: Provider, session_log_text: &str) ->
     match provider {
         Provider::Codex => codex_latest_explicit_error_fact(&record),
         Provider::Claude | Provider::ClaudeCode => claude_latest_explicit_error_fact(&record),
-        Provider::GeminiCli | Provider::Fake => None,
+        // C-3-5 cr verdict: copilot N35 通知不依赖 turn-state 分类;一期 Unknown,
+        // 与 GeminiCli/Fake 同精神。二期接 sqlite turns 表后再回填。
+        Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
     }
 }
 
@@ -155,7 +157,9 @@ fn extract_lifecycle_facts(provider: Provider, records: &[serde_json::Value]) ->
         .filter_map(|record| match provider {
             Provider::Claude | Provider::ClaudeCode => claude_lifecycle_fact(record),
             Provider::Codex => codex_lifecycle_fact(record),
-            Provider::GeminiCli | Provider::Fake => None,
+            // C-3-1 cr verdict: copilot lifecycle facts 一期不导出(classify→None,
+            // Unknown);二期读 sqlite turns 表(turn_index/assistant_response)。
+            Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
         })
         .collect()
 }

package/crates/team-agent/src/provider/faults.rs

@@ -17,7 +17,8 @@ pub fn explicit_error_fact(record: &serde_json::Value, provider: Provider) -> Op
     match provider {
         Provider::Codex => codex_explicit_error_fact(record),
         Provider::Claude | Provider::ClaudeCode => claude_explicit_error_fact(record),
-        Provider::GeminiCli | Provider::Fake => None,
+        // copilot 一期不接 jsonl 真相源(C-3-5)。
+        Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
     }
 }
 
@@ -59,7 +60,7 @@ fn fault_fact(provider: Provider, record: &serde_json::Value) -> Option<FaultFac
     match provider {
         Provider::Claude | Provider::ClaudeCode => claude_fault_fact(record),
         Provider::Codex => codex_fault_fact(record),
-        Provider::GeminiCli | Provider::Fake => None,
+        Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
     }
 }
 

package/crates/team-agent/src/provider/startup_prompt.rs

@@ -232,17 +232,31 @@ fn max_two(a: Option<usize>, b: Option<usize>) -> Option<usize> {
 /// + push {prompt:"codex_update_available", action:"sent_skip"}; on `Ready` -> stop. Loops up to
 ///   `checks` (golden default 30), `sleep_s` (golden 0.5) between iterations. Returns the ordered
 ///   `handled` list. Capture is full scrollback (golden `tmux capture-pane -p -S - -t <target>`).
+/// swallow batch 2 ② (A1): the structured startup-prompt outcome — `handled` keeps the
+/// Python golden list shape; `capture_error` carries the FIRST capture failure so the
+/// caller can surface it (an unobservable pane must never be silently treated as
+/// "no prompts to handle").
+#[derive(Debug, Clone, Default)]
+pub struct StartupPromptOutcome {
+    pub handled: Vec<HandledPrompt>,
+    pub capture_error: Option<String>,
+}
+
 pub fn codex_handle_startup_prompts(
     transport: &dyn Transport,
     target: &Target,
     checks: usize,
     sleep_s: f64,
-) -> Vec<HandledPrompt> {
+) -> StartupPromptOutcome {
     let mut handled = Vec::new();
+    let mut capture_error: Option<String> = None;
     for _ in 0..checks {
         let screen = match transport.capture(target, CaptureRange::Full) {
             Ok(captured) => captured.text,
-            Err(_) => String::new(),
+            Err(error) => {
+                capture_error.get_or_insert_with(|| error.to_string());
+                String::new()
+            }
         };
         match classify_codex_startup_screen(&screen) {
             StartupScreenDecision::SkipUpdatePrompt => {
@@ -265,7 +279,7 @@ pub fn codex_handle_startup_prompts(
             StartupScreenDecision::KeepPolling => sleep_between_polls(sleep_s),
         }
     }
-    handled
+    StartupPromptOutcome { handled, capture_error }
 }
 
 pub fn claude_handle_startup_prompts(
@@ -273,12 +287,16 @@ pub fn claude_handle_startup_prompts(
     target: &Target,
     checks: usize,
     sleep_s: f64,
-) -> Vec<HandledPrompt> {
+) -> StartupPromptOutcome {
     let mut handled = Vec::new();
+    let mut capture_error: Option<String> = None;
     for _ in 0..checks {
         let screen = match transport.capture(target, CaptureRange::Full) {
             Ok(captured) => captured.text,
-            Err(_) => String::new(),
+            Err(error) => {
+                capture_error.get_or_insert_with(|| error.to_string());
+                String::new()
+            }
         };
         match classify_claude_startup_screen(&screen) {
             StartupScreenDecision::AnswerWorkspaceTrust => {
@@ -295,7 +313,7 @@ pub fn claude_handle_startup_prompts(
             }
         }
     }
-    handled
+    StartupPromptOutcome { handled, capture_error }
 }
 
 fn max_rfind(output: &str, needles: &[&str]) -> Option<usize> {
@@ -498,7 +516,7 @@ mod tests {
         };
         let target = Target::Pane(PaneId::new("%1"));
 
-        let handled = codex_handle_startup_prompts(&t, &target, 5, 0.0);
+        let handled = codex_handle_startup_prompts(&t, &target, 5, 0.0).handled;
 
         assert_eq!(
             handled,

package/crates/team-agent/src/provider/types.rs

@@ -143,10 +143,17 @@ pub enum Confidence {
 }
 
 /// auth_hint 状态(`adapter.py:38` 等)。doctor 用。
+///
+/// `PresentWeak`(C-A-5 cr verdict v2):provider 无 auth-status 子命令(如 copilot
+/// — main-help Commands 节仅 completion/help/init/login/mcp/plugin/update/version,
+/// **无 status**)时,framework 只能弱检测(命令在 PATH + ~/.copilot/config.json
+/// 存在 等表层信号)。诚实 surface(MUST-NOT-13)— 不假报"已登录",doctor 文案
+/// 标"weak / no auth-status command available"。
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum AuthHintStatus {
     Present,
+    PresentWeak,
     Missing,
     MissingOrUnknown,
     Unknown,
@@ -311,6 +318,10 @@ pub struct ProviderCaps {
 #[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub struct ProviderCommandOverrides {
     pub model: Option<String>,
+    /// Python `provider_env.py:62-65` — profile CODEX_PROFILE/NATIVE_PROFILE → `--profile <x>`.
+    pub codex_profile: Option<String>,
+    /// Python `provider_env.py:66-79` — compatible_api model_provider `-c` items, verbatim.
+    pub codex_config: Vec<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]

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

@@ -609,6 +609,7 @@ fn parse_provider(raw: &str) -> Option<Provider> {
         "claude" => Some(Provider::Claude),
         "claude_code" => Some(Provider::ClaudeCode),
         "codex" => Some(Provider::Codex),
+        "copilot" => Some(Provider::Copilot),
         "gemini_cli" => Some(Provider::GeminiCli),
         "fake" => Some(Provider::Fake),
         _ => None,

package/crates/team-agent/src/state/persist.rs

@@ -270,20 +270,27 @@ fn read_latest_state_under_lock(workspace: &Path, path: &Path) -> Option<Value>
 }
 
 fn preserve_latest_roster_entries(incoming: &mut Value, latest: &Value, deleted_agent_ids: &BTreeSet<String>) {
-    if !same_runtime_projection(incoming, latest) {
-        return;
+    // A0/R1: the projection gate only guards the TOP-LEVEL passes (top-level agents and
+    // the top-level<->active-team cross projections depend on which team is active); the
+    // per-team `teams.<k>.agents` merge below is team-key self-identifying and must run
+    // even when another process flipped session_name/active_team_key between this
+    // writer's load and save.
+    let projection_matches = same_runtime_projection(incoming, latest);
+    if projection_matches {
+        preserve_missing_agents(incoming.get_mut("agents"), latest.get("agents"), deleted_agent_ids);
+        preserve_latest_ownership_fields(incoming, latest);
     }
-    preserve_missing_agents(incoming.get_mut("agents"), latest.get("agents"), deleted_agent_ids);
-    preserve_latest_ownership_fields(incoming, latest);
 
     let active_team = active_team_key(incoming).or_else(|| active_team_key(latest));
-    if let Some(active_team) = active_team.as_deref() {
-        let latest_active_agents = latest
-            .get("teams")
-            .and_then(Value::as_object)
-            .and_then(|teams| teams.get(active_team))
-            .and_then(|entry| entry.get("agents"));
-        preserve_missing_agents(incoming.get_mut("agents"), latest_active_agents, deleted_agent_ids);
+    if projection_matches {
+        if let Some(active_team) = active_team.as_deref() {
+            let latest_active_agents = latest
+                .get("teams")
+                .and_then(Value::as_object)
+                .and_then(|teams| teams.get(active_team))
+                .and_then(|entry| entry.get("agents"));
+            preserve_missing_agents(incoming.get_mut("agents"), latest_active_agents, deleted_agent_ids);
+        }
     }
 
     let latest_teams = latest.get("teams").and_then(Value::as_object);
@@ -303,11 +310,13 @@ fn preserve_latest_roster_entries(incoming: &mut Value, latest: &Value, deleted_
             preserve_latest_ownership_fields(incoming_entry, latest_entry);
         }
     }
-    if let Some(active_team) = active_team.as_deref() {
-        let latest_top_agents = latest.get("agents");
-        if let Some(incoming_entry) = incoming_teams.get_mut(active_team) {
-            preserve_missing_agents(incoming_entry.get_mut("agents"), latest_top_agents, deleted_agent_ids);
-            preserve_latest_ownership_fields(incoming_entry, latest);
+    if projection_matches {
+        if let Some(active_team) = active_team.as_deref() {
+            let latest_top_agents = latest.get("agents");
+            if let Some(incoming_entry) = incoming_teams.get_mut(active_team) {
+                preserve_missing_agents(incoming_entry.get_mut("agents"), latest_top_agents, deleted_agent_ids);
+                preserve_latest_ownership_fields(incoming_entry, latest);
+            }
         }
     }
 }
@@ -384,9 +393,38 @@ fn preserve_missing_agents(
         if deleted_agent_ids.contains(agent_id) {
             continue;
         }
-        incoming_map
-            .entry(agent_id.clone())
-            .or_insert_with(|| latest_agent.clone());
+        match incoming_map.entry(agent_id.clone()) {
+            serde_json::map::Entry::Vacant(slot) => {
+                slot.insert(latest_agent.clone());
+            }
+            serde_json::map::Entry::Occupied(mut existing) => {
+                backfill_capture_fields(existing.get_mut(), latest_agent);
+            }
+        }
+    }
+}
+
+/// A0/R2: session-capture fields are written by another process (capture/update_state)
+/// between a writer's load and save; a stale incoming row must not regress them to null.
+/// Monotonic backfill ONLY for the capture field family (no generic deep-merge, so a
+/// deliberate field clear elsewhere is not masked).
+fn backfill_capture_fields(incoming_agent: &mut Value, latest_agent: &Value) {
+    const CAPTURE_FIELDS: [&str; 5] = [
+        "session_id",
+        "rollout_path",
+        "captured_at",
+        "captured_via",
+        "attribution_confidence",
+    ];
+    let Some(incoming_row) = incoming_agent.as_object_mut() else {
+        return;
+    };
+    for field in CAPTURE_FIELDS {
+        if incoming_row.get(field).is_none_or(Value::is_null) {
+            if let Some(value) = latest_agent.get(field).filter(|value| !value.is_null()) {
+                incoming_row.insert(field.to_string(), value.clone());
+            }
+        }
     }
 }
 
@@ -878,4 +916,42 @@ mod tests {
         let after = std::fs::read_to_string(runtime_state_path(&ws)).unwrap();
         assert_eq!(after, before, "已是迁移等价形的 legacy 文件不得 spurious 重写");
     }
+
+    // A0 GREEN 回归锁(.team/artifacts/a0-rs-lostupdate-locate.md §5.3):锁内 preserve 把磁盘
+    // latest 多出的 agent 补回 stale incoming(防 Python A0 lost-update),同时 deleted_agent_ids
+    // 豁免位必须让 remove-agent 的删除不被 merge 复活(persist.rs:383-385)。
+    #[test]
+    fn a0_green_lock_preserve_fills_missing_agents_but_deleted_ids_stay_dead() {
+        let ws = temp_ws();
+        std::fs::create_dir_all(runtime_dir(&ws)).unwrap();
+        std::fs::write(
+            runtime_state_path(&ws),
+            serde_json::to_string_pretty(&json!({
+                "session_name": "team-a",
+                "active_team_key": "team-a",
+                "agents": {
+                    "w1": {"status": "running", "provider": "codex", "agent_id": "w1"},
+                    "kept": {"status": "running", "provider": "codex", "agent_id": "kept"},
+                    "gone": {"status": "running", "provider": "codex", "agent_id": "gone"},
+                },
+            }))
+            .unwrap(),
+        )
+        .unwrap();
+        let incoming = json!({
+            "session_name": "team-a",
+            "active_team_key": "team-a",
+            "agents": { "w1": {"status": "running", "provider": "codex", "agent_id": "w1"} },
+        });
+        save_runtime_state_with_deleted_agents(&ws, &incoming, &["gone"]).unwrap();
+        let saved = read_state(&ws);
+        assert!(
+            saved.pointer("/agents/kept").is_some_and(Value::is_object),
+            "锁内 preserve 必须把磁盘 latest 多出的 `kept` 补回 stale incoming;saved={saved}"
+        );
+        assert!(
+            saved.pointer("/agents/gone").is_none(),
+            "deleted_agent_ids 豁免:被 remove 的 `gone` 不得被 preserve 复活;saved={saved}"
+        );
+    }
 }

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

@@ -660,15 +660,14 @@
     // ── 11. list_targets (TRANSPORT TRIO) — `list-panes -a -F TMUX_PANE_FORMAT` + per-line parse ────
     // Golden _legacy_pane_discovery.py:29-33 _tmux_list_panes: `tmux list-panes -a -F <TMUX_PANE_FORMAT>`
     // (returncode != 0 -> []), parse each tab line via _parse_tmux_pane_info. TMUX_PANE_FORMAT
-    // (runtime.py:456-460) is the byte-exact 11-field tab string locked below. RED today: list_targets is
-    // unimplemented!() -> PANIC. Porter: build the argv, split each stdout line on '\t', map the fields
-    // into PaneInfo (pane_active=="1" -> active). leader_env / pane_pid are the reverse-env real-machine
-    // bit (no field in TMUX_PANE_FORMAT) — out of this canned parse; the structured fields are locked here.
+    // (runtime.py:456-460) is the byte-exact tab string locked below; P5 (C-P5-3) appends
+    // `#{pane_pid}` as field 12 so pane pids ride the single list-panes call (the per-pane
+    // display-message N+1 fallback is gone). leader_env stays the reverse-env real-machine bit.
     #[test]
     fn list_targets_argv_and_parses_tmux_pane_format() {
-        const FMT: &str = "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}\t#{pane_current_path}\t#{session_attached}\t#{pane_in_mode}";
-        let stdout = "%7\tteam-x\t0\twin0\t0\t/dev/ttys003\tcodex\t1\t/Users/me/work\t1\t0\n\
-                      %8\tteam-x\t1\twin1\t0\t/dev/ttys004\tnode\t0\t/Users/me/other\t0\t0\n";
+        const FMT: &str = "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}\t#{pane_current_path}\t#{session_attached}\t#{pane_in_mode}\t#{pane_pid}";
+        let stdout = "%7\tteam-x\t0\twin0\t0\t/dev/ttys003\tcodex\t1\t/Users/me/work\t1\t0\t41001\n\
+                      %8\tteam-x\t1\twin1\t0\t/dev/ttys004\tnode\t0\t/Users/me/other\t0\t0\t41002\n";
         let (be, rec) = backend_with(MockResp::Out(ok(stdout)), vec![]);
         let panes = be.list_targets().expect("list_targets ok");
         assert_eq!(
@@ -692,6 +691,8 @@
             "field[8] -> pane_current_path"
         );
         assert!(!panes[1].active, "field[7] pane_active='0' -> active=false");
+        assert_eq!(p.pane_pid, Some(41001), "field[11] -> pane_pid (P5 C-P5-3, no N+1 fallback)");
+        assert_eq!(panes[1].pane_pid, Some(41002), "field[11] -> pane_pid (second pane)");
 
         // nonzero exit -> empty vec (golden returncode != 0 -> []).
         let (be, _r) = backend_with(MockResp::Out(fail(1, "no server running on /tmp/tmux-x/default")), vec![]);

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

@@ -169,6 +169,9 @@ pub struct TmuxBackend {
     /// `Some(name)` for a per-team socket -> every `tmux` argv gets `-L <name>` injected after the
     /// leading "tmux" token; `None` (default) -> bare `tmux` on the shared default socket.
     socket: Option<TmuxSocketEndpoint>,
+    /// swallow batch 2: workspace for failure-observability events (`tmux.*_failed`);
+    /// `None` for non-workspace-bound backends (no event log to write to).
+    event_workspace: Option<PathBuf>,
 }
 
 enum TmuxSocketEndpoint {
@@ -183,6 +186,7 @@ impl TmuxBackend {
         Self {
             runner: Box::new(RealCommandRunner),
             socket: None,
+            event_workspace: None,
         }
     }
 
@@ -195,6 +199,7 @@ impl TmuxBackend {
             socket: Some(TmuxSocketEndpoint::Name(socket_name_for_workspace(
                 workspace,
             ))),
+            event_workspace: Some(workspace.to_path_buf()),
         }
     }
 
@@ -205,6 +210,7 @@ impl TmuxBackend {
             Self {
                 runner: Box::new(RealCommandRunner),
                 socket: Some(TmuxSocketEndpoint::Name(socket.to_string())),
+                event_workspace: None,
             }
         }
     }
@@ -216,6 +222,7 @@ impl TmuxBackend {
             Self {
                 runner: Box::new(RealCommandRunner),
                 socket: Some(TmuxSocketEndpoint::Path(endpoint.to_string())),
+                event_workspace: None,
             }
         } else {
             Self::new()
@@ -227,6 +234,7 @@ impl TmuxBackend {
         Self {
             runner,
             socket: None,
+            event_workspace: None,
         }
     }
 
@@ -238,6 +246,7 @@ impl TmuxBackend {
             socket: Some(TmuxSocketEndpoint::Name(socket_name_for_workspace(
                 workspace,
             ))),
+            event_workspace: Some(workspace.to_path_buf()),
         }
     }
 
@@ -249,16 +258,19 @@ impl TmuxBackend {
             Self {
                 runner,
                 socket: Some(TmuxSocketEndpoint::Path(endpoint.to_string())),
+                event_workspace: None,
             }
         } else if endpoint.is_empty() || endpoint == "default" {
             Self {
                 runner,
                 socket: None,
+                event_workspace: None,
             }
         } else {
             Self {
                 runner,
                 socket: None,
+                event_workspace: None,
             }
         }
     }
@@ -318,6 +330,60 @@ pub(crate) fn socket_name_for_workspace(workspace: &Path) -> String {
     format!("ta-{:012x}", hasher.finish() & 0xffff_ffff_ffff)
 }
 
+pub(crate) fn socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
+    let socket_name = socket_name_for_workspace(workspace);
+    let roots = tmux_socket_roots();
+    for root in &roots {
+        let root = root.canonicalize().unwrap_or_else(|_| root.clone());
+        let candidate = root.join(&socket_name);
+        if candidate.exists() {
+            return Some(candidate.canonicalize().unwrap_or(candidate));
+        }
+    }
+    let uid = unsafe { libc::geteuid() };
+    let default_root = PathBuf::from(format!("/tmp/tmux-{uid}"));
+    let default_root = default_root
+        .canonicalize()
+        .unwrap_or(default_root);
+    Some(default_root.join(socket_name))
+}
+
+pub(crate) fn attach_command_for_workspace(
+    workspace: &Path,
+    session_name: &SessionName,
+    window_name: &str,
+) -> Option<String> {
+    let socket_path = socket_path_for_workspace(workspace)?;
+    Some(format!(
+        "tmux -S {} attach -t {}:{}",
+        socket_path.display(),
+        session_name.as_str(),
+        window_name
+    ))
+}
+
+pub(crate) fn attach_commands_for_windows<'a>(
+    workspace: &Path,
+    session_name: &SessionName,
+    window_names: impl IntoIterator<Item = &'a str>,
+) -> Vec<String> {
+    window_names
+        .into_iter()
+        .filter_map(|window_name| attach_command_for_workspace(workspace, session_name, window_name))
+        .collect()
+}
+
+fn tmux_socket_roots() -> Vec<PathBuf> {
+    let uid = unsafe { libc::geteuid() };
+    let mut roots = vec![PathBuf::from(format!("/tmp/tmux-{uid}"))];
+    if let Some(tmpdir) = std::env::var_os("TMPDIR") {
+        roots.push(PathBuf::from(tmpdir).join(format!("tmux-{uid}")));
+    }
+    roots.sort();
+    roots.dedup();
+    roots
+}
+
 pub(crate) fn socket_name_from_tmux_env() -> Option<String> {
     let tmux = std::env::var("TMUX")
         .ok()
@@ -366,9 +432,10 @@ impl TmuxBackend {
         argv: &[String],
         cwd: &Path,
         env: &BTreeMap<String, String>,
+        env_unset: &[String],
         first: bool,
     ) -> Result<SpawnResult, TransportError> {
-        let command = shell_command(argv, cwd, env);
+        let command = shell_command(argv, cwd, env, env_unset);
         let spawn_argv = tmux_spawn_argv(session, window, &command, first);
         self.run_spawn(&spawn_argv)?;
         let pane_argv = vec![
@@ -541,11 +608,24 @@ fn capture_has_pasted_content_prompt(text: &str) -> bool {
 const PASTED_CONTENT_APPEAR_POLLS: u32 = 5;
 const PASTED_CONTENT_SUBMIT_ATTEMPTS: u32 = 3;
 
-fn shell_command(argv: &[String], cwd: &Path, env: &BTreeMap<String, String>) -> String {
+fn shell_command(
+    argv: &[String],
+    cwd: &Path,
+    env: &BTreeMap<String, String>,
+    env_unset: &[String],
+) -> String {
     let mut parts = Vec::new();
     parts.push("cd".to_string());
     parts.push(shell_quote(&cwd.to_string_lossy()));
     parts.push("&&".to_string());
+    // D9 (#264) / Python providers.py:142-145 + provider_env.py:86 — profile env_unset keys
+    // must be unset in the shell itself: the `sh -lc` line inherits the tmux SERVER's stale
+    // environment, which exec-prefix assignments cannot clear.
+    for key in env_unset {
+        parts.push("unset".to_string());
+        parts.push(key.clone());
+        parts.push("&&".to_string());
+    }
     for (key, value) in env {
         parts.push(format!("{key}={}", shell_quote(value)));
     }
@@ -589,7 +669,31 @@ impl Transport for TmuxBackend {
         cwd: &Path,
         env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError> {
-        self.spawn(session, window, argv, cwd, env, true)
+        self.spawn(session, window, argv, cwd, env, &[], true)
+    }
+
+    fn spawn_first_with_env_unset(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+    ) -> Result<SpawnResult, TransportError> {
+        self.spawn(session, window, argv, cwd, env, env_unset, true)
+    }
+
+    fn spawn_into_with_env_unset(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+    ) -> Result<SpawnResult, TransportError> {
+        self.spawn(session, window, argv, cwd, env, env_unset, false)
     }
 
     fn spawn_into(
@@ -600,7 +704,7 @@ impl Transport for TmuxBackend {
         cwd: &Path,
         env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError> {
-        self.spawn(session, window, argv, cwd, env, false)
+        self.spawn(session, window, argv, cwd, env, &[], false)
     }
 
     fn inject(
@@ -744,7 +848,9 @@ impl Transport for TmuxBackend {
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        const TMUX_PANE_FORMAT: &str = "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}\t#{pane_current_path}\t#{session_attached}\t#{pane_in_mode}";
+        // P5 (C-P5-3): `#{pane_pid}` rides the single list-panes call (field index 11),
+        // killing the per-pane display-message N+1 fallback.
+        const TMUX_PANE_FORMAT: &str = "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}\t#{pane_current_path}\t#{session_attached}\t#{pane_in_mode}\t#{pane_pid}";
         let argv = self.tmux_argv(&[
             "tmux".to_string(),
             "list-panes".to_string(),
@@ -759,8 +865,28 @@ impl Transport for TmuxBackend {
         let mut panes = Vec::new();
         for line in output.stdout.lines().filter(|line| !line.is_empty()) {
             if let Some(mut pane) = parse_pane_info_line(line) {
+                // 0.3.5 integration union: P5 (C-P5-3) makes `#{pane_pid}` ride the
+                // single list-panes call — on real tmux the fallback below never fires.
+                // swallow batch 2 ① keeps it as a RESILIENT degrade for panes whose pid
+                // field came back empty (e.g. older tmux without #{pane_pid}): a single
+                // pane's probe failure must not fail the WHOLE list — the pane degrades
+                // to pane_pid=None and the failure is observable.
                 if pane.pane_pid.is_none() {
-                    pane.pane_pid = query_pane_pid(self, &pane.pane_id)?;
+                    match query_pane_pid(self, &pane.pane_id) {
+                        Ok(pid) => pane.pane_pid = pid,
+                        Err(error) => {
+                            if let Some(workspace) = &self.event_workspace {
+                                let _ = crate::event_log::EventLog::new(workspace).write(
+                                    "tmux.pane_pid_query_failed",
+                                    serde_json::json!({
+                                        "pane_id": pane.pane_id.as_str(),
+                                        "session": pane.session.as_str(),
+                                        "error": error.to_string(),
+                                    }),
+                                );
+                            }
+                        }
+                    }
                 }
                 panes.push(pane);
             }
@@ -852,6 +978,8 @@ impl Transport for TmuxBackend {
     }
 }
 
+/// swallow batch 2 ① fallback probe (only fires when `#{pane_pid}` came back empty —
+/// see the P5 union note in `list_targets`).
 fn query_pane_pid(backend: &TmuxBackend, pane: &PaneId) -> Result<Option<u32>, TransportError> {
     let argv = backend.tmux_argv(&[
         "tmux".to_string(),

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

@@ -421,6 +421,38 @@ pub trait Transport: Send + Sync {
         env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError>;
 
+    /// D9 (#264): spawn + profile `env_unset` keys that must be REALLY unset in the worker
+    /// shell line (Python providers.py:142-145 sources an env file whose first lines are
+    /// `unset <KEY>`) — the tmux server environment can carry stale values that plain
+    /// env-map removal cannot clear. Default forwards to the plain spawn: backends without
+    /// an inherited-shell layer have nothing stale to unset.
+    fn spawn_first_with_env_unset(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+    ) -> Result<SpawnResult, TransportError> {
+        let _ = env_unset;
+        self.spawn_first(session, window, argv, cwd, env)
+    }
+
+    /// 同 [`Transport::spawn_first_with_env_unset`],对应 `spawn_into`。
+    fn spawn_into_with_env_unset(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+    ) -> Result<SpawnResult, TransportError> {
+        let _ = env_unset;
+        self.spawn_into(session, window, argv, cwd, env)
+    }
+
     // —— INJECT / CAPTURE / QUERY(RIE):按稳定 Target 寻址 ——
 
     /// 归并 set/load-buffer + paste-buffer + send submit;空文本走纯 send-keys

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "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.3.3",
-    "@team-agent/cli-darwin-x64": "0.3.3",
-    "@team-agent/cli-linux-x64": "0.3.3"
+    "@team-agent/cli-darwin-arm64": "0.3.5",
+    "@team-agent/cli-darwin-x64": "0.3.5",
+    "@team-agent/cli-linux-x64": "0.3.5"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",