@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/backends/claude/tools.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Claude tool presentations: which
+ * card shape each Claude Code tool call and result renders as, in the
+ * backend-neutral `ToolPresentation` vocabulary the shared projector and the
+ * tool card already understand. The UI never picks a card by tool name; this
+ * table does, from the tool input and the structured `tool_use_result`.
+ *
+ * Every reader narrows `unknown`: inputs come from the model and structured
+ * results are undeclared in the SDK types. A shape this
+ * module does not recognise degrades to the plain text card.
+ */
+import { displayPath } from '../shared/display-path.js';
+import type { ToolCallPresentation, ToolResultPresentation } from '../../agent/presentation.js';
+/** How a tool call is projected besides (or instead of) a card. */
+export type ClaudeToolRole = 
+/** An ordinary tool card. */
+'card'
+/** `Agent`/`Task`: a subagent delegation (subagent row, never a card). */
+ | 'subagent'
+/** `AskUserQuestion`: the questionnaire surface. */
+ | 'question'
+/** `TodoWrite` and the task family that replaced it (CLI 2.1.284:
+ *  `TaskCreate`/`TaskUpdate`/`TaskList`/`TaskGet`): the todo panel, never
+ *  a card — the translator emits `todo.write` snapshots for them. Not the
+ *  `Task` subagent delegation nor `TaskStop` (a background task). */
+ | 'todo'
+/** `EnterPlanMode` / `ExitPlanMode`: the mode and the plan-review panel,
+ *  never a card (the translator emits no call for them). */
+ | 'plan';
+/** The role of a tool call (cards are the default). */
+export declare function claudeToolRole(name: string): ClaudeToolRole;
+export { displayPath };
+/** How a call renders while it runs. */
+export declare function presentClaudeToolCall(name: string, rawInput: unknown, cwd: string): ToolCallPresentation | undefined;
+/** The settled facts of one tool result. */
+export interface ClaudeToolOutcome {
+    readonly isError: boolean;
+    /** The result's text blocks joined. */
+    readonly text: string;
+    /** `tool_use_result` (undeclared, per-tool). */
+    readonly structured: unknown;
+}
+/** How a settled result renders (undefined = the plain text card). */
+export declare function presentClaudeToolResult(name: string, rawInput: unknown, outcome: ClaudeToolOutcome, cwd: string): ToolResultPresentation | undefined;
+//# sourceMappingURL=tools.d.ts.map

package/lib/types/backends/claude/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD,OAAO,KAAK,EAAE,oBAAoB,EAAwB,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AAGrH,mEAAmE;AACnE,MAAM,MAAM,cAAc;AACxB,6BAA6B;AAC3B,MAAM;AACR,0EAA0E;GACxE,UAAU;AACZ,oDAAoD;GAClD,UAAU;AACZ;;;qEAGqE;GACnE,MAAM;AACR;4DAC4D;GAC1D,MAAM,CAAA;AAkBV,uDAAuD;AACvD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAqB3D;AAED,OAAO,EAAE,WAAW,EAAE,CAAA;AA0CtB,wCAAwC;AACxC,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAwDpH;AAED,4CAA4C;AAC5C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC7B;AAeD,sEAAsE;AACtE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS,CAoDpJ"}

package/lib/types/backends/claude/tools.js

