@team-agent/installer 0.3.27 → 0.3.28

package/crates/team-agent/src/layout/sessions.rs

@@ -0,0 +1,277 @@
+//! 0.3.28 layout step 1 — session name constructors + topology invariant guard.
+//!
+//! Python 0.2.11 truth source (recap):
+//!   * Leader runs in a SEPARATE tmux session named
+//!     `team-agent-leader-<provider>-<folder>-<sha1[:8]>` (the existing
+//!     `crate::leader::start::leader_session_name`).
+//!   * Worker session is `runtime.session_name` or `team-<team.name>` (the
+//!     existing `lifecycle::launch::spec_session_name`).
+//!   * These two names MUST be disjoint by prefix
+//!     (`team-agent-leader-` vs `team-...`).
+//!
+//! This module re-exports those name constructors under a single namespace
+//! and adds the topology invariant guard. No behaviour change in Step 1;
+//! the guard runs as `tracing::warn!` so any drift is logged but not fatal.
+
+use std::path::Path;
+
+use crate::model::enums::Provider;
+use crate::model::yaml::Value as YamlValue;
+use crate::transport::SessionName;
+use serde_json::Value as JsonValue;
+
+/// `team-agent-leader-` — disjoint prefix for the leader session.
+/// Re-exported from `leader::start::LEADER_SESSION_PREFIX` so layout-layer
+/// code does not have to depend on the leader module's internals.
+pub const LEADER_SESSION_PREFIX: &str = crate::leader::start::LEADER_SESSION_PREFIX;
+
+/// Leader's dedicated tmux session name.
+///
+/// Format: `team-agent-leader-<provider_wire>-<folder>-<sha1(workspace)[:8]>`.
+///
+/// Re-exports `crate::leader::start::leader_session_name` so the rest of the
+/// runtime can derive this name without touching the leader module. The
+/// single underlying impl lives in `leader/start.rs` for now to minimise the
+/// Step-1 diff; Step 2 will move it.
+pub fn leader_session_name(provider: Provider, workspace: &Path) -> SessionName {
+    crate::leader::start::leader_session_name(provider, workspace)
+}
+
+/// Worker tmux session name derived from the team spec.
+///
+/// Format: `spec.runtime.session_name` if set, else `team-<team.name>`
+/// (default `team-agent`). This is a thin re-export of the existing
+/// `lifecycle::launch::worker_session_name_pub` — exposed here so layout-
+/// layer code has one place to ask. The spec is a `model::yaml::Value`
+/// (the team spec parser's native type).
+pub fn worker_session_name(spec: &YamlValue) -> SessionName {
+    crate::lifecycle::launch::worker_session_name_pub(spec)
+}
+
+/// True when `name` starts with the leader session prefix.
+pub fn is_leader_session(name: &SessionName) -> bool {
+    name.as_str().starts_with(LEADER_SESSION_PREFIX)
+}
+
+/// True when `name` equals the worker session name derived from `spec`.
+pub fn is_worker_session(name: &SessionName, spec: &YamlValue) -> bool {
+    worker_session_name(spec).as_str() == name.as_str()
+}
+
+/// A detected topology invariant violation, surfaced as a warn-level log line
+/// during the incremental migration (Steps 1–9). Hard error in Step 10.
+#[derive(Debug, Clone)]
+pub struct TopologyViolation {
+    pub kind: TopologyViolationKind,
+    pub detail: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TopologyViolationKind {
+    /// Worker session name shares the leader-session prefix.
+    WorkerSessionNamedAsLeader,
+    /// A worker window inside the worker session is named `leader`.
+    WorkerWindowNamedLeader,
+    /// Two agents share the same `pane_id` in state.
+    AgentPaneIdCollision,
+    /// `leader_receiver.pane_id` matches an active agent's `pane_id`.
+    LeaderPaneIdCollidesWithAgent,
+}
+
+/// Assert the runtime-state topology invariants (Step 1 — `warn!` only).
+///
+/// Checks:
+///   1. The worker session name does NOT start with the leader prefix.
+///   2. No agent window in worker session is literally named `leader`.
+///   3. No two agents share the same `pane_id`.
+///   4. `state.leader_receiver.pane_id` is not equal to any agent's
+///      `pane_id` (E51 family — co-located lease corruption).
+///
+/// Returns the list of violations without panicking. Callers may choose to
+/// emit `tracing::warn!` for each (the default in Steps 1–9) or escalate.
+pub fn assert_topology_invariants(state: &JsonValue, spec: &YamlValue) -> Vec<TopologyViolation> {
+    let mut out = Vec::new();
+    let worker_session = worker_session_name(spec);
+    if worker_session.as_str().starts_with(LEADER_SESSION_PREFIX) {
+        out.push(TopologyViolation {
+            kind: TopologyViolationKind::WorkerSessionNamedAsLeader,
+            detail: format!(
+                "worker session name `{}` starts with leader prefix `{LEADER_SESSION_PREFIX}` — \
+                 leader and worker sessions must be disjoint",
+                worker_session.as_str()
+            ),
+        });
+    }
+    let agents = state
+        .get("agents")
+        .and_then(JsonValue::as_object);
+    if let Some(agents) = agents {
+        for (agent_id, agent) in agents {
+            let window = agent.get("window").and_then(JsonValue::as_str).unwrap_or("");
+            if window.eq_ignore_ascii_case("leader") {
+                out.push(TopologyViolation {
+                    kind: TopologyViolationKind::WorkerWindowNamedLeader,
+                    detail: format!(
+                        "agent `{agent_id}` lives in window `leader` of worker session \
+                         `{}` — workers must use `agent_id` window names",
+                        worker_session.as_str()
+                    ),
+                });
+            }
+        }
+        // Pane-id collision among agents.
+        let mut by_pane: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
+        for (agent_id, agent) in agents {
+            if let Some(pane) = agent
+                .get("pane_id")
+                .and_then(JsonValue::as_str)
+                .filter(|s| !s.is_empty())
+            {
+                by_pane
+                    .entry(pane.to_string())
+                    .or_default()
+                    .push(agent_id.to_string());
+            }
+        }
+        for (pane, ids) in by_pane.iter() {
+            if ids.len() > 1 {
+                out.push(TopologyViolation {
+                    kind: TopologyViolationKind::AgentPaneIdCollision,
+                    detail: format!(
+                        "pane_id `{pane}` shared by agents {ids:?} — at most one agent may bind a pane_id"
+                    ),
+                });
+            }
+        }
+        // leader_receiver.pane_id ∉ any agent.pane_id.
+        let leader_pane = state
+            .get("leader_receiver")
+            .and_then(|lr| lr.get("pane_id"))
+            .and_then(JsonValue::as_str)
+            .filter(|s| !s.is_empty());
+        if let Some(leader_pane) = leader_pane {
+            for (agent_id, agent) in agents {
+                if agent
+                    .get("pane_id")
+                    .and_then(JsonValue::as_str)
+                    .is_some_and(|p| p == leader_pane)
+                {
+                    out.push(TopologyViolation {
+                        kind: TopologyViolationKind::LeaderPaneIdCollidesWithAgent,
+                        detail: format!(
+                            "leader_receiver.pane_id `{leader_pane}` is also bound to \
+                             agent `{agent_id}` — leader pane and agent pane must be disjoint"
+                        ),
+                    });
+                }
+            }
+        }
+    }
+    out
+}
+
+/// Logs each violation in `violations` to stderr under the
+/// `team_agent::layout` tag. No-op when the list is empty. This is the
+/// Step-1 surface — `eprintln!` matches the codebase's existing logging
+/// convention (see `lifecycle::launch::eprintln!` calls). Hard error path
+/// is deferred to Step 10.
+pub fn log_topology_violations(violations: &[TopologyViolation]) {
+    for v in violations {
+        eprintln!(
+            "team_agent::layout topology_invariant_violation kind={:?} detail={}",
+            v.kind, v.detail
+        );
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn spec_for(team: &str) -> YamlValue {
+        YamlValue::Map(vec![(
+            "team".to_string(),
+            YamlValue::Map(vec![("name".to_string(), YamlValue::Str(team.to_string()))]),
+        )])
+    }
+
+    #[test]
+    fn leader_and_worker_session_names_are_disjoint_by_prefix() {
+        let leader = leader_session_name(Provider::Claude, Path::new("/tmp/proj"));
+        let worker = worker_session_name(&spec_for("alpha"));
+        assert!(
+            leader.as_str().starts_with(LEADER_SESSION_PREFIX),
+            "leader name `{}` must start with `{LEADER_SESSION_PREFIX}`",
+            leader.as_str()
+        );
+        assert!(
+            !worker.as_str().starts_with(LEADER_SESSION_PREFIX),
+            "worker name `{}` must NOT start with `{LEADER_SESSION_PREFIX}`",
+            worker.as_str()
+        );
+        assert_ne!(leader.as_str(), worker.as_str());
+        assert!(is_leader_session(&leader));
+        assert!(!is_leader_session(&worker));
+        assert!(is_worker_session(&worker, &spec_for("alpha")));
+        assert!(!is_worker_session(&leader, &spec_for("alpha")));
+    }
+
+    #[test]
+    fn assert_topology_clean_state_returns_empty() {
+        let state = json!({
+            "agents": {
+                "developer": { "pane_id": "%1", "window": "developer" },
+                "tester":    { "pane_id": "%2", "window": "tester" }
+            },
+            "leader_receiver": { "pane_id": "%0" }
+        });
+        let v = assert_topology_invariants(&state, &spec_for("alpha"));
+        assert!(v.is_empty(), "clean state should produce no violations; got {v:?}");
+    }
+
+    #[test]
+    fn assert_topology_flags_pane_id_collision() {
+        let state = json!({
+            "agents": {
+                "developer": { "pane_id": "%1", "window": "developer" },
+                "tester":    { "pane_id": "%1", "window": "tester" }
+            },
+            "leader_receiver": { "pane_id": "%0" }
+        });
+        let v = assert_topology_invariants(&state, &spec_for("alpha"));
+        assert!(
+            v.iter().any(|x| matches!(x.kind, TopologyViolationKind::AgentPaneIdCollision)),
+            "must flag AgentPaneIdCollision; got {v:?}"
+        );
+    }
+
+    #[test]
+    fn assert_topology_flags_leader_pane_overlap_with_agent() {
+        let state = json!({
+            "agents": {
+                "developer": { "pane_id": "%0", "window": "developer" }
+            },
+            "leader_receiver": { "pane_id": "%0" }
+        });
+        let v = assert_topology_invariants(&state, &spec_for("alpha"));
+        assert!(
+            v.iter().any(|x| matches!(x.kind, TopologyViolationKind::LeaderPaneIdCollidesWithAgent)),
+            "must flag LeaderPaneIdCollidesWithAgent; got {v:?}"
+        );
+    }
+
+    #[test]
+    fn assert_topology_flags_worker_window_named_leader() {
+        let state = json!({
+            "agents": {
+                "stray": { "pane_id": "%5", "window": "leader" }
+            }
+        });
+        let v = assert_topology_invariants(&state, &spec_for("alpha"));
+        assert!(
+            v.iter().any(|x| matches!(x.kind, TopologyViolationKind::WorkerWindowNamedLeader)),
+            "must flag WorkerWindowNamedLeader; got {v:?}"
+        );
+    }
+}

package/crates/team-agent/src/layout/worker_env.rs

@@ -0,0 +1,267 @@
+//! 0.3.28 layout step 3 — worker spawn env (inherit-then-strip) + worker
+//! spawn cwd (YAML-only).
+//!
+//! Python truth source actual behavior (`providers.py:130-145` + contract
+//! test `worker_spawn_env_red`): worker env INHERITS the parent
+//! `team-agent` process environment (proxy / CA / PATH / random user
+//! vars like `NODE_EXTRA_CA_CERTS`) just like the user typing `codex`
+//! in the same terminal, then OVERLAYS the Team Agent identity
+//! (`TEAM_AGENT_WORKSPACE`, `TEAM_AGENT_ID`, `TEAM_AGENT_AGENT_ID`,
+//! `TEAM_AGENT_OWNER_TEAM_ID`).
+//!
+//! The leader's identity-specific env vars (`TEAM_AGENT_LEADER_*`,
+//! `TEAM_AGENT_MACHINE_FINGERPRINT`, `TEAM_AGENT_TEAM_ID`,
+//! `COPILOT_DISABLE_TERMINAL_TITLE`, `TMUX`, `TMUX_PANE`) are STRIPPED
+//! to prevent E60 identity contamination.
+//!
+//! Pre-0.3.28-final used a WHITELIST (only specific keys pass through)
+//! which broke `worker_spawn_env_red` by dropping legitimate user env
+//! (`NODE_EXTRA_CA_CERTS`, etc.). Switched to inherit-then-strip per
+//! leader verdict.
+//!
+//! Python uses `workspace` as the spawn cwd unconditionally; no
+//! per-agent override field exists in the spec. Rust pre-0.3.28 honoured
+//! `agent.spawn_cwd` from STATE which drifts (E56). Step 3 reads only
+//! YAML `spec.agent.spawn_cwd` and falls through to `workspace`.
+
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+use crate::model::yaml::Value as YamlValue;
+
+/// Env-key PREFIXES that are stripped from the inherited parent env
+/// before worker spawn. These carry leader-process identity and must
+/// not leak into worker provider TUIs (E60 root cause).
+const STRIP_PREFIXES: &[&str] = &[
+    "TEAM_AGENT_LEADER_",
+    "TEAM_AGENT_LEADER_BYPASS",
+    "TEAM_AGENT_MACHINE_FINGERPRINT",
+];
+
+/// Exact env-keys stripped from the inherited parent env.
+const STRIP_EXACT: &[&str] = &[
+    // The leader's team_id; the worker's TEAM_AGENT_OWNER_TEAM_ID overlay
+    // re-supplies the relevant scope.
+    "TEAM_AGENT_TEAM_ID",
+    // Suppresses copilot's title-rewrite — must be re-injected by
+    // `apply_copilot_instructions_overlay` based on per-agent provider,
+    // not inherited from the leader's provider.
+    "COPILOT_DISABLE_TERMINAL_TITLE",
+    // TMUX env points at the leader's pane — would attach the worker to it.
+    "TMUX",
+    "TMUX_PANE",
+];
+
+/// Build the worker spawn env per Python inherit-then-strip semantics.
+///
+/// Inputs:
+///   * `parent_env`: the team-agent process env (typically
+///     `std::env::vars()`). The whole env is inherited then filtered.
+///   * `workspace`: the team workspace root.
+///   * `agent_id`: this worker's agent_id.
+///   * `team_id`: optional owner team id.
+///
+/// Output: a `BTreeMap` containing:
+///   * All POSIX-valid shell identifier keys from `parent_env` EXCEPT
+///     those matching `STRIP_PREFIXES` / `STRIP_EXACT`.
+///   * Overlay: `TEAM_AGENT_WORKSPACE`, `TEAM_AGENT_ID`,
+///     `TEAM_AGENT_AGENT_ID`, `TEAM_AGENT_OWNER_TEAM_ID` (when present).
+///
+/// POSIX-validity filter: shell variable names must match
+/// `[A-Za-z_][A-Za-z0-9_]*`. Cargo's integration-test runner exports keys
+/// like `CARGO_BIN_EXE_team-agent` that contain a dash — those would
+/// break `sh -lc KEY=val` assignment and are dropped.
+pub fn worker_spawn_env<I>(
+    parent_env: I,
+    workspace: &Path,
+    agent_id: &str,
+    team_id: Option<&str>,
+) -> BTreeMap<String, String>
+where
+    I: IntoIterator<Item = (String, String)>,
+{
+    let mut env: BTreeMap<String, String> = BTreeMap::new();
+    for (k, v) in parent_env {
+        if is_stripped(&k) {
+            continue;
+        }
+        if !is_posix_shell_identifier(&k) {
+            continue;
+        }
+        env.insert(k, v);
+    }
+    env.insert(
+        "TEAM_AGENT_WORKSPACE".to_string(),
+        workspace.to_string_lossy().to_string(),
+    );
+    env.insert("TEAM_AGENT_ID".to_string(), agent_id.to_string());
+    env.insert("TEAM_AGENT_AGENT_ID".to_string(), agent_id.to_string());
+    if let Some(tid) = team_id.filter(|s| !s.is_empty()) {
+        env.insert("TEAM_AGENT_OWNER_TEAM_ID".to_string(), tid.to_string());
+    }
+    env
+}
+
+fn is_stripped(key: &str) -> bool {
+    if STRIP_EXACT.iter().any(|exact| *exact == key) {
+        return true;
+    }
+    if STRIP_PREFIXES.iter().any(|p| key.starts_with(p)) {
+        return true;
+    }
+    false
+}
+
+fn is_posix_shell_identifier(s: &str) -> bool {
+    let mut bytes = s.bytes();
+    let Some(first) = bytes.next() else { return false };
+    if !(first.is_ascii_alphabetic() || first == b'_') {
+        return false;
+    }
+    bytes.all(|b| b.is_ascii_alphanumeric() || b == b'_')
+}
+
+/// Compute worker spawn cwd per Python semantics: YAML
+/// `agent.spawn_cwd` if set, else `workspace`. The persisted-state
+/// `agent.spawn_cwd` override (the pre-0.3.28 Rust extension that caused
+/// E56 drift) is NOT consulted.
+pub fn worker_spawn_cwd(spec_agent: &YamlValue, workspace: &Path) -> PathBuf {
+    spec_agent
+        .get("spawn_cwd")
+        .and_then(YamlValue::as_str)
+        .filter(|s| !s.is_empty())
+        .map(PathBuf::from)
+        .unwrap_or_else(|| workspace.to_path_buf())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_parent_env(extras: &[(&str, &str)]) -> Vec<(String, String)> {
+        let mut env = vec![
+            ("PATH".to_string(), "/usr/bin:/bin".to_string()),
+            ("HOME".to_string(), "/Users/test".to_string()),
+            ("TERM".to_string(), "xterm-256color".to_string()),
+            ("CLAUDE_API_KEY".to_string(), "sk-test".to_string()),
+            ("OPENAI_API_KEY".to_string(), "sk-test".to_string()),
+            ("COPILOT_TOKEN".to_string(), "tok".to_string()),
+            // Leader identity — must be stripped.
+            ("TEAM_AGENT_LEADER_PROVIDER".to_string(), "claude".to_string()),
+            ("TEAM_AGENT_LEADER_SESSION_UUID".to_string(), "leader-uuid".to_string()),
+            ("TEAM_AGENT_MACHINE_FINGERPRINT".to_string(), "fp".to_string()),
+            ("TEAM_AGENT_TEAM_ID".to_string(), "alpha".to_string()),
+            ("TEAM_AGENT_LEADER_BYPASS".to_string(), "1".to_string()),
+            ("COPILOT_DISABLE_TERMINAL_TITLE".to_string(), "1".to_string()),
+            // Random noise — non-whitelisted prefix.
+            ("RANDOM_NOISE".to_string(), "x".to_string()),
+            ("TMUX".to_string(), "leader-pane".to_string()),
+            ("TMUX_PANE".to_string(), "%0".to_string()),
+        ];
+        for (k, v) in extras {
+            env.push((k.to_string(), v.to_string()));
+        }
+        env
+    }
+
+    #[test]
+    fn worker_spawn_env_strips_leader_identity_keys() {
+        let env = worker_spawn_env(
+            make_parent_env(&[]),
+            Path::new("/ws"),
+            "developer",
+            Some("alpha"),
+        );
+        for stripped in [
+            "TEAM_AGENT_LEADER_PROVIDER",
+            "TEAM_AGENT_LEADER_SESSION_UUID",
+            "TEAM_AGENT_MACHINE_FINGERPRINT",
+            "TEAM_AGENT_TEAM_ID",
+            "TEAM_AGENT_LEADER_BYPASS",
+            "COPILOT_DISABLE_TERMINAL_TITLE",
+            "TMUX",
+            "TMUX_PANE",
+        ] {
+            assert!(
+                !env.contains_key(stripped),
+                "worker env must not contain leader identity key `{stripped}`; env={env:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn worker_spawn_env_injects_agent_workspace_and_team_keys() {
+        let env = worker_spawn_env(
+            make_parent_env(&[]),
+            Path::new("/ws"),
+            "developer",
+            Some("alpha"),
+        );
+        assert_eq!(env.get("TEAM_AGENT_ID").map(String::as_str), Some("developer"));
+        assert_eq!(env.get("TEAM_AGENT_AGENT_ID").map(String::as_str), Some("developer"));
+        assert_eq!(env.get("TEAM_AGENT_WORKSPACE").map(String::as_str), Some("/ws"));
+        assert_eq!(env.get("TEAM_AGENT_OWNER_TEAM_ID").map(String::as_str), Some("alpha"));
+    }
+
+    #[test]
+    fn worker_spawn_env_inherits_parent_env_minus_strip_list() {
+        let env = worker_spawn_env(
+            make_parent_env(&[]),
+            Path::new("/ws"),
+            "developer",
+            None,
+        );
+        // Inherit-then-strip: every parent key passes through EXCEPT the
+        // strip list. PATH-like + provider creds + random user vars all
+        // present.
+        assert!(env.contains_key("PATH"));
+        assert!(env.contains_key("HOME"));
+        assert!(env.contains_key("TERM"));
+        assert!(env.contains_key("CLAUDE_API_KEY"));
+        assert!(env.contains_key("OPENAI_API_KEY"));
+        // Random user env (e.g. NODE_EXTRA_CA_CERTS, TA_SPAWN_ENV_CANARY)
+        // MUST pass through — this was the worker_spawn_env_red contract
+        // that the pre-final whitelist approach broke.
+        assert!(
+            env.contains_key("RANDOM_NOISE"),
+            "0.3.28 final: worker env inherits parent — random user vars \
+             must pass through (NODE_EXTRA_CA_CERTS / TA_SPAWN_ENV_CANARY \
+             contract). Got env={env:?}"
+        );
+    }
+
+    #[test]
+    fn worker_spawn_env_drops_posix_invalid_keys() {
+        let parent = make_parent_env(&[("CARGO_BIN_EXE_team-agent", "/bin/x")]);
+        let env = worker_spawn_env(parent, Path::new("/ws"), "developer", None);
+        assert!(!env.contains_key("CARGO_BIN_EXE_team-agent"));
+    }
+
+    #[test]
+    fn worker_spawn_cwd_returns_workspace_when_no_spec_override() {
+        // YAML agent with no spawn_cwd field.
+        let agent = YamlValue::Map(vec![("id".to_string(), YamlValue::Str("developer".to_string()))]);
+        assert_eq!(worker_spawn_cwd(&agent, Path::new("/ws")), PathBuf::from("/ws"));
+    }
+
+    #[test]
+    fn worker_spawn_cwd_returns_yaml_override_when_present() {
+        let agent = YamlValue::Map(vec![
+            ("id".to_string(), YamlValue::Str("developer".to_string())),
+            ("spawn_cwd".to_string(), YamlValue::Str("/explicit/cwd".to_string())),
+        ]);
+        assert_eq!(
+            worker_spawn_cwd(&agent, Path::new("/ws")),
+            PathBuf::from("/explicit/cwd")
+        );
+    }
+
+    #[test]
+    fn worker_spawn_cwd_returns_workspace_when_spec_override_is_empty() {
+        let agent = YamlValue::Map(vec![
+            ("id".to_string(), YamlValue::Str("developer".to_string())),
+            ("spawn_cwd".to_string(), YamlValue::Str("".to_string())),
+        ]);
+        assert_eq!(worker_spawn_cwd(&agent, Path::new("/ws")), PathBuf::from("/ws"));
+    }
+}

package/crates/team-agent/src/layout/worker_window_helpers.rs

@@ -0,0 +1,35 @@
+//! 0.3.28 layout step 2 — small provider-wire helper for layout-layer window naming.
+//!
+//! Mirrors `leader::helpers::provider_wire` so the layout module does not
+//! depend on the leader module's private helpers. Single source of truth
+//! is `provider_command_name` from `crate::provider::adapter` (the
+//! authoritative provider→string mapping).
+
+use crate::model::enums::Provider;
+
+/// Window name used inside the leader session, derived from the provider's
+/// wire identifier (e.g. `claude`, `codex`, `copilot`, `fake`). Mirrors
+/// Python's `leader_window_name = provider` (see
+/// `runtime/0.2.11/src/team_agent/leader/__init__.py:114-131`).
+pub fn provider_window_name(provider: Provider) -> &'static str {
+    match provider {
+        Provider::Claude | Provider::ClaudeCode => "claude",
+        Provider::Codex => "codex",
+        Provider::Copilot => "copilot",
+        Provider::GeminiCli => "gemini",
+        Provider::Fake => "fake",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn provider_window_names_are_lowercase_wire_strings() {
+        assert_eq!(provider_window_name(Provider::Claude), "claude");
+        assert_eq!(provider_window_name(Provider::ClaudeCode), "claude");
+        assert_eq!(provider_window_name(Provider::Codex), "codex");
+        assert_eq!(provider_window_name(Provider::Copilot), "copilot");
+    }
+}

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

@@ -53,12 +53,18 @@ pub fn leader_start_plan(
     let state = crate::state::persist::load_runtime_state(workspace).ok();
     let identity = leader_identity_context(workspace, None, state.as_ref())?;
     let external_path = external_leader || attach_existing || attach_session.is_some();
+    // 0.3.28 Step 2: managed mode now uses the SAME dedicated leader session
+    // as the external path (`team-agent-leader-<provider>-<folder>-<sha1[:8]>`)
+    // — Python parity. Pre-0.3.28 the managed branch used
+    // `managed_team_session_name(identity) = team-<team_id>` which is the
+    // worker session — that co-location is the structural root of
+    // E49/E51/E53/E57-3/E60.
     let session_name = if external_path {
         attach_session
             .cloned()
             .or_else(|| Some(leader_session_name(provider, workspace)))
     } else {
-        Some(managed_team_session_name(&identity))
+        Some(leader_session_name(provider, workspace))
     };
     let in_tmux = std::env::var_os("TMUX").is_some();
     if !in_tmux || !external_path {
@@ -107,8 +113,14 @@ pub fn leader_start_plan(
         session_name,
         argv,
         provider_argv,
+        // 0.3.28 Step 2: leader window inside the dedicated leader session is
+        // named after the provider wire (e.g. `claude`, `codex`, `copilot`),
+        // never the literal string `leader`. Python parity (see
+        // `leader/__init__.py:114-131`). This eliminates the `WorkerWindowNamedLeader`
+        // topology violation surface — the worker session never has a window
+        // named `leader` either, because the leader session is disjoint.
         leader_window: (mode == LeaderStartMode::ManagedTmuxClient)
-            .then(|| WindowName::new("leader")),
+            .then(|| WindowName::new(provider_wire(provider))),
         is_external_leader: external_path,
         leader_env: plan_env,
         identity: Some(identity),
@@ -265,7 +277,7 @@ fn start_argv(
             let Some(session) = session_name else {
                 return Err(LeaderError::Start("managed leader session missing".to_string()));
             };
-            managed_client_argv(workspace, session)
+            managed_client_argv(workspace, session, provider)
         }
         LeaderStartMode::AttachExisting => {
             let Some(session) = session_name else {
@@ -327,17 +339,21 @@ fn normalized_provider_args(provider_args: &[String]) -> impl Iterator<Item = St
         .cloned()
 }
 
-fn managed_team_session_name(identity: &LeaderIdentity) -> SessionName {
-    let team = identity.team_id.as_str();
-    if team.starts_with("team-") {
-        SessionName::new(team.to_string())
-    } else {
-        SessionName::new(format!("team-{team}"))
-    }
-}
+// 0.3.28 Step 2: `managed_team_session_name` deleted. Both managed and
+// external paths now compute the dedicated leader session via
+// `leader_session_name(provider, workspace)` directly. The old function
+// returned `team-<team_id>` which is the WORKER session — the structural
+// root of E49/E51/E53/E57-3/E60.
 
-fn managed_client_argv(workspace: &Path, session: &SessionName) -> Result<Vec<String>, LeaderError> {
-    let target = format!("{}:leader", session.as_str());
+fn managed_client_argv(
+    workspace: &Path,
+    session: &SessionName,
+    provider: Provider,
+) -> Result<Vec<String>, LeaderError> {
+    // 0.3.28 Step 2: leader window inside the dedicated leader session is
+    // named after `provider_wire(provider)` (e.g. `claude`, `codex`, `fake`),
+    // never the literal `leader`. Pre-0.3.28 this hardcoded `:leader`.
+    let target = format!("{}:{}", session.as_str(), provider_wire(provider));
     let argv = if std::env::var_os("TMUX").is_some() {
         vec![
             "tmux".to_string(),