@phnx-labs/agents-cli 1.22.49 → 1.22.51

package/dist/commands/device-config-test-harness.js

@@ -0,0 +1,59 @@
+import { afterEach, expect } from 'vitest';
+import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// End-to-end tests for the unified `agents devices config` surface and the
+// retired-subcommand tombstones (configure / note / set / set-interactive /
+// enable / disable / prefer / unprefer). Spawns the REAL CLI against a
+// throwaway HOME (same pattern as ssh.test.ts) — no mocking; the assertions
+// read the actual files the commands wrote: per-device docs under
+// devices/<name>/agents.yaml (device layer) and central agents.yaml
+// fleet.defaults.config (fleet layer).
+export const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+export const INDEX = path.join(REPO_ROOT, 'src', 'index.ts');
+let testHome = '';
+afterEach(() => {
+    if (testHome)
+        fs.rmSync(testHome, { recursive: true, force: true });
+    testHome = '';
+});
+export function guardedHome() {
+    testHome = fs.mkdtempSync(path.join(os.tmpdir(), 'agents-devices-config-home-'));
+    const systemDir = path.join(testHome, '.agents', '.system');
+    fs.mkdirSync(path.join(systemDir, '.git'), { recursive: true });
+    fs.writeFileSync(path.join(systemDir, '.update-check'), JSON.stringify({ lastCheck: 4102444800000, latestVersion: '0.0.0' }));
+}
+export function run(args, extraEnv = {}) {
+    const r = spawnSync('bun', [INDEX, ...args], {
+        encoding: 'utf-8',
+        env: {
+            ...process.env,
+            HOME: testHome,
+            // os.homedir() reads USERPROFILE on Windows, so HOME alone leaves the
+            // spawned CLI resolving the real profile ('agents-cli is not set up').
+            USERPROFILE: testHome,
+            AGENTS_NO_UPDATE_CHECK: '1',
+            AGENTS_NO_USAGE_TRACK: '1',
+            // Default identity is mac-mini so machine-local keys (scheduler, tmux,
+            // browser consent) can be set in these tests. Override per-call to act
+            // as a different box.
+            AGENTS_SYNC_MACHINE_ID: 'mac-mini',
+            ...extraEnv,
+        },
+    });
+    return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', status: r.status };
+}
+export function centralDoc() {
+    const p = path.join(testHome, '.agents', 'agents.yaml');
+    return fs.existsSync(p) ? fs.readFileSync(p, 'utf-8') : '';
+}
+export function deviceDoc(name) {
+    const p = path.join(testHome, '.agents', 'devices', name, 'agents.yaml');
+    return fs.existsSync(p) ? fs.readFileSync(p, 'utf-8') : '';
+}
+export function addDevice(name, target = 'muqsit@192.0.2.1') {
+    const r = run(['devices', 'add', name, target]);
+    expect(r.status, r.stderr).toBe(0);
+}

package/dist/commands/exec.js

