@team-agent/installer 0.5.105 → 0.5.106

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.105"
+version = "0.5.106"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.105"
+version = "0.5.106"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/README.md

@@ -82,9 +82,11 @@ Subagents are one-shot, fire-and-forget, and can't talk to each other. Team Agen
 
 ## Status
 
-`team-agent status` prints one concise row per registered node with seven fields:
-`name`, `provider`, `runtime_status`, `activity`, `health`, `session_name`, and `tmux_command`.
-`--json` exposes the same projection as structured JSON. Missing or conflicting evidence is
+`team-agent status` prints one concise row per registered node with nine fields:
+`name`, `provider`, `model`, `effort`, `runtime_status`, `activity`, `health`, `session_name`, and `tmux_command`.
+`model` and `effort` are the last accepted launch settings, or `null` when unspecified;
+pending role-file edits and provider defaults are not inferred.
+`--json` exposes the same projection as structured JSON. Missing or conflicting runtime evidence is
 reported as `unknown`; a non-null `tmux_command` is safe to copy for the observed socket,
 session, window, and pane. `--summary` and `--detail` remain accepted for compatibility and
 do not add diagnostic or history fields. The accepted nodeprobe pairing and

package/README.zh.md

@@ -82,9 +82,10 @@ subagent 是一次性的、干完即焚、彼此不通信。Team Agent 的队友
 
 ## 状态
 
-`team-agent status` 为每个已登记节点输出七个简要字段：
-`name`、`provider`、`runtime_status`、`activity`、`health`、`session_name`、`tmux_command`。
-`--json` 与人读输出使用同一信息投影。证据缺失或冲突时显示 `unknown`；非空
+`team-agent status` 为每个已登记节点输出九个简要字段：
+`name`、`provider`、`model`、`effort`、`runtime_status`、`activity`、`health`、`session_name`、`tmux_command`。
+`model`、`effort` 来自最近已接受的启动配置，未设置时为 `null`；不会把待启动的角色编辑或猜测的 provider 默认值当作已生效。
+`--json` 与人读输出使用同一信息投影。运行态证据缺失或冲突时显示 `unknown`；非空
 `tmux_command` 可复制到已观测的 socket、session、window 和 pane。`--summary` 与
 `--detail` 保留兼容性，但不会增加诊断或历史字段。已验收 nodeprobe 的配对方式、
 operator-trusted 能力 receipt 与 fail-closed 边界见

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

@@ -174,7 +174,7 @@ fn append_reminder(text: String, reminder: &str) -> String {
     }
 }
 
-/// `cmd_status`(`commands.py:90`)。CLI status 统一为只读七字段 brief；
+/// `cmd_status`(`commands.py:90`)。CLI status 统一为只读九字段 brief；
 /// `--json` 与人读路径共享 native tmux/process projection；`--summary`/`--detail` 保留参数兼容性但不暴露诊断。
 #[cfg(test)]
 pub(crate) fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
