@platless/axom-cli 0.1.0 → 0.5.9

package/dist/workstation/qoderAdapter/backgroundTerminalFold.js

@@ -0,0 +1,372 @@
+export const MAX_TASKS = 512;
+export const MAX_RESULT = 128 * 1024;
+export const MAX_RESULTS = 4 * 1024 * 1024;
+/** Child transcript rows remembered per background Agent (`BackgroundProcess`' `seen` bound). */
+export const CHILD_ROW_LIMIT = 4096;
+const TERMINALS = new Set(['completed', 'failed', 'cancelled']);
+export function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+export function address(value) {
+    return typeof value === 'string' && /^[a-zA-Z0-9_-]{1,160}$/.test(value) ? value : undefined;
+}
+function own(record, key) {
+    return Object.hasOwn(record, key) ? record[key] : undefined;
+}
+function put(record, key, value) {
+    Object.defineProperty(record, key, { value, enumerable: true, writable: true, configurable: true });
+}
+/** UTF-8 length of a string, as `Buffer.byteLength` counts it (a lone surrogate is 3 bytes). */
+export function utf8Length(text) {
+    let bytes = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        const code = text.charCodeAt(index);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length
+            && text.charCodeAt(index + 1) >= 0xdc00 && text.charCodeAt(index + 1) <= 0xdfff) {
+            bytes += 4;
+            index += 1;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+/**
+ * The facts in one root transcript row — `BackgroundTerminalRepair.consume` up to the point where it
+ * consulted its own memory (that half is {@link TerminalRepairFold.apply}).
+ */
+export function rootRowFacts(row, context) {
+    if (row.sessionId !== context.nativeSessionId || row.cwd !== context.cwd || row.isSidechain !== false)
+        return [];
+    const content = object(row.message).content;
+    if (!Array.isArray(content))
+        return [];
+    const facts = [];
+    // resume deliberately sends no historical ACP openings. Recover only certified root Agent
+    // background inputs; no opening is emitted and the existing exact-ID notification rules apply.
+    if (context.restoreCalls && row.type === 'assistant') {
+        for (const block of content.map(object)) {
+            const input = object(block.input), id = address(block.id);
+            if (block.type === 'tool_use' && block.name === 'Agent' && id && input.run_in_background === true &&
+                typeof input.prompt === 'string' && (input.subagent_type == null || typeof input.subagent_type === 'string')) {
+                facts.push({ kind: 'call', toolUseId: id, input });
+            }
+        }
+        return facts;
+    }
+    if (row.type !== 'user')
+        return facts;
+    const output = object(row.toolUseResult);
+    if (output.isAsync === true && output.status === 'async_launched') {
+        const results = content.map(object).filter(c => c.type === 'tool_result');
+        const id = results.length === 1 ? address(results[0].tool_use_id) : undefined;
+        const agent = address(output.agentId);
+        if (id)
+            facts.push({ kind: 'launch', toolUseId: id, ...(agent ? { agentId: agent } : {}) });
+        return facts;
+    }
+    if (row.isMeta !== true || object(row.origin).kind !== 'task-notification')
+        return facts;
+    for (const block of content.map(object)) {
+        if (block.type !== 'text' || typeof block.text !== 'string' ||
+            !block.text.startsWith('[SYSTEM NOTIFICATION - NOT USER INPUT]\n'))
+            continue;
+        // Match the authoritative envelope before result text; tags inside a result cannot change IDs.
+        const match = block.text.match(/<task-notification>\n<task-id>([a-zA-Z0-9_-]{1,160})<\/task-id>\n<tool-use-id>([a-zA-Z0-9_-]{1,160})<\/tool-use-id>\n(?:<output-file>[^\n]*<\/output-file>\n)?<status>(completed|failed|cancelled)<\/status>\n<summary>[^\n]*<\/summary>\n<result>([\s\S]*)<\/result>\n(?:<usage>[^\n]*<\/usage>\n)?<\/task-notification>\s*$/);
+        if (match && utf8Length(match[4]) <= MAX_RESULT) {
+            facts.push({ kind: 'terminal', toolUseId: match[2], taskId: match[1], state: match[3], result: match[4] });
+        }
+    }
+    return facts;
+}
+export function newTerminalRepairData(options) {
+    return {
+        nativeSessionId: options.nativeSessionId, restoreCalls: options.restoreCalls === true, includeProcess: options.includeProcess === true,
+        calls: {}, callCount: 0, launches: [], terminals: [], delivered: {}, pendingProcesses: {}, resultBytes: 0, childRows: {}, polledProcesses: {},
+    };
+}
+export class TerminalRepairFold {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    call(id) { return own(this.data.calls, id); }
+    agentOf(id) { return this.data.launches.find(([toolUseId]) => toolUseId === id)?.[1]; }
+    /** Every ACP event the session routes or emits (live or load history): learns the certified Agent calls. */
+    observe(event) {
+        if ((event.acpSessionId && event.acpSessionId !== this.data.nativeSessionId) ||
+            !['tool_call', 'tool_call_update'].includes(event.eventName))
+            return;
+        const payload = event.payload;
+        const id = address(payload.toolCallId);
+        if (!id)
+            return;
+        let call = this.call(id);
+        const input = object(payload.rawInput);
+        if (!call && input.run_in_background === true && typeof input.prompt === 'string' &&
+            (input.subagent_type == null || typeof input.subagent_type === 'string') && payload.kind === 'think' &&
+            object(object(payload._meta).qoder).toolName === 'Agent' && this.data.callCount < MAX_TASKS) {
+            const meta = object(object(payload._meta).qoder);
+            call = { input, invocationComplete: false, nativeTerminal: false,
+                process: this.data.includeProcess && meta.version === 1 && meta.source === 'native-acp-patch' };
+            put(this.data.calls, id, call);
+            this.data.callCount += 1;
+        }
+        if (!call)
+            return;
+        if (payload.status === 'completed')
+            call.invocationComplete = true;
+        const output = object(payload.rawOutput);
+        if (output.kind === 'agent-result' && (TERMINALS.has(String(output.state)) || output.state === 'error')) {
+            call.nativeTerminal = true; // Upstream's structured evidence always wins.
+            // Never published now: its input, child rows and status are dead (checkpointed state).
+            this.forget(id, call);
+        }
+    }
+    /** A known call has no result yet: the reader keeps polling the root transcript. */
+    active() {
+        return Object.entries(this.data.calls).some(([id, call]) => !Object.hasOwn(this.data.delivered, id) && !call.nativeTerminal);
+    }
+    /** This call's child transcript is still followed. */
+    wantsProcess(toolUseId) {
+        const call = this.call(toolUseId);
+        return call !== undefined && call.process && !Object.hasOwn(this.data.delivered, toolUseId) && !call.nativeTerminal;
+    }
+    /** Fold one fact; returns the ACP events to emit now (a child row's, or the results a poll's end publishes). */
+    apply(fact) {
+        const data = this.data;
+        switch (fact.kind) {
+            case 'call':
+                if (data.restoreCalls && !this.call(fact.toolUseId) && data.callCount < MAX_TASKS) {
+                    put(data.calls, fact.toolUseId, { input: fact.input, invocationComplete: false, nativeTerminal: false, process: false });
+                    data.callCount += 1;
+                }
+                return [];
+            case 'launch': {
+                const call = this.call(fact.toolUseId);
+                if (data.restoreCalls && call)
+                    call.invocationComplete = true;
+                if (fact.agentId && data.launches.length < MAX_TASKS && this.agentOf(fact.toolUseId) === undefined) {
+                    data.launches.push([fact.toolUseId, fact.agentId]);
+                }
+                return [];
+            }
+            case 'terminal': {
+                const bytes = utf8Length(fact.result);
+                if (bytes <= MAX_RESULT && data.resultBytes + bytes <= MAX_RESULTS && data.terminals.length < MAX_TASKS &&
+                    !data.terminals.some((terminal) => terminal.toolUseId === fact.toolUseId)) {
+                    data.resultBytes += bytes;
+                    data.terminals.push({ toolUseId: fact.toolUseId, taskId: fact.taskId, state: fact.state, result: fact.result });
+                }
+                return [];
+            }
+            case 'child': {
+                // Only a transcript the repair still follows (the reader asked the same question before reading).
+                if (!this.wantsProcess(fact.toolUseId) || this.agentOf(fact.toolUseId) === undefined)
+                    return [];
+                let seen = own(data.childRows, fact.toolUseId);
+                if (!seen)
+                    put(data.childRows, fact.toolUseId, seen = []);
+                if (seen.includes(fact.uuid) || seen.length >= CHILD_ROW_LIMIT)
+                    return [];
+                seen.push(fact.uuid);
+                return [...fact.events];
+            }
+            case 'child_status':
+                if (!this.wantsProcess(fact.toolUseId) || this.agentOf(fact.toolUseId) === undefined)
+                    return [];
+                if (fact.caughtUp)
+                    delete data.pendingProcesses[fact.toolUseId];
+                else
+                    put(data.pendingProcesses, fact.toolUseId, true);
+                put(data.polledProcesses, fact.toolUseId, true);
+                return [];
+            case 'poll_end':
+                return this.publish();
+        }
+    }
+    publish() {
+        const data = this.data;
+        const events = [];
+        for (const terminal of data.terminals) {
+            const id = terminal.toolUseId;
+            const call = this.call(id), agentId = this.agentOf(id);
+            if (call?.nativeTerminal)
+                terminal.result = '';
+            if (Object.hasOwn(data.delivered, id) || Object.hasOwn(data.pendingProcesses, id) || !call?.invocationComplete ||
+                call.nativeTerminal || !agentId || (call.process && !Object.hasOwn(data.polledProcesses, id)))
+                continue;
+            put(data.delivered, id, true);
+            events.push({ eventName: 'tool_call_update', payload: {
+                    name: 'Agent', kind: 'think', toolCallId: id, rawInput: call.input, status: 'completed',
+                    rawOutput: { kind: 'agent-result', state: terminal.state, agentId, result: terminal.result },
+                    content: [{ type: 'content', content: { type: 'text', text: terminal.result } }],
+                    _meta: { qoder: { toolName: 'Agent' }, axomNativeTerminalRepair: {
+                            patch: 'qoder-background-terminal', nativeSessionId: data.nativeSessionId,
+                            taskId: terminal.taskId, source: 'native-task-notification',
+                        } },
+                } });
+            // Delivered results are never published again; their text need not stay in a checkpoint.
+            terminal.result = '';
+            this.forget(id, call);
+        }
+        return events;
+    }
+    /**
+     * A delivered or natively finished call is never published and its child never followed again
+     * (`wantsProcess` is false for good), so what only those two read goes: the input (read by
+     * `publish` alone), the child rows' uuids and status. The call entry itself stays — `observe` must
+     * not register the same id afresh — and so do the launch and result entries, whose presence is what
+     * keeps a restarted reader's repeats from being taken as new.
+     */
+    forget(id, call) {
+        call.input = {};
+        delete this.data.childRows[id];
+        delete this.data.pendingProcesses[id];
+        delete this.data.polledProcesses[id];
+    }
+}
+// ---- notes ------------------------------------------------------------------------------------
+/**
+ * The note kinds (spec §5.4: "Qoder 侧文件推导出的事件" enter the log as notes):
+ * - `qoder_terminal_repair{nativeSessionId, restoreCalls?}` — the daemon enabled the certified repair
+ *   for this session (where today's path calls `enableBackgroundTerminalRepair`).
+ * - `qoder_side{fact}`, or for a fact too large for one note, consecutive
+ *   `qoder_side{chunk: {index, count, text}}` notes whose `text`s concatenate to the fact's JSON.
+ */
+export const REPAIR_NOTE = 'qoder_terminal_repair';
+export const SIDE_NOTE = 'qoder_side';
+/** Equal to the processor's `NOTE_MAX_BYTES` (asserted in a test; this module does not import the processor). */
+export const SIDE_NOTE_MAX_BYTES = 64 * 1024;
+/**
+ * A fact larger than this (serialized) is not recorded (the reader counts it). A child row's line is
+ * ≤ 2 MiB and re-serializes no larger, but its text can appear twice (`rawOutput` and `content`), so a
+ * fact stays ≤ ~4 MiB; 8 MiB keeps every fact the live driver would have emitted. Its chunk buffer can be
+ * that large while a chunked fact is half-read: T19 does not cut a checkpoint then (`sideChunk !== null`).
+ */
+export const MAX_SIDE_FACT_BYTES = 8 * 1024 * 1024;
+/** Enough for a {@link MAX_SIDE_FACT_BYTES} fact even when chunking doubles it (escaped quotes). */
+export const MAX_SIDE_CHUNKS = 512;
+/** Bytes `JSON.stringify` spends on one code unit (or pair) inside a string literal. */
+function escapedBytes(text, index) {
+    const code = text.charCodeAt(index);
+    if (code === 0x22 || code === 0x5c || code === 0x08 || code === 0x0c || code === 0x0a || code === 0x0d || code === 0x09)
+        return { bytes: 2, units: 1 };
+    if (code < 0x20)
+        return { bytes: 6, units: 1 };
+    if (code < 0x80)
+        return { bytes: 1, units: 1 };
+    if (code < 0x800)
+        return { bytes: 2, units: 1 };
+    if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {
+        const next = text.charCodeAt(index + 1);
+        if (next >= 0xdc00 && next <= 0xdfff)
+            return { bytes: 4, units: 2 };
+    }
+    if (code >= 0xd800 && code <= 0xdfff)
+        return { bytes: 6, units: 1 };
+    return { bytes: 3, units: 1 };
+}
+/**
+ * The notes that record one fact: one `{fact}` note when it fits {@link SIDE_NOTE_MAX_BYTES}, otherwise
+ * consecutive `{chunk}` notes, each within the limit. `[]` for a fact over {@link MAX_SIDE_FACT_BYTES}.
+ */
+export function sideNotes(fact) {
+    const whole = { type: SIDE_NOTE, fact };
+    if (utf8Length(JSON.stringify(whole)) <= SIDE_NOTE_MAX_BYTES)
+        return [whole];
+    const json = JSON.stringify(fact);
+    if (utf8Length(json) > MAX_SIDE_FACT_BYTES)
+        return [];
+    const overhead = utf8Length(JSON.stringify({ type: SIDE_NOTE, chunk: { index: MAX_SIDE_CHUNKS, count: MAX_SIDE_CHUNKS, text: '' } }));
+    const budget = SIDE_NOTE_MAX_BYTES - overhead;
+    const pieces = [];
+    let start = 0, used = 0;
+    for (let index = 0; index < json.length;) {
+        const { bytes, units } = escapedBytes(json, index);
+        if (used + bytes > budget) {
+            pieces.push(json.slice(start, index));
+            start = index;
+            used = 0;
+        }
+        used += bytes;
+        index += units;
+    }
+    pieces.push(json.slice(start));
+    if (pieces.length > MAX_SIDE_CHUNKS)
+        return [];
+    return pieces.map((text, index) => ({ type: SIDE_NOTE, chunk: { index, count: pieces.length, text } }));
+}
+function isEvent(value) {
+    const event = object(value);
+    return value === event && typeof event.eventName === 'string' && object(event.payload) === event.payload
+        && (event.acpSessionId === undefined || typeof event.acpSessionId === 'string');
+}
+/** A fact read back from a note, shape-checked (the log is the daemon's own, but a note is still data). */
+export function parseSideFact(value) {
+    const fact = object(value);
+    if (value !== fact)
+        return undefined;
+    const id = address(fact.toolUseId);
+    switch (fact.kind) {
+        case 'call':
+            return id && object(fact.input) === fact.input ? { kind: 'call', toolUseId: id, input: fact.input } : undefined;
+        case 'launch':
+            if (!id || (fact.agentId !== undefined && address(fact.agentId) === undefined))
+                return undefined;
+            return { kind: 'launch', toolUseId: id, ...(fact.agentId !== undefined ? { agentId: fact.agentId } : {}) };
+        case 'terminal':
+            return id && address(fact.taskId) && TERMINALS.has(String(fact.state)) && typeof fact.result === 'string'
+                ? { kind: 'terminal', toolUseId: id, taskId: fact.taskId, state: fact.state, result: fact.result }
+                : undefined;
+        case 'child':
+            return id && address(fact.uuid) && Array.isArray(fact.events) && fact.events.every(isEvent)
+                ? { kind: 'child', toolUseId: id, uuid: fact.uuid, events: fact.events }
+                : undefined;
+        case 'child_status':
+            return id && typeof fact.caughtUp === 'boolean' ? { kind: 'child_status', toolUseId: id, caughtUp: fact.caughtUp } : undefined;
+        case 'poll_end':
+            return { kind: 'poll_end' };
+        default:
+            return undefined;
+    }
+}
+/**
+ * Read one `qoder_side` note against the reassembly buffer. A `{fact}` note (or a chunk with index 0)
+ * abandons any half-read chunked fact — a reader that restarted re-reads from the start, so the
+ * fact comes again. `malformed` when the note could not be used (shape, order, or JSON).
+ */
+export function readSideNote(buffer, note) {
+    if (Object.hasOwn(note, 'fact')) {
+        const fact = parseSideFact(note.fact);
+        return fact ? { buffer: null, fact, malformed: false } : { buffer: null, malformed: true };
+    }
+    const chunk = object(note.chunk);
+    const { index, count, text } = chunk;
+    if (note.chunk !== chunk || !Number.isSafeInteger(index) || !Number.isSafeInteger(count) || typeof text !== 'string'
+        || count < 2 || count > MAX_SIDE_CHUNKS || index < 0 || index >= count) {
+        return { buffer, malformed: true };
+    }
+    let next;
+    if (index === 0)
+        next = { count: count, next: 1, text };
+    else if (buffer && buffer.count === count && buffer.next === index)
+        next = { count: buffer.count, next: buffer.next + 1, text: buffer.text + text };
+    else
+        return { buffer: null, malformed: true };
+    if (next.next < next.count)
+        return { buffer: next, malformed: false };
+    let parsed;
+    try {
+        parsed = JSON.parse(next.text);
+    }
+    catch {
+        return { buffer: null, malformed: true };
+    }
+    const fact = parseSideFact(parsed);
+    return fact ? { buffer: null, fact, malformed: false } : { buffer: null, malformed: true };
+}

package/dist/workstation/qoderAdapter/callbackContext.js

@@ -0,0 +1,76 @@
+/** A permission card whose tool call carries the SDK adapter's callback metadata. */
+export function isSdkCallbackCard(toolCall) {
+    const meta = toolCall && typeof toolCall === 'object' && !Array.isArray(toolCall)
+        ? toolCall._meta : undefined;
+    return !!meta && typeof meta === 'object' && !Array.isArray(meta) &&
+        Object.prototype.hasOwnProperty.call(meta, 'qoderSdk');
+}
+/**
+ * The callback snapshot's `connectionGeneration` on the processor path: one ACP session per adapter
+ * process, so it derives from the keeper's `spawnId` (spec §5.4), distinct from `hostGeneration`
+ * (= the `spawnId` itself).
+ */
+export function connectionGenerationOf(spawnId) {
+    return `session:${spawnId}`;
+}
+/** `AcpSession.callbackContextFor`, as a pure function. `undefined` = the card cannot carry a callback. */
+export function permissionCallbackContext(input) {
+    const { rootSessionId, diagnostics, requestId, toolCall, pendingRpcRequestId } = input;
+    if (input.origin !== rootSessionId)
+        return;
+    const profile = diagnostics.profile;
+    const callbacks = diagnostics.callbacks;
+    if (!diagnostics.available || profile?.mode !== 'sdk-adapter' || profile.initialized !== true ||
+        profile.rootConfirmed !== true || profile.rootSessionId !== rootSessionId ||
+        !profile.runtimeGeneration || callbacks?.complete !== true ||
+        callbacks.rootSessionId !== rootSessionId ||
+        typeof requestId !== 'string' || pendingRpcRequestId === undefined ||
+        !toolCall || typeof toolCall !== 'object' || Array.isArray(toolCall))
+        return;
+    const call = toolCall;
+    const sdkMeta = call._meta && typeof call._meta === 'object' && !Array.isArray(call._meta)
+        ? call._meta.qoderSdk : undefined;
+    if (!sdkMeta || typeof sdkMeta !== 'object' || Array.isArray(sdkMeta))
+        return;
+    const sdk = sdkMeta;
+    const origin = sdk.origin;
+    if (sdk.version !== 1 || sdk.blockingScope !== 'root' || sdk.callbackOnly !== true ||
+        typeof sdk.requestId !== 'string' || !/^[0-9a-f-]{36}$/i.test(sdk.requestId) ||
+        !origin || typeof origin !== 'object' || Array.isArray(origin))
+        return;
+    const source = origin;
+    const toolUseId = call.toolCallId;
+    const agentId = source.agentId;
+    if (source.rootSessionId !== rootSessionId || source.runtimeGeneration !== profile.runtimeGeneration ||
+        typeof toolUseId !== 'string' || source.toolUseId !== toolUseId ||
+        !toolUseId || utf8Length(toolUseId) > 256 ||
+        (agentId !== undefined && (typeof agentId !== 'string' || !agentId || utf8Length(agentId) > 256)))
+        return;
+    const pending = callbacks.pending.find((entry) => entry.requestId === requestId &&
+        entry.originNativeSessionId === rootSessionId);
+    if (!pending || callbacks.pending.length > 64 || pendingRpcRequestId !== pending.rpcRequestId)
+        return;
+    return { rootSessionId, hostGeneration: diagnostics.generation,
+        connectionGeneration: callbacks.connectionGeneration, requestId,
+        runtimeGeneration: profile.runtimeGeneration, toolUseId,
+        ...(agentId ? { agentId } : {}), independent: false };
+}
+/** `Buffer.byteLength(text, 'utf8')` in plain JS (a lone surrogate is 3 bytes). */
+function utf8Length(text) {
+    let bytes = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        const code = text.charCodeAt(index);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length
+            && text.charCodeAt(index + 1) >= 0xdc00 && text.charCodeAt(index + 1) <= 0xdfff) {
+            bytes += 4;
+            index += 1;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}

package/dist/workstation/qoderAdapter/completedContinuation.js

@@ -0,0 +1,139 @@
+import { capabilitiesFor, QODER_CERTIFICATIONS } from './profile.js';
+const MAX_ID_BYTES = 256;
+const MAX_MESSAGE_BYTES = 131072;
+const MAX_RECORDS = 4096;
+const states = new Set(['pending', 'paused', 'running', 'completed', 'stopped', 'failed', 'unknown']);
+const id = (value) => typeof value === 'string' && value.trim().length > 0 &&
+    Buffer.byteLength(value, 'utf8') <= MAX_ID_BYTES && !/[\x00-\x1f\x7f]/.test(value);
+const message = (value) => typeof value === 'string' &&
+    Buffer.byteLength(value, 'utf8') <= MAX_MESSAGE_BYTES;
+function exactIdentity(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const input = value;
+    return ['rootSessionId', 'runtimeGeneration', 'sourceTaskId', 'agentId', 'requestId', 'toolUseId']
+        .every((key) => id(input[key]));
+}
+function hasVendorResumeClaim(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    if (Object.prototype.hasOwnProperty.call(value, 'resumedAgentId'))
+        return true;
+    return Object.values(value).some((entry) => hasVendorResumeClaim(entry));
+}
+export function normalizeContinuationEvidence(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || hasVendorResumeClaim(value))
+        return undefined;
+    const input = value;
+    if (!exactIdentity(input.request) || !exactIdentity(input.sendMessage))
+        return undefined;
+    if (typeof input.sendMessage.success !== 'boolean')
+        return undefined;
+    const joined = input.joinedTask;
+    if (joined === undefined)
+        return {
+            request: { ...input.request },
+            sendMessage: { ...input.sendMessage,
+                success: input.sendMessage.success },
+        };
+    if (!joined || typeof joined !== 'object' || Array.isArray(joined))
+        return undefined;
+    const task = joined;
+    const joinedTask = task;
+    if (!exactIdentity(task) || !id(joinedTask.taskId) || joinedTask.taskId === joinedTask.sourceTaskId ||
+        !states.has(joinedTask.state) || !['pending', 'running', 'completed'].includes(joinedTask.state) ||
+        typeof joinedTask.live !== 'boolean' || typeof joinedTask.stale !== 'boolean')
+        return undefined;
+    return {
+        request: { ...input.request },
+        sendMessage: { ...input.sendMessage,
+            success: input.sendMessage.success },
+        joinedTask: { ...joinedTask },
+    };
+}
+function sameIdentity(a, b) {
+    return a.rootSessionId === b.rootSessionId && a.runtimeGeneration === b.runtimeGeneration &&
+        a.sourceTaskId === b.sourceTaskId && a.agentId === b.agentId && a.requestId === b.requestId &&
+        a.toolUseId === b.toolUseId;
+}
+/** Confirm only an observed, exact new execution. Natural-language claims are intentionally ignored. */
+export function confirmContinuation(expectedAgentId, value) {
+    if (!id(expectedAgentId))
+        return 'rejected';
+    const evidence = normalizeContinuationEvidence(value);
+    if (!evidence || !evidence.joinedTask || !evidence.sendMessage.success ||
+        evidence.request.agentId !== expectedAgentId || !sameIdentity(evidence.request, evidence.sendMessage) ||
+        !sameIdentity(evidence.request, evidence.joinedTask) || evidence.joinedTask.agentId !== expectedAgentId ||
+        evidence.joinedTask.stale || !evidence.joinedTask.taskId ||
+        evidence.joinedTask.taskId === evidence.request.sourceTaskId)
+        return 'rejected';
+    return 'confirmed';
+}
+function key(identity) {
+    return [identity.rootSessionId, identity.runtimeGeneration, identity.requestId].join('\u0000');
+}
+/** A bounded, request-scoped ledger prevents duplicate confirmations and keeps late proof unknown. */
+export class ContinuationLedger {
+    requests = new Map();
+    statuses = new Map();
+    joinedTaskIds = new Set();
+    evidence = new Map();
+    request(identity) {
+        if (!exactIdentity(identity) || this.requests.size >= MAX_RECORDS)
+            return 'rejected';
+        const requestKey = key(identity);
+        if (this.requests.has(requestKey))
+            return 'rejected';
+        this.requests.set(requestKey, { ...identity });
+        this.statuses.set(requestKey, 'requested');
+        return 'requested';
+    }
+    confirm(expectedAgentId, value) {
+        const evidence = normalizeContinuationEvidence(value);
+        if (!evidence)
+            return 'rejected';
+        const requestKey = key(evidence.request);
+        const original = this.requests.get(requestKey);
+        if (!original || !sameIdentity(original, evidence.request))
+            return 'unknown';
+        if (!evidence.joinedTask)
+            return 'unknown';
+        if (this.statuses.get(requestKey) === 'confirmed' || this.joinedTaskIds.has(evidence.joinedTask.taskId)) {
+            return 'rejected';
+        }
+        const result = confirmContinuation(expectedAgentId, evidence);
+        if (result === 'confirmed') {
+            this.joinedTaskIds.add(evidence.joinedTask.taskId);
+            this.statuses.set(requestKey, 'confirmed');
+            this.evidence.set(requestKey, evidence);
+        }
+        else
+            this.statuses.set(requestKey, 'rejected');
+        return result;
+    }
+    snapshot() {
+        return [...this.evidence.values()].map((entry) => ({
+            request: { ...entry.request }, sendMessage: { ...entry.sendMessage },
+            ...(entry.joinedTask ? { joinedTask: { ...entry.joinedTask } } : {}),
+        }));
+    }
+}
+export async function requestCompletedContinuation(rootSessionId, agentId, text, requestId, options) {
+    const rejected = () => ({ status: 'rejected', rootSessionId, agentId, requestId });
+    if (!options)
+        return rejected();
+    const profile = options.profile, task = options.task;
+    if (!id(rootSessionId) || !id(agentId) || !id(requestId) || !message(text) || options.enabled !== true ||
+        options.busy === true || !profile || !task ||
+        task.origin.rootSessionId !== rootSessionId || task.origin.agentId !== agentId ||
+        task.origin.runtimeGeneration !== profile.runtimeGeneration ||
+        !capabilitiesFor(profile, task, options.certifications ?? QODER_CERTIFICATIONS, options.binding).continueCompleted)
+        return rejected();
+    try {
+        await options.prompt(text);
+        return { status: 'requested', rootSessionId, agentId, requestId };
+    }
+    catch {
+        return rejected();
+    }
+}

