@cortexkit/opencode-magic-context 0.44.1 → 0.44.2

package/src/shared/sqlite-transaction-mode-guard.test.ts

@@ -4,14 +4,14 @@ import { join, relative, resolve } from "node:path";
 import ts from "typescript";
 
 /**
- * A deferred transaction (`db.transaction(fn)()`, `.deferred()`, `.default()`)
- * starts with no lock. If it reads before it writes, the write must upgrade a read
+ * An explicitly deferred transaction starts with no writer lock. If it reads before it writes, the write must upgrade a read
  * snapshot to a write lock, and SQLite never runs the busy handler for that
  * upgrade: under another process's write it fails at once with SQLITE_BUSY, or
  * with SQLITE_BUSY_SNAPSHOT when another commit landed after the read, and
  * busy_timeout never applies. Many OpenCode and Pi processes share one context.db,
- * so every transaction that writes must start with `.immediate()` (or
- * `.exclusive()`), which takes the write lock at BEGIN where busy_timeout covers it.
+ * so writing transactions must acquire at BEGIN. The shared runtime defaults
+ * writable handles to IMMEDIATE; plugin/Pi call sites keep their explicit
+ * `.immediate()` / `.exclusive()` declarations as an additional intent fence.
  *
  * Only read-only transactions may stay deferred. Each one is listed here, keyed
  * by file and the nearest named enclosing function, with the reason it never
@@ -26,7 +26,7 @@ const READ_ONLY_DEFERRED_TRANSACTIONS: Record<string, string> = {
 };
 
 const REPOSITORY_ROOT = resolve(import.meta.dir, "../../../..");
-const SOURCE_ROOTS = ["packages/plugin/src", "packages/pi-plugin/src"];
+const SOURCE_ROOTS = ["packages/plugin/src", "packages/pi-plugin/src", "packages/cli/src"];
 const LOCKING_MODES = new Set(["immediate", "exclusive"]);
 
 function sourceFiles(directory: string): string[] {
@@ -56,13 +56,16 @@ function isTransactionCall(node: ts.Node): node is ts.CallExpression {
 }
 
 /** True when `node` is the receiver of a called `.immediate()` / `.exclusive()`. */
