@team-agent/installer 0.3.24 → 0.3.26

package/crates/team-agent/src/cli/tests/shutdown_kill_plan.rs

@@ -378,6 +378,12 @@ struct CleanShutdownTransport {
     kill_server_called: Mutex<bool>,
     probe_timeout_kind: Option<&'static str>,
     targets_persist_after_kill: bool,
+    // E49 (0.3.24 P0, shutdown kills leader CLI): record per-pane / per-window /
+    // per-session kill targets so RED contracts can assert (a) the leader pane is
+    // never killed and (b) worker panes ARE killed via the new per-pane path.
+    killed_panes: Mutex<Vec<String>>,
+    killed_window_targets: Mutex<Vec<String>>,
+    killed_sessions: Mutex<Vec<String>>,
 }
 
 impl CleanShutdownTransport {
@@ -388,6 +394,9 @@ impl CleanShutdownTransport {
             kill_server_called: Mutex::new(false),
             probe_timeout_kind: None,
             targets_persist_after_kill: false,
+            killed_panes: Mutex::new(Vec::new()),
+            killed_window_targets: Mutex::new(Vec::new()),
+            killed_sessions: Mutex::new(Vec::new()),
         }
     }
 
@@ -409,6 +418,21 @@ impl CleanShutdownTransport {
         self.targets_persist_after_kill = true;
         self
     }
