@cortexkit/opencode-magic-context 0.49.5 → 0.49.7

package/dist/v2/server.js

@@ -7870,7 +7870,7 @@ var require_src2 = __commonJS(function(exports, module) {
 // package.json
 var package_default = {
   name: "@cortexkit/opencode-magic-context",
-  version: "0.49.5",
+  version: "0.49.7",
   type: "module",
   description: "OpenCode plugin for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -7913,8 +7913,8 @@ var package_default = {
     "check:tui-compiled": 'git diff --exit-code -- src/tui-compiled && test -z "$(git status --porcelain -- src/tui-compiled)"',
     "check:transformers-node-wasm": "bun scripts/verify-transformers-node-wasm.ts",
     typecheck: "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit && tsc -p tsconfig.scripts.json",
-    test: "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && BUN_JSC_useOMGJIT=0 bun test --parallel=4 --timeout 30000",
-    "test:serial": "bun install --frozen-lockfile && BUN_JSC_useOMGJIT=0 bun test --timeout 30000",
+    test: "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && MC_REVIEW_ASSERT_LIVENESS=1 BUN_JSC_useOMGJIT=0 bun test --parallel=4 --timeout 30000",
+    "test:serial": "bun install --frozen-lockfile && MC_REVIEW_ASSERT_LIVENESS=1 BUN_JSC_useOMGJIT=0 bun test --timeout 30000",
     "test:parallel:probe": "bun scripts/verify-parallel-db-isolation.ts",
     lint: "bun ../../scripts/check-bun.mjs && biome check .",
     "lint:fix": "biome check --write .",
@@ -8186,7 +8186,7 @@ async function setup(context) {
     log2("v2 setup() called on a host without session.hook; v1 server lane owns this host, v2 lane inert");
     return async () => {};
   }
-  const { registerContext } = await import("./context-6en6a8ar.js");
+  const { registerContext } = await import("./context-xq4rtywr.js");
   setHarness2("opencode2");
   bindStaleBuildNotice({}, import.meta.url, "opencode2");
   const duties = await registerContext(context);

package/dist/v2/{sqlite-mhjkerzq.js → sqlite-j3tvg8r0.js}

@@ -20,7 +20,7 @@ import {
   releaseIndexOwner2,
   withIndexChunk2,
   yieldIndexChunk2
-} from "./server-kb9nn0a0.js";
+} from "./server-j8epsc0g.js";
 export {
   Database2 as Database,
   SqliteAcquisitionBusyError2 as SqliteAcquisitionBusyError,

package/dist/v2/{storage-memory-07fx57k6.js → storage-memory-8168bgef.js}

@@ -31,10 +31,10 @@ import {
   deleteMemory2,
   getMemoryCount2,
   getMemoryCountsByStatus2
-} from "./server-7jzrrxap.js";
+} from "./server-9yyqq3mm.js";
 import"./server-4dhv7mqz.js";
 import"./server-fr0wbhdn.js";
-import"./server-kb9nn0a0.js";
+import"./server-j8epsc0g.js";
 export {
   COLUMN_MAP2 as COLUMN_MAP,
   ModuleMemoryAuthorityError2 as ModuleMemoryAuthorityError,

package/dist/v2/{storage-tags-3a4cavqb.js → storage-tags-j2fzq3sw.js}

@@ -60,10 +60,10 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-pcygfdbs.js";
+} from "./server-w3zeywp1.js";
 import"./server-1zx87sdm.js";
 import"./server-6byqfbqf.js";
-import"./server-kb9nn0a0.js";
+import"./server-j8epsc0g.js";
 import"./server-kzns2hbz.js";
 import"./server-t4k4qexw.js";
 import"./server-pavzsdc6.js";

package/dist/v2/{wrapup-orchestrator-r2v7kgy3.js → wrapup-orchestrator-s92ebfzv.js}

@@ -2,7 +2,7 @@ import"./server-pavzsdc6.js";
 import {
   sessionLog2
 } from "./server-t4k4qexw.js";
-import"./server-cvgn49tr.js";
+import"./server-1rfgbjfn.js";
 import {
   COMPARTMENT_LEASE_RENEWAL_MS,
   acquireCompartmentLease,
@@ -19,13 +19,13 @@ import {
   registerActiveCompartmentRun,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-e2v4m8xe.js";
+} from "./server-mv1w7t6z.js";
 import"./server-kzns2hbz.js";
 import"./server-hb6xhh9q.js";
-import"./server-kb9nn0a0.js";
-import"./server-2htmbqbv.js";
-import"./server-8wcf79fe.js";
-import"./server-3bc6k4k4.js";
+import"./server-j8epsc0g.js";
+import"./server-brhj8qtd.js";
+import"./server-fpqe39as.js";
+import"./server-7srtwsa4.js";
 import {
   getWrapupInProgressState,
   acquireWrapupInProgress,
@@ -34,39 +34,39 @@ import {
   getHistorianFailureState,
   clearEmergencyRecovery,
   prepareRawSessionOrdinals2
-} from "./server-4n2tknpc.js";
+} from "./server-gtv9wbhq.js";
 import"./server-6byqfbqf.js";
-import"./server-9a6v0wth.js";
+import"./server-v4fwha43.js";
 import"./server-1zx87sdm.js";
-import"./server-pcygfdbs.js";
+import"./server-w3zeywp1.js";
 import"./server-cw6521wn.js";
 import"./server-51779zs2.js";
-import"./server-3dqjhchy.js";
+import"./server-dd0nja67.js";
 import"./server-2ra6pwf3.js";
-import"./server-czb2rkpk.js";
+import"./server-wkdgjjch.js";
 import"./server-7ekna9zs.js";
 import"./server-fr0wbhdn.js";
-import"./server-8pqnnmf9.js";
-import"./server-q6j5dasr.js";
-import"./server-cjz51jm2.js";
+import"./server-hcvcxzx7.js";
+import"./server-kdrezdy0.js";
+import"./server-fw31krgq.js";
 import"./server-fb3zxn06.js";
-import"./server-rygvffsf.js";
+import"./server-jdwd03ep.js";
 import {
   pushNotification2
 } from "./server-x8a7jmkh.js";
-import"./server-9290a1mb.js";
+import"./server-x08d1xf3.js";
 import"./server-qt1qqasc.js";
 import"./server-4dhv7mqz.js";
 import"./server-ras2sxnc.js";
-import"./server-5zrpr764.js";
-import"./server-7jzrrxap.js";
+import"./server-sy4b1sra.js";
+import"./server-9yyqq3mm.js";
 import"./server-d6g4whc2.js";
 import"./server-vb7pbd9p.js";
 import"./server-t528t8qm.js";
 import"./server-676xw7at.js";
 import {
   sendStatusNotification2
-} from "./server-4enr7s6x.js";
+} from "./server-qcw43339.js";
 import"./server-3t0q2cqx.js";
 
 // src/hooks/magic-context/wrapup-orchestrator.ts

package/dist/{wrapup-orchestrator-z7agncp8.js → wrapup-orchestrator-df61jmz9.js}

@@ -1,43 +1,43 @@
 import {
   runManagedWrapup2
-} from "./index-p2hs3rps.js";
-import"./index-dd18gej8.js";
-import"./index-v4bqjy56.js";
-import"./index-yxawqmdd.js";
+} from "./index-w6vr754t.js";
+import"./index-rwmpkss5.js";
+import"./index-5tbvdff4.js";
+import"./index-sh91t19a.js";
 import"./index-sd3egckz.js";
-import"./index-fjtgekd4.js";
-import"./index-3wckxwfp.js";
-import"./index-7ndnvw7a.js";
-import"./index-7jzrrxap.js";
-import"./index-c0b01zrc.js";
-import"./index-gcdb3rqw.js";
+import"./index-n7kwfw2r.js";
+import"./index-wq16ahsn.js";
+import"./index-w6bd03dc.js";
+import"./index-9yyqq3mm.js";
+import"./index-sf94at64.js";
+import"./index-ax2jhztn.js";
 import"./index-4dhv7mqz.js";
 import"./index-w23dh319.js";
-import"./index-bhk710rw.js";
+import"./index-vt4sf4ep.js";
 import"./index-qt1qqasc.js";
 import"./index-x8a7jmkh.js";
 import"./index-tqf7yg27.js";
 import"./index-gbmqa9x9.js";
 import"./index-vkbqdnkj.js";
-import"./index-znzgze2v.js";
+import"./index-4btknbqh.js";
 import"./index-fb3zxn06.js";
-import"./index-xfbfrngb.js";
-import"./index-6m7rdv7y.js";
+import"./index-j5hce1ab.js";
+import"./index-w4mw92w3.js";
 import"./index-fr0wbhdn.js";
-import"./index-41gqa557.js";
-import"./index-7w18gg78.js";
-import"./index-7zg9dvx0.js";
-import"./index-yqps2zsv.js";
+import"./index-g8qbdb03.js";
+import"./index-rzmjkdd6.js";
+import"./index-n5a170gs.js";
+import"./index-tmtty2x5.js";
 import"./index-1zx87sdm.js";
-import"./index-qvr78ej6.js";
-import"./index-jpm52v9x.js";
+import"./index-a8acx4gc.js";
+import"./index-37q80veb.js";
 import"./index-v0p37hm2.js";
 import"./index-k6xvbj2e.js";
 import"./index-h2wc01qk.js";
 import"./index-1bt88epp.js";
 import"./index-58e3y90n.js";
 import"./index-4mjhqadz.js";
-import"./index-kb9nn0a0.js";
+import"./index-j8epsc0g.js";
 import"./index-qx53vezw.js";
 import"./index-nsjyysj0.js";
 import"./index-0sahzkwr.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.49.5",
+  "version": "0.49.7",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -43,8 +43,8 @@
     "check:tui-compiled": "git diff --exit-code -- src/tui-compiled && test -z \"$(git status --porcelain -- src/tui-compiled)\"",
     "check:transformers-node-wasm": "bun scripts/verify-transformers-node-wasm.ts",
     "typecheck": "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit && tsc -p tsconfig.scripts.json",
-    "test": "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && BUN_JSC_useOMGJIT=0 bun test --parallel=4 --timeout 30000",
-    "test:serial": "bun install --frozen-lockfile && BUN_JSC_useOMGJIT=0 bun test --timeout 30000",
+    "test": "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && MC_REVIEW_ASSERT_LIVENESS=1 BUN_JSC_useOMGJIT=0 bun test --parallel=4 --timeout 30000",
+    "test:serial": "bun install --frozen-lockfile && MC_REVIEW_ASSERT_LIVENESS=1 BUN_JSC_useOMGJIT=0 bun test --timeout 30000",
     "test:parallel:probe": "bun scripts/verify-parallel-db-isolation.ts",
     "lint": "bun ../../scripts/check-bun.mjs && biome check .",
     "lint:fix": "biome check --write .",

package/src/shared/processed-image-eligibility.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from "bun:test";
+import { createProcessedImageEligibility } from "./processed-image-eligibility";
+
+const messages = ["old", "image", "answer", "tail"];
+
+test("image position age inherits its next positive tag, never zero or an earlier tag", () => {
+    const policy = createProcessedImageEligibility(
+        messages,
+        new Map([
+            ["old", 1],
+            ["answer", 6],
+        ]),
+        { watermark: 1 },
+    );
+    expect(policy.ageTags.get("image")).toBe(6);
+    expect(policy.mayStrip("image")).toBe(false);
+    expect(policy.ageTags.has("tail")).toBe(false);
+    expect(policy.mayStrip("tail")).toBe(false);
+    const own = createProcessedImageEligibility(
+        messages,
+        new Map([
+            ["image", 3],
+            ["answer", 6],
+        ]),
+        { watermark: 4 },
+    );
+    expect(own.ageTags.get("image")).toBe(3);
+    expect(own.mayStrip("image")).toBe(true);
+});
+
+test("answered image-only positions outside the protected window are eligible", () => {
+    const policy = createProcessedImageEligibility(
+        messages,
+        new Map([
+            ["answer", 3],
+            ["tail", 5],
+        ]),
+        { watermark: 4, protectedCutoff: 5, contextPercentage: 94.99 },
+    );
+    expect(policy.ageTags.get("image")).toBe(3);
+    expect(policy.mayStrip("image")).toBe(true);
+});
+
+test("image positions inside the protected window stay below the 95 percent emergency", () => {
+    const policy = createProcessedImageEligibility(messages, new Map([["answer", 6]]), {
+        watermark: 10,
+        protectedCutoff: 5,
+        contextPercentage: 94.99,
+    });
+    expect(policy.mayStrip("image")).toBe(false);
+});
+
+test("image positions follow emergency drops when the newest window yields at 95 percent", () => {
+    for (const contextPercentage of [95, 99]) {
+        const policy = createProcessedImageEligibility(messages, new Map([["answer", 6]]), {
+            watermark: 10,
+            protectedCutoff: 5,
+            contextPercentage,
+        });
+        expect(policy.mayStrip("image")).toBe(true);
+        const notDroppedYet = createProcessedImageEligibility(messages, new Map([["answer", 11]]), {
+            watermark: 10,
+            protectedCutoff: 5,
+            contextPercentage,
+        });
+        expect(notDroppedYet.mayStrip("image")).toBe(false);
+    }
+});

package/src/shared/processed-image-eligibility.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared processed-image age and recency policy for both OpenCode adapters.
+ * Use the owning message's positive maximum tag; an untagged image-only message
+ * inherits the next positive tagged message after it, never age zero or a tag
+ * from an earlier message. Without either tag, retain the image at the live tail.
+ * A positive dropped-tag watermark must cover that position. Below 95% usage,
+ * retain every position at or beyond the protected newest-window cutoff. At
+ * 95% and above only that window yields, exactly as for emergency tool drops;
+ * independent per-tool protections still apply. Content before retained provider-signed
+ * thinking must stay unchanged unless an existing whole-turn rewrite removes that
+ * thinking first. Callers enforce these protections, later-assistant/stable-id checks, durable
+ * persistence and rewrite-only discovery. Frozen replay bypasses eligibility.
+ */
+export function createProcessedImageEligibility<T>(
+    messages: readonly T[],
+    messageTagNumbers: ReadonlyMap<T, number>,
+    options: { watermark: number; protectedCutoff?: number | null; contextPercentage?: number },
+): { ageTags: ReadonlyMap<T, number>; mayStrip: (message: T) => boolean } {
+    const ageTags = new Map<T, number>();
+    let nextTag: number | undefined;
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        const ownTag = messageTagNumbers.get(message);
+        if (ownTag !== undefined && Number.isFinite(ownTag) && ownTag > 0) nextTag = ownTag;
+        if (nextTag !== undefined) ageTags.set(message, nextTag);
+    }
+    return {
+        ageTags,
+        mayStrip: (message) => {
+            const age = ageTags.get(message);
+            return (
+                options.watermark > 0 &&
+                age !== undefined &&
+                age <= options.watermark &&
+                ((options.contextPercentage ?? 0) >= 95 ||
+                    options.protectedCutoff == null ||
+                    age < options.protectedCutoff)
+            );
+        },
+    };
+}

