@phnx-labs/agents-cli 1.21.2 → 1.22.0

package/dist/lib/session/discover.js

@@ -23,7 +23,8 @@ import { walkForFilesWithStat } from '../fs-walk.js';
 import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
-import { extractSessionTopic } from './prompt.js';
+import { extractSessionTopic, extractSlashCommandName, extractSlashCommandFromToolInput } from './prompt.js';
+import { isSkillInvocation, extractSkills, extractSlashCommands } from './highlights.js';
 import { parseAntigravity, parseCursor } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { costOfUsage } from '../pricing/index.js';
@@ -33,6 +34,8 @@ import { mapBounded } from '../concurrency.js';
 import { getDB, getScanStampByPath, getScanStampsForPaths, getParserStatesForPaths, getDirLedgerForPaths, recordDirScans, recordScans, syncLabels, seedLabelsFromNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, cacheLinearProject, } from './db.js';
 import { buildRunNameMap } from './run-names.js';
 import { resolveLinearApiKey } from '../auto-dispatch-linear.js';
+import { ToolCallCollector, collectClaudeToolCalls, collectCodexToolCalls, } from './tool-calls.js';
+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,
@@ -46,6 +49,73 @@ const HERMES_SESSIONS_DIR = path.join(HOME, '.hermes', '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. */
+export 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;
+    let bytesBeforeChunk = 0;
+    let consumedBytes = 0;
+    let skippedOversizedLine = false;
+    const stream = fs.createReadStream(filePath, { start: fromOffset });
+    try {
+        for await (const rawChunk of stream) {
+            const chunk = typeof rawChunk === 'string' ? Buffer.from(rawChunk, 'utf-8') : rawChunk;
+            let cursor = 0;
+            for (;;) {
+                const newline = chunk.indexOf(0x0a, cursor);
+                if (newline === -1) {
+                    if (!droppingOversizedLine) {
+                        const tail = chunk.subarray(cursor);
+                        if (pending.length + tail.length > SESSION_JSONL_LINE_MAX_BYTES) {
+                            pending = Buffer.alloc(0);
+                            droppingOversizedLine = true;
+                            skippedOversizedLine = true;
+                        }
+                        else if (tail.length > 0) {
+                            pending = pending.length > 0 ? Buffer.concat([pending, tail]) : Buffer.from(tail);
+                        }
+                    }
+                    if (droppingOversizedLine)
+                        consumedBytes = bytesBeforeChunk + chunk.length;
+                    break;
+                }
+                if (!droppingOversizedLine) {
+                    const segment = chunk.subarray(cursor, newline);
+                    if (pending.length + segment.length <= SESSION_JSONL_LINE_MAX_BYTES) {
+                        const line = (pending.length > 0 ? Buffer.concat([pending, segment]) : segment).toString('utf-8');
+                        if (line.trim()) {
+                            try {
+                                apply(JSON.parse(line));
+                            }
+                            catch {
+                                // One malformed line never aborts the session scan.
+                            }
+                        }
+                    }
+                    else {
+                        skippedOversizedLine = true;
+                    }
+                }
+                pending = Buffer.alloc(0);
+                droppingOversizedLine = false;
+                consumedBytes = bytesBeforeChunk + newline + 1;
+                cursor = newline + 1;
+            }
+            bytesBeforeChunk += chunk.length;
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+    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
@@ -101,8 +171,17 @@ export async function discoverSessions(options) {
             releaseScan(process.pid);
         }
     }
-    const sessions = querySessions(buildQueryOptions(options, agents, { includeLimit: true }));
-    await resolveLinearProjects(sessions);
+    return queryIndexedSessions(options, {
+        skipExistenceCheck: options?.skipExistenceCheck ?? false,
+    });
+}
+/** 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;
+    const sessions = querySessions(buildQueryOptions({ ...options, skipExistenceCheck: indexedOptions.skipExistenceCheck ?? true }, agents, { includeLimit: true }));
+    if (indexedOptions.resolveLinear !== false)
+        await resolveLinearProjects(sessions);
     for (const s of sessions)
         s.machine = machineForSessionFile(s.filePath, s.agent);
     return scopeToManaged(sessions, agents, options);
@@ -155,7 +234,7 @@ async function resolveLinearProjects(sessions) {
  * An agent with no managed versions is left alone entirely — someone who has never
  * run `agents add` sees exactly what they saw before.
  */
-function scopeToManaged(sessions, agents, options) {
+export function scopeToManaged(sessions, agents, options) {
     if (options?.includeUnmanaged)
         return sessions;
     if (!anyManagedVersions())
@@ -305,11 +384,14 @@ function buildQueryOptions(options, agents, opts) {
         project: projectQuery,
         sinceMs,
         untilMs: Number.isFinite(untilMs) ? untilMs : undefined,
-        limit: opts.includeLimit ? (options?.limit ?? 50) : undefined,
+        limit: opts.includeLimit && !options?.unbounded ? (options?.limit ?? 50) : undefined,
         excludeTeamOrigin: options?.excludeTeamOrigin,
         onlyTeamOrigin: options?.onlyTeamOrigin,
         origin: options?.origin,
         sortBy: options?.sortBy,
+        skipExistenceCheck: options?.skipExistenceCheck,
+        skill: options?.skill,
+        plugin: options?.plugin,
     };
 }
 /**
@@ -579,6 +661,7 @@ export function collectChangedFilesInLeafDirs(leafDirs, ext) {
                     continue;
                 toCompare.push({ filePath, fileMtimeMs: stat.mtimeMs, fileSize: stat.size });
             }
+            purgeMissingToolCallsInDirectory(getDB(), dirPath, files);
             if (!disabled)
                 dirScansToRecord.push({ dirPath, dirMtimeMs, entryCount });
         }
@@ -786,7 +869,13 @@ async function scanRoutineArchivesIncremental(agent, onProgress) {
         try {
             const result = await readRoutineArchiveMeta(agent, filePath);
             if (result)
-                entries.push({ meta: result.meta, content: result.content, scan });
+                entries.push({
+                    meta: result.meta,
+                    content: result.content,
+                    scan,
+                    toolCalls: result.toolCalls,
+                    toolIndexMode: result.toolIndexMode,
+                });
             else
                 touched.push({ filePath, scan });
         }
@@ -961,6 +1050,8 @@ async function scanClaudeIncremental(onProgress) {
                         scan,
                         parserState: result.parserState,
                         contentText: result.contentText,
+                        toolCalls: result.toolCalls,
+                        toolIndexMode: result.toolIndexMode,
                     });
                 }
                 else {
@@ -990,7 +1081,7 @@ async function scanClaudeIncremental(onProgress) {
  */
 async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account, label) {
     const prior = parsePriorClaudeState(priorRow);
-    const { scan, newState, mode } = await scanClaudeSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
+    const { scan, newState, toolCalls, mode } = await scanClaudeSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
     if (mode === 'incremental')
         claudeIncrementalScanCount++;
     else
@@ -1030,6 +1121,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             plan: scan.plan,
             todos: scan.todos,
             recentDirectoriesTouched: scan.recentDirectoriesTouched,
+            skillsUsed: scan.skillsUsed,
+            slashCommandsUsed: scan.slashCommandsUsed,
         };
     }
     else {
@@ -1061,6 +1154,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             plan: scan.plan,
             todos: scan.todos,
             recentDirectoriesTouched: scan.recentDirectoriesTouched,
+            skillsUsed: scan.skillsUsed,
+            slashCommandsUsed: scan.slashCommandsUsed,
         };
     }
     return {
@@ -1071,6 +1166,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
         // 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',
     };
 }
 // ---------------------------------------------------------------------------