+
+    /// E49 (0.3.24 P0): observed per-pane kill targets, in call order.
+    fn killed_panes(&self) -> Vec<String> {
+        self.killed_panes.lock().unwrap().clone()
+    }
+
+    /// E49 (0.3.24 P0): observed per-window kill targets (target stringified).
+    fn killed_window_targets(&self) -> Vec<String> {
+        self.killed_window_targets.lock().unwrap().clone()
+    }
+
+    /// E49 (0.3.24 P0): observed per-session kill targets, in call order.
+    fn killed_sessions_observed(&self) -> Vec<String> {
+        self.killed_sessions.lock().unwrap().clone()
+    }
 }
 
 impl Transport for CleanShutdownTransport {
@@ -499,10 +523,14 @@ impl Transport for CleanShutdownTransport {
         Ok(SetEnvOutcome::Applied)
     }
 
-    fn kill_session(&self, _session: &SessionName) -> Result<(), TransportError> {
+    fn kill_session(&self, session: &SessionName) -> Result<(), TransportError> {
         if let Some(probe) = self.probe_timeout_kind {
             crate::os_probe::set_probe_timeout_for_test(probe, None, 900);
         }
+        self.killed_sessions
+            .lock()
+            .unwrap()
+            .push(session.as_str().to_string());
         *self.session_present.lock().unwrap() = false;
         Ok(())
     }
@@ -512,7 +540,19 @@ impl Transport for CleanShutdownTransport {
         Ok(())
     }
 
-    fn kill_window(&self, _target: &Target) -> Result<(), TransportError> {
+    fn kill_window(&self, target: &Target) -> Result<(), TransportError> {
+        self.killed_window_targets
+            .lock()
+            .unwrap()
+            .push(format!("{target:?}"));
+        Ok(())
+    }
+
+    fn kill_pane(&self, pane: &PaneId) -> Result<(), TransportError> {
+        self.killed_panes
+            .lock()
+            .unwrap()
+            .push(pane.as_str().to_string());
         Ok(())
     }
 
@@ -730,24 +770,240 @@ fn leader_env_tmux_socket_never_kills_server_even_when_sessions_look_exclusive()
     );
 }
 
+/// E49 (0.3.24 P0, shutdown kills leader CLI): managed-leader topology with
+/// leader anchor pane + worker panes in the SAME tmux session.
+///
+/// Pre-fix (cli/mod.rs:629-638): `transport.kill_session(state.session_name)`
+/// killed the session unconditionally — including the leader's own pane.
+/// User truth: "执行命令绝不能关掉启动自己的那个 leader CLI". macmini repro:
+/// run `team-agent quick-start ...`, then `team-agent shutdown` from the
+/// same terminal → leader CLI dies.
+///
+/// Architect-approved fix:
+///   * pre :629 guard: when state is managed (NOT external leader) and the
+///     leader_receiver / team_owner anchor pane is in `state.session_name`,
+///     do NOT call kill_session(state.session_name). Instead kill workers
+///     per-pane via `kill_pane`, deriving pane_ids from state.agents +
+///     teams[*].agents and EXCLUDING the leader anchor pane ids
+///     (`collect_state_leader_anchor_pane_ids`).
+///   * cli/mod.rs:384-435 managed_leader_socket_cleanup: spare any session
+///     carrying a leader anchor; never kill_session it.
+///
+/// Pre-fix test asserted `killed_sessions=["team-current"]` — that was
+/// LOCKING THE BUG (the architect explicitly named it). Post-fix:
+///   * spared_sessions contains "team-current"
+///   * killed_sessions does NOT contain "team-current"
+///   * killed_panes contains worker panes %w1, %w2
+///   * killed_panes does NOT contain %leader
+///   * no kill_server call
 #[test]
-fn managed_leader_shutdown_never_kills_server_even_when_socket_looks_exclusive() {
-    let ws = tmp_shutdown_workspace("managed-leader-no-kill-server");
+fn e49_managed_leader_shutdown_spares_leader_session_and_kills_workers_per_pane() {
+    let ws = tmp_shutdown_workspace("e49-managed-leader-spares-session");
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
             "session_name": "team-current",
             "is_external_leader": false,
-            "agents": {}
+            "leader_receiver": {"pane_id": "%leader"},
+            "team_owner": {"pane_id": "%leader"},
+            "agents": {
+                "w1": {"status": "running", "provider": "codex", "window": "w1", "pane_id": "%w1"},
+                "w2": {"status": "running", "provider": "codex", "window": "w2", "pane_id": "%w2"}
+            }
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new()
+        .with_targets(vec![
+            // Leader anchor pane
+            PaneInfo {
+                pane_id: PaneId::new("%leader"),
+                session: SessionName::new("team-current"),
+                window_index: Some(0),
+                window_name: Some(WindowName::new("leader")),
+                pane_index: Some(0),
+                tty: None,
+                current_command: Some("codex".to_string()),
+                current_path: None,
+                active: true,
+                pane_pid: None,
+                leader_env: BTreeMap::new(),
+            },
+            // Worker pane 1
+            PaneInfo {
+                pane_id: PaneId::new("%w1"),
+                session: SessionName::new("team-current"),
+                window_index: Some(1),
+                window_name: Some(WindowName::new("w1")),
+                pane_index: Some(0),
+                tty: None,
+                current_command: Some("codex".to_string()),
+                current_path: None,
+                active: false,
+                pane_pid: None,
+                leader_env: BTreeMap::new(),
+            },
+            // Worker pane 2
+            PaneInfo {
+                pane_id: PaneId::new("%w2"),
+                session: SessionName::new("team-current"),
+                window_index: Some(2),
+                window_name: Some(WindowName::new("w2")),
+                pane_index: Some(0),
+                tty: None,
+                current_command: Some("codex".to_string()),
+                current_path: None,
+                active: false,
+                pane_pid: None,
+                leader_env: BTreeMap::new(),
+            },
+        ])
+        .with_targets_persist_after_kill();
+
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
+        .expect("shutdown should complete");
+
+    let killed_sessions = transport.killed_sessions_observed();
+    assert!(
+        !killed_sessions.iter().any(|s| s == "team-current"),
+        "E49 (RED): managed-leader shutdown must NEVER kill_session(team-current) — \
+         that ends the leader's own pane (the user's CLI). Got transport \
+         killed_sessions={killed_sessions:?}"
+    );
+    let killed_panes = transport.killed_panes();
+    assert!(
+        !killed_panes.iter().any(|p| p == "%leader"),
+        "E49 (RED): leader anchor pane %leader must NEVER be killed. Got \
+         killed_panes={killed_panes:?}"
+    );
+    assert!(
+        killed_panes.iter().any(|p| p == "%w1"),
+        "E49: worker pane %w1 must be killed per-pane (workers cleared, leader spared). \
+         Got killed_panes={killed_panes:?}"
+    );
+    assert!(
+        killed_panes.iter().any(|p| p == "%w2"),
+        "E49: worker pane %w2 must be killed per-pane. Got killed_panes={killed_panes:?}"
+    );
+    assert!(
+        !transport.kill_server_called(),
+        "E49: managed topology must never kill the tmux server (would end leader pane)."
+    );
+    // Report-level assertions: the leader session must appear in spared_sessions,
+    // not killed_sessions.
+    let out_killed = out["killed_sessions"]
+        .as_array()
+        .cloned()
+        .unwrap_or_default();
+    let out_spared = out["spared_sessions"]
+        .as_array()
+        .cloned()
+        .unwrap_or_default();
+    assert!(
+        !out_killed
+            .iter()
+            .any(|v| v.as_str() == Some("team-current")),
+        "E49: report's killed_sessions must NOT contain the leader session. Got {out_killed:?}"
+    );
+    assert!(
+        out_spared
+            .iter()
+            .any(|v| v.as_str() == Some("team-current")),
+        "E49: report's spared_sessions MUST contain the leader session. Got {out_spared:?}"
+    );
+    assert_eq!(out["ok"], json!(true));
+}
+
+/// E49 regression guard: external-leader topology (is_external_leader=true)
+/// must STILL kill_session unconditionally. In that topology the team session
+/// is a disposable worker session and the leader pane lives elsewhere
+/// (a separate terminal / different socket). Sparing the session here would
+/// leak worker processes after shutdown.
+#[test]
+fn e49_external_leader_shutdown_still_kills_team_session_unconditionally() {
+    let ws = tmp_shutdown_workspace("e49-external-leader-still-kills");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-external",
+            "is_external_leader": true,
+            "leader_receiver": {"pane_id": "%leaderelsewhere"},
+            "agents": {
+                "w1": {"status": "running", "provider": "codex", "window": "w1", "pane_id": "%w1"}
+            }
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new()
+        .with_targets(vec![
+            // Worker pane in team session
+            PaneInfo {
+                pane_id: PaneId::new("%w1"),
+                session: SessionName::new("team-external"),
+                window_index: Some(0),
+                window_name: Some(WindowName::new("w1")),
+                pane_index: Some(0),
+                tty: None,
+                current_command: Some("codex".to_string()),
+                current_path: None,
+                active: true,
+                pane_pid: None,
+                leader_env: BTreeMap::new(),
+            },
+            // Leader pane is in a DIFFERENT session (external topology)
+            PaneInfo {
+                pane_id: PaneId::new("%leaderelsewhere"),
+                session: SessionName::new("user-shell"),
+                window_index: Some(0),
+                window_name: Some(WindowName::new("shell")),
+                pane_index: Some(0),
+                tty: None,
+                current_command: Some("zsh".to_string()),
+                current_path: None,
+                active: true,
+                pane_pid: None,
+                leader_env: BTreeMap::new(),
+            },
+        ])
+        .with_targets_persist_after_kill();
+
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
+        .expect("shutdown should complete");
+
+    let killed_sessions = transport.killed_sessions_observed();
+    assert!(
+        killed_sessions.iter().any(|s| s == "team-external"),
+        "E49 regression guard: external-leader topology must STILL kill_session \
+         the team session — leader pane lives elsewhere so this is safe. Got \
+         transport killed_sessions={killed_sessions:?}"
+    );
+    assert_eq!(out["ok"], json!(true));
+}
+
+/// E49 regression guard: managed topology where the leader anchor pane is NOT
+/// in `state.session_name` (e.g. a stale state from an aborted launch where
+/// only worker panes exist in the session). The pre-fix behaviour (kill_session)
+/// is preserved here — no leader pane is at risk.
+#[test]
+fn e49_managed_leader_without_anchor_in_session_still_kills_session() {
+    let ws = tmp_shutdown_workspace("e49-managed-no-anchor-in-session");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-orphan",
+            "is_external_leader": false,
+            "agents": {
+                "w1": {"status": "running", "provider": "codex", "window": "w1", "pane_id": "%w1"}
+            }
         }),
     )
     .unwrap();
     let transport = CleanShutdownTransport::new()
         .with_targets(vec![PaneInfo {
-            pane_id: PaneId::new("%1"),
-            session: SessionName::new("team-current"),
+            pane_id: PaneId::new("%w1"),
+            session: SessionName::new("team-orphan"),
             window_index: Some(0),
-            window_name: Some(WindowName::new("leader")),
+            window_name: Some(WindowName::new("w1")),
             pane_index: Some(0),
             tty: None,
             current_command: Some("codex".to_string()),
@@ -761,13 +1017,14 @@ fn managed_leader_shutdown_never_kills_server_even_when_socket_looks_exclusive()
     let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
         .expect("shutdown should complete");
 
-    assert_eq!(out["ok"], json!(true));
-    assert_eq!(out["killed_sessions"], json!(["team-current"]));
-    assert_eq!(out["spared_sessions"], json!([]));
+    let killed_sessions = transport.killed_sessions_observed();
     assert!(
-        !transport.kill_server_called(),
-        "managed topology must clear the team session/window without kill-server"
+        killed_sessions.iter().any(|s| s == "team-orphan"),
+        "E49 regression guard: when no leader anchor pane is in the session, \
+         the pre-fix kill_session path is preserved (no leader is at risk). \
+         Got transport killed_sessions={killed_sessions:?}"
     );
+    assert_eq!(out["ok"], json!(true));
 }
 
 #[test]

package/crates/team-agent/src/cli/tests/status_send.rs

@@ -150,6 +150,7 @@ use super::*;
             confirm_human: false,
             json: false,
             message_id: None,
+            pane: None,
         }
     }
 

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