package/dist/workstation/qoderAdapter/contract.js

@@ -0,0 +1,78 @@
+import { spawn } from 'node:child_process';
+import { parseQoderProfile } from './profile.js';
+/**
+ * Native SDK/Hooks capabilities are opt-in until one real process has produced
+ * a complete, attributable contract record.  The fake fixture must never add a
+ * profile to QODER_CERTIFICATIONS by itself.
+ */
+export const QODER_NATIVE_FALLBACKS = Object.freeze({
+    model: 'Model changes are negotiated by the base ACP session only.',
+    mode: 'Mode changes are negotiated by the base ACP session only.',
+    media: 'Prompt media and resources are unsupported by the SDK adapter.',
+    forms: 'Form elicitation is unsupported until an equivalent public SDK callback is certified.',
+    load: 'Load requires an exact native session proof; it never creates a replacement session.',
+    fork: 'Fork is unsupported until an exact new native execution can be proved.',
+});
+export function nativeFallback(feature) {
+    return { supported: false, reason: QODER_NATIVE_FALLBACKS[feature] };
+}
+/**
+ * Parses the deliberately small output contract of an opt-in native runner.
+ * This is validation only: callers still decide whether to persist evidence or
+ * open a capability, and the shipping certification allowlist remains closed.
+ */
+export function parseNativeContractEvidence(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const input = value;
+    const profile = parseQoderProfile(input.profile);
+    if (input.certified !== true || !profile || input.tasks !== true || input.hooks !== true ||
+        input.approvals !== true || input.terminalControl !== true || input.replayFree !== true ||
+        profile.cliVersion !== '1.1.64' || profile.sdkVersion !== '1.0.50' || profile.mode !== 'sdk-adapter' ||
+        profile.transport !== 'process' || profile.initialized !== true || profile.rootConfirmed !== true ||
+        profile.observerHealthy !== true || !profile.capabilities.includes('background_tasks_v1'))
+        return undefined;
+    return { certified: true, profile, tasks: true, hooks: true, approvals: true,
+        terminalControl: true, replayFree: true };
+}
+const MAX_OUTPUT_BYTES = 128 * 1024;
+const TIMEOUT_MS = 120_000;
+/**
+ * Runs an external certification command only when explicitly configured. The
+ * command is an executable path (no shell), receives no credentials from this
+ * helper, and must print NativeContractEvidence JSON to stdout.
+ */
+export async function runOptInNativeContract(command = process.env.AXOM_QODER_SDK_CONTRACT_COMMAND) {
+    if (!command)
+        return { status: 'not-run', stdout: '', stderr: '' };
+    if (command.includes('\0') || command.trim() !== command || command.length > 4096)
+        throw new Error('Invalid native contract command');
+    return await new Promise((resolve) => {
+        const child = spawn(command, [], { shell: false, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
+        let stdout = '', stderr = '', oversized = false, settled = false;
+        const append = (target, chunk) => {
+            if (Buffer.byteLength(target === 'stdout' ? stdout : stderr, 'utf8') + chunk.byteLength > MAX_OUTPUT_BYTES) {
+                oversized = true;
+                child.kill('SIGTERM');
+                return;
+            }
+            if (target === 'stdout')
+                stdout += chunk.toString('utf8');
+            else
+                stderr += chunk.toString('utf8');
+        };
+        child.stdout.on('data', (chunk) => append('stdout', chunk));
+        child.stderr.on('data', (chunk) => append('stderr', chunk));
+        const timer = setTimeout(() => child.kill('SIGTERM'), TIMEOUT_MS);
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        child.once('error', (error) => finish({ status: 'failed', command, stdout, stderr: `${stderr}${error.message}` }));
+        child.once('close', (code) => finish({ status: oversized ? 'failed' : code === 0 ? 'completed' : 'failed',
+            command, exitCode: code, stdout, stderr }));
+    });
+}