@phnx-labs/agents-cli 1.22.47 → 1.22.49

package/dist/lib/session/highlights.d.ts

@@ -10,7 +10,7 @@
  * bounded `.git` walk over a handful of candidate dirs) and is the only
  * non-pure function here.
  */
-import type { SessionEvent } from './types.js';
+import type { SessionAgentId, SessionEvent } from './types.js';
 import { type FileChange } from './digest.js';
 export interface SkillUse {
     name: string;
@@ -100,3 +100,51 @@ export declare function extractArtifacts(changes: FileChange[]): ProducedArtifac
  * happens to run in, which is a wrong answer, not a degraded one.
  */
 export declare function extractRepos(events: SessionEvent[], cwd?: string): string[];
+/**
+ * True when this harness records backgrounded shells at all. Callers MUST gate
+ * on this before rendering a count: for a harness that cannot report it, "0" is
+ * a lie ("none running") where the truth is "unknown", so the segment is omitted
+ * entirely — the same way the Hooks line renders for Claude only.
+ */
+export declare function harnessTracksBackgroundShells(agent: SessionAgentId): boolean;
+/**
+ * True for a tool_use event that starts a background shell. Exported for the
+ * same reason {@link isSkillInvocation} is: the incremental parser can select
+ * matching events while streaming instead of re-reading the transcript.
+ */
+export declare function isBackgroundShellStart(e: SessionEvent): boolean;
+export interface BackgroundShell {
+    /** The command line as invoked, trimmed for display. */
+    command: string;
+    timestamp: string;
+}
+/**
+ * Shells the session started in the background, oldest first.
+ *
+ * This is "started", NOT "still running". A transcript records the start and
+ * never the death, and inferring liveness from its absence is the same trap
+ * `agents devices ps` documents — a killed process leaves no marker, so a naive
+ * reader reports "running" forever. Live status belongs to `sessions --active`,
+ * which resolves real pids.
+ */
+export declare function extractBackgroundShells(events: SessionEvent[]): BackgroundShell[];
+/**
+ * True for a tool call that spawns another agent. Deliberately counts BOTH
+ * shapes, because both are fan-out the operator needs to see:
+ *
+ *   in-process   an `Agent` / `Task` tool call inside this transcript
+ *   shelled-out  a Bash command that invokes `agents run`, `agents cloud run`,
+ *                or `agents teams add|start`
+ *
+ * Moved here from `commands/sessions-picker.ts` so BOTH preview body paths (the
+ * digest body and `formatMetaOnlyBody`) share one definition instead of
+ * drifting apart. Semantics are unchanged: session f045b577 counts 23
+ * in-process + 30 shelled-out = 53.
+ *
+ * The full summary's `Subagents (N)` section (`render.ts`) deliberately does NOT
+ * use this. It builds a described ROSTER, so it needs `args.description` /
+ * `args.prompt` and is necessarily limited to in-process `Agent`/`Task` calls —
+ * a shelled-out `agents run` carries no such description. Different question,
+ * different answer; do not "unify" them.
+ */
+export declare function isSubAgentTool(tool: string, command: string): boolean;

package/dist/lib/session/highlights.js

@@ -294,3 +294,98 @@ export function extractRepos(events, cwd) {
     }
     return repos;
 }
