@phnx-labs/agents-cli 1.22.105 → 1.22.107

package/dist/commands/resume.d.ts

@@ -1,28 +1,20 @@
 import type { SessionMeta } from '../lib/session/types.js';
 export declare const RESUME_SOURCE_ENV = "AGENTS_RESUME_SOURCE_JSON";
-/**
- * The source a dead-remote local fallback resumes from: the same session, but
- * with `machine` rewritten to THIS box so the delegated `agents run --resume`
- * resolves recovery locally (`sessionRecoveryPeer` returns undefined) instead of
- * bouncing back to the unreachable owner. Because no local version home owns the
- * peer's transcript, that local recovery lands on a labelled `/continue` replay
- * from the synced mirror — the only way to continue a session whose owning device
- * is gone. Owner-approved prefer-device, fall-back-local (PHNX-3626).
- *
- * Safe against the RUSH-2022 "silent local resume forks live state" hazard by
- * PRECONDITION: this is reached only after `runOnPeer` proved the owner
- * unreachable, so there is no live process on the peer to fork, and the fallback
- * is announced with a log line — never silent.
- */
+/** Inspect local archived context after the owner hop fails. Recovery still
+ * requires readable content and explicit replay consent before starting a run. */
 export declare function resumeLocalFallbackSource(session: SessionMeta, self?: string): SessionMeta;
 export interface StrictResumeOptions {
+    agent?: string;
     mode?: string;
+    account?: string;
+    model?: string;
     interactive?: boolean;
     headless?: boolean;
     cwd?: string;
     quiet?: boolean;
     /** Run on THIS machine even when the session belongs to a peer (escape hatch). */
     here?: boolean;
+    local?: boolean;
 }
 /**
  * The argv to re-run this resume on the machine that owns the session.
@@ -40,13 +32,6 @@ export declare function buildResumeRunArgs(session: {
     agent: string;
     version?: string;
 }, prompt: string | undefined, options: StrictResumeOptions): string[];
-/** Recreate a remote Claude launch whose forced id never materialized a transcript. */
-export declare function buildProvisionalRunArgs(session: {
-    id: string;
-    agent: string;
-    version?: string;
-    cwd?: string;
-}, prompt: string | undefined, options: StrictResumeOptions): string[];
 /** True when the caller asked for the strict resume path (prompt and/or flags). */
 export declare function wantsStrictResume(prompt: string | undefined, options: StrictResumeOptions): boolean;
 /**

package/dist/commands/resume.js

@@ -9,20 +9,8 @@ import { resolveSessionMetadataValue } from './sessions.js';
 import { sessionOwnerDevice, consumeResumePinned, RESUME_PINNED_ENV } from '../lib/session/resume-owner.js';
 import { machineId } from '../lib/machine-id.js';
 export const RESUME_SOURCE_ENV = 'AGENTS_RESUME_SOURCE_JSON';
-/**
- * The source a dead-remote local fallback resumes from: the same session, but
- * with `machine` rewritten to THIS box so the delegated `agents run --resume`
- * resolves recovery locally (`sessionRecoveryPeer` returns undefined) instead of
- * bouncing back to the unreachable owner. Because no local version home owns the
- * peer's transcript, that local recovery lands on a labelled `/continue` replay
- * from the synced mirror — the only way to continue a session whose owning device
- * is gone. Owner-approved prefer-device, fall-back-local (PHNX-3626).
- *
- * Safe against the RUSH-2022 "silent local resume forks live state" hazard by
- * PRECONDITION: this is reached only after `runOnPeer` proved the owner
- * unreachable, so there is no live process on the peer to fork, and the fallback
- * is announced with a log line — never silent.
- */
+/** Inspect local archived context after the owner hop fails. Recovery still
+ * requires readable content and explicit replay consent before starting a run. */
 export function resumeLocalFallbackSource(session, self = machineId()) {
     return { ...session, machine: self };
 }
