@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/commands/sessions-picker.js

@@ -1,44 +1,25 @@
-/**
- * Interactive session picker and preview renderer.
- *
- * Powers the fuzzy-searchable session list shown by `agents sessions` in a TTY.
- * Builds a compact preview for each session (prompt, activity summary, last
- * response) and delegates to the generic `itemPicker` for the interactive UI.
- */
 import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import { truncate, humanDuration, formatBytes } from '../lib/format.js';
-import { sessionDisplayAgent } from '../lib/session/types.js';
+import { sessionDisplayAgent } from '@phnx-labs/sessions-cli/reader';
 import { fetchPeerPreviewDigest } from '../lib/session/remote-list.js';
-import { parseSession, sanitizeForTerminal, SNAPSHOT_TODO_TOOLS } from '../lib/session/parse.js';
-import { readSessionTail, readSessionHead } from '../lib/session/tail.js';
-import { safeTeamText } from '../lib/session/team-filter.js';
-import { cleanSessionPrompt, extractSessionTopic, isSyntheticUserMessage, firstUserMessageFromEvents } from '../lib/session/prompt.js';
-import { linkPath, linkUrl, relativeToCwd, shortenModel } from '../lib/session/render.js';
-import { linearIssueUrl } from '../lib/session/linear.js';
-import { extractTodoProgress, WORKTREE_RE } from '../lib/session/state.js';
+import { parseSession, sanitizeForTerminal, SNAPSHOT_TODO_TOOLS } from '@phnx-labs/sessions-cli/reader';
+import { readSessionTail, readSessionHead } from '@phnx-labs/sessions-cli/reader';
+import { safeTeamText } from '@phnx-labs/sessions-cli/reader';
+import { cleanSessionPrompt, extractSessionTopic, isSyntheticUserMessage, firstUserMessageFromEvents } from '@phnx-labs/sessions-cli/reader';
+import { linkPath, linkUrl, relativeToCwd, shortenModel } from '@phnx-labs/sessions-cli/reader';
+import { linearIssueUrl } from '@phnx-labs/sessions-cli/reader';
+import { extractTodoProgress, WORKTREE_RE } from '@phnx-labs/sessions-cli/reader';
 import { renderMarkdown } from '../lib/markdown.js';
 import { wrapToWidth } from '../lib/wrap.js';
 import { terminalWidth, stringWidth } from '../lib/session/width.js';
 import { itemPicker } from '../lib/picker.js';
 import { createMemoryCache } from '../lib/memory-cache.js';
-import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
-import { extractArtifacts, extractHooks, extractLinks, extractRepos, extractSkills, harnessTracksBackgroundShells, isBackgroundShellStart, isSubAgentTool, } from '../lib/session/highlights.js';
+import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '@phnx-labs/sessions-cli/reader';
+import { extractArtifacts, extractHooks, extractLinks, extractRepos, extractSkills, harnessTracksBackgroundShells, isBackgroundShellStart, isSubAgentTool, } from '@phnx-labs/sessions-cli/reader';
 import { getSessionPlugins, readSessionPreviewCache, writeSessionPreviewCache, readSessionContent, readArchivedSessionPreview } from '../lib/session/db.js';
 import { machineId } from '../lib/session/sync/config.js';
-/** A session whose transcript FILE is on another machine: its `filePath` is on
- * that peer's disk, so the preview can't parse it locally — it fetches the
- * peer's digest over SSH and shows metadata + a "resume there" note until that
- * lands. `_remote` is an explicit signal; a peer `machine` plus no readable
- * local file covers host-dispatch index rows and live-registry rows that were
- * synthesized outside the fan-out. A locally-readable synced mirror stays
- * local even when its recorded owner is another machine.
- *
- * This is the READ rule and only the read rule. Whether a session may be
- * RESUMED here is a different question with a different answer — a mirror is
- * readable but not resumable — and `sessionOwnerDevice`
- * (lib/session/resume-owner.ts) is the single place that answers it (RUSH-2022). */
 export function transcriptOnPeerOf(session) {
     if (session._remote)
         return session.machine;
@@ -49,12 +30,6 @@ export function transcriptOnPeerOf(session) {
     }
     return undefined;
 }
