@team-agent/installer 0.4.10 → 0.5.0

package/crates/team-agent/src/diagnose/orphans.rs

@@ -503,20 +503,43 @@ fn is_provider_or_mcp_workspace_command(command: &str) -> bool {
 }
 
 fn parse_workspace_arg(command: &str) -> Option<PathBuf> {
-    let mut parts = command.split_whitespace().peekable();
-    while let Some(part) = parts.next() {
-        if let Some(value) = part.strip_prefix("--workspace=") {
-            if !value.is_empty() {
-                return Some(PathBuf::from(value));
-            }
+    for (start, _) in command.match_indices("--workspace") {
+        let boundary_before = start == 0
+            || command
+                .get(..start)
+                .and_then(|prefix| prefix.chars().next_back())
+                .is_some_and(char::is_whitespace);
+        if !boundary_before {
+            continue;
+        }
+        let after = &command[start + "--workspace".len()..];
+        if let Some(value) = after.strip_prefix('=') {
+            return parse_workspace_value(value);
         }
-        if part == "--workspace" {
-            return parts.peek().map(PathBuf::from);
+        if after.chars().next().is_some_and(char::is_whitespace) {
+            return parse_workspace_value(after);
         }
     }
     None
 }
 
+fn parse_workspace_value(value: &str) -> Option<PathBuf> {
+    let value = value.trim_start();
+    if value.is_empty() {
+        return None;
+    }
+    let value = value
+        .split_once(" --")
+        .map(|(workspace, _)| workspace)
+        .unwrap_or(value)
+        .trim_end();
+    if value.is_empty() {
+        None
+    } else {
+        Some(PathBuf::from(value))
+    }
+}
+
 fn classify_workspace_orphan(workspace: &Path, pid: Pid) -> Option<OrphanReason> {
     if !workspace.is_absolute() {
         return None;
@@ -656,3 +679,38 @@ fn reason_key(reason: &OrphanReason) -> &'static str {
         OrphanReason::PidNotRunning => "pid_not_running",
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_workspace_arg_keeps_trailing_path_with_spaces() {
+        let command = "/tmp/team-agent coordinator --workspace /Volumes/projects/My Agent";
+
+        assert_eq!(
+            parse_workspace_arg(command),
+            Some(PathBuf::from("/Volumes/projects/My Agent"))
+        );
+    }
+
+    #[test]
+    fn parse_workspace_arg_stops_at_next_flag() {
+        let command = "/tmp/team-agent coordinator --workspace /tmp/My Agent --once";
+
+        assert_eq!(
+            parse_workspace_arg(command),
+            Some(PathBuf::from("/tmp/My Agent"))
+        );
+    }
+
+    #[test]
+    fn parse_workspace_arg_supports_equals_form_with_spaces() {
+        let command = "/tmp/team-agent coordinator --workspace=/tmp/My Agent --once";
+
+        assert_eq!(
+            parse_workspace_arg(command),
+            Some(PathBuf::from("/tmp/My Agent"))
+        );
+    }
+}

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

@@ -1,14 +1,12 @@
-//! 0.3.28 layout step 2 — small provider-wire helper for layout-layer window naming.
+//! 0.3.28 layout step 2 — small window grammar helper for layout-layer 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).
+//! Command/UI grammar, not provider identity parsing: leader window names
+//! intentionally collapse `claude_code` to `claude` and use executable-style
+//! labels such as `gemini`.
 
 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
+/// Window name used inside the leader session. 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 {

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

@@ -8,7 +8,9 @@ use crate::transport::PaneInfo;
 
 use super::helpers::{parse_provider, provider_wire};
 
-const PROVIDER_COMMANDS: &[(&str, Provider)] = &[
+// Command grammar, not provider identity parsing: these are process argv/current-command
+// needles observed in tmux panes.
+const COMMAND_GRAMMAR_PROVIDER_COMMANDS: &[(&str, Provider)] = &[
     ("claude", Provider::ClaudeCode),
     ("claude.exe", Provider::ClaudeCode),
     ("codex", Provider::Codex),
@@ -37,7 +39,7 @@ fn attribute_pane_provider_with_process(
 }
 
 pub(crate) fn attribute_command_provider(command: &str) -> Option<Provider> {
-    provider_from_text(command)
+    provider_from_command_text(command)
 }
 
 pub(crate) fn command_matches_provider(provider: Provider, command: &str) -> bool {
@@ -58,7 +60,7 @@ fn provider_from_env(env: &BTreeMap<String, String>) -> Option<Provider> {
 fn provider_from_pid_argv(pid: u32) -> Option<Provider> {
     process_command_line(pid)
         .as_deref()
-        .and_then(provider_from_text)
+        .and_then(provider_from_command_text)
 }
 
 fn provider_from_pid_env(pid: u32) -> Option<Provider> {
@@ -67,9 +69,9 @@ fn provider_from_pid_env(pid: u32) -> Option<Provider> {
         .and_then(provider_from_env_text)
 }
 
-fn provider_from_text(text: &str) -> Option<Provider> {
+fn provider_from_command_text(text: &str) -> Option<Provider> {
     let lower = text.to_ascii_lowercase();
-    PROVIDER_COMMANDS
+    COMMAND_GRAMMAR_PROVIDER_COMMANDS
         .iter()
         .find_map(|(needle, provider)| lower.contains(needle).then_some(*provider))
 }

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

@@ -7,6 +7,7 @@ use serde_json::{json, Value};
 
 use crate::model::ids::{LeaderSessionUuid, OwnerEpoch};
 use crate::provider::Provider;
+use crate::provider::wire::provider_wire;
 use crate::transport::{PaneId, PaneInfo, SessionName, Transport, WindowName};
 
 use super::helpers::{get_path_str, now_ts, parse_provider, prefix, resolve_workspace_for_hash, sha1_hex_prefix};
@@ -902,17 +903,6 @@ fn uuid_prefix(uuid: Option<&LeaderSessionUuid>) -> String {
     uuid.map_or_else(String::new, |value| prefix(value.as_str(), 8).to_string())
 }
 
-fn provider_wire(provider: Provider) -> &'static str {
-    match provider {
-        Provider::Claude => "claude",
-        Provider::ClaudeCode => "claude_code",
-        Provider::Codex => "codex",
-        Provider::Copilot => "copilot",
-        Provider::GeminiCli => "gemini_cli",
-        Provider::Fake => "fake",
-    }
-}
-
 fn event_provider(identity: &OwnerIdentity) -> &'static str {
     provider_wire(identity.provider.unwrap_or(Provider::Codex))
 }

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

@@ -61,12 +61,20 @@ pub fn leader_start_plan(
     // `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.
+    // 0.4.10+ mirror-session fix v2 (option B): managed-mode session name
+    // gets a per-launch nonce so each `team-agent <provider>` entry in the
+    // same workspace creates its OWN tmux session — matching the user
+    // expectation that `tmux new-session + claude` is independent every
+    // time. Pre-fix the managed path used the workspace-keyed name (same
+    // session for every entry) and silently attached the second client →
+    // UI mirror. The external/attach paths keep the stable workspace-keyed
+    // name (per-launch nonce would break `--attach-session` reattach).
     let session_name = if external_path {
         attach_session
             .cloned()
             .or_else(|| Some(leader_session_name(provider, workspace)))
     } else {
-        Some(leader_session_name(provider, workspace))
+        Some(managed_leader_session_name(provider, workspace))
     };
     let in_tmux = std::env::var_os("TMUX").is_some();
     if !in_tmux {
@@ -266,6 +274,42 @@ pub fn leader_session_name(provider: Provider, workspace: &Path) -> SessionName
     ))
 }
 
+/// 0.4.10+ mirror-session fix v2: managed-mode session name with a
+/// per-launch nonce.
+///
+/// Format: `team-agent-leader-<provider>-<folder>-<hash>-<nonce>`.
+/// `nonce` = `<pid_hex>-<epoch_nanos_hex>`. The pid distinguishes
+/// concurrent launches; the epoch_nanos distinguishes sequential ones.
+///
+/// Each `team-agent <provider>` entry in the managed (non-tmux) path gets
+/// its OWN session, matching the user expectation that `tmux new-session
+/// + claude` is independent every time. The workspace-keyed prefix is
+/// preserved so existing leader-session-anchored protections
+/// (`LEADER_SESSION_PREFIX` matchers in shutdown/cli/mod.rs) still
+/// classify these sessions as leader sessions.
+///
+/// External / attach paths keep the stable `leader_session_name` —
+/// per-launch nonce would break `--attach-session <name>` reattach
+/// semantics.
+pub fn managed_leader_session_name(provider: Provider, workspace: &Path) -> SessionName {
+    let resolved = resolve_workspace_for_hash(workspace);
+    let folder_raw = resolved
+        .file_name()
+        .and_then(|n| n.to_str())
+        .unwrap_or("workspace");
+    let folder = sanitize_session_folder(folder_raw);
+    let hash = sha1_hex_prefix(resolved.to_string_lossy().as_bytes(), 8);
+    let pid = std::process::id();
+    let epoch_nanos = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or(0);
+    SessionName::new(format!(
+        "{LEADER_SESSION_PREFIX}{}-{folder}-{hash}-{pid:x}-{epoch_nanos:x}",
+        provider_wire(provider)
+    ))
+}
+
 fn start_argv(
     mode: LeaderStartMode,
     provider: Provider,
@@ -423,31 +467,14 @@ fn ensure_managed_leader_pane(
     plan: &LeaderStartPlan,
     workspace: &Path,
 ) -> Result<SpawnResult, LeaderError> {
+    // 0.4.10+ mirror-session fix v2 (option B): each managed launch gets
+    // its OWN session name (via `managed_leader_session_name`'s nonce).
+    // The historical "session already exists → reuse pane" branch is
+    // structurally unreachable now (the per-launch session never
+    // preexists). If a caller bypasses the nonce path and reuses a name,
+    // tmux's own duplicate-session error will surface — better than
+    // silently attaching a second client.
     if transport.has_session(session).unwrap_or(false) {
-        if transport
-            .list_windows(session)
-            .unwrap_or_default()
-            .iter()
-            .any(|existing| existing.as_str() == window.as_str())
-        {
-            if let Some(existing) = transport
-                .list_targets()
-                .unwrap_or_default()
-                .into_iter()
-                .find(|pane| {
-                    pane.session.as_str() == session.as_str()
-                        && pane.window_name.as_ref().map(WindowName::as_str)
-                            == Some(window.as_str())
-                })
-            {
-                return Ok(SpawnResult {
-                    pane_id: existing.pane_id,
-                    session: session.clone(),
-                    window: window.clone(),
-                    child_pid: existing.pane_pid,
-                });
-            }
-        }
         // 0.4.x (CR C-1 + C-2): leader env_unset reuses the worker
         // provider_env_unsets (single source of truth) + spawn through the
         // leader shell wrapper so provider exit returns to a shell, not
@@ -1586,4 +1613,121 @@ mod tests {
         assert_eq!(sent[0].0, Target::Pane(PaneId::new("%0")));
         assert_eq!(sent[0].1, vec![Key::Enter]);
     }
+
+    // ═══════════════════════════════════════════════════════════════════
+    // 0.4.10+ mirror-session fix v2 (option B: independent session per launch).
+    //
+    // managed_leader_session_name appends a per-launch nonce so each
+    // `team-agent <provider>` entry in the same workspace creates its own
+    // tmux session, matching `tmux new-session + claude` semantics.
+    // ═══════════════════════════════════════════════════════════════════
+
+    #[test]
+    fn managed_leader_session_name_carries_leader_prefix() {
+        // Protection invariant: every session name returned by the
+        // managed path must still match LEADER_SESSION_PREFIX so the
+        // shutdown / cli/mod.rs prefix matchers still classify it as a
+        // leader session.
+        let workspace = std::env::temp_dir().join(format!(
+            "ta_rs_mgr_prefix_{}",
+            std::process::id()
+        ));
+        let _ = std::fs::create_dir_all(&workspace);
+        let name = super::managed_leader_session_name(Provider::ClaudeCode, &workspace);
+        assert!(
+            name.as_str().starts_with(super::super::LEADER_SESSION_PREFIX),
+            "managed session name must carry LEADER_SESSION_PREFIX (`{}`); \
+             got `{}`",
+            super::super::LEADER_SESSION_PREFIX,
+            name.as_str()
+        );
+        assert!(
+            name.as_str().contains("claude_code"),
+            "managed session name must include provider wire; got `{}`",
+            name.as_str()
+        );
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    #[test]
+    fn managed_leader_session_name_is_unique_per_call() {
+        // Two consecutive calls must return DIFFERENT names — the
+        // per-launch nonce defeats the mirror-session bug.
+        let workspace = std::env::temp_dir().join(format!(
+            "ta_rs_mgr_unique_{}",
+            std::process::id()
+        ));
+        let _ = std::fs::create_dir_all(&workspace);
+        let a = super::managed_leader_session_name(Provider::ClaudeCode, &workspace);
+        // Sleep > 1ns to ensure epoch_nanos advances even on coarse clocks.
+        std::thread::sleep(std::time::Duration::from_millis(1));
+        let b = super::managed_leader_session_name(Provider::ClaudeCode, &workspace);
+        assert_ne!(
+            a.as_str(),
+            b.as_str(),
+            "two managed launches in the same workspace must get \
+             DIFFERENT session names (mirror-session fix v2); got \
+             `{}` vs `{}`",
+            a.as_str(),
+            b.as_str()
+        );
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    #[test]
+    fn leader_session_name_is_stable_across_calls() {
+        // External / attach paths must keep the stable workspace-keyed
+        // name — `--attach-session <name>` reattach would break if the
+        // name varied per call.
+        let workspace = std::env::temp_dir().join(format!(
+            "ta_rs_lsn_stable_{}",
+            std::process::id()
+        ));
+        let _ = std::fs::create_dir_all(&workspace);
+        let a = super::leader_session_name(Provider::ClaudeCode, &workspace);
+        let b = super::leader_session_name(Provider::ClaudeCode, &workspace);
+        assert_eq!(
+            a.as_str(),
+            b.as_str(),
+            "leader_session_name must be deterministic per workspace \
+             (external/attach paths depend on stability); got `{}` vs `{}`",
+            a.as_str(),
+            b.as_str()
+        );
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    /// CR C-5 source grep guard: managed mode passes the nonce session
+    /// name through `leader_start_plan` so the per-launch independence
+    /// reaches `ensure_managed_leader_pane`. External/attach paths must
+    /// keep `leader_session_name`.
+    #[test]
+    fn managed_path_uses_nonce_session_name_grep_guard() {
+        let manifest = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+        let start_rs = manifest.join("src").join("leader").join("start.rs");
+        let contents =
+            std::fs::read_to_string(&start_rs).expect("read leader/start.rs");
+        // leader_start_plan must dispatch to managed_leader_session_name
+        // on the managed path.
+        let start = contents
+            .find("pub fn leader_start_plan(")
+            .expect("leader_start_plan must exist");
+        let end = contents[start + 1..]
+            .find("\npub fn ")
+            .or_else(|| contents[start + 1..].find("\nfn "))
+            .map(|p| start + 1 + p)
+            .unwrap_or(contents.len());
+        let body = &contents[start..end];
+        assert!(
+            body.contains("managed_leader_session_name(provider, workspace)"),
+            "leader_start_plan must call managed_leader_session_name on \
+             the managed path (mirror-session fix v2); body excerpt: {body}"
+        );
+        // The external_path branch must still use the stable name.
+        assert!(
+            body.contains("leader_session_name(provider, workspace)"),
+            "leader_start_plan must keep leader_session_name on the \
+             external/attach paths; body excerpt: {body}"
+        );
+    }
 }

package/crates/team-agent/src/lifecycle/launch/plan.rs

@@ -15,9 +15,8 @@ pub fn start_plan(
             plan_path.display()
         )));
     }
-    let text = std::fs::read_to_string(plan_path).map_err(|e| {
-        LifecycleError::InvalidPlan(format!("{}: {e}", plan_path.display()))
-    })?;
+    let text = std::fs::read_to_string(plan_path)
+        .map_err(|e| LifecycleError::InvalidPlan(format!("{}: {e}", plan_path.display())))?;
     let plan = yaml::loads(&text).map_err(|e| LifecycleError::InvalidPlan(e.to_string()))?;
     let plan_id = plan_id_from_plan(plan_path, &plan)?;
     let state_path = plan_state_path(workspace, &plan_id);
@@ -66,7 +65,8 @@ pub fn handle_report_result(
         return Ok(PlanProgress::NoMatch);
     };
     for entry in entries {
-        let entry = entry.map_err(|e| LifecycleError::InvalidPlan(format!("read plan dir: {e}")))?;
+        let entry =
+            entry.map_err(|e| LifecycleError::InvalidPlan(format!("read plan dir: {e}")))?;
         let path = entry.path();
         if path.extension().and_then(|s| s.to_str()) != Some("json") {
             continue;
@@ -112,10 +112,19 @@ fn plan_stages(plan: &Value) -> Result<Vec<PlanStage>, LifecycleError> {
             .transpose()?;
         stages.push(PlanStage {
             id,
-            assignee: raw.get("assignee").and_then(Value::as_str).map(AgentId::new),
-            prompt: raw.get("prompt").and_then(Value::as_str).map(str::to_string),
+            assignee: raw
+                .get("assignee")
+                .and_then(Value::as_str)
+                .map(AgentId::new),
+            prompt: raw
+                .get("prompt")
+                .and_then(Value::as_str)
+                .map(str::to_string),
             on_result: condition,
-            status: raw.get("status").and_then(Value::as_str).map(str::to_string),
+            status: raw
+                .get("status")
+                .and_then(Value::as_str)
+                .map(str::to_string),
         });
     }
     Ok(stages)
@@ -222,6 +231,8 @@ fn json_scalar_to_string(value: &serde_json::Value) -> Option<String> {
         serde_json::Value::String(s) => Some(s.clone()),
         serde_json::Value::Bool(b) => Some(b.to_string()),
         serde_json::Value::Number(n) => Some(n.to_string()),
-        serde_json::Value::Null | serde_json::Value::Array(_) | serde_json::Value::Object(_) => None,
+        serde_json::Value::Null | serde_json::Value::Array(_) | serde_json::Value::Object(_) => {
+            None
+        }
     }
 }