@fungi.computer/shiitake 0.2.0 → 0.3.1

package/dist/internal/woodstock/storage-admission.d.ts

@@ -1,14 +1,14 @@
-import type { StorageBudget } from "../contracts.js";
+import type { StoragePressureCheck } from "../contracts.js";
 /** The admission check for writes that start new work. */
 export type StorageAdmission = Readonly<{
     /**
-     * Throw a typed `storage_pressure` refusal when the owner is near its
-     * budget. Called only for a new Session or a new prompt, never for a
-     * replayed request or for writes that finish admitted work.
+     * Throw a typed `storage_pressure` refusal when the host reports pressure.
+     * Called only for a new Session or a new prompt, never for a replayed
+     * request or for writes that finish admitted work.
      */
     admitNew: () => void;
 }>;
-/** The admission of a host that set no budget: nothing is refused. */
-export declare const admitWithoutBudget: StorageAdmission;
-/** Open the owner's admission check over the host's measured budget. */
-export declare function openStorageAdmission(budget: StorageBudget | undefined): StorageAdmission;
+/** The admission of a host that set no check: nothing is refused. */
+export declare const admitWithoutCheck: StorageAdmission;
+/** Open the owner's refusal door over the host's storage-pressure check. */
+export declare function openStorageAdmission(check: StoragePressureCheck | undefined): StorageAdmission;

package/dist/internal/woodstock/storage-admission.js

@@ -1,43 +1,17 @@
-import * as Schema from "effect/Schema";
 import { ShiitakeError } from "../../errors.js";
