@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/session/discover.js

@@ -1,11 +1,3 @@
-/**
- * Session discovery across Claude, Codex, Gemini, OpenCode, and OpenClaw.
- *
- * Performs incremental scans: each agent's session files are stat'd and compared
- * to a scan-stamp ledger in SQLite. Only files whose mtime or size changed since
- * the last run are re-parsed. All metadata is upserted into the sessions DB so
- * subsequent queries are served entirely from the cache.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -22,13 +14,14 @@ import { walkForFilesWithStat } from '../fs-walk.js';
 import { hasCommand } from '../cli-resources.js';
 import { execFileShellSpec } from '../platform/exec.js';
 import { getConfigSymlinkVersion } from '../installations/shims.js';
-import { SESSION_AGENTS } from './types.js';
+import { SESSION_AGENTS } from '@phnx-labs/sessions-cli/reader';
 import { deriveShortId } from './short-id.js';
 import { buildClaudeAccountIndex, resolveClaudeAccount } from './claude-accounts.js';
-import { cleanFirstUserMessage, extractSessionTopic, extractSlashCommandName, extractSlashCommandFromToolInput, cleanGeneratedSessionLabel } from './prompt.js';
-import { isBackgroundShellStart, isSkillInvocation, extractSkills, extractSlashCommands, isSubAgentTool } from './highlights.js';
-import { parseAntigravity, parseCursor, splitSessionFilePath } from './parse.js';
-import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
+import { cleanFirstUserMessage, extractSessionTopic, extractSlashCommandName, extractSlashCommandFromToolInput, cleanGeneratedSessionLabel } from '@phnx-labs/sessions-cli/reader';
+import { isBackgroundShellStart, isSkillInvocation, extractSkills, extractSlashCommands, isSubAgentTool } from '@phnx-labs/sessions-cli/reader';
+import { claudeSubagentFiles, resolvedSubAgentCount } from './glance-files.js';
+import { parseAntigravity, parseCursor, splitSessionFilePath } from '@phnx-labs/sessions-cli/reader';
+import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from '@phnx-labs/sessions-cli/reader';
 import { costOfUsage, costOfUsageNoCache } from '../pricing/index.js';
 import { isSelfHost } from '../devices/self-host.js';
 import { readSessionActorRecord } from './actor-sidecar.js';
@@ -38,31 +31,16 @@ import { mapBounded } from '../concurrency.js';
 import { getDB, getScanStampByPath, getScanStampsForPaths, getParserStatesForPaths, getDirLedgerForPaths, recordDirScans, recordScans, syncLabels, seedLabelsFromNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, getSessionById, tryClaimScan, releaseScan, scanInProgressByLivePid, cacheLinearProject, CONTENT_INDEX_VERSION, } from './db.js';
 import { buildRunNameMap } from './run-names.js';
 import { resolveLinearApiKey } from '../linear-cache.js';
-import { ToolCallCollector, collectClaudeToolCalls, collectCodexToolCalls, } from './tool-calls.js';
+import { ToolCallCollector, collectClaudeToolCalls, collectCodexToolCalls, } from '@phnx-labs/sessions-cli/reader';
 import { purgeMissingToolCallsInDirectory } from './tool-store.js';
 const HOME = os.homedir();
-// Versions can live under either repo: the user repo (current canonical
-// location, ~/.agents/.history/versions/) or the system repo (legacy / npm-shipped,
-// ~/.agents-system/versions/). Both must be scanned — sessions written by
-// any installed version end up in that version's projects/ dir, and the user
-// can be running one repo's version while another repo holds older versions
-// whose JSONLs the user still wants to search.
 const VERSIONS_ROOTS = [getHistoryDir(), getAgentsDir()];
 const RUSH_SESSIONS_DIR = path.join(HOME, '.rush', 'sessions');
 const HERMES_SESSIONS_DIR = path.join(HOME, '.hermes', 'sessions');
-/** Muse Code sessions: ~/.local/share/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl */
 const MUSE_SESSIONS_DIR = path.join(HOME, '.local', 'share', 'muse', 'sessions');
-/** How long OpenClaw channel/cron snapshots stay valid before we re-shell-out. */
 const OPENCLAW_TTL_MS = 60_000;
 const ACTIVE_APPEND_RESCAN_DEBOUNCE_MS = 5_000;
-/** One JSONL record may not force an unbounded string allocation. */
 const SESSION_JSONL_LINE_MAX_BYTES = 1024 * 1024;
-/**
- * Stream one appended JSONL range, applying only newline-terminated records.
- * Memory is bounded to one record. An ordinary unterminated tail remains for the
- * next scan. Once a record exceeds the cap, its consumed offset and a one-bit
- * dropping state advance together so later scans never reread the growing tail.
- */
 async function applyJsonlAppend(filePath, fromOffset, wasDroppingOversizedLine, apply) {
     let pending = Buffer.alloc(0);
     let droppingOversizedLine = wasDroppingOversizedLine;
@@ -101,7 +79,6 @@ async function applyJsonlAppend(filePath, fromOffset, wasDroppingOversizedLine,
                                 apply(JSON.parse(line));
                             }
                             catch {
-                                // One malformed line never aborts the session scan.
                             }
                         }
                     }
@@ -122,56 +99,30 @@ async function applyJsonlAppend(filePath, fromOffset, wasDroppingOversizedLine,
     }
     return { consumedBytes, droppingOversizedLine, skippedOversizedLine };
 }
-/**
- * How recently a file must have been scanned to be treated as "hot" — a
- * candidate for an in-place append even when its parent dir's mtime hasn't
- * moved. A dir-ledger match lets us skip the per-file stat of everything in a
- * leaf dir EXCEPT its hot set; a file is hot if it lives under the agent's live
- * `~/.<agent>` root (the only tree an agent appends to live) or was scanned
- * within this window. 10 minutes comfortably covers a session that paused
- * between `agents sessions` calls but is still being written to.
- */
 const HOT_FILE_WINDOW_MS = 600_000;
-/** Emergency kill-switch for the directory-ledger optimization. */
 function dirLedgerDisabled() {
     const v = process.env.AGENTS_SESSIONS_NO_DIR_LEDGER;
     return v === '1' || v === 'true';
 }
 let cachedOpenClawWorkspaces = null;
-/** Max time a `waitForScan` repair waits for a concurrent scan to settle. */
 const WAIT_FOR_SCAN_TIMEOUT_MS = 2_000;
 const WAIT_FOR_SCAN_POLL_MS = 100;
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 const cachedAgentVersions = new Map();
-/**
- * Discover sessions. Scans only files whose (mtime, size) have changed since
- * the last run; everything else is served from the SQLite cache.
- *
- * Only one process runs the incremental scan at a time. When many agents boot
- * simultaneously (e.g. after a restart), the first to claim the scan slot does
- * the work; the rest skip parsing entirely and serve from the DB. The claim is
- * stored in the `meta` table — crash-safe via dead-PID detection and a 2-min
- * TTL, no external lock files needed.
- */
 export async function discoverSessions(options) {
     const { claimed } = await scanSessionsIncremental({
         agent: options?.agent,
         onProgress: options?.onProgress,
     });
     if (!claimed && options?.waitForScan) {
-        // Lost the single-flight claim to another live process (a foreground
-        // `agents sessions*` or the daemon's index warm). Rather than return the
-        // pre-scan snapshot that just missed, wait (bounded) for that scan to finish
-        // so the read below reflects what it wrote (RUSH-2682 cold-miss repair).
         await waitForScanToSettle();
     }
     return queryIndexedSessions(options, {
         skipExistenceCheck: options?.skipExistenceCheck ?? false,
     });
 }
-/** Read only matching Claude/Codex transcripts on a cold ID lookup; indexing stays with the daemon. */
 export async function findLocalSessionTranscripts(selector, agent) {
     const matches = new Map();
     const seen = new Set();
@@ -209,7 +160,6 @@ export async function findLocalSessionTranscripts(selector, agent) {
     }
     return [...matches.values()];
 }
