@phnx-labs/agents-cli 1.22.47 → 1.22.50

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;

package/dist/lib/session/trajectory-html.js

@@ -14,6 +14,15 @@
  */
 import { formatDuration, formatTokenCount } from './render.js';
 import { escapeHtml } from './share-html.js';
+/**
+ * The honest footer prefix for a rendered trace: the redacted label only when
+ * something was actually redacted, else the "local only" disclaimer under
+ * `--no-redact`. One source for all three layouts (single / compare / lineage)
+ * so the label never drifts back to a hardcoded "Secret-redacted" claim.
+ */
+function redactionLabel(redacted) {
+    return redacted ? 'Secret-redacted' : 'Unredacted (local only)';
+}
 /** Color a tool bar by family; an error outcome overrides to red. */
 function toolColor(step) {
     if (step.outcome === 'error')
@@ -31,7 +40,7 @@ function toolColor(step) {
         return '#b98cff';
     return '#8b98a5';
 }
-/** Precise per-step duration for the waterfall: "8m04s", "1.6s", "320ms". */
+/** Precise per-step duration for the waterfall: "2h01m", "8m04s", "1.6s", "320ms". */
 function formatStepDuration(ms) {
     if (ms <= 0)
         return '0s';
@@ -40,6 +49,13 @@ function formatStepDuration(ms) {
     if (ms < 60_000)
         return `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)}s`;
     const totalSec = Math.round(ms / 1000);
+    // Beyond an hour, minutes-only reads as "1441m18s" for an overnight idle gap —
+    // roll into hours so a long stall is legible at a glance.
+    if (totalSec >= 3600) {
+        const h = Math.floor(totalSec / 3600);
+        const m = Math.floor((totalSec % 3600) / 60);
+        return `${h}h${String(m).padStart(2, '0')}m`;
+    }
     const m = Math.floor(totalSec / 60);
     const s = totalSec % 60;
     return `${m}m${String(s).padStart(2, '0')}s`;
@@ -242,7 +258,7 @@ export function renderTrajectoryHtml(model) {
   </div>
 </main>
 <footer>
-  ${model.truncatedSteps > 0 ? 'Truncated · ' : ''}${model.redacted ? 'Secret-redacted' : 'Unredacted (local only)'} trajectory rendered by agents-cli &middot; <code>agents sessions trace</code>
+  ${model.truncatedSteps > 0 ? 'Truncated · ' : ''}${redactionLabel(model.redacted)} trajectory rendered by agents-cli &middot; <code>agents sessions trace</code>
 </footer>
 <script>${THEME_SCRIPT}</script>
 </body>
@@ -335,23 +351,7 @@ const BASE_STYLE = `
     color: var(--dim); font-size: 12px;
     font-family: ui-monospace, "JetBrains Mono", Menlo, monospace;
   }
-`;
-/** Compare-only rules layered on top of {@link BASE_STYLE} — lanes, divergence marker, summary table. */
-const COMPARE_STYLE = `
-  svg .diverge { stroke: #e0b341; stroke-width: 1.4; stroke-dasharray: 4 3; }
-  .diverge-note { color: #e0b341; font-size: 12.5px; margin: 6px 0; }
-  table.cmp-table { border-collapse: collapse; width: 100%; font-family: ui-monospace, "JetBrains Mono", Menlo, monospace; font-size: 12.5px; }
-  table.cmp-table th, table.cmp-table td { text-align: left; padding: 6px 10px; border-bottom: 1px solid var(--border); }
-  table.cmp-table th { color: var(--dim); font-weight: 600; text-transform: uppercase; font-size: 10.5px; letter-spacing: .5px; }
-  .diff-cols { display: flex; gap: 24px; flex-wrap: wrap; }
-  .diff-col { flex: 1; min-width: 260px; }
-  .diff-col h3 { font-size: 11px; color: var(--dim); text-transform: uppercase; letter-spacing: .5px; margin: 0 0 8px; }
-  .diff-list { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 4px; }
-  .diff-list li {
-    font-family: ui-monospace, "JetBrains Mono", Menlo, monospace; font-size: 12px;
-    border: 1px solid var(--border); border-radius: 5px; padding: 5px 8px; background: var(--panel);
-  }
-  /* trace v2 — analysis hero + program-aware step list */
+  /* trace v2 — analysis hero + program-aware step list (single-session view; compare/lineage layer on top of BASE_STYLE, so this must live here) */
   main { padding: 20px; }
   .analysis { display: grid; grid-template-columns: 1.25fr 1fr; gap: 20px; margin-bottom: 26px; }
   @media (max-width: 720px) { .analysis { grid-template-columns: 1fr; } }
@@ -391,6 +391,22 @@ const COMPARE_STYLE = `
   .gap-divider { text-align: center; color: #7a5c3a; font-size: 11px; margin: 8px 0; letter-spacing: .06em; font-family: ui-monospace, "JetBrains Mono", Menlo, monospace; }
   details.step .detail { white-space: pre-wrap; color: var(--dim); font-size: 11px; background: var(--bg); border: 1px solid var(--border); border-radius: 6px; padding: 8px 10px; margin: 2px 0 8px 54px; max-height: 220px; overflow: auto; }
 `;
+/** Compare-only rules layered on top of {@link BASE_STYLE} — lanes, divergence marker, summary table. */
+const COMPARE_STYLE = `
+  svg .diverge { stroke: #e0b341; stroke-width: 1.4; stroke-dasharray: 4 3; }
+  .diverge-note { color: #e0b341; font-size: 12.5px; margin: 6px 0; }
+  table.cmp-table { border-collapse: collapse; width: 100%; font-family: ui-monospace, "JetBrains Mono", Menlo, monospace; font-size: 12.5px; }
+  table.cmp-table th, table.cmp-table td { text-align: left; padding: 6px 10px; border-bottom: 1px solid var(--border); }
+  table.cmp-table th { color: var(--dim); font-weight: 600; text-transform: uppercase; font-size: 10.5px; letter-spacing: .5px; }
+  .diff-cols { display: flex; gap: 24px; flex-wrap: wrap; }
+  .diff-col { flex: 1; min-width: 260px; }
+  .diff-col h3 { font-size: 11px; color: var(--dim); text-transform: uppercase; letter-spacing: .5px; margin: 0 0 8px; }
+  .diff-list { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 4px; }
+  .diff-list li {
+    font-family: ui-monospace, "JetBrains Mono", Menlo, monospace; font-size: 12px;
+    border: 1px solid var(--border); border-radius: 5px; padding: 5px 8px; background: var(--panel);
+  }
+`;
 const THEME_SCRIPT = `
   (function () {
     var root = document.documentElement;
@@ -521,7 +537,7 @@ export function renderTrajectoryCompareHtml(cmp) {
   ${renderCompareDiffLists(cmp)}
 </main>
 <footer>
-  Secret-redacted compare rendered by agents-cli &middot; <code>agents sessions trace</code>
+  ${redactionLabel(cmp.a.redacted || cmp.b.redacted)} compare rendered by agents-cli &middot; <code>agents sessions trace</code>
 </footer>
 <script>${THEME_SCRIPT}</script>
 </body>
@@ -696,8 +712,12 @@ const LINEAGE_SCRIPT = `
  * 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 function renderLineageHtml(lineage) {
+export function renderLineageHtml(lineage, redacted = true) {
     const root = lineage.nodes[0];
     const title = root ? `${root.agent} · ${root.shortId}` : 'lineage';
     const spawned = Math.max(0, lineage.nodes.length - 1);
@@ -740,7 +760,7 @@ export function renderLineageHtml(lineage) {
   </div>
 </main>
 <footer>
-  Secret-redacted lineage rendered by agents-cli &middot; <code>agents sessions trace --tree</code>
+  ${redactionLabel(redacted)} lineage rendered by agents-cli &middot; <code>agents sessions trace --tree</code>
 </footer>
 <script>${THEME_SCRIPT}</script>
 <script>${LINEAGE_SCRIPT}</script>

package/dist/lib/session/trajectory-text.js

@@ -12,7 +12,7 @@
 import { formatTokenCount } from './render.js';
 const DEFAULT_MAX_STEPS = 80;
 const LABEL_COL = 40;
-/** Precise, compact per-step duration: "8m04s", "1.6s", "320ms", "—" for zero. */
+/** Precise, compact per-step duration: "2h01m", "8m04s", "1.6s", "320ms", "—" for zero. */
 function dur(ms, estimated) {
     if (ms <= 0)
         return estimated ? '~0s' : '0s';
@@ -23,7 +23,14 @@ function dur(ms, estimated) {
         s = `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)}s`;
     else {
         const totalSec = Math.round(ms / 1000);
-        s = `${Math.floor(totalSec / 60)}m${String(totalSec % 60).padStart(2, '0')}s`;
+        // Beyond an hour, roll into hours so an overnight stall reads "24h01m", not
+        // "1441m18s" (matches the HTML renderer's formatStepDuration).
+        if (totalSec >= 3600) {
+            s = `${Math.floor(totalSec / 3600)}h${String(Math.floor((totalSec % 3600) / 60)).padStart(2, '0')}m`;
+        }
+        else {
+            s = `${Math.floor(totalSec / 60)}m${String(totalSec % 60).padStart(2, '0')}s`;
+        }
     }
     return estimated ? `~${s}` : s;
 }

package/dist/lib/session/trajectory.js

@@ -32,10 +32,12 @@ const INLINE_TASK_TOOLS = new Set(['Task', 'Agent']);
 /**
  * Shell tools whose command is worth resolving to an effective program — every
  * harness's shell-exec tool, kept in lockstep with the canonical set in
- * `state.ts` (`['Bash', 'exec_command', 'run_shell_command', 'shell', 'Execute']`)
- * so Codex's `exec_command` and the rest are covered, not just Claude's `Bash`.
+ * `state.ts` (`['Bash', 'exec_command', 'exec', 'run_shell_command', 'shell', 'Execute']`)
+ * so Codex's `exec_command`/`exec` and the rest are covered, not just Claude's `Bash`.
+ * `exec` is newer Codex (gpt-5.6-sol) whose real command the parser unwraps from a
+ * JS cell into the event's `command` before this runs.
  */
-const SHELL_TOOLS = new Set(['Bash', 'exec_command', 'run_shell_command', 'shell', 'Execute']);
+const SHELL_TOOLS = new Set(['Bash', 'exec_command', 'exec', 'run_shell_command', 'shell', 'Execute']);
 /**
  * Shell builtins/assignments that are rarely the POINT of a command — the action
  * is whatever runs after them (`export X=Y; git push` → `git`, `cd dir && bun test`
@@ -83,6 +85,52 @@ function stringArg(args, ...keys) {
     }
     return undefined;
 }
+/**
+ * Strip a shell command's leading throwaway statements so its label reads by what
+ * it DID, not by its setup. Real agent commands overwhelmingly open with a
+ * `cd <repo> &&` (or a multi-line script whose first line is `cd <repo>`), plus the
+ * occasional `export X=Y;`, `set -e`, `source …`, or bare `VAR=val` assignment —
+ * exactly the {@link SHELL_NOISE_PROGRAMS} the badge already skips when resolving
+ * the effective program. Without this, every `cd /long/path && git …` row renders
+ * an identical `cd /long/path` and the trajectory is unreadable; here we drop that
+ * prefix so the label agrees with the badge (`git …`, `gh …`, `bun …`).
+ *
+ * Conservative on purpose: only a LEADING run of noise statements separated by
+ * `&&`, `;`, or a newline is removed (an assignment PREFIX like `VAR=val cmd` too),
+ * pipelines (`|`) are left intact, and a command that is nothing but noise (a lone
+ * `cd dir`) is returned unchanged rather than emptied. The separator match is a
+ * plain negated class, not a shell tokenizer, so a separator INSIDE a quoted arg
+ * (`cd "a; b" && x`) would cut mid-quote — guarded by refusing any strip that
+ * leaves the label with unbalanced quotes and falling back to the whole command.
+ * Display-only — the value is still clipped and secret-redacted downstream.
+ */
+function quotesBalanced(text) {
+    const dq = (text.match(/(?<!\\)"/g) ?? []).length;
+    const sq = (text.match(/(?<!\\)'/g) ?? []).length;
+    return dq % 2 === 0 && sq % 2 === 0;
+}
+function stripLeadingShellNoise(command) {
+    // A leading `cd`/`export`/`set`/`source`/`unset`/`local`/`eval` statement, or an
+    // assignment, terminated by a statement separator (`&&`, `;`, or newline).
+    const noiseStatement = /^\s*(?:cd|export|set|source|unset|local|eval)\b[^\n&;|]*(?:&&|;|\n)+/i;
+    // A bare `VAR=val` — either a full statement (with a separator) or a prefix
+    // (followed by whitespace before the real program: `FOO=bar git push`).
+    const assignment = /^\s*[A-Za-z_][A-Za-z0-9_]*=[^\s&;|]*(?:\s*(?:&&|;|\n)+|\s+)/;
+    let cmd = command;
+    let prev = '';
+    while (cmd !== prev) {
+        prev = cmd;
+        cmd = cmd.replace(noiseStatement, '').replace(assignment, '');
+    }
+    const trimmed = cmd.trim();
+    if (trimmed.length === 0)
+        return command.trim();
+    // A strip that severed a quoted argument (a separator lived inside quotes) leaves
+    // a dangling quote — keep the whole command rather than show a mangled fragment.
+    if (!quotesBalanced(trimmed) && quotesBalanced(command))
+        return command.trim();
+    return trimmed;
+}
 /**
  * A redacted one-line label for a tool call, derived from the raw arguments.
  *
@@ -94,7 +142,8 @@ function toolLabel(tool, args, command, redact, knownSecrets) {
     let raw;
     const lower = tool.toLowerCase();
     if (lower === 'bash' || lower === 'shell' || lower === 'run_command' || lower.includes('exec')) {
-        raw = command ?? stringArg(args, 'command', 'cmd', 'script');
+        const cmd = command ?? stringArg(args, 'command', 'cmd', 'script');
+        raw = cmd ? stripLeadingShellNoise(cmd) : cmd;
     }
     else if (lower === 'read' || lower === 'edit' || lower === 'write' || lower === 'notebookedit' || lower === 'multiedit') {
         raw = stringArg(args, 'file_path', 'path', 'notebook_path', 'filePath');

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

@@ -247,6 +247,21 @@ export interface SessionMeta {
      * `isTeamOrigin` (which marks sessions spawned BY a team).
      */
     spawnedTeam?: string;
+    /**
+     * Fan-out this session left behind, captured at scan time so the preview can
+     * show it WITHOUT re-parsing the transcript — which is the only way a remote
+     * or unindexed row (rendered from `SessionMeta` alone) can show it at all.
+     *
+     * `undefined` and `0` are different claims and must render the same way (the
+     * segment omitted): `undefined` means the row predates the field or the
+     * harness cannot report it, `0` means scanned and none found. Rendering a
+     * literal "0 background shells" for a harness that cannot report them would
+     * assert "none running" where the truth is "unknown".
+     *
+     * Counts are "started", never "still running" — see `extractBackgroundShells`.
+     */
+    subAgentCount?: number;
+    backgroundShellCount?: number;
     /**
      * The plan markdown from the LAST `ExitPlanMode` tool call in the transcript
      * (Claude sessions only), captured at scan time. Present whenever the session