@team-agent/installer 0.5.86 → 0.5.91

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.86"
+version = "0.5.91"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.86"
+version = "0.5.91"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -314,7 +314,7 @@ fn warn_ignored_owner_team_id(team_dir: &std::path::Path) {
 }
 
 /// `cmd_status`(`commands.py:90`)。CLI status 统一为只读七字段 brief；
-/// `--json` 与人读路径共享 nodeprobe-backed projection；`--summary`/`--detail` 保留参数兼容性但不暴露诊断。
+/// `--json` 与人读路径共享 native tmux/process projection；`--summary`/`--detail` 保留参数兼容性但不暴露诊断。
 #[cfg(test)]
 pub(crate) fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
     cmd_status_for_team(args, args.team.as_deref())
@@ -357,7 +357,7 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
         }
     }
     // Status brief is deliberately independent of the legacy RuntimeSnapshot:
-    // it performs one bounded nodeprobe sample and exposes exactly seven
+    // it performs one native tmux/process sample and exposes exactly seven
     // fields. `--summary` and `--detail` remain parser-compatible but do not
     // re-enable history, runtime diagnostics, or reminder text.
     if args.json {
@@ -429,83 +429,6 @@ pub fn cmd_sessions(args: &SessionsArgs) -> Result<CmdResult, CliError> {
     ))
 }
 
-/// `cmd_collect`(`parser.py:292`)。
-#[cfg(test)]
-pub(crate) fn cmd_collect(args: &CollectArgs) -> Result<CmdResult, CliError> {
-    cmd_collect_for_team(args, args.team.as_deref())
-}
-
-pub fn cmd_collect_for_team(args: &CollectArgs, team: Option<&str>) -> Result<CmdResult, CliError> {
-    let selected = match crate::state::selector::resolve_active_team(
-        &args.workspace,
-        team,
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    ) {
-        Ok(selected) => selected,
-        Err(error) => {
-            return Ok(CmdResult::from_json(
-                json!({
-                    "ok": false,
-                    "error": error.to_string(),
-                    "workspace": args.workspace.to_string_lossy().to_string(),
-                }),
-                args.json,
-            ));
-        }
-    };
-    let value = match if team.is_some() {
-        messaging::collect_for_team(
-            &selected.run_workspace,
-            args.result_file.as_deref(),
-            false,
-            Some(&selected.team_key),
-        )
-    } else {
-        messaging::collect(&selected.run_workspace, args.result_file.as_deref(), false)
-    } {
-        Ok(value) => value,
-        Err(error) => {
-            return Ok(CmdResult::from_json(
-                json!({
-                    "ok": false,
-                    "error": error.to_string(),
-                    "workspace": selected.run_workspace.to_string_lossy().to_string(),
-                }),
-                args.json,
-            ));
-        }
-    };
-    let results = value.get("results").cloned().unwrap_or_else(|| json!({}));
-    let ok = value.get("ok").and_then(Value::as_bool).unwrap_or(true);
-    Ok(CmdResult::from_json(
-        json!({
-            "collected": [],
-            "collected_results": value.get("collected_results").cloned().unwrap_or_else(|| json!([])),
-            "coordinator": {
-                "ok": false,
-                "status": "not_required",
-            },
-            "delivered_messages": value.get("delivered_messages").cloned().unwrap_or_else(|| json!([])),
-            "invalid_results": value.get("invalid_results").cloned().unwrap_or_else(|| json!([])),
-            "ok": ok,
-            "results": results,
-            "state_file": value
-                .get("state_file")
-                .cloned()
-                .unwrap_or_else(|| {
-                    json!(selected
-                        .spec_workspace
-                        .as_deref()
-                        .unwrap_or(&selected.run_workspace)
-                        .join("team_state.md")
-                        .to_string_lossy()
-                        .to_string())
-                }),
-        }),
-        args.json,
-    ))
-}
-
 pub fn cmd_results(args: &ResultsArgs) -> Result<CmdResult, CliError> {
     let selected = match crate::state::selector::resolve_active_team(
         &args.workspace,
@@ -846,14 +769,14 @@ fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
                 .mark(message_id, "delivered", None)
                 .map_err(crate::messaging::MessagingError::from)?;
         }
-        let _ = messaging::report_result(
+        let report = messaging::report_result(
             workspace,
             &json!({
                 "schema_version": "result_envelope_v1",
                 "task_id": "task_impl",
                 "agent_id": "fake_impl",
                 "status": "success",
-                "summary": "fake result collected",
+                "summary": "fake result finalized",
                 "changes": [],
                 "tests": [],
                 "risks": [],
@@ -861,25 +784,29 @@ fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
                 "next_actions": [],
             }),
         )?;
-    }
-    let mut collect = messaging::collect(workspace, None, false)?;
-    let collected = collect
-        .get("collected_results")
-        .and_then(Value::as_array)
-        .is_some_and(|items| !items.is_empty());
-    if let Some(obj) = collect.as_object_mut() {
-        obj.insert("collected".to_string(), Value::Bool(collected));
+        let auto_finalized = report
+            .get("finalization_status")
+            .and_then(Value::as_str)
+            == Some("auto_finalized");
+        let shutdown = fake_shutdown(workspace)?;
+        let ok = launch.get("ok").and_then(Value::as_bool) == Some(true)
+            && send.ok
+            && auto_finalized
+            && shutdown.get("ok").and_then(Value::as_bool) == Some(true);
+        return Ok(json!({
+            "ok": ok,
+            "launch": launch,
+            "send": send_value,
+            "report": report,
+            "shutdown": shutdown,
+        }));
     }
     let shutdown = fake_shutdown(workspace)?;
-    let ok = launch.get("ok").and_then(Value::as_bool) == Some(true)
-        && send.ok
-        && collected
-        && shutdown.get("ok").and_then(Value::as_bool) == Some(true);
     Ok(json!({
-        "ok": ok,
+        "ok": false,
         "launch": launch,
         "send": send_value,
-        "collect": collect,
+        "report": null,
         "shutdown": shutdown,
     }))
 }