@@ -1208,6 +1305,8 @@ async function scanCodexIncremental(onProgress) {
                     scan,
                     parserState: result.parserState,
                     contentText: result.contentText,
+                    toolCalls: result.toolCalls,
+                    toolIndexMode: result.toolIndexMode,
                 });
             }
             else {
@@ -1310,6 +1409,8 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
     let scan;
     let newState;
     let newOffset = 0;
+    let toolCalls;
+    let toolIndexMode = 'replace';
     if (scanStamp) {
         const prior = parsePriorCodexState(priorRow);
         const result = await scanCodexSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
@@ -1320,6 +1421,8 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         scan = result.scan;
         newState = result.newState;
         newOffset = result.newOffset;
+        toolCalls = result.toolCalls;
+        toolIndexMode = result.mode === 'full' ? 'replace' : 'append';
     }
     else {
         scan = await scanCodexSession(filePath);
@@ -1366,6 +1469,8 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         // doc for the resume's hydrate. Absent when no stamp was supplied.
         parserState: newState ? JSON.stringify(newState) : undefined,
         contentText: newState?.contentText,
+        toolCalls,
+        toolIndexMode,
     };
 }
 /**
@@ -2446,6 +2551,9 @@ export function initClaudeParseState() {
         plan: undefined,
         checklistEvents: [],
         recentDirectoriesTouched: [],
+        toolCollector: new ToolCallCollector(),
+        skillEvents: [],
+        slashCommandEvents: [],
     };
 }
 const CHECKLIST_TOOLS = new Set(['TodoWrite', 'todo_write', 'update_plan', 'TaskCreate', 'TaskUpdate']);
@@ -2453,6 +2561,16 @@ 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);
+    if (event.tool === 'SlashCommand') {
+        const slashCommand = extractSlashCommandFromToolInput(event.args);
+        if (slashCommand)
+            state.slashCommandEvents.push({ ...event, slashCommand });
+    }
     if (!DIRECTORY_TOOLS.has(event.tool ?? ''))
         return;
     const next = extractRecentDirectoriesTouched([event], state.cwd);
@@ -2472,6 +2590,7 @@ function foldDerivedToolState(state, event) {
  * 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') {
@@ -2582,6 +2701,15 @@ 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({
+                    type: 'message', agent: 'claude', timestamp: parsed.timestamp || '', role: 'user', content: text, slashCommand,
+                });
+            }
         }
         return;
     }
@@ -2662,6 +2790,8 @@ export function finalizeClaudeScan(state) {
         plan: state.plan,
         todos: extractTodoProgressFromEvents(state.checklistEvents),
         recentDirectoriesTouched: state.recentDirectoriesTouched.length ? state.recentDirectoriesTouched : undefined,
+        skillsUsed: state.skillEvents.length ? extractSkills(state.skillEvents) : undefined,
+        slashCommandsUsed: state.slashCommandEvents.length ? extractSlashCommands(state.slashCommandEvents) : undefined,
     };
 }
 /** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
@@ -2696,15 +2826,16 @@ const SEEN_IDS_RECENT_CAP = 256;
  * `offset` bytes consumed. Round-trips through {@link hydrateClaudeParseState}
  * so incremental replay equals a full parse.
  */
