@cortexkit/opencode-magic-context 0.49.19 → 0.49.21

package/src/shared/logger.test.ts

@@ -37,6 +37,16 @@ type HotPathScenarioResult = {
     statCalls: number;
 };
 
+type ImmediateWriteScenarioResult = {
+    afterLog: string;
+    afterForward: string;
+};
+
+type BufferedWriteScenarioResult = {
+    beforeFlush: string;
+    afterFlush: string;
+};
+
 const loggerScenario = `
 import fs from "node:fs";
 import * as path from "node:path";
@@ -74,7 +84,19 @@ if (scenario === "hot-path") {
 
 const logger = await import(loggerModuleUrl);
 
-if (scenario === "retry") {
+if (scenario === "sync-write") {
+    logger.log("synchronous log line");
+    const afterLog = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "";
+    logger.writeForwardedLogLine("forwarded worker line\\n");
+    const afterForward = fs.readFileSync(logPath, "utf8");
+    console.log(JSON.stringify({ afterLog, afterForward }));
+} else if (scenario === "default-buffering") {
+    logger.log("buffered log line");
+    const beforeFlush = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "";
+    logger.flushLogger();
+    const afterFlush = fs.readFileSync(logPath, "utf8");
+    console.log(JSON.stringify({ beforeFlush, afterFlush }));
+} else if (scenario === "retry") {
     logger.log("first buffered line");
     logger.log("second buffered line");
     logger.flushLogger();
@@ -203,6 +225,8 @@ async function runLoggerScenario<T>(
     scenario:
         | "recovery"
         | "diagnostics"
+        | "sync-write"
+        | "default-buffering"
         | "rotation"
         | "stale-rotation"
         | "hot-path"
@@ -222,6 +246,7 @@ async function runLoggerScenario<T>(
             LOGGER_MODULE_URL: new URL("./logger.ts", import.meta.url).href,
             LOGGER_SCENARIO: scenario,
             LOGGER_SCENARIO_ROOT: root,
+            MAGIC_CONTEXT_LOG_SYNC: scenario === "sync-write" ? "1" : "",
         },
         stdout: "pipe",
         stderr: "pipe",
@@ -236,6 +261,22 @@ async function runLoggerScenario<T>(
 }
 
 describe("logger", () => {
+    test("writes local and forwarded lines immediately when sync logging is enabled", async () => {
+        const result = await runLoggerScenario<ImmediateWriteScenarioResult>("sync-write");
+
+        expect(result.afterLog).toContain("synchronous log line");
+        expect(result.afterLog).not.toContain("forwarded worker line");
+        expect(result.afterForward).toContain("synchronous log line");
+        expect(result.afterForward).toContain("forwarded worker line");
+    });
+
+    test("keeps lines buffered before the flush interval by default", async () => {
+        const result = await runLoggerScenario<BufferedWriteScenarioResult>("default-buffering");
+
+        expect(result.beforeFlush).toBe("");
+        expect(result.afterFlush).toContain("buffered log line");
+    });
+
     test("retries the whole buffered batch after a transient append failure", async () => {
         const result = await runLoggerScenario<RetryScenarioResult>("retry");
         expect(result.failed).toBe(1);

package/src/shared/logger.ts

@@ -5,6 +5,7 @@ import { sanitizeConfigValue, sanitizeDiagnosticText } from "./redaction";
 import { stalePluginBuildDiagnostic } from "./stale-plugin-build";
 
 const isTestEnv = process.env.NODE_ENV === "test";
+const syncLogWrites = process.env.MAGIC_CONTEXT_LOG_SYNC === "1";
 
 let buffer: string[] = [];
 let flushTimer: ReturnType<typeof setTimeout> | null = null;
@@ -198,6 +199,14 @@ function scheduleFlush(): void {
     }, FLUSH_INTERVAL_MS);
 }
 
+function appendLine(line: string): void {
+    buffer.push(line);
+    bufferedBytes += Buffer.byteLength(line);
+    boundBuffer();
+    if (syncLogWrites || buffer.length >= BUFFER_SIZE_LIMIT) flush();
+    else scheduleFlush();
+}
+
 // Set inside a worker thread so its lines reach the main thread's log file. The
 // log path depends on which host (OpenCode or Pi) the main thread registered,
 // and only the main thread's buffer and flush timer write that file.
@@ -215,11 +224,7 @@ export function setLogLineForwarder(forward: ((line: string) => void) | null): v
 export function writeForwardedLogLine(line: string): void {
     if (isTestEnv) return;
     try {
-        buffer.push(line);
-        bufferedBytes += Buffer.byteLength(line);
-        boundBuffer();
-        if (buffer.length >= BUFFER_SIZE_LIMIT) flush();
-        else scheduleFlush();
+        appendLine(line);
     } catch {
         // Intentional: logging must never throw
     }
@@ -249,14 +254,7 @@ export function log(message: string, data?: unknown): void {
             lineForwarder(line);
             return;
         }
-        buffer.push(line);
-        bufferedBytes += Buffer.byteLength(line);
-        boundBuffer();
-        if (buffer.length >= BUFFER_SIZE_LIMIT) {
-            flush();
-        } else {
-            scheduleFlush();
-        }
+        appendLine(line);
     } catch {
         // Intentional: logging must never throw
     }

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 = () =>
@@ -996,7 +996,7 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
 
         if (!cooledPrimary && !quota)
             log(
-                `[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(failure.error)}; trying ${fallbacks.length} fallback(s)`,
+                `[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(failure.error)}; ${fallbacks.length} fallback(s) configured, subject to remaining budget`,
             );
     }
 

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);
     }