@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/acp/test/fakeAgent.js

@@ -113,6 +113,12 @@
 //                                               // with this message instead of succeeding — lets a
 //                                               // test prove a real agent-side rejection surfaces as
 //                                               // a rejected promise
+//     authenticateNotifications?: Array<{method: string, params: unknown}>,
+//                                              // sent as client notifications at the top of the
+//                                              // `authenticate` handler, before anything else —
+//                                              // models an agent that pushes a login URL as an
+//                                              // extension notification (`_codebuddy.ai/authUrl`)
+//                                              // rather than eliciting or printing it
 //     hangOnAuthenticate?: boolean,            // if true, `authenticate` never resolves — the shape
 //                                               // measured on a real agent that opens a browser and
 //                                               // waits for its callback (spec §6.2: antigravity's
@@ -348,6 +354,13 @@ async function main() {
             writeFileSync(config.authenticateSink, JSON.stringify(ctx.params));
         if (config.authenticateRejectsWith)
             throw new Error(config.authenticateRejectsWith);
+        // Extension notifications an agent pushes while answering `authenticate` (measured on the real
+        // CodeBuddy adapter: `_codebuddy.ai/authUrl` with `{authUrl, provider}` — a URL channel that
+        // is neither `elicitation/create` nor stderr). Sent before the reply, so a client that only
+        // listens from the reply onward still misses them, exactly like the real one.
+        for (const { method, params } of config.authenticateNotifications ?? []) {
+            await ctx.client.notify(method, params);
+        }
         if (config.createElicitationDuringAuthenticate) {
             // `requestId` is filled in here rather than in the config: a login elicitation is
             // request-scoped (ACP's `ElicitationRequestScope` — "tied to a specific JSON-RPC request

package/dist/workstation/acp/test/keeperWorld.js

@@ -0,0 +1,295 @@
+/**
+ * The shared world of the keeper-acp end-to-end tests (Task 21's adoption tests, Task 23's fault-injection gate): a temp config dir
+ * with a real keeper-acp (the built bundle in `dist/keepers`), a real adapter process (`scriptAgent.ts`, driven by marker files), and
+ * the server's half played by {@link FakeServer} (frames applied once per seq — the server's de-duplication — plus the answers it
+ * recorded). A daemon life is either in-process ({@link KeeperWorld.life}: its own keeper connection, AcpAgents, manager and
+ * TaskRegistry; "killing" it drops the connection without any goodbye) or a real process ({@link KeeperWorld.daemonProcess}:
+ * `daemonLife.ts` under vite-node, killed with SIGKILL). {@link KeeperWorld.dispose} kills every keeper, adapter and daemon process it
+ * started, by pid.
+ */
+import { spawn } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import path, { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { expect, vi } from 'vitest';
+import { killKeepersUnder, tempDir } from '../../../test/keeperKit.js';
+import { AcpKeeperClient } from '../../keepers/acp/client.js';
+import { computeBuildVersion } from '../../keepers/kit/buildVersion.js';
+import { readKeeperManifest } from '../../keepers/kit/bundle.js';
+import { keeperGen } from '../../keepers/kit/identity.js';
+import { KeeperLauncher } from '../../keepers/kit/launcher.js';
+import { acquireStartupLock, releaseStartupLock } from '../../keepers/kit/lock.js';
+import { AgentSessionManager } from '../../agentSessions.js';
+import { AGENT_WIRE_VERSION } from '../../protocol/agent.js';
+import { TaskRegistry } from '../../update/taskRegistry.js';
+import { AcpAgents } from '../acpAgents.js';
+import { keeperGenerations } from '../processor/transport/generations.js';
+import { KeeperTransport } from '../processor/transport/keeper.js';
+import { LocalTransport } from '../processor/transport/local.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+export const packageRoot = path.join(here, '..', '..', '..', '..');
+export const realDist = path.join(packageRoot, 'dist', 'keepers');
+export const SCRIPT_AGENT = join(here, 'scriptAgent.ts');
+export const DAEMON_LIFE = join(here, 'daemonLife.ts');
+export const BOOTSTRAP = "eval(require('node:fs').readFileSync(process.argv[1], 'utf8'))";
+export const touch = (dir, name) => writeFileSync(join(dir, name), '');
+export const agentPid = (dir) => Number(readFileSync(join(dir, 'pid'), 'utf8'));
+export const stdinLines = (dir) => existsSync(join(dir, 'stdin.jsonl')) ? readFileSync(join(dir, 'stdin.jsonl'), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l)) : [];
+export const downMethods = (records) => records.filter((r) => r.kind === 'down').map((r) => JSON.parse(r.line).method);
+/** The server's half: applies each seq once, in order (bridge_seq), per ref; remembers the answers it gave (spec §5.5.4). */
+export class FakeServer {
+    applied = new Map();
+    lastSeen = new Map();
+    received = [];
+    /** ref → requestId → outcome: what the user answered (the card's `answer`). */
+    answers = new Map();
+    apply = (frame) => {
+        this.received.push(frame);
+        if ((frame.t === 'agent_event' || frame.t === 'agent_turn_done') && typeof frame.seq === 'number') {
+            const last = this.lastSeen.get(frame.sessionRef) ?? 0;
+            if (frame.seq <= last)
+                return; // the server's de-duplication
+            this.lastSeen.set(frame.sessionRef, frame.seq);
+            const list = this.applied.get(frame.sessionRef) ?? [];
+            list.push(frame);
+            this.applied.set(frame.sessionRef, list);
+        }
+    };
+    timeline(ref) { return this.applied.get(ref) ?? []; }
+    seqs(ref) { return this.timeline(ref).map((frame) => frame.seq); }
+    turnDones(ref) { return this.timeline(ref).filter((frame) => frame.t === 'agent_turn_done'); }
+    texts(ref) {
+        return this.timeline(ref).filter((f) => f.t === 'agent_event' && f.eventName === 'agent_message_chunk')
+            .map((f) => (f.payload.content?.text ?? ''));
+    }
+    cards(ref) {
+        return this.timeline(ref).filter((f) => f.eventName === 'permission_request').map((f) => f.payload.requestId);
+    }
+    /** The user answers a card: recorded first (the server's item), then sent if a daemon is there. */
+    answer(ref, requestId, outcome) {
+        const answered = this.answers.get(ref) ?? new Map();
+        answered.set(requestId, outcome);
+        this.answers.set(ref, answered);
+        return { t: 'agent_answer', sessionRef: ref, requestId, outcome };
+    }
+    /** Task 22's resend: the answers this side recorded for cards a durable reopen still reports pending. */
+    resends(ref, opened) {
+        const answered = this.answers.get(ref);
+        return (opened.pendingRequestIds ?? []).filter((id) => answered?.has(id))
+            .map((id) => ({ t: 'agent_answer', sessionRef: ref, requestId: id, outcome: answered.get(id) }));
+    }
+}
+/** What the server's timeline says, without the ref: compared between two runs. */
+export const comparable = (frames) => frames.map(({ sessionRef: _ref, ...rest }) => rest);
+/** Seqs 1..n, no duplicate, no gap. */
+export function expectContiguous(seqs) {
+    expect(seqs).toEqual(Array.from({ length: seqs.length }, (_, k) => k + 1));
+}
+export class KeeperWorld {
+    configDir;
+    agentDir;
+    launcher;
+    lives = [];
+    processes = [];
+    extraDists = [];
+    agentDirs = [];
+    constructor(prefix) {
+        this.configDir = tempDir(prefix);
+        this.agentDir = this.newAgentDir(`${prefix}agent-`);
+        this.launcher = this.launcherFor(realDist);
+    }
+    /** These integrations require keeper hosting, rather than fallback after an unrelated lock-port collision. */
+    static async create(prefix, includeOlderGeneration = false) {
+        const current = keeperGen((await readKeeperManifest(join(realDist, 'acp'))).buildVersion);
+        for (let attempt = 0; attempt < 100; attempt++) {
+            const candidate = new this(prefix);
+            const locks = [];
+            try {
+                const generations = [current];
+                if (includeOlderGeneration)
+                    generations.push(candidate.olderGeneration().oldGen);
+                for (const gen of new Set(generations)) {
+                    locks.push(await acquireStartupLock(candidate.launcher.pathsFor('acp', gen).lockPort));
+                }
+                return candidate;
+            }
+            catch (error) {
+                await candidate.dispose();
+                if (error.code !== 'EADDRINUSE')
+                    throw error;
+            }
+            finally {
+                await Promise.all(locks.map(releaseStartupLock));
+            }
+        }
+        throw new Error('No unoccupied keeper-acp integration fixture identity');
+    }
+    launcherFor(distDir) {
+        return new KeeperLauncher({ configDir: this.configDir, workstationId: 'ws-t21', server: 'http://test.invalid', distDir, useSystemd: false,
+            startTimeoutMs: 20_000, umask: 0o022 });
+    }
+    /** Another adapter's marker directory (its pid is killed on dispose). */
+    newAgentDir(prefix = 'axom-t23-agent-') {
+        const dir = tempDir(prefix);
+        this.agentDirs.push(dir);
+        return dir;
+    }
+    scriptArgs(config, dir = this.agentDir) {
+        return ['-e', BOOTSTRAP, SCRIPT_AGENT, JSON.stringify({ dir, ...config })];
+    }
+    /** One daemon life: its own keeper-acp connection, AcpAgents (with the generations), manager and TaskRegistry, bound to `server`. */
+    life(server, over = {}) {
+        const use = over.launcher ?? this.launcher;
+        const real = new KeeperTransport(new AcpKeeperClient({ launcher: use }));
+        const keeper = (over.wrapKeeper ? over.wrapKeeper(real) : real);
+        const generations = keeperGenerations({ launcher: use, current: keeper, log: () => { } });
+        const local = new LocalTransport({ configDir: this.configDir });
+        const acp = new AcpAgents({ cacheDir: this.configDir, registry: { load: async () => [] }, transports: { keeper, local }, keeperGenerations: generations,
+            sessionStartTimeoutMs: 15_000, ...over.acp });
+        const tasks = new TaskRegistry();
+        const sent = [];
+        const manager = new AgentSessionManager(acp, null, join(this.configDir, 'agents'), tasks);
+        manager.bindSend((frame) => { sent.push(frame); server.apply(frame); }, AGENT_WIRE_VERSION);
+        let killed = false;
+        const result = {
+            keeper, generations, acp, tasks, manager, sent,
+            // kill -9 as keeper-acp sees it: the connection drops, nothing is detached, nothing is said.
+            kill() { if (killed)
+                return; killed = true; keeper.close(); generations.close(); void local.dispose(0); },
+        };
+        this.lives.push(result);
+        return result;
+    }
+    openFrame(ref, config, over = {}) {
+        return {
+            t: 'agent_open', id: `open-${ref}-${Math.random().toString(36).slice(2, 8)}`, sessionRef: ref, agentKey: 'script', bridge: 'script-acp',
+            cwd: this.configDir, shell: '/bin/sh', command: process.execPath, args: this.scriptArgs(config), ...over,
+        };
+    }
+    /** Opens `ref` on life `l` and waits for the reply. */
+    async openOn(l, ref, config, over = {}) {
+        const frame = this.openFrame(ref, config, over);
+        await l.manager.handleFrame(frame);
+        const reply = opened(l, frame.id)[0];
+        expect(reply, `no agent_opened for ${ref}`).toBeDefined();
+        expect(reply.ok, reply.error ?? '').toBe(true);
+        return reply;
+    }
+    /** The server reopens `ref` on life `l` after a reconnect: `agent_open` with its watermark, then Task 22's answer resend. */
+    async reopenOn(l, server, ref, config, over = {}) {
+        const reply = await this.openOn(l, ref, config, { resumeFromSeq: server.lastSeen.get(ref) ?? 0, ...over });
+        for (const frame of server.resends(ref, reply))
+            await l.manager.handleFrame(frame);
+        return reply;
+    }
+    /** Every raw record of `ref`, read over a connection of its own. */
+    async rawOf(ref, launcher = this.launcher) {
+        const reader = new KeeperTransport(new AcpKeeperClient({ launcher }));
+        try {
+            await reader.attach(ref);
+            const records = [];
+            const summary = (await reader.list()).find((s) => s.sessionKey === ref);
+            for (let at = summary.raw.first;;) {
+                const page = await reader.readRaw(ref, at);
+                if (page.length === 0)
+                    break;
+                records.push(...page);
+                at = page[page.length - 1].o + 1;
+            }
+            return records;
+        }
+        finally {
+            reader.close();
+        }
+    }
+    /** keeper-acp's listing of `ref`, over a connection of its own. */
+    async summaryOf(ref) {
+        const reader = new KeeperTransport(new AcpKeeperClient({ launcher: this.launcher }));
+        try {
+            return (await reader.list()).find((s) => s.sessionKey === ref);
+        }
+        finally {
+            reader.close();
+        }
+    }
+    /**
+     * A daemon life in a process of its own (`daemonLife.ts` under vite-node): it adopts what keeper-acp holds, then handles the frames
+     * it is given on stdin (one JSON per line; `{cmd:'forceBegin'}` runs a force update's `TaskRegistry.stopAll()`, `{cmd:'forceStop'}`
+     * also the restart path's detach, and exits). Every
+     * frame it sends lands in a file; its stderr is kept in `<configDir>/daemon-<n>.stderr` (the sentinel grep reads it).
+     */
+    daemonProcess(faults = {}) {
+        const n = this.processes.length + 1;
+        const framesOut = join(this.configDir, `frames-daemon-${n}.jsonl`);
+        const stderrFile = join(this.configDir, `daemon-${n}.stderr`);
+        const child = spawn(join(packageRoot, 'node_modules', '.bin', 'vite-node'), [DAEMON_LIFE,
+            JSON.stringify({ configDir: this.configDir, distDir: realDist, framesOut, faults })], { cwd: packageRoot, stdio: ['pipe', 'ignore', 'pipe'] });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); appendFileSync(stderrFile, chunk); });
+        const exited = new Promise((resolve) => child.once('exit', () => resolve()));
+        const result = {
+            child,
+            frames: () => existsSync(framesOut) ? readFileSync(framesOut, 'utf8').split('\n').filter(Boolean).map((line) => JSON.parse(line)) : [],
+            send: (frame) => { child.stdin.write(`${JSON.stringify(frame)}\n`); },
+            stderr: () => stderr,
+            kill: async () => { if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGKILL'); await exited; },
+            exited,
+        };
+        this.processes.push(result);
+        return result;
+    }
+    /** Opens `ref` in a daemon process and waits for its `agent_opened{ok}` (the server never prompts before it). */
+    async openIn(proc, frame) {
+        proc.send(frame);
+        let reply;
+        await vi.waitFor(() => {
+            expect(proc.child.exitCode, proc.stderr()).toBeNull();
+            reply = proc.frames().find((f) => f.t === 'agent_opened' && f.id === frame.id);
+            expect(reply).toBeDefined();
+        }, { timeout: 45_000, interval: 100 });
+        expect(reply.ok, reply.error ?? '').toBe(true);
+        return reply;
+    }
+    /** An "older build" of keeper-acp: the same bundle with one byte more (its own buildVersion, so its own generation). */
+    olderGeneration() {
+        const oldDist = tempDir('axom-t21-old-dist-');
+        this.extraDists.push(oldDist);
+        mkdirSync(join(oldDist, 'acp'), { recursive: true });
+        writeFileSync(join(oldDist, 'acp', 'keeper.mjs'), `${readFileSync(join(realDist, 'acp', 'keeper.mjs'), 'utf8')}\n// an older generation\n`);
+        const manifest = JSON.parse(readFileSync(join(realDist, 'acp', 'manifest.json'), 'utf8'));
+        const oldBuild = computeBuildVersion(join(oldDist, 'acp'));
+        writeFileSync(join(oldDist, 'acp', 'manifest.json'), JSON.stringify({ ...manifest, buildVersion: oldBuild }));
+        return { oldLauncher: this.launcherFor(oldDist), oldGen: keeperGen(oldBuild) };
+    }
+    /** Kills every daemon process, life, keeper-acp generation and adapter this world started (by pid); the directories stay. */
+    async stop() {
+        for (const proc of this.processes.splice(0))
+            await proc.kill().catch(() => { });
+        for (const life of this.lives.splice(0))
+            life.kill();
+        for (const gen of await this.launcher.liveGenerations('acp').catch(() => []))
+            await this.launcher.stop('acp', gen, 'force').catch(() => { });
+        for (const dir of this.agentDirs) {
+            const pidFile = join(dir, 'pid');
+            if (existsSync(pidFile)) {
+                try {
+                    process.kill(Number(readFileSync(pidFile, 'utf8')), 'SIGKILL');
+                }
+                catch { /* gone */ }
+            }
+        }
+    }
+    /** {@link stop}, then removes every directory (killing any keeper whose pid manifest is still under the config dir). */
+    async dispose() {
+        await this.stop();
+        for (const dist of this.extraDists.splice(0))
+            await rm(dist, { recursive: true, force: true });
+        for (const dir of this.agentDirs.splice(0))
+            await rm(dir, { recursive: true, force: true });
+        killKeepersUnder(this.configDir);
+    }
+}
+export const opened = (l, id) => l.sent.filter((frame) => frame.t === 'agent_opened' && (id === undefined || frame.id === id));
+export const liveSessionOf = (l, ref) => l.manager.sessions.get(ref)?.session;

