@cortexkit/opencode-magic-context 0.49.19 → 0.49.20

package/src/shared/model-resolution.test.ts

@@ -118,12 +118,22 @@ describe("model-resolution", () => {
         // Inheritance is deliberately absent because a fallback model may not support the
         // qualifier selected for the primary model.
         expect(resolveHistorianModel(config, "opencode")).toEqual({
-            primary: { model: "open/primary", qualifier: "primary-only" },
-            fallbacks: [{ model: "open/fallback" }],
+            primary: {
+                model: "open/primary",
+                qualifier: "primary-only",
+                sourceConfigKey: "historian.opencode.model",
+            },
+            fallbacks: [
+                { model: "open/fallback", sourceConfigKey: "historian.opencode.fallback_models" },
+            ],
         });
         expect(resolveHistorianModel(config, "pi")).toEqual({
-            primary: { model: "pi/primary", qualifier: "high" },
-            fallbacks: [{ model: "pi/fallback" }],
+            primary: {
+                model: "pi/primary",
+                qualifier: "high",
+                sourceConfigKey: "historian.pi.model",
+            },
+            fallbacks: [{ model: "pi/fallback", sourceConfigKey: "historian.pi.fallback_models" }],
         });
     });
 
@@ -143,12 +153,32 @@ describe("model-resolution", () => {
         };
 
         expect(resolveHistorianModel(config, "opencode")).toEqual({
-            primary: { model: "open/code", qualifier: "oc-primary" },
-            fallbacks: [{ model: "open/fallback", qualifier: "oc-fallback" }],
+            primary: {
+                model: "open/code",
+                qualifier: "oc-primary",
+                sourceConfigKey: "historian.opencode.model",
+            },
+            fallbacks: [
+                {
+                    model: "open/fallback",
+                    qualifier: "oc-fallback",
+                    sourceConfigKey: "historian.opencode.fallback_models",
+                },
+            ],
         });
         expect(resolveHistorianModel(config, "pi")).toEqual({
-            primary: { model: "pi/model", qualifier: "high" },
-            fallbacks: [{ model: "pi/fallback", qualifier: "max" }],
+            primary: {
+                model: "pi/model",
+                qualifier: "high",
+                sourceConfigKey: "historian.pi.model",
+            },
+            fallbacks: [
+                {
+                    model: "pi/fallback",
+                    qualifier: "max",
+                    sourceConfigKey: "historian.pi.fallback_models",
+                },
+            ],
         });
     });
 