-/**
- * Provisional disk thresholds, as fractions of the host's budget. At
- * `refuseAt` new Sessions and new prompts are refused; once refusing, they
- * are admitted again only below `readmitBelow`, so admission does not flap
- * while usage hovers at the threshold. The gap is the room the work already
- * admitted keeps for finishing: its writes never pass through this check.
- */
-const storagePressureThresholds = Object.freeze({
-    refuseAt: 0.8,
-    readmitBelow: 0.75,
-});
-const decodeBudgetBytes = Schema.decodeUnknownResult(Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0))));
-const decodeUsedBytes = Schema.decodeUnknownResult(Schema.Number.pipe(Schema.check(Schema.isFinite()), Schema.check(Schema.isGreaterThanOrEqualTo(0))));
-/** The admission of a host that set no budget: nothing is refused. */
-export const admitWithoutBudget = Object.freeze({
+/** The admission of a host that set no check: nothing is refused. */
+export const admitWithoutCheck = Object.freeze({
     admitNew: () => {
-        // No budget, so there is no storage pressure to refuse for.
+        // No check, so there is no storage pressure to refuse for.
     },
 });
-/** Open the owner's admission check over the host's measured budget. */
-export function openStorageAdmission(budget) {
-    if (budget === undefined)
-        return admitWithoutBudget;
-    const budgetBytes = decodeBudgetBytes(budget.budgetBytes);
-    if (budgetBytes._tag === "Failure")
-        throw new ShiitakeError("contract", "invalid", "Storage budget must be a positive whole number of bytes");
-    const limit = budgetBytes.success;
-    let refusing = false;
+/** Open the owner's refusal door over the host's storage-pressure check. */
+export function openStorageAdmission(check) {
+    if (check === undefined)
+        return admitWithoutCheck;
     return Object.freeze({
         admitNew: () => {
-            const used = decodeUsedBytes(budget.usedBytes());
-            if (used._tag === "Failure")
-                throw new ShiitakeError("store", "unavailable", "Owner storage size is unavailable");
-            const fraction = used.success / limit;
-            refusing = refusing
-                ? fraction >= storagePressureThresholds.readmitBelow
-                : fraction >= storagePressureThresholds.refuseAt;
-            if (refusing)
+            if (check.underPressure())
                 throw new ShiitakeError("store", "storage_pressure", "Storage is near its budget. New Sessions and prompts are refused until space is freed; running work continues.");
         },
     });

package/dist/internal/woodstock/storage-conformance.d.ts

@@ -0,0 +1,15 @@
+import type { SqliteOwner } from "../contracts.js";
+/**
+ * Calls `use` exactly once with an empty, writable owner of the host under
+ * test, then releases the owner. It resolves after `use` returns.
+ */
+export type WoodstockStorageProvider = (use: (owner: SqliteOwner) => void) => Promise<void>;
+/** One named case. */
+export type WoodstockConformanceCase = Readonly<{
+    /** Stable case name, for the runner's test title. */
+    name: string;
+    /** Open a fresh owner through the provider and run the case on it. */
+    run: () => Promise<void>;
+}>;
+/** Create the runner-independent cases for one Woodstock storage host. */
+export declare function createWoodstockStorageConformance(withOwner: WoodstockStorageProvider): readonly WoodstockConformanceCase[];

package/dist/internal/woodstock/storage-conformance.js

@@ -0,0 +1,489 @@
+/**
+ * Runner-independent conformance cases for one Woodstock Session storage host.
+ *
+ * Adapted from Pi Durable's `src/testing/storage-conformance.ts`
+ * (`earendil-works/pi` at 8efd314f): every host that backs Woodstock with a
+ * {@link SqliteOwner} — the local `node:sqlite` owner and the Durable Object's
+ * `ctx.storage` — runs the same cases through Woodstock's own writers and
+ * readers. Fungi delta: Pi's suite checks a generic record store (ID minting,
+ * task and document tables); Woodstock's store is the parent-pointer Session
+ * tree, so these cases check atomic admission, request-ID replay, bounded
+ * lineage reads, branch, fork, placeholder completion, deletion and the inbox.
+ * The cases import no test runner, only `node:assert`, so they run inside a
+ * Worker with `nodejs_compat` too.
+ *
+ * @packageDocumentation
+ */
+import assert from "node:assert/strict";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { openAdmissionDoor } from "../admission-door.js";
+import { sessionIds } from "./identities.js";
+import { appendCompactionNotice, branchSession, createSession, deleteSession, forkSession, prepareWoodstockSchema, readSessionInbox, } from "./index.js";
+import { readSessionInboxChanges, readSessionInboxSummary, } from "./session-inbox.js";
+import { appendCompactionTransitionOwned, appendSessionEntry, buildSessionContext, compactionHeadState, completeSessionLeaf, hasStoredSession, lineageRowLimit, readPendingSessionCommands, readSelectedPath, readSessionCommandAdmissionByRequest, readSessionTree, readStoredSessionSummary, setSessionTitle, } from "./session-store.js";
+import { admitWithoutCheck } from "./storage-admission.js";
+const contract = { core: "a".repeat(64), extensions: [] };
+function commandEntry(text) {
+    return {
+        kind: "command",
+        workId: sessionIds.work.generate(),
+        requestId: `request-${sessionIds.fact.generate()}`,
+        receiptId: sessionIds.receipt.generate(),
+        message: { role: "user", content: text, timestamp: 1 },
+        contract,
+    };
+}
+function append(owner, sessionId, text) {
+    return appendSessionEntry(owner, {
+        sessionId,
+        id: sessionIds.fact.generate(),
+        entry: commandEntry(text),
+    });
+}
+function door(owner, enqueue = () => undefined) {
+    return openAdmissionDoor({
+        owner,
+        admitNew: admitWithoutCheck.admitNew,
+        contract: () => contract,
+        enqueue,
+        readQueueHead: () => ({ state: "idle" }),
+        commit: (mutation) => mutation,
+        requestWake: Effect.void,
+    });
+}
+function prompt(sessionId, requestId, text) {
+    return {
+        sessionId,
+        command: { type: "prompt", requestId, text, delivery: "followUp" },
+        when: "now",
+        origin: { kind: "user" },
+    };
+}
+function admit(owner, request) {
+    return Effect.runSync(door(owner).admit(request));
+}
+const decodeCount = Schema.decodeUnknownSync(Schema.Struct({ count: Schema.Number }));
+function count(owner, table) {
+    return decodeCount(owner.sql.exec(`SELECT COUNT(*) AS count FROM ${table}`).one()).count;
+}
+const idle = () => undefined;
+const usage = {
+    input: 7,
+    output: 3,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 10,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.5 },
+};
+/** Compact `sessionId` so its context starts at `head`, from the current leaf. */
+function compact(owner, sessionId, head) {
+    const leaf = readSelectedPath(owner, { sessionId }).at(-1);
+    assert.ok(leaf !== undefined, "The Session has a leaf");
+    return appendCompactionTransitionOwned(owner, {
+        sessionId,
+        expectedLeafId: leaf.id,
+        workId: sessionIds.work.generate(),
+        trigger: "threshold",
+        tokensAfter: 10,
+        head,
+        summary: "summary",
+        tokensBefore: 100,
+        usage,
+        contextRevision: leaf.id,
+    });
+}
+/** Woodstock's typed refusal for an operation, matched by its codes. */
+function refuses(operation, refusal) {
+    assert.throws(operation, { _tag: "ShiitakeError", ...refusal });
+}
+const sessionTables = [
+    "sessions",
+    "session_entries",
+    "session_command_admissions",
+    "session_inbox",
+];
+/** Create the runner-independent cases for one Woodstock storage host. */
+export function createWoodstockStorageConformance(withOwner) {
+    const prepared = (test) => (owner) => {
+        Effect.runSync(prepareWoodstockSchema(owner));
+        test(owner);
+    };
+    const testCase = (name, test) => ({
+        name,
+        run: () => withOwner(prepared(test)),
+    });
+    return Object.freeze([
+        testCase("prepares the schema idempotently over stored Sessions", (owner) => {
+            const root = append(owner, "prepared-twice", "kept");
+            Effect.runSync(prepareWoodstockSchema(owner));
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId: "prepared-twice" }).map(({ id }) => id), [root.id]);
+        }),
+        testCase("admits a command batch atomically and rolls every table back on failure", (owner) => {
+            const before = sessionTables.map((table) => count(owner, table));
+            let enqueued = 0;
+            const failing = door(owner, () => {
+                enqueued += 1;
+                if (enqueued === 2)
+                    throw new Error("enqueue refused");
+            });
+            const exit = Effect.runSyncExit(failing.transact((within) => {
+                within(prompt("atomic-first", "atomic-1", "first"));
+                within(prompt("atomic-second", "atomic-2", "second"));
+            }));
+            assert.strictEqual(exit._tag, "Failure");
+            assert.strictEqual(enqueued, 2);
+            assert.deepStrictEqual(sessionTables.map((table) => count(owner, table)), before);
+            assert.strictEqual(hasStoredSession(owner, "atomic-first"), false);
+            assert.strictEqual(readSessionCommandAdmissionByRequest(owner, "atomic-first", "atomic-1"), undefined);
+            // The same batch commits whole once nothing refuses it.
+            Effect.runSync(door(owner).transact((within) => {
+                within(prompt("atomic-first", "atomic-1", "first"));
+                within(prompt("atomic-second", "atomic-2", "second"));
+            }));
+            assert.strictEqual(hasStoredSession(owner, "atomic-first"), true);
+            assert.strictEqual(hasStoredSession(owner, "atomic-second"), true);
+        }),
+        testCase("replays a request ID per Session and refuses a conflicting reuse", (owner) => {
+            const first = admit(owner, prompt("replay-a", "same-request", "hi"));
+            const replay = admit(owner, prompt("replay-a", "same-request", "hi"));
+            const elsewhere = admit(owner, prompt("replay-b", "same-request", "hi"));
+            assert.deepStrictEqual(replay, { ...first, delivery: "replay" });
+            assert.strictEqual(first.status, "accepted");
+            assert.strictEqual(elsewhere.status, "accepted");
+            assert.notStrictEqual(elsewhere.commandId, first.commandId, "A request ID is scoped to its Session");
+            refuses(() => admit(owner, prompt("replay-a", "same-request", "changed")), { boundary: "contract", cause: "conflict" });
+            assert.strictEqual(readPendingSessionCommands(owner, "replay-a", 10).total, 1);
+        }),
+        testCase("creates one Session per creation request ID", (owner) => {
+            const create = (requestId) => Effect.runSync(createSession(owner, requestId, admitWithoutCheck.admitNew));
+            const created = create("create-1");
+            assert.strictEqual(create("create-1"), created);
+            assert.ok(create("create-2") !== created, "A new request is a new id");
+            assert.strictEqual(count(owner, "sessions"), 2);
+        }),
+        testCase("keeps string identities and text lossless", (owner) => {
+            const text = 'Ünïcödé 🍄 \u0000 \u2028 \ud800 "quoted" \\ end';
+            const requestId = "request-🍄-ünï";
+            const accepted = admit(owner, prompt("lossless", requestId, text));
+            assert.strictEqual(accepted.status, "accepted");
+            const stored = readSessionCommandAdmissionByRequest(owner, "lossless", requestId);
+            assert.ok(stored, "A Unicode request ID indexes its admission");
+            assert.strictEqual(stored.id, accepted.commandId);
+            assert.ok("message" in stored.entry, "The admission stores its prompt");
+            assert.strictEqual(stored.entry.message.content, text);
+            const row = append(owner, "lossless", text);
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId: "lossless" }).at(-1)?.entry, row.entry);
+            // Text columns cannot hold a lone surrogate, so the door refuses such
+            // an identity before any write instead of indexing a lossy copy.
+            const before = sessionTables.map((table) => count(owner, table));
+            refuses(() => admit(owner, prompt("lossless", "request-\ud800", "lone")), { boundary: "contract", cause: "invalid" });
+            refuses(() => admit(owner, prompt("lossless-\ud800", "request-lone", "lone")), { boundary: "contract", cause: "invalid" });
+            assert.deepStrictEqual(sessionTables.map((table) => count(owner, table)), before);
+        }),
+        testCase("reads the complete selected lineage past every bounded lineage page", (owner) => {
+            const sessionId = "deep-lineage";
+            // One row past the bounded lineage page is the fewest that crosses it;
+            // one transaction keeps a file-backed host from syncing every row.
+            const total = lineageRowLimit + 1;
+            const ids = owner.transactionSync(() => Array.from({ length: total }, (_, index) => append(owner, sessionId, `turn ${String(index)}`).id));
+            const path = readSelectedPath(owner, { sessionId });
+            assert.deepStrictEqual(path.map(({ id }) => id), ids);
+            assert.deepStrictEqual(path.map(({ parentId }) => parentId), [null, ...ids.slice(0, -1)]);
+            assert.deepStrictEqual(path.map(({ sequence }) => sequence), ids.map((_, index) => index + 1));
+        }),
+        testCase("moves the selected branch in place and keeps the abandoned branch", (owner) => {
+            const sessionId = "branching";
+            const root = append(owner, sessionId, "root");
+            const abandoned = append(owner, sessionId, "abandoned");
+            Effect.runSync(branchSession(owner, {
+                sessionId,
+                type: "branch",
+                entryId: root.id,
+                assertIdleSession: idle,
+            }));
+            const selected = append(owner, sessionId, "selected");
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId }).map(({ id }) => id), [root.id, selected.id]);
+            const tree = readSessionTree(owner, { sessionId });
+            assert.deepStrictEqual(tree.map(({ row }) => row.id), [root.id]);
+            assert.deepStrictEqual(tree[0]?.children.map(({ row }) => row.id), [abandoned.id, selected.id]);
+        }),
+        testCase("forks a lineage with fresh identities and leaves its source unchanged", (owner) => {
+            const sessionId = "fork-source";
+            const root = append(owner, sessionId, "root");
+            const middle = append(owner, sessionId, "middle");
+            const tail = append(owner, sessionId, "tail");
+            const source = readSelectedPath(owner, { sessionId });
+            const forked = Effect.runSync(forkSession(owner, {
+                sessionId,
+                type: "fork",
+                entryId: middle.id,
+                assertIdleSession: idle,
+            })).sessionId;
+            const fork = readSelectedPath(owner, { sessionId: forked });
+            assert.strictEqual(fork.length, 2);
+            assert.ok(fork.every(({ id }) => id !== root.id && id !== middle.id), "Forked rows get fresh identities");
+            assert.deepStrictEqual(fork.map(({ parentId }) => parentId), [null, fork[0]?.id]);
+            assert.deepStrictEqual(buildSessionContext(fork), buildSessionContext([root, middle]));
+            append(owner, forked, "fork only");
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId }), source);
+            assert.strictEqual(source.at(-1)?.id, tail.id);
+        }),
+        testCase("completes a streaming placeholder in place with the exact message", (owner) => {
+            const sessionId = "placeholder";
+            const command = commandEntry("question");
+            appendSessionEntry(owner, {
+                sessionId,
+                id: sessionIds.fact.generate(),
+                entry: command,
+            });
+            const run = { kind: "run", value: "run-1" };
+            const turn = { kind: "turn", value: "turn-1", parent: run };
+            const message = {
+                kind: "message",
+                value: sessionIds.fact.generate(),
+                parent: turn,
+            };
+            const placeholder = appendSessionEntry(owner, {
+                sessionId,
+                id: message.value,
+                state: "streaming",
+                entry: {
+                    kind: "message_start",
+                    workId: command.workId,
+                    run,
+                    turn,
+                    message,
+                    role: "assistant",
+                },
+            });
+            const value = {
+                role: "assistant",
+                content: [{ type: "text", text: "answer" }],
+                api: "anthropic-messages",
+                provider: "anthropic",
+                model: "claude-test",
+                usage: {
+                    input: 1,
+                    output: 1,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                    totalTokens: 2,
+                    cost: {
+                        input: 0,
+                        output: 0,
+                        cacheRead: 0,
+                        cacheWrite: 0,
+                        total: 0,
+                    },
+                },
+                stopReason: "stop",
+                timestamp: 2,
+            };
+            const completed = completeSessionLeaf(owner, {
+                sessionId,
+                id: message.value,
+                entry: {
+                    kind: "message",
+                    workId: command.workId,
+                    run,
+                    turn,
+                    message,
+                    value,
+                },
+            });
+            assert.deepStrictEqual([completed.id, completed.parentId, completed.sequence], [placeholder.id, placeholder.parentId, placeholder.sequence]);
+            assert.strictEqual(completed.state, "complete");
+            const leaf = readSelectedPath(owner, { sessionId }).at(-1);
+            assert.ok(leaf?.entry.kind === "message", "The leaf is the message");
+            assert.strictEqual(leaf.id, placeholder.id);
+            assert.deepStrictEqual(leaf.entry.value, value);
+        }),
+        testCase("deletes one Session completely and leaves the others intact", (owner) => {
+            admit(owner, prompt("doomed", "doomed-1", "bye"));
+            const kept = append(owner, "kept", "stay");
+            const deleted = Effect.runSync(deleteSession(owner, {
+                sessionId: "doomed",
+                assertIdleSession: idle,
+            }));
+            assert.strictEqual(deleted, true);
+            assert.strictEqual(hasStoredSession(owner, "doomed"), false);
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId: "doomed" }), []);
+            assert.strictEqual(readSessionCommandAdmissionByRequest(owner, "doomed", "doomed-1"), undefined);
+            assert.strictEqual(readSessionInboxSummary(owner, "doomed"), undefined);
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId: "kept" }).map(({ id }) => id), [kept.id]);
+            assert.strictEqual(Effect.runSync(deleteSession(owner, {
+                sessionId: "doomed",
+                assertIdleSession: idle,
+            })), false);
+        }),
+        testCase("keeps a live lineage whole where it is written, and still deletes it whole", (owner) => {
+            const root = append(owner, "guarded", "root");
+            const leaf = append(owner, "guarded", "leaf");
+            assert.throws(() => owner.sql.exec("DELETE FROM session_entries WHERE id = ?", root.id), /Session entry still has children/u);
+            assert.throws(() => owner.sql.exec("UPDATE session_entries SET parent_id = NULL WHERE id = ?", leaf.id), /Session entry lineage columns are immutable/u);
+            assert.strictEqual(Effect.runSync(deleteSession(owner, {
+                sessionId: "guarded",
+                assertIdleSession: idle,
+            })), true);
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId: "guarded" }), []);
+        }),
+        testCase("refuses a REPLACE that would take a parent's place under another id", (owner) => {
+            const root = append(owner, "replaced", "root");
+            const middle = append(owner, "replaced", "middle");
+            const leaf = append(owner, "replaced", "leaf");
+            // Same Session and sequence as the middle row, a different id: the
+            // UNIQUE (session_id, sequence) conflict would delete the middle row.
+            try {
+                assert.throws(() => owner.sql.exec(`INSERT OR REPLACE INTO session_entries
+                 (id, session_id, parent_id, sequence, type, role, state,
+                  request_id, work_id, data_json, timestamp, completed_at)
+               SELECT 'replacement', session_id, parent_id, sequence, type,
+                      role, state, 'replacement-request', work_id, data_json,
+                      timestamp, completed_at
+                 FROM session_entries WHERE id = ?`, middle.id), /Session entry would strand its children/u);
+            }
+            finally {
+                // A missing exception alone understates this regression: the old
+                // REPLACE actually deletes middle and orphans leaf.
+                assert.deepStrictEqual(owner.sql
+                    .exec(`SELECT
+                 EXISTS (SELECT 1 FROM session_entries WHERE id = ?) AS parent_exists,
+                 (SELECT COUNT(*) FROM session_entries AS child
+                    LEFT JOIN session_entries AS parent ON parent.id = child.parent_id
+                   WHERE child.id = ? AND parent.id IS NULL) AS orphaned_children`, middle.id, leaf.id)
+                    .one(), { parent_exists: 1, orphaned_children: 0 });
+            }
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId: "replaced" }).map(({ id }) => id), [root.id, middle.id, leaf.id]);
+        }),
+        testCase("refuses only the Session a writer outside Woodstock broke, from the next open", (owner) => {
+            append(owner, "healthy", "root");
+            append(owner, "damaged", "root");
+            const middle = append(owner, "damaged", "middle");
+            append(owner, "damaged", "leaf");
+            for (const guard of [
+                "session_entries_lineage_insert",
+                "session_entries_lineage_update",
+                "session_entries_lineage_delete",
+                "session_entries_damaged_session",
+                "session_entries_lineage_replace",
+                "session_entries_lineage_replace_position",
+            ])
+                owner.sql.exec(`DROP TRIGGER ${guard}`);
+            owner.sql.exec("DELETE FROM session_entries WHERE id = ?", middle.id);
+            Effect.runSync(prepareWoodstockSchema(owner));
+            assert.throws(() => readSelectedPath(owner, { sessionId: "damaged" }), /holds a broken lineage/u);
+            assert.throws(() => append(owner, "damaged", "more"), /holds a broken lineage/u);
+            const more = append(owner, "healthy", "more");
+            assert.deepStrictEqual(readSelectedPath(owner, { sessionId: "healthy" }).at(-1)?.id, more.id);
+        }),
+        testCase("judges a compaction head against the context start and the selected lineage", (owner) => {
+            const sessionId = "head-check";
+            const first = append(owner, sessionId, "first");
+            const second = append(owner, sessionId, "second");
+            const third = append(owner, sessionId, "third");
+            const state = (head) => compactionHeadState(owner, { sessionId, head });
+            // Before any compaction every entry on the lineage is current.
+            assert.strictEqual(state(first.id), "current");
+            compact(owner, sessionId, second.id);
+            // Older than the context start: a later compaction already cut it.
+            assert.strictEqual(state(first.id), "stale");
+            // At or after the context start: still inside the model context.
+            assert.strictEqual(state(second.id), "current");
+            assert.strictEqual(state(third.id), "current");
+            assert.strictEqual(state("unknown-entry"), "stale");
+            assert.strictEqual(compactionHeadState(owner, { sessionId: "no-such", head: first.id }), "stale");
+        }),
+        testCase("treats a compaction head off the selected lineage as stale", (owner) => {
+            const sessionId = "head-off-lineage";
+            const root = append(owner, sessionId, "root");
+            const abandoned = append(owner, sessionId, "abandoned");
+            Effect.runSync(branchSession(owner, {
+                sessionId,
+                type: "branch",
+                entryId: root.id,
+                assertIdleSession: idle,
+            }));
+            const selected = append(owner, sessionId, "selected");
+            assert.strictEqual(compactionHeadState(owner, { sessionId, head: abandoned.id }), "stale");
+            assert.strictEqual(compactionHeadState(owner, { sessionId, head: selected.id }), "current");
+        }),
+        testCase("round-trips a stale compaction notice with its usage", (owner) => {
+            const sessionId = "stale-notice";
+            append(owner, sessionId, "first");
+            const workId = sessionIds.work.generate();
+            const row = appendCompactionNotice(owner, {
+                sessionId,
+                workId,
+                trigger: "threshold",
+                result: "stale",
+                usage,
+            });
+            const stored = readSelectedPath(owner, { sessionId }).find(({ id }) => id === row.id);
+            assert.deepStrictEqual(stored?.entry, {
+                kind: "compaction_notice",
+                workId,
+                trigger: "threshold",
+                result: "stale",
+                usage,
+            });
+            // A notice that spent nothing records no usage.
+            const failed = appendCompactionNotice(owner, {
+                sessionId,
+                workId,
+                trigger: "threshold",
+                result: "failed",
+                diagnostic: "boom",
+            });
+            assert.ok(!("usage" in failed.entry), "A failed notice has no usage");
+        }),
+        testCase("keeps accepted work pending until a terminal settles it", (owner) => {
+            const first = admit(owner, prompt("pending", "pending-1", "one"));
+            const second = admit(owner, prompt("pending", "pending-2", "two"));
+            const pending = readPendingSessionCommands(owner, "pending", 10);
+            assert.strictEqual(pending.total, 2);
+            assert.deepStrictEqual(pending.commands.map(({ entry }) => entry.requestId), ["pending-1", "pending-2"]);
+            assert.ok(first.status === "accepted" && second.status === "accepted", "Both prompts are accepted");
+        }),
+        testCase("keeps explicit title overrides distinct from derived titles and replays clears without inbox changes", (owner) => {
+            const sessionId = "title-replay";
+            append(owner, sessionId, "Fern notes");
+            const before = readSessionInboxChanges(owner, 0, 64).latest;
+            // Equal-looking display text must still become an explicit override.
+            setSessionTitle(owner, sessionId, "Fern notes");
+            const overridden = readSessionInboxChanges(owner, before, 64);
+            assert.ok(overridden.latest > before);
+            assert.equal(readStoredSessionSummary(owner, sessionId)?.title, "Fern notes");
+            setSessionTitle(owner, sessionId, "Fern notes");
+            assert.deepStrictEqual(readSessionInboxChanges(owner, overridden.latest, 64), { rows: [], through: overridden.latest, latest: overridden.latest });
+            setSessionTitle(owner, sessionId, "Other notes");
+            assert.equal(readStoredSessionSummary(owner, sessionId)?.title, "Other notes");
+            setSessionTitle(owner, sessionId, null);
+            assert.equal(readStoredSessionSummary(owner, sessionId)?.title, "Fern notes");
+            const cleared = readSessionInboxChanges(owner, 0, 64).latest;
+            setSessionTitle(owner, sessionId, null);
+            assert.deepStrictEqual(readSessionInboxChanges(owner, cleared, 64), {
+                rows: [],
+                through: cleared,
+                latest: cleared,
+            });
+        }),
+        testCase("pages the inbox in one stable order past a full page", (owner) => {
+            // One Session past the 200-row inbox page, written in one transaction.
+            const total = 201;
+            owner.transactionSync(() => {
+                for (let index = 0; index < total; index += 1)
+                    append(owner, `inbox-${String(index).padStart(3, "0")}`, "hello");
+            });
+            const seen = [];
+            let after;
+            do {
+                const page = Effect.runSync(readSessionInbox(owner, after));
+                seen.push(...page.sessions.map(({ sessionId }) => sessionId));
+                after = page.next;
+            } while (after !== undefined);
+            assert.strictEqual(seen.length, total);
+            assert.strictEqual(new Set(seen).size, total);
+        }),
+    ]);
+}

