@phnx-labs/agents-cli 1.22.115 → 1.22.116

package/dist/commands/ssh.js

@@ -58,7 +58,6 @@ import { crabboxList, crabboxFind, crabboxSshArgv } from '../lib/crabbox/cli.js'
 import { boxAddress, boxStatus, fmtIdleShort, fmtExpiresShort, registerLeaseCommand } from './lease.js';
 import { registerSnapshotCommand } from './snapshot.js';
 import { authCellColor, formatCheckedAge, isDeadVerdict, readAuthHealthCache, summarizeHostAuth, summarizeVerdicts, verdictColor, verdictLabel, writeFleetAuthRows, } from '../lib/auth-health.js';
-import { runFleetLogin } from '../lib/fleet/remote-login.js';
 import { getConfigValue, listConfig, setConfigValue, unsetConfigValue, configKeySpec, autoPoolMode, configuredDeviceRole, listConfiguredDeviceRoles, setConfiguredDeviceRole, } from '../lib/device-config.js';
 import { filterAutoPool, listWorkerDevices } from '../lib/devices/pool.js';
 import { registerCommandGroups, setHelpSections } from '../lib/help.js';
@@ -1055,46 +1054,6 @@ function renderAuthMatrix(results, opts) {
     }
     return lines;
 }
-/** Render the final `fleet login` result summary in the house auth-matrix style. */
-function renderLoginMatrix(results) {
-    const lines = [chalk.bold('Fleet login')];
-    if (results.length === 0) {
-        lines.push(chalk.gray('  Nothing pending — every requested account is already logged in.'));
-        return lines;
-    }
-    const nameW = Math.max(6, ...results.map((r) => `${r.agent}@${r.device}`.length));
-    for (const r of results) {
-        const who = `${r.agent}@${r.device}`.padEnd(nameW);
-        let badge;
-        switch (r.state) {
-            case 'authorized':
-                badge = chalk.green('authorized');
-                break;
-            case 'ready':
-                badge = chalk.cyan('code ready');
-                break;
-            case 'driving':
-                badge = chalk.yellow('driving');
-                break;
-            case 'skipped':
-                badge = chalk.gray('not remotable');
-                break;
-            case 'error':
-                badge = chalk.red('error');
-                break;
-            default:
-                badge = chalk.gray(r.state);
-                break;
-        }
-        const note = r.detail ? chalk.dim(`  ${r.detail}`) : (r.reason && !r.remotable ? chalk.dim(`  ${r.reason}`) : '');
-        lines.push(`  ${who}  ${badge}${note}`);
-    }
-    const auth = results.filter((r) => r.state === 'authorized').length;
-    const remotable = results.filter((r) => r.remotable).length;
-    lines.push('');
-    lines.push(chalk.gray(`  ${auth}/${remotable} remotable logins authorized`));
-    return lines;
-}
 /** Register the `agents devices` command tree (also aliased as `fleet`). */
 function registerDevicesCommands(program) {
     const devicesCmd = program
@@ -1141,7 +1100,7 @@ function registerDevicesCommands(program) {
         { title: 'Inspect', names: ['list', 'show', 'status', 'ping', 'harnesses', 'accounts', 'snapshot'] },
         { title: 'Disposable devices', names: ['lease'] },
         { title: 'Configure a device', names: ['config', 'describe', 'render'] },
-        { title: 'Fleet operations', names: ['update', 'run', 'login', 'capture', 'apply', 'worktrees'] },
+        { title: 'Fleet operations', names: ['update', 'run', 'capture', 'apply', 'worktrees'] },
     ]);
     devicesCmd
         .command('sync')
@@ -2008,33 +1967,6 @@ agents devices accounts --json           # machine-readable, per-host account gr
 Collapses the installs that share one account (e.g. five claude versions on one
 email) into a single row. Use \`agents devices harnesses\` for the per-install view.`,
     });