@@ -0,0 +1,231 @@
+/**
+ * Claude tool presentations: which
+ * card shape each Claude Code tool call and result renders as, in the
+ * backend-neutral `ToolPresentation` vocabulary the shared projector and the
+ * tool card already understand. The UI never picks a card by tool name; this
+ * table does, from the tool input and the structured `tool_use_result`.
+ *
+ * Every reader narrows `unknown`: inputs come from the model and structured
+ * results are undeclared in the SDK types. A shape this
+ * module does not recognise degrades to the plain text card.
+ */
+import { displayPath } from '../shared/display-path.js';
+import { num, rec, str } from './narrow.js';
+const META = {
+    Read: { displayKey: 'tool-name-read', category: 'other' },
+    Write: { displayKey: 'tool-name-write', category: 'mutate' },
+    Edit: { displayKey: 'tool-name-edit', category: 'mutate' },
+    MultiEdit: { displayKey: 'tool-name-multiedit', category: 'mutate' },
+    NotebookEdit: { displayKey: 'tool-name-notebookedit', category: 'mutate' },
+    Bash: { displayKey: 'tool-name-bash', category: 'exec' },
+    PowerShell: { displayKey: 'tool-name-powershell', category: 'exec' },
+    Glob: { displayKey: 'tool-name-glob', category: 'other' },
+    Grep: { displayKey: 'tool-name-grep', category: 'other' },
+    WebFetch: { displayKey: 'tool-name-webfetch', category: 'other' },
+    WebSearch: { displayKey: 'tool-name-web_search', category: 'other' },
+    Skill: { displayKey: 'tool-name-skill', category: 'other' },
+};
+const metaOf = (name) => (Object.hasOwn(META, name) ? META[name] : undefined) ?? { category: 'other' };
+/** The role of a tool call (cards are the default). */
+export function claudeToolRole(name) {
+    switch (name) {
+        case 'Agent':
+        case 'Task':
+            return 'subagent';
+        case 'AskUserQuestion':
+            return 'question';
+        case 'TodoWrite':
+        // The task tools that replaced TodoWrite (CLI 2.1.284); both families
+        // are shouldDefer tools, so the preset alone never surfaces them.
+        case 'TaskCreate':
+        case 'TaskUpdate':
+        case 'TaskList':
+        case 'TaskGet':
+            return 'todo';
+        case 'EnterPlanMode':
+        case 'ExitPlanMode':
+            return 'plan';
+        default:
+            return 'card';
+    }
+}
+export { displayPath };
+/** `mcp__<server>__<tool>` → `server › tool`. */
+function mcpTitle(name) {
+    const match = /^mcp__(.+?)__(.+)$/u.exec(name);
+    return match === null ? undefined : `${match[1]} › ${match[2]}`;
+}
+/** Replace the first (or every) occurrence literally — no `$` patterns. */
+function replaceLiteral(text, from, to, all) {
+    if (from === '')
+        return text;
+    if (all)
+        return text.split(from).join(to);
+    const index = text.indexOf(from);
+    return index === -1 ? text : text.slice(0, index) + to + text.slice(index + from.length);
+}
+/** The diffs an Edit/MultiEdit input describes, applied to `original` when
+ *  the full before-image is known (else snippet diffs). */
+function editDiffs(path, edits, original) {
+    if (original !== undefined) {
+        let next = original;
+        for (const edit of edits)
+            next = replaceLiteral(next, edit.old, edit.new, edit.all);
+        return [{ path, oldText: original, newText: next }];
+    }
+    return edits.map(edit => ({ path, oldText: edit.old, newText: edit.new }));
+}
+function editsOf(name, input) {
+    if (name === 'MultiEdit') {
+        const list = Array.isArray(input.edits) ? input.edits : [];
+        return list.flatMap(item => {
+            const edit = rec(item);
+            const from = str(edit?.old_string);
+            const to = str(edit?.new_string);
+            return from === undefined || to === undefined ? [] : [{ old: from, new: to, all: edit?.replace_all === true }];
+        });
+    }
+    const from = str(input.old_string);
+    const to = str(input.new_string);
+    return from === undefined || to === undefined ? [] : [{ old: from, new: to, all: input.replace_all === true }];
+}
+/** How a call renders while it runs. */
+export function presentClaudeToolCall(name, rawInput, cwd) {
+    const role = claudeToolRole(name);
+    if (role === 'subagent')
+        return { card: 'subagent' };
+    if (role === 'question')
+        return { card: 'question' };
+    if (role === 'todo')
+        return { card: 'todo' };
+    // Plan-mode tools never reach here as calls; a stray one stays a plain card.
+    const input = rec(rawInput) ?? {};
+    const meta = metaOf(name);
+    const filePath = str(input.file_path) ?? str(input.notebook_path);
+    switch (name) {
+        case 'Read': {
+            if (filePath === undefined)
+                return undefined;
+            const offset = num(input.offset);
+            return { card: 'generic', title: `${displayPath(filePath, cwd)}${offset === undefined ? '' : `:${offset}`}`, ...meta };
+        }
+        case 'Write': {
+            const content = str(input.content);
+            if (filePath === undefined || content === undefined)
+                return undefined;
+            return { card: 'diff', title: displayPath(filePath, cwd), diffs: [{ path: filePath, oldText: null, newText: content }], ...meta };
+        }
+        case 'Edit':
+        case 'MultiEdit': {
+            if (filePath === undefined)
+                return undefined;
+            const edits = editsOf(name, input);
+            if (edits.length === 0)
+                return { card: 'generic', title: displayPath(filePath, cwd), ...meta };
+            return { card: 'diff', title: displayPath(filePath, cwd), diffs: editDiffs(filePath, edits, undefined), ...meta };
+        }
+        case 'NotebookEdit':
+            return filePath === undefined ? undefined : { card: 'generic', title: displayPath(filePath, cwd), ...meta };
+        case 'Bash':
+        case 'PowerShell': {
+            const command = str(input.command);
+            if (command === undefined)
+                return undefined;
+            const description = str(input.description);
+            return { card: 'terminal', title: command, ...(description === undefined ? {} : { description }), cwd, ...meta };
+        }
+        case 'Glob':
+        case 'Grep': {
+            const pattern = str(input.pattern);
+            if (pattern === undefined)
+                return undefined;
+            const where = str(input.path);
+            return { card: 'generic', title: where === undefined ? pattern : `${pattern} · ${displayPath(where, cwd)}`, ...meta };
+        }
+        case 'WebFetch':
+            return { card: 'generic', title: str(input.url) ?? name, ...meta };
+        case 'WebSearch':
+            return { card: 'generic', title: str(input.query) ?? name, ...meta };
+        case 'Skill': {
+            const skill = str(input.skill) ?? str(input.name);
+            return { card: 'generic', title: skill ?? name, ...meta };
+        }
+        default: {
+            const title = mcpTitle(name);
+            return title === undefined ? undefined : { card: 'generic', title, ...meta };
+        }
+    }
+}
+/** Parse `path:line:text` grep output into per-file matches. */
+function grepMatches(content) {
+    const files = new Map();
+    for (const raw of content.split('\n')) {
+        const match = /^(.+?):(\d+):(.*)$/u.exec(raw);
+        if (match === null)
+            continue;
+        const list = files.get(match[1]) ?? [];
+        list.push({ lineNumber: Number(match[2]), line: match[3] });
+        files.set(match[1], list);
+    }
+    return [...files].map(([path, matches]) => ({ path, matches }));
+}
+/** How a settled result renders (undefined = the plain text card). */
+export function presentClaudeToolResult(name, rawInput, outcome, cwd) {
+    if (outcome.isError || claudeToolRole(name) !== 'card')
+        return undefined;
+    const input = rec(rawInput) ?? {};
+    const result = rec(outcome.structured);
+    const meta = metaOf(name);
+    switch (name) {
+        case 'Read': {
+            const file = rec(result?.file);
+            const path = str(file?.filePath) ?? str(input.file_path);
+            const content = str(file?.content);
+            if (path === undefined || content === undefined)
+                return undefined;
+            return { card: 'read', title: displayPath(path, cwd), path, content: [{ type: 'text', text: content }], ...meta };
+        }
+        case 'Write': {
+            const path = str(result?.filePath) ?? str(input.file_path);
+            const content = str(result?.content) ?? str(input.content);
+            if (path === undefined || content === undefined)
+                return undefined;
+            const original = str(result?.originalFile);
+            return { card: 'diff', title: displayPath(path, cwd), diffs: [{ path, oldText: original ?? null, newText: content }], ...meta };
+        }
+        case 'Edit':
+        case 'MultiEdit': {
+            const path = str(result?.filePath) ?? str(input.file_path);
+            if (path === undefined)
+                return undefined;
+            const edits = editsOf(name, input);
+            if (edits.length === 0)
+                return undefined;
+            return { card: 'diff', title: displayPath(path, cwd), diffs: editDiffs(path, edits, str(result?.originalFile)), ...meta };
+        }
+        case 'Bash':
+        case 'PowerShell': {
+            const stdout = str(result?.stdout) ?? outcome.text;
+            const stderr = str(result?.stderr) ?? '';
+            const output = [stdout, stderr].filter(part => part !== '').join('\n');
+            return { card: 'terminal', output: result?.interrupted === true ? `${output}\n[aborted]` : output, exitCode: 0, ...meta };
+        }
+        case 'Glob': {
+            const paths = Array.isArray(result?.filenames) ? result.filenames.filter((path) => typeof path === 'string') : outcome.text.split('\n').filter(line => line !== '');
+            return { card: 'search', shape: 'paths', paths: paths.map(path => displayPath(path, cwd)), truncated: result?.truncated === true, total: num(result?.numFiles) ?? paths.length, ...meta };
+        }
+        case 'Grep': {
+            const content = str(result?.content);
+            if (str(result?.mode) === 'content' && content !== undefined) {
+                const files = grepMatches(content).map(file => ({ path: displayPath(file.path, cwd), matches: file.matches }));
+                return { card: 'search', shape: 'matches', files, truncated: false, total: files.reduce((sum, file) => sum + file.matches.length, 0), ...meta };
+            }
+            const paths = Array.isArray(result?.filenames) ? result.filenames.filter((path) => typeof path === 'string') : [];
+            if (paths.length === 0)
+                return undefined;
+            return { card: 'search', shape: 'paths', paths: paths.map(path => displayPath(path, cwd)), truncated: false, total: num(result?.numFiles) ?? paths.length, ...meta };
+        }
+        default:
+            return undefined;
+    }
+}