+// ── Background shells ─────────────────────────────────────────────────────────
+/**
+ * Per-harness shape of "start this shell command in the background", keyed the
+ * same way {@link SKILL_TOOL_NAME_BY_AGENT} is: one table entry per harness that
+ * has the capability, so adding a harness is a row and never another `else if`.
+ *
+ * An absent entry means "this harness cannot report it", which the renders must
+ * show as ABSENCE, never as a count of zero. Every absence below was probed
+ * against that harness's real transcripts on this fleet rather than assumed:
+ *
+ *   codex        0 of 176 session files carry any background marker; its `exec` /
+ *                `exec_command` record only `cmd` + `workdir`, no shell handle.
+ *   droid        0 of 126 session files.
+ *   antigravity  0 of 54 session files.
+ *   opencode     0 of 79 session files.
+ *   cursor       stores no tool calls locally at all — only `meta.json` and
+ *                `prompt_history.json`; the calls live server-side.
+ *
+ * Not probed, because no version home is installed on this fleet to probe:
+ * `muse`, `rush`, `hermes`, `openclaw`, `gemini`. They are absent for lack of
+ * evidence, NOT on a verified negative — add a row once one is confirmed, and
+ * until then absence renders as "unknown", which is the safe direction.
+ */
+const BACKGROUND_SHELL_BY_AGENT = {
+    claude: { tool: 'Bash', flag: 'run_in_background' },
+    kimi: { tool: 'Bash', flag: 'run_in_background' },
+    grok: { tool: 'run_terminal_command', flag: 'background' },
+};
+/**
+ * True when this harness records backgrounded shells at all. Callers MUST gate
+ * on this before rendering a count: for a harness that cannot report it, "0" is
+ * a lie ("none running") where the truth is "unknown", so the segment is omitted
+ * entirely — the same way the Hooks line renders for Claude only.
+ */
+export function harnessTracksBackgroundShells(agent) {
+    return BACKGROUND_SHELL_BY_AGENT[agent] !== undefined;
+}
+/**
+ * True for a tool_use event that starts a background shell. Exported for the
+ * same reason {@link isSkillInvocation} is: the incremental parser can select
+ * matching events while streaming instead of re-reading the transcript.
+ */
+export function isBackgroundShellStart(e) {
+    if (e.type !== 'tool_use' || e._local)
+        return false;
+    const spec = BACKGROUND_SHELL_BY_AGENT[e.agent];
+    return !!spec && e.tool === spec.tool && e.args?.[spec.flag] === true;
+}
+/**
+ * Shells the session started in the background, oldest first.
+ *
+ * This is "started", NOT "still running". A transcript records the start and
+ * never the death, and inferring liveness from its absence is the same trap
+ * `agents devices ps` documents — a killed process leaves no marker, so a naive
+ * reader reports "running" forever. Live status belongs to `sessions --active`,
+ * which resolves real pids.
+ */
+export function extractBackgroundShells(events) {
+    const out = [];
+    for (const e of events) {
+        if (!isBackgroundShellStart(e))
+            continue;
+        const raw = e.command ?? e.args?.command;
+        out.push({
+            command: typeof raw === 'string' ? raw.trim() : '',
+            timestamp: e.timestamp,
+        });
+    }
+    return out;
+}
+// ── Sub-agents ────────────────────────────────────────────────────────────────
+/**
+ * True for a tool call that spawns another agent. Deliberately counts BOTH
+ * shapes, because both are fan-out the operator needs to see:
+ *
+ *   in-process   an `Agent` / `Task` tool call inside this transcript
+ *   shelled-out  a Bash command that invokes `agents run`, `agents cloud run`,
+ *                or `agents teams add|start`
+ *
+ * Moved here from `commands/sessions-picker.ts` so BOTH preview body paths (the
+ * digest body and `formatMetaOnlyBody`) share one definition instead of
+ * drifting apart. Semantics are unchanged: session f045b577 counts 23
+ * in-process + 30 shelled-out = 53.
+ *
+ * The full summary's `Subagents (N)` section (`render.ts`) deliberately does NOT
+ * use this. It builds a described ROSTER, so it needs `args.description` /
+ * `args.prompt` and is necessarily limited to in-process `Agent`/`Task` calls —
+ * a shelled-out `agents run` carries no such description. Different question,
+ * different answer; do not "unify" them.
+ */
+export function isSubAgentTool(tool, command) {
+    if (/^(Agent|Task)$/i.test(tool))
+        return true;
+    return /\b(?:agents|ag)\b[^\n;&|]*\b(?:run|cloud\s+run|teams\s+(?:add|start))\b/.test(command);
+}

package/dist/lib/session/host-link.d.ts

@@ -25,12 +25,26 @@
  */
 /** How a session is connected to the client that should be driving it. */
 export type HostLink = 