-    devicesCmd
-        .command('login')
-        .description('Log agent CLIs into fleet boxes over SSH: drive each box\'s device-code OAuth, scrape the URL + code, and surface every pending login in one local browser page. Default drives all codes at once; --interactive walks one box at a time (codes requested just-in-time so they don\'t expire).')
-        .option('--agents <csv>', 'only these agents (comma-separated); default: every agent with a device-code flow')
-        .option('--devices <csv>', 'only these devices (comma-separated); default: every online box')
-        .option('--all', 'target every device-code pair regardless of cached login state (cold cache / forced re-login)')
-        .option('--interactive', 'guided one-box-at-a-time wizard (codes requested just-in-time)')
-        .option('--json', 'output the final result matrix as JSON')
-        .action(async (opts) => {
-        const csv = (s) => (s ? s.split(',').map((x) => x.trim()).filter(Boolean) : undefined);
-        const results = await runFleetLogin({
-            agents: csv(opts.agents),
-            devices: csv(opts.devices),
-            all: opts.all,
-            interactive: opts.interactive,
-            json: opts.json,
-        });
-        if (opts.json) {
-            console.log(JSON.stringify(results, null, 2));
-        }
-        else {
-            for (const line of renderLoginMatrix(results))
-                console.log(line);
-        }
-        if (results.some((r) => r.remotable && r.state !== 'authorized'))
-            process.exitCode = 1;
-    });
     devicesCmd
         .command('show <name>')
         .description('Show the full profile for one device.')

package/dist/lib/accounting/rotate.d.ts

@@ -4,7 +4,7 @@
  * Detects which installed versions have expired credentials and rotates
  * authentication tokens so users maintain active sessions across version switches.
  */
-import type { AgentId, RunStrategy } from '../types.js';
+import { type AgentId, type RunStrategy } from '../types.js';
 import type { FallbackEntry } from '../exec.js';
 import { PROJECTION_HORIZON_MIN, capacityWeight } from './capacity.js';
 import { type AccountInfo, type CredentialPresence } from '../agents.js';
@@ -549,6 +549,68 @@ export declare const DEFAULT_ROTATION_FAILOVER_LIMIT = 3;
  * completely unchanged.
  */
 export declare function rotationFailoverChain(rotation: RotateResult | null, pickedVersion: string, limit?: number): FallbackEntry[];
