@phnx-labs/agents-cli 1.22.105 → 1.22.107

package/dist/commands/exec.js

@@ -11,6 +11,7 @@ import { isTierToken } from '../lib/model-tiers.js';
 import { RUN_AUTO_KEYWORD } from '../lib/types.js';
 import { setHelpSections } from '../lib/help.js';
 import { isInteractiveTerminal, isPromptCancelled, requireInteractiveSelection } from './utils.js';
+import { isHumanFacingRun } from './run-account-picker.js';
 import { getUserAgentsDir, readMeta } from '../lib/state.js';
 import { parseLoopInterval } from '../lib/loop.js';
 import { AGENTS, resolveAgentName, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
@@ -36,15 +37,47 @@ export function parseExplicitSessionId(value) {
     }
     return value;
 }
-/** Distinguish a terminal account-picker marker from an explicit @version pin. */
-export function parseRunAccountPickerRequest(agentSpec) {
-    const requested = agentSpec.endsWith('@');
-    const normalizedAgentSpec = requested ? agentSpec.slice(0, -1) : agentSpec;
-    return {
-        requested,
-        normalizedAgentSpec,
-        valid: !requested || (!!normalizedAgentSpec && !normalizedAgentSpec.includes('@')),
-    };
+/**
+ * Parse the trailing picker markers on an `agents run` agent spec. A terminal
+ * run of `#`/`@` characters requests the account picker (`#`) and/or the
+ * device picker (`@`) — each at most once, in either order (`claude#@`,
+ * `claude@#`). Stripping them yields the normalized spec (`claude#work@` →
+ * `claude#work`, version pins and `#label` account pins intact). A picker
+ * cannot combine with an explicit pin of what it picks: `claude@2.1.218#`
+ * (the account picker already chooses the version — the old `claude@2.1.218@`
+ * rule), `claude#work#`, `claude@@`.
+ */
+export function parseRunPickerMarkers(agentSpec) {
+    let rest = agentSpec;
+    let accountPicker = false;
+    let devicePicker = false;
+    let reason;
+    while (rest.endsWith('#') || rest.endsWith('@')) {
+        const marker = rest.endsWith('#') ? '#' : '@';
+        if (marker === '#') {
+            if (accountPicker && reason === undefined)
+                reason = `the # picker marker may appear at most once in '${agentSpec}'`;
+            accountPicker = true;
+        }
+        else {
+            if (devicePicker && reason === undefined)
+                reason = `the @ picker marker may appear at most once in '${agentSpec}'`;
+            devicePicker = true;
+        }
+        rest = rest.slice(0, -1);
+    }
+    if (reason === undefined) {
+        if (!rest) {
+            reason = `'${agentSpec}' names no agent before the picker markers`;
+        }
+        else if (accountPicker && (rest.includes('@') || rest.includes('#'))) {
+            reason = `an explicit pin in '${rest}' already selects what the # account picker chooses`;
+        }
+        else if (devicePicker && rest.includes('@')) {
+            reason = `an explicit pin in '${rest}' cannot combine with the @ device picker`;
+        }
+    }
+    return { accountPicker, devicePicker, normalizedAgentSpec: rest, valid: reason === undefined, reason };
 }
 /**
  * The `--device` alias family — the flags that mean "dispatch this run to another
@@ -57,7 +90,11 @@ export function parseRunAccountPickerRequest(agentSpec) {
 export function hostTargetGiven(options) {
     return [options.host, options.device, options.on, options.computer].filter((v) => !!v);
 }
-/** Return every option whose selection semantics conflict with an account choice. */
+/**
+ * Return every option whose selection semantics conflict with an account
+ * choice (`agent#`). Device routing is deliberately absent: the marker rides
+ * the hop and the peer picks from ITS slots.
+ */
 export function runAccountPickerConflicts(options) {
     const conflicts = [];
     if (options.resume !== undefined)
@@ -66,6 +103,21 @@ export function runAccountPickerConflicts(options) {
         conflicts.push('--strategy');
     if (options.balanced)
         conflicts.push('--balanced');
+    if (options.lease)
+        conflicts.push('--lease');
+    if (options.box)
+        conflicts.push('--box');
+    if (options.account)
+        conflicts.push(`--account ${options.account}`);
+    return conflicts;
+}
+/**
+ * Return every option that already decides where the run lands, so a device
+ * choice (`agent@`) would be silently ignored: any explicit host flag, and the
+ * lease/box paths, which own placement outright.
+ */
+export function runDevicePickerConflicts(options) {
+    const conflicts = hostTargetGiven(options).map((h) => `--device ${h}`);
     if (options.lease)
         conflicts.push('--lease');
     if (options.box)
@@ -82,16 +134,54 @@ export { RUN_AUTO_KEYWORD };
 /**
  * Whether `run auto` should default its host layer to the affinity pick (the
  * same machinery as `--device auto`). False when the caller pinned any host
- * flag, and false when this process was itself dispatched by a host run — the
- * dispatcher exports AGENTS_RUN_AUTO_HOST_RESOLVED=1 into the remote SHELL
+ * flag, and false when this process was itself dispatched by a host run —
+ * the dispatcher exports AGENTS_RUN_AUTO_HOST_RESOLVED=1 into the remote SHELL
  * (hosts/dispatch.ts remoteRunShellPrelude) because it already resolved the
  * host layer, and re-picking here would chain-hop the run across the fleet.
- * Pure so the pinning matrix is unit-testable.
+ * An INTERACTIVE dispatch of a named harness also reaches the remote as a bare
+ * `agents run <harness>` (its argv forwards without the routing flag), so the
+ * interactive prelude's AGENTS_REMOTE_INTERACTIVE=1 counts as "already placed"
+ * too — without it the remote would re-place the run and ping-pong across the
+ * fleet. Pure so the pinning matrix is unit-testable.
  */
 export function runAutoDefaultsToAffinity(options, env = process.env) {
     if (hostTargetGiven(options).length > 0)
         return false;
-    return env.AGENTS_RUN_AUTO_HOST_RESOLVED !== '1';
+    if (env.AGENTS_RUN_AUTO_HOST_RESOLVED === '1')
+        return false;
+    return env.AGENTS_REMOTE_INTERACTIVE !== '1';
+}
+/**
+ * Whether a bare human-facing `agents run <harness>` — no prompt, so an
+ * interactive TUI run — defaults its placement to `--device auto` (PHNX-4083).
+ * A marker left off is decided for you: no `#` means balanced rotation, and no
+ * `@` (and no other placement flag) now means automatic device placement — the
+ * same engine as `--device auto`, whose pool never contains a box marked
+ * `personal`. ALL of these must hold:
+ *
+ * - no prompt (headless runs — teams, routines, hooks, `run <agent> "…"` —
+ *   keep running in place, unchanged);
+ * - a human-facing surface: a real TTY and no `--json`. This is the same
+ *   two-condition gate `signInLaunchDecision` uses in run-account-picker.ts —
+ *   reused here through isHumanFacingRun, not re-derived;
+ * - no device-picker marker (`agent@` already chose the device; picking this
+ *   machine there is a plain local run);
+ * - no `--resume` / `--lease` / `--box` / `--cloud` (those own placement);
+ * - the host layer is unpinned and this process is not itself a dispatched
+ *   hop — delegated to runAutoDefaultsToAffinity, which encodes both.
+ *
+ * Pure so the default-placement matrix is unit-testable.
+ */
+export function bareInteractiveRunDefaultsToDeviceAuto(options, run, surface, env = process.env) {
+    if (run.prompt !== undefined)
+        return false;
+    if (!isHumanFacingRun({ tty: surface.tty, json: surface.json === true }))
+        return false;
+    if (run.devicePickerRequested)
+        return false;
+    if (options.resume !== undefined || options.lease || options.box || options.cloud)
+        return false;
+    return runAutoDefaultsToAffinity(options, env);
 }
 /**
  * Whether an interactive host dispatch must mint a correlation launch id and
@@ -426,7 +516,7 @@ async function handleTerminalHandoff(agentSpec, options, prompt) {
     // isValidAgent / profileExists / resolveWorkflowRef chain below), so this must
     // accept all three. Gating on the agent table alone rejected every profile —
     // the whole Kimi/DeepSeek/Qwen/GLM path — for `--terminal` runs only.
-    const rawTarget = parseRunAccountPickerRequest(agentSpec).normalizedAgentSpec.split('#')[0].split('@')[0];
+    const rawTarget = parseRunPickerMarkers(agentSpec).normalizedAgentSpec.split('#')[0].split('@')[0];
     const knownAgent = resolveAgentName(rawTarget);
     const [{ profileExists }, { resolveWorkflowRef }] = await Promise.all([
         import('../lib/profiles.js'),
@@ -521,7 +611,7 @@ export function registerRunCommand(program) {
         .option('--list-tasks', 'With --broadcast: list available broadcast task ids')
         .option('--results [run-id]', 'With --broadcast: show one saved matrix run, or list saved runs newest first')
         .option('--concurrency <n>', 'With --broadcast: maximum cells running at once', '3')
-        .option('--resume [id]', 'Recover a previous conversation on its origin device. The exact healthy origin uses native resume; otherwise a healthy version of the same harness replays via /continue. Pair with a prompt to continue headlessly.')
+        .option('--resume [id]', 'Resume a conversation with its account on the origin device. Omit the id for the shared session picker; #account filters the history. Pair an id with a prompt to continue headlessly.')
         .option('--session-id <id>', 'Force a NEW conversation to use this exact session UUID (Claude only). This CREATES a session — to resume an existing one, use --resume.', parseExplicitSessionId)
         .option('--name <slug>', 'Name the run — seeds the session label so it shows up as `<name>` in `agents sessions` and resolves by it (and `agents hosts logs <name>` for --device runs) instead of an opaque id. An agent-generated title later refines the label; your name shows until then. Optional.')
         .option('--notify', 'Post a desktop notification when a headless run finishes. Fired by this process on exit, so it survives whatever launched the run (the menu bar dispatching it, a terminal you closed).')
@@ -587,12 +677,22 @@ export function registerRunCommand(program) {
       # Headless, can edit: have the agent make changes
       agents run claude "fix lint errors in src/" --mode edit
 
-      # Interactive (TUI) with the pinned default version
+      # Interactive (TUI): a bare run places itself like --device auto (a fleet
+      # worker, TUI forwarded over SSH); pin the device to stay on this machine
       agents run claude
+      agents run claude --device zion      # stay local (or pick this machine in claude@)
 
-      # Pick a signed-in account/version for only this run
+      # Pick a signed-in account/version for only this run (# = account picker)
+      agents run claude#
+
+      # Pick the device this run lands on (@ = device picker); this machine
+      # first, offline rows disabled, fleet state aged in the prompt
       agents run claude@
 
+      # Ask both, account first, then device — the run dispatches with the
+      # picked account to the picked device
+      agents run claude#@
+
       # Full-auto: affinity-pick the host, then the harness with the most
       # account headroom, then a balanced account on it
       agents run auto "fix the flaky test" --mode edit
@@ -677,9 +777,21 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
       best-account headroom), and the account (the strategy above). Zero
       healthy accounts on any harness exits nonzero with the earliest reset.
 
-      Account picker: append @ with no version (agents run claude@) to choose one
-        installed account for this run. Rows show identity, login state, plan,
-        and available limits; unsafe accounts stay visible but disabled.
+      Pickers: a trailing # opens the account picker (agents run claude#) to
+        choose one installed account for this run — rows show identity, login
+        state, plan, and available limits; unsafe accounts stay visible but
+        disabled. A trailing @ opens the device picker (agents run claude@);
+        #@ asks both, account first, then device. The pickers cannot combine
+        with an explicit pin of the same thing (--account, --device/--on/
+        --computer/--host) or with --strategy/--balanced/--resume/--lease/--box.
+
+      Interactive placement: a bare 'agents run <harness>' (no prompt, real TTY)
+        places itself like --device auto — a fleet worker runs it, with the TUI
+        forwarded over SSH. Headless runs (any prompt, --json, no TTY) are
+        unchanged: they run in place. To stay on this machine, pass
+        --device <this machine>, or pick this machine (listed first) in the
+        '<harness>@' device picker. When placement finds no healthy device the
+        run fails loud and names the local spellings.
 
       Fallback: --fallback codex,antigravity retries on rate-limit failure via /continue handoff. Each entry accepts @version.
 
@@ -692,7 +804,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         given. --cloud is mutually exclusive with --device/--lease and with
         local-run flags (--loop, --resume, --secrets, --terminal, …).
 
-      Resume: --resume <id> resolves full IDs locally first, then fleet-wide, and recovers on the source device with its cwd/mode. The exact healthy origin version uses native resume; otherwise a healthy version of the same harness replays via /continue. agents sessions resume <id> infers the harness too.
+      Resume: --resume <id> resolves full IDs locally first, then fleet-wide, and recovers on the source device with its cwd/mode. Resume preserves the conversation account and uses the installed binary; starting a new conversation from archived context requires an explicit choice. agents sessions resume <id> infers the harness too.
 
       Passthrough: everything after -- is forwarded verbatim to the underlying agent CLI.
         agents run kimi -- --plan --some-native-flag value
@@ -834,19 +946,25 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 host: options.host,
             });
         }
-        // A trailing @ is an explicit request to choose one installed account.
-        // Strip only that terminal marker; concrete agent@version pins retain
-        // their existing meaning in every dispatch path below.
-        const accountPicker = parseRunAccountPickerRequest(agentSpec);
-        const accountPickerRequested = accountPicker.requested;
-        let normalizedAgentSpec = accountPicker.normalizedAgentSpec;
-        if (!accountPicker.valid) {
-            console.error(chalk.red(`Invalid account picker target: ${agentSpec}. Use agents run <agent>@.`));
+        // Trailing picker markers request an interactive choice: `#` picks the
+        // account (and the version it signs in with), `@` picks the device, and
+        // `#@`/`@#` ask both. Strip only those terminal markers; concrete
+        // agent@version pins and `#label` account pins retain their meaning in
+        // every dispatch path below.
+        const pickerMarkers = parseRunPickerMarkers(agentSpec);
+        const accountPickerRequested = pickerMarkers.accountPicker;
+        const devicePickerRequested = pickerMarkers.devicePicker;
+        let normalizedAgentSpec = pickerMarkers.normalizedAgentSpec;
+        if (!pickerMarkers.valid) {
+            console.error(chalk.red(`Invalid run picker target: ${agentSpec}. ` +
+                `${pickerMarkers.reason ?? 'unrecognized picker markers'}. ` +
+                'Use agents run <agent># to pick an account, <agent>@ to pick a device, <agent>#@ for both.'));
             process.exit(1);
         }
         // Peel `#name` off before --device dispatch so the selector rides the hop
         // unchanged and the peer resolves ITS slot (PHNX-3940 T5). The later local
-        // parse is idempotent when the values match.
+        // parse is idempotent when the values match. A bare trailing `#` was the
+        // picker marker above, so it can never land here as an empty label.
         {
             const labelParts = normalizedAgentSpec.split('#');
             if (labelParts.length > 2 || labelParts[1] === '') {
@@ -861,6 +979,27 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             if (specAccountLabel)
                 options.account = specAccountLabel;
         }
+        // Bare resume is a session selection request, before fresh-run defaults or placement.
+        // Concrete IDs re-enter the executor below, so this cannot recurse.
+        if (options.resume === true || options.resume === '') {
+            if (options.sessionId || options.loop || options.fallback || options.resumeCheckpoint || options.lease) {
+                throw new Error('--resume cannot be combined with --session-id, --loop, --fallback, --resume-checkpoint, or --lease.');
+            }
+            const { sessionsResumeAction } = await import('./sessions-resume.js');
+            await sessionsResumeAction(undefined, prompt, {
+                agent: normalizedAgentSpec.split('#')[0] === RUN_AUTO_KEYWORD ? undefined : normalizedAgentSpec.split('#')[0],
+                account: options.account,
+                model: options.model,
+                mode: command.getOptionValueSource('mode') === 'default' ? undefined : options.mode,
+                interactive: options.interactive,
+                headless: options.headless,
+                cwd: options.cwd,
+                quiet: options.quiet,
+                device: options.host || options.device || options.on || options.computer,
+                runArgs: rawArgs.slice(2),
+            });
+            return;
+        }
         // Hard-deprecated harnesses cannot be run — point the user at the successor.
         const runBaseAgentName = normalizedAgentSpec.split('#')[0].split('@')[0];
         const runBaseAgentId = resolveAgentName(runBaseAgentName);
@@ -869,14 +1008,22 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             console.error(chalk.red(hardDeprecationError(runBaseAgentId)));
             process.exit(1);
         }
-        // Account-picker conflict check runs BEFORE device=auto may set balanced,
-        // so an implicit balanced preference never surfaces as a fake
-        // "cannot be combined with --balanced" when the user only typed trailing @.
+        // Picker conflict checks run BEFORE --resume/--device auto may place the
+        // run implicitly, so an implied placement never surfaces as a fake
+        // "cannot be combined with --device" when the user only typed a marker.
         if (accountPickerRequested) {
             const conflicts = runAccountPickerConflicts(options);
             if (conflicts.length > 0) {
                 console.error(chalk.red(`Account selection with ${agentSpec} cannot be combined with ${conflicts.join(', ')}. ` +
-                    'Remove the conflicting selector, or use an explicit agent@version target.'));
+                    'Remove the conflicting selector, or pin the target explicitly (agent@version or agent#label).'));
+                process.exit(1);
+            }
+        }
+        if (devicePickerRequested) {
+            const conflicts = runDevicePickerConflicts(options);
+            if (conflicts.length > 0) {
+                console.error(chalk.red(`Device selection with ${agentSpec} cannot be combined with ${conflicts.join(', ')}. ` +
+                    'Remove one — the picker already chooses where the run lands.'));
                 process.exit(1);
             }
         }
@@ -908,7 +1055,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             delete process.env.AGENTS_RESUME_SOURCE_JSON;
             const outcome = injectedSource
                 ? { kind: 'resolved', session: injectedSource }
-                : await (await import('./sessions.js')).resolveSessionMetadataValue(selector);
+                : await (await import('./sessions.js')).resolveSessionMetadataValue(selector, { agent: runBaseAgentId ?? undefined });
             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),
@@ -929,17 +1076,12 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 process.exit(1);
             }
             resolvedResumeSource = outcome.session;
-            const [requestedAgent, requestedVersion] = normalizedAgentSpec.split('#')[0].split('@');
+            const [requestedAgent] = normalizedAgentSpec.split('#')[0].split('@');
             if (!autoHarnessRequested && requestedAgent !== resolvedResumeSource.agent) {
                 console.error(chalk.red(`Session ${resolvedResumeSource.shortId} belongs to ${resolvedResumeSource.agent}, not ${requestedAgent}. ` +
                     `Use: agents sessions resume ${resolvedResumeSource.id}`));
                 process.exit(1);
             }
-            if (!autoHarnessRequested && requestedVersion && requestedVersion !== resolvedResumeSource.version) {
-                console.error(chalk.red(`Session ${resolvedResumeSource.shortId} started with ${resolvedResumeSource.agent}@${resolvedResumeSource.version ?? 'unknown'}, ` +
-                    `not @${requestedVersion}.`));
-                process.exit(1);
-            }
             // Omitted --mode inherits the effective source mode. Commander keeps
             // the normal new-run default as a real value, so consult its provenance
             // rather than mistaking the default for an explicit override.
@@ -960,7 +1102,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 options.host = sourcePeer;
             }
             else if (sourcePeer && explicitPlacement && !hostTargetGiven(options).some((host) => sessionRecoveryDestinationMatches(resolvedResumeSource, host))) {
-                console.error(chalk.red(`Session ${resolvedResumeSource.shortId} must recover on ${sourcePeer}, where its indexed transcript and version history are owned; ` +
+                console.error(chalk.red(`Session ${resolvedResumeSource.shortId} must recover on ${sourcePeer}, where its conversation state is stored; ` +
                     `the requested device was ${hostTargetGiven(options).join(', ')}.`));
                 process.exit(1);
             }
@@ -972,7 +1114,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             if (!sourcePeer) {
                 try {
                     const { resolveSessionRecovery } = await import('../lib/session/recovery.js');
-                    resolvedRecoveryTarget = await resolveSessionRecovery(resolvedResumeSource);
+                    resolvedRecoveryTarget = await resolveSessionRecovery(resolvedResumeSource, undefined, { account: options.account, model: options.model ?? resolvedResumeSource.model });
                 }
                 catch (err) {
                     console.error(chalk.red(err.message));
@@ -981,7 +1123,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 normalizedAgentSpec = `${resolvedRecoveryTarget.agent}@${resolvedRecoveryTarget.version}`;
                 autoHarnessRequested = false;
                 if (!options.quiet)
-                    process.stderr.write(chalk.gray(`[agents] session recovery → ${resolvedRecoveryTarget.mode} ${normalizedAgentSpec} on ${sourceMachine ?? machineId()} · ${resolvedRecoveryTarget.reason}\n`));
+                    process.stderr.write(chalk.gray(`[agents] session recovery → ${resolvedRecoveryTarget.mode} ${resolvedRecoveryTarget.agent} on ${sourceMachine ?? machineId()} · ${resolvedRecoveryTarget.reason}\n`));
             }
             else if (autoHarnessRequested) {
                 normalizedAgentSpec = sourceAgent;
@@ -997,7 +1139,11 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 process.exit(1);
             }
             if (accountPickerRequested) {
-                console.error(chalk.red(`agents run auto picks the harness and account itself — the trailing-@ account picker needs a concrete harness (agents run <harness>@).`));
+                console.error(chalk.red(`agents run auto picks the harness and account itself — the trailing-# account picker needs a concrete harness (agents run <harness>#).`));
+                process.exit(1);
+            }
+            if (devicePickerRequested) {
+                console.error(chalk.red(`agents run auto picks the harness and its placement itself — the trailing-@ device picker needs a concrete harness (agents run <harness>@).`));
                 process.exit(1);
             }
             // Host layer: with no explicit --device, default to the
@@ -1006,19 +1152,100 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             if (!resolvedResumeSource && runAutoDefaultsToAffinity(options))
                 options.device = 'auto';
         }
+        // The picker menus run HERE — after every conflict check, before
+        // placement resolves — so the picked account labels the device rows and
+        // the picked device is concrete for every host branch below.
+        //   `#@`/`@#`: account first, against THIS machine's slots; the picked
+        //     account becomes options.account and the device menu shows its
+        //     ✓/– per-device mark. A remote device pick dispatches with
+        //     `<agent>#<label>` so the peer resolves its own slot.
+        //   `@`: just the device menu; picking this machine is a plain local run.
+        // Either menu cancelled (Esc/Ctrl-C) launches nothing and exits 0.
+        let upFrontAccountPick = null;
+        if (accountPickerRequested && devicePickerRequested) {
+            const baseName = normalizedAgentSpec.split('#')[0].split('@')[0];
+            const baseAgentId = resolveAgentName(baseName);
+            const { profileExists: baseProfileExists } = await import('../lib/profiles.js');
+            if (!baseAgentId || baseProfileExists(baseName)) {
+                console.error(chalk.red(baseProfileExists(baseName)
+                    ? `Account selection is not available for custom harness '${baseName}'. Run its concrete host agent with # instead.`
+                    : `Account selection is not available for '${baseName}'. Run a concrete agent with # instead.`));
+                process.exit(1);
+            }
+            const { supportsAccountInspection: baseSupportsInspection, agentLabel: baseAgentLabel, ACCOUNT_INSPECTION_AGENT_IDS: inspectionAgentIds } = await import('../lib/agents.js');
+            if (!baseSupportsInspection(baseAgentId)) {
+                console.error(chalk.red(`${baseAgentLabel(baseAgentId)} does not expose local account state, so agents-cli cannot safely select an account.`));
+                console.error(chalk.gray(`Supported account pickers: ${inspectionAgentIds.join(', ')}`));
+                process.exit(1);
+            }
+            const { pickRunAccountCandidate } = await import('./run-account-picker.js');
+            const selected = await pickRunAccountCandidate(baseAgentId);
+            if (!selected)
+                return; // Esc/Ctrl-C: launch nothing.
+            if (selected.nativeAccount)
+                options.account = selected.nativeAccount;
+            upFrontAccountPick = selected;
+            if (!options.quiet) {
+                const identity = selected.accountLabel || 'signed-in account';
+                process.stderr.write(chalk.gray(`[agents] selected ${identity} · ${baseAgentId}@${selected.version} for this run\n`));
+            }
+        }
+        if (devicePickerRequested) {
+            // --resume above may have pinned the host implicitly (recovery to the
+            // source peer); a device menu against it would be a silent no-op.
+            const impliedHost = hostTargetGiven(options);
+            if (impliedHost.length > 0) {
+                console.error(chalk.red(`Device selection with ${agentSpec} cannot be combined with the placement --resume already chose (${impliedHost.join(', ')}). ` +
+                    'Remove one — both pick where the run lands.'));
+                process.exit(1);
+            }
+            const { pickRunDevice } = await import('./run-device-picker.js');
+            const baseName = normalizedAgentSpec.split('#')[0].split('@')[0];
+            const pickedDevice = await pickRunDevice({
+                agent: (resolveAgentName(baseName) ?? baseName),
+                accountLabel: options.account,
+            });
+            if (pickedDevice === null)
+                return; // Esc/Ctrl-C: launch nothing.
+            const { isSelfHost } = await import('../lib/devices/self-host.js');
+            // Picking this machine is a plain local run — leave options.device unset.
+            if (!isSelfHost(pickedDevice))
+                options.device = pickedDevice;
+        }
+        // Default placement (PHNX-4083): a bare human-facing `agents run
+        // <harness>` (no prompt, real TTY, no placement flags, not a dispatched
+        // hop) places itself like `--device auto` — a marker left off is decided
+        // for you. Headless runs (a prompt, --json, teams/routines/hooks) keep
+        // running in place, unchanged.
+        const defaultPlacement = bareInteractiveRunDefaultsToDeviceAuto(options, { prompt, devicePickerRequested }, { tty: isInteractiveTerminal(), json: options.json });
+        if (defaultPlacement)
+            options.device = 'auto';
         // --device auto (and deprecated --smart): live fleet pick.
         // Harness is always the agent the user typed — never auto-picked.
         // Placement failure propagates; an automatic request never becomes local.
         {
             const { applyDeviceAutoToOptions } = await import('../lib/smart-launch.js');
-            const result = await applyDeviceAutoToOptions(options, {
-                accountPickerRequested,
-                // `run auto` selects its harness after placement, so do not filter
-                // candidates against an arbitrary proxy harness at this stage.
-                agent: normalizedAgentSpec.split('#')[0].split('@')[0] === RUN_AUTO_KEYWORD
-                    ? undefined
-                    : (resolveAgentName(normalizedAgentSpec.split('#')[0].split('@')[0]) ?? undefined),
-            });
+            let result;
+            try {
+                result = await applyDeviceAutoToOptions(options, {
+                    accountPickerRequested,
+                    // `run auto` selects its harness after placement, so do not filter
+                    // candidates against an arbitrary proxy harness at this stage.
+                    agent: normalizedAgentSpec.split('#')[0].split('@')[0] === RUN_AUTO_KEYWORD
+                        ? undefined
+                        : (resolveAgentName(normalizedAgentSpec.split('#')[0].split('@')[0]) ?? undefined),
+                });
+            }
+            catch (err) {
+                // Placement the DEFAULT chose must fail loud AND name the local
+                // escape hatch — never silently fall back to a local launch.
+                if (!defaultPlacement)
+                    throw err;
+                console.error(chalk.red(err.message));
+                const { machineId } = await import('../lib/machine-id.js');
+                console.error(chalk.gray(`Run here instead: agents run ${runBaseAgentName} --device ${machineId()}`));
+                process.exit(1);
+            }
             if (!options.quiet && result.deprecationSmart) {
                 process.stderr.write(chalk.yellow('[agents] --smart is deprecated; use --device auto\n'));
             }
@@ -1419,8 +1646,6 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 hostRejects.push(RUN_OPTION_REJECT_MESSAGES.allowExpired);
             if (options.resumeCheckpoint)
                 hostRejects.push(RUN_OPTION_REJECT_MESSAGES.resumeCheckpoint);
-            if (options.resume === true)
-                hostRejects.push(RUN_OPTION_REJECT_MESSAGES.resumeBare);
             if (hostRejects.length > 0) {
                 for (const msg of hostRejects)
                     console.error(chalk.red(msg));
@@ -1498,9 +1723,11 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     process.exit(1);
                 }
                 const interactiveHost = options.interactive === true || (prompt === undefined && options.headless !== true);
-                if (accountPickerRequested && !interactiveHost) {
+                // When the account was already picked up front (`#@`), the dispatch
+                // forwards `#label` and the peer needs no interactive picker.
+                if (accountPickerRequested && !upFrontAccountPick && !interactiveHost) {
                     console.error(chalk.red(`Account selection with ${agentSpec} requires an interactive host run. ` +
-                        `Use agents run ${runAgent}@ --device ${host.name} --interactive.`));
+                        `Use agents run ${runAgent}# --device ${host.name} --interactive.`));
                     process.exit(1);
                 }
                 if (interactiveHost) {
@@ -1562,9 +1789,9 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     const exitCode = await runInteractiveOnHost(host, {
                         agent: runAgent,
                         version: resumeId ? undefined : runVersion,
-                        accountPicker: accountPickerRequested,
+                        accountPicker: accountPickerRequested && !upFrontAccountPick,
                         strategy: resumeId ? undefined : runStrategy,
-                        account: resumeId ? undefined : options.account,
+                        account: options.account,
                         fallback: options.fallback,
                         prompt,
                         mode: forwardedMode,
@@ -1672,7 +1899,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     agent: runAgent,
                     version: resumeId ? undefined : runVersion,
                     strategy: resumeId ? undefined : runStrategy,
-                    account: resumeId ? undefined : options.account,
+                    account: options.account,
                     fallback: options.fallback,
                     prompt,
                     mode: forwardedMode,
@@ -1894,12 +2121,12 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         let workflowHasSubagents = false;
         const cwd = options.cwd ?? process.cwd();
         if (accountPickerRequested && profileExists(rawAgent)) {
-            console.error(chalk.red(`Account selection is not available for custom harness '${rawAgent}'. Run its concrete host agent with @ instead.`));
+            console.error(chalk.red(`Account selection is not available for custom harness '${rawAgent}'. Run its concrete host agent with # instead.`));
             process.exit(1);
         }
         if (accountPickerRequested && !isValidAgent(rawAgent)) {
             if (resolveWorkflowRef(rawAgent, cwd)) {
-                console.error(chalk.red(`Account selection is not available for workflow '${rawAgent}'. Run a concrete agent with @ instead.`));
+                console.error(chalk.red(`Account selection is not available for workflow '${rawAgent}'. Run a concrete agent with # instead.`));
                 process.exit(1);
             }
         }
@@ -2180,7 +2407,10 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 process.exit(1);
             }
         }
-        if (accountPickerRequested) {
+        // `#@` already asked the account up front (before the device menu) — a
+        // remote device pick never reaches here, so apply the local pick's
+        // version/home and skip the on-the-spot menu.
+        if (accountPickerRequested && !upFrontAccountPick) {
             if (!supportsAccountInspection(agent)) {
                 console.error(chalk.red(`${agentLabel(agent)} does not expose local account state, so agents-cli cannot safely select an account.`));
                 console.error(chalk.gray(`Supported account pickers: ${ACCOUNT_INSPECTION_AGENT_IDS.join(', ')}`));
@@ -2206,88 +2436,101 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 process.exit(1);
             }
         }
+        if (upFrontAccountPick) {
+            version = upFrontAccountPick.version;
+            if (upFrontAccountPick.slotDir)
+                execHome = upFrontAccountPick.slotDir;
+        }
         version = resolveVersionAlias(agent, version);
-        // Account selection follows the binding order: explicit --account → exact
-        // `agent@version` binding → device-scoped `agent` binding → per-harness
-        // default. The exact-installation binding needs the concrete launch
-        // version, so resolve it (default when the run named no version).
         const { resolveSpawnAccount } = await import('../lib/account-registry.js');
-        // Binding key: a custom harness keys on its own profile name; a native /
-        // global run keys on the exact `agent@version` (default when unpinned).
-        const bindingTarget = fromProfile ? rawAgent : (version ? `${agent}@${version}` : `${agent}@${getGlobalDefault(agent) ?? ''}`);
         let spawnAccount = null;
-        try {
-            spawnAccount = resolveSpawnAccount(options.account, agent, version, readMeta(), { useDefault: !fromProfile, provider: profileProvider, target: bindingTarget });
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
+        let launchAccount;
+        if (resolvedRecoveryTarget) {
+            const { resolveLocalAccountLaunch } = await import('../lib/accounting/account-launch.js');
+            launchAccount = await resolveLocalAccountLaunch({
+                agent,
+                executableVersion: resolvedRecoveryTarget.version,
+                candidate: resolvedRecoveryTarget.candidate,
+                useDefault: false,
+            });
+            execHome = resolvedRecoveryTarget.mode === 'native' ? (resolvedRecoveryTarget.execHome ?? launchAccount.execHome) : launchAccount.execHome;
+            accountConfigVersion = resolvedRecoveryTarget.mode === 'native' ? (resolvedRecoveryTarget.configVersion ?? launchAccount.configVersion) : launchAccount.configVersion;
+            accountEnv = { ...accountEnv, ...launchAccount.env };
         }
-        // Downstream rotation gating asks only "was an account selected?".
-        const configuredAccount = spawnAccount?.name;
-        if (spawnAccount) {
-            if (options.cloud || options.provider || options.lease) {
-                console.error(chalk.red('--account selects a device-local credential and cannot be combined with cloud or lease placement.'));
+        else {
+            // Binding key: a custom harness keys on its own profile name; a native /
+            // global run keys on the exact `agent@version` (default when unpinned).
+            const bindingTarget = fromProfile ? rawAgent : (version ? `${agent}@${version}` : `${agent}@${getGlobalDefault(agent) ?? ''}`);
+            try {
+                spawnAccount = resolveSpawnAccount(options.account, agent, version, readMeta(), { useDefault: !fromProfile, provider: profileProvider, target: bindingTarget });
+            }
+            catch (err) {
+                console.error(chalk.red(err.message));
                 process.exit(1);
             }
-            if (spawnAccount.kind === 'native') {
-                // `#name` / `--account` on a --device run is forwarded unchanged at
-                // dispatch time; the peer resolves ITS slot. This block is local-only.
-                const remoteTarget = options.host || options.device;
-                if (!remoteTarget) {
-                    const { adoptedConfigPointsAtHome, adoptedSymlinkMismatchError, durableSlotEnv, isSymlinkAdoptedHarness, resolveNativeSpawnHome, symlinkAdoptedAccountError, } = await import('../lib/exec-account-home.js');
-                    const { readMeta } = await import('../lib/state.js');
-                    const meta = readMeta();
-                    if (isSymlinkAdoptedHarness(agent)) {
-                        const defaultName = meta.accounts?.defaults?.[agent];
-                        if (spawnAccount.name !== defaultName) {
-                            console.error(chalk.red(symlinkAdoptedAccountError(agent, spawnAccount.name, defaultName)));
-                            process.exit(1);
+            // Downstream rotation gating asks only "was an account selected?".
+            if (spawnAccount) {
+                if (options.cloud || options.provider || options.lease) {
+                    console.error(chalk.red('--account selects a device-local credential and cannot be combined with cloud or lease placement.'));
+                    process.exit(1);
+                }
+                if (spawnAccount.kind === 'native') {
+                    // `#name` / `--account` on a --device run is forwarded unchanged at
+                    // dispatch time; the peer resolves ITS slot. This block is local-only.
+                    const remoteTarget = options.host || options.device;
+                    if (!remoteTarget) {
+                        const { adoptedConfigPointsAtHome, adoptedSymlinkMismatchError, durableSlotEnv, isSymlinkAdoptedHarness, resolveNativeSpawnHome, symlinkAdoptedAccountError, } = await import('../lib/exec-account-home.js');
+                        const { readMeta } = await import('../lib/state.js');
+                        const meta = readMeta();
+                        if (isSymlinkAdoptedHarness(agent)) {
+                            const defaultName = meta.accounts?.defaults?.[agent];
+                            if (spawnAccount.name !== defaultName) {
+                                console.error(chalk.red(symlinkAdoptedAccountError(agent, spawnAccount.name, defaultName)));
+                                process.exit(1);
+                            }
                         }
-                    }
-                    try {
-                        const resolved = await resolveNativeSpawnHome(agent, spawnAccount, meta);
-                        if (isSymlinkAdoptedHarness(agent) && !adoptedConfigPointsAtHome(agent, resolved.execHome)) {
-                            console.error(chalk.red(adoptedSymlinkMismatchError(agent, spawnAccount.name, resolved.execHome)));
+                        try {
+                            const resolved = await resolveNativeSpawnHome(agent, spawnAccount, meta);
+                            if (isSymlinkAdoptedHarness(agent) && !adoptedConfigPointsAtHome(agent, resolved.execHome)) {
+                                console.error(chalk.red(adoptedSymlinkMismatchError(agent, spawnAccount.name, resolved.execHome)));
+                                process.exit(1);
+                            }
+                            execHome = resolved.execHome;
+                            // A worker's durable api-key slot holds no file: the pushed key
+                            // rides the harness env var (CURSOR_API_KEY, …) on this launch.
+                            const durable = durableSlotEnv(agent, spawnAccount, resolved, meta);
+                            if (Object.keys(durable).length > 0)
+                                accountEnv = { ...accountEnv, ...durable };
+                            if (resolved.source === 'legacy-home') {
+                                accountConfigVersion = resolved.label;
+                                // A leftover version-labeled home is both the spawn HOME and
+                                // the account's installation — the pre-T5 `resolveAccountVersion`
+                                // behavior. An explicit `@<label>` still controls the binary.
+                                if (!version && !fromProfile && resolved.label)
+                                    version = resolved.label;
+                            }
+                        }
+                        catch (err) {
+                            console.error(chalk.red(err.message));
                             process.exit(1);
                         }
-                        execHome = resolved.execHome;
-                        // A worker's durable api-key slot holds no file: the pushed key
-                        // rides the harness env var (CURSOR_API_KEY, …) on this launch.
-                        const durable = durableSlotEnv(agent, spawnAccount, resolved, meta);
-                        if (Object.keys(durable).length > 0)
-                            accountEnv = { ...accountEnv, ...durable };
-                        if (resolved.source === 'legacy-home') {
-                            accountConfigVersion = resolved.label;
-                            // A leftover version-labeled home is both the spawn HOME and
-                            // the account's installation — the pre-T5 `resolveAccountVersion`
-                            // behavior. An explicit `@<label>` still controls the binary.
-                            if (!version && !fromProfile && resolved.label)
-                                version = resolved.label;
+                        // Slot / provisioned: binary comes from the one managed install unless `@<label>` pins it.
+                        if (!version && !fromProfile) {
+                            const { ensureHarnessInstallation } = await import('../lib/installations/store.js');
+                            const { installation } = await ensureHarnessInstallation(agent);
+                            version = installation.label;
                         }
+                        if (!options.quiet)
+                            process.stderr.write(chalk.gray(`[agents] account '${spawnAccount.name}' · ${agent}\n`));
                     }
-                    catch (err) {
-                        console.error(chalk.red(err.message));
-                        process.exit(1);
-                    }
-                    // Slot / provisioned: binary comes from the one managed install unless `@<label>` pins it.
-                    if (!version && !fromProfile) {
-                        const { ensureHarnessInstallation } = await import('../lib/installations/store.js');
-                        const { installation } = await ensureHarnessInstallation(agent);
-                        version = installation.label;
-                    }
-                    if (!options.quiet)
-                        process.stderr.write(chalk.gray(`[agents] account '${spawnAccount.name}' · ${agent}\n`));
                 }
-            }
-            else {
-                accountEnv = spawnAccount.env;
+                else {
+                    accountEnv = spawnAccount.env;
+                }
             }
         }
-        // --resume: resolve a prior conversation and rewrite the run target to
-        // continue it. `version` here is already the alias-resolved candidate-version
-        // FILTER (undefined for default/any, concrete for @latest/@oldest/@x.y.z);
-        // it is replaced below by the chosen session's OWN version (isolation).
+        const configuredAccount = launchAccount?.account?.name ?? spawnAccount?.name;
+        // The account and native context were resolved before launch defaults.
         let resumeNative = false;
         let resumeSessionId;
         let forceInteractive = false;
@@ -2300,136 +2543,23 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 console.error(chalk.red('--resume cannot be combined with --loop, --fallback, or --resume-checkpoint (those are separate continuation mechanisms).'));
                 process.exit(1);
             }
-            const { findSessionsById } = await import('../lib/session/db.js');
-            const { discoverSessions } = await import('../lib/session/discover.js');
-            const { pickSessionInteractive } = await import('./sessions.js');
             const { buildContinuePrompt } = await import('../lib/loop.js');
-            // Freshen the index for this agent before any lookup (incremental, cached).
-            // AgentId is wider than SessionAgentId (amp/goose/copilot keep no transcripts);
-            // those simply yield no matches and fall through to the not-found error.
-            const sessionAgent = agent;
-            if (!resolvedResumeSource)
-                await discoverSessions({ agent: sessionAgent, version });
-            // Resume is interactive unless a follow-on prompt makes it headless.
-            const wantsInteractive = resolveInteractive({ interactive: options.interactive, headless: options.headless, prompt });
-            const idArg = typeof options.resume === 'string' ? options.resume.trim() : '';
-            let scopeCwd;
-            try {
-                scopeCwd = fs.realpathSync(cwd);
-            }
-            catch {
-                scopeCwd = cwd;
-            }
-            let session = resolvedResumeSource;
-            if (idArg) {
-                let matches = session ? [session] : findSessionsById(idArg, { agent: sessionAgent, version, cwd: scopeCwd });
-                if (matches.length === 0) {
-                    const wide = findSessionsById(idArg, { agent: sessionAgent, version });
-                    if (wide.length > 0) {
-                        if (!options.quiet)
-                            process.stderr.write(chalk.gray(`No match for "${idArg}" in this project; widened to all projects.\n`));
-                        matches = wide;
-                    }
-                }
-                if (matches.length === 0) {
-                    console.error(chalk.red(`No ${agent} session matching "${idArg}".`));
-                    console.error(chalk.gray(`Browse sessions: agents sessions ${idArg}`));
-                    process.exit(1);
-                }
-                else if (matches.length === 1) {
-                    session = matches[0];
-                }
-                else if (wantsInteractive) {
-                    const picked = await pickSessionInteractive(matches, `Multiple sessions match "${idArg}":`);
-                    if (!picked)
-                        process.exit(0);
-                    session = picked.session;
-                }
-                else {
-                    console.error(chalk.red(`"${idArg}" is ambiguous — ${matches.length} sessions match:`));
-                    for (const m of matches.slice(0, 10)) {
-                        console.error(chalk.gray(`  ${m.shortId}  ${m.timestamp.slice(0, 16).replace('T', ' ')}  ${m.topic ?? m.label ?? ''}`));
-                    }
-                    console.error(chalk.gray('Pass more of the id, or resume interactively (drop the prompt).'));
-                    process.exit(1);
-                }
-            }
-            else {
-                // Bare --resume: pick from recent sessions in scope. Needs a TTY.
-                if (!wantsInteractive) {
-                    console.error(chalk.red('--resume with no id needs an interactive terminal. Pass a session id (full or prefix), or run without --headless.'));
-                    process.exit(1);
-                }
-                const recent = await discoverSessions({ agent: sessionAgent, version, limit: 200 });
-                if (recent.length === 0) {
-                    console.error(chalk.red(`No ${agent} sessions found to resume in this project.`));
-                    console.error(chalk.gray('Browse all: agents sessions'));
-                    process.exit(1);
-                }
-                const picked = await pickSessionInteractive(recent, `Resume which ${agent} session?`);
-                if (!picked)
-                    process.exit(0);
-                session = picked.session;
-                forceInteractive = true; // bare resume always lands in the agent's TUI
-            }
-            // Bare `run <harness> --resume` learns the chosen SessionMeta only after
-            // the host-placement phase above. If the picker chose a synced session
-            // from another device, route the recovery command now; resolving local
-            // candidates would otherwise native-resume through this device's
-            // unrelated isolated home.
-            if (!resolvedResumeSource) {
-                const { sessionRecoveryPeer, sessionRecoveryRunArgs, } = await import('../lib/session/recovery.js');
-                const peer = sessionRecoveryPeer(session);
-                if (peer) {
-                    const { runOnPeer } = await import('../lib/session/remote-list.js');
-                    const routed = await runOnPeer(sessionRecoveryRunArgs(session), peer, { tty: true, sessionId: session.id });
-                    if (routed === 'no-target') {
-                        console.error(chalk.red(`Cannot recover session ${session.shortId}: origin device ${peer} is not a registered reachable peer.`));
-                        process.exitCode = 1;
-                    }
-                    return;
-                }
-            }
-            // Bare interactive --resume selects the SessionMeta only down here, so
-            // it has not gone through the early concrete-id resolver. Resolve it now;
-            // concrete ids reuse the exact same target chosen above.
-            if (!resolvedRecoveryTarget) {
-                try {
-                    const { resolveSessionRecovery } = await import('../lib/session/recovery.js');
-                    resolvedRecoveryTarget = await resolveSessionRecovery(session);
-                }
-                catch (err) {
-                    console.error(chalk.red(err.message));
-                    process.exit(1);
-                }
-            }
+            const session = resolvedResumeSource;
+            if (!session || !resolvedRecoveryTarget) {
+                throw new Error('Session recovery did not resolve a conversation on this device.');
+            }
+            if (!options.cwd)
+                options.cwd = resolvedRecoveryTarget.mode === 'native'
+                    ? resolvedRecoveryTarget.cwd ?? session.cwd
+                    : session.cwd;
+            forceInteractive = resolveInteractive({ interactive: options.interactive, headless: options.headless, prompt });
             if (resolvedRecoveryTarget.agent !== agent) {
                 console.error(chalk.red(`Session ${session.shortId} belongs to ${resolvedRecoveryTarget.agent}, not ${agent}. ` +
                     `Use: agents run auto --resume ${session.id}`));
                 process.exit(1);
             }
             version = resolvedRecoveryTarget.version;
-            // Account rotation (PHNX-3626 / PHNX-3674): recovery picked a healthy
-            // provider of the SAME harness. Inject that credential through the
-            // `--account` path so spawn does not authenticate as the version home's
-            // native login (the exhausted origin when the continue pick is a
-            // provider). An explicit --account (configuredAccount) always wins.
-            const rotatedAccount = resolvedRecoveryTarget.account;
-            if (rotatedAccount && !configuredAccount) {
-                try {
-                    const picked = resolveSpawnAccount(rotatedAccount.providerAccount, agent, version, readMeta(), { useDefault: false });
-                    if (picked?.kind === 'provider')
-                        accountEnv = picked.env;
-                }
-                catch {
-                    // Account-registry errors can carry provider credential material;
-                    // never relay them onto the terminal from this automatic path.
-                    console.error(chalk.red('Could not prepare the rotated provider account for session recovery.'));
-                    process.exit(1);
-                }
-            }
             if (resolvedRecoveryTarget.mode === 'native') {
-                version = session.version;
                 resumeNative = true;
                 resumeSessionId = session.id;
                 // The centralized recovery decision proves the transcript belongs to
@@ -2438,23 +2568,23 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 // differ from the earlier cwd that selected projects/<cwd-key>.
                 if (!options.cwd && resolvedRecoveryTarget.cwd)
                     options.cwd = resolvedRecoveryTarget.cwd;
-                if (rotatedAccount && !configuredAccount && !options.quiet) {
-                    process.stderr.write(chalk.gray(`[agents] origin ${agent} account limited → rotated to ${rotatedAccount.label} (native resume)\n`));
-                }
                 if (!options.quiet)
-                    process.stderr.write(chalk.gray(`Resuming ${agent} ${session.shortId} (native)${version ? ` @${version}` : ''} in ${options.cwd ?? cwd}\n`));
+                    process.stderr.write(chalk.gray(`Resuming ${agent} ${session.shortId} (native) in ${options.cwd ?? cwd}\n`));
             }
             else {
-                // Tier-2: launch fresh with a /continue <id> first message; the agent
-                // loads the transcript via `agents sessions <id>` and picks up.
+                if (!isInteractiveTerminal() || options.headless) {
+                    console.error(chalk.red(`Native resume is unavailable: ${resolvedRecoveryTarget.reason}. To start a new conversation with this context, explicitly run: agents run ${agent} "/continue ${session.id}"`));
+                    process.exit(1);
+                }
+                const { confirm } = await import('@inquirer/prompts');
+                const replay = await confirm({ message: `${resolvedRecoveryTarget.reason}. Start a new conversation using this transcript?`, default: false }).catch(() => false);
+                if (!replay)
+                    return;
                 prompt = buildContinuePrompt(session.id, prompt);
                 if (prompt.trim() === `/continue ${session.id}`)
                     forceInteractive = true;
-                if (rotatedAccount && !configuredAccount && !options.quiet) {
-                    process.stderr.write(chalk.gray(`[agents] origin ${agent} account limited → rotated to ${rotatedAccount.label} (/continue)\n`));
-                }
                 if (!options.quiet)
-                    process.stderr.write(chalk.gray(`Resuming ${agent} ${session.shortId} (/continue replay)${version ? ` @${version}` : ''}\n`));
+                    process.stderr.write(chalk.gray(`Resuming ${agent} ${session.shortId} (/continue replay)\n`));
             }
         }
         const configuredStrategy = getConfiguredRunStrategy(agent, cwd);
@@ -2511,7 +2641,9 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     // picker's other callers keep the native-only collector.
                     const { collectRunCandidatesForRun } = await import('../lib/accounting/account-pool-collect.js');
                     bootMark('resolve-version:start');
-                    const resolved = await resolveRunVersion(agent, strategy, cwd, collectRunCandidatesForRun);
+                    const routingModel = options.model ?? resolvedResumeSource?.model ?? workflowModel
+                        ?? (options.fallback ? undefined : resolveRunDefaults(agent, resolveVersion(agent, cwd), cwd).model);
+                    const resolved = await resolveRunVersion(agent, strategy, cwd, collectRunCandidatesForRun, routingModel);
                     bootMark('resolve-version:done');
                     if (resolved.exhausted) {
                         // Zero healthy accounts splits two ways, and conflating them is what
@@ -2526,7 +2658,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                         // - NEEDS A SIGN-IN (signed_out / revoked) -> launching IS the fix,
                         //   because the harness's own TUI is the login surface. So on a TTY we
                         //   carry the user into that login instead of erroring. Exiting here
-                        //   made `agents run <agent>`, `agents run <agent>@`, and `agents use`
+                        //   made `agents run <agent>`, `agents run <agent>#`, and `agents use`
                         //   all dead-end with no reachable way to authenticate.
                         const recoverable = signInRecoverableCandidates(resolved.exhausted);
                         const { signInLaunchDecision } = await import('./run-account-picker.js');
@@ -2539,7 +2671,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                             const { pickSignInLaunchVersion } = await import('./run-account-picker.js');
                             const signInVersion = await pickSignInLaunchVersion(agent, recoverable, !!options.quiet);
                             // A cancelled prompt launches nothing — same contract as the
-                            // trailing-@ account picker above.
+                            // trailing-# account picker above.
                             if (!signInVersion)
                                 return;
                             version = signInVersion;
@@ -2577,7 +2709,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                         if (decision === 'picker') {
                             const selected = await pickRunAccountCandidate(agent);
                             // A cancelled picker launches nothing — same contract as the
-                            // trailing-@ account picker and the sign-in launch above.
+                            // trailing-# account picker and the sign-in launch above.
                             if (!selected)
                                 return;
                             version = selected.version;
@@ -2665,17 +2797,6 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     console.error(chalk.red(`agents: ${agent}@${launchTarget} is not runnable and could not be repaired. Try: ${hint}`));
                     process.exit(1);
                 }
-                if (resolvedRecoveryTarget && healed !== launchTarget) {
-                    console.error(chalk.red(`agents: session recovery target ${agent}@${launchTarget} became unavailable on ` +
-                        `${resolvedResumeSource?.machine ?? 'this device'}; refusing to resume through another version home. ` +
-                        `Retry the command so recovery can select a healthy ${agent} version.`));
-                    process.exit(1);
-                }
-                // Always adopt the healed version explicitly. In the version-undefined
-                // path a fallback re-pins the GLOBAL default, but `resolveVersion`
-                // prefers a PROJECT pin — so leaving `version` undefined would let the
-                // shim re-resolve the still-broken project pin and crash anyway. Pinning
-                // the runnable version here is a no-op when nothing changed.
                 version = healed;
             }
         }
@@ -2741,13 +2862,13 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 // `signInLaunch` means the zero-healthy path already reported this exact
                 // account as logged out and named the login command, so re-probing here
                 // only prints a second, near-identical warning.
-                rotated: !!rotationResult || accountPickerRequested || signInLaunch || spawnAccount?.kind === 'provider',
+                rotated: !!rotationResult || accountPickerRequested || signInLaunch || (launchAccount?.account?.kind ?? spawnAccount?.kind) === 'provider',
             });
             if (preflight) {
                 try {
                     const { getAccountInfo } = await import('../lib/agents.js');
                     const authVersion = accountConfigVersion ?? version;
-                    const info = await getAccountInfo(agent, authVersion ? getVersionHomePath(agent, authVersion) : undefined);
+                    const info = await getAccountInfo(agent, execHome ?? (authVersion ? getVersionHomePath(agent, authVersion) : undefined));
                     // Claude authenticates interactively from a per-version setup-token on a
                     // keychain-less worker (the shim's .oauth_token fallback), which the
                     // native-credential probe above can't see — so don't warn "logged out" when
@@ -2761,8 +2882,8 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     }
                     if (!info.signedIn && !authedViaSetupToken) {
                         const { addSupported } = await import('../lib/accounts/add.js');
-                        const hint = spawnAccount?.kind === 'native'
-                            ? `agents accounts login ${agent}#${spawnAccount.name}`
+                        const hint = (launchAccount?.account?.kind ?? spawnAccount?.kind) === 'native'
+                            ? `agents accounts login ${agent}#${configuredAccount}`
                             : addSupported(agent)
                                 ? `agents accounts add ${agent} <name>`
                                 : loginHint(agent);
@@ -2823,7 +2944,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         // `--mode plan` is respected for genuine read-only command runs.
         const stallCmd = headlessPlanStallCommand({
             prompt,
-            interactive: options.interactive,
+            interactive: resolveInteractive({ prompt, headless: options.headless, interactive: options.interactive || forceInteractive }),
             mode: resolvedMode,
             modeIsDefault,
         });
@@ -2918,6 +3039,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             : undefined;
         const modelSource = runCmd.getOptionValueSource('model');
         let model = options.model
+            ?? resolvedResumeSource?.model
             ?? (!fromProfile && modelSource === undefined
                 ? (workflowModel ?? (options.fallback ? undefined : runDefaults.model))
                 : undefined);
@@ -2933,6 +3055,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         const execOptions = {
             agent,
             harnessName: profileName,
+            accountId: launchAccount?.account?.kind === 'legacy-native' ? undefined : (launchAccount?.account?.id ?? spawnAccount?.id),
             version,
             configVersion: accountConfigVersion,
             execHome,