package/lib/types/backends/claude/transcript-file.d.ts

@@ -0,0 +1,41 @@
+import { type JsonRecord } from '../../utils/jsonl.js';
+/** The largest transcript file read (larger is refused). */
+export declare const MAX_TRANSCRIPT_BYTES: number;
+/** Entries one older slice carries at most (extended back to a prompt). */
+export declare const MAX_SLICE_ENTRIES = 1000;
+/** The CLI's config directory for an environment. */
+export declare function claudeConfigDir(env: Readonly<Record<string, string | undefined>>): string;
+/**
+ * Find `<sessionId>.jsonl` under `<configDir>/projects/*` (the most recently
+ * written one if several project directories hold it).
+ */
+export declare function locateClaudeTranscript(sessionId: string, configDir: string): string | undefined;
+/** Every entry of a transcript file (bounded; malformed lines skipped). */
+export declare function readTranscriptEntries(path: string, maxBytes?: number): {
+    readonly entries: readonly JsonRecord[];
+    readonly badLines: number;
+};
+/** Whether an entry is a compaction boundary. */
+export declare function isCompactBoundary(entry: JsonRecord | undefined): boolean;
+/** The uuids a boundary preserved, oldest first. */
+export declare function preservedUuids(boundary: JsonRecord, byUuid: ReadonlyMap<string, JsonRecord>): string[];
+/** Where the next older slice ends (exclusive of what is already shown). */
+export interface OlderCursor {
+    /** The newest entry of the next slice. */
+    readonly end: string;
+    /** Entries the newer view already shows (a boundary's preserved ones). */
+    readonly exclude: ReadonlySet<string>;
+}
+/** The cursor before the boundary a view starts at. */
+export declare function cursorBefore(boundary: JsonRecord, byUuid: ReadonlyMap<string, JsonRecord>): OlderCursor | undefined;
+/** The newest compaction boundary a view starting at `head` began with. */
+export declare function headBoundary(entries: readonly JsonRecord[], byUuid: ReadonlyMap<string, JsonRecord>, head: string | undefined): JsonRecord | undefined;
+/**
+ * One older slice: the entries (oldest first) the replay paints, and the
+ * cursor of the slice before it (undefined: this was the oldest).
+ */
+export declare function olderSlice(byUuid: ReadonlyMap<string, JsonRecord>, cursor: OlderCursor, limit?: number): {
+    readonly entries: readonly JsonRecord[];
+    readonly next?: OlderCursor;
+};
+//# sourceMappingURL=transcript-file.d.ts.map

