@team-agent/installer 0.5.110 → 0.5.112

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

@@ -144,155 +144,12 @@ fn seed_leader_registry_entry(ws: &std::path::Path) {
     );
 }
 
-// =========================================================================
-// WAVE-2 NON-SUB CHECKPOINT — missing CLI subcommands (ABSENT from cli/emit.rs dispatch).
-// emit.rs `dispatch` has NO arm for sessions, peek, collect, e2e, diagnose,
-// preflight, wait-ready -> they fall to `_ => Ok(ExitCode::Error)`. These REDs
-// assert the dispatch ROUTES each subcommand: `run([sub,...]) == ExitCode::Ok` for a golden
-// EXIT-0 scenario (today unrouted -> ExitCode::Error -> RED; green once the porter adds the
-// dispatch arm + handler). Golden exit codes + JSON shapes probed via `python3 -m team_agent <sub>`.
-//
-// OBSERVABILITY NOTE: `run()` exposes only ExitCode (Ok=0/Error=1); it prints via println!, which
-// libtest intercepts (thread-local capture), so an fd-level stdout byte-capture is unreliable
-// under `cargo test`. The exact golden --json byte-shape is therefore LOCKED in each doc-comment
-// as the porter's parity obligation; the in-process assertion is the routing (exit code). A
-// follow-up can byte-lock output once each handler exists as a callable `cmd_*`/`*_port` symbol.
-//
-// Only golden-EXIT-0, tmux-SAFE scenarios make a clean RED (an exit-1 scenario's Error is
-// indistinguishable from the unknown-subcommand Error -> false-green, forbidden). preflight/
-// wait-ready/e2e/peek cannot reach golden-exit-0 on CI without real tmux/providers/a live team,
-// so they are #[ignore] real-effect seams (documented shape), NOT false-green exit-1 asserts.
-// =========================================================================
+// Retained doctor dispatch and shared status-readiness contracts.
 
 fn cli_argv(items: &[&str]) -> Vec<String> {
     items.iter().map(|s| (*s).to_string()).collect()
 }
 
-/// The exact golden fake spec (cli/e2e.py `_fake_spec`, dumped via simple_yaml) with the literal
-/// `/WS` placeholder substituted to the real workspace — the minimal VALID team.spec.yaml that
-/// `collect` accepts. (load_spec rejects partial specs: requires
-/// communication/context/leader/routing/runtime/tasks.)
-const FAKE_SPEC_YAML: &str = r#"version: 1
-team:
-  name: "fake-e2e"
-  mode: "supervisor_worker"
-  objective: "Exercise fake provider orchestration."
-  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"
-    permission_mode: "restricted"
-    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"
-    requires_tools:
-      - "fs_write"
-      - "execute_bash"
-    files:
-      - "src/example.py"
-    risk: "low"
-"#;
-
-fn seed_team_spec(ws: &std::path::Path) {
-    let spec = FAKE_SPEC_YAML.replace("/WS", &ws.to_string_lossy());
-    std::fs::write(ws.join("team.spec.yaml"), spec).unwrap();
-}
-
-// ── sessions ── golden cli/parser.py:230 `cmd_sessions` -> runtime.sessions(ws). EXIT 0.
-// `team-agent sessions --workspace <ws> --json` on an empty ws ->
-//   {"ok":true,"sessions":[],"workspace":"<ws>"}  (--json sort_keys). RED: unrouted -> Error.
-#[test]
-fn dispatch_routes_sessions_subcommand() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&["sessions", "--workspace", &ws.to_string_lossy(), "--json"]),
-        &ws,
-    );
-    assert_eq!(
-            code,
-            ExitCode::Ok,
-            "`sessions` must ROUTE to cmd_sessions (golden parser.py:230, exit 0 {{ok,sessions,workspace}}); \
-             today it falls to the unknown-subcommand arm (emit.rs:77) -> Error"
-        );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
 // ── diagnose ── attached is host-registry authority, not state.json self-sign.
 // Seed leader_receiver=attached + a ~/.team-agent/leaders/ row for this workspace
 // + NO session_name + NO agents -> issues=[] -> EXIT 0.
