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

package/dist/modes/json-event.js

@@ -1,3 +1,4 @@
+import { getAssistantCapture, } from "@earendil-works/pi-ai";
 function toJsonAssistantMessageEvent(event) {
     if (event.type === "toolcall_start") {
         const toolCall = event.partial.content[event.contentIndex];
@@ -13,7 +14,84 @@ function toJsonAssistantMessageEvent(event) {
     const { partial: _partial, ...deltaEvent } = event;
     return deltaEvent;
 }
-export function toJsonEvent(event) {
+/**
+ * Builds a seeded assistant event from the producer-time capture only: an ordinary delta reads its index, its
+ * delta string and the capture, never the shared partial, the block or the parsed arguments.
+ */
+function toSeededAssistantEvent(event, capture) {
+    if (event.type === "start")
+        return capture.message && { type: "start", seed: { message: capture.message } };
+    if (event.type === "done")
+        return { type: "done", reason: event.reason, message: event.message };
+    if (event.type === "error")
+        return { type: "error", reason: event.reason, error: event.error };
+    const contentIndex = capture.contentIndex ?? event.contentIndex;
+    if (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") {
+        const { offset, parsedThrough } = capture;
+        if (offset === undefined)
+            return undefined;
+        if (event.type !== "toolcall_delta")
+            return { type: event.type, contentIndex, delta: event.delta, offset };
+        if (parsedThrough === undefined)
+            return undefined;
+        return { type: event.type, contentIndex, delta: event.delta, offset, parsedThrough };
+    }
+    const { block, coveredCodeUnits } = capture;
+    if (event.type === "toolcall_end")
+        return block?.type === "toolCall" ? { type: event.type, contentIndex, toolCall: block } : undefined;
+    if (event.type === "text_end")
+        return block?.type === "text" ? { type: event.type, contentIndex, content: event.content, block } : undefined;
+    if (event.type === "thinking_end")
+        return block?.type === "thinking" ? { type: event.type, contentIndex, content: event.content, block } : undefined;
+    if (coveredCodeUnits === undefined)
+        return undefined;
+    if (event.type === "text_start")
+        return block?.type === "text" ? { type: event.type, contentIndex, seed: { block, coveredCodeUnits } } : undefined;
+    if (event.type === "thinking_start")
+        return block?.type === "thinking"
+            ? { type: event.type, contentIndex, seed: { block, coveredCodeUnits } }
+            : undefined;
+    const { rawArgumentPrefix, parsedThrough } = capture;
+    if (block?.type !== "toolCall" || rawArgumentPrefix === undefined || parsedThrough === undefined)
+        return undefined;
+    return {
+        type: event.type,
+        contentIndex,
+        id: block.id,
+        toolName: block.name,
+        seed: { block, rawArgumentPrefix, parsedThrough, coveredCodeUnits },
+    };
+}
+/**
+ * An assistant record with no capture has no seeded form (`undefined`): its producer captured nothing, so any
+ * seed would be read from the live partial and could already hold later bytes. Identity is never invented.
+ */
+function toSeededJsonEvent(event) {
+    if ((event.type === "message_start" || event.type === "message_end") && event.message.role === "assistant") {
+        const message = getAssistantCapture(event)?.message;
+        if (message)
+            return { ...event, message };
+        // The terminal message is complete when emitted; only an uncaptured start may already hold later bytes.
+        return event.type === "message_end" ? event : undefined;
+    }
+    if (event.type !== "message_update")
+        return event;
+    const capture = getAssistantCapture(event);
+    const assistantMessageEvent = capture && toSeededAssistantEvent(event.assistantMessageEvent, capture);
+    if (!capture || !assistantMessageEvent)
+        return undefined;
+    const { message: _message, assistantMessageEvent: _event, ...outer } = event;
+    const changed = capture.metadata !== undefined && Object.keys(capture.metadata).length > 0;
+    return {
+        ...outer,
+        usage: capture.usage,
+        ...(changed ? { messageMetadata: capture.metadata } : {}),
+        assistantMessageEvent,
+    };
+}
+export function toJsonEvent(event, options) {
+    if (options)
+        return toSeededJsonEvent(event);
     if (event.type !== "message_update") {
         return event;
     }

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

@@ -0,0 +1,85 @@
+import type { CompactContentStore, LeafId } from "./compact-content-store.ts";
+/**
+ * A spillable keyed collection: an immutable paged disk base plus one resident override slot per key
+ * (senpi#4272). Updates coalesce into that slot, so N updates to one key hold one slot, and a cold row
+ * changes without reading its page. Background compaction folds eligible overrides into new pages and
+ * publishes them in one synchronous swap that never removes an override newer than the one it read.
+ * A failed compaction leaves the previous base in place and the next one free to run.
+ * Pages are internal storage only; nothing here is a wire record.
+ */
+type Override<Row> = {
+    readonly kind: "row";
+    readonly row: Row;
+} | {
+    readonly kind: "patch";
+    readonly patch: Partial<Row>;
+} | {
+    readonly kind: "tombstone";
+};
+interface Page {
+    readonly path: string;
+    readonly bytes: number;
+    /** Published keys; a row skipped at publication stays in the file but is never read back. */
+    readonly keys: readonly string[];
+    readonly leaves: readonly LeafId[];
+    inBase: boolean;
+    pins: number;
+}
+interface IndexBase {
+    readonly pages: readonly Page[];
+    readonly pageOf: ReadonlyMap<string, Page>;
+}
+export interface FrozenIndex<Row> {
+    readonly base: IndexBase;
+    readonly overrides: ReadonlyMap<string, Override<Row>>;
+}
+export declare class CompactContentIndex<Row extends object> {
+    private readonly store;
+    private readonly leavesOf;
+    private readonly compactAboveRows;
+    private base;
+    private readonly overrides;
+    /** Uncommitted leaves per row override; only overrides absent here are eligible to fold. */
+    private readonly unsettledLeaves;
+    private readonly leafKey;
+    private compacting;
+    private tombstones;
+    private tombstoneKeyUnits;
+    constructor(store: CompactContentStore, leavesOf: (row: Row) => readonly LeafId[], compactAboveRows: number);
+    has(key: string): boolean;
+    set(key: string, row: Row): void;
+    patch(key: string, fields: Partial<Row>): void;
+    /** A key only the overlay ever held leaves no tombstone; a committed one is masked until compaction. */
+    delete(key: string): void;
+    freeze(): FrozenIndex<Row>;
+    release(frozen: FrozenIndex<Row>): void;
+    /** Every row visible at a frozen root, reading only that root's own pages. */
+    entries(frozen: FrozenIndex<Row>): Promise<Map<string, Row>>;
+    status(): {
+        overrideSlots: number;
+        deletionMasks: number;
+        deletionMaskBytes: number;
+        basePages: number;
+        baseRows: number;
+    };
+    /** The acceptance path checks counts only: an override is eligible once none of its leaves is uncommitted. */
+    maybeCompact(): void;
+    private committed;
+    /** Folds eligible overrides and every small base page; false leaves the previous base untouched. */
+    private compact;
+    /**
+     * The publication point: one synchronous step, so no acceptance observes a half-swapped index. A folded
+     * row is published only while its value is still observable (its override is the folded one, or a newer
+     * patch over it); a row removed or wholly replaced meanwhile is skipped, so every published leaf is still
+     * owned by the folded override or a touched page when its reference is added.
+     */
+    private swap;
+    private readPage;
+    private reclaimPage;
+    private put;
+    private drop;
+    private countTombstone;
+    private pinRow;
+}
+export {};
+//# sourceMappingURL=compact-content-index.d.ts.map

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

@@ -0,0 +1,254 @@
+import { isSmallPage, packPages } from "./compact-index-pages.js";
+export class CompactContentIndex {
+    constructor(store, leavesOf, compactAboveRows) {
+        this.base = { pages: [], pageOf: new Map() };
+        this.overrides = new Map();
+        /** Uncommitted leaves per row override; only overrides absent here are eligible to fold. */
+        this.unsettledLeaves = new Map();
+        this.leafKey = new Map();
+        this.compacting = false;
+        this.tombstones = 0;
+        this.tombstoneKeyUnits = 0;
+        this.store = store;
+        this.leavesOf = leavesOf;
+        this.compactAboveRows = compactAboveRows;
+        store.onCommitted = (id) => this.committed(id);
+    }
+    has(key) {
+        const override = this.overrides.get(key);
+        return override ? override.kind !== "tombstone" : this.base.pageOf.has(key);
+    }
+    set(key, row) {
+        this.put(key, { kind: "row", row });
+    }
+    patch(key, fields) {
+        const current = this.overrides.get(key);
+        if (current?.kind === "row")
+            this.put(key, { kind: "row", row: { ...current.row, ...fields } });
+        else if (current?.kind === "patch")
+            this.put(key, { kind: "patch", patch: { ...current.patch, ...fields } });
+        else
+            this.put(key, { kind: "patch", patch: fields });
+    }
+    /** A key only the overlay ever held leaves no tombstone; a committed one is masked until compaction. */
+    delete(key) {
+        if (this.base.pageOf.has(key))
+            this.put(key, { kind: "tombstone" });
+        else
+            this.drop(key);
+    }
+    freeze() {
+        for (const page of this.base.pages)
+            page.pins++;
+        for (const override of this.overrides.values())
+            this.pinRow(override, 1);
+        return { base: this.base, overrides: new Map(this.overrides) };
+    }
+    release(frozen) {
+        for (const override of frozen.overrides.values())
+            this.pinRow(override, -1);
+        for (const page of frozen.base.pages) {
+            page.pins--;
+            if (!page.inBase && page.pins === 0)
+                this.reclaimPage(page, 0, -1);
+        }
+    }
+    /** Every row visible at a frozen root, reading only that root's own pages. */
+    async entries(frozen) {
+        const rows = new Map();
+        for (const page of frozen.base.pages)
+            for (const [key, row] of await this.readPage(page))
+                rows.set(key, row);
+        applyOverrides(rows, frozen.overrides);
+        return rows;
+    }
+    status() {
+        return {
+            overrideSlots: this.overrides.size,
+            deletionMasks: this.tombstones,
+            deletionMaskBytes: this.tombstoneKeyUnits * 2,
+            basePages: this.base.pages.length,
+            baseRows: this.base.pageOf.size,
+        };
+    }
+    /** The acceptance path checks counts only: an override is eligible once none of its leaves is uncommitted. */
+    maybeCompact() {
+        if (this.compacting || !this.store.spillAllowed)
+            return;
+        if (this.overrides.size - this.unsettledLeaves.size < this.compactAboveRows)
+            return;
+        this.compacting = true;
+        this.store.enqueue("page_write", async () => {
+            let progressed = false;
+            try {
+                progressed = await this.compact();
+            }
+            finally {
+                this.compacting = false;
+            }
+            if (progressed)
+                this.maybeCompact();
+        });
+    }
+    committed(id) {
+        const key = this.leafKey.get(id);
+        if (key === undefined)
+            return;
+        this.leafKey.delete(id);
+        const left = (this.unsettledLeaves.get(key) ?? 0) - 1;
+        if (left > 0)
+            this.unsettledLeaves.set(key, left);
+        else
+            this.unsettledLeaves.delete(key);
+        this.maybeCompact();
+    }
+    /** Folds eligible overrides and every small base page; false leaves the previous base untouched. */
+    async compact() {
+        const base = this.base;
+        const selected = [...this.overrides].filter(([key]) => !this.unsettledLeaves.has(key));
+        if (selected.length < this.compactAboveRows)
+            return false;
+        const touched = new Set(base.pages.filter(isSmallPage));
+        for (const [key] of selected) {
+            const page = base.pageOf.get(key);
+            if (page)
+                touched.add(page);
+        }
+        const rows = new Map();
+        try {
+            for (const page of touched)
+                for (const [key, row] of await this.readPage(page))
+                    rows.set(key, row);
+        }
+        catch {
+            return false;
+        }
+        applyOverrides(rows, new Map(selected));
+        const written = [];
+        for (const chunk of packPages([...rows])) {
+            const data = Buffer.from(JSON.stringify(chunk));
+            const path = await this.store.writeFile(data, "page_write", data.byteLength);
+            if (path === undefined || !this.store.spillAllowed) {
+                for (const page of written)
+                    this.store.discard(page.path, page.bytes);
+                if (path !== undefined)
+                    this.store.discard(path, data.byteLength);
+                return false;
+            }
+            written.push({ path, bytes: data.byteLength, rows: chunk });
+        }
+        this.swap(base, touched, written, new Map(selected));
+        return true;
+    }
+    /**
+     * The publication point: one synchronous step, so no acceptance observes a half-swapped index. A folded
+     * row is published only while its value is still observable (its override is the folded one, or a newer
+     * patch over it); a row removed or wholly replaced meanwhile is skipped, so every published leaf is still
+     * owned by the folded override or a touched page when its reference is added.
+     */
+    swap(base, touched, written, selected) {
+        const pageOf = new Map(base.pageOf);
+        for (const page of touched)
+            for (const key of page.keys)
+                pageOf.delete(key);
+        const published = [];
+        for (const { path, bytes, rows } of written) {
+            const kept = rows.filter(([key]) => {
+                const folded = selected.get(key);
+                const current = this.overrides.get(key);
+                return folded === undefined || current === folded || current?.kind === "patch";
+            });
+            if (kept.length === 0) {
+                this.store.discard(path, bytes);
+                continue;
+            }
+            const leaves = kept.flatMap(([, row]) => this.leavesOf(row));
+            const page = { path, bytes, keys: kept.map(([key]) => key), leaves, inBase: true, pins: 0 };
+            for (const key of page.keys)
+                pageOf.set(key, page);
+            for (const id of leaves)
+                this.store.adjust(id, 1, 0);
+            published.push(page);
+        }
+        this.base = { pages: [...base.pages.filter((page) => !touched.has(page)), ...published], pageOf };
+        for (const [key, override] of selected) {
+            const current = this.overrides.get(key);
+            if (current === override || (current?.kind === "tombstone" && !pageOf.has(key)))
+                this.drop(key);
+        }
+        for (const page of touched) {
+            page.inBase = false;
+            if (page.pins === 0)
+                this.reclaimPage(page, -1, 0);
+            else
+                for (const id of page.leaves)
+                    this.store.adjust(id, -1, 1);
+        }
+    }
+    async readPage(page) {
+        const data = await this.store.readFile(page.path, page.bytes, "page_read");
+        const entries = JSON.parse(data.toString("utf8"));
+        if (entries.length === page.keys.length)
+            return entries;
+        const keys = new Set(page.keys);
+        return entries.filter(([key]) => keys.has(key));
+    }
+    reclaimPage(page, live, pins) {
+        for (const id of page.leaves)
+            this.store.adjust(id, live, pins);
+        this.store.discard(page.path, page.bytes);
+    }
+    put(key, override) {
+        const leaves = override.kind === "row" ? this.leavesOf(override.row) : [];
+        for (const id of leaves)
+            this.store.adjust(id, 1, 0);
+        this.drop(key);
+        this.overrides.set(key, override);
+        const unsettled = leaves.filter((id) => !this.store.isCommitted(id));
+        for (const id of unsettled)
+            this.leafKey.set(id, key);
+        if (unsettled.length > 0)
+            this.unsettledLeaves.set(key, unsettled.length);
+        if (override.kind === "tombstone")
+            this.countTombstone(key, 1);
+        this.maybeCompact();
+    }
+    drop(key) {
+        const old = this.overrides.get(key);
+        if (!old)
+            return;
+        this.overrides.delete(key);
+        this.unsettledLeaves.delete(key);
+        if (old.kind === "row") {
+            for (const id of this.leavesOf(old.row)) {
+                this.leafKey.delete(id);
+                this.store.adjust(id, -1, 0);
+            }
+        }
+        if (old.kind === "tombstone")
+            this.countTombstone(key, -1);
+    }
+    countTombstone(key, delta) {
+        this.tombstones += delta;
+        this.tombstoneKeyUnits += delta * key.length;
+    }
+    pinRow(override, delta) {
+        if (override.kind === "row")
+            for (const id of this.leavesOf(override.row))
+                this.store.adjust(id, 0, delta);
+    }
+}
+function applyOverrides(rows, overrides) {
+    for (const [key, override] of overrides) {
+        if (override.kind === "tombstone")
+            rows.delete(key);
+        else if (override.kind === "row")
+            rows.set(key, override.row);
+        else {
+            const row = rows.get(key);
+            if (row)
+                rows.set(key, { ...row, ...override.patch });
+        }
+    }
+}
+//# sourceMappingURL=compact-content-index.js.map

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

@@ -1,3 +1,4 @@
+import { CompactSpoolStorage } from "./compact-spool-storage.ts";
 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).
@@ -30,67 +31,29 @@ export interface CompactContentStoreOptions {
     readonly spillAboveBytes?: number;
     readonly spillTargetBytes?: number;
 }
-export declare class CompactContentStore {
-    readonly dir: string;
-    private readonly io;
+export declare class CompactContentStore extends CompactSpoolStorage {
     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;
+    /** Called after a leaf commits, so index compaction can include rows that now reference only disk. */
+    onCommitted: ((id: LeafId) => void) | undefined;
     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;
+    isCommitted(id: LeafId): boolean;
     /** 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;
+    protected scheduleSpill(): void;
     /** 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