package/lib/types/backends/claude/transcript-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript-file.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/transcript-file.ts"],"names":[],"mappings":"AA8BA,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAGlE,4DAA4D;AAC5D,eAAO,MAAM,oBAAoB,QAAmB,CAAA;AACpD,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAOrC,qDAAqD;AACrD,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GAAG,MAAM,CAGzF;AAKD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAqB/F;AAED,2EAA2E;AAC3E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAuB,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAK3J;AAED,iDAAiD;AACjD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAExE;AAED,oDAAoD;AACpD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,MAAM,EAAE,CAoBtG;AAED,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACtC;AAED,uDAAuD;AACvD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,WAAW,GAAG,SAAS,CAInH;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAUtJ;AAUD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EACvC,MAAM,EAAE,WAAW,EACnB,KAAK,SAAoB,GACxB;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAwC1E"}

package/lib/types/backends/claude/transcript-file.js

@@ -0,0 +1,195 @@
+/**
+ * The Claude session transcript file, read-only:
+ * what "load earlier" reads beyond the SDK's read API, which returns only
+ * the model-visible chain after the latest compaction.
+ *
+ * Location: the CLI keeps `<config>/projects/<munged cwd>/<sessionId>.jsonl`
+ * (`<config>` = `$CLAUDE_CONFIG_DIR` or `~/.claude`). The munged directory
+ * name is never computed here (its encoding differs by runtime and
+ * platform): the project directories are scanned for the session's file
+ * name instead.
+ *
+ * Reading: the whole file, at most {@link MAX_TRANSCRIPT_BYTES} (larger is
+ * refused, not truncated: a partial tree could misplace history), parsed
+ * line by line — a malformed line costs that line (`src/utils/jsonl.ts`).
+ *
+ * The chain: every entry names its `parentUuid`. A compaction writes a
+ * `system/compact_boundary` entry with `parentUuid: null` (the resumed chain
+ * stops there) and `logicalParentUuid` = the last entry before it, and lists
+ * the entries it preserved (`compactMetadata.preservedMessages.uuids`, or
+ * the older `preservedSegment` head…tail), which the loader splices after
+ * the summary (`anchorUuid`). One older segment is the chain walked back from
+ * a boundary's logical parent to the next `parentUuid: null` entry — an older
+ * boundary or the session's first entry — with that older boundary's
+ * preserved entries spliced in, and without the entries the newer boundary
+ * preserved (those were shown after the newer summary already).
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { t } from '../../i18n.js';
+import { parseJsonl } from '../../utils/jsonl.js';
+import { str } from './narrow.js';
+/** The largest transcript file read (larger is refused). */
+export const MAX_TRANSCRIPT_BYTES = 64 * 1024 * 1024;
+/** Entries one older slice carries at most (extended back to a prompt). */
+export const MAX_SLICE_ENTRIES = 1000;
+/** Steps a chain walk takes at most (a corrupted tree cannot loop us). */
+const MAX_WALK = 1_000_000;
+const rec = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) ? value : undefined;
+/** The CLI's config directory for an environment. */
+export function claudeConfigDir(env) {
+    const dir = env.CLAUDE_CONFIG_DIR;
+    return dir !== undefined && dir !== '' ? dir : join(homedir(), '.claude');
+}
+/** A session id is a file name, never a path. */
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
+/**
+ * Find `<sessionId>.jsonl` under `<configDir>/projects/*` (the most recently
+ * written one if several project directories hold it).
+ */
+export function locateClaudeTranscript(sessionId, configDir) {
+    if (!SAFE_ID.test(sessionId))
+        return undefined;
+    const projects = join(configDir, 'projects');
+    let dirs;
+    try {
+        dirs = readdirSync(projects, { withFileTypes: true }).filter(entry => entry.isDirectory()).map(entry => entry.name);
+    }
+    catch {
+        return undefined;
+    }
+    let found;
+    for (const dir of dirs) {
+        const path = join(projects, dir, `${sessionId}.jsonl`);
+        try {
+            const stat = statSync(path);
+            if (!stat.isFile())
+                continue;
+            if (found === undefined || stat.mtimeMs > found.mtime)
+                found = { path, mtime: stat.mtimeMs };
+        }
+        catch {
+            // Not in this project.
+        }
+    }
+    return found?.path;
+}
+/** Every entry of a transcript file (bounded; malformed lines skipped). */
+export function readTranscriptEntries(path, maxBytes = MAX_TRANSCRIPT_BYTES) {
+    const size = statSync(path).size;
+    if (size > maxBytes)
+        throw new Error(t('claude-transcript-too-large', { mb: String(Math.round(maxBytes / (1024 * 1024))) }));
+    const { records, badLines } = parseJsonl(readFileSync(path, 'utf8'));
+    return { entries: records, badLines };
+}
+/** Whether an entry is a compaction boundary. */
+export function isCompactBoundary(entry) {
+    return entry?.type === 'system' && entry.subtype === 'compact_boundary';
+}
+/** The uuids a boundary preserved, oldest first. */
+export function preservedUuids(boundary, byUuid) {
+    const meta = rec(boundary.compactMetadata) ?? rec(boundary.compact_metadata);
+    const listed = rec(meta?.preservedMessages)?.uuids;
+    if (Array.isArray(listed))
+        return listed.filter((uuid) => typeof uuid === 'string');
+    const segment = rec(meta?.preservedSegment);
+    const head = str(segment?.headUuid);
+    const tail = str(segment?.tailUuid);
+    if (head === undefined || tail === undefined)
+        return [];
+    const out = [];
+    // A corrupted tree cannot send the walk round a cycle (as in olderSlice).
+    const seen = new Set();
+    let cursor = tail;
+    while (cursor !== undefined && !seen.has(cursor) && out.length < MAX_WALK) {
+        seen.add(cursor);
+        out.push(cursor);
+        if (cursor === head)
+            return out.reverse();
+        cursor = str(byUuid.get(cursor)?.parentUuid);
+    }
+    // The head was never reached: the segment is not where it claims to be.
+    return [];
+}
+/** The cursor before the boundary a view starts at. */
+export function cursorBefore(boundary, byUuid) {
+    const end = str(boundary.logicalParentUuid);
+    if (end === undefined)
+        return undefined;
+    return { end, exclude: new Set(preservedUuids(boundary, byUuid)) };
+}
+/** The newest compaction boundary a view starting at `head` began with. */
+export function headBoundary(entries, byUuid, head) {
+    const named = head === undefined ? undefined : byUuid.get(head);
+    if (isCompactBoundary(named))
+        return named;
+    // The view's first entry is the summary right after it.
+    const parent = named === undefined ? undefined : byUuid.get(str(named.parentUuid) ?? '');
+    if (isCompactBoundary(parent))
+        return parent;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        if (isCompactBoundary(entries[index]))
+            return entries[index];
+    }
+    return undefined;
+}
+/** Whether a chain entry is a real prompt (a turn starts there). */
+function isPrompt(entry) {
+    if (entry.type !== 'user' || entry.isMeta === true || entry.isCompactSummary === true)
+        return false;
+    const content = rec(entry.message)?.content;
+    if (typeof content === 'string')
+        return content.trim() !== '' && !content.startsWith('<');
+    return Array.isArray(content) && !content.some(block => rec(block)?.type === 'tool_result') && content.some(block => rec(block)?.type === 'text');
+}
+/**
+ * One older slice: the entries (oldest first) the replay paints, and the
+ * cursor of the slice before it (undefined: this was the oldest).
+ */
+export function olderSlice(byUuid, cursor, limit = MAX_SLICE_ENTRIES) {
+    const chain = [];
+    const seen = new Set();
+    let uuid = cursor.end;
+    while (uuid !== undefined && !seen.has(uuid) && chain.length < MAX_WALK) {
+        seen.add(uuid);
+        const entry = byUuid.get(uuid);
+        if (entry === undefined)
+            break;
+        chain.push(entry);
+        uuid = str(entry.parentUuid);
+    }
+    chain.reverse();
+    const shown = chain.filter(entry => (entry.type === 'user' || entry.type === 'assistant') && entry.isSidechain !== true && !cursor.exclude.has(str(entry.uuid) ?? ''));
+    if (shown.length > limit) {
+        // The newest `limit` entries, extended back to the prompt their first
+        // turn began with; the rest (all on the same chain) is the next slice.
+        let cut = shown.length - limit;
+        for (let index = cut; index >= Math.max(0, cut - limit); index -= 1) {
+            if (isPrompt(shown[index])) {
+                cut = index;
+                break;
+            }
+        }
+        const end = str(shown[cut - 1]?.uuid);
+        return { entries: shown.slice(cut), ...(end === undefined ? {} : { next: { end, exclude: cursor.exclude } }) };
+    }
+    // The whole segment: it began at an older boundary (continue before that
+    // one next) or at the session's first entry (nothing older).
+    const root = chain[0];
+    if (root === undefined || !isCompactBoundary(root))
+        return { entries: shown };
+    const next = cursorBefore(root, byUuid);
+    // The older boundary's preserved entries follow its summary, as the loader
+    // shows them.
+    const meta = rec(root.compactMetadata);
+    const preserved = preservedUuids(root, byUuid).flatMap((id) => {
+        const entry = byUuid.get(id);
+        return entry === undefined ? [] : [entry];
+    });
+    const anchor = str(rec(meta?.preservedMessages)?.anchorUuid) ?? str(rec(meta?.preservedSegment)?.anchorUuid);
+    const anchored = anchor === undefined ? -1 : shown.findIndex(entry => entry.uuid === anchor);
+    const at = anchored !== -1 ? anchored : shown.findIndex(entry => entry.isCompactSummary === true);
+    const segment = preserved.length === 0 ? shown : [...shown.slice(0, at + 1), ...preserved, ...shown.slice(at + 1)];
+    return { entries: segment, ...(next === undefined ? {} : { next }) };
+}

