@phnx-labs/agents-cli 1.22.24 → 1.22.26

package/dist/commands/routines.js

@@ -12,7 +12,7 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemonLog, getDaemonStatus, } from '../lib/daemon.js';
 import { assertSchedulerEnabled } from '../lib/device-config.js';
-import { resolveAgentName, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
+import { resolveAgentName, isAgentHardDeprecated, hardDeprecationError, ROUTINE_AGENT_IDS } from '../lib/agents.js';
 import { humanizeCron, humanizeNextRun, formatRepoLink, REPO_DISPLAY_MAX } from '../lib/routines-format.js';
 import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, routineStats, getLatestRun, getRunDir, getJobPath, parseAtTime, hasCompletedOneShotRun, isOneShotLikeSchedule, isOneShotRoutine, isPastOneShotRoutine, jobRunsOnThisDevice, checkJobDeviceEligibility, normalizeTriggerEvent, parseHostStrategy, resolveHostStrategy, HOST_STRATEGIES, computeProjectGroup, computeProjectGroupKind, projectGroupKey, projectGroupTitle, projectGroupOrder, normalizeProjects, } from '../lib/routines.js';
 import { listProjectDefs, isSafeProjectName } from '../lib/projects.js';
@@ -21,7 +21,7 @@ import { fireWebhookJobs, matchJobsToWebhook } from '../lib/triggers/webhook.js'
 import { getRoutinesDir } from '../lib/state.js';
 import { IS_WINDOWS } from '../lib/platform/index.js';
 import { safeJoin } from '../lib/paths.js';
-import { executeJob, monitorRunningJobs, ROUTINE_AGENT_IDS } from '../lib/runner.js';
+import { executeJob, monitorRunningJobs } from '../lib/runner.js';
 import { JobScheduler } from '../lib/scheduler.js';
 import { detectOverdueJobs } from '../lib/overdue.js';
 import { runCatchup } from '../lib/catchup.js';
