@team-agent/installer 0.5.110 → 0.5.112

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(

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

@@ -1090,52 +1090,6 @@ fn collect_rejects_message_scoped_result_without_matching_recipient() {
     );
 }
 
-#[test]
-fn allow_peer_talk_records_bidirectional_allowlist_and_event() {
-    let ws = tmp_ws("allowpeer");
-    let out = allow_peer_talk(&ws, "alice", "bob").unwrap();
-    assert_eq!(out.get("ok").and_then(|v| v.as_bool()), Some(true));
-    assert_eq!(out.get("a").and_then(|v| v.as_str()), Some("alice"));
-    assert_eq!(out.get("b").and_then(|v| v.as_str()), Some("bob"));
-    assert_eq!(
-        out.get("status").and_then(|v| v.as_str()),
-        Some("compat_noop")
-    );
-    assert_eq!(
-        out.get("reason").and_then(|v| v.as_str()),
-        Some("team_scoped_peer_messages_enabled")
-    );
-
-    let store = store_for(&ws);
-    let conn = seed_conn(&store);
-    let rows = conn
-        .prepare("select a, b from peer_allowlist order by a, b")
-        .unwrap()
-        .query_map([], |row| {
-            Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
-        })
-        .unwrap()
-        .collect::<Result<Vec<_>, _>>()
-        .unwrap();
-    assert_eq!(
-        rows,
-        vec![
-            ("alice".to_string(), "bob".to_string()),
-            ("bob".to_string(), "alice".to_string()),
-        ]
-    );
-
-    let events = EventLog::new(&ws).tail(10).unwrap();
-    let event = events
-        .iter()
-        .find(|event| {
-            event.get("event").and_then(|v| v.as_str()) == Some("communication.peer_allowed")
-        })
-        .expect("communication.peer_allowed event");
-    assert_eq!(event.get("a").and_then(|v| v.as_str()), Some("alice"));
-    assert_eq!(event.get("b").and_then(|v| v.as_str()), Some("bob"));
-}
-
 // ════════════════════════════════════════════════════════════════════════
 // GROUP R — run_comms_selftest: §84 / MUST-NOT-13 zero-provider-SDK gate.
 // diagnose/comms.py:21-47. The whole point: assert zero provider client calls.

package/crates/team-agent/src/state/repository.rs

@@ -527,7 +527,6 @@ pub enum StateWriteIntent<'a> {
     TaskRepair {
         team_key: Option<&'a str>,
     },
-    FakeE2eSeed,
     SelfMigration,
 }
 
@@ -743,10 +742,7 @@ fn route_direct(
         },
         // TaskRepair -> `save_team_scoped_state` (cli/adapters.rs:675).
         StateWriteIntent::TaskRepair { .. } => helper_write_team_scoped(workspace, state),
-        // FakeE2eSeed / SelfMigration are diagnostic seams. The current
-        // callsites live at cli/adapters.rs:1035/1070 and
-        // state/persist.rs:1127; S1a routes them to the root helper.
-        StateWriteIntent::FakeE2eSeed => helper_write_root(workspace, state),
+        // SelfMigration persists through the root helper.
         StateWriteIntent::SelfMigration => helper_write_root(workspace, state),
     }
 }

package/package.json

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

package/templates/team_state.md

@@ -29,4 +29,4 @@ Pending.
 
 ## Next Step
 
-- Run `team-agent validate team.spec.yaml`, review permissions, then run `team-agent launch team.spec.yaml --yes`.
+- Review role files and permissions, then run `team-agent quick-start`; use `team-agent doctor` to diagnose the team.

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

