@team-agent/installer 0.5.77 → 0.5.80

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

@@ -467,6 +467,21 @@ pub struct InjectReport {
 /// pasted-prompt branch + (informational) for the appear-gate poll.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct SubmitDiagnostics {
+    /// The concrete branch that produced the post-Enter consumption outcome.
+    /// Unknown is retained for paths that do not expose a branch reason.
+    pub consumption_reason: SubmitConsumptionReason,
+    /// Reserved for a pre-paste baseline; this path has no such capture and emits null.
+    pub before_busy_signal_kind: Option<BusySignalKind>,
+    /// Structured busy predicate category for the accepted/current capture.
+    pub busy_signal_kind: Option<BusySignalKind>,
+    /// Bottom-relative non-empty line index of the busy match.
+    pub busy_line_from_bottom: Option<u8>,
+    /// Whether this message marker is in the bottom 15 non-empty lines.
+    pub current_marker_in_bottom_15: Option<bool>,
+    /// Whether the tracked paste identity is still in the composer.
+    pub paste_identity_in_composer: Option<bool>,
+    /// Result of the structural consumption predicate on the current capture.
+    pub consumption_from_capture_result: Option<bool>,
     /// Time spent in the appear-gate (poll for the pasted-content placeholder
     /// before Enter). When `saw_pasted_prompt == false` this is the time we
     /// spent polling before falling through to the E46 token path.
@@ -505,6 +520,63 @@ pub struct SubmitDiagnostics {
     pub target_pane_query_matched: Option<bool>,
 }
 
+/// Structured category returned by the provider-busy predicate.
+///
+/// This is diagnostic metadata only; it does not change delivery semantics.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BusySignalKind {
+    Working,
+    Thinking,
+    Processing,
+    EscToInterrupt,
+    SpinnerGlyph,
+}
+
+impl BusySignalKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Working => "working",
+            Self::Thinking => "thinking",
+            Self::Processing => "processing",
+            Self::EscToInterrupt => "esc_to_interrupt",
+            Self::SpinnerGlyph => "spinner_glyph",
+        }
+    }
+}
+
+/// Structured reason for the post-Enter consumption observation.
+///
+/// This is diagnostic metadata only; it does not change delivery semantics.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum SubmitConsumptionReason {
+    /// The token/input identity disappeared in the consumption capture.
+    ConsumptionFromCapture,
+    /// Cursor's bounded polling observed a provider-busy signal.
+    CursorPollingBusy,
+    /// The final fallback capture observed a provider-busy signal.
+    FallbackBusy,
+    /// The payload had no token marker, so no structural consumption probe ran.
+    NoMarker,
+    /// The bounded probe did not establish consumption.
+    Unverified,
+    /// An older or otherwise uncovered path did not provide a reason.
+    #[default]
+    Unknown,
+}
+
+impl SubmitConsumptionReason {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::ConsumptionFromCapture => "consumption_from_capture",
+            Self::CursorPollingBusy => "cursor_poll_busy",
+            Self::FallbackBusy => "fallback_busy",
+            Self::NoMarker => "no_marker",
+            Self::Unverified => "unverified",
+            Self::Unknown => "unknown",
+        }
+    }
+}
+
 /// Last capture sample of the inject token path. Distinguishes "read failed"
 /// from "read succeeded and token was absent". Does not change delivery gates.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -909,6 +981,12 @@ pub trait Transport: Send + Sync {
     /// pane 存活三态(`PaneLiveness`,bug-085 穷尽 match;unknown ≠ dead ≠ live)。
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError>;
 