package/dist/model-preference.d.ts

@@ -1,7 +1,7 @@
 import * as JsonSchema from "effect/JsonSchema";
-import { ModelPreferenceSchema, parseModelPreference, parseModelPreferenceJson } from "./internal/model-preference.js";
+import { ModelPreferenceSchema, reasoningLevels, parseModelPreference, parseModelPreferenceJson } from "./internal/model-preference.js";
 import type { ModelPreference } from "./internal/model-preference.js";
-export { ModelPreferenceSchema, parseModelPreference, parseModelPreferenceJson, };
+export { ModelPreferenceSchema, reasoningLevels as modelReasoningLevels, parseModelPreference, parseModelPreferenceJson, };
 export type { ModelPreference } from "./internal/model-preference.js";
 /** JSON Schema generated from Shiitake's maintained model preference schema. */
 export declare const modelPreferenceJsonSchema: JsonSchema.JsonSchema;

package/dist/model-preference.js

@@ -1,7 +1,7 @@
 import * as JsonSchema from "effect/JsonSchema";
 import * as Schema from "effect/Schema";
-import { ModelPreferenceSchema, parseModelPreference, parseModelPreferenceJson, } from "./internal/model-preference.js";
-export { ModelPreferenceSchema, parseModelPreference, parseModelPreferenceJson, };
+import { ModelPreferenceSchema, reasoningLevels, parseModelPreference, parseModelPreferenceJson, } from "./internal/model-preference.js";
+export { ModelPreferenceSchema, reasoningLevels as modelReasoningLevels, parseModelPreference, parseModelPreferenceJson, };
 /** JSON Schema generated from Shiitake's maintained model preference schema. */
 export const modelPreferenceJsonSchema = JsonSchema.toDocumentDraft07(Schema.toJsonSchemaDocument(ModelPreferenceSchema, {
     onExcessProperty: "error",

package/dist/node.js

@@ -224,7 +224,7 @@ export async function openNodeShiitake(options) {
         host = runtime;
         const agent = await Shiitake.make({
             ...shiitakeOptions,
-            store: fromNodeSqlite(opened),
+            store: { ...fromNodeSqlite(opened), storeName: `Store file ${path}` },
             runtime: runtime.runtime,
         });
         const routes = createShiitakeHttpRoutes((sessionId, meta) => (meta === undefined ? agent : agent.withMeta(meta)).session(sessionId), agent.listSessions, agent.createSession, agent.deleteSession, () => agent.extensions);

package/dist/remote-client.js

@@ -10,7 +10,7 @@ import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
-import { parseAccepted, parseCancelResult, parseForkedSession, parseCreatedSession, parseDeletedSession, parseExtensionOutput, parseExtensionStatus, parseExtensionStatuses, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
+import { parseAccepted, parseWithdrawResult, parseCancelResult, parseLatestPendingPrompt, parseForkedSession, parseCreatedSession, parseDeletedSession, parseExtensionOutput, parseExtensionStatus, parseExtensionStatuses, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
 import { ShiitakeError } from "./errors.js";
 import { decodeClientReadOptions, decodeClientSessionCreationRequestId, decodeClientPageCursor, decodeClientSessionId, decodeClientSubscribeOptions, } from "./internal/client-boundary.js";
 import { toPromiseAgent } from "./internal/effect-client.js";
@@ -201,6 +201,12 @@ function makeRemoteEffectAgent(options) {
         }
         return Object.freeze({
             command,
+            withdraw: (requestId) => ensureOpen.pipe(Effect.andThen(request((signal) => fetch(`${addressedUrl}/withdraw`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ requestId }),
+                signal,
+            }), parseWithdrawResult, "Request withdrawal"))),
             abort: command({ type: "abort" }),
             send: (text, sendOptions) => Effect.sync(() => sendOptions?.requestId ?? nanoid()).pipe(Effect.flatMap((requestId) => {
                 const prompt = {
@@ -216,6 +222,7 @@ function makeRemoteEffectAgent(options) {
                     : new ShiitakeError(error.boundary, error.cause, error.message, requestId)));
             })),
             cancel: (input) => command({ type: "cancel", ...input }),
+            latestPending: ensureOpen.pipe(Effect.andThen(request((signal) => fetch(`${addressedUrl}/pending/latest`, { signal }), parseLatestPendingPrompt, "Newest pending prompt"))),
             modelPreference: Object.freeze({
                 read: ensureOpen.pipe(Effect.andThen(request((signal) => fetch(`${addressedUrl}/model-preference`, { signal }), parseModelPreferenceJson, "Model preference read"))),
                 set: (preference) => ensureOpen.pipe(Effect.andThen(request((signal) => fetch(`${addressedUrl}/model-preference`, {