@phnx-labs/agents-cli 1.22.52 → 1.22.54

package/dist/commands/monitors.js

@@ -24,6 +24,7 @@ import { IS_WINDOWS } from '../lib/platform/index.js';
 import { safeJoin } from '../lib/paths.js';
 import { machineId, normalizeHost } from '../lib/machine-id.js';
 import { loadDevices } from '../lib/devices/registry.js';
+import { assertDaemonEnabled } from '../lib/device-config.js';
 import { setHelpSections } from '../lib/help.js';
 import { isInteractiveTerminal, requireInteractiveSelection } from './utils.js';
 function stdoutJson(payload) {
@@ -52,6 +53,26 @@ function sourceLabel(source) {
             return source.type;
     }
 }
+/** Warn when a run/routine action has no postcondition — completed-exit-0 still records as ok (PHNX-2842). */
+function warnMissingPostcondition(action) {
+    if ((action.type === 'run' || action.type === 'routine') && !action.postcondition) {
+        stderrLine(chalk.yellow(`  Note: ${action.type} has no --postcondition — a completed agent that did nothing will still record as ok. Add --postcondition '<cmd>' that exits 0 when the intended effect happened.`));
+    }
+}
+/** Reconciled one-line outcome for a fire (ok / no effect / failed). */
+function fireOutcomeDisplay(name, f) {
+    const rec = resolveFireOutcome(name, f);
+    if (rec.ok)
+        return { label: chalk.green('ok'), note: '' };
+    if (rec.effect === 'none') {
+        const note = rec.error ? chalk.gray(`    ${rec.error}`) : '';
+        return { label: chalk.yellow('no effect'), note };
+    }
+    const corrected = f.ok !== false && rec.runStatus
+        ? chalk.yellow(` (run ${rec.runStatus})`)
+        : '';
+    return { label: chalk.red('failed') + corrected, note: '' };
+}
 /** A one-line human label for a monitor's action. */
 function actionLabel(action) {
     switch (action.type) {
@@ -123,12 +144,26 @@ function livenessLabel(monitor, state, liveness) {
     }
     return chalk.gray(`checked ${liveness.checkCount}x · last ${checkedAgo} · no match yet`);
 }
-/** Start or reload the background daemon so a newly-added monitor is watched. */
+/**
+ * Start or reload the background daemon so a newly-added monitor is watched.
+ * Returns false when auto-start was refused (`daemon.enabled=false`); the add
+ * itself already succeeded — the monitor is config and stays valid fleet-wide.
+ * The refusal names the setting and the fix. Mirrors `ensureSchedulerRunning`
+ * in commands/routines.ts (PHNX-2637).
+ */
 function ensureDaemonRunning() {
+    try {
+        assertDaemonEnabled();
+    }
+    catch (err) {
+        // Loud stated skip, on stderr so --json stdout stays clean.
+        stderrLine(chalk.yellow(err.message));
+        return false;
+    }
     if (isDaemonRunning()) {
         signalDaemonReload();
         stderrLine(chalk.gray('Daemon reloaded'));
-        return;
+        return true;
     }
     const result = startDaemon();
     if (result.pid) {
@@ -138,6 +173,7 @@ function ensureDaemonRunning() {
     else {
         stderrLine(chalk.yellow('Could not start the daemon. Start it manually with: agents routines start'));
     }
+    return true;
 }
 /**
  * Assert the postcondition of `add`: the engine actually picked the monitor up.
@@ -272,10 +308,16 @@ function buildAction(options) {
             action.effort = options.effort;
         if (options.actionTimeout)
             action.timeout = options.actionTimeout;
+        if (options.postcondition)
+            action.postcondition = options.postcondition;
+        chosen.push(action);
+    }
+    if (options.routine) {
+        const action = { type: 'routine', routine: options.routine };
+        if (options.postcondition)
+            action.postcondition = options.postcondition;
         chosen.push(action);
     }
-    if (options.routine)
-        chosen.push({ type: 'routine', routine: options.routine });
     if (options.notify !== undefined) {
         // --notify may be a bare flag (notify the owner) or carry a channel that
         // overrides notify.owner.channel. Left unset, the send resolves the owner
@@ -293,6 +335,10 @@ function buildAction(options) {
         stderrLine(chalk.red(`Exactly one action is allowed; got ${chosen.map((c) => c.type).join(', ')}`));
         process.exit(1);
     }
+    if (options.postcondition && chosen[0].type !== 'run' && chosen[0].type !== 'routine') {
+        stderrLine(chalk.red('--postcondition only applies to --run or --routine'));
+        process.exit(1);
+    }
     return chosen[0];
 }
 /** Interactive monitor picker. Returns the selected name or null on cancel/empty. */
@@ -379,7 +425,7 @@ async function guardAgainstDuplicateMonitor(config, force) {
 export function registerMonitorsCommands(program) {
     const monitorsCmd = program
         .command('monitors')
-        .description('Durable event-triggered watchers: watch a source, detect a change, fire an action. The daemon auto-starts on first add.');
+        .description('Durable event-triggered watchers: watch a source, detect a change, fire an action. The daemon auto-starts on first add unless daemon.enabled is false.');
     setHelpSections(monitorsCmd, {
         examples: `
       # CI went red → triage it (poll a command, diff, fire an agent)
@@ -388,6 +434,12 @@ export function registerMonitorsCommands(program) {
         --run claude --prompt 'CI failed on #1119: {event}. Diagnose and fix.' \\
         --device yosemite-s0
 
+      # Merge-on-green: the fire is ok only if the PR actually merged
+      agents monitors add merge-1682 \\
+        --poll 'gh pr view 1682 --json state --jq .state' 2m --match OPEN \\
+        --run claude --prompt 'Rebase-merge #1682: {event}' \\
+        --postcondition 'gh pr view 1682 --json state --jq .state | grep -qx MERGED'
+
       # SSL cert issued → notify (poll an HTTPS endpoint every 8h)
       agents monitors add cert-issued \\
         --poll-http 'https://secure.ssl.com/team/.../co-ec1l5dgjofa' 8h \\
@@ -406,10 +458,14 @@ export function registerMonitorsCommands(program) {
         - SOURCE    (--watch, --poll, --poll-http, --ws, --watch-file, --watch-device, --on)
         - CONDITION (--on-change [default], --match <re>, --every; --dedupe-key)
         - ACTION    (--run <agent> --prompt, --routine, --notify, --webhook-out)
+                    --postcondition <cmd> on --run/--routine asserts the effect
+                    happened (exit 0) after the agent settles; otherwise the
+                    fire records as "no effect", not ok.
 
       The fired event is injected into a run/routine prompt as {event}.
       Pin the single OWNER device with --device (exactly-once). The daemon (shared
-      with routines) auto-starts on first add; manage it with 'agents routines start|stop'.
+      with routines) auto-starts on first add unless daemon.enabled is false on this
+      device; manage it with 'agents daemon start|stop' (or 'agents routines start|stop').
 
       v1 evaluates poll sources (command, poll, poll-http, file, device). Push
       sources (ws, webhook) are accepted but delivered through a receiver wired in
@@ -419,7 +475,7 @@ export function registerMonitorsCommands(program) {
     // ─── add ────────────────────────────────────────────────────────────────────
     monitorsCmd
         .command('add [nameOrPath]')
-        .description('Create a monitor from inline flags or a YAML file. Auto-starts the daemon.')
+        .description('Create a monitor from inline flags or a YAML file. Auto-starts the daemon unless daemon.enabled is false.')
         // SOURCE
         .option('--watch <cmd>', 'Run a shell command; its stdout is the observation')
         .option('--poll <cmd...>', 'Re-run a command every interval: --poll "<cmd>" <interval> (e.g. 30s)')
@@ -445,6 +501,7 @@ export function registerMonitorsCommands(program) {
         .option('--mode <mode>', 'Execution mode for --run: plan, edit, auto, or skip')
         .option('--effort <effort>', 'Reasoning effort for --run: low | medium | high | xhigh | max | auto')
         .option('--action-timeout <t>', 'Kill the --run action if it runs longer than this (e.g. 10m)')
+        .option('--postcondition <cmd>', 'Shell command that must exit 0 after a --run/--routine action settles; otherwise the fire records as no-effect, not ok. {event} is replaced with the fired event summary')
         .option('--routine <name>', 'Fire an existing routine on change')
         .option('--notify [channel]', 'Notify the owner (notify.owner); [channel] overrides the owner channel')
         .option('--webhook-out <url>', 'POST the event to this URL')
@@ -481,8 +538,9 @@ export function registerMonitorsCommands(program) {
             await guardAgainstDuplicateMonitor(config, options.force === true);
             writeMonitor(config);
             console.log(chalk.green(`Monitor '${name}' added`));
-            ensureDaemonRunning();
-            await assertEnginePickup(config);
+            warnMissingPostcondition(config.action);
+            if (ensureDaemonRunning())
+                await assertEnginePickup(config);
             return;
         }
         if (!nameOrPath) {
@@ -556,8 +614,9 @@ export function registerMonitorsCommands(program) {
         writeMonitor(config);
         console.log(chalk.green(`Monitor '${nameOrPath}' added`));
         console.log(chalk.gray(`  ${sourceLabel(source)} → [${condition.mode}] → ${actionLabel(action)} · owner: ${ownerLabel(config)}`));
-        ensureDaemonRunning();
-        await assertEnginePickup(config);
+        warnMissingPostcondition(action);
+        if (ensureDaemonRunning())
+            await assertEnginePickup(config);
     });
     // ─── list ────────────────────────────────────────────────────────────────────
     monitorsCmd
@@ -641,7 +700,7 @@ export function registerMonitorsCommands(program) {
                 state,
                 liveness,
                 stalled: isStalled(monitor, liveness),
-                recentFires,
+                recentFires: recentFires.map((f) => ({ ...f, reconciled: resolveFireOutcome(name, f) })),
             });
             return;
         }
@@ -671,9 +730,11 @@ export function registerMonitorsCommands(program) {
         if (recentFires.length > 0) {
             console.log(chalk.bold('\nRecent fires'));
             for (const f of recentFires) {
-                // Reconciled against the run's real status — see `runs`, above (RUSH-2690).
-                const { ok } = resolveFireOutcome(name, f);
-                console.log(`  ${chalk.gray(f.firedAt)}  ${f.action ?? '?'}  ${ok ? chalk.green('ok') : chalk.red('failed')}`);
+                // Reconciled against the run's real status + postcondition (RUSH-2690, PHNX-2842).
+                const { label, note } = fireOutcomeDisplay(name, f);
+                console.log(`  ${chalk.gray(f.firedAt)}  ${f.action ?? '?'}  ${label}`);
+                if (note)
+                    console.log(note);
             }
         }
     });
@@ -847,23 +908,17 @@ export function registerMonitorsCommands(program) {
         }
         console.log(chalk.bold(`Fire history: ${name}\n`));
         for (const f of fires.slice(-20)) {
-            // Reconcile against the run's REAL, current status (RUSH-2690) rather
-            // than trusting the frozen `ok` written at fire time — `dispatchAction`
-            // only sees a synchronous 'running' snapshot before the run has
-            // actually settled, so a run that later fails/times out/never produces
-            // output would otherwise read `ok` here forever while `agents monitors
-            // logs` (which reads the run record fresh) already shows the truth.
-            const { ok, runStatus } = resolveFireOutcome(name, f);
-            const outcome = ok ? chalk.green('ok') : chalk.red('failed');
-            // Surface the divergence explicitly when the frozen write disagreed
-            // with the reconciled read — the exact "fire says ok, run says
-            // otherwise" symptom RUSH-2690 reported.
-            const corrected = f.ok !== false && !ok && runStatus
-                ? chalk.yellow(` (run ${runStatus})`)
-                : '';
+            // Reconcile against the run's REAL, current status (RUSH-2690) and a
+            // declared postcondition (PHNX-2842) rather than trusting the frozen
+            // `ok` written at fire time — `dispatchAction` only sees a synchronous
+            // 'running' snapshot before the run has actually settled, and a
+            // `completed` agent that did nothing used to read `ok` here forever.
+            const { label, note } = fireOutcomeDisplay(name, f);
             const runRef = f.runId ? chalk.gray(`  run ${f.runId}`) : '';
-            console.log(`  ${f.firedAt}  ${(f.action ?? '?').padEnd(12)} ${outcome}${corrected}${runRef}`);
+            console.log(`  ${f.firedAt}  ${(f.action ?? '?').padEnd(12)} ${label}${runRef}`);
             console.log(chalk.gray(`    ${f.summary.slice(0, 100)}`));
+            if (note)
+                console.log(note);
         }
     });
     // ─── pause / resume ───────────────────────────────────────────────────────────

package/dist/commands/output.js

@@ -42,8 +42,14 @@ The burn is split into input / cache-read / cache-write where the harness record
 (Claude/Codex/Gemini/Droid). --pricing no-cache reprices cached tokens at the input rate,
 so you can see what caching is saving. --json always carries both actual and no-cache costs.
 `)
-        .action(async (options) => {
-        await outputAction(options);
+        // Read opts via optsWithGlobals(): `--json`/`--since`/`--by` collide by name
+        // with the `insights` parent's own options, so commander binds them to the
+        // parent at parse time and the leaf's plain opts() never sees them. Merging
+        // ancestor opts is what the sibling `insights mix` recipes already do
+        // (mix-commands.ts) — without it every flag on this command is silently
+        // dropped (e.g. `agents insights output --json` printed the human table).
+        .action(async (_options, command) => {
+        await outputAction(command.optsWithGlobals());
     });
 }
 function resolveGroup(by) {

package/dist/commands/repo.js

@@ -1052,6 +1052,14 @@ export function registerRepoCommands(program) {
             ].filter(Boolean);
             if (parts.length > 0)
                 console.log(chalk.gray(`Device policy: ${parts.join(' · ')}`));
+            const { syncReservedAuthBundle } = await import('../lib/secrets/reserved-sync.js');
+            const auth = syncReservedAuthBundle();
+            if (auth.pushed.length > 0) {
+                console.log(chalk.gray(`Auth bundle: pushed to ${auth.pushed.join(', ')}`));
+            }
+            for (const err of auth.errors) {
+                console.error(chalk.yellow(`Auth bundle: ${err.device}: ${err.message}`));
+            }
         }
     });
     repoCmd
@@ -1091,6 +1099,16 @@ export function registerRepoCommands(program) {
             const result = await commitAndPush(t.dir, options.message);
             if (result.success) {
                 spinner.succeed(`${formatRepoTarget(t.alias, t.dir, result.branch)}: ${result.detail ?? 'pushed'}`);
+                if (t.alias === 'user') {
+                    const { syncReservedAuthBundle } = await import('../lib/secrets/reserved-sync.js');
+                    const auth = syncReservedAuthBundle();
+                    if (auth.pushed.length > 0) {
+                        console.log(chalk.gray(`Auth bundle: pushed to ${auth.pushed.join(', ')}`));
+                    }
+                    for (const err of auth.errors) {
+                        console.error(chalk.yellow(`Auth bundle: ${err.device}: ${err.message}`));
+                    }
+                }
             }
             else {
                 spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${result.error}`);

package/dist/commands/secrets.js

@@ -18,7 +18,7 @@ import { ensureDaemonStarted, isDaemonRunning } from '../lib/daemon/daemon.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, isAgentInvocationContext, migrateLegacyBundles, parseDotenv, readAndResolveBundleEnv, readBundle, readBundleIfDecryptable, reAclBundleItems, renameBundle, rotateBundleSecret, sanitizeProcessEnv, validateBundleName, validateEnvKey, validateExpiresFutureDated, validateSecretType, writeBundle, writeBundleWithItems, SECRET_TYPES, } from '../lib/secrets/bundles.js';
+import { bundleBackend, bundleExists, bundleItemStore, bundlePolicy, deleteBundle, describeBundle, keychainItemsForBundle, keychainRef, listBundles, healKeychainBundleMetadataAclOnce, isHeadlessSecretsContext, isAgentInvocationContext, migrateLegacyBundles, parseDotenv, readAndResolveBundleEnv, readBundle, readBundleIfDecryptable, reAclBundleItems, renameBundle, rotateBundleSecret, sanitizeProcessEnv, validateBundleName, validateEnvKey, validateExpiresFutureDated, validateSecretType, writeBundle, writeBundleWithItems, assertFileBundleDecryptable, isReservedBundleName, ReservedBundleWrongBackendError, 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';
 import { getKeychainToken, hasKeychainToken, secretsKeychainItem, setKeychainToken, maybeAutoRekey, } from '../lib/secrets/index.js';
@@ -846,7 +846,12 @@ export function renderExpiringCol(b, now = Date.now()) {
  * exists to describe. `--force` already means "overwrite what is there".
  */
 export function resolveImportBundle(name, backendOpt, synced = false, force = false) {
-    const requestedBackend = synced ? 'vault' : resolveBackendOpt(backendOpt);
+    if (isReservedBundleName(name) && (synced || (backendOpt && backendOpt !== 'file'))) {
+        throw new ReservedBundleWrongBackendError(name, synced ? 'vault' : resolveBackendOpt(backendOpt));
+    }
+    const requestedBackend = isReservedBundleName(name)
+        ? 'file'
+        : (synced ? 'vault' : resolveBackendOpt(backendOpt));
     if (bundleExists(name)) {
         // readBundleIfDecryptable nulls ONLY on BundleUndecryptableError; a locked
         // keychain or logged-out vault still throws, so a recoverable state can
@@ -892,6 +897,9 @@ function applyEnvToBundle(bundle, env, opts) {
     else {
         writeBundle(bundle);
     }
+    if (added > 0) {
+        assertFileBundleDecryptable(bundle.name, Object.keys(env).filter((k) => k in bundle.vars));
+    }
     return { added, skipped };
 }
 /** Register the `agents secrets` command tree. */
@@ -1581,7 +1589,16 @@ export function registerSecretsCommands(program) {
             // inherits the configured default (`hold`) instead of being pinned.
             const policyOpt = opts.policy ?? opts.tier;
             const policy = policyOpt ? parsePolicyOpt(policyOpt) : undefined;
-            const backend = opts.synced ? 'vault' : resolveBackendOpt(opts.backend);
+            let backend = opts.synced ? 'vault' : resolveBackendOpt(opts.backend);
+            if (isReservedBundleName(resolvedName)) {
+                // Reserved `auth` is file-backed by construction. Omitting --backend
+                // still forces file even when agents.yaml defaults to keychain; an
+                // explicit non-file backend fails loud (SEC-GAP-3).
+                if (opts.synced || (opts.backend && opts.backend !== 'file')) {
+                    throw new ReservedBundleWrongBackendError(resolvedName, backend);
+                }
+                backend = 'file';
+            }
             if (bundleExists(resolvedName) && !opts.force) {
                 console.error(chalk.red(`Bundle '${resolvedName}' already exists. Use --force to overwrite.`));
                 process.exit(1);
@@ -2134,7 +2151,7 @@ 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('--device <target...>', 'Push the bundle over SSH to this device (host alias or user@host); repeatable for multiple machines')
-        .option('--remote-backend <backend>', 'Backend for the bundle on the remote device (with --device): keychain (default) or file. file is headless-readable via the remote\'s machine-local key; it forwards AGENTS_SECRETS_PASSPHRASE over stdin only if set (opt-in).', 'keychain')
+        .option('--remote-backend <backend>', 'Backend for the bundle on the remote device (with --device): keychain (default) or file. file is headless-readable via the remote\'s machine-local key and never forwards AGENTS_SECRETS_PASSPHRASE.', 'keychain')
         .option('--force', 'Overwrite existing keys/items on the target (used with --to-1password and --device)')
         .option('--to-file <path>', `Write the bundle as an AES-256-GCM encrypted offline file (needs ${SYNC_PASSPHRASE_ENV}; symmetric counterpart of import --from-file)`)
         .action(async (bundleName, opts) => {
@@ -2170,15 +2187,18 @@ Examples:
                     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. Forcing a shared passphrase would
-                // defeat headless reads, so we no longer require one.
-                const remotePassphrase = remoteBackend === 'file' ? (process.env.AGENTS_SECRETS_PASSPHRASE ?? '') : '';
+                let remoteBackend = parsedBackend;
+                if (isReservedBundleName(resolvedBundleName)) {
+                    if (opts.remoteBackend && opts.remoteBackend !== 'file') {
+                        throw new ReservedBundleWrongBackendError(resolvedBundleName, parsedBackend);
+                    }
+                    remoteBackend = 'file';
+                }
+                // File-backend export NEVER forwards AGENTS_SECRETS_PASSPHRASE
+                // (PHNX-2371). Forwarding it keys the remote ciphertext to a secret
+                // the destination daemon does not hold, so later headless reads fail
+                // while import still prints "Imported N key(s)". The remote
+                // auto-provisions its own machine-local key instead.
                 // Resolve ONCE for N hosts — reading a bundle can prompt, and doing it
                 // per host would prompt per host.
                 //
@@ -2197,7 +2217,6 @@ Examples:
                     const out = pushResolvedBundleToHost(resolvedForPush, resolvedBundleName, host, {
                         remoteBackend,
                         force: opts.force,
-                        passphrase: remotePassphrase,
                         operation: 'ssh export',
                     });
                     if (!out.ok) {

package/dist/commands/sessions-inject.js

@@ -26,7 +26,11 @@ async function resolveTarget(sessionId) {
     const resolution = resolveInjectTargetForSession(match);
     if (!resolution.addressable) {
         // Surface the resolver's precise reason (host/rail), not a generic "not tmux".
-        return { target: null, reason: `Session "${sessionId}": ${resolution.reason}` };
+        return {
+            target: null,
+            reason: `Session "${sessionId}": ${resolution.reason}`,
+            hint: resolution.hint,
+        };
     }
     return { target: resolution.target };
 }
@@ -43,10 +47,11 @@ async function runInject(sessionId, text, options) {
     else {
         const resolved = await resolveTarget(sessionId);
         if (!resolved.target) {
+            const message = resolved.hint ? `${resolved.reason}\n${resolved.hint}` : resolved.reason;
             if (options.json)
-                console.log(JSON.stringify({ ok: false, error: resolved.reason }));
+                console.log(JSON.stringify({ ok: false, error: message }));
             else
-                console.error(chalk.red(resolved.reason));
+                console.error(chalk.red(message));
             process.exit(1);
         }
         target = resolved.target;

package/dist/commands/sessions-picker.js

@@ -9,6 +9,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import { truncate, humanDuration } from '../lib/format.js';
+import { sessionDisplayAgent } from '../lib/session/types.js';
 import { fetchPeerPreviewDigest } from '../lib/session/remote-list.js';
 import { parseSession, sanitizeForTerminal, SNAPSHOT_TODO_TOOLS } from '../lib/session/parse.js';
 import { safeTeamText } from '../lib/session/team-filter.js';
@@ -404,7 +405,7 @@ function formatHeader(session, events) {
     const { createdAgo, lastActiveAgo, duration } = extractTiming(session, events);
     // Line 1: Agent v version · shortId · model · account
     const line1 = [];
-    line1.push(chalk.gray(`${displayAgent(session.agent)}${session.version ? ` v${session.version}` : ''}`));
+    line1.push(chalk.gray(`${displayAgent(sessionDisplayAgent(session))}${session.version ? ` v${session.version}` : ''}`));
     if (session.shortId)
         line1.push(chalk.dim(session.shortId));
     if (model)

package/dist/commands/sessions.d.ts

@@ -676,7 +676,7 @@ export declare function formatPickerLabel(s: SessionMeta, query: string, cols?:
  * so it stays fixed across the picker's re-renders within a single run.
  */
 export declare function formatPickerTip(sessions: SessionMeta[]): string;
-export declare function pickSessionInteractive(sessions: SessionMeta[], message?: string, initialSearch?: string, hiddenCount?: number, enterHint?: string): Promise<PickedSession | null>;
+export declare function pickSessionInteractive(sessions: SessionMeta[], message?: string, initialSearch?: string, hiddenCount?: number, enterHint?: string, scope?: SessionSearchScope): Promise<PickedSession | null>;
 /**
  * Row-id prefix for a live session whose agent has not reported a session id yet
  * (a booting harness, a queued teammate). The browser lists these so nothing live
@@ -736,6 +736,16 @@ interface AgentFilter {
  * alias and single-typo rules. Kept pure so focus and the browser cannot drift. */
 export declare function resolveSessionAgentName(name: string): SessionAgentId | null;
 export declare function parseAgentFilter(agentName?: string): AgentFilter;
+/**
+ * Explicit `--agent` / `--project` / `--routine` flags. Distinct from the
+ * listing pool (cwd-scoped, default-capped) that PHNX-2767 hydrates past:
+ * these flags MUST still exclude FTS hits after that union.
+ */
+export type SessionSearchScope = {
+    agent?: string;
+    project?: string;
+    routine?: boolean | string;
+};
 /**
  * How a `sessions <query>` argument was resolved against the pool.
  *
@@ -759,29 +769,27 @@ export interface SessionQueryResolution {
  */
 export declare function resolveSessionQuery(pool: SessionMeta[], query: string, options?: {
     indexFallback?: boolean;
+    scope?: SessionSearchScope;
 }): SessionQueryResolution;
 /** Honest result of a fleet sweep that found nothing: it says what the sweep
  * actually did — how many peers answered, which were unreachable — instead of
  * dead-ending on "search with --device <host>" after the search already ran. */
 export declare function fleetNotFoundMessage(query: string, deviceCount: number, unreachable: string[]): string[];
 /** Filter and rank sessions by a multi-term search query across metadata and content. */
-export declare function filterSessionsByQuery(sessions: SessionMeta[], query: string | undefined): SessionMeta[];
+export declare function filterSessionsByQuery(sessions: SessionMeta[], query: string | undefined, scope?: SessionSearchScope): SessionMeta[];
 /**
  * Narrow a session list by --project and --agent before search resolution.
  * Without this, a query like "scoped search" could match sessions in BOTH
  * the project you specified AND elsewhere, producing an ambiguity error
  * even though the user already pointed at the correct scope.
+ *
+ * PHNX-2767 hydrates FTS hits missing from the listing pool *after* this
+ * runs, so callers that search must also pass the same scope into
+ * `filterSessionsByQuery` / `scopedContentIndex` or the union
+ * reintroduces the rows this function just dropped.
  */
-export declare function applyScopeFilters(sessions: SessionMeta[], scope: {
-    agent?: string;
-    project?: string;
-    routine?: boolean | string;
-}): SessionMeta[];
-export declare function artifactLookupScope(agent?: string, project?: string, routine?: boolean | string): {
-    agent?: string;
-    project?: string;
-    routine?: boolean | string;
-};
+export declare function applyScopeFilters(sessions: SessionMeta[], scope: SessionSearchScope): SessionMeta[];
+export declare function artifactLookupScope(agent?: string, project?: string, routine?: boolean | string): SessionSearchScope;
 /**
  * Whether a missed local id lookup should widen to a cross-machine sweep.
  *