@spexcode/transcript 0.7.0-next.11 → 0.7.0-next.13

package/dist/parsers.d.ts

@@ -1,4 +1,4 @@
-import { type TranscriptRange, type TranscriptRead } from './turns.js';
+import { type TranscriptRange, type TranscriptRead, type TurnOutcome } from './turns.js';
 export declare const MAX_TURNS = 200;
 export declare const MAX_OUTPUT_BYTES: number;
 export type MutableTool = {
@@ -16,6 +16,8 @@ export type MutableTurn = {
     role: 'user' | 'assistant';
     text?: string;
     tools: MutableTool[];
+    outcome?: TurnOutcome;
+    error?: string;
 };
 export type ToolOutcome = 'failed' | 'rejected';
 export type ParsedEvent = {
@@ -34,7 +36,7 @@ export declare function codexAppServerEvent(value: unknown): ParsedEvent | null;
 export declare function codexAppServerStream(): Parse;
 export declare function piEvent(value: unknown): ParsedEvent | null;
 export declare function geminiEvent(value: unknown): ParsedEvent | null;
-export declare function openclawEvent(value: unknown): ParsedEvent | null;
+export declare const openclawEvent: typeof piEvent;
 export declare function hermesEvents(value: unknown): ParsedEvent[];
 export declare function opencodeEvents(value: unknown): ParsedEvent[];
 export declare class IntervalCollector {

package/dist/parsers.js

@@ -183,6 +183,18 @@ export function codexEvent(value) {
         const rawInput = payload.input === undefined && payload.arguments === undefined ? undefined : compact(payload.input ?? payload.arguments);
         return { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'assistant', tools: [{ id, name: string(payload.name ?? payload.tool_name) ?? 'tool', input: codexExecCommand(rawInput), outputLines: 0, outputBytes: 0 }] } };
     }
+    // THE ROLLOUT PUTS THE VERDICT IN A THIRD RECORD. Unlike every other source here, a codex result item
+    // carries no failure field at all — `function_call_output` and `custom_tool_call_output` have only
+    // `{call_id, output}`. The harness records how the command ended in a separate `event_msg`, joined by the
+    // same `call_id`: `exec_command_end.status` (completed | failed, 6,194 failed of 83,990 in the rollouts on
+    // this box, matching exactly the nonzero exit codes) and `patch_apply_end.success`. Without this second
+    // join every failed command in a codex transcript reads as an ordinary one. The outcome is carried alone,
+    // with no text, so it lands on the call the output record already filled.
+    if (entry.type === 'event_msg' && (type === 'exec_command_end' || type === 'patch_apply_end')) {
+        const id = string(payload.call_id);
+        const failed = string(payload.status) === 'failed' || payload.success === false;
+        return id && failed ? { at: eventAt, turn: null, toolOutputs: [{ id, text: '', outcome: 'failed' }] } : { at: eventAt, turn: null };
+    }
     if (entry.type === 'response_item' && (type === 'custom_tool_call_output' || type === 'function_call_output')) {
         const id = string(payload.call_id ?? payload.id);
         const output = payload.output ?? payload.result ?? '';
@@ -190,6 +202,17 @@ export function codexEvent(value) {
     }
     return null;
 }
+// A file edit names the paths it touched, and its result is the diff the app-server already computed. Both
+// come off `FileUpdateChange[]`, which is the only shape on the union whose payload is a list of records
+// rather than one field.
+const filePaths = (changes) => {
+    const paths = items(changes).map((change) => string(object(change)?.path)).filter(Boolean);
+    return paths.length ? paths.join('\n') : undefined;
+};
+const fileDiffs = (changes) => {
+    const diffs = items(changes).map((change) => string(object(change)?.diff)).filter(Boolean);
+    return diffs.length ? diffs.join('\n') : undefined;
+};
 // Codex app-server notifications are a different native stream from rollout lines. Keep this mapping stateless:
 // a caller that needs streamed prose uses codexAppServerStream below, while file and in-memory sources still
 // share the same one-record parser contract.
@@ -203,7 +226,12 @@ export function codexAppServerEvent(value) {
     const recognized = method === 'item/agentMessage/delta' || method === 'item/started' || method === 'item/completed';
     if (!recognized)
         return null;
-    const eventAt = timestamp(params.emittedAtMs) ?? timestamp(params.startedAtMs) ?? timestamp(params.completedAtMs);
+    // `emittedAtMs` is a SIBLING of `method` and `params`, not a field inside them — the app-server's own
+    // generated envelope type puts it there, and every line of the capture in `fixtures/codex-app-server` has
+    // exactly the keys `method`, `params`, `emittedAtMs`. Reading it from `params` found nothing, which made
+    // every `item/agentMessage/delta` clockless and therefore dropped: the streaming path parsed and produced
+    // nothing at all. The lifecycle clocks below do sit in `params`.
+    const eventAt = timestamp(entry.emittedAtMs) ?? timestamp(params.startedAtMs) ?? timestamp(params.completedAtMs);
     if (eventAt === null)
         return { at: null, turn: null };
     if (method === 'item/agentMessage/delta') {
@@ -227,27 +255,35 @@ export function codexAppServerEvent(value) {
         const text = string(item.text);
         return { at: eventAt, turn: { id, at: eventAt, role: 'assistant', text: text ?? undefined, tools: [] } };
     }
-    const toolTypes = new Set(['commandExecution', 'functionCall', 'customToolCall', 'mcpToolCall', 'dynamicToolCall']);
+    // The tool-bearing variants of the app-server's own `ThreadItem` union. `functionCall` and `customToolCall`
+    // used to be listed here and are NOT members of it — those are ROLLOUT record types, and no such string
+    // exists anywhere in the app-server binary. `fileChange` is a real one that was missing, so a codex file
+    // edit appeared as no call at all.
+    const toolTypes = new Set(['commandExecution', 'fileChange', 'mcpToolCall', 'dynamicToolCall']);
     if (!toolTypes.has(type))
         return null;
     if (method === 'item/started') {
         const name = type === 'commandExecution' ? 'command'
-            : string(item.name) ?? string(item.tool) ?? (type === 'mcpToolCall' ? 'mcp' : 'tool');
+            : type === 'fileChange' ? 'edit'
+                : string(item.name) ?? string(item.tool) ?? (type === 'mcpToolCall' ? 'mcp' : 'tool');
         const input = item.arguments !== undefined ? item.arguments
             : item.input !== undefined ? item.input
                 : item.command !== undefined ? item.command
-                    : undefined;
+                    : type === 'fileChange' ? filePaths(item.changes)
+                        : undefined;
         return { at: eventAt, turn: { id, at: eventAt, role: 'assistant', tools: [{ id, name, input: input === undefined ? undefined : compact(input), outputLines: 0, outputBytes: 0 }] } };
     }
     let output = undefined;
     if (type === 'commandExecution')
         output = item.aggregatedOutput;
-    else if (type === 'functionCall' || type === 'customToolCall')
-        output = item.output ?? item.result;
+    // an MCP result is `{content, structuredContent, _meta}`: the text is in `content`, and handing the wrapper
+    // to `resultText` printed the JSON envelope instead of what the tool said
     else if (type === 'mcpToolCall')
-        output = item.result ?? item.error;
+        output = object(item.result)?.content ?? item.result ?? object(item.error)?.message ?? item.error;
     else if (type === 'dynamicToolCall')
         output = item.contentItems ?? item.output ?? item.error;
+    else if (type === 'fileChange')
+        output = fileDiffs(item.changes);
     // the item status is the app-server's own verdict: `failed`, or `declined` when the person refused the call —
     // a declined call has no output, so the empty result is what ends its "running"
     const status = string(item.status);
@@ -313,6 +349,16 @@ export function piEvent(value) {
                 turn.tools.push({ id, name: string(block.name) ?? 'tool', input: block.arguments === undefined ? undefined : compact(block.arguments), outputLines: 0, outputBytes: 0 });
             }
         }
+        // the producer's verdict on the TURN (`StopReason` in pi's shipped types): `error` is the provider's own
+        // failure, `aborted` the turn a stop ended. These are exactly the turns that carry no text and no calls —
+        // 13 of 578 assistant messages in the sessions on this box — so without them the turn is an empty gap.
+        const stop = string(message.stopReason);
+        if (stop === 'error' || stop === 'aborted') {
+            turn.outcome = stop === 'aborted' ? 'cancelled' : 'failed';
+            const reason = string(message.errorMessage);
+            if (reason)
+                turn.error = reason;
+        }
         return { at: eventAt, turn };
     }
     if (message.role === 'toolResult') {
@@ -360,37 +406,23 @@ export function geminiEvent(value) {
     }
     return null;
 }
-export function openclawEvent(value) {
-    const entry = object(value);
-    const message = object(entry?.message);
-    if (!entry || entry.type !== 'message' || !message)
-        return null;
-    const eventAt = at(message) ?? at(entry);
-    if (eventAt === null)
-        return { at: null, turn: null };
-    if (message.role === 'user') {
-        const text = blockText(message.content);
-        return text ? { at: eventAt, turn: { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'user', text, tools: [] } } : null;
-    }
-    if (message.role === 'toolResult') {
-        const id = string(message.toolCallId);
-        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: blockText(message.content) ?? compact(message.content ?? ''), ...(message.isError === true ? { outcome: 'failed' } : {}) }] } : null;
-    }
-    if (message.role === 'assistant') {
-        const turn = { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'assistant', tools: [] };
-        for (const blockValue of items(message.content)) {
-            const block = object(blockValue);
-            if (block?.type === 'text')
-                turn.text = [turn.text, string(block.text)].filter(Boolean).join('\n') || undefined;
-            if (block?.type === 'toolCall') {
-                const id = string(block.id) ?? `tool-${turn.tools.length}`;
-                turn.tools.push({ id, name: string(block.name) ?? 'tool', input: block.arguments === undefined ? undefined : compact(block.arguments), outputLines: 0, outputBytes: 0 });
-            }
-        }
-        return turn.text || turn.tools.length ? { at: eventAt, turn } : null;
-    }
-    return null;
-}
+// OPENCLAW WRITES PI'S FORMAT. Verified field by field against pi's shipped schema: the `{"type":"session",
+// "version":3}` header, the 8-char hex id tree, the `user|assistant|toolResult` roles, the `text`/`thinking`/
+// `toolCall` blocks, `toolResult`'s exact key set. The only OpenClaw-specific things are its own `customType`
+// namespace and where the file lives — neither of which a parser reads. So this is not a second parser: two
+// hand-written copies had already drifted into two defects (a different clock preference on identical bytes,
+// and dropping every turn with no text and no calls, which is precisely the failed and aborted ones). Where a
+// harness differs only in where its file sits, the adapter row is the LOCATOR ([[transcript-reader]]), never a
+// second copy of the parse.
+export const openclawEvent = piEvent;
+// HERMES COUNTS IN SECONDS. Its export writes `timestamp` as a float epoch SECOND (`1787942674.556185`),
+// where every other harness here writes milliseconds and `at()` reads a bare number as one. Unconverted, a
+// Hermes turn lands in January 1970 and every interval read of a real thread — the session API hands `from`
+// and `to` as epoch ms — comes back empty. The unit is this producer's, so the conversion is this adapter's.
+const hermesAt = (message) => {
+    const seconds = at(message);
+    return seconds === null ? null : Math.round(seconds * 1000);
+};
 export function hermesEvents(value) {
     const root = object(value);
     const events = [];
@@ -398,7 +430,7 @@ export function hermesEvents(value) {
         const message = object(messageValue);
         if (!message)
             continue;
-        const eventAt = at(message);
+        const eventAt = hermesAt(message);
         if (eventAt === null) {
             events.push({ at: null, turn: null });
             continue;

package/dist/readers.d.ts

@@ -4,13 +4,18 @@ export declare function codexRolloutPath(threadId: string, root?: string, archiv
 export declare function piSessionPath(threadId: string, root?: string): string | null;
 export declare function geminiTranscriptPath(threadId: string, root?: string): string | null;
 export declare function openclawTranscriptPath(threadId: string, root?: string): string | null;
+export declare const claudeTranscriptReader: (root?: string) => TranscriptReader;
+export declare const codexTranscriptReader: (root?: string) => TranscriptReader;
+export declare const piTranscriptReader: (root?: string) => TranscriptReader;
+export declare const geminiTranscriptReader: (root?: string) => TranscriptReader;
+export declare const openclawTranscriptReader: (root?: string) => TranscriptReader;
 export declare const claudeTranscript: TranscriptReader;
 export declare const codexTranscript: TranscriptReader;
 export declare const piTranscript: TranscriptReader;
 export declare const geminiTranscript: TranscriptReader;
 export declare const openclawTranscript: TranscriptReader;
 export declare function opencodeTranscriptReader(root?: string, load?: (threadId: string) => string): TranscriptReader;
-export declare const opencodeTranscript: TranscriptReader;
 export declare function hermesTranscriptReader(root?: string, load?: (threadId: string) => string): TranscriptReader;
+export declare const opencodeTranscript: TranscriptReader;
 export declare const hermesTranscript: TranscriptReader;
 export declare function unsupportedTranscript(harness: string): TranscriptReader;

package/dist/readers.js

@@ -108,29 +108,9 @@ const openclawRoot = () => process.env.OPENCLAW_STATE_DIR || join(homedir(), '.o
 export function openclawTranscriptPath(threadId, root = openclawRoot()) { return findJsonl(root, threadId); }
 const opencodeStoreRoot = () => process.env.SPEXCODE_OPENCODE_DATA_DIR
     || join(process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'opencode');
-function opencodeStoreRevision(root) {
-    try {
-        const database = statSync(join(root, 'opencode.db'));
-        let writeAheadLog = '0:0';
-        try {
-            const stat = statSync(join(root, 'opencode.db-wal'));
-            writeAheadLog = `${stat.size}:${Math.floor(stat.mtimeMs)}`;
-        }
-        catch { /* a checkpointed database has no separate write-ahead log */ }
-        return `${database.size}:${Math.floor(database.mtimeMs)}:${writeAheadLog}`;
-    }
-    catch {
-        return null;
-    }
-}
 // The export is read RAW: `--sanitize` replaces every prose and tool-output part with a `[redacted:…]` token,
 // which made the whole conversation unreadable; the reader hands over the same local bytes the other harnesses'
 // files hold, and nothing here leaves the machine that ran the thread.
-function opencodeExport(threadId) {
-    return execFileSync(process.env.SPEXCODE_OPENCODE_CMD || 'opencode', ['export', threadId], {
-        encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
-    });
-}
 const fileRevision = (path) => {
     try {
         const stat = statSync(path);
@@ -147,7 +127,14 @@ const intervalOffsets = new Map();
 // One pass over the bytes from `scan.position` to the end of the file. Every complete line is parsed as JSON
 // and handed to `onLine` with its byte offset; `onLine` returning true stops the scan early (a bounded
 // lookahead), which abandons the rest — only a one-shot read does that.
-function scanLines(harness, fd, scan, onLine) {
+// ONE UNREADABLE LINE IS OMITTED PAYLOAD, NOT AN UNREADABLE TRANSCRIPT. A native log is written by another
+// process and can carry a line that is not JSON — a truncated record from a crash, a line someone appended by
+// hand. Throwing on it makes the whole thread unreadable forever, which is the loudest possible failure and
+// the least useful one: the person loses a conversation over one bad line. The reader already has an honest
+// word for this — the line's bytes are counted as omitted and the read reports `truncated`, exactly as it does
+// for a result past the cap. A file that is not this format at all still fails loudly, because nothing in it
+// parses and `finish()` refuses a read that never saw a timestamp.
+function scanLines(fd, scan, onLine, onUnparsable) {
     const chunk = Buffer.allocUnsafe(64 * 1024);
     let { position, carry } = scan;
     let lineStart = position - carry.length;
@@ -171,8 +158,9 @@ function scanLines(harness, fd, scan, onLine) {
             try {
                 value = JSON.parse(line);
             }
-            catch (error) {
-                throw new TranscriptReadError('invalid', `${harness} transcript cannot be parsed: ${error instanceof Error ? error.message : String(error)}`);
+            catch {
+                onUnparsable(Buffer.byteLength(line));
+                continue;
             }
             if (onLine(value, lineOffset))
                 return { position, carry: Buffer.alloc(0) };
@@ -229,7 +217,7 @@ class LineFileCursor {
         try {
             fd = openSync(this.path, 'r');
             let postRangeLines = 0;
-            this.scan = scanLines(this.harness, fd, this.scan, (value, offset) => {
+            this.scan = scanLines(fd, this.scan, (value, offset) => {
                 const event = this.parse(value);
                 if (!event)
                     return false;
@@ -238,7 +226,7 @@ class LineFileCursor {
                     intervalOffsets.set(this.seekKey, offset);
                 const pastRange = this.collector.add(event);
                 return pastRange && ++postRangeLines >= lookahead;
-            });
+            }, (bytes) => { this.collector.omittedBytes += bytes; });
         }
         catch (error) {
             if (error instanceof TranscriptReadError)
@@ -274,100 +262,100 @@ function lineFileReader(harness, locate, parse) {
         },
     };
 }
-export const claudeTranscript = lineFileReader('claude', (threadId) => claudeTranscriptPath(threadId), claudeEvent);
-export const codexTranscript = lineFileReader('codex', (threadId) => codexRolloutPath(threadId), codexEvent);
-export const piTranscript = lineFileReader('pi', (threadId) => piSessionPath(threadId), piEvent);
-export const geminiTranscript = lineFileReader('gemini', (threadId) => geminiTranscriptPath(threadId), geminiEvent);
-export const openclawTranscript = lineFileReader('openclaw', (threadId) => openclawTranscriptPath(threadId), openclawEvent);
-// OpenCode has no per-thread file: the store's revision is the change token, and one export per
-// revision is parsed and kept, so repeated interval reads of a quiet thread cost nothing new.
-const opencodeExports = new Map();
-export function opencodeTranscriptReader(root = opencodeStoreRoot(), load = opencodeExport) {
-    const reader = {
-        revision: () => opencodeStoreRevision(root),
-        read: async (threadId, range) => {
-            const revision = opencodeStoreRevision(root);
-            if (!revision)
-                throw new TranscriptReadError('missing', `opencode transcript for ${threadId} is unavailable: store was not found`);
-            const key = `${root}:${threadId}`;
-            let cached = opencodeExports.get(key);
-            if (!cached || cached.revision !== revision) {
-                let exported;
-                try {
-                    exported = load(threadId);
-                }
-                catch (error) {
-                    throw new TranscriptReadError('unreadable', `opencode transcript could not be exported: ${error instanceof Error ? error.message : String(error)}`);
-                }
-                let value;
-                try {
-                    value = JSON.parse(exported);
-                }
-                catch (error) {
-                    throw new TranscriptReadError('invalid', `opencode transcript cannot be parsed: ${error instanceof Error ? error.message : String(error)}`);
-                }
-                cached = { revision, events: opencodeEvents(value) };
-                opencodeExports.set(key, cached);
-            }
-            const collector = new IntervalCollector(range);
-            for (const event of cached.events)
-                collector.add(event);
-            return collector.finish(revision, 'opencode');
-        },
-    };
-    return {
-        ...reader,
-        // no file grows here: an open interval is re-collected from the cached export, which is one export per revision
-        tail: (threadId, from) => ({ advance: (to) => reader.read(threadId, { from, to }), close: () => { } }),
-    };
-}
-export const opencodeTranscript = opencodeTranscriptReader();
-const hermesRoot = () => process.env.HERMES_HOME || join(homedir(), '.hermes', 'profiles', 'default');
-function hermesRevision(root) {
-    try {
-        const stat = statSync(join(root, 'state.db'));
-        return `${stat.size}:${Math.floor(stat.mtimeMs)}`;
-    }
-    catch {
-        return null;
+// A ROOT IS A PARAMETER OF EVERY READER, not of some of them. Each locator already takes one; only the store
+// readers exposed it, so anything wanting a second pi root — a producer under an isolated agent dir, a test —
+// had no way to ask. Passing nothing keeps the old behaviour exactly: the locator's own default is evaluated
+// per call, so a late `CLAUDE_CONFIG_DIR` is still picked up.
+export const claudeTranscriptReader = (root) => lineFileReader('claude', (threadId) => claudeTranscriptPath(threadId, root ?? projectTranscriptRoot()), claudeEvent);
+export const codexTranscriptReader = (root) => lineFileReader('codex', (threadId) => codexRolloutPath(threadId, root ?? codexSessionsDir()), codexEvent);
+export const piTranscriptReader = (root) => lineFileReader('pi', (threadId) => piSessionPath(threadId, root ?? piSessionsRoot()), piEvent);
+export const geminiTranscriptReader = (root) => lineFileReader('gemini', (threadId) => geminiTranscriptPath(threadId, root ?? geminiRoot()), geminiEvent);
+export const openclawTranscriptReader = (root) => lineFileReader('openclaw', (threadId) => openclawTranscriptPath(threadId, root ?? openclawRoot()), openclawEvent);
+export const claudeTranscript = claudeTranscriptReader();
+export const codexTranscript = codexTranscriptReader();
+export const piTranscript = piTranscriptReader();
+export const geminiTranscript = geminiTranscriptReader();
+export const openclawTranscript = openclawTranscriptReader();
+function storeRevision(root, files) {
+    const legs = [];
+    for (const [index, name] of files.entries()) {
+        try {
+            const stat = statSync(join(root, name));
+            legs.push(`${stat.size}:${Math.floor(stat.mtimeMs)}`);
+        }
+        catch {
+            // the database itself must exist; a checkpointed store simply has no separate write-ahead log
+            if (index === 0)
+                return null;
+            legs.push('0:0');
+        }
     }
+    return legs.join(':');
 }
-function hermesExport(threadId) {
-    return execFileSync(process.env.SPEXCODE_HERMES_CMD || 'hermes', ['sessions', 'export', '--format', 'jsonl', '--session-id', threadId, '--yes'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-}
-const hermesExports = new Map();
-export function hermesTranscriptReader(root = hermesRoot(), load = hermesExport) {
+const storeExports = new Map();
+function storeReader(source, root, load) {
     const read = async (threadId, range) => {
-        const revision = hermesRevision(root);
+        const revision = storeRevision(root, source.files);
         if (!revision)
-            throw new TranscriptReadError('missing', `hermes transcript for ${threadId} is unavailable: state.db was not found`);
-        const key = `${root}:${threadId}`;
-        let cached = hermesExports.get(key);
+            throw new TranscriptReadError('missing', `${source.harness} transcript for ${threadId} is unavailable: ${source.missing}`);
+        const key = `${source.harness}:${root}:${threadId}`;
+        let cached = storeExports.get(key);
         if (!cached || cached.revision !== revision) {
             let exported;
             try {
                 exported = load(threadId);
             }
             catch (error) {
-                throw new TranscriptReadError('unreadable', `hermes transcript could not be exported: ${error instanceof Error ? error.message : String(error)}`);
+                throw new TranscriptReadError('unreadable', `${source.harness} transcript could not be exported: ${error instanceof Error ? error.message : String(error)}`);
             }
             let value;
             try {
                 value = JSON.parse(exported);
             }
             catch (error) {
-                throw new TranscriptReadError('invalid', `hermes transcript cannot be parsed: ${error instanceof Error ? error.message : String(error)}`);
+                throw new TranscriptReadError('invalid', `${source.harness} transcript cannot be parsed: ${error instanceof Error ? error.message : String(error)}`);
             }
-            cached = { revision, events: hermesEvents(value) };
-            hermesExports.set(key, cached);
+            cached = { revision, events: source.parse(value) };
+            storeExports.set(key, cached);
         }
         const collector = new IntervalCollector(range);
         for (const event of cached.events)
             collector.add(event);
-        return collector.finish(revision, 'hermes');
+        return collector.finish(revision, source.harness);
+    };
+    return {
+        revision: () => storeRevision(root, source.files),
+        read,
+        // no file grows here: an open interval is re-collected from the cached export, one export per revision
+        tail: (threadId, from) => ({ advance: (to) => read(threadId, { from, to }), close: () => { } }),
     };
-    return { revision: () => hermesRevision(root), read, tail: (threadId, from) => ({ advance: (to) => read(threadId, { from, to }), close: () => { } }) };
 }
+// The export is read RAW: OpenCode's `--sanitize` replaces every prose and tool-output part with a
+// `[redacted:…]` token, which made the whole conversation unreadable; the reader hands over the same local
+// bytes the other harnesses' files hold, and nothing here leaves the machine that ran the thread.
+const OPENCODE_STORE = {
+    harness: 'opencode',
+    defaultRoot: opencodeStoreRoot,
+    files: ['opencode.db', 'opencode.db-wal'],
+    missing: 'store was not found',
+    load: (threadId) => execFileSync(process.env.SPEXCODE_OPENCODE_CMD || 'opencode', ['export', threadId], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }),
+    parse: opencodeEvents,
+};
+const HERMES_STORE = {
+    harness: 'hermes',
+    defaultRoot: () => process.env.HERMES_HOME || join(homedir(), '.hermes', 'profiles', 'default'),
+    files: ['state.db', 'state.db-wal'],
+    missing: 'state.db was not found',
+    load: (threadId) => execFileSync(process.env.SPEXCODE_HERMES_CMD || 'hermes', ['sessions', 'export', '--format', 'jsonl', '--session-id', threadId, '--yes'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }),
+    parse: hermesEvents,
+};
+export function opencodeTranscriptReader(root = OPENCODE_STORE.defaultRoot(), load = OPENCODE_STORE.load) {
+    return storeReader(OPENCODE_STORE, root, load);
+}
+export function hermesTranscriptReader(root = HERMES_STORE.defaultRoot(), load = HERMES_STORE.load) {
+    return storeReader(HERMES_STORE, root, load);
+}
+export const opencodeTranscript = opencodeTranscriptReader();
 export const hermesTranscript = hermesTranscriptReader();
 export function unsupportedTranscript(harness) {
     const refuse = async () => { throw new TranscriptReadError('unsupported', `${harness} does not support transcript access`); };

package/dist/turns.d.ts

@@ -11,12 +11,15 @@ export type TranscriptTool = Readonly<{
     outputBytes: number;
     outcome?: 'failed' | 'rejected';
 }>;
+export type TurnOutcome = 'failed' | 'cancelled';
 export type TranscriptTurn = Readonly<{
     id: string;
     at: number;
     role: 'user' | 'assistant';
     text?: string;
     tools?: readonly TranscriptTool[];
+    outcome?: TurnOutcome;
+    error?: string;
 }>;
 export type TranscriptRead = Readonly<{
     revision: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/transcript",
-  "version": "0.7.0-next.11",
+  "version": "0.7.0-next.13",
   "type": "module",
   "description": "Normalized agent transcripts: one parser per harness, a bounded interval reader over a native thread file or an in-memory event stream, and the full/delta frame protocol every transport and renderer share.",
   "files": [