@platless/axom-cli 0.1.0 → 0.5.9

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

@@ -0,0 +1,355 @@
+/**
+ * The open session and its controls, as notes and their responses (Task 17b): `session/new|load|resume`,
+ * `historyEnd`, `session/set_config_option`/`set_mode`, `_session/steering`, `_session/async_task/stop`,
+ * delegation's non-secret fields and the runtime `launch` (spec 2026-10-11 §5.4).
+ *
+ * ## Opening, and binding from the response
+ *
+ * `agent_session_open{mode, cwd, sessionId?, mcpServers?, redact?, delegation?}` sends one request —
+ * the params `AcpSession.open` (`buildSession`), `replayNativeSession` (`session/load`) and the Qoder
+ * resume path build, `_meta` included (`newSessionMetaFor`, decided from the initialize reading). The
+ * MCP server list arrives finished: the daemon validated the delegation lease (`buildSessionMcpServers`,
+ * which reads the clock) before it wrote the note, and the bearer in it is a `secretRef` token the
+ * executor substitutes into stdin only (`redact`, spec §13). The **response** binds the root
+ * (`bindRootSession`) and sets the config snapshot — no pre-bind buffer, no window. A failed open is
+ * reported (`processor.open_result`) and never retried as `session/new` here.
+ *
+ * ## Replies
+ *
+ * `agent_config_option_set` and `agent_steered` are RPC replies: unnumbered frames carrying the
+ * server's frame `id` from the note, built as `agentSessions.ts` builds them. A steer's blocks travel
+ * like a prompt's (`fill: {blocksRef}`); if the executor lost them, the same `agent_prompt_failed` note
+ * fails the steer.
+ *
+ * ## `steeredIds` (spec §5.5.4)
+ *
+ * {@link steeredIds}: steers whose line reached the agent and that are unanswered, plus the last
+ * {@link STEERED_HISTORY_LIMIT} the agent answered `injected`. A `promptRequired`, a refusal, or a
+ * line that never reached the agent is not steered: the server delivers that message the ordinary way.
+ */
+import { newSessionMetaFor } from '../activityReporting.js';
+import { flatChoicesOf, modesAlreadyRepresented, modelsAlreadyRepresented, normalizeConfigOptions, SYNTHESIZED_MODES_CONFIG_ID, SYNTHESIZED_MODEL_CONFIG_ID } from '../configOptions.js';
+import { ASYNC_TASK_STOP_METHOD, mapSteerOutcome, STEER_METHOD } from '../steering.js';
+import { emitEvent, isRecord } from './emit.js';
+import { settlementErrorCode } from './jsonrpc.js';
+import { sameCause } from './record.js';
+import { onLaunchNote, onRootBound } from './runtime.js';
+import { bindRootSession, closeErrorText, connected } from './session.js';
+import { getOwn, putOwn, STEERED_HISTORY_LIMIT, } from './state.js';
+import { closeRepair } from './sideChannel.js';
+import { endHistory } from './updates.js';
+const OPEN_METHODS = { new: 'session/new', load: 'session/load', resume: 'session/resume' };
+export const NOT_INITIALIZED = 'The ACP connection has not finished initialize';
+export const ALREADY_OPEN = 'An ACP session is already open on this connection';
+export const NOT_OPEN = 'No ACP session is open on this connection';
+function request(state, out, method, params, kind, ctx, extras = {}) {
+    const { id, cause } = out.request(method, params, extras);
+    const pending = { id, method, kind, cause, ...(ctx !== undefined ? { ctx } : {}) };
+    state.outbound[String(id)] = pending;
+    return pending;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function delegationOf(value) {
+    if (value === undefined)
+        return null;
+    if (!isRecord(value))
+        return undefined;
+    const { expiresAtEpochMs, leaseId, bindingId, instanceId } = value;
+    if (!Number.isSafeInteger(expiresAtEpochMs) || typeof leaseId !== 'string' || leaseId === ''
+        || (bindingId !== undefined && typeof bindingId !== 'string') || (instanceId !== undefined && typeof instanceId !== 'string')
+        || (bindingId !== undefined) !== (instanceId !== undefined))
+        return undefined;
+    return {
+        expiresAtEpochMs: expiresAtEpochMs, leaseId,
+        ...(bindingId !== undefined ? { bindingId, instanceId: instanceId, renewalRevision: 0 } : {}),
+    };
+}
+// ---- open ---------------------------------------------------------------------------------------
+/** `agent_session_open{mode, cwd, sessionId?, mcpServers?, redact?, delegation?}`. */
+export function onOpenNote(state, note, out) {
+    const { mode, cwd, sessionId, mcpServers, redact } = note;
+    const delegation = delegationOf(note.delegation);
+    if ((mode !== 'new' && mode !== 'load' && mode !== 'resume') || typeof cwd !== 'string' || cwd === ''
+        || (mode === 'new' ? sessionId !== undefined : typeof sessionId !== 'string' || sessionId === '')
+        || (mcpServers !== undefined && !Array.isArray(mcpServers)) || (redact !== undefined && !isStringArray(redact))
+        || delegation === undefined) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    const refuse = (error) => out.unjournaled({ t: 'processor.open_result', ok: false, mode, error });
+    if (!connected(state))
+        return refuse(closeErrorText(state));
+    if (state.initialize.status !== 'ready')
+        return refuse(NOT_INITIALIZED);
+    if (state.open.status === 'pending' || state.open.status === 'open')
+        return refuse(ALREADY_OPEN);
+    const meta = mode === 'resume' ? undefined : newSessionMetaFor(state.initialize.facts.agentInfo?.name);
+    const servers = mcpServers ?? [];
+    const params = mode === 'new'
+        ? { cwd, mcpServers: servers, ...(meta ? { _meta: meta } : {}) }
+        : mode === 'load'
+            ? { sessionId, cwd, mcpServers: servers, ...(meta ? { _meta: meta } : {}) }
+            : { sessionId, cwd, mcpServers: servers };
+    const pending = request(state, out, OPEN_METHODS[mode], params, 'open', { mode, ...(sessionId !== undefined ? { sessionId } : {}), ...(delegation ? { delegation } : {}) }, redact !== undefined && redact.length > 0 ? { redact } : {});
+    state.open = { status: 'pending', requestId: pending.id, mode };
+    if (mode === 'load')
+        state.history = { rootSessionId: sessionId, scopes: {}, messages: [], droppedCount: 0 };
+}
+/** The open request settled: on success the response binds the root session, now. */
+export function settleOpen(state, entry, settlement, out) {
+    const ctx = entry.ctx;
+    if (state.open.status !== 'pending' || state.open.requestId !== entry.id)
+        return;
+    const { mode } = ctx;
+    if (settlement.outcome !== 'result') {
+        const code = settlementErrorCode(settlement);
+        const error = settlement.outcome === 'error' ? settlement.error.message : closeErrorText(state);
+        state.open = { status: 'failed', mode, error, ...(code !== undefined ? { code } : {}) };
+        endHistory(state, out, false);
+        // A failed open closes the attached session, and its repair with it (`AcpSession.close`).
+        closeRepair(state);
+        out.unjournaled({ t: 'processor.open_result', ok: false, mode, error, ...(code !== undefined ? { code } : {}) });
+        return;
+    }
+    const result = isRecord(settlement.result) ? settlement.result : {};
+    const nativeSessionId = mode === 'new' ? (typeof result.sessionId === 'string' ? result.sessionId : '') : ctx.sessionId;
+    if (nativeSessionId.length > 0) {
+        bindRootSession(state, nativeSessionId);
+        onRootBound(state, out, nativeSessionId);
+    }
+    state.configOptions = normalizeConfigOptions(result.configOptions, result.modes, result.models);
+    state.delegation = ctx.delegation ?? null;
+    state.open = { status: 'open', mode };
+    out.unjournaled({
+        t: 'processor.open_result', ok: true, mode,
+        nativeSessionId: nativeSessionId.length > 0 ? nativeSessionId : null,
+        configOptions: state.configOptions,
+    });
+}
+/** `historyEnd{}` — the daemon's decision that a load's history is over (analysis B A4). */
+export function onHistoryEndNote(state, out) {
+    if (!state.history) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    endHistory(state, out, true);
+}
+/** Usable for a session request: connected, and the open succeeded with a root. */
+function sessionReady(state) {
+    if (!connected(state))
+        return closeErrorText(state);
+    if (state.open.status !== 'open' || state.rootSessionId === null)
+        return NOT_OPEN;
+    return undefined;
+}
+/** `agent_set_config_option{id, configId, value}` — `setConfigOptionRequest`'s request half. */
+export function onSetConfigOptionNote(state, note, out) {
+    const { id, configId, value } = note;
+    if (typeof id !== 'string' || typeof configId !== 'string' || (typeof value !== 'string' && typeof value !== 'boolean')) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    const fail = (error) => out.unjournaled({ t: 'agent_config_option_set', id, ok: false, error });
+    const unusable = sessionReady(state);
+    if (unusable !== undefined)
+        return fail(unusable);
+    const sessionId = state.rootSessionId;
+    const ctx = { id, configId, value };
+    if (configId === SYNTHESIZED_MODES_CONFIG_ID) {
+        if (typeof value !== 'string')
+            return fail(`[acp] ${SYNTHESIZED_MODES_CONFIG_ID} takes a mode id (a string), got ${typeof value}`);
+        request(state, out, 'session/set_mode', { sessionId, modeId: value }, 'config', ctx);
+        return;
+    }
+    // 合成的模型控件走 unstable 的专用 RPC，与 set_mode 同一条保留 id 的路由规则。hermes 回合进行中
+    // 会拒绝（"Session is busy"），那正是 settle 的错误支要说的话。
+    if (configId === SYNTHESIZED_MODEL_CONFIG_ID) {
+        if (typeof value !== 'string')
+            return fail(`[acp] ${SYNTHESIZED_MODEL_CONFIG_ID} takes a model id (a string), got ${typeof value}`);
+        request(state, out, 'session/set_model', { sessionId, modelId: value }, 'config', ctx);
+        return;
+    }
+    request(state, out, 'session/set_config_option', typeof value === 'boolean' ? { sessionId, configId, type: 'boolean', value } : { sessionId, configId, value }, 'config', ctx);
+}
+/** The set settled — `setConfigOptionRequest`'s snapshot rules, then `agent_config_option_set`. */
+export function settleConfig(state, entry, settlement, out) {
+    const { id, configId, value } = entry.ctx;
+    if (settlement.outcome !== 'result') {
+        out.unjournaled({ t: 'agent_config_option_set', id, ok: false,
+            error: settlement.outcome === 'error' ? settlement.error.message : closeErrorText(state) });
+        return;
+    }
+    const current = state.configOptions ?? [];
+    let next;
+    if (entry.method === 'session/set_mode') {
+        next = current.map((option) => (option.id === configId && option.type === 'select' ? { ...option, currentValue: value } : option));
+    }
+    else if (entry.method === 'session/set_model') {
+        // hermes 的 SetSessionModelResponse 是空对象（切完不回快照、也不推更新），与 set_mode 同款：
+        // 本地把 currentValue 换成刚设的值；agent 若将来回了新状态，也只会被下一次 open 快照纠回真相。
+        next = current.map((option) => (option.id === configId && option.type === 'select' ? { ...option, currentValue: value } : option));
+    }
+    else {
+        const result = isRecord(settlement.result) ? settlement.result : {};
+        const reNormalized = normalizeConfigOptions(result.configOptions, null);
+        // 两个合成控件（modes、model）都不在 agent 自己的 configOptions 里，re-normalize 会把它们丢掉；
+        // 只要 agent 的新快照里还没有能替代它们的控件，就原样携带。
+        next = reNormalized.concat(current.filter((option) => (option.id === SYNTHESIZED_MODES_CONFIG_ID
+            && !modesAlreadyRepresented(reNormalized, flatChoicesOf(option) ?? []))
+            || (option.id === SYNTHESIZED_MODEL_CONFIG_ID && !modelsAlreadyRepresented(reNormalized))));
+    }
+    state.configOptions = next;
+    out.unjournaled({ t: 'agent_config_option_set', id, ok: true, configOptions: next });
+}
+// ---- steering -----------------------------------------------------------------------------------
+/** `agent_steer{id, blocksRef, priority?}` — `steerRequest`, blocks filled by the executor. */
+export function onSteerNote(state, note, out) {
+    const { id, blocksRef, priority } = note;
+    if (typeof id !== 'string' || id === '' || typeof blocksRef !== 'string' || blocksRef === ''
+        || (priority !== undefined && typeof priority !== 'string')) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    const unusable = sessionReady(state);
+    if (unusable !== undefined) {
+        out.unjournaled({ t: 'agent_steered', id, ok: false, error: unusable });
+        return;
+    }
+    if (getOwn(state.steers, id)) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    const pending = request(state, out, STEER_METHOD, {
+        sessionId: state.rootSessionId,
+        prompt: [],
+        _meta: { steering: { idleBehavior: 'promptRequired', ...(priority === undefined ? {} : { priority }) } },
+    }, 'steer', { id }, { fill: { blocksRef } });
+    putOwn(state.steers, id, { requestId: pending.id, cause: pending.cause, sent: false });
+}
+/** A `down` record: a queued steer's line reached the agent. */
+export function onSteerDown(state, record) {
+    const cause = record.annotation?.cause;
+    if (!cause)
+        return;
+    for (const steer of Object.values(state.steers)) {
+        if (!steer.sent && sameCause(cause, steer.cause))
+            steer.sent = true;
+    }
+}
+function rememberSteered(state, id) {
+    state.steered.push(id);
+    if (state.steered.length > STEERED_HISTORY_LIMIT)
+        state.steered.splice(0, state.steered.length - STEERED_HISTORY_LIMIT);
+}
+/** The steer settled: `agent_steered`, with `mapSteerOutcome`'s narrowing (a throw is a failed reply). */
+export function settleSteer(state, entry, settlement, out) {
+    const { id } = entry.ctx;
+    delete state.steers[id];
+    if (settlement.outcome !== 'result') {
+        out.unjournaled({ t: 'agent_steered', id, ok: false,
+            error: settlement.outcome === 'error' ? settlement.error.message : closeErrorText(state) });
+        return;
+    }
+    let outcome;
+    try {
+        outcome = mapSteerOutcome(settlement.result);
+    }
+    catch (error) {
+        out.unjournaled({ t: 'agent_steered', id, ok: false, error: error instanceof Error ? error.message : String(error) });
+        return;
+    }
+    if (outcome === 'injected')
+        rememberSteered(state, id);
+    out.unjournaled({ t: 'agent_steered', id, ok: true, outcome });
+}
+/** `agent_prompt_failed` for a steer whose blocks were gone: it never reached the agent. */
+export function failUnsentSteer(state, entry, error, out) {
+    const { id } = entry.ctx;
+    const steer = getOwn(state.steers, id);
+    if (!steer || steer.sent)
+        return false;
+    delete state.outbound[String(entry.id)];
+    delete state.steers[id];
+    out.unjournaled({ t: 'agent_steered', id, ok: false, error });
+    return true;
+}
+/** `agent_opened.steeredIds` (spec §5.5.4): see the file header. */
+export function steeredIds(state) {
+    const inFlight = Object.entries(state.steers).filter(([, steer]) => steer.sent).map(([id]) => id);
+    return [...state.steered, ...inFlight];
+}
+// ---- background tasks, delegation, launch -------------------------------------------------------
+/** `agent_async_task_stop{asyncTaskId}` — `asyncTaskStopRequest`; its answer is diagnostics only. */
+export function onAsyncTaskStopNote(state, note, out) {
+    const { asyncTaskId } = note;
+    if (typeof asyncTaskId !== 'string' || !asyncTaskId.trim() || sessionReady(state) !== undefined) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    request(state, out, ASYNC_TASK_STOP_METHOD, { sessionId: state.rootSessionId, asyncTaskId }, 'rpc', undefined);
+}
+/**
+ * `agent_delegation_renewed{expiresAtEpochMs, renewalRevision}` — a renewal the daemon accepted
+ * (`agent_delegation_renew`'s checks read the clock, so the decision is the daemon's; the note is
+ * its record).
+ */
+export function onDelegationRenewedNote(state, note) {
+    const { expiresAtEpochMs, renewalRevision } = note;
+    const delegation = state.delegation;
+    if (!delegation || delegation.bindingId === undefined || !Number.isSafeInteger(expiresAtEpochMs) || !Number.isSafeInteger(renewalRevision)) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    delegation.expiresAtEpochMs = expiresAtEpochMs;
+    delegation.renewalRevision = renewalRevision;
+}
+/** `agent_delegation_refresh_pending{}` — a refreshed lease waits for the session to go idle. */
+export function onDelegationRefreshPendingNote(state) {
+    if (!state.delegation) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    state.delegation.refreshPending = true;
+}
+/** `agent_launch{launch}` (see `runtime.ts`). */
+export function onLaunch(state, note) {
+    if (!onLaunchNote(state, note.launch))
+        state.diagnostics.droppedNotes += 1;
+}
+/**
+ * `agent_install_outcome{ok, agentName, version, error?}` (Task 20): the adapter install an open had to run first finished within
+ * the open's budget (spec §6.2). The daemon writes it right after `agent_launch`; it becomes one past-tense `step` on the session's
+ * timeline, numbered like any other event — the words the manager used to journal itself (interface-contracts, 15a/15c).
+ */
+export function onInstallOutcomeNote(state, note, out) {
+    const { ok, agentName, version, error } = note;
+    if (typeof ok !== 'boolean' || typeof agentName !== 'string' || typeof version !== 'string' || (!ok && typeof error !== 'string')) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    emitEvent(state, out, {
+        eventName: 'step',
+        payload: ok
+            ? { title: 'Agent adapter', message: `Installed ${agentName} adapter ${version}`, tone: 'neutral' }
+            : { title: 'Agent adapter', message: `Could not install ${agentName} adapter ${version}`, detail: error, tone: 'error' },
+    });
+}
+/**
+ * `agent_output_gap{detail}` (Task 21): this session numbers on in a transport other than the one an earlier life of the ref ran in,
+ * and that life's unacknowledged output could not be read (keeper-acp unreachable while the session runs in the daemon) — its frames
+ * may never reach the server. The daemon seeded the seq above everything that life may have numbered (spec §5.5), so nothing is
+ * reused; this past-tense `step` says that output may be missing.
+ */
+export function onOutputGapNote(state, note, out) {
+    const { detail } = note;
+    if (typeof detail !== 'string' || detail.length === 0) {
+        state.diagnostics.droppedNotes += 1;
+        return;
+    }
+    emitEvent(state, out, {
+        eventName: 'step',
+        payload: { title: 'Agent session', message: 'Earlier output of this session could not be recovered', detail, tone: 'error' },
+    });
+}

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

@@ -0,0 +1,26 @@
+import { validateWireEvent } from '../validate.js';
+export function nextSeq(state) {
+    state.seq += 1;
+    return state.seq;
+}
+/**
+ * A journaled `agent_event` (the wire frame minus `sessionRef`, which the projection adds). Returns
+ * whether it was emitted.
+ */
+export function emitEvent(state, out, event) {
+    if (validateWireEvent(event)) {
+        state.diagnostics.invalidEvents += 1;
+        return false;
+    }
+    out.frame({
+        t: 'agent_event',
+        seq: nextSeq(state),
+        eventName: event.eventName,
+        payload: event.payload,
+        ...(event.acpSessionId ? { acpSessionId: event.acpSessionId } : {}),
+    });
+    return true;
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,172 @@
+/**
+ * Synchronous JSON-RPC for the processor: id allocation, message classification, response
+ * correlation, and the exact bytes of every line it writes.
+ *
+ * ## Why the processor does this itself
+ *
+ * Today the SDK's `Connection` owns JSON-RPC, and its correlation is a per-connection counter from 0
+ * kept in a `Map` that dies with the process. Re-attaching to a still-running adapter with a fresh
+ * connection therefore reuses ids, and a late response to a previous daemon's `session/prompt`
+ * resolves whatever new request happens to hold the same number — measured in
+ * `docs/superpowers/reports/2026-10-11-keepers-analysis/experiments/exp-reattach.mjs naive`, where the
+ * new connection's third `_test/slow` call resolved to `{"stopReason":"end_turn"}`.
+ *
+ * Here:
+ * - every outbound request id is `o * 16 + i` ({@link outboundRequestId}) — numeric, strictly
+ *   increasing along the log, and therefore never reused by any daemon generation reading the same
+ *   log;
+ * - a response is matched only against the processor's own pending table, keyed by that id. An id
+ *   the table does not hold is an **orphan**: it is counted and never attributed to anything else.
+ *
+ * ## Same semantics as the SDK, on purpose
+ *
+ * Every shape below mirrors `@agentclientprotocol/sdk` 1.4.0 `dist/jsonrpc.js` / `dist/stream.js`, so
+ * moving a session onto the processor changes nothing an adapter or the server can observe:
+ * - classification follows `receiveWireMessage`/`receiveMessage` (`isRequestMessage`,
+ *   `isNotificationMessage`, `isResponseShapedMessage`, `isJsonRpcId`);
+ * - an unparseable line answers `-32700 Parse error`, a non-message `-32600 Invalid request`, both
+ *   with `id: null` (`protocolErrorResponse`);
+ * - a response-shaped message for a pending id that is not a valid response settles that request
+ *   as `RequestError.invalidRequest(response)` (`handleResponse`);
+ * - an error response settles with `{code, message, data}` exactly as `new RequestError(code, message,
+ *   data)` would, and {@link settlementErrorCode} applies `jsonRpcErrorCode`'s rule to it;
+ * - an unhandled inbound request answers `RequestError.methodNotFound(method)`, a zod failure
+ *   `RequestError.invalidParams(error.format())`.
+ */
+import { jsonRpcErrorCodeOf } from '../initializeResponse.js';
+export const CANCEL_REQUEST_METHOD = '$/cancel_request';
+/** Requests one record may send: their `i` ranges over `[0, 16)` so `o * 16 + i` is collision-free. */
+export const COMMANDS_PER_RECORD = 16;
+/**
+ * Commands of any kind one record may produce. Responses and notifications take no id, so only the
+ * first 16 commands may be requests; the rest (e.g. an interrupt cancelling 64 pending permission
+ * cards) only need a unique `(o, i)` cause for idempotency.
+ */
+export const MAX_COMMANDS_PER_RECORD = 256;
+export class CommandBudgetExceededError extends Error {
+}
+/**
+ * The JSON-RPC id of the request a record's `i`-th command sends (spec §5.4).
+ *
+ * Throws rather than wrapping: a 17th command from one record would collide with the next record's
+ * first id, which is precisely the defect this scheme exists to make impossible.
+ */
+export function outboundRequestId(cause) {
+    const { o, i } = cause;
+    if (!Number.isSafeInteger(o) || o < 0)
+        throw new CommandBudgetExceededError(`record offset ${o} is not a non-negative integer`);
+    if (!Number.isInteger(i) || i < 0 || i >= COMMANDS_PER_RECORD) {
+        throw new CommandBudgetExceededError(`record ${o} produced command #${i}; at most ${COMMANDS_PER_RECORD} commands per record`);
+    }
+    const id = o * COMMANDS_PER_RECORD + i;
+    if (!Number.isSafeInteger(id))
+        throw new CommandBudgetExceededError(`record offset ${o} is too large for a safe JSON-RPC id`);
+    return id;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function isJsonRpcId(value) {
+    return value === null || typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value));
+}
+function isEnvelope(value) {
+    return isRecord(value) && value.jsonrpc === '2.0';
+}
+function isRequestMessage(value) {
+    return isEnvelope(value) && 'id' in value && typeof value.method === 'string' && isJsonRpcId(value.id);
+}
+function isNotificationMessage(value) {
+    return isEnvelope(value) && !('id' in value) && typeof value.method === 'string';
+}
+function isResponseShaped(value) {
+    return !('method' in value) && ('id' in value || 'result' in value || 'error' in value);
+}
+function isErrorObject(value) {
+    return isRecord(value) && typeof value.code === 'number' && Number.isInteger(value.code) && typeof value.message === 'string';
+}
+/** The SDK's `isResponseMessage`: exactly one of `result`/`error`, a valid id, a well-formed error. */
+function isValidResponse(value) {
+    if (!isEnvelope(value) || 'method' in value)
+        return false;
+    if (!('id' in value) || !isJsonRpcId(value.id))
+        return false;
+    const hasResult = Object.hasOwn(value, 'result');
+    const hasError = Object.hasOwn(value, 'error');
+    if (hasResult === hasError)
+        return false;
+    return !hasError || isErrorObject(value.error);
+}
+/** Classify one adapter stdout line the way the SDK's stream + connection would. */
+export function classifyLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return { type: 'empty' };
+    let message;
+    try {
+        message = JSON.parse(trimmed);
+    }
+    catch {
+        return { type: 'parse_error' };
+    }
+    if (Array.isArray(message))
+        return { type: 'batch', raw: message };
+    if (!isRecord(message))
+        return { type: 'invalid', raw: message };
+    if (isRequestMessage(message)) {
+        return { type: 'request', id: message.id, method: message.method, params: message.params, raw: message };
+    }
+    if (isNotificationMessage(message)) {
+        return { type: 'notification', method: message.method, params: message.params, raw: message };
+    }
+    if (isResponseShaped(message)) {
+        return 'id' in message ? { type: 'response', id: message.id, raw: message } : { type: 'unaddressed', raw: message };
+    }
+    return { type: 'invalid', raw: message };
+}
+/** Turn a response for a pending id into its settlement — `handleResponse`'s three branches. */
+export function settlementOf(response) {
+    if (!isValidResponse(response))
+        return { outcome: 'error', error: invalidRequest(response) };
+    if (Object.hasOwn(response, 'result'))
+        return { outcome: 'result', result: response.result };
+    const { code, message, data } = response.error;
+    return { outcome: 'error', error: { code, message, data } };
+}
+/** `jsonRpcErrorCode(err)` for a settlement: the code an agent answered with, if a frame may carry it. */
+export function settlementErrorCode(settlement) {
+    return settlement.outcome === 'error' ? jsonRpcErrorCodeOf(settlement.error.code) : undefined;
+}
+/** The key a numeric outbound id is stored under; only numbers can ever match our own ids. */
+export function outboundKey(id) {
+    return typeof id === 'number' && Number.isSafeInteger(id) ? String(id) : undefined;
+}
+/** The key an inbound (agent-allocated) id is stored under — type-tagged, as the SDK's `Map` keys are. */
+export function inboundKey(id) {
+    return JSON.stringify(id);
+}
+// ---- error objects, exactly as `RequestError.<factory>(…).toErrorResponse()` spells them ----------
+export function parseError() {
+    return { code: -32700, message: 'Parse error', data: undefined };
+}
+export function invalidRequest(data) {
+    return { code: -32600, message: 'Invalid request', data };
+}
+export function methodNotFound(method) {
+    return { code: -32601, message: `"Method not found": ${method}`, data: { method } };
+}
+export function invalidParams(data) {
+    return { code: -32602, message: 'Invalid params', data };
+}
+// ---- lines, with the SDK's key order (`{jsonrpc, id, method, params}`, `{jsonrpc, id, ...result}`) ----
+export function requestLine(id, method, params) {
+    return JSON.stringify({ jsonrpc: '2.0', id, method, params });
+}
+export function notificationLine(method, params) {
+    return JSON.stringify({ jsonrpc: '2.0', method, params });
+}
+export function resultLine(id, result) {
+    return JSON.stringify({ jsonrpc: '2.0', id, result: result ?? null });
+}
+export function errorLine(id, error) {
+    return JSON.stringify({ jsonrpc: '2.0', id, error });
+}

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

