@code-yeongyu/senpi 2026.10.25-4 → 2026.10.26-1

package/dist/modes/rpc/compact-session-state.js

@@ -0,0 +1,206 @@
+import { COMPACT_LEAF_CODE_UNITS, CompactContentStore, } from "./compact-content-store.js";
+class CompactTransitionError extends Error {
+    constructor(reason, detail) {
+        super(`compact transition rejected (${reason}): ${detail}`);
+        this.name = "CompactTransitionError";
+        this.reason = reason;
+    }
+}
+const byContentIndex = ([a], [b]) => a - b;
+export class CompactSessionState {
+    constructor(options) {
+        this.settled = new Map();
+        this.active = new Map();
+        this.sequence = 0;
+        this.frozenTailBytes = 0;
+        this.store = new CompactContentStore(options);
+    }
+    get acceptedSequence() {
+        return this.sequence;
+    }
+    accept(transition) {
+        switch (transition.type) {
+            case "block_start":
+                this.start(transition);
+                break;
+            case "block_delta":
+                this.delta(this.block(transition), transition.offset, transition.text);
+                break;
+            case "block_replace":
+                this.replace(this.block(transition), transition.text);
+                break;
+            case "message_status":
+                this.setPersistence(transition.messageId, transition.persistence);
+                break;
+            case "message_remove":
+                this.remove(transition.messageId);
+                break;
+        }
+        return ++this.sequence;
+    }
+    freeze() {
+        const active = new Map();
+        for (const [messageId, blocks] of this.active)
+            active.set(messageId, this.seal(blocks, false));
+        const settled = new Map(this.settled);
+        for (const blocks of active.values())
+            this.pin(blocks, 1);
+        for (const row of settled.values())
+            this.pin(row.blocks, 1);
+        return { sequence: this.sequence, active, settled };
+    }
+    release(frozen) {
+        for (const blocks of frozen.active.values())
+            this.pin(blocks, -1);
+        for (const row of frozen.settled.values())
+            this.pin(row.blocks, -1);
+    }
+    /** Rejects with the storage error when committed content is gone; never returns empty content for it. */
+    async read(frozen) {
+        const messages = [];
+        for (const [messageId, row] of frozen.settled) {
+            messages.push({ messageId, persistence: row.persistence, blocks: await this.texts(row.blocks) });
+        }
+        for (const [messageId, blocks] of frozen.active) {
+            messages.push({ messageId, persistence: undefined, blocks: await this.texts(blocks) });
+        }
+        return { sequence: frozen.sequence, messages };
+    }
+    storageStatus() {
+        let residentTailBytes = 0;
+        let hotWitnessBytes = 0;
+        for (const blocks of this.active.values()) {
+            for (const block of blocks.values()) {
+                residentTailBytes += block.tail.length * 2;
+                hotWitnessBytes += block.witness.length * 2;
+            }
+        }
+        return {
+            ...this.store.status(),
+            residentTailBytes,
+            frozenTailBytes: this.frozenTailBytes,
+            hotWitnessBytes,
+            residentSettledRows: this.settled.size,
+        };
+    }
+    idle() {
+        return this.store.idle();
+    }
+    retire() {
+        return this.store.retire();
+    }
+    start(t) {
+        if (this.active.get(t.messageId)?.has(t.contentIndex) || this.settled.has(t.messageId)) {
+            throw new CompactTransitionError("duplicate_block", `${t.messageId}#${t.contentIndex}`);
+        }
+        const covered = t.coveredCodeUnits;
+        if (!Number.isInteger(covered) || (covered !== 0 && covered !== t.seed.length)) {
+            throw new CompactTransitionError("invalid_coverage", `${covered} of ${t.seed.length} seed code units`);
+        }
+        const emitted = covered > 0 ? 0 : t.seed.length;
+        const block = { kind: t.kind, leaves: [], tail: "", units: 0, emitted, covered, witness: "" };
+        block.witness = t.seed.slice(0, covered);
+        this.append(block, t.seed);
+        const blocks = this.active.get(t.messageId) ?? new Map();
+        blocks.set(t.contentIndex, block);
+        this.active.set(t.messageId, blocks);
+    }
+    /**
+     * Appends only the new suffix. Overlap exists only while a fully covered seed is being replayed
+     * (`emitted < covered == units`), so it always lies inside the producer-declared coverage.
+     */
+    delta(block, offset, text) {
+        if (offset !== block.emitted) {
+            throw new CompactTransitionError("non_contiguous", `offset ${offset}, expected ${block.emitted}`);
+        }
+        const overlapEnd = Math.min(offset + text.length, block.units);
+        const overlap = Math.max(0, overlapEnd - offset);
+        if (overlap > 0 && text.slice(0, overlap) !== block.witness.slice(offset, overlapEnd)) {
+            throw new CompactTransitionError("conflicting_overlap", `[${offset}, ${overlapEnd})`);
+        }
+        this.append(block, text.slice(overlap));
+        block.emitted = offset + text.length;
+        if (block.emitted >= block.covered)
+            block.witness = "";
+    }
+    replace(block, text) {
+        for (const id of block.leaves.splice(0))
+            this.store.adjust(id, -1, 0);
+        block.tail = "";
+        block.units = 0;
+        block.covered = 0;
+        block.witness = "";
+        this.append(block, text);
+        block.emitted = block.units;
+    }
+    setPersistence(messageId, persistence) {
+        const blocks = this.active.get(messageId);
+        if (blocks) {
+            this.settled.set(messageId, { persistence, blocks: this.seal(blocks, true) });
+            this.active.delete(messageId);
+            return;
+        }
+        const row = this.settled.get(messageId);
+        if (row) {
+            this.settled.set(messageId, { ...row, persistence });
+        }
+        else {
+            throw new CompactTransitionError("unknown_message", messageId);
+        }
+    }
+    remove(messageId) {
+        const blocks = this.active.get(messageId);
+        const row = this.settled.get(messageId);
+        if (!blocks && !row)
+            throw new CompactTransitionError("unknown_message", messageId);
+        for (const block of blocks?.values() ?? [])
+            for (const id of block.leaves)
+                this.store.adjust(id, -1, 0);
+        for (const block of row?.blocks ?? [])
+            for (const id of block.leaves)
+                this.store.adjust(id, -1, 0);
+        this.active.delete(messageId);
+        this.settled.delete(messageId);
+    }
+    block(address) {
+        const block = this.active.get(address.messageId)?.get(address.contentIndex);
+        if (!block)
+            throw new CompactTransitionError("unknown_block", `${address.messageId}#${address.contentIndex}`);
+        return block;
+    }
+    append(block, text) {
+        block.units += text.length;
+        let rest = text;
+        while (block.tail.length + rest.length >= COMPACT_LEAF_CODE_UNITS) {
+            const take = COMPACT_LEAF_CODE_UNITS - block.tail.length;
+            block.leaves.push(this.store.createLeaf(block.tail + rest.slice(0, take)));
+            block.tail = "";
+            rest = rest.slice(take);
+        }
+        block.tail += rest;
+    }
+    /** Settling mints the final tail into a spillable leaf; a freeze of an active block shares the tail. */
+    seal(blocks, settle) {
+        return [...blocks].sort(byContentIndex).map(([contentIndex, block]) => {
+            if (settle && block.tail.length > 0) {
+                block.leaves.push(this.store.createLeaf(block.tail));
+                block.tail = "";
+            }
+            return { contentIndex, kind: block.kind, leaves: [...block.leaves], tail: block.tail };
+        });
+    }
+    pin(blocks, delta) {
+        for (const block of blocks) {
+            this.frozenTailBytes += delta * block.tail.length * 2;
+            for (const id of block.leaves)
+                this.store.adjust(id, 0, delta);
+        }
+    }
+    async texts(blocks) {
+        return Promise.all(blocks.map(async ({ contentIndex, kind, leaves, tail }) => {
+            const parts = await Promise.all(leaves.map((id) => this.store.readLeaf(id)));
+            return { contentIndex, kind, text: parts.join("") + tail };
+        }));
+    }
+}
+//# sourceMappingURL=compact-session-state.js.map