-/** A client is attached, or nothing indicates otherwise. The normal case. */
+/** A client is attached — positively established, not assumed. */
 'connected'
 /** Alive, but nothing is viewing it — the host window is gone and the agent outlived it. */
  | 'no-client'
 /** The host window is gone AND the agent process died with it — an unclean exit. */
- | 'host-gone';
+ | 'host-gone'
+/**
+ * Alive, and we have NO usable signal either way — no window owns it and it is
+ * not tmux-hosted, so neither input this function keys on exists.
+ *
+ * This case used to return `connected`, which reads as "verified fine" when the
+ * truth is "nobody looked". That is the wrong default for a detector: the rows
+ * it silently blesses are precisely the ones with no observer — a bare terminal,
+ * a team spawn, a cloud task, or any session whose pane lives on another
+ * machine (this function's inputs are all local, so a `--device` session is
+ * structurally unobservable from the launching box).
+ *
+ * Callers MUST NOT render this as healthy. It means the question is open.
+ */
+ | 'unknown';
 /**
  * How long an IDE window's registry slice may go without a refresh before we
  * treat that window as gone. AGI EXT force-republishes its slice

package/dist/lib/session/host-link.js

@@ -60,5 +60,11 @@ export function classifyHostLink(input) {
     // that owned it is gone. The agent outlived its editor.
     if (windowGone)
         return 'no-client';
-    return 'connected';
+    // Positive evidence of a client: tmux counted at least one attached client, or
+    // a window is refreshing its registry slice. Either is a real observation.
+    if (input.tmuxClients !== undefined || input.windowHeartbeatMs !== undefined)
+        return 'connected';
+    // Neither input exists, so nothing here observed anything. Say so rather than
+    // reporting the healthy answer by default — see {@link HostLink}'s `unknown`.
+    return 'unknown';
 }

package/dist/lib/session/parse.js

@@ -11,7 +11,7 @@ import { sanitizeForTerminal } from '../redact.js';
 import * as path from 'path';
 import Database from '../sqlite.js';
 import { isSyntheticUserMessage, extractSlashCommandName, extractSlashCommandFromToolInput } from './prompt.js';
-import { structuredToolResult } from './tool-calls.js';
+import { structuredToolResult, commandsFromCodexExec } from './tool-calls.js';
 /**
  * Largest session file we will load into memory. Above this we throw a clean
  * error instead of OOMing or hitting V8's ERR_STRING_TOO_LONG. Aligns with
@@ -270,6 +270,15 @@ export function summarizeToolUse(tool, args) {
         // Codex tools
         case 'exec_command':
             return `Bash: ${truncate(String(args.command || args.cmd || '').replace(/\n/g, ' ').trim(), 120)}`;
+        // Newer Codex JS-cell shell wrapper: prefer the unwrapped command (set at parse
+        // time), else the extracted command, else the raw cell code.
+        case 'exec': {
+            const cmd = args.command || codexExecCommand(String(args.input || ''));
+            if (cmd)
+                return `Bash: ${truncate(String(cmd).replace(/\n/g, ' ').trim(), 120)}`;
+            const code = String(args.input || '').replace(/\n/g, ' ').trim();
+            return code ? `exec: ${truncate(code, 100)}` : 'exec';
+        }
         case 'read_file':
             return `Read ${shortenPath(args.file_path || args.path || '')}`;
         case 'write_file':
@@ -573,6 +582,23 @@ export function applyPatchTargetPaths(input) {
 function applyPatchTargetPath(input) {
     return applyPatchTargetPaths(input)[0];
 }
+/**
+ * Newer Codex (gpt-5.6-sol / codex >=~0.145) runs every shell command inside a JS
+ * cell: a `custom_tool_call` named `exec` whose `input` is code like
+ * `const r = await tools.exec_command({cmd:"git status", "workdir":"…"});`. The real
+ * shell command(s) are buried in those `cmd:"…"` literals. Reuse the canonical
+ * acorn-based extractor (`commandsFromCodexExec` in `tool-calls.ts`, already used by
+ * the tool-call index): it walks the whole AST — so a cell that runs several via
+ * `Promise.all([tools.exec_command(...), tools.exec_command(...)])` yields every
+ * command, not just the first — and matches only real `tools.exec_command` calls,
+ * so a `cmd:"…"` string mentioned in a comment or docstring is never mistaken for an
+ * invocation. Returns `undefined` for a non-shell cell (`tools.view_image(...)`, a
+ * raw JS computation) so it stays labeled by its code, not faked into a shell step.
+ */
+function codexExecCommand(input) {
+    const commands = commandsFromCodexExec(input);
+    return commands.length > 0 ? commands.join('\n') : undefined;
+}
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized
  * events. Split from `parseCodex` so the tail reader can parse just the last