@@ -312,6 +312,13 @@ pub struct SendArgs {
     /// When set, the store insert uses this id verbatim; a repeat with the same
     /// id returns a `Duplicate` refusal instead of creating a second row.
     pub message_id: Option<String>,
+    /// F1 (0.3.26): `--pane <pane_id>` — direct pane-id targeting. Mutually
+    /// exclusive with `target` / `targets`. When set, the message is injected
+    /// directly into the specified tmux pane via `transport.inject`, bypassing
+    /// the agent-name → pane-id resolution + team-membership check. This is
+    /// the **cross-team communication** primitive: the target pane does not
+    /// need to be in the sender's team.
+    pub pane: Option<String>,
 }
 
 /// E23 worker-side emergency fallback for `team_orchestrator.send_message`

package/crates/team-agent/src/coordinator/tests/energy.rs

@@ -471,6 +471,7 @@ impl Transport for EnergyTransport {
             submit_verification: SubmitVerification::EnterSentWithoutPlaceholderCheck,
             turn_verification: TurnVerification::NotYetObserved,
             attempts: 1,
+            submit_diagnostics: None,
         })
     }
 

package/crates/team-agent/src/coordinator/tests/health_sync.rs

@@ -33,6 +33,7 @@ impl Transport for CapturingTransport {
             submit_verification: crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
             turn_verification: crate::transport::TurnVerification::NotYetObserved,
             attempts: 1,
+            submit_diagnostics: None,
         })
     }
     fn send_keys(&self, _t: &Target, _k: &[Key]) -> Result<(), TransportError> {

package/crates/team-agent/src/coordinator/tests/spine.rs

@@ -59,6 +59,7 @@ impl Transport for DeliveringTransport {
             submit_verification: crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
             turn_verification: crate::transport::TurnVerification::NotYetObserved,
             attempts: 1,
+            submit_diagnostics: None,
         })
     }
     fn send_keys(&self, t: &Target, k: &[Key]) -> Result<(), TransportError> {

package/crates/team-agent/src/coordinator/tests/takeover.rs

@@ -35,6 +35,7 @@ impl Transport for CountingCaptureTransport {
             submit_verification: crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
             turn_verification: crate::transport::TurnVerification::NotYetObserved,
             attempts: 1,
+            submit_diagnostics: None,
         })
     }
     fn send_keys(&self, _t: &Target, _k: &[Key]) -> Result<(), TransportError> {

package/crates/team-agent/src/coordinator/tick.rs

@@ -544,13 +544,27 @@ impl Coordinator {
                 .get("last_output_at")
                 .and_then(Value::as_str)
                 .map(str::to_string);
-            let activity = crate::messaging::classify_agent_activity(
-                &snapshot,
-                &captured.text,
-                pane_in_mode,
-                current_command.as_deref(),
-                last_output_at_now.as_deref(),
-            );
+            // E47 (0.3.24 P0, idle/busy 假阳): consult the AUTHORITATIVE
+            // provider JSONL classifier BEFORE the TUI keyword scan. The
+            // scrollback Tail(40) keeps historical `• Working (...· esc to
+            // interrupt)` + spinners within the 40-line window long after a
+            // turn completed, so `classify_agent_activity`'s rfind-recency
+            // grep flips a truly-idle worker to Working/Stuck. The provider
+            // JSONL (codex task_complete / claude end_turn) is the single
+            // source of truth for "turn closed". Only fall back to TUI
+            // scanning when the JSONL is unreadable or no lifecycle fact has
+            // been written yet (TurnState::Unknown) — never silently fall
+            // through into the leaky grep on a CONFIRMED IDLE.
+            let activity_from_jsonl = jsonl_activity_for_agent(agent);
+            let activity = activity_from_jsonl.unwrap_or_else(|| {
+                crate::messaging::classify_agent_activity(
+                    &snapshot,
+                    &captured.text,
+                    pane_in_mode,
+                    current_command.as_deref(),
+                    last_output_at_now.as_deref(),
+                )
+            });
             remember_idle_capture_schedule(agent, &activity);
             write_activity(agent, &activity, false);
             let last_output_at = last_output_at_now;
@@ -2519,6 +2533,40 @@ fn agent_rollout_path(agent: &Value) -> Option<PathBuf> {
         .map(PathBuf::from)
 }
 
+/// E47 (0.3.24 P0, idle/busy 假阳): consult the authoritative provider JSONL
+/// classifier and map to neutral `AgentActivity`. Returns `None` when the
+/// classifier reports `TurnState::Unknown` (unreadable JSONL / no lifecycle
+/// fact yet) so the caller falls back to the TUI scan — this honours the
+/// IRON LAW (activity.rs:3 / bug-071/077/085): no-signal = Uncertain (not
+/// silently coerced to Idle); but here Unknown means "JSONL gave no signal",
+/// so we hand off to the TUI scanner which has its OWN no-signal → Uncertain
+/// path. Copilot/Gemini/Fake providers (which don't have JSONL — classify.rs
+/// returns Unknown for them) thus keep using TUI scanning unchanged.
+fn jsonl_activity_for_agent(agent: &Value) -> Option<crate::messaging::AgentActivity> {
+    let rollout_path = agent_rollout_path(agent)?;
+    let provider = agent
+        .get("provider")
+        .and_then(Value::as_str)
+        .and_then(parse_provider)?;
+    let log_text = std::fs::read_to_string(&rollout_path).ok()?;
+    let process = explicit_process_liveness(agent).unwrap_or(ProcessLiveness::Unverifiable);
+    let result = crate::provider::classify(provider, &log_text, process, 0.0).ok()?;
+    use crate::messaging::{ActivityStatus, AgentActivity};
+    use crate::provider::types::TurnState;
+    let status = match result.state {
+        TurnState::Idle => ActivityStatus::Idle,
+        TurnState::IdleInterrupted => ActivityStatus::Idle,
+        TurnState::Working => ActivityStatus::Working,
+        TurnState::BlockedOnHuman | TurnState::Abnormal => ActivityStatus::Uncertain,
+        TurnState::Unknown => return None,
+    };
+    Some(AgentActivity {
+        status,
+        confidence: 0.95,
+        rationale: format!("provider_jsonl:{}", result.reason),
+    })
+}
+
 fn runtime_approval_target(
     agent: &Value,
     session_name: Option<&str>,

package/crates/team-agent/src/leader/lease.rs

@@ -581,6 +581,31 @@ fn claim_lease_no_incident_with_target(
             ));
         }
     }