+    /// Exit status recorded by the provider's supervising wrapper, never inferred
+    /// from terminal text. None means running or no authoritative receipt.
+    fn provider_exit_status(&self, _pane: &PaneId) -> Result<Option<u8>, TransportError> {
+        Ok(None)
+    }
+
     /// Cheap direct pane existence check when a backend can prove it. `Ok(None)`
     /// preserves the existing Unknown boundary.
     fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {

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

@@ -51,6 +51,59 @@ use crate::conpty::ConPtyBackend;
 use crate::tmux_backend::TmuxBackend;
 use crate::transport::{BackendKind, Transport};
 
+#[cfg(test)]
+thread_local! {
+    static LEADER_ENDPOINT_TRANSPORT_OVERRIDE: std::cell::RefCell<
+        Option<(String, crate::transport::test_support::OfflineTransport)>,
+    > = std::cell::RefCell::new(None);
+}
+
+/// Production live-probe transport for a recorded leader endpoint.
+/// `classify_leader_binding`, restart `transport_for_receiver`, and
+/// `attach_leader_targets` all go through this function.
+pub fn leader_endpoint_transport(endpoint: &str) -> Box<dyn Transport> {
+    #[cfg(test)]
+    if let Some(injected) = LEADER_ENDPOINT_TRANSPORT_OVERRIDE.with(|slot| {
+        slot.borrow().as_ref().and_then(|(expected, transport)| {
+            (expected == endpoint).then(|| Box::new(transport.clone()) as Box<dyn Transport>)
+        })
+    }) {
+        return injected;
+    }
+    if endpoint.is_empty() || endpoint == "default" {
+        Box::new(tmux_default_transport())
+    } else {
+        Box::new(tmux_endpoint_transport(endpoint))
+    }
+}
+
+#[cfg(test)]
+struct LeaderEndpointTransportGuard {
+    previous: Option<(String, crate::transport::test_support::OfflineTransport)>,
+}
+
+#[cfg(test)]
+impl Drop for LeaderEndpointTransportGuard {
+    fn drop(&mut self) {
+        LEADER_ENDPOINT_TRANSPORT_OVERRIDE.with(|slot| {
+            *slot.borrow_mut() = self.previous.take();
+        });
+    }
+}
+
+#[cfg(test)]
+pub fn with_leader_endpoint_transport<T>(
+    endpoint: &str,
+    transport: crate::transport::test_support::OfflineTransport,
+    f: impl FnOnce() -> T,
+) -> T {
+    let previous = LEADER_ENDPOINT_TRANSPORT_OVERRIDE.with(|slot| {
+        slot.replace(Some((endpoint.to_string(), transport)))
+    });
+    let _guard = LeaderEndpointTransportGuard { previous };
+    f()
+}
+
 /// User-visible backend selector on the CLI (`--backend tmux|conpty`).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum RequestedTransportBackend {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.77",
+  "version": "0.5.80",
   "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.77",
-    "@team-agent/cli-darwin-x64": "0.5.77",
-    "@team-agent/cli-linux-x64": "0.5.77"
+    "@team-agent/cli-darwin-arm64": "0.5.80",
+    "@team-agent/cli-darwin-x64": "0.5.80",
+    "@team-agent/cli-linux-x64": "0.5.80"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",
@@ -33,7 +33,6 @@
   "files": [
     "npm/bincheck.mjs",
     "npm/install.mjs",
-    "npm/check-skill-links.mjs",
     "skills",
     "templates",
     "examples",

package/skills/team-agent/SKILL.md

@@ -2,14 +2,14 @@
 name: team-agent
 description: Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.
 requires_team_agent: ">=0.5.0"
-last_verified_against: "0.5.73"
+last_verified_against: "0.5.66"
 ---
 
 # Team Agent
 
-Use this skill only for Team Agent operation. The detailed operator handbook (permissions, models, routing, and recovery) is in [the operator reference](references/team-agent-operator.md). Nested teams have a separate [nested-team reference](references/team-in-team.md).
+Sealed appliance for someone who just got the CLI. Operator handbook (permissions, models, routing, recovery): `docs/reference/team-agent-operator.md`.
 
-If `team-agent --version` does not match `last_verified_against`, inspect the live CLI before copying examples:
+If `team-agent --version` does not match `last_verified_against`, do not copy examples as current truth. Learn from the live CLI:
 
 ```bash
 team-agent --version
@@ -17,24 +17,52 @@ team-agent --help
 team-agent doctor --help
 ```
 
-## Pi TeamMate startup
+**Launch** from a tmux-addressable pane: `team-agent claude` or `team-agent codex`, then `team-agent quick-start .team/current`. Do not start a real team from a naked terminal. Existing tmux/Ghostty layouts are valid if `quick-start` runs from the leader pane.
 
-For a Pi worker, use this existing three-step flow:
+**Operate**
 
-1. Discover exact model ids: `team-agent models --provider pi` (add `--search TEXT` when useful).
-2. Use the existing lifecycle command that matches the actual state: `team-agent quick-start` for a new team, `team-agent add-agent NAME --role-file FILE` for a new worker, or `team-agent start-agent NAME` for a missing worker.
-3. Send work through the canonical route: `team-agent send AGENT MESSAGE`.
+- Dispatch: `team-agent send TO MESSAGE` (positional TO; `--watch-result` is deprecated). After success, do not poll with `sleep` / `status` / `inbox` / `collect`.
+  TO has two co-equal logical forms: an **in-team short name** (`team-agent send reviewer "..."`) and a fully qualified `<workspace>::<team>/<agent>`. Use the qualified form across workspaces.
+- Inspect: `team-agent status` / `status --json`. `ok: true` plus `ready: false` is not a crash.
+- Lifecycle: `restart .` resumes a stopped team; `add-agent NAME --role-file FILE` adds or `--force` recreates one worker; `shutdown --workspace .` stops. Do not shutdown the whole team to add a worker.
+- Roles: every `agents/*.md` must declare boolean `dangerously_skip_permissions`. Never rewrite a user-supplied model id. Never read `.env` files.
 
-Pi roles preserve the direct Pi login, model defaults, extensions/plugins, skills, context, trust, and tools. Team Agent adds only per-seat identity/session isolation. `model` and `effort` are optional explicit pass-throughs. Use the shared role schema, a block-style `tools` list containing `mcp_team`, and the required boolean `dangerously_skip_permissions`.
+**On failure:** if the CLI prints a structured `action`, run that `action` first, then stop. Do not guess flags. `coordinator.session_missing` is a self-healing transient — re-check `status --json`; do not shutdown because of it.
 
-Pi tool contract: use only `mcp_team`, `fs_read`, `fs_list`, `fs_write`, and `execute_bash`. Do not copy `provider_builtin`, `git_diff`, or `network` from a generic Codex role; Pi cannot map those categories. `compile`/`validate` rejects unsupported Pi categories before quick-start persists runtime state.
+The current user-facing agent is the leader (orchestrate only). Workers call `report_result` exactly once. Nested teams: `skills/team-agent/references/team-in-team.md`.
 
-## Operate
+## Provider Capability Matrix
 
-- Send: `team-agent send TO MESSAGE` using an in-team short name or fully qualified `<workspace>::<team>/<agent>`; these are co-equal positional TO forms. For example, `team-agent send reviewer "..."` uses an in-team short name. Do not poll after success.
-- Inspect: `team-agent status` or `team-agent status --json`; `ok: true` with `ready: false` is not a crash.
-- `quick-start` / `restart` / `claim-leader` JSON is compact by default (`ok`, `status`/`reason`, next action, attach/send, and `readiness.all_workers_spawned`); pass `--detail` only for internal diagnostics.
-- On a structured failure with an `action`, run that action first, then stop. Never guess flags.
-- Never rewrite a user-supplied model id or read `.env` files.
+Claude / Codex / Copilot / Gemini / fake: `docs/reference/team-agent-operator.md`. These two are in the runtime but were missing from that table:
+`quick-start` / `restart` / `claim-leader` JSON is compact by default (`ok`, `status`/`reason`, next action, attach/send, and `readiness.all_workers_spawned`); pass `--detail` only for internal diagnostics.
 
-Workers report completion through `mcp_team` and call `report_result` exactly once.
+| Provider | Resume | Turn-state detection | Per-worker model override | Native session fork |
+|---|---|---|---|---|
+| `grok` | yes (`--resume <id>`, archive-gated) | no | yes (role `model` required) | yes (`--fork-session` + new `--session-id`) |
+| `cursor_agent` | yes (argv `--resume <chatId>`, archive-gated) | no | required on role; same-family catalog id can take effect; unknown id silent-fallback; pane chrome ≠ proven live | **no — `CapabilityUnsupported`** |
+
+Grok / `cursor_agent` have no JSONL turn-state reader (classify → Unknown).
+
+## Provider Prep
+
+### Cursor provider notes
+
+Frontmatter: `provider: cursor_agent` (not `cursor`; launcher verb is `team-agent cursor`), `auth_mode: subscription`, `name:` required (omit → `missing front matter field name`). Also required: `role:`, `tools:`, `dangerously_skip_permissions:` (bool). Subscription needs no `profile`.
+
+`model:` is required (omit compile-fails; blocks a silent builtin `sonnet-4-thinking`). The flag stays on argv. Same-family catalog ids can change pane chrome. An id not in that provider's catalog silent-falls back (landing not stable; no events/stderr/pane warning). Pick names from the catalog; after spawn, `capture-pane` once for chrome. Do not treat the role field or pane chrome as proof of the live model.
+
+One `cursor_agent` per workspace. A second seat (including `add-agent --force` of a different id) fail-closes:
+
+```
+error: cursor_agent seat already occupies this workspace
+reason: <workspace>/.cursor/mcp.json is directory-scoped; a second seat overwrites TEAM_AGENT_ID (last-writer)
+action: do not add another CursorAgent in this workspace until per-seat MCP identity is isolated
+```
+
+Several cursor seats → one workspace directory each. Same seat, fresh context → `reset-agent --discard-session`.
+
+`clone-agent` copies the source role (provider unchanged). Runtime add: `clone-agent` → `stop-agent` → `remove-agent --confirm` (deletes `.team/dynamic-role-files/`) → write the role file → `add-agent --role-file` → dispatch.
+
+- Restart emits `--resume <chatId>` when `store.db`/`meta.json` exist; the gate does not read chat text. Persist anything that must survive restart.
+- Delivery sends one Enter; a second Enter interrupts the turn.
+- After spawn, the pane footer should show `Cursor Agent v<version>`. Do not use `strings` to probe the binary.

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

@@ -3,7 +3,7 @@
   "authority": {
     "kind": "normative_handbook_plus_live_help",
     "handbook": {
-      "path": "skills/team-agent/references/team-agent-operator.md",
+      "path": "docs/reference/team-agent-operator.md",
       "start_marker": "<!-- command-coverage:normative-start -->",
       "end_marker": "<!-- command-coverage:normative-end -->"
     },
@@ -67,13 +67,7 @@
       "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 claim-leader --detail",
-      "bucket": "declared_gap",
-      "covered": false,
-      "owner": "runtime-owner:leader-channel",
-      "plan": "Execute the exact argv and bind assertions to detail-only topology_convergence, owner_epoch, and checked_paths fields."
-    },
+
     {
       "command": "team-agent claude",
       "bucket": "declared_gap",
@@ -240,13 +234,7 @@
         }
       }
     },