+/**
+ * Whether a run SHAPE may take the preflight alternate-harness handoff
+ * ({@link preflightFallbackHandoff}) — the sibling of
+ * {@link shouldArmRotationFailover}, and load-bearing for the same reason.
+ *
+ * The handoff consumes the entry it uses from the `--fallback` spec, and the
+ * canonical `--fallback` validation runs LATER in the run command: it rejects a
+ * chain on an interactive, `--acp`, `--loop`, or `--resume-checkpoint` run, and
+ * requires a prompt. Handing off first on one of those shapes would empty the
+ * spec, leave that guard nothing to reject, and let the run proceed as the
+ * alternate harness — an interactive Codex launch from
+ * `agents run claude --interactive --fallback codex`, which the CLI refuses
+ * today. Gating the shape here keeps the original validation intact: an
+ * ineligible shape never switches, so the spec survives and still fails there
+ * with its own message.
+ *
+ * `resume` and `workflowScoped` are excluded for their own reasons: a resume is
+ * bound to the session's OWN harness, and a workflow's tool/MCP scoping is
+ * claude-only, so switching harness would silently drop the declared sandbox —
+ * the fail-open `runWithFallback` only warns about.
+ *
+ * Pure so the matrix is unit-testable without invoking the run command.
+ */
+export interface PreflightHandoffContext {
+    hasPrompt: boolean;
+    interactive: boolean;
+    acp: boolean;
+    loop: boolean;
+    resumeCheckpoint: boolean;
+    resume: boolean;
+    workflowScoped: boolean;
+}
+export declare function preflightHandoffEligible(ctx: PreflightHandoffContext): boolean;
+/**
+ * The permitted alternate harness to launch when EVERY account of the primary
+ * agent is already exhausted at PREFLIGHT (PHNX-3999 F19).
+ *
+ * `runWithFallback` only reaches a `--fallback` entry after the primary has
+ * actually RUN and hit a rate limit. When the primary's accounts are throttled
+ * before the run starts, version resolution reports `exhausted` and the run used
+ * to exit — so the alternate a user configured for exactly this case never fired.
+ * This resolves the first usable alternate from the same `--fallback` spec, and
+ * returns the remainder of the spec so the alternate becomes the primary and is
+ * not also listed as its own fallback.
+ *
+ * Deliberately NOT a second parser: an entry this cannot resolve exactly — a
+ * typo, an alias the canonical parse would fuzzy-match, the primary itself —
+ * makes the WHOLE spec yield `null`, so the run reaches the one canonical
+ * `--fallback` parse and fails (or corrects) there with the message it already
+ * has. `--fallback typoo,codex` must never silently launch codex while dropping
+ * `typoo`.
+ *
+ * Returns `null` when there is no spec, when any entry is not an exact agent id
+ * or names the primary, or when the primary is only sign-in-recoverable rather
+ * than throttled — a logged-out account is fixed by logging in, not by silently
+ * running a different harness.
+ */
+export declare function preflightFallbackHandoff(spec: string | undefined, primary: AgentId, exhausted: RotateCandidate[]): {
+    agent: AgentId;
+    version?: string;
+    remainingSpec?: string;
+} | null;
 /**
  * Whether a run is eligible to have a mid-run rate-limit failover chain armed
  * (issue #348). Failover injects synthesized `FallbackEntry`s into the same

package/dist/lib/accounting/rotate.js

@@ -6,6 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { isAgentId } from '../types.js';
 import { PROJECTION_HORIZON_MIN, capacityWeight } from './capacity.js';
 import { accountDisplayLabel, getAccountInfo, credentialPresence, ALL_AGENT_IDS, } from '../agents.js';
 import { readMeta, getHelpersDir } from '../state.js';
@@ -1206,6 +1207,61 @@ export function rotationFailoverChain(rotation, pickedVersion, limit = DEFAULT_R
     }
     return chain;
 }
+export function preflightHandoffEligible(ctx) {
+    return (ctx.hasPrompt &&
+        !ctx.interactive &&
+        !ctx.acp &&
+        !ctx.loop &&
+        !ctx.resumeCheckpoint &&
+        !ctx.resume &&
+        !ctx.workflowScoped);
+}
+/**
+ * The permitted alternate harness to launch when EVERY account of the primary
+ * agent is already exhausted at PREFLIGHT (PHNX-3999 F19).
+ *
+ * `runWithFallback` only reaches a `--fallback` entry after the primary has
+ * actually RUN and hit a rate limit. When the primary's accounts are throttled
+ * before the run starts, version resolution reports `exhausted` and the run used
+ * to exit — so the alternate a user configured for exactly this case never fired.
+ * This resolves the first usable alternate from the same `--fallback` spec, and
+ * returns the remainder of the spec so the alternate becomes the primary and is
+ * not also listed as its own fallback.
+ *
+ * Deliberately NOT a second parser: an entry this cannot resolve exactly — a
+ * typo, an alias the canonical parse would fuzzy-match, the primary itself —
+ * makes the WHOLE spec yield `null`, so the run reaches the one canonical
+ * `--fallback` parse and fails (or corrects) there with the message it already
+ * has. `--fallback typoo,codex` must never silently launch codex while dropping
+ * `typoo`.
+ *
+ * Returns `null` when there is no spec, when any entry is not an exact agent id
+ * or names the primary, or when the primary is only sign-in-recoverable rather
+ * than throttled — a logged-out account is fixed by logging in, not by silently
+ * running a different harness.
+ */
+export function preflightFallbackHandoff(spec, primary, exhausted) {
+    if (!spec)
+        return null;
+    if (exhausted.length === 0)
+        return null;
+    if (signInRecoverableCandidates(exhausted).length > 0)
+        return null;
+    const entries = spec.split(',').map((e) => e.trim()).filter(Boolean);
+    if (entries.length === 0)
+        return null;
+    const parsed = entries.map((entry) => entry.split('@'));
+    // Every entry has to be exactly resolvable, or this defers entirely.
+    if (parsed.some(([name]) => !isAgentId(name) || name === primary))
+        return null;
+    const [name, version] = parsed[0];
+    const remaining = entries.slice(1);
+    return {
+        agent: name,
+        version: version || undefined,
+        remainingSpec: remaining.length > 0 ? remaining.join(',') : undefined,
+    };
+}
 export function shouldArmRotationFailover(ctx) {
     return (ctx.hasRotation &&
         ctx.hasVersion &&

package/dist/lib/accounts/add.js

@@ -89,11 +89,11 @@ export function workerProvisioningHint(agent) {
             parts.push(env === 'provider' ? 'a provider API key collected by add (--api-key)' : `the ${env} collected by add (--api-key)`);
         }
         else if (kind.startsWith('per-device')) {
-            parts.push(`per-device login on each worker (--per-device / agents fleet login ${agent})`);
+            parts.push(`per-device login on each worker (--per-device; run \`agents run ${agent} --device <box>\` there and complete its native login)`);
         }
     }
     if (parts.length === 0)
-        return `${agent} has no portable credential — it logs in per box (agents fleet login ${agent})`;
+        return `${agent} has no portable credential — it logs in per box (run \`agents run ${agent} --device <box>\` on the worker and complete its native login)`;
     return parts.join(', or ');
 }
 /**

package/dist/lib/accounts/slots.js

@@ -13,7 +13,8 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { agentConfigDirName } from '../agents.js';
+import { AGENTS, agentConfigDirName } from '../agents.js';
+import { createLink } from '../platform/links.js';
 import { harnessAuth, harnessWorkerIsPerDevice } from '../harness-auth-capabilities.js';
 import { installSessionTrackerHookSync } from '../hooks/install.js';
 import { getGlobalDefault, getVersionHomePath, listInstalledVersions } from '../installations/store.js';
@@ -64,7 +65,36 @@ function projectResources(harness, version, destHome, fromHome) {
         if (!writer)
             continue;
         if (kind === 'rules') {
-            writer.write({ version, versionHome: destHome, selection: { preset: 'default' }, cwd });
+            // Symlink to the version home's rules instead of composing a duplicate.
+            // Harnesses whose shim pins a separate config dir (e.g. CLAUDE_CONFIG_DIR
+            // → account slot) cause the harness to load rules from both the version
+            // home (~/.claude/) and the slot, doubling ~5 K tokens per session.
+            // A symlink gives both paths the same inode so the harness can dedup.
+            const cap = AGENTS[harness].capabilities.rules;
+            if (typeof cap !== 'object')
+                continue;
+            const srcFile = path.join(fromHome, agentConfigDirName(harness), cap.file);
+            if (!fs.existsSync(srcFile)) {
+                writer.write({ version, versionHome: destHome, selection: { preset: 'default' }, cwd });
+                continue;
+            }
+            const destFile = path.join(destHome, agentConfigDirName(harness), cap.file);
+            fs.mkdirSync(path.dirname(destFile), { recursive: true });
+            try {
+                const st = fs.lstatSync(destFile);
+                if (st.isSymbolicLink() || st.isFile())
+                    fs.unlinkSync(destFile);
+            }
+            catch { /* did not exist */ }
+            try {
+                createLink(srcFile, destFile);
+            }
+            catch (err) {
+                if (err.code === 'EEXIST') {
+                    continue;
+                }
+                throw err;
+            }
             continue;
         }
         const names = getDetector(kind, harness)?.list({ version, versionHome: fromHome, cwd }) ?? [];

