@team-agent/installer 0.5.63 → 0.5.65

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.63"
+version = "0.5.65"
 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.63"
+version = "0.5.65"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -523,6 +523,11 @@ pub fn cmd_results(args: &ResultsArgs) -> Result<CmdResult, CliError> {
     })
 }
 
+pub fn cmd_wait(args: &WaitArgs) -> Result<CmdResult, CliError> {
+    let result = messaging::wait_for_result(&args.workspace, &args.task_id)?;
+    Ok(CmdResult::from_json(result.to_json(), args.json))
+}
+
 /// `cmd_allow_peer_talk`(`parser.py allow-peer-talk`).
 pub fn cmd_allow_peer_talk(args: &AllowPeerTalkArgs) -> Result<CmdResult, CliError> {
     if args.team.is_some() {

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

@@ -196,6 +196,7 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
                 .map(emit_result)
         }
         "results" => cmd_results(&results_args(args, cwd)?).map(emit_result),
+        "wait" => cmd_wait(&wait_args(args, cwd)?).map(emit_result),
         "diagnose" => cmd_diagnose(&diagnose_args(args, cwd)).map(emit_result),
         "preflight" => cmd_preflight(&preflight_args(args, cwd)).map(emit_result),
         "wait-ready" => cmd_wait_ready(&wait_ready_args(args, cwd)).map(emit_result),
@@ -243,6 +244,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "profile",
     "collect",
     "results",
+    "wait",
     "diagnose",
     "preflight",
     "wait-ready",
@@ -403,6 +405,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]".to_string(),
         Some("collect") => "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]".to_string(),
         Some("results") => "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
+        Some("wait") => "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]".to_string(),
         Some("diagnose") => "usage: team-agent diagnose [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("preflight") => "usage: team-agent preflight [TEAMDIR] [--json]".to_string(),
         Some("wait-ready") => "usage: team-agent wait-ready [--workspace WORKSPACE] [--team TEAM] [--timeout SECONDS] [--json]".to_string(),
@@ -1319,6 +1322,18 @@ fn watch_args(args: &[String], cwd: &Path) -> WatchArgs {
     }
 }
 
