@cortexkit/opencode-magic-context 0.46.0 → 0.47.0

package/src/shared/sqlite-640-review.test.ts

@@ -0,0 +1,183 @@
+import { expect, spyOn, test } from "bun:test";
+import { openDatabase } from "../features/magic-context/storage-db";
+import { getOrCreateSessionMeta, updateSessionMeta } from "../features/magic-context/storage-meta";
+import { recordToolDefinition } from "../features/magic-context/tool-definition-tokens";
+import { captureLkgSlot } from "../hooks/magic-context/lkg-replay";
+import { lkgReplayFits } from "../hooks/magic-context/lkg-replay-fit";
+import { resetLkgSlotsForTest } from "../hooks/magic-context/lkg-slot";
+import type { MessageLike } from "../hooks/magic-context/transform-operations";
+import { createMessagesTransformHandler } from "../plugin/messages-transform";
+import { refreshModelLimitsFromApi } from "./models-dev-cache";
+import { Database, SqliteAcquisitionBusyError, withAsyncPrivilegedWriter } from "./sqlite";
+
+function fixture() {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)");
+    db.exec("CREATE TABLE writes(value INTEGER)");
+    return db;
+}
+
+test("review: shared async admission rolls back callback busy without retrying side effects", async () => {
+    const db = fixture();
+    let callbacks = 0;
+    let recoveries = 0;
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(
+                db,
+                () => {
+                    callbacks++;
+                    db.prepare("INSERT INTO writes VALUES (1)").run();
+                    throw new SqliteAcquisitionBusyError(new Error("nested acquisition busy"));
+                },
+                {
+                    beforeRetry: () => {
+                        recoveries++;
+                    },
+                },
+            ),
+        ).rejects.toThrow("SQLite writer acquisition remained busy");
+        expect(callbacks).toBe(1);
+        expect(recoveries).toBe(0);
+        expect(db.prepare("SELECT * FROM writes").all()).toEqual([]);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        db.close();
+    }
+});
+
+test("review: default OpenCode empty admission retries BEGIN only and preserves output bytes", async () => {
+    const db = fixture();
+    const exec = db.exec.bind(db);
+    let attempts = 0;
+    const spy = spyOn(db, "exec").mockImplementation((sql) => {
+        if (sql === "BEGIN IMMEDIATE" && ++attempts === 1)
+            throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+        return exec(sql);
+    });
+    try {
+        const output = [{ role: "user", content: "§1§ managed input" }];
+        const before = JSON.stringify(output);
+        await withAsyncPrivilegedWriter(db, () => undefined);
+        expect(attempts).toBe(2);
+        expect(JSON.stringify(output)).toBe(before);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        spy.mockRestore();
+        db.close();
+    }
+});
+
+test("review: COMMIT busy after empty admission is surfaced once and transaction is released", async () => {
+    const db = fixture();
+    const exec = db.exec.bind(db);
+    let callbacks = 0;
+    let commits = 0;
+    const spy = spyOn(db, "exec").mockImplementation((sql) => {
+        if (sql === "COMMIT") {
+            commits++;
+            throw Object.assign(new Error("reader holds rollback-journal lock"), {
+                code: "SQLITE_BUSY",
+            });
+        }
+        return exec(sql);
+    });
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(db, () => {
+                callbacks++;
+            }),
+        ).rejects.toThrow("reader holds rollback-journal lock");
+        expect(callbacks).toBe(1);
+        expect(commits).toBe(1);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        spy.mockRestore();
+        db.close();
+    }
+});
+
+test("review: OpenCode tries a valid saved request before backed-off writer retry", async () => {
+    resetLkgSlotsForTest();
+    const db = openDatabase();
+    if (!db) throw new Error("isolated test database unavailable");
+    const sessionId = "review-opencode-order";
+    const model = { providerID: "openai", modelID: "gpt-4.1" };
+    await refreshModelLimitsFromApi({
+        config: {
+            providers: async () => ({
+                data: {
+                    providers: [
+                        {
+                            id: model.providerID,
+                            models: {
+                                [model.modelID]: { limit: { context: 1000000, output: 8192 } },
+                            },
+                        },
+                    ],
+                },
+            }),
+        },
+    });
+    getOrCreateSessionMeta(db, sessionId);
+    updateSessionMeta(db, sessionId, { systemPromptTokens: 100 });
+    recordToolDefinition(model.providerID, model.modelID, undefined, "read", "read file", {
+        type: "object",
+    });
+    const messages = [
+        {
+            info: { id: "u0", role: "user", sessionID: sessionId, model },
+            parts: [{ type: "text", text: "old raw history" }],
+        },
+    ] as MessageLike[];
+    const managed = structuredClone(messages);
+    (managed[0].parts[0] as { text: string }).text = "saved managed prefix";
+    expect(
+        captureLkgSlot({
+            sessionId,
+            input: messages,
+            output: managed,
+            modelKey: "openai/gpt-4.1",
+            providerKey: "openai",
+        }),
+    ).toBe(true);
+    expect(
+        lkgReplayFits({
+            db,
+            sessionId,
+            messages: managed,
+            model,
+            modelKey: "openai/gpt-4.1",
+            systemPromptTokens: 100,
+        }).fits,
+    ).toBe(true);
+    const exec = db.exec.bind(db);
+    let attempts = 0;
+    let callbacks = 0;
+    const spy = spyOn(db, "exec").mockImplementation((sql) => {
+        if (sql === "BEGIN IMMEDIATE" && ++attempts === 1)
+            throw Object.assign(new Error("writer busy"), { code: "SQLITE_BUSY" });
+        return exec(sql);
+    });
+    try {
+        const output = { messages: structuredClone(messages) };
+        const handler = createMessagesTransformHandler({
+            magicContext: {
+                "experimental.chat.messages.transform": async (_input, result) => {
+                    callbacks++;
+                    (result.messages[0].parts[0] as { text: string }).text =
+                        "recomputed after retry";
+                },
+            },
+        });
+        await handler({}, output as Parameters<typeof handler>[1]);
+        expect({ callbacks, attempts, messages: output.messages }).toEqual({
+            callbacks: 0,
+            attempts: 1,
+            messages: managed,
+        });
+    } finally {
+        spy.mockRestore();
+        resetLkgSlotsForTest();
+    }
+});

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

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
     Database,