@@ -1,164 +0,0 @@
-use super::*;
-
-// =============================================================================
-// P0-1 LANE — `allow-peer-talk` byte-lock (was ZERO-test; a SHIPPED compat-noop).
-//
-// golden: cli/commands.py:422 -> messaging/leader.py:25 allow_peer_talk(ws,a,b)
-//   -> message_store/core.py:326 allow_peer (INSERT OR IGNORE BOTH (a,b) & (b,a))
-//   + events.py:27-35 EventLog.write (sort_keys=True -> .team/logs/events.jsonl).
-//
-// Golden bytes captured live (PYTHONPATH=.../src python3 /tmp/probe_app*.py):
-//   return (insertion order):  {"ok":true,"a":..,"b":..,"status":"compat_noop",
-//                               "reason":"team_scoped_peer_messages_enabled"}
-//   return (--json sort_keys):  keys a,b,ok,reason,status
-//   event line (sort_keys):     {"a":..,"b":..,"event":"communication.peer_allowed","ts":..}
-//   idempotent:                 2nd call -> identical return + a SECOND event line
-//                               (event fires per-call; DB rows are insert-or-ignore)
-//   unknown/undeclared agents:  NO validation -> ok:true compat_noop, exit 0
-//
-// Rust impl: messaging/peers.rs:11 + message_store.rs:251 + adapters.rs:173.
-// serde_json `preserve_order` is ON (Cargo.toml:24) so the default (human) output
-// iterates dict keys in golden insertion order. These tests LOCK the contract so a
-// porter/refactor cannot silently drift this live verb.
-// =============================================================================
-
-fn app_out(r: CmdResult) -> serde_json::Value {
-    match r.output {
-        CmdOutput::Json(v) => v,
-        _ => panic!("allow-peer-talk must emit a Json CmdOutput"),
-    }
-}
-
-fn app_events(ws: &std::path::Path) -> Vec<String> {
-    std::fs::read_to_string(ws.join(".team").join("logs").join("events.jsonl"))
-        .unwrap_or_default()
-        .lines()
-        .map(str::to_string)
-        .collect()
-}
-
-fn app_call(ws: &std::path::Path, a: &str, b: &str) -> CmdResult {
-    cmd_allow_peer_talk(&AllowPeerTalkArgs {
-        a: a.to_string(),
-        b: b.to_string(),
-        workspace: ws.to_path_buf(),
-        json: false,
-        team: None,
-    })
-    .expect("allow-peer-talk is a compat-noop and must not error")
-}
-
-// ── return dict: exact compat_noop shape + golden insertion order (drives human emit) ──
-#[test]
-fn allow_peer_talk_output_byte_locks_golden_compat_noop() {
-    let ws = tmp_workspace();
-    let v = app_out(app_call(&ws, "alpha", "bravo"));
-    assert_eq!(
-        v,
-        json!({
-            "ok": true,
-            "a": "alpha",
-            "b": "bravo",
-            "status": "compat_noop",
-            "reason": "team_scoped_peer_messages_enabled"
-        }),
-        "golden leader.py:28 return dict (key set + values); got {v:?}"
-    );
-    let order: Vec<&str> = v
-        .as_object()
-        .expect("object")
-        .keys()
-        .map(String::as_str)
-        .collect();
-    assert_eq!(
-        order,
-        vec!["ok", "a", "b", "status", "reason"],
-        "golden dict insertion order ok,a,b,status,reason drives the default human emit key order \
-         (helpers.py:16-19); got {order:?}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── event: exactly one `communication.peer_allowed` line, sort_keys byte form, payload {a,b} ──
-#[test]
-fn allow_peer_talk_event_byte_locks_golden_line() {
-    let ws = tmp_workspace();
-    let _ = app_call(&ws, "alpha", "bravo");
-    let lines = app_events(&ws);
-    assert_eq!(lines.len(), 1, "exactly one event per call; got {lines:?}");
-    let v: serde_json::Value = serde_json::from_str(&lines[0]).expect("event line must be json");
-    let ts = v["ts"].as_str().expect("event has string ts").to_string();
-    let expected = format!(
-        "{{\"a\": \"alpha\", \"b\": \"bravo\", \"event\": \"communication.peer_allowed\", \"ts\": \"{ts}\"}}"
-    );
-    assert_eq!(
-        lines[0], expected,
-        "golden events.py:35 json.dumps(...,sort_keys=True) line: sorted keys a,b,event,ts with \
-         Python `, `/`: ` spacing; got {}",
-        lines[0]
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── idempotency: identical return, event fires on EVERY call (rows are insert-or-ignore) ──
-#[test]
-fn allow_peer_talk_is_idempotent_and_fires_event_per_call() {
-    let ws = tmp_workspace();
-    let v1 = app_out(app_call(&ws, "alpha", "bravo"));
-    let v2 = app_out(app_call(&ws, "alpha", "bravo")); // duplicate pair
-    assert_eq!(
-        v1, v2,
-        "repeated allow returns identical compat_noop output"
-    );
-    let lines = app_events(&ws);
-    assert_eq!(
-        lines.len(),
-        2,
-        "golden fires communication.peer_allowed on EVERY call (event NOT deduped; only DB rows \
-         are insert-or-ignore); got {lines:?}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── permissive: undeclared/unknown agents still succeed (golden has NO validation path) ──
-#[test]
-fn allow_peer_talk_unknown_agents_succeed_no_validation() {
-    let ws = tmp_workspace(); // no state.json / no spec: agents never declared
-    let r = app_call(&ws, "ghost", "phantom-x");
-    assert_eq!(
-        r.exit,
-        ExitCode::Ok,
-        "golden leader.py:25-28 never validates agent ids -> no error, exit 0"
-    );
-    let v = app_out(r);
-    assert_eq!(
-        v,
-        json!({
-            "ok": true,
-            "a": "ghost",
-            "b": "phantom-x",
-            "status": "compat_noop",
-            "reason": "team_scoped_peer_messages_enabled"
-        }),
-        "unknown agents still get compat_noop (no unknown-agent error string/exit); got {v:?}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-#[test]
-fn allow_peer_talk_explicit_team_is_rejected_until_backend_is_scoped() {
-    let ws = tmp_workspace();
-    let err = cmd_allow_peer_talk(&AllowPeerTalkArgs {
-        a: "alpha".to_string(),
-        b: "bravo".to_string(),
-        workspace: ws.clone(),
-        json: true,
-        team: Some("current".to_string()),
-    })
-    .expect_err("explicit --team must not silently write the global peer allowlist");
-    assert!(
-        err.to_string().contains("not supported yet"),
-        "allow-peer-talk --team must be an explicit refusal until backend supports scoped writes; got {err}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}