@team-agent/installer 0.5.31 → 0.5.32

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

@@ -94,3 +94,27 @@ fn delete_agent_health(workspace: &Path, agent_id: &AgentId) -> Result<(), crate
     )?;
     Ok(())
 }
+
+/// 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+/// clear the `(owner_team_id, agent_id)` health observation row on a new
+/// worker process cohort boundary. Distinct from `delete_agent_health` (used
+/// by remove-agent rollback): this narrow helper keyed on both owner_team_id
+/// and agent_id so a sibling team with the same agent_id keeps its own row.
+/// Silently no-ops when the row is absent.
+pub fn clear_agent_health_observation(
+    workspace: &Path,
+    owner_team_id: &str,
+    agent_id: &AgentId,
+) -> Result<(), crate::db::DbError> {
+    if owner_team_id.is_empty() {
+        return Ok(());
+    }
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| crate::db::DbError::Schema(e.to_string()))?;
+    let conn = crate::db::schema::open_db(store.db_path())?;
+    conn.execute(
+        "delete from agent_health where owner_team_id = ?1 and agent_id = ?2",
+        rusqlite::params![owner_team_id, agent_id.as_str()],
+    )?;
+    Ok(())
+}

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

@@ -284,6 +284,14 @@ pub(crate) fn start_agent_at_paths(
     // after spawn" race with coordinator and no double source of truth.
     crate::lifecycle::launch::annotate_runtime_tmux_endpoint(&mut state, transport, workspace);
     let team_key = restart_projection_team_key(&state, team);
+    // 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+    // clear the matching `agent_health` observation on the new spawn cohort
+    // so five-line status summary and status --json do not surface a stale
+    // WORKING row from the pre-shutdown process. Best-effort: DB failure
+    // must not fail the start-agent path.
+    let _ = crate::db::agent_health_capture::clear_agent_health_observation(
+        workspace, &team_key, agent_id,
+    );
     let skip_capture_backfill = if matches!(
         start_mode,
         StartMode::Fresh | StartMode::FreshAfterMissingRollout
@@ -977,6 +985,12 @@ fn mark_agent_started(
             agent_id
         )));
     };
+    // 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+    // a successful new process cohort invalidates the per-agent
+    // turn/activity observation set. Do this before overwriting the
+    // lifecycle/topology fields so absence == UNKNOWN until the next
+    // coordinator tick or pane fallback produces a post-spawn observation.
+    clear_agent_runtime_activity_observation(agent);
     // S1-CAPTURE-001 (0.4.8, CR M3 provider-agnostic): on a Fresh /
     // FreshAfterMissingRollout start, the prior session's authoritative
     // capture tuple MUST be cleared before persist_command_plan_state

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

@@ -1601,6 +1601,33 @@ pub(super) fn state_spawn_epoch_for_agent(workspace: &Path, agent_id: &AgentId)
         .unwrap_or(0)
 }
 
+/// 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+/// clear the per-agent turn/activity observation set on a successful new
+/// worker process cohort. Called from `mark_agent_started` /
+/// `mark_agent_respawned` / `mark_fake_harness_agent_respawned`; NOT from
+/// `mark_agent_running_noop` (no new process was created there).
+///
+/// Removes only observation fields — never lifecycle/topology fields. After
+/// clearing, absence is UNKNOWN, not synthesized idle (T7 unknown-never-idle
+/// discipline); the next post-spawn tick may repopulate from JSONL freshness
+/// gate + pane fallback.
+pub(super) fn clear_agent_runtime_activity_observation(
+    agent: &mut serde_json::Map<String, serde_json::Value>,
+) {
+    for field in [
+        "activity",
+        "worker_state",
+        "last_output_at",
+        "last_output_hash",
+        "current_turn_message_id",
+        "current_task_id", // ALLOWED-LEGACY-READ (Phase-DX E2): cleanup removal of legacy display-only key on new spawn cohort; helper does not read the value.
+        "task_id",
+        "coordinator_idle_capture_next_at",
+    ] {
+        agent.remove(field);
+    }
+}
+
 #[cfg(test)]
 mod e36_transcript_backing_tests {
     use super::*;

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

@@ -433,8 +433,7 @@ fn restart_with_selected_team_and_transport(
             &decision.agent_id,
             &raw_agent,
         );
-        if endpoint_convergence_fake_harness_enabled(&state)
-            && is_fake_model_harness_agent(&agent)
+        if endpoint_convergence_fake_harness_enabled(&state) && is_fake_model_harness_agent(&agent)
         {
             write_fake_harness_spawn_argv_event(
                 &selected.run_workspace,
@@ -449,6 +448,13 @@ fn restart_with_selected_team_and_transport(
                 &session_name,
                 &selected.team_key,
             );
+            // 0.5.32: fake harness respawn shares the same spawn cohort
+            // boundary — clear the matching `agent_health` observation.
+            let _ = crate::db::agent_health_capture::clear_agent_health_observation(
+                &selected.run_workspace,
+                &selected.team_key,
+                &decision.agent_id,
+            );
             successful_agents.push(decision.clone());
             continue;
         }
@@ -556,6 +562,15 @@ fn restart_with_selected_team_and_transport(
         {
             persist_effective_approval_policy_for_restart(agent, &safety);
         }
+        // 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+        // pair the state-side activity clear with a DB `agent_health` clear so
+        // status --json's health projection does not surface the pre-restart
+        // WORKING row. Best-effort: DB failure must not fail the restart loop.
+        let _ = crate::db::agent_health_capture::clear_agent_health_observation(
+            &selected.run_workspace,
+            &selected.team_key,
+            &decision.agent_id,
+        );
     }
     // END_B5_RESTART_ISOLATION_LOOP
     let mut topology_authority_agent_ids = successful_agents
@@ -1630,6 +1645,12 @@ fn mark_agent_respawned(
             agent_id
         )));
     };
