@cortexkit/opencode-magic-context 0.44.2 → 0.44.3

package/dist/{wrapup-orchestrator-h8tr10c6.js → wrapup-orchestrator-sy4m56a7.js}

@@ -1,14 +1,14 @@
 import {
   runManagedWrapup2
-} from "./index-3x9caerx.js";
-import"./index-40s1xz22.js";
-import"./index-ttdn47aq.js";
+} from "./index-nf9sk8sh.js";
+import"./index-rdsaxnf2.js";
+import"./index-yhm60r53.js";
 import"./index-sd3egckz.js";
-import"./index-stb5fg12.js";
-import"./index-r9vkp4n9.js";
-import"./index-esxfcz5z.js";
+import"./index-9y5p0d50.js";
+import"./index-33q7s9y2.js";
+import"./index-dgg5y7er.js";
 import"./index-y5145x8k.js";
-import"./index-egkfvhms.js";
+import"./index-4an2p8qa.js";
 import"./index-kr5qehbd.js";
 import"./index-jdxxq8cz.js";
 import"./index-kwe03yde.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.44.2",
+  "version": "0.44.3",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/config/latch-permanence-guard.test.ts

@@ -53,6 +53,10 @@ const KNOWN_SLOTS: Record<string, KnownSlot> = {
         classification: "VERDICT",
         reason: "Correct: circuit state expires and a half-open probe re-evaluates the endpoint.",
     },
