@cortexkit/opencode-magic-context 0.44.3 → 0.45.0

package/src/shared/rpc-utils.test.ts

@@ -10,8 +10,11 @@ import {
     classifyProcessKind,
     discoverLivePiProcessIds,
     inspectLivePiProcesses,
+    inspectWindowsProcessesSync,
     isPidAlive,
     isPidIdentityPlausible,
+    parseTasklistOutput,
+    processCannotBeRpcHost,
     type RpcPortFileRecord,
     readProcessProbeEvidence,
 } from "./rpc-utils";
@@ -441,7 +444,7 @@ describe("isPidAlive", () => {
         expect(calls).toEqual([
             {
                 file: "tasklist",
-                args: ["/FO", "CSV", "/FI", `PID eq ${PID}`],
+                args: ["/FO", "CSV", "/NH", "/FI", `PID eq ${PID}`],
                 stdio: ["ignore", "pipe", "pipe"],
             },
         ]);
@@ -623,19 +626,195 @@ describe("isPidIdentityPlausible", () => {
         });
 
         expect(isPidIdentityPlausible(record(0))).toBe("plausible");
-        expect(calls).toEqual([{ file: "tasklist", args: ["/FO", "CSV", "/FI", `PID eq ${PID}`] }]);
+        expect(calls).toEqual([
+            { file: "tasklist", args: ["/FO", "CSV", "/NH", "/FI", `PID eq ${PID}`] },
+        ]);
 
         calls.length = 0;
+        // With the start time unreadable, the image is read next: only an image
+        // that cannot be a host would prove the record stale, and OpenCode.exe can.
         expect(isPidIdentityPlausible(record(NOW_MS))).toBe("inconclusive");
-        expect(calls).toEqual([
-            {
-                file: "powershell",
-                args: [
-                    "-NoProfile",
-                    "-Command",
-                    "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine,CreationDate | ConvertTo-Json -Compress",
-                ],
-            },
-        ]);
+        expect(calls.map((call) => call.file)).toEqual(["powershell", "tasklist"]);
+        expect(calls[0]?.args.slice(0, 2)).toEqual(["-NoProfile", "-Command"]);
+        expect(String(calls[0]?.args[2])).toContain("Get-CimInstance Win32_Process");
+        expect(String(calls[0]?.args[2])).toContain("ToString('o')");
+    });
+});
+
+test("the synchronous Windows process list allows more output than the 1 MiB default", () => {
+    // Bun's execFileSync throws ENOBUFS past 1 MiB, and a Win32_Process listing
+    // with command lines passes that on a busy desktop; the snapshot then falls
+    // back to tasklist, which has no start times.
+    const limits: unknown[] = [];
+    __setRpcIdentityTestHooks({
+        platform: "win32",
+        processListExecFileSync: ((
+            _file: string,
+            _args: readonly string[],
+            options?: { maxBuffer?: number },
+        ) => {
+            limits.push(options?.maxBuffer);
+            return JSON.stringify([
+                {
+                    ProcessId: 7,
+                    ParentProcessId: 1,
+                    Name: "opencode.exe",
+                    CommandLine: "opencode",
+                    CreationDate: "2026-09-30T10:15:00Z",
+                },
+            ]);
+        }) as unknown as typeof execFileSync,
+    });
+    const inspection = inspectWindowsProcessesSync();
+    expect(inspection.processSnapshot?.source).toBe("cim");
+    expect(limits).toEqual([8 * 1024 * 1024]);
+});
+
+test("Spanish tasklist no-match is not running", () => {
+    const output =
+        "INFORMACIÓN: no hay tareas ejecutándose que coincidan con los\ncriterios especificados.";
+    expect(parseTasklistOutput(output)).toEqual([]);
+    __setRpcIdentityTestHooks({ platform: "win32", execFileSync: psOutput(output) });
+    expect(isPidAlive(PID)).toBe("dead");
+});
+
+test("German tasklist no-match is not running", () => {
+    expect(
+        parseTasklistOutput(
+            "INFORMATION: Es werden keine Aufgaben mit den angegebenen Kriterien ausgeführt.",
+        ),
+    ).toEqual([]);
+});
+
+test("tasklist CSV live process is running", () => {
+    expect(parseTasklistOutput('"opencode.exe","1234","Console","1","10,000 K"')).toEqual([
+        { pid: 1234, command: "opencode.exe" },
+    ]);
+});
+
+describe("proving a discovery record stale from the record's own start time", () => {
+    // Values from a Windows machine where PIDs from old records had been reused.
+    const RECORDED = Date.parse("2026-08-16T22:49:55Z");
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    const windowsRecord = (startedAt: number): RpcPortFileRecord => ({
+        port: 54209,
+        pid: 15520,
+        started_at: startedAt,
+    });
+
+    test("a PID whose process started after the record was written is a reused PID", () => {
+        expect(
+            isPidIdentityPlausible(windowsRecord(RECORDED), {
+                startTime: RECORDED + 42 * DAY_MS,
+                commandLine: "C:\\Windows\\System32\\RuntimeBroker.exe -Embedding",
+                imageName: "RuntimeBroker.exe",
+            }),
+        ).toBe("implausible");
+        // The start time alone is proof, even when the new process is a runtime a
+        // host could use.
+        expect(
+            isPidIdentityPlausible(windowsRecord(RECORDED), {
+                startTime: RECORDED + 42 * DAY_MS,
+                commandLine: "node.exe C:\\tools\\unrelated.js",
+                imageName: "node.exe",
+            }),
+        ).toBe("implausible");
+    });
+
+    test("a host that started at or before its record is genuine", () => {
+        for (const startTime of [RECORDED - 13_000, RECORDED]) {
+            expect(
+                isPidIdentityPlausible(windowsRecord(RECORDED), {
+                    startTime,
+                    commandLine: null,
+                    imageName: "RuntimeBroker.exe",
+                }),
+            ).toBe("plausible");
+        }
+    });
+
+    test("an unreadable start time with an image no host can run is a reused PID", () => {
+        for (const imageName of ["svchost.exe", "WinAutomation.UserAgent.exe"]) {
+            expect(
+                isPidIdentityPlausible(windowsRecord(RECORDED), {
+                    startTime: null,
+                    commandLine: imageName,
+                    imageName,
+                }),
+            ).toBe("implausible");
+        }
+    });
+
+    test("an unreadable start time with a host-like image stays inconclusive", () => {
+        for (const imageName of [
+            "opencode.exe",
+            "OpenChamber.exe",
+            "pi.exe",
+            "omp.exe",
+            "bun.exe",
+            "node.exe",
+            "ck-mc.exe",
+        ]) {
+            expect(
+                isPidIdentityPlausible(windowsRecord(RECORDED), {
+                    startTime: null,
+                    commandLine: null,
+                    imageName,
+                }),
+            ).toBe("inconclusive");
+        }
+        expect(
+            isPidIdentityPlausible(windowsRecord(RECORDED), {
+                startTime: null,
+                commandLine: null,
+                imageName: null,
+            }),
+        ).toBe("inconclusive");
+    });
+
+    test("an unreadable start time is resolved from the probed image when no evidence is passed", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: ((file: string | URL) => {
+                if (String(file) === "powershell") throw new Error("CIM unavailable");
+                return tasklistOutput([[15520, "svchost.exe"]]);
+            }) as typeof execFileSync,
+        });
+        expect(isPidIdentityPlausible(windowsRecord(RECORDED))).toBe("implausible");
+    });
+
+    test("a record without a start time is stale only when its image cannot be a host", () => {
+        expect(
+            isPidIdentityPlausible(windowsRecord(0), {
+                startTime: null,
+                commandLine: "dllhost.exe",
+                imageName: "dllhost.exe",
+            }),
+        ).toBe("implausible");
+        expect(
+            isPidIdentityPlausible(windowsRecord(0), {
+                startTime: null,
+                commandLine: "pi.exe",
+                imageName: "pi.exe",
+            }),
+        ).toBe("inconclusive");
+    });
+
+    test("host markers are matched in either the image name or the command line", () => {
+        expect(processCannotBeRpcHost({ commandLine: null, imageName: "Cherry Studio.exe" })).toBe(
+            true,
+        );
+        expect(
+            processCannotBeRpcHost({
+                commandLine: "C:\\Users\\a\\.bun\\bin\\omp.exe",
+                imageName: "unknown",
+            }),
+        ).toBe(false);
+        expect(
+            processCannotBeRpcHost({
+                commandLine: "/usr/bin/env node /opt/pi-coding-agent/dist/cli.js",
+            }),
+        ).toBe(false);
+        expect(processCannotBeRpcHost({ commandLine: "  ", imageName: null })).toBe(false);
     });
 });