-export function serializeClaudeParserState(state, offset) {
+export function serializeClaudeParserState(state, offset, jsonlDroppingOversizedLine = false) {
     const allIds = [...state.seenAssistantIds];
     const seenIdsRecent = allIds.length > SEEN_IDS_RECENT_CAP
         ? allIds.slice(allIds.length - SEEN_IDS_RECENT_CAP)
         : allIds;
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
-        v: 1,
+        v: 2,
         offset,
+        jsonlDroppingOversizedLine: jsonlDroppingOversizedLine || undefined,
         timestamp: state.timestamp,
         cwd: state.cwd,
         gitBranch: state.gitBranch,
@@ -2740,6 +2871,9 @@ export function serializeClaudeParserState(state, offset) {
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
         checklistEvents: state.checklistEvents,
         recentDirectoriesTouched: state.recentDirectoriesTouched,
+        toolCalls: state.toolCollector.snapshot(),
+        skillEvents: state.skillEvents,
+        slashCommandEvents: state.slashCommandEvents,
     };
 }
 /**
@@ -2796,6 +2930,9 @@ export function hydrateClaudeParseState(prior) {
         plan: prior.plan,
         checklistEvents: prior.checklistEvents ?? [],
         recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
+        toolCollector: new ToolCallCollector(prior.toolCalls),
+        skillEvents: prior.skillEvents ?? [],
+        slashCommandEvents: prior.slashCommandEvents ?? [],
     };
 }
 /**
@@ -2819,45 +2956,20 @@ export async function scanClaudeSessionIncremental(filePath, fromOffset, prior)
     // 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; any tail after it
-    // (syntactically broken OR complete-but-not-yet-terminated) is a still-being-
-    // written record we DEFER to the next pass, once its '\n' lands.
-    const chunks = [];
-    const stream = fs.createReadStream(filePath, { start: fromOffset });
-    try {
-        for await (const chunk of stream) {
-            chunks.push(typeof chunk === 'string' ? Buffer.from(chunk, 'utf-8') : chunk);
-        }
-    }
-    finally {
-        stream.destroy();
-    }
-    const appended = Buffer.concat(chunks);
-    // Bytes up to AND INCLUDING the last '\n' are the committed, complete-line run.
-    const lastNl = appended.lastIndexOf(0x0a);
-    const consumedBytes = lastNl === -1 ? 0 : lastNl + 1;
-    if (consumedBytes > 0) {
-        // split('\n') on the committed run: the element after the final '\n' is ''
-        // (skipped by the trim guard). A stray '\r' from CRLF is tolerated by the
-        // JSON.parse below exactly as the full parse tolerates it.
-        for (const line of appended.subarray(0, consumedBytes).toString('utf-8').split('\n')) {
-            if (!line.trim())
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            applyClaudeLine(state, parsed);
-        }
-    }
-    const newOffset = fromOffset + consumedBytes;
+    // 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 toolCalls = state.toolCollector.drainChanged();
     return {
-        scan: finalizeClaudeScan(state),
-        newState: serializeClaudeParserState(state, newOffset),
+        scan,
+        newState: serializeClaudeParserState(state, newOffset, append.droppingOversizedLine),
         newOffset,
+        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. */
@@ -2952,7 +3064,7 @@ function parsePriorClaudeState(row) {
         return null;
     try {
         const parsed = JSON.parse(row.parserState);
-        if (parsed?.v !== 1 || typeof parsed.offset !== 'number')
+        if (parsed?.v !== 2 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
             return null;
         return parsed;
     }
@@ -2997,6 +3109,9 @@ export function initCodexParseState() {
         spawnedTeam: undefined,
         checklistEvents: [],
         recentDirectoriesTouched: [],
+        toolCollector: new ToolCallCollector(),
+        skillEvents: [],
+        slashCommandEvents: [],
     };
 }
 /**
@@ -3006,6 +3121,7 @@ export function initCodexParseState() {
  * malformed-line skip happens in the caller, as before).
  */
 export 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') {
@@ -3178,11 +3294,12 @@ async function scanCodexSession(filePath) {
  * bytes consumed. Round-trips through {@link hydrateCodexParseState} so
  * incremental replay equals a full parse.
  */
-export function serializeCodexParserState(state, offset) {
+export function serializeCodexParserState(state, offset, jsonlDroppingOversizedLine = false) {
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
-        v: 1,
+        v: 2,
         offset,
+        jsonlDroppingOversizedLine: jsonlDroppingOversizedLine || undefined,
         sessionId: state.sessionId,
         timestamp: state.timestamp,
         cwd: state.cwd,
@@ -3209,6 +3326,7 @@ export function serializeCodexParserState(state, offset) {
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
         checklistEvents: state.checklistEvents,
         recentDirectoriesTouched: state.recentDirectoriesTouched,
+        toolCalls: state.toolCollector.snapshot(),
     };
 }
 /**
@@ -3244,6 +3362,12 @@ export function hydrateCodexParseState(prior) {
         spawnedTeam: prior.spawnedTeam,
         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: [],
     };
 }
 /**
@@ -3253,47 +3377,25 @@ export function hydrateCodexParseState(prior) {
  *
  * 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`. Any tail after the last `'\n'` —
- * syntactically broken OR a complete-but-not-yet-terminated record — is DEFERRED
- * to the next pass once its `'\n'` lands. Codex `messageCount` is additive with
+ * `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 chunks = [];
-    const stream = fs.createReadStream(filePath, { start: fromOffset });
-    try {
-        for await (const chunk of stream) {
-            chunks.push(typeof chunk === 'string' ? Buffer.from(chunk, 'utf-8') : chunk);
-        }
-    }
-    finally {
-        stream.destroy();
-    }
-    const appended = Buffer.concat(chunks);
-    // Bytes up to AND INCLUDING the last '\n' are the committed, complete-line run.
-    const lastNl = appended.lastIndexOf(0x0a);
-    const consumedBytes = lastNl === -1 ? 0 : lastNl + 1;
-    if (consumedBytes > 0) {
-        for (const line of appended.subarray(0, consumedBytes).toString('utf-8').split('\n')) {
-            if (!line.trim())
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            applyCodexLine(state, parsed);
-        }
-    }
-    const newOffset = fromOffset + consumedBytes;
+    const append = await applyJsonlAppend(filePath, fromOffset, prior.jsonlDroppingOversizedLine === true, (parsed) => applyCodexLine(state, parsed));
+    if (append.skippedOversizedLine)
+        state.toolCollector.recordIndexLimit();
+    const newOffset = fromOffset + append.consumedBytes;
+    const scan = finalizeCodexScan(state);
+    const toolCalls = state.toolCollector.drainChanged();
     return {
-        scan: finalizeCodexScan(state),
-        newState: serializeCodexParserState(state, newOffset),
+        scan,
+        newState: serializeCodexParserState(state, newOffset, append.droppingOversizedLine),
         newOffset,
+        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. */
@@ -3382,7 +3484,7 @@ function parsePriorCodexState(row) {
         return null;
     try {
         const parsed = JSON.parse(row.parserState);
-        if (parsed?.v !== 1 || typeof parsed.offset !== 'number')
+        if (parsed?.v !== 2 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
             return null;
         return parsed;
     }

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

@@ -17,12 +17,32 @@ export interface SkillUse {
     count: number;
 }
 /**
- * Skills invoked during the session, from `Skill` tool calls. Claude and Kimi
- * both name the tool `Skill` and carry the skill id in `args.skill` (plugin
- * skills surface here too — a plugin-provided skill is invoked through the
- * same tool). Sorted by count desc, then name.
+ * True for a tool_use event that is that harness's skill-invocation call (see
+ * {@link SKILL_TOOL_NAME_BY_AGENT}). Exported so an INCREMENTAL parser
+ * (discover.ts's ClaudeParseState/foldDerivedToolState) can select matching
+ * events into a small held array as it streams, then run {@link extractSkills}
+ * over just that subset at finalize — without re-parsing the whole transcript.
+ */
+export declare function isSkillInvocation(e: SessionEvent): boolean;
+/**
+ * Skills invoked during the session, from that harness's skill-invocation
+ * tool calls (see {@link SKILL_TOOL_NAME_BY_AGENT}). Carries the skill id in
+ * `args.skill` (or `args.name`). Sorted by count desc, then name.
  */
 export declare function extractSkills(events: SessionEvent[]): SkillUse[];
+export interface SlashCommandUse {
+    /** WITH the leading slash, e.g. `/recap`, `/code:commit` — matches SessionEvent.slashCommand's shape. */
+    name: string;
+    count: number;
+}
+/**
+ * Slash commands invoked during the session — either the user typing one
+ * (Claude's `<command-name>` wrapper) or the model invoking one via the
+ * `SlashCommand` tool (`SessionEvent.slashCommand`, populated by
+ * `parseClaudeContent` for both sources — see session/prompt.ts). Sorted by
+ * count desc, then name.
+ */
+export declare function extractSlashCommands(events: SessionEvent[]): SlashCommandUse[];
 export interface HookUse {
     /** Hook name as configured, e.g. `SessionStart:startup`. */
     name: string;

package/dist/lib/session/highlights.js

@@ -15,17 +15,44 @@ import os from 'node:os';
 import path from 'node:path';
 import { isNoisePath } from './digest.js';
 /**
- * Skills invoked during the session, from `Skill` tool calls. Claude and Kimi
- * both name the tool `Skill` and carry the skill id in `args.skill` (plugin
- * skills surface here too — a plugin-provided skill is invoked through the
- * same tool). Sorted by count desc, then name.
+ * The tool name a harness uses to invoke a skill, keyed by `SessionAgentId` —
+ * a registry, not a single hardcoded string, so a harness whose transcript
+ * names the tool differently is one table row away from support instead of a
+ * near-identical `if` arm (see CLAUDE.md's registry-over-if-chain convention).
+ *
+ * Verified entries only: Claude and Kimi both empirically name the tool
+ * `Skill` (a plugin-provided skill rides the same tool). No other harness has
+ * a confirmed skill-invocation tool name in this codebase's fixtures — an
+ * absent entry means "we don't know yet", not "this harness has no skills";
+ * extractSkills yields `[]` for it rather than guessing a name and silently
+ * mismatching (or worse, matching a coincidental tool with the same name).
+ */
+const SKILL_TOOL_NAME_BY_AGENT = {
+    claude: 'Skill',
+    kimi: 'Skill',
+};
+/**
+ * True for a tool_use event that is that harness's skill-invocation call (see
+ * {@link SKILL_TOOL_NAME_BY_AGENT}). Exported so an INCREMENTAL parser
+ * (discover.ts's ClaudeParseState/foldDerivedToolState) can select matching
+ * events into a small held array as it streams, then run {@link extractSkills}
+ * over just that subset at finalize — without re-parsing the whole transcript.
+ */
+export function isSkillInvocation(e) {
+    if (e.type !== 'tool_use' || e._local)
+        return false;
+    const skillTool = SKILL_TOOL_NAME_BY_AGENT[e.agent];
+    return !!skillTool && e.tool === skillTool;
+}
+/**
+ * Skills invoked during the session, from that harness's skill-invocation
+ * tool calls (see {@link SKILL_TOOL_NAME_BY_AGENT}). Carries the skill id in
+ * `args.skill` (or `args.name`). Sorted by count desc, then name.
  */
 export function extractSkills(events) {
     const counts = new Map();
     for (const e of events) {
-        if (e.type !== 'tool_use' || e._local)
-            continue;
-        if (e.tool !== 'Skill')
+        if (!isSkillInvocation(e))
             continue;
         const name = e.args?.skill ?? e.args?.name;
         if (typeof name !== 'string' || !name.trim())
@@ -37,6 +64,24 @@ export function extractSkills(events) {
         .map(([name, count]) => ({ name, count }))
         .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
 }
+/**
+ * Slash commands invoked during the session — either the user typing one
+ * (Claude's `<command-name>` wrapper) or the model invoking one via the
+ * `SlashCommand` tool (`SessionEvent.slashCommand`, populated by
+ * `parseClaudeContent` for both sources — see session/prompt.ts). Sorted by
+ * count desc, then name.
+ */
+export function extractSlashCommands(events) {
+    const counts = new Map();
+    for (const e of events) {
+        if (!e.slashCommand)
+            continue;
+        counts.set(e.slashCommand, (counts.get(e.slashCommand) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([name, count]) => ({ name, count }))
+        .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
 /**
  * Hooks that fired during the session, folded from `hook` events (parsed from
  * Claude's `hook_success`/`hook_error`/… attachment records; other harnesses

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

@@ -12,7 +12,14 @@ import type { SessionAgentId, SessionEvent } from './types.js';
  * Node's ~512MB string ceiling with a healthy margin.
  */
 export declare const SESSION_FILE_MAX_BYTES = 200000000;
-export declare function sanitizeForTerminal(s: string): string;
+/**
+ * Strip terminal control sequences that a malicious session file could use to
+ * hijack the user's terminal (clipboard via OSC 52, scrollback wipe, alt-screen
+ * takeover, cursor moves, etc.). Allowed through: tab (0x09), newline (0x0a),
+ * carriage return (0x0d). Everything else in the C0/C1 range and every CSI/OSC
+ * escape is dropped.
+ */
+export { sanitizeForTerminal } from '../redact.js';
 /** In-place sanitize every user-visible string field on a list of events. */
 export declare function sanitizeEvents(events: SessionEvent[]): void;
 /**