@platless/axom-cli 0.3.13 → 0.6.36

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

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

@@ -0,0 +1,67 @@
+/**
+ * What one record produced: its down commands (each with its `(o, i)` cause) and its frames (each with
+ * its `(o, i)` src). Shared by `step.ts` (connection layer) and `session.ts` (turns and cards).
+ */
+import { CommandBudgetExceededError, MAX_COMMANDS_PER_RECORD, errorLine, notificationLine, outboundRequestId, requestLine, resultLine, } from './jsonrpc.js';
+/** A command was produced with no running adapter process to address it to — a processor bug. */
+export class CommandWithoutSpawnError extends Error {
+}
+export class RecordOutput {
+    o;
+    spawnId;
+    commands = [];
+    frames = [];
+    /**
+     * @param spawnId the running spawn **when a command is pushed** (read then, not at construction: a
+     * `spawn` record closes the old process and addresses its `initialize` to the new one).
+     */
+    constructor(o, spawnId = () => undefined) {
+        this.o = o;
+        this.spawnId = spawnId;
+    }
+    push(line, extras = {}) {
+        const i = this.commands.length;
+        if (i >= MAX_COMMANDS_PER_RECORD) {
+            throw new CommandBudgetExceededError(`record ${this.o} produced more than ${MAX_COMMANDS_PER_RECORD} commands`);
+        }
+        const spawnId = this.spawnId();
+        if (spawnId === undefined)
+            throw new CommandWithoutSpawnError(`record ${this.o} produced a command with no running adapter process`);
+        const cause = { o: this.o, i };
+        this.commands.push({
+            cause,
+            spawnId,
+            line: line(i),
+            ...(extras.annotation !== undefined ? { annotation: extras.annotation } : {}),
+            ...(extras.fill !== undefined ? { fill: extras.fill } : {}),
+            ...(extras.redact !== undefined ? { redact: extras.redact } : {}),
+        });
+        return cause;
+    }
+    /** Throws `CommandBudgetExceededError` once this record already produced 16 commands (`outboundRequestId`). */
+    request(method, params, extras) {
+        let id = -1;
+        const cause = this.push((index) => {
+            id = outboundRequestId({ o: this.o, i: index });
+            return requestLine(id, method, params);
+        }, extras);
+        return { id, cause };
+    }
+    notify(method, params) {
+        this.push(() => notificationLine(method, params));
+    }
+    result(id, result) {
+        this.push(() => resultLine(id, result));
+    }
+    error(id, error) {
+        this.push(() => errorLine(id, error));
+    }
+    /** A journaled frame; the caller has already numbered it. */
+    frame(frame) {
+        this.frames.push({ journaled: true, frame, src: { o: this.o, i: this.frames.length } });
+    }
+    /** An unnumbered frame: a level, an RPC reply, or a `processor.*` frame for the daemon. */
+    unjournaled(frame) {
+        this.frames.push({ journaled: false, frame, src: { o: this.o, i: this.frames.length } });
+    }
+}

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

@@ -0,0 +1,42 @@
+import { AGENT_WIRE_RUNTIME_PROFILE_VERSION, AGENT_WIRE_SCOPED_ORIGIN_VERSION, AGENT_WIRE_SESSION_AUTH_METHODS_VERSION, AGENT_WIRE_SESSION_STATE_VERSION, } from '../../protocol/agent.js';
+function withSessionRef(frame, sessionRef) {
+    const { t, ...rest } = frame;
+    return { t, sessionRef, ...rest };
+}
+export function projectFrame(output, context) {
+    const frame = output.frame;
+    const t = frame.t;
+    if (typeof t !== 'string' || t.startsWith('processor.'))
+        return { frame: null };
+    const wire = context.serverAgentWire;
+    switch (t) {
+        case 'agent_event': {
+            if (frame.acpSessionId !== undefined && wire < AGENT_WIRE_SCOPED_ORIGIN_VERSION) {
+                const payload = frame.payload;
+                if (frame.eventName === 'permission_request' && typeof payload?.requestId === 'string') {
+                    return { frame: null, note: { type: 'agent_answer_undeliverable', requestId: payload.requestId } };
+                }
+                return { frame: null };
+            }
+            return { frame: withSessionRef(frame, context.sessionRef) };
+        }
+        case 'agent_turn_done': {
+            const { agentRefused, errorCode, ...rest } = frame;
+            const projected = withSessionRef(rest, context.sessionRef);
+            if (agentRefused === true && rest.status === 'failed' && wire >= AGENT_WIRE_SESSION_AUTH_METHODS_VERSION) {
+                if (context.authMethods)
+                    projected.authMethods = context.authMethods;
+                if (typeof errorCode === 'number')
+                    projected.errorCode = errorCode;
+            }
+            return { frame: projected };
+        }
+        case 'agent_session_state':
+            return { frame: wire >= AGENT_WIRE_SESSION_STATE_VERSION ? withSessionRef(frame, context.sessionRef) : null };
+        case 'agent_runtime_profile':
+            return { frame: wire >= AGENT_WIRE_RUNTIME_PROFILE_VERSION ? withSessionRef(frame, context.sessionRef) : null };
+        default:
+            // RPC replies carry the server's request `id`, not a `sessionRef`.
+            return { frame: { ...frame } };
+    }
+}

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

