@phnx-labs/agents-cli 1.20.77 → 1.20.82

package/dist/commands/secrets.js

@@ -15,19 +15,21 @@ import * as path from 'path';
 import { SSH_TARGET_RE, assertValidSshTarget, sshExec } 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, } from '../lib/secrets/remote.js';
+import { parseHostsOption, remoteResolveEnv, remoteSecretsRaw, remoteSecretsStream, resolveHostSshTarget, verifyRemoteKeychainPush, keychainWriteFailureMessage, } from '../lib/secrets/remote.js';
 import { remoteShellFor, buildWindowsStdinImportCommand } from '../lib/hosts/remote-cmd.js';
 import { resolveRemoteOsSync } from '../lib/hosts/remote-os.js';
 import { bundleBackend, bundleExists, bundleItemStore, bundlePolicy, deleteBundle, describeBundle, keychainItemsForBundle, keychainRef, listBundles, migrateLegacyBundles, parseDotenv, readAndResolveBundleEnv, isHeadlessSecretsContext, readBundle, readBundleIfDecryptable, renameBundle, rotateBundleSecret, sanitizeProcessEnv, validateBundleName, validateEnvKey, validateExpiresFutureDated, validateSecretType, writeBundle, writeBundleWithItems, } from '../lib/secrets/bundles.js';
 import { encryptForFallback, decryptForFallback } from '../lib/secrets/filestore.js';
 import { getKeychainToken, getKeychainTokens, hasKeychainToken, secretsKeychainItem, setKeychainToken, } from '../lib/secrets/index.js';
 import { assertOpAvailable, createPasswordItem, deleteItemByTitle, extractSecrets, itemExistsByTitle, listItems, listVaults, } from '../lib/onepassword.js';
+import { GLOBAL_HARNESS } from '../lib/secrets/scope.js';
 import { secretsHoldMs, secretsAgentDurable, agentLoad, agentLock, agentPing, agentStatus, ensureAgentRunning, runAgentLoadFromStdin, runSecretsAgent, uninstallSecretsAgentService, } from '../lib/secrets/agent.js';
 import { saveSession, deleteBundleSessions, deleteAllSessions } from '../lib/secrets/session-store.js';
 import { getCliVersionFresh } from '../lib/version.js';
 import { readMeta } from '../lib/state.js';
 import { parseDuration } from '../lib/hooks/cache.js';
 import { emit, query } from '../lib/events.js';
+import { emitSecretAudit } from '../lib/secrets/audit.js';
 import { frequentlyPromptedBundles } from '../lib/secrets/unlock-hints.js';
 import { registerCommandGroups, setHelpSections } from '../lib/help.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
