@platless/axom-cli 0.5.9 → 0.6.36

package/dist/runtime-deps/qoder-sdk/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "axom-qoder-sdk-runtime",
-  "version": "1.0.0",
-  "private": true,
-  "dependencies": {
-    "@qoder-ai/qoder-agent-sdk": "1.0.50"
-  }
-}

package/dist/workstation/acp/delegationMcp.js

@@ -1,24 +0,0 @@
-export function buildSessionMcpServers(userServers = [], lease) {
-    if (!lease)
-        return [...userServers];
-    const fail = () => { throw new Error('Delegation MCP configuration is unavailable'); };
-    let url;
-    try {
-        url = new URL(lease.url);
-    }
-    catch {
-        return fail();
-    }
-    if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash ||
-        url.pathname !== '/mcp/delegation' || !Number.isSafeInteger(lease.expiresAtEpochMs) ||
-        lease.expiresAtEpochMs <= Date.now() || userServers.some((server) => server.name === 'axom-delegation'))
-        return fail();
-    const headers = Object.entries(lease.headers);
-    if (headers.length !== 1 || headers[0][0].toLowerCase() !== 'authorization' ||
-        !/^Bearer [A-Za-z0-9_-]+$/.test(headers[0][1]))
-        return fail();
-    return [...userServers, {
-            type: 'http', name: 'axom-delegation', url: url.toString(),
-            headers: headers.map(([name, value]) => ({ name, value })),
-        }];
-}

package/dist/workstation/acp/processor/sideChannel.js

@@ -1,80 +0,0 @@
-/**
- * Side channels as notes (Task 17c, spec 2026-10-11 §5.4: "一切输入都进日志" — Qoder side-file events
- * included).
- *
- * Qoder's certified background terminal repair reads the agent's transcript files. The processor
- * never does: a file can change between the live run and a replay. The daemon reads them
- * (`qoderAdapter/backgroundTerminal.ts` `BackgroundSideNotes`, run by T19) and appends what it
- * derived as notes; the processor folds a fact only when it reads its note, with the pure fold
- * (`qoderAdapter/backgroundTerminalFold.ts`) over checkpointed state. A replay therefore gives the same
- * frames whatever the files say by then, or if they are gone.
- *
- * - `qoder_terminal_repair{nativeSessionId, restoreCalls?}` — the daemon enabled the repair where
- *   today's path calls `enableBackgroundTerminalRepair`: after the open note for a load (so the
- *   history is observed), after the open result for new/resume (`restoreCalls: true` on resume).
- *   Refused (`droppedNotes`) unless connected, the runtime is the certified one, the id is the root
- *   (or the session being loaded) and no repair is on yet. `includeProcess` follows the subwork
- *   boundary (`supportsSubworkMeta`), as `AcpSession` decides it.
- * - `qoder_side{fact}` / `qoder_side{chunk}` — one derived fact (or the consecutive chunks of one too
- *   large for a note). Its events — a child transcript row's, or the results a poll's end publishes —
- *   are emitted the way `AcpSession.emitEvent` emits the repair's (`updates.ts` `emitSessionEvent`).
- *   Facts are idempotent by their own fields (ids, row uuids), so a reader that restarted from the
- *   start of a file repeats nothing. Dropped while no repair is on or the connection is closed.
- */
-import { certifiedRuntime } from '../../qoderAdapter/foregroundOutput.js';
-import { supportsSubworkMeta } from '../../qoderAdapter/subwork.js';
-import { newTerminalRepairData, readSideNote, TerminalRepairFold } from '../../qoderAdapter/backgroundTerminalFold.js';
-import { connected } from './session.js';
-import { emitSessionEvent } from './updates.js';
-function agentInfo(state) {
-    return state.initialize.status === 'ready' ? state.initialize.facts.agentInfo : undefined;
-}
-/** `qoder_terminal_repair{nativeSessionId, restoreCalls?}`. */
-export function onRepairNote(state, note) {
-    const { nativeSessionId, restoreCalls } = note;
-    const root = state.rootSessionId ?? state.history?.rootSessionId ?? null;
-    if (!connected(state) || state.boundaries.repair !== null || !certifiedRuntime(agentInfo(state)) || typeof nativeSessionId !== 'string'
-        || nativeSessionId !== root || (restoreCalls !== undefined && typeof restoreCalls !== 'boolean')) {
-        state.diagnostics.droppedNotes += 1;
-        return;
-    }
-    state.boundaries.repair = newTerminalRepairData({
-        nativeSessionId, restoreCalls: restoreCalls === true, includeProcess: supportsSubworkMeta(agentInfo(state)),
-    });
-}
-/** `qoder_side{fact | chunk}`. */
-export function onSideNote(state, note, out) {
-    const repair = state.boundaries.repair;
-    if (repair === null || !connected(state)) {
-        state.diagnostics.droppedNotes += 1;
-        return;
-    }
-    const read = readSideNote(state.boundaries.sideChunk, note);
-    state.boundaries.sideChunk = read.buffer;
-    if (read.malformed) {
-        state.diagnostics.droppedNotes += 1;
-        return;
-    }
-    if (!read.fact)
-        return;
-    for (const event of new TerminalRepairFold(repair).apply(read.fact))
-        emitSessionEvent(state, out, event);
-}
-/** The connection or the session is gone: the repair stops (`BackgroundTerminalRepair.close`). */
-export function closeRepair(state) {
-    state.boundaries.repair = null;
-    state.boundaries.sideChunk = null;
-}
-/**
- * What the daemon's reader asks before it reads (`BackgroundSideNotes.poll(demand)`), answered from the
- * processor's **current** state, or `undefined` while no repair is on (stop the reader). The answers
- * only steer which files are read; what was read reaches the processor through the notes alone.
- */
-export function sideDemand(state) {
-    if (state.boundaries.repair === null)
-        return undefined;
-    return {
-        active: () => state.boundaries.repair !== null && new TerminalRepairFold(state.boundaries.repair).active(),
-        wantsProcess: (toolUseId) => state.boundaries.repair !== null && new TerminalRepairFold(state.boundaries.repair).wantsProcess(toolUseId),
-    };
-}