package/src/shared/processed-image-position-review.json

@@ -0,0 +1,20 @@
+[
+    { "name": "own maximum wins over a later smaller tag", "tags": [[2, 10, 4], [3]], "target": 0, "watermark": 8, "cutoff": null, "percentage": 60, "age": 10, "eligible": false },
+    { "name": "own maximum at watermark", "tags": [[2, 10, 4], [30]], "target": 0, "watermark": 10, "cutoff": null, "percentage": 60, "age": 10, "eligible": true },
+    { "name": "first later tag not largest later tag", "tags": [[], [3], [20]], "target": 0, "watermark": 3, "cutoff": null, "percentage": 60, "age": 3, "eligible": true },
+    { "name": "first later message contributes its own maximum", "tags": [[], [2, 9], [3]], "target": 0, "watermark": 5, "cutoff": null, "percentage": 60, "age": 9, "eligible": false },
+    { "name": "skip empty and zero tags when looking forward", "tags": [[1], [], [0], [4]], "target": 1, "watermark": 4, "cutoff": null, "percentage": 60, "age": 4, "eligible": true },
+    { "name": "zero own tag inherits later positive", "tags": [[0], [7]], "target": 0, "watermark": 6, "cutoff": null, "percentage": 60, "age": 7, "eligible": false },
+    { "name": "preceding tag cannot age live tail", "tags": [[1], [], []], "target": 1, "watermark": 100, "cutoff": null, "percentage": 60, "age": null, "eligible": false },
+    { "name": "all untagged is ineligible", "tags": [[], []], "target": 0, "watermark": 100, "cutoff": null, "percentage": 60, "age": null, "eligible": false },
+    { "name": "watermark zero even with emergency", "tags": [[], [1]], "target": 0, "watermark": 0, "cutoff": 1, "percentage": 95, "age": 1, "eligible": false },
+    { "name": "age above watermark even with emergency", "tags": [[], [7]], "target": 0, "watermark": 6, "cutoff": 1, "percentage": 100, "age": 7, "eligible": false },
+    { "name": "cutoff inclusive at 94.99 percent", "tags": [[5], [8]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 94.99, "age": 5, "eligible": false },
+    { "name": "inside cutoff is a range not set membership", "tags": [[], [6]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 60, "age": 6, "eligible": false },
+    { "name": "below cutoff is eligible", "tags": [[4], [8]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 94.99, "age": 4, "eligible": true },
+    { "name": "exactly 95 waives cutoff", "tags": [[], [6]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 95, "age": 6, "eligible": true },
+    { "name": "above 95 waives cutoff", "tags": [[5], [8]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 95.01, "age": 5, "eligible": true },
+    { "name": "emergency cannot invent tail age", "tags": [[1], []], "target": 1, "watermark": 100, "cutoff": 1, "percentage": 100, "age": null, "eligible": false },
+    { "name": "own positive tag overrides later greater tag", "tags": [[2], [20]], "target": 0, "watermark": 2, "cutoff": 3, "percentage": 60, "age": 2, "eligible": true },
+    { "name": "last message with own tag is aged", "tags": [[1], [4]], "target": 1, "watermark": 4, "cutoff": null, "percentage": 60, "age": 4, "eligible": true }
+]

package/src/shared/processed-image-position-review.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { createProcessedImageEligibility } from "./processed-image-eligibility";
+import cases from "./processed-image-position-review.json";
+
+// OpenCode, Rust and Pi can reuse these cases: each row supplies per-message
+// tag numbers rather than provider-specific message objects or image encodings.
+for (const row of cases) {
+    test(`independent image position table: ${row.name}`, () => {
+        const messages = row.tags.map((_, i) => `message-${i}`);
+        const tags = new Map(messages.map((message, i) => [message, Math.max(0, ...row.tags[i])]));
+        const policy = createProcessedImageEligibility(messages, tags, {
+            watermark: row.watermark,
+            protectedCutoff: row.cutoff,
+            contextPercentage: row.percentage,
+        });
+        expect(policy.ageTags.get(messages[row.target]) ?? null).toBe(row.age);
+        expect(policy.mayStrip(messages[row.target])).toBe(row.eligible);
+    });
+}

package/src/shared/recovery-reasoning-prefix.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "bun:test";
+import { recoveryReasoningPrefixes } from "./recovery-reasoning-prefix";
+
+for (const key of ["content", "parts"] as const) {
+    test(`recovery reasoning ${key}: exact preceding messages and same-message parts`, () => {
+        const messages = [
+            { role: "user", [key]: [{ type: "text", text: "original" }] },
+            {
+                role: "assistant",
+                [key]: [
+                    { type: "text", text: "before" },
+                    { type: "thinking", thinkingSignature: "first" },
+                    { type: "text", text: "between" },
+                    { type: "redacted_thinking", data: "opaque" },
+                    { type: "text", text: "after" },
+                ],
+            },
+        ];
+        const original = recoveryReasoningPrefixes(messages, key);
+        expect(original).toHaveLength(2);
+        const edited = structuredClone(messages);
+        edited[0]![key]![0]!.text = "changed";
+        expect(recoveryReasoningPrefixes(edited, key)).not.toEqual(original);
+        const parts = structuredClone(messages);
+        parts[1]![key]![2]!.text = "changed";
+        expect(recoveryReasoningPrefixes(parts, key)[0]).toBe(original[0]);
+        expect(recoveryReasoningPrefixes(parts, key)[1]).not.toBe(original[1]);
+        const suffix = structuredClone(messages);
+        suffix[1]![key]![4]!.text = "changed";
+        expect(recoveryReasoningPrefixes(suffix, key)).toEqual(original);
+        suffix[1]![key]!.splice(3, 1);
+        expect(recoveryReasoningPrefixes(suffix, key)).not.toEqual(original);
+    });
+}

package/src/shared/recovery-reasoning-prefix.ts

@@ -0,0 +1,35 @@
+/**
+ * Serialize each request prefix ending at a thinking/reasoning part, including
+ * earlier messages and earlier parts of that message. Comparing these snapshots
+ * detects edits to bytes authenticated by a kept signature, or missing blocks.
+ * Include reasoning without a visible signature too: a host may carry its
+ * provider signature in fields this helper does not interpret.
+ */
+export function recoveryReasoningPrefixes(
+    messages: readonly unknown[],
+    partsKey: "parts" | "content",
+): string[] {
+    const prefixes: string[] = [];
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index] as Record<string, unknown> | null;
+        const parts = message?.[partsKey];
+        if (!Array.isArray(parts)) continue;
+        for (let p = 0; p < parts.length; p++) {
+            const type = (parts[p] as { type?: string } | null)?.type;
+            if (
+                type !== "thinking" &&
+                type !== "reasoning" &&
+                type !== "redactedThinking" &&
+                type !== "redacted_thinking"
+            )
+                continue;
+            prefixes.push(
+                JSON.stringify([
+                    ...messages.slice(0, index),
+                    { ...message, [partsKey]: parts.slice(0, p + 1) },
+                ]),
+            );
+        }
+    }
+    return prefixes;
+}

package/src/shared/sqlite-acquisition-routing.test.ts

@@ -118,7 +118,7 @@ test("exhausted routed acquisition never enters the callback or multiplies privi
         db.close();
         rmSync(dir, { recursive: true, force: true });
     }
-});
+}, 30_000);
 
 for (const mode of ["run", "get", "all", "exec"] as const) {
     test(`foreground ${mode} autocommit waits share one turn budget and restore production timeout`, () => {
@@ -147,7 +147,8 @@ for (const mode of ["run", "get", "all", "exec"] as const) {
                 }
                 expect(() => db.exec("BEGIN IMMEDIATE")).toThrow("acquisition remained busy");
             });
-            expect(performance.now() - started).toBeLessThan(650);
+            expect(performance.now() - started).toBeGreaterThanOrEqual(1900);
+            expect(performance.now() - started).toBeLessThan(2600);
             expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
             expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
             blocker.exec("ROLLBACK");
@@ -159,5 +160,5 @@ for (const mode of ["run", "get", "all", "exec"] as const) {
             db.close();
             rmSync(dir, { recursive: true, force: true });
         }
-    });
+    }, 30_000);
 }

