@cortexkit/opencode-magic-context 0.44.2 → 0.44.4

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);

package/src/shared/sqlite.ts

@@ -224,7 +224,9 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
         writable: true,
         value: (sql: string) => {
             if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
-                retryAcquisition(() => nativeExec(sql), sql.trim());
+                if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore())
+                    acquireShort(db, () => nativeExec(sql), sql.trim());
+                else nativeExec(sql);
                 return db;
             }
             return nativeExec(sql);
@@ -489,6 +491,13 @@ export type Statement = BetterSqlite3.Statement<unknown[], unknown>;
 
 const privilegeDepth = new WeakMap<Database, number>();
 const transformPassScope = new AsyncLocalStorage<{ active: boolean } | undefined>();
+const admissionScope = new AsyncLocalStorage<boolean>();
+const backgroundWriterScope = new AsyncLocalStorage<boolean>();
+
+/** Opt in only a writer that can safely defer its work after a busy acquisition. */
+export function withSqliteBackgroundWriter<T>(operation: () => T): T {
+    return backgroundWriterScope.run(true, operation);
+}
 
 /** Only an awaited foreground transform may spend the extra acquisition budget.
  * The mutable lease also expires for detached descendants when that pass ends. */
@@ -530,35 +539,123 @@ export class SqliteAcquisitionBusyError extends Error {
     readonly code = "SQLITE_BUSY";
     readonly stage: string;
     constructor(cause: unknown, stage = "BEGIN IMMEDIATE") {
-        super("SQLite writer acquisition remained busy after 3 attempts", { cause });
+        super("SQLite writer acquisition remained busy", { cause });
         this.name = "SqliteAcquisitionBusyError";
         this.stage = stage;
     }
 }
 
-/** Retry only acquisition: no privilege flag, callback or in-memory mutation has run yet. */
-function retryAcquisition(acquire: () => unknown, stage: string): void {
-    // Maintenance writers retry on their next tick. Multiplying their native
-    // busy timeout here would stall every session sharing the host event loop.
-    if (!transformPassScope.getStore()?.active) {
+const SHORT_BUSY_TIMEOUT_MS = 25;
+const FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS = 250;
+const FOREGROUND_ACQUISITION_BUDGET_MS = 16_500;
+
+/** The connection is never handed back to another caller with a shortened timeout. */
+function acquireShort(db: Database, acquire: () => unknown, site: string): void {
+    const started = performance.now();
+    const previous = pragmaNumber(db, "busy_timeout");
+    let acquired = false;
+    try {
+        // Async admission retries after yielding, so each of its BEGIN attempts
+        // stays short. An ordinary BEGIN inside a transform pass cannot yield;
+        // give that single attempt enough time for a brief writer to finish.
+        const timeout =
+            transformPassScope.getStore()?.active &&
+            !admissionScope.getStore() &&
+            !backgroundWriterScope.getStore()
+                ? FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS
+                : SHORT_BUSY_TIMEOUT_MS;
+        db.exec(`PRAGMA busy_timeout=${timeout}`);
         acquire();
-        return;
+        acquired = true;
+    } catch (error) {
+        if (transformPassScope.getStore()?.active && isTransientSqliteError(error))
+            throw new SqliteAcquisitionBusyError(error, site);
+        throw error;
+    } finally {
+        if (previous !== null) db.exec(`PRAGMA busy_timeout=${previous}`);
+        const elapsed = performance.now() - started;
+        if (elapsed >= 250)
+            console.warn(
+                `[${new Date().toISOString()}] [magic-context] sqlite acquisition site=${site} lane=${transformPassScope.getStore()?.active ? "foreground" : "background"} elapsed=${Math.round(elapsed)}ms attempts=1 outcome=${acquired ? "acquired" : "busy"}`,
+            );
     }
-    const delays = [500, 1000];
-    for (let attempt = 0; ; attempt++) {
+}
+
+/** Begin an immediate transaction with bounded asynchronous retries on writer contention.
+ * Callers must recheck any lease or source snapshot after this function returns. */
+export async function beginSqliteWriterAsync(db: Database, site: string): Promise<void> {
+    const started = performance.now();
+    let attempts = 0;
+    for (;;) {
+        attempts++;
         try {
-            acquire();
+            withSqliteBackgroundWriter(() => db.exec("BEGIN IMMEDIATE"));
+            const elapsed = performance.now() - started;
+            if (elapsed >= 250)
+                console.warn(
+                    `[${new Date().toISOString()}] [magic-context] sqlite acquisition site=${site} lane=background elapsed=${Math.round(elapsed)}ms attempts=${attempts} outcome=acquired`,
+                );
             return;
         } catch (error) {
-            // Handles created by this module already retry inside exec. Do not
-            // apply the attempt budget twice; externally supplied handles still
-            // need the acquisition retry performed by withPrivilegedWriter.
-            if (error instanceof SqliteAcquisitionBusyError || !isTransientSqliteError(error))
+            if (!isTransientSqliteError(error)) throw error;
+            const elapsed = performance.now() - started;
+            if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+                console.warn(
+                    `[${new Date().toISOString()}] [magic-context] sqlite acquisition site=${site} lane=background elapsed=${Math.round(elapsed)}ms attempts=${attempts} outcome=busy`,
+                );
                 throw error;
-            if (attempt === delays.length) throw new SqliteAcquisitionBusyError(error, stage);
-            // The database API is synchronous on both hosts. With busy_timeout=5000,
-            // three attempts plus these waits bound one acquisition to 16.5 seconds.
-            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delays[attempt]);
+            }
+            await new Promise<void>((resolve) =>
+                setTimeout(
+                    resolve,
+                    Math.min(
+                        attempts === 1 ? 500 : 1000,
+                        FOREGROUND_ACQUISITION_BUDGET_MS - elapsed,
+                    ),
+                ),
+            );
+        }
+    }
+}
+
+/** Retry admission before any turn work, yielding between short lock attempts. */
+export async function withAsyncPrivilegedWriter<T>(db: Database, operation: () => T): Promise<T> {
+    const started = performance.now();
+    let attempts = 0;
+    for (;;) {
+        attempts++;
+        try {
+            const result = admissionScope.run(true, () =>
+                withSqliteTransformPass(() => withPrivilegedWriter(db, operation)),
+            );
+            const elapsed = performance.now() - started;
+            if (elapsed >= 250)
+                console.warn(
+                    `[${new Date().toISOString()}] [magic-context] sqlite acquisition site=privileged_writer lane=foreground elapsed=${Math.round(elapsed)}ms attempts=${attempts} outcome=acquired`,
+                );
+            return result;
+        } catch (error) {
+            // A callback failure can occur after writes; only retry a failed BEGIN.
+            if (!(error instanceof SqliteAcquisitionBusyError)) throw error;
+            const elapsed = performance.now() - started;
+            if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+                if (elapsed >= 250)
+                    console.warn(
+                        `[${new Date().toISOString()}] [magic-context] sqlite acquisition site=privileged_writer lane=foreground elapsed=${Math.round(elapsed)}ms attempts=${attempts} outcome=busy`,
+                    );
+                throw error instanceof SqliteAcquisitionBusyError
+                    ? error
+                    : new SqliteAcquisitionBusyError(error);
+            }
+            await new Promise<void>((resolve) =>
+                setTimeout(
+                    resolve,
+                    Math.min(
+                        attempts === 1 ? 500 : 1000,
+                        FOREGROUND_ACQUISITION_BUDGET_MS - elapsed,
+                    ),
+                ),
+            );
         }
     }
 }
