@team-agent/installer 0.3.14 → 0.3.16

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/status.rs

@@ -104,6 +104,10 @@ pub fn format_status_summary(data: &Value) -> String {
         ],
         "-",
     );
+    let topology = non_empty_str(
+        data.get("leader_topology").and_then(Value::as_str),
+        "external",
+    );
     let agents = data.get("agents").unwrap_or(&Value::Null);
     let health = data.get("agent_health").unwrap_or(&Value::Null);
     let counts = agent_summary_counts(agents, health);
@@ -137,7 +141,7 @@ pub fn format_status_summary(data: &Value) -> String {
         .map(format_latest_result)
         .unwrap_or_else(|| "none".to_string());
     format!(
-        "coordinator: {coordinator} schema_ok={schema_ok} tmux={tmux}\nreceiver: {pane} cmd={cmd}\n{agent_line}\nqueued: {queued} mailbox messages awaiting delivery\nlatest result: {latest}"
+        "coordinator: {coordinator} schema_ok={schema_ok} tmux={tmux}\nreceiver: {pane} cmd={cmd} topology={topology}\n{agent_line}\nqueued: {queued} mailbox messages awaiting delivery\nlatest result: {latest}"
     )
 }
 

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

@@ -48,6 +48,22 @@ use rusqlite::params;
             .cloned()
             .unwrap_or_else(|| json!({}));
         let session_name = state.get("session_name").cloned().unwrap_or(Value::Null);