-function isCalledWithLockingMode(node: ts.Node): boolean {
+function isCalledWithLockingMode(
+    node: ts.Node,
+    modes: ReadonlySet<string> = LOCKING_MODES,
+): boolean {
     const access = node.parent;
     return (
         access !== undefined &&
         ts.isPropertyAccessExpression(access) &&
         access.expression === node &&
-        LOCKING_MODES.has(access.name.text) &&
+        modes.has(access.name.text) &&
         access.parent !== undefined &&
         ts.isCallExpression(access.parent) &&
         access.parent.expression === access
@@ -92,7 +95,11 @@ function enclosingFunctionName(node: ts.Node): string {
  * A transaction stored in a variable is locking only when every use of that
  * variable calls `.immediate()` or `.exclusive()` on it.
  */
-function storedTransactionLocks(call: ts.CallExpression, source: ts.SourceFile): boolean {
+function storedTransactionLocks(
+    call: ts.CallExpression,
+    source: ts.SourceFile,
+    modes: ReadonlySet<string> = LOCKING_MODES,
+): boolean {
     const declaration = call.parent;
     if (!ts.isVariableDeclaration(declaration) || !ts.isIdentifier(declaration.name)) return false;
     const name = declaration.name.text;
@@ -111,7 +118,7 @@ function storedTransactionLocks(call: ts.CallExpression, source: ts.SourceFile):
         ts.forEachChild(node, visit);
     };
     visit(scope);
-    return uses.length > 0 && uses.every(isCalledWithLockingMode);
+    return uses.length > 0 && uses.every((use) => isCalledWithLockingMode(use, modes));
 }
 
 interface TransactionScan {
@@ -154,8 +161,33 @@ function repositorySources(): Array<{ path: string; text: string }> {
 }
 
 describe("SQLite transaction lock mode", () => {
+    it("declares every audited read-only transaction explicitly deferred", () => {
+        const candidates: string[] = [];
+        for (const file of repositorySources()) {
+            const source = ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, true);
+            const visit = (node: ts.Node): void => {
+                if (isTransactionCall(node)) {
+                    const key = `${file.path}#${enclosingFunctionName(node)}`;
+                    if (key in READ_ONLY_DEFERRED_TRANSACTIONS) {
+                        const deferred = new Set(["deferred"]);
+                        if (
+                            !isCalledWithLockingMode(node, deferred) &&
+                            !storedTransactionLocks(node, source, deferred)
+                        )
+                            candidates.push(key);
+                    }
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(source);
+        }
+        expect(candidates.sort()).toEqual([]);
+    });
+
     it("starts every writing transaction with .immediate() or .exclusive()", () => {
-        const { deferredSites, lockingSites } = scanTransactionModes(repositorySources());
+        const { deferredSites, lockingSites } = scanTransactionModes(
+            repositorySources().filter((file) => !file.path.startsWith("packages/cli/")),
+        );
         // The scan must actually see the codebase's transactions.
         expect(lockingSites).toBeGreaterThan(50);
 

package/src/shared/sqlite-write-locker-test-support.ts

@@ -26,6 +26,7 @@ export async function startSqliteWriteLocker(
     const child = Bun.spawn(["bun", import.meta.path, dbPath, String(holdMs)], {
         stdout: "pipe",
         stderr: "pipe",
+        windowsHide: true,
     });
     const reader = child.stdout.getReader();
     const decoder = new TextDecoder();

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,70 @@ 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)) {
+                retryAcquisition(() => nativeExec(sql), sql.trim());
+                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 +297,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 +326,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 +364,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 +488,80 @@ 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>();
+
+/** 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 after 3 attempts", { 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) {
+        acquire();
+        return;
+    }
+    const delays = [500, 1000];
+    for (let attempt = 0; ; attempt++) {
+        try {
+            acquire();
+            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))
+                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]);
+        }
+    }
+}
 
 function isInTransaction(db: Database): boolean {
     const candidate = db as unknown as { inTransaction?: unknown; isTransaction?: unknown };
@@ -501,7 +587,7 @@ export function withPrivilegedWriter<T>(db: Database, operation: () => T): T {
     if (nested) {
         db.exec(`SAVEPOINT ${savepoint}`);
     } else {
-        db.exec("BEGIN IMMEDIATE");
+        retryAcquisition(() => db.exec("BEGIN IMMEDIATE"), "BEGIN IMMEDIATE");
     }
     privilegeDepth.set(db, previousDepth + 1);
     try {

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

@@ -0,0 +1,95 @@
+import { afterAll, afterEach, describe, expect, spyOn, test } from "bun:test";
+import {
+    Database,
+    isTransientSqliteError,
+    withSqliteTransformPass,
+    withPrivilegedWriter as writePrivileged,
+} 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:");
+        let calls = 0;
+        wait.mockImplementation(() => "timed-out");
+        const exec = spyOn(db, "exec").mockImplementation(() => {
+            throw Object.assign(new Error("original lock"), { code: "SQLITE_LOCKED" });
+        });
+        try {
+            expect(() => withPrivilegedWriter(db, () => calls++)).toThrow("after 3 attempts");
+            expect(exec).toHaveBeenCalledTimes(3);
+            expect(calls).toBe(0);
+        } finally {
+            exec.mockRestore();
+            db.close();
+        }
+    });
+    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([]);
+            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);
+        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

@@ -190,6 +190,7 @@ describe("write transaction attribution fences", () => {
             logger.flushLogger();
         `;
         const child = Bun.spawn({
+            windowsHide: true,
             cmd: ["bun", "--eval", scenario],
             cwd: import.meta.dir,
             env: {