-/**
- * Compact checklist tally for list rows and previews (RUSH-2045).
- * Example: `✓6/8 · A5 wiring runner`. Empty string when there is no list.
- * Consumes `SessionMeta.todos` / `ActiveSession.todos` as populated by the
- * state engine — does not re-parse transcripts.
- */
 export function formatTodoCompact(todos) {
     if (!todos || !Number.isFinite(todos.total) || todos.total < 1)
         return '';
@@ -63,11 +38,6 @@ export function formatTodoCompact(todos) {
     const step = todos.activeForm?.replace(/\s+/g, ' ').trim();
     return step ? `${tally} · ${step}` : tally;
 }
-/**
- * Best-effort GitHub repo URL from a checkout path shaped like
- * `…/github.com/<owner>/<repo>/…`. Used to make the project name clickable
- * when no Linear project URL is available.
- */
 export function githubRepoUrlFromCwd(cwd) {
     if (!cwd)
         return undefined;
@@ -75,12 +45,7 @@ export function githubRepoUrlFromCwd(cwd) {
     const m = norm.match(/\/github\.com\/([^/]+\/[^/]+)/);
     return m ? `https://github.com/${m[1]}` : undefined;
 }
-/**
- * SessionMeta originates in discover.ts (gitBranch, cwd, label, etc. read from
- * untrusted session files). parseSession sanitizes event payloads at its
- * chokepoint, but meta fields bypass that path. Strip terminal escapes here
- * before any meta string reaches a TTY.
- */
+// Peer metadata is untrusted: bound its shape and strip terminal escapes before rendering.
 function sanitizeMeta(s) {
     const clean = (v) => (v == null ? v : sanitizeForTerminal(v));
     const todos = s.todos
@@ -110,9 +75,6 @@ function sanitizeMeta(s) {
         generatedTitle: clean(s.generatedTitle),
         ticketId: clean(s.ticketId),
         prUrl: clean(s.prUrl),
-        // A remote row's meta is peer-supplied JSON that parseRemoteList hands over
-        // unsanitized, and both of these reach the preview pane — so an escape
-        // sequence in a peer's plan text or path list would otherwise hit our TTY.
         plan: clean(s.plan),
         spawnedTeam: clean(s.spawnedTeam),
         recentDirectoriesTouched: s.recentDirectoriesTouched?.map(sanitizeForTerminal),
@@ -130,17 +92,10 @@ const remoteDigestCache = createMemoryCache({
 function remoteDigestKey(sessionId, machine) {
     return `${machine}:${sessionId}`;
 }
-/**
- * The open picker's repaint trigger. The peer fetch resolves while the pane is
- * already painted, so completion has to nudge the picker into re-rendering —
- * pickers register their trigger here (via `registerPreviewRepaint`) and clear
- * it when they close, making a late fetch after close a no-op.
- */
 let remotePreviewRepaint;
 export function setRemotePreviewRepaint(repaint) {
     remotePreviewRepaint = repaint;
 }
-/** Seam for tests: the real fetcher opens an SSH connection to the peer. */
 let peerDigestFetcher = fetchPeerPreviewDigest;
 export function setPeerDigestFetcherForTest(fetcher) {
     peerDigestFetcher = fetcher ?? fetchPeerPreviewDigest;
@@ -148,12 +103,6 @@ export function setPeerDigestFetcherForTest(fetcher) {
 export function clearRemoteDigestCacheForTest() {
     remoteDigestCache.clear();
 }
-/**
- * Look up (or start fetching) the peer digest for a remote row. Returns the
- * current entry synchronously — `buildPreview` renders whatever state exists
- * now, and the fetch's completion repaints the pane through the registered
- * trigger.
- */
 function remoteDigestForPreview(session, machine) {
     const key = remoteDigestKey(session.id, machine);
     const existing = remoteDigestCache.get(key);
@@ -172,14 +121,7 @@ function remoteDigestForPreview(session, machine) {
         .then(() => remotePreviewRepaint?.());
     return pending;
 }
-/**
- * Validate + scrub a peer-supplied preview digest before any of it reaches this
- * terminal. Peer JSON is untrusted at this boundary — the same rule
- * `sanitizeMeta` applies to fan-out rows — so every string is stripped of
- * terminal escapes and every list re-shaped field by field. Anything that
- * doesn't look like the v1 digest is rejected, so a version-skewed peer
- * degrades to the metadata card instead of a corrupted pane.
- */
+// Remote links retain OSC-8 only for http(s); every other field is terminal-sanitized and size-bounded.
 export function sanitizeRemoteDigest(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return undefined;
@@ -235,15 +177,9 @@ export function sanitizeRemoteDigest(raw) {
         planFile: str(d.planFile),
         todos,
         subAgentCount: num(d.subAgentCount),
-        // optNum, not num: a peer's JSON is untrusted, and the undefined-vs-0
-        // distinction is load-bearing here — num() would coerce a malformed value
-        // to 0, which reads as "scanned, none running".
         backgroundShellCount: optNum(d.backgroundShellCount),
         toolTags: strList(d.toolTags),
         changes,
-        // Per-file paths from an untrusted peer: keep only well-formed {path, op}
-        // entries (path scrubbed of terminal escapes, op a known FileOp), bounded
-        // like the local build so a hostile peer can't flood the pane.
         changedFiles: objList(d.changedFiles, (f) => {
             const path = str(f.path);
             const op = f.op === 'created' || f.op === 'modified' || f.op === 'deleted' ? f.op : undefined;
@@ -271,8 +207,6 @@ export function sanitizeRemoteDigest(raw) {
         links: objList(d.links, (l) => {
             const url = str(l.url);
             const label = str(l.label);
-            // Only http(s) URLs render as OSC 8 hyperlinks — anything else a peer
-            // sends (file:, a bare payload) is dropped rather than linkified.
             return /^https?:\/\//.test(url) && label ? { kind: 'other', url, label } : undefined;
         }),
         errorCount: num(d.errorCount),
@@ -295,14 +229,9 @@ function previewCacheKey(session, remote) {
             fileStamp = 'missing';
         }
     }
-    // A remote row's rendered pane depends on the fetched digest's state
-    // (none → pending → ready/failed), so the state rides the key — otherwise the
-    // memoized metadata-only card would keep serving after the digest arrived.
     const remoteDigestState = remote
         ? remoteDigestCache.get(remoteDigestKey(session.id, remote))?.state ?? 'none'
         : '';
-    // The transcript stamp invalidates derived activity. Metadata that can change
-    // independently (label/ticket/PR/live scanner enrichment) also rides the key.
     return JSON.stringify([
         remote ?? '', remoteDigestState, session.id, fileStamp, session.lastActivity, session.label,
         session.generatedTitle,
@@ -317,21 +246,11 @@ export function clearPreviewMemoryCacheForTest() {
 }
 export function loadSessionPreviewDigest(session) {
     if (!session.filePath || !fs.existsSync(session.filePath)) {
-        // File gone, but an archived session (RUSH-2436) keeps its last-computed
-        // digest in the DB — serve that so the picker preview still shows its turns
-        // instead of a bare "not indexed here" note. No events to replay.
         const archived = readArchivedSessionPreview(session.id);
         if (archived) {
             archived.plugins = getSessionPlugins(session.id);
             return { digest: archived, events: [] };
         }
-        // No file on disk AND no archived digest: a metadata-only row (a Rush
-        // dispatch/audit row, a synthesized attach-only entry, a live session not
-        // yet indexed) with nothing to read (PHNX-3999). Callers that only
-        // destructure `digest` (the picker's "not indexed here" note) are
-        // unaffected; a JSON caller reading `error` gets a truthful reason instead
-        // of a `preview: null` that looks identical to "this session genuinely has
-        // no content yet".
         return { events: [], error: 'no local transcript for this session (metadata-only entry, no archived digest)' };
     }
     const safe = sanitizeMeta(session);
@@ -348,49 +267,14 @@ export function loadSessionPreviewDigest(session) {
         fileSize: sourceStamp.size,
     });
     if (!digest) {
+        // Large uncached transcripts use bounded tail plus bounded head, so a tail follow-up is never mislabeled as the first prompt.
         if (sourceStamp.size > PREVIEW_DIGEST_MAX_PARSE_BYTES) {
-            // A full `parseSession` on a cache miss is a synchronous, unbounded
-            // whole-file parse with no time/byte cap of its own (PHNX-3999) — real
-            // 6.3 MiB and 35.7 MiB screenshot-heavy transcripts on this fleet both
-            // lacked a computed digest/timeline, consistent with this path not
-            // finishing in a reasonable request budget for either. `PREVIEW_DIGEST_MAX_PARSE_BYTES`
-            // is deliberately smaller than the daemon's own background-work ceiling
-            // (see that constant's own doc) so this catches both real cases.
-            //
-            // This IS genuinely partial, not empty: rather than parsing nothing,
-            // `readSessionTail` (`tail.ts`) reads only the LAST 128 KiB of the file
-            // (already the live-view's own bounded reader, reused verbatim — no new
-            // parse logic) for a real recent-events window on the two harnesses it
-            // supports (Claude/Codex); event-derived fields below (toolCalls,
-            // toolTags, etc.) reflect that tail window, not the whole session, which
-            // `partialReason` states explicitly.
-            //
-            // `firstUser` is NEVER set from the tail fold: a tail window's "first
-            // user message IN THAT WINDOW" is a mid-session follow-up on any
-            // multi-turn session, not the session's actual original request, and
-            // there is no honest way to tell the two apart from the tail alone.
-            // Falling back to it would silently mislabel a follow-up as the
-            // original ask. Preference order for the CANONICAL original request:
-            // (1) the already-indexed `SessionMeta.firstUserMessage` (zero
-            // extra I/O); (2) failing that, a bounded HEAD read (`readSessionHead`,
-            // `tail.ts` — the mirror of the tail reader, first ~32 KiB from byte 0,
-            // where a session's opening turn always lives) so a row with no indexed
-            // value yet still gets the REAL original request rather than nothing.
-            // Only when neither is available does `firstUser` stay empty —
-            // `partial`/`partialReason` already say why detail is missing, which is
-            // the truthful signal, never a guessed value. The digest is cached
-            // against this stamp so the bound is paid once per transcript version,
-            // not once per call.
             events = readSessionTail(session.filePath, session.agent);
             digest = buildSessionPreviewDigest(events, safe);
             if (session.firstUserMessage) {
                 digest.firstUser = session.firstUserMessage;
             }
             else {
-                // Reuse the canonical extractor (rejects synthetic/system-injected
-                // turns, unwraps a Grok/Cursor <user_query> wrapper) rather than a
-                // bespoke inline find — the same rules SessionMeta.firstUserMessage
-                // itself was built with.
                 digest.firstUser = firstUserMessageFromEvents(readSessionHead(session.filePath, session.agent)) ?? '';
             }
             digest.partial = true;
@@ -421,7 +305,6 @@ export function loadSessionPreviewDigest(session) {
     digest.plugins = getSessionPlugins(session.id);
     return { digest, events };
 }
-/** Build a cached multi-line preview string for display in the session picker. */
 export function buildPreview(session) {
     const remote = transcriptOnPeerOf(session);
     const cacheKey = previewCacheKey(session, remote);
@@ -429,22 +312,9 @@ export function buildPreview(session) {
     if (cached)
         return cached;
     const safe = sanitizeMeta(session);
-    // Remote session: the transcript is on the peer's disk, so there is nothing to
-    // parse here. The common case is now a fleet-synced MIRROR row (PHNX-3792): its
-    // topic + first-user snippet + metadata are already local, so the compact card
-    // renders INLINE with no per-row SSH. The live SSH digest fetch stays as the
-    // fallback for a never-synced row (or a peer whose digest was already fetched
-    // this session), and `space` still reads the full transcript live over SSH.
     if (remote) {
-        // A fleet-synced MIRROR row is the explicit signal that this box already
-        // holds the peer session's topic + first-user snippet locally (PHNX-3792):
-        // render inline with NO per-row SSH. An ordinary remote row (a live fan-out
-        // row, or a never-synced host-dispatch stub) is NOT treated as synced — it
-        // keeps the live digest fetch below, so this change is scoped to mirror rows.
         const fetched = remoteDigestCache.get(remoteDigestKey(session.id, remote));
         if (fetched?.state === 'ready') {
-            // A richer live digest already landed this session (changed files, tool
-            // mix) — prefer it over the lightweight mirror card.
             const note = '  ' + chalk.gray(`on `) + chalk.bold.white(remote)
                 + chalk.gray(` — enter to resume there`);
             const body = formatCompactPreview(fetched.digest, safe);
@@ -460,8 +330,6 @@ export function buildPreview(session) {
             previewCache.set(cacheKey, output);
             return output;
         }
-        // Not a mirror row: fall back to the live SSH digest fetch (kicked off on
-        // first render; the pane repaints when it lands).
         const note = '  ' + chalk.gray(`on `) + chalk.bold.white(remote)
             + chalk.gray(` — enter to resume there, or space then enter to read it over SSH`);
         const entry = remoteDigestForPreview(session, remote);
@@ -479,9 +347,6 @@ export function buildPreview(session) {
         previewCache.set(cacheKey, output);
         return output;
     }
-    // No transcript on disk — either an archived session (file gone, user turns
-    // still in the DB — RUSH-2436), a live session not indexed locally, or a
-    // synthesized entry (an attach-only resume). Show the header + a clean note.
     if (!session.filePath || !fs.existsSync(session.filePath)) {
         const archivedContent = readSessionContent(session.id);
         if (archivedContent && archivedContent.trim() !== '') {
@@ -514,7 +379,6 @@ const DOT = chalk.gray(' · ');
 function formatHeader(session, events) {
     const model = extractModel(events) || session.model;
     const { createdAgo, lastActiveAgo, duration } = extractTiming(session, events);
-    // Line 1: Agent v version · shortId · model · account
     const line1 = [];
     line1.push(chalk.gray(`${displayAgent(sessionDisplayAgent(session))}${session.version ? ` v${session.version}` : ''}`));
     if (session.shortId)
@@ -523,9 +387,6 @@ function formatHeader(session, events) {
         line1.push(chalk.bold.white(shortenModel(model)));
     if (session.account)
         line1.push(chalk.gray(session.account));
-    // Line 2: cwd · project · branch · created X ago · last active Y ago · lasted Z
-    // Project is clickable: Linear issue URL is for tickets (line 4); for the
-    // project name prefer a GitHub repo URL derived from the checkout path.
     const line2 = [];
     if (session.cwd) {
         const label = relativeToCwd(session.cwd);
@@ -543,8 +404,6 @@ function formatHeader(session, events) {
         line2.push(chalk.gray('last active ') + chalk.white(lastActiveAgo + ' ago'));
     if (duration)
         line2.push(chalk.gray('lasted ') + chalk.white(duration));
-    // Line 4: ticket + PR — clickable when a URL is resolvable (OSC 8 hyperlink),
-    // plain text otherwise. Only rendered when the session carries either.
     const line4 = [];
     if (session.ticketId) {
         const url = linearIssueUrl(session.ticketId);
@@ -554,14 +413,6 @@ function formatHeader(session, events) {
         const label = session.prNumber ? `PR#${session.prNumber}` : 'PR';
         line4.push(chalk.blue(linkUrl(session.prUrl, label)));
     }
-    // Lead with the session's human title: `session.label` — an agent-generated
-    // name / `/rename`, else the `--name` launch handle — else the daemon-generated
-    // title (PHNX-3797), which is a short technical NAME, not a restatement of the
-    // prompt. NOT `session.topic`: the topic is the derived first-prompt, already
-    // shown on the `Prompt:` line, so using it here too would print the same text
-    // twice. A session with neither keeps that `Prompt:` line as its topic
-    // indicator and simply leads with the agent line. Wrapped to the pane (the
-    // header sits at column 0, full terminal width).
     const title = (session.label || session.generatedTitle || '').trim();
     const titleLines = title
         ? wrapToWidth(title, terminalWidth()).map(l => chalk.bold.white(l))
@@ -573,44 +424,7 @@ function formatHeader(session, events) {
         ...(line4.length ? [line4.join(DOT)] : []),
     ].join('\n');
 }
-/**
- * Body lines available from SessionMeta alone (no transcript parse) — used for
- * remote / unindexed sessions so checklist progress still surfaces when the
- * parser teammate (or a prior scan) has populated `session.todos`.
- */
-/**
- * The session's place in a team, from whichever end it sits at: the orchestrator
- * that ran `agents teams create` (from the scan-derived `spawnedTeam`), or a
- * teammate (from its `meta.json`, via `classifyTeamSession`). Empty for a session
- * with no team involvement, which is the overwhelming majority.
- *
- * Deliberately no live teammate counts: tallying a team means reading every
- * record under the teams-agents dir, which runs to thousands of files on a busy
- * machine — far too much for a pane that repaints as the cursor moves. The line
- * names the command that does report them instead.
- */
-/**
- * The "what did this session leave running" segments of the Doing line.
- *
- * Prefers a DERIVED count (fresh, from the transcript the caller just parsed)
- * and falls back to the PERSISTED column, which is what lets a remote/unindexed
- * row — rendered from `SessionMeta` alone, with no events — show fan-out at all.
- * That fallback is the whole reason the counts are columns (RUSH-3091/3095).
- *
- * A count of 0 or undefined renders NOTHING. Both are real states — "scanned,
- * none found" and "this harness cannot report it" — and a literal "0 background
- * shells" would assert "nothing is running" for a harness that simply does not
- * record them.
- *
- * Wording is "left behind", not "running": a transcript records a start and
- * never a death (see extractBackgroundShells).
- */
 export function formatFanOut(session, derived) {
-    // DERIVED wins when the caller has one. It is computed from the transcript as
-    // it stands right now, whereas the persisted column is only as fresh as the
-    // last scan — for a live session those disagree within seconds. The persisted
-    // value is the fallback that makes a remote/unindexed row (no events, so no
-    // derived value) render at all, which is the whole reason it is a column.
     const subAgents = derived?.subAgentCount ?? session.subAgentCount ?? 0;
     const shells = derived?.backgroundShellCount ?? session.backgroundShellCount ?? 0;
     const out = [];
@@ -647,10 +461,6 @@ function formatMetaOnlyBody(session) {
     const lines = [];
     const termWidth = process.stdout.columns || 80;
     const valueWidth = termWidth - VERB_GUTTER - 5;
-    // Same verb-led rows as the digest body (RUSH-2757), from SessionMeta alone.
-    // Prefer the fuller first genuine user turn over the one-line topic when the
-    // row carries it (a fleet-synced mirror row does — PHNX-3792) so the inline
-    // card reads like the originating prompt, not just its title.
     const asked = session.firstUserMessage?.trim() || session.topic?.trim();
     if (asked) {
         lines.push(verbLabel('Asked') + chalk.white(`"${truncate(asked, valueWidth)}"`));
@@ -664,9 +474,6 @@ function formatMetaOnlyBody(session) {
     for (const l of session.todos?.items?.length ? renderTodos(session.todos.items, termWidth) : []) {
         lines.push('  ' + l);
     }
-    // `plan` is the whole ExitPlanMode markdown, not a path — summarize it. The
-    // pane is height-clamped anyway, so pasting the blob would just push every
-    // other line out of view.
     const planLines = session.plan?.trim() ? session.plan.trim().split('\n') : [];
     if (planLines.length) {
         const head = truncate(planLines[0].replace(/^#+\s*/, ''), termWidth - 20);
@@ -702,19 +509,7 @@ function extractModel(events) {
     }
     return undefined;
 }
-/** Shortest span worth reporting as a separate last-activity field — matches the
- * listing's rule, so the pane and the row agree on what counts as a one-shot. */
 const TIMING_SPAN_MIN_MS = 60_000;
-/**
- * The three timing facts the header reports: when the session was created, when
- * it was last active, and how long it ran. Reads the parsed transcript when
- * there is one and otherwise the indexed `SessionMeta`, so a remote or
- * unindexed session — which has no local transcript to parse — still reports
- * them instead of silently dropping the whole line.
- *
- * `lastActive` and `lasted` are omitted for a session whose whole life was under
- * a minute: there they just restate `created`.
- */
 export function extractTiming(session, events) {
     const firstMs = Date.parse(events[0]?.timestamp ?? session.timestamp);
     if (Number.isNaN(firstMs))
@@ -723,8 +518,6 @@ export function extractTiming(session, events) {
     const lastMs = Date.parse(events[events.length - 1]?.timestamp ?? session.lastActivity ?? session.timestamp);
     if (Number.isNaN(lastMs))
         return { createdAgo };
-    // A scan-persisted duration beats the timestamp subtraction when there are no
-    // events to read, because `lastActivity` may have fallen back to file mtime.
     const spanMs = events.length === 0 && session.durationMs !== undefined
         ? session.durationMs
         : Math.max(0, lastMs - firstMs);
@@ -749,7 +542,6 @@ function formatTokens(n) {
     const v = n / 1_000_000;
     return (v >= 100 ? Math.round(v).toString() : v.toFixed(1).replace(/\.0$/, '')) + 'm';
 }
-/** Patterns that indicate a user message is system context, not a real prompt. */
 const SYSTEM_MESSAGE_PATTERNS = [
     /^\s*<environment_context>/i,
     /^\s*<system-reminder>/i,
@@ -759,11 +551,8 @@ const SYSTEM_MESSAGE_PATTERNS = [
     /^\s*# AGENTS\.md instructions for\b/i,
     /^\s*<command-(message|name|args)>/i,
 ];
-/** Strip XML/HTML tags and clean up content for display. */
 function stripTags(text) {
-    // Remove complete tag pairs with their content for known system tags
     let cleaned = text.replace(/<(system-reminder|environment_context|permissions[^>]*)>[\s\S]*?<\/\1>/gi, '');
-    // Remove remaining XML-like tags
     cleaned = cleaned.replace(/<\/?[a-z_-]+[^>]*>/gi, '');
     return cleaned;
 }
@@ -771,28 +560,8 @@ const LAST_RESPONSE_MAX_LINES = 15;
 const LAST_RESPONSE_MAX_LINES_WITH_TODOS = 8;
 const TODOS_MAX_ITEMS = 5;
 const DIRS_TOUCHED_MAX = 5;
-// Upper bound on the per-file `changedFiles` list carried on the digest. High
-// enough to cover any real session's edits, low enough that a runaway rewrite
-// can't bloat the cached JSON. The `changes` counts stay the true totals.
 const CHANGED_FILES_MAX = 200;
-/**
- * Bound for an uncached `loadSessionPreviewDigest` parse (PHNX-3999).
- *
- * Deliberately SMALLER than the daemon's own
- * `TIMELINE_PASS_MAX_WHOLE_FILE_BYTES` (16 MiB, `timeline-pass.ts`) — that
- * number bounds BACKGROUND work the daemon tick can afford to spend; this one
- * bounds a SYNCHRONOUS request an interactive caller (the Menu, with its own
- * end-to-end latency budget) is actively waiting on. Two real screenshot-heavy
- * transcripts on this fleet (6.3 MiB and 35.7 MiB) both lacked any computed
- * digest/timeline — a 16 MiB threshold here would still miss the smaller one.
- * The exact per-byte cost of `parseSession` is not measured in this change;
- * 4 MiB is a conservative invariant (well under the 6.3 MiB failure case,
- * comfortably above ordinary non-screenshot transcript sizes), not a timing
- * guarantee — verify against real transcripts before relying on a specific
- * elapsed-time bound.
- */
 const PREVIEW_DIGEST_MAX_PARSE_BYTES = 4 * 1024 * 1024;
-/** Fold a harness-normalized event stream into the stable preview data model. */
 export function buildSessionPreviewDigest(events, session) {
     let firstUser = '';
     let lastAssistant = '';
@@ -800,22 +569,12 @@ export function buildSessionPreviewDigest(events, session) {
     const toolCounts = {};
     let toolCalls = 0;
     let planFile = '';
-    /** Latest checklist from the transcript (Claude TodoWrite / Codex update_plan). */
     let latestTodos;
     let subAgentCount = 0;
-    // undefined, not 0, when the harness records no background-shell concept —
-    // formatFanOut renders absence for both, but conflating them here would let a
-    // later consumer read "0 shells" as a positive "none running" claim.
     let backgroundShellCount = harnessTracksBackgroundShells(session.agent)
         ? 0
         : undefined;
     const toolTags = new Set();
-    // usedBrowser/usedComputer are computed at scan time from a sessionId-scoped
-    // events-log read (session/db.ts detectToolUsage), NOT a transcript regex —
-    // undefined means a legacy row this scanner hasn't computed the field for
-    // yet, so only THEN does classifySessionTool's transcript-derived guess run
-    // below (mirrors directoriesTouched's prefer-persisted/fall-back-to-derived
-    // pattern for recentDirectoriesTouched).
     const knownToolUsage = session.usedBrowser !== undefined;
     for (const event of events) {
         if (event.type === 'message') {
@@ -846,9 +605,6 @@ export function buildSessionPreviewDigest(events, session) {
             if (!planFile && p && /\/plans\/[^/]+\.md$/.test(p)) {
                 planFile = p;
             }
-            // Every harness's checklist-snapshot tool (Claude TodoWrite, Kimi TodoList,
-            // Codex update_plan, …) — the same registry the state engine folds through
-            // extractTodoProgress. Prefer the most recent write.
             if (SNAPSHOT_TODO_TOOLS.has(tool)) {
                 const progress = extractTodoProgress(event.args);
                 if (progress)
@@ -859,15 +615,10 @@ export function buildSessionPreviewDigest(events, session) {
             toolCalls++;
         }
     }
-    // Persisted field wins when computed — it comes from real browser.navigate/
-    // browser.screenshot/computer.action events, not a fuzzy tool-name regex.
     if (session.usedBrowser)
         toolTags.add('browser');
     if (session.usedComputer)
         toolTags.add('computer');
-    // Prefer the transcript-derived list when we just re-parsed the file (freshest
-    // checklist write); fall back to SessionMeta.todos for rows where the scan/
-    // fan-out attached progress but the event stream has no TodoWrite yet.
     const todos = latestTodos ?? session.todos;
     const changes = classifyFileChanges(events);
     const chg = changeCounts(changes);
@@ -884,9 +635,6 @@ export function buildSessionPreviewDigest(events, session) {
         backgroundShellCount,
         toolTags: [...toolTags],
         changes: chg,
-        // Full per-file list the picker used to collapse to `chg` and throw away.
-        // Bounded so a mass-rewrite session can't blow up the cached digest; the
-        // counts above remain the true totals.
         changedFiles: changes.slice(0, CHANGED_FILES_MAX),
         dirs: directoriesTouched(session, events, changes),
         repos: extractRepos(events, session.cwd),
@@ -901,8 +649,6 @@ export function buildSessionPreviewDigest(events, session) {
         test: detectTestResult(events),
     };
 }
-// Verb-led row gutter (RUSH-2757): every row label pads to this width so the
-// values align into one scannable column. 'Details ▸' is the widest label.
 const VERB_GUTTER = 9;
 function verbLabel(v) {
     return chalk.cyan(v.padEnd(VERB_GUTTER)) + ' ';
@@ -912,15 +658,12 @@ function formatCompactPreview(digest, session, events) {
     const lines = [];
     const termWidth = process.stdout.columns || 80;
     const valueWidth = termWidth - VERB_GUTTER - 5;
-    // Asked — the originating user prompt (first non-system user turn), quoted.
     const asked = firstUser
         ? (extractSessionTopic(firstUser) || cleanSessionPrompt(firstUser).split('\n').find(l => l.trim()) || '')
         : (session.topic && !isSyntheticUserMessage(session.topic) ? session.topic : '');
     if (asked.trim()) {
         lines.push(verbLabel('Asked') + chalk.white(`"${truncate(asked.trim(), valueWidth)}"`));
     }
-    // Doing — the work in motion: checklist progress (RUSH-2045), team lineage,
-    // sub-agent fan-out. The full checklist renders indented beneath.
     const compact = formatTodoCompact(todos);
     const teamLine = formatTeamLineage(session);
     const doing = [
@@ -934,8 +677,6 @@ function formatCompactPreview(digest, session, events) {
     const todosRendered = todos?.items?.length ? renderTodos(todos.items, termWidth) : [];
     for (const l of todosRendered)
         lines.push('  ' + l);
-    // Made — what the session produced: file deltas, reads, artifacts (named +
-    // clickable), the plan file, and the PR when the session carries one.
     const made = [];
     const changed = chg.created + chg.modified + chg.deleted;
     if (changed) {
@@ -962,7 +703,6 @@ function formatCompactPreview(digest, session, events) {
     if (made.length) {
         lines.push(verbLabel('Made') + made.join(DOT));
     }
-    // Health — error tally + the last test/build verdict; absent when both clean.
     const health = [];
     if (errorCount) {
         health.push(chalk.red(`${errorCount} failure${errorCount === 1 ? '' : 's'}`) + chalk.gray(` — first: ${firstError || 'unknown'}`));
@@ -978,8 +718,6 @@ function formatCompactPreview(digest, session, events) {
     if (health.length) {
         lines.push(verbLabel('Health') + health.join(DOT));
     }
-    // Cost — volume: messages, tokens (moved here from the header's old line 3),
-    // and the top of the tool mix.
     const totalMessages = session.messageCount ?? (events ? countMessages(events) : undefined);
     const cost = [];
     if (totalMessages !== undefined) {
@@ -997,12 +735,8 @@ function formatCompactPreview(digest, session, events) {
     if (cost.length) {
         lines.push(verbLabel('Cost') + cost.join(DOT));
     }
-    // Latest — the agent's last message, full and wrapped to the pane (the densest
-    // line in the preview; parts 1-2 of RUSH-2757 made it wrap instead of clip).
     if (lastAssistant) {
         const maxLines = todosRendered.length > 0 || compact ? LAST_RESPONSE_MAX_LINES_WITH_TODOS : LAST_RESPONSE_MAX_LINES;
-        // Content sits at column 4 (outer body indent + the '  ' prefix below), so
-        // wrap it to the pane minus that indent.
         const rendered = renderLastResponse(lastAssistant, maxLines, terminalWidth() - 4);
         if (rendered.length > 0) {
             lines.push('');
@@ -1011,12 +745,6 @@ function formatCompactPreview(digest, session, events) {
                 lines.push('  ' + l);
         }
     }
-    // Details ▸ — the folded long tail: session id, skills, plugins, hooks, links,
-    // dirs, repos, capability tags. One width-capped line instead of seven labeled
-    // rows (a long tail used to wrap and swamp the whole pane); links stay
-    // clickable (OSC 8), hook failures stay red. Full lists go to the cap — it is
-    // the ONLY bounding, so its `… +N more` tail accounts for every hidden item
-    // (pre-slicing here made overflow vanish with no trace).
     const details = [
         session.filePath ? chalk.gray(linkPath(session.filePath, session.id.slice(0, 8))) : chalk.gray(session.id.slice(0, 8)),
         ...skills.map(s => chalk.white(s.name) + (s.count > 1 ? chalk.gray(` ×${s.count}`) : '')),
@@ -1040,19 +768,9 @@ function classifySessionTool(tool, command) {
         tags.push('computer');
     return tags;
 }
-/**
- * Unique directories the session touched, compact and human-readable.
- * Prefer `session.recentDirectoriesTouched` — the scan records it on the row, so
- * it is present for remote rows whose transcript we can't parse here — otherwise
- * derive from the file-change + tool paths already available.
- */
 function directoriesTouched(session, events, changes) {
     const fromMeta = session.recentDirectoriesTouched;
     if (Array.isArray(fromMeta) && fromMeta.length > 0) {
-        // The scan stores ABSOLUTE paths, so they go through the same relativizer the
-        // derived branch below uses — otherwise adopting this field (which a remote row
-        // needs, having no transcript to derive from) would turn every local preview's
-        // `Dirs:` line from `src/lib · docs` into a column of full home-rooted paths.
         const seen = new Set();
         for (const raw of fromMeta) {
             const dir = relativizeDir(sanitizeForTerminal(String(raw).trim()), session.cwd);
@@ -1085,31 +803,10 @@ function directoriesTouched(session, events, changes) {
         .map(([d]) => d)
         .slice(0, DIRS_TOUCHED_MAX);
 }
-/**
- * Claude names its per-project transcript store `~/.claude/projects/<slug>`, where
- * `<slug>` is the cwd with every `/` AND `.` replaced by `-` — so `/Users/me/app`
- * → `-Users-me-app` and `.agents/worktrees/x` → `--agents-worktrees-x`. That slug
- * leaks into transcript paths as a leading segment (`<slug>/<session-id>/…`).
- *
- * The encoding is LOSSY and irreversible (`-`, `/`, and `.` all collapse to `-`),
- * so we never try to decode it back to a path. Instead we ENCODE the comparison
- * targets (cwd, the worktree marker) into the same slug space and match there. See
- * {@link relativizeDir}. `encodeClaudeSlug` mirrors Claude's own transform.
- */
 function encodeClaudeSlug(absPath) {
     return absPath.replace(/[/.]/g, '-');
 }
-/** The `.agents/worktrees/<name>` marker, Claude-slug-encoded (`/.` → `--`). */
 const SLUG_WORKTREE_RE = /--agents-worktrees-(.+)$/;
-/**
- * Join display tokens with ` · `, stopping before the line exceeds `maxWidth`
- * and appending `… +N more` for the rest. Keeps the Dirs line on one row.
- */
-/**
- * Join pre-styled items with ` · ` up to a visible width, then `… +N more`.
- * Width is measured ANSI-aware (stringWidth), so colored / OSC 8-linked items
- * are not miscounted; items arrive already styled and are not recolored.
- */
 function joinWidthCapped(items, maxWidth) {
     let out = '';
     let width = 0;
@@ -1126,52 +823,31 @@ function joinWidthCapped(items, maxWidth) {
     const remaining = items.length - shown;
     return out + (remaining > 0 ? chalk.gray(` … +${remaining} more`) : '');
 }
-/** Relativize a file path to its parent dir, short enough for one preview line. */
 export function relativizeDir(filePath, cwd) {
     const norm = filePath.replace(/\\/g, '/');
     if (!norm || norm.includes('node_modules') || norm.includes('/.git/') || norm.includes('/plans/')) {
         return undefined;
     }
-    // agents-cli internals — version homes, session/run archives, the bare
-    // worktree container/root — are never meaningful "directories the user works
-    // in". Cwd is exempt: a session running inside such a dir keeps its own paths.
     const normBase = cwd?.replace(/\\/g, '/').replace(/\/$/, '');
     const underCwd = normBase && (norm === normBase || norm.startsWith(normBase + '/'));
     if (!underCwd && (norm.includes('/.agents/.history/') || /\/\.agents\/worktrees(\/[^/]+)?\/?$/.test(norm))) {
         return undefined;
     }
     let dir = path.posix.dirname(norm);
-    // Claude project-slug form: a leading `-`-segment (`-home-me-…`) that carries
-    // the cwd, lossily encoded. Handle it in SLUG SPACE — never lossy-decode to a
-    // fake path. The slug is the first path segment; any real `/`-subdirs after it
-    // are Claude's internal storage (`<session-id>/scratchpad|tasks`), not code.
     if (dir.startsWith('-')) {
         const slash = dir.indexOf('/');
         const slug = slash === -1 ? dir : dir.slice(0, slash);
-        // CWD FIRST: if the slug is (or is under) this session's own cwd, the leaked
-        // path is Claude's internal projects-storage scratch (`<id>/scratchpad`) —
-        // not a meaningful code dir — so drop it like node_modules. Precedence over
-        // the worktree collapse so a session editing its OWN worktree isn't relabeled.
         if (cwd) {
             const cwdSlug = encodeClaudeSlug(cwd.replace(/\\/g, '/').replace(/\/$/, ''));
             if (slug === cwdSlug || slug.startsWith(cwdSlug + '-'))
                 return undefined;
         }
-        // Only a DIFFERENT worktree than cwd reaches here: a worktree encodes its
-        // `/.agents/worktrees/<name>` marker as `--agents-worktrees-<name>`, so
-        // collapse to the worktree name to disambiguate. (The name may contain `-`;
-        // we can't losslessly re-split it, so show the whole encoded remainder.)
         const wtSlug = slug.match(SLUG_WORKTREE_RE);
         if (wtSlug)
             return `⧉ ${wtSlug[1]}`;
-        // An unattributable slug: don't invent a `/`-joined fake path. Show only the
-        // trailing `-`-group as a minimal, honest token.
         const segs = slug.split('-').filter(Boolean);
         return segs.length ? segs[segs.length - 1] : undefined;
     }
-    // CWD FIRST for real paths too: strip the session-cwd prefix so a session
-    // editing its OWN worktree renders the concise relative remainder (`src/lib`),
-    // not the longer `⧉ <slug>/…` collapse.
     if (cwd) {
         const base = cwd.replace(/\\/g, '/').replace(/\/$/, '');
         if (dir === base)
@@ -1179,18 +855,14 @@ export function relativizeDir(filePath, cwd) {
         if (dir.startsWith(base + '/'))
             return dir.slice(base.length + 1);
     }
-    // No cwd match. If the dir is in a (different) git worktree, collapse to the
-    // worktree NAME + in-worktree remainder to disambiguate; else home→`~` + trim.
     const wt = dir.match(WORKTREE_RE);
     if (wt) {
         const after = dir.slice(dir.indexOf(wt[0]) + wt[0].length).replace(/^\//, '');
         return after ? `⧉ ${wt[1]}/${after}` : `⧉ ${wt[1]}`;
     }
-    // Collapse home prefix.
     const home = (process.env.HOME || '').replace(/\\/g, '/');
     if (home && dir.startsWith(home + '/'))
         dir = '~' + dir.slice(home.length);
-    // Drop ultra-deep absolute noise; keep last 3 segments.
     const parts = dir.split('/').filter(Boolean);
     if (parts.length > 3 && dir.startsWith('/'))
         dir = parts.slice(-3).join('/');
@@ -1207,16 +879,10 @@ export function renderLastResponse(content, maxLines = LAST_RESPONSE_MAX_LINES,
     catch {
         rendered = cleaned;
     }
-    // `marked-terminal` runs with `reflowText` off, so a paragraph with no hard
-    // breaks renders as one long line that overflows the pane. Wrap any line whose
-    // VISIBLE width exceeds the budget; leave lines that already fit untouched so
-    // rendered-markdown indentation (lists, code blocks) is preserved. The text is
-    // ANSI-coloured, so width is measured with `stringWidth`, never `String.length`.
     const all = rendered
         .replace(/\s+$/, '')
         .split('\n')
         .flatMap(line => (stringWidth(line) <= width ? [line] : wrapToWidth(line, width)));
-    // Drop leading/trailing empty lines
     while (all.length && !all[0].trim())
         all.shift();
     while (all.length && !all[all.length - 1].trim())
@@ -1231,7 +897,6 @@ export function renderLastResponse(content, maxLines = LAST_RESPONSE_MAX_LINES,
 function renderTodos(todos, termWidth) {
     const out = [];
     const shown = todos.slice(0, TODOS_MAX_ITEMS);
-    // Outer body indent (2) + inner '  ' (2) + marker (3) + space (1) = 8
     const maxText = Math.max(20, termWidth - 8);
     for (const item of shown) {
         const rawText = (item.content || item.text || '').trim();
@@ -1261,7 +926,6 @@ function renderTodos(todos, termWidth) {
     }
     return out;
 }
-/** Show an interactive session picker and return the selected session with its action (resume or view). */
 export async function sessionPicker(config) {
     const picked = await itemPicker({
         message: config.message,
@@ -1270,8 +934,6 @@ export async function sessionPicker(config) {
         filter: config.filter,
         labelFor: config.labelFor,
         buildPreview,
-        // A remote row's digest arrives over SSH after the pane painted — this is
-        // what lets its completion swap the metadata card for the full preview.
         registerPreviewRepaint: setRemotePreviewRepaint,
         shortIdFor: (s) => s.shortId,
         pageSize: config.pageSize,
@@ -1279,7 +941,6 @@ export async function sessionPicker(config) {
         emptyMessage: 'No sessions match.',
         enterHint: config.enterHint ?? 'resume',
         linesAbovePrompt: config.linesAbovePrompt,
-        // A late digest fetch must not poke a closed prompt.
     }).finally(() => setRemotePreviewRepaint(undefined));
     if (!picked)
         return null;