@@ -467,7 +469,7 @@ export function renderPolicyCol(b, held) {
     if (bundlePolicy(b) === 'always')
         return chalk.yellow('always · prompt');
     const exp = held?.get(b.name);
-    return exp ? chalk.green(`daily · held ${compactRemaining(exp)}`) : chalk.gray('daily');
+    return exp ? chalk.green(`hold · held ${compactRemaining(exp)}`) : chalk.gray('hold');
 }
 /** Human-readable hold window for `secrets status`. Sub-hour values render in
  * minutes (so a near-floor `holdMs` never shows a confusing "0 hours"), whole
@@ -668,7 +670,7 @@ function countExpiringSoon(meta) {
  * guard can't drift between them.
  */
 function resolveImportBundle(name, backendOpt, synced = false) {
-    const requestedBackend = synced ? 'vault' : parseBackendOpt(backendOpt);
+    const requestedBackend = synced ? 'vault' : resolveBackendOpt(backendOpt);
     if (bundleExists(name)) {
         const bundle = readBundle(name);
         if (requestedBackend !== 'keychain' && bundle.backend !== requestedBackend) {
@@ -734,7 +736,7 @@ export function registerSecretsCommands(program) {
       agents secrets view prod
 
       # Stop a noisy automation bundle from prompting every run: ask once a week
-      agents secrets policy prod daily
+      agents secrets policy prod hold
 
       # Eval the bundle into your current shell
       eval "$(agents secrets export prod --plaintext)"
@@ -752,17 +754,21 @@ export function registerSecretsCommands(program) {
 
       Touch ID noise: macOS pops a prompt per bundle per process. Each bundle has
       a prompt policy, shown in the POLICY column of 'agents secrets list':
-        daily (default)   ask once, then hold it silently in the local agent up
-                          to ~7 days, until sleep / logout or 'lock' (a bare
-                          screen-lock does NOT drop it). Name is historical.
+        hold (default)    ask once, then serve it silently from the local agent
+                          for the hold window ('secrets.agent.holdMs', 7d by
+                          default), until sleep / logout or 'lock' (a bare
+                          screen-lock does NOT drop it). Accepts the older names
+                          'daily' and 'session'.
         always            ask for Touch ID every time — never auto-held.
-      The default is 'daily' (one Touch ID per ~7 days); change it globally with
+        never             no biometry ACL at all — reads are silent forever, even
+                          if the agent is down. Automation credentials only.
+      The default is 'hold' (one Touch ID per hold window); change it globally with
       'secrets.policy' in agents.yaml, or per bundle with 'agents secrets policy
       <bundle> always'. 'agents secrets unlock <bundle>' holds any bundle after one
       prompt regardless of policy. Nothing on disk.
 
       See also:
-        agents secrets policy <bundle> daily           ask once a week, not every run
+        agents secrets policy <bundle> hold            ask once per hold window (7d by default), not every run
         agents secrets unlock <bundle>                 hold a bundle after one Touch ID
         agents secrets lock                            wipe held bundles (re-prompt next read)
         agents secrets status                          show held bundles + when they lock
@@ -788,6 +794,8 @@ export function registerSecretsCommands(program) {
         .description('List configured secrets bundles (use --host/--hosts to list bundles on other machines over SSH)')
         .option('--host <target>', 'List bundles on a remote host over SSH (enrolled `agents hosts` name, ssh-config alias, or user@host)')
         .option('--hosts <list>', 'Comma-separated hosts to list in one shot, e.g. yosemite-s0,yosemite-s1')
+        .option('--device <target>', 'Alias for --host')
+        .option('--devices <list>', 'Alias for --hosts')
         .option('--json', 'Emit machine-readable JSON (bundle metadata only — never secret values) instead of the table')
         .action(async (opts) => {
         const targets = parseHostsOption(opts);
@@ -855,6 +863,8 @@ export function registerSecretsCommands(program) {
         .option('--json', 'Emit machine-readable JSON (values masked unless --reveal) instead of the human view')
         .option('--host <target>', 'Show a bundle on a remote host over SSH (enrolled `agents hosts` name, ssh-config alias, or user@host)')
         .option('--hosts <list>', 'Comma-separated hosts to show in one shot, e.g. yosemite-s0,yosemite-s1')
+        .option('--device <target>', 'Alias for --host')
+        .option('--devices <list>', 'Alias for --hosts')
         .action(async (name, opts) => {
         try {
             const targets = parseHostsOption(opts);
@@ -912,8 +922,8 @@ export function registerSecretsCommands(program) {
                     }
                     const exposed = revealed.size + entries.filter((e) => e.kind === 'literal').length;
                     if (exposed > 0) {
-                        emit('secrets.get', {
-                            module: 'secrets',
+                        emitSecretAudit({
+                            event: 'secrets.get',
                             bundle: bundle.name,
                             operation: 'view --reveal --json',
                             source: 'reveal',
@@ -971,8 +981,8 @@ export function registerSecretsCommands(program) {
                 console.log(chalk.red.bold('policy: never — NO biometry ACL; reads are silent (no Touch ID, no user-presence check). Automation-only.'));
             }
             else {
-                console.log(bundlePolicy(bundle) === 'daily'
-                    ? chalk.gray('policy: daily (ask once, then held ~7 days until sleep / logout — screen-lock does not drop it)')
+                console.log(bundlePolicy(bundle) === 'hold'
+                    ? chalk.gray('policy: hold (ask once, then held for the hold window — 7d by default — until sleep / logout; screen-lock does not drop it)')
                     : chalk.gray('policy: always (asks for Touch ID every time — never auto-held)'));
             }
             if (bundle.created_at)
@@ -1020,8 +1030,8 @@ export function registerSecretsCommands(program) {
                 const literalCount = entries.filter((e) => e.kind === 'literal').length;
                 const exposedCount = revealedValues.size + literalCount;
                 if (exposedCount > 0) {
-                    emit('secrets.get', {
-                        module: 'secrets',
+                    emitSecretAudit({
+                        event: 'secrets.get',
                         bundle: bundle.name,
                         operation: 'view --reveal',
                         source: 'reveal',
@@ -1078,7 +1088,7 @@ export function registerSecretsCommands(program) {
                 const value = getKeychainToken(item);
                 // Raw item reads bypass readAndResolveBundleEnv, so audit here too.
                 // `item` is the keychain service name, never the value.
-                emit('secrets.get', { module: 'secrets', item, source: 'raw-item', status: 'success' });
+                emitSecretAudit({ event: 'secrets.get', item, source: 'raw-item', status: 'success' });
                 process.stdout.write(value.endsWith('\n') ? value : `${value}\n`);
             }
             catch {
@@ -1152,10 +1162,10 @@ export function registerSecretsCommands(program) {
         .description('Create an empty bundle')
         .option('--description <text>', 'Free-form description')
         .option('--allow-exec', 'Allow exec: refs in this bundle (off by default)')
-        .option('--policy <policy>', 'prompt policy: daily (default, ask once a week), always (ask every time), or never (silent, NO biometry ACL — needs --i-understand)')
+        .option('--policy <policy>', "prompt policy: hold (default, ask once per hold window — secrets.agent.holdMs, 7d by default), always (ask every time), or never (silent, NO biometry ACL — needs --i-understand). 'daily'/'session' are accepted aliases for 'hold'.")
         .addOption(new Option('--tier <policy>', 'deprecated alias for --policy').hideHelp())
         .option('--i-understand', 'Confirm creating a "never"-policy bundle (no biometry ACL) without an interactive prompt')
-        .option('--backend <backend>', 'storage backend: keychain (default) or file (passphrase-encrypted)', 'keychain')
+        .option('--backend <backend>', 'storage backend: keychain or file (defaults to agents.yaml secrets.backend)')
         .option('--synced', 'Store this bundle in the age-encrypted synced secrets file for user-managed cross-machine file sync')
         .option('--force', 'Overwrite an existing bundle')
         .action(async (name, opts) => {
@@ -1166,7 +1176,7 @@ export function registerSecretsCommands(program) {
             // inherits the configured default (`daily`) instead of being pinned.
             const policyOpt = opts.policy ?? opts.tier;
             const policy = policyOpt ? parsePolicyOpt(policyOpt) : undefined;
-            const backend = opts.synced ? 'vault' : parseBackendOpt(opts.backend);
+            const backend = opts.synced ? 'vault' : resolveBackendOpt(opts.backend);
             if (bundleExists(resolvedName) && !opts.force) {
                 console.error(chalk.red(`Bundle '${resolvedName}' already exists. Use --force to overwrite.`));
                 process.exit(1);
@@ -1187,8 +1197,8 @@ export function registerSecretsCommands(program) {
                 vars: {},
             };
             writeBundle(bundle);
-            const policyTag = bundlePolicy(bundle) === 'daily'
-                ? 'policy: daily'
+            const policyTag = bundlePolicy(bundle) === 'hold'
+                ? 'policy: hold'
                 : bundlePolicy(bundle) === 'always'
                     ? 'policy: always ask'
                     : 'policy: never (NO biometry ACL)';
@@ -1571,7 +1581,7 @@ Examples:
         .addOption(new Option('--from-1password', 'deprecated alias for --from 1password:<vault>').hideHelp())
         .addOption(new Option('--vault <name>', 'deprecated: name the vault in --from 1password:<vault>').hideHelp())
         .option('--all-plaintext', 'Store every imported value as a literal in the bundle metadata (skip keychain item creation)')
-        .option('--backend <backend>', 'When creating the bundle: keychain (default) or file (passphrase-encrypted)', 'keychain')
+        .option('--backend <backend>', 'When creating the bundle: keychain or file (defaults to agents.yaml secrets.backend)')
         .option('--synced', 'When creating the bundle, store it in the age-encrypted synced secrets file')
         .option('--force', 'Overwrite an existing key in the bundle')
         .option('--purge', 'With --from icloud: delete the iCloud copies after a successful import (iCloud propagates the deletion to your other devices)')
@@ -1622,7 +1632,7 @@ Examples:
             if (opts.from1password) {
                 console.log(chalk.yellow('--from-1password is deprecated; use --from 1password:<vault>.'));
             }
-            const requestedBackend = opts.synced ? 'vault' : parseBackendOpt(opts.backend);
+            const requestedBackend = opts.synced ? 'vault' : resolveBackendOpt(opts.backend);
             if (source.kind === 'icloud') {
                 await importFromICloud(bundleName, {
                     force: opts.force,
@@ -1673,12 +1683,18 @@ Examples:
         .option('--to-1password', 'Push every key in the bundle as a PASSWORD item in a 1Password vault')
         .option('--vault <name>', '1Password vault name (used with --to-1password)')
         .option('--host <target...>', 'Push the bundle over SSH to this target (host alias or user@host); repeatable for multiple machines')
+        .option('--device <target...>', 'Alias for --host; repeatable')
         .option('--remote-backend <backend>', 'Backend for the bundle on the remote (with --host): keychain (default) or file (passphrase-encrypted, headless-readable). file forwards AGENTS_SECRETS_PASSPHRASE over stdin.', 'keychain')
         .option('--force', 'Overwrite existing keys/items on the target (used with --to-1password and --host)')
         .option('--format <shell|json>', 'Output for --plaintext export: shell (default) or json (lossless, machine-readable; used by remote resolve)', 'shell')
         .option('--to-file <path>', 'Write the bundle as an AES-256-GCM encrypted offline file (needs AGENTS_SECRETS_PASSPHRASE; symmetric counterpart of import --from-file)')
         .action(async (bundleName, opts) => {
         try {
+            // `--device` is an alias for `--host` (fleet vocabulary parity with
+            // `agents activity`/`run --device`); fold it into the host list up front so
+            // every downstream branch sees one resolved target list.
+            if (opts.device?.length)
+                opts.host = [...(opts.host ?? []), ...opts.device];
             const { readAndResolveBundleEnv, bundleToEnvPrefix, isReservedEnvName } = await import('../lib/secrets/bundles.js');
             const resolvedBundleName = bundleName ?? (await pickBundleName('export'));
             if (opts.toFile) {
@@ -1769,6 +1785,29 @@ Examples:
                         console.error(chalk.red(`${host}: remote import failed (exit ${res.code})${msg ? `: ${msg}` : ''}`));
                         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`}`));
                 }
@@ -2057,7 +2096,7 @@ Examples:
         .description('Hold a bundle in the secrets-agent after one Touch ID, so concurrent runs read it without re-prompting (macOS). With --host, unlock FILE-backed bundle(s) on a remote (the passphrase prompt surfaces over the SSH TTY); keychain/biometry bundles are GUI-only and can\'t be remote-unlocked.')
         .option('--ttl <duration>', 'How long to hold it (e.g. 30m, 8h, 3d). Default 7d.')
         .option('--durable', 'Keep the unlock across sleep + reboot too (default: survives upgrade/restart but re-locks on sleep). Set secrets.agent.durable in agents.yaml to make this the default.')
-        .option('--for <agent>', 'Scope the unlock to one harness type (for example claude, codex, or kimi).')
+        .option('--for <agent>', 'Narrow the unlock to ONE harness type (for example claude, codex, or kimi). Default: the grant is global — every harness and a plain shell can read it, so one Touch ID covers them all.')
         .option('--all', 'Unlock every configured bundle')
         .option('--host <target>', 'Unlock the bundle(s) on this remote machine over SSH instead of locally (file-backed bundles only — the remote\'s passphrase prompt surfaces on your terminal over a -tt session). Single-valued (NOT variadic) so it never swallows the bundle name: `unlock <name> --host <machine>`.')
         .action(async (names, opts) => {
@@ -2130,7 +2169,12 @@ Examples:
         // (single-instance start lock, #414) and best-effort — never blocks unlock.
         ensureDaemonStarted();
         let loaded = 0;
-        const harness = opts.for || process.env.AGENTS_AGENT_NAME || 'cli';
+        // An unlock is a deliberate act, so it grants GLOBALLY unless `--for`
+        // narrows it to one harness. It must NOT inherit the ambient
+        // AGENTS_AGENT_NAME: that silently scoped a terminal unlock to whichever
+        // agent happened to launch the shell, leaving the grant unreadable to
+        // every other reader for its whole TTL.
+        const harness = opts.for || GLOBAL_HARNESS;
         for (const name of targets) {
             try {
                 // noAgent: read the real keychain (one Touch ID) rather than the
@@ -2146,13 +2190,29 @@ Examples:
                     loaded++;
                     // Persist a durable session snapshot so the unlock survives a daemon
                     // restart / upgrade (and sleep too, with --durable). session-store.ts.
+                    const durable = opts.durable ?? secretsAgentDurable();
                     saveSession(name, {
                         bundle,
                         env,
                         expiresAt: Date.now() + ttlMs,
-                        sleepPersist: opts.durable ?? secretsAgentDurable(),
+                        sleepPersist: durable,
                         harness,
                     });
+                    // Audit the GRANT itself — the broker + durable session now serve this
+                    // bundle prompt-free for the whole TTL, to every reader in `harness`
+                    // scope. The pre-read above emits `secrets.get`; this records the
+                    // longer-lived unlock a `secrets.get` does not capture. Key NAMES only.
+                    emitSecretAudit({
+                        event: 'secrets.unlocked',
+                        bundle: name,
+                        operation: 'unlock',
+                        source: durable ? 'broker+durable' : 'broker',
+                        status: 'success',
+                        keyCount: Object.keys(env).length,
+                        keys: Object.keys(env).sort(),
+                        agent: harness,
+                        ttlMs,
+                    });
                     console.log(`${chalk.green('unlocked')} ${chalk.cyan(name)} ${chalk.gray(`(${Object.keys(env).length} keys, ${humanRemaining(Date.now() + ttlMs)})`)}`);
                 }
                 else {
@@ -2272,7 +2332,7 @@ Examples:
     cmd
         .command('policy <bundle> [policy]')
         .alias('tier')
-        .description("Show or set a bundle's prompt policy: daily (default, ask once a week), always (ask every time), or never (silent, NO biometry ACL).")
+        .description("Show or set a bundle's prompt policy: hold (default, ask once per hold window — secrets.agent.holdMs, 7d by default), always (ask every time), or never (silent, NO biometry ACL). 'daily'/'session' are accepted aliases for 'hold'.")
         .option('--i-understand', 'Confirm switching to the "never" policy (no biometry ACL) without an interactive prompt')
         .action(async (bundleName, policyArg, opts) => {
         try {
@@ -2289,12 +2349,12 @@ Examples:
                 return;
             }
             bundle.policy = next;
-            // writeBundle evicts any broker-held copy, so tightening daily ->
+            // writeBundle evicts any broker-held copy, so tightening hold ->
             // always/never takes effect NOW: the next read re-prompts (`always`)
             // or reads its no-ACL item directly (`never`).
             writeBundle(bundle);
             console.log(chalk.green(`${bundle.name} policy set to ${next}.`));
-            if (next === 'daily') {
+            if (next === 'hold') {
                 console.log(chalk.gray('Held by the secrets-agent for ~7 days after one unlock (auto-cache is on by default; disable with `secrets.agent.auto: false` in agents.yaml).'));
             }
             else if (next === 'always') {
@@ -2369,11 +2429,11 @@ export function parsePolicyOpt(raw) {
     const v = (raw ?? 'always').toLowerCase();
     if (v === 'always' || v === 'biometry')
         return 'always';
-    if (v === 'daily' || v === 'session')
-        return 'daily';
+    if (v === 'hold' || v === 'daily' || v === 'session')
+        return 'hold';
     if (v === 'never' || v === 'none')
         return 'never';
-    throw new Error(`Invalid policy '${raw}'. Use 'always', 'daily', or 'never'.`);
+    throw new Error(`Invalid policy '${raw}'. Use 'always', 'hold', or 'never'.`);
 }
 /**
  * Gate a create/switch to the `never` prompt-policy behind an explicit,
@@ -2408,13 +2468,27 @@ async function confirmNeverPolicyInteractive(bundleName) {
     return confirm({ message: `Store '${bundleName}' WITHOUT biometry protection?`, default: false });
 }
 /** Validate a --backend value, exiting with a clear message on a bad one. */
-function parseBackendOpt(raw) {
-    const v = (raw ?? 'keychain').toLowerCase();
+export function secretsDefaultBackend() {
+    const raw = readMeta().secrets?.backend;
+    if (raw === undefined)
+        return 'keychain';
+    if (raw === 'keychain' || raw === 'file' || raw === 'vault')
+        return raw;
+    console.error(chalk.red(`Invalid secrets.backend '${raw}'. Use 'keychain', 'file', or 'vault'.`));
+    process.exit(1);
+}
+function parseBackendOpt(raw, defaultBackend = 'keychain') {
+    const v = (raw ?? defaultBackend).toLowerCase();
+    if (!raw && v === 'vault')
+        return 'vault';
     if (v === 'keychain' || v === 'file')
         return v;
     console.error(chalk.red(`Invalid --backend '${raw}'. Use 'keychain' or 'file'. For cross-machine file sync, pass --synced.`));
     process.exit(1);
 }
+function resolveBackendOpt(raw) {
+    return parseBackendOpt(raw, raw === undefined ? secretsDefaultBackend() : 'keychain');
+}
 /** Human-readable "locks in 3 hours" / "locks in 5 minutes" from an epoch-ms expiry. */
 function humanRemaining(expiresAt) {
     const ms = expiresAt - Date.now();

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

@@ -9,7 +9,8 @@
  * Built on {@link dynamicPicker}; every data source (discover, fleet, live index,
  * preview, resume dispatch) is reused from the existing sessions plumbing.
  */
-import type { SessionMeta } from '../lib/session/types.js';
+import { type SessionMeta } from '../lib/session/types.js';
+import type { ActiveSession } from '../lib/session/active.js';
 /**
  * The single canonical filter state. Every field has a flag equivalent, so the
  * same view is reachable interactively (hotkeys) or from the command line (flags).
@@ -59,11 +60,14 @@ export declare function activeBrowserSeed(opts: {
     agent?: string;
     host?: string[];
     since?: string;
+    all?: boolean;
 }): Partial<BrowserFilter>;
 /**
  * The initial filter for the bare interactive listing: current-repo subtree by
- * default (matches the static overview's cwd scoping), `--all` widens to every
- * directory, `--since` seeds the window.
+ * default (matches the static overview's cwd scoping). `--all` sets every
+ * non-status filter to its "all" value — every directory (project) AND all-time
+ * (window) — so one flag maxes the view; `--since` still overrides the window and
+ * `-a`/`--device` still narrow their axis.
  */
 export declare function bareBrowserSeed(opts: {
     teams?: boolean;
@@ -71,6 +75,44 @@ export declare function bareBrowserSeed(opts: {
     all?: boolean;
     since?: string;
 }): Partial<BrowserFilter>;
+/**
+ * A live session's stable row key: its session id when the agent reported one,
+ * else a per-machine handle so an id-less live session (a just-booted harness, a
+ * cloud task) still gets exactly one row instead of being dropped. Cloud rows key
+ * on the task id because they have no pid — keying them all on the machine alone
+ * would collapse two cloud tasks into one row, the same silent-drop this whole
+ * change exists to remove.
+ */
+export declare function liveRowKey(a: ActiveSession, self: string): string;
+/** Index live sessions by {@link liveRowKey} — the join key between the live scan
+ *  and the transcript pool. Id-carrying rows key on the session id, so a live row
+ *  and its transcript row collapse to one. */
+export declare function indexLiveRows(rows: ActiveSession[], self: string): Map<string, ActiveSession>;
+/**
+ * Project a live session onto the picker's row shape, for a session the transcript
+ * pool doesn't carry — a peer's session, a transcript outside the current window,
+ * or an agent that has not written one yet. `filePath` is the live transcript path
+ * when the scan resolved one and empty otherwise, which is what
+ * {@link handlePickedSession} keys "there is nothing to open yet" off.
+ */
+export declare function liveSessionToMeta(a: ActiveSession, self: string): SessionMeta;
+/**
+ * Fold the live scan INTO the transcript pool. The running filter used to be a
+ * pure intersection (`pool ∩ live`), which meant a session had to already be in
+ * the pool to be shown as running — so every session on another machine, and
+ * every local one outside the pool's window, was invisible in the browser while
+ * `--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[];
+/**
+ * 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.
+ * `liveCache` outlives a toggle of the `r` hotkey, so testing `live` alone would
+ * keep the column after running is turned back off, widening a plain transcript
+ * listing that has no live rows to explain it.
+ */
+export declare function shouldShowHostColumn(f: BrowserFilter, live: Map<string, ActiveSession> | null, rows: SessionMeta[]): boolean;
 /**
  * Launch the interactive session browser. `initial` seeds the filter (e.g.
  * `{ running: true }` for `--active`). Resolves after the user resumes a session

package/dist/commands/sessions-browser.js

@@ -9,14 +9,15 @@
  * Built on {@link dynamicPicker}; every data source (discover, fleet, live index,
  * preview, resume dispatch) is reused from the existing sessions plumbing.
  */
+import path from 'path';
 import { spawnSync } from 'child_process';
 import { dynamicPicker } from '../lib/picker.js';
-import { getActiveSessions } from '../lib/session/active.js';
+import { isSessionTrackedAgent } from '../lib/session/types.js';
 import { discoverSessions } from '../lib/session/discover.js';
 import { gatherRemoteList } from '../lib/session/remote-list.js';
 import { machineId, normalizeHost } from '../lib/session/sync/config.js';
 import { buildPreview } from './sessions-picker.js';
-import { formatPickerLabel, pickerColumnsFor, ticketLabel, mergeLocalFirst, indexActiveBySessionId, handlePickedSession, shouldIncludeLocal, remoteHostsToDial, } from './sessions.js';
+import { formatPickerLabel, pickerColumnsFor, ticketLabel, mergeLocalFirst, gatherActiveSessions, liveHostLabel, LIVE_ROW_PREFIX, cleanPreview, handlePickedSession, shouldIncludeLocal, remoteHostsToDial, } from './sessions.js';
 /** 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. */
@@ -102,20 +103,25 @@ export function activeBrowserSeed(opts) {
         agent: opts.agent,
         projectScope: 'all',
         device: normalizeDeviceSeed(opts.host?.[0]),
-        window: opts.since ?? '30d',
+        // --all widens the window to all-time (project is already 'all' here);
+        // --since still overrides.
+        window: opts.since ?? (opts.all ? undefined : '30d'),
     };
 }
 /**
  * The initial filter for the bare interactive listing: current-repo subtree by
- * default (matches the static overview's cwd scoping), `--all` widens to every
- * directory, `--since` seeds the window.
+ * default (matches the static overview's cwd scoping). `--all` sets every
+ * non-status filter to its "all" value — every directory (project) AND all-time
+ * (window) — so one flag maxes the view; `--since` still overrides the window and
+ * `-a`/`--device` still narrow their axis.
  */
 export function bareBrowserSeed(opts) {
     return {
         teams: !!opts.teams,
         agent: opts.agent,
+        // --all maxes every non-status filter: all dirs AND all-time. --since wins.
         projectScope: opts.all ? 'all' : 'repo',
-        window: opts.since ?? '30d',
+        window: opts.since ?? (opts.all ? undefined : '30d'),
     };
 }
 /** Copy text to the OS clipboard (best-effort; silently no-ops if unavailable). */
@@ -182,6 +188,99 @@ async function fetchRawPool(f, self, local, hosts) {
     }
     return { key: `${since ?? 'all'}|${f.teams}`, rows };
 }
+/**
+ * A live session's stable row key: its session id when the agent reported one,
+ * else a per-machine handle so an id-less live session (a just-booted harness, a
+ * cloud task) still gets exactly one row instead of being dropped. Cloud rows key
+ * on the task id because they have no pid — keying them all on the machine alone
+ * would collapse two cloud tasks into one row, the same silent-drop this whole
+ * change exists to remove.
+ */
+export function liveRowKey(a, self) {
+    if (a.sessionId)
+        return a.sessionId;
+    const handle = a.cloudTaskId ?? (a.pid != null ? String(a.pid) : 'unknown');
+    return `${LIVE_ROW_PREFIX}${a.machine ?? self}:${handle}`;
+}
+/** Index live sessions by {@link liveRowKey} — the join key between the live scan
+ *  and the transcript pool. Id-carrying rows key on the session id, so a live row
+ *  and its transcript row collapse to one. */
+export function indexLiveRows(rows, self) {
+    const byKey = new Map();
+    for (const a of rows)
+        byKey.set(liveRowKey(a, self), a);
+    return byKey;
+}
+/**
+ * Project a live session onto the picker's row shape, for a session the transcript
+ * pool doesn't carry — a peer's session, a transcript outside the current window,
+ * or an agent that has not written one yet. `filePath` is the live transcript path
+ * when the scan resolved one and empty otherwise, which is what
+ * {@link handlePickedSession} keys "there is nothing to open yet" off.
+ */
+export function liveSessionToMeta(a, self) {
+    const machine = a.machine ?? self;
+    const started = a.startedAtMs ?? a.lastActivityMs;
+    const topic = a.topic ?? a.preview;
+    return {
+        id: liveRowKey(a, self),
+        // No session id to short — name the row by what it IS (a cloud task, a pid),
+        // so the id column still identifies the process you'd go looking for.
+        shortId: a.sessionId
+            ? a.sessionId.slice(0, 8)
+            : a.cloudTaskId
+                ? a.cloudTaskId.slice(0, 8)
+                : `p:${a.pid ?? '?'}`,
+        agent: isSessionTrackedAgent(a.kind) ? a.kind : 'claude',
+        timestamp: new Date(started ?? Date.now()).toISOString(),
+        lastActivity: a.lastActivityMs ? new Date(a.lastActivityMs).toISOString() : undefined,
+        project: a.cwd ? path.basename(a.cwd) : undefined,
+        cwd: a.cwd,
+        filePath: a.sessionFile ?? '',
+        // A live topic is raw transcript text: a newline in it would break the row
+        // into two and misalign every column after it. Indexed rows are already
+        // cleaned at scan time, so this puts projected rows on the same footing.
+        topic: topic ? cleanPreview(topic) : undefined,
+        label: a.label ? cleanPreview(a.label) : undefined,
+        machine,
+        // Reading/resuming a peer's session hops back over SSH — same contract the
+        // cross-machine listing sets, so handlePickedSession routes it correctly.
+        _remote: machine !== self,
+        prUrl: a.pr?.url,
+        prNumber: a.pr?.number,
+        ticketId: a.ticket?.id,
+        worktreeSlug: a.worktree?.slug,
+    };
+}
+/**
+ * Fold the live scan INTO the transcript pool. The running filter used to be a
+ * pure intersection (`pool ∩ live`), which meant a session had to already be in
+ * the pool to be shown as running — so every session on another machine, and
+ * every local one outside the pool's window, was invisible in the browser while
+ * `--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) {
+    const known = new Set(rows.map((r) => r.id));
+    const extra = [];
+    for (const [key, a] of live) {
+        if (!known.has(key))
+            extra.push(liveSessionToMeta(a, self));
+    }
+    return extra.length === 0 ? rows : mergeLocalFirst([...rows, ...extra], self);
+}
+/**
+ * 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.
+ * `liveCache` outlives a toggle of the `r` hotkey, so testing `live` alone would
+ * keep the column after running is turned back off, widening a plain transcript
+ * listing that has no live rows to explain it.
+ */
+export function shouldShowHostColumn(f, live, rows) {
+    if (!f.running || !live)
+        return false;
+    return rows.some((r) => liveHostLabel(live.get(r.id)) !== '');
+}
 /** Apply the cheap in-memory filters (agent / device / project / running). */
 function applyFilters(rows, live, f, self) {
     let out = rows;
@@ -269,11 +368,14 @@ export async function runSessionBrowser(initial = {}, opts = {}) {
                 return []; // superseded — don't touch shared state
             pool = fetched;
         }
-        // Only pay for the live scan when the running filter needs it.
+        // Only pay for the live scan when the running filter needs it. Same fleet
+        // sweep the static `--active` view uses, so the two never disagree about
+        // what is running.
         let live = liveCache;
         if (f.running && !live) {
             try {
-                live = indexActiveBySessionId(await getActiveSessions());
+                const { sessions } = await gatherActiveSessions({ local, hosts });
+                live = indexLiveRows(sessions, self);
             }
             catch {
                 live = new Map();
@@ -286,10 +388,14 @@ export async function runSessionBrowser(initial = {}, opts = {}) {
         rawCache = pool;
         if (live)
             liveCache = live;
-        agentsInPool = distinct(pool.rows.map((r) => r.agent));
-        devicesInPool = distinct(pool.rows.map((r) => r.machine ?? self));
-        const filtered = applyFilters(pool.rows, live ?? new Map(), f, self);
+        // 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;
+        agentsInPool = distinct(rows.map((r) => r.agent));
+        devicesInPool = distinct(rows.map((r) => r.machine ?? self));
+        const filtered = applyFilters(rows, live ?? new Map(), f, self);
         cols = pickerColumnsFor(filtered);
+        cols.showHost = shouldShowHostColumn(f, live, filtered);
         return filtered;
     };
     const picked = await dynamicPicker({
@@ -297,7 +403,7 @@ export async function runSessionBrowser(initial = {}, opts = {}) {
         initialFilter,
         load,
         keyFor: (s) => s.id,
-        labelFor: (s, q) => formatPickerLabel(s, q, cols, sshOriginTagFor(liveCache, s.id)),
+        labelFor: (s, q) => formatPickerLabel(s, q, cols, sshOriginTagFor(liveCache, s.id), liveHostLabel(liveCache?.get(s.id))),
         matches: sessionMatchesQuery,
         buildPreview,
         headerFor,

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

@@ -1,2 +1,5 @@
 import type { Command } from 'commander';
+import type { SessionMeta } from '../lib/session/types.js';
 export declare function registerSessionsExportCommand(sessionsCmd: Command): void;
+/** ids > query > everything-in-scope. Exported for the id-resolution test. */
+export declare function selectSessions(metas: SessionMeta[], selectors: string[]): SessionMeta[];