@@ -0,0 +1,128 @@
+/**
+ * The raw records the ACP processor folds over (spec 2026-10-11 §5.3), and their on-stream spelling.
+ *
+ * ## Two spellings, one record
+ *
+ * keeper-acp stores each record as one line of a kit stream (`{o, t, k, …}`, §3.4) with short keys
+ * (`up{l}`, `down{l, a, redact?}`, `proc{kind, …}`, `note{n}`, `err{l}` — the names in
+ * interface-contracts). The processor works on the long, typed spelling below. {@link encodeStreamRecord}
+ * and {@link decodeStreamRecord} are the only bridge, so neither side has to know the other's names.
+ *
+ * ## What each kind is
+ *
+ * - `up`: one line the adapter wrote to stdout — a JSON-RPC message, verbatim.
+ * - `down`: one line written to the adapter's stdin. `annotation.cause = {o, i}` names the record
+ *   (and the command index within it) whose processing produced the line; that is what makes
+ *   commands idempotent (`commands.ts`). `annotation` is otherwise opaque to the keeper. `redact`
+ *   lists the `secretRef`s whose values were replaced in the *logged* copy of the line — stdin got
+ *   the real value, the log never does (§13). It names refs, never secrets.
+ * - `proc`: keeper-synthesised process events — `spawn{spawnId, pid, pgid, startTime}` and
+ *   `exit{code, signal, stderrTail, reason?}`.
+ * - `note`: an opaque record the daemon wrote (server commands, its own decisions). Notes carry no
+ *   secrets and no large payloads (§5.4): secrets by `secretRef`, large blocks by reference to the
+ *   one `down` record that carries them.
+ * - `err`: one already-redacted stderr line.
+ *
+ * `o` is the record's offset in the session's raw stream (monotonic, gap-free per stream) and `t` is
+ * the keeper's receive time in epoch ms — the **only** clock the processor may read.
+ */
+export function sameCause(a, b) {
+    return a !== undefined && a.o === b.o && a.i === b.i;
+}
+/** The map key for a cause; `o` and `i` are integers so this is injective. */
+export function causeKey(cause) {
+    return `${cause.o}:${cause.i}`;
+}
+export class MalformedRecordError extends Error {
+}
+export function encodeStreamRecord(record) {
+    const { o, t } = record;
+    switch (record.kind) {
+        case 'up':
+            return { o, t, k: 'up', l: record.line };
+        case 'down':
+            return {
+                o, t, k: 'down', l: record.line,
+                ...(record.annotation !== undefined ? { a: record.annotation } : {}),
+                ...(record.redact !== undefined ? { redact: record.redact } : {}),
+            };
+        case 'proc': {
+            const { type, ...rest } = record.proc;
+            return { o, t, k: 'proc', kind: type, ...rest };
+        }
+        case 'note':
+            return { o, t, k: 'note', n: record.note };
+        case 'err':
+            return { o, t, k: 'err', l: record.line };
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function str(value, what) {
+    if (typeof value !== 'string')
+        throw new MalformedRecordError(`${what} is not a string`);
+    return value;
+}
+/** Inverse of {@link encodeStreamRecord}. Throws {@link MalformedRecordError} on anything else. */
+export function decodeStreamRecord(value) {
+    if (!isRecord(value))
+        throw new MalformedRecordError('record is not an object');
+    const { o, t, k } = value;
+    if (typeof o !== 'number' || !Number.isSafeInteger(o) || o < 0)
+        throw new MalformedRecordError('record offset is not a non-negative integer');
+    if (typeof t !== 'number' || !Number.isFinite(t))
+        throw new MalformedRecordError('record time is not a number');
+    switch (k) {
+        case 'up':
+            return { o, t, kind: 'up', line: str(value.l, 'up.l') };
+        case 'err':
+            return { o, t, kind: 'err', line: str(value.l, 'err.l') };
+        case 'down': {
+            const a = value.a;
+            let annotation;
+            if (a !== undefined) {
+                if (!isRecord(a) || !isRecord(a.cause) || !Number.isSafeInteger(a.cause.o) || !Number.isSafeInteger(a.cause.i)) {
+                    throw new MalformedRecordError('down.a.cause is not {o, i}');
+                }
+                annotation = a;
+            }
+            const redact = value.redact;
+            if (redact !== undefined && !(Array.isArray(redact) && redact.every((r) => typeof r === 'string'))) {
+                throw new MalformedRecordError('down.redact is not a string array');
+            }
+            return {
+                o, t, kind: 'down', line: str(value.l, 'down.l'),
+                ...(annotation !== undefined ? { annotation } : {}),
+                ...(redact !== undefined ? { redact: redact } : {}),
+            };
+        }
+        case 'proc': {
+            if (value.kind === 'spawn') {
+                const { spawnId, pid, pgid, startTime } = value;
+                if (typeof spawnId !== 'string' || typeof pid !== 'number' || typeof pgid !== 'number'
+                    || (typeof startTime !== 'string' && typeof startTime !== 'number')) {
+                    throw new MalformedRecordError('proc spawn is missing spawnId/pid/pgid/startTime');
+                }
+                return { o, t, kind: 'proc', proc: { type: 'spawn', spawnId, pid, pgid, startTime } };
+            }
+            if (value.kind === 'exit') {
+                const { code, signal, stderrTail, reason } = value;
+                if ((code !== null && typeof code !== 'number') || (signal !== null && typeof signal !== 'string')
+                    || typeof stderrTail !== 'string' || (reason !== undefined && typeof reason !== 'string')) {
+                    throw new MalformedRecordError('proc exit is missing code/signal/stderrTail');
+                }
+                return { o, t, kind: 'proc', proc: { type: 'exit', code, signal, stderrTail, ...(reason !== undefined ? { reason } : {}) } };
+            }
+            throw new MalformedRecordError(`unknown proc kind ${JSON.stringify(value.kind)}`);
+        }
+        case 'note': {
+            const n = value.n;
+            if (!isRecord(n) || typeof n.type !== 'string')
+                throw new MalformedRecordError('note.n has no string type');
+            return { o, t, kind: 'note', note: n };
+        }
+        default:
+            throw new MalformedRecordError(`unknown record kind ${JSON.stringify(k)}`);
+    }
+}

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

@@ -0,0 +1,105 @@
+const connectionGeneration = (spawnId) => `session:${spawnId}`;
+import { claudeActivityRaw } from '../activityReporting.js';
+import { isRecord } from './emit.js';
+import { initialRuntime } from './state.js';
+function opened(state) {
+    return state.open.status === 'open';
+}
+/** One agent-reported activity push (vendor-verbatim): a level, never numbered. */
+export function reportActivity(state, out, raw, t) {
+    if (!opened(state))
+        return;
+    state.activity = { raw, t };
+    out.unjournaled({ t: 'agent_session_state', vendor: vendorOf(state), raw });
+}
+/** `InitializeResponse.agentInfo.name` (`agentSessions.ts`'s `vendor`), `''` when the agent named none. */
+export function vendorOf(state) {
+    return state.initialize.status === 'ready' ? state.initialize.facts.agentInfo?.name ?? '' : '';
+}
+/** `_claude/sdkMessage` — only the `session_state_changed` system message is activity. */
+export function onClaudeSdkMessage(state, out, params, t) {
+    const raw = claudeActivityRaw(isRecord(params) ? params : {});
+    if (raw)
+        reportActivity(state, out, raw, t);
+}
+/** `agent_opened.activityRaw`: the last push, if any. */
+export function activityRaw(state) {
+    return state.activity?.raw;
+}
+/** The current adapter process's `spawnId` (running, or the one that exited). */
+export function currentSpawnId(state) {
+    return state.process.status === 'running' ? state.process.spawn.spawnId
+        : state.process.status === 'exited' ? state.process.spawnId : undefined;
+}
+/**
+ * `AgentRuntimeDiagnostics.callbacks` — the snapshot `AcpSession.publishCallbacks` last published,
+ * recomputed from state (every change to the cards it lists publishes, so the two are the same), or
+ * `undefined` before the first publish. Pending and settled are listed only while `complete`.
+ */
+export function callbackSnapshot(state) {
+    const { complete, rootSessionId } = state.callbacks;
+    const spawnId = currentSpawnId(state);
+    if (rootSessionId === null || spawnId === undefined)
+        return undefined;
+    return {
+        rootSessionId, connectionGeneration: connectionGeneration(spawnId), complete,
+        pending: complete ? Object.values(state.permissions).map((card) => ({
+            requestId: card.requestId, originNativeSessionId: card.origin, rpcRequestId: card.rpcRequestId,
+        })) : [],
+        settled: complete ? state.settledPermissions.map(({ requestId, reason }) => ({ requestId, reason })) : [],
+    };
+}
+/** The diagnostics as `agent_runtime_profile`/`agent_opened.runtimeDiagnostics` carry them, or `undefined` before a spawn and its `agent_launch` note. */
+export function runtimeDiagnostics(state) {
+    const spawnId = currentSpawnId(state);
+    const { revision, available, launch } = state.runtime;
+    if (spawnId === undefined || launch === undefined)
+        return undefined;
+    const callbacks = callbackSnapshot(state);
+    return { generation: spawnId, revision, available, launch,
+        ...(callbacks !== undefined ? { callbacks } : {}) };
+}
+/**
+ * `AcpSession.publishCallbacks` → `connectAgent`'s `publishCallbacks`: the snapshot changed, the
+ * revision goes up and the level is re-sent. Ignored before a root is known (today: a snapshot for a
+ * session the connection has not bound). Callers change the cards first, then publish.
+ */
+export function publishCallbacks(state, out) {
+    const root = state.rootSessionId ?? state.history?.rootSessionId ?? null;
+    if (root === null)
+        return;
+    state.callbacks.rootSessionId = root;
+    state.runtime.revision += 1;
+    changed(state, out);
+}
+/** A diagnostics change: published (unnumbered) once the session is open, as `onRuntimeDiagnostics` is. */
+function changed(state, out) {
+    if (!opened(state))
+        return;
+    const diagnostics = runtimeDiagnostics(state);
+    if (diagnostics)
+        out.unjournaled({ t: 'agent_runtime_profile', diagnostics: JSON.parse(JSON.stringify(diagnostics)) });
+}
+export function resetRuntime(state) {
+    state.runtime = initialRuntime();
+    state.activity = null;
+}
+/** `agent_launch{launch}` — what `connectAgent` computes at spawn (`launchSource`, `findOnPath`, platform). */
+export function onLaunchNote(state, launch) {
+    if (!isRecord(launch) || state.process.status !== 'running')
+        return false;
+    const { source, executable, platform, architecture, transport } = launch;
+    if (!['command-override', 'registry', 'registry-fallback', 'direct'].includes(source) || typeof executable !== 'string'
+        || typeof platform !== 'string' || typeof architecture !== 'string' || transport !== 'stdio')
+        return false;
+    state.runtime.launch = { source: source, executable: executable.slice(0, 4096), platform, architecture, transport };
+    return true;
+}
+/** The child exited: unavailable, profile no longer observed (`child.once('exit')` in `connectAgent`). */
+export function onProcessExit(state, out) {
+    const runtime = state.runtime;
+    runtime.revision += 1;
+    runtime.available = false;
+    changed(state, out);
+}
+/** The root just bound (`bindDraftUpdates`' diagnostics half): drop a profile for another root, apply a pending one. */