@team-agent/installer 0.5.111 → 0.5.113

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

@@ -41,6 +41,71 @@ use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest}
 // `pane_verify_ms`, `startup_prompt_handler_ms`, `tmux_start_mode`) so
 // bounded-concurrency spawn can be justified with real numbers.
 
+/// Stable wire labels for launch/restart timing events, not readiness states.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum LifecyclePhase {
+    ResolveContext,
+    CompileSpec,
+    PlanClassification,
+    Teardown,
+    SpawnAll,
+    SaveState,
+    CoordinatorStart,
+    ReadinessWait,
+    Completed,
+}
+
+impl LifecyclePhase {
+    pub(crate) fn as_str(self) -> &'static str {
+        match self {
+            Self::ResolveContext => "resolve_context",
+            Self::CompileSpec => "compile_spec",
+            Self::PlanClassification => "plan_classification",
+            Self::Teardown => "teardown",
+            Self::SpawnAll => "spawn_all",
+            Self::SaveState => "save_state",
+            Self::CoordinatorStart => "coordinator_start",
+            Self::ReadinessWait => "readiness_wait",
+            Self::Completed => "completed",
+        }
+    }
+
+    /// Pure event formatting shared by launch/restart; no clock, I/O or readiness policy.
+    pub(crate) fn event_fields(self, elapsed_ms: u64) -> serde_json::Value {
+        serde_json::json!({
+            "phase": self.as_str(),
+            "elapsed_ms": elapsed_ms,
+        })
+    }
+}
+
+#[test]
+fn lifecycle_phase_wire_labels_remain_stable() {
+    for (phase, wire) in [
+        (LifecyclePhase::ResolveContext, "resolve_context"),
+        (LifecyclePhase::CompileSpec, "compile_spec"),
+        (LifecyclePhase::PlanClassification, "plan_classification"),
+        (LifecyclePhase::Teardown, "teardown"),
+        (LifecyclePhase::SpawnAll, "spawn_all"),
+        (LifecyclePhase::SaveState, "save_state"),
+        (LifecyclePhase::CoordinatorStart, "coordinator_start"),
+        (LifecyclePhase::ReadinessWait, "readiness_wait"),
+        (LifecyclePhase::Completed, "completed"),
+    ] {
+        assert_eq!(phase.as_str(), wire);
+        for elapsed_ms in [0, 123, u64::MAX] {
+            assert_eq!(phase.event_fields(elapsed_ms), serde_json::json!({
+                "phase": wire,
+                "elapsed_ms": elapsed_ms,
+            }));
+            assert_eq!(
+                serde_json::to_string(&phase.event_fields(elapsed_ms)).expect("phase JSON"),
+                format!("{{\"phase\":\"{wire}\",\"elapsed_ms\":{elapsed_ms}}}"),
+            );
+        }
+    }
+}
+
 pub(crate) struct RestartPhaseTimer {
     started_at: std::time::Instant,
 }
@@ -71,15 +136,9 @@ impl RestartPhaseTimer {
 ///   phase: 阶段名
 /// returns: 写事件失败被吞掉，不影响主流程
 /// ---
-    pub(crate) fn emit(&self, workspace: &Path, kind: &'static str, phase: &'static str) {
+    pub(crate) fn emit(&self, workspace: &Path, kind: &'static str, phase: LifecyclePhase) {
         let event_log = crate::event_log::EventLog::new(workspace);
-        let _ = event_log.write(
-            kind,
-            serde_json::json!({
-                "phase": phase,
-                "elapsed_ms": self.elapsed_ms(),
-            }),
-        );
+        let _ = event_log.write(kind, phase.event_fields(self.elapsed_ms()));
     }
 }
 
@@ -305,7 +364,7 @@ fn restart_with_selected_team_and_transport(
     // resolved a context; downstream phases are emitted with monotonic
     // `elapsed_ms` for at-a-glance latency triage.
     let phase_timer = RestartPhaseTimer::start();
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "resolve_context");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::ResolveContext);
     let lifecycle_lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &selected.run_workspace,
         operation: "restart",
