@phnx-labs/agents-cli 1.22.45 → 1.22.47

package/dist/lib/session/trajectory.d.ts

@@ -0,0 +1,102 @@
+import { type SessionStats } from './render.js';
+import type { SessionEvent, SessionMeta } from './types.js';
+/** One drawable step on a session's trajectory — a tool call or a thinking block. */
+export interface TrajectoryStep {
+    /** 1-based position among drawn steps, stable for `--errors-only` and step refs. */
+    ordinal: number;
+    kind: 'tool' | 'thinking';
+    /** Tool name for `kind === 'tool'` (e.g. `Bash`, `Read`, `Task`). */
+    tool?: string;
+    /** The waterfall row this draws on — the tool name, or `think` for reasoning. */
+    lane: string;
+    /** Milliseconds from session start (the earliest event) to this step's start. */
+    startMs: number;
+    /**
+     * Duration in ms. Measured by pairing this `tool_use` with its `tool_result`
+     * on `callId`; when no paired result exists (or the harness omits `callId`),
+     * falls back to the delta to the next event and sets `durationEstimated`.
+     */
+    durationMs: number;
+    /** True when `durationMs` is the next-event fallback, not a measured pairing. */
+    durationEstimated: boolean;
+    /** Structured harness outcome from the paired result; never inferred from text. */
+    outcome?: 'ok' | 'error' | 'unknown';
+    /** Redacted one-line summary (command / path / subagent / pattern). */
+    label: string;
+    /** Redacted, bounded output/evidence snippet from the paired result. */
+    detail?: string;
+    /** An inline `Task`/`Agent` sub-agent branch (a cross-session teammate is lineage). */
+    delegation?: 'inline-task' | 'teammate';
+    /** Output tokens attributed from the nearest following usage event. */
+    outputTokens?: number;
+    /** Harness-native call identity, when present. */
+    callId?: string;
+    /**
+     * For a shell tool call (`Bash`), the effective program the command actually
+     * ran — `git`, `gh`, `agents`, `bun`, `sed`… — extracted by the shared shell
+     * parser (`extractShellPrograms`, wrappers like `timeout`/`sudo`/`agents ssh`
+     * unwrapped). Lets a Bash-dominated trajectory read by what it DID, not a wall
+     * of "Bash". Undefined for non-shell tools or an unparseable command.
+     */
+    program?: string;
+    /** Process exit code from the paired result (or the tool_use event), when the harness recorded one. */
+    exitCode?: number;
+}
+/** An idle stall between two events — a candidate "where did it hang" marker. */
+export interface TrajectoryGap {
+    /** Milliseconds from session start to where the gap begins. */
+    startMs: number;
+    /** How long nothing happened, in ms. */
+    durationMs: number;
+    /** Ordinal of the last step before the gap (0 when the gap precedes step 1). */
+    afterOrdinal: number;
+}
+/** The derived trajectory of one session. */
+export interface SessionTrajectory {
+    session: SessionMeta;
+    /** Wall-clock span of the session in ms (last event − first event). */
+    spanMs: number;
+    steps: TrajectoryStep[];
+    gaps: TrajectoryGap[];
+    /**
+     * Fraction of measured tool time per effective program, summing to ~1 (empty if
+     * no time). Keyed by the same tag the step list and badges use — a shell call's
+     * effective program (`git`, `bun`, `gh`), else the raw tool — so a Bash-heavy
+     * session reads as `git / bun / gh`, never a single opaque `Bash`. The single
+     * source both the HTML and text "where the time went" panels read.
+     */
+    programTimeShare: Record<string, number>;
+    /**
+     * Failed steps — steps whose paired result carried `outcome: 'error'`. Distinct
+     * from `stats.errorCount`, which counts only standalone `type: 'error'` events;
+     * a tool that failed via a `tool_result` outcome is invisible there but counted
+     * here, so this is the truthful "how many calls failed" for the trajectory view.
+     */
+    errorCount: number;
+    /** True when derived labels/details were secret-redacted (false under `--no-redact`). */
+    redacted: boolean;
+    /** Reused wholesale from `computeSummaryStats` — turns, tools, tokens, span. */
+    stats: SessionStats;
+    /** Steps dropped by the `maxSteps` cap, surfaced so truncation is never silent. */
+    truncatedSteps: number;
+}
+export interface BuildTrajectoryOptions {
+    /** Redact derived labels/details (default true; `--no-redact` is local-only). */
+    redact?: boolean;
+    /** Known secret values to mask, from `knownSecretValuesFromEnv()`. */
+    knownSecrets?: readonly string[];
+    /** A gap longer than this (ms) is recorded as an idle stall. Default 120000. */
+    idleThresholdMs?: number;
+    /** Cap on drawn steps; the tail is dropped and counted. Default 5000. */
+    maxSteps?: number;
+}
+/**
+ * Build the derived trajectory for one session's normalized events.
+ *
+ * Pairs each `tool_use` with its `tool_result`/`error` on `callId` (FIFO within a
+ * reused id — never across ids, and never by arrival order for concurrent calls,
+ * matching `ToolCallCollector.takePending`'s refusal to guess, `tool-calls.ts:509`).
+ * A harness with no parseable transcript (OpenClaw, `parse.ts:186`) yields an empty
+ * event array and therefore an empty trajectory — never a crash or a fabricated one.
+ */
+export declare function buildTrajectory(events: SessionEvent[], meta: SessionMeta, options?: BuildTrajectoryOptions): SessionTrajectory;