package/lib/types/backends/claude/translate/attempts.d.ts

@@ -0,0 +1,33 @@
+/** Assemble turns, attempts and streaming deltas into canonical messages. */
+import type { AgentEvent, AgentEventOf, TurnEndReason, UsageDelta } from '../../../agent/events.js';
+import { type Rec } from '../narrow.js';
+import type { OpenAttempt } from './types.js';
+/** Settled API message ids remembered (a late block only ever trails the
+ *  response it belongs to by a few messages). */
+export declare const MAX_SETTLED_ATTEMPTS = 256;
+export declare function createAttemptTranslator(context: {
+    stepOpen: boolean;
+    step: number;
+    turn: number;
+    turnOpen: boolean;
+    turnTime: number;
+    toolResults: number;
+    narrated: string | undefined;
+    notificationTurnExpected: boolean;
+    currentModel: string;
+    attempt: OpenAttempt | undefined;
+    compactRequested: boolean;
+    readonly settledAttempts: Set<string>;
+    now(): number;
+    nextSeq(): number;
+}): {
+    closeStep: (out: AgentEvent[]) => void;
+    openTurn: (out: AgentEvent[], origin: AgentEventOf<"turn.start">["origin"], userMessageId?: string) => void;
+    settleAttempt: (out: AgentEvent[]) => void;
+    ensureAttempt: (out: AgentEvent[], id: string, model: string | undefined, usage: UsageDelta | undefined) => OpenAttempt | undefined;
+    delta: (open: OpenAttempt, value: AgentEventOf<"assistant.delta">["delta"], index: number) => AgentEvent;
+    translateStream: (message: Rec) => AgentEvent[];
+    translateResult: (message: Rec) => AgentEvent[];
+    forceCloseTurn: (reason: TurnEndReason) => AgentEvent[];
+};
+//# sourceMappingURL=attempts.d.ts.map

