@team-agent/installer 0.3.14 → 0.3.15

package/Cargo.lock

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

package/Cargo.toml

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

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

@@ -107,6 +107,7 @@ pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
         args.team_id.as_deref(),
         args.yes,
         args.fresh,
+        !args.no_display,
     )?;
     let readiness = value.get("readiness").and_then(Value::as_object);
     let all_resumable_have_session = readiness

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

@@ -77,6 +77,12 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "quick-start" => cmd_quick_start(&quick_start_args(args, cwd)?).map(emit_result),
         "compile" => cmd_compile(&compile_args(args, cwd)?).map(emit_result),
         "send" => cmd_send(&send_args(args, cwd)?).map(emit_result),
+        "fallback-send-leader" => {
+            cmd_fallback_send_leader(&fallback_send_leader_args(args, cwd)?).map(emit_result)
+        }
+        "fallback-report-result" => {
+            cmd_fallback_report_result(&fallback_report_result_args(args, cwd)?).map(emit_result)
+        }
         "allow-peer-talk" => {
             cmd_allow_peer_talk(&allow_peer_talk_args(args, cwd)?).map(emit_result)
         }
@@ -136,6 +142,8 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "quick-start",
     "compile",
     "send",
+    "fallback-send-leader",
+    "fallback-report-result",
     "allow-peer-talk",
     "status",
     "stop",
@@ -202,10 +210,12 @@ 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]\n\ndefaults: display_backend=none; set display_backend: adaptive in TEAM.md to opt in to adaptive display windows.".to_string(),
+        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--fresh] [--no-display] [--json]\n\ndefaults: display_backend=adaptive; set display_backend: none in TEAM.md or pass --no-display to use one worker window per agent.".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(),
+        Some("fallback-send-leader") => "usage: team-agent fallback-send-leader --workspace WORKSPACE --team TEAM --sender AGENT --message-id ID --content TEXT --primary-error ERROR [--task TASK] [--json]\n\nEmergency one-shot fallback only after a leader-bound MCP send transport failure; restart-agent after use.".to_string(),
+        Some("fallback-report-result") => "usage: team-agent fallback-report-result --workspace WORKSPACE --team TEAM --agent-id AGENT --task-id TASK --result-json JSON --primary-error ERROR [--json]\n\nEmergency one-shot fallback only after a report_result MCP transport failure; persists the result DB row, then restart-agent after use.".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]".to_string(),
         Some("stop") => "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
