@team-agent/installer 0.4.11 → 0.5.1

package/crates/team-agent/src/provider/session_scan/copilot.rs

@@ -0,0 +1,202 @@
+use std::path::{Path, PathBuf};
+
+use crate::provider::types::{CaptureVia, CapturedSession, Confidence, RolloutPath, SessionId};
+
+use super::{CaptureSessionContext, CapturedSessionCandidate};
+
+pub(super) fn scan_session_store(context: &CaptureSessionContext) -> Vec<CapturedSessionCandidate> {
+    let Some(home) = std::env::var_os("HOME").map(PathBuf::from) else {
+        return Vec::new();
+    };
+    let db_path = home.join(".copilot").join("session-store.db");
+    if !db_path.exists() {
+        return Vec::new();
+    }
+    let Ok(conn) = rusqlite::Connection::open_with_flags(
+        &db_path,
+        rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
+    ) else {
+        return Vec::new();
+    };
+    if let Some(expected) = context.expected_session_id.as_ref() {
+        let hit: Option<String> = conn
+            .prepare("select id from sessions where id = ?1 limit 1")
+            .ok()
+            .and_then(|mut stmt| {
+                stmt.query_row([expected.as_str()], |row| row.get::<_, String>(0))
+                    .ok()
+            });
+        if let Some(session_id) = hit {
+            return vec![copilot_candidate(session_id, &db_path, context)];
+        }
+        return Vec::new();
+    }
+    let _ = (&db_path, &conn);
+    Vec::new()
+}
+
+fn copilot_candidate(
+    session_id: String,
+    db_path: &Path,
+    context: &CaptureSessionContext,
+) -> CapturedSessionCandidate {
+    CapturedSessionCandidate {
+        captured: CapturedSession {
+            session_id: Some(SessionId::new(session_id)),
+            rollout_path: Some(RolloutPath::new(db_path.to_path_buf())),
+            captured_via: CaptureVia::FsWatch,
+            attribution_confidence: Confidence::High,
+            spawn_cwd: context.spawn_cwd.clone(),
+        },
+        positive_agent_id_match: false,
+        agent_path_match: false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::unwrap_used)]
+
+    use super::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    struct HomeGuard {
+        prev: Option<std::ffi::OsString>,
+    }
+
+    impl HomeGuard {
+        fn set(home: &Path) -> Self {
+            let prev = std::env::var_os("HOME");
+            std::env::set_var("HOME", home);
+            Self { prev }
+        }
+    }
+
+    impl Drop for HomeGuard {
+        fn drop(&mut self) {
+            match &self.prev {
+                Some(v) => std::env::set_var("HOME", v),
+                None => std::env::remove_var("HOME"),
+            }
+        }
+    }
+
+    fn tmp_root(tag: &str) -> PathBuf {
+        static CTR: AtomicU64 = AtomicU64::new(0);
+        let dir = std::env::temp_dir().join(format!(
+            "ta-e11-copilot-{}-{}-{}",
+            tag,
+            std::process::id(),
+            CTR.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    fn seed_copilot_db(home: &Path, rows: &[(&str, &str, i64)]) {
+        let dir = home.join(".copilot");
+        std::fs::create_dir_all(&dir).unwrap();
+        let conn = rusqlite::Connection::open(dir.join("session-store.db")).unwrap();
+        conn.execute(
+            "create table sessions (id text primary key, cwd text, updated_at integer)",
+            [],
+        )
+        .unwrap();
+        for (id, cwd, updated) in rows {
+            conn.execute(
+                "insert into sessions (id, cwd, updated_at) values (?1, ?2, ?3)",
+                rusqlite::params![id, cwd, updated],
+            )
+            .unwrap();
+        }
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_expected_id_wins_over_leader_latest_same_cwd() {
+        let base = tmp_root("expected");
+        let home = base.join("home");
+        std::fs::create_dir_all(&home).unwrap();
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let worker_id = "1142c4c2-0000-4000-8000-000000000001";
+        let leader_id = "f9c5485d-0000-4000-8000-00000000beef";
+        seed_copilot_db(
+            &home,
+            &[
+                (worker_id, &cwd.to_string_lossy(), 100),
+                (leader_id, &cwd.to_string_lossy(), 999),
+            ],
+        );
+        let home_guard = HomeGuard::set(&home);
+        let ctx = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: Some(SessionId::new(worker_id)),
+            provider_projects_root: None,
+        };
+        let out = scan_session_store(&ctx);
+        assert_eq!(out.len(), 1);
+        assert_eq!(
+            out[0].captured.session_id.as_ref().unwrap().as_str(),
+            worker_id
+        );
+        drop(home_guard);
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_expected_id_absent_in_db_returns_empty_not_leader() {
+        let base = tmp_root("absent");
+        let home = base.join("home");
+        std::fs::create_dir_all(&home).unwrap();
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let leader_id = "f9c5485d-0000-4000-8000-00000000beef";
+        seed_copilot_db(&home, &[(leader_id, &cwd.to_string_lossy(), 999)]);
+        let home_guard = HomeGuard::set(&home);
+        let ctx = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: Some(SessionId::new("1142c4c2-0000-4000-8000-000000000001")),
+            provider_projects_root: None,
+        };
+        let out = scan_session_store(&ctx);
+        assert!(out.is_empty());
+        drop(home_guard);
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_no_expected_same_cwd_only_leader_row_returns_empty_not_leader() {
+        let base = tmp_root("noexp");
+        let home = base.join("home");
+        std::fs::create_dir_all(&home).unwrap();
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let leader_id = "f9c5485d-0000-4000-8000-00000000beef";
+        seed_copilot_db(&home, &[(leader_id, &cwd.to_string_lossy(), 999)]);
+        let home_guard = HomeGuard::set(&home);
+        let ctx = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: None,
+            provider_projects_root: None,
+        };
+        let out = scan_session_store(&ctx);
+        assert!(out.is_empty());
+        drop(home_guard);
+        let _ = std::fs::remove_dir_all(&base);
+    }
+}

package/crates/team-agent/src/provider/session_scan.rs

@@ -1,49 +1,87 @@
-//! unit-7 (Stage 3) — provider session-scan boundary.
+//! Provider session-scan boundary.
 //!
-//! Dedicated home for provider transcript/backing scanning concerns
-//! (today co-located in adapter.rs around lines 511-546 and 969-1078).
-//! Created as part of the unit-7 boundary establishment; full relocation
-//! of the scanning fns is staged into follow-up commits so each diff
-//! stays reviewable.
-//!
-//! See sibling [`crate::provider::session::capture`] for the existing
-//! polling layer (moved under provider/session in unit-6).
+//! `ProviderAdapter` keeps the public polling facade in `adapter.rs`; this
+//! module owns one-shot backing-store scans and provider-specific attribution
+//! filters.
+
+use std::path::PathBuf;
+
+use crate::provider::types::{CapturedSession, ProviderError, SessionId};
+use crate::provider::Provider;
 
-/// Marker label for which scan strategy a provider uses. The Codex jsonl
-/// scan and the Claude transcript scan share the same outer "decide what
-/// to call" hook in adapter.rs; this enum exists to name the branch.
+pub(crate) mod claude;
+pub(crate) mod codex;
+pub(crate) mod common;
+pub(crate) mod copilot;
+
+/// Marker label for which scan strategy a provider uses.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SessionScanStrategy {
-    /// Codex rollout jsonl scan (the existing
-    /// `agent_rollout_path`-based check).
     CodexJsonl,
-    /// Claude transcript scan (per-cwd `.claude/projects/<cwd>/*.jsonl`).
     ClaudeTranscript,
-    /// Copilot scan (different home; provider-specific layout).
     CopilotHome,
-    /// Provider does not require a backing scan to decide resume — the
-    /// session-id alone is the authority.
     NotRequired,
 }
 
 impl SessionScanStrategy {
-    pub fn for_provider(provider: crate::provider::Provider) -> Self {
+    pub fn for_provider(provider: Provider) -> Self {
         match provider {
-            crate::provider::Provider::Codex => Self::CodexJsonl,
-            crate::provider::Provider::Claude | crate::provider::Provider::ClaudeCode => {
-                Self::ClaudeTranscript
-            }
-            crate::provider::Provider::Copilot => Self::CopilotHome,
-            crate::provider::Provider::GeminiCli => Self::NotRequired,
-            crate::provider::Provider::Fake => Self::NotRequired,
+            Provider::Codex => Self::CodexJsonl,
+            Provider::Claude | Provider::ClaudeCode => Self::ClaudeTranscript,
+            Provider::Copilot => Self::CopilotHome,
+            Provider::GeminiCli => Self::NotRequired,
+            Provider::Fake => Self::NotRequired,
         }
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CaptureSessionContext {
+    pub agent_id: String,
+    pub spawn_cwd: PathBuf,
+    pub pane_id: Option<String>,
+    pub pane_pid: Option<u32>,
+    pub spawned_at: Option<String>,
+    pub expected_session_id: Option<SessionId>,
+    pub provider_projects_root: Option<PathBuf>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CapturedSessionCandidate {
+    pub captured: CapturedSession,
+    pub positive_agent_id_match: bool,
+    pub agent_path_match: bool,
+}
+
+pub(crate) fn scan_session_candidates_once(
+    provider: Provider,
+    context: &CaptureSessionContext,
+) -> Result<Vec<CapturedSessionCandidate>, ProviderError> {
+    if matches!(provider, Provider::Copilot) {
+        return Ok(copilot::scan_session_store(context));
+    }
+
+    let candidates = common::candidate_session_files(provider, context)?;
+    let mut out = common::parse_candidate_files(provider, context, candidates);
+
+    if matches!(provider, Provider::Codex) {
+        codex::apply_spawned_at_filter(&mut out, context);
+    }
+
+    if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
+        return claude::apply_expected_session_filter(context, out);
+    }
+
+    common::apply_spawn_time_window_if_unique(context, &mut out);
+    common::sort_expected_first_if_needed(context, &mut out);
+    Ok(out)
+}
+
+pub(crate) use claude::rollout_path_has_leader_marker as rollout_path_has_claude_leader_marker;
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::provider::Provider;
 
     #[test]
     fn strategy_per_provider() {

package/crates/team-agent/src/provider/tests/faults.rs

@@ -44,6 +44,10 @@ fn p2_claude_api_error_fault_requires_level_error() {
     assert_eq!(facts.len(), 1);
     assert_eq!(facts[0].signature.as_str(), "api_error");
     assert_eq!(facts[0].turn_id.as_ref().map(TurnId::as_str), Some("s-1"));
+    assert_eq!(facts[0].api_error_status, None);
+    assert_eq!(facts[0].error.as_deref(), None);
+    assert_eq!(facts[0].request_id.as_deref(), None);
+    assert_eq!(facts[0].assistant_uuid.as_deref(), None);
 }
 
 // P1 — claude api_error turn_id fallback chain = sessionId -> parentUuid -> uuid
@@ -61,6 +65,82 @@ fn p2_claude_api_error_turn_id_fallback_parentuuid_then_uuid() {
     assert_eq!(f2[0].turn_id.as_ref().map(TurnId::as_str), Some("uu-1"));
 }
 
+#[test]
+fn p2_claude_assistant_api_error_fault_uses_uuid_and_structured_details() {
+    let records = vec![serde_json::json!({
+        "type": "assistant",
+        "parentUuid": "parent-1",
+        "uuid": "assistant-1",
+        "requestId": "req_011CceNfWj2aPY5gtCdakULt",
+        "message": {"role": "assistant", "content": [
+            {"type": "text", "text": "There's an issue with the selected model."}
+        ]},
+        "error": "model_not_found",
+        "isApiErrorMessage": true,
+        "apiErrorStatus": 404,
+        "sessionId": "session-1",
+        "version": "2.1.181"
+    })];
+
+    let facts = read_fault_facts(&records, Provider::ClaudeCode);
+
+    assert_eq!(facts.len(), 1);
+    assert_eq!(facts[0].signature.as_str(), "api_error");
+    assert_eq!(facts[0].turn_id.as_ref().map(TurnId::as_str), Some("assistant-1"));
+    assert_eq!(facts[0].api_error_status, Some(404));
+    assert_eq!(facts[0].error.as_deref(), Some("model_not_found"));
+    assert_eq!(facts[0].request_id.as_deref(), Some("req_011CceNfWj2aPY5gtCdakULt"));
+    assert_eq!(facts[0].assistant_uuid.as_deref(), Some("assistant-1"));
+}
+
+#[test]
+fn p2_latest_explicit_error_fact_scans_claude_tail_past_bookkeeping() {
+    let text = [
+        line(serde_json::json!({
+            "type": "assistant",
+            "parentUuid": "245fce6f-2427-4b05-af01-8619df64afab",
+            "uuid": "94e88d55-aac7-46bc-85cd-b7fcfc8a9ef6",
+            "requestId": "req_011CceUVQ94dxahgwAHf8sdS",
+            "message": {"role": "assistant", "content": [
+                {"type": "text", "text": "There's an issue with the selected model."}
+            ]},
+            "error": "model_not_found",
+            "isApiErrorMessage": true,
+            "apiErrorStatus": 404,
+            "sessionId": "97ec1070-f19b-49ed-b60f-3cb158e92053",
+            "version": "2.1.181"
+        })),
+        line(serde_json::json!({
+            "type": "system",
+            "subtype": "turn_duration",
+            "uuid": "6c96328b-8c01-46c0-b68e-a096a89c904f",
+            "parentUuid": "94e88d55-aac7-46bc-85cd-b7fcfc8a9ef6",
+            "sessionId": "97ec1070-f19b-49ed-b60f-3cb158e92053"
+        })),
+        line(serde_json::json!({"type": "file-history-snapshot"})),
+    ]
+    .join("\n");
+
+    let fact = latest_explicit_error_fact(Provider::ClaudeCode, &text)
+        .expect("Claude assistant API error must survive following bookkeeping rows");
+
+    assert_eq!(fact.signature.as_str(), "api_error");
+    assert_eq!(
+        fact.turn_id.as_ref().map(TurnId::as_str),
+        Some("94e88d55-aac7-46bc-85cd-b7fcfc8a9ef6")
+    );
+    assert_eq!(fact.api_error_status, Some(404));
+    assert_eq!(fact.error.as_deref(), Some("model_not_found"));
+    assert_eq!(fact.request_id.as_deref(), Some("req_011CceUVQ94dxahgwAHf8sdS"));
+    assert_eq!(
+        fact.assistant_uuid.as_deref(),
+        Some("94e88d55-aac7-46bc-85cd-b7fcfc8a9ef6")
+    );
+    assert!(latest_explicit_error_fact(Provider::Copilot, &text).is_none());
+    assert!(latest_explicit_error_fact(Provider::GeminiCli, &text).is_none());
+    assert!(latest_explicit_error_fact(Provider::Fake, &text).is_none());
+}
+
 // P1 — codex requestApproval turn_id = params.turnId OR params.turn_id (codex.py:79).
 #[test]
 fn p2_codex_approval_turn_id_accepts_snake_case() {

package/crates/team-agent/src/provider/types.rs

@@ -452,12 +452,44 @@ pub struct ClassifyResult {
 }
 
 /// abnormal track 消费的 fault/approval fact(`provider_state.read_fault_facts`)。
-/// C8 dedup key = `(signature, turn_id)`。`turn_id` 可 `None`(`api_error` 无 ids)。
+/// C8 dedup key = `(signature, turn_id)`。`turn_id` 可 `None`(旧 `api_error` 可无 ids)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FaultFact {
     pub signature: Signature,
     pub turn_id: Option<TurnId>,
     pub kind: FactKind,
+    pub api_error_status: Option<i64>,
+    pub error: Option<String>,
+    pub request_id: Option<String>,
+    pub assistant_uuid: Option<String>,
+}
+
+impl FaultFact {
+    pub fn new(signature: Signature, turn_id: Option<TurnId>, kind: FactKind) -> Self {
+        Self {
+            signature,
+            turn_id,
+            kind,
+            api_error_status: None,
+            error: None,
+            request_id: None,
+            assistant_uuid: None,
+        }
+    }
+
+    pub fn with_api_error_details(
+        mut self,
+        api_error_status: Option<i64>,
+        error: Option<String>,
+        request_id: Option<String>,
+        assistant_uuid: Option<String>,
+    ) -> Self {
+        self.api_error_status = api_error_status;
+        self.error = error;
+        self.request_id = request_id;
+        self.assistant_uuid = assistant_uuid;
+        self
+    }
 }
 
 /// take-over reminder 判定结果(`idle_predicate.evaluate_takeover_reminder` `_result`)。

package/crates/team-agent/src/provider/wire.rs

@@ -51,6 +51,52 @@ pub(crate) fn parse_provider(raw: &str) -> Option<Provider> {
     None
 }
 
+/// Parse only canonical persisted provider wire strings.
+///
+/// Use this for spec/schema surfaces that historically rejected aliases such as
+/// `claude-code`; use [`parse_provider`] when reading state/log fields where
+/// historical aliases must remain accepted.
+pub(crate) fn parse_canonical_provider(raw: &str) -> Option<Provider> {
+    all_providers()
+        .iter()
+        .copied()
+        .find(|provider| provider_wire(*provider) == raw)
+}
+
+pub(crate) fn all_providers() -> &'static [Provider] {
+    ALL_PROVIDERS
+}
+
+pub(crate) fn is_claude_family(provider: Provider) -> bool {
+    matches!(provider, Provider::Claude | Provider::ClaudeCode)
+}
+
+pub(crate) fn requires_resume_backing(provider: Provider) -> bool {
+    matches!(
+        provider,
+        Provider::Codex | Provider::Claude | Provider::ClaudeCode | Provider::Copilot
+    )
+}
+
+pub(crate) fn provider_model_keys(provider: Provider) -> &'static [&'static str] {
+    match provider {
+        Provider::Claude => &["claude", "claude_code"],
+        Provider::ClaudeCode => &["claude_code", "claude"],
+        Provider::Codex => &["codex"],
+        Provider::Copilot => &["copilot"],
+        Provider::GeminiCli => &["gemini_cli"],
+        Provider::Fake => &["fake"],
+    }
+}
+
+pub(crate) fn builtin_provider_model(provider: Provider) -> Option<&'static str> {
+    match provider {
+        Provider::Claude | Provider::ClaudeCode => Some("claude-sonnet-4-6"),
+        Provider::Codex => Some("gpt-5.5"),
+        Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
+    }
+}
+
 /// All aliases (including the canonical wire form) that parse to `provider`.
 /// The canonical wire form is always the first entry, so callers that need
 /// the "primary" string can take `aliases(p)[0]` — though most code should
@@ -97,10 +143,18 @@ mod tests {
     use super::*;
 
     #[test]
-    fn wire_round_trip_for_every_provider() {
+    fn provider_wire_round_trip_all_providers() {
         for &p in ALL_PROVIDERS {
             let wire = provider_wire(p);
             assert_eq!(parse_provider(wire), Some(p), "round-trip {p:?}");
+            assert_eq!(
+                parse_canonical_provider(wire),
+                Some(p),
+                "canonical parse {p:?}"
+            );
+            for alias in aliases(p) {
+                assert_eq!(parse_provider(alias), Some(p), "alias {alias:?} -> {p:?}");
+            }
         }
     }
 
@@ -110,6 +164,122 @@ mod tests {
         assert_eq!(parse_provider("claude-code"), Some(Provider::ClaudeCode));
     }
 
+    #[test]
+    fn provider_wire_migrated_sites_compile_without_local_provider_clones() {
+        let capture_rs = include_str!("session/capture.rs");
+        let restart_selection_rs = include_str!("../lifecycle/restart/selection.rs");
+        let model_spec_rs = include_str!("../model/spec.rs");
+        let compiler_rs = include_str!("../compiler.rs");
+        let delivery_rs = include_str!("../messaging/delivery.rs");
+        let rediscover_rs = include_str!("../leader/rediscover.rs");
+        let profile_smoke_rs = include_str!("../lifecycle/profile_smoke.rs");
+        let diagnose_rs = include_str!("../cli/diagnose.rs");
+
+        assert!(
+            capture_rs.contains("provider::wire") && capture_rs.contains("parse_provider"),
+            "session capture must import the canonical provider parser"
+        );
+        assert!(
+            !capture_rs.contains("fn parse_provider("),
+            "session capture must not carry a local provider parser copy"
+        );
+        assert!(
+            capture_rs.contains("is_claude_family"),
+            "session capture must use typed Claude-family detection"
+        );
+        assert!(
+            restart_selection_rs.contains("parse_canonical_provider")
+                && restart_selection_rs.contains("requires_resume_backing"),
+            "restart selection must route resumable backing through typed provider helpers"
+        );
+        assert!(
+            !restart_selection_rs.contains(r#""codex" | "claude" | "claude_code" | "copilot""#),
+            "restart selection must not keep a local resumable provider string match"
+        );
+        assert!(
+            !model_spec_rs.contains("SUPPORTED_PROVIDERS"),
+            "model spec must not keep a local provider whitelist"
+        );
+        assert!(
+            model_spec_rs.contains("parse_canonical_provider")
+                && model_spec_rs.contains("is_claude_family"),
+            "model spec must validate providers through typed helpers"
+        );
+        assert!(
+            compiler_rs.contains("parse_canonical_provider")
+                && compiler_rs.contains("provider_model_keys")
+                && compiler_rs.contains("wire_builtin_provider_model"),
+            "compiler effort/model defaults must use typed provider helpers"
+        );
+        assert!(
+            delivery_rs.contains("parse_canonical_provider")
+                && delivery_rs.contains("parse_provider")
+                && delivery_rs.contains("provider_wire"),
+            "message delivery provider dispatch must use wire helpers"
+        );
+        for (path, source) in [
+            ("leader/rediscover.rs", rediscover_rs),
+            ("lifecycle/profile_smoke.rs", profile_smoke_rs),
+            ("cli/diagnose.rs", diagnose_rs),
+        ] {
+            assert!(
+                !source.contains("fn provider_wire("),
+                "{path} must not carry a local provider_wire clone"
+            );
+            assert!(
+                source.contains("provider::wire"),
+                "{path} must import provider wire helpers"
+            );
+        }
+    }
+
+    #[test]
+    fn provider_wire_command_grammar_sites_are_named_helpers_not_provider_parse() {
+        let provider_attribution_rs = include_str!("../leader/provider_attribution.rs");
+        let worker_window_helpers_rs = include_str!("../layout/worker_window_helpers.rs");
+        let runtime_detectors_rs = include_str!("../coordinator/runtime_detectors.rs");
+        let emit_rs = include_str!("../cli/emit.rs");
+        let messaging_helpers_rs = include_str!("../messaging/helpers.rs");
+
+        assert!(
+            provider_attribution_rs.contains("COMMAND_GRAMMAR_PROVIDER_COMMANDS")
+                && provider_attribution_rs.contains("provider_from_command_text"),
+            "leader provider attribution must name command grammar explicitly"
+        );
+        assert!(
+            worker_window_helpers_rs.contains("provider_window_name")
+                && worker_window_helpers_rs.contains("Command/UI grammar"),
+            "worker window helpers must keep a named window grammar helper"
+        );
+        assert!(
+            runtime_detectors_rs.contains("runtime_event_provider_name")
+                && runtime_detectors_rs.contains("Event-field grammar"),
+            "runtime detectors must name event provider grammar explicitly"
+        );
+        assert!(
+            emit_rs.contains("LEADER_PASSTHROUGH_COMMANDS")
+                && emit_rs.contains("is_leader_passthrough_command"),
+            "CLI emit must name passthrough command grammar explicitly"
+        );
+        assert!(
+            messaging_helpers_rs.contains("non_provider_command")
+                && messaging_helpers_rs.contains("Activity command grammar"),
+            "messaging helpers must name activity command grammar explicitly"
+        );
+        for (path, source) in [
+            ("leader/provider_attribution.rs", provider_attribution_rs),
+            ("layout/worker_window_helpers.rs", worker_window_helpers_rs),
+            ("coordinator/runtime_detectors.rs", runtime_detectors_rs),
+            ("cli/emit.rs", emit_rs),
+            ("messaging/helpers.rs", messaging_helpers_rs),
+        ] {
+            assert!(
+                !source.contains("parse_canonical_provider"),
+                "{path} is command/UI grammar and must not reuse provider identity parsing"
+            );
+        }
+    }
+
     #[test]
     fn unknown_string_returns_none() {
         assert_eq!(parse_provider(""), None);