@team-agent/installer 0.5.111 → 0.5.112

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

@@ -1,7 +1,7 @@
 //!
 //! `team.db` schema 初始化(真相源 `message_store/schema.py` + `schema_migration.py`)。
 //!
-//! slice 1:fresh DB schema —— 8 表 DDL、6 索引、ALTER 式列迁移、agent_health 重建、
+//! slice 1:fresh DB schema —— 7 表 DDL、6 索引、ALTER 式列迁移、agent_health 重建、
 //! WAL/busy_timeout pragmas、`user_version = SCHEMA_VERSION`。
 //! slice 2(待做):列**顺序**漂移的整表 rebuild(`ensure_table_layout`/`_rebuild_tables`)
 //! 与 `schema_diagnosis`,验 legacy_team_db_fixture + schema_migration 契约。
@@ -15,14 +15,13 @@ use crate::db::DbError;
 /// `schema.py:90`。
 pub const SCHEMA_VERSION: i64 = 5;
 
-/// 8 张表的 DDL(逐字照搬 `schema.py:initialize_schema` 的内联建表;含 `if not exists`)。
+/// 7 张表的 DDL(逐字照搬 `schema.py:initialize_schema` 的内联建表;含 `if not exists`)。
 /// 顺序与 Python 一致(leader_notification_log 在 ensure 块后创建)。
 const CREATE_MESSAGES: &str = "create table if not exists messages (\n              message_id text primary key,\n              owner_team_id text,\n              task_id text,\n              sender text,\n              recipient text,\n              reply_to text,\n              requires_ack integer,\n              status text,\n              content text,\n              presentation text not null default '{\"sink\":\"leader\",\"class\":\"message\"}',\n              artifact_refs text,\n              created_at text,\n              updated_at text,\n              delivered_at text,\n              acknowledged_at text,\n              error text,\n              delivery_attempts integer not null default 0\n            )";
 const CREATE_RESULTS: &str = "create table if not exists results (\n              result_id text primary key,\n              owner_team_id text,\n              task_id text not null,\n              agent_id text not null,\n              envelope text not null,\n              status text not null,\n              created_at text not null\n            )";
 const CREATE_SCHEDULED_EVENTS: &str = "create table if not exists scheduled_events (\n              id integer primary key,\n              owner_team_id text,\n              due_at text not null,\n              target text not null,\n              kind text not null,\n              payload_json text not null,\n              status text not null,\n              created_at text not null,\n              fired_at text,\n              result_json text\n            )";
 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              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            )";
@@ -96,7 +95,6 @@ const AGENT_HEALTH_COLUMNS: &[&str] = &[
     "current_task_id",
     "updated_at",
 ];
