@team-agent/installer 0.5.59 → 0.5.61

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

@@ -4,12 +4,40 @@ pub(super) fn parse_spawned_at(raw: &str) -> Option<std::time::SystemTime> {
         .map(|dt| std::time::SystemTime::from(dt.with_timezone(&chrono::Utc)))
 }
 
+pub(super) fn truncate_to_uuid_precision(
+    timestamp: std::time::SystemTime,
+) -> Option<std::time::SystemTime> {
+    let since_epoch = timestamp
+        .duration_since(std::time::SystemTime::UNIX_EPOCH)
+        .ok()?;
+    std::time::SystemTime::UNIX_EPOCH.checked_add(std::time::Duration::from_millis(
+        u64::try_from(since_epoch.as_millis()).ok()?,
+    ))
+}
+
 pub(super) fn rollout_created_at(path: &std::path::Path) -> Option<std::time::SystemTime> {
     created_at_from_rollout_uuid(path)
         .or_else(|| created_at_from_rollout_head(path))
         .or_else(|| created_at_from_rollout_filename(path))
 }
 
+pub(super) fn apply_expected_session_filter(
+    context: &super::CaptureSessionContext,
+    mut out: Vec<super::CapturedSessionCandidate>,
+) -> Vec<super::CapturedSessionCandidate> {
+    let Some(expected) = context.expected_session_id.as_ref() else {
+        return out;
+    };
+    out.retain(|candidate| {
+        candidate
+            .captured
+            .session_id
+            .as_ref()
+            .is_some_and(|session| session.as_str() == expected.as_str())
+    });
+    out
+}
+
 pub(super) fn retain_spawn_cwd(
     context: &super::CaptureSessionContext,
     out: &mut Vec<super::CapturedSessionCandidate>,

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

@@ -26,25 +26,36 @@ pub(super) fn candidate_session_files(
 ) -> Result<Vec<SessionCandidate>, ProviderError> {
     let mut out = Vec::new();
     if let Some(root) = context.provider_projects_root.as_ref() {
-        collect_optional_candidate_files(root, &context.agent_id, &mut out)?;
+        let allowed_team_root =
+            matches!(provider, Provider::Claude | Provider::ClaudeCode).then_some(root.as_path());
+        collect_optional_candidate_files(root, &context.agent_id, allowed_team_root, &mut out)?;
     }
-    collect_candidate_files(&context.spawn_cwd, &context.agent_id, 0, false, &mut out)?;
+    collect_candidate_files(
+        &context.spawn_cwd,
+        &context.agent_id,
+        0,
+        false,
+        None,
+        &mut out,
+    )?;
     if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
         match provider {
             Provider::Codex => {
                 collect_optional_candidate_files(
                     &home.join(".codex").join("sessions"),
                     &context.agent_id,
+                    None,
                     &mut out,
                 )?;
             }
             Provider::Claude | Provider::ClaudeCode => {
                 if let Some(dir) = super::claude::projects_dir_for_cwd(&home, &context.spawn_cwd) {
-                    collect_optional_candidate_files(&dir, &context.agent_id, &mut out)?;
+                    collect_optional_candidate_files(&dir, &context.agent_id, None, &mut out)?;
                 }
                 collect_optional_candidate_files(
                     &home.join(".claude").join("projects"),
                     &context.agent_id,
+                    None,
                     &mut out,
                 )?;
             }
@@ -146,13 +157,23 @@ pub(super) fn apply_spawned_at_filter(
         out.clear();
         return;
     };
+    let codex_spawned_at =
+        if matches!(provider, Provider::Codex) && context.expected_session_id.is_some() {
+            let Some(timestamp) = super::codex::truncate_to_uuid_precision(spawned_at) else {
+                out.clear();
+                return;
+            };
+            timestamp
+        } else {
+            spawned_at
+        };
     out.retain(|candidate| {
         let Some(path) = candidate.captured.rollout_path.as_ref() else {
             return false;
         };
         if matches!(provider, Provider::Codex) {
             return super::codex::rollout_created_at(path.as_path())
-                .is_some_and(|created_at| created_at >= spawned_at);
+                .is_some_and(|created_at| created_at >= codex_spawned_at);
         }
         candidate_mtime(path.as_path()).is_some_and(|mtime| mtime >= spawned_at)
     });
@@ -265,10 +286,11 @@ fn complete_head_text(bytes: &[u8]) -> String {
 fn collect_optional_candidate_files(
     dir: &Path,
     agent_id: &str,
+    allowed_team_root: Option<&Path>,
     out: &mut Vec<SessionCandidate>,
 ) -> Result<(), ProviderError> {
     if dir.exists() {
-        let _ = collect_candidate_files(dir, agent_id, 0, true, out);
+        let _ = collect_candidate_files(dir, agent_id, 0, true, allowed_team_root, out);
     }
     Ok(())
 }
@@ -278,6 +300,7 @@ fn collect_candidate_files(
     agent_id: &str,
     depth: usize,
     requires_cwd_match: bool,
+    allowed_team_root: Option<&Path>,
     out: &mut Vec<SessionCandidate>,
 ) -> Result<(), ProviderError> {
     if depth > 4 {
@@ -299,9 +322,10 @@ fn collect_candidate_files(
                 agent_id,
                 depth.saturating_add(1),
                 requires_cwd_match,
+                allowed_team_root,
                 out,
             )?;
-        } else if looks_like_session_file(&path, agent_id) {
+        } else if looks_like_session_file(&path, agent_id, allowed_team_root) {
             out.push(SessionCandidate {
                 path,
                 requires_cwd_match,
@@ -311,8 +335,10 @@ fn collect_candidate_files(
     Ok(())
 }
 
-fn looks_like_session_file(path: &Path, agent_id: &str) -> bool {
-    if path_is_under_team_runtime(path) {
+fn looks_like_session_file(path: &Path, agent_id: &str, allowed_team_root: Option<&Path>) -> bool {
+    if path_is_under_team_runtime(path)
+        && !allowed_team_root.is_some_and(|root| path.starts_with(root))
+    {
         return false;
     }
     let Some(name) = path.file_name().and_then(|s| s.to_str()) else {

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

@@ -61,6 +61,11 @@ pub(crate) fn scan_session_candidates_once(
     if matches!(provider, Provider::Copilot) {
         return Ok(copilot::scan_session_store(context));
     }
+    if matches!(provider, Provider::Claude | Provider::ClaudeCode)
+        && context.expected_session_id.is_some()
+    {
+        return Ok(claude::scan_expected_session(context));
+    }
 
     let candidates = common::candidate_session_files(provider, context)?;
     let mut out = common::parse_candidate_files(provider, context, candidates);
@@ -72,6 +77,9 @@ pub(crate) fn scan_session_candidates_once(
     if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
         return claude::apply_expected_session_filter(context, out);
     }
+    if matches!(provider, Provider::Codex) {
+        out = codex::apply_expected_session_filter(context, out);
+    }
 
     common::apply_spawn_time_window_if_unique(provider, context, &mut out);
     common::sort_expected_first_if_needed(context, &mut out);

package/crates/team-agent/src/topology.rs

@@ -399,6 +399,9 @@ fn append_worker_pane_binding_issues(
     let Some(agents) = state.get("agents").and_then(Value::as_object) else {
         return;
     };
+    if agents.is_empty() {
+        return;
+    }
     let Ok(live_targets) = backend.list_targets() else {
         return;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.59",
+  "version": "0.5.61",
   "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.5.59",
-    "@team-agent/cli-darwin-x64": "0.5.59",
-    "@team-agent/cli-linux-x64": "0.5.59"
+    "@team-agent/cli-darwin-arm64": "0.5.61",
+    "@team-agent/cli-darwin-x64": "0.5.61",
+    "@team-agent/cli-linux-x64": "0.5.61"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/skills/team-agent/command-coverage.json

@@ -0,0 +1,379 @@
+{
+  "schema_version": "team-agent-skill-command-coverage-v3",
+  "commands": [
+    {
+      "command": "team-agent add-agent <agent> --role-file <file>",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute the documented argv in an isolated add-agent fixture and bind assertions to the CLI result and created roster/window."
+    },
+    {
+      "command": "team-agent add-agent reviewer --role-file .team/current/agents/reviewer.md --workspace .",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute the exact reviewer argv in an isolated fixture and assert the reviewer state, role provenance, and worker window."
+    },
+    {
+      "command": "team-agent approvals",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:approvals",
+      "plan": "Execute the default approvals view and bind assertions to its exit and approval-list output."
+    },
+    {
+      "command": "team-agent approvals <agent_id>",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:approvals",
+      "plan": "Execute a representative agent_id filter and assert the bound CLI result contains only that agent's approvals."
+    },
+    {
+      "command": "team-agent approvals [coder]",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:approvals",
+      "plan": "Execute the literal coder representative and assert the bound CLI result's target-filter behavior."
+    },
+    {
+      "command": "team-agent attach-leader",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:leader-channel",
+      "plan": "Execute in a hermetic caller-pane fixture and bind assertions to either the persisted receiver binding or the precise zero-write refusal."
+    },
+    {
+      "command": "team-agent claim-leader",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:leader-channel",
+      "plan": "Execute in a hermetic leader fixture and bind assertions to owner/receiver persistence or a precise zero-write refusal."
+    },
+    {
+      "command": "team-agent claude",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:provider-launcher",
+      "plan": "Use a per-call hermetic PATH shim for claude, then assert the shim's exact provider argv log and the bound CLI exit/output."
+    },
+    {
+      "command": "team-agent clone-agent <source> --as <new>",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:provider-lifecycle",
+      "plan": "Use an isolated provider/session fixture or authorized subscription gate and bind assertions to clone success or its exact rollback refusal."
+    },
+    {
+      "command": "team-agent codex",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:provider-launcher",
+      "plan": "Use a per-call hermetic PATH shim for codex, then assert the shim's exact provider argv log and the bound CLI exit/output."
+    },
+    {
+      "command": "team-agent codex --dangerously-bypass-approvals-and-sandbox",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:provider-launcher",
+      "plan": "Use a per-call hermetic codex PATH shim and assert the exact dangerous flag argv log plus the bound CLI exit/output without invoking a real provider."
+    },
+    {
+      "command": "team-agent collect",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:results",
+      "plan": "Execute the exact human collect argv after a worker result and bind assertions to presentation and consumption of that same result."
+    },
+    {
+      "command": "team-agent doctor",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:diagnostics",
+      "plan": "Execute the exact human doctor argv and bind assertions to its exit and key diagnostic checks."
+    },
+    {
+      "command": "team-agent fork-agent <source> --as <new>",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:provider-lifecycle",
+      "plan": "Use an isolated provider/session fixture or authorized subscription gate and bind assertions to fork success or its exact rollback refusal."
+    },
+    {
+      "command": "team-agent inbox",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:messaging",
+      "plan": "Execute the exact default inbox argv and bind assertions to its selected recipient and message or empty-state output."
+    },
+    {
+      "command": "team-agent inbox coder",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:messaging",
+      "plan": "Execute the exact coder inbox argv and bind assertions to recipient filtering and delivery fields."
+    },
+    {
+      "command": "team-agent profile doctor <name> --workspace . --json",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:profiles",
+      "plan": "Execute a representative local profile doctor argv and bind assertions to its JSON validation result and write isolation."
+    },
+    {
+      "command": "team-agent profile init <name> --auth-mode subscription --workspace .",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:profiles",
+      "plan": "Execute a representative local profile init and assert the bound result plus persisted profile identity and subscription auth mode."
+    },
+    {
+      "command": "team-agent profile init claude-default --auth-mode subscription --workspace .",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:profiles",
+      "plan": "Execute the exact local init argv and assert the bound result plus claude-default subscription profile fields without launching Claude."
+    },
+    {
+      "command": "team-agent profile init codex-default --auth-mode subscription --workspace .",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:profiles",
+      "plan": "Execute the exact local init argv and assert the bound result plus codex-default subscription profile fields without launching Codex."
+    },
+    {
+      "command": "team-agent profile init deepseek --auth-mode compatible_api --workspace .",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:profiles",
+      "plan": "Execute the exact local init argv and assert the bound result plus compatible_api profile schema without network access."
+    },
+    {
+      "command": "team-agent profile show <name> --workspace . --json",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:profiles",
+      "plan": "Show a profile created in the same fixture and bind field-by-field round-trip assertions to the CLI result."
+    },
+    {
+      "command": "team-agent profile show deepseek --workspace . --json",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:profiles",
+      "plan": "Show the isolated deepseek profile and bind exact identity/auth-mode assertions to the CLI result."
+    },
+    {
+      "command": "team-agent quick-start",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute the exact argv from a hermetic project root and bind assertions to canonical runtime, team, and session identity."
+    },
+    {
+      "command": "team-agent quick-start ./roles --team-id alpha",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute against an isolated legacy roles fixture and bind assertions to the alpha team identity and unique runtime."
+    },
+    {
+      "command": "team-agent quick-start .team/alpha",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute against an isolated team directory and bind assertions proving the directory literal cannot split canonical team identity."
+    },
+    {
+      "command": "team-agent quick-start .team/current",
+      "bucket": "covered",
+      "cases": ["lnch_001_quick_start_basic"],
+      "evidence": {
+        "case": "lnch_001_quick_start_basic",
+        "source_file": "crates/team-agent/tests/e2e/cases/lnch_001_quick_start_basic.rs",
+        "invocation": {
+          "runner": "run_ta",
+          "line": 30,
+          "documented_argv": ["team-agent", "quick-start", ".team/current"],
+          "literal_argv": ["quick-start", ".team/current"]
+        },
+        "binding": {
+          "name": "out",
+          "line": 30
+        },
+        "assertion": {
+          "macro_name": "assert",
+          "line": 41,
+          "operand": "condition",
+          "behavior_fact": "stdout",
+          "failure_marker": "quick-start did not launch the team"
+        },
+        "negative_twin": {
+          "env_key": "TEAM_AGENT_COVERAGE_NEGATIVE_TWIN",
+          "env_value": "quick-start-status",
+          "operation": "remove_text_literal",
+          "remove_literal": "status: leader_receiver_unbound",
+          "replacement": "negative_twin_removed"
+        }
+      }
+    },
+    {
+      "command": "team-agent quick-start <dir>",
+      "bucket": "covered",
+      "cases": ["lnch_001_quick_start_basic"],
+      "evidence": {
+        "case": "lnch_001_quick_start_basic",
+        "source_file": "crates/team-agent/tests/e2e/cases/lnch_001_quick_start_basic.rs",
+        "invocation": {
+          "runner": "run_ta",
+          "line": 30,
+          "documented_argv": ["team-agent", "quick-start", "<dir>"],
+          "literal_argv": ["quick-start", ".team/current"]
+        },
+        "binding": {
+          "name": "out",
+          "line": 30
+        },
+        "assertion": {
+          "macro_name": "assert",
+          "line": 69,
+          "operand": "condition",
+          "behavior_fact": "stdout",
+          "failure_marker": "public output must expose the canonical session name"
+        },
+        "negative_twin": {
+          "env_key": "TEAM_AGENT_COVERAGE_NEGATIVE_TWIN",
+          "env_value": "quick-start-session-name",
+          "operation": "remove_text_literal",
+          "remove_literal": "session_name: ",
+          "replacement": "negative_twin_removed"
+        }
+      }
+    },
+    {
+      "command": "team-agent remove-agent <agent> --workspace . --confirm",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute the exact argv in a dedicated hermetic lifecycle fixture and bind assertions to roster/window removal and sibling preservation."
+    },
+    {
+      "command": "team-agent reset-agent <agent> --discard-session",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute the exact argv in a dedicated hermetic fixture and bind assertions to session discard and worker state."
+    },
+    {
+      "command": "team-agent restart",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:restart",
+      "plan": "Execute from an isolated single-team cwd and bind assertions to the restarted session and roster."
+    },
+    {
+      "command": "team-agent restart .",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:restart",
+      "plan": "Execute the exact argv including final dot and bind assertions to canonical team selection and restart outcome."
+    },
+    {
+      "command": "team-agent restart . --allow-fresh",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:restart",
+      "plan": "Execute in a dedicated hermetic rebuild fixture and bind assertions to the new session, agent state, and allow-fresh audit."
+    },
+    {
+      "command": "team-agent restart . --team <session_name_or_team_name>",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:restart",
+      "plan": "Execute a representative team selector and bind assertions to selected-team restart and sibling preservation."
+    },
+    {
+      "command": "team-agent send --task task_initial \"Start\"",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:messaging",
+      "plan": "Execute the exact task argv in an isolated task fixture and bind assertions to task/message attribution and durable row state."
+    },
+    {
+      "command": "team-agent send --watch-result",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:messaging",
+      "plan": "Execute the exact incomplete argv and bind assertions to its nonzero usage error and zero message/result writes."
+    },
+    {
+      "command": "team-agent send --watch-result coder \"Do the bounded task\"",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:messaging",
+      "plan": "Execute the exact argv in an isolated coder fixture and bind assertions to blocked-before-watch or the same-message result closure."
+    },
+    {
+      "command": "team-agent send reviewer \"Review this change\"",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:messaging",
+      "plan": "Execute the exact argv against a fake reviewer and bind recipient, delivered, original result, and collect assertions."
+    },
+    {
+      "command": "team-agent shutdown --workspace . --keep-logs",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:shutdown",
+      "plan": "Execute the exact argv only in a dedicated hermetic fixture and bind assertions to scoped session removal, kept logs, and sibling preservation."
+    },
+    {
+      "command": "team-agent start-agent <agent>",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute a representative exact argv for a stopped fake agent and bind assertions to status, pane, and window creation."
+    },
+    {
+      "command": "team-agent start-agent <agent_id> --workspace .",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute a representative exact workspace-dot argv and bind assertions to the same agent's lifecycle result."
+    },
+    {
+      "command": "team-agent start-agent coder --workspace .",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:lifecycle",
+      "plan": "Execute in an isolated coder fixture and bind assertions that the selected coder, not a sibling namesake, starts."
+    },
+    {
+      "command": "team-agent status",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:status",
+      "plan": "Execute the exact human status argv and bind assertions to selected team and agent output."
+    },
+    {
+      "command": "team-agent status --detail --json",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:status",
+      "plan": "Execute the exact argv and bind assertions to detail-only coordinator, readiness, and tmux fields."
+    },
+    {
+      "command": "team-agent status --json",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:status",
+      "plan": "Execute the exact argv and bind assertions to the compact status schema and absence of detail-only fields."
+    },
+    {
+      "command": "team-agent status coder",
+      "bucket": "declared_gap",
+      "covered": false,
+      "owner": "runtime-owner:status",
+      "plan": "Execute the exact coder status argv and bind assertions to coder-only presentation without sibling leakage."
+    }
+  ]
+}