@cortexkit/opencode-magic-context 0.44.1 → 0.44.3

package/src/shared/sqlite.ts

@@ -39,6 +39,7 @@
  * `run()` → {changes,lastInsertRowid}) is identical and was verified directly.
  */
 
+import { AsyncLocalStorage } from "node:async_hooks";
 import { statSync } from "node:fs";
 // Type import only — runtime is loaded dynamically below. @types/better-sqlite3
 // has the richest definitions and is a structural superset of the API surface
@@ -211,6 +212,72 @@ export interface SqliteMemoryStats {
 const trackedSqliteConnections = new Map<number, TrackedSqliteConnection>();
 let nextSqliteConnectionSequence = 1;
 
+/** Route native Bun and Node transaction entry through the same acquisition retry.
+ * Native Bun transaction wrappers execute BEGIN internally, bypassing an exec override,
+ * so both runtimes use this small synchronous wrapper instead. Writable handles
+ * default to IMMEDIATE; explicit deferred calls and readonly handles keep read
+ * snapshots without acquiring the writer lock. */
+function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean): void {
+    const nativeExec = db.exec.bind(db);
+    Object.defineProperty(db, "exec", {
+        configurable: true,
+        writable: true,
+        value: (sql: string) => {
+            if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
+                if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore())
+                    acquireShort(db, () => nativeExec(sql), sql.trim());
+                else nativeExec(sql);
+                return db;
+            }
+            return nativeExec(sql);
+        },
+    });
+    Object.defineProperty(db, "transaction", {
+        configurable: true,
+        writable: true,
+        // biome-ignore lint/suspicious/noExplicitAny: preserve the native callback's receiver and argument types.
+        value: (fn: (...args: any[]) => any) => {
+            const make = (mode: "IMMEDIATE" | "EXCLUSIVE" | "DEFERRED") =>
+                function (this: unknown, ...args: unknown[]): unknown {
+                    const nested = isInTransaction(db);
+                    // Equal savepoint names stack LIFO, matching both native backends.
+                    const savepoint = "mc_tx_sp";
+                    db.exec(nested ? `SAVEPOINT ${savepoint}` : `BEGIN ${mode}`);
+                    try {
+                        const result = fn.apply(this, args);
+                        db.exec(nested ? `RELEASE ${savepoint}` : "COMMIT");
+                        return result;
+                    } catch (error) {
+                        if (isInTransaction(db)) {
+                            if (nested) {
+                                db.exec(`ROLLBACK TO ${savepoint}`);
+                                db.exec(`RELEASE ${savepoint}`);
+                            } else db.exec("ROLLBACK");
+                        }
+                        throw error;
+                    }
+                };
+            const defaultTransaction = make(readonly ? "DEFERRED" : "IMMEDIATE");
+            const variants = {
+                default: defaultTransaction,
+                deferred: make("DEFERRED"),
+                immediate: make("IMMEDIATE"),
+                exclusive: make("EXCLUSIVE"),
+                database: db,
+            };
+            for (const transaction of [
+                variants.default,
+                variants.deferred,
+                variants.immediate,
+                variants.exclusive,
+            ]) {
+                Object.assign(transaction, variants);
+            }
+            return defaultTransaction;
+        },
+    });
+}
+
 function trackSqliteConnection(
     db: BetterSqlite3.Database,
     filename: unknown,
@@ -232,6 +299,7 @@ function trackSqliteConnection(
             ((options as { readonly?: unknown }).readonly === true ||
                 (options as { readOnly?: unknown }).readOnly === true),
     };
+    installTransactionRouting(db, metadata.readonly);
     Object.defineProperty(db, "close", {
         configurable: true,
         value: (...args: unknown[]) => {
@@ -260,18 +328,10 @@ const TrackedDatabase = new Proxy(DatabaseImpl, {
  * Wrap node:sqlite's `DatabaseSync` so it presents the better-sqlite3/bun
  * surface the rest of the codebase calls:
  *   - translate the `{ readonly }` constructor option → node:sqlite's `readOnly`
- *   - add a `transaction(fn)` helper that matches better-sqlite3 semantics,
- *     using `db.isTransaction` to pick BEGIN (top-level) vs SAVEPOINT (nested),
- *     so it composes correctly with manual `BEGIN IMMEDIATE` blocks too.
+ * Transaction routing is installed for both runtimes by trackSqliteConnection.
  */
 // biome-ignore lint/suspicious/noExplicitAny: node:sqlite has no shipped types here; the public export is cast to the better-sqlite3 shape.
 function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
-    // Single constant savepoint name is correct for arbitrary nesting depth:
-    // SQLite savepoints with the same name stack LIFO — RELEASE / ROLLBACK TO
-    // always target the most recent. node:sqlite is synchronous + single-process
-    // per connection, so there is no concurrent-savepoint hazard.
-    const SAVEPOINT = "mc_tx_sp";
-
     class NodeSqliteDatabase extends DatabaseSync {
         constructor(filename?: string | Buffer, options?: BetterSqlite3.Options) {
             const translated: Record<string, unknown> = { ...options };
@@ -306,52 +366,6 @@ function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
             }
             return stmt;
         }
-
-        // biome-ignore lint/suspicious/noExplicitAny: mirrors better-sqlite3's generic transaction(fn) signature.
-        transaction<F extends (...args: any[]) => any>(fn: F): F {
-            // biome-ignore lint/suspicious/noExplicitAny: faithful pass-through of this/args to fn.
-            const self = this as any;
-            const execute = (
-                mode: "" | "DEFERRED" | "IMMEDIATE" | "EXCLUSIVE",
-                receiver: unknown,
-                args: unknown[],
-            ) => {
-                const nested = self.isTransaction === true;
-                self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : `BEGIN${mode ? ` ${mode}` : ""}`);
-                try {
-                    const result = fn.apply(receiver, args);
-                    self.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
-                    return result;
-                } catch (error) {
-                    if (nested) {
-                        // ROLLBACK TO unwinds the savepoint's changes but leaves
-                        // it on the stack; RELEASE then pops it (better-sqlite3
-                        // does both).
-                        self.exec(`ROLLBACK TO ${SAVEPOINT}`);
-                        self.exec(`RELEASE ${SAVEPOINT}`);
-                    } else {
-                        self.exec("ROLLBACK");
-                    }
-                    throw error;
-                }
-            };
-            const wrapped = function (this: unknown, ...args: unknown[]): unknown {
-                return execute("", this, args);
-            };
-            wrapped.default = function (this: unknown, ...args: unknown[]): unknown {
-                return execute("", this, args);
-            };
-            wrapped.deferred = function (this: unknown, ...args: unknown[]): unknown {
-                return execute("DEFERRED", this, args);
-            };
-            wrapped.immediate = function (this: unknown, ...args: unknown[]): unknown {
-                return execute("IMMEDIATE", this, args);
-            };
-            wrapped.exclusive = function (this: unknown, ...args: unknown[]): unknown {
-                return execute("EXCLUSIVE", this, args);
-            };
-            return wrapped as unknown as F;
-        }
     }
 
     return NodeSqliteDatabase as unknown as typeof BetterSqlite3;
@@ -476,6 +490,175 @@ export type Database = BetterSqlite3.Database;
 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. */
+export function withSqliteTransformPass<T>(operation: () => T): T {
+    const lease = { active: true };
+    return transformPassScope.run(lease, () => {
+        try {
+            const result = operation();
+            if (result && typeof (result as { then?: unknown }).then === "function") {
+                return Promise.resolve(result).finally(() => {
+                    lease.active = false;
+                }) as T;
+            }
+            lease.active = false;
+            return result;
+        } catch (error) {
+            lease.active = false;
+            throw error;
+        }
+    });
+}
+
+/** Start detached maintenance work without borrowing a foreground pass's budget. */
+export function withoutSqliteTransformPass<T>(operation: () => T): T {
+    return transformPassScope.run(undefined, operation);
+}
+
+/** 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;
+    const value = error as { code?: unknown; errcode?: unknown };
+    return (
+        (typeof value.code === "string" && /^(SQLITE_BUSY|SQLITE_LOCKED)(_|$)/.test(value.code)) ||
+        (typeof value.errcode === "number" && [5, 6].includes(value.errcode & 0xff))
+    );
+}
+
+export class SqliteAcquisitionBusyError extends Error {
+    readonly code = "SQLITE_BUSY";
+    readonly stage: string;
+    constructor(cause: unknown, stage = "BEGIN IMMEDIATE") {
+        super("SQLite writer acquisition remained busy", { cause });
+        this.name = "SqliteAcquisitionBusyError";
+        this.stage = stage;
+    }
+}
+
+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();
+        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"}`,
+            );
+    }
+}
+
+/** 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 {
+            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) {
+            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;
+            }
+            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,
+                    ),
+                ),
+            );
+        }
+    }
+}
 
 function isInTransaction(db: Database): boolean {
     const candidate = db as unknown as { inTransaction?: unknown; isTransaction?: unknown };
@@ -501,7 +684,13 @@ export function withPrivilegedWriter<T>(db: Database, operation: () => T): T {
     if (nested) {
         db.exec(`SAVEPOINT ${savepoint}`);
     } else {
-        db.exec("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

@@ -0,0 +1,72 @@
+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,
+    withAsyncPrivilegedWriter,
+    withPrivilegedWriter,
+} from "./sqlite";
+
+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;
+        let ticks = 0;
+        const timer = setInterval(() => ticks++, 50);
+        const started = performance.now();
+        try {
+            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 {
+            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(
+            "CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER); CREATE TABLE result(value TEXT)",
+        );
+        let calls = 0;
+        try {
+            expect(() =>
+                withPrivilegedWriter(db, () => {
+                    calls++;
+                    db.exec("INSERT INTO result VALUES ('partial')");
+                    throw Object.assign(new Error("after acquisition"), { code: "SQLITE_BUSY" });
+                }),
+            ).toThrow("after acquisition");
+            expect(calls).toBe(1);
+            expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
+        } 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);
+        expect(isTransientSqliteError({ code: "ERR_SQLITE_ERROR", errcode: 262 })).toBe(true);
+        expect(isTransientSqliteError({ code: "SQLITE_CORRUPT" })).toBe(false);
+    });
+});

package/src/shared/subagent-runner.ts

@@ -71,6 +71,8 @@ export interface SubagentRunOptions {
     temperature?: number | undefined;
     /** Requested output-token budget for the provider request. */
     maxOutputTokens?: number | undefined;
+    /** Per-child cumulative prompt tokens for tool-loop dreamer tasks. */
+    tokenBudget?: number | undefined;
     cwd?: string | undefined;
     signal?: AbortSignal | undefined;
     /**
@@ -208,6 +210,8 @@ export type SubagentRunResult =
     | {
           ok: false;
           reason:
+              | "step_limit"
+              | "token_budget"
               | "invalid_prompt"
               | "timeout"
               | "abort"

package/src/shared/user-facing-codes.ts

@@ -38,6 +38,11 @@ export const USER_FACING_FAILURES = {
         sentence: "Memory maintenance stopped at its hidden agent step limit.",
         action: "This task needs less work per run; changing the model connection will not help.",
     },
+    dream_token_budget: {
+        code: "MC-D11",
+        sentence: "Memory maintenance reached its prompt-token budget.",
+        action: "The unfinished items will be retried on the next run.",
+    },
     dream_empty_completion: {
         code: "MC-D03",
         sentence: "Memory maintenance received no usable response.",
@@ -285,6 +290,7 @@ const DREAM_FAILURE_KEYS = {
     provider_timeout: "dream_provider_timeout",
     provider_error: "dream_provider_error",
     step_limit: "dream_step_limit",
+    token_budget: "dream_token_budget",
     empty_completion: "dream_empty_completion",
     no_models: "dream_no_models",
     child_aborted: "dream_child_aborted",

package/src/shared/windows-hidden-spawns.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import ts from "typescript";
+
+const root = resolve(import.meta.dir, "../../../..");
+const subprocessNames = new Set([
+    "exec",
+    "execSync",
+    "execFile",
+    "execFileSync",
+    "spawn",
+    "spawnSync",
+]);
+
+function sourceFiles(dir: string): string[] {
+    return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(dir, entry.name);
+        return entry.isDirectory() ? sourceFiles(path) : path.endsWith(".ts") ? [path] : [];
+    });
+}
+
+function missingHiddenOptions(path: string): string[] {
+    const text = readFileSync(path, "utf8");
+    if (!/node:child_process|Bun\.spawn/.test(text)) return [];
+    const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+    const imports = new Set<string>();
+    const variables = new Map<string, ts.Expression>();
+    for (const statement of source.statements) {
+        if (
+            ts.isImportDeclaration(statement) &&
+            statement.moduleSpecifier.getText(source).includes("node:child_process")
+        ) {
+            const bindings = statement.importClause?.namedBindings;
+            if (bindings && ts.isNamedImports(bindings)) {
+                for (const element of bindings.elements) {
+                    if (subprocessNames.has(element.propertyName?.text ?? element.name.text))
+                        imports.add(element.name.text);
+                }
+            }
+        }
+    }
+    function collect(node: ts.Node): void {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer)
+            variables.set(node.name.text, node.initializer);
+        ts.forEachChild(node, collect);
+    }
+    collect(source);
+    function hidden(node: ts.Expression | undefined, seen = new Set<string>()): boolean {
+        if (!node) return false;
+        if (ts.isIdentifier(node)) {
+            if (seen.has(node.text)) return false;
+            seen.add(node.text);
+            return hidden(variables.get(node.text), seen);
+        }
+        if (!ts.isObjectLiteralExpression(node)) return false;
+        // Later spreads can override an earlier flag, so inspect the effective last assignment.
+        for (const property of [...node.properties].reverse()) {
+            if (
+                ts.isPropertyAssignment(property) &&
+                property.name.getText(source) === "windowsHide"
+            ) {
+                return property.initializer.kind === ts.SyntaxKind.TrueKeyword;
+            }
+            if (ts.isSpreadAssignment(property) && hidden(property.expression, new Set(seen)))
+                return true;
+        }
+        return false;
+    }
+    const failures: string[] = [];
+    function visit(node: ts.Node): void {
+        if (ts.isCallExpression(node)) {
+            const expression = node.expression;
+            let name: string | undefined;
+            if (
+                ts.isIdentifier(expression) &&
+                (imports.has(expression.text) ||
+                    [
+                        "execFileAsync",
+                        "execFileSyncForIdentity",
+                        "rpcIdentityExecFileSync",
+                        "execFileForVerificationPaths",
+                    ].includes(expression.text) ||
+                    (expression.text === "exec" && path.endsWith("rpc-utils.ts")))
+            )
+                name = expression.text;
+            if (ts.isPropertyAccessExpression(expression)) {
+                const owner = expression.expression.getText(source);
+                if (
+                    owner === "Bun" &&
+                    (expression.name.text === "spawn" || expression.name.text === "spawnSync")
+                )
+                    name = "Bun.spawn";
+                if (
+                    (owner === "deps" || owner === "this") &&
+                    (subprocessNames.has(expression.name.text) ||
+                        expression.name.text === "spawnImpl")
+                )
+                    name = expression.name.text;
+            }
+            if (name) {
+                const index =
+                    name === "Bun.spawn"
+                        ? node.arguments.length === 1
+                            ? 0
+                            : 1
+                        : name === "execSync" || (name === "exec" && !path.endsWith("rpc-utils.ts"))
+                          ? 1
+                          : 2;
+                // A single-argument Bun.spawnSync({cmd, ...}) passes options as its first argument.
+                const option = node.arguments[index];
+                if (!hidden(option)) {
+                    const line =
+                        source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+                    failures.push(`${relative(root, path)}:${line} ${name}`);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(source);
+    return failures;
+}
+
+describe("Windows child processes", () => {
+    test("every plugin, Pi and CLI subprocess hides its Windows console", () => {
+        const failures = ["plugin", "pi-plugin", "cli"].flatMap((pkg) =>
+            sourceFiles(join(root, "packages", pkg, "src")).flatMap(missingHiddenOptions),
+        );
+        expect(failures).toEqual([]);
+    });
+});

package/src/shared/write-transaction-attribution.test.ts

@@ -6,7 +6,7 @@ import { join, resolve } from "node:path";
 const repoRoot = resolve(import.meta.dir, "../../../../");
 const beginImmediate = /\b(?:[A-Za-z_$][\w$]*\.)?exec\("BEGIN IMMEDIATE"\)/g;
 
-const fencedSources: Array<{ path: string; sites: string[] }> = [
+const fencedSources: Array<{ path: string; sites: string[]; reporterCalls?: string[] }> = [
     {
         path: "packages/plugin/src/features/magic-context/smart-notes/storage.ts",
         sites: ["smart_note_commit"],
@@ -52,8 +52,8 @@ const fencedSources: Array<{ path: string; sites: string[] }> = [
         // The chokepoint cannot import the logging chain (Node executes it
         // directly), so it reports through the injected reporter instead.
         path: "packages/plugin/src/shared/sqlite.ts",
-        sites: ["privileged_writer"],
-        reporterCall: "reportSlowPrivilegedWrite?.(",
+        sites: ["async_acquisition_dynamic_site", "privileged_writer"],
+        reporterCalls: ["console.warn(", "reportSlowPrivilegedWrite?.("],
     },
     {
         path: "packages/plugin/src/features/magic-context/git-commits/sweep-coordinator.ts",
@@ -75,10 +75,6 @@ const fencedSources: Array<{ path: string; sites: string[] }> = [
         path: "packages/plugin/src/hooks/magic-context/compartment-runner-recomp.ts",
         sites: ["historian-publish:recomp"],
     },
-    {
-        path: "packages/plugin/src/hooks/magic-context/compartment-runner-incremental.ts",
-        sites: ["historian-publish"],
-    },
     {
         path: "packages/plugin/src/features/magic-context/dreamer/lease.ts",
         sites: ["lease_dynamic_site"],
@@ -98,6 +94,10 @@ const fencedSources: Array<{ path: string; sites: string[] }> = [
 ];
 
 const nonBeginCoveredSites: Array<{ path: string; site: string }> = [
+    {
+        path: "packages/plugin/src/hooks/magic-context/compartment-runner-incremental.ts",
+        site: "historian-publish",
+    },
     {
         path: "packages/plugin/src/features/magic-context/message-index.ts",
         site: "message_index_clear",
@@ -159,7 +159,7 @@ function sourceFor(relativePath: string): string {
 function assertCoveredBeginImmediate(
     source: string,
     sites: string[],
-    reporterCall = "logSlowWriteTransaction(",
+    reporterCalls: string[] = [],
 ): void {
     const matches = [...source.matchAll(beginImmediate)];
     expect(matches).toHaveLength(sites.length);
@@ -167,8 +167,10 @@ function assertCoveredBeginImmediate(
         const match = matches[index];
         const nextBegin = matches[index + 1]?.index ?? source.length;
         const transactionRegion = source.slice(match.index, nextBegin);
-        expect(transactionRegion).toContain(reporterCall);
-        if (sites[index] === "lease_dynamic_site") {
+        expect(transactionRegion).toContain(reporterCalls[index] ?? "logSlowWriteTransaction(");
+        if (sites[index] === "async_acquisition_dynamic_site") {
+            expect(transactionRegion).toContain("site=${site}");
+        } else if (sites[index] === "lease_dynamic_site") {
             expect(transactionRegion).toContain("logSlowWriteTransaction(site");
         } else {
             expect(transactionRegion).toContain(`"${sites[index]}"`);
@@ -190,6 +192,7 @@ describe("write transaction attribution fences", () => {
             logger.flushLogger();
         `;
         const child = Bun.spawn({
+            windowsHide: true,
             cmd: ["bun", "--eval", scenario],
             cwd: import.meta.dir,
             env: {
@@ -218,7 +221,7 @@ describe("write transaction attribution fences", () => {
             assertCoveredBeginImmediate(
                 sourceFor(fencedSource.path),
                 fencedSource.sites,
-                "reporterCall" in fencedSource ? fencedSource.reporterCall : undefined,
+                fencedSource.reporterCalls,
             );
         }
         for (const coveredSite of nonBeginCoveredSites) {