+        let is_external_leader = state
+            .get("is_external_leader")
+            .and_then(Value::as_bool)
+            .unwrap_or(true);
+        let leader_topology = if is_external_leader { "external" } else { "managed" };
+        let leader_attach_command = if is_external_leader {
+            None
+        } else {
+            session_name.as_str().and_then(|session| {
+                crate::tmux_backend::attach_command_for_workspace(
+                    workspace,
+                    &crate::transport::SessionName::new(session.to_string()),
+                    "leader",
+                )
+            })
+        };
         let tmux_present = tmux_session_present(workspace, session_name.as_str());
         let mut readiness_state = state.clone();
         if let Some(obj) = readiness_state.as_object_mut() {
@@ -58,6 +74,10 @@ use rusqlite::params;
             "ok": true,
             "team": state.pointer("/leader/id").cloned().unwrap_or_else(|| json!("leader")),
             "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
+            "leader_topology": leader_topology,
+            "is_external_leader": is_external_leader,
+            "leader_attach_command": leader_attach_command,
+            "leader_client": state.get("leader_client").cloned().unwrap_or(Value::Null),
             "tmux_session_present": tmux_present,
             "all_spawned": readiness.get("all_spawned").cloned().unwrap_or(Value::Bool(false)),
             "all_attached_receiver": readiness.get("all_attached_receiver").cloned().unwrap_or(Value::Bool(true)),
@@ -553,6 +573,10 @@ use rusqlite::params;
         json!({
             "team": full.get("team").cloned().unwrap_or(Value::Null),
             "session_name": full.get("session_name").cloned().unwrap_or(Value::Null),
+            "leader_topology": full.get("leader_topology").cloned().unwrap_or_else(|| json!("external")),
+            "is_external_leader": full.get("is_external_leader").cloned().unwrap_or(Value::Bool(true)),
+            "leader_attach_command": full.get("leader_attach_command").cloned().unwrap_or(Value::Null),
+            "leader_client": full.get("leader_client").cloned().unwrap_or(Value::Null),
             "tmux_session_present": full.get("tmux_session_present").cloned().unwrap_or(Value::Bool(false)),
             "all_spawned": full.get("all_spawned").cloned().unwrap_or(Value::Bool(false)),
             "all_attached_receiver": full.get("all_attached_receiver").cloned().unwrap_or(Value::Bool(true)),

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

@@ -52,6 +52,7 @@ use super::*;
         assert!(!got.attach_existing);
         assert!(!got.confirm_attach);
         assert_eq!(got.attach_session, None);
+        assert!(!got.external_leader);
     }
 
     #[test]
@@ -72,6 +73,23 @@ use super::*;
         assert!(!got.confirm_attach);
     }
 
+    #[test]
+    fn leader_launcher_args_external_leader_opt_out() {
+        let got = leader_launcher_args(&[
+            "--external-leader".into(),
+            "--".into(),
+            "--model".into(),
+            "opus".into(),
+        ])
+        .unwrap();
+        assert!(got.external_leader);
+        assert!(!got.attach_existing);
+        assert_eq!(
+            got.provider_args,
+            vec!["--".to_string(), "--model".to_string(), "opus".to_string()]
+        );
+    }
+
     #[test]
     fn leader_launcher_args_attach_session_spaced() {
         // golden: ["--attach-session","mysess"] -> attach_session="mysess"
@@ -272,7 +290,7 @@ use super::*;
     fn format_status_summary_full_byte_lock() {
         // golden:
         // coordinator: running schema_ok=True tmux=True
-        // receiver: %3 cmd=codex
+        // receiver: %3 cmd=codex topology=external
         // agents: 2 — running=1 busy=1 idle=0 stopped=0 failed=0 unknown=0
         // queued: 2 mailbox messages awaiting delivery
         // latest result: a1 -> did the thing @ -
@@ -287,7 +305,7 @@ use super::*;
         });
         let got = format_status_summary(&data);
         let expected = "coordinator: running schema_ok=true tmux=true\n\
-receiver: %3 cmd=codex\n\
+receiver: %3 cmd=codex topology=external\n\
 agents: 2 — running=1 busy=1 idle=0 stopped=0 failed=0 unknown=0\n\
 queued: 2 mailbox messages awaiting delivery\n\
 latest result: a1 -> did the thing @ -";
@@ -299,7 +317,7 @@ latest result: a1 -> did the thing @ -";
         // golden empty data: stopped/false/false, dashes, 0 counts, none latest.
         let got = format_status_summary(&json!({}));
         let expected = "coordinator: stopped schema_ok=false tmux=false\n\
-receiver: - cmd=-\n\
+receiver: - cmd=- topology=external\n\
 agents: 0 — running=0 busy=0 idle=0 stopped=0 failed=0 unknown=0\n\
 queued: 0 mailbox messages awaiting delivery\n\
 latest result: none";

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

@@ -148,35 +148,35 @@ use super::*;
 
     #[test]
     fn red_format_status_summary_empty_pane_id_is_dash() {
-        // golden: pane_id='' -> 'receiver: - cmd=x'
+        // golden: pane_id='' -> 'receiver: - cmd=x topology=external'
         let line = format_status_summary(&json!({
             "leader_receiver": {"pane_id": "", "pane_current_command": "x"}
         }));
         assert_eq!(
             line.lines().nth(1).unwrap(),
-            "receiver: - cmd=x",
+            "receiver: - cmd=x topology=external",
             "empty-string pane_id MUST fall back to '-' (golden `pane_id or '-'`)"
         );
     }
 
     #[test]
     fn red_format_status_summary_cmd_falls_back_to_current_command() {
-        // golden: missing pane_current_command + current_command='claude' -> 'receiver: %3 cmd=claude'
+        // golden: missing pane_current_command + current_command='claude' -> 'receiver: %3 cmd=claude topology=external'
         let line_missing = format_status_summary(&json!({
             "leader_receiver": {"pane_id": "%3", "current_command": "claude"}
         }));
         assert_eq!(
             line_missing.lines().nth(1).unwrap(),
-            "receiver: %3 cmd=claude",
+            "receiver: %3 cmd=claude topology=external",
             "cmd MUST fall back to current_command when pane_current_command is absent (golden line 285)"
         );
-        // golden: empty pane_current_command + current_command='claude' -> 'receiver: %3 cmd=claude'
+        // golden: empty pane_current_command + current_command='claude' -> 'receiver: %3 cmd=claude topology=external'
         let line_empty = format_status_summary(&json!({
             "leader_receiver": {"pane_id": "%3", "pane_current_command": "", "current_command": "claude"}
         }));
         assert_eq!(
             line_empty.lines().nth(1).unwrap(),
-            "receiver: %3 cmd=claude",
+            "receiver: %3 cmd=claude topology=external",
             "empty pane_current_command MUST fall through to current_command (golden falsy `or`)"
         );
     }

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 {