@cortexkit/opencode-magic-context 0.49.34 → 0.49.36

package/dist/wrapup-orchestrator-xg9avt2p.js

@@ -0,0 +1,56 @@
+import {
+  runManagedWrapup2
+} from "./index-pp8vdn01.js";
+import"./index-ys7j6679.js";
+import"./index-9tdvbdv1.js";
+import"./index-850vthn3.js";
+import"./index-sd3egckz.js";
+import"./index-xnm0wq1r.js";
+import"./index-ty4vhe4n.js";
+import"./index-jjvbk92s.js";
+import"./index-21fgrfrf.js";
+import"./index-4dhv7mqz.js";
+import"./index-72czy45z.js";
+import"./index-2qbtqg1w.js";
+import"./index-2rs7912w.js";
+import"./index-2amn2s73.js";
+import"./index-66a50f3e.js";
+import"./index-dnqqqc5f.js";
+import"./index-ae1ar4v1.js";
+import"./index-qt1qqasc.js";
+import"./index-tn9drm1a.js";
+import"./index-8jjjmhab.js";
+import"./index-1zx87sdm.js";
+import"./index-vd2ywmfe.js";
+import"./index-x8a7jmkh.js";
+import"./index-fw42ms3m.js";
+import"./index-xd2p95m7.js";
+import"./index-c5dzns43.js";
+import"./index-jz5bk7xd.js";
+import"./index-dcjkw41m.js";
+import"./index-g4t7850m.js";
+import"./index-9fgmkfaf.js";
+import"./index-fb3zxn06.js";
+import"./index-nj360hcs.js";
+import"./index-fr0wbhdn.js";
+import"./index-txs8tce6.js";
+import"./index-b1ydbp95.js";
+import"./index-wh9fxds5.js";
+import"./index-2p37txes.js";
+import"./index-jkanybgq.js";
+import"./index-9wnbnx8f.js";
+import"./index-r2epb000.js";
+import"./index-96ztjvkn.js";
+import"./index-v0p37hm2.js";
+import"./index-58e3y90n.js";
+import"./index-fxbk7gk3.js";
+import"./index-4xyjr62e.js";
+import"./index-gzy5w8ya.js";
+import"./index-jrfre9ah.js";
+import"./index-g2q4htwp.js";
+import"./index-pavzsdc6.js";
+import"./index-z4p0ry94.js";
+import"./index-1d042x6w.js";
+export {
+  runManagedWrapup2 as runManagedWrapup
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.49.34",
+  "version": "0.49.36",
   "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);

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

@@ -0,0 +1,35 @@
+import { parentPort, threadId } from "node:worker_threads";
+import { serveWorkerJobs } from "./reusable-worker-entry";
+
+serveWorkerJobs<{
+    crash?: boolean;
+    hang?: boolean;
+    late?: boolean;
+    exitCode?: boolean;
+    value?: string;
+    shared?: SharedArrayBuffer;
+}>(async (input, port) => {
+    if (input.crash) throw new Error("injected worker crash");
+    if (input.hang) return await new Promise<void>(() => {});
+    if (input.exitCode) process.exitCode = 1;
+    if (input.shared) {
+        const state = new Int32Array(input.shared);
+        port.postMessage({ threadId, shared: Atomics.load(state, 0) });
+        await new Promise<void>((resolve) =>
+            port.once("message", () => {
+                port.postMessage({ threadId, shared: Atomics.add(state, 0, 1) });
+                resolve();
+            }),
+        );
+        port.close();
+        return;
+    }
+    if (input.late)
+        setTimeout(() => {
+            port.postMessage({ value: "stale" });
+            // Bypass the job port to verify the owner ignores a mismatched job id.
+            parentPort?.postMessage({ jobId: -1, value: { value: "stale" } });
+        }, 20);
+    port.postMessage({ threadId, value: input.value });
+    port.close();
+});