@@ -706,6 +732,9 @@ export function parseCodexContent(content) {
                 const rawName = payload.name || 'unknown';
                 const input = typeof payload.input === 'string' ? payload.input : '';
                 const isApplyPatch = rawName === 'apply_patch';
+                // Newer Codex wraps shell in a JS `exec` cell — unwrap the real command so
+                // the step reads by its program instead of a bare "exec" (see extractor).
+                const execCommand = rawName === 'exec' ? codexExecCommand(input) : undefined;
                 // Multi-file patches: one tool_use per file so artifact discovery sees
                 // every path (RUSH-1410). Single-file / non-patch keep one event.
                 const patchPaths = isApplyPatch ? applyPatchTargetPaths(input) : [];
@@ -715,6 +744,8 @@ export function parseCodexContent(content) {
                     const args = { input: truncatedInput };
                     if (patchPath)
                         args.file_path = patchPath;
+                    if (execCommand)
+                        args.command = execCommand;
                     const callId = payload.call_id || payload.id;
                     if (callId)
                         callMap.set(callId, { name: tool, args });
@@ -725,6 +756,7 @@ export function parseCodexContent(content) {
                         tool,
                         callId,
                         args,
+                        command: execCommand,
                         path: patchPath,
                     });
                 };

package/dist/lib/session/remote/remote-list.d.ts

@@ -141,8 +141,17 @@ export declare function fetchPeerPreviewDigest(sessionId: string, machine: strin
  * that would inherit it for its whole life — `agents browser start` inside it
  * would then be refused as a cross-machine drive. A one-shot `--device` command
  * can carry the marker; a session cannot.
+ *
+ * `opts.sessionId` (with `tty`) prints the session id and resume command when
+ * the SSH hop ends, so OpenSSH's `Shared connection … closed.` is not the last
+ * thing on the local shell (RUSH-3227). Omit it for one-shot non-TTY renders.
  */
+export declare function peerHopCloseNotice(opts: {
+    tty?: boolean;
+    sessionId?: string;
+}, machine: string, code: number | null): string | undefined;
 export declare function runOnPeer(args: string[], machine: string, opts?: {
     tty?: boolean;
     env?: Record<string, string>;
+    sessionId?: string;
 }): Promise<'ok' | 'no-target'>;

package/dist/lib/session/remote/remote-list.js

@@ -15,7 +15,8 @@
  */
 import { spawn } from 'child_process';
 import chalk from 'chalk';
-import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote, REMOTE_STDOUT_MAX_BYTES, RemoteUtf8Accumulator, } from '../../ssh-exec.js';
+import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote, SSH_CONN_FAILURE_CODE, REMOTE_STDOUT_MAX_BYTES, RemoteUtf8Accumulator, } from '../../ssh-exec.js';
+import { connectionEndedNotice } from '../../hosts/reconnect.js';
 import { sshTargetFor } from '../../devices/connect.js';
 import { resolveExplicitTargetSet } from '../../devices/resolve-target.js';
 import { loadDevices, isDialableDevice } from '../../devices/registry.js';