package/dist/modes/rpc/compact-spool-dir.d.ts

@@ -0,0 +1,5 @@
+/** Creates a fresh private epoch directory and returns the token its ownership marker holds. */
+export declare function createSpoolDir(dir: string): Promise<string>;
+/** Removes `dir` only while it is still the private, marked directory `createSpoolDir` made. */
+export declare function removeSpoolDir(dir: string, token: string): Promise<void>;
+//# sourceMappingURL=compact-spool-dir.d.ts.map

package/dist/modes/rpc/compact-spool-dir.js

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+/**
+ * Ownership of the compact spool's epoch directory (senpi#4272). The store creates the directory
+ * itself (0700, never adopting an existing one) and writes a private marker into it; removal
+ * re-checks the directory and that marker without following symlinks, so retirement never deletes
+ * a directory this store did not create and still own.
+ */
+const MARKER = ".compact-spool-owner";
+class CompactSpoolRefusedError extends Error {
+    constructor(reason, path) {
+        super(`compact spool directory refused (${reason}): ${path}`);
+        this.name = "CompactSpoolRefusedError";
+        this.reason = reason;
+        this.path = path;
+    }
+}
+/** Creates a fresh private epoch directory and returns the token its ownership marker holds. */
+export async function createSpoolDir(dir) {
+    await mkdir(dirname(dir), { recursive: true, mode: 0o700 });
+    try {
+        await mkdir(dir, { mode: 0o700 });
+    }
+    catch (cause) {
+        if (cause.code === "EEXIST")
+            throw new CompactSpoolRefusedError("pre_existing", dir);
+        throw cause;
+    }
+    const token = randomUUID();
+    await writeFile(join(dir, MARKER), token, { flag: "wx", mode: 0o600 });
+    return token;
+}
+/** Removes `dir` only while it is still the private, marked directory `createSpoolDir` made. */
+export async function removeSpoolDir(dir, token) {
+    const refusal = await refusalFor(dir, token);
+    if (refusal)
+        throw new CompactSpoolRefusedError(refusal, dir);
+    await rm(dir, { recursive: true, force: true });
+}
+async function refusalFor(dir, token) {
+    const owned = await lstat(dir);
+    if (owned.isSymbolicLink())
+        return "symlink";
+    if (!owned.isDirectory())
+        return "not_directory";
+    const markerPath = join(dir, MARKER);
+    const marker = await lstat(markerPath).catch(() => undefined);
+    if (!marker?.isFile() || (await readFile(markerPath, "utf8")) !== token)
+        return "marker_missing";
+    // Windows has no POSIX owner or mode bits; the marker token and the no-follow checks still apply.
+    const uid = process.getuid?.();
+    if (uid === undefined)
+        return undefined;
+    if (owned.uid !== uid || marker.uid !== uid)
+        return "foreign_owner";
+    if (((owned.mode | marker.mode) & 0o077) !== 0)
+        return "wide_mode";
+    return undefined;
+}
+//# sourceMappingURL=compact-spool-dir.js.map

