@team-agent/installer 0.3.8 → 0.3.9

package/Cargo.lock

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

package/Cargo.toml

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

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

@@ -23,7 +23,7 @@ pub fn emit(output: &CmdOutput, as_json: bool) -> Option<String> {
     }
 }
 
-/// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude passthrough 早返回 →
+/// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude/copilot passthrough 早返回 →
 /// 解析 argv 到 subcommand → 调对应 handler → 异常落盘 + 信封 + `ExitCode::Error` →
 /// `consume_leader_inbox_summary` → `emit` → `result.ok is False ? Error : Ok`。
 /// **行为入口**:契约可端到端跑 argv→(stdout, exit code)。
@@ -31,7 +31,7 @@ pub fn run(argv: &[String], cwd: &Path) -> ExitCode {
     let Some(command) = argv.first().map(String::as_str) else {
         return emit_missing_subcommand_usage();
     };
-    if command == "codex" || command == "claude" {
+    if command == "codex" || command == "claude" || command == "copilot" {
         return cmd_leader_passthrough(command, &argv[1..], cwd)
             .map(emit_result)
             .unwrap_or(ExitCode::Error);
@@ -193,7 +193,7 @@ fn is_known_subcommand(command: &str) -> bool {
 fn command_help(command: Option<&str>) -> String {
     match command {
         None => {
-            let mut commands = vec!["codex", "claude"];
+            let mut commands = vec!["codex", "claude", "copilot"];
             commands.extend_from_slice(DISPATCH_COMMANDS);
             commands.extend_from_slice(SPEC_ONLY_HELP_COMMANDS);
             format!(
@@ -261,7 +261,7 @@ fn emit_unknown_subcommand_usage(command: &str) -> ExitCode {
 
 /// 在已知子命令里找与 `input` 最接近的一个(Levenshtein ≤ 阈值)。无足够接近者 → None。
 fn nearest_subcommand(input: &str) -> Option<&'static str> {
-    let mut candidates: Vec<&'static str> = vec!["codex", "claude"];
+    let mut candidates: Vec<&'static str> = vec!["codex", "claude", "copilot"];
     candidates.extend_from_slice(DISPATCH_COMMANDS);
     candidates.extend_from_slice(SPEC_ONLY_HELP_COMMANDS);
     // 阈值随长度放宽,但短词收紧,避免 'x' 误配任何东西。
@@ -1418,6 +1418,22 @@ mod tests {
                 "top-level --help is missing spec-only help command `{command}`"
             );
         }
+        assert!(
+            top_help.contains("copilot"),
+            "top-level leader passthrough help must list copilot"
+        );
+    }
+
+    #[test]
+    fn copilot_is_listed_as_leader_passthrough_candidate() {
+        assert!(command_help(None).contains("copilot"));
+        assert_eq!(nearest_subcommand("copliot"), Some("copilot"));
+    }
+
+    #[test]
+    fn copilot_help_dispatches_as_leader_passthrough() {
+        let cwd = tmp_workspace();
+        assert_eq!(run(&cli_argv(&["copilot", "--help"]), &cwd), ExitCode::Ok);
     }
 
     #[test]

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

@@ -1,4 +1,4 @@
-//! cli · leader — `codex`/`claude` passthrough(`cmd_leader_passthrough` + `_provider_args` /
+//! cli · leader — `codex`/`claude`/`copilot` passthrough(`cmd_leader_passthrough` + `_provider_args` /
 //! `_leader_launcher_args`)+ leader fallback inbox 摘要(`consume_leader_inbox_summary` 及
 //! `_leader_inbox_entries` / `_leader_inbox_summary` / `_leader_inbox_entry_title`)。
 
@@ -68,9 +68,9 @@ fn without_leader_json(values: &[String]) -> Vec<String> {
     out
 }
 
-/// `codex`/`claude` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
+/// `codex`/`claude`/`copilot` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
 /// **不**进 subparser。`-h`/`--help` 打 usage 直接返回 [`CmdResult::none`]。否则解析 attach
-/// 旗标 + `lifecycle_port::start_leader`。`command` ∈ {codex, claude}。
+/// 旗标 + `lifecycle_port::start_leader`。`command` ∈ {codex, claude, copilot}。
 pub fn cmd_leader_passthrough(
     command: &str,
     provider_args: &[String],
@@ -82,15 +82,19 @@ pub fn cmd_leader_passthrough(
     let as_json = leader_launcher_json(provider_args);
     let launcher_args = without_leader_json(provider_args);
     let attach = leader_launcher_args(&launcher_args)?;
-    let provider = if command == "codex" {
-        crate::model::enums::Provider::Codex
-    } else {
-        crate::model::enums::Provider::ClaudeCode
-    };
+    let provider = leader_passthrough_provider(command);
     let value = lifecycle_port::start_leader(provider, &attach.provider_args, cwd, &attach)?;
     Ok(CmdResult::from_json(value, as_json))
 }
 
+pub(crate) fn leader_passthrough_provider(command: &str) -> crate::model::enums::Provider {
+    match command {
+        "codex" => crate::model::enums::Provider::Codex,
+        "copilot" => crate::model::enums::Provider::Copilot,
+        _ => crate::model::enums::Provider::ClaudeCode,
+    }
+}
+
 // =============================================================================
 // leader fallback inbox 摘要(helpers.py `consume_leader_inbox_summary`)
 // =============================================================================

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

@@ -617,5 +617,19 @@ Truncated: more fallback entries available; run team-agent inbox leader";
         assert_eq!(r.exit, ExitCode::Ok);
         let r2 = cmd_leader_passthrough("claude", &["--help".into()], Path::new(".")).unwrap();
         assert_eq!(r2.output, CmdOutput::None);
+        let r3 = cmd_leader_passthrough("copilot", &["--help".into()], Path::new(".")).unwrap();
+        assert_eq!(r3.output, CmdOutput::None);
     }
 
+    #[test]
+    fn cmd_leader_passthrough_maps_copilot_provider() {
+        assert_eq!(leader_passthrough_provider("codex"), crate::model::enums::Provider::Codex);
+        assert_eq!(
+            leader_passthrough_provider("claude"),
+            crate::model::enums::Provider::ClaudeCode
+        );
+        assert_eq!(
+            leader_passthrough_provider("copilot"),
+            crate::model::enums::Provider::Copilot
+        );
+    }

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

@@ -264,9 +264,13 @@ fn current_uid() -> Option<String> {
             json: true,
         };
         let text = outcome_text(cmd_restart(&args));
+        // RED-2-STILL: entry gate now resolves via canonical_run_workspace; for a no-spec workspace
+        // the "no spec" surfacing may come from either the entry gate ("missing spec for restart")
+        // or, when a stray ancestor .team lets it past, the resolve gate ("active team spec not
+        // found"). Both are the REAL crate::lifecycle error (not a placeholder ok:true).
         assert!(
-            text.contains("missing spec for restart"),
-            "cmd_restart must surface the REAL crate::lifecycle::restart 'missing spec for restart' error \
+            text.contains("missing spec for restart") || text.contains("active team spec not found"),
+            "cmd_restart must surface the REAL crate::lifecycle::restart missing-spec error \
              (not the placeholder's canned ok:true); got {text}"
         );
     }

package/crates/team-agent/src/leader/start.rs

@@ -14,8 +14,8 @@ use super::helpers::{
 };
 use super::owner_bind::leader_identity_context;
 use super::{
-    LeaderError, LeaderLaunchOutcome, LeaderLaunchSocket, LeaderLaunchStatus, LeaderStartMode,
-    LeaderStartPlan,
+    LeaderError, LeaderIdentity, LeaderLaunchOutcome, LeaderLaunchSocket, LeaderLaunchStatus,
+    LeaderStartMode, LeaderStartPlan,
 };
 
 // ── leader::start — leader_start_plan / start_leader / session 名 ──
@@ -72,27 +72,7 @@ pub fn leader_start_plan(
     } else {
         LeaderStartMode::NewTmuxSession
     };
-    let mut leader_env = BTreeMap::new();
-    leader_env.insert(
-        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
-        provider_wire(provider).to_string(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_LEADER_SESSION_UUID".to_string(),
-        identity.leader_session_uuid.as_str().to_string(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
-        identity.machine_fingerprint.clone(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_WORKSPACE".to_string(),
-        identity.workspace_abspath.to_string_lossy().into_owned(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_TEAM_ID".to_string(),
-        identity.team_id.as_str().to_string(),
-    );
+    let leader_env = leader_env_for_identity(provider, &identity);
     let argv = start_argv(
         mode,
         provider,
@@ -119,6 +99,37 @@ pub fn leader_start_plan(
     })
 }
 
+pub(crate) fn leader_env_for_identity(
+    provider: Provider,
+    identity: &LeaderIdentity,
+) -> BTreeMap<String, String> {
+    let mut leader_env = BTreeMap::new();
+    leader_env.insert(
+        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+        provider_wire(provider).to_string(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_LEADER_SESSION_UUID".to_string(),
+        identity.leader_session_uuid.as_str().to_string(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
+        identity.machine_fingerprint.clone(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_WORKSPACE".to_string(),
+        identity.workspace_abspath.to_string_lossy().into_owned(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_TEAM_ID".to_string(),
+        identity.team_id.as_str().to_string(),
+    );
+    if provider == Provider::Copilot {
+        leader_env.insert("COPILOT_DISABLE_TERMINAL_TITLE".to_string(), "1".to_string());
+    }
+    leader_env
+}
+
 /// `start_leader`(card §46;`__init__.py:60`)。计算并执行 leader 启动计划(spawn + 信号处理)。
 /// 进程退出后 `Err`/退出码经 caller 处理(此处返 `Result` 替代 Python 的 `SystemExit`)。
 pub fn start_leader(

package/crates/team-agent/src/leader/tests/identity.rs

@@ -90,6 +90,28 @@ use super::*;
         }
     }
 
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_leader_env_disables_terminal_title_only_for_copilot() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_lsp_copilot_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let identity = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
+
+        let copilot = leader_env_for_identity(Provider::Copilot, &identity);
+        assert_eq!(
+            copilot.get("COPILOT_DISABLE_TERMINAL_TITLE").map(String::as_str),
+            Some("1")
+        );
+
+        for provider in [Provider::Codex, Provider::ClaudeCode] {
+            let leader_env = leader_env_for_identity(provider, &identity);
+            assert!(
+                !leader_env.contains_key("COPILOT_DISABLE_TERMINAL_TITLE"),
+                "{provider:?} leader env must not include copilot title override"
+            );
+        }
+    }
+
     // ═══════════════ P2 FIX-LOOP RED (复绿即对抗 cross-model findings) ═══════════════
     // Lock CORRECT Python v0.2.11 leader-identity behavior the contracts missed.
     // Golden re-probed via /tmp/probe_p2_leader.py vs team-agent-public @ 439bef8

package/crates/team-agent/src/leader/tests/wake_start_owner.rs

@@ -134,6 +134,19 @@ use super::*;
         assert!(got.as_str().starts_with("team-agent-leader-claude_code-proj-"), "got {}", got.as_str());
     }
 
+    #[test]
+    fn leader_session_name_uses_copilot_provider_string() {
+        let base = std::env::temp_dir().join(format!("ta_rs_lsn_copilot_{}", std::process::id()));
+        let dir = base.join("proj");
+        std::fs::create_dir_all(&dir).unwrap();
+        let got = leader_session_name(Provider::Copilot, &dir);
+        assert!(
+            got.as_str().starts_with("team-agent-leader-copilot-proj-"),
+            "got {}",
+            got.as_str()
+        );
+    }
+
     // =====================================================================
     // 6. Family A 正源 owner 绑定 — bind_owner_from_caller_pane(unimplemented → RED)
     // =====================================================================

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -77,10 +77,17 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     transport: &dyn crate::transport::Transport,
     session_converge_deadline_ms: Option<u64>,
 ) -> Result<RestartReport, LifecycleError> {
-    if crate::lifecycle::restart::input_has_no_local_team_context(workspace) {
+    // RED-2-STILL(P0):入口门必须在 canonical_run_workspace 解析后的路径上判,不用 raw workspace。
+    // 根因:quick-start <dir> 把 .team/runtime/spec 落在 team_workspace(dir)=**parent**/.team;
+    // 入口门查 raw dir 自身的 .team/state(空,它在 parent)→ 误判"无 team context"早退,到不了
+    // 067f78f 下移后的第二道门。canonical_run_workspace 已能正确解析到 parent(走 parent.join(".team")
+    // 分支),在它之上判 input_has_no_local_team_context 才对齐 quick-start 落点。
+    let resolved_ws = crate::model::paths::canonical_run_workspace(workspace)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if crate::lifecycle::restart::input_has_no_local_team_context(&resolved_ws) {
         return Err(LifecycleError::TeamSelect(format!(
-            "missing spec for restart: {}",
-            workspace.join("team.spec.yaml").display()
+            "missing spec for restart: {} (run `team-agent quick-start <teamdir>` first)",
+            crate::model::paths::runtime_dir(&resolved_ws).display()
         )));
     }
     // RED-2(P0)修:存在性门下移到 resolve 之后,用 selected.spec_path(读序 B:runtime 优先、

package/crates/team-agent/src/lifecycle/restart.rs

@@ -49,11 +49,15 @@ pub(crate) fn lifecycle_run_workspace(workspace: &Path) -> Result<std::path::Pat
 }
 
 fn lifecycle_paths(workspace: &Path, team: Option<&str>) -> Result<LifecyclePaths, LifecycleError> {
-    if input_has_no_local_team_context(workspace) {
+    // RED-2-STILL(P0):入口门在 canonical_run_workspace 解析后的路径上判(quick-start 的 .team 落
+    // team_dir 父目录,raw team_dir 必 miss)。期望路径报解析后 runtime 落点,不指 raw team_dir。
+    let resolved_ws = crate::model::paths::canonical_run_workspace(workspace)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if input_has_no_local_team_context(&resolved_ws) {
         return Err(LifecycleError::TeamSelect(format!(
-            "active team spec not found: input_workspace={} expected_spec_path={}",
+            "active team spec not found: input_workspace={} expected_runtime_dir={}",
             workspace.display(),
-            workspace.join("team.spec.yaml").display()
+            crate::model::paths::runtime_dir(&resolved_ws).display()
         )));
     }
     let selected = crate::state::selector::resolve_active_team(

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -581,6 +581,82 @@ fn red2_restart_empty_workspace_still_reports_missing() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+// RED-2-STILL (P0) — the ENTRY gate (input_has_no_local_team_context) must judge on the
+// canonical_run_workspace-resolved path, not raw. quick-start <team_dir> lands .team under the
+// resolved workspace (team_dir's parent when invoked from there); restart <team_dir> with raw gate
+// checks team_dir's own (empty) .team → false "no context" early-exit before the down-moved gate.
+//
+// Two forms (leader hard requirement — must lock BOTH, not the coincidental same-dir form):
+//   Form A: .team in the team_dir's PARENT (standard quick-start <dir> from parent cwd).
+//   Form B: .team in the team_dir itself (cwd == team_dir).
+#[test]
+fn red2still_entry_gate_resolves_parent_dot_team_form_a() {
+    // Build: base/  (has .team)  + base/teamdir/{TEAM.md, agents/} (role docs, NO own .team).
+    let base = temp_ws();
+    let team_dir = base.join("teamdir");
+    std::fs::create_dir_all(team_dir.join("agents")).unwrap();
+    std::fs::write(team_dir.join("TEAM.md"), "---\nname: teamdir\nobjective: o\nprovider: codex\n---\nt.\n").unwrap();
+    std::fs::write(team_dir.join("agents").join("w1.md"), QS_VALID_ROLE).unwrap();
+    // .team lives in the PARENT (base), with a runtime spec — mirrors quick-start <dir> from base cwd.
+    let spec = crate::compiler::compile_team(&team_dir).unwrap();
+    let runtime_spec = crate::model::paths::runtime_spec_path(&base, "teamdir");
+    std::fs::create_dir_all(runtime_spec.parent().unwrap()).unwrap();
+    std::fs::write(&runtime_spec, crate::model::yaml::dumps(&spec)).unwrap();
+    // Seed minimal team state under base so resolve finds it.
+    crate::state::persist::save_runtime_state(
+        &base,
+        &json!({"session_name": "team-teamdir", "team_dir": team_dir.to_string_lossy(),
+                "spec_path": runtime_spec.to_string_lossy(),
+                "agents": {"w1": {"status": "running", "provider": "codex"}}}),
+    )
+    .unwrap();
+    // Entry gate on team_dir: raw team_dir has NO .team (it's in parent), but resolved → base has it.
+    assert!(
+        crate::lifecycle::restart::input_has_no_local_team_context(&team_dir),
+        "precondition: raw team_dir has no local .team (it's in the parent)"
+    );
+    let resolved = crate::model::paths::canonical_run_workspace(&team_dir).unwrap();
+    assert!(
+        !crate::lifecycle::restart::input_has_no_local_team_context(&resolved),
+        "RED-2-STILL: gate on canonical_run_workspace-resolved path must see parent .team (false)"
+    );
+    // Full restart on team_dir must NOT early-exit with missing spec.
+    let transport = OfflineTransport::new();
+    let text = format!("{:?}", restart_with_transport(&team_dir, false, None, &transport));
+    assert!(
+        !text.contains("missing spec for restart") && !text.contains("active team spec not found"),
+        "RED-2-STILL Form A: restart <team_dir> (.team in parent) must not report missing; got {text}"
+    );
+    let _ = std::fs::remove_dir_all(&base);
+}
+
+#[test]
+fn red2still_entry_gate_same_dir_dot_team_form_b() {
+    // Form B: .team in team_dir itself (cwd == team_dir at quick-start time).
+    let team_dir = temp_ws();
+    std::fs::create_dir_all(team_dir.join("agents")).unwrap();
+    std::fs::write(team_dir.join("TEAM.md"), "---\nname: tb\nobjective: o\nprovider: codex\n---\nt.\n").unwrap();
+    std::fs::write(team_dir.join("agents").join("w1.md"), QS_VALID_ROLE).unwrap();
+    let spec = crate::compiler::compile_team(&team_dir).unwrap();
+    let runtime_spec = crate::model::paths::runtime_spec_path(&team_dir, "tb");
+    std::fs::create_dir_all(runtime_spec.parent().unwrap()).unwrap();
+    std::fs::write(&runtime_spec, crate::model::yaml::dumps(&spec)).unwrap();
+    crate::state::persist::save_runtime_state(
+        &team_dir,
+        &json!({"session_name": "team-tb", "team_dir": team_dir.to_string_lossy(),
+                "spec_path": runtime_spec.to_string_lossy(),
+                "agents": {"w1": {"status": "running", "provider": "codex"}}}),
+    )
+    .unwrap();
+    let transport = OfflineTransport::new();
+    let text = format!("{:?}", restart_with_transport(&team_dir, false, None, &transport));
+    assert!(
+        !text.contains("missing spec for restart") && !text.contains("active team spec not found"),
+        "RED-2-STILL Form B: restart <team_dir> (.team in team_dir) must not report missing; got {text}"
+    );
+    let _ = std::fs::remove_dir_all(&team_dir);
+}
+
 // E5 task#3 / RC-A6b — restart with role definitions MISSING explicitly refuses (lists what's
 // missing) and leaves the previous runtime spec in place (no silent path, no data destruction).
 #[test]

package/crates/team-agent/src/messaging/results.rs

@@ -689,28 +689,33 @@ pub fn report_result_for_owner_team(
                     std::thread::sleep(std::time::Duration::from_millis(50));
                 }
             }
-            match inject_leader_notification_direct(workspace, &delivery_state, &content, &message_id) {
-                Ok(()) => {
-                    store.mark(&message_id, "delivered", None)?;
-                    outcome = crate::messaging::DeliveryOutcome {
-                        ok: true,
-                        status: crate::messaging::DeliveryStatus::Delivered,
-                        message_status: super::helpers::MessageStatusShadow("delivered".to_string()),
-                        message_id: Some(message_id),
-                        verification: None,
-                        stage: None,
-                        reason: None,
-                        channel: Some("leader_receiver".to_string()),
-                    };
-                }
-                Err(reason) => {
-                    event_log.write(
-                        "leader_receiver.direct_inject_skipped",
-                        serde_json::json!({
-                            "message_id": message_id,
-                            "reason": reason,
-                        }),
-                    )?;
+            // E15(F4.4 双投修):direct inject 是 deliver **失败时的兜底**,不是无条件第二投。
+            // deliver loop 成功(outcome.ok)→ 跳过 direct inject,leader 仅收 deliver 那一条;
+            // 全失败 → direct inject 兜底投一条(不丢 result,守 #230/MUST-8)。两全:恰一条。
+            if !outcome.ok {
+                match inject_leader_notification_direct(workspace, &delivery_state, &content, &message_id) {
+                    Ok(()) => {
+                        store.mark(&message_id, "delivered", None)?;
+                        outcome = crate::messaging::DeliveryOutcome {
+                            ok: true,
+                            status: crate::messaging::DeliveryStatus::Delivered,
+                            message_status: super::helpers::MessageStatusShadow("delivered".to_string()),
+                            message_id: Some(message_id),
+                            verification: None,
+                            stage: None,
+                            reason: None,
+                            channel: Some("leader_receiver".to_string()),
+                        };
+                    }
+                    Err(reason) => {
+                        event_log.write(
+                            "leader_receiver.direct_inject_skipped",
+                            serde_json::json!({
+                                "message_id": message_id,
+                                "reason": reason,
+                            }),
+                        )?;
+                    }
                 }
             }
     }

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1435,3 +1435,21 @@ fn r8_attach_requeue_exhausted_to_notify_failed_golden_attach_event() {
     assert_eq!(ev.get("trigger").and_then(|v| v.as_str()), Some("attach_leader"));
     assert_eq!(ev.get("new_pane_id").and_then(|v| v.as_str()), Some("%leader-new"));
 }
+
+// E15 (F4.4 双投修)·源码守卫:report_result 的 direct inject 必须被 `if !outcome.ok` 守为
+// deliver 失败时的真兜底,绝不在 deliver 成功后无条件再投一次(=用户看到两条同内容回复)。
+#[test]
+fn e15_direct_inject_is_gated_by_deliver_failure_not_unconditional() {
+    let src = include_str!("../results.rs");
+    // 锁:inject_leader_notification_direct 调用点之前必须有 `if !outcome.ok` 门。
+    let gate = "if !outcome.ok {";
+    let inject_call = "match inject_leader_notification_direct(";
+    let gate_pos = src.find(gate);
+    let inject_pos = src.find(inject_call);
+    assert!(gate_pos.is_some(), "E15: direct inject must be gated by `if !outcome.ok` (deliver-fail fallback)");
+    assert!(inject_pos.is_some(), "inject_leader_notification_direct call site must exist (do NOT delete it; #230 fallback)");
+    assert!(
+        gate_pos.unwrap() < inject_pos.unwrap(),
+        "E15: the `if !outcome.ok` gate must precede the direct-inject call (deliver-success must skip inject → leader gets exactly one copy)"
+    );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.3.8",
-    "@team-agent/cli-darwin-x64": "0.3.8",
-    "@team-agent/cli-linux-x64": "0.3.8"
+    "@team-agent/cli-darwin-arm64": "0.3.9",
+    "@team-agent/cli-darwin-x64": "0.3.9",
+    "@team-agent/cli-linux-x64": "0.3.9"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",