@team-agent/installer 0.5.94 → 0.5.98

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

@@ -299,7 +299,7 @@ fn dispatch_routes_sessions_subcommand() {
 // + NO session_name + NO agents -> issues=[] -> EXIT 0.
 #[test]
 #[serial(env)]
-fn dispatch_routes_diagnose_healthy_leader() {
+fn dispatch_routes_diagnose_checks_runtime_beyond_healthy_leader() {
     let _env = EnvUnsetGuard::unset(&[
         "TMUX",
         "TMUX_PANE",
@@ -332,17 +332,26 @@ fn dispatch_routes_diagnose_healthy_leader() {
             pane_pid: None,
             leader_env: Default::default(),
         }]);
-    let code = crate::transport_factory::with_leader_endpoint_transport(endpoint, transport, || {
-        run(
-            &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
-            &ws,
-        )
+    crate::transport_factory::with_leader_endpoint_transport(endpoint, transport, || {
+        for command in ["doctor", "diagnose"] {
+            let code = run(
+                &cli_argv(&[command, "--workspace", &ws.to_string_lossy(), "--json"]),
+                &ws,
+            );
+            assert_eq!(code, ExitCode::Error, "healthy binding alone cannot hide missing coordinator");
+        }
+        let result = cmd_diagnose(&DiagnoseArgs {
+            workspace: ws.clone(), json: true, team: None,
+        }).expect("diagnostic report");
+        let CmdOutput::Json(report) = result.output else {
+            panic!("expected JSON diagnostic report");
+        };
+        assert_eq!(report["coordinator"]["ok"], false, "{report}");
+        let issues = report["issues"].to_string();
+        for binding_failure in ["leader_not_attached", "leader_receiver_unbound", "leader_workspace_mismatch"] {
+            assert!(!issues.contains(binding_failure), "healthy binding regressed: {report}");
+        }
     });
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "`diagnose` must be Ok when canonical owner/receiver, production registry, and live align; got {code:?}"
-    );
     let _ = std::fs::remove_dir_all(&ws);
 }
 

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

@@ -123,7 +123,6 @@ fn outcome_text(r: Result<CmdResult, CliError>) -> String {
 }
 
 mod base;
-mod compile;
 mod divergence;
 mod lane_c;
 mod leader_watch;

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

@@ -23,6 +23,49 @@ fn anchors(raw: &[&str]) -> BTreeSet<String> {
     raw.iter().map(|s| s.to_string()).collect()
 }
 
+#[test]
+fn leader_anchors_are_endpoint_scoped_and_unknown_anchors_stay_protected() {
+    use crate::cli::lifecycle_port::collect_state_leader_anchor_pane_ids as collect;
+    let state = json!({
+        "team_owner": {"pane_id": "%2"},
+        "leader_receiver": {"pane_id": "%2", "tmux_socket": "/tmp/s4-host.sock"},
+        "teams": {
+            "local": {
+                "team_owner": {"pane_id": "%3", "tmux_socket": "/tmp/s4-worker.sock"},
+                "leader_receiver": {"pane_id": "%3"}
+            },
+            "legacy": {"team_owner": {"pane_id": "%4"}}
+        }
+    });
+    assert_eq!(collect(&state, Some("/tmp/s4-worker.sock")), anchors(&["%3", "%4"]));
+    assert_eq!(collect(&state, Some("/tmp/s4-host.sock")), anchors(&["%2", "%4"]));
+    assert_eq!(collect(&state, None), anchors(&["%2", "%3", "%4"]));
+
+    // An unrelated receiver's socket is not evidence about the owner's pane.
+    let different_panes = json!({
+        "team_owner": {"pane_id": "%5"},
+        "leader_receiver": {"pane_id": "%2", "tmux_socket": "/tmp/s4-host.sock"}
+    });
+    assert_eq!(collect(&different_panes, Some("/tmp/s4-worker.sock")), anchors(&["%5"]));
+}
+
+#[test]
+#[cfg(unix)]
+fn leader_anchor_endpoint_aliases_preserve_same_server_protection() {
+    use crate::cli::lifecycle_port::collect_state_leader_anchor_pane_ids as collect;
+    let ws = tmp_shutdown_workspace("anchor-endpoint-alias");
+    let socket = ws.join("server.sock");
+    let alias = ws.join("alias.sock");
+    std::fs::write(&socket, b"fixture").unwrap();
+    std::os::unix::fs::symlink(&socket, &alias).unwrap();
+    let state = json!({"leader_receiver": {"pane_id": "%2", "tmux_socket": alias}});
+    assert_eq!(collect(&state, socket.to_str()), anchors(&["%2"]));
+    let short_name = format!("s4-anchor-{}", std::process::id());
+    let full_path = crate::tmux_backend::socket_path_for_name(&short_name).unwrap();
+    let state = json!({"leader_receiver": {"pane_id": "%2", "tmux_socket": short_name}});
+    assert_eq!(collect(&state, full_path.to_str()), anchors(&["%2"]));
+}
+
 // RC-4: even an apparently exclusive socket uses per-session cleanup.
 #[test]
 fn rc4_exclusive_socket_is_fail_closed() {

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

@@ -35,43 +35,27 @@ pub(crate) fn render(command: &str, report: &Value) -> String {
     // generic emitter redacts again for defense in depth.
     let report = crate::redaction::redact_external_value(report);
     let ok = report.get("ok").and_then(Value::as_bool).unwrap_or(false);
-    let mut lines = vec![bounded(format!(
+    let runtime = report
+        .get("runtime")
+        .and_then(|runtime| runtime.get("status"))
+        .and_then(Value::as_str);
+    let issues = array_items(report.get("issues"));
+    let repairs = array_items(report.get("suggested_repairs"));
+    let mut summary = format!(
         "{command}: {}",
         if ok { "ok" } else { "needs attention" }
-    ))];
-
-    if command == "doctor" {
-        for finding in array_items(
-            report
-                .get("secret_scan")
-                .and_then(|scan| scan.get("findings")),
-        ) {
-            let Some(object) = finding.as_object() else {
-                continue;
-            };
-            let (Some(rule), Some(path), Some(line)) = (
-                object.get("rule").and_then(Value::as_str),
-                object.get("path").and_then(Value::as_str),
-                object.get("line").and_then(Value::as_u64),
-            ) else {
-                continue;
-            };
-            lines.push(bounded(format!("warn: {rule} in {path}:{line}")));
-        }
+    );
+    if let Some(runtime) = runtime {
+        summary.push_str(&format!("; runtime={runtime}"));
     }
-
-    for issue in array_items(report.get("issues")) {
+    summary.push_str(&format!("; issues={}; repairs={}", issues.len(), repairs.len()));
+    let mut lines = vec![bounded(summary)];
+    for issue in issues {
         lines.push(bounded(format!("issue: {}", summarize(issue, false))));
     }
-    for repair in array_items(report.get("suggested_repairs")) {
+    for repair in repairs {
         lines.push(bounded(format!("repair: {}", summarize(repair, true))));
     }
-    if let Some(error) = report.get("error").filter(|value| !value.is_null()) {
-        lines.push(bounded(format!("detail: {}", summarize(error, false))));
-    }
-    if lines.len() == 1 {
-        lines.push(bounded("detail: no issues detected".to_string()));
-    }
     lines.join("\n")
 }
 
@@ -95,6 +79,15 @@ fn summarize(value: &Value, repair: bool) -> String {
                     .as_slice()
             };
             let mut parts = Vec::new();
+            if let Some(path) = object.get("path").and_then(Value::as_str) {
+                let location = match object.get("line").and_then(Value::as_u64) {
+                    Some(line) => format!("{path}:{line}"),
+                    None => path.to_string(),
+                };
+                // Keep the target ahead of prose so bounded human lines retain
+                // the distinguishing location rather than only the issue id.
+                parts.push(format!("at={location}"));
+            }
             for key in keys {
                 if let Some(value) = object.get(*key).and_then(Value::as_str) {
                     parts.push(format!("{key}={value}"));
@@ -166,6 +159,13 @@ mod tests {
     fn renderer_projects_secret_findings_without_values() {
         let report = json!({
             "ok": false,
+            "issues": [{
+                "id": "secret_scan_finding",
+                "rule": "api_key_assignment",
+                "path": "leaky-role.md",
+                "line": 7,
+            }],
+            "suggested_repairs": [{"issue": "secret_scan_finding", "action": "remove secret finding at leaky-role.md:7"}],
             "secret_scan": {
                 "findings": [{
                     "rule": "api_key_assignment",
@@ -176,7 +176,7 @@ mod tests {
             }
         });
         let output = render("doctor", &report);
-        assert!(output.contains("warn: api_key_assignment in leaky-role.md:7"));
+        assert!(output.contains("issue: at=leaky-role.md:7; id=secret_scan_finding"));
         assert!(!output.contains("match_excerpt"));
         assert!(!output.contains("OPENAI_API_KEY=secret"));
     }

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

@@ -321,14 +321,6 @@ pub struct InitArgs {
     pub json: bool,
 }
 
-/// `compile`(`parser.py:125`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CompileArgs {
-    pub team: PathBuf,
-    pub out: PathBuf,
-    pub json: bool,
-}
-
 /// `send`(`parser.py:262`)。`target` xor `--to`(fanout);`message` 多 token join 空格。
 #[derive(Debug, Clone, PartialEq)]
 pub struct SendArgs {
@@ -697,7 +689,9 @@ pub struct WaitArgs {
     pub json: bool,
 }
 
-/// `diagnose`(`parser.py:298`) runtime health report, distinct from `doctor`.
+/// `diagnose` compatibility spelling for the canonical `doctor` health report.
+/// The CLI normalizes it to `DoctorArgs`; this narrow type remains for direct
+/// Rust callers that used the pre-unification API.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DiagnoseArgs {
     pub workspace: PathBuf,

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -1041,6 +1041,32 @@ fn restart_with_selected_team_and_transport(
             attach_commands,
         });
     }
+    // Respawn changes the generation used by shutdown's ownership check, even
+    // when build-before-destroy keeps the tmux session itself alive. Stamp only
+    // the selected session, after its replacement state is durable.
+    if let Some(generation) = state
+        .get("generation")
+        .and_then(serde_json::Value::as_str)
+        .or_else(|| {
+            state
+                .get("agents")
+                .and_then(serde_json::Value::as_object)
+                .and_then(|agents| {
+                    agents.values().find_map(|agent| {
+                        agent.get("spawned_at").and_then(serde_json::Value::as_str)
+                    })
+                })
+        })
+    {
+        transport
+            .set_session_owner_with_generation(
+                &session_name,
+                &selected.run_workspace,
+                &selected.team_key,
+                generation,
+            )
+            .map_err(|error| LifecycleError::Transport(error.to_string()))?;
+    }
     // RM-039-SESS-001 step 2 (architect verdict 2026-06-22): post-respawn
     // resume backing validation.
     //

package/crates/team-agent/src/lifecycle/tests/claude_profile_launch_red.rs

@@ -168,8 +168,10 @@ fn launch_restart_start_add_and_fork_all_delegate_to_the_profile_launch_resolver
 }
 
 #[test]
+#[serial_test::serial(env)]
 fn diagnose_missing_profile_is_rc1_ok_false_and_zero_token() {
-    let ws = tmp_dir("diagnose-missing-profile");
+    let env = hermetic_guard::HermeticTestEnv::enter("diagnose-missing-profile");
+    let ws = env.workspace("missing-profile");
     let team = write_claude_profile_team(&ws, "diagteam", "clauder");
     std::fs::remove_file(
         ws.join(".team")
@@ -180,7 +182,7 @@ fn diagnose_missing_profile_is_rc1_ok_false_and_zero_token() {
     .unwrap();
 
     let output = Command::new(crate::lifecycle::tests::test_binary_path())
-        .args(["diagnose", "--workspace", ws.to_str().unwrap(), "--json"])
+        .args(["diagnose", team.to_str().unwrap(), "--workspace", ws.to_str().unwrap(), "--json"])
         .current_dir(&team)
         .output()
         .expect("diagnose subprocess should run");
@@ -197,10 +199,14 @@ fn diagnose_missing_profile_is_rc1_ok_false_and_zero_token() {
         json!(false),
         "diagnose missing profile must emit ok:false JSON; stdout={stdout} stderr={stderr}"
     );
+    assert_eq!(json["profile_smoke"]["ok"], false, "{json}");
     assert!(
-        stdout.contains("profile") || stderr.contains("profile"),
-        "diagnose missing profile must name the profile problem without invoking Claude; stdout={stdout} stderr={stderr}"
+        json["profile_smoke"].to_string().contains("profile"),
+        "diagnose missing profile must identify the scoped configuration failure: {json}"
     );
+    assert!(json["providers"].as_object().unwrap().values().all(|provider| {
+        provider["probe_status"] == "not_run"
+    }));
     assert!(
         !stdout.contains("tokens") && !stderr.contains("tokens"),
         "diagnose dry-run must not consume provider tokens or report token usage; stdout={stdout} stderr={stderr}"

package/crates/team-agent/src/lifecycle/tests/restart_build_before_destroy_0540_contract.rs

@@ -30,7 +30,7 @@ use team_agent::state::persist::{load_runtime_state, save_runtime_state};
 use team_agent::transport::{
     AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport,
     InjectStage, InjectVerification, Key, PaneField, PaneId, PaneInfo, PaneLiveness, SessionName,
-    SetEnvOutcome, SpawnResult, SubmitVerification, Target, Transport, TransportError,
+    SessionOwner, SetEnvOutcome, SpawnResult, SubmitVerification, Target, Transport, TransportError,
     TurnVerification, WindowName,
 };
 
@@ -130,6 +130,95 @@ fn server_exited_during_replacement_spawn_does_not_cascade_session_disappeared_a
     );
 }
 
+#[test]
+#[serial(env)]
+fn scoped_shutdown_after_restart_refreshes_owner_and_preserves_sibling() {
+    let case = RestartCase::new("restart-shutdown-owner", worker_ids(2), ProviderShape::Fake);
+    let transport = BuildBeforeDestroyTransport::recording(worker_ids(2));
+    for pane in transport.state.lock().unwrap().panes.values_mut() {
+        pane.current_path = Some(case.workspace.clone());
+        pane.pane_pid = None;
+    }
+    let session = SessionName::new(TEAM_SESSION);
+    let sibling_session = SessionName::new("team-sibling");
+    let mut state = case.read_state();
+    // Host and worker tmux servers may allocate the same pane ID. The host
+    // receiver must not protect the replacement worker on this transport.
+    state["leader_receiver"] = json!({
+        "pane_id": "%new-1", "tmux_socket": "/tmp/s4-host-only.sock"
+    });
+    state["team_owner"] = json!({"pane_id": "%new-1"});
+    state["teams"][TEAM]["leader_receiver"] = state["leader_receiver"].clone();
+    state["teams"][TEAM]["team_owner"] = state["team_owner"].clone();
+    state["teams"]["sibling"] = json!({
+        "team_key": "sibling",
+        "session_name": sibling_session.as_str(),
+        "tmux_socket": TMUX_ENDPOINT,
+        "agents": {
+            "sibling-worker": {
+                "provider": "fake", "status": "running", "pane_id": "%sibling",
+                "spawned_at": "sibling-generation"
+            }
+        }
+    });
+    save_runtime_state(&case.workspace, &state).unwrap();
+    let sibling_before = case.read_state()["teams"]["sibling"].clone();
+    let mut sibling_pane = pane_info(
+        sibling_session.clone(), WindowName::new("sibling-worker"), PaneId::new("%sibling"),
+    );
+    sibling_pane.current_path = Some(case.workspace.clone());
+    sibling_pane.pane_pid = None;
+    transport.state.lock().unwrap().panes.insert("%sibling".to_string(), sibling_pane.clone());
+    transport.set_session_owner_with_generation(
+        &session, &case.workspace, TEAM, "2026-07-14T00:00:00+00:00",
+    ).unwrap();
+    transport.set_session_owner_with_generation(
+        &sibling_session, &case.workspace, "sibling", "sibling-generation",
+    ).unwrap();
+    let sibling_owner = transport.session_owner(&sibling_session).unwrap();
+
+    let report = restart_with_transport(&case.workspace, true, Some(TEAM), &transport).unwrap();
+    assert!(matches!(report, RestartReport::Restarted { .. }), "{report:?}");
+    let state = case.read_state();
+    let expected_generation = state["teams"][TEAM]["agents"]["w1"]["spawned_at"].as_str().unwrap();
+    assert_ne!(expected_generation, "2026-07-14T00:00:00+00:00");
+    let owner = transport.session_owner(&session).unwrap().unwrap();
+    assert_eq!(owner.workspace, case.workspace.canonicalize().unwrap().to_string_lossy());
+    assert_eq!(owner.team, TEAM);
+    assert_eq!(owner.generation, expected_generation);
+    assert_no_original_session_kill(&transport.ops(), "restart retains the session");
+
+    let out = team_agent::cli::lifecycle_port::shutdown_with_transport(
+        &case.workspace, true, Some(TEAM), &transport,
+    ).unwrap();
+    assert_eq!(out["ok"], true, "{out}");
+    assert_eq!(out["session_killed"], true, "{out}");
+    assert_eq!(out["spared_sessions"], json!([]), "{out}");
+    assert_eq!(out["coordinator_stop_reason"], "scoped_live_sibling_present", "{out}");
+    assert!(!transport.has_session(&session).unwrap());
+    assert!(transport.has_session(&sibling_session).unwrap());
+    assert_eq!(transport.session_owner(&sibling_session).unwrap(), sibling_owner);
+    assert_eq!(case.read_state()["teams"]["sibling"], sibling_before);
+    assert_eq!(transport.state.lock().unwrap().panes.get("%sibling"), Some(&sibling_pane));
+}
+
+#[test]
+#[serial(env)]
+fn failed_replacement_preserves_original_session_owner() {
+    let case = RestartCase::new("failed-restart-owner", worker_ids(1), ProviderShape::Fake);
+    let transport = BuildBeforeDestroyTransport::recording(worker_ids(1))
+        .with_spawn_failure("w1", "injected replacement spawn failure");
+    let session = SessionName::new(TEAM_SESSION);
+    transport.set_session_owner_with_generation(
+        &session, &case.workspace, TEAM, "2026-07-14T00:00:00+00:00",
+    ).unwrap();
+    let owner_before = transport.session_owner(&session).unwrap();
+    let report = restart_with_transport(&case.workspace, true, Some(TEAM), &transport).unwrap();
+    assert_restart_did_not_succeed(&report);
+    assert_eq!(transport.session_owner(&session).unwrap(), owner_before);
+    assert_eq!(transport.ops().iter().filter(|op| op.starts_with("set_session_owner:")).count(), 1);
+}
+
 struct RestartCase {
     env: hermetic_guard::HermeticTestEnv,
     workspace: PathBuf,
@@ -354,6 +443,7 @@ struct TransportState {
     session_present: bool,
     ops: Vec<String>,
     panes: BTreeMap<String, PaneInfo>,
+    owners: BTreeMap<String, SessionOwner>,
     next_pane: usize,
     spawns: usize,
 }
@@ -416,6 +506,7 @@ impl BuildBeforeDestroyTransport {
         kind: &'static str,
         session: &SessionName,
         window: &WindowName,
+        cwd: &Path,
     ) -> Result<SpawnResult, TransportError> {
         let mut state = self.state.lock().unwrap();
         state
@@ -434,10 +525,10 @@ impl BuildBeforeDestroyTransport {
         let pane_id = PaneId::new(format!("%new-{}", state.next_pane));
         state.next_pane += 1;
         state.session_present = true;
-        state.panes.insert(
-            pane_id.as_str().to_string(),
-            pane_info(session.clone(), window.clone(), pane_id.clone()),
-        );
+        let mut pane = pane_info(session.clone(), window.clone(), pane_id.clone());
+        pane.current_path = Some(cwd.to_path_buf());
+        pane.pane_pid = None;
+        state.panes.insert(pane_id.as_str().to_string(), pane);
         if self.server_exit_after_first_spawn && state.spawns == 1 {
             state.session_present = false;
         }
@@ -451,7 +542,12 @@ impl BuildBeforeDestroyTransport {
 
     fn real_tmux_has_session(&self, session: &SessionName) -> Result<bool, TransportError> {
         let Some(socket) = self.real_socket.as_ref() else {
-            return Ok(self.state.lock().unwrap().session_present);
+            let state = self.state.lock().unwrap();
+            return Ok(if session.as_str() == TEAM_SESSION {
+                state.session_present
+            } else {
+                state.panes.values().any(|pane| pane.session == *session)
+            });
         };
         Ok(Command::new("tmux")
             .args([
@@ -535,10 +631,10 @@ impl Transport for BuildBeforeDestroyTransport {
         session: &SessionName,
         window: &WindowName,
         _argv: &[String],
-        _cwd: &Path,
+        cwd: &Path,
         _env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError> {
-        self.spawn("spawn_first", session, window)
+        self.spawn("spawn_first", session, window, cwd)
     }
 
     fn spawn_into(
@@ -546,10 +642,10 @@ impl Transport for BuildBeforeDestroyTransport {
         session: &SessionName,
         window: &WindowName,
         _argv: &[String],
-        _cwd: &Path,
+        cwd: &Path,
         _env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError> {
-        self.spawn("spawn_into", session, window)
+        self.spawn("spawn_into", session, window, cwd)
     }
 
     fn inject(
@@ -648,6 +744,27 @@ impl Transport for BuildBeforeDestroyTransport {
         Ok(windows.into_iter().collect())
     }
 
+    fn set_session_owner_with_generation(
+        &self,
+        session: &SessionName,
+        workspace: &Path,
+        team: &str,
+        generation: &str,
+    ) -> Result<(), TransportError> {
+        let mut state = self.state.lock().unwrap();
+        state.ops.push(format!("set_session_owner:{}", session.as_str()));
+        state.owners.insert(session.as_str().to_string(), SessionOwner {
+            workspace: workspace.canonicalize().unwrap().to_string_lossy().into_owned(),
+            team: team.to_string(),
+            generation: generation.to_string(),
+        });
+        Ok(())
+    }
+
+    fn session_owner(&self, session: &SessionName) -> Result<Option<SessionOwner>, TransportError> {
+        Ok(self.state.lock().unwrap().owners.get(session.as_str()).cloned())
+    }
+
     fn set_session_env(
         &self,
         _session: &SessionName,
@@ -665,7 +782,7 @@ impl Transport for BuildBeforeDestroyTransport {
             .push(format!("kill_session:{}", session.as_str()));
         if session.as_str() == TEAM_SESSION {
             self.state.lock().unwrap().session_present = false;
-            self.state.lock().unwrap().panes.clear();
+            self.state.lock().unwrap().panes.retain(|_, pane| pane.session != *session);
             if let Some(socket) = self.real_socket.as_ref() {
                 let status = Command::new("tmux")
                     .args([

package/package.json

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