-const PEER_ALLOWLIST_COLUMNS: &[&str] = &["a", "b", "created_at"];
 const RESULT_WATCHER_COLUMNS: &[&str] = &[
     "owner_team_id",
     "watcher_id",
@@ -249,7 +247,6 @@ pub fn initialize_schema(
         CREATE_SCHEDULED_EVENTS,
         CREATE_DELIVERY_TOKENS,
         CREATE_AGENT_HEALTH,
-        CREATE_PEER_ALLOWLIST,
         CREATE_RESULT_WATCHERS,
     ] {
         tx.execute(ddl, [])?;
@@ -293,7 +290,6 @@ pub fn initialize_schema(
     )?;
     ensure_table_columns(&tx, "delivery_tokens", DELIVERY_TOKEN_COLUMNS, &[])?;
     migrate_agent_health_owner_team_id(&tx)?;
-    ensure_table_columns(&tx, "peer_allowlist", PEER_ALLOWLIST_COLUMNS, &[])?;
     ensure_table_columns(
         &tx,
         "result_watchers",
@@ -333,7 +329,28 @@ mod tests {
         conn
     }
 
-    // golden 由 Python initialize_schema 新建 DB 取(team-agent-public@439bef8)。
+    #[test]
+    fn retired_peer_allowlist_is_neither_created_nor_managed() {
+        let conn = fresh();
+        assert!(table_layout(&conn, "peer_allowlist").unwrap().is_empty());
+        // Legacy residue may have an obsolete layout. Initialization must leave
+        // its data alone, not rebuild/drop it or require it for schema health.
+        conn.execute_batch(
+            "create table peer_allowlist (legacy_payload text);\n             insert into peer_allowlist values ('preserve-this-row');",
+        )
+        .unwrap();
+        initialize_schema(&conn, None).unwrap();
+        assert!(crate::db::migration::ensure_table_layout(&conn, SCHEMA_VERSION, None)
+            .unwrap()
+            .is_empty());
+        assert_eq!(table_layout(&conn, "peer_allowlist").unwrap(), ["legacy_payload"]);
+        let value: String = conn.query_row("select legacy_payload from peer_allowlist", [], |row| row.get(0)).unwrap();
+        assert_eq!(value, "preserve-this-row");
+        let version: i64 = conn.query_row("pragma user_version", [], |row| row.get(0)).unwrap();
+        assert_eq!(version, 5);
+    }
+
+    // Fresh managed schema, excluding retired legacy tables.
     #[test]
     fn fresh_schema_matches_python_sqlite_master() {
         let conn = fresh();
@@ -356,7 +373,6 @@ mod tests {
             ("idx_scheduled_events_owner_team_id", "index"),
             ("leader_notification_log", "table"),
             ("messages", "table"),
-            ("peer_allowlist", "table"),
             ("result_watchers", "table"),
             ("results", "table"),
             ("scheduled_events", "table"),
@@ -419,9 +435,9 @@ mod tests {
         assert_eq!(idx, 6, "二次 init 后 6 个 named index 仍在");
     }
 
-    // 全 8 表逐列 (name, type, notnull, dflt, pk) golden(Python initialize_schema table_info)。
+    // Managed tables: (name, type, notnull, dflt, pk).
     #[test]
-    fn per_column_table_info_all_eight_tables() {
+    fn per_column_table_info_managed_tables() {
         type Col = (&'static str, &'static str, i64, Option<&'static str>, i64);
         let golden: &[(&str, &[Col])] = &[
             (
@@ -503,14 +519,6 @@ mod tests {
                     ("updated_at", "TEXT", 1, None, 0),
                 ],
             ),
-            (
-                "peer_allowlist",
-                &[
-                    ("a", "TEXT", 1, None, 1),
-                    ("b", "TEXT", 1, None, 2),
-                    ("created_at", "TEXT", 1, None, 0),
-                ],
-            ),
             (
                 "result_watchers",
                 &[
@@ -582,7 +590,7 @@ mod tests {
         ];
         let got: Vec<(&str, &str)> = idx.iter().map(|(n, s)| (n.as_str(), s.as_str())).collect();
         assert_eq!(got, want);
-        // 7 个 sqlite_autoindex(每个有 pk/unique 约束的表各一)。
+        // 6 个 sqlite_autoindex(每个有 pk/unique 约束的表各一)。
         let auto: Vec<String> = conn
             .prepare(
                 "select name from sqlite_master where type='index' and sql is null order by name",
@@ -599,7 +607,6 @@ mod tests {
                 "sqlite_autoindex_delivery_tokens_1",
                 "sqlite_autoindex_leader_notification_log_1",
                 "sqlite_autoindex_messages_1",
-                "sqlite_autoindex_peer_allowlist_1",
                 "sqlite_autoindex_result_watchers_1",
                 "sqlite_autoindex_results_1",
             ]

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

@@ -17,30 +17,6 @@ use super::{
     OwnerBindResult, TeamOwner,
 };
 
-// ── leader::identity — leader_identity / 身份上下文 ──
-
-/// `leader_identity`(card §47;`__init__.py:355`)。`team-agent identity` 入口。
-/// 返回 uuid_prefix + 身份字段(JSON dict,CLI 直出)。
-pub fn leader_identity(workspace: &Path, team: Option<&str>) -> Result<Value, LeaderError> {
-    let state = crate::state::persist::load_runtime_state(workspace)?;
-    let identity = leader_identity_context(workspace, team, Some(&state))?;
-    Ok(json!({
-        "ok": true,
-        "uuid_prefix": prefix(identity.leader_session_uuid.as_str(), 12),
-        "machine_fingerprint": identity.machine_fingerprint,
-        "workspace_abspath": identity.workspace_abspath.to_string_lossy(),
-        "os_user": identity.os_user,
-        "team_id": identity.team_id.as_str(),
-        "current_pane_id": std::env::var("TEAM_AGENT_LEADER_PANE_ID")
-            .ok()
-            .filter(|v| !v.is_empty())
-            .or_else(|| std::env::var("TMUX_PANE").ok().filter(|v| !v.is_empty())),
-        "last_seen_at": get_path_str(&state, &["leader_receiver", "attached_at"])
-            .or_else(|| get_path_str(&state, &["leader_receiver", "last_seen_at"])),
-        "source": serde_json::to_value(identity.leader_session_uuid_source)?,
-    }))
-}
-
 /// `_leader_identity_context`(`__init__.py:192`)。派生 leader 身份上下文(override / state / derive)。
 pub fn leader_identity_context(
     workspace: &Path,

package/crates/team-agent/src/leader/tests/byte_findings.rs

@@ -353,23 +353,3 @@ fn attach_leader_to_state_nonfirst_does_not_overwrite_owner_or_advance_epoch() {
         "non-first-time attach must NOT advance owner_epoch (golden keeps 3); Rust bumps to 4"
     );
 }
-
-// C3 [WARN] — leader_identity.current_pane_id honors TEAM_AGENT_LEADER_PANE_ID priority (golden
-// :366 = env(TEAM_AGENT_LEADER_PANE_ID) or env(TMUX_PANE) or None). Rust owner_bind.rs:32 reads
-// TMUX_PANE only. RED: with TEAM_AGENT_LEADER_PANE_ID set + TMUX_PANE unset, current_pane_id must be
-// the LEADER_PANE_ID. (Sibling gap, noted: last_seen_at = receiver.attached_at OR receiver.last_seen_at;
-// Rust reads attached_at only.)
-#[test]
-#[serial_test::serial(env)]
-fn c3_leader_identity_current_pane_honors_leader_pane_id_env() {
-    let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
-    let _e = EnvGuard::apply(&[
-        ("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None),
-        ("TEAM_AGENT_LEADER_PANE_ID", Some("%foo")),
-        ("TMUX_PANE", None),
-    ]);
-    let ws = p2_temp_ws("c3_pane_env");
-    let v = leader_identity(&ws, None).unwrap();
-    assert_eq!(v["current_pane_id"], serde_json::json!("%foo"),
-            "golden :366 current_pane_id = TEAM_AGENT_LEADER_PANE_ID or TMUX_PANE or None; Rust reads TMUX_PANE only");
-}

package/crates/team-agent/src/leader/tests/identity.rs

@@ -23,38 +23,6 @@ fn leader_identity_context_derives_when_no_override_no_state() {
     assert_eq!(id.leader_session_uuid.as_str().len(), 32);
 }
 
-// leader_identity:CLI 直出 dict(__init__.py:355-369)。unimplemented → RED。
-// 强化:uuid_prefix 必须 == leader_identity_context 派生 uuid 的前 12 hex(绑到真值,
-// 而非任意 12 字符);整个 dict 的 machine_fingerprint/os_user/team_id/source 必须与 context 一致。
-#[test]
-#[serial_test::serial(env)]
-fn leader_identity_dict_ties_prefix_and_fields_to_derived_context() {
-    let ws = std::env::temp_dir().join(format!("ta_rs_lid_{}", std::process::id()));
-    std::fs::create_dir_all(&ws).unwrap();
-    // 空 state → context 走 derive(无 override/无 state uuid)。
-    let ctx = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
-    let expected_prefix = &ctx.leader_session_uuid.as_str()[..12];
-    let v = leader_identity(&ws, None).unwrap();
-    assert_eq!(v["ok"], serde_json::json!(true));
-    // uuid_prefix 绑到派生真值的前 12 hex(错的 12 字符串会被抓)。
-    assert_eq!(v["uuid_prefix"].as_str().unwrap(), expected_prefix);
-    // 其余身份字段与 context 字节一致。
-    assert_eq!(
-        v["machine_fingerprint"].as_str().unwrap(),
-        ctx.machine_fingerprint
-    );
-    assert_eq!(v["os_user"].as_str().unwrap(), ctx.os_user);
-    assert_eq!(v["team_id"].as_str().unwrap(), ctx.team_id.as_str());
-    // source == 派生侧 "derived"(无 override → 不是 "override"/"env")。
-    assert_eq!(v["source"], serde_json::json!("derived"));
-    assert_eq!(
-        ctx.leader_session_uuid_source,
-        LeaderSessionUuidSource::Derived
-    );
-    // CLI 直出形态:current_pane_id / last_seen_at 在无 env/无 receiver 时为 null。
-    assert_eq!(v["last_seen_at"], serde_json::Value::Null);
-}
-
 // =====================================================================
 // 13. leader_start_plan(unimplemented → RED):钉 mode 选择 + leader_env 导出键。
 // =====================================================================

package/crates/team-agent/src/leader/tests/lease_claim.rs

@@ -398,61 +398,6 @@ fn claim_lease_no_incident_caller_not_live_refused_under_n_rn3_any_live_pane() {
     assert_eq!(r.reason, Some(LeaseReason::CallerPaneNotLive));
 }
 
-// ── 14b. leader_identity dict — workspace_abspath key (golden __init__.py:363) ──
-//
-// LOCK→RED: leader_identity IS implemented (owner_bind.rs:22) but its dict
-// OMITS the golden `workspace_abspath` key (probe_lid.py shows it sits between
-// machine_fingerprint and os_user). This pins the missing key so the porter
-// must add it. Fails today (key absent → null) = RED against the omission.
-#[test]
-#[serial_test::serial(env)]
-fn leader_identity_dict_includes_workspace_abspath_key() {
-    let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
-    let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
-    let ws = p2_temp_ws("lid_wsabs");
-    let v = leader_identity(&ws, None).unwrap();
-    let ctx = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
-    // golden key present + equals the resolved workspace abspath from context.
-    assert!(
-        v.get("workspace_abspath").is_some(),
-        "golden leader_identity dict carries 'workspace_abspath' (probe_lid.py)"
-    );
-    assert_eq!(
-        v["workspace_abspath"].as_str().unwrap(),
-        ctx.workspace_abspath.to_string_lossy(),
-        "workspace_abspath must equal the context's resolved abspath"
-    );
-}
-
-// LOCK — leader_identity key ORDER & full key set (golden probe_lid.py):
-// [ok, uuid_prefix, machine_fingerprint, workspace_abspath, os_user, team_id,
-//  current_pane_id, last_seen_at, source]. Pins the 9-key surface CLI emits.
-#[test]
-#[serial_test::serial(env)]
-fn leader_identity_dict_has_exact_nine_golden_keys() {
-    let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
-    let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
-    let ws = p2_temp_ws("lid_keys");
-    let v = leader_identity(&ws, None).unwrap();
-    let obj = v.as_object().expect("leader_identity → JSON object");
-    for key in [
-        "ok",
-        "uuid_prefix",
-        "machine_fingerprint",
-        "workspace_abspath",
-        "os_user",
-        "team_id",
-        "current_pane_id",
-        "last_seen_at",
-        "source",
-    ] {
-        assert!(
-            obj.contains_key(key),
-            "golden leader_identity dict must carry '{key}'"
-        );
-    }
-}
-
 // ═════════════════════════════════════════════════════════════════════════
 // WAVE-2 Lane B — leader-lease DIVERGENCE round (adversarial review @ 2cd71ce).
 // The lease gate is green but NOT byte-parity. Golden: leader/__init__.py

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/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(