@team-agent/installer 0.5.65 → 0.5.68

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

@@ -468,12 +468,52 @@ fn scoped_degraded_shutdown_does_not_persist_team_shutdown_status() {
 
 #[test]
 fn repeated_owned_endpoint_shutdowns_leave_no_socket_file_growth() {
+    #[cfg(unix)]
+    const CHILD: &str = "RB11_F01_NATURAL_PROBE_FAILURE_CHILD";
+    #[cfg(unix)]
+    const TEST: &str =
+        "cli::tests::shutdown_kill_plan::repeated_owned_endpoint_shutdowns_leave_no_socket_file_growth";
+
+    #[cfg(unix)]
+    if std::env::var_os(CHILD).is_none() {
+        let path = tmp_shutdown_workspace("rb11-f01-empty-path").join("bin");
+        std::fs::create_dir_all(&path).unwrap();
+        let output = std::process::Command::new(std::env::current_exe().unwrap())
+            .args(["--exact", TEST, "--nocapture", "--test-threads=1"])
+            .env(CHILD, "1")
+            .env("PATH", path)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "directed child failed: status={} stdout={} stderr={}",
+            output.status,
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        assert!(
+            stdout.contains("running 1 test")
+                && stdout.contains(&format!("test {TEST} ..."))
+                && stdout.contains("RB11_F01_CHILD_SUCCESS"),
+            "directed child omitted success marker: stdout={} stderr={}",
+            stdout,
+            String::from_utf8_lossy(&output.stderr)
+        );
+        println!("RB11_F01_DIRECTED_CHILD_OUTPUT\n{stdout}");
+        return;
+    }
+
+    #[cfg(unix)]
+    let expected_probe_failure = std::env::var_os(CHILD).is_some();
+    #[cfg(not(unix))]
+    let expected_probe_failure = false;
     let ws = tmp_shutdown_workspace("owned-loop-no-growth");
     let sockets = (0..20)
         .map(|idx| ws.join(format!("owned-loop-{idx}.sock")))
         .collect::<Vec<_>>();
     let starting = sockets.iter().filter(|path| path.exists()).count();
-    for socket in &sockets {
+    for (iteration, socket) in sockets.iter().enumerate() {
         std::fs::write(socket, b"socket").unwrap();
         crate::state::persist::save_runtime_state(
             &ws,
@@ -487,20 +527,251 @@ fn repeated_owned_endpoint_shutdowns_leave_no_socket_file_growth() {
             }),
         )
         .unwrap();
-        let out = crate::cli::lifecycle_port::shutdown_with_transport(
+        let before_len = crate::event_log::EventLog::new(&ws)
+            .tail(0)
+            .expect("read shutdown event boundary")
+            .len();
+        let result = crate::cli::lifecycle_port::shutdown_with_transport(
             &ws,
             true,
             None,
             &CleanShutdownTransport::new(),
-        )
-        .expect("shutdown should complete");
-        assert_eq!(out["ok"], json!(true), "shutdown report: {out}");
+        );
+        let out = match &result {
+            Ok(out) if !shutdown_result_is_degraded(out) => out,
+            Ok(out) if expected_probe_failure => {
+                let diagnostic =
+                    shutdown_invocation_diagnostic(&ws, before_len, iteration, socket, &result);
+                assert!(
+                    shutdown_result_is_degraded(out),
+                    "directed probe-failure child unexpectedly clean: {diagnostic}"
+                );
+                assert_eq!(
+                    out["ok"],
+                    json!(false),
+                    "probe failure must remain degraded: {out}"
+                );
+                if iteration == 0 {
+                    println!("RB11_F01_FIRST_FAILURE {diagnostic}");
+                }
+                out
+            }
+            Ok(out) => {
+                let diagnostic =
+                    shutdown_invocation_diagnostic(&ws, before_len, iteration, socket, &result);
+                panic!("unexpected degraded shutdown: {diagnostic}");
+            }
+            Err(error) => {
+                let diagnostic =
+                    shutdown_invocation_diagnostic(&ws, before_len, iteration, socket, &result);
+                panic!("shutdown invocation failed: {error}; {diagnostic}");
+            }
+        };
+        if !expected_probe_failure {
+            assert_eq!(out["ok"], json!(true), "shutdown report: {out}");
+        }
     }
     let ending = sockets.iter().filter(|path| path.exists()).count();
     assert_eq!(
         ending, starting,
         "owned socket files must not grow across loops"
     );
+    #[cfg(unix)]
+    if expected_probe_failure {
+        println!("RB11_F01_CHILD_SUCCESS iterations={}", sockets.len());
+    }
+}
+
+fn shutdown_result_is_degraded(out: &serde_json::Value) -> bool {
+    out["ok"] != json!(true)
+        || out["probe_degraded"] == json!(true)
+        || out["verification_degraded"] == json!(true)
+}
+
+fn shutdown_invocation_diagnostic(
+    ws: &Path,
+    before_len: usize,
+    iteration: usize,
+    socket: &Path,
+    result: &Result<serde_json::Value, crate::cli::CliError>,
+) -> String {
+    let result_summary = match result {
+        Ok(out) => format!("report={out}"),
+        Err(error) => format!("error={error}"),
+    };
+    let events = crate::event_log::EventLog::new(ws)
+        .tail(0)
+        .unwrap_or_else(|error| {
+            panic!(
+                "shutdown diagnostic event read failed: iteration={iteration} socket={} \
+                 {result_summary}; error={error}",
+                socket.display()
+            )
+        });
+    let appended = events.get(before_len..).unwrap_or_else(|| {
+        panic!(
+            "shutdown diagnostic boundary invalid: iteration={iteration} socket={} \
+             {result_summary}; before_len={before_len} event_len={}",
+            socket.display(),
+            events.len()
+        )
+    });
+    fn event_name(event: &serde_json::Value) -> Option<&str> {
+        event["event"].as_str()
+    }
+    let starts = appended
+        .iter()
+        .enumerate()
+        .filter(|(_, event)| event_name(event) == Some("lifecycle.shutdown.started"))
+        .map(|(index, _)| index)
+        .collect::<Vec<_>>();
+    let terminals = appended
+        .iter()
+        .enumerate()
+        .filter(|(_, event)| event_name(event) == Some("lifecycle.shutdown"))
+        .map(|(index, _)| index)
+        .collect::<Vec<_>>();
+    if starts.len() != 1 || terminals.len() != 1 || starts[0] >= terminals[0] {
+        panic!(
+            "shutdown diagnostic markers invalid: iteration={iteration} socket={} \
+             {result_summary}; appended={appended:?}",
+            socket.display()
+        );
+    }
+    let terminal = &appended[terminals[0]];
+    let expected_socket = socket.to_string_lossy();
+    if terminal["owned_endpoint"].as_str() != Some(expected_socket.as_ref()) {
+        panic!(
+            "shutdown diagnostic endpoint mismatch: iteration={iteration} socket={} \
+             {result_summary}; terminal={terminal}",
+            socket.display()
+        );
+    }
+    let bounded = &appended[starts[0]..=terminals[0]];
+    let probe_failures = bounded
+        .iter()
+        .filter(|event| event_name(event) == Some("shutdown.process_probe_failed"))
+        .cloned()
+        .collect::<Vec<_>>();
+    if probe_failures.is_empty() {
+        panic!(
+            "shutdown diagnostic missing process-probe failure: iteration={iteration} \
+             socket={} {result_summary}; bounded={bounded:?}",
+            socket.display()
+        );
+    }
+    for event in &probe_failures {
+        let phase = event["phase"].as_str();
+        if event["probe"].as_str() != Some("ps_table")
+            || !matches!(phase, Some("entry" | "residual_round" | "post_verify"))
+            || !matches!(
+                event["error"].as_str(),
+                Some(error)
+                    if !error.trim().is_empty()
+                        && !error.contains("exited with status")
+                        && (error.contains("No such file") || error.contains("os error 2"))
+            )
+        {
+            panic!(
+                "shutdown diagnostic probe failure invalid: iteration={iteration} \
+                 socket={} {result_summary}; event={event}",
+                socket.display()
+            );
+        }
+    }
+    format!(
+        "iteration={iteration} socket={} {result_summary}; probe_failures={probe_failures:?}",
+        socket.display()
+    )
+}
+
+#[cfg(unix)]
+#[test]
+fn rb07_probe_failure_diagnostic_is_iteration_bound() {
+    const CHILD: &str = "RB07_PROBE_FAILURE_DIAGNOSTIC_CHILD";
+    const TEST: &str =
+        "cli::tests::shutdown_kill_plan::rb07_probe_failure_diagnostic_is_iteration_bound";
+    if std::env::var_os(CHILD).is_none() {
+        let path = tmp_shutdown_workspace("rb07-empty-path").join("bin");
+        std::fs::create_dir_all(&path).unwrap();
+        let output = std::process::Command::new(std::env::current_exe().unwrap())
+            .args(["--exact", TEST, "--nocapture"])
+            .env(CHILD, "1")
+            .env("PATH", path)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "directed child failed: status={} stdout={} stderr={}",
+            output.status,
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        assert!(
+            stdout.contains("running 1 test")
+                && stdout.contains(&format!("test {TEST} ..."))
+                && stdout.contains("RB07_CHILD_SUCCESS"),
+            "directed child omitted success marker: stdout={} stderr={}",
+            stdout,
+            String::from_utf8_lossy(&output.stderr)
+        );
+        return;
+    }
+
+    let ws = tmp_shutdown_workspace("rb07-child");
+    let socket = ws.join("owned.sock");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-rb07-child",
+            "tmux_endpoint": socket.to_string_lossy(),
+            "tmux_socket": socket.to_string_lossy(),
+            "tmux_socket_source": "workspace",
+            "is_external_leader": false,
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let event_log = crate::event_log::EventLog::new(&ws);
+    event_log
+        .write(
+            "shutdown.process_probe_failed",
+            json!({
+                "phase": "entry",
+                "probe": "ps_table",
+                "error": "rb07-stale-decoy"
+            }),
+        )
+        .unwrap();
+    let before_len = event_log.tail(0).unwrap().len();
+    let result = crate::cli::lifecycle_port::shutdown_with_transport(
+        &ws,
+        true,
+        None,
+        &CleanShutdownTransport::new(),
+    );
+    let diagnostic = shutdown_invocation_diagnostic(&ws, before_len, 0, &socket, &result);
+    let failures = match result {
+        Ok(out) => {
+            assert!(
+                shutdown_result_is_degraded(&out),
+                "child must force ps failure: {out}"
+            );
+            let text = diagnostic;
+            assert!(
+                !text.contains("rb07-stale-decoy"),
+                "stale event leaked: {text}"
+            );
+            text
+        }
+        Err(error) => panic!("child shutdown unexpectedly returned Err: {error}; {diagnostic}"),
+    };
+    assert!(
+        failures.contains("probe_failures=["),
+        "missing bounded failures: {failures}"
+    );
+    println!("RB07_CHILD_SUCCESS {failures}");
 }
 
 fn tmp_shutdown_workspace(tag: &str) -> PathBuf {
@@ -521,6 +792,7 @@ struct CleanShutdownTransport {
     kill_server_called: Mutex<bool>,
     probe_timeout_kind: Option<&'static str>,
     targets_persist_after_kill: bool,
+    kill_session_error: Option<String>,
     // E49 (0.3.24 P0, shutdown kills leader CLI): record per-pane / per-window /
     // per-session kill targets so RED contracts can assert (a) the leader pane is
     // never killed and (b) worker panes ARE killed via the new per-pane path.
@@ -537,6 +809,7 @@ impl CleanShutdownTransport {
             kill_server_called: Mutex::new(false),
             probe_timeout_kind: None,
             targets_persist_after_kill: false,
+            kill_session_error: None,
             killed_panes: Mutex::new(Vec::new()),
             killed_window_targets: Mutex::new(Vec::new()),
             killed_sessions: Mutex::new(Vec::new()),
@@ -562,6 +835,11 @@ impl CleanShutdownTransport {
         self
     }
 
+    fn with_kill_session_error(mut self, detail: impl Into<String>) -> Self {
+        self.kill_session_error = Some(detail.into());
+        self
+    }
+
     /// E49 (0.3.24 P0): observed per-pane kill targets, in call order.
     fn killed_panes(&self) -> Vec<String> {
         self.killed_panes.lock().unwrap().clone()
@@ -675,7 +953,19 @@ impl Transport for CleanShutdownTransport {
             .unwrap()
             .push(session.as_str().to_string());
         *self.session_present.lock().unwrap() = false;
-        Ok(())
+        match self.kill_session_error.as_deref() {
+            Some(detail) => Err(TransportError::Subprocess {
+                argv: vec![
+                    "tmux".to_string(),
+                    "kill-session".to_string(),
+                    "-t".to_string(),
+                    session.as_str().to_string(),
+                ],
+                code: Some(1),
+                stderr: detail.to_string(),
+            }),
+            None => Ok(()),
+        }
     }
 
     fn kill_server(&self) -> Result<(), TransportError> {
@@ -1132,6 +1422,8 @@ fn e49_external_leader_shutdown_still_kills_team_session_unconditionally() {
         ])
         .with_targets_persist_after_kill();
 
+    let event_log = crate::event_log::EventLog::new(&ws);
+    let event_start = event_log.tail(0).expect("events before shutdown").len();
     let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
         .expect("shutdown should complete");
 
@@ -1142,9 +1434,98 @@ fn e49_external_leader_shutdown_still_kills_team_session_unconditionally() {
          the team session — leader pane lives elsewhere so this is safe. Got \
          transport killed_sessions={killed_sessions:?}"
     );
+    if out["ok"] != json!(true) {
+        let events = event_log.tail(0).expect("events after shutdown");
+        let invocation_events = events
+            .into_iter()
+            .skip(event_start)
+            .take(64)
+            .collect::<Vec<_>>();
+        panic!(
+            "E49 external-leader shutdown returned a non-clean outcome: workspace tag=e49-external-leader-still-kills, expected session=team-external, shutdown report={out}, killed_sessions={killed_sessions:?}, bounded invocation events={invocation_events:?}"
+        );
+    }
     assert_eq!(out["ok"], json!(true));
 }
 
+#[test]
+fn e49_external_leader_non_clean_diagnostic_is_bounded_and_still_kills() {
+    let ws = tmp_shutdown_workspace("e49-external-leader-non-clean");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-external",
+            "is_external_leader": true,
+            "leader_receiver": {"pane_id": "%leaderelsewhere"},
+            "agents": {
+                "w1": {"status": "running", "provider": "codex", "window": "w1", "pane_id": "%w1"}
+            }
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new()
+        .with_targets(vec![PaneInfo {
+            pane_id: PaneId::new("%w1"),
+            session: SessionName::new("team-external"),
+            window_index: Some(0),
+            window_name: Some(WindowName::new("w1")),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("codex".to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: None,
+            leader_env: BTreeMap::new(),
+        }])
+        .with_kill_session_error("deterministic E49 kill-session failure");
+
+    let event_log = crate::event_log::EventLog::new(&ws);
+    let event_start = event_log.tail(0).expect("events before shutdown").len();
+    let diagnostic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
+            .expect("shutdown should complete");
+        let killed_sessions = transport.killed_sessions_observed();
+        assert!(
+            killed_sessions.iter().any(|s| s == "team-external"),
+            concat!(
+                "E49 non-clean path must still attempt kill_session(team-external); ",
+                "got killed_sessions={:?}"
+            ),
+            killed_sessions
+        );
+        if out["ok"] != json!(true) {
+            let events = event_log.tail(0).expect("events after shutdown");
+            let invocation_events = events
+                .into_iter()
+                .skip(event_start)
+                .take(64)
+                .collect::<Vec<_>>();
+            panic!(
+                "E49 external-leader shutdown returned a non-clean outcome: workspace tag=e49-external-leader-non-clean, expected session=team-external, shutdown report={out}, killed_sessions={killed_sessions:?}, bounded invocation events={invocation_events:?}"
+            );
+        }
+    }))
+    .expect_err("deterministic kill-session error must exercise the diagnostic path");
+    let diagnostic = diagnostic
+        .downcast_ref::<String>()
+        .cloned()
+        .or_else(|| diagnostic.downcast_ref::<&str>().map(ToString::to_string))
+        .expect("diagnostic panic should carry text");
+    let bounded_events = diagnostic
+        .split("bounded invocation events=")
+        .nth(1)
+        .expect("diagnostic should include bounded invocation events");
+    let event_count = bounded_events.matches("\"event\":").count();
+    assert!(
+        event_count > 0,
+        "diagnostic should include invocation events"
+    );
+    assert!(
+        event_count <= 64,
+        "diagnostic must be bounded to 64 invocation events, got {event_count}"
+    );
+}
+
 /// E49 regression guard: managed topology where the leader anchor pane is NOT
 /// in `state.session_name` (e.g. a stale state from an aborted launch where
 /// only worker panes exist in the session). The pre-fix behaviour (kill_session)

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

@@ -227,13 +227,12 @@ fn rm039_stat001_status_resolves_active_team_when_root_team_key_missing() {
 #[test]
 fn status_port_status_compact_json_shape_against_seeded_fixture() {
     // cmd_status json branch (detail=false) delegates status_port::status(compact=true).
-    // 0.4.x compact slim: exactly 7 top-level fields; diagnostics moved
-    // to --detail. Plan: .team/artifacts/status-compact-plan.md.
+    // Compact slim is the original 7 keys plus `grok_slot` and
+    // `grok_identity_slot_ok`. `ok` is command success (always true here).
     let ws = seed_status_workspace();
     let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false)
         .expect("seeded fixture status should project a value");
     let obj = v.as_object().expect("--json status is a dict");
-    // Exactly these 7 keys, no more.
     let expected: std::collections::BTreeSet<&str> = [
         "ok",
         "team",
@@ -242,6 +241,8 @@ fn status_port_status_compact_json_shape_against_seeded_fixture() {
         "ready",
         "not_ready",
         "agents",
+        "grok_slot",
+        "grok_identity_slot_ok",
     ]
     .iter()
     .copied()
@@ -249,7 +250,30 @@ fn status_port_status_compact_json_shape_against_seeded_fixture() {
     let actual: std::collections::BTreeSet<&str> = obj.keys().map(String::as_str).collect();
     assert_eq!(
         actual, expected,
-        "0.4.x compact must expose exactly 7 keys; got {actual:?}"
+        "compact must expose the original 7 keys plus grok_slot and grok_identity_slot_ok (9); got {actual:?}"
+    );
+    let grok_slot = obj
+        .get("grok_slot")
+        .and_then(serde_json::Value::as_object)
+        .expect("compact must carry grok_slot");
+    let grok_ok = grok_slot
+        .get("consistent")
+        .and_then(serde_json::Value::as_bool)
+        == Some(true)
+        && grok_slot
+            .get("readable")
+            .and_then(serde_json::Value::as_bool)
+            == Some(true);
+    assert_eq!(
+        obj.get("ok").and_then(serde_json::Value::as_bool),
+        Some(true),
+        "compact ok is command success and must stay true; grok_slot={grok_slot:?}"
+    );
+    assert_eq!(
+        obj.get("grok_identity_slot_ok")
+            .and_then(serde_json::Value::as_bool),
+        Some(grok_ok),
+        "grok_identity_slot_ok must follow readable∧consistent; grok_slot={grok_slot:?}"
     );
     // Diagnostic keys must NOT leak into the default compact payload.
     for forbidden in [
@@ -282,6 +306,44 @@ fn status_port_status_compact_json_shape_against_seeded_fixture() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[test]
+fn status_compact_reports_identity_slot_health_on_grok_identity_slot_ok() {
+    // 已废除的行为：旧实现看不见 grok 身份槽。此墓碑留下槽健康断言。
+    // 2026-08-18 裁定：`ok` 是命令成功标志，成功投影必须恒真；身份槽健康
+    // 走顶层 `grok_identity_slot_ok`，不再重载 `ok`。
+    // 2026-08-18 身份串台：judge-g 的产出从 developer-d61 的通道报出并占掉
+    // 后者 exactly-once report_result。那时若完全不报槽健康才是一句谎。
+    let ws = seed_status_workspace();
+    let grok = ws.join(".grok");
+    std::fs::create_dir_all(&grok).unwrap();
+    std::fs::write(
+        grok.join("config.toml"),
+        "[mcp_servers.team_orchestrator.env]\nTEAM_AGENT_ID = \"impostor-seat\"\n",
+    )
+    .unwrap();
+
+    let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false)
+        .expect("mismatched grok slot must still project compact status");
+    assert_eq!(
+        v.get("ok").and_then(serde_json::Value::as_bool),
+        Some(true),
+        "successful status must keep ok=true; slot health is a sibling key; got {v}"
+    );
+    assert_eq!(
+        v.get("grok_identity_slot_ok")
+            .and_then(serde_json::Value::as_bool),
+        Some(false),
+        "identity-slot mismatch must force grok_identity_slot_ok=false; got {v}"
+    );
+    assert_eq!(
+        v.pointer("/grok_slot/consistent")
+            .and_then(serde_json::Value::as_bool),
+        Some(false),
+        "fixture must actually be a slot mismatch; got {v}"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
 #[test]
 fn cmd_status_human_appends_harness_reminder() {
     let ws = seed_status_workspace();
@@ -617,8 +679,14 @@ fn cmd_send_default_human_output_is_one_line_without_false_delivered() {
         "channel:",
         "reminder:",
     ] {
+        // 字段级匹配，⛔ 不用裸 contains：人类输出以 " " 连接 `"{key}: {value}"`
+        // （send/presentation.rs 的 `parts.join(" ")` / `send_human_field`），
+        // 所以一个字段只可能出现在行首或某个空格之后。裸子串会让
+        // `turn_verification:` 误命中名单里的 `verification:`（该键由 ab2134c0
+        // 有意加进人类输出名单）——那是判据误伤，不是产品缺陷。
+        let present = text.starts_with(hidden) || text.contains(&format!(" {hidden}"));
         assert!(
-            !text.contains(hidden),
+            !present,
             "default send output should hide {hidden} unless needed; got {text}"
         );
     }
@@ -913,10 +981,8 @@ fn run_send_legacy_task_flag_is_internalized_before_persistence() {
         ExitCode::Ok,
         "legacy --task is sunset-noticed and ignored; public send persists without caller binding"
     );
-    let connection = rusqlite::Connection::open(
-        ws.join(".team").join("runtime").join("team.db"),
-    )
-    .unwrap();
+    let connection =
+        rusqlite::Connection::open(ws.join(".team").join("runtime").join("team.db")).unwrap();
     let task_id: Option<String> = connection
         .query_row(
             "SELECT task_id FROM messages WHERE content = 'go' ORDER BY rowid DESC LIMIT 1",
@@ -924,7 +990,10 @@ fn run_send_legacy_task_flag_is_internalized_before_persistence() {
             |row| row.get(0),
         )
         .unwrap();
-    assert_eq!(task_id, None, "caller-supplied task ids must not reach storage");
+    assert_eq!(
+        task_id, None,
+        "caller-supplied task ids must not reach storage"
+    );
     let _ = std::fs::remove_dir_all(&ws);
 }
 

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

@@ -36,7 +36,7 @@ agents:
       - "git_diff"
       - "mcp_team"
       - "provider_builtin"
-    permission_mode: "restricted"
+    dangerously_skip_permissions: false
     preferred_for:
       - "implementation"
     avoid_for: []

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

@@ -10,7 +10,7 @@ pub enum CommunicationMode {
 
 const LEADER_CENTRIC_RUNTIME_CONTRACT: &str = r#"# Team Agent communication contract: leader_centric
 
-- Progress, blockers, questions: team_orchestrator.send_message(to='leader', content='...')
+- Progress, blockers, questions: {send_message}(to='leader', content='...')
 
 When you receive a message from the leader or a teammate, you MUST respond
 through MCP tools. Writing a reply in your terminal does nothing — the sender
@@ -39,10 +39,12 @@ impl CommunicationMode {
             .find(|mode| mode.as_str() == value)
     }
 
-    pub const fn runtime_contract(self) -> &'static str {
+    pub fn runtime_contract(self, send_message: &str) -> String {
         match self {
-            Self::LeaderCentric => LEADER_CENTRIC_RUNTIME_CONTRACT,
-            Self::Orchestrated => ORCHESTRATED_RUNTIME_CONTRACT,
+            Self::LeaderCentric => {
+                LEADER_CENTRIC_RUNTIME_CONTRACT.replace("{send_message}", send_message)
+            }
+            Self::Orchestrated => ORCHESTRATED_RUNTIME_CONTRACT.to_string(),
         }
     }
 }