package/dist/lib/answer-router.d.ts

@@ -10,7 +10,7 @@
  * This module picks the delivery mechanism from (open feed block × session
  * liveness × runtime rail). Pure — unit-testable without a live terminal.
  */
-import type { OpenBlock, BlockOption } from './feed/feed.js';
+import { type OpenBlock, type BlockOption } from './feed/feed.js';
 import type { ActiveSession } from './session/active.js';
 import type { InjectTarget } from './terminal/index.js';
 export type AnswerRouteKind = 'mailbox' | 'tmux' | 'iterm' | 'resume' | 'refuse';
@@ -67,7 +67,16 @@ export declare function keystrokesForAnswer(answer: string, options?: Array<Pick
 };
 /** True when the session is waiting on user input (parked on a question/plan). */
 export declare function isParkedOnInput(session: ActiveSession | null | undefined): boolean;
-/** True when an open feed block still needs an answer. */
+/**
+ * True when an open feed block still needs an answer.
+ *
+ * Openness comes from {@link deriveBlockState}, not from `block.answer` being
+ * truthy: a PENDING claim records the answer while deliberately leaving the
+ * block `open` (feed.ts `recordAnswer`'s two-phase mode), so reading the field
+ * directly would call a claimed-but-undelivered block "closed" — and a retry of
+ * a stranded claim would then re-route a parked headless agent to the mailbox it
+ * will never drain (PHNX-3999).
+ */
 export declare function isOpenQuestionBlock(block: OpenBlock | null | undefined): boolean;
 /**
  * Pick the delivery mechanism for one answer.

package/dist/lib/answer-router.js

@@ -1,3 +1,16 @@
+/**
+ * Parked-agent answer router (RUSH-1474).
+ *
+ * `agents message` historically only enqueued into the mailbox (delivered at the
+ * next PreToolUse). That steers a *running* agent between tool calls but never
+ * unblocks a *parked* agent:
+ *   - interactive TUI open on AskUserQuestion (needs keystrokes, not context)
+ *   - headless run waiting on input (no next tool call; needs resume)
+ *
+ * This module picks the delivery mechanism from (open feed block × session
+ * liveness × runtime rail). Pure — unit-testable without a live terminal.
+ */
+import { deriveBlockState } from './feed/feed.js';
 import { addressabilityRecoveryHint } from './terminal/resolve.js';
 import { injectTargetFromReplyRail } from './session/inject.js';
 /** The Escape keystroke as its raw control byte — what a tmux/iterm rail reads as a real Escape. */
