@phnx-labs/agents-cli 1.22.22 → 1.22.24

package/dist/commands/doctor.js

@@ -848,6 +848,11 @@ function renderTargetText(report, options) {
         // sees what was checked. options.requestedKinds drives this.
         if (options.requestedKinds && !options.requestedKinds.has(kind))
             continue;
+        if (kind === 'hooks' && report.hookInventory) {
+            const wired = report.hookInventory.wiringSupported ? String(report.hookInventory.wired.length) : 'unknown';
+            const unmanaged = report.hookInventory.unmanaged.length > 0 ? ` · unmanaged ${report.hookInventory.unmanaged.length}` : '';
+            console.log(chalk.gray(`  inventory: capable ${report.hookInventory.capable ? 'yes' : 'no'} · on-disk ${report.hookInventory.onDisk.length} · wired ${wired}${unmanaged}`));
+        }
         renderKindSection(kind, rows, report.layers, options);
         // A hook file can reconcile "ok" above yet be absent from settings.json — a
         // present-but-dead hook. Surface that right under the hooks section.
@@ -1022,10 +1027,13 @@ function runCheckGate(opts, cwd) {
         const orphanNote = drift.orphanVersionCount > 0
             ? chalk.gray(` (${drift.orphanVersionCount} version(s) carry orphans — run \`agents prune cleanup\`)`)
             : '';
-        console.log(`${chalk.green('ok')}  ${drift.syncRows.length} version(s) in sync${orphanNote}`);
+        console.log(`${chalk.gray('check:')} ${chalk.green('ok')} — ${drift.syncRows.length} version(s) in sync${orphanNote}`);
         process.exit(0);
     }
-    // Drift: one-line verdict always, per-version detail unless --quiet.
+    // Drift: one-line verdict always, per-version detail unless --quiet. The
+    // `check:` prefix and total count make every verdict line grep/parse-alike
+    // whether it's clean or drifted, instead of the bare `drift  <parts>` shape
+    // that gave CI logs no anchor to search on.
     const parts = [];
     if (drift.staleCount > 0)
         parts.push(`${drift.staleCount} stale`);
@@ -1035,16 +1043,21 @@ function runCheckGate(opts, cwd) {
         parts.push(`${drift.unwiredHookVersions} with unwired hooks`);
     if (drift.sourceBehind.length > 0)
         parts.push(`${drift.sourceBehind.length} source layer(s) behind origin`);
-    console.error(`${chalk.red('drift')}  ${parts.join(', ')}`);
+    console.error(`${chalk.gray('check:')} ${chalk.red('drift')} — ${parts.join(', ')} across ${drift.syncRows.length} version(s)`);
     if (!opts.quiet) {
+        // Fixed-width, left-aligned so rows form a real column; the badge text is
+        // the actual status name ('never-synced'), not the unrelated 'cold' label
+        // that used to hide it. Width is 'never-synced'.length + a 2-space gap so
+        // the longest badge still separates cleanly from the label that follows.
+        const STATUS_BADGE_WIDTH = 'never-synced'.length + 2;
         for (const row of drift.syncRows) {
             const unwired = (row.unwiredHooks ?? 0) > 0;
             if (row.status === 'fresh' && !unwired)
                 continue;
-            const tag = row.status === 'stale' ? chalk.yellow('stale')
-                : row.status === 'never-synced' ? chalk.gray('cold ')
-                    : chalk.red('unwired'); // fresh but hooks not wired into settings.json
-            console.error(`  ${tag}  ${checkLabel(row)}`);
+            const tag = row.status === 'stale' ? chalk.yellow('stale'.padEnd(STATUS_BADGE_WIDTH))
+                : row.status === 'never-synced' ? chalk.gray('never-synced'.padEnd(STATUS_BADGE_WIDTH))
+                    : chalk.red('unwired'.padEnd(STATUS_BADGE_WIDTH)); // fresh but hooks not wired into settings.json
+            console.error(`  ${tag}${checkLabel(row)}`);
             for (const line of row.divergence ?? []) {
                 console.error(chalk.gray(`           ${line}`));
             }

package/dist/commands/exec.js

@@ -516,7 +516,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.')
-        .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). \'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 (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('-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], [])
@@ -532,7 +532,7 @@ export function registerRunCommand(program) {
         .option('--headless', 'Force headless mode. Auto-enabled when a prompt is provided; pass explicitly to stay headless with no prompt (reads the prompt from stdin).', false)
         .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('--resume [id]', 'Resume a previous conversation. Full IDs resolve locally first, then fleet-wide. Claude, Codex, Grok, Kimi, Droid, and Cursor use version-gated native resume; other agents replay via /continue. Pair with a prompt to continue headlessly.')
+        .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('--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.')
         .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 --host 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).')
@@ -647,12 +647,14 @@ export function registerRunCommand(program) {
       agents run claude "fix the bug" -- --custom-flag
     `,
         notes: `
-      Modes (not every agent supports every mode — check agents.yaml capabilities):
+      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)
         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
+        Models (cheap|default|best|ultra): agents models <agent[@version]>
 
       Headless plan support (a prompt makes the run headless):
         plan works headless on claude, codex, droid, opencode.
@@ -689,7 +691,7 @@ export function registerRunCommand(program) {
         given. --cloud is mutually exclusive with --host/--lease and with
         local-run flags (--loop, --resume, --secrets, --terminal, …).
 
-      Resume: --resume <id> resolves full IDs locally first, then fleet-wide, and restores the source version/device/mode. Claude, Codex, Grok, Kimi, Droid, and Cursor use version-gated native resume; others replay via /continue. agents 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. The exact healthy origin version uses native resume; otherwise a healthy version of the same harness replays via /continue. agents 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
@@ -835,6 +837,7 @@ export function registerRunCommand(program) {
         }
         let autoHarnessRequested = normalizedAgentSpec === RUN_AUTO_KEYWORD;
         let resolvedResumeSource;
+        let resolvedRecoveryTarget;
         // Concrete resume ids resolve BEFORE placement. Full UUIDs take the local
         // SQLite fast path; only a local miss fans out to the fleet. This lets a
         // command entered on zion discover that the owning version-home is on a
@@ -882,38 +885,48 @@ export function registerRunCommand(program) {
             // the normal new-run default as a real value, so consult its provenance
             // rather than mistaking the default for an explicit override.
             if (command.getOptionValueSource('mode') === 'default') {
-                if (resolvedResumeSource.mode)
+                if (resolvedResumeSource.mode) {
                     options.mode = resolvedResumeSource.mode;
+                    command.setOptionValueWithSource('mode', resolvedResumeSource.mode, 'implied');
+                }
                 else if (!options.quiet)
                     process.stderr.write(chalk.yellow(`[agents] session ${resolvedResumeSource.shortId} predates stored launch modes; using --mode ${options.mode}\n`));
             }
             const { machineId } = await import('../lib/machine-id.js');
+            const { sessionRecoveryDestinationMatches, sessionRecoveryPeer, } = await import('../lib/session/recovery.js');
             const sourceMachine = resolvedResumeSource.machine;
+            const sourcePeer = sessionRecoveryPeer(resolvedResumeSource);
             const explicitPlacement = hostTargetGiven(options).length > 0;
-            if (sourceMachine && sourceMachine !== machineId() && !explicitPlacement) {
-                options.host = sourceMachine;
+            if (sourcePeer && !explicitPlacement) {
+                options.host = sourcePeer;
             }
-            else if (!autoHarnessRequested && sourceMachine && sourceMachine !== machineId() && explicitPlacement && !hostTargetGiven(options).includes(sourceMachine)) {
-                console.error(chalk.red(`Strict resume must run on ${sourceMachine}, where session ${resolvedResumeSource.shortId} is owned. ` +
-                    `Use agents run auto --resume ${resolvedResumeSource.id} to hand off elsewhere.`));
+            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; ` +
+                    `the requested device was ${hostTargetGiven(options).join(', ')}.`));
                 process.exit(1);
             }
-            // On the owning machine, `auto` first asks the existing account router
-            // whether the exact source version is healthy. If it is, native resume
-            // wins. If not, keep `auto` so the normal harness/account router selects
-            // a healthy local target and the later resume block performs /continue.
-            if (autoHarnessRequested && (!sourceMachine || sourceMachine === machineId())) {
-                const sourceAgent = resolvedResumeSource.agent;
-                if (sourceAgent in AGENTS && resolvedResumeSource.version) {
-                    const { resolveRunVersion } = await import('../lib/rotate.js');
-                    const health = await resolveRunVersion(sourceAgent, 'available', resolvedResumeSource.cwd ?? process.cwd());
-                    if (!health.exhausted && health.version === resolvedResumeSource.version) {
-                        normalizedAgentSpec = `${sourceAgent}@${resolvedResumeSource.version}`;
-                        autoHarnessRequested = false;
-                        if (!options.quiet)
-                            process.stderr.write(chalk.gray(`[agents] auto resume → native ${normalizedAgentSpec} on ${sourceMachine ?? machineId()}\n`));
-                    }
+            // Recovery is resolved on the device that owns the transcript. A remote
+            // dispatch is pinned to the source HARNESS (not `run auto`'s cross-harness
+            // picker); the peer repeats this block with the injected SessionMeta and
+            // chooses its own healthy version. Locally, resolve it now.
+            const sourceAgent = resolvedResumeSource.agent;
+            if (!sourcePeer) {
+                try {
+                    const { resolveSessionRecovery } = await import('../lib/session/recovery.js');
+                    resolvedRecoveryTarget = await resolveSessionRecovery(resolvedResumeSource);
                 }
+                catch (err) {
+                    console.error(chalk.red(err.message));
+                    process.exit(1);
+                }
+                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`));
+            }
+            else if (autoHarnessRequested) {
+                normalizedAgentSpec = sourceAgent;
+                autoHarnessRequested = false;
             }
         }
         if (autoHarnessRequested) {
@@ -1540,13 +1553,15 @@ export function registerRunCommand(program) {
                         });
                     }
                     const isRaw = options.raw || options.tmux === false || options.disableTmux === true;