package/dist/workstation/acp/qoderStartup.js

@@ -1,45 +0,0 @@
-import { execFile } from 'node:child_process';
-import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { buildSessionMcpServers } from './delegationMcp.js';
-export const QODER_MANAGED_VERSION = '1.1.61';
-/** Owned by one process; the bearer is never an argument or environment variable. */
-export async function prepareQoderStartup(launch, lease, cwd, env, agentEnv) {
-    buildSessionMcpServers([], lease);
-    if (launch.args.some((arg) => arg === '--' || /^(--mcp-config|--strict-mcp-config|--settings|--setting-sources)(=|$)/.test(arg))) {
-        throw new Error('Managed Qoder startup has conflicting configuration arguments');
-    }
-    const version = await new Promise((resolve, reject) => {
-        execFile(launch.command, [...launch.args, '--version'], {
-            cwd, env: { ...process.env, ...launch.env, ...env, ...agentEnv },
-            encoding: 'utf8', timeout: 10_000, maxBuffer: 64 * 1024, windowsHide: true,
-        }, (error, stdout) => error ? reject(new Error('Managed Qoder version could not be verified')) : resolve(stdout.trim()));
-    });
-    if (version !== QODER_MANAGED_VERSION)
-        throw new Error('Managed Qoder version is not certified');
-    const dir = await mkdtemp(join(tmpdir(), 'axom-qoder-mcp-'));
-    let disposal;
-    const dispose = () => disposal ??= rm(dir, { recursive: true, force: true });
-    try {
-        await chmod(dir, 0o700);
-        const config = join(dir, 'mcp.json');
-        const authorization = Object.values(lease.headers)[0];
-        await writeFile(config, JSON.stringify({ mcpServers: {
-                'axom-delegation': { type: 'http', url: lease.url, headers: { Authorization: authorization } },
-            } }), { mode: 0o600, flag: 'wx' });
-        // Validate again after the asynchronous version probe; an expired lease cannot start a process.
-        buildSessionMcpServers([], lease);
-        return {
-            launch: { ...launch, args: [...launch.args, '--strict-mcp-config', '--mcp-config', config,
-                    '--setting-sources', '', '--settings', '{"autoMemoryEnabled":false}',
-                    '--disallowed-tools', 'Agent', '--cwd', cwd,
-                    '--append-system-prompt', 'Use the axom-delegation MCP tools for delegation. Native Agent execution is disabled in this session.'] },
-            secrets: [authorization, authorization.slice('Bearer '.length)], dir, dispose,
-        };
-    }
-    catch (error) {
-        await dispose();
-        throw error;
-    }
-}

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

