@platless/axom-cli 0.1.0 → 0.5.9

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 };
+}

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

@@ -0,0 +1,125 @@
+/**
+ * Qoder captures for Task 17d, built from the update-level Qoder fixtures — there is **no raw Qoder
+ * capture** (ruling: a real one is the T23 real-machine gate's).
+ *
+ * Each one is wrapped into the same raw-record spelling as a sanitised real capture, as the wire
+ * `qoder-cli` / the SDK adapter would put it between a client and itself: `initialize` (the adapter's
+ * identity), `session/new`, one `session/prompt`, the fixture's `session/update` lines, the prompt's
+ * response. Side-channel inputs (the root transcript rows the background terminal repair reads) are
+ * returned beside the capture: the live path reads them from a history home, the processor gets them
+ * as `qoder_side` notes from the daemon's reader.
+ *
+ * Sources: `acp/test/qoder-parallel-foreground.json`, `acp/test/qoder-delegation.json` (the `live`
+ * phase of both probes), `acp/test/qoder-background-terminal.json` (updates + native rows, plus a
+ * variant whose result is large enough to be chunked into several notes), and
+ * `qoderAdapter/fixtures/native-events.json` through the real SDK adapter `QoderMessageMapper` and
+ * `PermissionBridge` (SDK callback cards).
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { QoderMessageMapper } from '../../../qoderAdapter/mapper.js';
+import { PermissionBridge } from '../../../qoderAdapter/permissions.js';
+import { QODER_PROFILE } from '../../processor/test/fixtureLog.js';
+const json = (path) => JSON.parse(readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8'));
+export const CERTIFIED_QODER = { name: 'qoder-cli', version: '1.1.61' };
+export const QODER_SDK = { name: 'axom-qoder-sdk', version: '1.0.50' };
+/** 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 } });
+/** initialize → session/new → (between) → prompt → updates → response. */
+function oneTurn(options) {
+    return 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: [],
+                agentInfo: options.agentInfo, ...(options.initializeMeta ? { _meta: options.initializeMeta } : {}) } }),
+        down({ jsonrpc: '2.0', id: 2, method: 'session/new', params: { cwd: options.cwd, mcpServers: [] } }),
+        up({ jsonrpc: '2.0', id: 2, result: { sessionId: options.sessionId } }),
+        ...(options.afterOpen ?? []),
+        down({ jsonrpc: '2.0', id: 3, method: 'session/prompt', params: { sessionId: options.sessionId, prompt: [{ type: 'text', text: 'xxxxx' }] } }),
+        ...options.updates.map((value) => update(options.sessionId, value)),
+        ...(options.inTurn ?? []),
+        up({ jsonrpc: '2.0', id: 3, result: { stopReason: options.stopReason ?? 'end_turn' } }),
+    ]);
+}
+function parallelForeground() {
+    const fixture = json('../qoder-parallel-foreground.json');
+    const sessionId = 'qoder-root';
+    const cwd = '/work/baseline';
+    return { name: 'qoder-parallel-foreground', sessionId, cwd,
+        text: oneTurn({ agentInfo: CERTIFIED_QODER, sessionId, cwd, updates: fixture.updates }) };
+}
+function delegationProbes() {
+    const fixture = json('../qoder-delegation.json');
+    return fixture.probes.map((probe) => {
+        const sessionId = probe.events[0].sessionId;
+        const cwd = '/work/delegation';
+        return { name: `qoder-delegation-${probe.name}`, sessionId, cwd, text: oneTurn({ agentInfo: CERTIFIED_QODER, sessionId, cwd,
+                updates: probe.events.filter((event) => event.phase === 'live').map((event) => event.update) }) };
+    });
+}
+function backgroundTerminal(large) {
+    const fixture = json('../qoder-background-terminal.json');
+    // The large variant: task B's result grows to ~96 KiB (under the 128 KiB result cap, over one
+    // 64 KiB note), so its `terminal` fact reaches the processor as several `qoder_side` chunks.
+    const rows = large
+        ? fixture.nativeRows.map((row) => JSON.parse(JSON.stringify(row).replace('QODER_TERMINAL_20261003_B_DONE', `QODER_TERMINAL_20261003_B_DONE ${'0123456789abcdef'.repeat(6 * 1024)}`)))
+        : fixture.nativeRows;
+    return { name: large ? 'qoder-background-terminal-large' : 'qoder-background-terminal', sessionId: fixture.nativeSessionId, cwd: fixture.cwd,
+        nativeRows: rows, text: oneTurn({ agentInfo: CERTIFIED_QODER, sessionId: fixture.nativeSessionId, cwd: fixture.cwd, updates: fixture.updates }) };
+}
+/**
+ * The SDK adapter's callback cards: `native-events.json`'s two child tool calls mapped by the real
+ * `QoderMessageMapper`, and one permission request per child raised through the real
+ * `PermissionBridge` (its random request id replaced by a fixed UUID), answered allow / reject.
+ */
+async function sdkCards() {
+    const fixture = json('../../../qoderAdapter/fixtures/native-events.json');
+    const binding = { rootSessionId: fixture.rootSessionId, runtimeGeneration: fixture.runtimeGeneration };
+    const corrections = [];
+    const mapper = new QoderMessageMapper(binding, { correction: (value) => corrections.push(value) });
+    const updates = [];
+    const tools = fixture.hooks.filter((hook) => hook.event === 'tool');
+    for (const [index, hook] of tools.entries()) {
+        updates.push(...mapper.map({ type: 'assistant', session_id: fixture.rootSessionId, uuid: `assistant-${index}`, parent_tool_use_id: null,
+            message: { role: 'assistant', content: [{ type: 'tool_use', id: hook.toolUseId, name: 'Edit', input: { path: '/work/sdk/fixture.txt' } }] } }, `run-${hook.agentId}`));
+        mapper.observe({ ...binding, toolUseId: hook.toolUseId, agentId: hook.agentId, launchingToolUseId: hook.launchingToolUseId });
+    }
+    updates.push(...corrections);
+    mapper.dispose();
+    const requests = [];
+    const bridge = new PermissionBridge({ ...binding, request: async (request) => {
+            requests.push(request);
+            return { outcome: { outcome: 'cancelled' } };
+        } });
+    for (const hook of tools) {
+        await bridge.canUseTool('Edit', { path: '/work/sdk/fixture.txt' }, {
+            toolUseID: hook.toolUseId, agentID: hook.agentId, signal: new AbortController().signal,
+            permissionOptions: [{ outcome: 'proceed_once', allowed: true }],
+        });
+    }
+    bridge.close();
+    const cards = [];
+    requests.forEach((request, index) => {
+        const meta = request.toolCall._meta.qoderSdk;
+        const fixed = { ...request, toolCall: { ...request.toolCall, _meta: { qoderSdk: { ...meta, requestId: `00000000-0000-4000-8000-${String(index + 1).padStart(12, '0')}` } } } };
+        cards.push(up({ jsonrpc: '2.0', id: 10 + index, method: 'session/request_permission', params: fixed }));
+        cards.push(down({ jsonrpc: '2.0', id: 10 + index, result: { outcome: { outcome: 'selected', optionId: index === 0 ? 'allow' : 'reject' } } }));
+    });
+    const sdkProfile = { ...QODER_PROFILE, mode: 'sdk-adapter' };
+    const sessionId = fixture.rootSessionId;
+    return { name: 'qoder-sdk-cards', sessionId, cwd: '/work/sdk', text: oneTurn({
+            agentInfo: QODER_SDK, initializeMeta: { qoderProfile: sdkProfile }, sessionId, cwd: '/work/sdk',
+            afterOpen: [up({ jsonrpc: '2.0', method: '_axom/qoder/profile', params: { sessionId, revision: 1,
+                        profile: { ...sdkProfile, rootSessionId: sessionId, runtimeGeneration: fixture.runtimeGeneration, rootConfirmed: true, initialized: true } } })],
+            updates, inTurn: cards,
+        }) };
+}
+export async function qoderCaptures() {
+    return [parallelForeground(), ...delegationProbes(), backgroundTerminal(false), backgroundTerminal(true), await sdkCards()];
+}