@@ -64,11 +77,22 @@ export function isParkedOnInput(session) {
     }
     return false;
 }
-/** True when an open feed block still needs an answer. */
+/**
+ * True when an open feed block still needs an answer.
+ *
+ * Openness comes from {@link deriveBlockState}, not from `block.answer` being
+ * truthy: a PENDING claim records the answer while deliberately leaving the
+ * block `open` (feed.ts `recordAnswer`'s two-phase mode), so reading the field
+ * directly would call a claimed-but-undelivered block "closed" — and a retry of
+ * a stranded claim would then re-route a parked headless agent to the mailbox it
+ * will never drain (PHNX-3999).
+ */
 export function isOpenQuestionBlock(block) {
     if (!block)
         return false;
-    if (block.answer || block.parkedAt || block.continuedAt || block.defaultedAt)
+    if (block.parkedAt || block.continuedAt || block.defaultedAt)
+        return false;
+    if (deriveBlockState(block) !== 'open')
         return false;
     return (block.questions?.length ?? 0) > 0;
 }

package/dist/lib/auth-mint.d.ts

@@ -1,8 +1,8 @@
 /**
  * First-class setup-token mint + seed (PHNX-2364).
  *
- * Closes the mint-auth manual recipe: drive `claude setup-token` through the
- * same injectable term driver `agents fleet login` uses, capture a well-formed
+ * Closes the mint-auth manual recipe: drive `claude setup-token` through an
+ * injectable term driver (`lib/term-driver.ts`), capture a well-formed
  * `sk-ant-oat01-…` token (the #1767 ANSI-banner guard), and seed BOTH:
  *
  *   1. a named provider account (`agents accounts add` shape, policy never)
@@ -16,7 +16,7 @@
 import type { AgentId, Meta } from './types.js';
 import { type CredentialAccount } from './account-registry.js';
 import { type StorableCredentialKind } from './secrets-policy.js';
-import { type DriveOptions, type TermDriver } from './fleet/remote-login.js';
+import { type DriveOptions, type TermDriver } from './term-driver.js';
 /** Well-formed Claude setup-token as it appears inside a TTY blob. */
 export declare const CLAUDE_SETUP_TOKEN_CAPTURE_RE: RegExp;
 export interface MintFlow {
@@ -37,7 +37,8 @@ export interface MintFlow {
  * key, COLLECTED via `--api-key` or a prompt by `accounts add` (never derived
  * from OAuth). The api-key entries describe collection only — they have no
  * mint argv, and `mintAndSeed` refuses them with the `accounts add` pointer.
- * Native device-code login (kimi/antigravity) stays on `agents fleet login`.
+ * A token-less harness (kimi/antigravity) has no portable credential and logs
+ * in per box (run it there and complete its native login).
  * The apiKeyEnv values are pinned to HARNESS_AUTH's `api-key:<ENV>` worker
  * kinds by auth-mint.test.ts — keep them in lockstep.
  */

package/dist/lib/auth-mint.js

@@ -5,7 +5,7 @@ import { bundleBackendSync, isSecretsClientError, bundleExists, bundleExistsSync
 import { assertStorableCredentialKind, reservedStoreName, } from './secrets-policy.js';
 import { getBinaryPath, getGlobalDefault, getVersionHomePath, listInstalledVersions } from './installations/versions.js';
 import { shellQuote } from './ssh-exec.js';
-import { defaultTermDriver, } from './fleet/remote-login.js';
+import { defaultTermDriver, } from './term-driver.js';
 import { showUrl } from './open-url.js';
 import { loadDevices } from './devices/registry.js';
 import { isSelfHost } from './devices/self-host.js';
@@ -21,7 +21,8 @@ const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  * key, COLLECTED via `--api-key` or a prompt by `accounts add` (never derived
  * from OAuth). The api-key entries describe collection only — they have no
  * mint argv, and `mintAndSeed` refuses them with the `accounts add` pointer.
- * Native device-code login (kimi/antigravity) stays on `agents fleet login`.
+ * A token-less harness (kimi/antigravity) has no portable credential and logs
+ * in per box (run it there and complete its native login).
  * The apiKeyEnv values are pinned to HARNESS_AUTH's `api-key:<ENV>` worker
  * kinds by auth-mint.test.ts — keep them in lockstep.
  */
@@ -63,7 +64,7 @@ export function unmintableMessage(harness) {
     return [
         `Cannot mint a setup-token for '${harness}'.`,
         `Interactive setup-token mint is implemented for: ${listMintableHarnesses().join(', ')}.`,
-        `Device-code native login is \`agents fleet login --agent ${harness}\`.`,
+        `A token-less harness like '${harness}' logs in per box — run it on that device and complete its native login.`,
         `API-key / pasted-token accounts use \`agents accounts add <name> --provider <provider> --auth api-key\`.`,
     ].join(' ');
 }

package/dist/lib/browser/drivers/arc.d.ts

@@ -7,7 +7,7 @@ interface ArcNativeTab extends ArcNativeTabRef {
     url: string;
     title: string;
 }
-interface ArcEnumeratedSpace {
+export interface ArcEnumeratedSpace {
     windowId: string;
     spaceId: string;
     spaceTitle: string;

package/dist/lib/browser/service.d.ts

@@ -731,6 +731,16 @@ export declare class BrowserService {
      * async/promise evaluation fails honestly with an AppleScript error.
      */
     private evaluateArcNative;
+    /**
+     * Resolve a task's owned Arc tabs against one shared snapshot of every
+     * window/space/tab, rather than asking Arc per tab as `listArcTaskTabs` does.
+     *
+     * Same ownership rule as the live path — `requireArcTask`, then the recorded
+     * ref must be present in its original window and Space. The snapshot changes
+     * how often Arc is asked, never what counts as owned. Actions keep the live
+     * path, because a snapshot can go stale before it is acted on.
+     */
+    private listArcTaskTabsFromSnapshot;
     private listArcTaskTabs;
     /**
      * Close native Arc tabs owned by a task. Only closes tabs the task created