@@ -389,120 +246,6 @@ fn dispatch_routes_diagnose_self_signed_attached_without_registry_is_not_ok() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
-// ── preflight (#[ignore] real-machine) ── golden parser.py:160 `cmd_preflight` -> runtime.preflight
-// (Path(args.team)). Validates a team role-doc dir: checks compile(TEAM.md)/tmux/ghostty/rust_core/
-// profile_dir; golden -> {"blockers":[...],"checks":[...],"details_log":...,"next_actions":[...],
-// "ok":bool,"summary":...}. Reaches ok:true (exit 0) ONLY with a valid TEAM.md + ghostty installed,
-// which CI cannot supply (ghostty absent -> blocker) -> not a clean in-process exit-0 RED.
-#[test]
-#[ignore = "real-machine: `preflight --team <dir>` needs a valid TEAM.md role-doc dir + ghostty to \
-                reach ok:true; on CI it golden-exits 1 (compile/ghostty blockers) which is \
-                indistinguishable from the unknown-subcommand Error (false-green). Routes to cmd_preflight \
-                (parser.py:160); shape {blockers,checks,details_log,next_actions,ok,summary}"]
-fn dispatch_routes_preflight_real_machine() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&["preflight", "--team", &ws.to_string_lossy(), "--json"]),
-        &ws,
-    );
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "preflight must ROUTE + exit 0 on a valid team dir"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── wait-ready (#[ignore] real-machine) ── golden parser.py:171 `cmd_wait_ready` -> runtime.wait_ready
-// (ws, timeout). Polls worker readiness; golden -> {"details_log":...,"next_actions":[...],"ok":bool,
-// "readiness":{cli_prompt_ready,mcp_ready,process_started,task_prompt_delivered},"summary":...}.
-// ok:true (exit 0) needs a LIVE ready team; CI has none -> golden-exits 1 (false-green vs unknown).
-#[test]
-#[ignore = "real-machine: `wait-ready` polls a LIVE team's readiness; with no workers golden-exits 1 \
-                (false-green vs unknown-subcommand Error). Routes to cmd_wait_ready (parser.py:171); shape \
-                {details_log,next_actions,ok,readiness{cli_prompt_ready,mcp_ready,process_started,task_prompt_delivered},summary}"]
-fn dispatch_routes_wait_ready_real_machine() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&[
-            "wait-ready",
-            "--workspace",
-            &ws.to_string_lossy(),
-            "--timeout",
-            "1",
-            "--json",
-        ]),
-        &ws,
-    );
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "wait-ready must ROUTE + exit 0 once the team is ready"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── e2e --providers fake (#[ignore] real-machine) ── golden parser.py:449 `cmd_e2e` (cli/e2e.py:12).
-// `--providers fake` runs a REAL end-to-end: runtime.launch(spec, auto_approve=True) (spawns a tmux
-// team) -> send_message -> sleep -> collect -> shutdown. Result envelope (e2e.py:16,48-56):
-//   {"workspace":str,"providers":{"fake":{"ok":bool,"launch":{...},"send":{...},"collect":{...},
-//    "shutdown":{...}}},"ok":bool}. Real tmux spawn -> #[ignore] (NOT runnable in-process).
-#[test]
-#[ignore = "real-machine: `e2e --providers fake` calls runtime.launch -> spawns a REAL tmux team \
-                (send/collect/shutdown). Routes to cmd_e2e (parser.py:449 / e2e.py:12); envelope \
-                {workspace,providers:{fake:{ok,launch,send,collect,shutdown}},ok}"]
-fn dispatch_routes_e2e_fake_real_machine() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&[
-            "e2e",
-            "--providers",
-            "fake",
-            "--workspace",
-            &ws.to_string_lossy(),
-            "--json",
-        ]),
-        &ws,
-    );
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "e2e --providers fake must ROUTE + run the fake end-to-end (ok:true)"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── peek (#[ignore] real-machine) ── golden parser.py:201 `cmd_peek` (commands.py:118). Requires
-// `--allow-raw-screen` (else TeamAgentError) + a mutually-exclusive --head/--tail/--search; then
-// runtime.peek captures a LIVE tmux pane (tmux capture-pane). Real tmux -> #[ignore]. Routes to
-// cmd_peek; --json returns the peek dict (text + capture metadata).
-#[test]
-#[ignore = "real-machine: `peek <agent> --tail N --allow-raw-screen` captures a LIVE tmux pane \
-                (tmux capture-pane); needs a running worker pane. Routes to cmd_peek (parser.py:201); \
-                --json returns the peek dict (raw screen text + metadata)"]
-fn dispatch_routes_peek_real_machine() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&[
-            "peek",
-            "fake_impl",
-            "--workspace",
-            &ws.to_string_lossy(),
-            "--tail",
-            "20",
-            "--allow-raw-screen",
-            "--json",
-        ]),
-        &ws,
-    );
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "peek must ROUTE + capture the live pane (real machine)"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
 // CONTRACT (shared-root, real-machine-driven; golden = correct-behavior baseline): wait_readiness
 // derives cli_prompt_ready from the LIFECYCLE status — an alive worker (status="running") IS
 // cli_prompt_ready (golden quick_start.py:173 `status ∈ {running, busy}`). Rust (diagnose.rs:280)

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