@@ -182,8 +212,18 @@ describe("model-resolution", () => {
         };
 
         expect(resolveHistorianModel(configured, "omp")).toEqual({
-            primary: { model: "omp/historian", qualifier: "auto" },
-            fallbacks: [{ model: "omp/historian-fallback", qualifier: "max" }],
+            primary: {
+                model: "omp/historian",
+                qualifier: "auto",
+                sourceConfigKey: "historian.omp.model",
+            },
+            fallbacks: [
+                {
+                    model: "omp/historian-fallback",
+                    qualifier: "max",
+                    sourceConfigKey: "historian.omp.fallback_models",
+                },
+            ],
         });
         expect(
             resolveDreamerTaskModel({ config: configured, harness: "omp", task: "verify" }),
@@ -197,6 +237,7 @@ describe("model-resolution", () => {
         expect(resolveHistorianModel(piFallback, "omp")?.primary).toEqual({
             model: "pi/historian",
             qualifier: "high",
+            sourceConfigKey: "historian.pi.model",
         });
         expect(
             resolveDreamerTaskModel({ config: piFallback, harness: "omp", task: "verify" }),
@@ -245,8 +286,22 @@ describe("model-resolution", () => {
         };
 
         expect(resolveDreamerTaskModel({ config, harness: "opencode", task: "curate" })).toEqual({
-            primary: { model: "open/task", qualifier: "task-variant" },
-            fallbacks: [{ model: "open/bare" }, { model: "open/qualified", qualifier: "fb" }],
+            primary: {
+                model: "open/task",
+                qualifier: "task-variant",
+                sourceConfigKey: "dreamer.opencode.tasks.curate.model",
+            },
+            fallbacks: [
+                {
+                    model: "open/bare",
+                    sourceConfigKey: "dreamer.opencode.tasks.curate.fallback_models",
+                },
+                {
+                    model: "open/qualified",
+                    qualifier: "fb",
+                    sourceConfigKey: "dreamer.opencode.tasks.curate.fallback_models",
+                },
+            ],
             schedule: "0 4 * * *",
             timeoutMinutes: 12,
             promotionThreshold: 3,

package/src/shared/model-resolution.ts

@@ -5,6 +5,8 @@ export interface ResolvedModelEntry {
     model: string;
     /** OpenCode variant or Pi thinking level, selected for the active entry only. */
     qualifier?: string;
+    /** Config location that supplied this attempt, for accurate failure diagnostics. */
+    sourceConfigKey?: string;
 }
 
 export type ModelInput = string | ResolvedModelEntry;
@@ -35,6 +37,10 @@ function resolveHarnessBlock(
     return asRecord(selected);
 }
 
+function sourceHarness(container: ConfigRecord | undefined, harness: ModelHarness): ModelHarness {
+    return harness === "omp" && container?.omp == null ? "pi" : harness;
+}
+
 /**
  * Collapses the string and object spellings of a harness model entry into the
  * same model identity. Qualifiers stay separate because they alter an attempt,
@@ -116,14 +122,20 @@ export function resolveHistorianModel(
     const historian = asRecord(asRecord(config)?.historian);
     const block = resolveHarnessBlock(historian, harness);
     if (!block) return { fallbacks: [] };
+    const source = `historian.${sourceHarness(historian, harness)}`;
+    const primary = resolvePrimaryEntry({
+        entry: block.model,
+        defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+        harness,
+    });
+    const fallbacks = resolveFallbackEntries(block.fallback_models, harness);
 
     return {
-        primary: resolvePrimaryEntry({
-            entry: block.model,
-            defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
-            harness,
-        }),
-        fallbacks: resolveFallbackEntries(block.fallback_models, harness),
+        primary: primary ? { ...primary, sourceConfigKey: `${source}.model` } : undefined,
+        fallbacks: fallbacks.map((entry) => ({
+            ...entry,
+            sourceConfigKey: `${source}.fallback_models`,
+        })),
     };
 }
 
@@ -171,19 +183,34 @@ export function resolveDreamerTaskModel(args: {
         harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ??
         normalizeModelEntry(harnessBlock.model, args.harness)?.qualifier;
     const taskHasModel = taskBlock !== undefined && hasOwn(taskBlock, "model");
+    const taskHasFallbacks = taskBlock !== undefined && hasOwn(taskBlock, "fallback_models");
     const primarySource = taskHasModel ? taskBlock?.model : harnessBlock.model;
-    const fallbackSource =
-        taskBlock !== undefined && hasOwn(taskBlock, "fallback_models")
-            ? taskBlock.fallback_models
-            : harnessBlock.fallback_models;
+    const fallbackSource = taskHasFallbacks
+        ? taskBlock?.fallback_models
+        : harnessBlock.fallback_models;
+    const source = `dreamer.${sourceHarness(dreamer, args.harness)}`;
+    const primary = resolvePrimaryEntry({
+        entry: primarySource,
+        defaultQualifier: taskQualifier ?? harnessQualifier,
+        harness: args.harness,
+    });
+    const fallbacks = resolveFallbackEntries(fallbackSource, args.harness);
 
     return {
-        primary: resolvePrimaryEntry({
-            entry: primarySource,
-            defaultQualifier: taskQualifier ?? harnessQualifier,
-            harness: args.harness,
-        }),
-        fallbacks: resolveFallbackEntries(fallbackSource, args.harness),
+        primary: primary
+            ? {
+                  ...primary,
+                  sourceConfigKey: taskHasModel
+                      ? `${source}.tasks.${args.task}.model`
+                      : `${source}.model`,
+              }
+            : undefined,
+        fallbacks: fallbacks.map((entry) => ({
+            ...entry,
+            sourceConfigKey: taskHasFallbacks
+                ? `${source}.tasks.${args.task}.fallback_models`
+                : `${source}.fallback_models`,
+        })),
         schedule: readString(schedulingTask?.schedule),
         timeoutMinutes:
             typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,

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

@@ -357,7 +357,7 @@ async function promptWithTimeout(
                   // Only a transport that watches the child can say the model is silent.
                   if (!activity.monitored || activity.received) return;
                   silent = true;
-                  controller.abort();
+                  controller.abort(new ModelProducedNoOutputError(firstOutputTimeoutMs));
               }, firstOutputTimeoutMs)
             : undefined;
     const timeoutError = () =>

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

@@ -7,7 +7,10 @@ import {
     releaseBudgetFinalizeChild,
     TOKEN_BUDGET_FINALIZE_MESSAGE,
 } from "../features/magic-context/dreamer/token-budget";
-import { sumTokensFromChildMessages } from "../features/magic-context/subagent-token-capture";
+import {
+    annotateSubagentInvocationError,
+    sumTokensFromChildMessages,
+} from "../features/magic-context/subagent-token-capture";
 import { describeAssistantError } from "./assistant-message-extractor";
 import { sessionLog } from "./logger";
 import type { PromptArgs, PromptTransport } from "./model-suggestion-retry";
@@ -60,6 +63,7 @@ export interface PromptAsyncWaitOptions {
     pollIntervalMs?: number;
     startGraceMs?: number;
     tokenBudget?: number;
+    modelConfigKey?: string;
     /** Shared across retries of one child session. */
     budgetGuard?: ReturnType<typeof createDreamTokenBudget>;
     onBudgetUpdate?: (
@@ -93,6 +97,19 @@ export function isHostSessionError(error: unknown): boolean {
     );
 }
 
+/** Return the original host error carried by a marked child-session failure. */
+export function hostSessionErrorOf(error: unknown): unknown {
+    if (!isHostSessionError(error)) return undefined;
+    return (error as { hostError?: unknown }).hostError;
+}
+
+function requestModelRef(request: PromptArgs): string | undefined {
+    const model = request.body?.model;
+    if (model && typeof model.providerID === "string" && typeof model.modelID === "string")
+        return `${model.providerID}/${model.modelID}`;
+    return undefined;
+}
+
 /** True when the host client can send without waiting and report session status. */
 export function supportsPromptAsync(client: Client): boolean {
     const session = sessionApi(client);
@@ -339,11 +356,32 @@ export async function promptAsyncAndWaitForIdle(
     // retains that provider/model error while this child is actively awaited.
     activeSessionErrors.set(sessionId, undefined);
     try {
-        const sent = await session.promptAsync?.(request);
+        let sent: unknown;
+        try {
+            sent = await session.promptAsync?.(request);
+        } catch (error) {
+            annotateSubagentInvocationError(error, {
+                attemptedModel: requestModelRef(request),
+                modelConfigKey: options.modelConfigKey,
+                hostError: error,
+            });
+            throw error;
+        }
         if (sent && typeof sent === "object" && "error" in sent) {
             const rejection = (sent as { error?: unknown }).error;
             if (rejection) {
-                throw new Error(`prompt_async was rejected: ${describeRejection(rejection)}`);
+                const error = new Error(
+                    `prompt_async was rejected: ${describeRejection(rejection)}`,
+                    {
+                        cause: rejection,
+                    },
+                );
+                annotateSubagentInvocationError(error, {
+                    attemptedModel: requestModelRef(request),
+                    modelConfigKey: options.modelConfigKey,
+                    hostError: rejection,
+                });
+                throw error;
             }
         }
         let sentAt = Date.now();
@@ -364,6 +402,12 @@ export async function promptAsyncAndWaitForIdle(
                     name: "DreamerProviderOutputFailureError",
                     transient: true,
                     [HOST_SESSION_ERROR]: true,
+                    hostError,
+                });
+                annotateSubagentInvocationError(error, {
+                    attemptedModel: requestModelRef(request),
+                    modelConfigKey: options.modelConfigKey,
+                    hostError,
                 });
                 throw error;
             }

package/src/shared/rpc-types.ts

@@ -380,6 +380,7 @@ export interface DebugSessionHolderCount {
     wireMessages: number;
     wireContentSnapshots: number;
     wireEstimatedBytes: number;
+    generateReplayBytes: number;
 }
 
 export interface DebugMemoryHolders {
@@ -401,6 +402,12 @@ export interface DebugMemoryHolders {
     compartmentMirrors: {
         entries: number;
     };
+    /** OpenCode 2 only: kept copies of each session's last served request, which side
+     * questions replay. Zero on other hosts. */
+    generateReplay: {
+        sessionCount: number;
+        estimatedBytes: number;
+    };
     messageIndexQueue: {
         queueLength: number;
         reconciliationScheduled: number;

package/src/shared/sqlite-busy-budget-review.test.ts

@@ -34,6 +34,7 @@ async function lock(path: string, mode: "read" | "write" | "exclusive", holdMs:
             "--eval",
             `import { Database } from "bun:sqlite";
         const db = new Database(process.argv[1]);
+        db.exec("PRAGMA busy_timeout = 5000");
         db.exec(process.argv[2] === "read" ? "BEGIN; SELECT * FROM result"
             : process.argv[2] === "write" ? "BEGIN IMMEDIATE" : "BEGIN EXCLUSIVE");
         console.log("LOCKED");
@@ -51,7 +52,11 @@ async function lock(path: string, mode: "read" | "write" | "exclusive", holdMs:
     while (!output.includes("LOCKED\n")) {
         const chunk = await reader.read();
         if (chunk.done) {
-            throw new Error(`locker failed: ${await new Response(child.stderr).text()}`);
+            const [exitCode, stderr] = await Promise.all([
+                child.exited,
+                new Response(child.stderr).text(),
+            ]);
+            throw new Error(`locker failed (exit ${exitCode}): ${stderr.trim() || "<no stderr>"}`);
         }
         output += new TextDecoder().decode(chunk.value);
     }

package/src/shared/sqlite.ts

@@ -1283,7 +1283,7 @@ export async function withAsyncPrivilegedWriter<T>(
     operation: () => T,
     options: {
         signal?: AbortSignal;
-        beforeRetry?: (error: SqliteAcquisitionBusyError) => void;
+        beforeRetry?: (error: SqliteAcquisitionBusyError) => void | Promise<void>;
         jitter?: boolean;
         budgetMs?: number;
         assertCurrentPass?: () => void;
@@ -1326,7 +1326,9 @@ export async function withAsyncPrivilegedWriter<T>(
             if (entered || !(error instanceof SqliteAcquisitionBusyError)) throw error;
             // Adapters may serve a validated saved request instead of waiting.
             // This runs only after a failed BEGIN, never after callback writes.
-            options.beforeRetry?.(error);
+            // It may read asynchronously (OpenCode 2 reads its host store to
+            // rebuild the transform input); the retry waits for it.
+            await options.beforeRetry?.(error);
             const elapsed = performance.now() - started;
             if (elapsed >= budgetMs) {
                 reportSqliteDiagnostic(

package/src/shared/subagent-runner.ts

@@ -103,6 +103,8 @@ export interface SubagentRunOptions {
 
     /** Optional token accounting metadata. When present, harness runners persist subagent_invocations. */
     accountingSessionId?: string | undefined;
+    /** Config key supplying the selected model, for host refusal diagnostics. */
+    accountingModelConfigKey?: string | undefined;
     accountingSubagent?:
         | "historian"
         | "historian_editor"

package/src/shared/worker-shutdown-fence.test.ts

@@ -0,0 +1,87 @@
+import { expect, test } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import ts from "typescript";
+
+// A worker that installs exitOnWorkerClose must close its parent port only
+// through the returned closePort, which removes the close listener first. On
+// Bun 1.3.14 a worker whose port closes with that listener still attached never
+// exits, and the port's own close() cannot be wrapped there (it is read-only),
+// so this fence rejects a direct close in any such file.
+
+const root = resolve(import.meta.dir, "../../../..");
+const helper = "packages/plugin/src/shared/worker-shutdown.ts";
+
+function files(dir: string): string[] {
+    return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) return files(path);
+        return /\.tsx?$/.test(path) && !/\.test\.|\.d\.ts$/.test(path) ? [path] : [];
+    });
+}
+
+function unwrap(node: ts.Expression): ts.Expression {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) || ts.isNonNullExpression(current))
+        current = current.expression;
+    return current;
+}
+
+/** Direct closes of the parent port, or of a variable holding it, in a file that installs the close listener. */
+function scan(path: string, text: string): { usesHelper: boolean; violations: string[] } {
+    const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+    const ports = new Set(["parentPort"]);
+    let usesHelper = false;
+    const closes: ts.CallExpression[] = [];
+    const visit = (node: ts.Node) => {
+        if (
+            ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer &&
+            ts.isIdentifier(unwrap(node.initializer)) &&
+            ports.has((unwrap(node.initializer) as ts.Identifier).text)
+        )
+            ports.add(node.name.text);
+        if (ts.isCallExpression(node)) {
+            const callee = unwrap(node.expression);
+            if (ts.isIdentifier(callee) && callee.text === "exitOnWorkerClose") usesHelper = true;
+            if (ts.isPropertyAccessExpression(callee) && callee.name.text === "close")
+                closes.push(node);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    if (!usesHelper || path === helper) return { usesHelper, violations: [] };
+    const violations = closes.flatMap((call) => {
+        const target = unwrap((unwrap(call.expression) as ts.PropertyAccessExpression).expression);
+        if (!ts.isIdentifier(target) || !ports.has(target.text)) return [];
+        const line = source.getLineAndCharacterOfPosition(call.getStart(source)).line + 1;
+        return [
+            `${path}:${line}: close the port through exitOnWorkerClose's closePort, not ${target.text}.close()`,
+        ];
+    });
+    return { usesHelper, violations };
+}
+
+test("workers with the close listener close their port only through closePort", () => {
+    const scans = ["packages/plugin/src", "packages/pi-plugin/src", "packages/cli/src"]
+        .flatMap((directory) => files(join(root, directory)))
+        .map((path) => scan(relative(root, path), readFileSync(path, "utf8")));
+    // Pi tag snapshots, raw-ordinal warm-up, auto-search, the chunk writer and the test fixture.
+    expect(scans.filter((result) => result.usesHelper).length).toBeGreaterThanOrEqual(5);
+    expect(scans.flatMap((result) => result.violations)).toEqual([]);
+});
+
+test("the fence rejects direct port closes and accepts closePort", () => {
+    const header = 'import { parentPort } from "node:worker_threads";\n';
+    const install = "const { closePort } = exitOnWorkerClose(parentPort, () => db.close());\n";
+    expect(scan("worker.ts", `${header}${install}parentPort?.close();`).violations).toHaveLength(1);
+    expect(
+        scan("worker.ts", `${header}const port = parentPort!;\n${install}port.close();`).violations,
+    ).toHaveLength(1);
+    expect(
+        scan("worker.ts", `${header}${install}db.close();\nclosePort();`).violations,
+    ).toHaveLength(0);
+    // A worker without the close listener may close its port directly.
+    expect(scan("worker.ts", `${header}parentPort?.close();`).violations).toHaveLength(0);
+});

package/src/shared/worker-shutdown.fixture.ts

@@ -0,0 +1,25 @@
+// Worker for worker-shutdown.test.ts. "cooperative" closes its connection
+// when asked; "deaf" never reads parent messages, so only terminate() stops it.
+// "finish" installs the close listener, finishes its work and closes its own
+// port through the helper's `closePort()`; the thread must then exit by itself.
+import { parentPort, workerData } from "node:worker_threads";
+import { Database } from "./sqlite";
+import { exitOnWorkerClose } from "./worker-shutdown";
+
+const { path, mode } = workerData as {
+    path: string;
+    mode: "cooperative" | "deaf" | "finish";
+};
+const db = new Database(path);
+db.prepare("SELECT 1").get();
+if (mode === "finish") {
+    const { closePort } = exitOnWorkerClose(parentPort, () => db.close());
+    db.close();
+    parentPort?.postMessage("ready");
+    closePort();
+} else {
+    if (mode === "cooperative") exitOnWorkerClose(parentPort, () => db.close());
+    // Keep the thread alive until it is asked to close or is terminated.
+    setInterval(() => {}, 1_000);
+    parentPort?.postMessage("ready");
+}

package/src/shared/worker-shutdown.test.ts

@@ -0,0 +1,127 @@
+import { Database } from "bun:sqlite";
+import { afterEach, expect, test } from "bun:test";
+import { EventEmitter } from "node:events";
+import { join } from "node:path";
+import { Worker } from "node:worker_threads";
+import { createTestTempDir } from "./test-temp-dir";
+import {
+    createWorkerShutdown,
+    exitOnWorkerClose,
+    getWorkerShutdownStats,
+    type WorkerClosePort,
+} from "./worker-shutdown";
+
+const cleanups: (() => void)[] = [];
+afterEach(() => {
+    for (const cleanup of cleanups.splice(0)) cleanup();
+});
+
+async function start(mode: "cooperative" | "deaf" | "finish") {
+    const { dir, cleanup } = createTestTempDir("mc-worker-shutdown-");
+    cleanups.push(cleanup);
+    const path = join(dir, "store.db");
+    const owner = new Database(path);
+    owner.exec("PRAGMA journal_mode=WAL");
+    cleanups.unshift(() => owner.close());
+    const worker = new Worker(new URL("./worker-shutdown.fixture.ts", import.meta.url), {
+        workerData: { path, mode },
+    });
+    const exitCode = new Promise<number>((resolve) => worker.once("exit", resolve));
+    await new Promise<void>((resolve) => worker.once("message", () => resolve()));
+    return { owner, worker, exitCode };
+}
+
+function counts(site: string) {
+    return { ...(getWorkerShutdownStats().get(site) ?? { graceful: 0, forced: 0 }) };
+}
+
+test("a worker asked to close shuts its connection and exits by itself", async () => {
+    const site = "test-cooperative";
+    const { owner, worker, exitCode } = await start("cooperative");
+    const before = counts(site);
+    const shutdown = createWorkerShutdown(worker, site, 10_000);
+    const started = performance.now();
+    await shutdown.close();
+    // Well inside the deadline: the worker exited on its own, it was not terminated.
+    expect(performance.now() - started).toBeLessThan(5_000);
+    expect(await exitCode).toBe(0);
+    expect(counts(site)).toEqual({ graceful: before.graceful + 1, forced: before.forced });
+    owner.exec("PRAGMA busy_timeout=0");
+    owner.exec("BEGIN IMMEDIATE");
+    owner.exec("ROLLBACK");
+});
+
+test("a worker that does not exit is terminated at the deadline", async () => {
+    const site = "test-deaf";
+    const { worker, exitCode } = await start("deaf");
+    const before = counts(site);
+    const shutdown = createWorkerShutdown(worker, site, 100);
+    const started = performance.now();
+    await shutdown.close();
+    expect(performance.now() - started).toBeGreaterThanOrEqual(90);
+    await exitCode;
+    expect(counts(site)).toEqual({ graceful: before.graceful, forced: before.forced + 1 });
+});
+
+test("closing twice shares one shutdown, and closing an exited worker is a no-op", async () => {
+    const site = "test-repeat";
+    const { worker, exitCode } = await start("cooperative");
+    const before = counts(site);
+    const shutdown = createWorkerShutdown(worker, site, 10_000);
+    const first = shutdown.close();
+    expect(shutdown.close()).toBe(first);
+    await first;
+    await exitCode;
+    expect(counts(site)).toEqual({ graceful: before.graceful + 1, forced: before.forced });
+
+    const exited = await start("deaf");
+    const late = createWorkerShutdown(exited.worker, site, 10_000);
+    await exited.worker.terminate();
+    await exited.exitCode;
+    await late.close();
+    expect(counts(site)).toEqual({ graceful: before.graceful + 1, forced: before.forced });
+});
+
+/** A port that records how many message listeners were attached when it closed. */
+function recordingPort() {
+    const events = new EventEmitter();
+    const closedWith: number[] = [];
+    const port = {
+        on: (event: string, listener: (...args: unknown[]) => void) => {
+            events.on(event, listener);
+            return port;
+        },
+        off: (event: string, listener: (...args: unknown[]) => void) => {
+            events.off(event, listener);
+            return port;
+        },
+        close: () => {
+            closedWith.push(events.listenerCount("message"));
+        },
+    };
+    return { port: port as unknown as WorkerClosePort, events, closedWith };
+}
+
+test("closePort removes the close listener before the port closes", async () => {
+    const { port, events, closedWith } = recordingPort();
+    const { closePort } = exitOnWorkerClose(port, () => {});
+    expect(events.listenerCount("message")).toBe(1);
+    closePort();
+    // Closing again does not close the port twice.
+    closePort();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Bun 1.3.14 never ends a worker whose port closes with a listener attached.
+    expect(closedWith).toEqual([0]);
+});
+
+test("a worker that closes its own port through closePort exits by itself", async () => {
+    const { worker, exitCode } = await start("finish");
+    const outcome = await Promise.race([
+        exitCode,
+        new Promise<string>((resolve) => setTimeout(() => resolve("no exit"), 5_000)),
+    ]);
+    // Terminate only a worker that is still running: on Bun 1.3.14,
+    // terminate() on a worker that has already exited never settles.
+    if (outcome === "no exit") await worker.terminate();
+    expect(outcome).toBe(0);
+});