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

package/dist/core/extensions/builtin/permission-system/parsers.d.ts

@@ -7,6 +7,8 @@ export type PermissionRequest = Pick<Request, "permission" | "patterns" | "alway
 };
 /** Parser function that extracts permission requests from tool input */
 export type ToolPermissionParser = (toolName: string, input: Record<string, unknown>, cwd: string) => PermissionRequest[];
+/** Marks a bash request target that no command-specific rule can match: only a `*` rule decides it. */
+export declare const UNPARSED_BASH_PREFIX = "(unparsed) ";
 /** The `eval` class a cell carries on its own, used when its tool-owned parser names anything narrower. */
 export declare function fallbackEvalPermissionRequest(): PermissionRequest;
 /**

package/dist/core/extensions/builtin/permission-system/parsers.js

@@ -2,6 +2,7 @@ import { dirname, resolve } from "node:path";
 import { realpathWithoutOpen } from "../../../../utils/paths.js";
 import { extractPatchedPaths } from "../gpt-apply-patch/index.js";
 import { BashArity } from "../permission-system/arity.js";
+import { analyzeBashCommand, bestEffortCommandLines } from "../permission-system/bash-command-segments.js";
 import { extractExternalPaths, isExternalPath, toParentDirectoryPattern, } from "../permission-system/external-dir.js";
 import { setApprovedMonitorParent } from "../terminal/monitor-permission.js";
 import { urlOriginAlias, widerAlwaysScope } from "./always-scope.js";
@@ -73,6 +74,48 @@ function withExternalDirectoryRequests(requests, paths, cwd, scope) {
         },
     ];
 }
+const uniq = (values) => [...new Set(values)];
+/**
+ * The targets an "Allow always" answer may store. Stored rules are matched as globs, so a target holding
+ * its own `*` or `?` would be remembered as a wildcard that matches other commands; such a target is
+ * allowed once and never stored. Request patterns stay raw, so existing rules match exactly as before.
+ */
+const rememberable = (targets) => targets.filter((target) => !/[*?]/.test(target));
+/** Marks a bash request target that no command-specific rule can match: only a `*` rule decides it. */
+export const UNPARSED_BASH_PREFIX = "(unparsed) ";
+/**
+ * The `bash` requests for one command. Every simple command it runs is decided, so the call is as
+ * strict as its strictest command: one pattern per command (its arity prefix), all of which must be
+ * allowed, and "Allow always" stores exactly those prefixes. A command the lexer cannot parse is one
+ * target only a `*` rule (a preset, a blanket setting) can decide, so no grant for one command can
+ * allow it; its plain words are still checked against deny rules.
+ */
+function bashCommandRequests(command) {
+    const analysis = analyzeBashCommand(command);
+    if (analysis.kind === "unparsed") {
+        const target = `${UNPARSED_BASH_PREFIX}${command}`;
+        const candidates = uniq(bestEffortCommandLines(command)
+            .map((words) => BashArity.prefix(words).join(" "))
+            .filter(Boolean));
+        // The deny-only check runs first, so a denied call is refused before anyone is asked.
+        return [
+            ...(candidates.length === 0
+                ? []
+                : [{ permission: "bash", patterns: candidates, always: [], autoApproveAsk: true }]),
+            { permission: "bash", patterns: [target], always: rememberable([target]) },
+        ];
+    }
+    const prefixes = uniq(analysis.segments.map((words) => BashArity.prefix([...words]).join(" ")).filter(Boolean));
+    if (prefixes.length === 0)
+        return [{ permission: "bash", patterns: [command], always: rememberable([command]) }];
+    return [
+        {
+            permission: "bash",
+            patterns: prefixes,
+            always: rememberable(prefixes).flatMap((prefix) => [prefix, `${prefix} *`]),
+        },
+    ];
+}
 /** The `eval` class a cell carries on its own, used when its tool-owned parser names anything narrower. */
 export function fallbackEvalPermissionRequest() {
     return { permission: "eval", patterns: ["*"], always: ["*"] };
@@ -135,16 +178,7 @@ export function createBuiltinParserRegistry() {
         if (!command) {
             return [fallbackPermissionRequest("bash")];
         }
-        const tokens = command.split(/\s+/).filter(Boolean);
-        const prefix = BashArity.prefix(tokens).join(" ");
-        const always = prefix ? [prefix, `${prefix} *`] : ["*"];
-        const requests = [
-            {
-                permission: "bash",
-                patterns: [prefix || command],
-                always,
-            },
-        ];
+        const requests = bashCommandRequests(command);
         const externalPaths = extractExternalPaths(command, cwd);
         if (externalPaths.length > 0) {
             requests.push({

package/dist/modes/interactive/session-control-commands.js

@@ -13,6 +13,7 @@ import { ENTRIES_TAIL_CAPABILITY, OBSERVE_READS_CAPABILITY, SESSION_STATUS_CAPAB
 import { answerGetEntries } from "../rpc/get-entries-command.js";
 import { answeredUiRequestId, settledQuestionStatus, unansweredQuestionIds } from "../rpc/extension-ui-response.js";
 import { buildRpcSessionState } from "../rpc/rpc-session-state.js";
+import { sessionUiAnswerLedger } from "../rpc/ui-answer-ledger.js";
 import { runTuiRpcCommand, TUI_RPC_COMMANDS } from "./session-control-rpc-commands.js";
 import { failure, success } from "./session-control-server.js";
 import { runSessionControlCommand, SESSION_CONTROL_COMMANDS, } from "./session-control-session-commands.js";
@@ -45,6 +46,8 @@ export async function runControlCommand(context, connection, command) {
                     TUI_OBSERVER_CAPABILITY,
                     OBSERVE_READS_CAPABILITY,
                     ENTRIES_TAIL_CAPABILITY,
+                    "snapshot_cursor",
+                    "ui_answer_ledger",
                 ],
                 mode: "tui",
                 endpoint_kind: "tui",
@@ -89,7 +92,7 @@ export async function runControlCommand(context, connection, command) {
             return success(id, type, { admitted: result.admitted ?? [] });
         }
         case "extension_ui_response":
-            return answerQuestion(context.surface, command);
+            return answerQuestion(context, command);
         default: {
             const rpc = await runTuiRpcCommand(context, connection, command);
             if (rpc !== undefined)
@@ -121,12 +124,25 @@ function sessionRow(session) {
  * settles by the host's rule (`settledQuestionStatus`), so the same frame reaches the model as the same
  * message on either surface.
  */
-function answerQuestion(surface, command) {
+function answerQuestion(context, command) {
+    const { surface, session } = context;
+    const ledger = sessionUiAnswerLedger(session);
+    const answerId = command.answerId;
+    if (answerId !== undefined && (typeof answerId !== "string" || answerId.length < 1 || answerId.length > 256))
+        return failure(command.id, "extension_ui_response", "invalid_answer_id");
     const frameId = command.id;
     const requestId = answeredUiRequestId(command);
+    const receipt = requestId === undefined || answerId === undefined ? undefined : ledger.lookup(requestId, answerId);
+    if (receipt === "replay")
+        return { ...success(frameId, "extension_ui_response"), disposition: receipt };
+    if (receipt === "already_answered")
+        return { ...failure(frameId, "extension_ui_response", "already_answered"), disposition: receipt };
     const request = requestId === undefined ? undefined : surface.pendingQuestion(requestId);
     if (requestId === undefined || request === undefined) {
-        return failure(frameId, "extension_ui_response", "unknown_request");
+        return {
+            ...failure(frameId, "extension_ui_response", answerId === undefined ? "unknown_request" : "unknown_extension_ui_request"),
+            disposition: "unknown",
+        };
     }
     const response = questionResponse(command, request.questions);
     if (response === "question_incomplete")
@@ -134,7 +150,8 @@ function answerQuestion(surface, command) {
     if (response === undefined || !surface.answerQuestion(requestId, response)) {
         return failure(frameId, "extension_ui_response", "invalid_response");
     }
-    return success(frameId, "extension_ui_response");
+    ledger.record(requestId, answerId);
+    return { ...success(frameId, "extension_ui_response"), disposition: "applied" };
 }
 function questionResponse(command, questions) {
     // Another client's cancel (the desktop's Remove) is the user's; the builtin settles it from its own draft.

package/dist/modes/interactive/session-control-rpc-commands.d.ts

@@ -1,7 +1,7 @@
 import type { AgentSession } from "../../core/agent-session.ts";
 import { type ControlAttachments } from "./session-control-attach.ts";
 import { type ControlCommand, type ControlConnection } from "./session-control-server.ts";
-export declare const TUI_RPC_COMMANDS: readonly ["open_session", "subscribe_sessions", "unsubscribe_sessions", "steer", "follow_up", "prompt", "get_effect_status", "set_client_info", "attach_session", "release_attachment", "abort"];
+export declare const TUI_RPC_COMMANDS: readonly ["open_session", "get_snapshot", "subscribe_sessions", "unsubscribe_sessions", "steer", "follow_up", "prompt", "get_effect_status", "set_client_info", "attach_session", "release_attachment", "abort"];
 export interface RpcCommandContext {
     /** This endpoint's instance id: the `expectedHostInstance` an `attach_session` may name. */
     readonly instanceId: string;

package/dist/modes/interactive/session-control-rpc-commands.js

@@ -17,11 +17,13 @@ import { CONNECTION_ROLE_FIXED } from "../rpc/connection-roles.js";
 import { INTERACTIVE_USER_CAPABILITY } from "../rpc/custom-capability.js";
 import { runAbort, runGetEffectStatus } from "../rpc/effect-commands.js";
 import { buildRpcSessionState } from "../rpc/rpc-session-state.js";
+import { getSnapshot } from "../rpc/get-snapshot.js";
 import { answerSubscribeSessions, answerUnsubscribeSessions, refusal } from "../rpc/session-status-commands.js";
 import { keyOf } from "./session-control-attach.js";
 import { failure, success } from "./session-control-server.js";
 export const TUI_RPC_COMMANDS = [
     "open_session",
+    "get_snapshot",
     "subscribe_sessions",
     "unsubscribe_sessions",
     "steer",
@@ -38,6 +40,23 @@ const STOP_REQUIRES_INTERACTIVE_CLIENT = "stop_requires_interactive_client: decl
 /** `null` = answered on the writer already; `undefined` = not a command this file owns. */
 export async function runTuiRpcCommand(context, connection, command) {
     switch (command.type) {
+        case "get_snapshot": {
+            const { attachments, session } = context;
+            if (command.sessionId !== undefined && command.sessionId !== attachments.handle)
+                return {
+                    id: command.id,
+                    type: "response",
+                    command: command.type,
+                    success: false,
+                    error: "unknown_session",
+                };
+            const snapshot = getSnapshot(session, { tail: command.tail, maxBytes: command.maxBytes }, {
+                enqueue: (markerId) => attachments.run(connection, () => attachments.writer.enqueue(attachments.handle, { type: "snapshot_marker", markerId })),
+            });
+            return "error" in snapshot
+                ? { id: command.id, type: "response", command: command.type, success: false, error: snapshot.error }
+                : answered(idOf(command), command.type, snapshot.data);
+        }
         case "open_session":
             return openSession(context, connection, command);
         case "subscribe_sessions":

package/dist/modes/rpc/compact-content-store.d.ts

@@ -0,0 +1,96 @@
+import { type CompactStorageFailure, type CompactStorageIo } from "./compact-storage-io.ts";
+/**
+ * Owned bounded leaves for compact current state (senpi#4272, R3.C6.4 / R3.C2.4).
+ *
+ * Acceptance never waits here: a leaf is created synchronously in RAM, and a spill only relocates
+ * that immutable value. Its RAM copy is released only after the whole file was written and closed;
+ * a failed write keeps the bytes resident, halts further spilling and is reported through
+ * `status()`, never dropped. All storage work runs as one serial asynchronous job chain.
+ */
+/** 32,768 UTF-16 code units (64 KiB as UTF-16LE), so a split surrogate survives a leaf boundary exactly. */
+export declare const COMPACT_LEAF_CODE_UNITS = 32768;
+export type LeafId = number;
+export interface CompactStorageStatus {
+    readonly residentPayloadBytes: number;
+    readonly pendingIoCopyBytes: number;
+    readonly pinnedOnlyBytes: number;
+    readonly spilledLiveBytes: number;
+    readonly spillBytesWritten: number;
+    readonly reclaimDebtBytes: number;
+    /** Resident bytes above the spill target that a halted spool keeps in RAM (ruling 08 condition 1). */
+    readonly spillFailureRetainedBytes: number;
+    readonly spillHalted: boolean;
+    readonly failures: readonly CompactStorageFailure[];
+}
+export interface CompactContentStoreOptions {
+    /** Private epoch spool directory the store creates itself (0700, never an existing one; files 0600). Not a transcript. */
+    readonly dir: string;
+    readonly io?: CompactStorageIo;
+    /** Spilling starts above this many resident leaf bytes and stops at the target. */
+    readonly spillAboveBytes?: number;
+    readonly spillTargetBytes?: number;
+}
+export declare class CompactContentStore {
+    readonly dir: string;
+    private readonly io;
+    private readonly spillAboveBytes;
+    private readonly spillTargetBytes;
+    private readonly leaves;
+    /** Resident leaves in creation order, so each spill takes the oldest without rescanning committed ones. */
+    private readonly ramLeaves;
+    private readonly failures;
+    private nextLeafId;
+    private nextFile;
+    private dirReady;
+    private spoolToken;
+    private chain;
+    private queued;
+    private spillQueued;
+    private halted;
+    private retired;
+    private residentPayloadBytes;
+    private pendingIoCopyBytes;
+    private pinnedOnlyBytes;
+    private spilledLiveBytes;
+    private spillBytesWritten;
+    private reclaimDebtBytes;
+    constructor(options: CompactContentStoreOptions);
+    /** Takes ownership of an immutable value with one live reference. */
+    createLeaf(text: string): LeafId;
+    /** Moves live and cut-pin references; the last reference drops RAM or reclaims the file. */
+    adjust(id: LeafId, live: number, pins: number): void;
+    /** Reads a leaf the caller still references, from RAM or its committed file. */
+    readLeaf(id: LeafId): Promise<string>;
+    /** Resolves once every queued storage job, including the ones they queued, has completed. */
+    idle(): Promise<void>;
+    /**
+     * Invalidates spilling, joins owned I/O, then removes the epoch directory only when this store
+     * created it and it still passes the ownership checks; otherwise rejects with `CompactSpoolRefusedError`.
+     */
+    retire(): Promise<void>;
+    status(): CompactStorageStatus;
+    /** Reads a committed file and rejects a missing, unreadable or short one. */
+    private readFile;
+    /** Writes one new spool file; undefined means the write failed, was reported, and spilling halted. */
+    private writeFile;
+    /**
+     * An unreferenced (or partially written) spool file: reclamation debt until its unlink completes or
+     * finds it gone. Files dropped after retirement started belong to the directory retirement removes.
+     */
+    private discard;
+    /** A failed unlink keeps its debt and is retried with bounded backoff outside the job chain. */
+    private reclaim;
+    private get spillAllowed();
+    /** True while a storage failure or unreclaimed debt above the work allowance holds spilling back. */
+    private get spillStopped();
+    private enqueue;
+    private scheduleSpill;
+    /** Spills one oldest resident leaf per job, so other storage work interleaves fairly. */
+    private spillNext;
+    /** Creates the private epoch directory once; a refusal or failure halts spilling and is reported. */
+    private ensureDir;
+    private readFailure;
+    private fail;
+    private record;
+}
+//# sourceMappingURL=compact-content-store.d.ts.map

package/dist/modes/rpc/compact-content-store.js

@@ -0,0 +1,269 @@
+import { join } from "node:path";
+import { createSpoolDir, removeSpoolDir } from "./compact-spool-dir.js";
+import { CompactStorageReadError, describeCause, nodeCompactStorageIo, } from "./compact-storage-io.js";
+/**
+ * Owned bounded leaves for compact current state (senpi#4272, R3.C6.4 / R3.C2.4).
+ *
+ * Acceptance never waits here: a leaf is created synchronously in RAM, and a spill only relocates
+ * that immutable value. Its RAM copy is released only after the whole file was written and closed;
+ * a failed write keeps the bytes resident, halts further spilling and is reported through
+ * `status()`, never dropped. All storage work runs as one serial asynchronous job chain.
+ */
+/** 32,768 UTF-16 code units (64 KiB as UTF-16LE), so a split surrogate survives a leaf boundary exactly. */
+export const COMPACT_LEAF_CODE_UNITS = 32_768;
+const RECLAIM_WORK_ALLOWANCE_BYTES = 1024 * 1024;
+const RECLAIM_RETRY_DELAYS_MS = [100, 400, 1_600, 6_400, 25_600];
+const FAILURE_HISTORY = 32;
+export class CompactContentStore {
+    constructor(options) {
+        this.leaves = new Map();
+        /** Resident leaves in creation order, so each spill takes the oldest without rescanning committed ones. */
+        this.ramLeaves = new Set();
+        this.failures = [];
+        this.nextLeafId = 1;
+        this.nextFile = 1;
+        this.chain = Promise.resolve();
+        this.queued = 0;
+        this.spillQueued = false;
+        this.halted = false;
+        this.retired = false;
+        this.residentPayloadBytes = 0;
+        this.pendingIoCopyBytes = 0;
+        this.pinnedOnlyBytes = 0;
+        this.spilledLiveBytes = 0;
+        this.spillBytesWritten = 0;
+        this.reclaimDebtBytes = 0;
+        this.dir = options.dir;
+        this.io = options.io ?? nodeCompactStorageIo;
+        this.spillAboveBytes = options.spillAboveBytes ?? 4 * 1024 * 1024;
+        this.spillTargetBytes = options.spillTargetBytes ?? 2 * 1024 * 1024;
+    }
+    /** Takes ownership of an immutable value with one live reference. */
+    createLeaf(text) {
+        const id = this.nextLeafId++;
+        this.leaves.set(id, { text, units: text.length, live: 1, pins: 0, state: "ram" });
+        this.ramLeaves.add(id);
+        this.residentPayloadBytes += text.length * 2;
+        this.scheduleSpill();
+        return id;
+    }
+    /** Moves live and cut-pin references; the last reference drops RAM or reclaims the file. */
+    adjust(id, live, pins) {
+        const leaf = this.leaves.get(id);
+        if (!leaf)
+            throw new Error(`compact leaf ${id} is not owned`);
+        const pinnedOnly = leaf.live === 0 && leaf.pins > 0;
+        leaf.live += live;
+        leaf.pins += pins;
+        if (pinnedOnly !== (leaf.live === 0 && leaf.pins > 0))
+            this.pinnedOnlyBytes += (pinnedOnly ? -2 : 2) * leaf.units;
+        if (leaf.live > 0 || leaf.pins > 0)
+            return;
+        this.leaves.delete(id);
+        this.ramLeaves.delete(id);
+        if (leaf.state === "committed" && leaf.path) {
+            this.spilledLiveBytes -= leaf.units * 2;
+            this.discard(leaf.path, leaf.units * 2);
+            return;
+        }
+        this.residentPayloadBytes -= leaf.units * 2;
+    }
+    /** Reads a leaf the caller still references, from RAM or its committed file. */
+    async readLeaf(id) {
+        const leaf = this.leaves.get(id);
+        if (!leaf)
+            throw new Error(`compact leaf ${id} is not owned`);
+        if (leaf.text !== undefined)
+            return leaf.text;
+        return (await this.readFile(leaf.path ?? "", leaf.units * 2, "leaf_read")).toString("utf16le");
+    }
+    /** Resolves once every queued storage job, including the ones they queued, has completed. */
+    async idle() {
+        while (this.queued > 0)
+            await this.chain;
+    }
+    /**
+     * Invalidates spilling, joins owned I/O, then removes the epoch directory only when this store
+     * created it and it still passes the ownership checks; otherwise rejects with `CompactSpoolRefusedError`.
+     */
+    async retire() {
+        this.retired = true;
+        await this.idle();
+        const token = this.spoolToken;
+        this.spoolToken = undefined;
+        if (token !== undefined)
+            await removeSpoolDir(this.dir, token);
+    }
+    status() {
+        return {
+            residentPayloadBytes: this.residentPayloadBytes,
+            pendingIoCopyBytes: this.pendingIoCopyBytes,
+            pinnedOnlyBytes: this.pinnedOnlyBytes,
+            spilledLiveBytes: this.spilledLiveBytes,
+            spillBytesWritten: this.spillBytesWritten,
+            reclaimDebtBytes: this.reclaimDebtBytes,
+            spillFailureRetainedBytes: this.spillStopped
+                ? Math.max(0, this.residentPayloadBytes - this.spillTargetBytes)
+                : 0,
+            spillHalted: this.spillStopped,
+            failures: [...this.failures],
+        };
+    }
+    /** Reads a committed file and rejects a missing, unreadable or short one. */
+    async readFile(path, bytes, operation) {
+        let data;
+        try {
+            data = await this.io.readFile(path);
+        }
+        catch (cause) {
+            throw this.readFailure(operation, path, cause);
+        }
+        if (data.byteLength !== bytes) {
+            throw this.readFailure(operation, path, new Error(`expected ${bytes} bytes, found ${data.byteLength}`));
+        }
+        return data;
+    }
+    /** Writes one new spool file; undefined means the write failed, was reported, and spilling halted. */
+    async writeFile(data, operation, retainedInMemoryBytes) {
+        const path = await this.ensureDir(retainedInMemoryBytes);
+        if (path === undefined)
+            return undefined;
+        const file = join(path, `leaf-${this.nextFile++}.bin`);
+        this.pendingIoCopyBytes += data.byteLength;
+        try {
+            await this.io.writeFile(file, data);
+            this.spillBytesWritten += data.byteLength;
+            return file;
+        }
+        catch (cause) {
+            this.fail(operation, file, cause, retainedInMemoryBytes);
+            this.discard(file, data.byteLength);
+            return undefined;
+        }
+        finally {
+            this.pendingIoCopyBytes -= data.byteLength;
+        }
+    }
+    /**
+     * An unreferenced (or partially written) spool file: reclamation debt until its unlink completes or
+     * finds it gone. Files dropped after retirement started belong to the directory retirement removes.
+     */
+    discard(path, bytes) {
+        if (this.retired)
+            return;
+        this.reclaimDebtBytes += bytes;
+        this.enqueue("reclaim", () => this.reclaim(path, bytes, 0));
+    }
+    /** A failed unlink keeps its debt and is retried with bounded backoff outside the job chain. */
+    async reclaim(path, bytes, attempt) {
+        try {
+            await this.io.unlink(path);
+        }
+        catch (cause) {
+            if (cause.code !== "ENOENT") {
+                this.fail("reclaim", path, cause, 0);
+                const delay = RECLAIM_RETRY_DELAYS_MS[attempt];
+                if (delay !== undefined) {
+                    setTimeout(() => {
+                        if (this.retired)
+                            this.reclaimDebtBytes -= bytes;
+                        else
+                            this.enqueue("reclaim", () => this.reclaim(path, bytes, attempt + 1));
+                    }, delay).unref?.();
+                }
+                return;
+            }
+        }
+        this.reclaimDebtBytes -= bytes;
+        this.scheduleSpill();
+    }
+    get spillAllowed() {
+        return !this.halted && !this.retired;
+    }
+    /** True while a storage failure or unreclaimed debt above the work allowance holds spilling back. */
+    get spillStopped() {
+        return this.halted || this.reclaimDebtBytes > RECLAIM_WORK_ALLOWANCE_BYTES;
+    }
+    enqueue(operation, job) {
+        this.queued++;
+        this.chain = this.chain
+            .then(job)
+            .catch((cause) => {
+            if (operation === "spill_write")
+                this.spillQueued = false;
+            this.fail(operation, this.dir, cause, 0);
+        })
+            .finally(() => {
+            this.queued--;
+        });
+    }
+    scheduleSpill() {
+        if (this.spillQueued || !this.spillAllowed || this.residentPayloadBytes <= this.spillAboveBytes)
+            return;
+        if (this.reclaimDebtBytes > RECLAIM_WORK_ALLOWANCE_BYTES)
+            return;
+        this.spillQueued = true;
+        this.enqueue("spill_write", () => this.spillNext());
+    }
+    /** Spills one oldest resident leaf per job, so other storage work interleaves fairly. */
+    async spillNext() {
+        const [id] = this.ramLeaves;
+        const leaf = id === undefined ? undefined : this.leaves.get(id);
+        if (id === undefined || !leaf || leaf.text === undefined || !this.spillAllowed) {
+            this.spillQueued = false;
+            return;
+        }
+        const bytes = leaf.units * 2;
+        leaf.state = "pending";
+        this.ramLeaves.delete(id);
+        const path = await this.writeFile(Buffer.from(leaf.text, "utf16le"), "spill_write", bytes);
+        const owned = this.leaves.get(id) === leaf;
+        if (path === undefined) {
+            leaf.state = "ram";
+            if (owned)
+                this.ramLeaves.add(id);
+        }
+        else if (!owned || this.retired) {
+            this.discard(path, bytes);
+        }
+        else {
+            leaf.state = "committed";
+            leaf.path = path;
+            leaf.text = undefined;
+            this.residentPayloadBytes -= bytes;
+            this.spilledLiveBytes += bytes;
+        }
+        this.spillQueued = false;
+        if (this.residentPayloadBytes > this.spillTargetBytes) {
+            this.spillQueued = this.spillAllowed;
+            if (this.spillQueued)
+                this.enqueue("spill_write", () => this.spillNext());
+        }
+    }
+    /** Creates the private epoch directory once; a refusal or failure halts spilling and is reported. */
+    ensureDir(retained) {
+        this.dirReady ??= createSpoolDir(this.dir).then((token) => {
+            this.spoolToken = token;
+            return this.dir;
+        }, (cause) => {
+            this.fail("spool_create", this.dir, cause, retained);
+            return undefined;
+        });
+        return this.dirReady;
+    }
+    readFailure(operation, path, cause) {
+        this.fail(operation, path, cause, 0);
+        return new CompactStorageReadError(operation, path, cause);
+    }
+    fail(operation, path, cause, retained) {
+        if (operation === "spill_write" || operation === "spool_create")
+            this.halted = true;
+        this.record({ operation, path, cause: describeCause(cause), retainedInMemoryBytes: retained });
+    }
+    record(failure) {
+        this.failures.push(failure);
+        if (this.failures.length > FAILURE_HISTORY)
+            this.failures.shift();
+    }
+}
+//# sourceMappingURL=compact-content-store.js.map

package/dist/modes/rpc/compact-session-state.d.ts

@@ -0,0 +1,111 @@
+import { type CompactContentStoreOptions, type CompactStorageStatus, type LeafId } from "./compact-content-store.ts";
+/**
+ * The in-memory current-state owner over compact storage (senpi#4272, R3.C6.4 first half).
+ *
+ * `accept` is synchronous: it validates a typed transition completely, then publishes the next
+ * sequence, or throws and leaves the prior root untouched. Block text lives in owned bounded leaves
+ * that spill asynchronously; settled message rows live in a resident map whose persistence status
+ * changes only through `message_status`, never through storage success or failure. The map is
+ * exact for every transition: a status change replaces the whole row, a removal deletes it, and a
+ * transition addressing a removed or unknown message is refused rather than masked. `freeze` pins
+ * an immutable cut synchronously, and `read` materializes it asynchronously from RAM or disk.
+ */
+type CompactBlockKind = "text" | "thinking" | "tool_arguments";
+type CompactPersistence = "pending" | "appended" | "failed";
+interface BlockAddress {
+    readonly messageId: string;
+    readonly contentIndex: number;
+}
+export type CompactTransition = (BlockAddress & {
+    readonly type: "block_start";
+    readonly kind: CompactBlockKind;
+    readonly seed: string;
+    /**
+     * The whole seed when later deltas replay it from offset 0, or 0 when they continue after it. Partial
+     * coverage is refused: the uncovered seed tail would make every later delta overlap or leave a gap.
+     */
+    readonly coveredCodeUnits: number;
+}) | (BlockAddress & {
+    readonly type: "block_delta";
+    readonly offset: number;
+    readonly text: string;
+}) | (BlockAddress & {
+    readonly type: "block_replace";
+    readonly text: string;
+}) | {
+    readonly type: "message_status";
+    readonly messageId: string;
+    readonly persistence: CompactPersistence;
+} | {
+    readonly type: "message_remove";
+    readonly messageId: string;
+};
+interface FrozenBlock {
+    readonly contentIndex: number;
+    readonly kind: CompactBlockKind;
+    readonly leaves: readonly LeafId[];
+    /** A cut shares the immutable active tail string (under one leaf) instead of minting a leaf per freeze. */
+    readonly tail: string;
+}
+interface SettledRow {
+    readonly persistence: CompactPersistence;
+    readonly blocks: readonly FrozenBlock[];
+}
+interface FrozenCompactState {
+    readonly sequence: number;
+    readonly active: ReadonlyMap<string, readonly FrozenBlock[]>;
+    readonly settled: ReadonlyMap<string, SettledRow>;
+}
+interface CompactMessageView {
+    readonly messageId: string;
+    readonly persistence: CompactPersistence | undefined;
+    readonly blocks: readonly {
+        readonly contentIndex: number;
+        readonly kind: CompactBlockKind;
+        readonly text: string;
+    }[];
+}
+export declare class CompactSessionState {
+    private readonly store;
+    private readonly settled;
+    private readonly active;
+    private sequence;
+    private frozenTailBytes;
+    constructor(options: CompactContentStoreOptions);
+    get acceptedSequence(): number;
+    accept(transition: CompactTransition): number;
+    freeze(): FrozenCompactState;
+    release(frozen: FrozenCompactState): void;
+    /** Rejects with the storage error when committed content is gone; never returns empty content for it. */
+    read(frozen: FrozenCompactState): Promise<{
+        sequence: number;
+        messages: CompactMessageView[];
+    }>;
+    storageStatus(): CompactStorageStatus & {
+        readonly residentTailBytes: number;
+        /** Active tails held by unreleased cuts; may share storage with `residentTailBytes`. */
+        readonly frozenTailBytes: number;
+        readonly hotWitnessBytes: number;
+        /** Settled rows kept resident: S03a-1 has no paged row index, so every row header stays in RAM. */
+        readonly residentSettledRows: number;
+    };
+    idle(): Promise<void>;
+    retire(): Promise<void>;
+    private start;
+    /**
+     * 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.
+     */
+    private delta;
+    private replace;
+    private setPersistence;
+    private remove;
+    private block;
+    private append;
+    /** Settling mints the final tail into a spillable leaf; a freeze of an active block shares the tail. */
+    private seal;
+    private pin;
+    private texts;
+}
+export {};
+//# sourceMappingURL=compact-session-state.d.ts.map