+fn wait_args(args: &[String], cwd: &Path) -> Result<WaitArgs, CliError> {
+    let parsed = parse_args(args);
+    let workspace = workspace(&parsed, cwd);
+    Ok(WaitArgs {
+        task_id: parsed
+            .task
+            .ok_or_else(|| CliError::Usage("wait requires --task <id>".to_string()))?,
+        workspace,
+        json: parsed.json,
+    })
+}
+
 fn approvals_args(args: &[String], cwd: &Path) -> ApprovalsArgs {
     let parsed = parse_args(args);
     ApprovalsArgs {

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

@@ -2245,14 +2245,15 @@ pub mod lifecycle_port {
     /// runs, where the leader is never in the invoker's ancestry.
     ///
     /// 0.4.x (CR R3): leader shell wrapper interaction. The leader pane's
-    /// controlling process is the `sh -lc "...; exec ${SHELL} -l"` that
-    /// runs Claude as a CHILD. When Claude exits and the shell wrapper falls
-    /// back via `exec ${SHELL} -l`, the controlling PID is REPLACED in-place
-    /// by the interactive shell (same pane_pid). Because this function
-    /// protects by `pane.pane_pid` (Source 1 & 2), the fallback interactive
-    /// shell is already covered by the same protection set — shutdown will
-    /// NOT treat the fallback shell as a stray process. Verified by the
-    /// `leader_fallback_shell_protected_when_provider_exited` test.
+    /// controlling process is the `sh -lc` wrapper that runs Claude as a
+    /// CHILD. When Claude exits, the wrapper records the marker and replaces
+    /// its command with the inert `/bin/sh -c` tail (which ignores INT/QUIT
+    /// and does not read pane stdin). Because this function protects by
+    /// `pane.pane_pid` (Source 1 & 2), that tail is covered by the same
+    /// protection set — shutdown will NOT treat it as a stray process.
+    /// This protection is currently untested; the former claim that
+    /// `leader_fallback_shell_protected_when_provider_exited` verified it
+    /// referred to a test absent from this repository (A-46).
     ///
     /// Two leader-pane sources(N39 双来源,真机 grounded):
     /// 1. **Session prefix**: tmux session starts with `team-agent-leader-`(契约 grounded;

package/crates/team-agent/src/cli/send/presentation.rs

@@ -108,6 +108,7 @@ pub(super) fn delivery_outcome_json(
         "sender": opts.sender,
         "message_id": outcome.message_id,
         "message_status": outcome.message_status.0,
+        "ack_forced_off": outcome.ack_forced_off,
         "verification": outcome.verification,
         "stage": outcome.stage.map(delivery_stage_wire),
         "reason": outcome.reason.map(delivery_refusal_wire),

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

@@ -78,6 +78,7 @@ pub(crate) enum DispatchKind {
     Profile,
     Collect,
     Results,
+    Wait,
     Diagnose,
     Preflight,
     WaitReady,
@@ -123,6 +124,7 @@ pub(crate) const ALL_DISPATCH_KINDS: &[DispatchKind] = &[
     DispatchKind::Profile,
     DispatchKind::Collect,
     DispatchKind::Results,
+    DispatchKind::Wait,
     DispatchKind::Diagnose,
     DispatchKind::Preflight,
     DispatchKind::WaitReady,
@@ -162,6 +164,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "collect", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Collect), summary: "collect reported results", usage: "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "wait", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Wait), summary: "block until a task result is stored", usage: "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "shutdown", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Shutdown), summary: "stop the selected team", usage: "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "add-agent", tier: CommandTier::Core, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::AddAgent), summary: "add or force-recreate a worker", usage: "usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },

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

@@ -42,6 +42,37 @@ fn seed_status_workspace() -> std::path::PathBuf {
     dir
 }
 
+fn seed_send_workspace() -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!(
+        "ta-cli-send-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    let team = dir.join(".team");
+    std::fs::create_dir_all(team.join("runtime")).unwrap();
+    let state = json!({
+        "active_team_key": "teamA",
+        "teams": {
+            "teamA": {
+                "agents": {
+                    "alice": {"provider": "codex"},
+                    "drifted": {"provider": "codex", "status": "session_drift"}
+                },
+                "tasks": [{"id": "t-1"}]
+            }
+        }
+    });
+    std::fs::write(
+        team.join("runtime").join("state.json"),
+        serde_json::to_vec_pretty(&state).unwrap(),
+    )
+    .unwrap();
+    dir
+}
+
 const DELEG_VALID_ROLE: &str = "---\nname: implementer\nrole: Implementation Engineer\nprovider: fake\nmodel: fake\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nImplement bounded tasks.\n";
 const DELEG_INVALID_ROLE: &str = "---\nname: broken\nrole: Broken Worker\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nNo provider field.\n";
 const DELEG_TEAM_MD: &str =

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

@@ -453,11 +453,13 @@ fn status_port_status_detail_full_keeps_uncompacted_events() {
 // =========================================================================
 
 fn send_args_fixture() -> SendArgs {
+    let workspace = seed_send_workspace();
+    let _ = crate::message_store::MessageStore::open(&workspace).unwrap();
     SendArgs {
         target: Some("alice".into()),
         message: vec!["hello".into(), "world".into(), "foo".into()],
         targets: None,
-        workspace: PathBuf::from("."),
+        workspace,
         team: Some("teamA".into()),
         task: Some("t-1".into()),
         sender: TrustedSender::leader(),
@@ -565,9 +567,17 @@ fn cmd_send_joins_message_with_single_space() {
         CmdOutput::Json(ref v) => {
             assert!(v.get("ok").is_some(), "send result Json must carry `ok`");
             if v.get("ok").and_then(|ok| ok.as_bool()) == Some(true) {
+                let delivered = v.get("delivered").and_then(|x| x.as_bool()) == Some(true);
+                // hermetic tier 假设：此 fixture 无法产生真实 tmux Delivered。
+                // 若 delivered=true 命中说明 tier 前提变了（例如 seed 开了 Delivered 通路），
+                // 应立即失败以强制重新审视，而不是悄悄跑一条从未验过的分支。
+                assert!(
+                    !delivered,
+                    "hermetic seed 不应产生 delivered=true；tier 假设变了"
+                );
                 assert_eq!(
                     v.get("reminder").and_then(|reminder| reminder.as_str()),
-                    Some(crate::cli::SEND_REMINDER)
+                    Some("Message queued; coordinator will notify when the worker receives it. Do not poll the worker terminal with capture-pane.")
                 );
             }
         }
@@ -689,7 +699,7 @@ fn cmd_send_failed_outcome_yields_error_exit() {
     // DeliveryOutcome ok=false (e.g. refused) -> from_json -> ExitCode::Error (parser.py:507).
     // A failed send to a target must propagate non-zero exit reporting through CmdResult.
     let args = SendArgs {
-        target: Some("nonexistent".into()),
+        target: Some("drifted".into()),
         no_ack: false,
         no_wait: false,
         watch_result: false,

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

@@ -677,6 +677,13 @@ pub struct ResultsArgs {
     pub json: bool,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WaitArgs {
+    pub task_id: String,
+    pub workspace: PathBuf,
+    pub json: bool,
+}
+
 /// `diagnose`(`parser.py:298`) runtime health report, distinct from `doctor`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DiagnoseArgs {

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

@@ -1064,6 +1064,23 @@ pub fn render_event_line(event: &Value) -> Option<String> {
             clean_field(event, &["provider"], "-"),
             clean_field(event, &["matched_pattern_snippet", "snippet"], "-")
         )),
+        "result_wake.registered" => Some(format!(
+            "result_wake.registered: task={} watcher={}",
+            clean_field(event, &["task_id"], "-"),
+            clean_field(event, &["watcher_id"], "-")
+        )),
+        "result_wake.notified" => Some(format!(
+            "result_wake.notified: task={} result={} watcher={}",
+            clean_field(event, &["task_id"], "-"),
+            clean_field(event, &["result_id"], "-"),
+            clean_field(event, &["watcher_id"], "-")
+        )),
+        "result_wake.notify_failed" => Some(format!(
+            "result_wake.notify_failed: task={} watcher={} reason={}",
+            clean_field(event, &["task_id"], "-"),
+            clean_field(event, &["watcher_id"], "-"),
+            clean_field(event, &["reason", "error"], "-")
+        )),
         _ => None,
     }
 }

package/crates/team-agent/src/coordinator/steps/abnormal.rs

@@ -578,7 +578,7 @@ fn agent_process_liveness(
     // pane for POSITIVE provider evidence via current-command + worker
     // exit marker. Under the 0.5.39 wrapper, `state.status=running` is
     // administrative spawn accounting, not runtime truth — a provider
-    // may have exited into the shell fallback while state still reads
+    // may have exited into the inert shell tail while state still reads
     // running. The marker probe positively proves that case; when it
     // fires we return Dead here instead of the false Alive further
     // down.
@@ -795,9 +795,29 @@ fn worker_provider_exit_marker_check(
         .capture(&target, crate::transport::CaptureRange::Tail(200))
         .ok()?;
     if cap.text.contains(&marker) {
+        // The wrapper writes its exit code immediately after this marker.  A
+        // truncated capture can leave the marker without a complete token;
+        // keep that case explicit rather than guessing success (or zero).
+        // Scope: this detail only covers exits that execute the wrapper's
+        // marker printf. SIGKILL, direct pane termination, and host power loss
+        // produce no marker; that absence is silent, not `rc=unknown`.
+        let rc = cap
+            .text
+            .split_once(&marker)
+            .and_then(|(_, tail)| {
+                let token = tail.split_whitespace().next()?;
+                let end = tail.find(token)? + token.len();
+                tail.as_bytes()
+                    .get(end)
+                    .is_some_and(u8::is_ascii_whitespace)
+                    .then_some(token)
+            })
+            .and_then(|token| token.parse::<i32>().ok())
+            .map(|value| value.to_string())
+            .unwrap_or_else(|| "unknown".to_string());
         Some(process_check(
             ProcessLiveness::Dead,
-            format!("worker_provider_exited:{pane_id_str}"),
+            format!("worker_provider_exited:{pane_id_str}:rc={rc}"),
         ))
     } else {
         None
@@ -1816,6 +1836,39 @@ mod tests {
         );
     }
 
+    #[test]
+    fn worker_exit_marker_detail_includes_exit_code() {
+        let pane_id = crate::transport::PaneId::new("%marker-rc");
+        let marker = crate::tmux_backend::worker_provider_exit_marker("codex");
+        let transport = crate::transport::test_support::OfflineTransport::new()
+            .with_capture_for_pane(pane_id.as_str(), format!("\n{marker} 23\n"));
+        let mut agent = test_abnormal_agent("/tmp/rollout.jsonl", Some(1), None);
+        agent.pane_id = Some(pane_id.as_str().to_string());
+
+        let check = worker_provider_exit_marker_check(&agent, &transport).expect("marker hit");
+
+        assert_eq!(check.state, ProcessLiveness::Dead);
+        assert_eq!(check.detail, "worker_provider_exited:%marker-rc:rc=23");
+    }
+
+    #[test]
+    fn worker_exit_marker_detail_uses_unknown_for_truncated_exit_code() {
+        let pane_id = crate::transport::PaneId::new("%marker-truncated");
+        let marker = crate::tmux_backend::worker_provider_exit_marker("codex");
+        let transport = crate::transport::test_support::OfflineTransport::new()
+            .with_capture_for_pane(pane_id.as_str(), format!("\n{marker} "));
+        let mut agent = test_abnormal_agent("/tmp/rollout.jsonl", Some(1), None);
+        agent.pane_id = Some(pane_id.as_str().to_string());
+
+        let check = worker_provider_exit_marker_check(&agent, &transport).expect("marker hit");
+
+        assert_eq!(check.state, ProcessLiveness::Dead);
+        assert_eq!(
+            check.detail,
+            "worker_provider_exited:%marker-truncated:rc=unknown"
+        );
+    }
+
     #[test]
     fn abnormal_dead_fresh_error_event_reports_actual_dead_booleans() {
         let dir = temp_abnormal_dir("dead-fresh");

package/crates/team-agent/src/db/migration.rs

@@ -98,6 +98,7 @@ pub const MANAGED_TABLE_LAYOUTS: &[(&str, &[&str])] = &[
             "agent_id",
             "message_id",
             "leader_id",
+            "recipient",
             "status",
             "created_at",
             "completed_at",
@@ -129,7 +130,7 @@ const CREATE_TABLE_TEMPLATES: &[(&str, &str)] = &[
     ("delivery_tokens", "create table if not exists __TABLE__ (\n          message_id text primary key,\n          unique_token text not null,\n          injected_at text not null,\n          visible_at text,\n          consumed_at text,\n          failed_at text,\n          failure_reason text\n        )"),
     ("agent_health", "create table if not exists __TABLE__ (\n          owner_team_id text,\n          agent_id text not null,\n          status text not null,\n          last_output_at text,\n          context_usage_pct integer,\n          current_task_id text,\n          updated_at text not null,\n          unique(owner_team_id, agent_id)\n        )"),
     ("peer_allowlist", "create table if not exists __TABLE__ (\n          a text not null,\n          b text not null,\n          created_at text not null,\n          primary key (a, b)\n        )"),
-    ("result_watchers", "create table if not exists __TABLE__ (\n          watcher_id text primary key,\n          owner_team_id text,\n          task_id text,\n          agent_id text,\n          message_id text,\n          leader_id text not null,\n          status text not null,\n          created_at text not null,\n          completed_at text,\n          result_id text,\n          notified_message_id text,\n          error text\n        )"),
+    ("result_watchers", "create table if not exists __TABLE__ (\n          watcher_id text primary key,\n          owner_team_id text,\n          task_id text,\n          agent_id text,\n          message_id text,\n          leader_id text not null,\n          recipient text,\n          status text not null,\n          created_at text not null,\n          completed_at text,\n          result_id text,\n          notified_message_id text,\n          error text\n        )"),
     ("leader_notification_log", "create table if not exists __TABLE__ (\n          result_id text not null,\n          owner_team_id text not null default '',\n          owner_epoch integer not null default 0,\n          leader_session_uuid text,\n          notified_message_id text not null,\n          notified_at text not null,\n          leader_pane_id_at_notify text,\n          envelope_content_hash text,\n          primary key (result_id, owner_team_id, owner_epoch)\n        )"),
 ];
 

package/crates/team-agent/src/db/schema.rs

@@ -13,7 +13,7 @@ use rusqlite::Connection;
 use crate::db::DbError;
 
 /// `schema.py:90`。
-pub const SCHEMA_VERSION: i64 = 4;
+pub const SCHEMA_VERSION: i64 = 5;
 
 /// 8 张表的 DDL(逐字照搬 `schema.py:initialize_schema` 的内联建表;含 `if not exists`)。
 /// 顺序与 Python 一致(leader_notification_log 在 ensure 块后创建)。
@@ -23,7 +23,7 @@ const CREATE_SCHEDULED_EVENTS: &str = "create table if not exists scheduled_even
 const CREATE_DELIVERY_TOKENS: &str = "create table if not exists delivery_tokens (\n              message_id text primary key,\n              unique_token text not null,\n              injected_at text not null,\n              visible_at text,\n              consumed_at text,\n              failed_at text,\n              failure_reason text\n            )";
 const CREATE_AGENT_HEALTH: &str = "create table if not exists agent_health (\n              owner_team_id text,\n              agent_id text not null,\n              status text not null,\n              last_output_at text,\n              context_usage_pct integer,\n              current_task_id text,\n              updated_at text not null,\n              unique(owner_team_id, agent_id)\n            )";
 const CREATE_PEER_ALLOWLIST: &str = "create table if not exists peer_allowlist (\n              a text not null,\n              b text not null,\n              created_at text not null,\n              primary key (a, b)\n            )";
-const CREATE_RESULT_WATCHERS: &str = "create table if not exists result_watchers (\n              watcher_id text primary key,\n              owner_team_id text,\n              task_id text,\n              agent_id text,\n              message_id text,\n              leader_id text not null,\n              status text not null,\n              created_at text not null,\n              completed_at text,\n              result_id text,\n              notified_message_id text,\n              error text\n            )";
+const CREATE_RESULT_WATCHERS: &str = "create table if not exists result_watchers (\n              watcher_id text primary key,\n              owner_team_id text,\n              task_id text,\n              agent_id text,\n              message_id text,\n              leader_id text not null,\n              recipient text,\n              status text not null,\n              created_at text not null,\n              completed_at text,\n              result_id text,\n              notified_message_id text,\n              error text\n            )";
 const CREATE_LEADER_NOTIFICATION_LOG: &str = "create table if not exists leader_notification_log (\n              result_id text not null,\n              owner_team_id text not null default '',\n              owner_epoch integer not null default 0,\n              leader_session_uuid text,\n              notified_message_id text not null,\n              notified_at text not null,\n              leader_pane_id_at_notify text,\n              envelope_content_hash text,\n              primary key (result_id, owner_team_id, owner_epoch)\n            )";
 const CREATE_AGENT_HEALTH_NEW: &str = "create table agent_health_new (\n              owner_team_id text,\n              agent_id text not null,\n              status text not null,\n              last_output_at text,\n              context_usage_pct integer,\n              current_task_id text,\n              updated_at text not null,\n              unique(owner_team_id, agent_id)\n            )";
 
@@ -104,6 +104,7 @@ const RESULT_WATCHER_COLUMNS: &[&str] = &[
     "agent_id",
     "message_id",
     "leader_id",
+    "recipient",
     "status",
     "created_at",
     "completed_at",
@@ -297,10 +298,16 @@ pub fn initialize_schema(
         &tx,
         "result_watchers",
         RESULT_WATCHER_COLUMNS,
-        &[(
-            "owner_team_id",
-            "alter table result_watchers add column owner_team_id text",
-        )],
+        &[
+            (
+                "owner_team_id",
+                "alter table result_watchers add column owner_team_id text",
+            ),
+            (
+                "recipient",
+                "alter table result_watchers add column recipient text",
+            ),
+        ],
     )?;
     tx.execute(CREATE_LEADER_NOTIFICATION_LOG, [])?;
     ensure_table_columns(
@@ -360,13 +367,13 @@ mod tests {
     }
 
     #[test]
-    fn user_version_is_four() {
+    fn user_version_is_five() {
         let conn = fresh();
         let v: i64 = conn
             .query_row("pragma user_version", [], |r| r.get(0))
             .unwrap();
         assert_eq!(v, SCHEMA_VERSION);
-        assert_eq!(v, 4);
+        assert_eq!(v, 5);
     }
 
     #[test]
@@ -513,6 +520,7 @@ mod tests {
                     ("agent_id", "TEXT", 0, None, 0),
                     ("message_id", "TEXT", 0, None, 0),
                     ("leader_id", "TEXT", 1, None, 0),
+                    ("recipient", "TEXT", 0, None, 0),
                     ("status", "TEXT", 1, None, 0),
                     ("created_at", "TEXT", 1, None, 0),
                     ("completed_at", "TEXT", 0, None, 0),

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

@@ -505,7 +505,6 @@ pub fn claim_leader(
     team: Option<&str>,
     confirm: bool,
 ) -> Result<LeaseResult, LeaderError> {
-    let _ = confirm;
     let caller = std::env::var("TMUX_PANE")
         .ok()
         .filter(|pane| !pane.is_empty())
@@ -598,7 +597,7 @@ pub fn claim_leader(
         Some(team_id.as_str()),
         &team_id,
         &PaneId::new(caller),
-        true,
+        confirm,
         &event_log,
         &liveness,
         caller_target.as_ref(),

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

@@ -1269,12 +1269,12 @@ fn ensure_managed_provider_live_after_attach(
 /// 0.4.x (CR C-3 P0): leader provider health reconciliation. The default
 /// `liveness()` check only proves the pane is ADDRESSABLE via tmux — it
 /// returns `Live` even when the provider has exited and the wrapper shell
-/// fell back to an interactive shell. This function distinguishes
+/// remains at its inert tail. This function distinguishes
 /// `provider_alive` from `provider_exited` by:
 ///   1. Reading `pane_current_command` (tmux `#{pane_current_command}`).
 ///   2. If the current command matches the expected provider binary (or
 ///      one of its known aliases), report `Alive`.
-///   3. If the current command is an interactive shell AND the pane
+///   3. If the current command is a shell tail process AND the pane
 ///      content contains the exit marker `[team-agent] <provider> exited`
 ///      (emitted by `leader_shell_wrapper_command`), report
 ///      `ProviderExited`.
@@ -1282,7 +1282,7 @@ fn ensure_managed_provider_live_after_attach(
 ///      conservative default — avoid false-positive exit alarms.
 ///
 /// Note: when the leader shell wrapper is used (CR C-2), a provider exit
-/// leaves the pane as `<SHELL:-/bin/zsh>` with the exit marker in
+/// leaves the pane as an inert `/bin/sh -c` tail with the exit marker in
 /// scrollback. Pre-wrapper code that hit `exec claude` would have left the
 /// pane as `[exited]` and `liveness()` would have returned `Dead`. The new
 /// failure mode requires this richer health check to surface
@@ -1340,16 +1340,16 @@ pub enum LeaderProviderHealth {
     Unreachable,
 }
 
-/// 0.4.x (CR R6 + R3): single-source interactive-shell detection.
+/// 0.4.x (CR R6 + R3): single-source shell-tail detection.
 /// Used by:
-///   - `leader_provider_health` to decide "pane fell back to shell"
-///   - shutdown logic to recognise a leader pane in fallback-shell mode
+///   - `leader_provider_health` to decide "pane is at the shell tail"
+///   - shutdown logic to recognise a leader pane in shell-tail mode
 ///     as still owned by the leader (not stray).
 ///
 /// Matches by basename (case-insensitive) — `pane_current_command` returns
 /// the basename of the running binary. Conservative whitelist of POSIX +
-/// common interactive shells; missing entries here are false negatives
-/// (shell looks like provider absent → health says Alive) which is the
+/// common shell processes; missing entries here are false negatives
+/// (shell tail looks like provider absent → health says Alive) which is the
 /// safe default per the CR R6 conservative-Alive rule.
 fn is_interactive_shell_basename(name: &str) -> bool {
     let trimmed = name.trim().to_ascii_lowercase();

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

@@ -131,8 +131,35 @@ pub(crate) fn start_agent_at_paths(
             return Err(LifecycleError::RequirementUnmet(error));
         }
     }
-    let agent_live = if adaptive_layout {
-        agent_pane_live(transport, &raw_agent)
+    // A persisted window name is only a topology hint. Once a pane binding is
+    // recorded, the pane must be both physically live and owned by the
+    // intended session/window; a foreign pane must never make start-agent
+    // return Noop. A coordinator-provided pane_dead reason is also
+    // authoritative when a backend cannot answer the exact-pane probe.
+    let pane_marked_dead = raw_agent
+        .get("stale_reason")
+        .and_then(serde_json::Value::as_str)
+        .is_some_and(|reason| matches!(reason, "pane_dead" | "both"));
+    // A stale cached pane may still be recoverable without a spawn when the
+    // intended per-agent window has exactly one live pane. The pane found by
+    // this session/window lookup, not the cached id, is the binding that the
+    // Noop path refreshes. A foreign pane with no intended window still falls
+    // through to a real spawn.
+    let noop_pane = if adaptive_layout {
+        None
+    } else {
+        single_live_pane_for_window(transport, &session_name, &window)
+    };
+    let agent_live = if pane_marked_dead {
+        false
+    } else if adaptive_layout
+        || raw_agent
+            .get("pane_id")
+            .and_then(serde_json::Value::as_str)
+            .is_some_and(|pane| !pane.is_empty())
+    {
+        agent_pane_owned_and_live(transport, &raw_agent, &session_name, &window)
+            || noop_pane.is_some()
     } else {
         window_exists(transport, &session_name, &window)
     };
@@ -145,11 +172,6 @@ pub(crate) fn start_agent_at_paths(
     // state — assert_topology_invariants from Step 1 catches the
     // upstream corruption.
     let has_collision = pane_conflicts_with_leader_or_other(&state, agent_id, &raw_agent);
-    let noop_pane = if adaptive_layout {
-        None
-    } else {
-        single_live_pane_for_window(transport, &session_name, &window)
-    };
     if has_collision && noop_pane.is_none() {
         eprintln!(
             "team_agent::layout e51_collision_post_step2 agent_id=`{agent_id}` \
@@ -603,7 +625,12 @@ fn pane_socket_binding(value: &serde_json::Value) -> Option<PaneSocketBinding<'_
     })
 }
 
-fn agent_pane_live(transport: &dyn crate::transport::Transport, agent: &serde_json::Value) -> bool {
+fn agent_pane_owned_and_live(
+    transport: &dyn crate::transport::Transport,
+    agent: &serde_json::Value,
+    expected_session: &crate::transport::SessionName,
+    expected_window: &str,
+) -> bool {
     let Some(pane) = agent
         .get("pane_id")
         .and_then(serde_json::Value::as_str)
@@ -612,7 +639,22 @@ fn agent_pane_live(transport: &dyn crate::transport::Transport, agent: &serde_js
     else {
         return false;
     };
-    agent_pane_live_by_id(transport, &pane)
+    let Ok(targets) = transport.list_targets() else {
+        // Ownership is unknown when the topology snapshot fails. Preserve the
+        // base liveness direction: only positive death evidence may authorize
+        // a destructive respawn; otherwise fall back to the pane probe and
+        // leave retry authority to the operator.
+        return agent_pane_live_by_id(transport, &pane);
+    };
+    let owned = targets.iter().any(|target| {
+        target.pane_id == pane
+            && target.session.as_str() == expected_session.as_str()
+            && target
+                .window_name
+                .as_ref()
+                .is_some_and(|window| window.as_str() == expected_window)
+    });
+    owned && agent_pane_live_by_id(transport, &pane)
 }
 
 fn agent_pane_live_by_id(

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

@@ -405,9 +405,9 @@ pub(super) fn spawn_agent_window(
 
     // 0.5.39 Slice 2 (tmux-server-death-locate §7 Slice 2): route the
     // primary worker spawn through the worker shell wrapper so provider
-    // exit leaves the pane at an interactive shell with an explicit exit
-    // marker instead of collapsing the pane into `[exited]`. This mirrors
-    // the leader wrapper's manual-tmux equivalence. The split path stays
+    // exit leaves the pane at an inert sh tail with an explicit exit marker
+    // instead of collapsing the pane into `[exited]`. The inert tail does
+    // not read pane stdin. The split path stays
     // on plain spawn_split — split panes are display overlays, not the
     // primary worker process.
     let provider_label = crate::provider::wire::command_name(provider);