@team-agent/installer 0.3.3 → 0.3.5

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.3"
+version = "0.3.5"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.3"
+version = "0.3.5"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -1490,6 +1490,14 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
     if args.fix && args.gate.is_none() {
         return Err(CliError::Runtime("--fix requires --gate".to_string()));
     }
+    // swallow batch 3 ①: an unknown gate refuses explicitly (Python commands.py:234-235
+    // `unknown doctor gate`), never an empty default-doctor green.
+    if let Some(DoctorGate::Unknown(raw)) = &args.gate {
+        return Ok(CmdResult::from_json(
+            serde_json::json!({"ok": false, "status": "unknown_gate", "gate": raw}),
+            args.json,
+        ));
+    }
     if args.comms || matches!(args.gate, Some(DoctorGate::Comms)) {
         let value = crate::diagnose::comms::doctor_comms_json(&args.workspace, args.team.as_deref(), Some("comms"))?;
         if !args.json {

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

@@ -115,7 +115,7 @@ pub(crate) fn build_preflight_report(team: &std::path::Path) -> Result<Value, Cl
     let display_backend = compiled
         .as_ref()
         .and_then(|spec| yaml_path_str(spec, &["runtime", "display_backend"]))
-        .unwrap_or("adaptive");
+        .unwrap_or("none");
     let ghostty_required = display_backend == "ghostty_window" || display_backend == "ghostty";
     let ghostty_path = command_path("ghostty");
     checks.push(json!({
@@ -289,21 +289,46 @@ fn copy_optional_field(from: &Value, to: &mut Value, key: &str) {
 }
 
 pub(crate) fn build_wait_ready_report(workspace: &std::path::Path, timeout: f64) -> Result<Value, CliError> {
-    let selected = crate::state::selector::resolve_active_team(
+    // swallow batch 3 ③: an unreadable runtime state must never read as "ready" — the
+    // read error is surfaced verbatim (state_read_error) with ready=false instead of
+    // silently degrading to an empty/stale state.
+    let selected = match crate::state::selector::resolve_active_team(
         workspace,
         None,
         crate::state::selector::SelectorMode::RuntimeOnly,
-    )
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    ) {
+        Ok(selected) => selected,
+        Err(error) => {
+            return Ok(json!({
+                "ok": false,
+                "status": "error",
+                "reason": "state_read_error",
+                "state_read_error": error.to_string(),
+                "readiness": {"ready": false},
+                "summary": "runtime state could not be read",
+                "next_actions": [json!("inspect .team/runtime/state.json (corrupt or unreadable) and retry")],
+            }));
+        }
+    };
     let timeout = if timeout.is_finite() && timeout > 0.0 { timeout } else { 0.0 };
     let deadline = std::time::Instant::now() + std::time::Duration::from_secs_f64(timeout);
     let mut readiness;
+    let mut state_read_error: Option<String> = None;
     loop {
-        let mut state = crate::state::projection::select_runtime_state(
+        let mut state = match crate::state::projection::select_runtime_state(
             &selected.run_workspace,
             Some(&selected.team_key),
-        )
-        .unwrap_or_else(|_| selected.state.clone());
+        ) {
+            Ok(state) => {
+                state_read_error = None;
+                state
+            }
+            Err(error) => {
+                state_read_error = Some(error.to_string());
+                readiness = json!({"ready": false, "state_read_error": error.to_string()});
+                break;
+            }
+        };
         inject_tmux_session_present(&selected.run_workspace, &mut state);
         inject_message_counts(&selected.run_workspace, &mut state)?;
         readiness = wait_readiness(&state);
@@ -322,7 +347,15 @@ pub(crate) fn build_wait_ready_report(workspace: &std::path::Path, timeout: f64)
         .and_then(Value::as_bool)
         == Some(true);
     let ready = readiness.get("ready").and_then(Value::as_bool) == Some(true);
-    let (ok, status, reason, summary, next_actions) = if awaiting_trust {
+    let (ok, status, reason, summary, next_actions) = if state_read_error.is_some() {
+        (
+            false,
+            "error",
+            "state_read_error",
+            "runtime state could not be read",
+            vec![json!("inspect .team/runtime/state.json (corrupt or unreadable) and retry")],
+        )
+    } else if awaiting_trust {
         (
             false,
             "pending",
@@ -360,7 +393,7 @@ pub(crate) fn build_wait_ready_report(workspace: &std::path::Path, timeout: f64)
             "readiness": readiness,
         }),
     )?;
-    Ok(json!({
+    let mut report = json!({
         "details_log": details_log.to_string_lossy().to_string(),
         "next_actions": next_actions,
         "ok": ok,
@@ -368,7 +401,11 @@ pub(crate) fn build_wait_ready_report(workspace: &std::path::Path, timeout: f64)
         "readiness": readiness,
         "status": status,
         "summary": summary,
-    }))
+    });
+    if let Some(error) = state_read_error {
+        report["state_read_error"] = json!(error);
+    }
+    Ok(report)
 }
 
 fn inject_tmux_session_present(workspace: &std::path::Path, state: &mut Value) {
@@ -392,10 +429,12 @@ pub(crate) fn wait_readiness(state: &Value) -> Value {
     let mut task_prompt_delivered = false;
     let mut awaiting_trust_prompt = false;
     let mut incomplete_sessions = Vec::new();
+    // A-5: a missing/unreadable leader_receiver must NOT count as attached —
+    // "unreadable is never ready" (doctor/wait-ready truthfulness rule).
     let all_attached_receiver = state
         .get("leader_receiver")
         .and_then(Value::as_object)
-        .is_none_or(|receiver| {
+        .is_some_and(|receiver| {
             receiver
                 .get("status")
                 .and_then(Value::as_str)
@@ -673,6 +712,7 @@ fn provider_wire(provider: crate::provider::Provider) -> &'static str {
         crate::provider::Provider::Claude => "claude",
         crate::provider::Provider::ClaudeCode => "claude_code",
         crate::provider::Provider::Codex => "codex",
+        crate::provider::Provider::Copilot => "copilot",
         crate::provider::Provider::GeminiCli => "gemini_cli",
         crate::provider::Provider::Fake => "fake",
     }
@@ -682,6 +722,7 @@ fn provider_command(provider: crate::provider::Provider) -> &'static str {
     match provider {
         crate::provider::Provider::Claude | crate::provider::Provider::ClaudeCode => "claude",
         crate::provider::Provider::Codex => "codex",
+        crate::provider::Provider::Copilot => "copilot",
         crate::provider::Provider::GeminiCli => "gemini",
         crate::provider::Provider::Fake => "team-agent fake-worker",
     }

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

@@ -200,7 +200,7 @@ fn command_help(command: Option<&str>) -> String {
             )
         }
         Some("init") => "usage: team-agent init [--workspace WORKSPACE] [--force] [--json]".to_string(),
-        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--fresh] [--json]".to_string(),
+        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--fresh] [--json]\n\ndefaults: display_backend=none; set display_backend: adaptive in TEAM.md to opt in to adaptive display windows.".to_string(),
         Some("start") => "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]".to_string(),
         Some("compile") => "usage: team-agent compile --team TEAM [--out FILE] [--json]".to_string(),
         Some("send") => "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]".to_string(),
@@ -963,7 +963,8 @@ fn doctor_gate(raw: Option<&str>) -> Option<DoctorGate> {
     match raw {
         Some("orphans") => Some(DoctorGate::Orphans),
         Some("comms") => Some(DoctorGate::Comms),
-        _ => None,
+        Some(other) => Some(DoctorGate::Unknown(other.to_string())),
+        None => None,
     }
 }