+    // E51 (0.3.26 P0, lease guard): refuse to write the leader binding when the
+    // caller pane is a REGISTERED WORKER pane. Without this, claim_leader from a
+    // worker's tmux pane overwrites leader_receiver.pane_id with the worker's
+    // pane → delivery routes worker messages to itself (loop) and the leader
+    // loses its handle (the macmini "hand-handle mapping 灾难" truth source).
+    if let Some(worker_id) = registered_worker_for_pane(state, caller_pane) {
+        emit_lease_refusal(
+            event_log,
+            LeaseReason::CallerNotLeaderShaped,
+            state,
+            bound_pane_id.as_deref(),
+            Some(caller_pane.as_str()),
+            team_id,
+        )?;
+        return Ok(refused(
+            LeaseReason::CallerNotLeaderShaped,
+            &format!(
+                "pane {} is registered as worker {worker_id}; \
+                 run claim-leader from the leader's own pane, not a worker pane",
+                caller_pane.as_str()
+            ),
+            None,
+            bound_pane_id.clone().map(PaneId::new),
+        ));
+    }
     let reason = if bound_pane_id.is_some() {
         LeaseReason::PreviousOwnerPaneDead
     } else {
@@ -974,6 +999,38 @@ fn make_owner(
     }
 }
 
+/// E51 (0.3.26 P0, lease guard): scan state.agents + teams[*].agents for a worker
+/// whose pane_id matches the caller. Returns the first matching agent_id, or None
+/// if no registered worker owns this pane. The check is O(N agents) — negligible
+/// on a team-agent team which rarely exceeds ~20 workers.
+fn registered_worker_for_pane(state: &Value, caller_pane: &PaneId) -> Option<String> {
+    if let Some(agent_id) = scan_agents_for_pane(state.get("agents"), caller_pane) {
+        return Some(agent_id);
+    }
+    if let Some(teams) = state.get("teams").and_then(Value::as_object) {
+        for (_, team_state) in teams {
+            if let Some(agent_id) = scan_agents_for_pane(team_state.get("agents"), caller_pane) {
+                return Some(agent_id);
+            }
+        }
+    }
+    None
+}
+
+fn scan_agents_for_pane(agents: Option<&Value>, caller_pane: &PaneId) -> Option<String> {
+    let map = agents?.as_object()?;
+    for (agent_id, agent) in map {
+        if agent
+            .get("pane_id")
+            .and_then(Value::as_str)
+            .is_some_and(|pane| pane == caller_pane.as_str())
+        {
+            return Some(agent_id.clone());
+        }
+    }
+    None
+}
+
 fn write_binding_to_state(
     state: &mut Value,
     receiver: &LeaderReceiver,

package/crates/team-agent/src/leader/start.rs

@@ -865,6 +865,7 @@ mod tests {
                 submit_verification: SubmitVerification::EnterSentWithoutPlaceholderCheck,
                 turn_verification: TurnVerification::NotRequired,
                 attempts: 1,
+                submit_diagnostics: None,
             })
         }