@@ -36,6 +24,12 @@ export function resumeLocalFallbackSource(session, self = machineId()) {
  */
 export function buildResumeRemoteArgs(sessionId, prompt, options) {
     const args = ['sessions', 'resume', sessionId, ...(prompt === undefined ? [] : [prompt])];
+    if (options.agent)
+        args.push('--agent', options.agent);
+    if (options.account)
+        args.push('--account', options.account);
+    if (options.model)
+        args.push('--model', options.model);
     if (options.mode)
         args.push('--mode', options.mode);
     if (options.interactive)
@@ -51,8 +45,12 @@ export function buildResumeRemoteArgs(sessionId, prompt, options) {
 /** Translate `agents sessions resume <id>` to the canonical `agents run` surface after
  * resolving the source identity. The run command remains the only executor. */
 export function buildResumeRunArgs(session, prompt, options) {
-    const spec = session.version ? `${session.agent}@${session.version}` : session.agent;
+    const spec = session.agent;
     const args = ['run', spec, ...(prompt === undefined ? [] : [prompt]), '--resume', session.id];
+    if (options.account)
+        args.push('--account', options.account);
+    if (options.model)
+        args.push('--model', options.model);
     if (options.mode)
         args.push('--mode', options.mode);
     if (options.interactive)
@@ -65,23 +63,6 @@ export function buildResumeRunArgs(session, prompt, options) {
         args.push('--quiet');
     return args;
 }
-/** Recreate a remote Claude launch whose forced id never materialized a transcript. */
-export function buildProvisionalRunArgs(session, prompt, options) {
-    const spec = session.version ? `${session.agent}@${session.version}` : session.agent;
-    const args = ['run', spec, ...(prompt === undefined ? [] : [prompt]), '--session-id', session.id];
-    if (options.mode)
-        args.push('--mode', options.mode);
-    if (options.interactive)
-        args.push('--interactive');
-    if (options.headless)
-        args.push('--headless');
-    const cwd = options.cwd ?? session.cwd;
-    if (cwd)
-        args.push('--cwd', cwd);
-    if (options.quiet)
-        args.push('--quiet');
-    return args;
-}
 function consumeResumeSource() {
     const raw = process.env[RESUME_SOURCE_ENV];
     delete process.env[RESUME_SOURCE_ENV];
@@ -124,7 +105,7 @@ export async function runStrictResume(sessionId, prompt, options) {
     }
     // An owner hop must inspect only the owner's index. Fleet fan-out here can
     // rediscover the dispatcher's synthetic row and bounce the same id forever.
-    const outcome = await resolveSessionMetadataValue(sessionId.trim(), pinnedHere ? { local: true } : {});
+    const outcome = await resolveSessionMetadataValue(sessionId.trim(), { agent: options.agent, local: pinnedHere || options.local });
     if (outcome.kind === 'partial') {
         // RUSH-2492: an unreachable peer is a warning, not a hard failure. The
         // resolver already resolves an id found on the reachable fleet (SES-9a),
@@ -138,19 +119,6 @@ export async function runStrictResume(sessionId, prompt, options) {
         return;
     }
     if (outcome.kind === 'not-found') {
-        if (routedHop && routedSource?.filePath === '' && routedSource.agent === 'claude') {
-            const args = buildProvisionalRunArgs(routedSource, prompt, options);
-            const child = spawn(process.execPath, [process.argv[1], ...args], {
-                stdio: 'inherit',
-                env: process.env,
-            });
-            const exitCode = await new Promise((resolve) => {
-                child.once('error', () => resolve(127));
-                child.once('exit', (code, signal) => resolve(code ?? (signal ? 1 : 0)));
-            });
-            process.exitCode = exitCode;
-            return;
-        }
         console.error(chalk.red(`No session matching "${sessionId}".`));
         process.exitCode = 1;
         return;
@@ -184,21 +152,16 @@ export async function runStrictResume(sessionId, prompt, options) {
             sessionId: outcome.session.id,
         });
         if (rc === 'no-target' || rc === 'unreachable') {
-            // Prefer-device, fall back to local (PHNX-3626): the owning device is
-            // unreachable — either not a dialable registered device ('no-target') or
-            // registered but offline/asleep so the SSH connection itself failed
-            // ('unreachable'). Either way there is no live harness to reach OR to fork,
-            // so continue the session HERE from its synced mirror rather than
-            // dead-ending. The local recovery resolves this to a labelled `/continue`
-            // replay (no local home owns the peer's transcript), the honest degradation.
+            // The owner may still be running. Only verified local content can be
+            // offered as a separate conversation after explicit replay consent.
             if (!options.quiet) {
-                process.stderr.write(chalk.yellow(`[agents] session ${outcome.session.shortId} belongs to ${owner}, which is unreachable → resuming locally (/continue replay from the synced transcript)\n`));
+                process.stderr.write(chalk.yellow(`[agents] session ${outcome.session.shortId} belongs to ${owner}, which is unreachable; checking for local transcript content before offering replay\n`));
             }
             process.exitCode = await delegateLocalResume(resumeLocalFallbackSource(outcome.session), prompt, options);
         }
         return;
     }
-    process.exitCode = await delegateLocalResume(outcome.session, prompt, options);
+    process.exitCode = await delegateLocalResume(pinnedHere ? resumeLocalFallbackSource(outcome.session) : outcome.session, prompt, options);
 }
 /**
  * Spawn the delegated local `agents run --resume` for a session this box owns

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

@@ -35,6 +35,17 @@ export declare function buildSwitchAccountChoices(rows: SwitchAccountRow[]): Run
  * A cancelled picker writes nothing.
  */
 export declare function pickSwitchAccount(agent: AgentId, rows: SwitchAccountRow[]): Promise<string | null>;
+/**
+ * The two-condition "human-facing" gate behind signInLaunchDecision and
+ * noVerifiedUsageDecision: a real TTY and no `--json`. Off a TTY nobody can
+ * answer a prompt, and `--json` marks a MACHINE consumer, which must never be
+ * handed a picker or dropped into a login TUI. Mirrors the canonical
+ * `Surface.interactive = tty && !json` in `commands/utils.ts`.
+ */
+export declare function isHumanFacingRun(input: {
+    tty: boolean;
+    json: boolean;
+}): boolean;
 /**
  * Whether a zero-healthy run may recover by launching for a login, or must keep
  * failing loud. Three inputs, all of which have to hold:

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

@@ -204,6 +204,16 @@ export async function pickSwitchAccount(agent, rows) {
         throw err;
     }
 }
+/**
+ * The two-condition "human-facing" gate behind signInLaunchDecision and
+ * noVerifiedUsageDecision: a real TTY and no `--json`. Off a TTY nobody can
+ * answer a prompt, and `--json` marks a MACHINE consumer, which must never be
+ * handed a picker or dropped into a login TUI. Mirrors the canonical
+ * `Surface.interactive = tty && !json` in `commands/utils.ts`.
+ */
+export function isHumanFacingRun(input) {
+    return input.tty && !input.json;
+}
 /**
  * Whether a zero-healthy run may recover by launching for a login, or must keep
  * failing loud. Three inputs, all of which have to hold:
@@ -217,7 +227,7 @@ export async function pickSwitchAccount(agent, rows) {
  *   gets the parseable fail-loud error instead.
  */
 export function signInLaunchDecision(input) {
-    const humanPresent = input.tty && !input.json;
+    const humanPresent = isHumanFacingRun(input);
     return input.recoverable > 0 && humanPresent ? 'launch' : 'fail-loud';
 }
 /**

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

@@ -20,9 +20,13 @@ export interface ResumeOptions extends StrictResumeOptions {
     splits?: boolean;
     attachOnly?: boolean;
     local?: boolean;
+    /** Original run argv; only the bare resume selector changes after picking. */
+    runArgs?: string[];
 }
 export declare function registerSessionsResumeCommand(sessionsCmd: Command): void;
 export declare function sessionsResumeAction(query: string | undefined, prompt: string | undefined, options: ResumeOptions): Promise<void>;
+/** Preserve run options and lifecycle intent when the picker opens its selected rows. */
+export declare function buildSelectedResumeArgs(id: string, prompt: string | undefined, options: ResumeOptions): string[];
 /** 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 declare function isDirectResumeSelector(query: string): boolean;

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/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>;