package/dist/modes/rpc/compact-storage-io.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The asynchronous file seam of compact current-state storage (senpi#4272) and the failures it
+ * reports. Every spool access goes through `CompactStorageIo`; nothing here blocks the host loop.
+ */
+export type CompactStorageOperation = "spool_create" | "spill_write" | "leaf_read" | "reclaim";
+export interface CompactStorageFailure {
+    readonly operation: CompactStorageOperation;
+    readonly path: string;
+    readonly cause: string;
+    /** Accepted bytes this failure leaves resident in memory instead of on disk. */
+    readonly retainedInMemoryBytes: number;
+}
+/** Asynchronous file access the host supplies; the default is node's promise filesystem. */
+export interface CompactStorageIo {
+    writeFile(path: string, data: Buffer): Promise<void>;
+    readFile(path: string): Promise<Buffer>;
+    unlink(path: string): Promise<void>;
+}
+export declare const nodeCompactStorageIo: CompactStorageIo;
+export declare function describeCause(cause: unknown): string;
+/** Committed storage that can no longer be read: a real error, never empty content. */
+export declare class CompactStorageReadError extends Error {
+    readonly operation: CompactStorageOperation;
+    readonly path: string;
+    constructor(operation: CompactStorageOperation, path: string, cause: unknown);
+}
+//# sourceMappingURL=compact-storage-io.d.ts.map

package/dist/modes/rpc/compact-storage-io.js

@@ -0,0 +1,19 @@
+import { readFile, unlink, writeFile } from "node:fs/promises";
+export const nodeCompactStorageIo = {
+    writeFile: (path, data) => writeFile(path, data, { flag: "wx", mode: 0o600 }),
+    readFile: (path) => readFile(path),
+    unlink: (path) => unlink(path),
+};
+export function describeCause(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+/** Committed storage that can no longer be read: a real error, never empty content. */
+export class CompactStorageReadError extends Error {
+    constructor(operation, path, cause) {
+        super(`compact storage ${operation} failed for ${path}: ${describeCause(cause)}`, { cause });
+        this.name = "CompactStorageReadError";
+        this.operation = operation;
+        this.path = path;
+    }
+}
+//# sourceMappingURL=compact-storage-io.js.map

package/dist/modes/rpc/connection-handler.d.ts

@@ -48,6 +48,8 @@ export interface RpcConnectionOptions {
  */
 export interface RpcConnectionSink {
     writeRaw(chunk: string): void;
+    /** Shared bindings accept correlated records synchronously, before JSONL buffering. */
+    writeRecord?(record: object): void;
     waitForBackpressure(): Promise<void>;
     /** Tears the transport down once its event queue can no longer deliver (overflow, write failure). */
     close?(): void;

package/dist/modes/rpc/connection-handler.js

@@ -57,6 +57,8 @@ import { protocolIdentity } from "./protocol-identity.js";
 import { buildRpcCommandsForSession, createCommandsChangedEvent, rpcCommandListDigest } from "./rpc-command-surface.js";
 import { rpcCommandPayloadError, rpcCommandShapeError, rpcMessageLengthError, sessionRetryFallbackError, } from "./rpc-input-validation.js";
 import { buildRpcSessionState } from "./rpc-session-state.js";
+import { getSnapshot } from "./get-snapshot.js";
+import { sessionUiAnswerLedger } from "./ui-answer-ledger.js";
 import { RPC_ERROR_EVAL_CELL_NOT_FOUND, RPC_ERROR_EVAL_CELLS_UNAVAILABLE, RPC_ERROR_INVALID_ARGUMENT, RPC_ERROR_INVALID_EVAL_CELL_REQUEST, RPC_ERROR_MEDIA_NOT_FOUND, RPC_ERROR_MODEL_NOT_FOUND, STEER_WHEN_IDLE_CAPABILITY, USER_ACTIVITY_CAPABILITY, } from "./rpc-types.js";
 import { runPauseForRun, runResumeForRun } from "./run-hold-commands.js";
 import { availableModelsData, interruptRunningTurn } from "./session-control-actions-data.js";
@@ -197,7 +199,9 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     let loadedSurfacesDigest;
     let rpcCommandsDigest;
     let suppressLoadedSurfaceEvents = false;
-    const eventOutput = createRpcEventOutputBuffer(sink.writeRaw, options.eventFlushScheduler);
+    const eventOutput = sink.writeRecord
+        ? undefined
+        : createRpcEventOutputBuffer(sink.writeRaw, options.eventFlushScheduler);
     const effectContext = () => ({
         session,
         by: { connectionId: options.clientInfo?.connectionId() ?? "local" },
@@ -205,10 +209,18 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     });
     const tagSessionRecord = (value) => routingSessionId === undefined ? value : { ...value, sessionId: routingSessionId };
     const output = (obj) => {
-        eventOutput.writeImmediate(tagSessionRecord(obj));
+        const record = tagSessionRecord(obj);
+        if (sink.writeRecord)
+            sink.writeRecord(record);
+        else
+            eventOutput?.writeImmediate(record);
     };
     const outputEvent = (event) => {
-        eventOutput.enqueueEvent(tagSessionRecord(event));
+        const record = tagSessionRecord(event);
+        if (sink.writeRecord)
+            sink.writeRecord(record);
+        else
+            eventOutput?.enqueueEvent(record);
     };
     const currentLoadedSurfaces = () => {
         const extensions = loadedExtensions(session);
@@ -268,7 +280,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         });
     });
     const waitForRpcBackpressure = async () => {
-        eventOutput.flushEvents();
+        eventOutput?.flushEvents();
         await sink.waitForBackpressure();
     };
     const success = (id, command, data) => {
@@ -292,10 +304,15 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         };
     };
     // Pending extension UI requests waiting for response