@@ -1640,6 +1640,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn reminders_only_recommend_supported_result_commands() {
+        let reminder = crate::cli::QUICK_START_REMINDER;
+        assert!(reminder.contains("Use team-agent status / inbox instead."));
+        for text in [
+            reminder,
+            crate::cli::STATUS_REMINDER,
+            crate::cli::SEND_REMINDER,
+            &quickstart_human(&json!({"summary": "team started"})),
+        ] {
+            assert!(!text.contains("collect"), "removed CLI command leaked: {text}");
+        }
+    }
+
     #[test]
     fn e13_quickstart_human_summary_only_when_no_attach() {
         let value = json!({"summary": "quick-start complete"});

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

@@ -340,15 +340,21 @@ fn command_help(command: Option<&str>) -> String {
         )
         .to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
-        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出七字段：name/provider/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。缺少可靠定位或原生 tmux/process 采样时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
+        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出九字段：name/provider/model/effort/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。model/effort 为已接受启动配置，未设置为 null，不猜 provider 默认值。缺少可靠定位或原生 tmux/process 采样时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
         Some("models") => "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code] [QUERY|--search TEXT] [--json]\n\nLists exact provider model ids with case-insensitive multi-word search across provider, vendor, id, display name, and source aliases. Uses each provider's native catalog; Codex uses `codex debug models` and Claude uses SDK stream-json initialize.".to_string(),
         Some("leaders") => "usage: team-agent leaders [QUERY|--search TEXT] [--all|--stale] [--json] | --prune [--dry-run] [--json]\n\nLists LIVE leaders by default. Use --all to include retained STALE entries, --stale to inspect only STALE entries, QUERY or --search TEXT to match workspace/team/name fields, and --prune to remove only entries proven terminal by canonical state. --dry-run is valid only with --prune.".to_string(),
         Some("shutdown") => "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
         Some("restart") => "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json] [--detail]".to_string(),
         Some("reset-agent") => "usage: team-agent reset-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--discard-session] [--json]".to_string(),
-        Some("start-agent") => "usage: team-agent start-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--force] [--allow-fresh] [--json]\n\nAfter a successful start, use the returned `send_commands` with `team-agent send AGENT MESSAGE`.".to_string(),
+        Some(name @ ("start-agent" | "add-agent")) => command_spec(name)
+            .map(|spec| format!(
+                "{}\n\n{}\n\nAfter a successful {}, use the returned `send_commands` with `team-agent send AGENT MESSAGE`.",
+                spec.usage,
+                spec.summary,
+                if name == "start-agent" { "start" } else { "add" },
+            ))
+            .unwrap_or_else(|| format!("usage: team-agent {name} [options]")),
         Some("stop-agent") => "usage: team-agent stop-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
-        Some("add-agent") => "usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--json]\n\nAfter a successful add, use the returned `send_commands` with `team-agent send AGENT MESSAGE`.".to_string(),
         Some("clone-agent") => "usage: team-agent clone-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("fork-agent") => "usage: team-agent fork-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("remove-agent") => "usage: team-agent remove-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--from-spec] [--confirm] [--force] [--json]".to_string(),
@@ -2173,11 +2179,8 @@ mod tests {
             (
                 "start-agent",
                 &[
-                    "--workspace",
-                    "--team",
-                    "--force",
-                    "--allow-fresh",
-                    "--json",
+                    "--model", "--effort", "--bypass", "--prompt", "--profile", "--provider",
+                    "--workspace", "--team", "--allow-fresh", "--json",
                 ][..],
             ),
             (
@@ -2192,10 +2195,8 @@ mod tests {
             (
                 "add-agent",
                 &[
-                    "--role-file",
-                    "--workspace",
-                    "--team",
-                    "--json",
+                    "--role-file", "--provider", "--bypass", "--model", "--effort", "--prompt", "--profile",
+                    "--force", "--workspace", "--team", "--json",
                 ][..],
             ),
             (
@@ -2282,11 +2283,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn worker_lifecycle_help_uses_authoritative_spec_usage_and_summary() {
+        for name in ["start-agent", "add-agent"] {
+            let spec = command_spec(name).expect("registered worker lifecycle command");
+            let help = command_help(Some(name));
+            assert_eq!(help.lines().next(), Some(spec.usage));
+            assert!(help.contains(spec.summary));
+            for flag in ["--model SLUG", "--effort LEVEL", "--bypass true|false", "--prompt TEXT", "--profile NAME", "--provider NAME"] {
+                assert!(help.contains(flag), "{name} help missing {flag}: {help}");
+            }
+            assert!(help.contains("team-agent send AGENT MESSAGE"));
+        }
+        assert!(!command_help(Some("start-agent")).contains("--force"));
+        let add = command_help(Some("add-agent"));
+        assert!(add.contains("[--role-file FILE]"));
+        assert!(add.contains("provider/bypass required from CLI or role file"));
+        assert!(add.contains("conflicting values rejected"));
+    }
+
     #[test]
     fn status_help_describes_brief_projection_and_unknown_boundary() {
         let help = command_help(Some("status"));
         for marker in [
-            "name/provider/runtime_status/activity/health/session_name/tmux_command",
+            "name/provider/model/effort/runtime_status/activity/health/session_name/tmux_command",
             "人读与 --json 使用同一投影",
             "显示 unknown",
             "tmux_command",

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

@@ -49,7 +49,7 @@ use crate::messaging::{self, MessageTarget, SendOptions, TrustedSender};
 use crate::model::ids::{TaskId, TeamKey};
 
 pub(crate) const COMMS_BOUNDARY_TEXT: &str = "validates live pane binding consistency and zero-token comms contracts. Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
-pub(crate) const QUICK_START_REMINDER: &str = "Reminder: Do not inspect raw worker pane output during normal operation. Use team-agent status / inbox / collect instead. Wait for report_result.";
+pub(crate) const QUICK_START_REMINDER: &str = "Reminder: Do not inspect raw worker pane output during normal operation. Use team-agent status / inbox instead. Wait for report_result.";
 pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker to report_result. Do not poll the worker terminal with capture-pane.";
 pub(crate) const STATUS_REMINDER: &str = "Results are finalized automatically; use --watch-result or team-agent inbox AGENT -n 3 for transport fallback. Do not capture-pane worker terminals.";
 
@@ -707,19 +707,7 @@ pub mod lifecycle_port {
     }
 
     fn state_generation(state: &Value) -> Option<&str> {
-        state
-            .get("generation")
-            .and_then(Value::as_str)
-            .or_else(|| {
-                state
-                    .get("agents")
-                    .and_then(Value::as_object)
-                    .and_then(|agents| {
-                        agents.values().find_map(|agent| {
-                            agent.get("spawned_at").and_then(Value::as_str)
-                        })
-                    })
-            })
+        crate::state::projection::session_generation(state)
     }
 
     fn state_for_session<'a>(state: &'a Value, session: &str) -> Option<&'a Value> {
@@ -777,12 +765,23 @@ pub mod lifecycle_port {
         if owner.generation != expected_generation {
             return SessionOwnership::Foreign;
         }
-        if session_targets.iter().any(|target| {
-            target.current_path.as_ref().map_or(true, |path| {
-                !path_is_under(path.as_path(), workspace)
-            })
-        }) {
-            return SessionOwnership::Unknown;
+        for target in session_targets {
+            if target.current_path.as_ref().is_some_and(|path| {
+                path_is_under(path.as_path(), workspace)
+            }) {
+                continue;
+            }
+            // An exited keepalive has no cwd or live process. Exempt only the
+            // internal anchor, with native positive dead-pane proof, AFTER the
+            // session workspace/team/generation ownership gates above.
+            let dead_anchor = target.current_path.as_ref().is_none_or(|path| {
+                path.as_os_str().is_empty()
+            }) && target.window_name.as_ref().is_some_and(|window| {
+                window.as_str() == crate::tmux_backend::KEEPALIVE_WINDOW_NAME
+            }) && matches!(transport.pane_is_dead(&target.pane_id), Ok(Some(true)));
+            if !dead_anchor {
+                return SessionOwnership::Unknown;
+            }
         }
         SessionOwnership::Owned
     }
@@ -793,7 +792,135 @@ pub mod lifecycle_port {
 
         use super::*;
         use crate::transport::test_support::OfflineTransport;
-        use crate::transport::{PaneId, PaneInfo, SessionName};
+        use crate::transport::{PaneId, PaneInfo, SessionName, Transport, WindowName};
+
+        fn ownership_pane(session: &SessionName, pane: &str, window: &str, cwd: Option<PathBuf>) -> PaneInfo {
+            PaneInfo {
+                pane_id: PaneId::new(pane),
+                session: session.clone(),
+                window_index: None,
+                window_name: Some(WindowName::new(window)),
+                pane_index: None,
+                tty: None,
+                current_command: None,
+                current_path: cwd,
+                active: false,
+                pane_pid: None,
+                leader_env: BTreeMap::new(),
+            }
+        }
+
+        #[test]
+        fn dead_anchor_ownership_requires_native_dead_proof_and_all_owner_markers() {
+            let workspace = std::env::temp_dir().canonicalize().unwrap();
+            let session = SessionName::new("owned");
+            let state = json!({"team_key": "owned", "generation": "g"});
+            for (window, cwd, dead, team, generation, expected) in [
+                (crate::tmux_backend::KEEPALIVE_WINDOW_NAME, None, Some(true), "owned", "g", SessionOwnership::Owned),
+                (crate::tmux_backend::KEEPALIVE_WINDOW_NAME, None, Some(false), "owned", "g", SessionOwnership::Unknown),
+                (crate::tmux_backend::KEEPALIVE_WINDOW_NAME, None, None, "owned", "g", SessionOwnership::Unknown),
+                ("foreign", None, Some(true), "owned", "g", SessionOwnership::Unknown),
+                (crate::tmux_backend::KEEPALIVE_WINDOW_NAME, Some(PathBuf::from("/foreign-workspace")), Some(true), "owned", "g", SessionOwnership::Unknown),
+                (crate::tmux_backend::KEEPALIVE_WINDOW_NAME, None, Some(true), "other-team", "g", SessionOwnership::Foreign),
+                (crate::tmux_backend::KEEPALIVE_WINDOW_NAME, None, Some(true), "owned", "other-generation", SessionOwnership::Foreign),
+            ] {
+                let mut transport = OfflineTransport::new().with_session_owner(&workspace, team, generation);
+                if let Some(dead) = dead { transport = transport.with_pane_dead("%1", dead); }
+                let targets = vec![
+                    ownership_pane(&session, "%2", "assistant", Some(workspace.clone())),
+                    ownership_pane(&session, "%1", window, cwd),
+                ];
+                assert_eq!(session_ownership(&workspace, &state, &transport, &session, &targets), expected);
+                if expected == SessionOwnership::Foreign {
+                    assert!(!transport.calls().contains(&"pane_is_dead"), "owner gates must precede exemption");
+                }
+                assert!(!transport.calls().contains(&"kill_session"));
+            }
+        }
+
+        #[test]
+        #[cfg(unix)]
+        #[ignore = "isolated native tmux: explicit Grok execution, no provider subscription"]
+        fn dead_anchor_scoped_shutdown_reaps_worker_wrapper_and_spares_other_team() {
+            let root = std::env::temp_dir().join(format!(
+                "ta-r2-{}-{}", std::process::id(), chrono::Utc::now().timestamp_nanos_opt().unwrap(),
+            ));
+            std::fs::create_dir(&root).unwrap();
+            let root = root.canonicalize().unwrap();
+            let workspace = root.join("owned");
+            let foreign_workspace = root.join("foreign");
+            std::fs::create_dir(&workspace).unwrap();
+            std::fs::create_dir(&foreign_workspace).unwrap();
+            let endpoint = root.join("sock");
+            let transport = crate::tmux_backend::TmuxBackend::with_runner_for_tmux_endpoint(
+                Box::new(crate::tmux_backend::RealCommandRunner), endpoint.to_str().unwrap(),
+            );
+            let session = SessionName::new("round2-owned");
+            let foreign = SessionName::new("round2-foreign");
+            struct Cleanup<'a>(&'a crate::tmux_backend::TmuxBackend, [&'a SessionName; 2], &'a Path);
+            impl Drop for Cleanup<'_> {
+                fn drop(&mut self) {
+                    for session in self.1 { let _ = self.0.kill_session(session); }
+                    let _ = std::fs::remove_dir_all(self.2);
+                }
+            }
+            let _cleanup = Cleanup(&transport, [&session, &foreign], &root);
+            let env = BTreeMap::new();
+            let argv = vec!["sh".to_string(), "-c".to_string(), "exit 0".to_string()];
+            let first = transport.spawn_first_with_worker_shell_wrapper(
+                &session, &WindowName::new("assistant"), &argv, &workspace, &env, &[], "pi",
+            ).unwrap();
+            transport.set_session_owner_with_generation(&session, &workspace, "round2-owned", "g").unwrap();
+            transport.preserve_session_before_stop(&session, &[crate::transport::Target::Pane(first.pane_id.clone())]).unwrap();
+            transport.kill_pane(&first.pane_id).unwrap();
+            let worker = transport.spawn_into_with_worker_shell_wrapper(
+                &session, &WindowName::new("assistant"), &argv, &workspace, &env, &[], "pi",
+            ).unwrap();
+            let foreign_worker = transport.spawn_first(
+                &foreign, &WindowName::new("other"), &["sleep".to_string(), "60".to_string()],
+                &foreign_workspace, &env,
+            ).unwrap();
+            transport.set_session_owner_with_generation(&foreign, &foreign_workspace, "round2-foreign", "foreign-g").unwrap();
+            let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3);
+            let marker = format!("{} 0", crate::tmux_backend::worker_provider_exit_marker("pi"));
+            loop {
+                // This controlled fixture prints nothing: the worker wrapper
+                // and its inert tail supply these two lines. provider_exit_status
+                // is a leader-only receipt, not a worker-wrapper observation.
+                let captured = transport.capture(
+                    &crate::transport::Target::Pane(worker.pane_id.clone()),
+                    crate::transport::CaptureRange::Full,
+                ).unwrap();
+                if captured.text.contains(&marker)
+                    && captured.text.contains("Provider exited; this pane no longer accepts input.")
+                {
+                    break;
+                }
+                assert!(std::time::Instant::now() < deadline, "worker must reach its inert exit wrapper: {}", captured.text);
+                std::thread::sleep(std::time::Duration::from_millis(20));
+            }
+            assert_eq!(transport.pane_is_dead(&worker.pane_id).unwrap(), Some(false));
+            let worker_pid = worker.child_pid.unwrap();
+            assert!(crate::platform::process::pid_is_alive(worker_pid));
+            let state = json!({
+                "team_key": "round2-owned", "active_team_key": "round2-owned",
+                "session_name": session.as_str(), "tmux_socket": endpoint.to_str().unwrap(),
+                "generation": "g", "is_external_leader": true,
+                "agents": {"assistant": {
+                    "status": "running", "provider": "pi", "model": "openai-codex/gpt-6-luna", "effort": "max",
+                    "window": "assistant", "pane_id": worker.pane_id.as_str(), "pane_pid": worker_pid,
+                    "spawned_at": "new-worker-birth-after-start"
+                }}
+            });
+            crate::state::persist::save_runtime_state(&workspace, &state).unwrap();
+            let result = shutdown_with_transport_and_state(&workspace, true, None, &transport, Some(state)).unwrap();
+            assert_eq!(result["ok"], true, "{result}");
+            assert_eq!(result["residuals"], json!({"sessions": [], "processes": [], "owned_files": []}), "{result}");
+            assert!(!transport.has_session(&session).unwrap());
+            assert!(!crate::platform::process::pid_is_alive(worker_pid));
+            assert!(transport.has_session(&foreign).unwrap());
+            assert!(crate::platform::process::pid_is_alive(foreign_worker.child_pid.unwrap()));
+        }
 
         #[test]
         fn leader_process_protection_does_not_alias_panes_across_endpoints() {

package/crates/team-agent/src/cli/status_port/brief.rs

@@ -1,4 +1,4 @@
-//! Seven-field, read-only status projection backed by native tmux and process samples.
+//! Read-only status: native runtime samples plus accepted launch model/effort.
 //!
 //! This intentionally does not reuse RuntimeSnapshot: the legacy snapshot reads
 //! coordinator/db/history and carries diagnostic fields that are outside the
@@ -82,6 +82,8 @@ static NODEPROBE_RESOLVER_ACTIVE: AtomicBool = AtomicBool::new(false);
 struct RegisteredNode {
     name: String,
     provider: String,
+    model: Option<String>,
+    effort: Option<String>,
     endpoint: Option<String>,
     session: Option<String>,
     window: Option<String>,
@@ -106,6 +108,8 @@ struct ProbeNode {
 struct BriefNode {
     name: String,
     provider: String,
+    model: Option<String>,
+    effort: Option<String>,
     runtime_status: String,
     activity: String,
     health: String,
@@ -157,7 +161,7 @@ pub(crate) fn status_brief_scoped(
     })
 }
 
-/// Human output is the exact same seven-field projection as JSON, rendered in
+/// Human output is the exact same nine-field projection as JSON, rendered in
 /// stable field order. Null values remain explicit rather than becoming a
 /// diagnostic or an inferred value.
 pub(crate) fn format_status_brief(
@@ -305,9 +309,11 @@ fn write_test_capability_receipt(path: &Path) {
 
 fn format_brief_node(value: &Value) -> Option<String> {
     Some(format!(
-        "name: {} provider: {} runtime_status: {} activity: {} health: {} session_name: {} tmux_command: {}",
+        "name: {} provider: {} model: {} effort: {} runtime_status: {} activity: {} health: {} session_name: {} tmux_command: {}",
         value.get("name")?.as_str()?,
         value.get("provider")?.as_str()?,
+        display_optional(value.get("model")?),
+        display_optional(value.get("effort")?),
         value.get("runtime_status")?.as_str()?,
         value.get("activity")?.as_str()?,
         value.get("health")?.as_str()?,
@@ -369,6 +375,10 @@ fn registered_node(name: &str, value: &Value, state: &Value) -> RegisteredNode {
     RegisteredNode {
         name: name.to_string(),
         provider,
+        // Accepted launch settings, not pending role-file edits or guessed
+        // provider defaults. Runtime liveness remains a separate signal.
+        model: string_at(value, &["model"]),
+        effort: string_at(value, &["effort"]),
         endpoint: endpoint(value).or_else(|| endpoint(state)),
         session: first_string(value, &["session_name", "session"])
             .or_else(|| {
@@ -1052,6 +1062,8 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
             MatchResult::Missing => BriefNode {
                 name: node.name.clone(),
                 provider: node.provider.clone(),
+                model: node.model.clone(),
+                effort: node.effort.clone(),
                 runtime_status: "stopped".to_string(),
                 activity: "unknown".to_string(),
                 health: "unknown".to_string(),
@@ -1092,6 +1104,8 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
         } else {
             node.provider.clone()
         },
+        model: node.model.clone(),
+        effort: node.effort.clone(),
         runtime_status: "running".to_string(),
         activity: activity.to_string(),
         health: health.to_string(),
@@ -1172,6 +1186,8 @@ impl BriefNode {
         Self {
             name: node.name.clone(),
             provider: node.provider.clone(),
+            model: node.model.clone(),
+            effort: node.effort.clone(),
             runtime_status: "unknown".to_string(),
             activity: "unknown".to_string(),
             health: "unknown".to_string(),
@@ -1184,6 +1200,8 @@ impl BriefNode {
         let mut object = Map::new();
         object.insert("name".to_string(), json!(self.name));
         object.insert("provider".to_string(), json!(self.provider));
+        object.insert("model".to_string(), json!(self.model));
+        object.insert("effort".to_string(), json!(self.effort));
         object.insert("runtime_status".to_string(), json!(self.runtime_status));
         object.insert("activity".to_string(), json!(self.activity));
         object.insert("health".to_string(), json!(self.health));
@@ -1208,6 +1226,8 @@ mod tests {
         RegisteredNode {
             name: "worker".to_string(),
             provider: "pi".to_string(),
+            model: None,
+            effort: None,
             endpoint: Some("/tmp/tmux socket/o'k".to_string()),
             session: Some("sess".to_string()),
             window: Some("win".to_string()),
@@ -1234,6 +1254,45 @@ mod tests {
         br#"{"schema_version":1,"socket":"/tmp/sock","sampled_at":"2026-01-01T00:00:00Z","nodes":[],"error":{"kind":"tmux_inventory","message":"missing"}}"#
     }
 
+    #[test]
+    fn status_model_effort_project_accepted_launch_settings_in_all_runtime_states() {
+        for settings in [(None, None), (Some("openai-codex/gpt-6-luna"), Some("max"))] {
+            let mut node = registered();
+            node.model = settings.0.map(str::to_string);
+            node.effort = settings.1.map(str::to_string);
+            for lifecycle in [None, Some("stopped")] {
+                node.lifecycle = lifecycle.map(str::to_string);
+                for sample in [None, Some(ProbeResult { nodes: vec![probe("pi_activity_channel")] })] {
+                    let value = project_node(&node, Some(&sample)).into_json();
+                    assert_eq!(value["model"], json!(settings.0));
+                    assert_eq!(value["effort"], json!(settings.1));
+                    let human = format_brief_node(&value).unwrap();
+                    assert!(human.contains(&format!("model: {} effort: {}", settings.0.unwrap_or("null"), settings.1.unwrap_or("null"))));
+                    assert_eq!(value.as_object().unwrap().len(), 9);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn status_model_effort_use_canonical_runtime_roster_not_stale_projection() {
+        let state = json!({
+            "active_team_key": "selected",
+            "agents": {"worker": {"model": "stale-model", "effort": "low"}},
+            "teams": {"selected": {"agents": {
+                "worker": {"model": "accepted-model", "effort": "max"},
+                "plain": {}
+            }}}
+        });
+        let selected = registered_nodes(&state, Some("worker"));
+        assert_eq!(selected.len(), 1);
+        assert_eq!(selected[0].model.as_deref(), Some("accepted-model"));
+        assert_eq!(selected[0].effort.as_deref(), Some("max"));
+        let plain = registered_nodes(&state, Some("plain"));
+        assert!(plain[0].model.is_none());
+        assert!(plain[0].effort.is_none());
+    }
+
     #[test]
     fn pi_pane_title_is_unknown_not_idle() {
         let node = registered();

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

@@ -333,12 +333,12 @@ fn cli_add_agent_duplicate_id_surfaces_real_error() {
         );
 }
 
-// 5 [P1] — cmd_status --json emits the concise seven-field node projection.
+// 5 [P1] — cmd_status --json emits the concise nine-field node projection.
 // Status must not leak coordinator/db/history diagnostics; missing exact nodeprobe evidence remains
 // an explicit unknown projection. The fixture still seeds a real store to ensure the status path
 // does not accidentally depend on coordinator or mailbox reads.
 #[test]
-fn cli_status_emits_seven_field_brief_without_diagnostics() {
+fn cli_status_emits_nine_field_brief_without_diagnostics() {
     let ws = seed_status_workspace(); // writes .team/runtime/state.json
     let store = crate::message_store::MessageStore::open(&ws).unwrap();
     let _ = store
@@ -399,6 +399,8 @@ fn cli_status_emits_seven_field_brief_without_diagnostics() {
         [
             "name",
             "provider",
+            "model",
+            "effort",
             "runtime_status",
             "activity",
             "health",

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

@@ -345,7 +345,7 @@ fn status_compact_reports_identity_slot_health_on_grok_identity_slot_ok() {
 }
 
 #[test]
-fn cmd_status_human_is_seven_field_brief_without_diagnostics() {
+fn cmd_status_human_is_nine_field_brief_without_diagnostics() {
     let ws = seed_status_workspace();
     let args = StatusArgs {
         agent: None,
@@ -364,7 +364,7 @@ fn cmd_status_human_is_seven_field_brief_without_diagnostics() {
 
     assert!(
         text.contains(
-            "name: a1 provider: unknown runtime_status: unknown activity: unknown health: unknown session_name: null tmux_command: null"
+            "name: a1 provider: unknown model: null effort: null runtime_status: unknown activity: unknown health: unknown session_name: null tmux_command: null"
         ),
         "{text}"
     );

package/crates/team-agent/src/lifecycle/launch/state_projection.rs

@@ -170,12 +170,17 @@ pub(super) fn persist_spawn_agent_state(
             )?,
         );
     }
+    let generation = started
+        .first()
+        .map(|agent| agent.spawned_at.as_str())
+        .unwrap_or(session_name.as_str());
+    // Use the same birth identity as the native session owner marker. Worker
+    // spawned_at may change on start-agent; this session generation must not.
     if let Some(obj) = state.as_object_mut() {
         obj.insert("agents".to_string(), serde_json::Value::Object(agents));
+        obj.insert("generation".to_string(), serde_json::json!(generation));
     } else {
-        let mut obj = serde_json::Map::new();
-        obj.insert("agents".to_string(), serde_json::Value::Object(agents));
-        state = serde_json::Value::Object(obj);
+        state = serde_json::json!({"agents": agents, "generation": generation});
     }
     save_launched_team_state_for_key(workspace, &state, Some(&team_id), None)
 }

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

@@ -373,6 +373,8 @@ pub(crate) fn start_agent_at_paths(
     };
     let into_existing_session =
         session_live_or_default(transport, &session_name, session_name_present(&state));
+    let inherited_generation =
+        crate::state::projection::session_generation(&state).map(str::to_string);
     let safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn_json(
         &agent,
         provider,
@@ -441,6 +443,24 @@ pub(crate) fn start_agent_at_paths(
         &safety,
         start_mode,
     )?;
+    let generation = if into_existing_session {
+        inherited_generation.as_deref()
+    } else {
+        Some(spawn.spawned_at.as_str())
+    };
+    if let Some(generation) = generation {
+        state["generation"] = serde_json::json!(generation);
+        if !into_existing_session {
+            transport
+                .set_session_owner_with_generation(
+                    &session_name,
+                    workspace,
+                    &resolved_team_key,
+                    generation,
+                )
+                .map_err(|error| LifecycleError::Transport(error.to_string()))?;
+        }
+    }
     // 0.5.66 bypass 单源 §2.7:启动即带 bypass → 审计留痕。
     if safety.enabled {
         let state_agent = state
@@ -1156,6 +1176,30 @@ pub(super) fn stop_agent_at_paths(
         || !same_role_panes.is_empty()
         || (pane_id.is_none() && window_exists(transport, &session_name, &window));
     if stopped {
+        let stop_targets =
+            if let Some(pane) = pane_id.as_ref().filter(|_| stored_pane_live) {
+                vec![Target::Pane(pane.clone())]
+            } else if !same_role_panes.is_empty() {
+                same_role_panes
+                    .iter()
+                    .map(|pane| Target::Pane(pane.pane_id.clone()))
+                    .collect()
+            } else {
+                vec![Target::SessionWindow {
+                    session: session_name.clone(),
+                    window: WindowName::new(&window),
+                }]
+            };
+        // Explicit kill-pane/kill-window ignores remain-on-exit on the worker.
+        // Preserve the last window BEFORE killing it, or the coordinator sees
+        // a missing session and stops while the seat is merely being stopped.
+        transport
+            .preserve_session_before_stop(&session_name, &stop_targets)
+            .map_err(|error| {
+                LifecycleError::Transport(format!(
+                    "failed to preserve session before stopping agent {agent_id}: {error}"
+                ))
+            })?;
         // golden operations.py:84-86: a non-zero kill-window raises
         // RuntimeError(f"failed to stop agent {agent_id}: {proc.stderr.strip()}").
         //