@@ -0,0 +1,49 @@
+import { causeKey } from './record.js';
+export class MemoryRawLog {
+    clock;
+    stdin;
+    records = [];
+    downsByCause = new Map();
+    /**
+     * @param clock the keeper-receive time stamped on each appended record.
+     * @param stdin where `writeDown` delivers the line, standing in for the adapter's stdin.
+     */
+    constructor(clock, stdin = () => { }) {
+        this.clock = clock;
+        this.stdin = stdin;
+    }
+    /** The offset the next record will get (one past the last). */
+    get head() {
+        return this.records.length;
+    }
+    /** The spawn this "keeper" runs now (from its own `proc` records), or `null`. */
+    running = null;
+    append(entry) {
+        const record = { ...entry, o: this.records.length, t: this.clock() };
+        this.records.push(record);
+        if (record.kind === 'proc')
+            this.running = record.proc.type === 'spawn' ? record.proc.spawnId : null;
+        if (record.kind === 'down' && record.annotation)
+            this.downsByCause.set(causeKey(record.annotation.cause), record);
+        return record;
+    }
+    /** Records with `o >= from`, at most `limit` of them, in order. */
+    read(from, limit = Number.POSITIVE_INFINITY) {
+        return this.records.slice(Math.max(0, from), Math.min(this.records.length, Math.max(0, from) + limit));
+    }
+    hasDown(cause) {
+        return this.downsByCause.has(causeKey(cause));
+    }
+    writeDown(command) {
+        if (command.spawnId !== this.running)
+            return 'refused';
+        this.stdin(command.line);
+        this.append({
+            kind: 'down',
+            line: command.line,
+            annotation: { ...command.annotation, cause: command.cause, spawnId: command.spawnId },
+            ...(command.redact !== undefined ? { redact: command.redact } : {}),
+        });
+        return 'written';
+    }
+}

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