@@ -1286,89 +1213,82 @@ pub fn cmd_inbox(args: &InboxArgs) -> Result<CmdResult, CliError> {
         &selected.run_workspace,
         &args.agent,
         args.limit,
-        args.since.as_deref(),
-        args.json,
         Some(&selected.team_key),
     )?;
     if args.json {
         Ok(CmdResult::from_json(value, true))
     } else {
-        Ok(CmdResult::human(format_inbox_human(
-            &selected.run_workspace,
-            &args.agent,
-            args.since.as_deref(),
-            &value,
-            Some(&selected.team_key),
-        )?))
+        Ok(CmdResult::human(format_inbox_human(&args.agent, &value)))
     }
 }
 
-fn format_inbox_human(
-    workspace: &Path,
-    agent: &str,
-    since: Option<&str>,
-    value: &Value,
-    owner_team_id: Option<&str>,
-) -> Result<String, CliError> {
+const INBOX_LINE_LIMIT_BYTES: usize = 160;
+
+fn clean_inbox_field(value: &str) -> String {
+    value.chars().filter(|ch| !ch.is_control()).collect()
+}
+
+fn truncate_inbox_line(line: &str) -> String {
+    if line.len() <= INBOX_LINE_LIMIT_BYTES {
+        return line.to_string();
+    }
+    let budget = INBOX_LINE_LIMIT_BYTES.saturating_sub("…".len());
+    let mut end = 0;
+    for (index, ch) in line.char_indices() {
+        let next = index + ch.len_utf8();
+        if next > budget {
+            break;
+        }
+        end = next;
+    }
+    format!("{}…", &line[..end])
+}
+
+fn format_inbox_human(agent: &str, value: &Value) -> String {
     let messages = value
         .get("messages")
         .and_then(Value::as_array)
         .cloned()
         .unwrap_or_default();
-    let mut lines = Vec::new();
     if messages.is_empty() {
-        let mut line = format!("{agent}: no messages");
-        if let Some(since) = since {
-            line.push_str(" since ");
-            line.push_str(since);
-        }
-        lines.push(line);
-    } else {
-        lines.push(format!("{agent}: {} message(s)", messages.len()));
-        for message in messages {
-            let sender = message.get("sender").and_then(Value::as_str).unwrap_or("-");
-            let content = message.get("content").and_then(Value::as_str).unwrap_or("");
-            let status = message.get("status").and_then(Value::as_str).unwrap_or("-");
-            let attempts = message
-                .get("delivery_attempts")
-                .and_then(Value::as_i64)
-                .unwrap_or(0);
-            let error = message.get("error").and_then(Value::as_str).unwrap_or("-");
-            lines.push(format!(
-                "- {sender}: {content} [status={status} attempts={attempts} error={error}]"
-            ));
-        }
+        return format!("{agent}: no messages");
     }
-    let pending = uncollected_result_count(workspace, owner_team_id)?;
-    let mut note = "final results are not in inbox; use team-agent collect".to_string();
-    if pending > 0 {
-        note.push_str(&format!(" ({pending} uncollected result(s) pending)"));
-    }
-    lines.push(note);
-    Ok(lines.join("\n"))
-}
-
-fn uncollected_result_count(
-    workspace: &Path,
-    owner_team_id: Option<&str>,
-) -> Result<i64, CliError> {
-    let store = crate::message_store::MessageStore::open(workspace)
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let conn = crate::db::schema::open_db(store.db_path())
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    match owner_team_id {
-        Some(team) => conn.query_row(
-            "select count(*) from results where status not in ('collected', 'invalid') and owner_team_id = ?1",
-            [team],
-            |row| row.get::<_, i64>(0),
-        ),
-        None => conn.query_row(
-            "select count(*) from results where status not in ('collected', 'invalid')",
-            [],
-            |row| row.get::<_, i64>(0),
-        ),
-    }
-    .map_err(|e| CliError::Runtime(e.to_string()))
+    messages
+        .iter()
+        .map(|message| {
+            let id = clean_inbox_field(
+                message
+                    .get("message_id")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let sender = clean_inbox_field(
+                message.get("sender").and_then(Value::as_str).unwrap_or("-"),
+            );
+            let recipient = clean_inbox_field(
+                message
+                    .get("recipient")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let status = clean_inbox_field(
+                message.get("status").and_then(Value::as_str).unwrap_or("-"),
+            );
+            let time = clean_inbox_field(
+                message
+                    .get("created_at")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let summary = clean_inbox_field(
+                message.get("summary").and_then(Value::as_str).unwrap_or(""),
+            );
+            truncate_inbox_line(&format!(
+                "[{id}] [{sender} -> {recipient}] [{status}] [{time}] [{summary}]"
+            ))
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
 }
 
 /// `cmd_takeover`(`commands.py:152`)。
@@ -1629,11 +1549,31 @@ mod tests {
     #![allow(clippy::unwrap_used)]
 
     use super::{
-        agent_pane_id, append_send_guidance, quickstart_human, send_command, split_shell_argv,
+        agent_pane_id, append_send_guidance, format_inbox_human, quickstart_human, send_command,
+        split_shell_argv,
     };
     use serde_json::{json, Value};
     use std::path::{Path, PathBuf};
 
+    #[test]
+    fn inbox_human_output_sanitizes_controls_and_caps_each_line() {
+        let value = json!({
+            "messages": [{
+                "message_id": "msg-\u{001b}[31m".repeat(20),
+                "sender": "sender\t\u{001b}[2J".repeat(20),
+                "recipient": "worker".repeat(20),
+                "status": "delivered",
+                "created_at": "2026-09-19T00:00:00Z",
+                "summary": "中".repeat(120)
+            }]
+        });
+        let output = format_inbox_human("worker", &value);
+        for line in output.lines() {
+            assert!(line.len() <= 160, "line is {} bytes: {line:?}", line.len());
+            assert!(!line.chars().any(char::is_control), "controls leaked: {line:?}");
+        }
+    }
+
     // E13:happy 人类输出必须带 attach 块(此前 else 分支只打 summary 丢 attach_commands)。
     #[test]
     fn e13_quickstart_human_includes_attach_commands() {

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

@@ -223,10 +223,6 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "validate" => cmd_validate(&validate_args(args, cwd)).map(emit_result),
         "install-skill" => cmd_install_skill(&install_skill_args(args)?).map(emit_result),
         "profile" => cmd_profile(&profile_args(args, cwd)?).map(emit_result),
-        "collect" => {
-            cmd_collect_for_team(&collect_args(args, cwd)?, parse_args(args).team.as_deref())
-                .map(emit_result)
-        }
         "results" => cmd_results(&results_args(args, cwd)?).map(emit_result),
         "wait" => cmd_wait(&wait_args(args, cwd)?).map(emit_result),
         "diagnose" => cmd_diagnose(&diagnose_args(args, cwd)).map(emit_result),
@@ -275,7 +271,6 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "validate",
     "install-skill",
     "profile",
-    "collect",
     "results",
     "wait",
     "diagnose",
@@ -328,7 +323,6 @@ pub(crate) fn default_help() -> String {
             "quick-start",
             "send",
             "status",
-            "collect",
             "results",
             "models",
             "leaders",
@@ -417,7 +411,7 @@ fn command_help(command: Option<&str>) -> String {
         )
         .to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
-        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出七字段：name/provider/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。缺少可靠定位或 nodeprobe 证据时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
+        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出七字段：name/provider/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。缺少可靠定位或原生 tmux/process 采样时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
         Some("models") => "usage: team-agent models [--provider pi|cursor_agent] [QUERY|--search TEXT] [--json]\n\nLists exact provider model ids with case-insensitive multi-word search across provider, vendor, id, and display name. Cursor uses the local `agent --list-models` catalog.".to_string(),
         Some("leaders") => "usage: team-agent leaders [QUERY|--search TEXT] [--all|--stale] [--json] | --prune [--dry-run] [--json]\n\nLists LIVE leaders by default. Use --all to include retained STALE entries, --stale to inspect only STALE entries, QUERY or --search TEXT to match workspace/team/name fields, and --prune to remove only entries proven terminal by canonical state. --dry-run is valid only with --prune.".to_string(),
         Some("stop") => compat_hidden_help("stop", "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]"),
@@ -441,14 +435,13 @@ fn command_help(command: Option<&str>) -> String {
         Some("attach-app-server-leader") => "usage: team-agent attach-app-server-leader [--workspace WORKSPACE] [--team TEAM] --socket unix:///path.sock --thread-id THREAD_ID [--json]".to_string(),
         Some("identity") => "usage: team-agent identity [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("approvals") => "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
-        Some("inbox") => "usage: team-agent inbox AGENT [--workspace WORKSPACE] [--team TEAM] [--limit N] [--since CURSOR] [--json]".to_string(),
+        Some("inbox") => "usage: team-agent inbox AGENT [-n N|--limit N] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("doctor") => "usage: team-agent doctor [SPEC] [--workspace WORKSPACE] [--team TEAM] [--gate orphans|comms] [--comms] [--fix] [--fix-schema] [--cleanup-orphans] [--confirm] [--json]".to_string(),
         Some("watch") => "usage: team-agent watch [--workspace WORKSPACE] [--team TEAM]".to_string(),
         Some("sessions") => "usage: team-agent sessions [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("validate") => "usage: team-agent validate [SPEC] [--json]".to_string(),
         Some("install-skill") => "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]".to_string(),
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--proxy-mode direct|inherit] [--json]".to_string(),
-        Some("collect") => "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]".to_string(),
         Some("results") => "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("wait") => "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]".to_string(),
         Some("diagnose") => "usage: team-agent diagnose [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
@@ -842,7 +835,6 @@ struct ParsedArgs {
     confirm: bool,
     alert_type: Option<String>,
     limit: Option<usize>,
-    since: Option<String>,
     gate: Option<String>,
     comms: bool,
     fix: bool,
@@ -856,7 +848,6 @@ struct ParsedArgs {
     tail: Option<usize>,
     head: Option<usize>,
     search: Option<String>,
-    result_file: Option<PathBuf>,
     file: Option<PathBuf>,
     result: Option<String>,
     real: bool,
@@ -936,10 +927,9 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--from-spec" => parsed.from_spec = true,
             "--confirm" => parsed.confirm = true,
             "--alert-type" => parsed.alert_type = next_arg(args, &mut i),
-            "--limit" => {
+            "-n" | "--limit" => {
                 parsed.limit = next_arg(args, &mut i).and_then(|v| v.parse::<usize>().ok())
             }
-            "--since" => parsed.since = next_arg(args, &mut i),
             "--gate" => parsed.gate = next_arg(args, &mut i),
             "--comms" => parsed.comms = true,
             "--fix" => parsed.fix = true,
@@ -955,7 +945,6 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--tail" => parsed.tail = next_arg(args, &mut i).and_then(|v| v.parse::<usize>().ok()),
             "--head" => parsed.head = next_arg(args, &mut i).and_then(|v| v.parse::<usize>().ok()),
             "--search" => parsed.search = next_arg(args, &mut i),
-            "--result-file" => parsed.result_file = next_arg(args, &mut i).map(PathBuf::from),
             "--file" => parsed.file = next_arg(args, &mut i).map(PathBuf::from),
             "--result" => parsed.result = next_arg(args, &mut i),
             "--real" => parsed.real = true,
@@ -1069,17 +1058,37 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
         ));
     }
     let parsed = parse_args(args);
-    let workspace = workspace(&parsed, cwd);
-    let agents_dir = parsed
-        .positionals
-        .first()
-        .map(PathBuf::from)
-        .unwrap_or_else(|| workspace.clone());
-    let agents_dir = if agents_dir.is_absolute() {
-        agents_dir
-    } else {
-        workspace.join(agents_dir)
-    };
+    let explicit_workspace = parsed
+        .workspace
+        .as_deref()
+        .map(|path| resolve_cli_path(cwd, path));
+    let positional_agents_dir = parsed.positionals.first().map(PathBuf::from).map(|path| {
+        if path.is_absolute() {
+            path
+        } else if let Some(workspace) = explicit_workspace.as_ref() {
+            workspace.join(path)
+        } else {
+            cwd.join(path)
+        }
+    });
+    let workspace = explicit_workspace
+        .or_else(|| {
+            let path = positional_agents_dir.as_ref()?;
+            if let Some(run_workspace) = path
+                .ancestors()
+                .find(|ancestor| ancestor.file_name().and_then(|name| name.to_str()) == Some(".team"))
+                .and_then(Path::parent)
+            {
+                return Some(run_workspace.to_path_buf());
+            }
+            path.join("TEAM.md").is_file().then(|| path.to_path_buf())
+        })
+        .unwrap_or_else(|| cwd.to_path_buf());
+    // A positional team directory containing TEAM.md is a complete standalone
+    // workspace. Use it as the runtime workspace unless --workspace explicitly
+    // selects another root; this prevents host owner context/state leaking into
+    // an independent quick-start target.
+    let agents_dir = positional_agents_dir.unwrap_or_else(|| workspace.clone());
     // 0.5.x Phase 1d Batch 2: validate the `--backend` literal up-front
     // so users get a fast, actionable error instead of a downstream
     // factory refusal. Accept the same literals as the factory
@@ -1418,12 +1427,19 @@ fn approvals_args(args: &[String], cwd: &Path) -> ApprovalsArgs {
 }
 
 fn inbox_args(args: &[String], cwd: &Path) -> Result<InboxArgs, CliError> {
+    if args
+        .iter()
+        .any(|arg| arg == "--since" || arg.starts_with("--since="))
+    {
+        return Err(CliError::Usage(
+            "inbox only supports -n/--limit; --since is not supported".to_string(),
+        ));
+    }
     let parsed = parse_args(args);
     Ok(InboxArgs {
         agent: required_pos(&parsed, 0, "agent")?,
         workspace: workspace(&parsed, cwd),
-        limit: parsed.limit.unwrap_or(20),
-        since: parsed.since,
+        limit: parsed.limit.unwrap_or(3),
         json: parsed.json,
         team: parsed.team,
     })
@@ -1828,18 +1844,6 @@ fn profile_args(args: &[String], cwd: &Path) -> Result<ProfileArgs, CliError> {
     })
 }
 
-fn collect_args(args: &[String], cwd: &Path) -> Result<CollectArgs, CliError> {
-    let parsed = parse_args(args);
-    let workspace = workspace(&parsed, cwd);
-    refuse_if_multi_alive_team_missing_scope("collect", &workspace, parsed.team.as_deref())?;
-    Ok(CollectArgs {
-        workspace,
-        result_file: parsed.result_file,
-        json: parsed.json,
-        team: parsed.team,
-    })
-}
-
 fn results_args(args: &[String], cwd: &Path) -> Result<ResultsArgs, CliError> {
     if args
         .iter()
@@ -2329,15 +2333,11 @@ mod tests {
                     "--json",
                 ][..],
             ),
-            (
-                "collect",
-                &["--workspace", "--team", "--result-file", "--json"][..],
-            ),
             ("stuck-list", &["--workspace", "--team", "--json"][..]),
             ("approvals", &["--workspace", "--team", "--json"][..]),
             (
                 "inbox",
-                &["--workspace", "--team", "--limit", "--since", "--json"][..],
+                &["--workspace", "--team", "-n", "--limit", "--json"][..],
             ),
             ("sessions", &["--workspace", "--team", "--json"][..]),
             ("diagnose", &["--workspace", "--team", "--json"][..]),
@@ -2565,6 +2565,30 @@ mod tests {
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn ux_quick_start_positional_team_dir_is_standalone_workspace() {
+        let cwd = tmp_workspace();
+        let ws = tmp_workspace();
+        std::fs::write(ws.join("TEAM.md"), "# team\n").unwrap();
+        let args = quick_start_args(&cli_argv(&[&ws.to_string_lossy()]), &cwd).unwrap();
+        assert_eq!(args.workspace, ws);
+        assert_eq!(args.agents_dir, ws);
+        let _ = std::fs::remove_dir_all(&cwd);
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn ux_quick_start_team_dir_under_dot_team_uses_project_workspace() {
+        let cwd = tmp_workspace();
+        let team_dir = cwd.join(".team/current");
+        std::fs::create_dir_all(&team_dir).unwrap();
+        std::fs::write(team_dir.join("TEAM.md"), "# team\n").unwrap();
+        let args = quick_start_args(&cli_argv(&[".team/current"]), &cwd).unwrap();
+        assert_eq!(args.workspace, cwd);
+        assert_eq!(args.agents_dir, team_dir);
+        let _ = std::fs::remove_dir_all(&cwd);
+    }
+
     // ── E8 (N38): 未知子命令 → 最近似建议(additive,不破坏 golden invalid-choice 行) ──
     #[test]
     fn e8_unknown_subcommand_suggests_nearest_known_command() {
@@ -2621,37 +2645,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn refuse_helper_passes_when_explicit_team_provided_even_in_multi_alive() {
-        let ws = tmp_workspace();
-        seed_two_alive_teams_in(&ws);
-        assert!(
-            refuse_if_multi_alive_team_missing_scope("collect", &ws, Some("alpha")).is_ok(),
-            "explicit --team alpha must bypass the ambiguity gate"
-        );
-    }
-
-    #[test]
-    fn refuse_helper_refuses_when_multi_alive_team_and_no_explicit_team() {
-        let ws = tmp_workspace();
-        seed_two_alive_teams_in(&ws);
-        let err = refuse_if_multi_alive_team_missing_scope("collect", &ws, None)
-            .expect_err("multi-alive-team must refuse without --team");
-        let message = err.to_string();
-        assert!(
-            message.contains("multiple alive teams"),
-            "refusal must name the ambiguity; got: {message}"
-        );
-        assert!(
-            message.contains("alpha") && message.contains("beta"),
-            "refusal must list candidate teams; got: {message}"
-        );
-        assert!(
-            message.contains("collect"),
-            "refusal must name the command for diagnostic clarity; got: {message}"
-        );
-    }
-
     #[test]
     fn stuck_cancel_args_builder_refuses_on_multi_alive_team() {
         let ws = tmp_workspace();
@@ -2664,18 +2657,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn collect_args_builder_refuses_on_multi_alive_team() {
-        let ws = tmp_workspace();
-        seed_two_alive_teams_in(&ws);
-        let argv = cli_argv(&["--workspace", &ws.to_string_lossy()]);
-        let err = collect_args(&argv, &ws).expect_err("must refuse");
-        assert!(
-            err.to_string().contains("multiple alive teams"),
-            "collect args builder must surface the refusal; got: {err}"
-        );
-    }
-
     #[test]
     fn shutdown_args_builder_refuses_on_multi_alive_team() {
         let ws = tmp_workspace();

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

@@ -51,7 +51,7 @@ use crate::model::ids::{TaskId, TeamKey};
 pub(crate) const COMMS_BOUNDARY_TEXT: &str = "validates live pane binding consistency and zero-token comms contracts. Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
 pub(crate) const QUICK_START_REMINDER: &str = "Reminder: Do not inspect raw worker terminal output during normal operation. Use team-agent status / inbox / collect instead. Wait for report_result.";
 pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker to report_result. Do not poll the worker terminal with capture-pane.";
-pub(crate) const STATUS_REMINDER: &str = "To wait for results use --watch-result or team-agent collect. Do not capture-pane worker terminals.";
+pub(crate) const STATUS_REMINDER: &str = "Results are finalized automatically; use --watch-result or team-agent inbox AGENT -n 3 for transport fallback. Do not capture-pane worker terminals.";
 
 pub mod adapters;
 pub mod attach_app_server_leader;