@team-agent/installer 0.5.111 → 0.5.113

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

@@ -51,6 +51,7 @@ pub mod argv_route;
 /// 0.5.66 bypass 单源:provider → bypass argv flag 配置表(唯一权威)。
 pub(crate) mod bypass_flags;
 pub mod classify;
+pub(crate) mod command_helpers;
 pub mod faults;
 pub mod model_catalog;
 pub mod session;

package/crates/team-agent/src/provider/model_catalog.rs

@@ -9,6 +9,7 @@ use std::sync::mpsc;
 use std::time::{Duration, Instant};
 
 use crate::model::enums::Provider;
+use crate::provider::wire::{parse_canonical_provider, provider_wire};
 
 const CATALOG_TIMEOUT: Duration = Duration::from_secs(10);
 const MAX_CATALOG_BYTES: u64 = 1024 * 1024;
@@ -126,29 +127,7 @@ fn display_provider(provider: &str) -> &str {
 
 /// Only the documented catalog names are accepted; launch aliases stay unchanged.
 pub fn parse_catalog_provider(name: &str) -> Option<Provider> {
-    match name {
-        "pi" => Some(Provider::Pi),
-        "cursor_agent" => Some(Provider::CursorAgent),
-        "codex" => Some(Provider::Codex),
-        "claude" => Some(Provider::Claude),
-        "claude_code" => Some(Provider::ClaudeCode),
-        "grok" => Some(Provider::Grok),
-        _ => None,
-    }
-}
-
-fn provider_wire_name(provider: Provider) -> &'static str {
-    match provider {
-        Provider::Pi => "pi",
-        Provider::CursorAgent => "cursor_agent",
-        Provider::Codex => "codex",
-        Provider::Claude => "claude",
-        Provider::ClaudeCode => "claude_code",
-        Provider::Copilot => "copilot",
-        Provider::GeminiCli => "gemini_cli",
-        Provider::Grok => "grok",
-        Provider::Fake => "fake",
-    }
+    parse_canonical_provider(name).filter(|provider| catalog_source(*provider).is_some())
 }
 
 #[derive(Clone, Copy)]
