@tangle-network/harness-sessions 0.0.0-stage → 0.1.0

package/dist/formats/kimi.js

@@ -0,0 +1,205 @@
+/**
+ * Kimi Code: one directory per session, `~/.kimi/sessions/<workdir hash>/<session id>/`, holding
+ * `wire.jsonl` (the event stream this reader folds) and `context.jsonl` (the model context).
+ *
+ * Wire records are `{timestamp, message: {type, payload}}` with epoch-second timestamps.
+ * `TurnBegin` carries the user's input; each `StepBegin` is one model call, whose `ContentPart`s
+ * (`think`, `text`), `ToolCall`s (arguments streamed on in `ToolCallPart`s) and `StatusUpdate`
+ * (`token_usage`: `input_other`, `output`, `input_cache_read`, `input_cache_creation`, disjoint,
+ * and the provider's `message_id`) follow. `ToolResult` answers a call. `StepRetry` is a failed
+ * attempt with the provider's status code; `StepInterrupted` ends a step without an answer. A
+ * subagent's events arrive wrapped in `SubagentEvent`. The wire records no model.
+ */
+import { basename, dirname, join } from 'node:path';
+import { SessionBuilder, count, isRecord, sessionError, str, textOf, usageOrNull } from '../builder.js';
+import { fileRecords } from '../source.js';
+import { EVIDENCE, STORES, mtimeMs, storeGlob, walkFiles } from '../stores.js';
+import { runFold } from './fold.js';
+const FORMAT = 'kimi.session-dir';
+const STORE = STORES[FORMAT];
+const HARNESS = 'kimi-code';
+/** The event stream this reader folds; the store also holds context.jsonl and state.json. */
+const WIRE = '*/{id}/wire.jsonl';
+function usageOf(value) {
+    if (!isRecord(value))
+        return null;
+    return usageOrNull({
+        input: count(value.input_other),
+        output: count(value.output),
+        reasoning: null,
+        cacheRead: count(value.input_cache_read),
+        cacheWrite: count(value.input_cache_creation),
+    });
+}
+export function createFold(ref, mode, stats) {
+    const builder = new SessionBuilder(HARNESS, FORMAT, EVIDENCE[FORMAT].servedModel, mode, ref.nativeSessionId, ref.parentNativeSessionId);
+    let turn = 0;
+    let calls = 0;
+    let step = null;
+    let lastToolCall = null;
+    let aborted = null;
+    let compactions = 0;
+    let subagentEvents = 0;
+    const openStep = (at) => {
+        if (step)
+            return step;
+        calls += 1;
+        const id = `${builder.nativeSessionId}:turn:${turn}:step:${calls}`;
+        const call = builder.modelCall({ id, at, provider: null, servedModel: null, requestedModel: null, usage: null, costUsd: null, stopReason: null, error: null });
+        builder.message({ id: `${id}:message`, role: 'assistant', actor: 'agent', at, modelCallId: id, parts: [] });
+        step = { call, messageId: `${id}:message` };
+        return step;
+    };
+    const flushToolArguments = () => {
+        if (lastToolCall)
+            builder.setToolInput(lastToolCall.id, lastToolCall.text);
+        lastToolCall = null;
+    };
+    const observe = (record) => {
+        const message = isRecord(record.message) ? record.message : null;
+        if (message === null)
+            return;
+        const type = str(message.type);
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const at = builder.seen(record.timestamp);
+        if (type !== 'ToolCallPart')
+            flushToolArguments();
+        switch (type) {
+            case 'TurnBegin': {
+                turn += 1;
+                step = null;
+                aborted = null;
+                const input = payload.user_input;
+                const parts = typeof input === 'string'
+                    ? [{ type: 'text', text: input }]
+                    : (textOf(input) !== null ? [{ type: 'text', text: textOf(input) }] : []);
+                builder.message({ id: `${builder.nativeSessionId}:turn:${turn}:input`, role: 'user', actor: ref.parentNativeSessionId ? 'subagent-spawn' : 'human', at, modelCallId: null, parts });
+                break;
+            }
+            case 'StepBegin':
+                step = null;
+                openStep(at);
+                break;
+            case 'ContentPart': {
+                const current = openStep(at);
+                if (payload.type === 'think')
+                    builder.appendParts(current.messageId, [{ type: 'reasoning', text: str(payload.think) ?? '', redacted: payload.encrypted != null && !payload.think }]);
+                else if (typeof payload.text === 'string')
+                    builder.appendParts(current.messageId, [{ type: 'text', text: payload.text }]);
+                break;
+            }
+            case 'ToolCall': {
+                const current = openStep(at);
+                const fn = isRecord(payload.function) ? payload.function : {};
+                const id = str(payload.id) ?? `${builder.nativeSessionId}:call:${stats.line}`;
+                const text = typeof fn.arguments === 'string' ? fn.arguments : JSON.stringify(fn.arguments ?? {});
+                builder.appendParts(current.messageId, [{ type: 'tool-call', toolCallId: id }]);
+                builder.toolCall({ id, name: str(fn.name) ?? 'unknown', input: null, inputText: text, at, messageId: current.messageId });
+                lastToolCall = { id, text };
+                break;
+            }
+            case 'ToolCallPart':
+                if (lastToolCall && typeof payload.arguments_part === 'string')
+                    lastToolCall.text += payload.arguments_part;
+                break;
+            case 'ToolResult': {
+                const id = str(payload.tool_call_id) ?? '';
+                const value = isRecord(payload.return_value) ? payload.return_value : {};
+                const resultId = `${id}:result`;
+                builder.message({ id: resultId, role: 'tool', actor: 'tool-result', at, modelCallId: null, parts: [{ type: 'tool-result', toolCallId: id }] });
+                builder.toolResult(id, { output: value.output ?? null, text: typeof value.output === 'string' ? value.output : textOf(value.output), isError: value.is_error === true, at, messageId: resultId, details: value });
+                break;
+            }
+            case 'StatusUpdate': {
+                const usage = usageOf(payload.token_usage);
+                if (usage === null)
+                    break;
+                const current = openStep(at);
+                current.call.usage = usage;
+                break;
+            }
+            case 'StepRetry': {
+                // A failed attempt Kimi retried: a model call that returned no answer.
+                calls += 1;
+                builder.modelCall({
+                    id: `${builder.nativeSessionId}:turn:${turn}:retry:${calls}`, at, provider: null, servedModel: null, requestedModel: null, usage: null, costUsd: null, stopReason: null,
+                    error: sessionError(str(payload.error_type) ?? 'retry', `${str(payload.error_type) ?? 'error'}${payload.status_code ? ` (status ${String(payload.status_code)})` : ''}`, at, count(payload.status_code)),
+                });
+                break;
+            }
+            case 'StepInterrupted':
+                aborted = { at };
+                step = null;
+                break;
+            case 'TurnEnd':
+                step = null;
+                break;
+            case 'CompactionBegin':
+                compactions += 1;
+                break;
+            case 'SubagentEvent': {
+                subagentEvents += 1;
+                const agent = str(payload.agent_id);
+                if (agent)
+                    builder.child(agent, str(payload.parent_tool_call_id));
+                break;
+            }
+            default:
+                break;
+        }
+    };
+    const finish = () => {
+        flushToolArguments();
+        builder.source(stats);
+        if (compactions > 0)
+            builder.gap(`${compactions} compactions replaced earlier context`);
+        if (subagentEvents > 0)
+            builder.gap(`${subagentEvents} subagent events are logged in this session; each subagent is its own session`);
+        builder.inferEnding(aborted ? { at: aborted.at, error: null } : undefined);
+        return builder;
+    };
+    return { builder, observe, finish };
+}
+export async function fold(ref, mode, options, source = fileRecords(ref.path, { strict: options.corruption === 'strict', signal: options.signal })) {
+    return runFold(createFold(ref, mode, source.stats), source);
+}
+async function locate(home, opts) {
+    const root = join(home, STORE.root);
+    const pattern = storeGlob(WIRE, opts.nativeSessionId);
+    const refs = [];
+    for (const rel of await walkFiles(root)) {
+        if (!pattern.test(rel))
+            continue;
+        const path = join(root, rel);
+        const mtime = await mtimeMs(path);
+        if (opts.sinceMs && mtime < opts.sinceMs)
+            continue;
+        // Kimi keys the session directory by a hash of its working directory and records no cwd.
+        if (opts.cwd)
+            continue;
+        const id = basename(dirname(path));
+        const context = join(dirname(path), 'context.jsonl');
+        const files = (await mtimeMs(context)) > 0 ? [path, context] : [path];
+        refs.push({ harness: HARNESS, format: FORMAT, nativeSessionId: id, path, files, home, cwd: null, mtimeMs: mtime, parentNativeSessionId: null });
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+export const kimiReader = {
+    harness: HARNESS,
+    aliases: ['kimi', 'kimi-cli'],
+    formats: [FORMAT],
+    stores: [STORE],
+    globs: { session: WIRE },
+    evidence: EVIDENCE[FORMAT],
+    locate: (home, opts = {}) => locate(home, opts),
+    async read(ref, opts = {}) {
+        return (await fold(ref, 'full', opts)).build();
+    },
+    async summarize(ref, opts = {}) {
+        return (await fold(ref, 'summary', opts)).summary();
+    },
+};
+/** A session read from its `wire.jsonl` outside a HOME layout. */
+export function kimiRefForFile(path) {
+    return { harness: HARNESS, format: FORMAT, nativeSessionId: basename(dirname(path)), path, files: [path], home: null, cwd: null, mtimeMs: 0, parentNativeSessionId: null };
+}

package/dist/formats/opencode.d.ts

@@ -0,0 +1,4 @@
+import type { HarnessSessionReader, LocateOptions, SessionRef } from '../schema.js';
+/** Every session in one store file, without opening the live store. */
+export declare function opencodeSessionsInStore(path: string, home: string | null, opts?: LocateOptions): Promise<SessionRef[]>;
+export declare const opencodeReader: HarnessSessionReader;

package/dist/formats/opencode.js

@@ -0,0 +1,241 @@
+/**
+ * OpenCode 1.x: one SQLite store for every session in the HOME,
+ * `~/.local/share/opencode/opencode.db` (with `-wal` and `-shm` siblings while it is open).
+ *
+ * `session` rows carry the cwd, the parent session and session totals. `message` rows carry a JSON
+ * `data` blob: role, the provider and model the message was sent to, tokens, cost, finish and the
+ * error that ended it. `part` rows carry the content: `text`, `reasoning`, `tool` (the call and
+ * its result in one row), `step-start` and `step-finish` (one model response, with its tokens and
+ * cost), `retry` (a failed attempt) and bookkeeping parts. The store is read from a private copy,
+ * never in place: opening it can checkpoint the write-ahead log of a store a capture is keeping.
+ */
+import { join } from 'node:path';
+import { SessionBuilder, count, isRecord, isoTime, sessionError, str, usageOrNull } from '../builder.js';
+import { isMissing, withSqliteCopy } from '../source.js';
+import { EVIDENCE, STORES, mtimeMs } from '../stores.js';
+const FORMAT = 'opencode.sqlite';
+const STORE = STORES[FORMAT];
+const HARNESS = 'opencode';
+function usageOf(tokens) {
+    if (!isRecord(tokens))
+        return null;
+    const cache = isRecord(tokens.cache) ? tokens.cache : {};
+    return usageOrNull({
+        input: count(tokens.input),
+        output: count(tokens.output),
+        reasoning: count(tokens.reasoning),
+        cacheRead: count(cache.read),
+        cacheWrite: count(cache.write),
+    });
+}
+function errorOf(value, at) {
+    if (!isRecord(value))
+        return null;
+    const data = isRecord(value.data) ? value.data : {};
+    const name = str(value.name) ?? 'error';
+    return sessionError(name, str(data.message) ?? str(value.message) ?? name, at, count(data.statusCode));
+}
+function parse(json) {
+    if (typeof json !== 'string')
+        return null;
+    try {
+        const value = JSON.parse(json);
+        return isRecord(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function foldSession(db, ref, mode, builder) {
+    const session = db.prepare('SELECT id, parent_id, directory, time_created, time_updated FROM session WHERE id = ?').get(ref.nativeSessionId);
+    if (!session) {
+        builder.gap(`session ${ref.nativeSessionId} is not in the store`);
+        return;
+    }
+    builder.cwd = session.directory;
+    builder.parentNativeSessionId = session.parent_id ?? null;
+    builder.seen(session.time_created);
+    const messages = db.prepare('SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created, id').all(ref.nativeSessionId);
+    const partsOf = db.prepare('SELECT id, time_created, data FROM part WHERE message_id = ? ORDER BY id');
+    let unparsed = 0;
+    let aborted = null;
+    for (const row of messages) {
+        const data = parse(row.data);
+        if (data === null) {
+            unparsed += 1;
+            continue;
+        }
+        const time = isRecord(data.time) ? data.time : {};
+        const at = builder.seen(time.created ?? row.time_created);
+        builder.seen(time.completed);
+        const parts = [];
+        for (const partRow of partsOf.iterate(row.id)) {
+            const part = parse(partRow.data);
+            if (part === null)
+                unparsed += 1;
+            else
+                parts.push({ id: partRow.id, data: part });
+        }
+        if (data.role === 'user') {
+            aborted = null;
+            const content = [];
+            let synthetic = parts.length > 0;
+            for (const { data: part } of parts) {
+                if (part.type === 'text' && typeof part.text === 'string') {
+                    content.push({ type: 'text', text: part.text });
+                    if (part.synthetic !== true)
+                        synthetic = false;
+                }
+                else if (part.type === 'file') {
+                    content.push({ type: 'attachment', mediaType: str(part.mime) ?? 'file', ref: str(part.filename) ?? str(part.url)?.slice(0, 200) ?? row.id });
+                    synthetic = false;
+                }
+            }
+            builder.message({ id: row.id, role: 'user', actor: synthetic ? 'injected' : builder.parentNativeSessionId ? 'subagent-spawn' : 'human', at, modelCallId: null, parts: content });
+            continue;
+        }
+        if (data.role !== 'assistant')
+            continue;
+        const provider = str(data.providerID);
+        const model = str(data.modelID);
+        const messageError = errorOf(data.error, isoTime(time.completed) ?? at);
+        let step = null;
+        let steps = 0;
+        const startStep = (stepAt) => {
+            steps += 1;
+            const id = `${row.id}:step:${steps}`;
+            const call = builder.modelCall({ id, at: stepAt, provider, servedModel: model, requestedModel: model, usage: null, costUsd: null, stopReason: null, error: null });
+            builder.message({ id, role: 'assistant', actor: 'agent', at: stepAt, modelCallId: id, parts: [] });
+            return { call, messageId: id };
+        };
+        for (const { id: partId, data: part } of parts) {
+            const partTime = isRecord(part.time) ? part.time : {};
+            const partAt = builder.seen(partTime.start) ?? at;
+            switch (part.type) {
+                case 'step-start':
+                    step = startStep(partAt);
+                    break;
+                case 'step-finish': {
+                    const current = step ?? startStep(partAt);
+                    current.call.usage = usageOf(part.tokens);
+                    current.call.costUsd = count(part.cost);
+                    current.call.stopReason = str(part.reason);
+                    step = null;
+                    break;
+                }
+                case 'text':
+                    if (typeof part.text === 'string') {
+                        const current = step ?? (step = startStep(partAt));
+                        builder.appendParts(current.messageId, [{ type: 'text', text: part.text }]);
+                    }
+                    break;
+                case 'reasoning':
+                    if (typeof part.text === 'string') {
+                        const current = step ?? (step = startStep(partAt));
+                        builder.appendParts(current.messageId, [{ type: 'reasoning', text: part.text, redacted: false }]);
+                    }
+                    break;
+                case 'tool': {
+                    const current = step ?? (step = startStep(partAt));
+                    const callId = str(part.callID) ?? partId;
+                    const state = isRecord(part.state) ? part.state : {};
+                    const stateTime = isRecord(state.time) ? state.time : {};
+                    builder.appendParts(current.messageId, [{ type: 'tool-call', toolCallId: callId }]);
+                    builder.toolCall({ id: callId, name: str(part.tool) ?? 'unknown', input: state.input ?? null, inputText: null, at: isoTime(stateTime.start) ?? partAt, messageId: current.messageId });
+                    if (state.status === 'completed' || state.status === 'error') {
+                        const endAt = builder.seen(stateTime.end) ?? partAt;
+                        const output = state.status === 'error' ? (state.error ?? null) : (state.output ?? null);
+                        const resultId = `${callId}:result`;
+                        builder.message({ id: resultId, role: 'tool', actor: 'tool-result', at: endAt, modelCallId: null, parts: [{ type: 'tool-result', toolCallId: callId }] });
+                        builder.toolResult(callId, { output, text: typeof output === 'string' ? output : null, isError: state.status === 'error', at: endAt, messageId: resultId, details: state.metadata ?? null });
+                    }
+                    const metadata = isRecord(state.metadata) ? state.metadata : {};
+                    const childId = str(metadata.sessionId);
+                    if (childId)
+                        builder.child(childId, callId);
+                    break;
+                }
+                case 'retry': {
+                    // A failed request OpenCode retried: a model call that returned no answer.
+                    builder.modelCall({ id: `${row.id}:retry:${partId}`, at: isoTime(partTime.created) ?? partAt, provider, servedModel: null, requestedModel: model, usage: null, costUsd: null, stopReason: null, error: errorOf(part.error, partAt) ?? sessionError('retry', 'retried request', partAt) });
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        if (steps === 0) {
+            // No response step was recorded: the request failed or the process stopped first.
+            builder.modelCall({ id: `${row.id}:request`, at, provider: messageError ? null : provider, servedModel: messageError ? null : model, requestedModel: model, usage: usageOf(data.tokens), costUsd: count(data.cost), stopReason: str(data.finish), error: messageError });
+            if (messageError)
+                builder.message({ id: row.id, role: 'assistant', actor: 'injected', at, modelCallId: `${row.id}:request`, parts: [{ type: 'text', text: messageError.message }] });
+        }
+        else if (messageError) {
+            const last = builder.modelCalls[builder.modelCalls.length - 1];
+            last.error = messageError;
+        }
+        aborted = messageError?.kind === 'MessageAbortedError' ? { at: messageError.at, error: messageError } : null;
+    }
+    const children = db.prepare('SELECT id FROM session WHERE parent_id = ? ORDER BY time_created, id').all(ref.nativeSessionId);
+    for (const child of children)
+        builder.child(child.id, null);
+    if (unparsed > 0)
+        builder.source({ path: `${ref.path}#session=${ref.nativeSessionId}`, sha256: '', bytes: 0, unparsed });
+    const last = builder.modelCalls[builder.modelCalls.length - 1];
+    if (aborted && last?.error?.kind === 'MessageAbortedError')
+        last.error = null;
+    builder.inferEnding(aborted ?? undefined);
+}
+async function fold(ref, mode, options) {
+    options.signal?.throwIfAborted();
+    const builder = new SessionBuilder(HARNESS, FORMAT, EVIDENCE[FORMAT].servedModel, mode, ref.nativeSessionId, ref.parentNativeSessionId);
+    await withSqliteCopy(ref.path, (db, sources) => {
+        for (const source of sources)
+            builder.source(source);
+        foldSession(db, ref, mode, builder);
+    });
+    if (ref.truncated)
+        builder.markTruncated(`${ref.path}: the store copy was cut short`);
+    return builder;
+}
+/** Every session in one store file, without opening the live store. */
+export async function opencodeSessionsInStore(path, home, opts = {}) {
+    const mtime = await mtimeMs(path);
+    const files = [path];
+    for (const suffix of ['-wal', '-shm'])
+        if ((await mtimeMs(`${path}${suffix}`)) > 0)
+            files.push(`${path}${suffix}`);
+    return withSqliteCopy(path, (db) => {
+        const rows = db.prepare('SELECT id, parent_id, directory, time_updated FROM session ORDER BY time_updated DESC').all();
+        return rows
+            .filter((row) => (!opts.nativeSessionId || row.id === opts.nativeSessionId)
+            && (!opts.cwd || row.directory.startsWith(opts.cwd))
+            && (!opts.sinceMs || row.time_updated >= opts.sinceMs))
+            .map((row) => ({ harness: HARNESS, format: FORMAT, nativeSessionId: row.id, path, files, home, cwd: row.directory, mtimeMs: row.time_updated || mtime, parentNativeSessionId: row.parent_id }));
+    });
+}
+export const opencodeReader = {
+    harness: HARNESS,
+    aliases: ['opencode-acp', 'opencode-cli'],
+    formats: [FORMAT],
+    stores: [STORE],
+    globs: { session: STORE.files[0] },
+    evidence: EVIDENCE[FORMAT],
+    async locate(home, opts = {}) {
+        const path = join(home, STORE.root, STORE.files[0]);
+        try {
+            return await opencodeSessionsInStore(path, home, opts);
+        }
+        catch (error) {
+            if (isMissing(error))
+                return [];
+            throw error;
+        }
+    },
+    async read(ref, opts = {}) {
+        return (await fold(ref, 'full', opts)).build();
+    },
+    async summarize(ref, opts = {}) {
+        return (await fold(ref, 'summary', opts)).summary();
+    },
+};

package/dist/formats/pi.d.ts

@@ -0,0 +1,8 @@
+import { SessionBuilder, type BuildMode } from '../builder.js';
+import type { HarnessSessionReader, ReadOptions, SessionRef } from '../schema.js';
+import { type RecordSource, type SourceStats } from '../source.js';
+import { type SessionFold } from './fold.js';
+export declare function createFold(ref: SessionRef, mode: BuildMode, stats: SourceStats): SessionFold;
+export declare function fold(ref: SessionRef, mode: BuildMode, options: ReadOptions, source?: RecordSource): Promise<SessionBuilder>;
+export declare const piReader: HarnessSessionReader;
+export declare function piRefForFile(path: string): SessionRef;

package/dist/formats/pi.js

@@ -0,0 +1,201 @@
+/**
+ * Pi: `~/.pi/agent/sessions/<encoded cwd>/<timestamp>_<session id>.jsonl`, one entry per line.
+ *
+ * The first entry is the `session` header (id, cwd). Conversation entries are `message` entries
+ * whose `message.role` is `user`, `assistant` or `toolResult`. Each assistant message records the
+ * provider and model it was sent to, its usage (input, output and cache counts are disjoint, with a
+ * cost breakdown), its stop reason and, on a failure, the provider's error message. Tool calls are
+ * `toolCall` blocks inside assistant content, answered by `toolResult` messages keyed by
+ * `toolCallId`. Entries form a tree through `parentId`; branches share one file.
+ */
+import { basename, join } from 'node:path';
+import { SessionBuilder, count, isRecord, sessionError, str, textOf, usageOrNull } from '../builder.js';
+import { fileRecords } from '../source.js';
+import { runFold } from './fold.js';
+import { EVIDENCE, STORES, mtimeMs, storeGlob, walkFiles } from '../stores.js';
+import { headRecord } from './head.js';
+const FORMAT = 'pi.session-jsonl';
+const STORE = STORES[FORMAT];
+const HARNESS = 'pi';
+function usageOf(value) {
+    if (!isRecord(value))
+        return { usage: null, cost: null };
+    const cost = isRecord(value.cost) ? count(value.cost.total) : null;
+    return {
+        usage: usageOrNull({
+            input: count(value.input),
+            output: count(value.output),
+            reasoning: count(value.reasoning),
+            cacheRead: count(value.cacheRead),
+            cacheWrite: count(value.cacheWrite),
+        }),
+        cost,
+    };
+}
+function contentParts(content, ref) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    const parts = [];
+    if (!Array.isArray(content))
+        return parts;
+    for (const block of content) {
+        if (!isRecord(block))
+            continue;
+        if (block.type === 'text' && typeof block.text === 'string')
+            parts.push({ type: 'text', text: block.text });
+        else if (block.type === 'thinking')
+            parts.push({ type: 'reasoning', text: str(block.thinking) ?? '', redacted: block.redacted === true });
+        else if (block.type === 'image')
+            parts.push({ type: 'attachment', mediaType: str(block.mimeType) ?? 'image', ref: `inline:${ref}` });
+    }
+    return parts;
+}
+/** Session ids are the part of the file name after the timestamp: `<timestamp>_<id>.jsonl`. */
+function idFromName(path) {
+    return basename(path, '.jsonl').replace(/^[\dTZ.:-]+_/u, '');
+}
+export function createFold(ref, mode, stats) {
+    const builder = new SessionBuilder(HARNESS, FORMAT, EVIDENCE[FORMAT].servedModel, mode, ref.nativeSessionId, ref.parentNativeSessionId);
+    let previousId = null;
+    let branches = 0;
+    let compactions = 0;
+    let aborted = null;
+    const observe = (entry) => {
+        const entryAt = builder.seen(entry.timestamp);
+        const id = str(entry.id) ?? `${builder.nativeSessionId}:${stats.line}`;
+        const parentId = str(entry.parentId);
+        if (entry.type === 'session') {
+            if (typeof entry.id === 'string')
+                builder.nativeSessionId = entry.id;
+            builder.cwd = str(entry.cwd);
+            previousId = null;
+            return;
+        }
+        if (parentId !== null && previousId !== null && parentId !== previousId)
+            branches += 1;
+        previousId = id;
+        if (entry.type === 'compaction') {
+            compactions += 1;
+            if (typeof entry.summary === 'string') {
+                builder.message({ id, role: 'user', actor: 'injected', at: entryAt, modelCallId: null, parts: [{ type: 'text', text: entry.summary }] });
+            }
+            return;
+        }
+        if (entry.type !== 'message' || !isRecord(entry.message))
+            return;
+        const message = entry.message;
+        const at = entryAt ?? builder.seen(message.timestamp);
+        const role = str(message.role);
+        if (role === 'user') {
+            aborted = null;
+            builder.message({ id, role: 'user', actor: ref.parentNativeSessionId ? 'subagent-spawn' : 'human', at, modelCallId: null, parts: contentParts(message.content, id) });
+            return;
+        }
+        if (role === 'toolResult') {
+            const callId = str(message.toolCallId) ?? `${id}:result`;
+            builder.message({ id, role: 'tool', actor: 'tool-result', at, modelCallId: null, parts: [{ type: 'tool-result', toolCallId: callId }] });
+            const content = message.content;
+            const single = Array.isArray(content) && content.length === 1 && isRecord(content[0]) && content[0].type === 'text';
+            builder.toolResult(callId, {
+                output: single ? content[0].text : (content ?? null),
+                text: textOf(content),
+                isError: message.isError === true,
+                at,
+                name: str(message.toolName) ?? undefined,
+                messageId: id,
+                details: message.details ?? null,
+            });
+            return;
+        }
+        if (role === 'assistant') {
+            const stopReason = str(message.stopReason);
+            const errorText = str(message.errorMessage);
+            const failed = stopReason === 'error';
+            const { usage, cost } = usageOf(message.usage);
+            // A failed request returned no response, so no model served it; the model it was sent to
+            // stays in the profile and the request, not here.
+            builder.modelCall({
+                id,
+                at,
+                provider: failed ? null : str(message.provider),
+                // Pi 0.85 records the provider's own answer as responseModel; model is what it asked for.
+                servedModel: failed ? null : (str(message.responseModel) ?? str(message.model)),
+                requestedModel: str(message.model),
+                usage,
+                costUsd: cost,
+                stopReason,
+                error: failed ? sessionError('error', errorText ?? 'Pi assistant stopped with an error', at) : null,
+            });
+            const parts = contentParts(message.content, id);
+            const content = Array.isArray(message.content) ? message.content : [];
+            for (const block of content) {
+                if (!isRecord(block) || block.type !== 'toolCall')
+                    continue;
+                const callId = str(block.id) ?? `${id}:call:${parts.length}`;
+                parts.push({ type: 'tool-call', toolCallId: callId });
+                const input = block.arguments ?? block.input ?? null;
+                builder.toolCall({ id: callId, name: str(block.name) ?? 'tool', input, inputText: typeof input === 'string' ? input : null, at, messageId: id });
+            }
+            builder.message({ id, role: 'assistant', actor: failed ? 'injected' : 'agent', at, modelCallId: id, parts: failed && parts.length === 0 && errorText ? [{ type: 'text', text: errorText }] : parts });
+            aborted = stopReason === 'aborted' ? { at, message: errorText } : null;
+            return;
+        }
+        // Harness-injected messages (system prompts, extension messages, shell executions).
+        if (role === 'system' || role === 'custom' || role === 'bashExecution') {
+            builder.message({ id, role: role === 'system' ? 'system' : 'user', actor: 'injected', at, modelCallId: null, parts: contentParts(message.content ?? message.output, id) });
+        }
+    };
+    const finish = () => {
+        builder.source(stats);
+        if (branches > 0)
+            builder.gap(`${branches} entries continue an earlier entry rather than the previous one (the session branched); all branches are read in file order`);
+        if (compactions > 0)
+            builder.gap(`${compactions} compaction entries replaced earlier context`);
+        builder.inferEnding(aborted ? { at: aborted.at, error: aborted.message ? sessionError('aborted', aborted.message, aborted.at, null) : null } : undefined);
+        return builder;
+    };
+    return { builder, observe, finish };
+}
+export async function fold(ref, mode, options, source = fileRecords(ref.path, { strict: options.corruption === 'strict', signal: options.signal })) {
+    return runFold(createFold(ref, mode, source.stats), source);
+}
+async function locate(home, opts) {
+    const root = join(home, STORE.root);
+    const pattern = storeGlob(STORE.files[0], opts.nativeSessionId);
+    const refs = [];
+    for (const rel of await walkFiles(root)) {
+        if (!pattern.test(rel))
+            continue;
+        const path = join(root, rel);
+        const mtime = await mtimeMs(path);
+        if (opts.sinceMs && mtime < opts.sinceMs)
+            continue;
+        const header = await headRecord(path, (r) => r.type === 'session', 1);
+        const cwd = header ? str(header.cwd) : null;
+        if (opts.cwd && (cwd === null || !cwd.startsWith(opts.cwd)))
+            continue;
+        const id = (header && str(header.id)) ?? idFromName(rel);
+        if (opts.nativeSessionId && id !== opts.nativeSessionId && idFromName(rel) !== opts.nativeSessionId)
+            continue;
+        refs.push({ harness: HARNESS, format: FORMAT, nativeSessionId: id, path, files: [path], home, cwd, mtimeMs: mtime, parentNativeSessionId: null });
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+export const piReader = {
+    harness: HARNESS,
+    aliases: ['pi-coding-agent', 'pi-agent'],
+    formats: [FORMAT],
+    stores: [STORE],
+    globs: { session: STORE.files[0] },
+    evidence: EVIDENCE[FORMAT],
+    locate: (home, opts = {}) => locate(home, opts),
+    async read(ref, opts = {}) {
+        return (await fold(ref, 'full', opts)).build();
+    },
+    async summarize(ref, opts = {}) {
+        return (await fold(ref, 'summary', opts)).summary();
+    },
+};
+export function piRefForFile(path) {
+    return { harness: HARNESS, format: FORMAT, nativeSessionId: idFromName(path), path, files: [path], home: null, cwd: null, mtimeMs: 0, parentNativeSessionId: null };
+}