@@ -577,7 +578,16 @@ export async function fetchPeerPreviewDigest(sessionId, machine, timeoutMs = PEE
  * that would inherit it for its whole life — `agents browser start` inside it
  * would then be refused as a cross-machine drive. A one-shot `--device` command
  * can carry the marker; a session cannot.
+ *
+ * `opts.sessionId` (with `tty`) prints the session id and resume command when
+ * the SSH hop ends, so OpenSSH's `Shared connection … closed.` is not the last
+ * thing on the local shell (RUSH-3227). Omit it for one-shot non-TTY renders.
  */
+export function peerHopCloseNotice(opts, machine, code) {
+    if (!opts.tty || !opts.sessionId)
+        return undefined;
+    return connectionEndedNotice({ kind: 'session', id: opts.sessionId }, machine, { dropped: code === SSH_CONN_FAILURE_CODE });
+}
 export async function runOnPeer(args, machine, opts = {}) {
     const peer = await resolvePeerTarget(machine);
     if (!peer)
@@ -602,6 +612,13 @@ export async function runOnPeer(args, machine, opts = {}) {
             process.stderr.write(chalk.red(`Failed to reach ${machine}: ${err?.message ?? 'ssh failed to launch'}\n`));
             resolve('ok');
         });
-        child.on('close', () => resolve('ok'));
+        child.on('close', (code) => {
+            // Interactive TTY hop: OpenSSH prints "Shared connection … closed." and
+            // nothing else. Leave the session id on the local shell (RUSH-3227).
+            const notice = peerHopCloseNotice(opts, machine, code);
+            if (notice)
+                process.stderr.write(notice);
+            resolve('ok');
+        });
     });
 }

package/dist/lib/session/remote/watch.js

@@ -9,7 +9,7 @@ import { machineId, normalizeHost } from '../../machine-id.js';
 import { SSH_OPTS, controlOpts, shellQuote } from '../../ssh-exec.js';
 import { buildWindowsAgentsCommand, remoteShellFor } from '../../hosts/remote-cmd.js';
 import { isReapableOrphan } from '../active.js';
-import { activeSessionsJournalPath, activeSessionJournalIdentity, readActiveSessionsCache, } from '../session-cache.js';
+import { activeSessionsJournalPath, activeSessionJournalIdentity, readActiveSessionsCache, noteActiveSessionsJournalReader, } from '../session-cache.js';
 export const SESSION_WATCH_VERSION = 1;
 export const SESSION_WATCH_HEARTBEAT_MS = 15_000;
 /** Stable, opaque identity for one row within one device scope. */