+    SqliteAcquisitionBusyError,
     withAsyncPrivilegedWriter,
     withPrivilegedWriter,
     withSqliteTransformPass,
@@ -11,6 +12,23 @@ import {
 import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
 import { createTestTempDirFromPath } from "./test-temp-dir";
 
+test("async writer never retries callback acquisition errors after work began", async () => {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)");
+    let calls = 0;
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(db, () => {
+                calls++;
+                throw new SqliteAcquisitionBusyError(new Error("nested BEGIN"));
+            }),
+        ).rejects.toThrow("acquisition remained busy");
+        expect(calls).toBe(1);
+    } finally {
+        db.close();
+    }
+});
+
 for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
     test(`shared SQLite retries ${mode} acquisition before running any writes`, async () => {
         const dir = createTestTempDirFromPath(join(tmpdir(), "mc-routed-acquisition-"));

package/src/shared/sqlite.ts

@@ -245,6 +245,7 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
         configurable: true,
         writable: true,
         value: (sql: string) => {
+            if (/^\s*(?:COMMIT|END)\b/i.test(sql)) assertTransformWrite();
             if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
                 // A transaction that ended without passing through exec (for
                 // example an automatic rollback) must not be timed as this one.
@@ -430,6 +431,18 @@ function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
 
 export const Database: typeof BetterSqlite3 = TrackedDatabase;
 
+/** The constructor path, without querying SQLite on the prompt thread. */
+export function getSqliteDatabasePath(db: Database): string | null {
+    for (const connection of trackedSqliteConnections.values()) {
+        if (connection.reference.deref() === db) {
+            return connection.filename === ":memory:" || connection.filename === "<buffer>"
+                ? null
+                : connection.filename;
+        }
+    }
+    return null;
+}
+
 function pragmaValue(db: BetterSqlite3.Database, name: string): unknown {
     const row = db.prepare(`PRAGMA ${name}`).get() as Record<string, unknown> | undefined;
     if (!row) return undefined;
@@ -617,7 +630,12 @@ export function prepareCachedStatement(db: Database, sql: string): Statement {
 
 const privilegeDepth = new WeakMap<Database, number>();
 const transformPassScope = new AsyncLocalStorage<
-    { active: boolean; remainingWaitMs: number } | undefined
+    | {
+          active: boolean;
+          remainingWaitMs: number;
+          guard?: { assert(): void; remainingMs(): number };
+      }
+    | undefined
 >();
 const admissionScope = new AsyncLocalStorage<boolean>();
 const backgroundWriterScope = new AsyncLocalStorage<boolean>();
@@ -655,6 +673,17 @@ export function withoutSqliteTransformPass<T>(operation: () => T): T {
     return transformPassScope.run(undefined, operation);
 }
 
+/** Attach the adapter's existing generation/cancellation/deadline guard to writes. */
+export function guardSqliteTransformPass(guard: { assert(): void; remainingMs(): number }): void {
+    const lease = transformPassScope.getStore();
+    if (lease) lease.guard = guard;
+}
+
+/** Check the attached generation/cancellation/deadline guard before SQL or cache publication. */
+export function assertTransformWrite(): void {
+    if (!backgroundWriterScope.getStore()) transformPassScope.getStore()?.guard?.assert();
+}
+
 /** Bun names SQLite codes; node:sqlite exposes the numeric (possibly extended) errcode. */
 export function isTransientSqliteError(error: unknown): boolean {
     if (!error || typeof error !== "object") return false;
@@ -698,6 +727,7 @@ interface WriterAcquisition {
     startedAt: number;
     attempts: number;
     claimed: boolean;
+    remainingMs?: () => number;
 }
 
 /** A write transaction whose BEGIN went through `acquireShort` and has not ended yet. */
@@ -724,6 +754,7 @@ function foregroundWaitLease() {
  * native API cannot separate lock waiting from statement execution. Exhaustion
  * switches to zero-wait acquisition, not a refusal when the writer is free. */
 function withAutocommitTimeout<T>(db: Database, operation: () => T): T {
+    assertTransformWrite();
     const lease = foregroundWaitLease();
     if (isInTransaction(db) || (!lease && !backgroundWriterScope.getStore())) return operation();
     const previous = pragmaNumber(db, "busy_timeout");
@@ -749,6 +780,7 @@ function withAutocommitTimeout<T>(db: Database, operation: () => T): T {
 
 /** The connection is never handed back to another caller with a shortened timeout. */
 function acquireShort(db: Database, acquire: () => unknown, site: string): void {
+    assertTransformWrite();
     const started = performance.now();
     const previous = pragmaNumber(db, "busy_timeout");
     const outer = writerAcquisitionScope.getStore();
@@ -763,7 +795,12 @@ function acquireShort(db: Database, acquire: () => unknown, site: string): void
         // stays short. An ordinary BEGIN inside a transform pass cannot yield;
         // give that single attempt enough time for a brief writer to finish.
         const lease = foregroundWaitLease();
-        const timeout = lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS;
+        const timeout = Math.floor(
+            Math.min(
+                lease ? lease.remainingWaitMs : SHORT_BUSY_TIMEOUT_MS,
+                owner?.remainingMs?.() ?? lease?.guard?.remainingMs() ?? Infinity,
+            ),
+        );
         db.exec(`PRAGMA busy_timeout=${timeout}`);
         acquire();
         acquiredAt = performance.now();
@@ -871,11 +908,28 @@ export async function beginSqliteWriterAsync(db: Database, site: string): Promis
 }
 
 /** Retry admission before any turn work, yielding between short lock attempts. */
-export async function withAsyncPrivilegedWriter<T>(db: Database, operation: () => T): Promise<T> {
+export async function withAsyncPrivilegedWriter<T>(
+    db: Database,
+    operation: () => T,
+    options: {
+        signal?: AbortSignal;
+        beforeRetry?: (error: SqliteAcquisitionBusyError) => void;
+        jitter?: boolean;
+        budgetMs?: number;
+        assertCurrentPass?: () => void;
+    } = {},
+): Promise<T> {
     const started = performance.now();
+    const budgetMs = Math.max(
+        0,
+        Math.min(FOREGROUND_ACQUISITION_BUDGET_MS, options.budgetMs ?? Infinity),
+    );
     let attempts = 0;
     for (;;) {
+        options.signal?.throwIfAborted();
+        options.assertCurrentPass?.();
         attempts++;
+        let entered = false;
         try {
             const acquisition: WriterAcquisition = {
                 site: "privileged_writer",
@@ -883,35 +937,51 @@ export async function withAsyncPrivilegedWriter<T>(db: Database, operation: () =
                 startedAt: started,
                 attempts,
                 claimed: false,
+                remainingMs: () => Math.max(0, budgetMs - (performance.now() - started)),
             };
             // The acquisition and hold of this transaction are reported when it
             // commits or rolls back (see endWriterTransaction).
             return admissionScope.run(true, () =>
                 withSqliteTransformPass(() =>
                     writerAcquisitionScope.run(acquisition, () =>
-                        withPrivilegedWriter(db, operation),
+                        withPrivilegedWriter(db, () => {
+                            entered = true;
+                            return operation();
+                        }),
                     ),
                 ),
             );
         } catch (error) {
             // A callback failure can occur after writes; only retry a failed BEGIN.
-            if (!(error instanceof SqliteAcquisitionBusyError)) throw error;
+            if (entered || !(error instanceof SqliteAcquisitionBusyError)) throw error;
+            // Adapters may serve a validated saved request instead of waiting.
+            // This runs only after a failed BEGIN, never after callback writes.
+            options.beforeRetry?.(error);
             const elapsed = performance.now() - started;
-            if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+            if (elapsed >= budgetMs) {
                 reportSqliteDiagnostic(
                     `sqlite writer site=privileged_writer lane=foreground acquire_ms=${Math.round(elapsed)} attempts=${attempts} outcome=busy`,
                 );
                 throw error;
             }
-            await new Promise<void>((resolve) =>
-                setTimeout(
-                    resolve,
-                    Math.min(
-                        attempts === 1 ? 500 : 1000,
-                        FOREGROUND_ACQUISITION_BUDGET_MS - elapsed,
-                    ),
-                ),
+            const backoff = attempts === 1 ? 500 : 1000;
+            const delay = Math.min(
+                options.jitter ? backoff * (0.8 + Math.random() * 0.4) : backoff,
+                budgetMs - elapsed,
             );
+            await new Promise<void>((resolve, reject) => {
+                const abort = () => {
+                    clearTimeout(timer);
+                    options.signal?.removeEventListener("abort", abort);
+                    reject(options.signal?.reason ?? new Error("Writer wait aborted"));
+                };
+                const timer = setTimeout(() => {
+                    options.signal?.removeEventListener("abort", abort);
+                    resolve();
+                }, delay);
+                options.signal?.addEventListener("abort", abort, { once: true });
+                if (options.signal?.aborted) abort();
+            });
         }
     }
 }

package/src/shared/status-view.test.ts

@@ -118,7 +118,12 @@ describe("status view model", () => {
         expect(rowLabels("Tags")).toEqual(["Active", "Dropped", "Total"]);
         expect(rowLabels("Reductions")).toEqual(["Execute threshold", "Last reduce anchor"]);
         expect(rowLabels("Pending Queue")).toEqual(["Drops", "Marker"]);
-        expect(rowLabels("Context Details")).toEqual(["Protected tags", "Subagent"]);
+        expect(rowLabels("Context Details")).toEqual([
+            "Protected tags",
+            "Subagent",
+            "Denominator",
+            "Window source",
+        ]);
         expect(rowLabels("Cache TTL")).toEqual([
             "Configured",
             "Last response",

package/src/shared/status-view.ts

@@ -31,7 +31,11 @@ import {
     type UserFacingFailureKey,
     userFacingFailureCode,
 } from "./user-facing-codes";
-import { formatWindowDerivationLine, type WindowGeometryResult } from "./window-geometry";
+import {
+    formatWindowDerivationLine,
+    formatWindowSource,
+    type WindowGeometryResult,
+} from "./window-geometry";
 
 /** Theme-independent colour role; each host maps these onto its own palette. */
 export type StatusTone = "accent" | "text" | "muted" | "warning" | "error";
@@ -656,6 +660,16 @@ function statusSections(source: StatusViewSource, now: number): StatusSection[]
                     tone: "muted",
                 },
                 { label: "Subagent", value: source.isSubagent ? "yes" : "no", tone: "muted" },
+                {
+                    label: "Denominator",
+                    value: `${Math.round(source.contextLimit)} tokens`,
+                    tone: "muted",
+                },
+                {
+                    label: "Window source",
+                    value: formatWindowSource(source.windowGeometry),
+                    tone: "muted",
+                },
             ],
         },
         { title: "Cache TTL", labelWidth: 14, rows: cacheRows(source, now) },

package/src/shared/tag-transcript.ts

@@ -1157,6 +1157,10 @@ function buildAggregateTarget(
     };
 
     return {
+        mutationParts: occurrences.map((occ) => ({
+            message: { info: occ.message.info, parts: [] },
+            part: occ.part,
+        })),
         measureReclaim(skeleton) {
             let beforeTools = 0;
             let afterTools = 0;
@@ -1319,6 +1323,7 @@ function buildTextTarget(
     textPrefix: string,
 ): TagTarget {
     return {
+        mutationParts: [{ message: { info: message.info, parts: [] }, part }],
         textPrefix,
         setContent(content: string): boolean {
             return part.setText(content);
@@ -1351,6 +1356,7 @@ function buildToolTarget(
     tagId: number,
 ): TagTarget {
     return {
+        mutationParts: [{ message: { info: message.info, parts: [] }, part }],
         setContent(content: string): boolean {
             return setToolContentOrText(part, content);
         },

package/src/shared/window-geometry.ts

@@ -89,6 +89,8 @@ export interface WindowDerivation {
     geometry: WindowGeometry;
     windowSource: WindowLimitSource;
     absoluteWall: number;
+    /** Accepted provider input used to raise the usable denominator above metadata. */
+    provenInputTokens?: number;
 }
 
 export interface WindowGeometryResult {
@@ -691,6 +693,7 @@ export function applyProvenInputFloor(
                 absoluteWall: trustedAbsoluteWall
                     ? geometry.derivation.absoluteWall
                     : Math.max(geometry.derivation.absoluteWall, provenInputTokens),
+                provenInputTokens,
             },
         },
     };
@@ -715,6 +718,13 @@ export function formatWindowDerivationLine(
     return `${formatCompactTokens(inputTokens)} / ${formatCompactTokens(result.usableSoft)} usable · window ${formatCompactTokens(result.derivation.window)} · ${formatCompactTokens(result.derivation.reserve)} ${reserveLabel}`;
 }
 
+/** Distinguish metadata from a denominator raised by an accepted input measurement. */
+export function formatWindowSource(result: WindowGeometryResult | undefined): string {
+    return result?.derivation.provenInputTokens
+        ? `provider-measured floor (${result.derivation.windowSource})`
+        : (result?.derivation.windowSource ?? "unknown");
+}
+
 export function formatCompactTokens(value: number): string {
     if (Math.abs(value) >= 1_000_000) {
         return `${(value / 1_000_000).toFixed(1).replace(/\.0$/, "")}m`;

package/dist/wrapup-orchestrator-kw3x3myw.js

@@ -1,26 +0,0 @@
-import {
-  runManagedWrapup2
-} from "./index-e2dtv0ra.js";
-import"./index-j7fvnjye.js";
-import"./index-p821bjdb.js";
-import"./index-sd3egckz.js";
-import"./index-7qw742ev.js";
-import"./index-0d3g3461.js";
-import"./index-yasgb8ej.js";
-import"./index-r5hmbx3t.js";
-import"./index-3h0ybwah.js";
-import"./index-majxda46.js";
-import"./index-1zx87sdm.js";
-import"./index-q4yp4b52.js";
-import"./index-5gq3b2ya.js";
-import"./index-b35pxds2.js";
-import"./index-5eqk6z3s.js";
-import"./index-sj29b3z2.js";
-import"./index-fg34g6a5.js";
-import"./index-x8a7jmkh.js";
-import"./index-fzbvakh0.js";
-import"./index-hybnrwq0.js";
-import"./index-q6hef7fh.js";
-export {
-  runManagedWrapup2 as runManagedWrapup
-};