-    {
-      "command": "team-agent quick-start --json --detail",
-      "bucket": "declared_gap",
-      "covered": false,
-      "owner": "runtime-owner:lifecycle",
-      "plan": "Execute the exact argv and bind assertions to detail-only receiver, topology, and coordinator diagnostics while keeping compact default JSON."
-    },
+
     {
       "command": "team-agent quick-start <dir>",
       "bucket": "covered",
@@ -322,13 +310,7 @@
       "owner": "runtime-owner:restart",
       "plan": "Execute a representative team selector and bind assertions to selected-team restart and sibling preservation."
     },
-    {
-      "command": "team-agent restart --json --detail",
-      "bucket": "declared_gap",
-      "covered": false,
-      "owner": "runtime-owner:restart",
-      "plan": "Execute the exact argv and bind assertions to detail-only coordinator diagnostics while keeping compact default JSON."
-    },
+
     {
       "command": "team-agent send --task task_initial \"Start\"",
       "bucket": "declared_gap",
@@ -357,13 +339,6 @@
       "owner": "runtime-owner:messaging",
       "plan": "Execute the compact-skill positional send smoke with representative target and message tokens, then bind delivery truth."
     },
-    {
-      "command": "team-agent send AGENT MESSAGE",
-      "bucket": "declared_gap",
-      "covered": false,
-      "owner": "runtime-owner:messaging",
-      "plan": "Execute a representative positional send with explicit agent and message tokens, then bind recipient and delivery truth."
-    },
     {
       "command": "team-agent send reviewer \"...\"",
       "bucket": "declared_gap",

package/npm/check-skill-links.mjs

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-/** Resolve local Markdown links and optionally validate package/installed inventories. */
-import fs from "node:fs";
-import path from "node:path";
-
-const args = process.argv.slice(2);
-const value = (name) => { const i = args.indexOf(name); return i < 0 ? null : args[i + 1]; };
-const rootArg = value("--root") ?? "skills/team-agent";
-const root = path.resolve(rootArg);
-const installedArg = value("--installed");
-const inventoryArg = value("--inventory");
-const markdownLink = /!?(?:\[[^\]]*\])\(([^)]+)\)/g;
-const files = [];
-const fail = (message) => { throw new Error(message); };
-const real = (file) => { try { return fs.realpathSync.native(file); } catch (error) { fail(`cannot resolve ${file}: ${error.message}`); } };
-const rootReal = real(root);
-const inside = (candidate, base = rootReal) => candidate === base || candidate.startsWith(`${base}${path.sep}`);
-const lexicalInside = (candidate, base = root) => candidate === base || candidate.startsWith(`${base}${path.sep}`);
-
-function walk(dir, boundary = rootReal) {
-  let entries;
-  try { entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name)); }
-  catch (error) { fail(`cannot read ${dir}: ${error.message}`); }
-  for (const entry of entries) {
-    const file = path.join(dir, entry.name);
-    const fileReal = real(file);
-    if (!inside(fileReal, boundary)) fail(`${file}: realpath escapes tree`);
-    if (entry.isDirectory()) walk(file, boundary);
-    else if (entry.isFile() && file.endsWith(".md")) files.push(file);
-  }
-}
-function normalizeFragment(fragment) {
-  return decodeURIComponent(fragment).toLowerCase().trim().replace(/<[^>]+>/g, "")
-    .replace(/[`*_~]/g, "").replace(/[^\p{L}\p{N} -]/gu, "").replace(/\s+/g, "-");
-}
-function anchors(text) {
-  const found = new Set();
-  const used = new Map();
-  const add = (value) => {
-    const base = normalizeFragment(value); if (!base) return;
-    const n = used.get(base) ?? 0; used.set(base, n + 1); found.add(n ? `${base}-${n}` : base);
-  };
-  for (const m of text.matchAll(/^(?: {0,3})#{1,6}\s+(.+?)\s*#*\s*$/gm) ) add(m[1]);
-  for (const m of text.matchAll(/^(?: {0,3})([^\n#]+)\n(?:=+|-+)\s*$/gm)) add(m[1]);
-  for (const m of text.matchAll(/<(?:a|[^>]+)\s+[^>]*(?:id|name)=["']([^"']+)["'][^>]*>/gi)) add(m[1]);
-  return found;
-}
-function checkTree(dir, baseRoot, baseReal) {
-  files.length = 0; walk(dir, baseReal);
-  const errors = [];
-  for (const file of [...files].sort()) {
-    const text = fs.readFileSync(file, "utf8");
-    const known = anchors(text);
-    for (const match of text.matchAll(markdownLink)) {
-      const href = match[1].trim();
-      if (!href || /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(href)) continue;
-      const hash = href.indexOf("#");
-      const rawPath = hash < 0 ? href : href.slice(0, hash);
-      const fragment = hash < 0 ? "" : href.slice(hash + 1).split("?", 1)[0];
-      const target = rawPath ? path.resolve(path.dirname(file), rawPath) : file;
-      if (!lexicalInside(target, baseRoot)) { errors.push(`${file}: lexical target escapes tree: ${href}`); continue; }
-      const targetReal = real(target);
-      if (!inside(targetReal, baseReal)) { errors.push(`${file}: realpath target escapes tree: ${href}`); continue; }
-      if (!fs.statSync(targetReal).isFile()) { errors.push(`${file}: target is not a file: ${href}`); continue; }
-      if (fragment && targetReal.endsWith(".md")) {
-        const targetAnchors = targetReal === real(file) ? known : anchors(fs.readFileSync(targetReal, "utf8"));
-        if (!targetAnchors.has(normalizeFragment(fragment))) errors.push(`${file}: missing fragment: ${href}`);
-      }
-    }
-  }
-  if (errors.length) fail(errors.sort().join("\n"));
-  return [...files].sort().length;
-}
-const count = checkTree(root, root, rootReal);
-if (inventoryArg) {
-  const inventory = path.resolve(inventoryArg);
-  for (const relative of fs.readFileSync(inventory, "utf8").split(/\r?\n/).filter(Boolean).sort()) {
-    if (path.isAbsolute(relative)) fail(`inventory path must be relative: ${relative}`);
-    const candidate = path.resolve(root, relative);
-    if (!lexicalInside(candidate)) fail(`inventory path escapes tree: ${relative}`);
-    const candidateReal = real(candidate);
-    if (!inside(candidateReal)) fail(`inventory realpath escapes tree: ${relative}`);
-  }
-}
-if (installedArg) {
-  const installed = path.resolve(installedArg); console.log(`checked ${checkTree(installed, installed, real(installed))} Markdown files in ${installed}`);
-}
-console.log(`checked ${count} Markdown files in ${root}`);