-    const pendingExtensionRequests = new SessionExtensionUiRequests(() => session.refreshLifecycle());
+    const uiRequestChanged = (change) => {
+        session.refreshLifecycle();
+        if (change && routingSessionId !== undefined)
+            output(change);
+    };
+    const pendingExtensionRequests = new SessionExtensionUiRequests(uiRequestChanged);
     const grantRequests = new Map();
     sessionDialogRequests.set(session, pendingExtensionRequests);
-    const questions = new ConnectionQuestionBridge(output, () => session.refreshLifecycle());
+    const questions = new ConnectionQuestionBridge(output, uiRequestChanged);
     let shutdownRequested = false;
     // In-flight OAuth logins, keyed by provider. login_start registers one; the
     // login promise clears it on completion; login_cancel aborts it. The flow is
@@ -858,6 +875,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                         capabilities: [
                             ...new Set([
                                 "multi_session",
+                                "snapshot_cursor",
+                                "ui_answer_ledger",
                                 "session_lifecycle",
                                 AUTO_TITLE_SESSIONS_CAPABILITY,
                                 MEDIA_PLACEHOLDERS_CAPABILITY,
@@ -1080,6 +1099,18 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     refreshGrantPresentation();
                 return success(id, "set_client_info");
             }
+            case "get_snapshot": {
+                const snapshot = getSnapshot(session, command, {
+                    lastAbortSource,
+                    enqueue: (markerId) => {
+                        if (routingSessionId !== undefined)
+                            output({ type: "snapshot_marker", markerId });
+                    },
+                });
+                return "error" in snapshot
+                    ? error(id, "get_snapshot", snapshot.error, RPC_ERROR_INVALID_ARGUMENT)
+                    : success(id, "get_snapshot", snapshot.data);
+            }
             case "get_state":
                 return success(id, "get_state", buildRpcSessionState(session, lastAbortSource));
             case "request_self_settle":
@@ -1688,6 +1719,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 questions,
                 dialogs: pendingExtensionRequests,
                 routed: routingSessionId !== undefined,
+                ledger: sessionUiAnswerLedger(session),
                 // An answer is a person's input by its entry point, whatever the connection role.
                 beforeAnswer: () => session.admitHumanAnswer(),
             });