@@ -2377,7 +2377,13 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             }
             else {
                 try {
-                    const resolved = await resolveRunVersion(agent, strategy, cwd);
+                    // Account-centric candidate list: native version-home logins PLUS
+                    // provider accounts (setup-token / API-key) that can auth this agent,
+                    // so `--strategy balanced` spreads across ALL accounts, not just the
+                    // ones sitting in a version home (RUSH-3182). Run-path only — the
+                    // picker's other callers keep the native-only collector.
+                    const { collectRunCandidatesForRun } = await import('../lib/accounting/account-pool-collect.js');
+                    const resolved = await resolveRunVersion(agent, strategy, cwd, collectRunCandidatesForRun);
                     if (resolved.exhausted) {
                         // Zero healthy accounts splits two ways, and conflating them is what
                         // stranded a logged-out harness with no way in at all (RUSH-2334):
@@ -2428,6 +2434,23 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     else if (resolved.version) {
                         version = resolved.version;
                         rotationResult = resolved.rotation;
+                        // A balanced/available pick of a PROVIDER account (setup-token /
+                        // API-key) carries `providerAccount`. Resolve its env through the
+                        // same `resolveSpawnAccount` path an explicit `--account` uses, so
+                        // exec injects the credential; a native pick has no providerAccount
+                        // and runs from its own version home unchanged (RUSH-3182).
+                        const pickedProviderAccount = resolved.rotation?.picked.providerAccount;
+                        if (pickedProviderAccount) {
+                            try {
+                                const picked = resolveSpawnAccount(pickedProviderAccount, agent, resolved.version, readMeta(), { useDefault: false });
+                                if (picked?.kind === 'provider')
+                                    accountEnv = picked.env;
+                            }
+                            catch (err) {
+                                console.error(chalk.red(err.message));
+                                process.exit(1);
+                            }
+                        }
                         if (resolved.rotation && !options.quiet) {
                             const banner = formatRotationBanner(resolved.rotation, strategy);
                             process.stderr.write(chalk.gray(banner + '\n'));

package/dist/commands/feedback.js

@@ -7,7 +7,7 @@ import { arch, platform, release } from 'node:os';
 import { createRequire } from 'node:module';
 import chalk from 'chalk';
 import { showUrl } from '../lib/open-url.js';
-const REPO = 'phnx-labs/agents-cli';
+const REPO = 'phnx-labs/agi-cli';
 const DISCUSSION_BASE = `https://github.com/${REPO}/discussions/new`;
 const ISSUE_BASE = `https://github.com/${REPO}/issues/new`;
 function readCliVersion() {

package/dist/commands/menubar.js

@@ -27,8 +27,9 @@ function printStatus(s, opts = {}) {
         return;
     }
     console.log(`  app installed      ${s.installedApp ? chalk.gray(s.installedApp) : chalk.gray('no')}`);
-    console.log(`  installed version  ${s.installedVersion ? chalk.gray(s.installedVersion) : chalk.gray('unknown')}`);
-    console.log(`  current version    ${chalk.gray(s.currentVersion)}`);
+    console.log(`  helper installed   ${s.installedVersion ? chalk.gray(s.installedVersion) : chalk.gray('unknown')}`);
+    console.log(`  helper available   ${chalk.gray(s.currentVersion)}`);
+    console.log(`  CLI version        ${chalk.gray(s.cliVersion)}`);
     console.log(`  bundle source      ${s.source ? chalk.gray(s.source) : chalk.red('missing (cannot enable)')}`);
     console.log(`  disabled by user   ${yn(s.disabledByUser)}`);
     // Two copies of the INSTALLED bundle is the duplicate the user sees as two
@@ -80,8 +81,9 @@ function printSetupResult(r) {
 function printDoctorReport(r) {
     console.log(chalk.bold('AGI Menu doctor\n'));
     console.log(`  install path       ${r.installPath ? chalk.gray(r.installPath) : chalk.red('not installed')}`);
-    console.log(`  installed version  ${r.installedVersion ? chalk.gray(r.installedVersion) : chalk.gray('unknown')}`);
-    console.log(`  CLI version        ${chalk.gray(r.currentVersion)}${r.versionMatches ? '' : chalk.yellow('  (mismatch — `agents menubar setup` updates it)')}`);
+    console.log(`  helper installed   ${r.installedVersion ? chalk.gray(r.installedVersion) : chalk.gray('unknown')}`);
+    console.log(`  helper available   ${chalk.gray(r.currentVersion)}${r.versionMatches ? '' : chalk.yellow('  (newer helper available — `agents menubar setup` installs it)')}`);
+    console.log(`  CLI version        ${chalk.gray(r.cliVersion)}`);
     const identity = r.signingIdentity === 'developer-id'
         ? chalk.green('Developer ID (update-stable)')
         : r.signingIdentity === 'ad-hoc'

package/dist/commands/share.js

@@ -36,6 +36,9 @@ export function formatSharePublishResult(result, json = false) {
     if (visibility === 'unlisted') {
         lines.push(chalk.dim('  visibility: unlisted (noindex, hidden from gallery)'));
     }
+    else if (visibility === 'me' || visibility === 'org') {
+        lines.push(chalk.dim(`  visibility: ${visibility} (login required, hidden from gallery)`));
+    }
     else {
         lines.push(chalk.dim(`  visibility: ${visibility}`));
     }
@@ -436,8 +439,8 @@ export function registerShareCommands(artifactsCmd) {
         .option('--slug <slug>', 'custom URL slug under your namespace (default: <feature>-<16hex>)')
         .option('--github-user <user>', 'GitHub username for the share namespace (default: resolved from gh/git config; ignored on the managed endpoint)')
         .option('--expire <spec>', "auto-expire (default 30d). e.g. 12h, 30d, 2026-08-01, or 'never'")
-        .addOption(new Option('--visibility <level>', 'public | unlisted (default public). unlisted is a capability URL: GET still works, hidden from the gallery, X-Robots-Tag: noindex')
-        .choices(['public', 'unlisted'])
+        .addOption(new Option('--visibility <level>', 'public | unlisted | me | org (default public). unlisted is a capability URL; me/org require a Phoenix session and are hidden from the gallery')
+        .choices(['public', 'unlisted', 'me', 'org'])
         .default('public'))
         .addOption(new Option('--unlisted', 'hidden alias of --visibility unlisted').hideHelp())
         .addOption(new Option('--private', 'hidden alias of --visibility unlisted').hideHelp())
@@ -525,8 +528,10 @@ ${SHARE_DELETE_EXAMPLES}
   a permanent link. --visibility unlisted (hidden aliases: --unlisted / --private)
   hides the page from the public gallery and agents artifacts share list; the
   direct URL is still world-readable (unlisted, not secret) and GET sends
-  X-Robots-Tag: noindex. A pre-publish scan refuses emails and credential-shaped
-  strings unless --force is passed.
+  X-Robots-Tag: noindex. --visibility me requires a Phoenix session and is only
+  visible to the signed-in owner; --visibility org requires the same and is
+  visible to members of the same Phoenix organization. A pre-publish scan
+  refuses emails and credential-shaped strings unless --force is passed.
 
   Every publish carries provenance auto-captured from the exec env/git/clock
   (agent, session, host, repo, date) — never invented, only sent when present —

package/dist/commands/teams.d.ts

@@ -7,9 +7,11 @@
  */
 import type { Command } from 'commander';
 import { AgentManager, AgentStatus, type TaskType } from '../lib/teams/agents.js';
+import type { DispatchOptions } from '../lib/cloud/types.js';
 import { type TaskInfo } from '../lib/teams/api.js';
 import { type TeamRow } from './teams-picker.js';
 import { type TeamSpawner } from '../lib/session/db.js';
+import type { AgentProcess } from '../lib/teams/agents.js';
 type TeamRegistry = Record<string, {
     created_at: string;
     description?: string;
@@ -106,6 +108,16 @@ 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;
+/**
+ * Single-wave start used by `teams start` without --watch. startReady()
+ * terminalizes a placement/spawn/cloud/dependency failure to FAILED with
+ * evidence rather than leaving it PENDING, so a teammate that failed this wave
+ * appears in neither `launched` nor `still_pending` — it must be diffed against
+ * the pre-wave roster and reported explicitly, or the wave reads as a success.
+ * A wave that only produced failures sets a non-zero exit code.
+ */
+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>): {

package/dist/commands/teams.js

@@ -364,17 +364,21 @@ export function wireCloudDispatcher(mgr) {
             throw new Error(`Teammate ${a.agentId} has no cloud provider set`);
         }
         const prov = resolveProvider(a.cloudProvider);
-        const dispatchOpts = {
-            prompt: a.prompt,
-            agent: a.agentType,
-            repo: a.cloudRepo ?? undefined,
-            branch: a.cloudBranch ?? undefined,
-            model: a.model ?? undefined,
-        };
+        const dispatchOpts = cloudDispatchOptions(a);
         const cloudTask = await prov.dispatch(dispatchOpts);
         return { cloudSessionId: cloudTask.id };
     });
 }
+export function cloudDispatchOptions(agent) {
+    return {
+        prompt: agent.prompt,
+        agent: agent.agentType,
+        repo: agent.cloudRepo ?? undefined,
+        branch: agent.cloudBranch ?? undefined,
+        model: agent.model ?? undefined,
+        env: shareRuntimeEnv(),
+    };
+}
 /**
  * Advisory: warn once per agent type of any still-pending (staged `--after`)
  * teammate whose CLI may not be signed in. Warn-only — never blocks `start`.
@@ -446,20 +450,32 @@ async function warnUnsignedTeammates(mgr, team) {
         }
     }
 }
-/** Single-wave start used by `teams start` without --watch. */
-async function runOneWave(mgr, team, json) {
+/**
+ * Single-wave start used by `teams start` without --watch. startReady()
+ * terminalizes a placement/spawn/cloud/dependency failure to FAILED with
+ * evidence rather than leaving it PENDING, so a teammate that failed this wave
+ * appears in neither `launched` nor `still_pending` — it must be diffed against
+ * the pre-wave roster and reported explicitly, or the wave reads as a success.
+ * A wave that only produced failures sets a non-zero exit code.
+ */
+export async function runOneWave(mgr, team, json) {
+    const preWavePending = new Set((await mgr.listByTask(team)).filter((a) => a.status === 'pending').map((a) => a.agentId));
     const launched = await mgr.startReady(team);
     const all = await mgr.listByTask(team);
     const stillPending = all.filter((a) => a.status === 'pending');
+    const failed = all.filter((a) => a.status === 'failed' && preWavePending.has(a.agentId));
+    if (failed.length > 0 && launched.length === 0)
+        process.exitCode = 1;
     if (json) {
         console.log(JSON.stringify({
             team,
             launched: launched.map((a) => ({ agent_id: a.agentId, name: a.name, after: a.after })),
             still_pending: stillPending.map((a) => ({ agent_id: a.agentId, name: a.name, after: a.after })),
+            failed: failed.map((a) => ({ agent_id: a.agentId, name: a.name, after: a.after, failure: a.failure })),
         }, null, 2));
         return;
     }
-    if (launched.length === 0 && stillPending.length === 0) {
+    if (launched.length === 0 && stillPending.length === 0 && failed.length === 0) {
         console.log(chalk.gray(`No pending teammates in team ${team}.`));
         return;
     }
@@ -471,6 +487,16 @@ async function runOneWave(mgr, team, json) {
             console.log(`  ${chalk.cyan(h)}  ${who}`);
         }
     }
+    if (failed.length > 0) {
+        if (launched.length > 0)
+            console.log();
+        console.log(chalk.red(`Failed this wave (${failed.length}):`));
+        for (const a of failed) {
+            const h = a.name || shortId(a.agentId);
+            const why = a.failure ? `${a.failure.code}: ${a.failure.message}` : 'no failure evidence recorded';
+            console.log(`  ${chalk.red(h)}  ${why}`);
+        }
+    }
     if (stillPending.length > 0) {
         console.log();
         console.log(chalk.gray(`Still pending (${stillPending.length}):`));
@@ -710,6 +736,9 @@ function printAgentDetail(a, session) {
     if (a.host) {
         console.log(`    ${chalk.gray('host    ')} ${chalk.cyan(a.host)}`);
     }
+    if (a.failure) {
+        console.log(`    ${chalk.red('failure ')} ${a.failure.code}: ${a.failure.message}`);
+    }
     // If the agent's internal session id differs from ours (non-Claude), show
     // it as a hint for `agents sessions <id>`.
     if (a.remote_session_id && a.remote_session_id !== a.agent_id) {
@@ -798,6 +827,9 @@ function printAgentSummary(s) {
     const tools = chalk.gray(` · ${s.tool_count} tools`);
     const hostBadge = s.host ? chalk.gray(' · on ') + chalk.cyan(s.host) : '';
     console.log(`  ${chalk.cyan(handle.padEnd(14))} ${ident.padEnd(11)} ${label}${duration}${tools}${hostBadge}${errBadge}`);
+    if (s.failure) {
+        console.log(`    ${chalk.red('failure ')} ${s.failure.code}: ${s.failure.message}`);
+    }
     // Files: counts + basenames. Read is count only.
     const fileLines = [];
     const renderCat = (label, cat) => {
@@ -1856,36 +1888,8 @@ export function registerTeamsCommands(program) {
                 return { cloudSessionId: cloudTask.id };
             });
         }
-        let cloudSessionId = null;
+        const cloudSessionId = null;
         const isStaged = after.length > 0;
-        if (cloudProviderId && !isStaged) {
-            // Ready to run now: dispatch to the cloud provider before registering
-            // the teammate so we have the remote session id up front.
-            //
-            // resolveProvider() and shareRuntimeEnv() are INSIDE the try on purpose:
-            // both read config (the cloud registry; `agents.yaml`'s share block) and
-            // both throw on a malformed one, and by this point the worktree already
-            // exists — leaving them outside stranded the branch with no catch at all.
-            try {
-                const prov = resolveProvider(cloudProviderId);
-                const dispatchOpts = {
-                    prompt: effectiveTask,
-                    agent,
-                    repo: opts.repo,
-                    branch: opts.branch,
-                    model: opts.model,
-                    env: shareRuntimeEnv(),
-                };
-                const cloudTask = await prov.dispatch(dispatchOpts);
-                cloudSessionId = cloudTask.id;
-            }
-            catch (err) {
-                // Same orphan class as a failed spawn: this add already created its
-                // worktree, so a dispatch failure must not strand the branch either.
-                await tearDownCreatedWorktree();
-                dieFriction('teams', 'cloud-dispatch-failed', `Cloud dispatch failed: ${err.message}`);
-            }
-        }
         try {
             const result = await handleSpawn(mgr, team, agent, effectiveTask, cwd, opts.mode, opts.effort, null, cwd, version, opts.name ?? null, after, opts.model ?? null, envOverrides ?? null, taskType, cloudProviderId, cloudSessionId, opts.repo ?? null, opts.branch ?? null, worktreeName, worktreePath, profileName, hostName, hostTarget, hostRepoPath, teamMeta?.project ?? null);
             emit('teams.add', { module: 'teams', team, agent, name: result.name, agent_id: result.agent_id, status: result.status });
@@ -2057,7 +2061,7 @@ export function registerTeamsCommands(program) {
     });
     // start — fire any staged teammates whose --after deps have all completed
     addHostOption(teams.command('start [team]'))
-        .description('Launch any pending teammates whose --after dependencies are satisfied. Use --watch to keep draining the DAG as teammates finish and as new tasks are added mid-flight.')
+        .description('Launch ready teammates independently. Failed launch/placement and blocked --after dependencies persist in status; --watch keeps draining viable DAG branches.')
         .option('--json', 'Output machine-readable JSON')
         .option('--watch', 'Keep running: poll every --interval seconds, fire new waves, exit when the DAG drains.')
         .option('--interval <seconds>', 'Seconds between waves in --watch mode (default 8)', '8')
@@ -2094,33 +2098,6 @@ export function registerTeamsCommands(program) {
             await warnUnsignedTeammates(mgr, team);
             await warnThrottledTeammates(mgr, team);
         }
-        // Health-/harness-aware pre-flight (RUSH-2002): if the team declares a
-        // device pool and no device in it can run a pending teammate's agent, fail
-        // loud here rather than launching a wave that strands teammates pending.
-        // --force downgrades it to a warning so the user can still try.
-        const placementError = await mgr.preflightPlacement(team);
-        if (placementError) {
-            if (isJsonMode(opts)) {
-                console.log(JSON.stringify({
-                    team,
-                    error: 'no-viable-device',
-                    message: placementError.message,
-                    excluded: placementError.excluded,
-                }));
-                if (!opts.force) {
-                    process.exitCode = 1;
-                    return;
-                }
-            }
-            else if (opts.force) {
-                console.error(chalk.yellow(`⚠ ${placementError.message}\n  Continuing anyway (--force).`));
-            }
-            else {
-                console.error(chalk.red(placementError.message));
-                process.exitCode = 1;
-                return;
-            }
-        }
         emit('teams.start', { module: 'teams', team, watch: Boolean(opts.watch) });
         if (!opts.watch) {
             await runOneWave(mgr, team, Boolean(opts.json));

package/dist/commands/traces.js

@@ -1,7 +1,6 @@
 import chalk from 'chalk';
 import { setHelpSections } from '../lib/help.js';
-import { syncTraces } from '../lib/traces/sync.js';
-import { readSyncLedger } from '../lib/traces/sync.js';
+import { readSyncLedger, syncTraces } from '../lib/traces/sync.js';
 import { managedTracesBaseUrl, resolveTracesBackend } from '../lib/traces/backend.js';
 import { showUrl } from '../lib/open-url.js';
 import { DEFAULT_CF_BUNDLE, readCloudflareCreds } from '../lib/share/config.js';
@@ -32,6 +31,10 @@ const SYNC_NOTES = `
   An incremental gate (traces-sync.json ledger) means re-runs only upload
   sessions whose file_mtime_ms changed since the last sync.
 
+  On a real (non-dry-run) sync with the managed Phoenix backend, also
+  fire-and-forget registers this session with Prix (api.prix.dev) so the
+  console can serve live trajectories — a link failure never blocks sync.
+
   Sign in first with: agents auth login
 `.trimStart();
 const STATUS_EXAMPLES = `
@@ -89,7 +92,18 @@ async function handleSync(opts) {
         parts.push(chalk.dim(`${result.skipped} skipped`));
     }
     if (result.errors > 0) {
-        parts.push(chalk.yellow(`${result.errors} errors`));
+        // Distinguish expected history (transcripts cleaned off disk) from genuine
+        // failures that will be retried, so the operator knows which need attention.
+        const detail = [];
+        if (result.transcriptUnavailable > 0) {
+            detail.push(`${result.transcriptUnavailable} transcripts no longer on disk`);
+        }
+        const retryable = result.parseFailed + result.uploadFailed;
+        if (retryable > 0) {
+            detail.push(`${retryable} parse/upload failures — will retry`);
+        }
+        parts.push(chalk.yellow(`${result.errors} errors`) +
+            (detail.length ? chalk.dim(` (${detail.join(' · ')})`) : ''));
     }
     if (parts.length === 0) {
         parts.push(chalk.dim('nothing new'));
@@ -104,7 +118,25 @@ async function handleStatus() {
     }
     const when = new Date(ledger.lastSyncMtime).toLocaleString();
     console.log(`Last sync: ${chalk.bold(when)}`);
-    console.log(chalk.dim('Run `agents traces sync` to push new sessions.'));
+    const failures = ledger.failures ?? [];
+    if (failures.length > 0) {
+        const byKind = new Map();
+        for (const f of failures) {
+            const list = byKind.get(f.kind) ?? [];
+            list.push(f);
+            byKind.set(f.kind, list);
+        }
+        console.log(chalk.yellow(`\n${failures.length} unresolved failure${failures.length === 1 ? '' : 's'}:`));
+        for (const [kind, list] of byKind) {
+            const retry = kind === 'transcript-unavailable' ? chalk.dim(' (not retried)') : chalk.dim(' (retried each sync)');
+            console.log(`  ${chalk.bold(list.length)} ${kind}${retry}`);
+            const example = list[0];
+            if (example?.detail) {
+                console.log(chalk.dim(`    e.g. ${example.id.slice(0, 8)} · ${example.detail}`));
+            }
+        }
+    }
+    console.log(chalk.dim('\nRun `agents traces sync` to push new sessions.'));
 }
 async function handleOpen() {
     // M2 console — for now open the base URL which will route to the console once deployed.

package/dist/lib/account-provider-registry.d.ts

@@ -15,4 +15,13 @@ export interface AccountProviderAdapter {
     validate(kind: AccountAuthKind, value: string): void;
 }
 export declare function getAccountProvider(provider: string): AccountProviderAdapter;
+/**
+ * Whether a provider account of kind `auth` can authenticate `agent` — i.e. the
+ * adapter has an `envFor(agent, auth)` mapping. Used both by the account UI and by
+ * the run-candidate pool so a Cursor key never enters Claude's pool and a harness
+ * with no provider adapter at all (e.g. kimi, native-login only) yields nothing.
+ * A "cannot authenticate" is a clean false; any other error (unknown provider,
+ * unsupported kind) is a real bug and re-throws rather than being swallowed.
+ */
+export declare function providerAuthenticatesHarness(provider: string, auth: AccountAuthKind, agent: AgentId): boolean;
 export declare function listAccountProviders(): string[];

package/dist/lib/account-provider-registry.js

@@ -54,6 +54,26 @@ export function getAccountProvider(provider) {
         throw new Error(`Unknown account provider '${provider}'. Supported: ${listAccountProviders().join(', ')}.`);
     return adapter;
 }
+/**
+ * Whether a provider account of kind `auth` can authenticate `agent` — i.e. the
+ * adapter has an `envFor(agent, auth)` mapping. Used both by the account UI and by
+ * the run-candidate pool so a Cursor key never enters Claude's pool and a harness
+ * with no provider adapter at all (e.g. kimi, native-login only) yields nothing.
+ * A "cannot authenticate" is a clean false; any other error (unknown provider,
+ * unsupported kind) is a real bug and re-throws rather than being swallowed.
+ */
+export function providerAuthenticatesHarness(provider, auth, agent) {
+    try {
+        getAccountProvider(provider).envFor(agent, auth);
+        return true;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('cannot authenticate'))
+            return false;
+        throw err;
+    }
+}
 export function listAccountProviders() {
     return [...ADAPTERS.keys()].sort();
 }

package/dist/lib/accounting/account-pool-collect.d.ts

@@ -0,0 +1,34 @@
+import type { AgentId } from '../types.js';
+import { type RotateCandidate } from './rotate.js';
+import { type RegistryAccountRecord } from './account-pool.js';
+/** Inputs to {@link foldRegistryCandidates} — injectable so the fold is unit-tested. */
+export interface RunCandidateInputs {
+    native: RotateCandidate[];
+    records: RegistryAccountRecord[];
+    runVersion: string | undefined;
+}
+/**
+ * PURE: fold provider-account candidates into the native version-home list.
+ *
+ * A registry account runs in `runVersion` (the agent's default installed home);
+ * the token/key overrides that home's own login at exec, so any home works. It
+ * carries `providerAccount` so the run path routes it through the existing
+ * `--account` injection (`resolveSpawnAccount` → `accountEnv`). An account already
+ * covered by a native login is skipped by accountKey. With no installed version
+ * there is nowhere to execute a registry account, so the native list passes
+ * through unchanged.
+ */
+export declare function foldRegistryCandidates(agent: AgentId, inputs: RunCandidateInputs): RotateCandidate[];
+/**
+ * Candidate list for the `agents run` strategy pick, account-centric: the usual
+ * native version-home candidates PLUS one candidate per provider account whose
+ * provider can authenticate `agent` and whose credential is present locally
+ * (RUSH-3182). This is what makes a setup-token / API-key account balance-eligible.
+ *
+ * Passed as the `collect` argument to {@link resolveRunVersion} on the RUN path
+ * ONLY — the other consumers of {@link collectRunCandidates} (watchdog, session
+ * recovery, teams placement) keep calling it directly and are unaffected. The
+ * existing {@link pickBalancedCandidate} selects over the combined list, so the
+ * revoked / rate-limit / exhausted logic is unchanged.
+ */
+export declare function collectRunCandidatesForRun(agent: AgentId): Promise<RotateCandidate[]>;

package/dist/lib/accounting/account-pool-collect.js

@@ -0,0 +1,71 @@
+import { readAccountRegistry } from '../account-registry.js';
+import { hasKeychainToken } from '../secrets/index.js';
+import { getGlobalDefault, listInstalledVersions } from '../installations/versions.js';
+import { collectRunCandidates } from './rotate.js';
+import { registryPoolCandidates } from './account-pool.js';
+/**
+ * Provider accounts whose credential is present on THIS device, as capability
+ * records. A registry entry with no local secret is skipped: including it would
+ * let `--strategy balanced` pick an account that then fails at spawn and exits the
+ * whole run (`resolveSpawnAccount` throws on a missing credential) instead of
+ * rotating to a healthy one.
+ */
+function localRegistryRecords() {
+    return Object.values(readAccountRegistry().accounts)
+        .filter((a) => hasKeychainToken(a.secretRef))
+        .map((a) => ({ name: a.name, provider: a.provider, auth: a.auth }));
+}
+/**
+ * PURE: fold provider-account candidates into the native version-home list.
+ *
+ * A registry account runs in `runVersion` (the agent's default installed home);
+ * the token/key overrides that home's own login at exec, so any home works. It
+ * carries `providerAccount` so the run path routes it through the existing
+ * `--account` injection (`resolveSpawnAccount` → `accountEnv`). An account already
+ * covered by a native login is skipped by accountKey. With no installed version
+ * there is nowhere to execute a registry account, so the native list passes
+ * through unchanged.
+ */
+export function foldRegistryCandidates(agent, inputs) {
+    const { native, records, runVersion } = inputs;
+    if (!runVersion)
+        return native;
+    const seen = new Set(native.filter((c) => c.accountKey).map((c) => c.accountKey));
+    const extra = registryPoolCandidates(records, agent)
+        .filter((r) => !seen.has(r.accountKey))
+        .map((r) => ({
+        agent,
+        version: runVersion,
+        accountKey: r.accountKey,
+        accountLabel: r.name,
+        email: null,
+        usageKey: null,
+        usageStatus: null,
+        usageSnapshot: null,
+        usageError: null,
+        usageMinutesToLimit: null,
+        plan: null,
+        signedIn: true,
+        authVerdict: null,
+        lastActive: null,
+        providerAccount: r.name,
+    }));
+    return [...native, ...extra];
+}
+/**
+ * Candidate list for the `agents run` strategy pick, account-centric: the usual
+ * native version-home candidates PLUS one candidate per provider account whose
+ * provider can authenticate `agent` and whose credential is present locally
+ * (RUSH-3182). This is what makes a setup-token / API-key account balance-eligible.
+ *
+ * Passed as the `collect` argument to {@link resolveRunVersion} on the RUN path
+ * ONLY — the other consumers of {@link collectRunCandidates} (watchdog, session
+ * recovery, teams placement) keep calling it directly and are unaffected. The
+ * existing {@link pickBalancedCandidate} selects over the combined list, so the
+ * revoked / rate-limit / exhausted logic is unchanged.
+ */
+export async function collectRunCandidatesForRun(agent) {
+    const native = await collectRunCandidates(agent);
+    const runVersion = getGlobalDefault(agent) ?? listInstalledVersions(agent)[0];
+    return foldRegistryCandidates(agent, { native, records: localRegistryRecords(), runVersion });
+}

package/dist/lib/accounting/account-pool.d.ts

@@ -0,0 +1,46 @@
+import type { AgentId } from '../types.js';
+import type { AccountAuthKind } from '../account-provider-registry.js';
+/**
+ * The provider-account side of the run-candidate pool (RUSH-3182).
+ *
+ * `--strategy balanced` used to enumerate only version-home native logins, so a
+ * setup-token / API-key account added via `agents accounts add` never balanced.
+ * This module turns the account registry into the extra candidates the run path
+ * folds in — see `collectRunCandidatesForRun` in `account-pool-collect.ts`.
+ *
+ * Pure + dependency-light so the harness-capability filter is unit-tested in
+ * isolation with fixtures.
+ */
+/** A provider account record as stored in the registry (identity captured separately). */
+export interface RegistryAccountRecord {
+    name: string;
+    provider: string;
+    auth: AccountAuthKind;
+}
+/** A registry account eligible to run one harness, ready to map to a candidate. */
+export interface RegistryAccountInput {
+    /** Agent-scoped key so `(claude, X)` and `(codex, X)` stay distinct. */
+    accountKey: string;
+    email: string | null;
+    name: string;
+    provider: string;
+    auth: AccountAuthKind;
+}
+/**
+ * Which provider accounts can authenticate `agent`. An account is a candidate for
+ * harness H only when its provider adapter has an `envFor(H, kind)` mapping
+ * (`providerAuthenticatesHarness`, the same check the account UI uses) — so a
+ * Cursor key never enters Claude's pool and a Claude setup-token never enters
+ * Codex's. This is registry-driven, no per-harness `else if`: a harness gets a
+ * provider-account pool exactly when the adapter table maps a provider to it —
+ * today claude, codex, grok, cursor, opencode (plus gemini/antigravity). A harness
+ * with only a native OAuth login and no provider adapter — kimi — returns `[]`
+ * here and keeps balancing its native logins only.
+ *
+ * `accountKey` is synthetic here (`${agent}:name=${name}`) — a stable per-account
+ * key so balancing can include it immediately; the real agent-scoped identity
+ * (email / org uuid) is backfilled by identity capture and replaces it. `email`
+ * is null until then, which routes the account as usage-unverified but still a
+ * candidate, never excluded.
+ */
+export declare function registryPoolCandidates(records: RegistryAccountRecord[], agent: AgentId): RegistryAccountInput[];