@cortexkit/opencode-magic-context 0.49.5 → 0.49.6

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

@@ -2,7 +2,7 @@ import"./server-pavzsdc6.js";
 import {
   sessionLog2
 } from "./server-t4k4qexw.js";
-import"./server-cvgn49tr.js";
+import"./server-wrem2nmz.js";
 import {
   COMPARTMENT_LEASE_RENEWAL_MS,
   acquireCompartmentLease,
@@ -19,13 +19,13 @@ import {
   registerActiveCompartmentRun,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-e2v4m8xe.js";
+} from "./server-7skbfb81.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-0nnd4bry.js";
+import"./server-yezz0cp2.js";
+import"./server-keswwkvv.js";
+import"./server-qn23p4h7.js";
 import {
   getWrapupInProgressState,
   acquireWrapupInProgress,
@@ -34,39 +34,39 @@ import {
   getHistorianFailureState,
   clearEmergencyRecovery,
   prepareRawSessionOrdinals2
-} from "./server-4n2tknpc.js";
+} from "./server-fby0cxbq.js";
 import"./server-6byqfbqf.js";
-import"./server-9a6v0wth.js";
+import"./server-09g9pkvx.js";
 import"./server-1zx87sdm.js";
-import"./server-pcygfdbs.js";
+import"./server-yd01snxq.js";
 import"./server-cw6521wn.js";
 import"./server-51779zs2.js";
-import"./server-3dqjhchy.js";
+import"./server-387vkhjq.js";
 import"./server-2ra6pwf3.js";
-import"./server-czb2rkpk.js";
+import"./server-4tn95znb.js";
 import"./server-7ekna9zs.js";
 import"./server-fr0wbhdn.js";
-import"./server-8pqnnmf9.js";
-import"./server-q6j5dasr.js";
-import"./server-cjz51jm2.js";
+import"./server-ww9nr8pe.js";
+import"./server-btgnsv7w.js";
+import"./server-158ehmk2.js";
 import"./server-fb3zxn06.js";
-import"./server-rygvffsf.js";
+import"./server-x2r63c0x.js";
 import {
   pushNotification2
 } from "./server-x8a7jmkh.js";
-import"./server-9290a1mb.js";
+import"./server-6a9mxnb2.js";
 import"./server-qt1qqasc.js";
 import"./server-4dhv7mqz.js";
 import"./server-ras2sxnc.js";
-import"./server-5zrpr764.js";
-import"./server-7jzrrxap.js";
+import"./server-f9py7s7a.js";
+import"./server-cm4hmxyk.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-9zqewm6g.js";
 import"./server-3t0q2cqx.js";
 
 // src/hooks/magic-context/wrapup-orchestrator.ts

package/dist/{wrapup-orchestrator-z7agncp8.js → wrapup-orchestrator-mqp0v195.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-a796ct3s.js";
+import"./index-ck6y3td2.js";
+import"./index-vh3e2mvr.js";
+import"./index-f3dnvnw6.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-s0gsmthp.js";
+import"./index-1xaw2pq8.js";
+import"./index-7q1m1qjk.js";
+import"./index-cm4hmxyk.js";
+import"./index-9s58tq95.js";
+import"./index-j55vn694.js";
 import"./index-4dhv7mqz.js";
 import"./index-w23dh319.js";
-import"./index-bhk710rw.js";
+import"./index-hr64sth2.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-besxhcsh.js";
 import"./index-fb3zxn06.js";
-import"./index-xfbfrngb.js";
-import"./index-6m7rdv7y.js";
+import"./index-xqyj5c85.js";
+import"./index-9m7bn21d.js";
 import"./index-fr0wbhdn.js";
-import"./index-41gqa557.js";
-import"./index-7w18gg78.js";
-import"./index-7zg9dvx0.js";
-import"./index-yqps2zsv.js";
+import"./index-g9exahnx.js";
+import"./index-bg5qqene.js";
+import"./index-vztbgcdk.js";
+import"./index-1j8jcjpa.js";
 import"./index-1zx87sdm.js";
-import"./index-qvr78ej6.js";
-import"./index-jpm52v9x.js";
+import"./index-ab3bgm2m.js";
+import"./index-vnjhmkwk.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-0nnd4bry.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.6",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

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();
+        }
+    });
+}

package/src/shared/sqlite-pass-scope.test.ts

@@ -100,7 +100,7 @@ test("foreground admission keeps the loop ticking while a separate writer holds
     }
 }, 30000);
 
-test("a foreground in-pass writer has bounded 250ms tolerance and restores its timeout", () => {
+test("a foreground in-pass writer has bounded 2000ms tolerance and restores its timeout", () => {
     const { db, path, close } = fixture();
     const blocker = new Database(path);
     blocker.exec("BEGIN IMMEDIATE");
@@ -109,15 +109,15 @@ test("a foreground in-pass writer has bounded 250ms tolerance and restores its t
         expect(() =>
             withSqliteTransformPass(() => withPrivilegedWriter(db, () => undefined)),
         ).toThrow(SqliteAcquisitionBusyError);
-        expect(performance.now() - start).toBeGreaterThanOrEqual(200);
-        expect(performance.now() - start).toBeLessThan(400);
+        expect(performance.now() - start).toBeGreaterThanOrEqual(1900);
+        expect(performance.now() - start).toBeLessThan(2500);
         expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
     } finally {
         blocker.exec("ROLLBACK");
         blocker.close();
         close();
     }
-});
+}, 30000);
 
 test("ready background publication retries on a timer and retains its write", async () => {
     const { db, path, close } = fixture();

package/src/shared/sqlite.ts

@@ -940,7 +940,7 @@ export class SqliteAcquisitionBusyError extends Error {
 }
 
 const SHORT_BUSY_TIMEOUT_MS = 25;
-const FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS = 250;
+const FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS = 2_000;
 const FOREGROUND_ACQUISITION_BUDGET_MS = 16_500;
 /** Waiting this long for the writer lock, or holding it this long, is logged. */
 const SLOW_WRITER_LOG_MS = 250;
@@ -994,7 +994,7 @@ function withAutocommitTimeout<T>(db: Database, operation: () => T): T {
     if (isInTransaction(db) || (!lease && !backgroundWriterScope.getStore())) return operation();
     const previous = pragmaNumber(db, "busy_timeout");
     db.exec(
-        `PRAGMA busy_timeout=${lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS}`,
+        `PRAGMA busy_timeout=${lease ? Math.floor(Math.min(lease.remainingWaitMs, lease.guard?.remainingMs() ?? Infinity)) : SHORT_BUSY_TIMEOUT_MS}`,
     );
     const started = performance.now();
     try {