@@ -405,6 +405,72 @@ function runMetaJson(run) {
 export function buildRunsJson(runs) {
     return runs.map(runMetaJson);
 }
+/** Build the exact structured routine rows shared by `routines list --json`
+ * and the one-process AGI Menu snapshot. */
+export function buildRoutineListJson() {
+    try {
+        monitorRunningJobs();
+    }
+    catch { /* best-effort orphan reap */ }
+    const jobs = listAllJobs(process.cwd());
+    if (jobs.length === 0)
+        return [];
+    const scheduler = new JobScheduler(async () => { });
+    scheduler.loadAll();
+    try {
+        const overdueSet = new Set();
+        try {
+            for (const job of detectOverdueJobs())
+                overdueSet.add(job.name);
+        }
+        catch {
+            // Best-effort indicator; never block the list on detection errors.
+        }
+        const now = new Date();
+        const knownProjectNames = new Set(listProjectDefs().map((project) => project.name));
+        return jobs.map((job) => {
+            const latestRun = localLatestRun(job);
+            const enabledDevices = devicesWithRoutineEnabled(job.name);
+            return {
+                name: job.name,
+                agent: job.agent ?? null,
+                workflow: job.workflow ?? null,
+                command: job.command ?? null,
+                repo: job.repo ?? null,
+                schedule: job.schedule ?? null,
+                scheduleHuman: fireConditionLabel(job),
+                trigger: job.trigger ?? null,
+                timezone: job.timezone ?? null,
+                devices: enabledDevices,
+                enabledDevices,
+                host: job.host ?? null,
+                hostStrategy: resolveHostStrategy(job),
+                source: job.source ?? null,
+                sourceRepo: job.source?.repo ?? job.repo ?? null,
+                sourceBranch: job.source?.branch ?? null,
+                runOnce: Boolean(job.runOnce),
+                catchup: job.catchup !== false,
+                oneShot: isOneShotRoutine(job),
+                expired: isPastOneShotRoutine(job, now),
+                runsHere: jobRunsOnThisDevice(job),
+                enabled: job.enabled,
+                overdue: overdueSet.has(job.name),
+                nextRun: nextRunForDisplay(job, scheduler)?.toISOString() ?? null,
+                nextRunHuman: nextRunLabel(job, scheduler, now),
+                lastStatus: latestRun?.status ?? null,
+                exitCode: latestRun?.exitCode ?? null,
+                failureReason: latestRun?.errorMessage ?? null,
+                lastRunStartedAt: latestRun?.startedAt ?? null,
+                lastRunCompletedAt: latestRun?.completedAt ?? null,
+                projects: job.projects ?? [],
+                projectGroup: computeProjectGroup(job.projects, knownProjectNames),
+            };
+        });
+    }
+    finally {
+        scheduler.stopAll();
+    }
+}
 /** Detect Ctrl+C or premature stream close during an interactive prompt. */
 function isPromptCancelled(err) {
     return (err instanceof Error &&
@@ -554,6 +620,10 @@ export function registerRoutinesCommands(program) {
             console.error(chalk.red(`Unsupported --group-by '${options.groupBy}'. Use: project (default) or device`));
             process.exit(1);
         }
+        if (options.json) {
+            process.stdout.write(JSON.stringify(buildRoutineListJson()) + '\n');
+            return;
+        }
         try {
             monitorRunningJobs();
         }
@@ -579,53 +649,6 @@ export function registerRoutinesCommands(program) {
         catch {
             // Best-effort indicator; never block the list on detection errors.
         }
-        // Machine-readable path: same data the table renders, but structured.
-        // The menu bar helper relies on this so it never reimplements cron math.
-        if (options.json) {
-            const nowJson = new Date();
-            const knownProjectNames = new Set(listProjectDefs().map((p) => p.name));
-            const payload = jobs.map((job) => {
-                const latestRun = localLatestRun(job);
-                const enabledDevices = devicesWithRoutineEnabled(job.name);
-                return {
-                    name: job.name,
-                    agent: job.agent ?? null,
-                    workflow: job.workflow ?? null,
-                    command: job.command ?? null,
-                    repo: job.repo ?? null,
-                    schedule: job.schedule ?? null,
-                    scheduleHuman: fireConditionLabel(job),
-                    trigger: job.trigger ?? null,
-                    timezone: job.timezone ?? null,
-                    devices: enabledDevices,
-                    enabledDevices,
-                    host: job.host ?? null,
-                    hostStrategy: resolveHostStrategy(job),
-                    source: job.source ?? null,
-                    sourceRepo: job.source?.repo ?? job.repo ?? null,
-                    sourceBranch: job.source?.branch ?? null,
-                    runOnce: Boolean(job.runOnce),
-                    catchup: job.catchup !== false,
-                    oneShot: isOneShotRoutine(job),
-                    expired: isPastOneShotRoutine(job, nowJson),
-                    runsHere: jobRunsOnThisDevice(job),
-                    enabled: job.enabled,
-                    overdue: overdueSet.has(job.name),
-                    nextRun: nextRunForDisplay(job, scheduler)?.toISOString() ?? null,
-                    nextRunHuman: nextRunLabel(job, scheduler, nowJson),
-                    lastStatus: latestRun?.status ?? null,
-                    exitCode: latestRun?.exitCode ?? null,
-                    failureReason: latestRun?.errorMessage ?? null,
-                    lastRunStartedAt: latestRun?.startedAt ?? null,
-                    lastRunCompletedAt: latestRun?.completedAt ?? null,
-                    projects: job.projects ?? [],
-                    projectGroup: computeProjectGroup(job.projects, knownProjectNames),
-                };
-            });
-            scheduler.stopAll();
-            process.stdout.write(JSON.stringify(payload) + '\n');
-            return;
-        }
         console.log(chalk.bold('Scheduled Jobs\n'));
         // OSC 8 hyperlink helper — renders as a clickable link in supporting terminals.
         // Guarded on process.stdout.isTTY so that piped/redirected output never

package/dist/commands/run-cloud.js

@@ -91,7 +91,7 @@ export function resolveRunCloudProvider(agentId, explicitProvider) {
         return resolveProvider(explicitProvider);
     if (!nativeProviderForAgent(agentId)) {
         throw new RunCloudError(`${agentId} has no native cloud. Cloud-capable agents: ${cloudCapableAgentIds().join(', ')}. ` +
-            `Override with --provider <id> (rush | codex | factory | antigravity | host).`);
+            `Override with --provider <id> (rush | codex | cursor | factory | antigravity | host).`);
     }
     return resolveProvider(undefined, agentId);
 }

package/dist/commands/secrets.d.ts

@@ -8,6 +8,8 @@
 import { type Command } from 'commander';
 import { SSH_TARGET_RE, assertValidSshTarget } from '../lib/ssh-exec.js';
 import { quoteWin32ExecArg } from '../lib/platform/index.js';
+import { bundleEnvToDotenv } from '../lib/secrets/push.js';
+export { bundleEnvToDotenv };
 import { type SecretsBackend, type SecretsBundle, type SecretsPolicy } from '../lib/secrets/bundles.js';
 import { type SecretsListFilterOpts } from '../lib/secrets/list-filter.js';
 import { type BundleUsageSummary } from '../lib/secrets/usage-db.js';
@@ -78,14 +80,6 @@ export { SSH_TARGET_RE, assertValidSshTarget };
  * the executed command.
  */
 export declare function buildSecretsExecEnv(parentEnv: NodeJS.ProcessEnv, secretEnv: Record<string, string>): NodeJS.ProcessEnv;
-/**
- * Serialize a resolved env map to `.env` lines that round-trip losslessly through
- * `parseDotenv` on the remote: `KEY="VALUE"`. parseDotenv strips exactly one outer
- * quote pair and takes the inner bytes verbatim (no unescaping), so any single-line
- * value survives unchanged with no escaping. Newlines would break its line-based
- * parse, so multi-line values are rejected rather than silently corrupted.
- */
-export declare function bundleEnvToDotenv(env: Record<string, string>): string;
 /**
  * Encrypt a resolved env map to an offline bundle file using AES-256-GCM
  * (the same EncFile envelope as the per-item file store). Inner plaintext is

package/dist/commands/secrets.js

@@ -12,12 +12,12 @@ import { terminalWidth, truncateToWidth, stringWidth } from '../lib/session/widt
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { SSH_TARGET_RE, assertValidSshTarget, sshExec } from '../lib/ssh-exec.js';
+import { SSH_TARGET_RE, assertValidSshTarget } from '../lib/ssh-exec.js';
 import { quoteWin32ExecArg, composeWin32CommandLine } from '../lib/platform/index.js';
 import { ensureDaemonStarted, isDaemonRunning } from '../lib/daemon.js';
-import { parseHostsOption, remoteResolveEnv, remoteSecretsRaw, remoteSecretsStream, resolveHostSshTarget, verifyRemoteKeychainPush, keychainWriteFailureMessage, buildRemoteFileImportCommand, } from '../lib/secrets/remote.js';
-import { remoteShellFor, buildWindowsStdinImportCommand } from '../lib/hosts/remote-cmd.js';
-import { resolveRemoteOsSync } from '../lib/hosts/remote-os.js';
+import { parseHostsOption, remoteResolveEnv, remoteSecretsRaw, remoteSecretsStream, resolveHostSshTarget, } from '../lib/secrets/remote.js';
+import { resolveBundleForPush, pushResolvedBundleToHost, bundleEnvToDotenv } from '../lib/secrets/push.js';
+export { bundleEnvToDotenv };
 import { bundleBackend, bundleExists, bundleItemStore, bundlePolicy, deleteBundle, describeBundle, keychainItemsForBundle, keychainRef, listBundles, healKeychainBundleMetadataAclOnce, isHeadlessSecretsContext, migrateLegacyBundles, parseDotenv, readAndResolveBundleEnv, readBundle, readBundleIfDecryptable, reAclBundleItems, renameBundle, rotateBundleSecret, sanitizeProcessEnv, validateBundleName, validateEnvKey, validateExpiresFutureDated, validateSecretType, writeBundle, writeBundleWithItems, SECRET_TYPES, } from '../lib/secrets/bundles.js';
 import { parseListFilters, bundleMatchesFilter, bundleExpiry, filterIsActive, describeFilter, parseSortField, sortBundles, SORT_FIELDS, REF_KINDS, DEFAULT_EXPIRING_DAYS, } from '../lib/secrets/list-filter.js';
 import { encryptForFallback, decryptForFallback } from '../lib/secrets/filestore.js';
@@ -354,24 +354,6 @@ function getCliVersion() {
         return '0.0.0';
     }
 }
-/**
- * Serialize a resolved env map to `.env` lines that round-trip losslessly through
- * `parseDotenv` on the remote: `KEY="VALUE"`. parseDotenv strips exactly one outer
- * quote pair and takes the inner bytes verbatim (no unescaping), so any single-line
- * value survives unchanged with no escaping. Newlines would break its line-based
- * parse, so multi-line values are rejected rather than silently corrupted.
- */
-export function bundleEnvToDotenv(env) {
-    const lines = [];
-    for (const [k, v] of Object.entries(env)) {
-        if (/[\r\n]/.test(v)) {
-            throw new Error(`Key '${k}' has a multi-line value; the SSH .env transport can't carry newlines. ` +
-                `Set it directly on the remote with 'agents secrets add ${k} --value-stdin'.`);
-        }
-        lines.push(`${k}="${v}"`);
-    }
-    return lines.join('\n') + '\n';
-}
 /**
  * Encrypt a resolved env map to an offline bundle file using AES-256-GCM
  * (the same EncFile envelope as the per-item file store). Inner plaintext is
@@ -2115,100 +2097,42 @@ Examples:
             if (hosts.length > 0) {
                 for (const h of hosts)
                     assertValidSshTarget(h);
-                const remoteBackend = parseBackendOpt(opts.remoteBackend);
+                const parsedBackend = parseBackendOpt(opts.remoteBackend);
+                // `--remote-backend` documents keychain|file only, and parseBackendOpt
+                // exits on anything else — but its return type still admits 'vault',
+                // which has no remote-push path. Refuse it here rather than let it fall
+                // through to the keychain branch and half-work.
+                if (parsedBackend === 'vault') {
+                    console.error(chalk.red("--remote-backend vault is not supported; use 'keychain' or 'file'."));
+                    process.exit(1);
+                }
+                const remoteBackend = parsedBackend;
                 // For a file-backed remote bundle a passphrase is OPTIONAL. The file
                 // store is passphrase-free by default: with AGENTS_SECRETS_PASSPHRASE
                 // unset the remote `import --backend file` auto-provisions the remote's
                 // own machine-local key (0600 under ~/.agents/.secrets-key/), so reads
                 // are HEADLESS. We forward the LOCAL AGENTS_SECRETS_PASSPHRASE only when
-                // the operator opts in by setting it (e.g. to key the bundle off-disk
-                // under a shared secret) — shipped as the FIRST stdin line so it never
-                // lands in argv / `ps` / the remote shell history. Forcing a shared
-                // passphrase would defeat headless reads, so we no longer require one.
+                // the operator opts in by setting it. Forcing a shared passphrase would
+                // defeat headless reads, so we no longer require one.
                 const remotePassphrase = remoteBackend === 'file' ? (process.env.AGENTS_SECRETS_PASSPHRASE ?? '') : '';
-                const { env } = readAndResolveBundleEnv(resolvedBundleName, { caller: `ssh export`, keyMode: 'storage', agentOnly: true });
-                const dotenv = bundleEnvToDotenv(env);
-                const keyCount = Object.keys(env).length;
-                // Drive the remote's own `agents secrets import --from -` so the values
-                // land in its chosen backend, reading the .env off ssh stdin (never
-                // parsed by a remote shell — `--from -` replaces the POSIX-only
-                // `/dev/stdin`). The keychain path is built OS-aware via
-                // `remoteSecretsRaw` (bash -lc on POSIX, PowerShell on Windows), so it
-                // works on macOS, Linux AND Windows targets. `import` auto-creates the
-                // bundle, so no separate `create` (the old `|| true` was a POSIXism
-                // that broke on PowerShell: `'true' is not recognized`).
+                // Resolve ONCE for N hosts — reading a bundle can prompt, and doing it
+                // per host would prompt per host.
+                const resolvedForPush = resolveBundleForPush(resolvedBundleName, 'ssh export');
+                const keyCount = resolvedForPush.keyCount;
                 let failures = 0;
                 for (const host of hosts) {
-                    let res;
-                    if (remoteBackend === 'file') {
-                        // File backend: headless-readable via the remote's machine-local key
-                        // when no passphrase is set; otherwise forwards AGENTS_SECRETS_PASSPHRASE
-                        // as the FIRST stdin line (consumed by `read`, so it never lands in
-                        // argv / `ps` / remote history), then the .env. Both build a POSIX
-                        // `bash -lc` command — refuse a Windows target cleanly rather than
-                        // emit broken PowerShell.
-                        if (remoteShellFor(resolveRemoteOsSync(host.split('@').pop() ?? host)) === 'powershell') {
-                            failures++;
-                            console.error(chalk.red(`${host}: file backend export to a Windows target is not yet supported.`));
-                            continue;
-                        }
-                        const { remoteCmd, input } = buildRemoteFileImportCommand(resolvedBundleName, dotenv, {
-                            passphrase: remotePassphrase,
-                            force: opts.force,
-                        });
-                        res = sshExec(host, remoteCmd, { input });
-                    }
-                    else if (remoteShellFor(resolveRemoteOsSync(host.split('@').pop() ?? host)) === 'powershell') {
-                        // Keychain on a Windows target: the `agents.ps1` shim doesn't
-                        // forward ssh-piped stdin to node, so `--from -` would hang.
-                        // Bridge the piped .env through PowerShell into a temp file and
-                        // import `--from <file>` (deleted afterwards). Same hardened ssh
-                        // engine, .env still only ever crosses the wire over ssh stdin.
-                        res = sshExec(host, buildWindowsStdinImportCommand(resolvedBundleName, { force: opts.force }), { input: dotenv });
-                    }
-                    else {
-                        // Keychain on a POSIX target: OS-aware wrapping + hardened ssh
-                        // engine (BatchMode, ConnectTimeout, keepalive, control-socket
-                        // reuse) via the same path the READ inverse (`remoteResolveEnv`)
-                        // uses. `--from -` reads the .env off ssh stdin.
-                        res = remoteSecretsRaw(host, ['import', resolvedBundleName, '--from', '-', ...(opts.force ? ['--force'] : [])], { input: dotenv, osLookupName: host });
-                    }
-                    if (res.code === null) {
-                        failures++;
-                        console.error(chalk.red(`${host}: ${res.stderr.trim() || (res.timedOut ? 'ssh timed out' : 'ssh failed')}`));
-                        continue;
-                    }
-                    if (res.code !== 0) {
+                    const out = pushResolvedBundleToHost(resolvedForPush, resolvedBundleName, host, {
+                        remoteBackend,
+                        force: opts.force,
+                        passphrase: remotePassphrase,
+                        operation: 'ssh export',
+                    });
+                    if (!out.ok) {
                         failures++;
-                        const msg = (res.stderr || res.stdout || '').trim();
-                        console.error(chalk.red(`${host}: remote import failed (exit ${res.code})${msg ? `: ${msg}` : ''}`));
+                        console.error(chalk.red(`${host}: ${out.message}`));
                         continue;
                     }
-                    // A keychain-backed push to a macOS remote over headless SSH can land
-                    // the bundle metadata but no READABLE value items: the remote login
-                    // keychain is locked in the non-interactive SSH context, so Security
-                    // accepts the write but the biometry-ACL'd item is unreadable, and the
-                    // remote `import` still exits 0. Read the bundle back the same way a
-                    // release will (drops the plaintext, keeps only key presence; the
-                    // remote's headless `agentOnly` guard fails fast, so no Touch ID) and
-                    // FAIL LOUDLY if the keys didn't materialize — rather than leave a
-                    // metadata-only bundle that breaks later with "stored item not found".
-                    // The file backend is headless-readable by construction, so skip it.
-                    if (remoteBackend === 'keychain') {
-                        const verdict = verifyRemoteKeychainPush(host, resolvedBundleName, Object.keys(env), { osLookupName: host });
-                        if (!verdict.ok) {
-                            failures++;
-                            if (verdict.kind === 'locked-keychain') {
-                                console.error(chalk.red(keychainWriteFailureMessage(host, resolvedBundleName, verdict.reason)));
-                            }
-                            else {
-                                console.error(chalk.red(`${host}: pushed '${resolvedBundleName}' but could not verify it on the remote: ${verdict.reason}`));
-                            }
-                            continue;
-                        }
-                    }
-                    const remoteMsg = (res.stdout || '').trim().split('\n').map((l) => l.trim()).filter(Boolean).pop();
-                    console.log(chalk.green(`${host} -> '${resolvedBundleName}': ${remoteMsg || `${keyCount} key(s) exported`}`));
+                    console.log(chalk.green(`${host} -> '${resolvedBundleName}': ${out.message}`));
                 }
                 emitSecretAudit({ event: 'secrets.export', bundle: resolvedBundleName, operation: `export --host ${hosts.join(',')}`, source: 'ssh', host: hosts.join(','), status: failures > 0 ? 'error' : 'success', keyCount });
                 if (failures > 0)

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

@@ -147,7 +147,7 @@ export declare function liveSessionToMeta(a: ActiveSession, self: string): Sessi
  * `--active --json` listed it. Live sessions the pool lacks are appended as their
  * own rows, then the whole set is grouped local-machine-first.
  */
-export declare function mergeLiveIntoPool(rows: SessionMeta[], live: Map<string, ActiveSession>, self: string): SessionMeta[];
+export declare function mergeLiveIntoPool(rows: SessionMeta[], live: Map<string, ActiveSession>, self: string, includeUnindexed?: boolean): SessionMeta[];
 /**
  * Whether to render the host-program column. It belongs to the running view
  * only, so this gates on the FILTER — not on the live index being populated.

package/dist/commands/sessions-browser.js

@@ -22,7 +22,7 @@ import { enrichTeamOrigins, safeTeamText } from '../lib/session/team-filter.js';
 import { listFavorites, toggleFavorite } from '../lib/session/favorites.js';
 import { machineId, normalizeHost } from '../lib/session/sync/config.js';
 import { buildPreview } from './sessions-picker.js';
-import { formatPickerLabel, pickerColumnsFor, ticketLabel, mergeLocalFirst, gatherActiveSessions, liveHostLabel, LIVE_ROW_PREFIX, cleanPreview, handlePickedSession, shouldIncludeLocal, remoteHostsToDial, matchesTeam, formatLiveStatusHeadline, matchesLiveStatus, parseAgentFilter, } from './sessions.js';
+import { formatPickerLabel, pickerColumnsFor, ticketLabel, mergeLocalFirst, gatherActiveSessions, liveHostLabel, LIVE_ROW_PREFIX, cleanPreview, handlePickedSession, shouldIncludeLocal, remoteHostsToDial, matchesTeam, formatLiveStatusHeadline, isRunningLiveSession, matchesLiveStatus, parseAgentFilter, } from './sessions.js';
 /**
  * Complete a seed into the filter the picker actually runs on.
  *
@@ -73,6 +73,8 @@ function poolCacheKey(f) {
 }
 /** Pool size when a team filter is active; one team's rows can sit anywhere. */
 const WHOLE_TEAM_POOL_LIMIT = 5000;
+/** A cold peer may need to resolve an installed-version alias and scan its index. */
+const BROWSER_PEER_TIMEOUT_MS = 30_000;
 /** Ordered window cycle for the `W` key. `undefined` = all time. */
 const WINDOW_CYCLE = [undefined, '1d', '7d', '30d'];
 /** Return the next value in `[undefined, ...options]`, wrapping. */
@@ -309,7 +311,9 @@ async function fetchRawPool(f, self, local, hosts, fixedFilters = false) {
             // --in-team itself, which a peer on an older build would reject as an
             // unknown option and fail the whole fan-out.
             const forwarded = remotePoolArgs(f, fixedFilters);
-            const remoteResult = await gatherRemoteList(forwarded, remoteHosts);
+            const remoteResult = await gatherRemoteList(forwarded, remoteHosts, {
+                timeoutMs: BROWSER_PEER_TIMEOUT_MS,
+            });
             unreachable = remoteResult.unreachable;
             if (remoteResult.sessions.length > 0)
                 rows = mergeLocalFirst([...rows, ...remoteResult.sessions], self);
@@ -423,7 +427,12 @@ export function liveSessionToMeta(a, self) {
  * `--active --json` listed it. Live sessions the pool lacks are appended as their
  * own rows, then the whole set is grouped local-machine-first.
  */
-export function mergeLiveIntoPool(rows, live, self) {
+export function mergeLiveIntoPool(rows, live, self, includeUnindexed = true) {
+    // A latest/oldest selector is resolved by the peer's transcript query. A live
+    // row absent from that result has no proof it belongs to the resolved version,
+    // so callers using an alias fail closed instead of widening the selector.
+    if (!includeUnindexed)
+        return rows;
     const known = new Set(rows.map((r) => r.id));
     const extra = [];
     for (const [key, a] of live) {
@@ -483,8 +492,15 @@ export function applyFilters(rows, live, f, self, favorites) {
         const cwd = process.cwd();
         out = out.filter((r) => !!r.cwd && (r.cwd === cwd || r.cwd.startsWith(cwd + '/')));
     }
-    if (f.running)
-        out = out.filter((r) => live.has(r.id));
+    // The live registry retains dead rows so explicit --closed/--crashed filters
+    // can recover them. Bare --active means currently active; a lifecycle filter
+    // intentionally replaces that default predicate with its exact status union.
+    if (f.running && f.statuses.length === 0) {
+        out = out.filter((r) => {
+            const active = live.get(r.id);
+            return !!active && isRunningLiveSession(active);
+        });
+    }
     if (f.statuses.length > 0) {
         out = out.filter((r) => {
             const active = live.get(r.id);
@@ -507,8 +523,9 @@ export async function collectSessionCandidates(initial, opts = {}) {
         const { sessions } = await gatherActiveSessions({ local: opts.local ?? false, hosts });
         liveById = indexLiveRows(sessions, self);
     }
+    const includeUnindexedLive = !filter.agent?.match(/@(latest|oldest)$/);
     const rows = filter.running || opts.includeLive
-        ? mergeLiveIntoPool(pool.rows, liveById, self)
+        ? mergeLiveIntoPool(pool.rows, liveById, self, includeUnindexedLive)
         : pool.rows;
     const sessions = applyFilters(rows, liveById, filter, self, listFavorites());
     return { sessions, liveById, self, unreachable: pool.unreachable };
@@ -618,7 +635,10 @@ export async function runSessionBrowser(initial = {}, opts = {}) {
             liveCache = live;
         // Live sessions the transcript pool lacks become rows of their own, so the
         // running view lists every active session, not just the ones already indexed.
-        const rows = f.running && live ? mergeLiveIntoPool(pool.rows, live, self) : pool.rows;
+        const includeUnindexedLive = !f.agent?.match(/@(latest|oldest)$/);
+        const rows = f.running && live
+            ? mergeLiveIntoPool(pool.rows, live, self, includeUnindexedLive)
+            : pool.rows;
         agentsInPool = distinct(rows.map((r) => r.agent));
         devicesInPool = distinct(rows.map((r) => r.machine ?? self));
         // Both ends of the lineage seed the cycle: teams a row spawned, and teams a

package/dist/commands/sessions-resume.js

@@ -14,7 +14,8 @@ import { discoverSessions } from '../lib/session/discover.js';
 import { filterTeamSessions } from '../lib/session/team-filter.js';
 import { multiItemPicker, itemPicker } from '../lib/picker.js';
 import { buildPreview } from './sessions-picker.js';
-import { filterSessionsByQuery, formatPickerLabel, pickerColumnsFor, buildSessionRecoveryCommand, resumeSessionInPlace, parseAgentFilter, } from './sessions.js';
+import { formatPickerLabel, pickerColumnsFor, buildSessionRecoveryCommand, resumeSessionInPlace, parseAgentFilter, } from './sessions.js';
+import { sessionMatchesQuery } from './sessions-browser.js';
 import { openSurfaces, availableBackends, detectCurrentBackend, currentContext, } from '../lib/terminal/index.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { setHelpSections } from '../lib/help.js';
@@ -111,7 +112,7 @@ async function sessionsResumeAction(query, options) {
         chosen = await multiItemPicker({
             message: 'Select sessions to resume:',
             items: sessions,
-            filter: (q) => (q.trim() ? filterSessionsByQuery(sessions, q) : sessions),
+            filter: (q) => (q.trim() ? sessions.filter((s) => sessionMatchesQuery(s, q)) : sessions),
             labelFor: (s, q) => formatPickerLabel(s, q, cols),
             keyFor: (s) => s.id,
             buildPreview,

package/dist/commands/sessions.d.ts

@@ -131,7 +131,7 @@ export declare function formatActiveRowDescription(s: ActiveSession): string;
  */
 export declare function indexActiveBySessionId(active: ActiveSession[]): Map<string, ActiveSession>;
 /** The SessionMeta fields the live-row backfill reads — the enrichment a running process cannot report. */
-type BackfillMeta = Pick<SessionMeta, 'version' | 'timestamp' | 'label' | 'ticketId' | 'prUrl' | 'prNumber'>;
+export type BackfillMeta = Pick<SessionMeta, 'version' | 'timestamp' | 'label' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName'>;
 /**
  * Backfill display-only fields onto live rows from the indexed SessionMeta, by
  * full session id (RUSH-2205). A running process reports no agent version, and a
@@ -141,6 +141,8 @@ type BackfillMeta = Pick<SessionMeta, 'version' | 'timestamp' | 'label' | 'ticke
  * the DB read that builds `metaById` is the caller's concern.
  */
 export declare function backfillActiveRowsFromMeta(sessions: ActiveSession[], metaById: Map<string, BackfillMeta>): void;
+/** Add indexed display metadata to active rows for non-renderer consumers. */
+export declare function backfillActiveRowsFromIndex(sessions: ActiveSession[]): void;
 /**
  * The live decoration for a listing row: a status glyph and the latest-turn
  * preview, when the session is still running. `●` running / `◐` waiting on the
@@ -184,6 +186,16 @@ export declare function liveStatusWord(a: ActiveSession | undefined): string;
  * stays excluded rather than inventing a human who can answer.
  */
 export declare function isAwaitingUser(s: ActiveSession): boolean;
+/**
+ * Whether a row belongs in an unqualified `--active` view.
+ *
+ * The live registry deliberately retains terminally-dead rows long enough for
+ * `--closed` / `--crashed` and recovery to find them. Presence in that registry
+ * therefore is not, by itself, evidence that a session is still active.
+ * Explicit lifecycle filters bypass this predicate and select those retained
+ * rows through {@link matchesLiveStatus} instead.
+ */
+export declare function isRunningLiveSession(s: ActiveSession): boolean;
 /**
  * The tracker/PR ref for a session's dedicated column: the ticket id when known,
  * else `PR#<n>`, else empty. Pulled out of the trailing badge blob so refs align

package/dist/commands/sessions.js

@@ -57,6 +57,7 @@ import { registerSessionsFavoriteCommand } from './sessions-favorite.js';
 import { isFavorite, listFavorites } from '../lib/session/favorites.js';
 import { registerGoCommand } from './go.js';
 import { registerFocusCommand } from './focus.js';
+import { registerReconnectCommand } from './reconnect.js';
 import { registerDetachCommand } from './detach.js';
 import { registerAttachCommand } from './attach.js';
 import { registerSessionsInjectCommand } from './sessions-inject.js';
@@ -66,6 +67,7 @@ import { registerSessionsImportCommand } from './sessions-import.js';
 import { registerSessionsMigrateCommand, registerSessionsMigrationsCommand } from './sessions-migrate.js';
 import { registerSessionsBackfillCommand } from './sessions-backfill.js';
 import { registerSessionsStatsCommand } from './sessions-stats.js';
+import { registerSessionsInsightsCommand } from './insights.js';
 import { registerSessionsOptimizeCommand } from './sessions-optimize.js';
 import { runBrowserSessions } from '../lib/browser/sessions-list.js';
 import { countToolProgramOccurrences, parseToolProgramCountClause, readToolIndexCoverage, searchToolCalls, TOOL_QUERY_MAX_CLAUSE_BYTES, TOOL_QUERY_MAX_CLAUSES, TOOL_QUERY_MAX_RESULT_SESSIONS, serializeToolSearchEnvelope, toolSearchRemoteReceiveBudget, } from '../lib/session/tool-index.js';
@@ -411,6 +413,10 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
             if (!Number.isNaN(ts))
                 s.startedAtMs = ts;
         }
+        if (!s.origin && m.origin)
+            s.origin = m.origin;
+        if (!s.routineName && m.routineName)
+            s.routineName = m.routineName;
     }
 }
 /**
@@ -435,6 +441,10 @@ function loadBackfillMetaFor(sessions) {
     }
     return byId;
 }
+/** Add indexed display metadata to active rows for non-renderer consumers. */
+export function backfillActiveRowsFromIndex(sessions) {
+    backfillActiveRowsFromMeta(sessions, loadBackfillMetaFor(sessions));
+}
 /**
  * The live decoration for a listing row: a status glyph and the latest-turn
  * preview, when the session is still running. `●` running / `◐` waiting on the
@@ -527,6 +537,20 @@ export function isAwaitingUser(s) {
         return false;
     return s.status === 'input_required' || s.activity === 'waiting_input';
 }
+/**
+ * Whether a row belongs in an unqualified `--active` view.
+ *
+ * The live registry deliberately retains terminally-dead rows long enough for
+ * `--closed` / `--crashed` and recovery to find them. Presence in that registry
+ * therefore is not, by itself, evidence that a session is still active.
+ * Explicit lifecycle filters bypass this predicate and select those retained
+ * rows through {@link matchesLiveStatus} instead.
+ */
+export function isRunningLiveSession(s) {
+    if (s.status === 'closed' || s.status === 'crashed')
+        return false;
+    return s.pidAlive !== false;
+}
 /** Width of the live status column — `crashed` is the longest word it renders. */
 const LIVE_STATUS_W = 8;
 /** The colored, space-padded status cell for a listing row (empty when not live). */
@@ -1275,14 +1299,14 @@ async function renderActiveSessions(asJson, waitingOnly = false, opts = {}) {
     // gate: exit non-zero when the union contains a session awaiting the user.
     const statusFiltered = opts.statuses?.length
         ? merged.filter((session) => opts.statuses.some((status) => matchesLiveStatus(session, status)))
-        : merged;
+        : merged.filter(isRunningLiveSession);
     const sessions = statusFiltered;
     // Backfill agent version + ticket/PR/label/created onto the live rows from the
     // historical index (RUSH-2205) — a running process reports none of these, and
     // an orphan row usually lacks them. Done before both the JSON and human paths
     // so every consumer (incl. the SSH fan-out's remote --json) sees enriched rows;
     // transcripts sync across the fleet, so a remote row resolves from the local DB.
-    backfillActiveRowsFromMeta(sessions, loadBackfillMetaFor(sessions));
+    backfillActiveRowsFromIndex(sessions);
     if (asJson) {
         // Resolve who is watching each local tmux pane before serializing: `viewingIn`
         // is how a consumer distinguishes a session someone is looking at from one
@@ -4060,6 +4084,7 @@ export function registerSessionsCommands(program) {
     registerSessionsFavoriteCommand(sessionsCmd);
     registerGoCommand(sessionsCmd);
     registerFocusCommand(sessionsCmd);
+    registerReconnectCommand(sessionsCmd);
     registerDetachCommand(sessionsCmd);
     registerAttachCommand(sessionsCmd);
     registerSessionsInjectCommand(sessionsCmd);
@@ -4070,6 +4095,7 @@ export function registerSessionsCommands(program) {
     registerSessionsMigrationsCommand(sessionsCmd);
     registerSessionsBackfillCommand(sessionsCmd);
     registerSessionsStatsCommand(sessionsCmd);
+    registerSessionsInsightsCommand(sessionsCmd);
     registerSessionsOptimizeCommand(sessionsCmd);
     // Observe-umbrella alias (Phase 3): roster → sessions --active.
     registerSessionsObserveAliases(program);

package/dist/commands/setup-secrets.d.ts

@@ -15,6 +15,7 @@ interface SetupSecretsOptions {
     iUnderstand?: boolean;
     force?: boolean;
 }
+export declare function setupSecretsPrefsPath(): string;
 /** The wizard's `--policy` shares the canonical parser with `agents secrets
  * policy`, so it accepts `hold` (and the `daily`/`session` aliases) rather than
  * carrying its own copy that knows only the retired vocabulary. `parsePolicyOpt`

package/dist/commands/setup-secrets.js

@@ -15,7 +15,7 @@ import { parsePolicyOpt } from './secrets.js';
 function defaultBackendForPlatform(platform = process.platform) {
     return platform === 'darwin' ? 'keychain' : 'file';
 }
-function setupSecretsPrefsPath() {
+export function setupSecretsPrefsPath() {
     return path.join(getHistoryDir(), 'setup', 'secrets.json');
 }
 function parseBackend(raw) {