@@ -0,0 +1,48 @@
+/**
+ * The permission-origin graph (Task 17a, moved here in 17b): which native sessions may ask for
+ * permission — the root, and children with a complete `subagent_spawned` path to it
+ * (`AcpSession.observePermissionOrigin`). Fed by every mapped `subagent_spawned` event, live or load
+ * history (`observeReplayEvent`), in log order.
+ */
+import { getOwn, putOwn, UNRESOLVED_ORIGIN_LIMIT } from './state.js';
+/**
+ * `AcpSession.observePermissionOrigin`, over plain records. `root` is the bound root session, or —
+ * inside a load's history window, before the load response binds it — the session being loaded.
+ */
+export function observeSubagentSpawned(state, parent, child, root = state.rootSessionId) {
+    const reject = () => { state.diagnostics.rejectedRelations += 1; };
+    if (typeof parent !== 'string' || !parent.trim() || typeof child !== 'string' || !child.trim())
+        return reject();
+    if (child === parent || child === root)
+        return reject();
+    const existing = getOwn(state.permissionParents, child);
+    if (existing !== undefined) {
+        if (existing !== parent)
+            reject();
+        return;
+    }
+    for (let ancestor = parent; ancestor !== undefined; ancestor = getOwn(state.permissionParents, ancestor)) {
+        if (ancestor === child)
+            return reject();
+    }
+    const trusted = parent === root || getOwn(state.permissionOrigins, parent) === true;
+    if (!trusted && Object.keys(state.unresolvedPermissionOrigins).length >= UNRESOLVED_ORIGIN_LIMIT)
+        return reject();
+    putOwn(state.permissionParents, child, parent);
+    if (!trusted) {
+        putOwn(state.unresolvedPermissionOrigins, child, true);
+        return;
+    }
+    putOwn(state.permissionOrigins, child, true);
+    let promoted;
+    do {
+        promoted = false;
+        for (const candidate of Object.keys(state.unresolvedPermissionOrigins)) {
+            if (getOwn(state.permissionOrigins, getOwn(state.permissionParents, candidate))) {
+                delete state.unresolvedPermissionOrigins[candidate];
+                putOwn(state.permissionOrigins, candidate, true);
+                promoted = true;
+            }
+        }
+    } while (promoted);
+}