@@ -129,11 +129,9 @@ mod leader_watch;
 mod main_preserved;
 mod missing_subcommands;
 mod named_address;
-mod peer_allow;
 mod run_delegation;
 mod shutdown_kill_plan;
 mod status_brief;
 mod status_send;
 mod verb_install_skill;
 mod verb_profile;
-mod verb_validate;

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

@@ -248,12 +248,9 @@ fn resolve_qualified_name_prefers_unique_state_pane_over_same_window_idle_pane()
         pane("team-a", "qa", "%idle"),
     ]);
 
-    let resolved = resolve_name_with_transport(
-        &ws,
-        &format!("{}::team-a/qa", ws.display()),
-        &transport,
-    )
-    .expect("a qualified worker address should use its unique state pane");
+    let resolved =
+        resolve_name_with_transport(&ws, &format!("{}::team-a/qa", ws.display()), &transport)
+            .expect("a qualified worker address should use its unique state pane");
     assert_eq!(resolved.pane_id, "%worker");
     assert_eq!(resolved.state_pane_id.as_deref(), Some("%worker"));
     assert!(!resolved.state_pane_stale);
@@ -271,11 +268,17 @@ fn resolve_qualified_name_state_pane_must_uniquely_match_scoped_candidates() {
                     .as_object_mut()
                     .unwrap()
                     .remove("pane_id");
-                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+                vec![
+                    pane("team-a", "qa", "%worker"),
+                    pane("team-a", "qa", "%idle"),
+                ]
             }
             "stale" => {
                 team["agents"]["qa"]["pane_id"] = json!("%stale");
-                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+                vec![
+                    pane("team-a", "qa", "%worker"),
+                    pane("team-a", "qa", "%idle"),
+                ]
             }
             "cross-session" => vec![
                 pane("old-team-a", "qa", "%worker"),
@@ -293,12 +296,9 @@ fn resolve_qualified_name_state_pane_must_uniquely_match_scoped_candidates() {
         };
         seed_state(&ws, state_with_teams(json!({"team-a": team})));
         let transport = OfflineTransport::new().with_targets(targets);
-        let err = resolve_name_with_transport(
-            &ws,
-            &format!("{}::team-a/qa", ws.display()),
-            &transport,
-        )
-        .expect_err("non-unique state pane evidence must remain fail-closed");
+        let err =
+            resolve_name_with_transport(&ws, &format!("{}::team-a/qa", ws.display()), &transport)
+                .expect_err("non-unique state pane evidence must remain fail-closed");
         assert_eq!(err.kind, NamedAddressErrorKind::NameAmbiguous, "{scenario}");
         let _ = std::fs::remove_dir_all(&ws);
     }
@@ -313,11 +313,8 @@ fn resolve_qualified_name_canonicalizes_legacy_session_alias() {
             "teamdir": worker_team("team-displayname", "qa", "%1", "qa")
         })),
     );
-    let transport = OfflineTransport::new().with_targets(vec![pane(
-        "team-displayname",
-        "qa",
-        "%1",
-    )]);
+    let transport =
+        OfflineTransport::new().with_targets(vec![pane("team-displayname", "qa", "%1")]);
 
     let resolved = resolve_name_with_transport(&ws, "displayname/qa", &transport)
         .expect("qualified legacy alias must resolve through the canonical selector");