@@ -175,7 +154,7 @@ fn catalog_source(provider: Provider) -> Option<CatalogSource> {
 pub fn discover_model_catalog(provider_name: &str) -> Result<Vec<ModelRecord>, CatalogError> {
     let provider = parse_catalog_provider(provider_name).ok_or(CatalogError::UnsupportedProvider)?;
     let source = catalog_source(provider).ok_or(CatalogError::UnsupportedProvider)?;
-    let requested_provider = provider_wire_name(provider);
+    let requested_provider = provider_wire(provider);
     let records = match source {
         CatalogSource::Pi => {
             let bytes = run_native("pi", &["--list-models"], None, None, &[], CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut NoopObserver)?;
@@ -881,10 +860,24 @@ mod tests {
 
     #[test]
     fn provider_capability_is_explicit_and_exact() {
-        assert_eq!(parse_catalog_provider("claude_code"), Some(Provider::ClaudeCode));
-        assert_eq!(parse_catalog_provider("cloud"), None);
-        assert!(catalog_source(Provider::Codex).is_some());
-        assert!(catalog_source(Provider::Fake).is_none());
+        for (name, provider) in [
+            ("pi", Provider::Pi),
+            ("cursor_agent", Provider::CursorAgent),
+            ("codex", Provider::Codex),
+            ("claude", Provider::Claude),
+            ("claude_code", Provider::ClaudeCode),
+            ("grok", Provider::Grok),
+        ] {
+            assert_eq!(parse_catalog_provider(name), Some(provider));
+            assert_eq!(provider_wire(provider), name);
+            assert!(catalog_source(provider).is_some());
+        }
+        for name in ["", "cloud", "cursor", "agent", "claude-code", "copilot", "gemini_cli", "fake", "Pi", "CODEX", " pi", "pi ", "pi/model", "codex:model", "claude_code_extra"] {
+            assert_eq!(parse_catalog_provider(name), None);
+        }
+        for provider in [Provider::Copilot, Provider::GeminiCli, Provider::Fake] {
+            assert!(catalog_source(provider).is_none());
+        }
     }
 
     #[test]

package/crates/team-agent/src/provider/tests/adapter.rs

@@ -1,3 +1,73 @@
+#[test]
+fn trimmed_provider_builders_preserve_fresh_and_resume_argv() {
+    for (provider, base) in [
+        (
+            Provider::Grok,
+            vec!["grok", "--model", "test-model", "--rules", "role"],
+        ),
+        (
+            Provider::CursorAgent,
+            vec!["agent", "--model", "test-model", "--workspace", "{workspace}"],
+        ),
+        (
+            Provider::Copilot,
+            vec![
+                "copilot", "--no-color", "--no-auto-update", "--no-remote",
+                "--disable-builtin-mcps", "--allow-tool", "team_orchestrator",
+                "--model", "test-model",
+            ],
+        ),
+    ] {
+        let adapter = get_adapter(provider);
+        let ctx = ProviderCommandContext {
+            auth_mode: AuthMode::Subscription,
+            mcp_config: None,
+            system_prompt: Some("role"),
+            model: Some("test-model"),
+            dangerously_skip_permissions: false,
+            profile_launch: None,
+            agent_id_hint: Some("worker"),
+            effort: None,
+        };
+        let mut expected = base.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+        let fresh = adapter.build_command_plan(ctx).expect("fresh plan");
+        if provider != Provider::CursorAgent {
+            expected.push("--session-id".to_string());
+            expected.push(
+                fresh.expected_session_id.as_ref().expect("session hint").as_str().to_string(),
+            );
+        } else {
+            assert!(fresh.expected_session_id.is_none());
+        }
+        assert_eq!(fresh.argv, expected, "{provider:?} fresh argv");
+        let session = SessionId::new("existing-session");
+        let mut expected = base.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+        expected.extend(["--resume".to_string(), session.as_str().to_string()]);
+        assert_eq!(
+            adapter
+                .build_resume_command_plan(Some(&session), ctx)
+                .expect("resume plan")
+                .argv,
+            expected,
+            "{provider:?} resume argv"
+        );
+        if provider == Provider::CursorAgent {
+            let mut expected = base.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+            expected.insert(1, "--resume".to_string());
+            expected.insert(2, session.as_str().to_string());
+            assert_eq!(
+                adapter
+                    .build_resume_command_with_context(
+                        Some(&session), ctx.auth_mode, None, ctx.system_prompt, ctx.model, false,
+                    )
+                    .expect("legacy resume"),
+                expected,
+                "legacy Cursor resume must retain its distinct flag order"
+            );
+        }
+    }
+}
+
 #[test]
 fn abnormal_dedup_key_uses_signature_and_optional_turn_id() {
     // probe(/tmp/probe_idle.py read_fault_facts): the C8 dedup key is

package/crates/team-agent/src/provider/tests/command_helpers.rs

@@ -0,0 +1,55 @@
+//! Exact argv characterization: no helper may trim, escape or reorder caller values.
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+use super::*;
+use crate::model::enums::ProviderEffort;
+use crate::provider::adapters::{claude, codex, copilot, cursor_agent, grok, pi};
+use crate::provider::ProviderCommandOverrides;
+
+#[test]
+fn command_helpers_keep_provider_argv_bytes_and_order() {
+    let raw = " \"'\\\n ";
+    let mcp = McpConfig { raw: serde_json::json!({}) };
+    assert_eq!(claude::claude_base_command(
+        &BasicProviderAdapter { provider: Provider::Claude }, AuthMode::Subscription,
+        Some(&mcp), Some(raw), Some(""), false, false, Some(ProviderEffort::High),
+    ).expect("claude"), ["claude", "--permission-mode", "default", "--model", "", "--effort", "high", "--append-system-prompt", raw, "--mcp-config", "{\"mcpServers\":{}}"]);
+
+    let overrides = ProviderCommandOverrides {
+        codex_profile: Some("".to_string()),
+        codex_config: vec!["model_reasoning_effort=low".to_string()],
+        ..Default::default()
+    };
+    assert_eq!(codex::codex_base_command(
+        Some("resume"), AuthMode::Subscription, Some(&mcp), Some(raw), Some(""),
+        true, Some(&overrides), Some(ProviderEffort::Max),
+    ), ["codex", "resume", "--no-alt-screen", "--disable", "shell_snapshot", "--disable", "apps", "--profile", "", "--dangerously-bypass-approvals-and-sandbox", "--model", "", "-c", "model_reasoning_effort=low", "-c", "model_reasoning_effort=max", "-c", "developer_instructions=\" \\\"'\\\\\\n \""]);
+
+    assert_eq!(copilot::copilot_base_command(
+        AuthMode::Subscription, Some(&mcp), Some(raw), Some(""), true,
+    ), ["copilot", "--no-color", "--no-auto-update", "--no-remote", "--disable-builtin-mcps", "--allow-all", "--allow-tool", "team_orchestrator", "--model", "", "--additional-mcp-config", "{}"]);
+    assert_eq!(cursor_agent::cursor_agent_base_command(Some(raw), true).expect("cursor"),
+        ["agent", "--trust", "--sandbox", "disabled", "--force", "--model", raw, "--workspace", "{workspace}"]);
+    assert_eq!(grok::grok_base_command(Some(raw), Some("  model-id  "), true, Some(ProviderEffort::Medium)).expect("grok"),
+        ["grok", "--always-approve", "--model", "model-id", "--effort", "medium", "--rules", raw]);
+    assert_eq!(grok::grok_base_command(Some(""), Some("  "), false, None).expect("grok empty"), ["grok", "--rules", ""]);
+    assert_eq!(pi::build_pi_command_argv(pi::PiCommandRequest {
+        extension: std::path::Path::new("extension.ts"), model: Some("vendor/model"),
+        effort: Some(ProviderEffort::XHigh), system_prompt: raw,
+        session_dir: Some(std::path::Path::new("sessions")),
+        session: pi::PiSessionSelector::Fresh { session_id: "session-id" }, agent_id: "worker",
+    }).expect("pi"), ["pi", "-e", "extension.ts", "--model", "vendor/model", "--thinking", "xhigh", "--append-system-prompt", raw, "--session-dir", "sessions", "--session-id", "session-id", "--name", "worker"]);
+}
+
+#[test]
+fn command_helpers_keep_absent_options_and_safe_defaults() {
+    assert_eq!(claude::claude_base_command(
+        &BasicProviderAdapter { provider: Provider::Claude }, AuthMode::Subscription,
+        None, None, None, false, false, None,
+    ).expect("claude"), ["claude", "--permission-mode", "default"]);
+    assert_eq!(codex::codex_base_command(None, AuthMode::Subscription, None, None, None, false, None, None),
+        ["codex", "--no-alt-screen", "--disable", "shell_snapshot", "--disable", "apps"]);
+    assert_eq!(copilot::copilot_base_command(AuthMode::Subscription, None, None, None, false),
+        ["copilot", "--no-color", "--no-auto-update", "--no-remote", "--disable-builtin-mcps", "--allow-tool", "team_orchestrator"]);
+    assert_eq!(cursor_agent::cursor_agent_base_command(None, false).expect("cursor"), ["agent", "--workspace", "{workspace}"]);
+    assert_eq!(grok::grok_base_command(None, None, false, None).expect("grok"), ["grok"]);
+}

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.111",
+  "version": "0.5.113",
   "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.111",
-    "@team-agent/cli-darwin-x64": "0.5.111",
-    "@team-agent/cli-linux-x64": "0.5.111"
+    "@team-agent/cli-darwin-arm64": "0.5.113",
+    "@team-agent/cli-darwin-x64": "0.5.113",
+    "@team-agent/cli-linux-x64": "0.5.113"
   },
   "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);
-}

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

@@ -1,195 +0,0 @@
-use super::*;
-
-const VALIDATE_SPEC_TEMPLATE: &str = r#"version: 1
-team:
-  name: "fake-e2e"
-  mode: "supervisor_worker"
-  objective: "Exercise validate."
-  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"
-      - "fs_write"
-      - "fs_list"
-      - "execute_bash"
-      - "git_diff"
-      - "mcp_team"
-      - "provider_builtin"
-    dangerously_skip_permissions: false
-    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"
-  session_name: "team-agent-fake-e2e"
-  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 write_validate_spec(
-    ws: &std::path::Path,
-    file_name: &str,
-    provider: &str,
-) -> std::path::PathBuf {
-    let spec = VALIDATE_SPEC_TEMPLATE
-        .replace("__WS__", &ws.to_string_lossy())
-        .replacen(
-            "provider: \"fake\"",
-            &format!("provider: \"{provider}\""),
-            1,
-        );
-    let path = ws.join(file_name);
-    std::fs::write(&path, spec).unwrap();
-    path
-}
-
-// Golden source:
-// - cli/parser.py:120-123 registers `validate [spec=team.spec.yaml] --json`.
-// - cli/commands.py:38-39 delegates to `runtime.validate_file(Path(args.spec).resolve())`.
-// - launch/bootstrap.py:30-43: file specs return `{ok: True, workspace: str(workspace), team: name}`.
-// - cli/helpers.py:12-16 JSON emits `json.dumps(..., indent=2, ensure_ascii=False, sort_keys=True)`.
-//
-// Golden probe:
-//   PYTHONPATH=/Users/alauda/Documents/code/team-agent-public/src python3 /tmp/probe_validate_cli.py
-//   valid file --json rc=0 stdout:
-//   {
-//     "ok": true,
-//     "team": "fake-e2e",
-//     "workspace": "<ws>"
-//   }
-#[test]
-fn validate_valid_spec_file_json_byte_shape() {
-    let ws = tmp_workspace();
-    let spec_path = write_validate_spec(&ws, "team.spec.yaml", "fake");
-
-    let result = cmd_validate(&ValidateArgs {
-        spec: spec_path.clone(),
-        json: true,
-    })
-    .expect("valid spec must return an ok CmdResult");
-
-    assert_eq!(result.exit, ExitCode::Ok);
-    assert_eq!(
-        emit(&result.output, true).unwrap(),
-        format!(
-            "{{\n  \"ok\": true,\n  \"team\": \"fake-e2e\",\n  \"workspace\": \"{}\"\n}}",
-            ws.to_string_lossy()
-        ),
-        "validate --json must match Python sort_keys+indent bytes for a valid file spec",
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// Golden source:
-// - spec.py:85-91 accumulates validation messages and raises
-//   `team.spec.yaml validation failed:\n- ...`.
-// - spec.py semantic provider check emits `/leader/provider: unknown provider 'bogus'`.
-// - cli/helpers.py:137-155 error payload insertion order is `ok,error,action,log`.
-// - cli/helpers.py:128-131 prints compact JSON, not pretty/sorted JSON, for `--json` errors.
-#[test]
-fn validate_invalid_spec_json_error_envelope_byte_shape() {
-    let ws = tmp_workspace();
-    let spec_path = write_validate_spec(&ws, "bad.spec.yaml", "bogus");
-
-    let err = cmd_validate(&ValidateArgs {
-        spec: spec_path,
-        json: true,
-    })
-    .expect_err("invalid spec must surface a CLI/runtime validation error");
-
-    assert_eq!(
-        err.to_string(),
-        "team.spec.yaml validation failed:\n- /leader/provider: unknown provider 'bogus'",
-    );
-    let payload = err.to_payload(&ws.join(".team/logs/cli-error-123.log"), "validate");
-    assert_eq!(
-        serde_json::to_string(&payload).unwrap(),
-        format!(
-            "{{\"ok\":false,\"error\":\"team.spec.yaml validation failed:\\n- /leader/provider: unknown provider 'bogus'\",\"action\":\"run `team-agent doctor` or inspect the log path shown here\",\"log\":\"{}\"}}",
-            ws.join(".team/logs/cli-error-123.log").to_string_lossy()
-        ),
-        "validate --json errors must match Python compact error envelope key order and text",
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// Golden source:
-// - cli/parser.py:120-123 default spec argument is `team.spec.yaml`.
-// Current Rust dispatch has no `validate` arm; this must be RED until the porter routes it.
-#[test]
-fn dispatch_routes_validate_default_spec() {
-    let ws = tmp_workspace();
-    let _spec_path = write_validate_spec(&ws, "team.spec.yaml", "fake");
-    let code = run(&["validate".to_string(), "--json".to_string()], &ws);
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "`validate --json` must route and exit 0 for default team.spec.yaml"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}