package/dist/workstation/acp/test/memoryOutbox.js

@@ -0,0 +1,55 @@
+/**
+ * Test stand-in for a transport's outbox stream (Task 20): what `acp.outbox.append` / `acp.commit` do to one session's outbox,
+ * in memory — strictly increasing seqs, offsets, truncation through an offset with its `committedTail` watermark, checkpoints and
+ * raw truncation recorded. Kept per sessionRef by the manager tests' fake agents so a "reopen" reads back what an earlier life
+ * left, as `ProcessorSession.start` does from the real stream.
+ */
+import { SessionOutbox } from '../outbox.js';
+export class MemoryOutboxStream {
+    records = [];
+    next = 0;
+    committed = -1;
+    committedTail = null;
+    checkpoints = [];
+    rawTruncations = [];
+    commits = [];
+    /** Non-null: the next appends fail with it (a transport that went away). */
+    failAppend = null;
+    async append(entries) {
+        if (this.failAppend)
+            throw this.failAppend;
+        let last = this.records.at(-1)?.seq ?? this.committedTail?.seq ?? -Infinity;
+        for (const entry of entries) {
+            if (!(entry.seq > last))
+                throw new Error(`Outbox seq ${entry.seq} does not follow ${last}`);
+            last = entry.seq;
+        }
+        const first = this.next;
+        for (const entry of entries)
+            this.records.push({ o: this.next++, t: 0, seq: entry.seq, src: { ...entry.src }, frame: { ...entry.frame } });
+        return { first, last: this.next - 1 };
+    }
+    async commit(params) {
+        this.commits.push(params);
+        if (params.checkpoint)
+            this.checkpoints.push({ offset: params.checkpoint.offset, blob: String(params.checkpoint.blob) });
+        if (params.outbox) {
+            if (params.outbox.through >= this.next)
+                throw new Error('Outbox commit is beyond the outbox head');
+            this.committed = Math.max(this.committed, params.outbox.through);
+            this.committedTail = params.outbox.tail;
+            this.records = this.records.filter((r) => r.o > this.committed);
+        }
+        if (params.rawThrough !== undefined) {
+            const latest = this.checkpoints.at(-1)?.offset ?? -1;
+            if (params.rawThrough > latest)
+                throw new Error('Raw may only be truncated through the latest checkpoint');
+            this.rawTruncations.push(params.rawThrough);
+        }
+        return {};
+    }
+    /** What a new life reads back: the records past the watermark. */
+    leftovers() { return this.records.filter((r) => r.o > this.committed); }
+    /** A new life's {@link SessionOutbox} over this stream, as `ProcessorSession.start` builds it. */
+    outbox() { return new SessionOutbox(this, { leftovers: this.leftovers(), committedTail: this.committedTail }); }
+}

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