+                    const { modeForRemoteDispatch } = await import('../lib/codex-policy.js');
+                    const forwardedMode = modeForRemoteDispatch(options.mode, command.getOptionValueSource('mode'));
                     const exitCode = await runInteractiveOnHost(host, {
                         agent: runAgent,
                         version: resumeId ? undefined : runVersion,
                         strategy: resumeId ? undefined : runStrategy,
                         fallback: options.fallback,
                         prompt,
-                        mode: options.mode,
+                        mode: forwardedMode,
                         model: options.model,
                         effort: options.effort,
                         env: hostEnv,
@@ -1625,13 +1640,15 @@ export function registerRunCommand(program) {
                 }
                 // Session-id mint, detached dispatch, and local session-index
                 // registration all live in the shared helper (lib/hosts/run-target.ts).
+                const { modeForRemoteDispatch } = await import('../lib/codex-policy.js');
+                const forwardedMode = modeForRemoteDispatch(options.mode, command.getOptionValueSource('mode'));
                 const { task, exitCode } = await dispatchPromptToHost(host, {
                     agent: runAgent,
                     version: resumeId ? undefined : runVersion,
                     strategy: resumeId ? undefined : runStrategy,
                     fallback: options.fallback,
                     prompt,
-                    mode: options.mode,
+                    mode: forwardedMode,
                     model: options.model,
                     effort: options.effort,
                     env: options.env,
@@ -1770,7 +1787,7 @@ export function registerRunCommand(program) {
                 await warnUnpushedWork(resumeExec.cwd ?? process.cwd());
             process.exit(resumeExit);
         }
-        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, headlessPlanStallCommand, nativeResume, resolveInteractive, inferredInteractiveWithoutTty }, { ALL_AGENT_IDS, ACCOUNT_INSPECTION_AGENT_IDS, agentLabel, supportsAccountInspection }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle, assertRemoteBundleFlagsUnsupported }, { splitBundleRef, resolveHostSshTarget, remoteResolveEnv }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, rotationFailoverChain, shouldArmRotationFailover, RUN_STRATEGIES, collectHarnessCandidates, pickHarnessWeighted, classifyHarnessCandidates, formatHarnessPickBanner, formatNoHealthyHarnessError, formatNoHealthyAccountError }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias, ensureAgentRunnable }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef, resolveAllowedSubagents, pruneStaleWorkflowSubagents, ensureSubagentDispatchTool }, { resolveRunDefaults }, { getMcpServersByName, buildWorkflowMcpConfig }, { supports, capableAgents }, { shareRuntimeEnv },] = await Promise.all([
+        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, implicitModeFor, headlessPlanStallCommand, nativeResume, resolveInteractive, inferredInteractiveWithoutTty }, { ALL_AGENT_IDS, ACCOUNT_INSPECTION_AGENT_IDS, agentLabel, supportsAccountInspection }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle, assertRemoteBundleFlagsUnsupported }, { splitBundleRef, resolveHostSshTarget, remoteResolveEnv }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, rotationFailoverChain, shouldArmRotationFailover, RUN_STRATEGIES, collectHarnessCandidates, pickHarnessWeighted, classifyHarnessCandidates, formatHarnessPickBanner, formatNoHealthyHarnessError, formatNoHealthyAccountError }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias, ensureAgentRunnable }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef, resolveAllowedSubagents, pruneStaleWorkflowSubagents, ensureSubagentDispatchTool }, { resolveRunDefaults }, { getMcpServersByName, buildWorkflowMcpConfig }, { supports, capableAgents }, { shareRuntimeEnv },] = await Promise.all([
             import('../lib/exec.js'),
             import('../lib/agents.js'),
             import('../lib/profiles.js'),
@@ -2211,10 +2228,44 @@ export function registerRunCommand(program) {
                 session = picked.session;
                 forceInteractive = true; // bare resume always lands in the agent's TUI
             }
-            // Native resume is valid only for the source harness + exact isolated
-            // version. `auto` may have selected another healthy harness/account; in
-            // that case keep the target version and hand off through /continue.
-            const canResumeNatively = session.agent === agent && nativeResume(agent, session.version);
+            // 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 });
+                    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);
+                }
+            }
+            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;
+            const canResumeNatively = resolvedRecoveryTarget.mode === 'native';
             if (canResumeNatively) {
                 version = session.version;
                 resumeNative = true;
@@ -2324,6 +2375,12 @@ export function registerRunCommand(program) {
                     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
@@ -2407,7 +2464,14 @@ export function registerRunCommand(program) {
         // `skip` still hard-fails when unsupported — pretending we bypassed
         // permissions would be unsafe.
         const modeIsDefault = modeSource === 'default';
-        const requestedMode = normalizeMode(mode);
+        let requestedMode = normalizeMode(mode);
+        // Codex's intrinsic omitted-mode default is safe writable: workspace plus
+        // common caches, network enabled, approvals on request. An explicit
+        // --mode plan and a configured run default remain read-only.
+        const { modeWasImplicit } = await import('../lib/codex-policy.js');
+        const wasModeImplicit = modeWasImplicit(modeSource, modeFromRunDefault);
+        if (wasModeImplicit)
+            requestedMode = implicitModeFor(agent);
         let resolvedMode;
         try {
             resolvedMode = resolveMode(agent, requestedMode);
@@ -2434,7 +2498,8 @@ export function registerRunCommand(program) {
             console.error(chalk.gray(`Pass --mode plan explicitly if you really want a read-only run.`));
             process.exit(1);
         }
-        const effort = options.effort;
+        const effortSource = runCmd.getOptionValueSource('effort');
+        const effort = (effortSource === 'default' && runDefaults.effort ? runDefaults.effort : options.effort);
         if (!['low', 'medium', 'high', 'xhigh', 'max', 'auto'].includes(effort)) {
             console.error(chalk.red(`Invalid effort: ${effort}. Use 'low', 'medium', 'high', 'xhigh', 'max', or 'auto'`));
             process.exit(1);
@@ -2531,6 +2596,7 @@ export function registerRunCommand(program) {
             prompt,
             interactive: options.interactive || forceInteractive,
             mode: requestedMode,
+            modeWasImplicit: wasModeImplicit,
             effort,
             cwd: options.cwd,
             model,

package/dist/commands/feed.d.ts

@@ -60,6 +60,24 @@ export declare function sessionHintsFromActive(sessions: Array<{
         slug?: string;
     };
 }>): SessionOutcomeHint[];
+/**
+ * True when a SQLite open/query failed because another writer holds the lock.
+ * better-sqlite3 surfaces this as message "database is locked" and/or code
+ * SQLITE_BUSY (RUSH-2006).
+ */
+export declare function isSqliteBusyError(err: unknown): boolean;
+/**
+ * Load session metas for feed outcome enrichment. The sessions index can be
+ * locked by a concurrent scanner/daemon — enrichment is best-effort, so a lock
+ * degrades to an empty list instead of crashing `agents feed` (RUSH-2006).
+ *
+ * `load` is injected so tests can throw a real lock-shaped error without
+ * mocking the session module.
+ */
+export declare function loadSessionMetasForFeedEnrichment<T>(load: () => Promise<T[]>): Promise<{
+    metas: T[];
+    skippedLock: boolean;
+}>;
 export declare function registerFeedCommand(program: Command): void;
 /** Feed view selector (RUSH-2015): decisions, progress, or both. */
 export type FeedFilter = 'needs' | 'updates' | 'all';

package/dist/commands/feed.js

@@ -253,6 +253,39 @@ export function sessionHintsFromActive(sessions) {
         project: s.cwd ? projectKeyFromCwd(s.cwd) : undefined,
     }));
 }
+/**
+ * True when a SQLite open/query failed because another writer holds the lock.
+ * better-sqlite3 surfaces this as message "database is locked" and/or code
+ * SQLITE_BUSY (RUSH-2006).
+ */
+export function isSqliteBusyError(err) {
+    if (err == null)
+        return false;
+    const msg = err instanceof Error ? err.message : String(err);
+    const code = typeof err === 'object' && err !== null && 'code' in err
+        ? String(err.code ?? '')
+        : '';
+    return /SQLITE_BUSY|database is locked/i.test(msg) || /SQLITE_BUSY/i.test(code);
+}
+/**
+ * Load session metas for feed outcome enrichment. The sessions index can be
+ * locked by a concurrent scanner/daemon — enrichment is best-effort, so a lock
+ * degrades to an empty list instead of crashing `agents feed` (RUSH-2006).
+ *
+ * `load` is injected so tests can throw a real lock-shaped error without
+ * mocking the session module.
+ */
+export async function loadSessionMetasForFeedEnrichment(load) {
+    try {
+        return { metas: await load(), skippedLock: false };
+    }
+    catch (err) {
+        if (isSqliteBusyError(err)) {
+            return { metas: [], skippedLock: true };
+        }
+        throw err;
+    }
+}
 export function registerFeedCommand(program) {
     const feed = program
         .command('feed')
@@ -446,7 +479,17 @@ export function registerFeedCommand(program) {
         if (includeLocal) {
             sessions = await getActiveSessions();
         }
-        const sessionMetas = includeLocal && sessions.length > 0 ? await discoverSessions({ all: true, limit: 5000 }) : [];
+        // discoverSessions touches sessions.db; under concurrent scan pressure it
+        // can throw SQLITE_BUSY. Outcome enrichment is best-effort — degrade with
+        // a warning rather than crash the whole feed (RUSH-2006).
+        let sessionMetas = [];
+        if (includeLocal && sessions.length > 0) {
+            const loaded = await loadSessionMetasForFeedEnrichment(() => discoverSessions({ all: true, limit: 5000 }));
+            if (loaded.skippedLock) {
+                console.error(chalk.yellow('Feed: session index is locked; skipping local outcome enrichment'));
+            }
+            sessionMetas = loaded.metas;
+        }
         const localSignals = buildSessionSignals(sessions, sessionMetas);
         if (opts.pause || opts.kill) {
             if (!includeLocal) {

package/dist/commands/focus.d.ts

@@ -13,9 +13,57 @@
  * why `--tmux`-wrapped launches are worth it for sessions you'll want back live.
  */
 import type { Command } from 'commander';
-import { type UnreachableFallback } from './go.js';
+import { probeAttachRail, type AttachRailLiveness, type UnreachableFallback } from './go.js';
 import type { ActiveSession } from '../lib/session/active.js';
-import type { SessionMeta } from '../lib/session/types.js';
+import { type SessionMeta } from '../lib/session/types.js';
+import { type LiveStatusFilter } from './sessions.js';
+import { openSurfaces, type Backend } from '../lib/terminal/index.js';
+/** Options for `sessions focus` — device/host scope + the `--active` live-state filters. */
+export interface FocusOptions {
+    local?: boolean;
+    attachOnly?: boolean;
+    host?: string[];
+    device?: string[];
+    active?: boolean;
+    agent?: string;
+    claude?: boolean;
+    codex?: boolean;
+    kimi?: boolean;
+    antigravity?: boolean;
+    grok?: boolean;
+    opencode?: boolean;
+    all?: boolean;
+    teams?: boolean;
+    inTeam?: string;
+    routine?: boolean;
+    project?: string;
+    skill?: string;
+    plugin?: string;
+    since?: string;
+    until?: string;
+    limit?: string;
+    favorites?: boolean;
+    unmanaged?: boolean;
+    sort?: string;
+    working?: boolean;
+    idle?: boolean;
+    waiting?: boolean;
+    orphan?: boolean;
+    orphaned?: boolean;
+    crashed?: boolean;
+    closed?: boolean;
+    abandoned?: boolean;
+    queued?: boolean;
+    unknown?: boolean;
+}
+/** Commander gives overlapping `sessions` flags to the parent command, even
+ * when they appear after `focus`. Fold only values explicitly provided there
+ * into the child options; child defaults (limit/sort) otherwise stay intact. */
+export declare function inheritFocusOptions(child: FocusOptions, parent?: Command): FocusOptions;
+/** `--device` is an alias of `--host`; both are repeatable. Merge into one host list. */
+export declare function mergeFocusHosts(opts: FocusOptions): string[];
+/** Picker header that reflects the active filter + device, e.g. "Focus orphaned sessions on yosemite-s0:". */
+export declare function focusHeader(statuses: LiveStatusFilter[], hosts: string[]): string;
 export declare function registerFocusCommand(program: Command): void;
 /**
  * Which fallback fires when a session has no attach rail. `--attach-only` (the old
@@ -23,9 +71,64 @@ export declare function registerFocusCommand(program: Command): void;
  * without touching `jumpTo`'s side effects.
  */
 export declare function selectFallback(attachOnly: boolean | undefined): UnreachableFallback;
-export declare function focusAction(id: string | undefined, opts: {
-    local?: boolean;
+export declare function focusAction(id: string | undefined, opts: FocusOptions): Promise<void>;
+/** A retained pane is not attachable merely because tmux can still display it. */
+export declare function isAttachableLiveSession(session: ActiveSession): boolean;
+/**
+ * How a single selected live session opens in its new tab.
+ *  - `attach` — a live tmux pane joined in the tab (a second client, no fork),
+ *    local (`sh -c`) or remote (`ssh -tt`). tmux is the only rail that can be
+ *    *joined* without forking (see the file header).
+ *  - `resume` — no attach rail, so resume a copy in the tab (the original keeps
+ *    running); never a silent drop.
+ *  - `skip` — not resumable AND no rail: reported, not dropped.
+ */
+export type FocusSurfacePlan = {
+    kind: 'attach';
+    command: string[];
+    note: string;
+} | {
+    kind: 'resume';
+    command: string[];
+    note: string;
+} | {
+    kind: 'skip';
+    note: string;
+};
+/**
+ * Shell that resolves a tmux pane to its session and attaches it — the exact form
+ * `jumpTo` uses, minus the pre-select-window nicety, so a batch tab joins the live
+ * session (a second client) without forking. Reused for local and (wrapped in ssh)
+ * remote panes.
+ */
+export declare function tmuxAttachScript(mux: {
+    socket?: string;
+    pane: string;
+}): string;
+/**
+ * Decide how one live session opens as a tab. Pure over the session + a
+ * `resumeCommandFor` resolver (injected so the local version-pinned resume command
+ * and the tests stay decoupled from `discoverSessions`).
+ */
+export declare function planFocusSurface(s: ActiveSession, self: string, resumeCommandFor: (s: ActiveSession) => string[] | null, rail?: AttachRailLiveness): FocusSurfacePlan;
+/** The engine seam — real `openSurfaces`, overridable in tests to assert the tab requests. */
+export type OpenSurfacesFn = typeof openSurfaces;
+/** Test seams for `openFocusTabs`: inject the engine boundary + force a backend. */
+export interface OpenFocusTabsDeps {
+    open?: OpenSurfacesFn;
+    /** Skip `resolveBackend` (which needs a live terminal) when set — tests pass 'tmux'. */
+    backend?: Backend | 'inplace';
+    /** Rich rows selected by the shared browser pipeline (including remote history). */
+    metas?: SessionMeta[];
+    /** Liveness boundary; production probes tmux, tests exercise planning deterministically. */
+    probe?: typeof probeAttachRail;
+    /** Strict focus mode: open living attach rails only; never recover a copy. */
     attachOnly?: boolean;
-}): Promise<void>;
+}
+/**
+ * Open each selected live session as a tab: attach its live pane where one exists,
+ * else resume a copy. Reuses `resume`'s backend resolution + flood guard.
+ */
+export declare function openFocusTabs(targets: ActiveSession[], self: string, deps?: OpenFocusTabsDeps): Promise<void>;
 /** Minimal SessionMeta for a live session, enough for `buildResumeCommand` + placement. */
 export declare function metaFromActive(s: ActiveSession): SessionMeta;