@@ -1,125 +0,0 @@
-/**
- * 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()];
-}

package/dist/workstation/qoderAdapter/backgroundProcess.js

@@ -1,118 +0,0 @@
-/** Native Qoder does not forward background child SDK messages through ACP. Read only the
- * exact transcript named by a validated root launch receipt; never scan or infer ownership.
- *
- * Each accepted row's derived events go to `onRow` (with the row's `uuid`) when it is given — the
- * side-file reader records them as one `child` fact (`backgroundTerminalFold.ts`) — and otherwise one
- * by one to `emit`. */
-import { constants } from 'node:fs';
-import { open } from 'node:fs/promises';
-const object = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-const id = (value) => typeof value === 'string' && /^[a-zA-Z0-9_-]{1,160}$/.test(value);
-const LIMIT = 2 * 1024 * 1024;
-export class BackgroundProcess {
-    options;
-    offset = 0;
-    tail = Buffer.alloc(0);
-    skipLine = false;
-    seen = new Set();
-    tools = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    async poll() {
-        const file = await open(this.options.path, constants.O_RDONLY | constants.O_NOFOLLOW);
-        try {
-            const stat = await file.stat();
-            if (!stat.isFile())
-                return true;
-            if (stat.size < this.offset) {
-                this.offset = 0;
-                this.tail = Buffer.alloc(0);
-                this.skipLine = false;
-            }
-            const end = Math.min(stat.size, this.offset + 4 * 1024 * 1024);
-            while (this.offset < end) {
-                const chunk = Buffer.alloc(Math.min(64 * 1024, end - this.offset));
-                const { bytesRead } = await file.read(chunk, 0, chunk.length, this.offset);
-                if (!bytesRead)
-                    break;
-                this.offset += bytesRead;
-                this.consumeBytes(chunk.subarray(0, bytesRead));
-            }
-            return this.offset >= stat.size;
-        }
-        finally {
-            await file.close();
-        }
-    }
-    consumeBytes(bytes) {
-        let start = 0;
-        for (let end = bytes.indexOf(10); end >= 0; end = bytes.indexOf(10, start)) {
-            const part = bytes.subarray(start, end);
-            if (!this.skipLine && this.tail.length + part.length <= LIMIT) {
-                try {
-                    this.consume(object(JSON.parse(Buffer.concat([this.tail, part]).toString('utf8'))));
-                }
-                catch { /* not evidence */ }
-            }
-            this.tail = Buffer.alloc(0);
-            this.skipLine = false;
-            start = end + 1;
-        }
-        const part = bytes.subarray(start);
-        if (!this.skipLine && this.tail.length + part.length <= LIMIT)
-            this.tail = Buffer.concat([this.tail, part]);
-        else {
-            this.tail = Buffer.alloc(0);
-            this.skipLine = true;
-        }
-    }
-    consume(row) {
-        const o = this.options;
-        if (row.sessionId !== o.sessionId || row.cwd !== o.cwd || row.agentId !== o.agentId ||
-            row.parent_tool_use_id !== o.parentToolUseId || row.isSidechain !== true || row.version !== '1.1.61' ||
-            !id(row.uuid) || this.seen.has(row.uuid) || this.seen.size >= 4096)
-            return;
-        this.seen.add(row.uuid);
-        const content = object(row.message).content;
-        if (!Array.isArray(content))
-            return;
-        const events = [];
-        for (const block of content.map(object)) {
-            if (row.type === 'assistant' && block.type === 'tool_use' && id(block.id) && typeof block.name === 'string') {
-                if (this.tools.has(block.id) || this.tools.size >= 4096)
-                    continue;
-                const input = object(block.input);
-                this.tools.set(block.id, { name: block.name, input });
-                this.derive(events, 'tool_call', { toolCallId: block.id, name: block.name, title: block.name,
-                    kind: block.name === 'Read' ? 'read' : block.name === 'Bash' ? 'execute' : block.name === 'Agent' ? 'think' : 'other',
-                    rawInput: input, status: 'pending' }, block.name);
-            }
-            else if (row.type === 'user' && block.type === 'tool_result' && id(block.tool_use_id)) {
-                const tool = this.tools.get(block.tool_use_id);
-                if (!tool)
-                    continue;
-                const raw = row.toolUseResult ?? block.content;
-                const text = typeof block.content === 'string' ? block.content : JSON.stringify(block.content ?? '');
-                this.derive(events, 'tool_call_update', { toolCallId: block.tool_use_id, name: tool.name,
-                    status: block.is_error === true ? 'failed' : 'completed', rawOutput: raw,
-                    content: [{ type: 'content', content: { type: 'text', text } }] }, tool.name);
-            }
-            else if (row.type === 'assistant' && ((block.type === 'text' && typeof block.text === 'string') ||
-                (block.type === 'thinking' && typeof block.thinking === 'string'))) {
-                this.derive(events, block.type === 'text' ? 'agent_message_chunk' : 'agent_thought_chunk', { content: { type: 'text', text: block.type === 'text' ? block.text : block.thinking } });
-            }
-        }
-        if (this.options.onRow) {
-            if (events.length > 0)
-                this.options.onRow(row.uuid, events);
-        }
-        else
-            for (const event of events)
-                this.options.emit(event);
-    }
-    derive(events, eventName, payload, toolName) {
-        events.push({ eventName, payload: { ...payload, _meta: { qoder: { version: 1, source: 'correction',
-                        parentToolUseId: this.options.parentToolUseId, route: 'child', ...(toolName ? { toolName } : {}) } } } });
-    }
-}