@@ -0,0 +1,196 @@
+/**
+ * Real-capture fixtures (Task 17d) and the transducer that turns one into a processor raw log.
+ *
+ * ## What a fixture is
+ *
+ * A sanitised capture (`sanitize.ts`) in the kit-stream spelling: the wire between an ACP adapter and
+ * the client that captured it — `scripts/acp-capture.mjs` or the legacy capture harness. The `down`
+ * lines are **that client's**, with its own JSON-RPC ids; nothing in a fixture depends on the
+ * processor's id scheme, so a fixture stays valid when the processor changes.
+ *
+ * ## The transducer
+ *
+ * {@link transduce} plays the daemon against a fixture: every client decision the capture shows
+ * becomes the note the daemon would write (`session/new` → `agent_session_open`, `session/prompt` →
+ * `agent_prompt`, `session/set_mode` → `agent_set_config_option`, a permission answer →
+ * `agent_answer`, `session/cancel` → `agent_interrupt`, anything else → `rpc.request`), the processor
+ * writes its own `down` lines through the real record loop (`processor/test/harness.ts` `run`), and the
+ * adapter's `up` lines follow in capture order — a response's id rewritten from the capture client's
+ * request to the processor's. The result is the raw log keeper-acp would have recorded for the same
+ * conversation: the input of the determinism, batching, checkpoint and equivalence tests.
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { permissionRequestId } from '../../permission.js';
+import { MemoryRawLog } from '../../processor/memoryLog.js';
+import { decodeStreamRecord } from '../../processor/record.js';
+import { createProcessor } from '../../processor/step.js';
+import { run } from '../../processor/test/harness.js';
+export const RAW_DIR = fileURLToPath(new URL('.', import.meta.url));
+/** The spawn id every transduced log uses (card ids are `perm:<SPAWN_ID>:<agent id>`). */
+export const SPAWN_ID = 'spawn-fixture';
+/** Every committed fixture, by discovery (never a hand-kept list). */
+export function fixtureNames() {
+    return readdirSync(RAW_DIR).filter((name) => name.endsWith('.jsonl')).sort();
+}
+export function readFixtureText(name) {
+    return readFileSync(join(RAW_DIR, name), 'utf8');
+}
+/** A fixture's records, decoded through the processor's own stream decoder. */
+export function loadFixture(name) {
+    return readFixtureText(name).split('\n').filter((line) => line.trim()).map((line) => decodeStreamRecord(JSON.parse(line)));
+}
+const isResponse = (m) => m.method === undefined && m.id !== undefined && ('result' in m || 'error' in m);
+/** Fold a capture into the processor raw log keeper-acp would have recorded for the same conversation. */
+export function transduce(capture, options = {}) {
+    let clock = 0;
+    const stdin = [];
+    const log = new MemoryRawLog(() => clock, (line) => stdin.push(line));
+    const session = { log, stdin, outbox: [], blocks: new Map() };
+    const processor = createProcessor();
+    const actions = [];
+    /** capture request id → processor request id (both as JSON). */
+    const ids = new Map();
+    /** capture request id → method, for the agent's requests (to classify the client's answers). */
+    const agentRequests = new Map();
+    let next = 0;
+    let turns = 0;
+    /** An interrupt was decided since the last prompt: the cards it cancelled are answered by the processor itself. */
+    let interrupted = false;
+    let configs = 0;
+    /** The capture id of a `session/load`: its response is where the daemon closes the history window. */
+    let loadRequest;
+    const fold = () => { next = run(processor, session, next); };
+    /** Append a note (and any entries that must precede its fold), fold, and return the requests the processor wrote for it. */
+    const decide = (entry, ...with_) => {
+        const before = stdin.length;
+        log.append(entry);
+        for (const extra of with_)
+            log.append(extra);
+        fold();
+        return stdin.slice(before).map((line) => JSON.parse(line)).filter((m) => m.method !== undefined && m.id !== undefined);
+    };
+    const map = (captured, written) => {
+        const own = written.find((m) => m.method === captured.method);
+        if (!own)
+            throw new Error(`transduce: the processor wrote no ${captured.method} for capture request ${JSON.stringify(captured.id)}`);
+        ids.set(JSON.stringify(captured.id), own.id);
+    };
+    for (const record of capture) {
+        clock = record.t;
+        if (record.kind === 'proc') {
+            if (record.proc.type === 'spawn') {
+                decide({ kind: 'proc', proc: { ...record.proc, spawnId: SPAWN_ID } });
+                if (options.launch !== undefined)
+                    decide({ kind: 'note', note: { type: 'agent_launch', launch: options.launch } });
+            }
+            else {
+                decide({ kind: 'proc', proc: record.proc });
+            }
+        }
+        else if (record.kind === 'err') {
+            decide({ kind: 'err', line: record.line });
+        }
+        else if (record.kind === 'note') {
+            decide({ kind: 'note', note: record.note });
+        }
+        else if (record.kind === 'up') {
+            let line = record.line;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch { /* a parse error is the processor's business */ }
+            if (message && isResponse(message)) {
+                const own = ids.get(JSON.stringify(message.id));
+                if (own !== undefined)
+                    line = JSON.stringify({ ...message, id: own });
+            }
+            else if (message && message.method !== undefined && message.id !== undefined) {
+                agentRequests.set(JSON.stringify(message.id), message.method);
+            }
+            decide({ kind: 'up', line });
+            // T19: the daemon writes `historyEnd` as soon as it has seen the load's result (the open result
+            // the processor reports on this record) — every update after it is live, never history.
+            if (message && isResponse(message) && loadRequest !== undefined && JSON.stringify(message.id) === loadRequest) {
+                loadRequest = undefined;
+                decide({ kind: 'note', note: { type: 'historyEnd' } });
+            }
+        }
+        else {
+            const message = JSON.parse(record.line);
+            const params = message.params ?? {};
+            if (message.method === 'initialize') {
+                const own = stdin.map((l) => JSON.parse(l)).filter((m) => m.method === 'initialize').at(-1);
+                if (!own)
+                    throw new Error('transduce: no initialize was written at spawn');
+                ids.set(JSON.stringify(message.id), own.id);
+            }
+            else if (message.method === 'session/new' || message.method === 'session/load' || message.method === 'session/resume') {
+                const mode = message.method.slice('session/'.length);
+                const mcpServers = Array.isArray(params.mcpServers) ? params.mcpServers : [];
+                actions.push({ kind: 'open', mode: mode, cwd: String(params.cwd), mcpServers,
+                    ...(mode !== 'new' ? { sessionId: String(params.sessionId) } : {}) });
+                if (mode === 'load')
+                    loadRequest = JSON.stringify(message.id);
+                map(message, decide({ kind: 'note', note: {
+                        type: 'agent_session_open', mode, cwd: params.cwd, mcpServers,
+                        ...(mode !== 'new' ? { sessionId: params.sessionId } : {}),
+                    } }, ...(mode === 'load' && options.afterLoadOpen ? options.afterLoadOpen(String(params.sessionId)) : [])));
+            }
+            else if (message.method === 'session/prompt') {
+                turns += 1;
+                const blocksRef = `blocks-${turns}`;
+                const blocks = params.prompt;
+                const platformTurnId = `turn-${turns}`;
+                session.blocks.set(blocksRef, blocks);
+                interrupted = false;
+                actions.push({ kind: 'prompt', blocks, platformTurnId });
+                map(message, decide({ kind: 'note', note: { type: 'agent_prompt', blocksRef, platformTurnId } }));
+            }
+            else if (message.method === 'session/set_mode' || message.method === 'session/set_config_option') {
+                configs += 1;
+                const configId = message.method === 'session/set_mode' ? 'acp:modes' : String(params.configId);
+                const value = message.method === 'session/set_mode' ? params.modeId : params.value;
+                actions.push({ kind: 'config', configId, value });
+                map(message, decide({ kind: 'note', note: { type: 'agent_set_config_option', id: `cfg-${configs}`, configId, value } }));
+            }
+            else if (message.method === 'session/cancel') {
+                actions.push({ kind: 'interrupt', o: record.o });
+                interrupted = true;
+                decide({ kind: 'note', note: { type: 'agent_interrupt' } });
+            }
+            else if (message.method !== undefined && message.id !== undefined) {
+                actions.push({ kind: 'rpc', method: message.method });
+                map(message, decide({ kind: 'note', note: { type: 'rpc.request', method: message.method, ...(message.params !== undefined ? { params } : {}) } }));
+            }
+            else if (isResponse(message)) {
+                const method = agentRequests.get(JSON.stringify(message.id));
+                if (method === 'session/request_permission') {
+                    const outcome = message.result?.outcome;
+                    const optionId = outcome?.outcome === 'selected' && typeof outcome.optionId === 'string' ? outcome.optionId : null;
+                    // A `cancelled` answer after the client's interrupt is the interrupt's own doing: the processor
+                    // answered that card on the `agent_interrupt` note, as `AcpSession.interrupt` does.
+                    const byInterrupt = optionId === null && interrupted;
+                    actions.push({ kind: 'answer', agentRequestId: message.id, optionId, byInterrupt });
+                    if (!byInterrupt) {
+                        decide({ kind: 'note', note: {
+                                type: 'agent_answer', requestId: permissionRequestId(SPAWN_ID, message.id), outcome: optionId ?? '__cancelled__',
+                            } });
+                    }
+                }
+                // Any other answer (the capture client refusing fs/terminal with -32601) the processor
+                // already gave itself on the request's own record.
+            }
+            else {
+                throw new Error(`transduce: no daemon decision for the capture's down line ${record.line.slice(0, 200)}`);
+            }
+        }
+        const extra = options.after?.get(record.o);
+        if (extra)
+            for (const entry of extra())
+                decide(entry);
+    }
+    return { session, records: log.read(0), frames: session.outbox, processor, actions };
+}