package/src/shared/rpc-utils.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 
 import { log } from "./logger";
 import { PI_IMAGE_NAMES, piHarnessKindFromExecutable } from "./pi-executable";
+import { canonicalProjectDirectory } from "./project-directory-key";
 
 export type ProcessKind = "OpenCode server" | "OpenCode instance (TUI/CLI)" | "Pi" | "process";
 
@@ -14,6 +15,11 @@ export interface ProcessProbeEvidence {
     startTime: number | null;
     /** The raw command line, or null when the platform/probe cannot provide it. */
     commandLine: string | null;
+    /**
+     * The executable image name when the process list reports it separately
+     * from the command line (Windows CIM and tasklist), otherwise absent.
+     */
+    imageName?: string | null;
 }
 
 export interface RpcPortFileRecord {
@@ -68,8 +74,27 @@ export function isOwnRpcServerRecord(
 /**
  * Stable hash for a project directory — scopes RPC port files per-project
  * so multiple OpenCode instances don't collide.
+ *
+ * The server that writes a discovery file and the TUI that looks it up often
+ * receive the same directory spelled differently (macOS `/var` vs
+ * `/private/var`; on Windows drive-letter case, separators, a trailing
+ * separator, `\\?\` prefixes, 8.3 short names). Both hash the one canonical
+ * spelling from `canonicalProjectDirectory`, so any of those spellings finds the
+ * same file.
  */
 export function projectHash(directory: string): string {
+    return createHash("sha256")
+        .update(canonicalProjectDirectory(directory))
+        .digest("hex")
+        .slice(0, 16);
+}
+
+/**
+ * The hash builds up to 0.44.4 used: the spelling as given, minus trailing
+ * slashes. Lookups also read that directory so a TUI can still find an older
+ * server (and tell the user it is older).
+ */
+export function legacyProjectHash(directory: string): string {
     const normalized = directory.replace(/\/+$/, "");
     return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
 }
@@ -79,6 +104,16 @@ export function rpcPortDir(storageDir: string, directory: string): string {
     return join(storageDir, "rpc", projectHash(directory));
 }
 
+/**
+ * Every directory a lookup reads for this project: the canonical one servers
+ * write now, and the pre-canonical one older servers wrote.
+ */
+export function rpcPortDirsForLookup(storageDir: string, directory: string): string[] {
+    const canonical = rpcPortDir(storageDir, directory);
+    const legacy = join(storageDir, "rpc", legacyProjectHash(directory));
+    return legacy === canonical ? [canonical] : [canonical, legacy];
+}
+
 /** Per-process RPC port file path. */
 export function rpcPortFilePath(
     storageDir: string,
@@ -92,7 +127,7 @@ export function rpcPortFilePath(
 
 /** Legacy single-port file used by v0.18.0 and earlier. */
 export function legacyRpcPortFilePath(storageDir: string, directory: string): string {
-    return join(rpcPortDir(storageDir, directory), "port");
+    return join(storageDir, "rpc", legacyProjectHash(directory), "port");
 }
 
 export type PidLiveness = "alive" | "dead" | "inconclusive";
@@ -121,10 +156,21 @@ const WINDOWS_CIM_PROBE_TIMEOUT_MS = 5_000;
 const WINDOWS_PROCESS_SNAPSHOT_TTL_MS = 2_000;
 const MAX_ANCESTOR_WALK_DEPTH = 16;
 const OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
-const TASKLIST_NO_TASKS_PATTERN =
-    /^INFO:\s+No tasks are running which match the specified criteria\.?$/im;
+// CreationDate is formatted in the query as an ISO-8601 UTC string. Left as a
+// DateTime, ConvertTo-Json's output depends on the PowerShell edition (Windows
+// PowerShell 5.1 can emit `\/Date(ms)\/` or an object wrapping it; PowerShell 7
+// emits a local-offset string), and a start time the parser cannot read turns
+// every live RPC holder's identity check inconclusive.
 const WINDOWS_CIM_COMMAND =
-    "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine,CreationDate | ConvertTo-Json -Compress";
+    "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine,@{Name='CreationDate';Expression={if ($_.CreationDate) { $_.CreationDate.ToUniversalTime().ToString('o') } else { $null }}} | ConvertTo-Json -Compress";
+/**
+ * Output limit for process-list commands. A full Win32_Process listing with
+ * command lines routinely exceeds the 1 MiB `execFileSync` default (browser and
+ * editor processes carry very long command lines); past the limit the call
+ * throws ENOBUFS and the probe falls back to tasklist, which reports no start
+ * times.
+ */
+const PROCESS_LIST_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 const PI_HARNESS_ARC_MARKERS = [
     "pi-coding-agent",
     "oh-my-pi",
@@ -212,6 +258,12 @@ export function readProcessProbeEvidence(pid: number): ProcessProbeEvidence {
     };
 }
 
+function readCachedWindowsImageName(pid: number): string | null {
+    return rpcIdentityPlatform === "win32"
+        ? (windowsProcessFactsCache?.get(pid)?.imageName ?? null)
+        : null;
+}
+
 interface ProcessListEntry {
     pid: number;
     command: string;
@@ -270,34 +322,39 @@ function parseCsvLine(line: string): string[] | null {
     return fields;
 }
 
-function parseTasklistOutput(output: string): ProcessListEntry[] | null {
+export function parseTasklistOutput(output: string): ProcessListEntry[] | null {
     const entries: ProcessListEntry[] = [];
-    let sawHeader = false;
+
     for (const rawLine of output.split(/\r?\n/)) {
         const line = rawLine.trim();
         if (!line) continue;
-        if (TASKLIST_NO_TASKS_PATTERN.test(line)) return [];
+
         const fields = parseCsvLine(line);
         if (!fields) continue;
         if (fields[1]?.trim().toLowerCase() === "pid") {
-            sawHeader = true;
             continue;
         }
         const pid = Number(fields[1]);
         if (!Number.isInteger(pid) || pid <= 0 || !fields[0]) continue;
         entries.push({ pid, command: fields[0] });
     }
-    return entries.length > 0 || sawHeader ? entries : null;
+    // Successful tasklist commands return localized prose when no PID matches.
+    // Only CSV PID fields are evidence of a live process; failures are caught by the caller.
+    return entries;
 }
 
 function readWindowsProcess(pid: number): { state: PidLiveness; command?: string } {
     try {
-        const output = rpcIdentityExecFileSync("tasklist", ["/FO", "CSV", "/FI", `PID eq ${pid}`], {
-            encoding: "utf8",
-            timeout: PS_PROBE_TIMEOUT_MS,
-            stdio: ["ignore", "pipe", "pipe"],
-            windowsHide: true,
-        });
+        const output = rpcIdentityExecFileSync(
+            "tasklist",
+            ["/FO", "CSV", "/NH", "/FI", `PID eq ${pid}`],
+            {
+                encoding: "utf8",
+                timeout: PS_PROBE_TIMEOUT_MS,
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            },
+        );
         const entries = parseTasklistOutput(String(output));
         if (entries === null) return { state: "inconclusive" };
         const process = entries.find((entry) => entry.pid === pid);
@@ -417,6 +474,50 @@ function commandLooksLikeOpenCode(command: string): boolean {
     return OPEN_CODE_COMMAND_MARKERS.some((marker) => normalized.includes(marker));
 }
 
+/**
+ * Text found in the image name or command line of every process that can write
+ * an RPC discovery record: OpenCode (CLI, server, desktop app, the CLI bundled
+ * in OpenChamber), Pi and Oh My Pi, ck-mc, and the runtimes they run on. These
+ * are matched as substrings, so a renamed or wrapped launch still counts as a
+ * possible host. A false match only keeps a record, never deletes one.
+ */
+const RPC_HOST_PROCESS_MARKERS = [
+    "opencode",
+    "openchamber",
+    "ck-mc",
+    "magic-context",
+    "cortexkit",
+    "electron",
+    "node",
+    "bun",
+    "deno",
+    "pi-coding-agent",
+    "oh-my-pi",
+];
+
+/**
+ * Whether the process's image name or command line proves it cannot be a Magic
+ * Context host. Pi's image names (`pi`, `omp`) are too short to match as
+ * substrings, so they are compared as whole executable names. Missing evidence
+ * is never proof: with neither field readable this returns false.
+ */
+export function processCannotBeRpcHost(
+    evidence: Pick<ProcessProbeEvidence, "commandLine" | "imageName">,
+): boolean {
+    const texts = [evidence.imageName, evidence.commandLine].filter(
+        (text): text is string => typeof text === "string" && text.trim().length > 0,
+    );
+    if (texts.length === 0) return false;
+    for (const text of texts) {
+        const normalized = text.toLowerCase();
+        if (RPC_HOST_PROCESS_MARKERS.some((marker) => normalized.includes(marker))) return false;
+        const tokens = commandTokens(text);
+        if (commandHasPiExecutable(tokens)) return false;
+        if (tokens.some((token) => piHarnessKindFromExecutable(token) !== undefined)) return false;
+    }
+    return true;
+}
+
 /**
  * Verify that a live PID still belongs to the process that wrote a port record.
  *
@@ -426,6 +527,10 @@ function commandLooksLikeOpenCode(command: string): boolean {
  * database-open guard path. Legacy records without a start time use a weaker
  * command-name check. A failed filesystem or process probe is inconclusive,
  * not proof that this port record still belongs to OpenCode.
+ *
+ * "implausible" is returned only with proof that the live process did not write
+ * the record: it started after the record's `started_at`, or its image cannot
+ * be any Magic Context host. Callers may delete such a record on every platform.
  */
 export type PidIdentityPlausibility = "plausible" | "implausible" | "inconclusive";
 
@@ -437,10 +542,22 @@ export function isPidIdentityPlausible(
 
     if (Number.isFinite(record.started_at) && record.started_at > 0) {
         const processStartTime = evidence ? evidence.startTime : readProcessStartTime(record.pid);
-        if (processStartTime === null) return "inconclusive";
-        return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS
-            ? "plausible"
-            : "implausible";
+        if (processStartTime !== null) {
+            // A host writes `started_at` after it starts, so a process that started
+            // later than the record (beyond clock skew) cannot have written it: the
+            // PID was reused and the record is stale.
+            return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS
+                ? "plausible"
+                : "implausible";
+        }
+        // Some start times cannot be read at all (Windows service hosts such as
+        // svchost, when the query is not elevated). Then only an image that no host
+        // can run proves the PID was reused; anything else stays unknown.
+        const identity = evidence ?? {
+            commandLine: readProcessCommand(record.pid),
+            imageName: readCachedWindowsImageName(record.pid),
+        };
+        return processCannotBeRpcHost(identity) ? "implausible" : "inconclusive";
     }
 
     const command = evidence
@@ -451,7 +568,13 @@ export function isPidIdentityPlausible(
             ? (readWindowsProcess(record.pid).command ?? null)
             : readPsProcessCommand(record.pid);
     if (command === null) return "inconclusive";
-    return commandLooksLikeOpenCode(command) ? "plausible" : "implausible";
+    if (commandLooksLikeOpenCode(command)) return "plausible";
+    // A record without a start time carries only a PID. Its process is proven
+    // unrelated only when its image cannot be a host (Pi and OpenChamber, for
+    // example, do not match the OpenCode markers above).
+    return processCannotBeRpcHost({ commandLine: command, imageName: evidence?.imageName })
+        ? "implausible"
+        : "inconclusive";
 }
 
 export function __setRpcIdentityTestHooks(hooks: {
@@ -526,6 +649,7 @@ function execProcessList(
         exec(file, [...args], {
             encoding: "utf8",
             timeout,
+            maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES,
             stdio: ["ignore", "pipe", "pipe"],
             windowsHide: true,
         }),
@@ -533,6 +657,11 @@ function execProcessList(
 }
 
 function parseWindowsCreationDate(value: unknown): number | null {
+    // Windows PowerShell 5.1 can serialize a DateTime carrying extended
+    // properties as { value: "\/Date(ms)\/", DisplayHint, DateTime }.
+    if (value !== null && typeof value === "object" && "value" in value) {
+        return parseWindowsCreationDate((value as { value: unknown }).value);
+    }
     if (typeof value === "number" && Number.isFinite(value)) {
         return value > 1e12 ? value : value * 1_000;
     }
@@ -632,7 +761,11 @@ function tryReadWindowsCimSnapshot(exec: typeof execFileSync): ProcessSnapshot |
 
 function tryReadWindowsTasklistSnapshot(): ProcessSnapshot | null {
     try {
-        const output = execProcessList(rpcProcessListExecFileSync, "tasklist", ["/FO", "CSV"]);
+        const output = execProcessList(rpcProcessListExecFileSync, "tasklist", [
+            "/FO",
+            "CSV",
+            "/NH",
+        ]);
         const entries = parseTasklistOutput(output);
         if (entries === null) return null;
         const facts = entries.map((entry) => ({
@@ -873,6 +1006,15 @@ export interface AsyncProcessInspection {
     liveness(pid: number): PidLiveness;
 }
 
+/** Process evidence from one snapshot row; the image name is included only when known. */
+function snapshotEvidence(fact: ProcessFacts | undefined): ProcessProbeEvidence {
+    return {
+        startTime: fact?.startTime ?? null,
+        commandLine: fact?.commandLine ?? fact?.imageName ?? null,
+        ...(fact?.imageName ? { imageName: fact.imageName } : {}),
+    };
+}
+
 function execProcessListAsync(file: string, args: string[], timeout: number): Promise<string> {
     return new Promise((resolve, reject) => {
         execFile(
@@ -921,7 +1063,11 @@ export function inspectProcessesAsync(forceFresh = false): Promise<AsyncProcessI
                 }
                 if (!snapshot) {
                     const entries = parseTasklistOutput(
-                        await asyncProcessExec("tasklist", ["/FO", "CSV"], PS_PROBE_TIMEOUT_MS),
+                        await asyncProcessExec(
+                            "tasklist",
+                            ["/FO", "CSV", "/NH"],
+                            PS_PROBE_TIMEOUT_MS,
+                        ),
                     );
                     if (entries)
                         snapshot = snapshotFromFacts(
@@ -975,10 +1121,7 @@ export function inspectProcessesAsync(forceFresh = false): Promise<AsyncProcessI
             ...(fresh && snapshot
                 ? { processSnapshot: { source: snapshot.source, facts: snapshot.facts } }
                 : {}),
-            evidence: (pid: number) => ({
-                startTime: byPid.get(pid)?.startTime ?? null,
-                commandLine: byPid.get(pid)?.commandLine ?? byPid.get(pid)?.imageName ?? null,
-            }),
+            evidence: (pid: number) => snapshotEvidence(byPid.get(pid)),
             liveness: (pid: number) => (byPid.has(pid) ? "alive" : fresh ? "dead" : "inconclusive"),
         } satisfies AsyncProcessInspection;
     })().finally(() => {
@@ -986,3 +1129,18 @@ export function inspectProcessesAsync(forceFresh = false): Promise<AsyncProcessI
     });
     return asyncInspection;
 }
+
+/** Take one fresh Windows process snapshot with command time limits for synchronous callers. */
+export function inspectWindowsProcessesSync(): AsyncProcessInspection {
+    const snapshot =
+        tryReadWindowsCimSnapshot(rpcProcessListExecFileSync) ?? tryReadWindowsTasklistSnapshot();
+    const byPid = new Map(snapshot?.facts.map((fact) => [fact.pid, fact]));
+    return {
+        pi: snapshot ? classifyLivePiSnapshot(snapshot) : { state: "unreadable", processIds: [] },
+        ...(snapshot
+            ? { processSnapshot: { source: snapshot.source, facts: snapshot.facts } }
+            : {}),
+        evidence: (pid) => snapshotEvidence(byPid.get(pid)),
+        liveness: (pid) => (byPid.has(pid) ? "alive" : snapshot ? "dead" : "inconclusive"),
+    };
+}

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

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -9,10 +9,11 @@ import {
     withSqliteTransformPass,
 } from "./sqlite";
 import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
     test(`shared SQLite retries ${mode} acquisition before running any writes`, async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mc-routed-acquisition-"));
+        const dir = createTestTempDirFromPath(join(tmpdir(), "mc-routed-acquisition-"));
         const path = join(dir, "context.db");
         const db = new Database(path);
         db.exec(
@@ -75,7 +76,7 @@ test("routed transactions preserve nesting, receiver, arguments and rollback wit
 });
 
 test("exhausted routed acquisition never enters the callback or multiplies privileged retries", () => {
-    const dir = mkdtempSync(join(tmpdir(), "mc-routed-exhaustion-"));
+    const dir = createTestTempDirFromPath(join(tmpdir(), "mc-routed-exhaustion-"));
     const path = join(dir, "context.db");
     const blocker = new Database(path);
     const db = new Database(path);
@@ -100,3 +101,45 @@ test("exhausted routed acquisition never enters the callback or multiplies privi
         rmSync(dir, { recursive: true, force: true });
     }
 });
+
+for (const mode of ["run", "get", "all", "exec"] as const) {
+    test(`foreground ${mode} autocommit waits share one turn budget and restore production timeout`, () => {
+        const dir = createTestTempDirFromPath(join(tmpdir(), "mc-autocommit-budget-"));
+        const path = join(dir, "context.db");
+        const db = new Database(path);
+        db.exec(
+            "PRAGMA journal_mode=WAL; CREATE TABLE result(value TEXT); PRAGMA busy_timeout=5000",
+        );
+        const blocker = new Database(path);
+        blocker.exec("BEGIN IMMEDIATE");
+        try {
+            const started = performance.now();
+            withSqliteTransformPass(() => {
+                for (let attempt = 0; attempt < 3; attempt++) {
+                    // Nested foreground wrappers must reuse the turn's remaining budget.
+                    expect(() =>
+                        withSqliteTransformPass(() => {
+                            if (mode === "exec") db.exec("INSERT INTO result VALUES ('blocked')");
+                            else
+                                db.prepare("INSERT INTO result VALUES ('blocked') RETURNING value")[
+                                    mode
+                                ]();
+                        }),
+                    ).toThrow("acquisition remained busy");
+                }
+                expect(() => db.exec("BEGIN IMMEDIATE")).toThrow("acquisition remained busy");
+            });
+            expect(performance.now() - started).toBeLessThan(650);
+            expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
+            expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
+            blocker.exec("ROLLBACK");
+            withSqliteTransformPass(() => db.prepare("INSERT INTO result VALUES ('free')").run());
+            expect(db.prepare("SELECT * FROM result").all()).toEqual([{ value: "free" }]);
+        } finally {
+            if (blocker.inTransaction) blocker.exec("ROLLBACK");
+            blocker.close();
+            db.close();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+}

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

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -13,9 +13,10 @@ import {
     withSqliteTransformPass,
 } from "./sqlite";
 import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 function fixture() {
-    const dir = mkdtempSync(join(tmpdir(), "mc-busy-yield-"));
+    const dir = createTestTempDirFromPath(join(tmpdir(), "mc-busy-yield-"));
     const path = join(dir, "context.db");
     const db = new Database(path);
     db.exec(