package/dist/lib/session/trajectory.js

@@ -0,0 +1,335 @@
+/**
+ * Derived session trajectory model — the one genuinely new computation behind
+ * `agents sessions trace`.
+ *
+ * Nothing in the session pipeline records a per-step DURATION: the indexed tool
+ * call (`tool-calls.ts`) keeps only a start timestamp, and `SessionEvent`
+ * (`types.ts:46`) carries a `tool_use` and its `tool_result` as two separate
+ * events. This module pairs them by `callId` to recover how long each call took,
+ * flags the idle gaps between events (stalls), and rolls the per-tool time up
+ * into a "where the time went" share — all DERIVED from the normalized event
+ * stream, never persisted onto `SessionEvent` or the SQLite `tool_calls` index.
+ *
+ * Pure and framework-free: it takes the parsed `SessionEvent[]` and the session
+ * metadata and returns a plain object the three renderers (HTML / text / JSON)
+ * project. Redaction reuses the same `redactSecrets` path as `render`/`share`
+ * (`redact.ts`), applied to the derived one-line labels; the label is the only
+ * place raw command/argument text reaches the model.
+ *
+ * The types (`SessionTrajectory`, `TrajectoryStep`) are shaped to also carry the
+ * later compare + lineage layouts (a stats block, gaps, and time-share per
+ * session), even though this PR renders only the single-session layout.
+ */
+import { redactSecrets } from '../redact.js';
+import { computeSummaryStats } from './render.js';
+import { extractShellPrograms } from './shell-programs.js';
+const DEFAULT_IDLE_THRESHOLD_MS = 120_000;
+const DEFAULT_MAX_STEPS = 5000;
+const LABEL_MAX = 140;
+const DETAIL_MAX = 400;
+/** Tools that spawn an inline sub-agent inside THIS transcript (a `tool_use` row). */
+const INLINE_TASK_TOOLS = new Set(['Task', 'Agent']);
+/**
+ * Shell tools whose command is worth resolving to an effective program — every
+ * harness's shell-exec tool, kept in lockstep with the canonical set in
+ * `state.ts` (`['Bash', 'exec_command', 'run_shell_command', 'shell', 'Execute']`)
+ * so Codex's `exec_command` and the rest are covered, not just Claude's `Bash`.
+ */
+const SHELL_TOOLS = new Set(['Bash', 'exec_command', 'run_shell_command', 'shell', 'Execute']);
+/**
+ * Shell builtins/assignments that are rarely the POINT of a command — the action
+ * is whatever runs after them (`export X=Y; git push` → `git`, `cd dir && bun test`
+ * → `bun`). Skipped when a real program follows so a Bash row reads by what it did.
+ */
+const SHELL_NOISE_PROGRAMS = new Set(['export', 'cd', 'set', 'source', '.', 'unset', 'local', 'eval']);
+/**
+ * The effective program a shell command ran, via the shared shell parser
+ * (`extractShellPrograms` — which unwraps the wrappers it knows: `env`, `sudo`,
+ * `agents ssh`; note `timeout` is deliberately NOT a wrapper there, per SES-37,
+ * so `timeout 30 npm test` resolves to `timeout`). On top of that this skips
+ * bare builtins/assignments (`cd`, `export`, …) when a real program follows. For
+ * a pipeline it takes the LEFTMOST effective program (`cat f | grep x` → `cat`),
+ * matching how the parser orders occurrences. Undefined when nothing static is
+ * identifiable. Never executes anything.
+ */
+function effectiveProgram(command) {
+    if (!command)
+        return undefined;
+    const { occurrences, programs } = extractShellPrograms(command);
+    const effective = occurrences.filter((o) => o.role === 'effective').map((o) => o.program);
+    const meaningful = effective.find((p) => !SHELL_NOISE_PROGRAMS.has(p))
+        ?? programs.find((p) => !SHELL_NOISE_PROGRAMS.has(p));
+    return meaningful ?? effective[0] ?? programs[0];
+}
+function toMs(timestamp) {
+    const ms = new Date(timestamp).getTime();
+    return Number.isNaN(ms) ? NaN : ms;
+}
+function firstLine(text) {
+    const nl = text.indexOf('\n');
+    return nl === -1 ? text : text.slice(0, nl);
+}
+function clip(text, max) {
+    const collapsed = firstLine(text).replace(/\s+/g, ' ').trim();
+    return collapsed.length <= max ? collapsed : `${collapsed.slice(0, max - 1)}…`;
+}
+function stringArg(args, ...keys) {
+    if (!args)
+        return undefined;
+    for (const key of keys) {
+        const value = args[key];
+        if (typeof value === 'string' && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * A redacted one-line label for a tool call, derived from the raw arguments.
+ *
+ * This is the single place unredacted command/argument text enters the model, so
+ * it runs through the same `redactSecrets` pass `render`/`share` use. `--no-redact`
+ * (local only) skips that pass; the caller passes `redact: false`.
+ */
+function toolLabel(tool, args, command, redact, knownSecrets) {
+    let raw;
+    const lower = tool.toLowerCase();
+    if (lower === 'bash' || lower === 'shell' || lower === 'run_command' || lower.includes('exec')) {
+        raw = command ?? stringArg(args, 'command', 'cmd', 'script');
+    }
+    else if (lower === 'read' || lower === 'edit' || lower === 'write' || lower === 'notebookedit' || lower === 'multiedit') {
+        raw = stringArg(args, 'file_path', 'path', 'notebook_path', 'filePath');
+    }
+    else if (lower === 'grep' || lower === 'glob' || lower === 'search' || lower === 'codebase_search') {
+        raw = stringArg(args, 'pattern', 'query', 'q');
+    }
+    else if (lower === 'task' || lower === 'agent') {
+        const subagent = stringArg(args, 'subagent_type', 'agentType', 'subagent');
+        const description = stringArg(args, 'description', 'prompt');
+        raw = subagent ? (description ? `${subagent}: ${description}` : subagent) : description;
+    }
+    else if (lower === 'webfetch' || lower === 'websearch' || lower === 'web_search') {
+        raw = stringArg(args, 'url', 'query', 'q');
+    }
+    else {
+        raw = stringArg(args, 'command', 'cmd', 'file_path', 'path', 'query', 'pattern', 'url', 'description');
+    }
+    const base = raw && raw.trim().length > 0 ? clip(raw, LABEL_MAX) : tool;
+    return redact ? redactSecrets(base, knownSecrets) : base;
+}
+function resultOutcome(event) {
+    if (event.outcome === 'ok' || event.outcome === 'error' || event.outcome === 'unknown')
+        return event.outcome;
+    if (event.success === true)
+        return 'ok';
+    if (event.success === false)
+        return 'error';
+    if (event.type === 'error')
+        return 'error';
+    return 'unknown';
+}
+function resultDetail(event, redact, knownSecrets) {
+    const text = event.output ?? event.content;
+    if (!text || text.trim().length === 0)
+        return undefined;
+    const clipped = clip(text, DETAIL_MAX);
+    return redact ? redactSecrets(clipped, knownSecrets) : clipped;
+}
+/**
+ * Build the derived trajectory for one session's normalized events.
+ *
+ * Pairs each `tool_use` with its `tool_result`/`error` on `callId` (FIFO within a
+ * reused id — never across ids, and never by arrival order for concurrent calls,
+ * matching `ToolCallCollector.takePending`'s refusal to guess, `tool-calls.ts:509`).
+ * A harness with no parseable transcript (OpenClaw, `parse.ts:186`) yields an empty
+ * event array and therefore an empty trajectory — never a crash or a fabricated one.
+ */
+export function buildTrajectory(events, meta, options = {}) {
+    const redact = options.redact !== false;
+    const knownSecrets = options.knownSecrets;
+    const idleThreshold = options.idleThresholdMs ?? DEFAULT_IDLE_THRESHOLD_MS;
+    const maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
+    const stats = computeSummaryStats(events);
+    const firstTs = stats.firstTs;
+    const spanMs = stats.lastTs > stats.firstTs ? stats.lastTs - stats.firstTs : 0;
+    // Absolute ms per event index (NaN when the timestamp is unparseable).
+    const eventMs = events.map((e) => toMs(e.timestamp));
+    // The next event index (after i) that carries a valid timestamp — the anchor
+    // for the next-event duration fallback and for idle-gap detection.
+    const nextValidTs = new Array(events.length).fill(NaN);
+    for (let i = events.length - 1, later = NaN; i >= 0; i--) {
+        nextValidTs[i] = later;
+        if (!Number.isNaN(eventMs[i]))
+            later = eventMs[i];
+    }
+    // Draw a step for each thinking block and each non-local tool_use, in order.
+    // `_local` tool calls (Claude `!`-prefixed shell) are excluded to match the
+    // header's tool count (`computeSummaryStats` skips them, `render.ts:224`).
+    const drafts = [];
+    const pendingByCallId = new Map();
+    for (let i = 0; i < events.length; i++) {
+        const e = events[i];
+        if (e.type === 'thinking') {
+            drafts.push({
+                step: {
+                    ordinal: 0,
+                    kind: 'thinking',
+                    lane: 'think',
+                    startMs: Number.isNaN(eventMs[i]) ? 0 : Math.max(0, eventMs[i] - firstTs),
+                    durationMs: 0,
+                    durationEstimated: true,
+                    label: 'thinking',
+                },
+                eventIndex: i,
+            });
+        }
+        else if (e.type === 'tool_use' && !e._local) {
+            const tool = e.tool || 'unknown';
+            const draftIndex = drafts.length;
+            drafts.push({
+                step: {
+                    ordinal: 0,
+                    kind: 'tool',
+                    tool,
+                    lane: tool,
+                    startMs: Number.isNaN(eventMs[i]) ? 0 : Math.max(0, eventMs[i] - firstTs),
+                    durationMs: 0,
+                    durationEstimated: true,
+                    outcome: 'unknown',
+                    label: toolLabel(tool, e.args, e.command, redact, knownSecrets),
+                    delegation: INLINE_TASK_TOOLS.has(tool) ? 'inline-task' : undefined,
+                    callId: e.callId,
+                    program: SHELL_TOOLS.has(tool) ? effectiveProgram(e.command ?? (typeof e.args?.command === 'string' ? e.args.command : undefined)) : undefined,
+                    exitCode: typeof e.exitCode === 'number' ? e.exitCode : undefined,
+                },
+                eventIndex: i,
+                callId: e.callId,
+            });
+            if (e.callId) {
+                const queue = pendingByCallId.get(e.callId);
+                if (queue)
+                    queue.push(draftIndex);
+                else
+                    pendingByCallId.set(e.callId, [draftIndex]);
+            }
+        }
+        else if ((e.type === 'tool_result' || e.type === 'error') && e.callId) {
+            // Pair strictly by callId, FIFO within a reused id — never across ids.
+            const queue = pendingByCallId.get(e.callId);
+            if (queue && queue.length > 0) {
+                const draftIndex = queue.shift();
+                drafts[draftIndex].resultEventIndex = i;
+            }
+        }
+    }
+    // Resolve durations, outcomes, and detail now that pairing is complete.
+    for (const draft of drafts) {
+        const { step } = draft;
+        const startAbs = Number.isNaN(eventMs[draft.eventIndex]) ? NaN : eventMs[draft.eventIndex];
+        if (draft.resultEventIndex !== undefined) {
+            const resultEvent = events[draft.resultEventIndex];
+            const resultAbs = eventMs[draft.resultEventIndex];
+            if (!Number.isNaN(startAbs) && !Number.isNaN(resultAbs)) {
+                step.durationMs = Math.max(0, resultAbs - startAbs);
+                step.durationEstimated = false;
+            }
+            step.outcome = resultOutcome(resultEvent);
+            // Prefer the exit code recorded on the paired result; keep the tool_use
+            // event's code (set at draft time) only when the result carries none.
+            if (typeof resultEvent.exitCode === 'number')
+                step.exitCode = resultEvent.exitCode;
+            const detail = resultDetail(resultEvent, redact, knownSecrets);
+            if (detail)
+                step.detail = detail;
+        }
+        else {
+            // No paired result — fall back to the delta to the next timestamped event.
+            const nextAbs = nextValidTs[draft.eventIndex];
+            if (!Number.isNaN(startAbs) && !Number.isNaN(nextAbs)) {
+                step.durationMs = Math.max(0, nextAbs - startAbs);
+            }
+            step.durationEstimated = true;
+        }
+    }
+    // Attribute output tokens: each usage event lands on the most recent tool step
+    // (the nearest following usage from that step's point of view).
+    let lastToolDraft;
+    const draftByEventIndex = new Map();
+    for (const draft of drafts)
+        draftByEventIndex.set(draft.eventIndex, draft);
+    for (let i = 0; i < events.length; i++) {
+        const draft = draftByEventIndex.get(i);
+        if (draft && draft.step.kind === 'tool')
+            lastToolDraft = draft;
+        else if (events[i].type === 'usage' && lastToolDraft) {
+            const out = events[i].outputTokens ?? 0;
+            if (out > 0)
+                lastToolDraft.step.outputTokens = (lastToolDraft.step.outputTokens ?? 0) + out;
+        }
+    }
+    // Number the steps and apply the cap (tail dropped, counted — never silent).
+    let steps = drafts.map((d) => d.step);
+    let truncatedSteps = 0;
+    if (steps.length > maxSteps) {
+        truncatedSteps = steps.length - maxSteps;
+        steps = steps.slice(0, maxSteps);
+    }
+    steps.forEach((step, index) => { step.ordinal = index + 1; });
+    // Idle gaps: a long delta between consecutive timestamped events. `afterOrdinal`
+    // is the last step whose event index precedes the gap.
+    const gaps = [];
+    const orderedTs = [];
+    for (let i = 0; i < events.length; i++) {
+        if (!Number.isNaN(eventMs[i]))
+            orderedTs.push({ index: i, ms: eventMs[i] });
+    }
+    const stepOrdinalAtOrBefore = (eventIndex) => {
+        let ordinal = 0;
+        for (const d of drafts) {
+            if (d.eventIndex <= eventIndex && d.step.ordinal > 0)
+                ordinal = d.step.ordinal;
+            else if (d.eventIndex > eventIndex)
+                break;
+        }
+        return ordinal;
+    };
+    for (let k = 1; k < orderedTs.length; k++) {
+        // A span that OPENS on a `tool_use` is that tool executing (waiting on its
+        // own result), not the agent sitting idle — so it is not a stall. Counting
+        // it double-reports a long `bun test` as both its step duration and a fake
+        // "idle" gap. Only spans that open after a completed boundary are idle.
+        if (events[orderedTs[k - 1].index].type === 'tool_use')
+            continue;
+        const delta = orderedTs[k].ms - orderedTs[k - 1].ms;
+        if (delta > idleThreshold) {
+            gaps.push({
+                startMs: Math.max(0, orderedTs[k - 1].ms - firstTs),
+                durationMs: delta,
+                afterOrdinal: stepOrdinalAtOrBefore(orderedTs[k - 1].index),
+            });
+        }
+    }
+    // Where the time went — measured tool duration share per tool.
+    // Sum tool time by the EFFECTIVE PROGRAM (a shell call's `git`/`bun`/`gh`, else
+    // the raw tool) — the same tag the step list and badges show — so both renderers
+    // read one program-keyed source instead of each re-bucketing the steps.
+    const perProgram = {};
+    let totalToolMs = 0;
+    for (const step of steps) {
+        if (step.kind !== 'tool')
+            continue;
+        const tag = step.program ?? step.tool;
+        if (!tag)
+            continue;
+        perProgram[tag] = (perProgram[tag] ?? 0) + step.durationMs;
+        totalToolMs += step.durationMs;
+    }
+    const programTimeShare = {};
+    if (totalToolMs > 0) {
+        for (const [tag, ms] of Object.entries(perProgram)) {
+            if (ms > 0)
+                programTimeShare[tag] = ms / totalToolMs;
+        }
+    }
+    const errorCount = steps.reduce((n, s) => (s.outcome === 'error' ? n + 1 : n), 0);
+    return { session: meta, spanMs, steps, gaps, programTimeShare, errorCount, redacted: redact, stats, truncatedSteps };
+}

package/dist/lib/startup/command-registry.d.ts

@@ -30,8 +30,11 @@ export declare const KNOWN_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
  * read-only local web companion + `--control` anchor) was removed with the
  * unshipped iOS Fleet Cockpit it existed for (RUSH-3001). `apply` nested under
  * `agents fleet apply` / `agents devices apply`. `beta` nested under
- * `agents setup beta` (RUSH-2981). `auth` and `org` (the Prix-coupled account
- * layer) were removed pending the Phoenix-backed replacement (RUSH-2581).
+ * `agents setup beta` (RUSH-2981). `org` (the Prix-coupled account layer) was
+ * removed; `agents auth` returned against Phoenix ID with `auth space` as the
+ * team surface (RUSH-2581). `usage` was removed as a duplicate surface of
+ * `agents view`, which renders per-account usage with account, version, and
+ * auth state beside it (RUSH-3079).
  */
 export declare const RETIRED_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
 export declare function isKnownTopLevelCommand(name: string): boolean;

package/dist/lib/startup/command-registry.js

@@ -1,11 +1,11 @@
 const LOADED_COMMAND_NAMES = [
-    'accounts', 'view', 'inspect', 'feedback', 'commands', 'hooks', 'skills', 'rules', 'memory',
+    'accounts', 'auth', 'view', 'inspect', 'feedback', 'commands', 'hooks', 'skills', 'rules', 'memory',
     'permissions', 'mcp', 'clis', 'subagents', 'plugins', 'workflows', 'add', 'use', 'list',
     'remove', 'rm', 'purge', 'update', 'prune', 'import', 'registry', 'search', 'install',
     'routines', 'monitors', 'projects', 'run', 'open', 'reconnect', 'fork', 'config',
     'models', 'modes', 'trash', 'restore', 'doctor',
     'route', 'harness', 'harnesses', 'secrets', 'menubar', 'sync',
-    'refresh-rules', 'factory', 'usage', 'insights', 'perf',
+    'refresh-rules', 'factory', 'insights', 'trace', 'perf',
     'pty', 'tmux', 'watchdog', 'browser', 'computer', 'logs', 'events',
     'ssh', 'devices', 'fleet', 'repos', 'repo', 'setup', 'uninstall', 'upgrade', 'sessions',
     'teams', 'cloud', 'message', 'send', 'notify', 'feed',
@@ -50,14 +50,17 @@ export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
  * read-only local web companion + `--control` anchor) was removed with the
  * unshipped iOS Fleet Cockpit it existed for (RUSH-3001). `apply` nested under
  * `agents fleet apply` / `agents devices apply`. `beta` nested under
- * `agents setup beta` (RUSH-2981). `auth` and `org` (the Prix-coupled account
- * layer) were removed pending the Phoenix-backed replacement (RUSH-2581).
+ * `agents setup beta` (RUSH-2981). `org` (the Prix-coupled account layer) was
+ * removed; `agents auth` returned against Phoenix ID with `auth space` as the
+ * team surface (RUSH-2581). `usage` was removed as a duplicate surface of
+ * `agents view`, which renders per-account usage with account, version, and
+ * auth state beside it (RUSH-3079).
  */
 export const RETIRED_TOP_LEVEL_COMMANDS = new Set([
     'webhook',
-    'auth',
     'org',
     'serve',
+    'usage',
     'login',
     'logout',
     'budget',

package/dist/lib/state.d.ts

@@ -258,7 +258,7 @@ export declare function getTeamsAgentsDir(): string;
 export declare function getTeamsRegistryPath(): string;
 /** Path to the device registry — SSH device profiles with platform/auth metadata. Durable runtime, per-machine (host list + addresses are NOT pulled by `agents repo push`). */
 export declare function getDevicesRegistryPath(): string;
-/** Path to the device ignore-list — tailscale node names the user dismissed, so auto-discovery never re-suggests them. Per-machine, same dir as the registry. */
+/** Path to the LEGACY per-machine device ignore-list — superseded by the tracked `fleet.ignored` list in central agents.yaml (RUSH-3062); only lib/devices/config-migration.ts still reads it (to fold + remove it). */
 export declare function getDevicesIgnoredPath(): string;
 /** Path to the LEGACY device auto-launch preference file — which registered devices are eligible/preferred for the ext's auto-host selection. Superseded by the per-device doc `config:` block; only lib/devices/config-migration.ts still reads it (to fold + remove it). */
 export declare function getDevicesAutoLaunchPath(): string;

package/dist/lib/state.js

@@ -563,7 +563,9 @@ export function getTeamsAgentsDir() { return TEAMS_AGENTS_DIR; }
 /** Path to the team registry — list of named teams with timestamps. Durable runtime, per-machine. */
 export function getTeamsRegistryPath() { return path.join(HISTORY_DIR, 'teams', 'registry.json'); }
 /**
- * The devices dir (registry + ignore-list live here). Read at CALL time so a
+ * The devices dir (the registry lives here; the ignore-list moved to the
+ * tracked central agents.yaml as `fleet.ignored` — RUSH-3062). Read at CALL
+ * time so a
  * test can redirect it to a temp dir via AGENTS_DEVICES_DIR without racing the
  * module-load capture of HISTORY_DIR — mirrors the AGENTS_EVENTS_PATH /
  * AGENTS_SECRETS_AGENT_DIR test-isolation escape hatches. Never set in
@@ -575,7 +577,7 @@ function getDevicesDir() {
 }
 /** Path to the device registry — SSH device profiles with platform/auth metadata. Durable runtime, per-machine (host list + addresses are NOT pulled by `agents repo push`). */
 export function getDevicesRegistryPath() { return path.join(getDevicesDir(), 'registry.json'); }
-/** Path to the device ignore-list — tailscale node names the user dismissed, so auto-discovery never re-suggests them. Per-machine, same dir as the registry. */
+/** Path to the LEGACY per-machine device ignore-list — superseded by the tracked `fleet.ignored` list in central agents.yaml (RUSH-3062); only lib/devices/config-migration.ts still reads it (to fold + remove it). */
 export function getDevicesIgnoredPath() { return path.join(getDevicesDir(), 'ignored.json'); }
 /** Path to the LEGACY device auto-launch preference file — which registered devices are eligible/preferred for the ext's auto-host selection. Superseded by the per-device doc `config:` block; only lib/devices/config-migration.ts still reads it (to fold + remove it). */
 export function getDevicesAutoLaunchPath() { return path.join(getDevicesDir(), 'auto-launch.json'); }

package/dist/lib/teams/agents.js

@@ -1451,6 +1451,15 @@ export class AgentManager {
         }
         this.defaultMode = resolvedDefaultMode;
         this.initPromise = this.doInitialize();
+        // Mark the deferred rejection as observed. Construction fires init
+        // fire-and-forget; every public method still surfaces a failed init at its
+        // own `await this.initialize()` (the same promise rejects for each new
+        // awaiter). Without this, an init that loses a race with its directory
+        // being removed — measured twice as an unhandled
+        // `ENOENT mkdir /tmp/agents-retention-*` that failed a fully-green suite
+        // (exit 1 with 12k tests passed) and blocked release attestation — crashes
+        // the process instead of failing the caller that actually cares.
+        this.initPromise.catch(() => { });
     }
     async initialize() {
         if (!this.initPromise) {

package/dist/lib/terminal/inject.d.ts

@@ -98,12 +98,31 @@ export interface InjectOptions {
 export interface InjectResult {
     ok: boolean;
     backend: InjectBackend;
+    /**
+     * Delivery is CONFIRMED to have reached the running agent, not merely dispatched.
+     *
+     * For tmux / iterm / ghostty / pty, `ok` already means delivered: `tmux
+     * send-keys` errors on a missing pane, `osascript write text` errors on a bad
+     * session id, and a pty write errors if the sidecar can't reach the fd — so a
+     * successful transport IS the confirmation. For **vscodium**, `ok` only means the
+     * editor CLI accepted the `--open-url` hand-off; whether the swarm-ext extension
+     * actually parsed the verb and typed anything is unknown from the CLI side (the
+     * ext must ack — RUSH follow-up). So vscodium is delivered-but-UNCONFIRMED, and
+     * the watchdog must not book a nudge as landed on that alone.
+     */
+    confirmed: boolean;
     /** Discrete writes delivered: 2 for the Ink-safe text+Enter split, 1 when combined or enter=false. */
     writes: number;
     /** For the tmux / AppleScript backends (or any dryRun), the spec(s) that ran / would run. */
     specs?: LaunchSpec[];
     error?: string;
 }
+/**
+ * Whether a successful transport on this backend CONFIRMS delivery to the agent.
+ * Everything but vscodium self-confirms (see InjectResult.confirmed); vscodium's
+ * `--open-url` is fire-and-forget until the swarm-ext extension acks the verb.
+ */
+export declare function backendConfirmsDelivery(backend: InjectBackend): boolean;
 /**
  * argv for `tmux send-keys` targeting a pane by id. Starts with `tmux` (like the
  * engine's `tmuxTabArgv`) so the same transport runs it locally or over SSH. The

package/dist/lib/terminal/inject.js

@@ -46,6 +46,14 @@ import { appleScriptStr } from './quote.js';
 import { runSpec } from './transport.js';
 import { itermBackend, ghosttyBackend } from './backends/index.js';
 import { currentContext } from './types.js';
+/**
+ * Whether a successful transport on this backend CONFIRMS delivery to the agent.
+ * Everything but vscodium self-confirms (see InjectResult.confirmed); vscodium's
+ * `--open-url` is fire-and-forget until the swarm-ext extension acks the verb.
+ */
+export function backendConfirmsDelivery(backend) {
+    return backend !== 'vscodium';
+}
 /** Carriage return — what Enter delivers into a raw PTY/tmux byte stream. */
 const CR = '\r';
 // --- tmux -------------------------------------------------------------------
@@ -180,22 +188,23 @@ export function vscodiumInjectSpec(target, text, opts) {
 // --- pty --------------------------------------------------------------------
 async function injectPty(target, text, o) {
     if (o.host && o.host !== 'local') {
-        return { ok: false, backend: 'pty', writes: 0, error: 'pty injection is local-only (the sidecar is not a remote surface)' };
+        return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: 'pty injection is local-only (the sidecar is not a remote surface)' };
     }
     // Same Ink-safe split as tmux: text write, then a separate CR write.
     const writes = o.enter && o.combined ? [text + CR] : o.enter ? [text, CR] : [text];
     if (o.dryRun)
-        return { ok: true, backend: 'pty', writes: writes.length };
+        return { ok: true, confirmed: true, backend: 'pty', writes: writes.length };
     try {
         for (const input of writes) {
             const res = await ptyRequest('write', target.id, { input });
             if (!res.ok)
-                return { ok: false, backend: 'pty', writes: 0, error: res.error ?? 'pty write failed' };
+                return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: res.error ?? 'pty write failed' };
         }
-        return { ok: true, backend: 'pty', writes: writes.length };
+        // A successful sidecar write reached the fd — real delivery.
+        return { ok: true, confirmed: true, backend: 'pty', writes: writes.length };
     }
     catch (err) {
-        return { ok: false, backend: 'pty', writes: 0, error: err instanceof Error ? err.message : String(err) };
+        return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: err instanceof Error ? err.message : String(err) };
     }
 }
 // --- public entry -----------------------------------------------------------
@@ -225,8 +234,9 @@ export async function injectIntoTerminal(target, text, opts = {}) {
         : target.backend === 'ghostty'
             ? enter ? 2 : 1
             : enter && !combined ? 2 : 1;
+    const confirmed = backendConfirmsDelivery(target.backend);
     if (opts.dryRun)
-        return { ok: true, backend: target.backend, writes, specs };
+        return { ok: true, confirmed, backend: target.backend, writes, specs };
     // AppleScript backends: guard on the backend's own availability, but only for a
     // LOCAL run (a remote host is assumed to have the app — its ssh leg reports failure).
     if (target.backend === 'iterm' || target.backend === 'ghostty') {
@@ -234,14 +244,14 @@ export async function injectIntoTerminal(target, text, opts = {}) {
             const backend = target.backend === 'iterm' ? itermBackend : ghosttyBackend;
             const ctx = opts.ctx ?? currentContext();
             if (!backend.isAvailable(ctx)) {
-                return { ok: false, backend: target.backend, writes: 0, specs, error: `${backend.label} is not available here (platform ${ctx.platform})` };
+                return { ok: false, confirmed: false, backend: target.backend, writes: 0, specs, error: `${backend.label} is not available here (platform ${ctx.platform})` };
             }
         }
     }
     for (const spec of specs) {
         const res = await runSpec(spec, opts.host, opts.resolveHost);
         if (!res.ok)
-            return { ok: false, backend: target.backend, writes: 0, specs, error: res.error };
+            return { ok: false, confirmed: false, backend: target.backend, writes: 0, specs, error: res.error };
     }
-    return { ok: true, backend: target.backend, writes, specs };
+    return { ok: true, confirmed, backend: target.backend, writes, specs };
 }