package/src/shared/sqlite-foreground-wait.test.ts

@@ -0,0 +1,140 @@
+import { expect, test } from "bun:test";
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { StorageBusyRefusalError } from "../hooks/magic-context/storage-busy-refusal";
+import { createMessagesTransformHandler } from "../plugin/messages-transform";
+import { log } from "./logger";
+import {
+    Database,
+    guardSqliteTransformPass,
+    registerSqliteDiagnosticSink,
+    SqliteAcquisitionBusyError,
+    withPrivilegedWriter,
+    withSqliteTransformPass,
+} from "./sqlite";
+import { type SqliteWriteLocker, startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+function fixture() {
+    const dir = createTestTempDirFromPath(join(tmpdir(), "mc-foreground-wait-"));
+    const path = join(dir, "context.db");
+    const db = new Database(path);
+    db.exec(`
+        PRAGMA journal_mode=WAL;
+        PRAGMA busy_timeout=5000;
+        CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER);
+        CREATE TABLE result(value TEXT);
+    `);
+    return {
+        db,
+        path,
+        close() {
+            db.close();
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+}
+
+for (const holdMs of [1000, 2500]) {
+    test(holdMs === 1000
+        ? "a transform commits and serves managed output after a 1s in-pass writer lock"
+        : "a transform refuses a 2.5s in-pass writer lock without raw fallback and logs the real wait", async () => {
+        const { db, path, close } = fixture();
+        const sessionId = `foreground-wait-${holdMs}`;
+        const output = {
+            messages: [
+                {
+                    info: { id: "u", sessionID: sessionId, role: "user" },
+                    parts: [{ type: "text", text: "raw input must not be served on failure" }],
+                },
+            ],
+        };
+        let locker: SqliteWriteLocker | undefined;
+        let refusals = 0;
+        let served = false;
+        let waitedMs = 0;
+        const diagnostics: string[] = [];
+        registerSqliteDiagnosticSink((line) => diagnostics.push(line));
+        const handler = createMessagesTransformHandler({
+            onStorageBusyRefusal: async (id) => {
+                expect(id).toBe(sessionId);
+                refusals++;
+            },
+            magicContext: {
+                "experimental.chat.messages.transform": async (_input, result) => {
+                    // Start the competing writer only once the transform callback begins;
+                    // otherwise the wrapper's yielding lock check would absorb the wait.
+                    locker = await startSqliteWriteLocker(path, holdMs);
+                    const started = performance.now();
+                    try {
+                        withPrivilegedWriter(db, () => {
+                            db.prepare("INSERT INTO result VALUES ('managed')").run();
+                        });
+                    } finally {
+                        waitedMs = performance.now() - started;
+                    }
+                    (result.messages[0].parts[0] as { text: string }).text = "managed output";
+                },
+            },
+        });
+        try {
+            const pass = handler({}, output as Parameters<typeof handler>[1]).then((messages) => {
+                served = true;
+                return messages;
+            });
+            if (holdMs === 1000) {
+                await pass;
+                expect(served).toBe(true);
+                expect(refusals).toBe(0);
+                expect(output.messages[0].parts[0].text).toBe("managed output");
+                expect(db.prepare("SELECT * FROM result").all()).toEqual([{ value: "managed" }]);
+                expect(waitedMs).toBeGreaterThanOrEqual(900);
+            } else {
+                await expect(pass).rejects.toBeInstanceOf(StorageBusyRefusalError);
+                expect(served).toBe(false);
+                expect(refusals).toBe(1);
+                expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
+                expect(waitedMs).toBeGreaterThanOrEqual(1900);
+                expect(waitedMs).toBeLessThan(2400);
+                const busy = diagnostics.filter((line) => line.includes("outcome=busy"));
+                expect(busy).toHaveLength(1);
+                expect(busy[0]).toContain("lane=foreground");
+                const reportedMs = Number(/acquire_ms=(\d+)/.exec(busy[0])?.[1]);
+                expect(Math.abs(reportedMs - waitedMs)).toBeLessThan(100);
+            }
+            expect(db.inTransaction).toBe(false);
+            expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
+        } finally {
+            registerSqliteDiagnosticSink(log);
+            if (locker) expect(await locker.exited).toBe(0);
+            close();
+        }
+    }, 30_000);
+}
+
+for (const mode of ["BEGIN", "autocommit"]) {
+    test(`foreground ${mode} wait is capped by the pass deadline`, () => {
+        const { db, path, close } = fixture();
+        const blocker = new Database(path);
+        blocker.exec("BEGIN IMMEDIATE");
+        try {
+            const started = performance.now();
+            withSqliteTransformPass(() => {
+                guardSqliteTransformPass({ assert() {}, remainingMs: () => 100 });
+                expect(() => {
+                    if (mode === "BEGIN") withPrivilegedWriter(db, () => undefined);
+                    else db.prepare("INSERT INTO result VALUES ('late')").run();
+                }).toThrow(SqliteAcquisitionBusyError);
+            });
+            expect(performance.now() - started).toBeGreaterThanOrEqual(75);
+            expect(performance.now() - started).toBeLessThan(700);
+            expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
+            expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
+        } finally {
+            blocker.exec("ROLLBACK");
+            blocker.close();
+            close();
+        }
+    });
+}