@phnx-labs/agents-cli 1.22.46 → 1.22.49

package/dist/lib/session/render.js

@@ -9,7 +9,7 @@
 import chalk from 'chalk';
 import { truncate } from '../format.js';
 import { summarizeToolUse } from './parse.js';
-import { cleanSessionPrompt, extractSessionTopic } from './prompt.js';
+import { cleanSessionPrompt, classifyUserPrompt, extractSessionTopic } from './prompt.js';
 import { renderMarkdown } from '../markdown.js';
 import { redactSecrets } from '../redact.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from './digest.js';
@@ -635,8 +635,12 @@ export function renderSummary(events, cwd) {
     // 1. Prompt
     if (firstUserMessage) {
         const cleaned = cleanSessionPrompt(firstUserMessage);
-        if (cleaned) {
-            lines.push(chalk.bold('Prompt:') + ' ' + cleaned.split('\n')[0]);
+        // Show the classified prompt (a screenshot path folds to `[image]`, a
+        // pasted `$ cmd` to the command, a skill install path to `/<name>`) so the
+        // recap's first line is intent, never path noise (RUSH-3011).
+        const { clean } = classifyUserPrompt(firstUserMessage, { hasImageAttachment: attachments.length > 0 });
+        if (clean || cleaned) {
+            lines.push(chalk.bold('Prompt:') + ' ' + (clean || cleaned.split('\n')[0]));
             const secondLine = cleaned.split('\n')[1]?.trim();
             if (secondLine)
                 lines.push('  ' + secondLine);

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

@@ -27,7 +27,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { createMemoryCache } from '../memory-cache.js';
 import { getCacheDir } from '../state.js';
-import { sessionProcessIsLocal } from './active.js';
+import { backfillActiveRowsFromIndex, sessionProcessIsLocal } from './active.js';
 /** Snapshot file under `getCacheDir()` (regenerable, gitignored). */
 const SNAPSHOT_FILE = '.active-sessions.json';
 /** Immutable-field memo file (keyed by sessionId + transcript mtime). */
@@ -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) {
@@ -376,6 +464,10 @@ export async function loadLocalActiveSessions(opts = {}) {
             return getActiveSessions({ localOnly: true });
         });
     const sessions = await gather();
+    // The index owns transcript-derived labels (Claude custom-title / ai-title).
+    // Enrich before publishing so the canonical watch snapshot carries the same
+    // label as one-shot `sessions --active` output.
+    backfillActiveRowsFromIndex(sessions);
     for (const s of sessions)
         applyImmutableMemo(s);
     updateImmutableMemos(sessions, now);

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-compare.d.ts

@@ -0,0 +1,47 @@
+import type { SessionMeta } from './types.js';
+import type { SessionTrajectory, TrajectoryStep } from './trajectory.js';
+/** Where two sessions' tool sequences first stop lining up. */
+export interface TrajectoryDivergence {
+    /** Ordinal of the last step both sessions still agree on (0 if none). */
+    afterOrdinalA: number;
+    afterOrdinalB: number;
+    /** ms into each session's own timeline where the divergence begins. */
+    startMsA: number;
+    startMsB: number;
+    /** One-line description of what differs — the next tool step on each side. */
+    detail: string;
+}
+/** Aggregate numbers for one side of a compare — the summary table row. */
+export interface TrajectorySummary {
+    session: SessionMeta;
+    toolCount: number;
+    errorCount: number;
+    spanMs: number;
+    outputTokens: number;
+}
+/** The result of diffing two trajectories. */
+export interface TrajectoryComparison {
+    a: SessionTrajectory;
+    b: SessionTrajectory;
+    /** Undefined only when the tool sequences are identical (or one/both are empty and equal). */
+    divergence?: TrajectoryDivergence;
+    /** Tool steps present in `b` with no counterpart in `a`, in `b`'s order. */
+    added: TrajectoryStep[];
+    /** Tool steps present in `a` with no counterpart in `b`, in `a`'s order. */
+    removed: TrajectoryStep[];
+    summaryA: TrajectorySummary;
+    summaryB: TrajectorySummary;
+    /** Tool steps dropped from the diff computation by the `maxDiffSteps` cap, per side. */
+    truncatedA: number;
+    truncatedB: number;
+}
+export interface DiffTrajectoriesOptions {
+    /** Cap on tool steps considered per side (the LCS table is O(n*m)). Default 1000. */
+    maxDiffSteps?: number;
+}
+/**
+ * Diff two trajectories: align their tool-step sequences, find the first
+ * divergence, and collect the steps each session ran that the other never
+ * did. Never mutates either input.
+ */
+export declare function diffTrajectories(a: SessionTrajectory, b: SessionTrajectory, options?: DiffTrajectoriesOptions): TrajectoryComparison;

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

@@ -0,0 +1,116 @@
+/**
+ * Diff two {@link SessionTrajectory} models for `agents sessions trace <a> <b>` —
+ * the second selector turns the single-session trajectory into a **compare**.
+ *
+ * Aligns the two sessions' TOOL steps (thinking steps carry no comparable
+ * identity) with the `diff` package's `diffArrays` (already a dependency,
+ * `lib/diff-text.ts`), comparator-keyed on tool name, in order — cheap,
+ * deterministic, and matches how a human reads "where did these two runs
+ * diverge": the first point their tool sequence stops lining up.
+ *
+ * Pure and framework-free, exactly like `trajectory.ts`: takes two already-built
+ * `SessionTrajectory` models (never re-parses a transcript) and returns a plain
+ * diff object the HTML/text/JSON renderers project.
+ */
+import { diffArrays } from 'diff';
+const DEFAULT_MAX_DIFF_STEPS = 1000;
+/**
+ * Turn `diffArrays`' run-length change objects into a per-step edit script.
+ *
+ * `diffArrays(a, b, { comparator })` (Myers' diff under the hood) returns
+ * consecutive-run chunks, not individual elements, and — per its own docs —
+ * an unchanged chunk's `value` is drawn from `b`, not `a`. Neither shape is
+ * what a divergence marker needs (a stepA/stepB PAIR per matched step, with
+ * both sides' own ordinals/timestamps), so this walks two cursors over the
+ * original arrays in lockstep with the run lengths `diffArrays` reports,
+ * recovering the exact `a[i]`/`b[j]` pairing for every `same` step.
+ */
+function computeEditScript(a, b) {
+    const changes = diffArrays(a, b, { comparator: (x, y) => x.tool === y.tool });
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    for (const change of changes) {
+        const count = change.count ?? change.value.length;
+        if (change.removed) {
+            for (let k = 0; k < count; k++)
+                ops.push({ type: 'remove', stepA: a[i++] });
+        }
+        else if (change.added) {
+            for (let k = 0; k < count; k++)
+                ops.push({ type: 'add', stepB: b[j++] });
+        }
+        else {
+            for (let k = 0; k < count; k++)
+                ops.push({ type: 'same', stepA: a[i++], stepB: b[j++] });
+        }
+    }
+    return ops;
+}
+function describeDivergence(op) {
+    if (op.type === 'remove')
+        return `${op.stepA.tool ?? op.stepA.kind} — only in the first session`;
+    if (op.type === 'add')
+        return `${op.stepB.tool ?? op.stepB.kind} — only in the second session`;
+    return '';
+}
+function summarize(t) {
+    return {
+        session: t.session,
+        toolCount: t.stats.toolCount,
+        errorCount: t.errorCount,
+        spanMs: t.spanMs,
+        outputTokens: t.stats.outputTokens,
+    };
+}
+/**
+ * Diff two trajectories: align their tool-step sequences, find the first
+ * divergence, and collect the steps each session ran that the other never
+ * did. Never mutates either input.
+ */
+export function diffTrajectories(a, b, options = {}) {
+    const maxDiffSteps = options.maxDiffSteps ?? DEFAULT_MAX_DIFF_STEPS;
+    const allToolStepsA = a.steps.filter((s) => s.kind === 'tool');
+    const allToolStepsB = b.steps.filter((s) => s.kind === 'tool');
+    const toolStepsA = allToolStepsA.slice(0, maxDiffSteps);
+    const toolStepsB = allToolStepsB.slice(0, maxDiffSteps);
+    const truncatedA = allToolStepsA.length - toolStepsA.length;
+    const truncatedB = allToolStepsB.length - toolStepsB.length;
+    const ops = computeEditScript(toolStepsA, toolStepsB);
+    const added = [];
+    const removed = [];
+    let divergence;
+    let lastSameA;
+    let lastSameB;
+    for (const op of ops) {
+        if (op.type === 'same') {
+            lastSameA = op.stepA;
+            lastSameB = op.stepB;
+            continue;
+        }
+        if (op.type === 'remove')
+            removed.push(op.stepA);
+        else
+            added.push(op.stepB);
+        if (!divergence) {
+            divergence = {
+                afterOrdinalA: lastSameA?.ordinal ?? 0,
+                afterOrdinalB: lastSameB?.ordinal ?? 0,
+                startMsA: op.type === 'remove' ? op.stepA.startMs : (lastSameA?.startMs ?? 0),
+                startMsB: op.type === 'add' ? op.stepB.startMs : (lastSameB?.startMs ?? 0),
+                detail: describeDivergence(op),
+            };
+        }
+    }
+    return {
+        a,
+        b,
+        divergence,
+        added,
+        removed,
+        summaryA: summarize(a),
+        summaryB: summarize(b),
+        truncatedA,
+        truncatedB,
+    };
+}

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

@@ -0,0 +1,19 @@
+import type { SessionTrajectory } from './trajectory.js';
+import type { TrajectoryComparison } from './trajectory-compare.js';
+import type { SessionLineage } from './trajectory-lineage.js';
+/** Render one session's trajectory as a self-contained HTML page. */
+export declare function renderTrajectoryHtml(model: SessionTrajectory): string;
+/** Render a two-session {@link TrajectoryComparison} as a self-contained HTML page. */
+export declare function renderTrajectoryCompareHtml(cmp: TrajectoryComparison): string;
+/**
+ * Render a {@link SessionLineage} as ONE self-contained HTML page: the inline-SVG
+ * delegation graph (orchestrator on top, the sessions it spawned below, edges
+ * 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, redacted?: boolean): string;