@@ -116,9 +116,15 @@ export async function watchLocalSessions(options) {
     catch { /* first publication */ }
     const initial = readCache('local');
     options.emit(state.reset(options.scope, initial?.sessions ?? []));
+    // Known gap (out of scope for RUSH-2484): a present cache alone marks
+    // 'available' with no staleness/age check, so a reconnect can briefly render
+    // a stale snapshot as live before the out-of-band gather this file triggers
+    // (see watchActiveSessionsReaderPresence in session-cache.ts) replaces it.
     options.emit(state.scope(options.scope, initial ? 'available' : 'unavailable', initial ? undefined : 'awaiting publisher'));
     if (options.signal.aborted)
         return;
+    // Signal the daemon that a consumer is live so it does not skip the gather.
+    noteActiveSessionsJournalReader();
     await new Promise((resolve) => {
         let partial = '';
         let reading = false;
@@ -167,7 +173,10 @@ export async function watchLocalSessions(options) {
         fs.mkdirSync(path.dirname(journal), { recursive: true });
         const journalListener = () => readAppended();
         fs.watchFile(journal, { interval: options.journalPollMs ?? 250 }, journalListener);
-        const heartbeatTimer = setInterval(() => options.emit(state.heartbeat(options.scope)), heartbeatMs);
+        const heartbeatTimer = setInterval(() => {
+            noteActiveSessionsJournalReader();
+            options.emit(state.heartbeat(options.scope));
+        }, heartbeatMs);
         const stop = () => { fs.unwatchFile(journal, journalListener); clearInterval(heartbeatTimer); resolve(); };
         options.signal.addEventListener('abort', stop, { once: true });
         // Close the offset/read/watch handoff: a publisher may append after the

package/dist/lib/session/session-cache.d.ts

@@ -59,6 +59,16 @@ export declare const IMMUTABLE_FIELD_KEYS: readonly ["topic", "label", "name", "
  * only cache that may carry them — and only as a whole-row snapshot.
  */
 export declare const LIVE_STATUS_KEYS: readonly ["status", "activity", "preview", "tokPerSec", "awaitingReason", "question", "todos", "tail", "lastActivityMs", "hostLink", "presence", "pidAlive", "tmuxClients", "windowHeartbeatMs", "provenance", "rateLimited", "plan"];
+/**
+ * How long after the last reader heartbeat the daemon considers the journal
+ * to have no active consumer and skips the expensive `ps`+`lsof` gather.
+ *
+ * Must be significantly larger than {@link SESSION_WATCH_HEARTBEAT_MS} (15s)
+ * so a single delayed heartbeat does not cause a false-idle. Three tick-lengths
+ * gives adequate margin while still cutting load within ~45s of the last
+ * watcher disconnecting.
+ */
+export declare const ACTIVE_SESSIONS_READER_IDLE_WINDOW_MS = 45000;
 /** Test seam: redirect the snapshot file. Returns the previous override. */
 export declare function setActiveSessionsSnapshotPathForTest(p: string | null): string | null;
 /** Test seam: isolate process-local entries between fixtures. */
@@ -67,7 +77,50 @@ export declare function clearActiveSnapshotMemoryForTest(): void;
 export declare function setImmutableMemoPathForTest(p: string | null): string | null;
 /** Test seam: redirect the append-only live-state journal. */
 export declare function setActiveSessionsJournalPathForTest(p: string | null): string | null;
+/** Test seam: redirect the reader-presence file. Returns the previous override. */
+export declare function setActiveSessionsReaderPresencePathForTest(p: string | null): string | null;
 export declare function activeSessionsJournalPath(): string;
+/**
+ * Record that a journal consumer is active right now.
+ *
+ * Called by {@link watchLocalSessions} on startup and on each heartbeat so
+ * the daemon warm tick can gate the expensive `ps`+`lsof` gather on reader
+ * presence and skip it when no watcher has checked in recently.
+ */
+export declare function noteActiveSessionsJournalReader(nowMs?: number): void;
+/**
+ * True when a journal consumer has signalled its presence within
+ * {@link ACTIVE_SESSIONS_READER_IDLE_WINDOW_MS}.
+ *
+ * Used by the daemon warm tick to decide whether to run the expensive
+ * `ps`+`lsof` gather. On an idle box with no watcher the tick skips the
+ * gather entirely; the moment a new watcher connects it calls
+ * {@link noteActiveSessionsJournalReader} and the following tick gathers.
+ */
+export declare function isActiveSessionsJournalReaderRecent(nowMs?: number, idleWindowMs?: number): boolean;
+/** Default poll cadence for {@link watchActiveSessionsReaderPresence}. */
+export declare const ACTIVE_SESSIONS_READER_TRANSITION_POLL_MS = 1000;
+/**
+ * Watch for a reader going from absent/idle to present and fire `onConnect`
+ * out of band, instead of waiting for the next scheduled warm tick (RUSH-2484).
+ *
+ * {@link noteActiveSessionsJournalReader} only writes a timestamp — it has no
+ * path back to the daemon process that owns the warm tick's `setInterval`. A
+ * watcher connecting to a cold or long-idle daemon therefore used to wait up
+ * to one full {@link ACTIVE_SESSIONS_WARM_TICK_MS} tick for its first fresh
+ * rows. This polls the tiny presence file (not the expensive `ps`+`lsof`
+ * gather) at {@link ACTIVE_SESSIONS_READER_TRANSITION_POLL_MS} and calls
+ * `onConnect` only on the idle→recent edge, so a steadily-connected reader's
+ * repeated heartbeats never re-trigger it and an idle box with no reader never
+ * gathers — the CPU win from RUSH-3193 is preserved.
+ *
+ * Returns a disposer that stops the poll.
+ */
+export declare function watchActiveSessionsReaderPresence(onConnect: () => void, opts?: {
+    pollMs?: number;
+    idleWindowMs?: number;
+    nowMs?: () => number;
+}): () => void;
 /** Read one scope from the snapshot file (best-effort; missing/corrupt → null). */
 export declare function readActiveSessionsCache(scope: ActiveCacheScope): ActiveSessionsSnapshot | null;
 /**

package/dist/lib/session/session-cache.js

@@ -94,10 +94,21 @@ export const LIVE_STATUS_KEYS = [
     'rateLimited',
     'plan',
 ];
+/**
+ * How long after the last reader heartbeat the daemon considers the journal
+ * to have no active consumer and skips the expensive `ps`+`lsof` gather.
+ *
+ * Must be significantly larger than {@link SESSION_WATCH_HEARTBEAT_MS} (15s)
+ * so a single delayed heartbeat does not cause a false-idle. Three tick-lengths
+ * gives adequate margin while still cutting load within ~45s of the last
+ * watcher disconnecting.
+ */
+export const ACTIVE_SESSIONS_READER_IDLE_WINDOW_MS = 45_000;
 // ── path overrides (test seam) ─────────────────────────────────────────────
 let snapshotPathOverride = null;
 let immutablePathOverride = null;
 let journalPathOverride = null;
+let readerPresencePathOverride = null;
 /** Test seam: redirect the snapshot file. Returns the previous override. */
 export function setActiveSessionsSnapshotPathForTest(p) {
     const prev = snapshotPathOverride;
@@ -121,6 +132,12 @@ export function setActiveSessionsJournalPathForTest(p) {
     journalPathOverride = p;
     return prev;
 }
+/** Test seam: redirect the reader-presence file. Returns the previous override. */
+export function setActiveSessionsReaderPresencePathForTest(p) {
+    const prev = readerPresencePathOverride;
+    readerPresencePathOverride = p;
+    return prev;
+}
 function snapshotPath() {
     return snapshotPathOverride ?? path.join(getCacheDir(), SNAPSHOT_FILE);
 }
@@ -131,6 +148,77 @@ export function activeSessionsJournalPath() {
     return journalPathOverride
         ?? (snapshotPathOverride ? `${snapshotPathOverride}.journal.jsonl` : path.join(getCacheDir(), JOURNAL_FILE));
 }
+const READER_PRESENCE_FILE = '.active-sessions-reader.presence';
+function readerPresencePath() {
+    return readerPresencePathOverride ?? path.join(getCacheDir(), READER_PRESENCE_FILE);
+}
+/**
+ * Record that a journal consumer is active right now.
+ *
+ * Called by {@link watchLocalSessions} on startup and on each heartbeat so
+ * the daemon warm tick can gate the expensive `ps`+`lsof` gather on reader
+ * presence and skip it when no watcher has checked in recently.
+ */
+export function noteActiveSessionsJournalReader(nowMs = Date.now()) {
+    try {
+        const p = readerPresencePath();
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, String(nowMs));
+    }
+    catch { /* best-effort: a failed write does not block the caller */ }
+}
+/**
+ * True when a journal consumer has signalled its presence within
+ * {@link ACTIVE_SESSIONS_READER_IDLE_WINDOW_MS}.
+ *
+ * Used by the daemon warm tick to decide whether to run the expensive
+ * `ps`+`lsof` gather. On an idle box with no watcher the tick skips the
+ * gather entirely; the moment a new watcher connects it calls
+ * {@link noteActiveSessionsJournalReader} and the following tick gathers.
+ */
+export function isActiveSessionsJournalReaderRecent(nowMs = Date.now(), idleWindowMs = ACTIVE_SESSIONS_READER_IDLE_WINDOW_MS) {
+    try {
+        const content = fs.readFileSync(readerPresencePath(), 'utf8').trim();
+        const ts = Number(content);
+        if (!Number.isFinite(ts))
+            return false;
+        return nowMs - ts < idleWindowMs;
+    }
+    catch {
+        return false;
+    }
+}
+/** Default poll cadence for {@link watchActiveSessionsReaderPresence}. */
+export const ACTIVE_SESSIONS_READER_TRANSITION_POLL_MS = 1_000;
+/**
+ * Watch for a reader going from absent/idle to present and fire `onConnect`
+ * out of band, instead of waiting for the next scheduled warm tick (RUSH-2484).
+ *
+ * {@link noteActiveSessionsJournalReader} only writes a timestamp — it has no
+ * path back to the daemon process that owns the warm tick's `setInterval`. A
+ * watcher connecting to a cold or long-idle daemon therefore used to wait up
+ * to one full {@link ACTIVE_SESSIONS_WARM_TICK_MS} tick for its first fresh
+ * rows. This polls the tiny presence file (not the expensive `ps`+`lsof`
+ * gather) at {@link ACTIVE_SESSIONS_READER_TRANSITION_POLL_MS} and calls
+ * `onConnect` only on the idle→recent edge, so a steadily-connected reader's
+ * repeated heartbeats never re-trigger it and an idle box with no reader never
+ * gathers — the CPU win from RUSH-3193 is preserved.
+ *
+ * Returns a disposer that stops the poll.
+ */
+export function watchActiveSessionsReaderPresence(onConnect, opts = {}) {
+    const pollMs = opts.pollMs ?? ACTIVE_SESSIONS_READER_TRANSITION_POLL_MS;
+    const now = opts.nowMs ?? Date.now;
+    let lastRecent = isActiveSessionsJournalReaderRecent(now(), opts.idleWindowMs);
+    const timer = setInterval(() => {
+        const recent = isActiveSessionsJournalReaderRecent(now(), opts.idleWindowMs);
+        if (recent && !lastRecent)
+            onConnect();
+        lastRecent = recent;
+    }, pollMs);
+    timer.unref?.();
+    return () => clearInterval(timer);
+}
 // ── snapshot read / write ──────────────────────────────────────────────────
 /** Read one scope from the snapshot file (best-effort; missing/corrupt → null). */
 export function readActiveSessionsCache(scope) {

package/dist/lib/session/state.js

@@ -174,7 +174,7 @@ export function extractRecentDirectoriesTouched(events, cwd) {
         if (['Edit', 'Write', 'edit_file', 'write_file', 'create_file', 'edit', 'write'].includes(tool)) {
             add(args.file_path ?? args.filePath ?? args.path ?? event.path, true);
         }
-        else if (['Bash', 'exec_command', 'run_shell_command', 'shell', 'Execute'].includes(tool)) {
+        else if (['Bash', 'exec_command', 'exec', 'run_shell_command', 'shell', 'Execute'].includes(tool)) {
             add(args.cwd ?? args.Cwd ?? args.workdir ?? args.working_directory ?? cwd);
         }
     }

package/dist/lib/session/tool-calls.d.ts

@@ -34,6 +34,8 @@ export interface ToolCallCollectorSnapshot {
     pending: IndexedToolCall[];
 }
 export declare function sanitizeToolEvidenceText(value: string, maxBytes: number, knownValues?: readonly string[]): string;
+/** Extract literal shell commands from the Codex orchestration tool without evaluating transcript code. */
+export declare function commandsFromCodexExec(source: string): string[];
 export declare function structuredToolResult(value: unknown): {
     text: string;
     outcome: ToolCallOutcome;

package/dist/lib/session/tool-calls.js

@@ -181,7 +181,7 @@ function canonicalInput(tool, args, command) {
     }
 }
 /** Extract literal shell commands from the Codex orchestration tool without evaluating transcript code. */
-function commandsFromCodexExec(source) {
+export function commandsFromCodexExec(source) {
     const commands = [];
     let root;
     try {

package/dist/lib/session/trajectory-html.d.ts

@@ -11,5 +11,9 @@ export declare function renderTrajectoryCompareHtml(cmp: TrajectoryComparison):
  * auto-discovered from the team records) plus a per-node summary card revealed
  * by clicking a node. Same shell, redaction, and no-CDN rule as the other two
  * layouts; local paths (`filePath`/`cwd`) are deliberately never rendered.
+ *
+ * `redacted` follows the trace's `--no-redact` flag so the footer states the
+ * honest label, exactly as the single-trajectory and compare renderers do; it
+ * defaults to the redacted claim to keep the shared/safe default.
  */
-export declare function renderLineageHtml(lineage: SessionLineage): string;
+export declare function renderLineageHtml(lineage: SessionLineage, redacted?: boolean): string;