package/lib/types/backends/claude/translate/attempts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempts.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/translate/attempts.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAoB,aAAa,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErH,OAAO,EAAsB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAI7C;iDACiD;AACjD,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,QAAQ,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,wBAAwB,EAAE,OAAO,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,WAAW,GAAG,SAAS,CAAA;IAChC,gBAAgB,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACrC,GAAG,IAAI,MAAM,CAAA;IACb,OAAO,IAAI,MAAM,CAAA;CAClB;qBAEyB,UAAU,EAAE,KAAG,IAAI;oBAMpB,UAAU,EAAE,UAAU,YAAY,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,kBAAkB,MAAM,KAAG,IAAI;yBAiBpF,UAAU,EAAE,KAAG,IAAI;yBAkCnB,UAAU,EAAE,MAAM,MAAM,SAAS,MAAM,GAAG,SAAS,SAAS,UAAU,GAAG,SAAS,KAAG,WAAW,GAAG,SAAS;kBAoBnH,WAAW,SAAS,YAAY,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC,SAAS,MAAM,KAAG,UAAU;+BAG3E,GAAG,KAAG,UAAU,EAAE;+BA8ElB,GAAG,KAAG,UAAU,EAAE;6BA8CpB,aAAa,KAAG,UAAU,EAAE;EAW7D"}