@@ -345,7 +404,7 @@ fn restart_with_selected_team_and_transport(
     // 写 runtime spec。角色缺(TEAM.md/agents 不在)→ 显式拒(列缺哪些),旧 spec 原地保留不删不用。
     let spec =
         rebuild_runtime_spec_from_roles(&selected.run_workspace, &selected.team_key, &state)?;
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "compile_spec");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::CompileSpec);
     // 重建后 spec_workspace 恒为 runtime spec 的父目录(.team/runtime/<team_key>/)。
     let runtime_spec =
         crate::model::paths::runtime_spec_path(&selected.run_workspace, &selected.team_key);
@@ -441,7 +500,7 @@ fn restart_with_selected_team_and_transport(
     phase_timer.emit(
         &selected.run_workspace,
         "restart.phase",
-        "plan_classification",
+        LifecyclePhase::PlanClassification,
     );
     write_restart_resume_decision_events(
         &selected.run_workspace,
@@ -558,8 +617,8 @@ fn restart_with_selected_team_and_transport(
             &topology_authority_agent_ids,
         )?;
     }
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "teardown");
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "spawn_all");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::Teardown);
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::SpawnAll);
     // 0.5.40 Slice 3 (tmux-server-death-locate §7 Slice 3): when the
     // pre-spawn teardown was DEFERRED (live worker session with
     // authoritative running agents), snapshot the pre-spawn agent rows
@@ -582,8 +641,8 @@ fn restart_with_selected_team_and_transport(
     // tmux session is created deterministically; the remaining independent
     // decisions run their `transport.spawn_into` in parallel via a thread
     // scope with concurrency capped at `min(4, workers-1)`. Every spawn
-    // result is collected in-memory; `verify_spawned_agent_live` +
-    // `mark_agent_respawned` are then applied in ORIGINAL PLAN ORDER so
+    // result is collected in-memory; `mark_agent_respawned` is then
+    // applied in ORIGINAL PLAN ORDER so
     // persisted `spawn_epoch` / `spawned_at` / `pane_id` / `window` stay
     // deterministic regardless of thread completion order. Failure
     // aggregation stays equivalent to serial: per-agent errors go into
@@ -837,17 +896,14 @@ fn restart_with_selected_team_and_transport(
             agent.get("dangerously_skip_permissions"),
             Some(serde_json::Value::Bool(true))
         );
-        if let Err(error) = verify_spawned_agent_live(&decision.agent_id, &spawn, transport)
-            .and_then(|_| {
-                mark_agent_respawned(
-                    &mut state,
-                    &decision.agent_id,
-                    decision.restart_mode,
-                    &spawn,
-                    transport,
-                    launched_bypass,
-                )
-            })
+        if let Err(error) = mark_agent_respawned(
+            &mut state,
+            &decision.agent_id,
+            decision.restart_mode,
+            &spawn,
+            transport,
+            launched_bypass,
+        )
         {
             let error = error.to_string();
             mark_agent_restart_failed(&mut state, decision, &error);
@@ -1026,7 +1082,7 @@ fn restart_with_selected_team_and_transport(
         &capture_backfill_skip_agent_ids,
         &topology_authority_agent_ids,
     )?;
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "save_state");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::SaveState);
     if fatal_resume_failure {
         let attach_commands = Vec::new();
         let next_actions = restart_failure_next_actions(&failed_agents);
@@ -1304,10 +1360,10 @@ fn restart_with_selected_team_and_transport(
     phase_timer.emit(
         &selected.run_workspace,
         "restart.phase",
-        "coordinator_start",
+        LifecyclePhase::CoordinatorStart,
     );
     let coordinator_started = coordinator.ok;
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "readiness_wait");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::ReadinessWait);
     wait_restart_readiness_or_timeout(
         &selected.run_workspace,
         &state,
@@ -1331,7 +1387,7 @@ fn restart_with_selected_team_and_transport(
     let mut next_actions = Vec::new();
     if !failed_agents.is_empty() {
         next_actions.extend(restart_failure_next_actions(&failed_agents));
-        phase_timer.emit(&selected.run_workspace, "restart.phase", "completed");
+        phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::Completed);
         write_restart_completed_event(
             &selected.run_workspace,
             &successful_agents,
@@ -1360,7 +1416,7 @@ fn restart_with_selected_team_and_transport(
             leader_bind_reason,
         });
     }
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "completed");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::Completed);
     write_restart_completed_event(
         &selected.run_workspace,
         &successful_agents,
@@ -1852,14 +1908,6 @@ fn yes_no(value: bool) -> &'static str {
     }
 }
 