@@ -347,7 +357,9 @@ fn install_skill_args(args: &[String]) -> Result<InstallSkillArgs, CliError> {
 
 /// 取 `--flag <value>` 的值(用于 install-skill 的 --source/--dest,parse_args 不覆盖的旗标)。
 fn flag_value(args: &[String], flag: &str) -> Option<String> {
-    args.iter().position(|a| a == flag).and_then(|i| args.get(i + 1).cloned())
+    args.iter()
+        .position(|a| a == flag)
+        .and_then(|i| args.get(i + 1).cloned())
 }
 
 /// `team-agent install-skill`(RED-1 单源):repo `skills/team-agent` → `~/.codex|.claude|.copilot`。
@@ -355,7 +367,9 @@ fn flag_value(args: &[String], flag: &str) -> Option<String> {
 fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
     // 卸载分支(单源:走同一 SkillTarget 表的 dest_dir;all → SINGLE_TARGETS 全集)。
     if args.uninstall {
-        let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("."));
+        let home = std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| PathBuf::from("."));
         let targets: Vec<crate::packaging::SkillTarget> = match args.target {
             crate::packaging::SkillTarget::All => {
                 crate::packaging::SkillTarget::SINGLE_TARGETS.to_vec()
@@ -367,7 +381,8 @@ fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
             if let Some(dest) = t.dest_dir(&home) {
                 let existed = dest.0.exists();
                 if existed && !args.dry_run {
-                    std::fs::remove_dir_all(&dest.0).map_err(|e| CliError::Runtime(e.to_string()))?;
+                    std::fs::remove_dir_all(&dest.0)
+                        .map_err(|e| CliError::Runtime(e.to_string()))?;
                 }
                 removed.push(serde_json::json!({
                     "target": t,
@@ -386,13 +401,14 @@ fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
         .source
         .clone()
         .ok_or_else(|| CliError::Usage("missing --source <skill dir>".to_string()))?;
-    let outcomes = crate::packaging::install::install_skill(&crate::packaging::SkillInstallOptions {
-        target: args.target,
-        dest: args.dest.clone(),
-        dry_run: args.dry_run,
-        source,
-    })
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let outcomes =
+        crate::packaging::install::install_skill(&crate::packaging::SkillInstallOptions {
+            target: args.target,
+            dest: args.dest.clone(),
+            dry_run: args.dry_run,
+            source,
+        })
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
     let installed: Vec<serde_json::Value> = outcomes
         .iter()
         .map(|o| {
@@ -643,6 +659,11 @@ struct ParsedArgs {
     pane: Option<String>,
     provider: Option<String>,
     message_id: Option<String>,
+    content: Option<String>,
+    primary_error: Option<String>,
+    agent_id: Option<String>,
+    task_id: Option<String>,
+    result_json: Option<String>,
 }
 
 fn parse_args(args: &[String]) -> ParsedArgs {
@@ -664,7 +685,9 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--team-id" => parsed.team_id = next_arg(args, &mut i),
             "--targets" | "--target" | "--to" => parsed.targets = next_arg(args, &mut i),
             "--task" => parsed.task = next_arg(args, &mut i),
+            "--task-id" => parsed.task_id = next_arg(args, &mut i),
             "--sender" => parsed.sender = next_arg(args, &mut i),
+            "--agent-id" => parsed.agent_id = next_arg(args, &mut i),
             "--watch-result" => parsed.watch_result = true,
             "--requires-ack" => parsed.requires_ack = true,
             "--no-ack" => parsed.no_ack = true,
@@ -719,6 +742,9 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--pane" => parsed.pane = next_arg(args, &mut i),
             "--provider" => parsed.provider = next_arg(args, &mut i),
             "--message-id" => parsed.message_id = next_arg(args, &mut i),
+            "--content" => parsed.content = next_arg(args, &mut i),
+            "--primary-error" => parsed.primary_error = next_arg(args, &mut i),
+            "--result-json" => parsed.result_json = next_arg(args, &mut i),
             "-h" | "--help" => {}
             other if other.starts_with("--team=") => {
                 parsed.team = Some(other.trim_start_matches("--team=").to_string());
@@ -792,6 +818,7 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
         team_id: parsed.team_id.or(parsed.team),
         yes: parsed.yes,
         fresh: parsed.fresh,
+        no_display: parsed.no_display,
         json: parsed.json,
     })
 }
@@ -862,6 +889,60 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
     })
 }
 
+fn fallback_send_leader_args(
+    args: &[String],
+    cwd: &Path,
+) -> Result<FallbackSendLeaderArgs, CliError> {
+    let parsed = parse_args(args);
+    Ok(FallbackSendLeaderArgs {
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        sender: parsed
+            .sender
+            .or(parsed.agent_id)
+            .ok_or_else(|| CliError::Usage("missing --sender <agent>".to_string()))?,
+        task: parsed.task.or(parsed.task_id),
+        message_id: parsed
+            .message_id
+            .ok_or_else(|| CliError::Usage("missing --message-id <id>".to_string()))?,
+        content: parsed
+            .content
+            .or_else(|| (!parsed.positionals.is_empty()).then(|| parsed.positionals.join(" ")))
+            .ok_or_else(|| CliError::Usage("missing --content <text>".to_string()))?,
+        primary_error: parsed
+            .primary_error
+            .ok_or_else(|| CliError::Usage("missing --primary-error <error>".to_string()))?,
+        json: parsed.json,
+    })
+}
+
+fn fallback_report_result_args(
+    args: &[String],
+    cwd: &Path,
+) -> Result<FallbackReportResultArgs, CliError> {
+    let parsed = parse_args(args);
+    Ok(FallbackReportResultArgs {
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        agent_id: parsed
+            .agent_id
+            .or(parsed.sender)
+            .ok_or_else(|| CliError::Usage("missing --agent-id <agent>".to_string()))?,
+        task_id: parsed
+            .task_id
+            .or(parsed.task)
+            .ok_or_else(|| CliError::Usage("missing --task-id <task>".to_string()))?,
+        result_json: parsed
+            .result_json
+            .or_else(|| parsed.result)
+            .ok_or_else(|| CliError::Usage("missing --result-json <json>".to_string()))?,
+        primary_error: parsed
+            .primary_error
+            .ok_or_else(|| CliError::Usage("missing --primary-error <error>".to_string()))?,
+        json: parsed.json,
+    })
+}
+
 fn allow_peer_talk_args(args: &[String], cwd: &Path) -> Result<AllowPeerTalkArgs, CliError> {
     let parsed = parse_args(args);
     Ok(AllowPeerTalkArgs {

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

@@ -115,9 +115,16 @@ pub mod lifecycle_port {
         team_id: Option<&str>,
         yes: bool,
         fresh: bool,
+        open_display: bool,
     ) -> Result<Value, CliError> {
-        match crate::lifecycle::quick_start_in_workspace(
-            workspace, agents_dir, name, yes, fresh, team_id,
+        match crate::lifecycle::quick_start_in_workspace_with_display(
+            workspace,
+            agents_dir,
+            name,
+            yes,
+            fresh,
+            team_id,
+            open_display,
         ) {
             Ok(report) => Ok(quick_start_value(report)),
             Err(e) => Ok(error_value(e)),
@@ -169,7 +176,7 @@ pub mod lifecycle_port {
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let state = shutdown_state_for_team(&run_ws, team)?;
         let transport = if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
-            crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
+            shutdown_transport_for_endpoint(endpoint)
         } else {
             shutdown_workspace_transport(&run_ws)
         };
@@ -278,6 +285,33 @@ pub mod lifecycle_port {
         let anchor_sessions = anchor_sessions_from_state(state, &pane_targets, event_log);
         match sessions_to_kill(&sessions, &anchor_sessions) {
             KillDecision::KillServerExclusive => {
+                if state
+                    .get("tmux_socket_source")
+                    .and_then(Value::as_str)
+                    == Some("leader_env")
+                {
+                    let _ = event_log.write(
+                        "shutdown.kill_server_skipped_shared_socket",
+                        json!({
+                            "reason": "leader_env_tmux_socket",
+                            "spared_sessions": [],
+                            "killed_sessions": sessions.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                        }),
+                    );
+                    let mut error = None;
+                    for session in &sessions {
+                        if let Err(err) = transport.kill_session(session) {
+                            if !tmux_absent_error(&err.to_string()) {
+                                error.get_or_insert_with(|| err.to_string());
+                            }
+                        }
+                    }
+                    return ShutdownSocketCleanup {
+                        killed_sessions: sessions,
+                        spared_sessions: Vec::new(),
+                        error,
+                    };
+                }
                 let error = transport.kill_server().err().map(|error| error.to_string());
                 ShutdownSocketCleanup {
                     killed_sessions: sessions,
@@ -466,9 +500,17 @@ pub mod lifecycle_port {
             None
         };
         let probe_timeout = crate::os_probe::probe_timeout();
-        // swallow batch 1: a failed ps probe degrades verification truthfully — the
-        // empty table must never read as a clean "no residual processes".
-        let verification_degraded = probe_timeout.is_some() || probe_degraded;
+        let probe_timeout_kind = probe_timeout.as_ref().map(|timeout| timeout.probe);
+        // swallow batch 1: a failed ps probe degrades cleanup truthfully — the
+        // empty table must never read as a clean "no residual processes". A slow
+        // per-process cwd probe is diagnostic only once session/process residuals
+        // are otherwise clean.
+        let cleanup_truth_degraded = probe_degraded || probe_timeout_kind == Some("ps_table");
+        let diagnostic_probe_degraded = probe_timeout_kind == Some("lsof_cwd");
+        let other_probe_timeout_degraded =
+            probe_timeout.is_some() && !cleanup_truth_degraded && !diagnostic_probe_degraded;
+        let verification_degraded =
+            cleanup_truth_degraded || diagnostic_probe_degraded || other_probe_timeout_degraded;
         let session_killed = !killed_sessions.is_empty()
             && kill_error.is_none()
             && session_residuals.is_empty()
@@ -500,13 +542,13 @@ pub mod lifecycle_port {
             && kill_error.is_none()
             && session_residuals.is_empty()
             && process_residuals.is_empty()
-            && !verification_degraded
+            && !cleanup_truth_degraded
             && !coordinator_timeout;
         let status = if ok {
             "ok"
         } else if coordinator_timeout {
             "timeout"
-        } else if verification_degraded {
+        } else if cleanup_truth_degraded {
             "partial"
         } else if kill_error.is_some() {
             "failed"
@@ -515,12 +557,11 @@ pub mod lifecycle_port {
         };
         let phase = if coordinator_timeout {
             Some("stop_coordinator")
-        } else if verification_degraded {
+        } else if cleanup_truth_degraded {
             Some("os_probe")
         } else {
             None
         };
-        let probe_timeout_kind = probe_timeout.as_ref().map(|timeout| timeout.probe);
         let probe_timeout_value = probe_timeout.as_ref().map(|timeout| {
             json!({
                 "probe": timeout.probe,
@@ -652,10 +693,19 @@ pub mod lifecycle_port {
         crate::tmux_backend::TmuxBackend::for_workspace(workspace)
     }
 
+    fn shutdown_transport_for_endpoint(endpoint: &str) -> crate::tmux_backend::TmuxBackend {
+        if Path::new(endpoint).is_absolute() {
+            crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
+        } else {
+            crate::tmux_backend::TmuxBackend::for_socket_name(endpoint)
+        }
+    }
+
     fn legacy_worker_tmux_endpoint(state: &Value) -> Option<&str> {
         state
             .get("tmux_endpoint")
             .and_then(Value::as_str)
+            .or_else(|| state.get("tmux_socket").and_then(Value::as_str))
             .filter(|endpoint| !endpoint.is_empty())
     }
 

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

@@ -37,6 +37,120 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     Ok(CmdResult::from_json(value, args.json))
 }
 
+pub fn cmd_fallback_send_leader(args: &FallbackSendLeaderArgs) -> Result<CmdResult, CliError> {
+    if let Some(value) = fallback_business_refusal(&args.primary_error, args.json) {
+        return Ok(value);
+    }
+    let selected = crate::state::selector::resolve_active_team(
+        &args.workspace,
+        args.team.as_deref(),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )?;
+    let target = MessageTarget::Single("leader".to_string());
+    let opts = SendOptions {
+        task_id: args.task.as_ref().map(|task| TaskId::new(task.clone())),
+        route_task_id: false,
+        sender: args.sender.clone(),
+        requires_ack: false,
+        wait_visible: false,
+        block_until_delivered: false,
+        team: Some(TeamKey::new(selected.team_key.clone())),
+        message_id: Some(args.message_id.clone()),
+        ..SendOptions::default()
+    };
+    let primary = messaging::send_message(&selected.run_workspace, &target, &args.content, &opts);
+    let message_id = match &primary {
+        Ok(outcome) => outcome
+            .message_id
+            .clone()
+            .unwrap_or_else(|| args.message_id.clone()),
+        Err(_) => args.message_id.clone(),
+    };
+    if let Ok(outcome) = &primary {
+        if is_business_refusal_outcome(outcome) {
+            let value = json!({
+                "ok": false,
+                "status": "refused",
+                "reason": "business_reject",
+                "primary_error": args.primary_error,
+                "message_id": outcome.message_id,
+                "action": "N38 fallback refused: business rule refusals must not use fallback pane delivery",
+            });
+            return Ok(CmdResult::from_json(value, args.json));
+        }
+    }
+
+    let state = selected_state_with_active_key(&selected);
+    let event_log = crate::event_log::EventLog::new(&selected.run_workspace);
+    let primary_error = match primary {
+        Ok(outcome) if primary_delivery_succeeded(outcome.status) => {
+            let mut value = delivery_outcome_json(&outcome, &target, &args.content, &opts);
+            if let Some(obj) = value.as_object_mut() {
+                obj.insert("fallback_used".to_string(), json!(false));
+                obj.insert("primary_error".to_string(), json!(args.primary_error));
+            }
+            return Ok(CmdResult::from_json(value, args.json));
+        }
+        Ok(outcome) => format!(
+            "{}; fallback_cli_primary_status={}",
+            args.primary_error,
+            delivery_status_wire(outcome.status)
+        ),
+        Err(error) => format!("{}; fallback_cli_primary_error={error}", args.primary_error),
+    };
+    let outcome = messaging::deliver_to_leader_fallback_pane(
+        &selected.run_workspace,
+        &state,
+        &message_id,
+        None,
+        &args.content,
+        false,
+        Some(&primary_error),
+        &event_log,
+    )?;
+    let mut value = delivery_outcome_json(&outcome, &target, &args.content, &opts);
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("primary_error".to_string(), json!(args.primary_error));
+        obj.insert("delivered_via".to_string(), json!("fallback_pane"));
+        obj.insert(
+            "next_action".to_string(),
+            json!("run team-agent restart-agent to refresh the worker MCP transport"),
+        );
+    }
+    Ok(CmdResult::from_json(value, args.json))
+}
+
+pub fn cmd_fallback_report_result(args: &FallbackReportResultArgs) -> Result<CmdResult, CliError> {
+    if let Some(value) = fallback_business_refusal(&args.primary_error, args.json) {
+        return Ok(value);
+    }
+    let selected = crate::state::selector::resolve_active_team(
+        &args.workspace,
+        args.team.as_deref(),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )?;
+    let envelope = fallback_result_envelope(args)?;
+    let value = messaging::report_result_for_owner_team_with_primary_error(
+        &selected.run_workspace,
+        &envelope,
+        Some(&selected.team_key),
+        Some(&args.primary_error),
+    )?;
+    let mut value = value;
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("primary_error".to_string(), json!(args.primary_error));
+        obj.insert(
+            "fallback_protocol".to_string(),
+            json!("fallback-report-result"),
+        );
+        obj.insert(
+            "next_action".to_string(),
+            json!("run team-agent restart-agent to refresh the worker MCP transport"),
+        );
+    }
+    Ok(CmdResult::from_json(value, args.json))
+}
+
 fn routing_ambiguous_value(
     workspace: &Path,
     args: &SendArgs,
@@ -77,6 +191,101 @@ fn routing_ambiguous_value(
     }))
 }
 
+fn selected_state_with_active_key(selected: &crate::state::selector::SelectedTeam) -> Value {
+    let mut state = selected.state.clone();
+    if let Some(obj) = state.as_object_mut() {
+        obj.insert(
+            "active_team_key".to_string(),
+            Value::String(selected.team_key.clone()),
+        );
+    }
+    state
+}
+
+fn fallback_result_envelope(args: &FallbackReportResultArgs) -> Result<Value, CliError> {
+    let mut envelope: Value = serde_json::from_str(&args.result_json)?;
+    let Some(obj) = envelope.as_object_mut() else {
+        return Err(CliError::Usage(
+            "--result-json must be a JSON object".to_string(),
+        ));
+    };
+    obj.entry("schema_version".to_string())
+        .or_insert_with(|| json!("result_envelope_v1"));
+    obj.entry("task_id".to_string())
+        .or_insert_with(|| json!(args.task_id));
+    obj.entry("agent_id".to_string())
+        .or_insert_with(|| json!(args.agent_id));
+    obj.entry("status".to_string())
+        .or_insert_with(|| json!("success"));
+    obj.entry("summary".to_string())
+        .or_insert_with(|| json!("completed"));
+    for key in ["changes", "tests", "risks", "artifacts", "next_actions"] {
+        obj.entry(key.to_string()).or_insert_with(|| json!([]));
+    }
+    Ok(envelope)
+}
+
+fn fallback_business_refusal(primary_error: &str, as_json: bool) -> Option<CmdResult> {
+    is_business_reject_text(primary_error).then(|| {
+        CmdResult::from_json(
+            json!({
+                "ok": false,
+                "status": "refused",
+                "reason": "business_reject",
+                "primary_error": primary_error,
+                "action": "N38 fallback refused: business rule refusals must not use fallback pane delivery",
+            }),
+            as_json,
+        )
+    })
+}
+
+fn is_business_refusal_outcome(outcome: &DeliveryOutcome) -> bool {
+    matches!(
+        outcome.reason,
+        Some(
+            DeliveryRefusal::TargetNotInTeam
+                | DeliveryRefusal::HumanConfirmationRequired
+                | DeliveryRefusal::MissingPermissions
+                | DeliveryRefusal::UnknownRecipient
+                | DeliveryRefusal::TeamOwnerMismatch
+                | DeliveryRefusal::Ambiguous
+                | DeliveryRefusal::RecipientPaneInNonInputMode
+                | DeliveryRefusal::SessionDrift
+                | DeliveryRefusal::RoutingAmbiguous
+                | DeliveryRefusal::EmptyTargetList
+        )
+    )
+}
+
+fn primary_delivery_succeeded(status: DeliveryStatus) -> bool {
+    matches!(
+        status,
+        DeliveryStatus::Delivered | DeliveryStatus::AlreadyDelivered
+    )
+}
+
+fn is_business_reject_text(error: &str) -> bool {
+    let lower = error.to_ascii_lowercase();
+    [
+        "peer_not_in_scope",
+        "target_not_in_team",
+        "permission denied",
+        "missing_permissions",
+        "human_confirmation_required",
+        "unknown_recipient",
+        "routing_ambiguous",
+        "quota",
+        "rate limit",
+        "rate_limit",
+        "blacklist",
+        "blacklisted",
+        "forbidden",
+    ]
+    .iter()
+    .any(|needle| lower.contains(needle))
+}
+
 /// `_send_target`(`commands.py:181-184`):`--to` comma-split fanout / `target` 单值 / None。
 pub fn send_target(targets: Option<&str>, target: Option<&str>) -> MessageTarget {
     if let Some(targets) = targets.filter(|s| !s.is_empty()) {
@@ -221,3 +430,46 @@ fn delivery_stage_wire(stage: DeliveryStage) -> &'static str {
         DeliveryStage::VisibleCheck => "visible_check",
     }
 }
+
+#[cfg(test)]
+mod e23_tests {
+    use super::*;
+
+    #[test]
+    fn fallback_error_classifier_allows_transport_and_primary_bugs() {
+        for error in [
+            "Transport closed",
+            "Connection refused",
+            "Broken pipe",
+            "EOF on transport",
+            "MCP timeout after 5s",
+            "internal assertion failed: unwrap on Err",
+            "primary_delivery_error: serialize failed",
+        ] {
+            assert!(
+                !is_business_reject_text(error),
+                "failure should be fallback-eligible, not classified as a business refusal: {error}"
+            );
+        }
+    }
+
+    #[test]
+    fn fallback_error_classifier_blocks_business_refusals() {
+        for error in [
+            "peer_not_in_scope",
+            "target_not_in_team",
+            "permission denied",
+            "missing_permissions",
+            "human_confirmation_required",
+            "unknown_recipient",
+            "quota exceeded",
+            "rate_limit",
+            "blacklisted target",
+        ] {
+            assert!(
+                is_business_reject_text(error),
+                "business refusal must not use fallback pane delivery: {error}"
+            );
+        }
+    }
+}

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

@@ -206,6 +206,7 @@ fn current_uid() -> Option<String> {
             team_id: None,
             yes: true,
             fresh: false,
+            no_display: false,
             json: true,
         };
         let _ = cmd_quick_start(&args); // real quick_start compiles the spec before any coordinator/launch step
@@ -240,6 +241,7 @@ fn current_uid() -> Option<String> {
             team_id: None,
             yes: false,
             fresh: false,
+            no_display: false,
             json: true,
         };
         let text = outcome_text(cmd_quick_start(&args));
@@ -275,15 +277,25 @@ fn current_uid() -> Option<String> {
         );
     }
 
-    // 4 [P1] — cmd_add_agent with a DUPLICATE agent id surfaces the REAL crate::lifecycle::add_agent
-    // "agent id already exists" error (launch.rs:252). The placeholder returns {ok:true} -> RED.
-    // OS-safe (the dup check fires before compile/spawn).
+    // 4 [P1] — cmd_add_agent with a DUPLICATE runtime agent id surfaces the REAL
+    // crate::lifecycle::add_agent "agent id already exists" error. E25: role docs/spec files are
+    // inputs, not membership; duplicate membership is runtime-state based.
     #[test]
     fn cli_add_agent_duplicate_id_surfaces_real_error() {
         let team = deleg_uniq_dir("addagent");
         std::fs::create_dir_all(team.join("agents")).unwrap();
         std::fs::write(team.join("TEAM.md"), DELEG_TEAM_MD).unwrap();
         std::fs::write(team.join("agents").join("implementer.md"), DELEG_VALID_ROLE).unwrap(); // 'implementer' already exists
+        crate::state::persist::save_runtime_state(
+            &team,
+            &json!({
+                "session_name": "team-deleg-addagent",
+                "agents": {
+                    "implementer": {"status": "running", "provider": "codex", "window": "implementer"}
+                }
+            }),
+        )
+        .unwrap();
         let dup_role = team.join("dup-role.md");
         std::fs::write(&dup_role, DELEG_VALID_ROLE).unwrap(); // role file must exist
         let args = AddAgentArgs {