@phnx-labs/agents-cli 1.22.46 → 1.22.49

package/dist/commands/exec.js

@@ -14,6 +14,7 @@ import { isInteractiveTerminal, isPromptCancelled, requireInteractiveSelection }
 import { getUserAgentsDir, readMeta } from '../lib/state.js';
 import { parseLoopInterval } from '../lib/loop.js';
 import { AGENTS, resolveAgentName, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
+import { parseAgentVersionSpec } from '../lib/agent-spec/agents.js';
 import { recordDispatchedRun } from '../lib/audit/log.js';
 import { maybeShowStarNudge } from '../lib/star-nudge.js';
 import { warnUnpushedWork, shouldWarnUnpushed } from '../lib/warn-unpushed.js';
@@ -416,7 +417,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];
+    const rawTarget = parseRunAccountPickerRequest(agentSpec).normalizedAgentSpec.split('#')[0].split('@')[0];
     const knownAgent = resolveAgentName(rawTarget);
     const [{ profileExists }, { resolveWorkflowRef }] = await Promise.all([
         import('../lib/profiles.js'),
@@ -490,7 +491,7 @@ export function registerRunCommand(program) {
     const runCmd = program
         .command('run [agent] [prompt]')
         .description('Execute an agent. Pass a prompt for headless runs; omit it to launch the agent interactively. With --broadcast, run the same prompt/task across an agent × model matrix.')
-        .option('-m, --mode <mode>', 'How much the agent can do: plan (read-only), edit (can write files), auto (smart classifier auto-approves safe ops, prompts for risky), skip (bypass all permission prompts). Omitted Codex mode defaults to safe writable edit; other harnesses default to plan. \'full\' accepted as alias for skip.', 'plan')
+        .option('-m, --mode <mode>', 'How much the agent can do: plan (read-only), edit (can write files), auto (more autonomous than edit, mechanism per-harness: smart classifier auto-approves safe ops and still prompts for risky ones on Claude/Copilot; approval_policy=never over the edit sandbox on Codex, which never prompts), skip (bypass all permission prompts). Omitted Codex mode defaults to safe writable edit; other harnesses default to plan. \'full\' accepted as alias for skip.', 'plan')
         .option('-e, --effort <effort>', 'Reasoning effort: low | medium | high | xhigh | max | auto (claude and codex only)', 'auto')
         .option('--model <model>', 'Cost tier (cheap|default|best|ultra) or a concrete model id; tiers resolve per harness+version to a supported model')
         .option('--env <key=value>', 'Pass environment variable to the agent (repeatable, e.g., --env DEBUG=1 --env API_KEY=xyz)', (val, prev) => [...prev, val], [])
@@ -507,7 +508,7 @@ export function registerRunCommand(program) {
         .option('--no-auth-check', 'Skip the pre-launch "looks logged out" warning on an interactive run (advisory; never blocks anyway). Also silenced by AGENTS_NO_AUTH_CHECK=1.')
         .option('-i, --interactive', 'Force interactive mode even when a prompt is provided. Mutually exclusive with --headless.')
         .option('--broadcast', 'Run the same prompt or --task across multiple agents (comma-separated [agent]) × --model cells. Replaces the former `agents bench` group.')
-        .option('--task <id>', 'With --broadcast: house benchmark task id under apps/cli/bench/tasks/')
+        .option('--task <id>', 'With --broadcast: house benchmark task id under cli/bench/tasks/')
         .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')
@@ -517,14 +518,14 @@ export function registerRunCommand(program) {
         .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).')
         .option('--terminal [backend]', "Open this run in a real terminal tab instead of here. Without a value the terminal is detected from your live sessions (`agents sessions --active` host), so it lands where you already work — Ghostty for a Ghostty user, iTerm for an iTerm user. Name one to force it: iterm | ghostty | terminal | tmux | vscodium-agent. This is how the menu bar's New Session opens.")
         .option('--verbose', 'Show detailed execution logs')
-        .option('--raw', 'Interactive runs on macOS/Linux launch inside a shared tmux session (for %pane addressing + re-attach). Pass --raw to spawn the agent directly instead. Also disabled by AGENTS_NO_TMUX=1.')
-        .option('--no-tmux', 'Spawn the agent directly instead of wrapping it in the shared tmux session. Same effect as --raw / AGENTS_NO_TMUX=1. Use this to see the agent\'s full startup output when a launch is failing; to turn the wrap off for every run on this machine, set `agents config set devices.<name>.tmux off`.')
-        .option('--disable-tmux', 'Alias for --no-tmux.')
+        .option('--raw', 'Keep this interactive run direct when the device has opted into tmux wrapping. A no-op under the default tmux-off configuration; equivalent to AGENTS_NO_TMUX=1.')
+        .option('--no-tmux', 'Keep this run direct when tmux wrapping is enabled for the device. Same effect as --raw / AGENTS_NO_TMUX=1; it is a no-op under the default tmux-off configuration.')
+        .option('--disable-tmux', 'Compatibility alias for --no-tmux; a no-op when tmux wrapping is already off.')
         .option('--timeout <duration>', 'Kill the agent after this duration (e.g., 30m, 1h, 2h30m)')
         .option('--fallback <agents>', 'Comma-separated agents to try on rate-limit failure. Each entry accepts an optional @version pin (e.g., codex@0.116.0,antigravity). The primary runs first; if it exits with a rate-limit error, the next agent picks up via /continue handoff.')
         .option('-b, --balanced', 'Shortcut for --strategy balanced. Ignored when @version is pinned.')
         .option('--strategy <strategy>', 'Version/account selection strategy: pinned | available | balanced. Defaults to run.<agent>.strategy, then balanced (spreads load across healthy accounts and skips any that are rate-limited). (Legacy `rotate` accepted as alias for `balanced`.)')
-        .option('--account <name>', 'Use this durable provider credential for the run')
+        .option('--account <label>', 'Use this labeled native login or durable provider credential for the run')
         .option('--acp', 'Route through the Agent Client Protocol instead of direct exec. Supported for claude via @zed-industries/claude-code-acp adapter. Unified event stream; emits ndjson when --json.')
         .option('-y, --yes', 'Skip the interactive budget-confirm prompt (require_confirm_over). Never skips a hard budget block.', false)
         .option('--loop', 'Re-inject the prompt/entrypoint each iteration until a stop condition (issue #332). Guards (--max-iterations, --budget, --until) are enforced outside the agent. Writes a checkpoint after every iteration for --resume-checkpoint.')
@@ -534,7 +535,7 @@ export function registerRunCommand(program) {
         .option('--until <signal>', 'Loop stop condition. `signal` reads <runDir>/loop-signal.json {continue,reason} each iteration; absent or continue:false stops (fail-closed). Loop only.')
         .option('--interval <dur>', 'Loop delay between iterations ("0" back-to-back, "30m" paces). Loop only.')
         .option('--where <spec>', 'Where this run\'s body executes (one placement door): local | device:<name> | auto | lease[:backend] | cloud[:provider]. Expands to --device/--lease/--cloud. Do not combine with those flags. See docs/00-concepts.md#placement.')
-        .option('-D, --device <name>', 'Offload this run onto another machine over SSH — a registered device, or user@host. Pass "auto" to pick the least-loaded reachable device where the requested agent is installed and signed in, keeping the run local when no remote is better. Same as --where device:<name>. See `agents devices`.')
+        .option('-D, --device <name>', 'Offload this run onto another machine over SSH — a registered device, or user@host. Pass "auto" to pick the least-loaded reachable device where the requested agent is installed and signed in, keeping the run local when no remote is better, or "interactive" for the machine pinned as interactive.host (the box a human is sitting at). Same as --where device:<name>. See `agents devices`.')
         .option('--remote-cwd <dir>', "Explicit device working directory for --device runs, used VERBATIM (overrides --cwd; usually --cwd suffices — it re-roots a local-home path onto the remote home). Pass a single-quoted '$HOME/…' or a valid remote absolute path; a local ~ expands here and won't exist there (/Users/you vs /home/you).")
         .option('--no-follow', 'With --device, dispatch detached and return immediately (track via `agents hosts ps/logs`).')
         .option('--any', 'With --device <cap> (a capability tag), pick any matching device instead of erroring when several match.')
@@ -636,7 +637,11 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
       Modes (not every agent supports every mode — run \`agents modes <agent>\`):
         plan  read-only investigation; no writes, no shell side-effects
         edit  may edit files; prompts for shell / risky operations
-        auto  smart classifier auto-approves safe ops, prompts for risky (claude, copilot)
+        auto  more autonomous than edit; the mechanism is per-harness --
+              claude, copilot: smart classifier auto-approves safe ops and
+                     STILL PROMPTS for risky ones
+              codex: approval_policy=never over the edit sandbox; never
+                     prompts at all, and a denied command fails instead
         skip  bypass every permission prompt (dangerously-skip-permissions)
         Legacy 'full' is silently rewritten to 'skip'.
         List per-harness support + native flags: agents modes · agents modes claude
@@ -829,7 +834,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             process.exit(1);
         }
         // Hard-deprecated harnesses cannot be run — point the user at the successor.
-        const runBaseAgentName = normalizedAgentSpec.split('@')[0];
+        const runBaseAgentName = normalizedAgentSpec.split('#')[0].split('@')[0];
         const runBaseAgentId = resolveAgentName(runBaseAgentName);
         const { profileExists: runProfileExists } = await import('../lib/profiles.js');
         if (runBaseAgentId && !runProfileExists(runBaseAgentName) && isAgentHardDeprecated(runBaseAgentId)) {
@@ -849,7 +854,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         }
         // `agents run auto`: the reserved harness keyword — full-auto dispatch
         // (host affinity → cross-harness balance → account balance, RUSH-2132).
-        if (normalizedAgentSpec.split('@')[0] === RUN_AUTO_KEYWORD && normalizedAgentSpec !== RUN_AUTO_KEYWORD) {
+        if (normalizedAgentSpec.split('#')[0].split('@')[0] === RUN_AUTO_KEYWORD && normalizedAgentSpec !== RUN_AUTO_KEYWORD) {
             console.error(chalk.red(`agents run auto picks the harness itself — a @version pin does not apply. ` +
                 `Pin a concrete harness instead: agents run <harness>@<version>.`));
             process.exit(1);
@@ -896,7 +901,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 process.exit(1);
             }
             resolvedResumeSource = outcome.session;
-            const [requestedAgent, requestedVersion] = normalizedAgentSpec.split('@');
+            const [requestedAgent, requestedVersion] = 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}`));
@@ -982,9 +987,9 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 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] === RUN_AUTO_KEYWORD
+                agent: normalizedAgentSpec.split('#')[0].split('@')[0] === RUN_AUTO_KEYWORD
                     ? undefined
-                    : (resolveAgentName(normalizedAgentSpec.split('@')[0]) ?? undefined),
+                    : (resolveAgentName(normalizedAgentSpec.split('#')[0].split('@')[0]) ?? undefined),
             });
             if (!options.quiet && result.deprecationSmart) {
                 process.stderr.write(chalk.yellow('[agents] --smart is deprecated; use --device auto\n'));
@@ -1137,7 +1142,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             const { getConfiguredRunStrategy, resolveRunVersion } = await import('../lib/accounting/rotate.js');
             const { profileExists, readProfile, resolveProfileEnv } = await import('../lib/profiles.js');
             const detected = await detectSignedInRuntimes();
-            const [agentName, rawLeaseVersion] = normalizedAgentSpec.split('@');
+            const [agentName, rawLeaseVersion] = normalizedAgentSpec.split('#')[0].split('@');
             let runtime = null;
             let credentialRuntimes = [];
             let dispatchProfile;
@@ -1398,7 +1403,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 throw e;
             }
             try {
-                const [runAgent, rawRunVersion] = normalizedAgentSpec.split('@');
+                const [runAgent, rawRunVersion] = normalizedAgentSpec.split('#')[0].split('@');
                 // Forward the explicit @version pin verbatim. Resolving aliases like
                 // @latest locally would check local installs, but the remote host may
                 // have versions the laptop does not. The remote agents CLI resolves
@@ -1496,6 +1501,19 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     if (process.env.AGENTS_DISPATCH_DEBUG || options.verbose) {
                         process.stderr.write(chalk.gray(`[hosts] dispatch interactive ${runAgent}${runVersion ? `@${runVersion}` : ''} -> ${host.name}\n`));
                     }
+                    {
+                        const { connectionStartedNotice, startConnectionTarget } = await import('../lib/hosts/reconnect.js');
+                        const startTarget = startConnectionTarget({
+                            agent: runAgent,
+                            hostSessionId,
+                            resumeId,
+                        });
+                        if (startTarget) {
+                            const started = connectionStartedNotice(startTarget, host.name);
+                            if (started)
+                                process.stderr.write(chalk.gray(started));
+                        }
+                    }
                     const exitCode = await runInteractiveOnHost(host, {
                         agent: runAgent,
                         version: resumeId ? undefined : runVersion,
@@ -1560,19 +1578,32 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     // `raw` runs aren't tmux wrapped, so there is nothing to reconnect to.
                     // For `run auto` prefer the join-resolved id (the harness the remote
                     // ACTUALLY picked) over the explicit --session-id only claude adopts.
-                    const reconnectId = (runAgent === RUN_AUTO_KEYWORD
-                        ? resolvedRemoteId ?? hostSessionId
-                        : hostSessionId ?? resolvedRemoteId) ?? resumeId;
-                    if (reconnectId && !isRaw) {
-                        const { reconnectInteractiveSession, SSH_CONN_FAILURE } = await import('../lib/hosts/reconnect.js');
-                        if (exitCode === SSH_CONN_FAILURE) {
-                            process.exit(await reconnectInteractiveSession({
-                                host,
-                                sessionId: reconnectId,
-                                initialExit: exitCode,
-                            }));
-                        }
+                    const { pickReconnectTarget, reconnectInteractiveSession, afterInteractiveRemoteExit, SSH_CONN_FAILURE } = await import('../lib/hosts/reconnect.js');
+                    const reconnectTarget = pickReconnectTarget({
+                        agent: runAgent,
+                        sessionId: hostSessionId,
+                        resolvedId: resolvedRemoteId,
+                        resumeId,
+                        launchId: correlationLaunchId,
+                    });
+                    // Raw is not tmux-wrapped, so it never auto-reconnects — but it
+                    // still prints the session id (EXEC-55). Bundling the notice
+                    // behind `!isRaw` left a dropped `--raw` tab as a bare shell.
+                    const next = afterInteractiveRemoteExit({
+                        target: reconnectTarget,
+                        host: host.name,
+                        exitCode,
+                        willReconnect: exitCode === SSH_CONN_FAILURE && !isRaw,
+                    });
+                    if (next.reconnect && reconnectTarget) {
+                        process.exit(await reconnectInteractiveSession({
+                            host,
+                            target: reconnectTarget,
+                            initialExit: exitCode,
+                        }));
                     }
+                    if (next.notice)
+                        process.stderr.write(next.notice);
                     process.exit(exitCode);
                 }
                 // Headless host run: launch detached, tail the remote log, and follow
@@ -1754,12 +1785,33 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             import('../lib/share/config.js'),
         ]);
         const isValidAgent = (agent) => ALL_AGENT_IDS.includes(agent);
-        // Parse agent@version
-        const [rawAgent, rawVersion] = normalizedAgentSpec.split('@');
+        // Parse agent@version#label. The label selects native auth without pinning
+        // the binary version; --account remains the equivalent flag form.
+        const labelParts = normalizedAgentSpec.split('#');
+        if (labelParts.length > 2 || labelParts[1] === '') {
+            console.error(chalk.red(`Invalid account label in '${normalizedAgentSpec}'.`));
+            process.exit(1);
+        }
+        const [rawAgent, rawVersion] = labelParts[0].split('@');
+        const specAccountLabel = labelParts[1];
+        if (resolveAgentName(rawAgent)) {
+            const parsed = parseAgentVersionSpec(normalizedAgentSpec);
+            if ('error' in parsed) {
+                console.error(chalk.red(parsed.error));
+                process.exit(1);
+            }
+        }
+        if (specAccountLabel && options.account && specAccountLabel !== options.account) {
+            console.error(chalk.red(`Account '${specAccountLabel}' from the agent spec conflicts with --account '${options.account}'.`));
+            process.exit(1);
+        }
+        if (specAccountLabel)
+            options.account = specAccountLabel;
         let agent;
         let version = rawVersion || undefined;
         let profileEnv;
         let accountEnv;
+        let accountConfigVersion;
         let profileProvider;
         let fromProfile = false;
         let profileFallbackModel;
@@ -2126,29 +2178,19 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                     console.error(chalk.red(`Account '${spawnAccount.name}' is a device-local ${spawnAccount.agent} login and cannot be forwarded to '${remoteTarget}'. Sign in on that device and name the login there.`));
                     process.exit(1);
                 }
-                if (version) {
-                    // A pinned version must actually be signed in as the named identity.
-                    const { getAccountInfo } = await import('../lib/agents.js');
-                    const info = await getAccountInfo(agent, getVersionHomePath(agent, version));
-                    const liveKey = info.accountKey ?? info.email?.toLowerCase() ?? null;
-                    if (!info.signedIn || liveKey !== spawnAccount.identityKey) {
-                        console.error(chalk.red(`Account '${spawnAccount.name}' names a specific ${spawnAccount.agent} identity, but ${agent}@${version} ${info.signedIn ? 'is signed in as a different identity' : 'is not signed in'}. Sign in as that identity, or re-name the account.`));
-                        process.exit(1);
-                    }
+                const { CONFIG_ENV_ISOLATED_AGENTS } = await import('../lib/installations/shims.js');
+                if (!CONFIG_ENV_ISOLATED_AGENTS.includes(agent)) {
+                    console.error(chalk.red(`${agent} cannot select native accounts independently of its installed version.`));
+                    process.exit(1);
                 }
-                else {
-                    // No version pinned: locate the installed version currently signed in
-                    // as this identity and pin the run to it — do NOT assume the global
-                    // default holds it (the account may live on another installed copy).
-                    const { resolveAccountVersion } = await import('../lib/accounting/rotate.js');
-                    const matched = await resolveAccountVersion(agent, spawnAccount.identityKey);
-                    if (!matched) {
-                        console.error(chalk.red(`No installed ${spawnAccount.agent} version is signed in as the identity named by account '${spawnAccount.name}'. Sign in as that identity, or attach a different account.`));
-                        process.exit(1);
-                    }
-                    version = matched;
+                const { resolveAccountVersion } = await import('../lib/accounting/rotate.js');
+                accountConfigVersion = await resolveAccountVersion(agent, spawnAccount.identityKey) ?? undefined;
+                if (!accountConfigVersion) {
+                    console.error(chalk.red(`No installed ${spawnAccount.agent} version is signed in as the identity labeled '${spawnAccount.name}'. Sign in as that identity, or label a different account.`));
+                    process.exit(1);
                 }
-                // Native identity confirmed live; the harness reads it from its home.
+                if (!options.quiet)
+                    process.stderr.write(chalk.gray(`[agents] account '${spawnAccount.name}' · ${agent} auth from ${accountConfigVersion}\n`));
             }
             else {
                 accountEnv = spawnAccount.env;
@@ -2252,7 +2294,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 const peer = sessionRecoveryPeer(session);
                 if (peer) {
                     const { runOnPeer } = await import('../lib/session/remote-list.js');
-                    const routed = await runOnPeer(sessionRecoveryRunArgs(session), peer, { tty: true });
+                    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;
@@ -2507,7 +2549,18 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 try {
                     const { getAccountInfo } = await import('../lib/agents.js');
                     const info = await getAccountInfo(agent);
-                    if (!info.signedIn) {
+                    // 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
+                    // a setup-token resolves for this version. No-op on macOS, where the
+                    // credential lives in the keychain and resolveClaudeSetupToken returns null.
+                    let authedViaSetupToken = false;
+                    if (!info.signedIn && agent === 'claude' && version) {
+                        const { resolveClaudeSetupToken } = await import('../lib/claude-account-token.js');
+                        const { getVersionHomePath } = await import('../lib/installations/versions.js');
+                        authedViaSetupToken = resolveClaudeSetupToken(getVersionHomePath('claude', version)) !== null;
+                    }
+                    if (!info.signedIn && !authedViaSetupToken) {
                         process.stderr.write(chalk.yellow(`⚠  ${agent} looks logged out — log in with: ${loginHint(agent)}. Launching anyway...\n`));
                     }
                 }
@@ -2670,6 +2723,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         const execOptions = {
             agent,
             version,
+            configVersion: accountConfigVersion,
             prompt,
             interactive: options.interactive || forceInteractive,
             mode: requestedMode,

package/dist/commands/feed-watch.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerFeedWatchCommand(parent: Command): void;

package/dist/commands/feed-watch.js

@@ -0,0 +1,28 @@
+import { machineId } from '../lib/machine-id.js';
+import { setHelpSections } from '../lib/help.js';
+import { watchFleetFeed, watchLocalFeed } from '../lib/feed/watch.js';
+export function registerFeedWatchCommand(parent) {
+    const command = parent.command('watch').description('Stream the canonical agent, attention, and activity projection as NDJSON')
+        .option('--json', 'Emit versioned NDJSON envelopes').option('--local', 'Watch only this machine');
+    setHelpSections(command, { examples: `agents feed watch --json\nagents feed watch --json --local`, notes: 'Order by streamId + sequence. Unavailable scopes retain their last rows until reset on reconnect.' });
+    command.action(async (_opts, invoked) => {
+        const opts = invoked.optsWithGlobals();
+        if (!opts.json)
+            invoked.error("error: required option '--json' not specified");
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        const emit = (event) => process.stdout.write(`${JSON.stringify(event)}\n`);
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        try {
+            if (opts.local)
+                await watchLocalFeed({ scope: machineId(), signal: controller.signal, emit });
+            else
+                await watchFleetFeed({ signal: controller.signal, emit });
+        }
+        finally {
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+        }
+    });
+}

package/dist/commands/feed.js

@@ -13,6 +13,8 @@ import { relTime } from '../lib/format.js';
 import { gatherRemoteAgentsJson } from '../lib/remote-agents-json.js';
 import { loadPolicy, applyPolicyToBlock, isPhoneUrgent } from '../lib/feed-policy.js';
 import { notifyUrgentBlock } from '../lib/notify.js';
+import { registerFeedWatchCommand } from './feed-watch.js';
+import { claimAndRouteAttentionAnswer, forwardFeedAnswer } from '../lib/feed/answer.js';
 import { gcMailbox } from '../lib/mailbox-gc.js';
 import { isValidMailboxId } from '../lib/mailbox.js';
 import { getActiveSessions } from '../lib/session/active.js';
@@ -323,6 +325,31 @@ export function registerFeedCommand(program) {
         .option('--dispatch', 'Run stall suppression + default-on-no-answer policy and urgent notifications')
         .option('--pause <id>', 'Pause a runaway/needy local process (SIGSTOP) or cancel a cloud task')
         .option('--kill <id>', 'Kill a runaway/needy local process (SIGTERM) or cancel a cloud task');
+    registerFeedWatchCommand(feed);
+    feed.command('answer <attention-key>')
+        .description('Atomically claim and deliver one answer to an open attention item')
+        .option('--choice <choice-id>', 'Stable choice id from the attention item')
+        .option('--text <answer>', 'Free-text answer')
+        .option('--as <operator>', 'Verified operator id for high-consequence answers')
+        .option('--json', 'Emit the delivery result as JSON')
+        .action(async (attentionKey, opts, invoked) => {
+        try {
+            const ownerHost = attentionKey.slice(0, attentionKey.indexOf('/'));
+            const result = ownerHost && ownerHost !== machineId()
+                ? await forwardFeedAnswer({ host: ownerHost, attentionKey, choiceId: opts.choice, text: opts.text, operatorId: opts.as })
+                : await claimAndRouteAttentionAnswer({
+                    attentionKey, choiceId: opts.choice, text: opts.text,
+                    operator: { id: opts.as, verified: Boolean(opts.as), label: opts.as },
+                });
+            if (opts.json || invoked.parent?.opts()?.json)
+                console.log(JSON.stringify(result));
+            else
+                console.log(result.status === 'delivered' ? `Delivered ${result.receipt.msgId}.` : `Already answered (${result.receipt.at}).`);
+        }
+        catch (error) {
+            invoked.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
     feed
         .command('post')
         .description('Post a status update to the fleet activity stream (for agents)')

package/dist/commands/feedback.js

@@ -3,10 +3,10 @@
  * pre-filled with version + OS + agent inventory; falls back to printing the
  * URL when no browser is available.
  */
-import { spawnSync } from 'node:child_process';
 import { arch, platform, release } from 'node:os';
 import { createRequire } from 'node:module';
 import chalk from 'chalk';
+import { showUrl } from '../lib/open-url.js';
 const REPO = 'phnx-labs/agents-cli';
 const DISCUSSION_BASE = `https://github.com/${REPO}/discussions/new`;
 const ISSUE_BASE = `https://github.com/${REPO}/issues/new`;
@@ -20,22 +20,6 @@ function readCliVersion() {
         return 'unknown';
     }
 }
-function openInBrowser(url) {
-    const openers = process.platform === 'darwin'
-        ? [['open', [url]]]
-        : process.platform === 'win32'
-            ? [['cmd', ['/c', 'start', '""', url]]]
-            : [
-                ['xdg-open', [url]],
-                ['gnome-open', [url]]
-            ];
-    for (const [cmd, args] of openers) {
-        const r = spawnSync(cmd, args, { stdio: 'ignore' });
-        if (r.status === 0)
-            return true;
-    }
-    return false;
-}
 function buildPrefill(kind, summary) {
     const version = readCliVersion();
     const os = `${platform()} ${release()} (${arch()})`;
@@ -69,7 +53,7 @@ export function registerFeedbackCommand(program) {
         .option('-i, --idea', 'File as a feature idea (Discussions → Ideas)')
         .option('-q, --question', 'Ask a question (Discussions → Q&A)')
         .option('--print', 'Print the URL instead of opening it')
-        .action((summary, opts) => {
+        .action(async (summary, opts) => {
         const kind = opts.bug ? 'bug' : opts.idea ? 'idea' : 'question';
         const summaryText = (summary ?? []).join(' ').trim();
         const { url } = buildPrefill(kind, summaryText);
@@ -77,7 +61,7 @@ export function registerFeedbackCommand(program) {
             console.log(url);
             return;
         }
-        const opened = openInBrowser(url);
+        const opened = (await showUrl(url)).via !== 'none';
         if (opened) {
             console.log(chalk.dim(`Opened ${kind} form in your browser:\n  ${url}`));
         }

package/dist/commands/focus.d.ts

@@ -20,6 +20,19 @@ import { type LiveStatusFilter } from './sessions.js';
 import { openSurfaces, type Backend } from '../lib/terminal/index.js';
 /** Options for `sessions focus` — device scope + the `--active` live-state filters. */
 export interface FocusOptions {
+    /**
+     * Resolve the target from the launcher's AGENT_LAUNCH_ID instead of a session
+     * id (RUSH-3125).
+     *
+     * A `--device` launcher mints this id BEFORE it opens the connection and
+     * forwards it, so it is the one handle that is still known after the link
+     * dies. A session id is not: only Claude is handed one up front, and every
+     * other harness's real id had to be read back off the peer — over the very
+     * link that just dropped — which is why a blink left a Grok or Codex tab with
+     * nothing to reconnect to. The lookup runs HERE, on the box that owns the hook
+     * records, so it needs no network at the moment it is needed most.
+     */
+    launchId?: string;
     local?: boolean;
     attachOnly?: boolean;
     device?: string[];
@@ -54,6 +67,7 @@ export interface FocusOptions {
     abandoned?: boolean;
     queued?: boolean;
     unknown?: boolean;
+    reconnectReattach?: boolean;
 }
 /** Commander gives overlapping `sessions` flags to the parent command, even
  * when they appear after `focus`. Fold only values explicitly provided there

package/dist/commands/focus.js

@@ -80,8 +80,10 @@ export function registerFocusCommand(program) {
         // console.warn here without first removing that delegation.
         .command('focus', { hidden: true })
         .argument('[selector]', 'Session id/prefix, agent@version, or topic/path search')
+        .option('--launch-id <id>', 'Target the run by its launcher AGENT_LAUNCH_ID instead of a session id (resolved from this machine\'s hook records)')
         .option('--local', 'Only this machine (skip the cross-host sweep)')
         .option('--attach-only', 'Attach only — never open a new tab / resume a copy (the old `go` behavior)')
+        .option('--reconnect-reattach', '(internal) Set by the reconnect loop — warns when the expected pane is dead and a fresh copy starts instead', false)
         .option('-D, --device <target...>', 'Scope the picker to live sessions on these devices (device alias from `agents devices`, user@host; repeatable)')
         .option('--active', 'Only sessions present in the live roster')
         .option('-a, --agent <agent>', 'Filter by harness and recorded version (for example claude@latest)')
@@ -162,6 +164,38 @@ export function selectFallback(attachOnly) {
     return attachOnly ? refuseFallback : resumeInNewTab;
 }
 export async function focusAction(id, opts) {
+    // RUSH-3125: `--launch-id` names the run by the handle its launcher minted,
+    // and this box holds the hook record that maps it to the real session id — a
+    // local read, so it still works when the network that started the run is gone.
+    // Resolved up front into the ordinary id path: everything below, including the
+    // attach-else-resume recovery, is identical once we know which session it is.
+    if (opts.launchId) {
+        if (id) {
+            console.error(chalk.red('Pass a session id or --launch-id, not both — they name the same thing two ways.'));
+            process.exitCode = 1;
+            return;
+        }
+        // Read the launch-id index directly rather than through
+        // `resolveHookSessionRecord`: that helper kind-guards every hit, which exists
+        // to stop a REUSED PID crossing harnesses. A launch id is a per-launch uuid
+        // and cannot collide, and the caller here is a reattach that deliberately
+        // does not assume which harness the peer picked (`run auto` chooses it
+        // remotely), so demanding a kind would reject the exact case this serves.
+        const { loadHookSessionIndex } = await import('../lib/session/hook-sessions.js');
+        const resolved = loadHookSessionIndex().byLaunchId.get(opts.launchId)?.session_id;
+        if (!resolved) {
+            // Fail loud: a launch id with no record means the harness never got far
+            // enough to write one (it died at startup, or it has no SessionStart
+            // hook). Silently opening the picker here would strand an automated
+            // reattach in an interactive prompt nobody is watching.
+            console.error(chalk.red(`No session recorded for launch id ${opts.launchId} on ${machineId()}.`));
+            console.error(chalk.gray('  The run may have failed before its SessionStart hook fired.'));
+            console.error(chalk.gray('  Look for it:  agents sessions --active'));
+            process.exitCode = 1;
+            return;
+        }
+        id = resolved;
+    }
     const hosts = mergeFocusHosts(opts);
     const statuses = requestedLiveStatuses(opts);
     // A device scope needs the cross-host sweep; --local only wins when no host is named.
@@ -204,7 +238,7 @@ export async function focusAction(id, opts) {
                 // still joined instead of resumed as a copy; a crashed session has no live
                 // row and recovers in place.
                 const { activeById } = await gatherLiveTargets(true, { statuses: [] });
-                await focusResolvedSession(localMatch[0], activeById, self, fallback, opts.attachOnly === true);
+                await focusResolvedSession(localMatch[0], activeById, self, fallback, opts.attachOnly === true, opts.reconnectReattach === true);
                 return;
             }
         }
@@ -290,7 +324,7 @@ export async function focusAction(id, opts) {
             exact = [focusTargetForResolved(filteredMatch, outcome.session)];
         }
         if (exact.length === 1) {
-            await focusResolvedSession(exact[0], liveById, self, fallback, opts.attachOnly === true);
+            await focusResolvedSession(exact[0], liveById, self, fallback, opts.attachOnly === true, opts.reconnectReattach === true);
             return;
         }
         if (exact.length > 1) {
@@ -524,7 +558,7 @@ async function pickFocusCandidates(sessions, liveById, initialSearch) {
 export function focusTargetForResolved(poolMatch, resolved) {
     return poolMatch ?? resolved;
 }
-async function focusResolvedSession(meta, liveById, self, fallback, attachOnly) {
+async function focusResolvedSession(meta, liveById, self, fallback, attachOnly, reconnectReattach = false) {
     const active = liveById.get(meta.id);
     if (active && isAttachableLiveSession(active)) {
         await jumpTo(active, self, fallback);
@@ -535,10 +569,19 @@ async function focusResolvedSession(meta, liveById, self, fallback, attachOnly)
         process.exitCode = 1;
         return;
     }
+    if (reconnectReattach) {
+        // The reconnect loop expected this pane to be alive. It isn't — the peer
+        // rebooted, tmux crashed, or the agent exited while the link was down.
+        // Warn before any recovery attempt (local resume OR remote hop) so the
+        // user always knows their original context was not directly recovered.
+        console.error(chalk.yellow(`\nWarning: ${meta.shortId}'s pane is gone (reboot, tmux crash, or agent exited).`));
+        console.error(chalk.gray(`  Prior context is in the transcript — starting recovery.\n` +
+            `  To see what happened: agents sessions preview ${meta.shortId}`));
+    }
     const remote = sessionProcessHost(meta, self);
     if (remote) {
         console.log(chalk.gray(`Recovering ${meta.shortId} on ${remote}…`));
-        const rc = await runOnPeer(sessionRecoveryRunArgs(meta), remote, { tty: true });
+        const rc = await runOnPeer(sessionRecoveryRunArgs(meta), remote, { tty: true, sessionId: meta.id });
         if (rc === 'no-target') {
             console.error(chalk.red(`Cannot recover ${meta.shortId}: ${remote} is unreachable.`));
             process.exitCode = 1;
@@ -765,7 +808,7 @@ const resumeInNewTab = async (s, remote) => {
     // it actually delivers you to the session (the peer picks the right version + HOME).
     if (remote) {
         console.log(chalk.gray(`${shortId(s)} has no live terminal on ${remote} — resuming it there over SSH…`));
-        const rc = await runOnPeer(sessionRecoveryRunArgs({ id }), remote, { tty: true });
+        const rc = await runOnPeer(sessionRecoveryRunArgs({ id }), remote, { tty: true, sessionId: id });
         if (rc === 'no-target') {
             console.log(chalk.red(`${remote} isn't reachable as a device. Try: agents devices sync`));
             console.log(chalk.gray(`  recovery must run on ${remote}, where the indexed session originated`));

package/dist/commands/go.d.ts

@@ -66,6 +66,9 @@ export interface Where {
     label: string;
     action: string;
 }
+/** What `jumpTo` writes after a remote tmux attach's SSH stream returns. Pure so
+ *  the ControlMaster close path is unit-tested without SSH (RUSH-3227). */
+export declare function remoteAttachEndedNotice(sessionId: string | undefined, host: string, code: number): string | undefined;
 /**
  * Pure, testable mirror of `jumpTo`'s path selection (jumpTo itself has side
  * effects — process.exit / ssh / osascript). Keep the branch ORDER in sync with