@phnx-labs/agents-cli 1.22.59 → 1.22.61

package/dist/commands/harness.js

@@ -17,7 +17,9 @@ import { listProfiles, readProfile, writeProfile, deleteProfile, profileExists,
 import { listPresets, getPreset } from '../lib/profiles-presets.js';
 import { AGENTS, ALL_AGENT_IDS, resolveAgentName } from '../lib/agents.js';
 import { findAccount } from '../lib/account-registry.js';
-import { runWizardSteps, createSteps, editSteps, defaultWizardIO, } from './harness-wizard.js';
+import { runWizardSteps, createSteps, editSteps, defaultWizardIO, runConnectionTest, } from './harness-wizard.js';
+import { harnessHooks } from './harness-hooks.js';
+import { CONNECTION_TEST_PROMPT } from '../lib/harness-connection-test.js';
 /** Short capability summary for a native harness — its supported run modes. */
 function nativeModes(id) {
     const modes = AGENTS[id]?.capabilities?.modes ?? [];
@@ -196,6 +198,73 @@ export function addNeedsWizard(name, opts) {
         return true;
     return !getPreset(name);
 }
+/**
+ * Resolve the tri-state connection-test gate (RUSH-2221), pure so the branching
+ * is unit-tested with no prompt or spawn. `--test` forces it on, `--no-test`
+ * forces it off, and with neither flag a TTY is asked (default yes) while a
+ * non-interactive caller (`--key-stdin`, piped, CI) skips it — so scripting stays
+ * non-interactive unless it opts in with `--test`.
+ */
+export function connectionTestGate(testFlag, interactive) {
+    if (testFlag === true)
+        return 'on';
+    if (testFlag === false)
+        return 'off';
+    return interactive ? 'ask' : 'off';
+}
+/**
+ * Pre-save connection test (RUSH-2221). The harness is already on disk (the test
+ * drives the real `agents run <name>` path, so it must be), so this runs a
+ * classified smoke test and — on a TTY, when it fails — offers to keep it, edit
+ * it, or delete-and-cancel. A test is never blocking on its own: a save is only
+ * discarded when the user explicitly chooses to, so a `--test` failure in a
+ * non-interactive shell warns and keeps rather than exiting non-zero.
+ */
+async function preSaveConnectionTest(name, testFlag) {
+    const interactive = isInteractiveTerminal();
+    const gate = connectionTestGate(testFlag, interactive);
+    let shouldTest;
+    if (gate === 'on')
+        shouldTest = true;
+    else if (gate === 'off')
+        shouldTest = false;
+    else {
+        const { confirm } = await import('@inquirer/prompts');
+        shouldTest = await confirm({ message: `Test the connection for '${name}' now?`, default: true });
+    }
+    if (!shouldTest)
+        return;
+    console.log(chalk.gray(`Testing '${name}' — sending "${CONNECTION_TEST_PROMPT}" through agents run…`));
+    const result = await runConnectionTest({ mode: 'create', name }, harnessHooks());
+    if (!result)
+        return;
+    if (result.ok) {
+        console.log(chalk.green(`✓ ${result.message}`));
+        return;
+    }
+    console.log(chalk.yellow(`✗ ${result.message}`));
+    if (!interactive) {
+        console.log(chalk.gray(`Kept anyway. Fix and retest with: agents harness edit ${name}`));
+        return;
+    }
+    const { select } = await import('@inquirer/prompts');
+    const action = await select({
+        message: 'The connection test failed. What would you like to do?',
+        choices: [
+            { name: 'Keep it (the endpoint may just be down right now)', value: 'keep' },
+            { name: 'Edit it now', value: 'edit' },
+            { name: 'Delete it and cancel', value: 'delete' },
+        ],
+    });
+    if (action === 'edit') {
+        await runEditWizard(name, {});
+        return;
+    }
+    if (action === 'delete') {
+        deleteProfile(name);
+        throw new Error(`Harness '${name}' deleted after a failed connection test.`);
+    }
+}
 /**
  * Shared build+persist flow for a fork — used by `agents harness fork`'s
  * flag-driven path AND by the wizard (both for `fork` and, when it falls back
@@ -223,6 +292,7 @@ async function runForkFlow(source, name, opts) {
     writeProfile(forked);
     console.log(chalk.green(`Harness '${name}' forked from ${source}.`));
     console.log(chalk.gray(`Try: agents run ${name} "hello"`));
+    await preSaveConnectionTest(name, opts.test);
 }
 /**
  * Interactive `agents harness add`/`fork` wizard — runs when required info is
@@ -234,7 +304,7 @@ async function runForkFlow(source, name, opts) {
  */
 async function runCreateWizard() {
     const io = await defaultWizardIO();
-    const draft = await runWizardSteps(createSteps(), { mode: 'create' }, io);
+    const draft = await runWizardSteps(createSteps(), { mode: 'create' }, io, harnessHooks());
     return {
         source: draft.source,
         name: draft.name,
@@ -292,7 +362,7 @@ async function runEditWizard(name, cliOpts) {
     }
     const original = readProfile(name);
     const io = await defaultWizardIO();
-    const draft = await runWizardSteps(editSteps(original), { mode: 'edit', original, host: original.host.agent, name }, io);
+    const draft = await runWizardSteps(editSteps(original), { mode: 'edit', original, host: original.host.agent, name }, io, harnessHooks());
     const opts = { ...draftToEditOptions(draft, original), keyStdin: cliOpts.keyStdin };
     if (!hasEditFlags(opts)) {
         console.log(chalk.gray(`No changes made to '${name}'.`));
@@ -308,6 +378,9 @@ async function runEditWizard(name, cliOpts) {
     writeProfile(edited);
     console.log(chalk.green(`Harness '${name}' updated.`));
     console.log(chalk.gray(`Model:  ${profileModelLabel(edited)}`));
+    // An edit that touched host/model/endpoint/auth is exactly what can break the
+    // harness, so re-test after saving (RUSH-2221). cliOpts carries the --test flag.
+    await preSaveConnectionTest(name, cliOpts.test);
 }
 export function registerHarnessCommands(program) {
     const cmd = program
@@ -362,6 +435,8 @@ Examples:
         .option('--from-secrets <bundle>[:<key>]', 'Removed: import the value with agents accounts add, then use --account')
         .option('--key-stdin', 'Read API key from stdin instead of prompting (for scripts/CI)')
         .option('--force', 'Overwrite an existing harness with the same name')
+        .option('--test', 'Run a connection test before saving (default: ask on a terminal)')
+        .option('--no-test', 'Skip the pre-save connection test')
         .action(async (name, opts) => {
         try {
             if (opts.authProvider || opts.fromSecrets)
@@ -371,10 +446,11 @@ Examples:
                     throw new Error("'agents harness add' needs --preset or --host + --model (or a name and an interactive terminal for the wizard).");
                 }
                 const wiz = await runCreateWizard();
-                await runForkFlow(wiz.source, wiz.name, { ...wiz.opts, force: opts.force, keyStdin: opts.keyStdin });
+                await runForkFlow(wiz.source, wiz.name, { ...wiz.opts, force: opts.force, keyStdin: opts.keyStdin, test: opts.test });
                 return;
             }
             await addProfile(name, opts, 'Harness');
+            await preSaveConnectionTest(name, opts.test);
         }
         catch (err) {
             console.error(chalk.red(err.message));
@@ -393,6 +469,8 @@ Examples:
         .option('--from-secrets <bundle>[:<key>]', 'Removed: import the value with agents accounts add, then use --account')
         .option('--key-stdin', 'Read the API key from stdin instead of prompting (for scripts/CI)')
         .option('--force', 'Overwrite an existing harness with the same name')
+        .option('--test', 'Run a connection test before saving (default: ask on a terminal)')
+        .option('--no-test', 'Skip the pre-save connection test')
         .addHelpText('after', `
 Examples:
   # Fork OpenCode into a harness pinned to a DeepSeek model on OpenRouter
@@ -417,7 +495,7 @@ Examples:
                     throw new Error("'agents harness fork' needs <source> and <name> (or an interactive terminal for the wizard).");
                 }
                 const wiz = await runCreateWizard();
-                await runForkFlow(wiz.source, wiz.name, { ...wiz.opts, force: opts.force, keyStdin: opts.keyStdin });
+                await runForkFlow(wiz.source, wiz.name, { ...wiz.opts, force: opts.force, keyStdin: opts.keyStdin, test: opts.test });
                 return;
             }
             await runForkFlow(source, name, opts);
@@ -439,6 +517,8 @@ Examples:
         .option('--fallback-model <id>', 'Secondary model retried on the same host on a rate limit (pass an empty string to clear it)')
         .option('--from-secrets <bundle>[:<key>]', 'Removed: import the value with agents accounts add, then use --account')
         .option('--key-stdin', 'Read the API key from stdin instead of prompting (for scripts/CI)')
+        .option('--test', 'Run a connection test after saving (default: ask on a terminal)')
+        .option('--no-test', 'Skip the connection test')
         .addHelpText('after', `
 Examples:
   # Swap the pinned model
@@ -479,6 +559,7 @@ Examples:
             writeProfile(edited);
             console.log(chalk.green(`Harness '${name}' updated.`));
             console.log(chalk.gray(`Model:  ${profileModelLabel(edited)}`));
+            await preSaveConnectionTest(name, opts.test);
         }
         catch (err) {
             console.error(chalk.red(err.message));

package/dist/commands/perf.js

@@ -132,6 +132,16 @@ function renderLabelTable(title, rows, warnMs, limit) {
         formatMs(r.maxMs),
         formatRateColumn(r),
     ]), sliced.map((r) => r.p99Ms > warnMs));
+    // Sub-phase break-out (agent.run's `startup` = spawn overhead before the child
+    // runs, PHNX-3468). Indented under the row so a slow boot is visible next to
+    // the total without adding columns that are empty for phaseless labels.
+    for (const r of sliced) {
+        if (!r.phases)
+            continue;
+        for (const [name, ph] of Object.entries(r.phases)) {
+            console.log(chalk.gray(`  └ ${name}: p50 ${formatMs(ph.p50Ms)}  p90 ${formatMs(ph.p90Ms)}  (n=${ph.n})`));
+        }
+    }
 }
 /**
  * Prefer SQLite samples; fall back to the legacy daily JSONL so existing

package/dist/commands/reminders.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `agents reminders` — list your personal operating reminders.
+ *
+ * The reminders live in `~/.agents/reminders/reminders.yaml` and are surfaced
+ * succinctly in the Claude statusline — one per session, chosen from the session
+ * id. This command shows the full set (and the file to edit).
+ */
+import type { Command } from 'commander';
+export declare function registerRemindersCommand(program: Command): void;

package/dist/commands/reminders.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { loadReminders, remindersFilePath } from '../lib/reminders.js';
+import { setHelpSections } from '../lib/help.js';
+const EXAMPLES = [
+    'agents reminders          # list your operating reminders',
+    'agents reminders --json   # machine-readable output',
+].join('\n');
+const NOTES = [
+    "Reminders live in ~/.agents/reminders/reminders.yaml and sync across the fleet via 'agents repo push'.",
+    'One shows succinctly in the Claude statusline per session, chosen deterministically from the session id,',
+    'so concurrent agents each show a different one and it stays stable within a session.',
+].join('\n');
+export function registerRemindersCommand(program) {
+    const cmd = program
+        .command('reminders')
+        .description('Personal operating reminders shown in the Claude statusline')
+        .option('--json', 'output as JSON')
+        .action((opts) => {
+        const file = remindersFilePath();
+        let reminders;
+        try {
+            reminders = loadReminders();
+        }
+        catch (err) {
+            console.error(chalk.red(`Could not read reminders: ${err instanceof Error ? err.message : String(err)}`));
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.json) {
+            process.stdout.write(`${JSON.stringify({ file, reminders }, null, 2)}\n`);
+            return;
+        }
+        if (reminders.length === 0) {
+            console.log(`No reminders yet. Add them to ${chalk.cyan(file)}`);
+            console.log(chalk.dim('Each shows succinctly in the Claude statusline — one per session.'));
+            return;
+        }
+        const count = `${reminders.length} reminder${reminders.length === 1 ? '' : 's'}`;
+        console.log(chalk.dim(`${count} · ${file}`));
+        console.log(chalk.dim('One shows in the Claude statusline per session, chosen from the session id.\n'));
+        for (const reminder of reminders) {
+            console.log(`  ${chalk.cyan('◆')} ${chalk.bold(reminder.short)}`);
+            if (reminder.full && reminder.full !== reminder.short) {
+                console.log(`    ${chalk.dim(reminder.full)}`);
+            }
+        }
+    });
+    setHelpSections(cmd, { examples: EXAMPLES, notes: NOTES });
+}

package/dist/commands/run-account-picker.d.ts

@@ -52,6 +52,20 @@ export declare function signInLaunchDecision(input: {
     tty: boolean;
     json: boolean;
 }): 'launch' | 'fail-loud';
+/**
+ * How a `balanced`/`available` run reacts when every account's usage is stale and
+ * none is verified (PHNX-2526). A human present at a real terminal gets the
+ * account `picker` — they can choose knowing the numbers are stale — while every
+ * unattended shape (`--headless`, `--json`, or no TTY) `fail-loud`s with
+ * NO_VERIFIED_USAGE rather than silently guess on a stale snapshot. `headless`
+ * joins the gate because a routine/machine dispatch can carry a TTY yet have no
+ * human to answer a picker; the split mirrors `signInLaunchDecision`.
+ */
+export declare function noVerifiedUsageDecision(input: {
+    tty: boolean;
+    json: boolean;
+    headless: boolean;
+}): 'picker' | 'fail-loud';
 /**
  * Choose which installed version to launch so the user can authenticate, when a
  * strategy found zero healthy accounts but at least one is merely signed out

package/dist/commands/run-account-picker.js

@@ -221,6 +221,19 @@ export function signInLaunchDecision(input) {
     const humanPresent = input.tty && !input.json;
     return input.recoverable > 0 && humanPresent ? 'launch' : 'fail-loud';
 }
+/**
+ * How a `balanced`/`available` run reacts when every account's usage is stale and
+ * none is verified (PHNX-2526). A human present at a real terminal gets the
+ * account `picker` — they can choose knowing the numbers are stale — while every
+ * unattended shape (`--headless`, `--json`, or no TTY) `fail-loud`s with
+ * NO_VERIFIED_USAGE rather than silently guess on a stale snapshot. `headless`
+ * joins the gate because a routine/machine dispatch can carry a TTY yet have no
+ * human to answer a picker; the split mirrors `signInLaunchDecision`.
+ */
+export function noVerifiedUsageDecision(input) {
+    const humanPresent = input.tty && !input.json && !input.headless;
+    return humanPresent ? 'picker' : 'fail-loud';
+}
 /**
  * Choose which installed version to launch so the user can authenticate, when a
  * strategy found zero healthy accounts but at least one is merely signed out

package/dist/commands/sessions-picker.d.ts

@@ -3,6 +3,19 @@ import { fetchPeerPreviewDigest } from '../lib/session/remote-list.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
 import type { FileChange } from '../lib/session/digest.js';
 import { extractArtifacts, extractHooks, extractLinks, extractSkills } from '../lib/session/highlights.js';
+/** A session whose transcript FILE is on another machine: its `filePath` is on
+ * that peer's disk, so the preview can't parse it locally — it fetches the
+ * peer's digest over SSH and shows metadata + a "resume there" note until that
+ * lands. `_remote` is an explicit signal; a peer `machine` plus no readable
+ * local file covers host-dispatch index rows and live-registry rows that were
+ * synthesized outside the fan-out. A locally-readable synced mirror stays
+ * local even when its recorded owner is another machine.
+ *
+ * This is the READ rule and only the read rule. Whether a session may be
+ * RESUMED here is a different question with a different answer — a mirror is
+ * readable but not resumable — and `sessionOwnerDevice`
+ * (lib/session/resume-owner.ts) is the single place that answers it (RUSH-2022). */
+export declare function transcriptOnPeerOf(session: SessionMeta): string | undefined;
 /**
  * Compact checklist tally for list rows and previews (RUSH-2045).
  * Example: `✓6/8 · A5 wiring runner`. Empty string when there is no list.

package/dist/commands/sessions-picker.js

@@ -25,19 +25,28 @@ import { createMemoryCache } from '../lib/memory-cache.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
 import { extractArtifacts, extractHooks, extractLinks, extractRepos, extractSkills, harnessTracksBackgroundShells, isBackgroundShellStart, isSubAgentTool, } from '../lib/session/highlights.js';
 import { getSessionPlugins, readSessionPreviewCache, writeSessionPreviewCache, readSessionContent, readArchivedSessionPreview } from '../lib/session/db.js';
-/** A session whose transcript FILE is on another machine (folded in over the
- * live cross-machine fan-out): its `filePath` is on that peer's disk, so the
- * preview can't parse it locally — it fetches the peer's digest over SSH and
- * shows metadata + a "resume there" note until that lands. Keys off `_remote`,
- * not the machine tag, so locally-readable synced mirrors still parse their
- * file normally.
+import { machineId } from '../lib/session/sync/config.js';
+/** A session whose transcript FILE is on another machine: its `filePath` is on
+ * that peer's disk, so the preview can't parse it locally — it fetches the
+ * peer's digest over SSH and shows metadata + a "resume there" note until that
+ * lands. `_remote` is an explicit signal; a peer `machine` plus no readable
+ * local file covers host-dispatch index rows and live-registry rows that were
+ * synthesized outside the fan-out. A locally-readable synced mirror stays
+ * local even when its recorded owner is another machine.
  *
  * This is the READ rule and only the read rule. Whether a session may be
  * RESUMED here is a different question with a different answer — a mirror is
  * readable but not resumable — and `sessionOwnerDevice`
  * (lib/session/resume-owner.ts) is the single place that answers it (RUSH-2022). */
-function transcriptOnPeerOf(session) {
-    return session._remote ? session.machine : undefined;
+export function transcriptOnPeerOf(session) {
+    if (session._remote)
+        return session.machine;
+    if (session.machine
+        && session.machine !== machineId()
+        && (!session.filePath || !fs.existsSync(session.filePath))) {
+        return session.machine;
+    }
+    return undefined;
 }
 /**
  * Compact checklist tally for list rows and previews (RUSH-2045).

package/dist/commands/sessions.js

@@ -55,7 +55,7 @@ import { listInstalledVersions, resolveVersionAliasLoose } from '../lib/installa
 import { getAgentsInvocation } from '../lib/daemon/daemon.js';
 import { sessionRecoveryRunArgs } from '../lib/session/recovery.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
-import { sessionPicker, buildPreview, loadSessionPreviewDigest, formatTodoCompact, githubRepoUrlFromCwd, } from './sessions-picker.js';
+import { sessionPicker, buildPreview, loadSessionPreviewDigest, transcriptOnPeerOf, formatTodoCompact, githubRepoUrlFromCwd, } from './sessions-picker.js';
 import { setHelpSections } from '../lib/help.js';
 import { registerSessionsTailCommand } from './sessions-tail.js';
 import { registerSessionsResumeCommand } from './sessions-resume.js';
@@ -2017,13 +2017,14 @@ export async function renderSessionPreview(query, scope) {
         return;
     }
     const session = outcome.session;
-    if (session._remote && session.machine && session.machine !== machineId()) {
+    const transcriptPeer = transcriptOnPeerOf(session);
+    if (transcriptPeer) {
         const args = ['sessions', 'preview', session.id, '--local'];
         if (scope.json)
             args.push('--json');
-        const rendered = await runOnPeer(args, session.machine);
+        const rendered = await runOnPeer(args, transcriptPeer);
         if (rendered === 'no-target') {
-            console.error(chalk.red(`Session ${session.id} is on ${session.machine}, but that device is not reachable.`));
+            console.error(chalk.red(`Session ${session.id} is on ${transcriptPeer}, but that device is not reachable.`));
             process.exitCode = 1;
         }
         return;
@@ -3873,11 +3874,11 @@ export async function handlePickedSession(picked) {
     }
     // Reading and resuming are on DIFFERENT machines' terms, and conflating them
     // is what RUSH-2022 was. Reading follows the FILE: a synced mirror sits on
-    // this disk, so only a live fan-out row (`_remote`) has to be read on the
-    // peer. Resuming follows the HARNESS STATE, which is on the owning machine
-    // whatever the transcript's location — a mirror included.
+    // this disk, so a peer-owned row with no readable local transcript has to be
+    // read on the peer. Resuming follows the HARNESS STATE, which is on the
+    // owning machine whatever the transcript's location — a mirror included.
     if (picked.action === 'view') {
-        const readFrom = picked.session._remote ? picked.session.machine : undefined;
+        const readFrom = transcriptOnPeerOf(picked.session);
         if (readFrom) {
             const rc = await runOnPeer(['sessions', picked.session.shortId, '--markdown'], readFrom);
             if (rc === 'no-target')
@@ -4503,7 +4504,8 @@ async function renderOneSession(query, mode, scope) {
         }
         if (outcome.kind === 'resolved') {
             const resolved = outcome.session;
-            if (resolved._remote && resolved.machine && resolved.machine !== machineId()) {
+            const transcriptPeer = transcriptOnPeerOf(resolved);
+            if (transcriptPeer) {
                 const args = ['sessions', resolved.id, '--local'];
                 const flag = modeFlag(mode);
                 if (flag)
@@ -4518,9 +4520,9 @@ async function renderOneSession(query, mode, scope) {
                     args.push('--last', String(scope.filter.last));
                 if (scope.redact === false)
                     args.push('--no-redact');
-                const rendered = await runOnPeer(args, resolved.machine);
+                const rendered = await runOnPeer(args, transcriptPeer);
                 if (rendered === 'no-target') {
-                    console.error(chalk.red(`Session ${resolved.id} is on ${resolved.machine}, but that device is not reachable.`));
+                    console.error(chalk.red(`Session ${resolved.id} is on ${transcriptPeer}, but that device is not reachable.`));
                     process.exit(1);
                 }
                 return;

package/dist/commands/teams-picker.js

@@ -9,6 +9,7 @@
 import chalk from 'chalk';
 import { relTime, truncate, humanDuration } from '../lib/format.js';
 import { itemPicker } from '../lib/picker.js';
+import { deliveryDisplayLabel, deliveryColorKey } from '../lib/teams/delivery.js';
 const AGENT_LABEL = {
     claude: 'Claude',
     codex: 'Codex',
@@ -21,6 +22,7 @@ function statusColor(status) {
         case 'pending': return chalk.blue;
         case 'running': return chalk.yellow;
         case 'completed': return chalk.green;
+        case 'stranded': return chalk.yellow;
         case 'failed': return chalk.red;
         case 'stopped': return chalk.gray;
         default: return chalk.white;
@@ -61,10 +63,12 @@ function displayAgent(agent, version) {
 function statusCell(t) {
     if (t.agent_count === 0)
         return chalk.gray('empty');
+    const done = Math.max(0, t.completed - (t.stranded ?? 0));
     const states = [
         [t.pending, chalk.blue, 'pending'],
         [t.running, chalk.yellow, 'working'],
-        [t.completed, chalk.green, 'done'],
+        [done, chalk.green, 'done'],
+        [t.stranded ?? 0, chalk.yellow, 'stranded'],
         [t.failed, chalk.red, 'failed'],
         [t.stopped, chalk.gray, 'stopped'],
     ];
@@ -76,13 +80,16 @@ function statusCell(t) {
     return nonzero.map(([n, color, label]) => color(`${n} ${label}`)).join(chalk.gray(' · '));
 }
 function statusSummaryParts(t) {
+    const done = Math.max(0, t.completed - (t.stranded ?? 0));
     const parts = [];
     if (t.pending)
         parts.push(chalk.blue(`${t.pending} pending`));
     if (t.running)
         parts.push(chalk.yellow(`${t.running} working`));
-    if (t.completed)
-        parts.push(chalk.green(`${t.completed} done`));
+    if (done)
+        parts.push(chalk.green(`${done} done`));
+    if (t.stranded)
+        parts.push(chalk.yellow(`${t.stranded} stranded`));
     if (t.failed)
         parts.push(chalk.red(`${t.failed} failed`));
     if (t.stopped)
@@ -173,7 +180,12 @@ export function buildTeamPreview(row) {
     const nameW = Math.max(6, ...row.agents.map((a) => displayHandle(a).length));
     const agentW = Math.max(8, ...row.agents.map((a) => displayAgent(a.agent_type, a.version).length));
     for (const a of row.agents) {
-        const stat = statusColor(a.status)(a.status);
+        const delivery = a.delivery;
+        const colorKey = delivery ? deliveryColorKey(delivery, a.status) : a.status;
+        const label = delivery
+            ? deliveryDisplayLabel(delivery, a.status)
+            : a.status.toUpperCase();
+        const stat = statusColor(colorKey)(label);
         const metaParts = [];
         if (a.task_type)
             metaParts.push(chalk.magenta(a.task_type));
@@ -244,8 +256,8 @@ function searchHaystack(row) {
         parts.push(a.status);
     }
     // Also include team-level status words exposed in the row ("done",
-    // "working", "pending", "failed", "stopped", "empty") so the search matches
-    // what the user sees on screen.
+    // "working", "pending", "stranded", "failed", "stopped", "empty") so the
+    // search matches what the user sees on screen.
     const t = row.team;
     if (t.agent_count === 0)
         parts.push('empty');
@@ -255,6 +267,8 @@ function searchHaystack(row) {
         parts.push('working', 'running');
     if (t.completed)
         parts.push('done', 'completed');
+    if (t.stranded)
+        parts.push('stranded');
     if (t.failed)
         parts.push('failed');
     if (t.stopped)

package/dist/commands/teams.d.ts

@@ -108,7 +108,7 @@ export declare function staleRepoError(params: {
  * the teammate itself so we don't need the original --cloud CLI args.
  */
 export declare function wireCloudDispatcher(mgr: AgentManager): void;
-export declare function cloudDispatchOptions(agent: Pick<AgentProcess, 'prompt' | 'agentType' | 'cloudRepo' | 'cloudBranch' | 'model'>): DispatchOptions;
+export declare function cloudDispatchOptions(agent: Pick<AgentProcess, 'prompt' | 'agentType' | 'cloudRepo' | 'cloudBranch' | 'model' | 'mode'>): DispatchOptions;
 /**
  * Single-wave start used by `teams start` without --watch. startReady()
  * terminalizes a placement/spawn/cloud/dependency failure to FAILED with
@@ -120,11 +120,11 @@ export declare function cloudDispatchOptions(agent: Pick<AgentProcess, 'prompt'
 export declare function runOneWave(mgr: AgentManager, team: string, json: boolean): Promise<void>;
 export declare function buildTeamRowsFromSnapshots(registry: TeamRegistry, agents: TeamListAgentSnapshot[], 
 /** team name -> the session that spawned it (see teamSpawners). */
-spawners?: Map<string, TeamSpawner>): {
+spawners?: Map<string, TeamSpawner>): Promise<{
     rows: TeamRow[];
     teams: TaskInfo[];
     names: string[];
-};
+}>;
 /**
  * `teams add --remote-cwd` is a no-op trap. `--remote-cwd` comes from the shared
  * `--device` option family (option.ts) and is meaningful for commands that *route*