@cortexkit/opencode-magic-context 0.49.35 → 0.49.37

package/dist/v2/{server-bpvsvtph.js → server-xfjjbrkt.js}

@@ -2554,7 +2554,9 @@ function getAllStatusTagTokenTotalsFlat2(db, sessionId, floor = 0, calibration =
                        FROM tags
                        WHERE session_id = ?`).all(sessionId);
   const totals = new Map;
+  const summaryRemovedTotals = new Map;
   const nullMessageIds = new Set;
+  const nullSummaryRemovedMessageIds = new Set;
   for (const row of rows) {
     if (row.type === "tool" && row.tool_owner_message_id === null)
       continue;
@@ -2564,6 +2566,7 @@ function getAllStatusTagTokenTotalsFlat2(db, sessionId, floor = 0, calibration =
     if (row.token_count === null) {
       nullMessageIds.add(owner);
       totals.delete(owner);
+      summaryRemovedTotals.delete(owner);
       continue;
     }
     if (nullMessageIds.has(owner))
@@ -2571,8 +2574,16 @@ function getAllStatusTagTokenTotalsFlat2(db, sessionId, floor = 0, calibration =
     const ratio = row.type === "tool" ? calibration.toolsRatio : calibration.proseRatio;
     const weight = ((row.token_count ?? 0) + (row.input_token_count ?? 0)) * ratio + (row.reasoning_token_count ?? 0) * calibration.proseRatio;
     totals.set(owner, (totals.get(owner) ?? 0) + weight);
+    if (row.type === "tool" && row.input_token_count === null) {
+      nullSummaryRemovedMessageIds.add(owner);
+      summaryRemovedTotals.delete(owner);
+    }
+    if (!nullSummaryRemovedMessageIds.has(owner)) {
+      const removedWeight = row.type === "tool" ? (row.input_token_count ?? 0) * calibration.toolsRatio : row.type === "message" ? row.token_count * calibration.proseRatio : 0;
+      summaryRemovedTotals.set(owner, (summaryRemovedTotals.get(owner) ?? 0) + removedWeight);
+    }
   }
-  return { totals, nullMessageIds };
+  return { totals, summaryRemovedTotals, nullMessageIds };
 }
 function getReasoningTokenEstimatesByMessage2(db, sessionId, proseRatio) {
   const summary = readTagOwnerSummary(db, sessionId, proseRatio);

package/dist/v2/server.js

@@ -1,6 +1,6 @@
 import {
   loadPluginConfigDetailed
-} from "./server-9k0mjef7.js";
+} from "./server-avdveykk.js";
 import {
   setHarness2
 } from "./server-pavzsdc6.js";
@@ -22,7 +22,7 @@ import {
   union,
   tuple,
   record
-} from "./server-24g8r2d0.js";
+} from "./server-7zacmty5.js";
 import {
   pushNotification2
 } from "./server-x8a7jmkh.js";
@@ -7875,7 +7875,7 @@ var require_src2 = __commonJS(function(exports, module) {
 // package.json
 var package_default = {
   name: "@cortexkit/opencode-magic-context",
-  version: "0.49.35",
+  version: "0.49.37",
   type: "module",
   description: "OpenCode plugin for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -8196,7 +8196,7 @@ async function setup(context) {
   if (claimStorageBackupWarningCheck() && isMagicContextStorageOutsideEngram(storageDir)) {
     log2(`[magic-context] Magic Context storage is at ${storageDir}, outside the folder Engram backs up (~/.local/share/cortexkit/magic-context). It is not included in CortexKit backups.`);
   }
-  const { registerContext } = await import("./context-znqfkap4.js");
+  const { registerContext } = await import("./context-05x7kr7f.js");
   setHarness2("opencode2");
   bindStaleBuildNotice({}, import.meta.url, "opencode2");
   const duties = await registerContext(context);

package/dist/v2/{storage-tags-19s0ebf0.js → storage-tags-cw07ky67.js}

@@ -63,7 +63,7 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-bpvsvtph.js";
+} from "./server-xfjjbrkt.js";
 import"./server-1zx87sdm.js";
 import"./server-tpt7bwq8.js";
 import"./server-969cdpmg.js";

package/dist/v2/{store-vdm8v3jd.js → store-z3qe67cg.js}

@@ -5,7 +5,7 @@ import {
   readV2RawMessagePagesForConversion2,
   createV2RawMessageReader2,
   createV2RawMessageProvider2
-} from "./server-5jp38p98.js";
+} from "./server-6emy0v9a.js";
 import"./server-ef1mskas.js";
 import"./server-468mya5v.js";
 import"./server-2ra6pwf3.js";

package/dist/v2/{v2-archive-reader-t2c0eypn.js → v2-archive-reader-z7wr42ry.js}

@@ -1,10 +1,10 @@
 import {
   readV2ArchiveOffThread2,
   serveV2ArchiveReads2
-} from "./server-x4m6xcn4.js";
-import"./server-51779zs2.js";
+} from "./server-e51xmr4d.js";
+import"./server-v0p37hm2.js";
 import"./server-gzy5w8ya.js";
-import"./server-cpjk5jd2.js";
+import"./server-1d042x6w.js";
 export {
   readV2ArchiveOffThread2 as readV2ArchiveOffThread,
   serveV2ArchiveReads2 as serveV2ArchiveReads

package/dist/v2/{wrapup-orchestrator-aqpqsveg.js → wrapup-orchestrator-j1v62bkj.js}

@@ -11,19 +11,20 @@ import {
   releaseCompartmentLeaseBestEffort,
   getCompartments,
   getLastCompartmentEndMessage
-} from "./server-qf2kzsh2.js";
+} from "./server-t8y64xj7.js";
 import"./server-2amn2s73.js";
 import"./server-969cdpmg.js";
 import"./server-zzgtgqmd.js";
 import {
   inRootAsyncContext2
 } from "./server-gzy5w8ya.js";
-import"./server-51779zs2.js";
-import"./server-cpjk5jd2.js";
-import"./server-s9xgyyj9.js";
-import"./server-ws5exe6q.js";
-import"./server-hsf0qsn5.js";
-import"./server-r3chnxs5.js";
+import"./server-v0p37hm2.js";
+import"./server-96ztjvkn.js";
+import"./server-1d042x6w.js";
+import"./server-tnzbk64q.js";
+import"./server-nmyganc8.js";
+import"./server-cp1a03vc.js";
+import"./server-dfq5vb8j.js";
 import {
   getWrapupInProgressState,
   acquireWrapupInProgress,
@@ -32,12 +33,12 @@ import {
   getHistorianFailureState,
   clearEmergencyRecovery,
   prepareRawSessionOrdinals2
-} from "./server-1xesqm5h.js";
+} from "./server-jd7vzwn4.js";
 import"./server-tpt7bwq8.js";
-import"./server-7ccxt4nq.js";
+import"./server-g3gqq4ac.js";
 import"./server-1zx87sdm.js";
-import"./server-bpvsvtph.js";
-import"./server-24g8r2d0.js";
+import"./server-xfjjbrkt.js";
+import"./server-7zacmty5.js";
 import"./server-2ra6pwf3.js";
 import"./server-mfn1yf9d.js";
 import"./server-xy7w7hrd.js";
@@ -51,7 +52,7 @@ import"./server-ypf1ap0v.js";
 import {
   pushNotification2
 } from "./server-x8a7jmkh.js";
-import"./server-xbtw0p9t.js";
+import"./server-r4430x9m.js";
 import {
   describeBoundaryDiagnostics,
   resolveWrapupProtectedTailBoundary,
@@ -62,16 +63,16 @@ import {
   registerActiveCompartmentRun,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-fqj6ddpr.js";
+} from "./server-5by3vdzs.js";
 import"./server-qt1qqasc.js";
-import"./server-bxpz2dcn.js";
+import"./server-7acq7815.js";
 import"./server-dcws5831.js";
 import"./server-4dhv7mqz.js";
-import"./server-rktnzs89.js";
-import"./server-kkxzwa6w.js";
+import"./server-6vzh6wej.js";
+import"./server-gkse1wyz.js";
 import"./server-jjvbk92s.js";
-import"./server-q0z2q2dx.js";
-import"./server-9k0mjef7.js";
+import"./server-nq3cb7be.js";
+import"./server-avdveykk.js";
 import"./server-qxzbmtqt.js";
 import"./server-sd8hvzte.js";
 import"./server-f0j864ma.js";

package/dist/{v2-archive-reader-tm2eayp2.js → v2-archive-reader-028z6kck.js}

@@ -1,10 +1,10 @@
 import {
   readV2ArchiveOffThread2,
   serveV2ArchiveReads2
-} from "./index-dy7w6wm4.js";
+} from "./index-prw8apnc.js";
 import"./index-v0p37hm2.js";
 import"./index-gzy5w8ya.js";
-import"./index-cpjk5jd2.js";
+import"./index-1d042x6w.js";
 export {
   readV2ArchiveOffThread2 as readV2ArchiveOffThread,
   serveV2ArchiveReads2 as serveV2ArchiveReads

package/dist/{wrapup-orchestrator-k5yp19a6.js → wrapup-orchestrator-xg9avt2p.js}

@@ -1,45 +1,46 @@
 import {
   runManagedWrapup2
-} from "./index-xwwsbsd3.js";
-import"./index-3d3872c6.js";
-import"./index-4bgk5ztz.js";
-import"./index-f9b3vtt1.js";
+} from "./index-pp8vdn01.js";
+import"./index-ys7j6679.js";
+import"./index-9tdvbdv1.js";
+import"./index-850vthn3.js";
 import"./index-sd3egckz.js";
-import"./index-0c7p8mq5.js";
-import"./index-pswsyf1w.js";
+import"./index-xnm0wq1r.js";
+import"./index-ty4vhe4n.js";
 import"./index-jjvbk92s.js";
-import"./index-jn0ddrhp.js";
+import"./index-21fgrfrf.js";
 import"./index-4dhv7mqz.js";
-import"./index-f297z1n8.js";
+import"./index-72czy45z.js";
 import"./index-2qbtqg1w.js";
-import"./index-pq0dpwrc.js";
+import"./index-2rs7912w.js";
 import"./index-2amn2s73.js";
 import"./index-66a50f3e.js";
 import"./index-dnqqqc5f.js";
-import"./index-2v6nvy3k.js";
+import"./index-ae1ar4v1.js";
 import"./index-qt1qqasc.js";
-import"./index-brg2w6qc.js";
-import"./index-ksv0a31x.js";
+import"./index-tn9drm1a.js";
+import"./index-8jjjmhab.js";
 import"./index-1zx87sdm.js";
-import"./index-pztqab6k.js";
+import"./index-vd2ywmfe.js";
 import"./index-x8a7jmkh.js";
 import"./index-fw42ms3m.js";
-import"./index-1rhgxqs8.js";
-import"./index-nxrsns5x.js";
+import"./index-xd2p95m7.js";
+import"./index-c5dzns43.js";
 import"./index-jz5bk7xd.js";
-import"./index-zhqwda72.js";
+import"./index-dcjkw41m.js";
 import"./index-g4t7850m.js";
-import"./index-gyaa159j.js";
+import"./index-9fgmkfaf.js";
 import"./index-fb3zxn06.js";
 import"./index-nj360hcs.js";
 import"./index-fr0wbhdn.js";
 import"./index-txs8tce6.js";
-import"./index-faxb7mck.js";
+import"./index-b1ydbp95.js";
 import"./index-wh9fxds5.js";
 import"./index-2p37txes.js";
 import"./index-jkanybgq.js";
 import"./index-9wnbnx8f.js";
-import"./index-qncw9hey.js";
+import"./index-r2epb000.js";
+import"./index-96ztjvkn.js";
 import"./index-v0p37hm2.js";
 import"./index-58e3y90n.js";
 import"./index-fxbk7gk3.js";
@@ -49,7 +50,7 @@ import"./index-jrfre9ah.js";
 import"./index-g2q4htwp.js";
 import"./index-pavzsdc6.js";
 import"./index-z4p0ry94.js";
-import"./index-cpjk5jd2.js";
+import"./index-1d042x6w.js";
 export {
   runManagedWrapup2 as runManagedWrapup
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.49.35",
+  "version": "0.49.37",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/shared/model-suggestion-retry.ts

@@ -429,7 +429,7 @@ async function promptWithTimeout(
  * instance-scoped fiber that `POST /session/{id}/abort` interrupts. Best-effort —
  * a failure here must not mask the original timeout/abort error.
  */
-async function abortChildRun(client: Client, sessionId: string): Promise<void> {
+export async function abortChildRun(client: Client, sessionId: string): Promise<void> {
     if (!client) return;
     try {
         // Bound the abort call: it's best-effort cleanup, and if the abort

package/src/shared/prompt-async-transport.test.ts

@@ -17,7 +17,7 @@ type Message = {
         finish?: string;
         error?: unknown;
     };
-    parts: Array<{ type: string; text?: string }>;
+    parts: Array<{ type: string; text?: string; error?: unknown }>;
 };
 
 /**
@@ -165,6 +165,42 @@ describe("promptAsyncAndWaitForIdle", () => {
         ).rejects.toThrow("did not start a run");
     });
 
+    test("ignores provider errors and retry parts from before the current send", async () => {
+        const host = asyncHost({
+            plan: ["busy", "settle"],
+            initialMessages: [
+                {
+                    info: {
+                        id: "old-error",
+                        role: "assistant",
+                        time: { created: 0 },
+                        error: { name: "APIError" },
+                    },
+                    parts: [{ type: "retry", error: { name: "APIError" } }],
+                },
+            ],
+        });
+        await promptAsyncAndWaitForIdle(host.client, request(), { pollIntervalMs: 1 });
+        expect(host.polls()).toBe(2);
+        expect(host.abort).not.toHaveBeenCalled();
+    });
+
+    test("accepts a successfully settled assistant that retains an earlier retry part", async () => {
+        const host = asyncHost({ plan: ["settle"] });
+        const read = host.list.getMockImplementation()!;
+        host.list.mockImplementation(async () => {
+            const result = await read();
+            const last = result.data.at(-1);
+            if (last?.info.finish === "stop") {
+                last.parts.push({ type: "retry", error: { name: "APIError" } });
+            }
+            return result;
+        });
+        await promptAsyncAndWaitForIdle(host.client, request(), { pollIntervalMs: 1 });
+        expect(host.polls()).toBe(1);
+        expect(host.abort).not.toHaveBeenCalled();
+    });
+
     test("surfaces a rejected prompt_async request", async () => {
         const host = asyncHost({ plan: ["settle"] });
         host.promptAsync.mockImplementation(async () => ({
@@ -653,9 +689,11 @@ describe("prompt_async transport and the first-output deadline", () => {
      * busy forever; "partial" streams a text part and then stays busy; "answer"
      * settles with a final assistant message on the next poll.
      */
-    function modelHost(behaviours: Record<string, "dead" | "partial" | "answer">) {
+    function modelHost(
+        behaviours: Record<string, "dead" | "partial" | "answer" | "error" | "retry">,
+    ) {
         const messages: Message[] = [];
-        let current: "dead" | "partial" | "answer" | null = null;
+        let current: "dead" | "partial" | "answer" | "error" | "retry" | null = null;
         const sent: string[] = [];
         const promptAsync = mock(
             async (request: { body: { model?: { providerID: string; modelID: string } } }) => {
@@ -684,6 +722,16 @@ describe("prompt_async transport and the first-output deadline", () => {
             return { data: true };
         });
         const status = mock(async () => {
+            if (current === "error" || current === "retry") {
+                const last = messages.at(-1)!;
+                const error = {
+                    name: "APIError",
+                    data: { statusCode: 429, message: "Free usage limit reached" },
+                };
+                if (current === "error") last.info.error = error;
+                else last.parts = [{ type: "retry", error }];
+                return { data: { "ses-child": { type: current === "retry" ? "retry" : "busy" } } };
+            }
             if (current === "dead" || current === "partial")
                 return { data: { "ses-child": { type: "busy" } } };
             if (current === "answer") {
@@ -751,4 +799,17 @@ describe("prompt_async transport and the first-output deadline", () => {
         await expect(runChain(host, 200, 40)).rejects.toThrow("prompt timed out after 200ms");
         expect(host.sent).toEqual(["opencode/free-model"]);
     });
+
+    for (const failure of ["error", "retry"] as const) {
+        test(`a recorded provider ${failure} stops the host retry loop and immediately tries the fallback`, async () => {
+            const host = modelHost({ "opencode/free-model": failure });
+            const startedAt = Date.now();
+            const result = await runChain(host, 5_000, 5_000);
+            expect(result.attempt.label).toBe("anthropic/claude-sonnet-5-5");
+            expect(host.sent).toEqual(["opencode/free-model", "anthropic/claude-sonnet-5-5"]);
+            expect(host.abort).toHaveBeenCalledTimes(1);
+            expect(host.abort).toHaveBeenCalledWith({ path: { id: "ses-child" } });
+            expect(Date.now() - startedAt).toBeLessThan(2_000);
+        });
+    }
 });

package/src/shared/prompt-async-transport.ts

@@ -14,7 +14,11 @@ import {
 import { describeAssistantError } from "./assistant-message-extractor";
 import { sessionLog } from "./logger";
 import type { PromptArgs, PromptTransport } from "./model-suggestion-retry";
-import { noteModelActivityMonitored, noteModelOutputReceived } from "./model-suggestion-retry";
+import {
+    abortChildRun,
+    noteModelActivityMonitored,
+    noteModelOutputReceived,
+} from "./model-suggestion-retry";
 
 type Client = ReturnType<typeof createOpencodeClient> | undefined;
 
@@ -196,6 +200,28 @@ function messageId(message: unknown): string | null {
     return typeof id === "string" ? id : null;
 }
 
+function recordedAssistantError(message: unknown): unknown {
+    const info = infoOf(message);
+    if (info.error != null) return info.error;
+    // A completed step can retain retry parts from a provider attempt that
+    // already recovered before this poll. Its successful settlement wins.
+    if (isSettledAssistant(message)) return undefined;
+    const parts = (message as { parts?: unknown[] } | null)?.parts;
+    if (!Array.isArray(parts)) return undefined;
+    // OpenCode records a failed provider attempt as a retry part before it
+    // settles the assistant row or emits session.error.
+    const retry = parts
+        .slice()
+        .reverse()
+        .find(
+            (part) =>
+                part !== null &&
+                typeof part === "object" &&
+                (part as { type?: unknown }).type === "retry",
+        ) as { error?: unknown } | undefined;
+    return retry?.error ?? undefined;
+}
+
 /** An assistant message the host has finished writing, successfully or not. */
 function isSettledAssistant(message: unknown): boolean {
     const info = infoOf(message);
@@ -355,6 +381,26 @@ export async function promptAsyncAndWaitForIdle(
     // Dispatch can fail before an assistant row exists. The plugin event hook
     // retains that provider/model error while this child is actively awaited.
     activeSessionErrors.set(sessionId, undefined);
+    const failForHostError = async (hostError: unknown): Promise<never> => {
+        // Stop the host's retry loop before handing the attempt to our model
+        // chain; otherwise the failed model keeps making requests in parallel.
+        await abortChildRun(client, sessionId);
+        const error = new Error(
+            `Host recorded session error: ${describeAssistantError(hostError)}`,
+        );
+        Object.assign(error, {
+            name: "DreamerProviderOutputFailureError",
+            transient: true,
+            [HOST_SESSION_ERROR]: true,
+            hostError,
+        });
+        annotateSubagentInvocationError(error, {
+            attemptedModel: requestModelRef(request),
+            modelConfigKey: options.modelConfigKey,
+            hostError,
+        });
+        throw error;
+    };
     try {
         let sent: unknown;
         try {
@@ -395,24 +441,23 @@ export async function promptAsyncAndWaitForIdle(
             await sleep(pollIntervalMs, signal);
             const hostError = activeSessionErrors.get(sessionId);
             if (hostError !== undefined) {
-                const error = new Error(
-                    `Host recorded session error: ${describeAssistantError(hostError)}`,
-                );
-                Object.assign(error, {
-                    name: "DreamerProviderOutputFailureError",
-                    transient: true,
-                    [HOST_SESSION_ERROR]: true,
-                    hostError,
-                });
-                annotateSubagentInvocationError(error, {
-                    attemptedModel: requestModelRef(request),
-                    modelConfigKey: options.modelConfigKey,
-                    hostError,
-                });
-                throw error;
+                await failForHostError(hostError);
             }
             const status = await readStatus(session, sessionId, dir, signal);
             const messages = await readMessages(session, sessionId, dir, signal);
+            const latestAssistant = messages
+                .slice()
+                .reverse()
+                .find((message) => {
+                    const id = messageId(message);
+                    return (
+                        id !== null &&
+                        !completionBaseline.has(id) &&
+                        infoOf(message).role === "assistant"
+                    );
+                });
+            const assistantError = recordedAssistantError(latestAssistant);
+            if (assistantError !== undefined) await failForHostError(assistantError);
             if (
                 !sawOutput &&
                 messages.some((message) => {

package/src/shared/reusable-worker-entry.ts

@@ -0,0 +1,58 @@
+import { EventEmitter } from "node:events";
+import { type MessagePort, parentPort, workerData } from "node:worker_threads";
+
+/** Dispatch each job with new per-job state and a port whose messages are matched by job id. */
+export function serveWorkerJobs<T>(
+    run: (data: T, port: MessagePort) => Promise<void> | void,
+    autoClose = true,
+): void {
+    if (!parentPort) throw new Error("worker requires a parent port");
+    const parent = parentPort;
+    if (!workerData?.reusableWorker) {
+        void Promise.resolve(run(workerData, parent)).catch(rethrow);
+        return;
+    }
+    let active: { id: number; port: EventEmitter } | undefined;
+    parent.on("message", (message: { jobId: number; start?: T; value?: unknown }) => {
+        if (!("start" in message)) {
+            if (active?.id === message.jobId) active.port.emit("message", message.value);
+            return;
+        }
+        if (active) throw new Error("reusable worker received overlapping jobs");
+        const id = message.jobId;
+        let closed = false;
+        const port = Object.assign(new EventEmitter(), {
+            postMessage(value: unknown, transferList?: readonly object[]) {
+                if (!closed) parent.postMessage({ jobId: id, value }, transferList as never);
+            },
+            close() {
+                if (closed) return;
+                closed = true;
+                port.removeAllListeners();
+                active = undefined;
+                parent.postMessage({
+                    jobId: id,
+                    finished: true,
+                    code: Number(process.exitCode) || 0,
+                });
+            },
+        });
+        active = { id, port };
+        try {
+            void Promise.resolve(run(message.start as T, port as unknown as MessagePort))
+                .then(() => {
+                    if (autoClose) port.close();
+                })
+                .catch(rethrow);
+        } catch (error) {
+            rethrow(error);
+        }
+    });
+}
+
+function rethrow(error: unknown): void {
+    // Bun 1.3 aborts the host for a microtask throw; a timer reports a Worker error.
+    setTimeout(() => {
+        throw error;
+    });
+}

package/src/shared/reusable-worker-reset.test.ts

@@ -0,0 +1,108 @@
+import { expect, spyOn, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { once } from "node:events";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as timers from "node:timers";
+import { fileURLToPath } from "node:url";
+import { resetReusableWorkersForTests, reuseWorker } from "./reusable-worker";
+import { withTestTempDir } from "./test-temp-dir";
+
+test("a temporary caller clock cannot replace the pool's idle timer", async () => {
+    const clock = spyOn(globalThis, "setTimeout").mockReturnValue(
+        0 as unknown as ReturnType<typeof setTimeout>,
+    );
+    try {
+        const worker = reuseWorker(new URL("./reusable-worker.fixture.ts", import.meta.url), {
+            workerData: { path: "caller-clock" },
+        });
+        const message = once(worker, "message");
+        const exit = once(worker, "exit");
+        await message;
+        await exit;
+        expect(clock).not.toHaveBeenCalled();
+    } finally {
+        clock.mockRestore();
+        await resetReusableWorkersForTests();
+    }
+});
+
+test("reset clears idle timers and waits for active and queued leases to exit", async () => {
+    const entry = new URL("./reusable-worker.fixture.ts", import.meta.url);
+    const schedules = spyOn(timers, "setTimeout");
+    const cancellations = spyOn(timers, "clearTimeout");
+    const idleMs = 12_345;
+    async function runIdle() {
+        const worker = reuseWorker(entry, { workerData: { path: "reset-idle" } }, idleMs);
+        const message = once(worker, "message");
+        const exit = once(worker, "exit");
+        const [reply] = await message;
+        await exit;
+        return reply.threadId as number;
+    }
+    try {
+        const previousThread = await runIdle();
+        const timerIndex = schedules.mock.calls.findIndex(([, delay]) => delay === idleMs);
+        expect(timerIndex).toBeGreaterThanOrEqual(0);
+        const idleTimer = schedules.mock.results[timerIndex]?.value;
+        const active = reuseWorker(entry, { workerData: { path: "reset-active", hang: true } });
+        const queued = reuseWorker(entry, {
+            workerData: { path: "reset-active", value: "queued" },
+        });
+        const replies: unknown[] = [];
+        queued.on("message", (message) => replies.push(message));
+        const activeExit = once(active, "exit");
+        const queuedExit = once(queued, "exit");
+        await Promise.resolve();
+        await Promise.all([resetReusableWorkersForTests(), activeExit, queuedExit]);
+        expect(cancellations).toHaveBeenCalledWith(idleTimer);
+        expect(replies).toEqual([]);
+        expect(await runIdle()).not.toBe(previousThread);
+    } finally {
+        schedules.mockRestore();
+        cancellations.mockRestore();
+        await resetReusableWorkersForTests();
+    }
+});
+
+test("the shared preload stops pooled workers between test cases", () => {
+    withTestTempDir("reusable-worker-boundaries-", (dir) => {
+        writeFileSync(
+            join(dir, "boundaries.test.ts"),
+            `import { expect, test } from "bun:test";
+import { once } from "node:events";
+import { reuseWorker } from ${JSON.stringify(new URL("./reusable-worker.ts", import.meta.url).href)};
+const entry = new URL(${JSON.stringify(new URL("./reusable-worker.fixture.ts", import.meta.url).href)});
+let previousThread;
+async function run() {
+    const worker = reuseWorker(entry, { workerData: { path: "test-boundaries" } });
+    const message = once(worker, "message");
+    const exit = once(worker, "exit");
+    const [reply] = await message;
+    await exit;
+    return reply.threadId;
+}
+test("finishes with an idle pooled worker", async () => {
+    previousThread = await run();
+    expect(previousThread).toBeGreaterThan(0);
+});
+test("cannot inherit the previous test's pooled worker", async () => {
+    expect(await run()).not.toBe(previousThread);
+});`,
+        );
+        const child = spawnSync(
+            process.execPath,
+            [
+                "test",
+                "--preload",
+                fileURLToPath(new URL("../../test-preload.ts", import.meta.url)),
+                join(dir, "boundaries.test.ts"),
+            ],
+            { cwd: dir, encoding: "utf8", timeout: 5_000, windowsHide: true },
+        );
+        const output = child.stdout + child.stderr;
+        expect(output).toContain("2 pass");
+        expect(output).toContain("0 fail");
+        expect(child.status).toBe(0);
+    });
+}, 10_000);