@@ -380,21 +377,21 @@ fn send_to_name_mutual_exclusion() {
     let args = named_send_args(&cwd, Some("team-a/qa"), Some("%1"), None, &["hello"]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message.contains("--to-name and --pane/TARGET/--to are mutually exclusive")),
+        matches!(err, CliError::Usage(ref message) if message.contains("--to-name/--pane/--to") && message.contains("不能同时")),
         "expected --to-name mutual exclusion, got {err:?}"
     );
 
     let args = named_send_args(&cwd, Some("team-a/qa"), None, Some("worker"), &["hello"]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message.contains("--to-name and --pane/TARGET/--to are mutually exclusive")),
+        matches!(err, CliError::Usage(ref message) if message.contains("--to-name/--pane/--to") && message.contains("不能同时")),
         "expected --to-name/--to mutual exclusion, got {err:?}"
     );
 
     let args = named_send_args(&cwd, Some("team-a/qa"), None, None, &[]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message == "--to-name requires a non-empty message"),
+        matches!(err, CliError::Usage(ref message) if message == "请填写任务内容；--to-name 不能发送空消息"),
         "expected empty-message usage error, got {err:?}"
     );
     let _ = std::fs::remove_dir_all(&cwd);

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

@@ -645,7 +645,7 @@ fn cmd_send_joins_message_with_single_space() {
                 );
                 assert_eq!(
                     v.get("reminder").and_then(|reminder| reminder.as_str()),
-                    Some("Message queued; coordinator will notify when the worker receives it. Do not poll the worker terminal with capture-pane.")
+                    Some("任务已收下，但还未确认送到队友对话。查看 team-agent status/doctor，等真实回复，不反复重发。")
                 );
             }
         }
@@ -654,22 +654,27 @@ fn cmd_send_joins_message_with_single_space() {
 }
 
 #[test]
-fn cmd_send_default_human_output_is_one_line_without_false_delivered() {
+fn cmd_send_default_human_output_is_brief_without_false_delivered() {
     let r = cmd_send(&queued_send_args_fixture(false)).expect("cmd_send returns CmdResult");
     assert!(!r.as_json);
     let text = emit(&r.output, r.as_json).expect("send should render human text");
     let lines: Vec<_> = text.lines().collect();
     assert_eq!(
         lines.len(),
-        1,
-        "default send output must be one line: {text}"
+        2,
+        "send must separate outcome and next action: {text}"
     );
     assert!(
-        lines[0].contains("ok:")
-            && lines[0].contains("status:")
-            && lines[0].contains("message_id:")
-            && lines[0].contains("target:"),
-        "default send output must keep only the core fields; got {text}"
+        lines[0].contains("任务已收下") && lines[0].contains("还未送到队友的对话"),
+        "queued send must report its true pending outcome: {text}"
+    );
+    assert!(
+        lines[1].contains("下一步")
+            && lines[1].contains("team-agent status")
+            && lines[1].contains("doctor")
+            && lines[1].contains("等真实回复")
+            && lines[1].contains("不反复重发"),
+        "queued send must give honest next steps: {text}"
     );
     assert!(
         !text.contains("delivered"),
@@ -946,7 +951,7 @@ fn cmd_send_unknown_task_surfaces_golden_error_envelope_not_silent() {
     );
     assert_eq!(
         payload.action,
-        "run `team-agent doctor` or inspect the log path shown here"
+        "先运行 team-agent doctor --workspace . 检查所选队伍，或查看此处列出的错误日志。"
     );
     let _ = std::fs::remove_dir_all(&ws);
 }

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

@@ -62,8 +62,8 @@ fn install_skill_missing_source_is_usage_error() {
     );
     assert_eq!(
         code,
-        ExitCode::Error,
-        "install-skill without --source must error (CliError::Usage -> emit_cli_error exit 1)"
+        ExitCode::Usage,
+        "known missing --source must give pure Usage2 guidance"
     );
     let _ = std::fs::remove_dir_all(&ws);
 }