+    // 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+    // multi-worker restart respawn is a new process cohort; clear the
+    // per-agent turn/activity observation set before overwriting lifecycle
+    // fields so stale `activity=working` / `worker_state=BUSY` do not
+    // survive into the fresh cohort.
+    clear_agent_runtime_activity_observation(agent);
     agent.insert("status".to_string(), serde_json::json!("running"));
     agent.insert(
         "window".to_string(),
@@ -1785,6 +1806,10 @@ fn mark_fake_harness_agent_respawned(
     else {
         return;
     };
+    // 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+    // fake harness respawn is also a new process cohort — RED fixtures must
+    // not preserve stale activity observations across restart.
+    clear_agent_runtime_activity_observation(agent);
     agent.insert("status".to_string(), serde_json::json!("running"));
     agent.insert("window".to_string(), serde_json::json!(agent_id.as_str()));
     agent.insert(

package/crates/team-agent/src/messaging/tests/main_preserved.rs

@@ -57,7 +57,7 @@ fn stuck_cancel_snapshot_delivered_message_ids_uses_golden_status_set() {
 // is `store.add_result(envelope)`'d (results.py:73) regardless of any in-flight delivery, then the
 // collection loop collects it when its task_id is a known task (state.tasks) OR message-scoped (msg_+
 // matching message). NO live in-flight task is required at ingest time. rt-host-b @ c262bf7 saw a
-// VALID envelope (validate-result accepts the same) collect to exit-1 / empty output / NOT in the
+// VALID envelope collect to exit-1 / empty output / NOT in the
 // results table — i.e. the --result-file ingest path was a no-op (results.rs once did
 // `let _ = (result_file, …)`). This pins the happy path: a valid envelope for a KNOWN task must be
 // ingested into the results table AND collected, with ok=true. (Completes the previously-deferred

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

@@ -75,7 +75,7 @@ use crate::model::enums::Provider;
 // ── REUSE — step 4 event_log(install/upgrade/repair 审计事件;原子替换的 rebuild/rollback 标记)──
 use crate::event_log::EventLog;
 
-// ── REUSE — step 5 state(uninstall「有 team 在跑勿删」判定经 state 投影;repair-state 转调)──
+// ── REUSE — step 5 state(uninstall「有 team 在跑勿删」判定经 state 投影)──
 // `state` 操作 state.json = serde_json::Value;此处仅在 fn 签名内经全限定路径引用,避免未用顶层 import。
 
 #[cfg(test)]

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

@@ -400,7 +400,7 @@ pub enum PackagingError {
     /// step 3 schema/migration 转调错误。
     #[error("schema: {0}")]
     Db(#[from] DbError),
-    /// step 5 state(repair-state / team-running 判定)转调错误。
+    /// step 5 state(team-running 判定)转调错误。
     #[error("state: {0}")]
     State(String),
     /// model 校验/解析转调(版本解析等)。

package/package.json

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

package/skills/team-agent/references/recovery-runbook.md

@@ -44,7 +44,7 @@ Fresh/reset red line:
 | Leader pane exists but messages say `leader_not_attached`, `rebind_required`, `team_owner_mismatch`, or leader 被抢 | Leader ownership or receiver binding drift | §2 L3 Claim Or Rebind Leader |
 | A live team must be recovered without losing worker context | Resume/restart path needed | §3 L2 Restart With Resume First |
 | Shutdown/restart cleanup status is ambiguous | Need residue-based truth, not a single `ok` field | §4 L1/L2 Cleanup Verification |
-| MCP tool call fails with `Transport closed` while the worker still has the payload | Provider-owned MCP stdio child died | §5 Superseded/Pending E23 Fallback Boundary |
+| MCP tool call fails with `Transport closed` while the worker still has the payload | Provider-owned MCP stdio child died | §5 MCP Transport-Dead Payload Handoff |
 
 ## 1. L1 Read-Only Triage
 
@@ -239,30 +239,15 @@ Python 0.2.11 compatibility note:
 
 - Python cleanup notes may mention direct tmux commands. They are not listed here as RS recovery prescriptions.
 
-## 5. Superseded/Pending E23 Fallback Boundary
+## 5. MCP Transport-Dead Payload Handoff
 
-[contextual: preserved] [level: L1] E23 fallback is the only narrow worker-scope exception to the normal tool boundary. It is for a current payload already in hand after a leader-bound MCP delivery failure.
+[contextual: preserved] [level: L1] If the worker already has a leader-bound payload in hand and the MCP transport dies before the normal `send` or `report_result` path can accept it, preserve the payload in a file handoff artifact and ask for leader/user recovery through the visible channel that still works.
 
-Current status:
-
-- Product implementation exists in the E23 branch for `fallback-send-leader` and `fallback-report-result`.
-- Local RS verification has covered CLI help and focused E23 tests.
-- This reference does not yet promote the fallback CLI to a general external prescription because the new documentation gate requires current-release RS validation in the Mac mini environment.
-
-Until that validation is added:
-
-- Workers should write a file handoff artifact for the current payload and ask for leader/user recovery.
-- Leaders should prefer restart/resume of the affected worker after the current payload is preserved.
-
-Do not use E23 fallback as a general message path. It does not permit arbitrary worker execution of L2/L3 recovery operations.
-
-RS verification record:
-
-- Local only at the time of this reference update: E23 focused tests and CLI help on the merged E23 documentation branch. Mac mini current-release validation is still required before adding exact fallback commands here.
+After restart/resume, use the normal MCP tool path again. Do not treat file handoff as a general message path or as permission to run arbitrary L2/L3 recovery operations.
 
 Python 0.2.11 compatibility note:
 
-- Python MCP stdio EOF had no durable reconnect. File handoff was the practical fallback. RS E23 adds product support, but this entry remains gated until real-machine validation is complete.
+- Python MCP stdio EOF had no durable reconnect. File handoff was the practical fallback.
 
 ## Held Out Of This Reference
 

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

@@ -1,374 +0,0 @@
-use super::*;
-
-const REPAIR_SPEC_TEMPLATE: &str = r#"version: 1
-team:
-  name: "repair-team"
-  mode: "supervisor_worker"
-  objective: "Exercise repair-state."
-  workspace: "__WS__"
-leader:
-  id: "leader"
-  role: "leader"
-  provider: "fake"
-  model: null
-  tools:
-    - "fs_read"
-    - "fs_list"
-    - "mcp_team"
-  context_policy:
-    keep_user_thread: true
-    receive_worker_outputs: "structured_only"
-    max_worker_result_tokens: 2000
-agents:
-  - id: "fake_impl"
-    role: "implementation_engineer"
-    provider: "fake"
-    model: null
-    working_directory: "__WS__"
-    system_prompt:
-      inline: "Handle fake implementation tasks."
-      file: null
-    tools:
-      - "fs_read"
-      - "mcp_team"
-    permission_mode: "restricted"
-    preferred_for:
-      - "implementation"
-    avoid_for: []
-    output_contract:
-      format: "result_envelope_v1"
-      required_fields:
-        - "task_id"
-        - "status"
-        - "summary"
-        - "artifacts"
-routing:
-  default_assignee: "leader"
-  rules:
-    - id: "implementation-to-fake"
-      match:
-        type:
-          - "implementation"
-      assign_to: "fake_impl"
-      priority: 10
-communication:
-  protocol: "mcp_inbox"
-  topology: "leader_centered"
-  worker_to_worker: true
-  ack_timeout_sec: 2
-  result_format: "result_envelope_v1"
-  message_store:
-    sqlite: ".team/runtime/team.db"
-    mirror_files: ".team/messages"
-runtime:
-  backend: "tmux"
-  display_backend: "none"
-  session_name: "team-agent-repair"
-  auto_launch: true
-  require_user_approval_before_launch: false
-  max_active_agents: 1
-  startup_order:
-    - "fake_impl"
-context:
-  state_file: "team_state.md"
-  artifact_dir: ".team/artifacts"
-  log_dir: ".team/logs"
-  summarization:
-    worker_full_logs: "retain_outside_leader_context"
-    state_update: "after_each_result"
-tasks:
-  - id: "task_impl"
-    title: "Fake implementation"
-    type: "implementation"
-    assignee: null
-    deps: []
-    acceptance:
-      - "fake result collected"
-    status: "pending"
-"#;
-
-fn seed_repair_workspace(ws: &std::path::Path) {
-    std::fs::create_dir_all(ws.join(".team").join("logs")).unwrap();
-    std::fs::create_dir_all(ws.join(".team").join("runtime")).unwrap();
-    let spec_path = ws.join("team.spec.yaml");
-    std::fs::write(
-        &spec_path,
-        REPAIR_SPEC_TEMPLATE.replace("__WS__", &ws.to_string_lossy()),
-    )
-    .unwrap();
-    crate::state::persist::save_runtime_state(
-        ws,
-        &json!({
-            "spec_path": spec_path.to_string_lossy(),
-            "session_name": "team-agent-repair",
-            "leader": {"id": "leader"},
-            "agents": {"fake_impl": {"status": "stopped", "provider": "fake"}},
-            "tasks": [{
-                "id": "task_impl",
-                "title": "Fake implementation",
-                "type": "implementation",
-                "assignee": null,
-                "deps": [],
-                "acceptance": ["fake result collected"],
-                "status": "pending"
-            }]
-        }),
-    )
-    .unwrap();
-}
-
-fn repair_args(
-    ws: &std::path::Path,
-    status: &str,
-    summary: Option<&str>,
-    json: bool,
-) -> RepairStateArgs {
-    RepairStateArgs {
-        workspace: ws.to_path_buf(),
-        task_id: "task_impl".to_string(),
-        assignee: Some("fake_impl".to_string()),
-        status: status.to_string(),
-        summary: summary.map(str::to_string),
-        json,
-        team: None,
-    }
-}
-
-fn team_repair_state(ws: &std::path::Path, team: &str) -> serde_json::Value {
-    json!({
-        "active_team_key": team,
-        "status": "alive",
-        "spec_path": ws.join(".team").join("runtime").join(team).join("team.spec.yaml").to_string_lossy(),
-        "session_name": format!("team-agent-{team}"),
-        "leader": {"id": "leader"},
-        "agents": {"fake_impl": {"status": "stopped", "provider": "fake"}},
-        "tasks": [{
-            "id": "task_impl",
-            "title": format!("{team} implementation"),
-            "type": "implementation",
-            "assignee": null,
-            "deps": [],
-            "acceptance": ["fake result collected"],
-            "status": "pending"
-        }]
-    })
-}
-
-fn seed_two_team_repair_workspace(ws: &std::path::Path) {
-    std::fs::create_dir_all(ws.join(".team").join("logs")).unwrap();
-    for team in ["alpha", "beta"] {
-        let spec_dir = ws.join(".team").join("runtime").join(team);
-        std::fs::create_dir_all(&spec_dir).unwrap();
-        std::fs::write(
-            spec_dir.join("team.spec.yaml"),
-            REPAIR_SPEC_TEMPLATE.replace("__WS__", &ws.to_string_lossy()),
-        )
-        .unwrap();
-    }
-    crate::state::persist::save_runtime_state(
-        ws,
-        &json!({
-            "active_team_key": "alpha",
-            "teams": {
-                "alpha": team_repair_state(ws, "alpha"),
-                "beta": team_repair_state(ws, "beta"),
-            }
-        }),
-    )
-    .unwrap();
-}
-
-// Golden source:
-// - cli/parser.py:303-310 registers `repair-state --workspace --task --assignee --status --summary --json`.
-// - cli/commands.py:196-203 delegates all five args to `runtime.repair_state`.
-// - diagnose/quick_start.py:285-324:
-//   * loads state + spec, validates assignee against spec agents plus leader id,
-//   * validates status against task_graph.py TASK_STATUSES,
-//   * before/after are three-field projections `{assignee,status,last_result_summary}`,
-//   * summary writes `last_result_summary` (not `summary`),
-//   * writes EventLog event `repair_state.task` with task_id/before/after,
-//   * returns `{ok,task_id,before,after,state_file}` in that insertion order.
-// - task_graph.py:5-14 legal statuses are exactly:
-//   blocked,cancelled,done,failed,needs_retry,pending,ready,running.
-//
-// Golden probe:
-//   PYTHONPATH=/Users/alauda/Documents/code/team-agent-public/src python3 /tmp/probe_repair_state_cli.py
-#[test]
-fn repair_state_success_json_human_and_event_byte_shape() {
-    let ws = tmp_workspace();
-    seed_repair_workspace(&ws);
-
-    let json_result = cmd_repair_state(&repair_args(&ws, "done", Some("patched"), true))
-        .expect("repair-state success should return ok");
-    assert_eq!(json_result.exit, ExitCode::Ok);
-    assert_eq!(
-        emit(&json_result.output, true).unwrap(),
-        format!(
-            "{{\n  \"after\": {{\n    \"assignee\": \"fake_impl\",\n    \"last_result_summary\": \"patched\",\n    \"status\": \"done\"\n  }},\n  \"before\": {{\n    \"assignee\": null,\n    \"last_result_summary\": null,\n    \"status\": \"pending\"\n  }},\n  \"ok\": true,\n  \"state_file\": \"{}\",\n  \"task_id\": \"task_impl\"\n}}",
-            ws.join("team_state.md").to_string_lossy()
-        ),
-        "repair-state --json must match Python pretty sorted JSON byte shape",
-    );
-
-    let event_line = std::fs::read_to_string(ws.join(".team/logs/events.jsonl"))
-        .expect("repair-state must write events.jsonl")
-        .lines()
-        .last()
-        .expect("repair-state must append an event")
-        .to_string();
-    assert!(
-        event_line.starts_with("{\"after\": {\"assignee\": \"fake_impl\", \"last_result_summary\": \"patched\", \"status\": \"done\"}, \"before\": {\"assignee\": null, \"last_result_summary\": null, \"status\": \"pending\"}, \"event\": \"repair_state.task\", \"task_id\": \"task_impl\", \"ts\": \""),
-        "repair_state.task event must be Python sort_keys JSON with after/before/event/task_id/ts order; got {event_line}",
-    );
-    assert!(event_line.ends_with("\"}"), "event line must end with timestamp string; got {event_line}");
-
-    let ws_human = tmp_workspace();
-    seed_repair_workspace(&ws_human);
-    let human_result = cmd_repair_state(&repair_args(&ws_human, "done", Some("patched"), false))
-        .expect("repair-state human success should return ok");
-    assert_eq!(
-        emit(&human_result.output, false).unwrap(),
-        format!(
-            "ok: True\ntask_id: task_impl\nbefore: {{\"assignee\": null, \"status\": \"pending\", \"last_result_summary\": null}}\nafter: {{\"assignee\": \"fake_impl\", \"status\": \"done\", \"last_result_summary\": \"patched\"}}\nstate_file: {}",
-            ws_human.join("team_state.md").to_string_lossy()
-        ),
-        "repair-state human output must preserve Python returned-dict and nested-dict insertion order",
-    );
-
-    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    assert_eq!(
-        state["tasks"][0]["last_result_summary"],
-        json!("patched"),
-        "golden writes summary into last_result_summary, not summary",
-    );
-    assert!(
-        state["tasks"][0].get("summary").is_none(),
-        "golden does not create a task.summary field during repair-state",
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-    let _ = std::fs::remove_dir_all(&ws_human);
-}
-
-#[test]
-fn repair_state_rejects_status_outside_task_statuses() {
-    let ws = tmp_workspace();
-    seed_repair_workspace(&ws);
-    let legal_statuses = vec![
-        "blocked",
-        "cancelled",
-        "done",
-        "failed",
-        "needs_retry",
-        "pending",
-        "ready",
-        "running",
-    ];
-    assert_eq!(
-        legal_statuses,
-        vec![
-            "blocked",
-            "cancelled",
-            "done",
-            "failed",
-            "needs_retry",
-            "pending",
-            "ready",
-            "running"
-        ],
-        "golden TASK_STATUSES from task_graph.py:5 must stay locked",
-    );
-
-    let err = cmd_repair_state(&repair_args(&ws, "assigned", None, true))
-        .expect_err("status outside TASK_STATUSES must error");
-    assert_eq!(err.to_string(), "unknown task status for repair: assigned");
-    let payload = err.to_payload(&ws.join(".team/logs/cli-error-123.log"), "repair-state");
-    assert_eq!(
-        serde_json::to_string(&payload).unwrap(),
-        format!(
-            "{{\"ok\":false,\"error\":\"unknown task status for repair: assigned\",\"action\":\"run `team-agent doctor` or inspect the log path shown here\",\"log\":\"{}\"}}",
-            ws.join(".team/logs/cli-error-123.log").to_string_lossy()
-        ),
-        "repair-state --json error envelope must match Python compact key order and text",
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-#[test]
-fn repair_state_explicit_team_updates_selected_team_not_active_team() {
-    let ws = tmp_workspace();
-    seed_two_team_repair_workspace(&ws);
-    let mut args = repair_args(&ws, "done", Some("patched beta"), true);
-    args.team = Some("beta".to_string());
-
-    let cmd = cmd_repair_state(&args).expect("repair-state --team beta should update beta");
-    assert_eq!(cmd.exit, ExitCode::Ok);
-    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    assert_eq!(
-        state["teams"]["alpha"]["tasks"][0]["status"],
-        json!("pending"),
-        "repair-state --team beta must not mutate active/default alpha"
-    );
-    assert_eq!(
-        state["teams"]["beta"]["tasks"][0]["status"],
-        json!("done"),
-        "repair-state must consume args.team and update beta"
-    );
-    assert_eq!(
-        state["teams"]["beta"]["tasks"][0]["last_result_summary"],
-        json!("patched beta")
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// CONTRACT (real-machine repair_state product FAIL): rt-host-d ran `repair-state --task rp1 --status done`
-// in a quick-start workspace whose spec lives in a teamdir (state.spec_path -> <ws>/teamdir/team.spec.yaml),
-// NOT at <ws>/team.spec.yaml. Rust cmd_repair_state calls load_team_spec(workspace) which HARDCODES
-// workspace.join("team.spec.yaml") (adapters.rs:982) -> read_to_string fails 'No such file or directory'.
-// golden (quick_start.py:295) resolves spec_path = state.get("spec_path", workspace/"team.spec.yaml") and
-// SUCCEEDS. NB: golden ALSO writes team_state.md (write_team_state -> state.py mkdir+write) and returns
-// state_file=team_state.md, so the fix is NOT to drop write_team_state (that diverges from golden and breaks
-// repair_state_success_json_human_and_event_byte_shape) — it is to resolve the spec from state.spec_path
-// (Rust already has load_team_spec_optional(workspace, state) that does exactly this).
-#[test]
-fn contract_repair_state_resolves_spec_from_state_spec_path_teamdir_layout() {
-    let ws = tmp_workspace();
-    std::fs::create_dir_all(ws.join(".team").join("logs")).unwrap();
-    std::fs::create_dir_all(ws.join(".team").join("runtime")).unwrap();
-    let teamdir = ws.join("teamdir");
-    std::fs::create_dir_all(&teamdir).unwrap();
-    let spec_path = teamdir.join("team.spec.yaml");
-    std::fs::write(
-        &spec_path,
-        REPAIR_SPEC_TEMPLATE.replace("__WS__", &ws.to_string_lossy()),
-    )
-    .unwrap();
-    // NOTE: NO <ws>/team.spec.yaml (the hardcoded path) and NO pre-existing team_state.md.
-    crate::state::persist::save_runtime_state(
-        &ws,
-        &json!({
-            "spec_path": spec_path.to_string_lossy(),
-            "session_name": "team-agent-repair",
-            "leader": {"id": "leader"},
-            "agents": {"fake_impl": {"status": "running", "provider": "fake"}},
-            "tasks": [{
-                "id": "task_impl", "title": "x", "type": "implementation",
-                "assignee": null, "deps": [], "acceptance": ["a"], "status": "pending"
-            }]
-        }),
-    )
-    .unwrap();
-
-    let cmd = cmd_repair_state(&repair_args(&ws, "done", Some("patched"), true)).expect(
-        "CONTRACT: repair-state --status done must resolve the spec from state.spec_path (golden \
-         quick_start.py:295), not the hardcoded <ws>/team.spec.yaml (adapters.rs:982) which is absent in \
-         the teamdir layout -> currently io 'No such file or directory'",
-    );
-    assert_eq!(cmd.exit, ExitCode::Ok);
-    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    assert_eq!(
-        state["tasks"][0]["status"],
-        json!("done"),
-        "the task must persist status=done after repair"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}