+    "packages/plugin/src/features/magic-context/memory/project-identity.ts:homeProjectPermission": {
+        classification: "VERDICT",
+        reason: "Boot config publishes the home-project permission; the setter replaces it on another host initialization, while explicit resolution arguments override it.",
+    },
     "packages/plugin/src/features/magic-context/memory/project-identity.ts:directoryFallbackCache":
         {
             classification: "VERDICT",

package/src/shared/data-path.test.ts

@@ -29,7 +29,7 @@ const savedEnv = {
 describe("data-path", () => {
     beforeEach(() => {
         process.env.XDG_CACHE_HOME = undefined;
-        process.env.XDG_DATA_HOME = undefined;
+        process.env.XDG_DATA_HOME = process.env.MAGIC_CONTEXT_TEST_DATA_DIR;
         delete process.env.MAGIC_CONTEXT_TEST_DATA_DIR;
         delete process.env.NODE_ENV;
         process.env.LOCALAPPDATA = undefined;

package/src/shared/models-dev-cache.test.ts

@@ -2,7 +2,14 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { resolveKnownHistorianContextLimit } from "../hooks/magic-context/derive-budgets";
+import {
+    resolveHistorianProducerLimits,
+    resolveKnownHistorianContextLimit,
+} from "../hooks/magic-context/derive-budgets";
+import {
+    historianProducerReserve,
+    producerInputTokenLimit,
+} from "../hooks/magic-context/producer-window-guard";
 import {
     clearModelsDevCache,
     getModelsDevCacheState,
@@ -231,6 +238,28 @@ describe("models-dev-cache (SDK-only)", () => {
         expect(getSdkContextLimit("openai", "gpt-5.4-mini")).toBe(922000);
     });
 
+    test("issue 567: production resolver keeps input cap separate from context reserve", async () => {
+        await refreshModelLimitsFromApi(
+            makeClient([
+                {
+                    id: "auth-provider",
+                    models: {
+                        model: { limit: { context: 400_000, input: 272_000, output: 128_000 } },
+                    },
+                },
+            ]),
+        );
+        const resolved = getSdkContextLimit("auth-provider", "model", undefined, {
+            reservation: "none",
+        });
+        const limits = resolveHistorianProducerLimits("auth-provider/model");
+        const reserve = historianProducerReserve(limits.context, undefined, 128_000);
+        expect(resolved).toBe(272_000);
+        expect(limits).toEqual({ context: 400_000, input: 272_000 });
+        expect(reserve).toBe(100_000);
+        expect(producerInputTokenLimit(limits.context, reserve, limits.input)).toBe(263_840);
+    });
+
     test("explicit SDK-resolved config limit wins over a larger catalog or detected value", async () => {
         // OpenCode's config.providers() has already applied opencode.json over its
         // catalog. The cache must preserve that 120K effective value, and a later

package/src/shared/run-token-log.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+import { runTokenLog } from "./run-token-log";
+
+describe("run token log host usage", () => {
+    test("OpenCode assistant message tokens retain reasoning and cache", () => {
+        const message = {
+            info: {
+                finish: "length",
+                tokens: { input: 10, output: 50, reasoning: 48, cache: { read: 7, write: 0 } },
+            },
+        };
+        expect(runTokenLog(message.info.tokens, 64, message.info.finish)).toEqual({
+            input: 10,
+            output: 50,
+            reasoning: 48,
+            cache_read: 7,
+            cache_write: 0,
+            max_tokens: 64,
+            finish_reason: "length",
+        });
+    });
+
+    test("OpenCode hidden-completion usage preserves omitted reasoning as null", () => {
+        const row = {
+            data: {
+                finish: "stop",
+                tokens: { input: 20, output: 4, cache: { read: 0, write: 3 } },
+            },
+        };
+        expect(runTokenLog(row.data.tokens, undefined, row.data.finish)).toEqual({
+            input: 20,
+            output: 4,
+            reasoning: null,
+            cache_read: 0,
+            cache_write: 3,
+            max_tokens: null,
+            finish_reason: "stop",
+        });
+    });
+
+    test("Pi stdout usage and absent usage remain distinguishable", () => {
+        const message = {
+            stopReason: "length",
+            usage: { input: 3, output: 12, cacheRead: 2, cacheWrite: 0 },
+        };
+        expect(runTokenLog(message.usage, 12, message.stopReason)).toEqual({
+            input: 3,
+            output: 12,
+            reasoning: null,
+            cache_read: 2,
+            cache_write: 0,
+            max_tokens: 12,
+            finish_reason: "length",
+        });
+        expect(runTokenLog(undefined)).toEqual({
+            input: null,
+            output: null,
+            reasoning: null,
+            cache_read: null,
+            cache_write: null,
+            max_tokens: null,
+            finish_reason: null,
+        });
+    });
+});

package/src/shared/run-token-log.ts

@@ -0,0 +1,39 @@
+export interface RunTokenLog {
+    input: number | null;
+    output: number | null;
+    reasoning: number | null;
+    cache_read: number | null;
+    cache_write: number | null;
+    max_tokens: number | null;
+    finish_reason: string | null;
+}
+
+function count(value: unknown): number | null {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+/** Keep provider omissions distinct from measured zero in diagnostic logs. */
+export function runTokenLog(tokens: unknown, maxTokens?: number, finish?: unknown): RunTokenLog {
+    const usage = tokens && typeof tokens === "object" ? (tokens as Record<string, unknown>) : {};
+    const cache =
+        usage.cache && typeof usage.cache === "object"
+            ? (usage.cache as Record<string, unknown>)
+            : {};
+    return {
+        input: count(usage.input ?? usage.input_tokens),
+        output: count(usage.output ?? usage.output_tokens),
+        reasoning: count(usage.reasoning ?? usage.reasoning_tokens),
+        cache_read: count(
+            usage.cacheRead ?? usage.cache_read ?? usage.cached_input_tokens ?? cache.read,
+        ),
+        cache_write: count(
+            usage.cacheWrite ?? usage.cache_write ?? usage.cache_write_tokens ?? cache.write,
+        ),
+        max_tokens: count(maxTokens),
+        finish_reason: typeof finish === "string" ? finish : null,
+    };
+}
+
+export function formatRunTokenLog(tokens: RunTokenLog): string {
+    return `tokens=${JSON.stringify(tokens)}`;
+}

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

@@ -1,8 +1,13 @@
-import { expect, spyOn, test } from "bun:test";
+import { expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { Database, withPrivilegedWriter, withSqliteTransformPass } from "./sqlite";
+import {
+    Database,
+    withAsyncPrivilegedWriter,
+    withPrivilegedWriter,
+    withSqliteTransformPass,
+} from "./sqlite";
 import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
 
 for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
@@ -10,7 +15,9 @@ for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
         const dir = mkdtempSync(join(tmpdir(), "mc-routed-acquisition-"));
         const path = join(dir, "context.db");
         const db = new Database(path);
-        db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=50; CREATE TABLE result(value TEXT)");
+        db.exec(
+            "PRAGMA journal_mode=WAL; PRAGMA busy_timeout=50; CREATE TABLE result(value TEXT); CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)",
+        );
         const locker = await startSqliteWriteLocker(path, 650);
         let calls = 0;
         const write = () => {
@@ -19,7 +26,8 @@ for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
             return "managed";
         };
         try {
-            withSqliteTransformPass(() => {
+            await withSqliteTransformPass(async () => {
+                await withAsyncPrivilegedWriter(db, () => undefined);
                 if (mode === "literal") {
                     db.exec("BEGIN IMMEDIATE");
                     write();
@@ -43,7 +51,9 @@ for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
 
 test("routed transactions preserve nesting, receiver, arguments and rollback without callback retries", () => {
     const db = new Database(":memory:");
-    db.exec("CREATE TABLE result(value TEXT)");
+    db.exec(
+        "CREATE TABLE result(value TEXT); CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)",
+    );
     let calls = 0;
     const transaction = db.transaction(function (this: { prefix: string }, value: string) {
         calls++;
@@ -69,23 +79,21 @@ test("exhausted routed acquisition never enters the callback or multiplies privi
     const path = join(dir, "context.db");
     const blocker = new Database(path);
     const db = new Database(path);
-    blocker.exec("PRAGMA journal_mode=WAL; CREATE TABLE result(value TEXT)");
+    blocker.exec(
+        "PRAGMA journal_mode=WAL; CREATE TABLE result(value TEXT); CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)",
+    );
     db.exec("PRAGMA busy_timeout=0");
     blocker.exec("BEGIN IMMEDIATE");
-    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
     let callbacks = 0;
     try {
         for (const run of [
             () => db.transaction(() => callbacks++)(),
             () => withPrivilegedWriter(db, () => callbacks++),
         ]) {
-            wait.mockClear();
-            expect(() => withSqliteTransformPass(run)).toThrow("after 3 attempts");
-            expect(wait).toHaveBeenCalledTimes(2);
+            expect(() => withSqliteTransformPass(run)).toThrow("acquisition remained busy");
             expect(callbacks).toBe(0);
         }
     } finally {
-        wait.mockRestore();
         blocker.exec("ROLLBACK");
         blocker.close();
         db.close();

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

@@ -1,182 +1,153 @@
-import { expect, spyOn, test } from "bun:test";
+import { expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
+    beginSqliteWriterAsync,
     Database,
-    withoutSqliteTransformPass,
+    isTransientSqliteError,
+    SqliteAcquisitionBusyError,
+    withAsyncPrivilegedWriter,
     withPrivilegedWriter,
+    withSqliteBackgroundWriter,
     withSqliteTransformPass,
 } from "./sqlite";
+import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
 
-test("background privileged acquisition attempts once without backoff", () => {
-    const db = new Database(":memory:");
-    const error = Object.assign(new Error("original busy"), { code: "SQLITE_BUSY" });
-    const exec = spyOn(db, "exec").mockImplementation(() => {
-        throw error;
-    });
-    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
-    let callbacks = 0;
+function fixture() {
+    const dir = mkdtempSync(join(tmpdir(), "mc-busy-yield-"));
+    const path = join(dir, "context.db");
+    const db = new Database(path);
+    db.exec(
+        "PRAGMA journal_mode=WAL; CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)",
+    );
+    db.exec("PRAGMA busy_timeout=5000");
+    return {
+        db,
+        path,
+        close: () => {
+            db.close();
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+}
+
+test("tool-style transaction outside a pass waits for a brief lock", async () => {
+    const { db, path, close } = fixture();
+    const locker = await startSqliteWriteLocker(path, 300);
     try {
-        expect(() => withPrivilegedWriter(db, () => callbacks++)).toThrow("original busy");
-        expect(exec).toHaveBeenCalledTimes(1);
-        expect(wait).not.toHaveBeenCalled();
-        expect(callbacks).toBe(0);
+        const start = performance.now();
+        db.transaction(() =>
+            db.prepare("INSERT INTO context_privilege_state(id, enabled) VALUES (1, 0)").run(),
+        ).immediate();
+        expect(performance.now() - start).toBeGreaterThanOrEqual(250);
+        expect(db.prepare("SELECT COUNT(*) AS count FROM context_privilege_state").get()).toEqual({
+            count: 1,
+        });
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
     } finally {
-        exec.mockRestore();
-        wait.mockRestore();
-        db.close();
+        await locker.exited;
+        close();
     }
-});
+}, 30000);
 
-test("background transaction exhausts one five-second busy timeout", () => {
-    const dir = mkdtempSync(join(tmpdir(), "mc-background-busy-"));
-    const path = join(dir, "context.db");
+test("named background acquisition gives up quickly and leaves work for retry", () => {
+    const { db, path, close } = fixture();
     const blocker = new Database(path);
-    const writer = new Database(path);
-    blocker.exec("PRAGMA journal_mode=WAL; CREATE TABLE result(value TEXT)");
-    writer.exec("PRAGMA busy_timeout=5000");
     blocker.exec("BEGIN IMMEDIATE");
-    let callbacks = 0;
+    let calls = 0;
+    let retryQueued = false;
     try {
         const start = performance.now();
-        expect(() => writer.transaction(() => callbacks++)()).toThrow();
-        const elapsed = performance.now() - start;
-        expect(callbacks).toBe(0);
-        expect(elapsed).toBeGreaterThanOrEqual(4500);
-        expect(elapsed).toBeLessThan(7500);
+        try {
+            withSqliteBackgroundWriter(() => db.transaction(() => calls++)());
+        } catch (error) {
+            if (!isTransientSqliteError(error)) throw error;
+            retryQueued = true;
+        }
+        expect(performance.now() - start).toBeLessThan(250);
+        expect(retryQueued).toBe(true);
+        expect(calls).toBe(0);
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
     } finally {
         blocker.exec("ROLLBACK");
         blocker.close();
-        writer.close();
-        rmSync(dir, { recursive: true, force: true });
+        close();
     }
-}, 30000);
+});
 
-test("foreground retry scope crosses awaits, nests and excludes detached maintenance", async () => {
-    const db = new Database(":memory:");
-    const error = Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
-    const exec = spyOn(db, "exec").mockImplementation(() => {
-        throw error;
-    });
-    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
-    const acquire = () =>
-        withPrivilegedWriter(db, () => {
-            throw new Error("callback must not run");
-        });
-    let late: Promise<void> | undefined;
-    let release!: () => void;
-    const gate = new Promise<void>((resolve) => {
-        release = resolve;
-    });
+test("foreground admission keeps the loop ticking while a separate writer holds the lock", async () => {
+    const { db, path, close } = fixture();
+    const locker = await startSqliteWriteLocker(path, 650);
+    let timerFired = false;
+    let calls = 0;
     try {
-        await withSqliteTransformPass(async () => {
-            await Promise.resolve();
-            expect(() => withSqliteTransformPass(acquire)).toThrow("after 3 attempts");
-            expect(exec).toHaveBeenCalledTimes(3);
-            exec.mockClear();
-            wait.mockClear();
-            withoutSqliteTransformPass(() => {
-                expect(acquire).toThrow("busy");
-                expect(exec).toHaveBeenCalledTimes(1);
-                expect(wait).not.toHaveBeenCalled();
-            });
-            exec.mockClear();
-            expect(acquire).toThrow("after 3 attempts");
-            expect(exec).toHaveBeenCalledTimes(3);
-            late = (async () => {
-                await gate;
-                exec.mockClear();
-                wait.mockClear();
-                expect(acquire).toThrow("busy");
-                expect(exec).toHaveBeenCalledTimes(1);
-                expect(wait).not.toHaveBeenCalled();
-            })();
-        });
-        release();
-        await late;
-        exec.mockClear();
-        expect(acquire).toThrow("busy");
-        expect(exec).toHaveBeenCalledTimes(1);
+        setTimeout(() => {
+            timerFired = true;
+        }, 100);
+        await withSqliteTransformPass(() =>
+            withAsyncPrivilegedWriter(db, () => {
+                calls++;
+            }),
+        );
+        expect(timerFired).toBe(true);
+        expect(calls).toBe(1);
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
     } finally {
-        release();
-        exec.mockRestore();
-        wait.mockRestore();
-        db.close();
+        await locker.exited;
+        close();
     }
-});
+}, 30000);
 
-test("throwing foreground passes cannot leak retry policy to later work", async () => {
-    const db = new Database(":memory:");
-    const exec = spyOn(db, "exec").mockImplementation(() => {
-        throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
-    });
-    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
+test("a foreground in-pass writer has bounded 250ms tolerance and restores its timeout", () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    blocker.exec("BEGIN IMMEDIATE");
     try {
-        await expect(
-            withSqliteTransformPass(async () => {
-                throw new Error("pass failed");
-            }),
-        ).rejects.toThrow("pass failed");
-        expect(() => withPrivilegedWriter(db, () => undefined)).toThrow("busy");
-        expect(exec).toHaveBeenCalledTimes(1);
-        expect(wait).not.toHaveBeenCalled();
+        const start = performance.now();
+        expect(() =>
+            withSqliteTransformPass(() => withPrivilegedWriter(db, () => undefined)),
+        ).toThrow(SqliteAcquisitionBusyError);
+        expect(performance.now() - start).toBeGreaterThanOrEqual(200);
+        expect(performance.now() - start).toBeLessThan(400);
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
     } finally {
-        exec.mockRestore();
-        wait.mockRestore();
-        db.close();
+        blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
     }
 });
 
-test("explicit deferred reads on a writable handle do not contend with the writer", () => {
-    const dir = mkdtempSync(join(tmpdir(), "mc-deferred-read-"));
-    const path = join(dir, "context.db");
-    const writer = new Database(path);
-    const reader = new Database(path);
-    writer.exec(
-        "PRAGMA journal_mode=WAL; CREATE TABLE result(value TEXT); INSERT INTO result VALUES ('committed')",
-    );
-    reader.exec("PRAGMA busy_timeout=0");
-    writer.exec("BEGIN IMMEDIATE");
-    writer.exec("INSERT INTO result VALUES ('uncommitted')");
+test("ready background publication retries on a timer and retains its write", async () => {
+    const { db, path, close } = fixture();
+    const locker = await startSqliteWriteLocker(path, 650);
+    let ticked = false;
     try {
-        const rows = withSqliteTransformPass(() =>
-            reader.transaction(() => reader.prepare("SELECT value FROM result").all()).deferred(),
-        );
-        expect(rows).toEqual([{ value: "committed" }]);
+        setTimeout(() => {
+            ticked = true;
+        }, 100);
+        await beginSqliteWriterAsync(db, "historian-publish");
+        db.prepare("INSERT INTO context_privilege_state(id, enabled) VALUES (1, 0)").run();
+        db.exec("COMMIT");
+        expect(ticked).toBe(true);
+        expect(db.prepare("SELECT COUNT(*) AS count FROM context_privilege_state").get()).toEqual({
+            count: 1,
+        });
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
     } finally {
-        writer.exec("ROLLBACK");
-        writer.close();
-        reader.close();
-        rmSync(dir, { recursive: true, force: true });
+        await locker.exited;
+        close();
     }
-});
+}, 30000);
 
-test("an explicitly started foreground pass owns its lifetime independently", async () => {
-    const db = new Database(":memory:");
-    const exec = spyOn(db, "exec").mockImplementation(() => {
-        throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
-    });
-    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
-    let release!: () => void;
-    const gate = new Promise<void>((resolve) => {
-        release = resolve;
-    });
-    let child!: Promise<void>;
+test("an in-pass BEGIN tolerates a sibling writer that releases within 250ms", async () => {
+    const { db, path, close } = fixture();
+    const locker = await startSqliteWriteLocker(path, 150);
     try {
-        await withSqliteTransformPass(async () => {
-            child = withSqliteTransformPass(async () => {
-                await gate;
-                expect(() => withPrivilegedWriter(db, () => undefined)).toThrow("after 3 attempts");
-                expect(exec).toHaveBeenCalledTimes(3);
-            });
-        });
-        release();
-        await child;
+        withSqliteTransformPass(() => withPrivilegedWriter(db, () => undefined));
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
     } finally {
-        release();
-        exec.mockRestore();
-        wait.mockRestore();
-        db.close();
+        await locker.exited;
+        close();
     }
-});
+}, 30000);