@phnx-labs/agents-cli 1.22.104 → 1.22.106

package/dist/commands/sessions-resume.js

@@ -17,7 +17,7 @@ import { discoverSessions } from '../lib/session/discover.js';
 import { filterTeamSessions } from '../lib/session/team-filter.js';
 import { multiItemPicker, itemPicker } from '../lib/picker.js';
 import { buildPreview } from './sessions-picker.js';
-import { formatPickerLabel, pickerColumnsFor, buildSessionRecoveryCommand, resumeSessionInPlace, parseAgentFilter, } from './sessions.js';
+import { formatPickerLabel, pickerColumnsFor, resolveSessionMetadataValue, parseAgentFilter, } from './sessions.js';
 import { sessionMatchesQuery } from './sessions-browser.js';
 import { openSurfaces, availableBackends, detectCurrentBackend, currentContext, } from '../lib/terminal/index.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
@@ -27,7 +27,7 @@ import { spawn } from 'node:child_process';
 import { looksLikeSessionId } from '../lib/session/discover.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { sessionOriginDevice, sessionRecoveryDestinationMatches } from '../lib/session/recovery.js';
-import { runStrictResume, wantsStrictResume } from './resume.js';
+import { buildResumeRemoteArgs, runStrictResume, wantsStrictResume } from './resume.js';
 import { attachLocalLiveSelector } from '../lib/session/local-tmux-attach.js';
 /** Opening more than this many live sessions at once asks for confirmation first. */
 export const CONFIRM_THRESHOLD = 5;
