@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/acp/test/raw/sanitize.js

@@ -0,0 +1,344 @@
+/**
+ * Sanitise a real ACP capture into a committable raw-record fixture (Task 17d).
+ *
+ * Input: either the legacy capture spelling `{ms, dir: 'in'|'out'|'note'|'stderr'|…, msg}` (the
+ * `tmp/*.jsonl` captures) or the kit-stream spelling `{o, t, k, …}` that `scripts/acp-capture.mjs`
+ * now writes. Output: kit-stream records (`encodeStreamRecord`'s spelling), one per line —
+ * a synthetic `proc spawn` first (`spawnId: 'capture'`, pid 0), then `up` / `down` / `err`, and the
+ * capture's `proc exit` (stderr tail placeholdered) if it has one. `in` → `up`, `out` → `down`, `stderr` → one `err`
+ * per line, `ms` → `t`, `o` renumbered gap-free. The capture tool's own bookkeeping (`note`,
+ * `fatal`) is dropped: it is not wire traffic and it repeats prompt results.
+ *
+ * What is kept verbatim: every JSON-RPC structural field and the record order — `jsonrpc`, ids,
+ * methods, update kinds, tool kinds, statuses, stop reasons, option ids, mode / model / config
+ * values, versions and agent names (the processor and the live path branch on them), numbers and
+ * booleans, object keys, and line (chunk) boundaries.
+ *
+ * What is replaced:
+ * - every other string (prompt and message text, titles, commands, outputs, paths, descriptions,
+ *   stderr) by a placeholder of the same length and shape: letters → `x`, digits → `0`, `@` → `_`;
+ *   whitespace and punctuation stay, so line structure and length class survive;
+ * - id-like values (keys `id`, `uuid`, `…Id`, `…_id`, `…Ids`) token by token: a random-looking token
+ *   (≥ 6 chars with a digit) is mapped injectively to a synthetic one (UUIDs to synthetic UUIDs), so
+ *   every reference to the same id stays equal and distinct ids stay distinct;
+ * - in the strings kept verbatim (and in keys), defensively: home paths, user and host names, emails,
+ *   `sk-` / `ghp_` / `Bearer` tokens and long base64 / hex blobs.
+ *
+ * Deterministic: the same input and options always give the same output.
+ */
+/**
+ * Keys whose string values are structural vocabulary, kept anywhere (after the defensive scrub of
+ * {@link Scrubber.verbatim}). `name` / `value` are deliberately **not** here: they are kept only in
+ * the contexts listed in {@link VOCABULARY_CONTEXTS} (ACP also spells env vars and headers as
+ * `[{name, value}]`).
+ */
+export const VERBATIM_KEYS = new Set([
+    'jsonrpc', 'method', 'sessionUpdate', 'kind', 'status', 'type', 'subtype', 'state', 'stopReason', 'outcome',
+    'toolName', 'tool_name', 'version', 'category', 'currency', 'phase', 'presentation', 'provider',
+    'controlMethod', 'actions', 'capabilities', 'task_type', 'taskType', 'subagent_type', 'priority', 'role', 'mimeType',
+    'protocolVersion', 'transport', 'platform', 'architecture', 'source', 'mode', 'action',
+]);
+/** Vocabulary ids (enumerations an agent offers, not identities): kept, never id-mapped. */
+export const VOCABULARY_ID_KEYS = new Set(['optionId', 'modeId', 'currentModeId', 'configId']);
+/**
+ * Where `id` / `name` / `value` / `currentValue` / `resetValue` are vocabulary and kept: the agent's
+ * identity, config options (except model lists, see {@link MODEL_KEYS}), modes, auth methods.
+ * Everywhere else — permission option labels, tool names, subagent names, env, headers — they are
+ * placeholdered (or id-mapped).
+ */
+export const VOCABULARY_CONTEXTS = new Set(['agentInfo', 'configOptions', 'availableModes', 'authMethods']);
+const VOCABULARY_FIELDS = new Set(['id', 'name', 'value', 'currentValue', 'resetValue']);
+/** Anything below these keys is secret-bearing (MCP server launch, env, headers): every string is placeholdered. */
+export const SECRET_CONTEXTS = new Set(['mcpServers', 'env', 'headers']);
+const SECRET_KEY = /authorization|api[_-]?key|token|secret|password|cookie/i;
+/**
+ * Model identifiers fingerprint the user's provider setup: they are mapped (consistently, one table)
+ * to `model-NNNN`. Also mapped: the option values of a config option whose `category` or `id` is
+ * `model`, and a `session/set_config_option` value for such an option. Their labels are placeholdered.
+ */
+export const MODEL_KEYS = new Set(['modelId', 'currentModelId', 'model', 'resolvedModel']);
+/** Subtrees whose strings are all placeholdered, names included (installed skills / plugins fingerprint the user). */
+export const OPAQUE_CONTEXTS = new Set(['availableCommands']);
+const ID_KEY = /^(id|uuid)$|Id$|_id$|Ids$/;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Agent id prefixes kept in front of a mapped id (structure, not identity). */
+const ID_PREFIX = /^(toolu|srvtoolu|msg|call|exec|rs|req|run|task|agent|child)[_-]/;
+/** Letters → `x`, digits → `0`, `@` → `_`: same length, same whitespace and punctuation. */
+export function placeholder(text) {
+    return text.replace(/\p{L}|\p{M}/gu, 'x').replace(/\p{N}/gu, '0').replace(/@/g, '_');
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+const ROOT = { secret: false, opaque: false, vocabulary: false, modelOption: false };
+class Scrubber {
+    #ids = new Map();
+    #models = new Map();
+    /** Config option ids whose values are models (a later `set_config_option` maps its value the same way). */
+    #modelConfigs = new Set();
+    #words;
+    constructor(words) {
+        const unique = [...new Set(words.filter((w) => w.length >= 3))].sort((a, b) => b.length - a.length);
+        this.#words = unique.length > 0 ? new RegExp(unique.map(escapeRegExp).join('|'), 'gi') : null;
+    }
+    /** Kept strings: only the defensive patterns are replaced. */
+    verbatim(text) {
+        let out = text
+            .replace(/\/(Users|home)\/[^/\s"'`]+/g, '/u/user')
+            .replace(/-(Users|home)-[A-Za-z0-9._]+/g, '-u-user')
+            .replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+/g, '<email>')
+            .replace(/\bBearer\s+\S+/gi, 'Bearer <redacted>').replace(/\bBearer\b/gi, '<auth>')
+            .replace(/\bsk-[A-Za-z0-9_-]+/g, '<redacted>')
+            .replace(/\bgh[pousr]_[A-Za-z0-9]+/g, '<redacted>')
+            .replace(/[A-Za-z0-9+/_=-]{40,}/g, (blob) => `<blob:${blob.length}>`);
+        if (this.#words)
+            out = out.replace(this.#words, 'user');
+        return out;
+    }
+    /**
+     * An identity: every `:`-separated segment that is not a plain number is mapped injectively (with or
+     * without digits — `natureserver-session` is an identity too). A UUID maps to a synthetic UUID; a
+     * known agent prefix (`toolu_`, `exec-`, …) is kept in front.
+     */
+    id(text) {
+        if (UUID.test(text))
+            return this.#uuid(text);
+        return text.split(':').map((segment) => (segment === '' || /^\d+$/.test(segment) ? segment : this.#segment(segment))).join(':');
+    }
+    #segment(segment) {
+        if (UUID.test(segment))
+            return this.#uuid(segment);
+        const known = this.#ids.get(segment);
+        if (known)
+            return known;
+        const prefix = ID_PREFIX.exec(segment)?.[0] ?? '';
+        const mapped = `${prefix}id${String(this.#ids.size + 1).padStart(4, '0')}`;
+        this.#ids.set(segment, mapped);
+        return mapped;
+    }
+    #uuid(token) {
+        const key = token.toLowerCase();
+        const known = this.#ids.get(key);
+        if (known)
+            return known;
+        const mapped = `00000000-0000-4000-8000-${String(this.#ids.size + 1).padStart(12, '0')}`;
+        this.#ids.set(key, mapped);
+        return mapped;
+    }
+    model(text) {
+        const known = this.#models.get(text);
+        if (known)
+            return known;
+        const mapped = `model-${String(this.#models.size + 1).padStart(4, '0')}`;
+        this.#models.set(text, mapped);
+        return mapped;
+    }
+    /**
+     * A side-file row (a Qoder native transcript row the background terminal repair reads, Task 30a): identities are mapped with the
+     * capture's table (so the row still names the capture's session and tool calls), `cwd` is placeholdered exactly as the capture's
+     * `cwd` was (the repair compares them), and free text keeps its words — the repair parses it (`<task-notification>` and its
+     * tags) — with every capture identity inside it rewritten and only the defensive patterns of {@link verbatim} applied. Such text
+     * is model output: review it before committing.
+     */
+    side(value, key) {
+        if (typeof value === 'string') {
+            if (key === 'cwd')
+                return placeholder(value);
+            if (ID_KEY.test(key))
+                return this.id(value);
+            return this.verbatim(this.#knownIdsIn(value));
+        }
+        if (Array.isArray(value))
+            return value.map((item) => this.side(item, key));
+        if (value !== null && typeof value === 'object') {
+            const out = {};
+            for (const [k, v] of Object.entries(value))
+                out[this.verbatim(k)] = this.side(v, k);
+            return out;
+        }
+        return value;
+    }
+    /** Every identity of the table (≥ 6 chars, longest first) rewritten where it appears inside `text`. */
+    #knownIdsIn(text) {
+        const known = [...this.#ids.entries()].filter(([original]) => original.length >= 6).sort((a, b) => b[0].length - a[0].length);
+        let out = text;
+        for (const [original, mapped] of known)
+            out = out.split(original).join(mapped);
+        return out;
+    }
+    /** A string that is not vocabulary: an identity already seen elsewhere keeps its mapping, anything else is placeholdered. */
+    #opaque(text) {
+        if (text.length >= 6) {
+            const known = this.#ids.get(text) ?? this.#ids.get(text.toLowerCase());
+            if (known)
+                return known;
+        }
+        return placeholder(text);
+    }
+    #string(text, key, context) {
+        if (context.secret || SECRET_KEY.test(key) || context.opaque)
+            return placeholder(text);
+        if (MODEL_KEYS.has(key))
+            return this.model(text);
+        if (context.modelOption && (key === 'value' || key === 'currentValue' || key === 'resetValue'))
+            return this.model(text);
+        if (VOCABULARY_ID_KEYS.has(key))
+            return this.verbatim(text);
+        if (context.vocabulary && VOCABULARY_FIELDS.has(key) && !(context.modelOption && key === 'name'))
+            return this.verbatim(text);
+        if (ID_KEY.test(key))
+            return this.id(text);
+        if (VERBATIM_KEYS.has(key))
+            return this.verbatim(text);
+        return this.#opaque(text);
+    }
+    value(value, key, context = ROOT) {
+        if (typeof value === 'string')
+            return this.#string(value, key, context);
+        if (Array.isArray(value))
+            return value.map((item) => this.value(item, key, context));
+        if (value !== null && typeof value === 'object') {
+            const record = value;
+            let here = context;
+            // An entry of `configOptions` is reached as an array item, so its `key` is still `configOptions`.
+            if (context.vocabulary && key === 'configOptions' && (record.category === 'model' || record.id === 'model')) {
+                if (typeof record.id === 'string')
+                    this.#modelConfigs.add(record.id);
+                here = { ...context, modelOption: true };
+            }
+            // A `session/set_config_option` request: its `value` is the option's vocabulary (a model id for a model option).
+            if (typeof record.configId === 'string') {
+                here = { ...here, vocabulary: true, modelOption: this.#modelConfigs.has(record.configId) };
+            }
+            const out = {};
+            for (const [k, v] of Object.entries(record)) {
+                const child = {
+                    ...here,
+                    secret: here.secret || SECRET_CONTEXTS.has(k),
+                    opaque: here.opaque || OPAQUE_CONTEXTS.has(k),
+                    vocabulary: here.vocabulary || VOCABULARY_CONTEXTS.has(k),
+                };
+                out[this.verbatim(k)] = this.value(v, k, child);
+            }
+            return out;
+        }
+        return value;
+    }
+}
+/** Home-directory user names named anywhere in the capture (`/Users/x`, `/home/x`, `-Users-x-`). */
+export function detectWords(text) {
+    const words = new Set();
+    for (const match of text.matchAll(/[/-](?:Users|home)[/-]([A-Za-z0-9._]+)/g)) {
+        const word = match[1];
+        if (word.length >= 3 && !['user', 'shared', 'runner'].includes(word.toLowerCase()))
+            words.add(word);
+    }
+    return [...words];
+}
+function readItems(text) {
+    const items = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        const row = JSON.parse(line);
+        if ('dir' in row) {
+            const t = Number(row.ms ?? 0);
+            if (row.dir === 'in')
+                items.push({ t, k: 'up', msg: row.msg });
+            else if (row.dir === 'out')
+                items.push({ t, k: 'down', msg: row.msg });
+            else if (row.dir === 'in-unparsed')
+                items.push({ t, k: 'up', text: String(row.msg) });
+            else if (row.dir === 'stderr') {
+                for (const part of String(row.msg).split('\n'))
+                    if (part.trim())
+                        items.push({ t, k: 'err', text: part });
+            }
+            continue;
+        }
+        const t = Number(row.t ?? 0);
+        if (row.k === 'up' || row.k === 'down') {
+            const raw = String(row.l);
+            try {
+                items.push({ t, k: row.k, msg: JSON.parse(raw) });
+            }
+            catch {
+                items.push({ t, k: row.k, text: raw });
+            }
+        }
+        else if (row.k === 'err')
+            items.push({ t, k: 'err', text: String(row.l) });
+        else if (row.k === 'proc' && row.kind === 'exit') {
+            items.push({ t, k: 'exit', msg: { code: row.code ?? null, signal: row.signal ?? null, stderrTail: String(row.stderrTail ?? '') } });
+        }
+    }
+    return items;
+}
+/** Remove whole turns: each dropped `session/prompt` request, its response, and everything between. */
+function dropTurns(items, turns) {
+    if (turns.length === 0)
+        return items;
+    const drop = new Set();
+    let promptIndex = 0;
+    for (let i = 0; i < items.length; i += 1) {
+        const msg = items[i].msg;
+        if (items[i].k !== 'down' || msg?.method !== 'session/prompt')
+            continue;
+        promptIndex += 1;
+        if (!turns.includes(promptIndex))
+            continue;
+        let end = i + 1;
+        for (; end < items.length; end += 1) {
+            const reply = items[end].msg;
+            if (items[end].k === 'up' && reply && reply.method === undefined && reply.id === msg.id)
+                break;
+        }
+        for (let j = i; j <= Math.min(end, items.length - 1); j += 1)
+            drop.add(j);
+    }
+    return items.filter((_, index) => !drop.has(index));
+}
+/** The whole sanitiser: capture text in, kit-stream ndjson out. */
+export function sanitizeCapture(text, options = {}) {
+    return sanitizeWith(new Scrubber([...detectWords(text), ...(options.words ?? [])]), text, options);
+}
+/**
+ * A capture and its side file (ndjson rows, `scripts/acp-capture.mjs --side-home`), sanitised with one identity table so the rows
+ * keep naming the capture's session and tool calls ({@link Scrubber.side}). Returns both texts.
+ */
+export function sanitizeCaptureWithSide(text, sideText, options = {}) {
+    const scrub = new Scrubber([...detectWords(text), ...detectWords(sideText), ...(options.words ?? [])]);
+    const capture = sanitizeWith(scrub, text, options);
+    const parsed = sideText.split('\n').filter((line) => line.trim()).map((line) => JSON.parse(line));
+    // Pass 1 fills the identity table from the rows' own id fields, so text naming an id before its field still maps (as for the capture).
+    for (const row of parsed)
+        scrub.side(row, '');
+    const rows = parsed.map((row) => JSON.stringify(scrub.side(row, '')));
+    return { capture, side: rows.length > 0 ? `${rows.join('\n')}\n` : '' };
+}
+function sanitizeWith(scrub, text, options) {
+    const items = dropTurns(readItems(text), options.dropTurns ?? []);
+    const out = [];
+    const t0 = items[0]?.t ?? 0;
+    out.push(JSON.stringify({ o: 0, t: 0, k: 'proc', kind: 'spawn', spawnId: 'capture', pid: 0, pgid: 0, startTime: 0 }));
+    // Pass 1 only fills the id tables, so a string that equals an identity seen *later* (a subagent's
+    // `name` equal to its agent id) still maps to that identity in pass 2.
+    for (const item of items)
+        if (item.msg !== undefined && item.k !== 'exit')
+            scrub.value(item.msg, '');
+    for (const item of items) {
+        const o = out.length;
+        const t = Math.max(0, item.t - t0);
+        if (item.k === 'exit') {
+            const exit = item.msg;
+            out.push(JSON.stringify({ o, t, k: 'proc', kind: 'exit', code: exit.code, signal: exit.signal, stderrTail: placeholder(exit.stderrTail) }));
+        }
+        else if (item.k === 'err')
+            out.push(JSON.stringify({ o, t, k: 'err', l: placeholder(item.text ?? '') }));
+        else {
+            const l = item.msg !== undefined ? JSON.stringify(scrub.value(item.msg, '')) : placeholder(item.text ?? '');
+            out.push(JSON.stringify({ o, t, k: item.k, l }));
+        }
+    }
+    return `${out.join('\n')}\n`;
+}

package/dist/workstation/acp/test/raw/sources.js

@@ -0,0 +1,135 @@
+import { join } from 'node:path';
+import { decodeStreamRecord } from '../../processor/record.js';
+import { fixtureNames, RAW_DIR, readFixtureText, transduce } from './fixtures.js';
+/** Lines → kit-stream ndjson (a synthetic `proc spawn` first, `t` = position). */
+export function captureText(lines) {
+    const records = [JSON.stringify({ o: 0, t: 0, k: 'proc', kind: 'spawn', spawnId: 'capture', pid: 0, pgid: 0, startTime: 0 })];
+    lines.forEach((line, index) => records.push(JSON.stringify({ o: index + 1, t: index + 1, k: line.k, l: JSON.stringify(line.message) })));
+    return `${records.join('\n')}\n`;
+}
+export const up = (message) => ({ k: 'up', message });
+export const down = (message) => ({ k: 'down', message });
+export const update = (sessionId, value) => up({ jsonrpc: '2.0', method: 'session/update', params: { sessionId, update: value } });
+const SYNTHETIC_PROMPT = [{ type: 'text', text: 'go' }];
+const opening = (sessionId) => [
+    down({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: 1, clientCapabilities: {} } }),
+    up({ jsonrpc: '2.0', id: 1, result: { protocolVersion: 1, agentCapabilities: {}, authMethods: [] } }),
+    down({ jsonrpc: '2.0', id: 2, method: 'session/new', params: { cwd: '/work/synthetic', mcpServers: [] } }),
+    up({ jsonrpc: '2.0', id: 2, result: { sessionId } }),
+];
+const chunk = (sessionId, text, messageId) => update(sessionId, { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text }, ...(messageId ? { messageId } : {}) });
+/**
+ * Experiment 0.1's wire (`docs/superpowers/reports/2026-10-11-keepers-analysis/experiments/ordering/agent.cjs`
+ * with `perm`): a draft `subagent_state_update` between two chunks, then a tool call, its permission
+ * request and a chunk after it — the capture client answers the card after the turn's response.
+ */
+function experiment01() {
+    const S = 'S';
+    return { name: 'synthetic-experiment-0.1', kind: 'synthetic', text: captureText([
+            ...opening(S),
+            down({ jsonrpc: '2.0', id: 3, method: 'session/prompt', params: { sessionId: S, prompt: SYNTHETIC_PROMPT } }),
+            chunk(S, 'A', 'm1'),
+            update(S, { sessionUpdate: 'subagent_state_update', subagentSessionId: 'child-1', state: 'running' }),
+            chunk(S, 'B', 'm1'),
+            update(S, { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'Bash', kind: 'execute', status: 'pending' }),
+            up({ jsonrpc: '2.0', id: 99, method: 'session/request_permission', params: { sessionId: S, toolCall: { toolCallId: 't1' },
+                    options: [{ optionId: 'allow', name: 'Allow', kind: 'allow_once' }] } }),
+            chunk(S, 'C', 'm2'),
+            up({ jsonrpc: '2.0', id: 3, result: { stopReason: 'end_turn' } }),
+            down({ jsonrpc: '2.0', id: 99, result: { outcome: { outcome: 'selected', optionId: 'allow' } } }),
+        ]) };
+}
+/** A chunk with no `messageId` after a turn's response, then the next prompt (17b's out-of-turn rule). */
+function outOfTurnThenPrompt() {
+    const S = 'S';
+    return { name: 'synthetic-out-of-turn-then-prompt', kind: 'synthetic', text: captureText([
+            ...opening(S),
+            down({ jsonrpc: '2.0', id: 3, method: 'session/prompt', params: { sessionId: S, prompt: SYNTHETIC_PROMPT } }),
+            chunk(S, 'first answer'),
+            up({ jsonrpc: '2.0', id: 3, result: { stopReason: 'end_turn' } }),
+            chunk(S, 'late words'),
+            down({ jsonrpc: '2.0', id: 4, method: 'session/prompt', params: { sessionId: S, prompt: SYNTHETIC_PROMPT } }),
+            chunk(S, 'second answer'),
+            up({ jsonrpc: '2.0', id: 4, result: { stopReason: 'end_turn' } }),
+        ]) };
+}
+/**
+ * An interrupt mid-turn: a chunk, a tool call and its permission card are out, then the client cancels
+ * (`session/cancel`, the card answered `cancelled` by the interrupt itself) and the agent ends the
+ * prompt with `stopReason: cancelled`.
+ */
+function interruptMidTurn() {
+    const S = 'S';
+    return { name: 'synthetic-interrupt', kind: 'synthetic', text: captureText([
+            ...opening(S),
+            down({ jsonrpc: '2.0', id: 3, method: 'session/prompt', params: { sessionId: S, prompt: SYNTHETIC_PROMPT } }),
+            chunk(S, 'working on it', 'm1'),
+            update(S, { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'Bash', kind: 'execute', status: 'pending' }),
+            up({ jsonrpc: '2.0', id: 7, method: 'session/request_permission', params: { sessionId: S, toolCall: { toolCallId: 't1' },
+                    options: [{ optionId: 'allow', name: 'Allow', kind: 'allow_once' }, { optionId: 'reject', name: 'Reject', kind: 'reject_once' }] } }),
+            down({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId: S } }),
+            down({ jsonrpc: '2.0', id: 7, result: { outcome: { outcome: 'cancelled' } } }),
+            update(S, { sessionUpdate: 'tool_call_update', toolCallId: 't1', status: 'failed' }),
+            up({ jsonrpc: '2.0', id: 3, result: { stopReason: 'cancelled' } }),
+        ]) };
+}
+/**
+ * T19 prerequisite: a `session/load` — the agent replays an earlier conversation (a user message, an
+ * assistant message across two chunks, a thought, a finished tool call) and answers with modes; the
+ * client then sets a mode, an `available_commands_update` arrives after that (after the load response,
+ * so live on both paths), and one turn runs on the loaded session.
+ */
+function loadThenPrompt() {
+    const S = 'S-loaded';
+    return { name: 'synthetic-load', kind: 'synthetic', text: captureText([
+            down({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: 1, clientCapabilities: {} } }),
+            up({ jsonrpc: '2.0', id: 1, result: { protocolVersion: 1, agentCapabilities: { loadSession: true }, authMethods: [] } }),
+            down({ jsonrpc: '2.0', id: 2, method: 'session/load', params: { sessionId: S, cwd: '/work/synthetic', mcpServers: [] } }),
+            update(S, { sessionUpdate: 'user_message_chunk', content: { type: 'text', text: 'earlier question' } }),
+            chunk(S, 'earlier ', 'h1'),
+            chunk(S, 'answer', 'h1'),
+            update(S, { sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: 'thinking it over' } }),
+            update(S, { sessionUpdate: 'tool_call', toolCallId: 'h-t1', title: 'Read', kind: 'read', status: 'completed' }),
+            chunk(S, 'second earlier answer', 'h2'),
+            up({ jsonrpc: '2.0', id: 2, result: { modes: { currentModeId: 'default', availableModes: [
+                            { id: 'default', name: 'Default' }, { id: 'plan', name: 'Plan' }
+                        ] } } }),
+            down({ jsonrpc: '2.0', id: 3, method: 'session/set_mode', params: { sessionId: S, modeId: 'plan' } }),
+            up({ jsonrpc: '2.0', id: 3, result: {} }),
+            update(S, { sessionUpdate: 'available_commands_update', availableCommands: [{ name: 'xxxx', description: 'xxxxxxx' }] }),
+            down({ jsonrpc: '2.0', id: 4, method: 'session/prompt', params: { sessionId: S, prompt: SYNTHETIC_PROMPT } }),
+            chunk(S, 'live answer', 'm1'),
+            up({ jsonrpc: '2.0', id: 4, result: { stopReason: 'end_turn' } }),
+        ]) };
+}
+/**
+ * T19 prerequisite: a cached `session/resume` (an adapter advertising
+ * `sessionCapabilities.resume`) — no history, a config snapshot on the response, then one turn.
+ */
+function resumeThenPrompt() {
+    const S = 'S-resumed';
+    return { name: 'synthetic-resume', kind: 'synthetic', text: captureText([
+            down({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: 1, clientCapabilities: {} } }),
+            up({ jsonrpc: '2.0', id: 1, result: { protocolVersion: 1, agentCapabilities: { loadSession: true, sessionCapabilities: { resume: {} } },
+                    authMethods: [], agentInfo: { name: '@agentclientprotocol/claude-agent-acp', version: '1.0.0' } } }),
+            down({ jsonrpc: '2.0', id: 2, method: 'session/resume', params: { sessionId: S, cwd: '/work/synthetic', mcpServers: [] } }),
+            up({ jsonrpc: '2.0', id: 2, result: { configOptions: [{ id: 'model', name: 'Model', type: 'select', currentValue: 'model-0001',
+                            options: [{ value: 'model-0001', name: 'xxxxx' }, { value: 'model-0002', name: 'xxxxx' }] }] } }),
+            down({ jsonrpc: '2.0', id: 3, method: 'session/prompt', params: { sessionId: S, prompt: SYNTHETIC_PROMPT } }),
+            chunk(S, 'resumed answer', 'm1'),
+            up({ jsonrpc: '2.0', id: 3, result: { stopReason: 'end_turn' } }),
+        ]) };
+}
+export async function allSources() {
+    const real = fixtureNames().map((name) => ({
+        name: name.replace(/\.jsonl$/, ''), kind: 'real', text: readFixtureText(name), path: join(RAW_DIR, name),
+    }));
+    return [...real, experiment01(), outOfTurnThenPrompt(), interruptMidTurn(), loadThenPrompt(), resumeThenPrompt()];
+}
+export function captureRecords(source) {
+    return source.text.split('\n').filter((line) => line.trim()).map((line) => decodeStreamRecord(JSON.parse(line)));
+}
+export async function buildLog(source, options = {}) {
+    const transduced = transduce(captureRecords(source), options);
+    return { ...transduced, records: transduced.session.log.read(0), source, sideNotes: 0 };
+}