@@ -587,7 +684,13 @@ export function withPrivilegedWriter<T>(db: Database, operation: () => T): T {
     if (nested) {
         db.exec(`SAVEPOINT ${savepoint}`);
     } else {
-        retryAcquisition(() => db.exec("BEGIN IMMEDIATE"), "BEGIN IMMEDIATE");
+        try {
+            db.exec("BEGIN IMMEDIATE");
+        } catch (error) {
+            if (transformPassScope.getStore()?.active && isTransientSqliteError(error))
+                throw new SqliteAcquisitionBusyError(error);
+            throw error;
+        }
     }
     privilegeDepth.set(db, previousDepth + 1);
     try {

package/src/shared/storage-busy.test.ts

@@ -1,70 +1,47 @@
-import { afterAll, afterEach, describe, expect, spyOn, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
     Database,
     isTransientSqliteError,
-    withSqliteTransformPass,
-    withPrivilegedWriter as writePrivileged,
+    withAsyncPrivilegedWriter,
+    withPrivilegedWriter,
 } from "./sqlite";
 
-const withPrivilegedWriter = <T>(db: Database, operation: () => T): T =>
-    withSqliteTransformPass(() => writePrivileged(db, operation));
-
-const wait = spyOn(Atomics, "wait");
-afterEach(() => wait.mockClear());
-afterAll(() => wait.mockRestore());
-
-describe("writer acquisition backoff", () => {
-    for (const clearsOn of [2, 3]) {
-        test(`acquisition clears on attempt ${clearsOn} and invokes callback exactly once`, () => {
-            const db = new Database(":memory:");
-            db.exec(
-                "CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER); CREATE TABLE result(value TEXT)",
-            );
-            const exec = db.exec.bind(db);
-            let attempts = 0;
-            let callbacks = 0;
-            const delays: number[] = [];
-            wait.mockImplementation((_array, _index, _value, timeout) => {
-                delays.push(timeout!);
-                return "timed-out";
-            });
-            const intercepted = spyOn(db, "exec").mockImplementation((sql) => {
-                if (sql === "BEGIN IMMEDIATE" && ++attempts < clearsOn)
-                    throw Object.assign(new Error("locked"), { code: "SQLITE_BUSY" });
-                return exec(sql);
-            });
-            try {
-                const result = withPrivilegedWriter(db, () => {
-                    callbacks++;
-                    db.prepare("INSERT INTO result VALUES (?)").run("managed");
-                    return JSON.stringify(db.prepare("SELECT * FROM result").all());
-                });
-                expect(result).toBe('[{"value":"managed"}]');
-                expect(attempts).toBe(clearsOn);
-                expect(callbacks).toBe(1);
-                expect(delays).toEqual([500, 1000].slice(0, clearsOn - 1));
-            } finally {
-                intercepted.mockRestore();
-                db.close();
-            }
-        });
-    }
-    test("exhausted acquisition never invokes callback", () => {
-        const db = new Database(":memory:");
+describe("writer acquisition", () => {
+    test("exhausted async admission preserves the foreground budget and never invokes the callback", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "mc-writer-budget-"));
+        const path = join(dir, "context.db");
+        const blocker = new Database(path);
+        blocker.exec(
+            "CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)",
+        );
+        const db = new Database(path);
+        db.exec("PRAGMA busy_timeout=5000");
+        blocker.exec("BEGIN IMMEDIATE");
         let calls = 0;
-        wait.mockImplementation(() => "timed-out");
-        const exec = spyOn(db, "exec").mockImplementation(() => {
-            throw Object.assign(new Error("original lock"), { code: "SQLITE_LOCKED" });
-        });
+        let ticks = 0;
+        const timer = setInterval(() => ticks++, 50);
+        const started = performance.now();
         try {
-            expect(() => withPrivilegedWriter(db, () => calls++)).toThrow("after 3 attempts");
-            expect(exec).toHaveBeenCalledTimes(3);
+            await expect(withAsyncPrivilegedWriter(db, () => calls++)).rejects.toThrow(
+                "acquisition remained busy",
+            );
+            expect(performance.now() - started).toBeGreaterThanOrEqual(16_500);
+            expect(performance.now() - started).toBeLessThan(17_500);
+            expect(ticks).toBeGreaterThan(100);
             expect(calls).toBe(0);
+            expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
         } finally {
-            exec.mockRestore();
+            clearInterval(timer);
+            blocker.exec("ROLLBACK");
+            blocker.close();
             db.close();
+            rmSync(dir, { recursive: true, force: true });
         }
-    });
+    }, 30000);
+
     test("busy callback rolls back without retrying mutations", () => {
         const db = new Database(":memory:");
         db.exec(
@@ -81,11 +58,11 @@ describe("writer acquisition backoff", () => {
             ).toThrow("after acquisition");
             expect(calls).toBe(1);
             expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
-            expect(wait).not.toHaveBeenCalled();
         } finally {
             db.close();
         }
     });
+
     test("recognizes Bun extended and Node numeric contention codes only", () => {
         expect(isTransientSqliteError({ code: "SQLITE_BUSY_SNAPSHOT" })).toBe(true);
         expect(isTransientSqliteError({ code: "ERR_SQLITE_ERROR", errcode: 5 })).toBe(true);

package/src/shared/tag-transcript.ts

@@ -1275,7 +1275,7 @@ function buildAggregateTarget(
             return any ? "truncated" : "absent";
         },
         // Open invocations still belong to the current turn; only complete arcs reclaim.
-        canDrop: complete,
+        canDrop: () => complete() && !occurrences.some((occ) => occ.part.hasUserAnswer?.()),
         requiresToolArcSkeleton,
         // Non-mutating read of the invocation input (the tool_use occurrence
         // carries the arguments). Used by smart-drops supersession selection.
@@ -1375,6 +1375,9 @@ function buildToolTarget(
         // drop() replaces an invocation part's arguments with a marker, so a
         // new drop of one keeps its real arguments instead.
         cannotRemove: () => part.setToolInput !== undefined,
+        // Without a paired tool call, an answer marker can forbid automatic dropping,
+        // but must not make ordinary results newly eligible for automatic reclaim.
+        ...(part.hasUserAnswer?.() ? { canDrop: () => false } : {}),
         inputStringBytes(): number | null {
             return part.setToolInput ? toolInputStringBytes(part.getToolInput?.() ?? null) : 0;
         },

package/src/shared/transcript.ts

@@ -78,6 +78,9 @@ export interface TranscriptPart {
     /** Discriminator for filter logic. Stable across mutations. */
     readonly kind: TranscriptPartKind;
 
+    /** True when the host marks this tool result as carrying a user's answer. */
+    hasUserAnswer?(): boolean;
+
     /**
      * Best-effort identifier for cross-pass tracking. May be:
      * - OpenCode part ID (e.g. "prt_..."), stable across passes.