-fn verify_spawned_agent_live(
-    _agent_id: &AgentId,
-    _spawn: &SpawnedAgentWindow,
-    _transport: &dyn crate::transport::Transport,
-) -> Result<(), LifecycleError> {
-    Ok(())
-}
-
 /// 0.3.30 Bug 1: restart success path auto-attach.
 /// When `TMUX_PANE` is present in the caller's env, treat the restart as if
 /// the user had also run `attach-leader` from that pane. Mirrors quick-start's
@@ -3088,8 +3136,8 @@ fn run_bounded_parallel_worker_spawns(
     outcomes
 }
 
-/// 0.5.38 Step 2: serial post-spawn stage. Runs verify_spawned_agent_live +
-/// mark_agent_respawned in plan order, emits worker.spawn_timing, and
+/// 0.5.38 Step 2: serial post-spawn stage. Runs mark_agent_respawned
+/// in plan order, emits worker.spawn_timing, and
 /// updates the successful/failed agent lists exactly like the pre-0.5.38
 /// serial loop. Keeping this serial guarantees deterministic persisted
 /// state (`spawn_epoch`, `spawned_at`, etc.) regardless of parallel
@@ -3111,17 +3159,14 @@ fn apply_marked_respawn(
     launched_bypass: bool,
 ) {
     let verify_start = std::time::Instant::now();
-    if let Err(error) =
-        verify_spawned_agent_live(&decision.agent_id, spawn, transport).and_then(|_| {
-            mark_agent_respawned(
-                state,
-                &decision.agent_id,
-                decision.restart_mode,
-                spawn,
-                transport,
-                launched_bypass,
-            )
-        })
+    if let Err(error) = mark_agent_respawned(
+        state,
+        &decision.agent_id,
+        decision.restart_mode,
+        spawn,
+        transport,
+        launched_bypass,
+    )
     {
         let error = error.to_string();
         mark_agent_restart_failed(state, decision, &error);

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

@@ -100,7 +100,7 @@ pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline
 // timer + worker timing writer so `lifecycle::launch::launch_with_transport_in_workspace`
 // can emit the same instrumentation event family with `source="launch"`.
 pub(crate) use rebuild::{
-    provider_wire_from_state, write_worker_spawn_timing_event, RestartPhaseTimer,
+    provider_wire_from_state, write_worker_spawn_timing_event, LifecyclePhase, RestartPhaseTimer,
 };
 pub use rebuild::{restart, restart_with_session_convergence_deadline};
 pub(crate) use rebuild::{

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

@@ -21,7 +21,6 @@ use std::sync::Mutex;
 
 use serde_json::{json, Value};
 use serial_test::serial;
-use team_agent::cli::{cmd_wait_ready, CmdOutput, WaitReadyArgs};
 use team_agent::lifecycle::{
     classify_restart_plan, restart_with_transport, RestartReport, ResumeDecision, StartMode,
 };
@@ -448,48 +447,7 @@ fn restart_refuses_first_send_at_null_running_resumable_session_incomplete_when_
 }
 
 #[test]
-#[ignore = "real-machine: provider session filesystem + restart/shutdown lifecycle convergence"]
-#[serial(env)]
-fn wait_ready_reports_session_capture_incomplete_for_running_resumable_worker_without_session() {
-    let fixture = RestartFixture::new("wait-ready-session-incomplete", "codex");
-    seed_running_state_without_session(&fixture.team, "codex", &fixture.spawn_cwd);
-    let mut state = load_runtime_state(&fixture.team).unwrap();
-    let mcp_config = fixture.team.join(".team/runtime/worker_a.mcp.json");
-    std::fs::create_dir_all(mcp_config.parent().unwrap()).unwrap();
-    std::fs::write(&mcp_config, "{}").unwrap();
-    state["agents"]["worker_a"]["pane_id"] = json!("%1");
-    state["agents"]["worker_a"]["mcp_config"] = json!(mcp_config.to_string_lossy().to_string());
-    save_runtime_state(&fixture.team, &state).unwrap();
-
-    let out = json_result(
-        cmd_wait_ready(&WaitReadyArgs {
-            workspace: fixture.team.clone(),
-            timeout: 0.0,
-            json: true,
-            team: None,
-        })
-        .expect("wait-ready should return structured JSON"),
-    );
-
-    assert_eq!(
-        out["ok"],
-        json!(false),
-        "wait-ready cannot report ready while a running Codex/Claude worker is missing captured session context; out={out}"
-    );
-    assert_eq!(
-        out["reason"],
-        json!("session_capture_incomplete"),
-        "readiness reason must distinguish missing resumable session from generic workers_not_ready; out={out}"
-    );
-    assert!(
-        out["readiness"]["session_capture_incomplete"].as_bool() == Some(true)
-            && out["readiness"]["all_resumable_have_session"].as_bool() == Some(false),
-        "readiness truth table must include all_resumable_have_session and session_capture_incomplete; out={out}"
-    );
-}
-
-#[test]
-fn status_quick_start_and_wait_ready_surfaces_include_session_capture_completeness() {
+fn status_and_quick_start_surfaces_include_session_capture_completeness() {
     let diagnose =
         std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/cli/diagnose.rs"))
             .unwrap();
@@ -500,7 +458,7 @@ fn status_quick_start_and_wait_ready_surfaces_include_session_capture_completene
             .unwrap();
 
     for (name, source) in [
-        ("wait-ready", diagnose.as_str()),
+        ("status readiness formula", diagnose.as_str()),
         ("status --json", status.as_str()),
         ("quick-start readiness", launch.as_str()),
         ("quick-start --json", adapters.as_str()),
@@ -945,13 +903,6 @@ fn read_events(team: &Path) -> String {
     std::fs::read_to_string(team.join(".team/logs/events.jsonl")).unwrap_or_default()
 }
 
-fn json_result(result: team_agent::cli::CmdResult) -> Value {
-    match result.output {
-        CmdOutput::Json(value) => value,
-        other => panic!("expected JSON command output, got {other:?}"),
-    }
-}
-
 fn assert_no_agent_attribution_ambiguous<const N: usize>(
     state: &Value,
     expected_agents: [&str; N],

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

@@ -165,14 +165,15 @@ fn purge_agent_help_and_dispatch_are_consistent() {
         output_text(&case.run(["purge-agent", "ghost", "--workspace", case.ws(), "--json"]));
     if help.contains("purge-agent") {
         assert!(
-            !command.contains("invalid choice") && !command.contains("unknown subcommand") && !command.contains("Commands:"),
+            !command.contains("invalid choice") && !command.contains("unknown subcommand")
+                && !command.contains("Unknown command:") && !command.contains("Commands:"),
             "RED6: help exposes purge-agent, so dispatch must be real or the command must be removed from help; help={help} command={command}"
         );
     } else {
         assert!(
             command.contains("unknown subcommand")
                 || command.contains("invalid choice")
-                || command.contains("没有这个操作"),
+                || command.contains("Unknown command:"),
             "RED6: if purge-agent is not implemented, help and dispatch must agree it is absent; help={help} command={command}"
         );
     }

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

@@ -23,7 +23,7 @@ use std::time::{Duration, Instant};
 
 use serde_json::{json, Value};
 use serial_test::serial;
-use team_agent::cli::{cmd_preflight, emit, CmdOutput, PreflightArgs};
+use team_agent::cli::{cmd_doctor, emit, CmdOutput, DoctorArgs};
 use team_agent::event_log::EventLog;
 use team_agent::message_store::MessageStore;
 use team_agent::state::persist::save_runtime_state;
@@ -334,11 +334,10 @@ fn red6_cli_restart_reports_and_top_level_error_logs_are_redacted() {
     env.scrub_tmux();
     env.assert_no_real_tmux();
     let workspace = env.workspace("red6");
-    let spec = write_invalid_validate_spec(&workspace, &marker);
     let mut combined = String::new();
     for json_mode in [true, false] {
         let mut command = Command::new(crate::lifecycle::tests::test_binary_path());
-        command.arg("validate").arg(&spec);
+        command.arg("profile").arg(credential_url(&marker)).arg("synthetic-profile");
         if json_mode {
             command.arg("--json");
         }
@@ -351,7 +350,7 @@ fn red6_cli_restart_reports_and_top_level_error_logs_are_redacted() {
             .expect("run top-level CLI error boundary");
         assert!(
             !output.status.success(),
-            "invalid spec must reach CLI error"
+            "invalid profile subcommand must reach CLI error"
         );
         combined.push_str(&String::from_utf8_lossy(&output.stdout));
         combined.push_str(&String::from_utf8_lossy(&output.stderr));
@@ -391,15 +390,30 @@ fn red7_pane_and_profile_scrubbers_converge_without_losing_existing_policy() {
     let env = hermetic_guard::HermeticTestEnv::enter("redact-red7");
     let pane_policy_preserved = pane_excerpt_uses_shared_redaction(&env, &marker);
     let team = write_profile_fixture(env.root(), server.base_url(), &profile_token);
-    let result = cmd_preflight(&PreflightArgs { team, json: true })
+    let result = cmd_doctor(&DoctorArgs {
+        spec: Some(team.join("TEAM.md")),
+        workspace: team,
+        gate: None,
+        comms: false,
+        team: None,
+        fix: false,
+        fix_schema: false,
+        cleanup_orphans: false,
+        confirm: false,
+        json: true,
+    })
         .expect("profile smoke returns a diagnostic report");
     let report = match result.output {
         CmdOutput::Json(value) => value,
-        other => panic!("expected JSON preflight output, got {other:?}"),
+        other => panic!("expected JSON doctor output, got {other:?}"),
     };
-    let text = report.to_string();
-    let profile_policy_preserved = !text.contains(&marker)
-        && !text.contains(&profile_token)
+    let report_text = report.to_string();
+    let text = report
+        .get("profile_smoke")
+        .unwrap_or_else(|| panic!("doctor must expose profile_smoke; report={report}"))
+        .to_string();
+    let profile_policy_preserved = !report_text.contains(&marker)
+        && !report_text.contains(&profile_token)
         && !text.contains(tail_sentinel)
         && text.contains(REDACTED)
         && text.contains("proxy.invalid:8443/path")
@@ -555,20 +569,6 @@ fn run_mcp_status_frames(
         .collect()
 }
 
-fn write_invalid_validate_spec(workspace: &Path, marker: &str) -> PathBuf {
-    let path = workspace.join("invalid-provider.spec.yaml");
-    fs::write(
-        &path,
-        format!(
-            "version: 1\nteam:\n  id: current\n  name: current\n  session_name: team-redaction-contract\n  workspace: \"{}\"\nleader:\n  provider: \"{}\"\nagents:\n  - id: worker\n    provider: fake\n    model: fake\n    role: Worker\n    window: worker\ntasks: []\n",
-            workspace.display(),
-            credential_url(marker)
-        ),
-    )
-    .unwrap();
-    path
-}
-
 fn read_cli_error_logs(workspace: &Path) -> String {
     let dir = workspace.join(".team/logs");
     fs::read_dir(dir)

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

@@ -92,15 +92,10 @@ const SUBROOT_FULL_TRUST_PANE_AFTER_QUICKSTART: &str = r#"> You are in /private/
 │ directory: /private/tmp/…/teamdir     │
 ╰───────────────────────────────────────╯
 
-
 › Find and fix a bug in @filename
 
   gpt-5.5 default · /private/tmp/ta-subroot-SUB-PROBE-1-trust-startup.uL9Boc/te…
 
-
-
-
-
 "#;
 
 fn tmp_dir(tag: &str) -> TempWorkspace {
@@ -419,8 +414,7 @@ fn contract_a_own_workspace_trust_is_actionable_not_ready_and_foreign_is_pending
 }
 
 #[test]
-fn contract_a_probe5_quick_start_ready_is_invalid_while_actionable_trust_remains() {
-    use team_agent::cli::{cmd_wait_ready, CmdOutput, WaitReadyArgs};
+fn contract_a_runtime_readiness_is_false_while_actionable_trust_remains() {
     use team_agent::provider::{classify_codex_startup_screen, StartupScreenDecision};
 
     assert_eq!(
@@ -429,67 +423,47 @@ fn contract_a_probe5_quick_start_ready_is_invalid_while_actionable_trust_remains
         "fixture sanity: probe5 pane text is an actionable own-workspace trust prompt"
     );
 
-    let ws = tmp_dir("a-wait-ready-trust");
+    let ws = tmp_dir("a-runtime-readiness-trust");
     let mcp_config = ws.join(".team").join("runtime").join("mcp").join("w1.json");
     std::fs::create_dir_all(mcp_config.parent().unwrap()).unwrap();
     std::fs::write(&mcp_config, "{}").unwrap();
-    team_agent::state::persist::save_runtime_state(
-        &ws,
-        &json!({
-            "session_name": "team-subprep",
-            "agents": {
-                "w1": {
-                    "provider": "codex",
-                    "status": "awaiting_trust_prompt",
-                    "startup_prompt_status": "awaiting_trust_prompt",
-                    "startup_prompts": "awaiting_trust_prompt",
-                    "pane_id": "%7",
-                    "window": "w1",
-                    "mcp_config": mcp_config.to_string_lossy().to_string(),
-                    "task_prompt_delivered": true
-                }
+    // Keep every other readiness gate satisfied; an unattached leader would
+    // make ready=false independently of the trust prompt under test.
+    let mut state = json!({
+        "session_name": "team-subprep",
+        "tmux_session_present": true,
+        "leader_receiver": {"status": "attached", "pane_id": "%9"},
+        "agents": {
+            "w1": {
+                "provider": "codex",
+                "status": "awaiting_trust_prompt",
+                "startup_prompt_status": "awaiting_trust_prompt",
+                "startup_prompts": "awaiting_trust_prompt",
+                "pane_id": "%7",
+                "window": "w1",
+                "mcp_config": mcp_config.to_string_lossy().to_string(),
+                "task_prompt_delivered": true
             }
-        }),
-    )
-    .unwrap();
-
-    let result = cmd_wait_ready(&WaitReadyArgs {
-        workspace: ws.to_path_buf(),
-        timeout: 0.0,
-        json: true,
-        team: None,
-    })
-    .expect("wait-ready SUT should return shaped JSON");
-    let value = match result.output {
-        CmdOutput::Json(value) => value,
-        other => panic!("wait-ready --json must return JSON output, got {other:?}"),
-    };
+        }
+    });
 
+    let value = crate::cli::diagnose::wait_readiness(&state);
     assert_eq!(
-        value["ok"],
-        json!(false),
-        "Contract A: quick-start/wait-ready readiness must not report ok=true while actionable trust remains; got {value}"
-    );
-    assert_eq!(
-        value["status"],
-        json!("pending"),
-        "Contract A: actionable trust prompt should keep readiness pending, not ready; got {value}"
-    );
-    assert_eq!(
-        value["reason"],
-        json!("awaiting_trust_prompt"),
-        "Contract A: not-ready reason must identify the startup trust boundary; got {value}"
-    );
-    assert_eq!(
-        value["readiness"]["awaiting_trust_prompt"],
+        value["awaiting_trust_prompt"],
         json!(true),
         "Contract A: ready logic must surface awaiting_trust_prompt=true; got {value}"
     );
     assert_eq!(
-        value["readiness"]["ready"],
+        value["ready"],
         json!(false),
         "Contract A: ready must stay false until the actionable trust prompt is cleared; got {value}"
     );
+    state["agents"]["w1"]["status"] = json!("running");
+    state["agents"]["w1"]["startup_prompt_status"] = json!("complete");
+    state["agents"]["w1"]["startup_prompts"] = json!("complete");
+    let cleared = crate::cli::diagnose::wait_readiness(&state);
+    assert_eq!(cleared["awaiting_trust_prompt"], json!(false));
+    assert_eq!(cleared["ready"], json!(true), "positive control: {cleared}");
 }
 
 #[test]

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

@@ -67,7 +67,6 @@ pub mod delivery;
 pub mod helpers;
 pub mod leader_channel;
 pub mod leader_receiver;
-pub mod peers;
 pub mod persist;
 pub mod presentation;
 pub mod results;
@@ -96,7 +95,6 @@ pub use leader_receiver::{
     mirror_peer_message_to_leader, send_to_leader_receiver,
     send_to_leader_receiver_with_presentation,
 };
-pub use peers::allow_peer_talk;
 pub use persist::{
     persist_resolved_send, DeliveryBlocker, InitialDisposition, InternalSendKind,
     LogicalRecipient, PersistResolution, PersistedSend, ResolvedSendIntent, SendOrigin,

package/crates/team-agent/src/messaging/results.rs

@@ -45,64 +45,6 @@ impl Default for ResultRoute {
     }
 }
 
-pub fn results_for_case(
-    workspace: &Path,
-    case_id: &str,
-    owner_team_id: Option<&str>,
-    requested_owner_team_id: Option<&str>,
-) -> Result<Vec<serde_json::Value>, MessagingError> {
-    let current_db = workspace.join(".team/runtime/team.db");
-    let legacy_db = workspace.join(".team/team.db");
-    if current_db.exists() {
-        return results_for_case_in_db(
-            &current_db,
-            case_id,
-            owner_team_id,
-            requested_owner_team_id,
-        );
-    }
-    if legacy_db.exists() {
-        return results_for_case_in_db(&legacy_db, case_id, owner_team_id, requested_owner_team_id);
-    }
-    Ok(Vec::new())
-}
-
-fn results_for_case_in_db(
-    db_path: &Path,
-    case_id: &str,
-    owner_team_id: Option<&str>,
-    requested_owner_team_id: Option<&str>,
-) -> Result<Vec<serde_json::Value>, MessagingError> {
-    let conn = crate::db::schema::open_db(db_path)?;
-    // The second predicate works around
-    // `.team/bugs/BUG-caseid-writable-when-route-undeclared-20260730.md`;
-    // it is not design intent.
-    let case_predicate = "task_id = ?1 or json_extract(envelope,'$.presentation.case_id') = ?1";
-    let sql = match owner_team_id {
-        Some(_) => format!(
-            "select envelope from results where ({case_predicate}) \
-             and (owner_team_id = ?2 or owner_team_id = ?3) \
-             order by created_at, result_id"
-        ),
-        None => format!(
-            "select envelope from results where {case_predicate} order by created_at, result_id"
-        ),
-    };
-    let mut stmt = conn.prepare(&sql)?;
-    let row_mapper = |row: &rusqlite::Row<'_>| row.get::<_, String>(0);
-    let rows = match (owner_team_id, requested_owner_team_id) {
-        (Some(team), Some(requested_team)) => {
-            stmt.query_map(params![case_id, team, requested_team], row_mapper)
-        }
-        (Some(team), None) => stmt.query_map(params![case_id, team, team], row_mapper),
-        (None, _) => stmt.query_map(params![case_id], row_mapper),
-    }?
-    .collect::<Result<Vec<_>, _>>()?;
-    rows.into_iter()
-        .map(|envelope| serde_json::from_str(&envelope).map_err(MessagingError::from))
-        .collect()
-}
-
 /// `collect` (`results.py:45`):投递 pending、捞 uncollected results、校验 envelope、更新任务态、
 /// 写 team_state、ensure coordinator。CLI `collect` + coordinator tick 调。
 pub fn collect(