@code-yeongyu/senpi 2026.10.26-2 → 2026.10.27-1

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

@@ -1,4 +1,6 @@
 import { CompactContentIndex } from "./compact-content-index.js";
+import { CompactReadError, CompactReadLease } from "./compact-read-lease.js";
+import { readCompactBlocks } from "./compact-text-view.js";
 import { COMPACT_LEAF_CODE_UNITS, CompactContentStore, } from "./compact-content-store.js";
 import { CompactTransitionError, } from "./compact-transition.js";
 const byContentIndex = ([a], [b]) => a - b;
@@ -7,14 +9,17 @@ export class CompactSessionState {
         this.active = new Map();
         this.sequence = 0;
         this.frozenTailBytes = 0;
+        this.cuts = new WeakMap();
         this.store = new CompactContentStore(options);
-        const leavesOf = (row) => row.blocks.flatMap((block) => block.leaves);
+        const leavesOf = (row) => row.blocks.map((block) => block.root);
         this.settled = new CompactContentIndex(this.store, leavesOf, options.compactAboveRows ?? 128);
     }
     get acceptedSequence() {
         return this.sequence;
     }
     accept(transition) {
+        if (transition.type !== "message_remove")
+            this.store.assertReadable();
         switch (transition.type) {
             case "block_start":
                 this.start(transition);
@@ -35,28 +40,56 @@ export class CompactSessionState {
         return ++this.sequence;
     }
     freeze() {
+        this.store.assertReadable();
         const active = new Map();
         for (const [messageId, blocks] of this.active)
             active.set(messageId, this.seal(blocks, false));
         for (const blocks of active.values())
             this.pin(blocks, 1);
-        return { sequence: this.sequence, active, settled: this.settled.freeze() };
+        const frozen = { sequence: this.sequence, active, settled: this.settled.freeze() };
+        this.cuts.set(frozen, new CompactReadLease(() => {
+            for (const blocks of frozen.active.values())
+                this.pin(blocks, -1);
+            this.settled.release(frozen.settled);
+        }));
+        return frozen;
     }
     release(frozen) {
-        for (const blocks of frozen.active.values())
-            this.pin(blocks, -1);
-        this.settled.release(frozen.settled);
+        this.cutLease(frozen).release();
     }
     /** 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 await this.settled.entries(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 };
+        const lease = this.cutLease(frozen);
+        const valid = () => {
+            lease.assert();
+            this.store.assertReadable();
+        };
+        valid();
+        return lease.run(async () => {
+            const messages = [];
+            for (const [messageId, row] of await this.settled.entries(frozen.settled)) {
+                messages.push({
+                    messageId,
+                    persistence: row.persistence,
+                    blocks: await readCompactBlocks(this.store.text, row.blocks, valid),
+                });
+            }
+            for (const [messageId, blocks] of frozen.active) {
+                messages.push({
+                    messageId,
+                    persistence: undefined,
+                    blocks: await readCompactBlocks(this.store.text, blocks, valid),
+                });
+            }
+            valid();
+            return { sequence: frozen.sequence, messages };
+        });
+    }
+    cutLease(frozen) {
+        const lease = this.cuts.get(frozen);
+        if (!lease)
+            throw new CompactReadError("ownership");
+        return lease;
     }
     storageStatus() {
         let residentTailBytes = 0;
@@ -73,6 +106,9 @@ export class CompactSessionState {
             residentTailBytes,
             frozenTailBytes: this.frozenTailBytes,
             hotWitnessBytes,
+            residentTextNodes: this.store.text.residentNodes,
+            // Fixed accounting charge for node headers, two edges and pending dependency bookkeeping.
+            residentTextIndexBytes: this.store.text.residentNodes * 192,
         };
     }
     idle() {
@@ -90,7 +126,7 @@ export class CompactSessionState {
             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: "" };
+        const block = { kind: t.kind, root: 0, 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();
@@ -116,8 +152,8 @@ export class CompactSessionState {
             block.witness = "";
     }
     replace(block, text) {
-        for (const id of block.leaves.splice(0))
-            this.store.adjust(id, -1, 0);
+        this.store.adjust(block.root, -1, 0);
+        block.root = 0;
         block.tail = "";
         block.units = 0;
         block.covered = 0;
@@ -130,8 +166,7 @@ export class CompactSessionState {
         if (blocks) {
             this.settled.set(messageId, { persistence, blocks: this.seal(blocks, true) });
             for (const block of blocks.values())
-                for (const id of block.leaves)
-                    this.store.adjust(id, -1, 0);
+                this.store.adjust(block.root, -1, 0);
             this.active.delete(messageId);
         }
         else if (this.settled.has(messageId)) {
@@ -147,8 +182,7 @@ export class CompactSessionState {
         if (!blocks && !settled)
             throw new CompactTransitionError("unknown_message", messageId);
         for (const block of blocks?.values() ?? [])
-            for (const id of block.leaves)
-                this.store.adjust(id, -1, 0);
+            this.store.adjust(block.root, -1, 0);
         this.active.delete(messageId);
         if (settled)
             this.settled.delete(messageId);
@@ -164,7 +198,7 @@ export class CompactSessionState {
         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.root = this.store.text.append(block.root, block.tail + rest.slice(0, take));
             block.tail = "";
             rest = rest.slice(take);
         }
@@ -174,24 +208,17 @@ export class CompactSessionState {
     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.root = this.store.text.append(block.root, block.tail);
                 block.tail = "";
             }
-            return { contentIndex, kind: block.kind, leaves: [...block.leaves], tail: block.tail };
+            return { contentIndex, kind: block.kind, root: block.root, 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);
+            this.store.adjust(block.root, 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-storage.d.ts

@@ -20,6 +20,10 @@ export declare abstract class CompactSpoolStorage {
     protected pendingIoCopyBytes: number;
     protected spillBytesWritten: number;
     protected reclaimDebtBytes: number;
+    private reads;
+    private reading;
+    assertReadable(): void;
+    beginRead(): () => void;
     constructor(dir: string, io: CompactStorageIo);
     /** Resolves once every queued storage job, including the ones they queued, has completed. */
     idle(): Promise<void>;
@@ -30,6 +34,7 @@ export declare abstract class CompactSpoolStorage {
     retire(): Promise<void>;
     /** Reads a committed file and rejects a missing, unreadable or short one. */
     readFile(path: string, bytes: number, operation: CompactStorageOperation): Promise<Buffer>;
+    private readCommittedFile;
     /** Writes one new spool file; undefined means the write failed and was reported (a spill write also halts spilling). */
     writeFile(data: Buffer, operation: CompactStorageOperation, retainedInMemoryBytes: number): Promise<string | undefined>;
     /**

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

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { CompactReadError } from "./compact-read-lease.js";
 import { createSpoolDir, removeSpoolDir } from "./compact-spool-dir.js";
 import { CompactStorageReadError, describeCause, } from "./compact-storage-io.js";
 /**
@@ -10,6 +11,25 @@ export 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 CompactSpoolStorage {
+    assertReadable() {
+        if (this.retired)
+            throw new CompactReadError("retired");
+    }
+    beginRead() {
+        this.assertReadable();
+        this.reads++;
+        this.reading ??= Promise.withResolvers();
+        let done = false;
+        return () => {
+            if (done)
+                return;
+            done = true;
+            if (--this.reads === 0) {
+                this.reading?.resolve();
+                this.reading = undefined;
+            }
+        };
+    }
     constructor(dir, io) {
         this.failures = [];
         this.nextFile = 1;
@@ -21,6 +41,7 @@ export class CompactSpoolStorage {
         this.pendingIoCopyBytes = 0;
         this.spillBytesWritten = 0;
         this.reclaimDebtBytes = 0;
+        this.reads = 0;
         this.dir = dir;
         this.io = io;
     }
@@ -35,6 +56,7 @@ export class CompactSpoolStorage {
      */
     async retire() {
         this.retired = true;
+        await this.reading?.promise;
         await this.idle();
         const token = this.spoolToken;
         this.spoolToken = undefined;
@@ -43,6 +65,17 @@ export class CompactSpoolStorage {
     }
     /** Reads a committed file and rejects a missing, unreadable or short one. */
     async readFile(path, bytes, operation) {
+        const done = this.beginRead();
+        try {
+            const result = await this.readCommittedFile(path, bytes, operation);
+            this.assertReadable();
+            return result;
+        }
+        finally {
+            done();
+        }
+    }
+    async readCommittedFile(path, bytes, operation) {
         let data;
         try {
             data = await this.io.readFile(path);

package/dist/modes/rpc/compact-text-roots.d.ts

@@ -0,0 +1,22 @@
+import { type CompactContentStore, type LeafId } from "./compact-content-store.ts";
+/** Persistent append tree: positive refs are leaves, negative refs are nodes, zero is empty. */
+export declare class CompactTextRoots {
+    private readonly nodes;
+    private readonly pending;
+    private readonly store;
+    private next;
+    constructor(store: CompactContentStore);
+    get residentNodes(): number;
+    units(id: LeafId): number;
+    isCommitted(id: LeafId): boolean;
+    /** Transfers one live root and one newly owned bounded leaf into the new root. */
+    append(root: LeafId, text: string): LeafId;
+    adjust(id: LeafId, live: number, pins: number): void;
+    /** Bounded UTF-16 result and bounded leaf/tail count, checked before any I/O. */
+    read(root: LeafId, tail: string, offset: number, units: number, maxLeaves?: number, valid?: () => void): Promise<string>;
+    private node;
+    private appendLeaf;
+    private height;
+    private join;
+}
+//# sourceMappingURL=compact-text-roots.d.ts.map

package/dist/modes/rpc/compact-text-roots.js

@@ -0,0 +1,138 @@
+import { CompactCommitDependencies } from "./compact-commit-dependencies.js";
+import { COMPACT_LEAF_CODE_UNITS } from "./compact-content-store.js";
+import { CompactReadError } from "./compact-read-lease.js";
+/** Persistent append tree: positive refs are leaves, negative refs are nodes, zero is empty. */
+export class CompactTextRoots {
+    constructor(store) {
+        this.nodes = new Map();
+        this.next = -1;
+        this.store = store;
+        this.pending = new CompactCommitDependencies(store, (id) => store.committed(id));
+    }
+    get residentNodes() {
+        return this.nodes.size;
+    }
+    units(id) {
+        return id === 0 ? 0 : id > 0 ? this.store.leafUnits(id) : this.node(id).units;
+    }
+    isCommitted(id) {
+        return this.nodes.has(id) && !this.pending.has(id);
+    }
+    /** Transfers one live root and one newly owned bounded leaf into the new root. */
+    append(root, text) {
+        this.units(root);
+        const leaf = this.store.createLeaf(text);
+        if (root === 0)
+            return leaf;
+        const result = this.appendLeaf(root, leaf);
+        this.store.adjust(root, -1, 0);
+        this.store.adjust(leaf, -1, 0);
+        return result;
+    }
+    adjust(id, live, pins) {
+        const node = this.node(id);
+        const beforeLive = Number(node.live > 0);
+        const beforePin = Number(node.live === 0 && node.pins > 0);
+        if (node.live + live < 0 || node.pins + pins < 0)
+            throw new CompactReadError("ownership");
+        node.live += live;
+        node.pins += pins;
+        const liveChange = Number(node.live > 0) - beforeLive;
+        const pinChange = Number(node.live === 0 && node.pins > 0) - beforePin;
+        // Extra cuts on a live subtree do not visit children. Only category transitions propagate.
+        if (liveChange || pinChange) {
+            this.store.adjust(node.left, liveChange, pinChange);
+            this.store.adjust(node.right, liveChange, pinChange);
+        }
+        if (node.live === 0 && node.pins === 0) {
+            this.pending.delete(id);
+            this.nodes.delete(id);
+        }
+    }
+    /** Bounded UTF-16 result and bounded leaf/tail count, checked before any I/O. */
+    async read(root, tail, offset, units, maxLeaves = 2, valid = () => this.store.assertReadable()) {
+        this.store.assertReadable();
+        valid();
+        const length = this.units(root);
+        if (!Number.isSafeInteger(offset) ||
+            !Number.isSafeInteger(units) ||
+            offset < 0 ||
+            units < 0 ||
+            offset + units > length + tail.length)
+            throw new CompactReadError("range");
+        if (units > COMPACT_LEAF_CODE_UNITS)
+            throw new CompactReadError("size_limit");
+        if (!Number.isSafeInteger(maxLeaves) || maxLeaves < 1 || maxLeaves > 2)
+            throw new CompactReadError("count_limit");
+        const selected = [];
+        const visit = (id, start, end) => {
+            if (start >= end || id === 0)
+                return;
+            if (id > 0) {
+                if (selected.length === maxLeaves)
+                    throw new CompactReadError("count_limit");
+                selected.push({ id, offset: start, units: end - start });
+            }
+            else {
+                const node = this.node(id);
+                const leftUnits = this.units(node.left);
+                visit(node.left, start, Math.min(end, leftUnits));
+                visit(node.right, Math.max(0, start - leftUnits), end - leftUnits);
+            }
+        };
+        visit(root, offset, Math.min(length, offset + units));
+        const tailUnits = units === 0 ? 0 : Math.max(0, offset + units - Math.max(offset, length));
+        if (selected.length + Number(tailUnits > 0) > maxLeaves)
+            throw new CompactReadError("count_limit");
+        this.store.adjust(root, 0, 1);
+        const done = this.store.beginRead();
+        try {
+            let result = "";
+            for (const part of selected) {
+                const text = await this.store.readLeaf(part.id);
+                valid();
+                result += text.slice(part.offset, part.offset + part.units);
+            }
+            valid();
+            return result + tail.slice(Math.max(0, offset - length), Math.max(0, offset - length) + tailUnits);
+        }
+        finally {
+            this.store.adjust(root, 0, -1);
+            done();
+        }
+    }
+    node(id) {
+        const node = this.nodes.get(id);
+        if (!node)
+            throw new CompactReadError("ownership");
+        return node;
+    }
+    appendLeaf(root, leaf) {
+        const node = this.nodes.get(root);
+        if (!node || this.height(node.left) === this.height(node.right))
+            return this.join(root, leaf);
+        const right = this.appendLeaf(node.right, leaf);
+        const result = this.join(node.left, right);
+        this.store.adjust(right, -1, 0);
+        return result;
+    }
+    height(id) {
+        return id > 0 ? 0 : this.node(id).height;
+    }
+    join(left, right) {
+        const id = this.next--;
+        this.nodes.set(id, {
+            left,
+            right,
+            units: this.units(left) + this.units(right),
+            height: 1 + Math.max(this.height(left), this.height(right)),
+            live: 1,
+            pins: 0,
+        });
+        this.store.adjust(left, 1, 0);
+        this.store.adjust(right, 1, 0);
+        this.pending.set(id, [left, right]);
+        return id;
+    }
+}
+//# sourceMappingURL=compact-text-roots.js.map

package/dist/modes/rpc/compact-text-view.d.ts

@@ -0,0 +1,22 @@
+import { type LeafId } from "./compact-content-store.ts";
+import type { CompactTextRoots } from "./compact-text-roots.ts";
+import type { CompactBlockKind, CompactPersistence } from "./compact-transition.ts";
+export interface FrozenBlock {
+    readonly contentIndex: number;
+    readonly kind: CompactBlockKind;
+    readonly root: LeafId;
+    /** A cut shares the immutable tail (under one leaf), not a new leaf for each freeze. */
+    readonly tail: string;
+}
+export interface CompactMessageView {
+    readonly messageId: string;
+    readonly persistence: CompactPersistence | undefined;
+    readonly blocks: readonly {
+        readonly contentIndex: number;
+        readonly kind: CompactBlockKind;
+        readonly text: string;
+    }[];
+}
+/** Compatibility assembly only; each underlying range is bounded, the resulting legacy view is not. */
+export declare function readCompactBlocks(texts: CompactTextRoots, blocks: readonly FrozenBlock[], valid: () => void): Promise<CompactMessageView["blocks"]>;
+//# sourceMappingURL=compact-text-view.d.ts.map

package/dist/modes/rpc/compact-text-view.js

@@ -0,0 +1,16 @@
+import { COMPACT_LEAF_CODE_UNITS } from "./compact-content-store.js";
+/** Compatibility assembly only; each underlying range is bounded, the resulting legacy view is not. */
+export async function readCompactBlocks(texts, blocks, valid) {
+    const result = [];
+    for (const { contentIndex, kind, root, tail } of blocks) {
+        valid();
+        const length = texts.units(root) + tail.length;
+        let text = "";
+        for (let offset = 0; offset < length; offset += COMPACT_LEAF_CODE_UNITS) {
+            text += await texts.read(root, tail, offset, Math.min(COMPACT_LEAF_CODE_UNITS, length - offset), 2, valid);
+        }
+        result.push({ contentIndex, kind, text });
+    }
+    return result;
+}
+//# sourceMappingURL=compact-text-view.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.26-2",
+	"version": "2026.10.27-1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -71,9 +71,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.26-2",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.26-2",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.26-2",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.27-1",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.27-1",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.27-1",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"ajv": "8.20.0",
 		"chalk": "6.0.0",
@@ -93,8 +93,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.306",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.26-2",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.26-2",
+		"@code-yeongyu/senpi-codemode": "2026.10.27-1",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.27-1",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",