package/dist/workstation/qoderAdapter/backgroundTerminal.js

@@ -1,193 +0,0 @@
-/** Qoder 1.1.61 drops native background task notifications from both live ACP and session/load.
- * This read-only compatibility boundary repairs only a known root Agent tool, never a session.
- * Lifecycle/removal contract: axom-patch/cli/qoder-background-terminal.md.
- *
- * The impure half (Task 17c): this file reads the side files; everything the repair decides is the
- * pure fold in `backgroundTerminalFold.ts`. {@link BackgroundSideNotes} is the daemon side of the deterministic
- * processor: a poll returns the facts as `qoder_side` note payloads for the raw log; the processor folds them only when it
- * reads those notes, so a replay never touches the files. (The old live path's in-process driver, `BackgroundTerminalRepair`,
- * was deleted with that path in Task 29.)
- */
-import { constants } from 'node:fs';
-import { open } from 'node:fs/promises';
-import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { BackgroundProcess } from './backgroundProcess.js';
-import { address, MAX_TASKS, object, rootRowFacts, sideNotes, } from './backgroundTerminalFold.js';
-export { TerminalRepairFold, newTerminalRepairData, sideNotes } from './backgroundTerminalFold.js';
-const CHUNK = 64 * 1024;
-const MAX_LINE = 2 * 1024 * 1024;
-const MAX_POLL = 4 * 1024 * 1024;
-export function nativeTerminalHistoryPath(identity, sessionId, cwd, historyHome) {
-    if (identity?.name !== 'qoder-cli' || identity.version !== '1.1.61' ||
-        !address(sessionId) || !isAbsolute(cwd) || !isAbsolute(historyHome))
-        return;
-    // Certified ~/.qoder/projects layout. Even a colliding directory name cannot cross session/cwd
-    // identity: every accepted row is checked again against the exact native session and directory.
-    return join(historyHome, '.qoder', 'projects', resolve(cwd).replace(/[^a-zA-Z0-9]/g, '-'), sessionId + '.jsonl');
-}
-/**
- * Reads the root transcript and the background children's transcripts incrementally (≤ 4 MiB per
- * poll and file, lines ≤ 2 MiB, `O_NOFOLLOW`, never written) and hands each derived {@link SideFact}
- * to the sink, in transcript order: root facts, then each followed child's rows and catch-up status,
- * then `poll_end` — only when the root read completed. Its offsets are its own (not checkpointed): a
- * new reader starts at 0 and the fold drops what it already has.
- */
-export class BackgroundSideReader {
-    options;
-    launches = new Map();
-    processes = new Map();
-    offset = 0;
-    fileIdentity = '';
-    pendingLine = Buffer.alloc(0);
-    skipLine = false;
-    closed = false;
-    warned = false;
-    restoring;
-    constructor(options) {
-        this.options = options;
-        this.restoring = options.restoreCalls === true;
-    }
-    /** One poll. Never rejects: a missing, replaced or unreadable file is not evidence. */
-    async read(demand, sink) {
-        if (this.closed || (!this.restoring && !demand.active()))
-            return;
-        try {
-            await this.readIncrement(demand, sink);
-        }
-        catch (error) {
-            const code = object(error).code;
-            if (!['ENOENT', 'ELOOP', 'ENOTDIR', 'EACCES'].includes(String(code)) && !this.warned) {
-                this.warned = true;
-                console.warn('[acp:qoder] background terminal repair unavailable; retaining native ACP state');
-            }
-        }
-    }
-    close() {
-        this.closed = true;
-        this.launches.clear();
-        this.processes.clear();
-        this.pendingLine = Buffer.alloc(0);
-    }
-    async readIncrement(demand, sink) {
-        // O_NOFOLLOW avoids importing a transcript through a replaced symlink. File is never written.
-        const file = await open(this.options.path, constants.O_RDONLY | constants.O_NOFOLLOW);
-        try {
-            const stat = await file.stat();
-            if (!stat.isFile() || this.closed)
-                return;
-            const identity = `${stat.dev}:${stat.ino}`;
-            if (identity !== this.fileIdentity || stat.size < this.offset) {
-                this.offset = 0;
-                this.pendingLine = Buffer.alloc(0);
-                this.skipLine = false;
-                this.fileIdentity = identity;
-            }
-            const end = Math.min(stat.size, this.offset + MAX_POLL);
-            const chunk = Buffer.alloc(CHUNK);
-            while (!this.closed && this.offset < end) {
-                const { bytesRead } = await file.read(chunk, 0, Math.min(CHUNK, end - this.offset), this.offset);
-                if (!bytesRead)
-                    break;
-                this.offset += bytesRead;
-                this.lines(chunk.subarray(0, bytesRead), sink);
-            }
-            if (this.offset >= stat.size)
-                this.restoring = false;
-            if (!this.closed) {
-                await this.pollProcesses(demand, sink);
-                if (!this.closed)
-                    sink({ kind: 'poll_end' });
-            }
-        }
-        finally {
-            await file.close();
-        }
-    }
-    lines(chunk, sink) {
-        let start = 0;
-        for (let end = chunk.indexOf(10); end !== -1; end = chunk.indexOf(10, start)) {
-            if (!this.skipLine && this.pendingLine.length + end - start <= MAX_LINE) {
-                const line = Buffer.concat([this.pendingLine, chunk.subarray(start, end)]).toString('utf8');
-                let row;
-                try {
-                    row = object(JSON.parse(line));
-                }
-                catch { /* partial/corrupt non-evidence */ }
-                if (row)
-                    this.consume(row, sink);
-            }
-            this.pendingLine = Buffer.alloc(0);
-            this.skipLine = false;
-            start = end + 1;
-        }
-        const tail = chunk.subarray(start);
-        if (!this.skipLine && this.pendingLine.length + tail.length <= MAX_LINE) {
-            this.pendingLine = Buffer.concat([this.pendingLine, tail]);
-        }
-        else {
-            this.pendingLine = Buffer.alloc(0);
-            this.skipLine = true;
-        }
-    }
-    consume(row, sink) {
-        const { nativeSessionId, cwd } = this.options;
-        for (const fact of rootRowFacts(row, { nativeSessionId, cwd, restoreCalls: this.options.restoreCalls === true })) {
-            // The reader's own copy of the receipts (same rule as the fold's): which child transcripts exist.
-            if (fact.kind === 'launch' && fact.agentId && this.launches.size < MAX_TASKS && !this.launches.has(fact.toolUseId)) {
-                this.launches.set(fact.toolUseId, fact.agentId);
-            }
-            sink(fact);
-        }
-    }
-    async pollProcesses(demand, sink) {
-        for (const [id, agentId] of this.launches) {
-            if (this.closed || !demand.wantsProcess(id))
-                continue;
-            let process = this.processes.get(id);
-            if (!process) {
-                process = new BackgroundProcess({
-                    path: join(dirname(this.options.path), this.options.nativeSessionId, 'subagents', `agent-${agentId}.jsonl`),
-                    sessionId: this.options.nativeSessionId, cwd: this.options.cwd, agentId, parentToolUseId: id,
-                    emit: () => { },
-                    onRow: (uuid, events) => { if (!this.closed)
-                        sink({ kind: 'child', toolUseId: id, uuid, events }); },
-                });
-                this.processes.set(id, process);
-            }
-            let caughtUp;
-            try {
-                caughtUp = await process.poll();
-            }
-            catch {
-                caughtUp = true; /* missing/corrupt transcript is not execution evidence */
-            }
-            sink({ kind: 'child_status', toolUseId: id, caughtUp });
-        }
-    }
-}
-/**
- * The daemon side of the processor (T19 runs it on its own timer, for a session whose processor
- * folded a `qoder_terminal_repair` note): one {@link poll} reads what is new and returns the note
- * payloads to append to the raw log, in order. `demand` is asked of the processor's current state
- * (`acp/processor/sideChannel.ts` `sideDemand`); what it answered is recorded only through the facts,
- * so the processor's fold never depends on when the daemon polled.
- */
-export class BackgroundSideNotes {
-    reader;
-    /** Facts over `MAX_SIDE_FACT_BYTES` that could not be recorded (diagnostics). */
-    droppedFacts = 0;
-    constructor(options) {
-        this.reader = new BackgroundSideReader(options);
-    }
-    async poll(demand) {
-        const notes = [];
-        await this.reader.read(demand, (fact) => {
-            const encoded = sideNotes(fact);
-            if (encoded.length === 0)
-                this.droppedFacts += 1;
-            notes.push(...encoded);
-        });
-        return notes;
-    }
-    close() { this.reader.close(); }
-}