-/** Repair local metadata before deciding that a conversation has no context. */
 export async function hydrateSessionTranscript(session) {
     const accountId = session.accountId ?? readSessionActorRecord(session.id)?.accountId;
     if (accountId && !session.accountId)
@@ -219,7 +169,7 @@ export async function hydrateSessionTranscript(session) {
         if (file && fs.statSync(file).isFile() && fs.statSync(file).size > 0)
             return session;
     }
-    catch { /* A moved account home needs a canonical rescan. */ }
+    catch { }
     if (session.machine && !isSelfHost(session.machine))
         return session;
     if (session.agent === 'claude' || session.agent === 'codex') {
@@ -237,33 +187,20 @@ export async function hydrateSessionTranscript(session) {
     const indexed = getSessionById(session.id);
     return indexed ? { ...session, ...indexed, accountId: session.accountId ?? indexed.accountId } : session;
 }
-/** Separate write half so daemon warming does not pay for listing or external enrichment. */
 export async function scanSessionsIncremental(options) {
-    // Touch the DB so the schema is ready and connection is cached for this run.
     getDB();
     const agents = options?.agent ? [options.agent] : SESSION_AGENTS;
     const onProgress = options?.onProgress;
     if (!tryClaimScan(process.pid))
         return { claimed: false, scanned: 0 };
-    // `parsed` climbs monotonically within one scanner run, so the last value per
-    // (phase, agent) is that scanner's total. Phase-keyed because the dotfile scan
-    // and the routine-archive scan both report under the same agent id.
     const parsedByPhaseAgent = new Map();
     const track = (phase) => (p) => {
         parsedByPhaseAgent.set(`${phase}\0${p.agent}`, p.parsed);
         onProgress?.(p);
     };
     try {
-        // Bounded + staggered instead of a single Promise.all: scanning every
-        // agent's dotfile dir (~/.claude, ~/.codex, ~/.gemini, …) simultaneously
-        // reads to behavioral EDR (CrowdStrike Falcon) as a ransomware-style bulk
-        // file-enumeration sweep. Same dirs, same results — just not all at once.
         await scanAgentsBounded(agents, agent => dispatchAgentScan(agent, track('dotfiles')));
         await scanAgentsBounded(agents, agent => scanRoutineArchivesIncremental(agent, track('routines')));
-        // Seed labels from `agents run --name` handles onto the freshly-scanned
-        // rows by id. Runs AFTER the per-agent scans (which applied agent-generated
-        // titles via syncLabels), so a real title always wins and the seed only
-        // backfills sessions that would otherwise be unnamed.
         seedLabelsFromNames(buildRunNameMap());
     }
     finally {
@@ -274,7 +211,6 @@ export async function scanSessionsIncremental(options) {
         scanned += n;
     return { claimed: true, scanned };
 }
-/** Bounded wait so a wedged scan cannot hang a foreground cold-miss repair. */
 export async function waitForScanToSettle(timeoutMs = WAIT_FOR_SCAN_TIMEOUT_MS, pollMs = WAIT_FOR_SCAN_POLL_MS) {
     const deadline = Date.now() + timeoutMs;
     while (scanInProgressByLivePid()) {
@@ -284,7 +220,6 @@ export async function waitForScanToSettle(timeoutMs = WAIT_FOR_SCAN_TIMEOUT_MS,
     }
     return true;
 }
-/** Read the current SQLite snapshot without scanning or parsing transcript files. */
 export async function queryIndexedSessions(options, indexedOptions = {}) {
     getDB();
     const agents = options?.agent ? [options.agent] : SESSION_AGENTS;
@@ -292,24 +227,11 @@ export async function queryIndexedSessions(options, indexedOptions = {}) {
     if (indexedOptions.resolveLinear !== false)
         await resolveLinearProjects(sessions);
     for (const s of sessions) {
-        // A non-empty transcript path is authoritative for origin (a live-home file
-        // is this box; `backups/<agent>/<machine>/…` names that peer), so derive
-        // there. An EMPTY file_path carries no such signal — `machineForSessionFile`
-        // falls back to THIS box — so keep the machine the row was recorded with
-        // instead: a host dispatch stamps the EXECUTION host on its empty-file index
-        // row (`registerHostSession`), and re-deriving re-attributed the dispatcher's
-        // own pool row to itself, splitting it from the executing peer's fan-out row
-        // and making resume-by-id read as "ambiguous (2 sessions)" (RUSH-2486 /
-        // RUSH-2479 criterion 2). A recorded-less empty-file row still falls back.
         if (s.filePath || !s.machine?.trim())
             s.machine = machineForSessionFile(s.filePath, s.agent);
     }
     return scopeToManaged(sessions, agents, options);
 }
-/**
- * Resolve locally without scanning or fleet I/O, keeping concurrent crash recovery lock-light.
- * The existence check preserves archived content while rejecting transcriptless phantoms.
- */
 export async function resolveIndexedSessionById(idQuery) {
     const q = idQuery.trim();
     if (!q)
@@ -357,16 +279,6 @@ async function resolveLinearProjects(sessions) {
         cacheLinearProject(session.id, project.name, project.url);
     }));
 }
-/**
- * Drop unmanaged rows for agents that HAVE managed versions.
- *
- * Scoping happens here, at query time, rather than by narrowing the scan: the index
- * stays complete, so `--unmanaged` needs no re-scan and every other consumer of the
- * DB (watchdog, the Factory watcher, `--roots`) is unaffected.
- *
- * An agent with no managed versions is left alone entirely — someone who has never
- * run `agents add` sees exactly what they saw before.
- */
 export function scopeToManaged(sessions, agents, options) {
     if (options?.includeUnmanaged)
         return sessions;
@@ -378,12 +290,6 @@ export function scopeToManaged(sessions, agents, options) {
         options?.onHiddenUnmanaged?.(hidden);
     return kept;
 }
-/**
- * True once agents-cli manages ANY agent version. Until then it manages nothing, so
- * scoping to "managed only" would leave the listing empty for a user who has never
- * run `agents add` — the browser is most of the tool's value before you install
- * anything through it.
- */
 function anyManagedVersions() {
     for (const root of VERSIONS_ROOTS) {
         const base = path.join(root, 'versions');
@@ -401,26 +307,19 @@ function anyManagedVersions() {
                 if (fs.readdirSync(path.join(base, a.name), { withFileTypes: true }).some((e) => e.isDirectory()))
                     return true;
             }
-            catch { /* unreadable */ }
+            catch { }
         }
     }
     return false;
 }
-/**
- * How many agents' dotfile dirs we scan at once, and the minimum spacing between
- * successive scan starts. A small bound + stagger turns a simultaneous bulk
- * multi-dotfile sweep (a behavioral-EDR file-enumeration trigger) into a trickle.
- */
 export const DOTFILE_SCAN_CONCURRENCY = 2;
 const DOTFILE_SCAN_STAGGER_MS = 15;
-/** Run each agent's incremental scan, bounded + staggered. Order is irrelevant (each scan writes its own rows). */
 export function scanAgentsBounded(items, run) {
     return mapBounded(items, run, {
         concurrency: DOTFILE_SCAN_CONCURRENCY,
         staggerMs: DOTFILE_SCAN_STAGGER_MS,
     });
 }
-/** Dispatch a single agent's incremental dotfile scan. */
 function dispatchAgentScan(agent, onProgress) {
     switch (agent) {
         case 'claude': return scanClaudeIncremental(onProgress);
@@ -438,61 +337,18 @@ function dispatchAgentScan(agent, onProgress) {
         default: return Promise.resolve();
     }
 }
-/**
- * The machine a discovered session originated on. Cross-machine sync mirrors a
- * remote transcript to backups/<agent>/<machine>/<subdir>/… (see mirrorPath in
- * sync/agents.ts); every other transcript is a live-home file on this box. So:
- * when the path sits under the agent's backups root, the first segment below it
- * is the origin machine id; otherwise it's the local machine.
- */
-/**
- * True when this transcript belongs to a version agents-cli manages — i.e. it lives
- * under a version home (or a backup mirror of one) rather than in the user's own
- * `~/.<agent>`.
- *
- * `agents sessions` scans both, which is right for indexing: the DB stays a complete
- * picture and `--unmanaged` can surface everything without a re-scan. But listing
- * *by default* is a different question. Once you have managed versions, an unmanaged
- * install's history is not really agents-cli's to show — most visibly after
- * `agents add --isolated`, where the whole point was to keep the two apart.
- */
 export function isManagedSessionFile(filePath) {
-    // Synthetic rows (OpenClaw workspace sessions, cloud/remote entries) have no local
-    // transcript to classify. They are produced BY agents-cli rather than read out of
-    // someone's dotfile dir, so scoping must not silently swallow them.
     if (!filePath || !path.isAbsolute(filePath))
         return true;
-    // A composite file_path (`<container>#<id>`) names a row inside a single shared
-    // DB the scanner reads from one fixed location (OpenCode's `opencode.db`) — that
-    // store is never a per-install dotfile under a version home, so the managed-vs-
-    // unmanaged split does not apply: there is exactly one store, not a "your own"
-    // copy to hide. Classifying it as unmanaged hid every OpenCode row from default
-    // listings once any agent was managed (RUSH-2357). Keyed off the composite FORM,
-    // so any future single-DB harness inherits this.
     if (splitSessionFilePath(filePath).fragment !== undefined)
         return true;
     const roots = [
         ...VERSIONS_ROOTS.map((root) => path.join(root, 'versions')),
         path.join(getHistoryDir(), 'backups'),
-        // Codex's managed home is not always under versions/. On macOS the versioned path
-        // overflows SUN_LEN for codex's control socket, so the shim relocates it to
-        // `<agentsUserDir>/.codex-homes/<key>/` (lib/codex-home.ts) — keyed by version OR
-        // by account short key (`a-<accountId prefix>`, lib/codex-home.ts `codexShortKey`).
         path.join(getUserAgentsDir(), '.codex-homes'),
-        // Account slots (PHNX-3940): a named account's HOME-shaped dir under
-        // `<historyDir>/accounts/<agent>/<accountId>/` (lib/accounts/slots.ts
-        // `slotDir`), sharing the one managed install rather than owning a version
-        // home of its own. Without this root, every account-slot transcript read as
-        // unmanaged the moment any version was managed, hiding a fully registered,
-        // runnable account's entire history from the default listing.
         path.join(getHistoryDir(), 'accounts'),
-        // Routine archives are agents-cli's OWN run output — managed by definition.
         getRunsDir(),
     ];
-    // Compare realpaths as well as the literal roots. A transcript's stored path is
-    // resolved, so on macOS (`/var` -> `/private/var`) a temp-dir HOME yields
-    // `/private/var/...` for the file and `/var/...` for the root, and a plain prefix
-    // test silently classifies every managed session as the user's own.
     const real = safeRealpathSync(filePath) || filePath;
     return roots.some((root) => {
         if (filePath.startsWith(root + path.sep))
@@ -501,16 +357,10 @@ export function isManagedSessionFile(filePath) {
         return !!realRoot && real.startsWith(realRoot + path.sep);
     });
 }
-/**
- * Count sessions in scope without running an incremental scan. Assumes the DB
- * is already fresh (typically true because `discoverSessions` ran first this
- * turn). Uses the exact same filter shape as the discover query.
- */
 export function countSessionsInScope(options) {
     const agents = options.agent ? [options.agent] : SESSION_AGENTS;
     return countSessions(buildQueryOptions(options, agents, { includeLimit: false }));
 }
-/** Translate DiscoverOptions into the QueryOptions shape expected by the DB layer. */
 function buildQueryOptions(options, agents, opts) {
     const projectQuery = options?.project?.trim();
     const sinceMs = options?.since ? parseTimeFilter(options.since) : undefined;
@@ -521,8 +371,6 @@ function buildQueryOptions(options, agents, opts) {
         cwdPrefixFilter = normalizeCwd(options.cwdPrefix);
     }
     else if (!options?.all && !projectQuery && options?.agent !== 'rush' && options?.agent !== 'hermes') {
-        // Rush and Hermes sessions are cloud/gateway-bound and have no cwd — skip
-        // cwd filtering when the user explicitly asked for them.
         cwdFilter = normalizeCwd(options?.cwd || process.cwd());
     }
     return {
@@ -546,109 +394,36 @@ function buildQueryOptions(options, agents, opts) {
         idPrefix: options?.idPrefix,
     };
 }
-/**
- * Canonicalize a working directory path (follows symlinks when it is local).
- *
- * Most callers pass a cwd RECORDED in a transcript, which may name a directory
- * on another machine — a POSIX path read on a Windows host, say. `path.resolve()`
- * rebases such a path onto the current drive (`/Users/me` -> `D:\Users\me`),
- * inventing a location that never existed. So an absolute path is normalized but
- * never rebased; only a genuinely relative one resolves against the process cwd.
- *
- * `path.normalize()` still runs on every branch: it collapses `.`, `..`, and
- * duplicate separators, and folds separators on Windows. Both sides of the cwd
- * filter in `db.ts` (`cwd = ?` and `cwd LIKE ? || path.sep || '%'`) come through
- * here, so dropping that would leave a trailing slash or a `..` segment in one
- * side and match nothing.
- *
- * Realpath is attempted only for a path that is absolute in THIS platform's
- * terms. A POSIX-rooted path on Windows is drive-relative to `fs.realpathSync`,
- * which would resolve `/Users/me` against the current drive and reintroduce the
- * graft for any path that happens to exist locally.
- */
 export function _normalizeCwdForTest(cwd) {
     return normalizeCwd(cwd);
 }
 function normalizeCwd(cwd) {
     if (!cwd)
         return '';
-    // A POSIX-rooted path on Windows belongs to another machine. Normalize it with
-    // POSIX rules so its separators survive — path.win32.normalize would fold them
-    // to backslashes, mangling the very path we are trying to preserve — and never
-    // realpath it, since fs.realpathSync would resolve it against the current drive.
     if (process.platform === 'win32' && /^\//.test(cwd) && !/^[a-zA-Z]:/.test(cwd)) {
         return stripTrailingSep(path.posix.normalize(cwd));
     }
-    // The mirror case (RUSH-2358): a Windows-rooted path (`C:\...`, `C:/...`, or a
-    // UNC `\\server\share\...`) read on POSIX belongs to another machine too, but
-    // `path.isAbsolute()` here uses POSIX rules and doesn't recognize a drive
-    // letter — without this branch such a cwd falls into the `path.resolve()` arm
-    // below and gets silently prefixed with THIS process's own cwd, corrupting the
-    // path (and, via WORKTREE_RE, can misattribute the worktree slug to whatever
-    // worktree the reading process happens to be running in). Normalize with
-    // win32 rules so separators survive; never realpath it, for the same
-    // cross-drive reason as the mirror branch above.
     if (process.platform !== 'win32' && /^([a-zA-Z]:[\\/]|\\\\)/.test(cwd)) {
         return stripTrailingSep(path.win32.normalize(cwd));
     }
     const normalized = path.isAbsolute(cwd) ? stripTrailingSep(path.normalize(cwd)) : path.resolve(cwd);
     return safeRealpathSync(normalized) || normalized;
 }
-/** Drop a trailing separator so `cwd = ?` and the `cwd LIKE ? + sep` subdir
- *  wildcard agree; a root path (`/`, `C:\`) keeps its separator. */
 function stripTrailingSep(p) {
     const stripped = p.replace(/[\\/]+$/, '');
     return stripped.length > 0 && !/^[a-zA-Z]:$/.test(stripped) ? stripped : p;
 }
-/** Canonical 8-4-4-4-12 hex UUID (covers both v4 and the v7 ids newer harnesses mint). */
 const UUID_36 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-/** kimi and rush mint `session_` + a UUID. */
 const SESSION_UUID_PREFIX = /^session_/;
-/** opencode mints `ses_` + a 26-char ULID — NOT a UUID, so it needs its own shape. */
 const SES_ULID = /^ses_[0-9a-z]{26}$/;
-/**
- * Whether a query is a session id in full, rather than an id prefix or a search
- * phrase.
- *
- * Callers use this to decide that an id lookup is the ONLY admissible
- * interpretation: a complete id is unique, so when it misses there is nothing
- * left to widen to. Without the check, `sessions <uuid>` fell through to the
- * FTS content search, which tokenizes the UUID and matches every transcript that
- * merely mentions it — surfacing unrelated sessions as if they were id matches.
- *
- * The accepted shapes are the ones the index actually holds, measured over a
- * 12,507-row index: a bare UUID (11,116 rows), `session_` + UUID (1,360 — kimi
- * and rush), and `ses_` + ULID (15 — opencode). Deliberately NOT covered, so a
- * miss keeps today's search behavior rather than gaining a wrong error: routine
- * run ids (ISO timestamps, matched via `routineRunId` below) and cloud execution
- * ids, whose charset is too permissive to distinguish from a search phrase.
- */
 export function isCompleteSessionId(query) {
     const q = query.trim().toLowerCase();
     return UUID_36.test(q.replace(SESSION_UUID_PREFIX, '')) || SES_ULID.test(q);
 }
-/**
- * Whether a query should be treated as a session id rather than a search phrase
- * — the one canonical id-shaped test, shared by every session-id resolver.
- *
- * True for a complete id (`isCompleteSessionId`) AND for a bare hex short-id or
- * prefix (`d3470b57`), which the complete-id check rejects. Any id-shaped query
- * resolves by id ONLY (exact -> prefix -> `findSessionsById` index) and must
- * never fall back to fuzzy content search: a short id like `d3470b57` otherwise
- * surfaces every transcript that merely MENTIONS the string (a resume prompt
- * echoes the parent id into the body of many later sessions). The hex test
- * catches the bare short-id/prefix; `isCompleteSessionId` additionally catches
- * the prefixed whole ids (`session_…`, `ses_…`) that the hex test rejects.
- */
 export function looksLikeSessionId(query) {
     const trimmed = query.trim();
     return /^[0-9a-f-]{6,}$/i.test(trimmed) || isCompleteSessionId(trimmed);
 }
-/**
- * Resolve a session by full or short ID. Accepts a pre-loaded session list
- * (fast path from discoverSessions) and falls back to a DB lookup for the
- * "I only know the id" case.
- */
 export function resolveSessionById(sessions, idQuery) {
     const query = idQuery.toLowerCase();
     const exact = sessions.filter(s => s.id.toLowerCase() === query ||
@@ -660,20 +435,6 @@ export function resolveSessionById(sessions, idQuery) {
         s.shortId.toLowerCase().startsWith(query) ||
         s.routineRunId?.toLowerCase().startsWith(query));
 }
-// ---------------------------------------------------------------------------
-// Content-index search (FTS5-backed)
-// ---------------------------------------------------------------------------
-/**
- * Run an FTS5 search over the DB and union hits with the given session list.
- *
- * The listing pool is a minority of the index — cwd-scoped, default-capped at
- * 50, and skipping whole classes of indexed transcript — so intersecting FTS
- * hits with it dropped grep-visible sessions that the index already found
- * (PHNX-2767: `agents sessions "tmux pane"` returned 0 while the project
- * transcripts matched). Hits already in the pool keep the caller's SessionMeta;
- * hits the pool missed are hydrated from the index so a content query returns
- * the transcript FTS matched.
- */
 export function searchContentIndex(sessions, query) {
     if (!query.trim())
         return new Map();
@@ -695,18 +456,6 @@ export function searchContentIndex(sessions, query) {
     }
     return result;
 }
-// ---------------------------------------------------------------------------
-// Incremental scan orchestration
-// ---------------------------------------------------------------------------
-/**
- * For a list of files, stat each, compare to the DB ledger, and return only
- * the ones that need rescanning. One bulk DB query for the whole list.
- *
- * Actively running agents append to their JSONL every few seconds. Without a
- * small debounce, repeated `agents sessions` invocations stream-parse the same
- * growing transcript over and over. The cached row is good enough for a few
- * seconds; once writes settle or the debounce expires, the file is parsed once.
- */
 export function filterChangedFiles(filePaths) {
     const entries = [];
     for (const filePath of filePaths) {
@@ -717,19 +466,6 @@ export function filterChangedFiles(filePaths) {
     }
     return filterChangedEntries(entries);
 }
-/**
- * Ledger-compare pre-stat'd entries (from the walk's own stat) without a second
- * stat. Same debounce and change-detection as filterChangedFiles; the raw
- * mtime is floored here so warm files match the ledger exactly as the stat path
- * does (Math.floor(stat.mtimeMs)).
- *
- * A file is also treated as "changed" — independent of (mtime, size) — when
- * its ledger row's `extractor_version` is behind {@link CONTENT_INDEX_VERSION}.
- * This is the lever that backfills a content-extractor improvement (e.g.
- * indexing assistant answers, not just user prompts) into every already-scanned
- * session on its next pass, without a `DELETE FROM scan_ledger` that would also
- * discard the Claude/Codex resumable parser_state.
- */
 export function filterChangedEntries(entries) {
     const ledger = getScanStampsForPaths(entries.map(e => e.filePath));
     const out = [];
@@ -760,31 +496,10 @@ export function shouldDeferRecentAppend(prev, current, nowMs, debounceMs = ACTIV
         return false;
     return nowMs - prev.scannedAt < debounceMs;
 }
-/**
- * Walk a set of leaf transcript directories and return the files that changed,
- * skipping the per-file `stat` of directories whose (mtime, entry_count) matches
- * the dir_ledger.
- *
- * Per leaf dir:
- *   - `stat` the dir once and `readdir` it (one cheap syscall) to get the entry
- *     count and the file list.
- *   - If the dir matches the dir_ledger (floored mtime AND entry_count), no file
- *     was created / deleted / renamed since we last walked it. We then stat ONLY
- *     the hot files (live-root files, or files scanned within HOT_FILE_WINDOW_MS)
- *     and run just those through the ledger compare — so an in-place append to a
- *     still-live session is still caught, while immutable backup/version dirs
- *     collapse to a single dir stat and zero per-file stats.
- *   - Else (changed dir, or no ledger row) we stat every file (today's full
- *     walk) and record the fresh dir stamp so the next run can short-circuit.
- *
- * The kill-switch (`AGENTS_SESSIONS_NO_DIR_LEDGER=1`) forces the full-walk branch
- * for every dir and never consults or records the dir_ledger.
- */
 function collectChangedFilesInLeafDirs(leafDirs, ext) {
     const disabled = dirLedgerDisabled();
     const dirStamps = disabled ? new Map() : getDirLedgerForPaths(leafDirs.map(d => d.dirPath));
     const now = Date.now();
-    // Files whose per-file stat we still need to ledger-compare this run.
     const toCompare = [];
     const allFiles = [];
     const dirScansToRecord = [];
@@ -807,16 +522,6 @@ function collectChangedFilesInLeafDirs(leafDirs, ext) {
         const prevDir = dirStamps.get(dirPath);
         const dirUnchanged = !disabled && prevDir !== undefined && prevDir.dirMtimeMs === dirMtimeMs && prevDir.entryCount === entryCount;
         if (dirUnchanged) {
-            // Contents did not change (no create/delete/rename). Stat only the hot
-            // files; the rest are served from the DB with no stat. An immutable backup
-            // dir (not a live root, nothing recently scanned) does zero per-file stats.
-            //
-            // A live-root dir treats every file as hot — that is the tree an agent
-            // appends to live, and an append does NOT bump the parent-dir mtime, so
-            // without this a growing session would be silently skipped. A non-live
-            // file is hot only if it was scanned within HOT_FILE_WINDOW_MS (bulk ledger
-            // lookup), covering a session under a version/backup path that is somehow
-            // still being written.
             const stamps = isLiveRoot ? null : getScanStampsForPaths(files);
             for (const filePath of files) {
                 let hot = isLiveRoot;
@@ -832,10 +537,8 @@ function collectChangedFilesInLeafDirs(leafDirs, ext) {
                     continue;
                 toCompare.push({ filePath, fileMtimeMs: stat.mtimeMs, fileSize: stat.size });
             }
-            // No dir stamp to record — nothing about the dir changed.
         }
         else {
-            // Changed dir (or cold ledger): full per-file stat, exactly as today.
             for (const filePath of files) {
                 const stat = safeStatSync(filePath);
                 if (!stat)
@@ -852,13 +555,6 @@ function collectChangedFilesInLeafDirs(leafDirs, ext) {
         recordDirScans(dirScansToRecord);
     return { changed, allFiles };
 }
-// ---------------------------------------------------------------------------
-// Multi-version directory scanning
-// ---------------------------------------------------------------------------
-/**
- * Collect all directories to scan for an agent's sessions. Deduplicates by
- * realpath to avoid double-counting symlinked version homes.
- */
 export function getAgentSessionDirs(agent, subdir) {
     const resolved = new Set();
     const dirs = [];
@@ -872,9 +568,6 @@ export function getAgentSessionDirs(agent, subdir) {
         resolved.add(key);
         dirs.push(dir);
     }
-    // Config-dir name relative to home — handles nested layouts (antigravity →
-    // .gemini/antigravity-cli) and ~/.config agents (amp, goose) as well as kimi
-    // (.kimi-code). Falls back to `.${agent}` for ids not in the registry.
     const configDirName = agent in AGENTS ? agentConfigDirName(agent) : `.${agent}`;
     addDir(path.join(HOME, configDirName, subdir));
     for (const root of VERSIONS_ROOTS) {
@@ -886,19 +579,8 @@ export function getAgentSessionDirs(agent, subdir) {
                 addDir(path.join(versionsBase, version, 'home', configDirName, subdir));
             }
         }
-        catch { /* dir unreadable */ }
-    }
-    // Codex's managed home is not always where the version layout says. On macOS
-    // the versioned path overflows SUN_LEN (104 bytes) for codex's control socket,
-    // so the shim relocates the home to `<agentsUserDir>/.codex-homes/<key>/.codex`
-    // (lib/codex-home.ts) — `<key>` is the version for a version home, or
-    // `a-<accountId prefix>` (`codexShortKey`) for an account slot under
-    // `<historyDir>/accounts/codex/`. Walking `.codex-homes/` directly — rather
-    // than deriving keys from the installed-version list — is what catches BOTH:
-    // an account short key is not a vendor version and never appears in
-    // `versions/codex/`, so iterating only installed versions silently dropped
-    // every transcript a codex account slot wrote. addDir skips what does not
-    // exist, so this is inert on Linux and for homes that never needed relocating.
+        catch { }
+    }
     if (agent === 'codex') {
         const codexHomesBase = path.join(getUserAgentsDir(), '.codex-homes');
         try {
@@ -906,25 +588,15 @@ export function getAgentSessionDirs(agent, subdir) {
                 addDir(path.join(codexHomesBase, key, '.codex', subdir));
             }
         }
-        catch { /* dir absent or unreadable */ }
-    }
-    // Account slots (PHNX-3940): a named account gets its own HOME-shaped dir
-    // under `<historyDir>/accounts/<agent>/<accountId>/`, sharing the one managed
-    // binary install rather than owning a version home of its own
-    // (lib/accounts/slots.ts `slotDir`). A slot-launched transcript lives ONLY
-    // there — never under `versions/` — so without this root it is fully
-    // discoverable by the account machinery (the account is registered and
-    // runnable) yet invisible to `agents sessions`, reading as if the history had
-    // vanished. `addDir` follows the realpath, so a codex slot whose `.codex` is a
-    // symlink onto its `.codex-homes/<key>` short home (SUN_LEN relocation, above)
-    // is deduplicated against that same target rather than double-counted.
+        catch { }
+    }
     const accountsBase = path.join(getHistoryDir(), 'accounts', agent);
     try {
         for (const accountId of fs.readdirSync(accountsBase)) {
             addDir(path.join(accountsBase, accountId, configDirName, subdir));
         }
     }
-    catch { /* dir absent or unreadable */ }
+    catch { }
     const backupsBase = path.join(getHistoryDir(), 'backups', agent);
     if (fs.existsSync(backupsBase)) {
         try {
@@ -932,18 +604,10 @@ export function getAgentSessionDirs(agent, subdir) {
                 addDir(path.join(backupsBase, ts, subdir));
             }
         }
-        catch { /* dir unreadable */ }
+        catch { }
     }
     return dirs;
 }
-/**
- * The (agent, subdir) pairs `discoverSessions` walks for JSONL transcripts —
- * the single source of truth for which directories hold live session files.
- * `getSessionRoots` expands each pair to its concrete directories so a consumer
- * (AGI EXT's fs.watch, see issue #741) can configure its watcher
- * from the CLI instead of hardcoding `~/.claude|.codex|.gemini`. Adding a new
- * on-disk agent here makes every consumer watch it automatically.
- */
 const SESSION_ROOT_SPECS = [
     { agent: 'claude', subdir: 'projects' },
     { agent: 'codex', subdir: 'sessions' },
@@ -956,12 +620,6 @@ const SESSION_ROOT_SPECS = [
 function sessionRootSubdir(agent) {
     return SESSION_ROOT_SPECS.find((spec) => spec.agent === agent)?.subdir ?? null;
 }
-/**
- * The directories `agents sessions` scans for each on-disk session agent,
- * resolved to what exists on this machine. Emitted by `agents sessions --roots
- * --json` so external watchers stay in lockstep with the CLI's discovery paths.
- * Agents with no directories present are omitted.
- */
 export function getSessionRoots() {
     const out = [];
     for (const { agent, subdir } of SESSION_ROOT_SPECS) {
@@ -1030,9 +688,6 @@ async function readRoutineArchiveMeta(agent, filePath) {
         return null;
     if (agent === 'claude') {
         const sessionId = path.basename(filePath).replace(/\.jsonl$/, '');
-        // Routine archives are finalized, immutable transcripts — no live append, so
-        // no continuation to resume. A FULL parse (undefined prior) is correct here;
-        // the returned continuation is unused by this archive path.
         const stat = safeStatSync(filePath);
         if (!stat)
             return null;
@@ -1045,8 +700,6 @@ async function readRoutineArchiveMeta(agent, filePath) {
         return result ? { ...result, meta: decorateRoutineSession(result.meta, info) } : null;
     }
     if (agent === 'cursor') {
-        // PR #1723 archives Cursor routine transcripts; preserve version resolution
-        // when this reader consumes those archives.
         const currentVersion = await getCurrentAgentVersion('cursor');
         const result = readCursorMeta(filePath, currentVersion);
         return result ? { ...result, meta: decorateRoutineSession(result.meta, info) } : null;
@@ -1096,34 +749,12 @@ async function scanRoutineArchivesIncremental(agent, onProgress) {
     upsertSessionsBatch(entries);
     recordScans(touched);
 }
-// ---------------------------------------------------------------------------
-// Claude account info
-// ---------------------------------------------------------------------------
 let cachedClaudeAccountIndex;
-/**
- * The account-attribution index, built at most once per scan pass.
- *
- * Rebuilt when `refresh` is set — `scanClaudeIncremental` does that at the start of
- * each pass so a long-lived process (the daemon) picks up an `agents use` switch or a
- * fresh login instead of attributing later sessions to a stale set of homes. Per-file
- * resolution then reads the cached index, because rebuilding it per transcript would
- * re-read every home's `.claude.json` thousands of times.
- */
 function claudeAccountIndex(refresh = false) {
     if (refresh || !cachedClaudeAccountIndex)
         cachedClaudeAccountIndex = buildClaudeAccountIndex();
     return cachedClaudeAccountIndex;
 }
-// ---------------------------------------------------------------------------
-// Claude
-// ---------------------------------------------------------------------------
-/**
- * Build a map of Claude sessionId -> user-given label from ~/.claude/sessions/*.json.
- * Each JSON has shape { pid, sessionId, cwd, startedAt, name?, ... }. The
- * `name` field only exists if the user ran /rename in that session.
- * For sessionId collisions (re-resume of the same session), prefer the most
- * recent startedAt.
- */
 export function buildClaudeLabelMap() {
     const map = new Map();
     const dir = path.join(HOME, '.claude', 'sessions');
@@ -1148,23 +779,16 @@ export function buildClaudeLabelMap() {
                 map.set(data.sessionId, { label: name, startedAt });
             }
         }
-        catch { /* unreadable session metadata file */ }
+        catch { }
     }
     const out = new Map();
     for (const [sid, { label }] of map)
         out.set(sid, label);
     return out;
 }
-/** Incrementally re-scan changed Claude session files and upsert into the DB. */
 async function scanClaudeIncremental(onProgress) {
-    // Rebuild once per pass; readClaudeMeta resolves each transcript against it.
     claudeAccountIndex(true);
     const labelMap = buildClaudeLabelMap();
-    // Enumerate every leaf project dir across all Claude roots. The FIRST root
-    // returned by getAgentSessionDirs is the agent's live `~/.claude/projects` —
-    // the only tree Claude appends to in place, so its project dirs are live roots
-    // (every file hot). Version-home + backup roots are immutable: their dirs
-    // short-circuit to a single dir stat when unchanged.
     const roots = getAgentSessionDirs('claude', 'projects');
     const leafDirs = [];
     const seenLeaf = new Set();
@@ -1187,17 +811,6 @@ async function scanClaudeIncremental(onProgress) {
         }
     });
     const { changed: changedAll, allFiles } = collectChangedFilesInLeafDirs(leafDirs, '.jsonl');
-    // Restore the pre-A-2 cross-root precedence: a session id present in multiple
-    // roots is ALWAYS served from its live path, never a frozen backup/version
-    // copy. Pre-A-2, dedup happened at enumeration time via a live-first `seen`
-    // set, so a non-live copy was never even stat'd when a live copy existed. This
-    // PR must not regress that to "whichever copy changed this run wins" — a cold
-    // (unchanged) live copy paired with a freshly-written backup snapshot would
-    // otherwise flip the row's file_path to the backup path.
-    //
-    // allFiles is every transcript file across all roots in live-first order, so
-    // the FIRST occurrence of each session id is its live (or highest-precedence)
-    // path — the durable winner, independent of which copy was flagged changed.
     const sessionIdOf = (fp) => path.basename(fp).replace('.jsonl', '');
     const winnerBySession = new Map();
     for (const { filePath } of allFiles) {
@@ -1205,18 +818,9 @@ async function scanClaudeIncremental(onProgress) {
         if (!winnerBySession.has(id))
             winnerBySession.set(id, filePath);
     }
-    // Keep a changed entry only if it is its session's winner. A changed non-live
-    // copy is dropped whenever a live copy exists anywhere; the winning path is
-    // parsed only when it itself changed (a cold winner needs no re-parse — its DB
-    // row already points at the live path).
     const changed = changedAll.filter(e => winnerBySession.get(sessionIdOf(e.filePath)) === e.filePath);
     if (changed.length > 0) {
         onProgress?.({ agent: 'claude', parsed: 0, total: changed.length });
-        // Bulk-fetch each changed file's prior resumable continuation. A file with a
-        // usable prior state + growth goes incremental (re-parse only the appended
-        // bytes); everything else does a FULL from-offset-0 parse. The decision + the
-        // parse both live in scanClaudeSessionResumable so full and incremental share
-        // one reducer and produce identical rows.
         const priorStates = getParserStatesForPaths(changed.map(c => c.filePath));
         const entries = [];
         const touched = [];
@@ -1252,24 +856,10 @@ async function scanClaudeIncremental(onProgress) {
         upsertSessionsBatch(entries);
         recordScans(touched);
     }
-    // Pick up /rename changes on sessions whose JSONL didn't change.
-    // Only bother for sessions we actually have a Claude row for.
     if (labelMap.size > 0)
         syncLabels(labelMap);
 }
-/**
- * Stream-parse a single Claude JSONL file to extract session metadata, resuming
- * from the persisted continuation when the file merely grew (see
- * {@link scanClaudeSessionResumable}). Returns the row's meta + FTS content plus
- * the serialized continuation (parser_state + content_text) to persist for the
- * next scan.
- */
 async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
-    // A prior continuation extracted at an older CONTENT_INDEX_VERSION is missing
-    // whatever the current extractor adds (e.g. assistant-answer text) — resuming
-    // from it would fold only the NEWLY appended lines into that gap, never
-    // backfilling the file's earlier assistant text. Treat it as absent so the
-    // file gets one full from-offset-0 reparse instead.
     const prior = priorRow?.extractorVersion === CONTENT_INDEX_VERSION ? parsePriorClaudeState(priorRow) : null;
     const { scan, newState, toolCalls, mode } = await scanClaudeSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
     if (mode === 'incremental')
@@ -1277,9 +867,6 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
     else
         claudeFullScanCount++;
     const isTeamOrigin = scan.entrypoint === 'sdk-cli';
-    // Which account produced this transcript. Resolved from the path plus the version
-    // recorded inside the file, so rows under the mutable ~/.claude symlink are
-    // attributed to the version that actually wrote them. See claude-accounts.ts.
     const acct = resolveClaudeAccount(claudeAccountIndex(), filePath, scan.version, readSessionActorRecord(sessionId)?.accountId);
     let meta;
     if (scan.timestamp) {
@@ -1301,8 +888,6 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             accountOrg: acct.orgName ?? undefined,
             topic: scan.topic,
             firstUserMessage: scan.firstUserMessage,
-            // The live sessions metadata file contains only user `/rename` values;
-            // prefer it when present, then fall back to the title parsed from JSONL.
             label: label || scan.label,
             messageCount: scan.messageCount,
             toolCallCount: scan.toolCallCount,
@@ -1343,8 +928,6 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             accountKey: acct.key,
             accountOrg: acct.orgName ?? undefined,
             model: scan.model,
-            // Keep parsed ai-title/custom-title values even when the transcript has
-            // no timestamp and therefore takes this stat-backed fallback path.
             label: label || scan.label,
             messageCount: scan.messageCount,
             toolCallCount: scan.toolCallCount,
@@ -1378,26 +961,14 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
         meta,
         content: scan.contentText || '',
         assistantContent: scan.assistantText || '',
-        // Persist the continuation so the next scan of this file can resume from the
-        // offset instead of a full reparse. content_text is the same accumulated user
-        // doc, cached so the resume can hydrate userTexts without re-reading the file.
         parserState: JSON.stringify(newState),
         contentText: newState.contentText,
         toolCalls,
         toolIndexMode: mode === 'full' ? 'replace' : 'append',
     };
 }
-// ---------------------------------------------------------------------------
-// Codex account info
-// ---------------------------------------------------------------------------
 let cachedCodexAccount;
-/** Number of times the auth.json JWT was actually base64-decoded. Test seam for the lazy-decode contract. */
 let codexAccountResolveCount = 0;
-/**
- * Base64url-decode a JWT and return its `email` claim, if present. Split out so
- * the decode is a single, testable step — and so it only runs when someone
- * actually reads the Codex account (see the lazy resolution below).
- */
 export function decodeJwtEmail(idToken) {
     const parts = idToken.split('.');
     if (parts.length < 2)
@@ -1407,17 +978,9 @@ export function decodeJwtEmail(idToken) {
         return typeof payload.email === 'string' ? payload.email : undefined;
     }
     catch {
-        return undefined; // malformed JWT
+        return undefined;
     }
 }
-/**
- * Extract the Codex account email from the JWT id_token in auth.json.
- *
- * Memoized and resolved LAZILY: the credential-harvesting-shaped JWT decode
- * (base64-decoding ~/.codex/auth.json) only runs when the account is actually
- * needed to build a session's metadata — never eagerly during the bulk scan.
- * A scan with no changed Codex files never touches the auth file.
- */
 function getCodexAccount() {
     if (cachedCodexAccount !== undefined)
         return cachedCodexAccount || undefined;
@@ -1432,7 +995,7 @@ function getCodexAccount() {
                 candidates.push(path.join(versionsBase, version, 'home', '.codex', 'auth.json'));
             }
         }
-        catch { /* versions dir unreadable */ }
+        catch { }
     }
     for (const candidate of candidates) {
         try {
@@ -1448,59 +1011,37 @@ function getCodexAccount() {
                 }
             }
         }
-        catch { /* auth file malformed */ }
+        catch { }
     }
     cachedCodexAccount = '';
     return undefined;
 }
-/** Test seam: how many times getCodexAccount has actually resolved (decoded) since the last reset. */
 export function __codexAccountResolveCountForTest() {
     return codexAccountResolveCount;
 }
-/** Test seam: clear the memoized account + resolve counter so laziness can be observed from a clean slate. */
 export function __resetCodexAccountCacheForTest() {
     cachedCodexAccount = undefined;
     codexAccountResolveCount = 0;
 }
-// ---------------------------------------------------------------------------
-// Codex
-// ---------------------------------------------------------------------------
-/** Incrementally re-scan changed Codex session files and upsert into the DB. */
 async function scanCodexIncremental(onProgress) {
-    // Lazy: getCodexAccount (the auth.json JWT decode) is only resolved by
-    // readCodexMeta when a changed session actually needs it — never eagerly here,
-    // so a no-op scan (changed.length === 0) never touches the credential file.
     const currentVersion = await getCurrentAgentVersion('codex');
     const prestat = [];
     for (const sessionsDir of getAgentSessionDirs('codex', 'sessions')) {
-        // High limit: the walk stats each file once here; parsing is gated by the
-        // ledger match below, which reuses that stat instead of re-stat'ing.
         for (const f of walkForFilesWithStat(sessionsDir, '.jsonl', 100_000)) {
             prestat.push({ filePath: f.path, fileMtimeMs: f.mtimeMs, fileSize: f.size });
         }
     }
     const changed = filterChangedEntries(prestat);
-    // Codex keeps human-readable titles (`thread_name`) in `session_index.jsonl`,
-    // which updates independently of the rollout files. Stat each index against the
-    // ledger *without reading it*; only read + re-apply titles when the index (or a
-    // rollout) actually changed. On a fully unchanged scan this collapses to a
-    // couple of stat() calls instead of a full read + a `syncTopics` DB pass.
     const titleIndex = diffCodexTitleIndexes();
     if (changed.length === 0 && !titleIndex.changed)
         return;
     const titles = readCodexThreadNames();
     if (changed.length === 0) {
-        // No rollouts changed, but the title index did — apply the new titles.
         syncTopics(titles);
         recordScans(titleIndex.stamps);
         return;
     }
     onProgress?.({ agent: 'codex', parsed: 0, total: changed.length });
-    // Bulk-fetch each changed rollout's prior resumable continuation. A file with
-    // a usable prior state + growth goes incremental (re-parse only the appended
-    // bytes); everything else does a FULL from-offset-0 parse. The decision + the
-    // parse both live in scanCodexSessionResumable so full and incremental share
-    // one reducer and produce identical rows.
     const priorStates = getParserStatesForPaths(changed.map(c => c.filePath));
     const entries = [];
     const touched = [];
@@ -1512,7 +1053,6 @@ async function scanCodexIncremental(onProgress) {
             const result = await readCodexMeta(filePath, getCodexAccount, currentVersion, scan, priorRow);
             if (result && !seen.has(result.meta.id)) {
                 seen.add(result.meta.id);
-                // Prefer the Codex-generated title over the first-prompt fallback.
                 const title = titles.get(result.meta.id);
                 if (title)
                     result.meta.topic = title;
@@ -1539,14 +1079,10 @@ async function scanCodexIncremental(onProgress) {
     }
     upsertSessionsBatch(entries);
     recordScans(touched);
-    // Only when the title index changed can an *unchanged* rollout have gained a
-    // title since the last scan; the inline titles applied above already cover
-    // every changed session, so skip the extra sync when the index is untouched.
     if (titleIndex.changed)
         syncTopics(titles);
     recordScans(titleIndex.stamps);
 }
-/** Parse the lines of a Codex `session_index.jsonl` into a session id -> title map. */
 export function parseCodexThreadNameIndex(raw) {
     const titles = new Map();
     for (const line of raw.split('\n')) {
@@ -1560,20 +1096,10 @@ export function parseCodexThreadNameIndex(raw) {
                 titles.set(id, name);
         }
         catch {
-            // skip malformed line
         }
     }
     return titles;
 }
-/**
- * Stat every Codex `session_index.jsonl` and diff it against the scan ledger
- * *without reading it*. Returns the fresh stamps (persisted only after a
- * successful title sync) and whether any index changed since the last scan — the
- * signal that lets a no-op scan skip the file read + `syncTopics` entirely.
- *
- * The index path is a sibling of `sessions/` (never inside it), so it is never
- * walked as a rollout and its ledger row can't collide with a transcript's.
- */
 function diffCodexTitleIndexes() {
     const stamps = [];
     let changed = false;
@@ -1581,7 +1107,7 @@ function diffCodexTitleIndexes() {
         const indexPath = path.join(path.dirname(sessionsDir), 'session_index.jsonl');
         const stat = safeStatSync(indexPath);
         if (!stat)
-            continue; // no index in this home
+            continue;
         const scan = { fileMtimeMs: Math.floor(stat.mtimeMs), fileSize: stat.size };
         const prev = getScanStampByPath(indexPath);
         if (!prev || prev.fileMtimeMs !== scan.fileMtimeMs || prev.fileSize !== scan.fileSize) {
@@ -1591,10 +1117,6 @@ function diffCodexTitleIndexes() {
     }
     return { stamps, changed };
 }
-/**
- * Read Codex session titles across every Codex home (live + versioned). The
- * `session_index.jsonl` file sits beside each `sessions/` rollout tree.
- */
 function readCodexThreadNames() {
     const titles = new Map();
     for (const sessionsDir of getAgentSessionDirs('codex', 'sessions')) {
@@ -1604,35 +1126,20 @@ function readCodexThreadNames() {
             raw = fs.readFileSync(indexPath, 'utf-8');
         }
         catch {
-            continue; // no index in this home
+            continue;
         }
         for (const [id, name] of parseCodexThreadNameIndex(raw))
             titles.set(id, name);
     }
     return titles;
 }
-/**
- * Stream-parse a single Codex JSONL file to extract session metadata.
- *
- * `resolveAccount` is a lazy thunk (not a resolved string): the JWT decode it
- * performs is deferred until we know this file is a real session worth building
- * metadata for, and only then — never during the file walk / stat phase.
- */
 export async function readCodexMeta(filePath, resolveAccount, currentVersion, scanStamp, priorRow) {
-    // Resume from the persisted continuation when the file merely grew; otherwise
-    // full-parse from byte 0. Both branches share one reducer, so an append yields
-    // a row identical to a from-scratch reparse. When no stamp is supplied (a
-    // caller outside the live scan path), fall back to a plain full parse with no
-    // continuation to persist.
     let scan;
     let newState;
     let newOffset = 0;
     let toolCalls;
     let toolIndexMode = 'replace';
     if (scanStamp) {
-        // See readClaudeMeta: a prior continuation from an older content extractor
-        // is missing what the current extractor adds, so it must not be resumed
-        // from — treat it as absent and force one full reparse.
         const prior = priorRow?.extractorVersion === CONTENT_INDEX_VERSION ? parsePriorCodexState(priorRow) : null;
         const result = await scanCodexSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
         if (result.mode === 'incremental')
@@ -1656,8 +1163,6 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         id: sessionId,
         shortId: deriveShortId(sessionId),
         agent: 'codex',
-        // Codex `session_meta` only carries the start time; use file mtime when
-        // it's newer so long-running sessions register as recently active.
         timestamp: pickLatestCodexTimestamp(scan.timestamp, filePath),
         lastActivity: scan.lastActivity,
         project: cwd ? path.basename(cwd) : undefined,
@@ -1691,21 +1196,12 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         meta,
         content: scan.contentText || '',
         assistantContent: scan.assistantText || '',
-        // Persist the continuation so the next scan of this rollout resumes from the
-        // offset instead of a full reparse; content_text caches the accumulated user
-        // doc for the resume's hydrate. Absent when no stamp was supplied.
         parserState: newState ? JSON.stringify(newState) : undefined,
         contentText: newState?.contentText,
         toolCalls,
         toolIndexMode,
     };
 }
-/**
- * Codex writes `session_meta` (with the start timestamp) on the first line of a
- * rollout and never updates it. For long-running sessions that's stale by
- * hours — `--since 2h` would drop a session still being actively written.
- * Compare against the file's mtime and use whichever is newer.
- */
 function pickLatestCodexTimestamp(metaTimestamp, filePath) {
     const fallback = new Date().toISOString();
     let mtimeIso = null;
@@ -1713,24 +1209,12 @@ function pickLatestCodexTimestamp(metaTimestamp, filePath) {
         mtimeIso = fs.statSync(filePath).mtime.toISOString();
     }
     catch {
-        /* file vanished between scan and stat */
     }
     const candidates = [metaTimestamp, mtimeIso].filter((v) => !!v);
     if (candidates.length === 0)
         return fallback;
     return candidates.reduce((best, cur) => (cur > best ? cur : best));
 }
-// ---------------------------------------------------------------------------
-// Antigravity
-//
-// Antigravity stores one SQLite DB per conversation at
-// ~/.gemini/antigravity-cli/conversations/<trajectory-uuid>.db. The filename
-// (minus .db) is the canonical session id. Each DB is stat'd against the ledger;
-// only changed DBs are re-parsed (via parseAntigravity, which shells out to
-// sqlite3). Tool count doubles as the message count; the toolSummary of the
-// first tool call becomes the topic, and any run_command's Cwd fills in cwd.
-// ---------------------------------------------------------------------------
-/** Incrementally re-scan changed Antigravity conversation DBs and upsert into the DB. */
 async function scanAntigravityIncremental(onProgress) {
     const currentVersion = await getCurrentAgentVersion('antigravity');
     const filePaths = [];
@@ -1779,13 +1263,11 @@ async function scanAntigravityIncremental(onProgress) {
     upsertSessionsBatch(entries);
     recordScans(touched);
 }
-/** Parse a single Antigravity conversation DB to extract session metadata. */
 function readAntigravityMeta(filePath, currentVersion) {
     const sessionId = path.basename(filePath).replace(/\.db$/, '');
     if (!sessionId)
         return null;
     const events = parseAntigravity(filePath);
-    // cwd: first run_command carries the working directory in its Cwd arg.
     let cwd;
     const contentParts = [];
     for (const e of events) {
@@ -1795,7 +1277,6 @@ function readAntigravityMeta(filePath, currentVersion) {
             contentParts.push(e.content);
     }
     const normalizedCwd = cwd ? normalizeCwd(cwd) : undefined;
-    // Topic: the first tool's human summary is a decent one-line label.
     const topic = events.find(e => e.content)?.content;
     const stat = safeStatSync(filePath);
     const meta = {
@@ -1812,73 +1293,15 @@ function readAntigravityMeta(filePath, currentVersion) {
     };
     return { meta, content: contentParts.join('\n'), events };
 }
-// ---------------------------------------------------------------------------
-// OpenCode
-// ---------------------------------------------------------------------------
 const OPENCODE_DB = path.join(HOME, '.local', 'share', 'opencode', 'opencode.db');
 let cachedOpenCodeAccount;
-/**
- * The active OpenCode account: the provider ids with a valid credential in
- * `auth.json`, joined (e.g. `"anthropic+muse-spark"`) — see
- * `resolveOpenCodeAccountId` in `../agents.js`, the single source of truth
- * `agents view`/`agents doctor` also read.
- *
- * OpenCode's `opencode.db` also carries `account`/`account_state`/
- * `control_account` tables that look like the obvious source, but on a real,
- * actively-used install (yosemite-s1, 1.16.0, 35 applied migrations) all
- * three are permanently empty — no migration populates them and no session
- * has ever written a row. Querying them (the pre-fix behavior here) always
- * returned undefined, credential or not; `auth.json` is what OpenCode
- * actually reads at runtime.
- */
 function getOpenCodeAccount() {
     if (cachedOpenCodeAccount !== undefined)
         return cachedOpenCodeAccount || undefined;
     cachedOpenCodeAccount = resolveOpenCodeAccountId(HOME) ?? '';
     return cachedOpenCodeAccount || undefined;
 }
-/**
- * The per-session ledger stamp for an OpenCode row: the newest write time across
- * the session's own row, its messages, and its parts, paired with the total byte
- * length of that session's message + part payloads.
- *
- * OpenCode keeps every session in ONE shared SQLite file, so that file's
- * mtime/size changes whenever *any* session is written. Stamping each session
- * with the whole-DB stat therefore invalidated every indexed session on every
- * scan: up to `LIMIT 1000` sessions were re-emitted into `upsertSessionsBatch`,
- * and its enrichment step re-opened `opencode.db` once per re-emitted entry via
- * `parseSession` (RUSH-2210).
- *
- * `s.time_updated` alone is NOT that session's change signal, which is the trap
- * this shape exists to avoid. On a real database, parts land long after the
- * session row was last touched — e.g. `ses_3955202dfffe…` carried
- * `time_updated = 1771316403087` with its newest part at `1771331512162`, over
- * four hours later. So the stamp maxes `time_updated` with the newest message
- * and part times, and pairs it with a byte total that also moves when an
- * existing part's `data` is rewritten in place (a streaming turn) without any
- * new row or timestamp.
- *
- * The byte total is a REAL size, not a repurposed counter, because
- * `sessions.file_size` is read back as bytes elsewhere: `ensureToolIndex` uses
- * it as the tool-backfill byte budget and `toolCallsForBackfill` as the 16 MiB
- * in-memory parser cap (`tool-index.ts`). A message/part byte total is the
- * honest cost of parsing that session — strictly better than the whole-DB size
- * this column used to hold for every OpenCode row.
- *
- * The size is `LENGTH(CAST(data AS BLOB))`, not `LENGTH(data)`: SQLite's
- * `LENGTH()` on a TEXT column counts CHARACTERS, so a CJK/emoji-heavy transcript
- * would under-report its real size by up to 4x — and this number is a byte
- * budget downstream.
- *
- * A degenerate row — nothing but zeros/NaN for every time AND no payload at all
- * — falls back to the whole-DB stat, keeping the pre-RUSH-2210 always-rescan
- * behavior for exactly those rows rather than pinning them to a stamp that never
- * changes.
- */
 function openCodeSessionStamp(times, bytes, dbScan) {
-    // A positive time, not merely a finite one: the SQL COALESCEs the aggregates
-    // to 0, so `Number.isFinite` alone would accept a row that told us nothing and
-    // this branch could never fire.
     const known = [times.timeUpdated, times.lastMessageAt, times.lastPartAt, times.timeCreated]
         .filter(t => Number.isFinite(t) && t > 0);
     const size = (Number.isFinite(bytes.messageBytes) ? bytes.messageBytes : 0)
@@ -1887,24 +1310,18 @@ function openCodeSessionStamp(times, bytes, dbScan) {
         return dbScan;
     return { fileMtimeMs: known.length === 0 ? 0 : Math.floor(Math.max(...known)), fileSize: size };
 }
-/** Scan OpenCode sessions from its SQLite database when the DB file has changed. */
 async function scanOpenCodeIncremental(onProgress) {
     if (!fs.existsSync(OPENCODE_DB))
         return;
     const stat = safeStatSync(OPENCODE_DB);
     if (!stat)
         return;
-    // OpenCode is one big DB. Its mtime/size is the cheap "did ANYTHING change"
-    // short-circuit for the whole harness — not the per-session stamp, which each
-    // row carries itself (see openCodeSessionStamp, RUSH-2210).
     const currentScan = {
         fileMtimeMs: Math.floor(stat.mtimeMs),
         fileSize: stat.size,
     };
     const prev = getScanStampByPath(OPENCODE_DB);
     const extractorUpgrade = prev != null && prev.extractorVersion !== CONTENT_INDEX_VERSION;
-    // OpenCode has a shared database rather than one transcript file per session,
-    // so this container-level gate must honor extractor-version invalidation too.
     if (prev &&
         prev.fileMtimeMs === currentScan.fileMtimeMs &&
         prev.fileSize === currentScan.fileSize &&
@@ -1912,24 +1329,13 @@ async function scanOpenCodeIncremental(onProgress) {
         return;
     }
     const currentVersion = await getCurrentAgentVersion('opencode');
-    // Read through the node/bun SQLite wrapper (not the `sqlite3` CLI) so this
-    // works on every OS — the CLI is absent on Windows.
     let db;
     try {
         db = new Database(OPENCODE_DB);
-        // OpenCode's `session` schema varies by version: `cost` and `model` are newer
-        // columns. Probe once and select NULL where absent, so an older opencode.db
-        // still scans instead of throwing "no such column" and dropping every session.
         const sessionCols = new Set(db.prepare('PRAGMA table_info(session);').all()
             .map(c => (typeof c.name === 'string' ? c.name : '')));
         const costExpr = sessionCols.has('cost') ? 's.cost' : 'NULL';
         const modelExpr = sessionCols.has('model') ? 's.model' : 'NULL';
-        // Every `json_extract` / `json_type` below is guarded by `json_valid`.
-        // SQLite raises "malformed JSON" on a non-JSON value, and that aborts the
-        // WHOLE query — so a single unparseable `part`/`message` row anywhere in the
-        // shared DB would drop EVERY OpenCode session from the index, silently in a
-        // non-TTY run (the handler below only prints when stderr is a TTY). A
-        // poisoned row must cost that row, not the harness.
         const query = `
       SELECT
         s.id AS id,
@@ -1989,10 +1395,6 @@ async function scanOpenCodeIncremental(onProgress) {
     `.replace(/\n/g, ' ');
         const account = getOpenCodeAccount();
         const rows = db.prepare(query).all();
-        // Two passes. First derive each row's identity + per-session stamp, then
-        // bulk-load the prior stamps in ONE query and keep only the rows that
-        // actually changed. Skipped rows never reach upsertSessionsBatch, so they
-        // never pay its per-entry `parseSession` re-open of this same DB.
         const asInt = (v) => typeof v === 'number' ? v : parseInt(String(v), 10);
         const candidates = rows.flatMap(row => {
             const id = typeof row.id === 'string' ? row.id : '';
@@ -2019,8 +1421,6 @@ async function scanOpenCodeIncremental(onProgress) {
                 || prevStamp.fileSize !== c.scan.fileSize
                 || prevStamp.extractorVersion !== CONTENT_INDEX_VERSION;
         });
-        // Role lives on the message row and the genuine user text lives on its
-        // ordered text parts. Poisoned JSON is ignored per row, never per database.
         const firstUserStmt = db.prepare(`
       SELECT json_extract(p.data, '$.text') AS text
       FROM part p
@@ -2054,18 +1454,11 @@ async function scanOpenCodeIncremental(onProgress) {
             const hasTokenData = asInt(row.has_token_data) === 1;
             const toolCallCount = asInt(row.tool_call_count);
             const timestamp = isNaN(timeCreated) ? new Date().toISOString() : new Date(timeCreated).toISOString();
-            // OpenCode is one shared DB, not one file per session — its row carries a
-            // per-session updated time. Set lastActivity explicitly (falling back to
-            // creation, never the whole-DB mtime the ScanStamp would otherwise supply).
             const lastActivity = Number.isNaN(timeUpdated) ? timestamp : new Date(timeUpdated).toISOString();
             const topic = title || undefined;
-            // Duration is the session-row span; a missing/degenerate pair yields no value
-            // rather than a negative or NaN.
             const durationMs = Number.isFinite(timeCreated) && Number.isFinite(timeUpdated) && timeUpdated > timeCreated
                 ? timeUpdated - timeCreated
                 : undefined;
-            // OpenCode stores the model as JSON (`{"id":"…","providerID":"…"}`); the
-            // index tracks the model id.
             let model;
             if (typeof row.model === 'string' && row.model.trim()) {
                 try {
@@ -2073,13 +1466,9 @@ async function scanOpenCodeIncremental(onProgress) {
                     if (typeof parsed?.id === 'string' && parsed.id.trim())
                         model = parsed.id;
                 }
-                catch { /* non-JSON model string — leave unset */ }
+                catch { }
             }
-            // `cost` is a REAL rollup OpenCode maintains on the session row (0 for a
-            // zero-priced provider, which is a real value, not "unknown").
             const costUsd = typeof row.cost === 'number' ? row.cost : undefined;
-            // Worktree slug is a pure function of cwd (`.agents/worktrees/<slug>/`),
-            // so it derives for OpenCode exactly as it does for every other harness.
             const cwd = directory ? normalizeCwd(directory) : undefined;
             const worktreeSlug = detectWorktree(cwd)?.slug;
             const meta = {
@@ -2110,13 +1499,7 @@ async function scanOpenCodeIncremental(onProgress) {
             entries.push({ meta, content: topic || '', scan });
         }
         upsertSessionsBatch(entries);
-        // Report what this scan indexed. OpenCode is one SQLite DB rather than N
-        // transcript files, so the whole batch lands as a single progress emit —
-        // enough for the daemon's warm tick to count it (RUSH-2691); without it a
-        // tick whose only changed sessions were OpenCode's reported 0 and logged
-        // nothing, the same silent-success class this tick exists to remove.
         onProgress?.({ agent: 'opencode', parsed: entries.length, total: entries.length });
-        // Stamp the OpenCode DB itself so we can short-circuit on the next run.
         recordScans([{ filePath: OPENCODE_DB, scan: currentScan }]);
     }
     catch (err) {
@@ -2128,22 +1511,12 @@ async function scanOpenCodeIncremental(onProgress) {
         try {
             db?.close();
         }
-        catch { /* best-effort close */ }
+        catch { }
     }
 }
-// ---------------------------------------------------------------------------
-// OpenClaw
-// ---------------------------------------------------------------------------
-/** Scan active OpenClaw channels and cron jobs via the openclaw CLI. */
 async function scanOpenClawIncremental(onProgress) {
-    // Check if openclaw is installed — silently skip if not. `which` is POSIX-only
-    // (Windows resolves PATH with `where`), so a bare `which` throws ENOENT on every
-    // Windows run and silently disabled the entire OpenClaw scan there — its sessions
-    // never reached the index (RUSH-2286). hasCommand() probes cross-platform.
     if (!hasCommand('openclaw'))
         return;
-    // TTL cache: skip subprocess calls if we scanned recently. Stored in the
-    // meta table so we skip even when no channels/cron exist to produce rows.
     const db = getDB();
     const row = db.prepare(`SELECT value FROM meta WHERE key = 'openclaw_last_scan_ms'`).get();
     const lastScanMs = row ? parseInt(row.value, 10) : 0;
@@ -2155,9 +1528,6 @@ async function scanOpenClawIncremental(onProgress) {
     const scan = { fileMtimeMs: now, fileSize: 0 };
     const entries = [];
     try {
-        // On Windows `openclaw` resolves to a .cmd/.ps1 shim that execFile can't launch
-        // directly; execFileShellSpec composes a shell-safe invocation there and is a
-        // no-op passthrough on POSIX (RUSH-2286).
         const channelsSpec = execFileShellSpec('openclaw', ['channels', 'status']);
         const { stdout: output } = await execFileAsync(channelsSpec.command, channelsSpec.args, {
             encoding: 'utf-8',
@@ -2187,7 +1557,6 @@ async function scanOpenClawIncremental(onProgress) {
         }
     }
     catch {
-        /* channels command failed */
     }
     try {
         const cronSpec = execFileShellSpec('openclaw', ['cron', 'list']);
@@ -2225,21 +1594,10 @@ async function scanOpenClawIncremental(onProgress) {
         }
     }
     catch {
-        /* cron command failed */
     }
     upsertSessionsBatch(entries);
-    // Deliberately NO onProgress emit, unlike every other scanner (RUSH-2691).
-    // This one cannot report a delta: its gate is a 60s TTL (not a store stamp),
-    // `scan` above stamps a fresh `now` on every entry every run, and `entries` is
-    // the CURRENT INVENTORY — running channels plus cron jobs — rebuilt from
-    // scratch each pass. Emitting entries.length would report "how many openclaw
-    // things exist", re-counted every 60s forever, which is a worse lie than
-    // silence: the warm tick's number means "transcripts parsed this scan". Giving
-    // OpenClaw a real per-entry stamp is tracked separately; until then it
-    // contributes 0 and the docblock on IncrementalScanResult says so.
     db.prepare(`INSERT OR REPLACE INTO meta (key, value) VALUES ('openclaw_last_scan_ms', ?)`).run(String(Date.now()));
 }
-/** Incrementally re-scan changed Rush session files and upsert into the DB. */
 async function scanRushIncremental(onProgress) {
     if (!fs.existsSync(RUSH_SESSIONS_DIR))
         return;
@@ -2288,7 +1646,6 @@ async function scanRushIncremental(onProgress) {
     upsertSessionsBatch(entries);
     recordScans(touched);
 }
-/** Stream-parse a single Rush messages.jsonl file to extract session metadata. */
 async function readRushMeta(filePath, sessionId) {
     const scan = await scanRushSession(filePath);
     const stat = safeStatSync(filePath);
@@ -2308,7 +1665,6 @@ async function readRushMeta(filePath, sessionId) {
     };
     return { meta, content: scan.contentText || '', assistantContent: scan.assistantText || '' };
 }
-/** Stream a Rush messages.jsonl file and extract scan-level metadata. */
 async function scanRushSession(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
@@ -2376,17 +1732,6 @@ async function scanRushSession(filePath) {
         assistantText: assistantTexts.length > 0 ? assistantTexts.join('\n') : undefined,
     };
 }
-// ---------------------------------------------------------------------------
-// Hermes
-//
-// Hermes sessions live at ~/.hermes/sessions/session_<id>.json (one JSON
-// file per session). Shape:
-//   { session_id, model, platform, session_start, last_updated,
-//     system_prompt, message_count, messages: [{role, content}, ...] }
-// request_dump_*.json files in the same dir are per-turn debug dumps — skip.
-// Hermes is a gateway/API agent, so cwd is left unset.
-// ---------------------------------------------------------------------------
-/** Incrementally re-scan changed Hermes session files and upsert into the DB. */
 async function scanHermesIncremental(onProgress) {
     if (!fs.existsSync(HERMES_SESSIONS_DIR))
         return;
@@ -2431,7 +1776,6 @@ async function scanHermesIncremental(onProgress) {
     upsertSessionsBatch(scanEntries);
     recordScans(touched);
 }
-/** Parse a single Hermes session JSON file to extract session metadata. */
 function readHermesMeta(filePath) {
     let session;
     try {
@@ -2489,14 +1833,6 @@ function readHermesMeta(filePath) {
     };
     return { meta, content: userTexts.join('\n'), assistantContent: assistantTexts.join('\n') };
 }
-/**
- * Muse Code stores one session per directory under
- * ~/.local/share/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl (event-sourced
- * JSONL). Walk the tree for session.jsonl files and index each one.
- *
- * Also scan version homes (`versions/muse/<v>/home/.local/share/muse/sessions`)
- * so managed/isolated runs that rewrite HOME still show up in `agents sessions`.
- */
 function scanMuseIncremental(onProgress) {
     const roots = [];
     if (fs.existsSync(MUSE_SESSIONS_DIR))
@@ -2513,7 +1849,6 @@ function scanMuseIncremental(onProgress) {
             }
         }
         catch {
-            /* unreadable */
         }
     }
     if (roots.length === 0)
@@ -2530,7 +1865,6 @@ function scanMuseIncremental(onProgress) {
         for (const ent of entries) {
             const full = path.join(dir, ent.name);
             if (ent.isDirectory()) {
-                // Skip subagent child sessions — nested under subagent/<id>/
                 if (ent.name === 'subagent')
                     continue;
                 walk(full);
@@ -2571,9 +1905,7 @@ function scanMuseIncremental(onProgress) {
     recordScans(touched);
     return Promise.resolve();
 }
-/** Parse a Muse session.jsonl for session metadata + first user prompt text. */
 function readMuseMeta(filePath) {
-    // Path shape: .../sessions/YYYY/MM/DD/<uuid>/session.jsonl
     const sessionId = path.basename(path.dirname(filePath));
     if (!/^[0-9a-f-]{36}$/i.test(sessionId))
         return null;
@@ -2605,7 +1937,6 @@ function readMuseMeta(filePath) {
         }
         if (typeof raw.recorded_at === 'number') {
             const v = raw.recorded_at;
-            // Muse logs use microseconds; values < 1e14 are treated as milliseconds.
             const ms = v > 1e14 ? Math.floor(v / 1000) : v;
             const ts = new Date(ms).toISOString();
             if (!firstTs)
@@ -2662,7 +1993,6 @@ function readMuseMeta(filePath) {
     };
     return { meta, content: userTexts.join('\n'), assistantContent: assistantTexts.join('\n') };
 }
-/** Extract plain text from a Hermes message content field (string or list of parts). */
 function extractHermesMessageText(content) {
     if (typeof content === 'string')
         return content.trim();
@@ -2679,18 +2009,10 @@ function extractHermesMessageText(content) {
         .join('\n')
         .trim();
 }
-/**
- * Incrementally re-scan changed Droid (Factory) session files and upsert into
- * the DB. Droid writes one `<uuid>.jsonl` transcript plus a sibling
- * `<uuid>.settings.json` (model + token usage) under
- * `~/.factory/sessions/<encoded-cwd>/`.
- */
 async function scanDroidIncremental(onProgress) {
     const currentVersion = await getCurrentAgentVersion('droid');
     const prestat = [];
     for (const sessionsDir of getAgentSessionDirs('droid', 'sessions')) {
-        // High limit: the walk stats each file once here; parsing is gated by the
-        // ledger match below, which reuses that stat instead of re-stat'ing.
         for (const f of walkForFilesWithStat(sessionsDir, '.jsonl', 100_000)) {
             prestat.push({ filePath: f.path, fileMtimeMs: f.mtimeMs, fileSize: f.size });
         }
@@ -2723,19 +2045,14 @@ async function scanDroidIncremental(onProgress) {
     upsertSessionsBatch(entries);
     recordScans(touched);
 }
-/** Stream-parse a single Droid JSONL file (+ sibling settings) into session metadata. */
 async function readDroidMeta(filePath, currentVersion) {
     const scan = await scanDroidSession(filePath);
-    // The filename is the canonical session id; fall back to the session_start id.
     const sessionId = path.basename(filePath).replace(/\.jsonl$/, '') || scan.sessionId || '';
     if (!sessionId)
         return null;
-    // Token usage and cost live only in the sibling `<uuid>.settings.json`.
     const settings = readDroidSettings(filePath.replace(/\.jsonl$/, '.settings.json'));
     const model = settings.model || scan.model;
     const tokenCount = settings.tokenCount;
-    // Droid records a full split (input / cache-read / cache-write / output) in its
-    // settings sidecar, so both the actual and no-cache cost are derivable (RUSH-2287).
     const usageForCost = model && settings.usage
         ? {
             model,
@@ -2774,7 +2091,6 @@ async function readDroidMeta(filePath, currentVersion) {
     };
     return { meta, content: scan.contentText || '', assistantContent: scan.assistantText || '' };
 }
-/** Read model + token usage from a Droid `<uuid>.settings.json` sidecar. */
 function readDroidSettings(settingsPath) {
     try {
         const data = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
@@ -2800,7 +2116,6 @@ function readDroidSettings(settingsPath) {
         return {};
     }
 }
-/** Stream a Droid JSONL file and extract scan-level metadata (id, cwd, topic, model, duration). */
 async function scanDroidSession(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
@@ -2831,7 +2146,6 @@ async function scanDroidSession(filePath) {
             if (parsed.type === 'session_start') {
                 sessionId = typeof parsed.id === 'string' ? parsed.id : sessionId;
                 cwd = typeof parsed.cwd === 'string' ? parsed.cwd : cwd;
-                // Droid auto-generates `sessionTitle`; `title` is the raw first prompt.
                 if (typeof parsed.sessionTitle === 'string' && parsed.sessionTitle.trim()) {
                     sessionTitle = parsed.sessionTitle.trim();
                 }
@@ -2842,7 +2156,6 @@ async function scanDroidSession(filePath) {
             }
             if (parsed.type !== 'message')
                 continue;
-            // Track duration across every timestamped message.
             if (typeof parsed.timestamp === 'string') {
                 const ms = new Date(parsed.timestamp).getTime();
                 if (!Number.isNaN(ms)) {
@@ -2884,8 +2197,6 @@ async function scanDroidSession(filePath) {
         sessionId,
         timestamp,
         cwd,
-        // Prefer Droid's auto-title, then the raw first-prompt title, then the
-        // derived first-user-message topic.
         topic: sessionTitle || title || firstUserTopic,
         firstUserMessage,
         model,
@@ -2896,7 +2207,6 @@ async function scanDroidSession(filePath) {
         assistantText: assistantTexts.length > 0 ? assistantTexts.join('\n') : undefined,
     };
 }
-/** Extract plain text from a Droid message content field (Anthropic-shaped blocks). */
 function extractDroidMessageText(content) {
     if (typeof content === 'string')
         return content.trim();
@@ -2904,13 +2214,10 @@ function extractDroidMessageText(content) {
         return '';
     return content
         .map((part) => (typeof part?.text === 'string' && part.type === 'text' ? part.text : ''))
-        // Droid front-loads injected context (date, skills list) as <system-reminder>
-        // text blocks on the first user turn — drop them so topic/content stay clean.
         .filter((text) => text.trim() && !text.trim().startsWith('<system-reminder>'))
         .join('\n')
         .trim();
 }
-/** Zero-value accumulator for a fresh (from-byte-0) Claude parse. */
 export function initClaudeParseState() {
     return {
         subAgents: 0,
@@ -2960,13 +2267,8 @@ const DIRECTORY_TOOLS = new Set(['Edit', 'Write', 'edit_file', 'write_file', 'cr
 function foldDerivedToolState(state, event) {
     if (CHECKLIST_TOOLS.has(event.tool ?? ''))
         state.checklistEvents.push(event);
-    // #12: skill/slash-command usage, held here instead of re-parsed later — the
-    // same reason checklistEvents is folded incrementally rather than recomputed
-    // from a full re-parse (see session/db.ts's writeResourceUsage doc comment).
     if (isSkillInvocation(event))
         state.skillEvents.push(event);
-    // Fan-out tallies (RUSH-3091/3095): counted, not held — we need the number,
-    // and a heavy orchestrator session can spawn hundreds of each.
     if (state.subAgents !== undefined && isSubAgentTool(event.tool ?? '', event.command ?? '')) {
         state.subAgents += 1;
     }
@@ -2990,23 +2292,11 @@ function foldDerivedToolState(state, event) {
     if (state.recentDirectoriesTouched.length > 10)
         state.recentDirectoriesTouched.splice(0, state.recentDirectoriesTouched.length - 10);
 }
-/**
- * Fold one parsed transcript line into the accumulator. This is the exact loop
- * body {@link scanClaudeSession} used to run inline — extracted verbatim,
- * mutating `state.*` in place. `parsed` is the already-`JSON.parse`d line (the
- * malformed-line skip happens in the caller, as before).
- */
 export function applyClaudeLine(state, parsed) {
     collectClaudeToolCalls(state.toolCollector, parsed);
-    // entrypoint ships on the first envelope event (attachment/user/assistant)
-    // and is the clean structural signal for "was this a team spawn?"
     if (!state.entrypoint && typeof parsed.entrypoint === 'string') {
         state.entrypoint = parsed.entrypoint;
     }
-    // Produced-artifact signals, structurally (independent of the PR gate below):
-    //   - a Bash `agents teams create/add` command → the team it spawned
-    //   - a Linear create_issue / `gh issue create` tool_use → its result carries
-    //     the new ticket ref, read from the matching tool_result.
     if (parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
         for (const b of parsed.message.content) {
             if (b?.type !== 'tool_use')
@@ -3020,8 +2310,6 @@ export function applyClaudeLine(state, parsed) {
             if (typeof b?.id === 'string' && isTicketCreateTool(b?.name, b?.input?.command)) {
                 state.pendingTicketTools.add(b.id);
             }
-            // ExitPlanMode plan markdown — last one wins so a re-planned session
-            // reports its most recent plan.
             if (b?.name === 'ExitPlanMode' && typeof b?.input?.plan === 'string') {
                 const p = b.input.plan.trim();
                 if (p)
@@ -3048,8 +2336,6 @@ export function applyClaudeLine(state, parsed) {
                 state.createdTickets.add(t);
         }
     }
-    // PR signal, structurally: a Bash tool_use whose command is `gh pr create`
-    // marks intent; the pull URL is then read from a tool_result's output.
     if (!state.prUrl) {
         if (!state.sawPrCreate && parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
             for (const b of parsed.message.content) {
@@ -3073,7 +2359,6 @@ export function applyClaudeLine(state, parsed) {
             }
         }
     }
-    // Track duration across every timestamped event, not just the first.
     if (typeof parsed.timestamp === 'string') {
         const ms = new Date(parsed.timestamp).getTime();
         if (!Number.isNaN(ms)) {
@@ -3110,9 +2395,6 @@ export function applyClaudeLine(state, parsed) {
             state.userTexts.push(text);
             if (!state.topic)
                 state.topic = extractSessionTopic(text);
-            // #12: the USER typing a slash command — Claude injects a <command-name>
-            // wrapper as the message content (extractClaudeUserText returns it
-            // un-stripped; isLocalCommandMessage only filters bash-echo wrappers).
             const slashCommand = extractSlashCommandName(text);
             if (slashCommand) {
                 state.slashCommandEvents.push({
@@ -3145,8 +2427,6 @@ export function applyClaudeLine(state, parsed) {
     }
     if (typeof usageObj?.output_tokens === 'number')
         state.outputTokens += usageObj.output_tokens;
-    // Burn split (RUSH-2287): accumulate the raw directional counts so `agents
-    // output` can report uncached-input / cache-read / cache-write separately.
     if (usageObj && typeof usageObj === 'object') {
         if (typeof usageObj.input_tokens === 'number')
             state.inputTokens += usageObj.input_tokens;
@@ -3155,8 +2435,6 @@ export function applyClaudeLine(state, parsed) {
         if (typeof usageObj.cache_creation_input_tokens === 'number')
             state.cacheWriteTokens += usageObj.cache_creation_input_tokens;
     }
-    // Per-assistant-message cost: each event carries its own model, so we
-    // multiply that event's raw token directions by that model's price.
     const model = parsed.message?.model;
     if (typeof model === 'string' && model)
         state.model = model;
@@ -3171,26 +2449,15 @@ export function applyClaudeLine(state, parsed) {
         const eventCost = costOfUsage(usageForCost);
         if (eventCost > 0) {
             state.costUsd += eventCost;
-            // No-cache scenario: reprice this same event's cache tokens at the input rate.
             state.costUsdNoCache += costOfUsageNoCache(usageForCost);
             state.sawCost = true;
         }
     }
 }
-/**
- * Build the {@link ClaudeSessionScan} return object from an accumulator. This is
- * the exact return-building {@link scanClaudeSession} used to run inline.
- */
-export function finalizeClaudeScan(state) {
+export function finalizeClaudeScan(state, sessionFile) {
     const durationMs = state.firstTsMs !== undefined && state.lastTsMs !== undefined && state.lastTsMs > state.firstTsMs
         ? state.lastTsMs - state.firstTsMs
         : undefined;
-    // A topic is the first meaningful prompt. Harness-owned names travel in the
-    // separate label field so consumers can replace an early topic once Claude's
-    // generated title (or a later `/rename`) arrives.
-    // Generated titles (Claude `ai-title`, Cursor `chatMeta.title`) go through
-    // one shared cleaner so a skill-preamble echo collapses to `/<skill>`. A
-    // `/rename` (`custom-title`) is the user's own words and is never rewritten.
     const label = state.customTitle || cleanGeneratedSessionLabel(state.aiTitle);
     const worktree = detectWorktree(state.cwd, state.gitBranch);
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
@@ -3228,11 +2495,10 @@ export function finalizeClaudeScan(state) {
         recentDirectoriesTouched: state.recentDirectoriesTouched.length ? state.recentDirectoriesTouched : undefined,
         skillsUsed: state.skillEvents.length ? extractSkills(state.skillEvents) : undefined,
         slashCommandsUsed: state.slashCommandEvents.length ? extractSlashCommands(state.slashCommandEvents) : undefined,
-        subAgentCount: state.subAgents,
+        subAgentCount: resolvedSubAgentCount(sessionFile ? claudeSubagentFiles(sessionFile) : undefined, state.subAgents),
         backgroundShellCount: state.backgroundShells,
     };
 }
-/** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
 export async function scanClaudeSession(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
@@ -3255,15 +2521,9 @@ export async function scanClaudeSession(filePath) {
         rl.close();
         stream.destroy();
     }
-    return finalizeClaudeScan(state);
+    return finalizeClaudeScan(state, filePath);
 }
-/** Cap on the FIFO window of recent assistant ids persisted in the continuation. */
 const SEEN_IDS_RECENT_CAP = 256;
-/**
- * Snapshot a live {@link ClaudeParseState} into its serializable form at
- * `offset` bytes consumed. Round-trips through {@link hydrateClaudeParseState}
- * so incremental replay equals a full parse.
- */
 export function serializeClaudeParserState(state, offset, jsonlDroppingOversizedLine = false) {
     const allIds = [...state.seenAssistantIds];
     const seenIdsRecent = allIds.length > SEEN_IDS_RECENT_CAP
@@ -3308,10 +2568,6 @@ export function serializeClaudeParserState(state, offset, jsonlDroppingOversized
         pendingTicketTools: [...state.pendingTicketTools],
         createdTickets: [...state.createdTickets],
         spawnedTeam: state.spawnedTeam,
-        // ticketId is derived at finalize time; persist it (and content_text) so a
-        // consumer (B-2) can rebuild the row + FTS doc on append without re-reading
-        // the whole file. worktreeSlug is re-derived from cwd/gitBranch, so it need
-        // not be persisted.
         ticketId: ticket?.id,
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
         assistantContentText: state.assistantTexts.length > 0 ? state.assistantTexts.join('\n') : undefined,
@@ -3322,26 +2578,8 @@ export function serializeClaudeParserState(state, offset, jsonlDroppingOversized
         slashCommandEvents: state.slashCommandEvents,
     };
 }
-/**
- * Rebuild a live {@link ClaudeParseState} from a persisted continuation so that
- * applying the appended lines yields the same accumulator a full parse would.
- *
- * `seenAssistantIds` is rehydrated from the recent-id FIFO window, then padded
- * with unique sentinel entries so its `.size` matches the true prior count
- * (`seenIdsSize`) — the fallback id `${ts}:${size}` must line up with the full
- * parse even when the window dropped older ids. Padding sentinels can never
- * collide with a real logical id (real ids are message ids/uuids or
- * `${ts}:${n}`; the sentinel prefix is not JSON-line-derived).
- *
- * `userTexts` is rehydrated as a single joined blob from `contentText`: only
- * `userTexts.join('\n')` (detectTicket + contentText) and `userTexts.length > 0`
- * are ever read downstream, and both are preserved by a one-element array
- * holding the joined content.
- */
 export function hydrateClaudeParseState(prior) {
     const seen = new Set(prior.seenIdsRecent);
-    // Pad to the true prior size so `seenAssistantIds.size` (which feeds the
-    // fallback logical id) is exact even when older ids fell out of the window.
     let pad = 0;
     while (seen.size < prior.seenIdsSize) {
         seen.add(`pad:${pad++}`);
@@ -3391,35 +2629,13 @@ export function hydrateClaudeParseState(prior) {
         slashCommandEvents: prior.slashCommandEvents ?? [],
     };
 }
-/**
- * Resume a Claude parse from `fromOffset` bytes into the file, folding only the
- * newly-appended lines into `prior`. Returns the finalized scan, the next
- * serialized continuation, and the byte offset to resume from next time —
- * `newOffset` stops at the last `'\n'` seen so a half-written trailing record is
- * re-read (not lost) on the next append.
- *
- * NOT wired into the live scan path yet (that is B-2); {@link scanClaudeSession}
- * remains the only caller-facing entry point. This exists so the parity harness
- * can prove full === hydrate(state@k) + apply(k+1..n).
- */
 export async function scanClaudeSessionIncremental(filePath, fromOffset, prior) {
     const state = hydrateClaudeParseState(prior);
-    // Read the appended byte range and apply ONLY newline-terminated lines. The
-    // applied lines and `newOffset` MUST stay consistent: readline (like the full
-    // parse) would emit a trailing UNTERMINATED final line at EOF, but `newOffset`
-    // stops before it — so the next pass, after that record's '\n' is flushed,
-    // would re-read and re-apply the same line and double-count it (user events
-    // have no dedup, unlike assistant `seenAssistantIds`). A record written
-    // non-atomically — bytes first, then '\n' in a second write — is exactly this
-    // case. So we slice at the last '\n' ourselves: everything up to and including
-    // it is a run of complete lines we apply and commit. An ordinary tail after
-    // it is deferred until its '\n' lands; after a tail exceeds 1 MiB, its offset
-    // advances with a persisted discard-until-newline bit.
     const append = await applyJsonlAppend(filePath, fromOffset, prior.jsonlDroppingOversizedLine === true, (parsed) => applyClaudeLine(state, parsed));
     if (append.skippedOversizedLine)
         state.toolCollector.recordIndexLimit();
     const newOffset = fromOffset + append.consumedBytes;
-    const scan = finalizeClaudeScan(state);
+    const scan = finalizeClaudeScan(state, filePath);
     const toolCalls = state.toolCollector.drainChanged();
     return {
         scan,
@@ -3428,39 +2644,10 @@ export async function scanClaudeSessionIncremental(filePath, fromOffset, prior)
         toolCalls,
     };
 }
-/** Serialized zero-value continuation: a fresh accumulator at offset 0, used to drive a FULL parse from the start through the same resumable path. */
 function freshClaudeParserState() {
     return serializeClaudeParserState(initClaudeParseState(), 0);
 }
-/**
- * Decide full-vs-incremental for one Claude file and parse it uniformly, always
- * returning a finalized scan plus the continuation to persist. Both branches run
- * through the SAME reducer (via {@link scanClaudeSessionIncremental}), so the row
- * an append produces is identical to a from-scratch full reparse by construction
- * (the B-1 parity harness proves this at the function level).
- *
- * INCREMENTAL when a prior continuation exists AND the file grew past the
- * persisted offset AND its mtime did not go backwards — an in-place append.
- * FULL (from byte 0, fresh state) otherwise: cold start (no prior), truncation /
- * rewrite (size shrank to at or below the offset), or a clock rewind / restore
- * (mtime older than the last parse). A FULL parse still produces a continuation,
- * so the file's very next append can go incremental.
- *
- * `mode` is returned so the caller (and tests) can confirm which branch ran.
- */
 export async function scanClaudeSessionResumable(filePath, prior, currentFileMtimeMs, currentFileSize, priorFileMtimeMs) {
-    // File size + mtime cannot distinguish an APPEND from an in-place rewrite or a
-    // restore that dropped DIFFERENT, larger content at the same path: both grow
-    // the file and move mtime forward. Resuming from the stored offset across that
-    // boundary would fold the new file's bytes into an accumulator hydrated from
-    // the OLD session, so the persisted row silently diverges from a full reparse.
-    // So the metadata gate below only makes a file ELIGIBLE; before trusting the
-    // offset we re-read the transcript's first user/assistant timestamp and require
-    // it to still match the prior continuation's. An append keeps that identity
-    // byte-for-byte; a rewrite/restore of a different session changes it. A
-    // mismatch — or an identity we cannot derive — falls back to a FULL parse,
-    // which is always correct. (A shrink is already handled: currentFileSize is not
-    // > prior.offset, so it takes the FULL branch.)
     let canIncrement = false;
     if (prior !== null &&
         currentFileSize > prior.offset &&
@@ -3475,14 +2662,6 @@ export async function scanClaudeSessionResumable(filePath, prior, currentFileMti
     const result = await scanClaudeSessionIncremental(filePath, 0, freshClaudeParserState());
     return { ...result, mode: 'full' };
 }
-/**
- * Cheaply derive a Claude transcript's session identity — the first
- * user/assistant event `timestamp` — by streaming only the START of the file
- * (at most `maxBytes`) and stopping at the first such event. Used by
- * {@link scanClaudeSessionResumable} to confirm a grown file is still the SAME
- * session before resuming from a stored parse offset. Returns undefined when no
- * user/assistant event appears within the budget, which forces a FULL parse.
- */
 async function claudeSessionIdentityAt(filePath, maxBytes = 1_048_576) {
     const state = initClaudeParseState();
     const stream = fs.createReadStream(filePath, { start: 0, end: maxBytes - 1, encoding: 'utf-8' });
@@ -3509,12 +2688,6 @@ async function claudeSessionIdentityAt(filePath, maxBytes = 1_048_576) {
     }
     return state.timestamp;
 }
-/**
- * Parse the prior continuation blob for a changed file into a usable
- * {@link ClaudeParserState}, or null when there is none / it is unusable. A blob
- * from a different serialization version is treated as absent so the file falls
- * back to a clean FULL parse rather than resuming against a stale shape.
- */
 function parsePriorClaudeState(row) {
     if (!row?.parserState)
         return null;
@@ -3528,20 +2701,15 @@ function parsePriorClaudeState(row) {
         return null;
     }
 }
-/** Test seam: how many times the incremental (append-resume) branch was taken since the last reset. */
 let claudeIncrementalScanCount = 0;
-/** Test seam: how many times a full (from-offset-0) Claude parse ran since the last reset. */
 let claudeFullScanCount = 0;
-/** Test seam: read the (incremental, full) Claude parse counters. */
 export function __claudeScanBranchCountsForTest() {
     return { incremental: claudeIncrementalScanCount, full: claudeFullScanCount };
 }
-/** Test seam: reset the Claude parse-branch counters to observe a scan from a clean slate. */
 export function __resetClaudeScanBranchCountsForTest() {
     claudeIncrementalScanCount = 0;
     claudeFullScanCount = 0;
 }
-/** Zero-value accumulator for a fresh (from-byte-0) Codex parse. */
 export function initCodexParseState() {
     return {
         sessionId: undefined,
@@ -3572,16 +2740,8 @@ export function initCodexParseState() {
         slashCommandEvents: [],
     };
 }
-/**
- * Fold one parsed Codex line into the accumulator — the exact loop body
- * {@link scanCodexSession} used to run inline, extracted verbatim and mutating
- * `state.*` in place. `parsed` is the already-`JSON.parse`d line (the
- * malformed-line skip happens in the caller, as before).
- */
 function applyCodexLine(state, parsed) {
     collectCodexToolCalls(state.toolCollector, parsed);
-    // PR signal, structurally: a Codex `function_call` whose command is
-    // `gh pr create`, then the pull URL from a `function_call_output`.
     if (parsed.type === 'response_item') {
         const p = parsed.payload || {};
         if (p.type === 'function_call') {
@@ -3591,7 +2751,7 @@ function applyCodexLine(state, parsed) {
                 args = typeof p.arguments === 'string' ? JSON.parse(p.arguments) : (p.arguments || {});
                 cmd = String(args.command || args.cmd || '');
             }
-            catch { /* non-JSON args */ }
+            catch { }
             foldDerivedToolState(state, {
                 type: 'tool_use', agent: 'codex', timestamp: parsed.timestamp || '', tool: p.name, args,
                 path: args.file_path || args.path, command: cmd || undefined,
@@ -3623,7 +2783,6 @@ function applyCodexLine(state, parsed) {
             }
         }
     }
-    // Track duration across every timestamped event.
     if (typeof parsed.timestamp === 'string') {
         const ms = new Date(parsed.timestamp).getTime();
         if (!Number.isNaN(ms)) {
@@ -3635,8 +2794,6 @@ function applyCodexLine(state, parsed) {
     }
     if (parsed.type === 'session_meta') {
         const payload = parsed.payload || {};
-        // Native forks prepend child ownership before inherited parent metadata.
-        // The first valid identity owns this file in both full and resumed scans.
         if (state.sessionId || typeof payload.id !== 'string' || !payload.id.trim())
             return;
         state.sessionId = payload.id;
@@ -3647,10 +2804,6 @@ function applyCodexLine(state, parsed) {
         state.model = payload.model || state.model;
         return;
     }
-    // Codex rollouts put per-turn metadata (including the model) on
-    // `turn_context` events. Use them as a fallback when session_meta itself
-    // does not carry the field, otherwise `agents sessions` shows blank model
-    // info for Codex.
     if (parsed.type === 'turn_context') {
         const payload = parsed.payload || {};
         if (!state.model && typeof payload.model === 'string')
@@ -3673,9 +2826,6 @@ function applyCodexLine(state, parsed) {
             if (!genuine)
                 return;
             state.userTexts.push(genuine);
-            // Codex records developer instructions as response_item messages too.
-            // They remain searchable for compatibility, but only an actual user role
-            // may become the session's first request.
             if (payloadRole === 'user' && !state.firstUserMessage)
                 state.firstUserMessage = genuine;
             if (!state.topic)
@@ -3691,24 +2841,13 @@ function applyCodexLine(state, parsed) {
         const total = getCodexTokenCount(totalUsage);
         if (total !== null)
             state.tokenCount = total;
-        // token_count is cumulative — keep the latest snapshot and price it once
-        // after the stream, so we don't double-count across intermediate events.
         if (totalUsage && typeof totalUsage === 'object')
             state.lastTotalTokenUsage = totalUsage;
-        // Codex also stamps the model on the rate_limits/token_count payload on
-        // some versions; prefer session_meta but fall back to it.
         if (!state.model && typeof parsed.payload.info?.model === 'string')
             state.model = parsed.payload.info.model;
     }
 }
-/**
- * Build the {@link CodexSessionScan} return object from an accumulator — the
- * exact return-building {@link scanCodexSession} used to run inline.
- */
 function finalizeCodexScan(state) {
-    // Codex reports one cumulative snapshot: uncached input, cached (cache-read)
-    // input, and output+reasoning. It has no cache-write bucket. Derive the burn
-    // split and both costs (actual + no-cache) from that final snapshot (RUSH-2287).
     const snap = state.lastTotalTokenUsage;
     const outputTokens = snap
         ? (snap.output_tokens ?? 0) + (snap.reasoning_output_tokens ?? 0)
@@ -3721,7 +2860,6 @@ function finalizeCodexScan(state) {
         inputTokens = typeof snap.input_tokens === 'number' ? snap.input_tokens : undefined;
         cacheReadTokens = typeof snap.cached_input_tokens === 'number' ? snap.cached_input_tokens : undefined;
     }
-    // Price the final cumulative token snapshot once, against the session model.
     if (state.model && snap) {
         const usage = {
             model: state.model,
@@ -3771,7 +2909,6 @@ function finalizeCodexScan(state) {
         recentDirectoriesTouched: state.recentDirectoriesTouched.length ? state.recentDirectoriesTouched : undefined,
     };
 }
-/** Stream a Codex JSONL file and extract scan-level metadata (session ID, cwd, topic, tokens). */
 async function scanCodexSession(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
@@ -3796,11 +2933,6 @@ async function scanCodexSession(filePath) {
     }
     return finalizeCodexScan(state);
 }
-/**
- * Snapshot a live {@link CodexParseState} into its serializable form at `offset`
- * bytes consumed. Round-trips through {@link hydrateCodexParseState} so
- * incremental replay equals a full parse.
- */
 export function serializeCodexParserState(state, offset, jsonlDroppingOversizedLine = false) {
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
@@ -3826,10 +2958,6 @@ export function serializeCodexParserState(state, offset, jsonlDroppingOversizedL
         pendingTicketTools: [...state.pendingTicketTools],
         createdTickets: [...state.createdTickets],
         spawnedTeam: state.spawnedTeam,
-        // ticketId is derived at finalize time; persist it (and content_text) so a
-        // consumer can rebuild the row + FTS doc on append without re-reading the
-        // whole file. worktreeSlug is re-derived from cwd/gitBranch, so it need not
-        // be persisted.
         ticketId: ticket?.id,
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
         assistantContentText: state.assistantTexts.length > 0 ? state.assistantTexts.join('\n') : undefined,
@@ -3838,16 +2966,6 @@ export function serializeCodexParserState(state, offset, jsonlDroppingOversizedL
         toolCalls: state.toolCollector.snapshot(),
     };
 }
-/**
- * Rebuild a live {@link CodexParseState} from a persisted continuation so that
- * applying the appended lines yields the same accumulator a full parse would.
- *
- * `userTexts` is rehydrated as a single joined blob from `contentText`: only
- * `userTexts.join('\n')` (detectTicket + contentText) and `userTexts.length > 0`
- * are ever read downstream, and both are preserved by a one-element array
- * holding the joined content. Topic is first-wins and already persisted, so a
- * collapsed userTexts never changes it.
- */
 function hydrateCodexParseState(prior) {
     return {
         sessionId: prior.sessionId,
@@ -3876,26 +2994,10 @@ function hydrateCodexParseState(prior) {
         checklistEvents: prior.checklistEvents ?? [],
         recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
         toolCollector: new ToolCallCollector(prior.toolCalls),
-        // Not persisted in CodexParserState (always empty for Codex today — see
-        // CodexParseState.skillEvents) — a resume starts fresh rather than
-        // round-tripping an always-empty array through the continuation blob.
         skillEvents: [],
         slashCommandEvents: [],
     };
 }
-/**
- * Resume a Codex parse from `fromOffset` bytes into the file, folding only the
- * newly-appended lines into `prior`. Returns the finalized scan, the next
- * serialized continuation, and the byte offset to resume from next time.
- *
- * Same trailing-line discipline as {@link scanClaudeSessionIncremental}: apply
- * ONLY the run of newline-terminated lines (slice at the last `'\n'`), and set
- * `newOffset = fromOffset + consumedBytes`. An ordinary tail after the last
- * `'\n'` is deferred; an oversized one advances under a persisted discard bit.
- * Codex `messageCount` is additive with
- * NO dedup, so re-reading a still-unterminated complete line would double-count
- * it; deferring prevents that (the bug class prix-cloud caught for Claude).
- */
 export async function scanCodexSessionIncremental(filePath, fromOffset, prior) {
     const state = hydrateCodexParseState(prior);
     const append = await applyJsonlAppend(filePath, fromOffset, prior.jsonlDroppingOversizedLine === true, (parsed) => applyCodexLine(state, parsed));
@@ -3911,20 +3013,9 @@ export async function scanCodexSessionIncremental(filePath, fromOffset, prior) {
         toolCalls,
     };
 }
-/** Serialized zero-value continuation: a fresh accumulator at offset 0, used to drive a FULL parse from the start through the same resumable path. */
 function freshCodexParserState() {
     return serializeCodexParserState(initCodexParseState(), 0);
 }
-/**
- * Cheaply derive a Codex rollout's session identity — the `session_meta` id — by
- * streaming only the START of the file (at most `maxBytes`) and stopping once the
- * id is known. Mirrors {@link claudeSessionIdentityAt}: used by
- * {@link scanCodexSessionResumable} to confirm a grown file is still the SAME
- * session before resuming from a stored parse offset. Codex writes `session_meta`
- * (carrying the durable session UUID) on the first line of every rollout, so the
- * id is reached almost immediately. Returns undefined when no id appears within
- * the budget, which forces a FULL parse.
- */
 async function codexSessionIdentityAt(filePath, maxBytes = 1_048_576) {
     const state = initCodexParseState();
     const stream = fs.createReadStream(filePath, { start: 0, end: maxBytes - 1, encoding: 'utf-8' });
@@ -3951,27 +3042,7 @@ async function codexSessionIdentityAt(filePath, maxBytes = 1_048_576) {
     }
     return state.sessionId;
 }
-/**
- * Decide full-vs-incremental for one Codex rollout and parse it uniformly,
- * always returning a finalized scan plus the continuation to persist. Both
- * branches run through the SAME reducer (via {@link scanCodexSessionIncremental}),
- * so an append produces a row identical to a from-scratch full reparse by
- * construction. INCREMENTAL when a prior continuation exists AND the file grew
- * past the persisted offset AND its mtime did not go backwards; FULL (from byte
- * 0, fresh state) otherwise (cold start, truncation/rewrite, clock rewind).
- */
 export async function scanCodexSessionResumable(filePath, prior, currentFileMtimeMs, currentFileSize, priorFileMtimeMs) {
-    // File size + mtime cannot distinguish an APPEND from an in-place rewrite or a
-    // restore that dropped a DIFFERENT, larger rollout at the same path: both grow
-    // the file and move mtime forward. Resuming from the stored offset across that
-    // boundary would fold the new session's bytes into an accumulator hydrated from
-    // the OLD session, so the persisted row silently diverges from a full reparse.
-    // So the metadata gate below only makes a file ELIGIBLE; before trusting the
-    // offset we re-read the rollout's `session_meta` id and require it to still
-    // match the prior continuation's. An append keeps that id; a rewrite/restore of
-    // a different session changes it. A mismatch — or an id we cannot derive —
-    // falls back to a FULL parse, which is always correct. (A shrink is already
-    // handled: currentFileSize is not > prior.offset, so it takes the FULL branch.)
     let canIncrement = false;
     if (prior !== null &&
         currentFileSize > prior.offset &&
@@ -3986,12 +3057,6 @@ export async function scanCodexSessionResumable(filePath, prior, currentFileMtim
     const result = await scanCodexSessionIncremental(filePath, 0, freshCodexParserState());
     return { ...result, mode: 'full' };
 }
-/**
- * Parse the prior continuation blob for a changed Codex file into a usable
- * {@link CodexParserState}, or null when there is none / it is unusable. A blob
- * from a different serialization version is treated as absent so the file falls
- * back to a clean FULL parse rather than resuming against a stale shape.
- */
 function parsePriorCodexState(row) {
     if (!row?.parserState)
         return null;
@@ -4005,20 +3070,15 @@ function parsePriorCodexState(row) {
         return null;
     }
 }
-/** Test seam: how many times the incremental (append-resume) branch was taken since the last reset. */
 let codexIncrementalScanCount = 0;
-/** Test seam: how many times a full (from-offset-0) Codex parse ran since the last reset. */
 let codexFullScanCount = 0;
-/** Test seam: read the (incremental, full) Codex parse counters. */
 export function __codexScanBranchCountsForTest() {
     return { incremental: codexIncrementalScanCount, full: codexFullScanCount };
 }
-/** Test seam: reset the Codex parse-branch counters to observe a scan from a clean slate. */
 export function __resetCodexScanBranchCountsForTest() {
     codexIncrementalScanCount = 0;
     codexFullScanCount = 0;
 }
-/** Resolve the working directory for an OpenClaw agent from its workspace config. */
 function getOpenClawSessionCwd(agentId) {
     const workspace = agentId ? getOpenClawWorkspaceMap().get(agentId) : undefined;
     if (workspace)
@@ -4026,7 +3086,6 @@ function getOpenClawSessionCwd(agentId) {
     const configDir = AGENTS.openclaw.configDir;
     return safeRealpathSync(configDir) || configDir;
 }
-/** Build a cached map of OpenClaw agent ID to workspace path from openclaw.json. */
 function getOpenClawWorkspaceMap() {
     if (cachedOpenClawWorkspaces)
         return cachedOpenClawWorkspaces;
@@ -4045,19 +3104,13 @@ function getOpenClawWorkspaceMap() {
         }
     }
     catch {
-        // Ignore invalid OpenClaw config and fall back to ~/.openclaw.
     }
     cachedOpenClawWorkspaces = workspaces;
     return workspaces;
 }
-// ---------------------------------------------------------------------------
-// Utilities
-// ---------------------------------------------------------------------------
-/** Compute the SHA-256 hex digest of a string. */
 function sha256(input) {
     return crypto.createHash('sha256').update(input).digest('hex');
 }
-/** Stat a path, returning null on any error. */
 function safeStatSync(p) {
     try {
         return fs.statSync(p);
@@ -4066,7 +3119,6 @@ function safeStatSync(p) {
         return null;
     }
 }
-/** Resolve a path to its real path, returning null on any error. */
 function safeRealpathSync(p) {
     try {
         return fs.realpathSync(p);
@@ -4075,7 +3127,6 @@ function safeRealpathSync(p) {
         return null;
     }
 }
-/** Extract meaningful user text from a Claude JSONL user event, skipping meta and local-command messages. */
 function extractClaudeUserText(parsed) {
     if (parsed.isMeta === true)
         return undefined;
@@ -4094,18 +3145,9 @@ function extractClaudeUserText(parsed) {
         return undefined;
     return text;
 }
-/** Check whether a message is a local-command wrapper rather than real user input. */
 function isLocalCommandMessage(text) {
     return /<local-command-caveat>|<bash-(input|stdout|stderr)>/i.test(text);
 }
-/**
- * Extract the assistant's own answer text from a Claude JSONL assistant event —
- * the reply text blocks, skipping tool_use/tool_result blocks and an
- * interrupted turn, mirroring {@link extractClaudeUserText}'s filters. Unlike
- * the user side (which keeps only the first text block), a single assistant
- * turn can legitimately carry multiple text blocks around tool calls, so every
- * one is joined.
- */
 function extractClaudeAssistantText(parsed) {
     const content = parsed.message?.content;
     if (typeof content === 'string') {
@@ -4121,7 +3163,6 @@ function extractClaudeAssistantText(parsed) {
         .join('\n');
     return text || undefined;
 }
-/** Sum all token usage fields from a Claude assistant message's usage object. */
 function getClaudeUsageTotal(usage) {
     if (!usage || typeof usage !== 'object')
         return null;
@@ -4132,7 +3173,6 @@ function getClaudeUsageTotal(usage) {
         usage.cache_read_input_tokens,
     ]);
 }
-/** Extract text from Codex message content blocks; the caller classifies user scaffolding. */
 function extractCodexMessageText(contentBlocks, role) {
     if (!Array.isArray(contentBlocks))
         return undefined;
@@ -4144,22 +3184,15 @@ function extractCodexMessageText(contentBlocks, role) {
         .find((value) => !!value);
     return text || undefined;
 }
-/** Trim and normalize a version string, returning undefined for empty values. */
 function normalizeVersion(version) {
     const trimmed = version?.trim();
     return trimmed ? trimmed : undefined;
 }
-/** Extract the version number from a managed versions/<agent>/<version>/... path under either repo. */
 export function extractVersionFromManagedPath(agent, sourcePath) {
     if (!sourcePath)
         return undefined;
     const candidates = [sourcePath, safeRealpathSync(sourcePath) || ''];
     const markers = [`/.agents/versions/${agent}/`, `/.agents-system/versions/${agent}/`];
-    // Codex is relocated by CODEX_HOME to `~/.agents/.codex-homes/<version>/`
-    // (shims.ts `codexHomeShimBash`), NOT the `versions/<agent>/<version>/home/…`
-    // layout every other isolated agent uses — so its rollout transcripts live
-    // under `.codex-homes/<version>/sessions/…` and the markers above never match,
-    // leaving `version` NULL and native resume degraded to `/continue` (PHNX-3626).
     if (agent === 'codex')
         markers.push('/.agents/.codex-homes/');
     for (const candidate of candidates) {
@@ -4177,7 +3210,6 @@ export function extractVersionFromManagedPath(agent, sourcePath) {
     }
     return undefined;
 }
-/** Resolve the current version of an agent CLI (symlink version or live CLI output, cached). */
 async function getCurrentAgentVersion(agent) {
     const cached = cachedAgentVersions.get(agent);
     if (cached)
@@ -4191,13 +3223,11 @@ async function getCurrentAgentVersion(agent) {
     cachedAgentVersions.set(agent, promise);
     return promise;
 }
-/** Resolve a session's version: embedded in file > extracted from managed path > current CLI version. */
 function resolveSessionVersion(agent, sourcePath, embeddedVersion, currentVersion) {
     return normalizeVersion(embeddedVersion)
         || extractVersionFromManagedPath(agent, sourcePath)
         || normalizeVersion(currentVersion);
 }
-/** Sum all token usage fields from a Codex total_token_usage object. */
 function getCodexTokenCount(totalTokenUsage) {
     if (!totalTokenUsage || typeof totalTokenUsage !== 'object')
         return null;
@@ -4208,7 +3238,6 @@ function getCodexTokenCount(totalTokenUsage) {
         totalTokenUsage.reasoning_output_tokens,
     ]);
 }
-/** Sum all numeric values in an array, returning null if none are valid numbers. */
 function sumKnownNumbers(values) {
     let total = 0;
     let found = false;
@@ -4220,20 +3249,6 @@ function sumKnownNumbers(values) {
     }
     return found ? total : null;
 }
-// ---------------------------------------------------------------------------
-// Time range parsing
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Cursor
-// ---------------------------------------------------------------------------
-// Cursor writes the conversation to
-// projects/<encoded-cwd>/agent-transcripts/<uuid>/<uuid>.jsonl and metadata to
-// chats/<workspace-hash>/<uuid>/meta.json. Discovery deliberately starts from
-// transcripts, then joins metadata by UUID: chat directories with no transcript
-// are empty or abandoned sessions and must not become broken zero-event rows.
-// Routine archives may contain only the transcript; those remain browsable with
-// file timestamps and without guessed cwd/title metadata.
-/** Incrementally re-scan changed Cursor transcript files and upsert into the DB. */
 async function scanCursorIncremental(onProgress) {
     const currentVersion = await getCurrentAgentVersion('cursor');
     const prestat = [];
@@ -4303,12 +3318,10 @@ function readCursorChatMeta(filePath, sessionId) {
             return JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
         }
         catch {
-            // This workspace hash does not own the session, or its metadata is unreadable.
         }
     }
     return undefined;
 }
-/** Parse one Cursor transcript and enrich it with the matching chat meta.json. */
 export function readCursorMeta(filePath, currentVersion) {
     const sessionId = path.basename(filePath).replace(/\.jsonl$/, '');
     if (!sessionId || path.basename(path.dirname(filePath)) !== sessionId)
@@ -4354,13 +3367,6 @@ export function readCursorMeta(filePath, currentVersion) {
     };
     return { meta, content: userTexts.join('\n'), assistantContent: assistantTexts.join('\n'), events };
 }
-// ---------------------------------------------------------------------------
-// Kimi
-// ---------------------------------------------------------------------------
-// Kimi stores sessions under ~/.kimi-code/sessions/<workdir_hash>/session_<uuid>/.
-// Each session has state.json (metadata) and agents/main/wire.jsonl (conversation).
-// A session_index.jsonl at ~/.kimi-code/ maps session IDs to directories.
-/** Incrementally re-scan changed Kimi session state.json files and upsert into the DB. */
 async function scanKimiIncremental(onProgress) {
     const filePaths = [];
     for (const sessionsDir of getAgentSessionDirs('kimi', 'sessions')) {
@@ -4399,9 +3405,6 @@ async function scanKimiIncremental(onProgress) {
     if (changed.length === 0)
         return;
     onProgress?.({ agent: 'kimi', parsed: 0, total: changed.length });
-    // Bulk-fetch each changed session's prior wire-parse continuation (offset +
-    // counter bases). A session whose wire.jsonl grew resumes from the offset;
-    // everything else (cold start, truncation) full-parses from byte 0.
     const priorStates = getParserStatesForPaths(changed.map(c => c.filePath));
     const scanEntries = [];
     const touched = [];
@@ -4427,7 +3430,6 @@ async function scanKimiIncremental(onProgress) {
     upsertSessionsBatch(scanEntries);
     recordScans(touched);
 }
-/** Parse a single Kimi session state.json file to extract session metadata. */
 export function readKimiMeta(filePath, priorRow) {
     let state;
     try {
@@ -4445,17 +3447,10 @@ export function readKimiMeta(filePath, priorRow) {
     const topic = title || lastPrompt || undefined;
     const createdAt = typeof state.createdAt === 'string' ? state.createdAt : undefined;
     const updatedAt = typeof state.updatedAt === 'string' ? state.updatedAt : undefined;
-    // Coerce to never-null, the same way every other parser does (Rush/Hermes/Droid/…):
-    // a real createdAt/updatedAt still wins; otherwise fall back to the state.json mtime.
-    // Kimi was the lone parser that could yield `undefined`, which binds NULL into
-    // `timestamp TEXT NOT NULL` and aborts the whole batch index. mtime also matches how
-    // the listing already ranks Kimi (last_activity resolves to the file mtime).
     const stat = safeStatSync(filePath);
     const timestamp = updatedAt || createdAt
         || (stat ? stat.mtime.toISOString() : new Date().toISOString());
     const shortId = deriveShortId(sessionId, /^session_/);
-    // Try to infer project from session directory path
-    // ~/.kimi-code/sessions/<workdir_hash>/session_<uuid>/
     const workDirName = path.basename(path.dirname(sessionDir));
     let project;
     if (workDirName.startsWith('wd_')) {
@@ -4464,9 +3459,6 @@ export function readKimiMeta(filePath, priorRow) {
             project = parts.slice(0, -1).join('/');
         }
     }
-    // Parse wire.jsonl incrementally: resume from the persisted offset + counter
-    // bases when the wire grew, else full-parse from byte 0. The continuation is
-    // persisted on this session's state.json ledger row.
     const prior = parsePriorKimiState(priorRow);
     const { messageCount, tokenCount, outputTokens, newState } = parseKimiWireMetricsIncremental(sessionDir, prior);
     const meta = {
@@ -4495,7 +3487,6 @@ function kimiWireUserText(event) {
             : '';
     return cleanFirstUserMessage(raw);
 }
-/** Fold one parsed Kimi wire event into the additive counters, in place. */
 function applyKimiWireEvent(acc, event) {
     if (event.type === 'context.append_message') {
         acc.messageCount++;
@@ -4503,49 +3494,17 @@ function applyKimiWireEvent(acc, event) {
             acc.firstUserMessage = kimiWireUserText(event);
     }
     else if (event.type === 'usage.record' && event.usage) {
-        // Kimi usage structure: inputOther + output + inputCacheRead + inputCacheCreation
         const u = event.usage;
         acc.tokenCount += (u.inputOther || 0) + (u.output || 0) + (u.inputCacheRead || 0) + (u.inputCacheCreation || 0);
         acc.outputTokens += (u.output || 0);
     }
 }
-/**
- * Incrementally parse Kimi's wire.jsonl for message-count and token counters,
- * resuming from a persisted continuation instead of re-reading from byte 0 every
- * scan. Returns the finalized counters and the next {@link KimiParserState} to
- * persist (offset + the three counter bases).
- *
- * Same trailing-line discipline as {@link scanClaudeSessionIncremental}: read
- * only the appended byte range from `prior.offset`, apply ONLY the run of
- * newline-terminated lines (slice at the last `'\n'`), and advance the offset to
- * `prior.offset + consumedBytes`. A complete-but-not-yet-terminated last record
- * is DEFERRED to the next pass; because these counters are additive with no
- * dedup, re-reading such a line would double-count it. FULL parse from byte 0
- * (fresh counters) when there is no prior OR the file shrank below the stored
- * offset (truncation/rewrite).
- */
 export function parseKimiWireMetricsIncremental(sessionDir, prior) {
     const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');
     const stat = safeStatSync(wirePath);
     if (!stat) {
-        // No wire.jsonl (yet): zero counters, offset 0 so a later append is a clean
-        // full parse.
         return { messageCount: 0, tokenCount: 0, outputTokens: 0, newState: { v: 2, offset: 0, messageCount: 0, tokenCount: 0, outputTokens: 0 } };
     }
-    // INCREMENTAL only when a usable prior exists AND the file grew past its
-    // offset; otherwise FULL from byte 0 with fresh counters (cold start OR the
-    // file shrank to/below the offset — a truncation/rewrite).
-    //
-    // No session-identity re-check is needed here (unlike Claude's
-    // claudeSessionIdentityAt / Codex's codexSessionIdentityAt, which guard against
-    // an in-place rewrite dropping a DIFFERENT session at the same path). A Kimi
-    // wire.jsonl is uniquely keyed by its session dir — `.../session_<uuid>/agents/
-    // main/wire.jsonl` (see readKimiMeta: sessionId is `session_<uuid>` and must
-    // start with `session_`) — and Kimi only ever APPENDS to that per-session log.
-    // The path therefore cannot host a different session's transcript, so a
-    // size-grew wire.jsonl is always the same session's append. (A truncation/
-    // rewrite — the only way its bytes could diverge — already shrinks it to/below
-    // the offset and takes the FULL branch above.)
     const canIncrement = prior !== null && stat.size > prior.offset;
     const fromOffset = canIncrement ? prior.offset : 0;
     const acc = canIncrement
@@ -4554,12 +3513,6 @@ export function parseKimiWireMetricsIncremental(sessionDir, prior) {
     let consumedBytes = 0;
     let fd;
     try {
-        // Read ONLY the appended byte range [fromOffset, stat.size) — not the whole
-        // file. readSync from an explicit position keeps this function synchronous
-        // (its callers are sync) while making the disk read + allocation scale with
-        // the appended delta, not total file size, matching scanCodexSessionIncremental
-        // / scanClaudeSessionIncremental. Bytes past the stat'd size are a concurrent
-        // append and are deferred to the next scan.
         const bytesToRead = Math.max(0, stat.size - fromOffset);
         const appended = Buffer.allocUnsafe(bytesToRead);
         if (bytesToRead > 0) {
@@ -4572,7 +3525,6 @@ export function parseKimiWireMetricsIncremental(sessionDir, prior) {
                 read += n;
             }
             const chunk = read === bytesToRead ? appended : appended.subarray(0, read);
-            // Bytes up to AND INCLUDING the last '\n' are the committed, complete-line run.
             const lastNl = chunk.lastIndexOf(0x0a);
             consumedBytes = lastNl === -1 ? 0 : lastNl + 1;
             if (consumedBytes > 0) {
@@ -4583,22 +3535,19 @@ export function parseKimiWireMetricsIncremental(sessionDir, prior) {
                         applyKimiWireEvent(acc, JSON.parse(line));
                     }
                     catch {
-                        // Malformed line, skip
                     }
                 }
             }
         }
     }
     catch {
-        // If wire.jsonl can't be read, keep the accumulated counters (0s on a cold
-        // parse) — graceful degradation, matching the pre-incremental behavior.
     }
     finally {
         if (fd !== undefined) {
             try {
                 fs.closeSync(fd);
             }
-            catch { /* already closed / gone */ }
+            catch { }
         }
     }
     return {
@@ -4608,12 +3557,6 @@ export function parseKimiWireMetricsIncremental(sessionDir, prior) {
         newState: { v: 2, offset: fromOffset + consumedBytes, messageCount: acc.messageCount, tokenCount: acc.tokenCount, outputTokens: acc.outputTokens, firstUserMessage: acc.firstUserMessage },
     };
 }
-/**
- * Parse the prior continuation blob for a changed Kimi session into a usable
- * {@link KimiParserState}, or null when there is none / it is unusable. A blob
- * from a different serialization version is treated as absent so the wire parse
- * falls back to a clean FULL parse rather than resuming against a stale shape.
- */
 function parsePriorKimiState(row) {
     if (!row?.parserState)
         return null;
@@ -4627,14 +3570,6 @@ function parsePriorKimiState(row) {
         return null;
     }
 }
-/**
- * Scan Grok sessions. Grok stores one directory per session under
- * ~/.grok/sessions/<url-encoded-cwd>/<uuid>/, each holding a summary.json with
- * structured metadata (id, cwd, title, timestamps, message count). Same
- * dir-per-session (L3) shape as Kimi, so it walks two levels and gates the
- * summary.json read through the scan ledger. Before this, Grok had a type slot
- * and a placeholder parser but no scanner, so `agents sessions` never indexed it.
- */
 async function scanGrokIncremental(onProgress) {
     const currentVersion = await getCurrentAgentVersion('grok');
     const filePaths = [];
@@ -4696,18 +3631,6 @@ async function scanGrokIncremental(onProgress) {
     upsertSessionsBatch(scanEntries);
     recordScans(touched);
 }
-/**
- * Bounded read of a Grok `chat_history.jsonl` for the genuine full first user
- * turn (PHNX-3621 leftover from #3359). Grok's cheap scan reads only
- * `summary.json` (a LARGE-transcript harness whose full message log is
- * deliberately not parsed on the hot tick), but the first turn is at the START
- * of the log, so a bounded prefix read recovers it without paying the full-file
- * cost. Production logs lead with a `type:system` record, then a huge
- * `<user_info>` user dump (no `synthetic_reason`), then a `synthetic_reason`
- * reminder, then the originating turn at `prompt_index: 0` wrapped in
- * `<user_query>`. Skip that scaffolding and prefer `prompt_index` when present.
- * Returns undefined when no genuine user turn appears within the budget.
- */
 function readGrokFirstUserMessage(sessionDir, maxBytes = 262_144) {
     const historyPath = path.join(sessionDir, 'chat_history.jsonl');
     let fd;
@@ -4728,7 +3651,6 @@ function readGrokFirstUserMessage(sessionDir, maxBytes = 262_144) {
             read += n;
         }
         const chunk = buf.subarray(0, read).toString('utf-8');
-        // Drop a trailing partial line so we never parse half a JSON record.
         const lastNl = chunk.lastIndexOf('\n');
         const complete = lastNl === -1 ? chunk : chunk.slice(0, lastNl);
         let firstGenuine;
@@ -4770,11 +3692,10 @@ function readGrokFirstUserMessage(sessionDir, maxBytes = 262_144) {
             try {
                 fs.closeSync(fd);
             }
-            catch { /* already closed / gone */ }
+            catch { }
         }
     }
 }
-/** Parse a single Grok session summary.json into session metadata. */
 export function readGrokMeta(filePath, currentVersion) {
     let summary;
     try {
@@ -4784,7 +3705,6 @@ export function readGrokMeta(filePath, currentVersion) {
         return null;
     }
     const sessionDir = path.dirname(filePath);
-    // The uuid directory name is the canonical id; summary.info.id mirrors it.
     const sessionId = (typeof summary?.info?.id === 'string' && summary.info.id) || path.basename(sessionDir);
     if (!sessionId)
         return null;
@@ -4792,9 +3712,6 @@ export function readGrokMeta(filePath, currentVersion) {
     const topic = (typeof summary?.generated_title === 'string' && summary.generated_title.trim()) ||
         (typeof summary?.session_summary === 'string' && summary.session_summary.trim()) ||
         undefined;
-    // created_at is the session start; last_active_at/updated_at is the latest
-    // activity. Coerce timestamp to never-null (NOT NULL column) via the file mtime,
-    // matching how the other dir-per-session parsers (Kimi) fall back.
     const createdAt = typeof summary?.created_at === 'string' ? summary.created_at : undefined;
     const lastActivity = (typeof summary?.last_active_at === 'string' && summary.last_active_at) ||
         (typeof summary?.updated_at === 'string' && summary.updated_at) ||
@@ -4806,11 +3723,6 @@ export function readGrokMeta(filePath, currentVersion) {
         : typeof summary?.num_messages === 'number'
             ? summary.num_messages
             : undefined;
-    // Grok records its managed home in summary.grok_home
-    // (…/versions/grok/<version>/home/.grok) — recover the version from it. The
-    // value is written by the Grok CLI in the writing host's native separators, so
-    // a Windows-authored summary is backslash-separated; normalize to `/` before
-    // matching or the version never resolves on Windows (RUSH-2286).
     let embeddedVersion;
     if (typeof summary?.grok_home === 'string') {
         embeddedVersion = summary.grok_home.replace(/\\/g, '/').match(/versions\/grok\/([^/]+)\//)?.[1];
@@ -4831,9 +3743,4 @@ export function readGrokMeta(filePath, currentVersion) {
     };
     return { meta, content: topic || '' };
 }
-// parseTimeFilter moved to ./relative-time.js — a leaf module — so a caller that
-// only needs the duration parser does not pull this file's `../sqlite.js` import
-// (and Node's SQLite ExperimentalWarning on stderr) into its module graph.
-// Re-exported so every existing importer keeps working unchanged. Imported too,
-// because a bare re-export does not bind the name for this file's own callers.
 export { parseTimeFilter } from './relative-time.js';