@@ -35,9 +35,11 @@ export function registerSessionsResumeCommand(sessionsCmd) {
     const cmd = sessionsCmd
         .command('resume')
         .argument('[query]', 'Session id/tmux alias/label for strict resume, or text that filters the picker')
-        .argument('[prompt]', 'Optional follow-up prompt (strict resume with original harness/version/device)')
+        .argument('[prompt]', 'Optional follow-up prompt (same conversation, account and origin device)')
         .description('Resume a session by id (strict), or multi-select history into terminal tabs/splits.')
         .option('-a, --agent <agent>', 'Filter by agent type and version (e.g., claude, codex@0.116.0)')
+        .option('--account <account>', 'Filter by the account that owns the conversation')
+        .option('--model <model>', 'Override the resumed session model')
         .option('--all', 'Include sessions from every directory (not just current project)')
         .option('--teams', 'Include team-spawned sessions (hidden by default)')
         .option('--since <time>', 'Only sessions newer than this (e.g., 2h, 7d, 4w, or ISO date)')
@@ -84,7 +86,7 @@ export function registerSessionsResumeCommand(sessionsCmd) {
       agents sessions resume --device zion --tmux
     `,
         notes: `
-      - Strict path (id/tmux alias/label + optional prompt/--mode/--headless/--here): restores original harness, version, device, account, cwd, and mode. Searches the fleet; a local full-id hit resumes with zero SSH. Replaces the former top-level agents sessions resume.
+      - Strict path (id/tmux alias/label + optional prompt/--mode/--headless/--here): restores the harness, device, account, cwd, model, and mode using the installed binary. Searches the fleet; a local full-id hit resumes with zero SSH. Replaces the former top-level agents sessions resume.
       - Attach a live pane without forking: agents sessions focus <id>.
       - This is the ONE verb for getting back in. It detects the state: a live tmux pane is attached, a headless session comes to the foreground, an ended one recovers on its owning device.
       - A UUID/prefix or ag-<agent>-<suffix> alias bypasses the picker. A live alias attaches by name even when the session index cannot attribute it.
@@ -95,7 +97,8 @@ export function registerSessionsResumeCommand(sessionsCmd) {
       - Backend: auto-detected from the terminal you're in (iTerm / Ghostty / tmux); override with --iterm/--ghostty/--tmux/--vscodium.
       - --vscodium opens each session as an agent terminal tab in VSCodium via the swarm-ext extension (works with --device too).
       - --device <alias> opens the terminal surface on that device only when it is the selected sessions' origin; recovery never migrates a session to another device.
-      - Recovery runs on the session's origin device: exact healthy origin uses native resume; otherwise a healthy version of the same harness receives /continue <id>.
+      - Recovery uses the installed harness and the conversation's account on its origin device. Context replay requires an explicit choice.
+      - agents run claude --resume opens this same picker; claude#work filters it with --account work.
     `,
     });
     cmd.action(async (query, prompt, options) => {
@@ -103,19 +106,28 @@ export function registerSessionsResumeCommand(sessionsCmd) {
     });
 }
 export async function sessionsResumeAction(query, prompt, options) {
+    if (options.attachOnly && (prompt !== undefined || options.agent || options.account || options.model || options.mode || options.interactive || options.headless || options.cwd || options.here)) {
+        throw new Error('--attach-only cannot be combined with --agent, a follow-up prompt, or options that change the running session. Pass the session ID without filters.');
+    }
     const strictOpts = {
+        agent: parseAgentFilter(options.agent).agent,
+        account: options.account,
+        model: options.model,
         mode: options.mode,
         interactive: options.interactive,
         headless: options.headless,
         cwd: options.cwd,
         quiet: options.quiet,
         here: options.here,
+        local: options.local,
     };
+    const explicitSurface = !!(options.iterm || options.ghostty || options.tmux || options.vscodium || options.terminalApp || options.device);
+    const direct = !!query && (isDirectResumeSelector(query) || wantsStrictResume(prompt, strictOpts));
     // Direct id/alias (or label with prompt/strict flags) → strict resume
     // (former top-level `agents sessions resume`). `--attach-only` / `--local`
     // must go through sessions focus so they cannot silently fork a copy
     // (AGI EXT still shells `sessions resume <id> --local`).
-    if (query && (isDirectResumeSelector(query) || wantsStrictResume(prompt, strictOpts))) {
+    if (query && direct && !explicitSurface) {
         const hosts = options.device ? [options.device] : [];
         // PHNX-3292: a live LOCAL tmux pane (the exact alias, or a unique 8-hex
         // short id) attaches immediately, before any fleet SSH — the product rule
@@ -124,62 +136,86 @@ export async function sessionsResumeAction(query, prompt, options) {
         // `--attach-only`: a prompt/mode/headless/cwd override still means the
         // caller wants strict resume semantics (a scripted continue), so that
         // case is excluded via wantsStrictResume.
-        if (!wantsStrictResume(prompt, strictOpts) && await attachLocalLiveSelector(query.trim(), hosts)) {
+        if (!options.agent && !options.account && !options.model && !wantsStrictResume(prompt, strictOpts) && await attachLocalLiveSelector(query.trim(), hosts)) {
             return;
         }
-        if (resumeUsesLifecycleDispatch(query, prompt, options)) {
+        if (!options.agent && !options.account && !options.model && resumeUsesLifecycleDispatch(query, prompt, options)) {
             await dispatchSessionLifecycleInPlace(query.trim(), hosts, !!options.attachOnly, !!options.local);
             return;
         }
         await runStrictResume(query.trim(), prompt, strictOpts);
         return;
     }
-    if (!isInteractiveTerminal()) {
+    if (!direct && !isInteractiveTerminal()) {
         console.error(chalk.red('sessions resume needs an interactive terminal (or pass a session id for strict resume).'));
         process.exitCode = 1;
         return;
     }
-    const { agent, version } = parseAgentFilter(options.agent);
-    const limit = parseInt(options.limit || '200', 10);
-    const since = options.since ?? (options.all ? undefined : '30d');
-    let sessions = await discoverSessions({
-        agent,
-        version,
-        all: options.all,
-        cwd: process.cwd(),
-        since,
-        sortBy: 'timestamp',
-        limit,
-        excludeTeamOrigin: !options.teams,
-    });
-    const { visible } = filterTeamSessions(sessions, !!options.teams);
-    sessions = visible;
-    if (sessions.length === 0) {
-        console.log(chalk.gray('No sessions found. Try --all or a different --since window.'));
-        return;
-    }
-    // 1. Multi-select the sessions. gutter: 6 = the multi-select cursor + checkbox
-    // ('> [x] ') that multiItemPicker prepends, so rows size to fit without wrapping.
-    const cols = { ...pickerColumnsFor(sessions), gutter: 6 };
     let chosen;
-    try {
-        chosen = await multiItemPicker({
-            message: 'Select sessions to resume:',
-            items: sessions,
-            filter: (q) => (q.trim() ? sessions.filter((s) => sessionMatchesQuery(s, q)) : sessions),
-            labelFor: (s, q) => formatPickerLabel(s, q, cols),
-            keyFor: (s) => s.id,
-            buildPreview,
-            pageSize: 15,
-            initialSearch: query,
-            emptyMessage: 'No sessions match.',
-            enterHint: 'resume',
-        });
+    if (query && direct) {
+        const outcome = await resolveSessionMetadataValue(query, { local: options.local, hosts: options.device ? [options.device] : undefined, agent: parseAgentFilter(options.agent).agent });
+        if (outcome.kind !== 'resolved') {
+            console.error(chalk.red(`No session matching "${query}" (${outcome.kind}).`));
+            process.exitCode = 1;
+            return;
+        }
+        chosen = [outcome.session];
     }
-    catch (err) {
-        if (isPromptCancelled(err))
+    else {
+        const { agent, version } = parseAgentFilter(options.agent);
+        const limit = parseInt(options.limit || '200', 10);
+        const since = options.since ?? (options.all ? undefined : '30d');
+        let sessions = await discoverSessions({
+            agent,
+            version,
+            all: options.all,
+            cwd: process.cwd(),
+            since,
+            sortBy: 'timestamp',
+            limit: options.account ? undefined : limit,
+            unbounded: !!options.account,
+            excludeTeamOrigin: !options.teams,
+        });
+        const { visible } = filterTeamSessions(sessions, !!options.teams);
+        sessions = visible;
+        if (options.account) {
+            const { findUnifiedAccount } = await import('../lib/account-registry.js');
+            const { readMeta } = await import('../lib/state.js');
+            const { sessionMatchesAccount } = await import('../lib/session/recovery.js');
+            const account = findUnifiedAccount(options.account, readMeta(), undefined, agent);
+            if (!account)
+                throw new Error(`Unknown account '${options.account}'.`);
+            const context = account.kind === 'native'
+                ? await (await import('../lib/exec-account-home.js')).resolveNativeSpawnHome(account.agent, account, readMeta(), { readOnly: true }).catch(() => null)
+                : null;
+            sessions = sessions.filter(session => sessionMatchesAccount(session, account, context?.execHome)).slice(0, limit);
+        }
+        if (sessions.length === 0) {
+            console.log(chalk.gray('No sessions found. Try --all or a different --since window.'));
             return;
-        throw err;
+        }
+        // 1. Multi-select the sessions. gutter: 6 = the multi-select cursor + checkbox
+        // ('> [x] ') that multiItemPicker prepends, so rows size to fit without wrapping.
+        const cols = { ...pickerColumnsFor(sessions), gutter: 6 };
+        try {
+            chosen = await multiItemPicker({
+                message: 'Select sessions to resume:',
+                items: sessions,
+                filter: (q) => (q.trim() ? sessions.filter((s) => sessionMatchesQuery(s, q)) : sessions),
+                labelFor: (s, q) => formatPickerLabel(s, q, cols),
+                keyFor: (s) => s.id,
+                buildPreview,
+                pageSize: 15,
+                initialSearch: query,
+                emptyMessage: 'No sessions match.',
+                enterHint: 'resume',
+            });
+        }
+        catch (err) {
+            if (isPromptCancelled(err))
+                return;
+            throw err;
+        }
     }
     if (!chosen || chosen.length === 0)
         return;
@@ -198,7 +234,7 @@ export async function sessionsResumeAction(query, prompt, options) {
     // 2. Route every selection through the owning device's recovery resolver.
     const items = [];
     for (const s of chosen) {
-        const command = buildSessionRecoveryCommand(s, !!options.device);
+        const command = ['agents', ...buildSelectedResumeArgs(s.id, prompt, options)];
         const cwd = s.cwd && fs.existsSync(s.cwd) ? s.cwd : process.cwd();
         items.push({ session: s, cwd, command });
     }
@@ -222,7 +258,7 @@ export async function sessionsResumeAction(query, prompt, options) {
             console.log(chalk.gray(`Resuming ${items.length} sessions one at a time (no tab-capable terminal detected).`));
         }
         for (const it of items)
-            await resumeSessionInPlace(it.session);
+            await spawnCliInPlace(buildSelectedResumeArgs(it.session.id, prompt, options));
         return;
     }
     // 5b. Fan out through the engine. Full-width tabs are the default for batch
@@ -259,6 +295,52 @@ export async function sessionsResumeAction(query, prompt, options) {
     });
     console.log(chalk.gray(`\nOpened ${opened}/${items.length} in ${where}.`));
 }
+/** Preserve run options and lifecycle intent when the picker opens its selected rows. */
+export function buildSelectedResumeArgs(id, prompt, options) {
+    if (options.runArgs) {
+        const args = [...options.runArgs];
+        const boundary = args.indexOf('--');
+        const index = args.findIndex((arg, i) => (boundary < 0 || i < boundary) && (arg === '--resume' || arg === '--resume='));
+        if (index < 0)
+            throw new Error('The run command did not contain a bare --resume selector.');
+        args.splice(index, 1, '--resume', id);
+        // The outer surface already placed this terminal on the selected device.
+        if (options.device) {
+            let remoteCwd;
+            for (let i = 0; i < args.length && args[i] !== '--'; i++) {
+                if (args[i] === '--remote-cwd') {
+                    remoteCwd = args[i + 1];
+                    args.splice(i--, 2);
+                }
+                else if (args[i].startsWith('--remote-cwd=')) {
+                    remoteCwd = args[i].slice('--remote-cwd='.length);
+                    args.splice(i--, 1);
+                }
+                else if (['-D', '--device', '--host', '--where', '--on', '--computer'].includes(args[i])) {
+                    args.splice(i, 2);
+                    i--;
+                }
+                else if ((/^(?:--(?:device|host|where|on|computer)=|-D.)/.test(args[i]))) {
+                    args.splice(i, 1);
+                    i--;
+                }
+            }
+            if (remoteCwd !== undefined) {
+                const end = args.indexOf('--');
+                args.splice(end < 0 ? args.length : end, 0, '--cwd', remoteCwd);
+            }
+        }
+        return args;
+    }
+    const args = buildResumeRemoteArgs(id, prompt, options);
+    if (options.here)
+        args.push('--here');
+    if (options.local)
+        args.push('--local');
+    if (options.attachOnly)
+        args.push('--attach-only');
+    return args;
+}
 /** IDs and tmux aliases are actions, not picker search text. Human phrases keep
  * the existing pre-filtered picker, while an explicit identity resumes directly. */
 export function isDirectResumeSelector(query) {
@@ -285,6 +367,7 @@ export function resumeUsesLifecycleDispatch(query, prompt, options) {
         interactive: options.interactive,
         headless: options.headless,
         here: options.here,
+        local: options.local,
     });
 }
 export async function dispatchSessionLifecycleInPlace(selector, hosts = [], attachOnly = false, local = false) {

package/dist/commands/sessions.js

@@ -3523,6 +3523,8 @@ function renderArchivedSession(session, mode, options = {}) {
     }
 }
 async function renderSession(session, mode, filters, options = {}) {
+    const { hydrateSessionTranscript, findLocalSessionTranscripts } = await import('../lib/session/discover.js');
+    session = await hydrateSessionTranscript(session);
     // OpenCode stores sessions in SQLite; filePath is "db_path#session_id"
     const realPath = session.filePath.split('#')[0];
     if (!fs.existsSync(realPath)) {
@@ -3535,7 +3537,8 @@ async function renderSession(session, mode, filters, options = {}) {
             renderArchivedSession(session, mode, options);
             return;
         }
-        console.log(chalk.yellow('Session transcript not available (file no longer exists).'));
+        process.exitCode = 1;
+        console.log(chalk.yellow('Session transcript is unavailable after checking its recorded home and the session index.'));
         console.log(chalk.gray(`Path: ${session.filePath}`));
         if (session.version)
             console.log(chalk.gray(`Version: ${sessionDisplayAgent(session)} ${session.version}`));
@@ -4917,12 +4920,36 @@ export async function computeLocalMetadataMatches(selector, scope, deps = {}) {
     const includeLocal = !scope.hosts?.length || shouldIncludeLocal(scope.hosts, localMachine);
     if (!includeLocal)
         return [];
-    const indexed = resolveIndexedMetadataRows(indexedRowsForSelector(selector, scope), selector, scope);
-    if (indexed.length > 0 || !looksLikeSessionId(selector)) {
+    let indexed = resolveIndexedMetadataRows(indexedRowsForSelector(selector, scope), selector, scope);
+    if (!looksLikeSessionId(selector)) {
         return indexed.map(session => ({ ...session, machine: session.machine || localMachine }));
     }
-    const live = await liveMetadataMatches(selector, scope, localMachine, deps);
-    return live.map(session => ({ ...session, machine: session.machine || localMachine }));
+    const { hydrateSessionTranscript, findLocalSessionTranscripts } = await import('../lib/session/discover.js');
+    if (indexed.length === 0) {
+        const disk = await findLocalSessionTranscripts(selector, scope.agent);
+        const live = disk.length ? [] : await liveMetadataMatches(selector, scope, localMachine, deps);
+        if (disk.length > 0)
+            indexed = resolveIndexedMetadataRows(disk, selector, scope);
+        else if (live.length > 0)
+            indexed = live;
+        else if (scope.agent !== 'claude' && scope.agent !== 'codex') {
+            const { scanSessionsIncremental, waitForScanToSettle } = await import('../lib/session/discover.js');
+            const { claimed } = await scanSessionsIncremental({ agent: scope.agent });
+            if (!claimed) {
+                if (!await waitForScanToSettle())
+                    throw new Error('Session lookup is incomplete: another index scan is still running. Retry when it finishes.');
+                const retry = await scanSessionsIncremental({ agent: scope.agent });
+                if (!retry.claimed)
+                    throw new Error('Session lookup is incomplete: the session index is busy. Retry when the scan finishes.');
+            }
+            indexed = resolveIndexedMetadataRows(indexedRowsForSelector(selector, scope), selector, scope);
+        }
+    }
+    const hydrated = [];
+    for (const session of indexed) {
+        hydrated.push(await hydrateSessionTranscript({ ...session, machine: session.machine || localMachine }));
+    }
+    return hydrated;
 }
 /**
  * Resolve an id-shaped selector against the local live-session registry

package/dist/commands/setup-computer.js

@@ -43,8 +43,8 @@ export async function runComputerWizard() {
     catch (error) {
         if (!(error instanceof ComputerClientError) || error.code !== 'COMPUTER_BIN_MISSING')
             throw error;
-        console.log('Installing @phnx-labs/computer-cli@0.1.1…');
-        const installed = spawnSync('npm', ['install', '-g', '@phnx-labs/computer-cli@0.1.1'], { stdio: 'inherit' });
+        console.log('Installing @phnx-labs/computer-cli@0.1.2…');
+        const installed = spawnSync('npm', ['install', '-g', '@phnx-labs/computer-cli@0.1.2'], { stdio: 'inherit' });
         if (installed.status !== 0)
             return false;
         try {

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

@@ -0,0 +1,54 @@
+import type { AgentId, Meta } from '../types.js';
+import { type RotateCandidate } from './rotate.js';
+export type ResolvedLaunchAccountKind = 'native' | 'provider' | 'legacy-native';
+/** Safe account identity that may be passed between launch consumers. */
+export interface ResolvedLaunchAccount {
+    kind: ResolvedLaunchAccountKind;
+    /** Stable registry id, or the durable identity key for an unmigrated login. */
+    id: string;
+    /** User-facing account name, falling back to the durable identity label. */
+    name: string;
+    /** Selector another device may resolve against its own registry. */
+    selector: string;
+    /** Stable anti-collision/failover key; never derived from the binary label. */
+    key: string;
+}
+/**
+ * One fully-resolved spawn attempt. `env` may contain credential material and
+ * `execHome` is a device-local path, so this type is confined to the local exec
+ * boundary. Events and remote callers use {@link ResolvedLaunchAccount} only.
+ */
+export interface ResolvedLocalAccountLaunch {
+    agent: AgentId;
+    executableVersion: string;
+    account: ResolvedLaunchAccount | null;
+    execHome?: string;
+    /** Compatibility label for an explicitly recorded, unmigrated home. */
+    configVersion?: string;
+    env: Record<string, string>;
+    signedIn: boolean | null;
+    email: string | null;
+}
+export interface ResolveLocalAccountLaunchOptions {
+    agent: AgentId;
+    /** Selects the executable only. It never chooses account state. */
+    executableVersion: string;
+    /** Exact account candidate selected by strategy/picker/readiness. */
+    candidate?: RotateCandidate;
+    /** Explicit account name/id (`--account`, `#name`, or a consumer intent). */
+    selector?: string;
+    /** Resolve the harness default when no explicit selector/candidate exists. */
+    useDefault?: boolean;
+    provider?: string;
+    target?: string;
+    meta?: Pick<Meta, 'accounts' | 'deviceAccounts'>;
+}
+/**
+ * Resolve one account-specific attempt at the local spawn boundary.
+ *
+ * Native selections resolve the registered slot and harness-specific home;
+ * provider selections materialize their credential env exactly here. An
+ * unmigrated version-home candidate remains a compatibility case, but it is
+ * never rediscovered by scanning homes for identity.
+ */
+export declare function resolveLocalAccountLaunch(options: ResolveLocalAccountLaunchOptions): Promise<ResolvedLocalAccountLaunch>;

package/dist/lib/accounting/account-launch.js

@@ -0,0 +1,117 @@
+/**
+ * Canonical target-local account launch resolution (PHNX-3940).
+ *
+ * Callers may carry a selector or a {@link RotateCandidate} across a routing
+ * boundary. This module resolves that intent on the machine that will spawn the
+ * harness, where account slots and credential stores actually live. The result
+ * is deliberately local-only: `execHome` and `env` must never cross SSH or be
+ * written to events.
+ */
+import * as fs from 'node:fs';
+import { resolveSpawnAccount } from '../account-registry.js';
+import { adoptedConfigPointsAtHome, adoptedSymlinkMismatchError, durableSlotEnv, isSymlinkAdoptedHarness, resolveNativeSpawnHome, symlinkAdoptedAccountError, } from '../exec-account-home.js';
+import { getVersionHomePath } from '../installations/versions.js';
+import { readMeta } from '../state.js';
+import { candidateAccountKey } from './rotate.js';
+function launchAccountFromSpawn(account) {
+    return {
+        kind: account.kind,
+        id: account.id,
+        name: account.name,
+        selector: account.name,
+        key: `${account.kind}:${account.id}`,
+    };
+}
+function candidateSelector(candidate) {
+    return candidate.nativeAccount ?? candidate.providerAccount;
+}
+function legacyAccount(candidate) {
+    const key = candidateAccountKey(candidate);
+    const name = candidate.accountLabel || candidate.email || key;
+    return {
+        kind: 'legacy-native',
+        id: candidate.accountKey ?? candidate.email ?? key,
+        name,
+        selector: candidate.email ?? candidate.accountKey ?? name,
+        key,
+    };
+}
+/**
+ * Resolve one account-specific attempt at the local spawn boundary.
+ *
+ * Native selections resolve the registered slot and harness-specific home;
+ * provider selections materialize their credential env exactly here. An
+ * unmigrated version-home candidate remains a compatibility case, but it is
+ * never rediscovered by scanning homes for identity.
+ */
+export async function resolveLocalAccountLaunch(options) {
+    const meta = options.meta ?? readMeta();
+    const selected = options.candidate;
+    const selector = options.selector ?? (selected ? candidateSelector(selected) : undefined);
+    // Compatibility for a candidate already discovered in an unmigrated home.
+    // The candidate is the identity decision; the label only locates that exact
+    // local config home and never participates in account comparison.
+    if (selected && !selector) {
+        const execHome = getVersionHomePath(options.agent, selected.version);
+        if (!fs.existsSync(execHome)) {
+            throw new Error(`${selected.accountLabel || options.agent} has no local account home at ${execHome}.`);
+        }
+        return {
+            agent: options.agent,
+            executableVersion: options.executableVersion,
+            account: legacyAccount(selected),
+            execHome,
+            configVersion: selected.version,
+            env: {},
+            signedIn: selected.signedIn,
+            email: selected.email,
+        };
+    }
+    const spawnAccount = resolveSpawnAccount(selector, options.agent, options.executableVersion, meta, {
+        useDefault: options.useDefault,
+        provider: options.provider,
+        target: options.target,
+    });
+    if (!spawnAccount) {
+        return {
+            agent: options.agent,
+            executableVersion: options.executableVersion,
+            account: null,
+            env: {},
+            signedIn: selected?.signedIn ?? null,
+            email: selected?.email ?? null,
+        };
+    }
+    const account = launchAccountFromSpawn(spawnAccount);
+    if (spawnAccount.kind === 'provider') {
+        return {
+            agent: options.agent,
+            executableVersion: options.executableVersion,
+            account,
+            env: spawnAccount.env,
+            signedIn: selected?.signedIn ?? true,
+            email: selected?.email ?? null,
+        };
+    }
+    if (isSymlinkAdoptedHarness(options.agent)) {
+        const defaultName = meta.accounts?.defaults?.[options.agent];
+        if (spawnAccount.name !== defaultName) {
+            throw new Error(symlinkAdoptedAccountError(options.agent, spawnAccount.name, defaultName));
+        }
+    }
+    const home = await resolveNativeSpawnHome(options.agent, spawnAccount, meta);
+    if (isSymlinkAdoptedHarness(options.agent)
+        && !adoptedConfigPointsAtHome(options.agent, home.execHome)) {
+        throw new Error(adoptedSymlinkMismatchError(options.agent, spawnAccount.name, home.execHome));
+    }
+    return {
+        agent: options.agent,
+        executableVersion: options.executableVersion,
+        account,
+        execHome: home.execHome,
+        configVersion: home.source === 'legacy-home' ? home.label : undefined,
+        env: durableSlotEnv(options.agent, spawnAccount, home, meta),
+        signedIn: selected?.signedIn ?? null,
+        email: selected?.email ?? null,
+    };
+}

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

@@ -19,7 +19,7 @@ function localRegistryRecords() {
     try {
         return Object.values(readAccountRegistry().accounts)
             .filter((a) => hasKeychainTokenSync(a.secretRef))
-            .map((a) => ({ name: a.name, provider: a.provider, auth: a.auth, secretPresent: true }));
+            .map((a) => ({ id: a.id, name: a.name, provider: a.provider, auth: a.auth, secretPresent: true }));
     }
     catch (err) {
         if (isSecretsTransportError(err))
@@ -66,6 +66,7 @@ export function foldRegistryCandidates(agent, inputs) {
         authVerdict: null,
         lastActive: null,
         providerAccount: r.name,
+        providerAccountId: r.id,
     }));
     return [...native, ...extra];
 }

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

@@ -13,6 +13,7 @@ import type { AccountAuthKind } from '../account-provider-registry.js';
  */
 /** A provider account record as stored in the registry (identity captured separately). */
 export interface RegistryAccountRecord {
+    id?: string;
     name: string;
     provider: string;
     auth: AccountAuthKind;
@@ -29,6 +30,7 @@ export interface RegistryAccountRecord {
 }
 /** A registry account eligible to run one harness, ready to map to a candidate. */
 export interface RegistryAccountInput {
+    id?: string;
     /** Agent-scoped key so `(claude, X)` and `(codex, X)` stay distinct. */
     accountKey: string;
     email: string | null;

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

@@ -22,6 +22,7 @@ export function registryPoolCandidates(records, agent) {
         if (!providerAuthenticatesHarness(r.provider, r.auth, agent))
             continue;
         out.push({
+            id: r.id,
             accountKey: `${agent}:name=${r.name}`,
             email: null,
             name: r.name,