@@ -1719,7 +1751,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     // A single-session connection hears its account's new limit windows as they are reported. A host
     // session's handler (it has a routing `sessionId`) does not: the host broadcasts the record once.
     const stopLimitEvents = options.sessionId === undefined
-        ? subscriptionLimits.subscribe((limits) => eventOutput.enqueueEvent({ type: "subscription_limits", ...limits }))
+        ? subscriptionLimits.subscribe((limits) => outputEvent({ type: "subscription_limits", ...limits }))
         : () => { };
     const dispose = async (disposeOptions = {}) => {
         unbindMcpForms?.();

package/dist/modes/rpc/connection-question-bridge.d.ts

@@ -1,4 +1,5 @@
 import type { ExtensionUIContext, QuestionRequest, QuestionResponse } from "../../core/extensions/types.ts";
+import type { UiRequestChange } from "./snapshot-types.ts";
 import type { RpcExtensionUIProgress, RpcExtensionUIResponse, RpcQuestionUiRequest } from "./rpc-types.ts";
 type Options = Parameters<NonNullable<ExtensionUIContext["question"]>>[1];
 export declare const sessionQuestionBridges: WeakMap<object, ConnectionQuestionBridge>;
@@ -7,7 +8,7 @@ export declare class ConnectionQuestionBridge {
     private readonly resolved;
     private readonly output;
     private readonly changed;
-    constructor(output: (record: object) => void, changed?: () => void);
+    constructor(output: (record: object) => void, changed?: (change?: UiRequestChange) => void);
     pendingQuestions(): RpcQuestionUiRequest[];
     ask(request: QuestionRequest, opts?: Options): Promise<QuestionResponse>;
     respond(response: RpcExtensionUIResponse, beforeAnswer?: () => void): boolean | "question_incomplete" | "question_already_resolved";

package/dist/modes/rpc/connection-question-bridge.js

@@ -43,7 +43,11 @@ export class ConnectionQuestionBridge {
                 clearTimeout(timer);
                 opts?.signal?.removeEventListener("abort", cancel);
                 this.pending.delete(id);
-                this.changed?.();
+                this.changed?.({
+                    type: "ui_request_settled",
+                    uiRequestId: id,
+                    disposition: status === "answered" || status === "comment-submitted" ? "answered" : "cancelled",
+                });
                 this.resolved.add(id);
                 const result = {
                     status,
@@ -121,7 +125,7 @@ export class ConnectionQuestionBridge {
                 },
             });
             arm();
-            this.changed?.();
+            this.changed?.({ type: "ui_request_pending", uiRequestId: id, method: "question", request: frame });
             this.output(frame);
             opts?.signal?.addEventListener("abort", cancel, { once: true });
             if (opts?.signal?.aborted)

package/dist/modes/rpc/extension-ui-response.d.ts

@@ -1,5 +1,6 @@
 import type { QuestionRequest, QuestionResponse } from "../../core/extensions/types.ts";
 import type { RpcExtensionUIResponse } from "./rpc-types.ts";
+import type { UiAnswerLedger } from "./ui-answer-ledger.ts";
 /**
  * An `extension_ui_response` carries two ids: `id`, the frame's own correlation id that its reply
  * echoes, and `uiRequestId`, the extension UI request it answers. The short form every older client
@@ -23,6 +24,8 @@ export type ExtensionUiResponseReply = {
     readonly id: string;
     readonly type: "response";
     readonly command: "extension_ui_response";
+    /** The answer's outcome for its request; absent when a malformed answer was refused before settling anything. */
+    readonly disposition?: "applied" | "replay" | "already_answered" | "unknown";
 } & ({
     readonly success: true;
 } | {
@@ -37,13 +40,15 @@ type DialogAnswers = {
 };
 /**
  * Settles one response on a host connection and returns its reply, keyed by the frame `id`.
- * `undefined` only on an unrouted (single-session stdio) connection for a response no request here
- * matches: that connection has always ignored such a response, and still does.
+ * `undefined` only on an unrouted (single-session stdio) connection for an unnamed response no
+ * request here matches: that connection has always ignored such a response, and still does. A named
+ * response (`answerId`) asks for a receipt, so every connection answers it.
  */
 export declare function settleExtensionUiResponse(response: RpcExtensionUIResponse, targets: {
     readonly questions: QuestionAnswers;
     readonly dialogs: DialogAnswers;
     readonly routed: boolean;
+    readonly ledger?: UiAnswerLedger;
     readonly beforeAnswer?: () => void;
 }): ExtensionUiResponseReply | undefined;
 export {};

package/dist/modes/rpc/extension-ui-response.js

@@ -28,25 +28,45 @@ export function unansweredQuestionIds(questions, answers) {
 }
 /**
  * Settles one response on a host connection and returns its reply, keyed by the frame `id`.
- * `undefined` only on an unrouted (single-session stdio) connection for a response no request here
- * matches: that connection has always ignored such a response, and still does.
+ * `undefined` only on an unrouted (single-session stdio) connection for an unnamed response no
+ * request here matches: that connection has always ignored such a response, and still does. A named
+ * response (`answerId`) asks for a receipt, so every connection answers it.
  */
 export function settleExtensionUiResponse(response, targets) {
+    if (response.answerId !== undefined &&
+        (typeof response.answerId !== "string" || response.answerId.length < 1 || response.answerId.length > 256))
+        return refused(response.id, "invalid_answer_id");
     const requestId = answeredUiRequestId(response) ?? response.id;
+    const receipt = response.answerId === undefined ? undefined : targets.ledger?.lookup(requestId, response.answerId);
+    if (receipt === "replay")
+        return { ...reply(response.id), success: true, disposition: "replay" };
+    if (receipt === "already_answered")
+        return { ...reply(response.id), success: false, error: "already_answered", disposition: receipt };
     const answer = requestId === response.id ? response : { ...response, id: requestId };
     const question = targets.questions.respond(answer, targets.beforeAnswer);
     if (typeof question === "string")
-        return refused(response.id, question);
-    if (question || targets.dialogs.resolve(answer, targets.beforeAnswer))
-        return { ...reply(response.id), success: true };
+        return refused(response.id, response.answerId !== undefined && question === "question_already_resolved"
+            ? "unknown_extension_ui_request"
+            : question);
+    if (question || targets.dialogs.resolve(answer, targets.beforeAnswer)) {
+        targets.ledger?.record(requestId, response.answerId);
+        return { ...reply(response.id), success: true, disposition: "applied" };
+    }
     // A routed binding owns exactly one session's request map: an unmatched response is a protocol
     // error for its sender, never a cross-session match.
-    return targets.routed ? refused(response.id, "unknown_extension_ui_request") : undefined;
+    return targets.routed || response.answerId !== undefined
+        ? refused(response.id, "unknown_extension_ui_request")
+        : undefined;
 }
 function reply(id) {
     return { id, type: "response", command: "extension_ui_response" };
 }
 function refused(id, error) {
-    return { ...reply(id), success: false, error };
+    const disposition = error === "question_already_resolved"
+        ? "already_answered"
+        : error === "unknown_extension_ui_request"
+            ? "unknown"
+            : undefined;
+    return { ...reply(id), success: false, error, ...(disposition === undefined ? {} : { disposition }) };
 }
 //# sourceMappingURL=extension-ui-response.js.map

package/dist/modes/rpc/get-snapshot.d.ts

@@ -0,0 +1,18 @@
+import type { AgentAbortSource } from "../../core/agent-abort-provenance.ts";
+import type { AgentSession } from "../../core/agent-session.ts";
+import type { RpcSnapshot } from "./snapshot-types.ts";
+type SnapshotRequest = {
+    readonly tail?: unknown;
+    readonly maxBytes?: unknown;
+};
+/** Capture and mark on the source loop, before any response-writing await. */
+export declare function getSnapshot(session: AgentSession, request: SnapshotRequest, cursor: {
+    readonly enqueue: (markerId: string) => void;
+    readonly lastAbortSource?: AgentAbortSource;
+}): {
+    readonly data: RpcSnapshot;
+} | {
+    readonly error: string;
+};
+export {};
+//# sourceMappingURL=get-snapshot.d.ts.map

package/dist/modes/rpc/get-snapshot.js

@@ -0,0 +1,43 @@
+import { randomUUID } from "node:crypto";
+import { describeUsageLimitEntry } from "../../core/retry-fallback/usage-limit.js";
+import { currentResponseByteBudget, DEFAULT_ENTRY_PAGE_BYTES } from "./get-entries-page.js";
+import { buildRpcSessionState } from "./rpc-session-state.js";
+/** Capture and mark on the source loop, before any response-writing await. */
+export function getSnapshot(session, request, cursor) {
+    const tail = request.tail === undefined ? 100 : request.tail;
+    const maxBytes = request.maxBytes === undefined ? DEFAULT_ENTRY_PAGE_BYTES : request.maxBytes;
+    if (typeof tail !== "number" || !Number.isSafeInteger(tail) || tail < 0)
+        return { error: "tail must be a non-negative integer" };
+    if (typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes <= 0)
+        return { error: "maxBytes must be a positive integer" };
+    const state = buildRpcSessionState(session, cursor.lastAbortSource);
+    const history = session.sessionManager.getEntries();
+    const entries = [];
+    let bytes = 2;
+    for (let i = history.length - 1; i >= 0 && entries.length < tail; i--) {
+        const entry = history[i];
+        if (entry === undefined)
+            break;
+        const projected = describeUsageLimitEntry(entry);
+        const size = Buffer.byteLength(JSON.stringify(projected)) + (entries.length > 0 ? 1 : 0);
+        if (bytes + size > Math.min(maxBytes, currentResponseByteBudget()))
+            break;
+        entries.push(projected);
+        bytes += size;
+    }
+    entries.reverse();
+    const history_truncated = entries.length < history.length;
+    const markerId = randomUUID();
+    // Some state fields and entry payloads are live references: detach them before yielding, too.
+    const data = structuredClone({
+        state,
+        entries,
+        history_truncated,
+        next_before: history_truncated ? (entries[0]?.id ?? null) : null,
+        markerId,
+    });
+    session.releaseFullHistoryView();
+    cursor.enqueue(markerId);
+    return { data };
+}
+//# sourceMappingURL=get-snapshot.js.map

package/dist/modes/rpc/host-capabilities.js

@@ -20,6 +20,9 @@ export function multiSessionHostCapabilities(options) {
     return [
         ...new Set([
             "multi_session",
+            "snapshot_cursor",
+            "ui_answer_ledger",
+            "dialog_observer",
             ...(options.mcpPresenters ? ["mcp_form_presenter_v1"] : []),
             "session_lifecycle",
             "expected_host_instance",

package/dist/modes/rpc/host-ensure-start.js

@@ -63,6 +63,7 @@ export async function startHost(paths, socket, options, generation = 0) {
             socket,
             ...(options.owner ? ["--owner-fd", String(OWNER_WATCH_FD)] : []),
             ...(options.presenterBootstrap ? ["--mcp-presenter-fd", "4"] : []),
+            ...(options.mcpPresenterEnforcement ? ["--mcp-presenter-enforcement"] : []),
             ...(options.hostArgs ?? []),
         ];
         const launch = testOptions?.spawn ?? testOptions?.launch?.(supervisorArgs) ?? defaultHostLaunch(supervisorArgs);