@cortexkit/opencode-magic-context 0.36.1 → 0.37.0

package/src/shared/conflict-detector.test.ts

@@ -4,7 +4,7 @@ import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { detectConflicts } from "./conflict-detector";
+import { detectConflicts, resolveCompactionForBoot } from "./conflict-detector";
 
 /**
  * Regression tests for plugin-conflict detection. The previous substring-
@@ -492,4 +492,179 @@ describe("detectConflicts", () => {
             }
         });
     });
+
+    // --- Resolved-config arm (issue #309) ---
+    // The plugin boot now consumes the host's RESOLVED config
+    // (ctx.client.config.get()) instead of re-deriving compaction from files.
+    // These tests exercise the resolved arm directly via the
+    // `resolvedCompaction` option and the `resolveCompactionForBoot` helper.
+    describe("resolved-config arm (issue #309)", () => {
+        // The suite beforeEach sets OPENCODE_DISABLE_AUTOCOMPACT=1 to isolate
+        // plugin detection from compaction detection. These tests exercise the
+        // resolved arm, so they clear it and restore it per-case.
+        function withoutAutoCompactEnv<T>(fn: () => T): T {
+            const prev = process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            try {
+                return fn();
+            } finally {
+                if (prev !== undefined) process.env.OPENCODE_DISABLE_AUTOCOMPACT = prev;
+            }
+        }
+
+        it("resolved auto=false + file layer that would default true → NO conflict (#309)", () => {
+            // No compaction block in any file + no env override → the file-based
+            // arm would default to auto=true and wrongly disable the plugin.
+            // The resolved arm says auto=false, which must win.
+            withoutAutoCompactEnv(() => {
+                const result = detectConflicts(projectDir, {
+                    compactionEnabled: true,
+                    resolvedCompaction: { auto: false, prune: false },
+                });
+                expect(result.conflicts.compactionAuto).toBe(false);
+                expect(result.hasConflict).toBe(false);
+                expect(result.nativeCompaction.auto).toBe(false);
+            });
+        });
+
+        it("resolved auto=true → conflict, message carries '(resolved config)'", () => {
+            withoutAutoCompactEnv(() => {
+                const result = detectConflicts(projectDir, {
+                    compactionEnabled: true,
+                    resolvedCompaction: { auto: true, prune: false },
+                });
+                expect(result.conflicts.compactionAuto).toBe(true);
+                expect(result.hasConflict).toBe(true);
+                expect(result.reasons.join("; ")).toContain("(resolved config)");
+            });
+        });
+
+        it("resolved prune=true → conflict, message carries '(resolved config)'", () => {
+            withoutAutoCompactEnv(() => {
+                const result = detectConflicts(projectDir, {
+                    compactionEnabled: true,
+                    resolvedCompaction: { auto: false, prune: true },
+                });
+                expect(result.conflicts.compactionPrune).toBe(true);
+                expect(result.hasConflict).toBe(true);
+                expect(result.reasons.join("; ")).toContain("(resolved config)");
+            });
+        });
+
+        it("resolved arm is skipped when resolvedCompaction is absent (file-based fallback unchanged)", () => {
+            // No resolvedCompaction → the file-based check runs. With no
+            // compaction block and no env override, it defaults to auto=true.
+            withoutAutoCompactEnv(() => {
+                const result = detectConflicts(projectDir, { compactionEnabled: true });
+                expect(result.conflicts.compactionAuto).toBe(true);
+                expect(result.hasConflict).toBe(true);
+                // File-based arm does NOT carry the resolved-config label.
+                expect(result.reasons.join("; ")).not.toContain("(resolved config)");
+            });
+        });
+
+        it("OPENCODE_DISABLE_AUTOCOMPACT short-circuits the resolved arm", () => {
+            // Resolved says auto=true, but the env override must win.
+            process.env.OPENCODE_DISABLE_AUTOCOMPACT = "1";
+            try {
+                const result = detectConflicts(projectDir, {
+                    compactionEnabled: true,
+                    resolvedCompaction: { auto: true, prune: true },
+                });
+                expect(result.conflicts.compactionAuto).toBe(false);
+                expect(result.conflicts.compactionPrune).toBe(false);
+                expect(result.hasConflict).toBe(false);
+                expect(result.nativeCompaction.auto).toBe(false);
+                expect(result.nativeCompaction.prune).toBe(false);
+            } finally {
+                delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            }
+        });
+
+        it("compaction-off mode: resolved auto=true is NOT a conflict (native compaction active)", () => {
+            withoutAutoCompactEnv(() => {
+                const result = detectConflicts(projectDir, {
+                    compactionEnabled: false,
+                    resolvedCompaction: { auto: true, prune: false },
+                });
+                expect(result.conflicts.compactionAuto).toBe(false);
+                expect(result.hasConflict).toBe(false);
+                // Native compaction state is still reported honestly.
+                expect(result.nativeCompaction.auto).toBe(true);
+            });
+        });
+    });
+
+    // --- resolveCompactionForBoot (the resolved-config fetch helper) ---
+    describe("resolveCompactionForBoot", () => {
+        it("returns the resolved compaction block from the client", async () => {
+            const client = {
+                config: {
+                    get: async () => ({
+                        data: { compaction: { auto: false, prune: true } },
+                    }),
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toEqual({ auto: false, prune: true });
+        });
+
+        it("returns null when the compaction block is absent (file-based fallback, not host defaults)", async () => {
+            // An absent block means the response shape did not carry the resolved
+            // state (server version drift, a fetch racing boot) — NOT that the
+            // host resolved its defaults. Reading absence as auto=true disabled
+            // the plugin for real users whose auto=false lived in the file layer
+            // (issue #309, second arm: the 2026-08-14 desktop incident where
+            // every session overflowed with nothing managing the window).
+            const client = {
+                config: {
+                    get: async () => ({ data: {} }),
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toBeNull();
+        });
+
+        it("returns null when compaction values are not explicit booleans", async () => {
+            const client = {
+                config: {
+                    get: async () => ({ data: { compaction: { auto: "true", prune: null } } }),
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toBeNull();
+        });
+
+        it("returns null when the response data is missing entirely", async () => {
+            const client = {
+                config: {
+                    get: async () => ({}) as { data?: Record<string, unknown> },
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toBeNull();
+        });
+
+        it("returns null when the client throws (file-based fallback used)", async () => {
+            const client = {
+                config: {
+                    get: async () => {
+                        throw new Error("boom");
+                    },
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toBeNull();
+        });
+
+        it("returns null when the client times out (boot never hangs)", async () => {
+            const client = {
+                config: {
+                    get: () => new Promise<never>(() => {}), // never resolves
+                },
+            };
+            const result = await resolveCompactionForBoot(client, 20);
+            expect(result).toBeNull();
+        });
+    });
 });

package/src/shared/conflict-detector.ts

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { readJsoncFile } from "./jsonc-parser";
+import { log } from "./logger";
 import { getOpenCodeConfigPaths } from "./opencode-config-dir";
 
 interface OpenCodeConfig {
@@ -51,6 +52,18 @@ export interface ConflictResult {
     };
 }
 
+/**
+ * Resolved native compaction state, as reported by the host's own config
+ * resolution (ctx.client.config.get() — the same object `opencode debug
+ * config` prints). `auto`/`prune` are booleans; the OpenCode schema annotates
+ * `auto` with default `true` and `prune` with default `false`, so an absent
+ * compaction block resolves to `{ auto: true, prune: false }`.
+ */
+export interface ResolvedCompaction {
+    auto: boolean;
+    prune: boolean;
+}
+
 /**
  * Options for {@link detectConflicts}.
  *
@@ -63,6 +76,13 @@ export interface ConflictResult {
  * omit it and accept the default `true` (mode-on) behavior, which preserves
  * today's conflict semantics; it must never silently skip the check.
  *
+ * `resolvedCompaction` is the host's RESOLVED native compaction state
+ * (fetched via {@link resolveCompactionForBoot}). When present, the
+ * file-based {@link checkCompaction} is NOT called — the resolved values are
+ * used directly. Absent means the file-based fallback is used. The
+ * OPENCODE_DISABLE_AUTOCOMPACT env short-circuit is applied on top of
+ * whichever arm produced the value.
+ *
  * When `compactionEnabled` is `false` (compaction-off mode), OpenCode
  * `compaction.auto=true` / `compaction.prune=true` are NOT plugin-disabling
  * conflicts — native compaction is the user's chosen window manager. DCP
@@ -71,6 +91,7 @@ export interface ConflictResult {
  */
 export interface DetectConflictsOptions {
     compactionEnabled?: boolean;
+    resolvedCompaction?: ResolvedCompaction;
 }
 
 /**
@@ -81,6 +102,11 @@ export interface DetectConflictsOptions {
  * When `false` (compaction-off mode), native `compaction.auto`/`prune` are
  * reported in {@link ConflictResult.nativeCompaction} but are NOT flagged as
  * conflicts — native compaction is the intended window manager in that mode.
+ *
+ * `resolvedCompaction` (optional) is the host's RESOLVED native compaction
+ * state from {@link resolveCompactionForBoot}. When present it is used
+ * directly and the file-based {@link checkCompaction} is skipped; when absent
+ * the file-based fallback runs unchanged.
  */
 export function detectConflicts(
     directory: string,
@@ -98,18 +124,38 @@ export function detectConflicts(
     const reasons: string[] = [];
 
     // --- Check OpenCode compaction config ---
-    const compactionResult = checkCompaction(directory);
+    // The host's resolved config is the authority when available (issue #309:
+    // the file-based re-derivation defaults to auto=true when no file resolves,
+    // wrongly disabling the plugin for users whose auto=false lives in a layer
+    // the file reader cannot see). When the resolved fetch failed, fall back to
+    // the file-based check unchanged.
+    let compactionResult = options?.resolvedCompaction ?? checkCompaction(directory);
+    // OPENCODE_DISABLE_AUTOCOMPACT short-circuits BOTH arms: it is the first,
+    // cheapest check and is correct regardless of which arm produced the value.
+    // (checkCompaction already applies it internally for the file arm; this
+    // covers the resolved arm, which skips checkCompaction entirely.)
+    if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+        compactionResult = { auto: false, prune: false };
+    }
     // Native compaction is a conflict ONLY when MC compaction is ON. In
     // compaction-off mode the user has explicitly handed the window to native
     // compaction (or nothing), so compaction.auto=true / prune=true are the
     // intended state, not a plugin-disabling conflict.
     if (compactionEnabled && compactionResult.auto) {
         conflicts.compactionAuto = true;
-        reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
+        reasons.push(
+            options?.resolvedCompaction
+                ? "OpenCode auto-compaction is enabled (compaction.auto=true) (resolved config)"
+                : "OpenCode auto-compaction is enabled (compaction.auto=true)",
+        );
     }
     if (compactionEnabled && compactionResult.prune) {
         conflicts.compactionPrune = true;
-        reasons.push("OpenCode prune is enabled (compaction.prune=true)");
+        reasons.push(
+            options?.resolvedCompaction
+                ? "OpenCode prune is enabled (compaction.prune=true) (resolved config)"
+                : "OpenCode prune is enabled (compaction.prune=true)",
+        );
     }
 
     // --- Check for DCP plugin ---
@@ -152,6 +198,83 @@ export function detectConflicts(
 
 // --- Compaction detection (extracted from opencode-compaction-detector.ts) ---
 
+/**
+ * Minimal shape of the OpenCode SDK client's `config.get()` response. The
+ * SDK's generated `Config` type does not declare a `compaction` field (the
+ * schema lives in OpenCode's core config, not the SDK surface), so we read it
+ * defensively at runtime. `config.get()` returns a `RequestResult` whose
+ * `data` is the resolved config object — the same object `opencode debug
+ * config` prints. The `data` is typed as `unknown` here so the real SDK client
+ * (whose `Config` has no `compaction` key) is structurally assignable.
+ */
+export interface OpencodeConfigClientLike {
+    config: {
+        get: () => Promise<{ data?: unknown }>;
+    };
+}
+
+/**
+ * Shape of the `compaction` block inside the resolved config, read defensively
+ * from the SDK response at runtime.
+ */
+interface ResolvedCompactionBlock {
+    compaction?: {
+        auto?: boolean;
+        prune?: boolean;
+    };
+}
+
+/**
+ * Fetch the host's RESOLVED native compaction state from the OpenCode SDK
+ * client (`ctx.client.config.get()`). This is the authority for the plugin's
+ * conflict decision (issue #309): the file-based re-derivation cannot see
+ * every layer OpenCode folds in (env-var config path, managed configs,
+ * multi-file merge), so any user whose `auto=false` lives in a layer we don't
+ * read would be wrongly flagged. We never re-derive what the host will tell
+ * us.
+ *
+ * A response WITHOUT a compaction block is INCONCLUSIVE, not "host defaults
+ * apply": a server whose `/config` shape drifted (OpenCode Desktop bundles
+ * its own server version) or a fetch racing boot returns data with no
+ * `compaction` key, and reading that absence as `auto=true` disables the
+ * plugin — the one wrong direction, because a false disable leaves NOTHING
+ * managing the window and every long session overflows (issue #309, second
+ * arm). Only an explicit boolean from the host resolves this arm; anything
+ * else returns `null` so the caller falls back to the file-based check,
+ * which reads the layers the user actually wrote.
+ *
+ * Returns `null` when the fetch fails, times out (bounded to `timeoutMs` so
+ * boot never hangs), or serves no explicit compaction block.
+ */
+export async function resolveCompactionForBoot(
+    client: OpencodeConfigClientLike,
+    timeoutMs = 2_000,
+): Promise<ResolvedCompaction | null> {
+    try {
+        const result = await Promise.race([
+            client.config.get(),
+            new Promise<never>((_, reject) =>
+                setTimeout(() => reject(new Error("config.get() timed out")), timeoutMs),
+            ),
+        ]);
+        // The SDK's generated `Config` type has no `compaction` key, so read it
+        // defensively from the runtime response.
+        const compaction = (result?.data as ResolvedCompactionBlock | undefined)?.compaction;
+        // Explicit booleans only. An absent block (or non-boolean values) means
+        // the response shape did not carry the resolved state — fall back to the
+        // file arm rather than resolving to the plugin-disabling default.
+        if (typeof compaction?.auto !== "boolean" || typeof compaction?.prune !== "boolean") {
+            log(
+                `[magic-context] conflict-detector: resolved config carried no explicit compaction block (${JSON.stringify(compaction) ?? "absent"}); falling back to file-based detection`,
+            );
+            return null;
+        }
+        return { auto: compaction.auto, prune: compaction.prune };
+    } catch {
+        return null;
+    }
+}
+
 function checkCompaction(directory: string): { auto: boolean; prune: boolean } {
     if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
         return { auto: false, prune: false };

package/src/shared/harness-provider-map.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import {
+    modelRefLookupOrder,
     ompModelRefToCanonical,
     piModelRefToCanonical,
     resolveModelRefForOmp,
@@ -64,6 +65,25 @@ describe("harness-provider-map", () => {
             const piForm = "openai-codex/gpt-5.5";
             expect(resolveModelRefForPi(piModelRefToCanonical(piForm))).toBe(piForm);
         });
+
+        describe("modelRefLookupOrder (config read edge)", () => {
+            it("tries canonical before the Pi-native spelling", () => {
+                expect(modelRefLookupOrder("openai-codex/gpt-5.6-sol")).toEqual([
+                    "openai/gpt-5.6-sol",
+                    "openai-codex/gpt-5.6-sol",
+                ]);
+                expect(modelRefLookupOrder("openai/gpt-5.6-sol")).toEqual([
+                    "openai/gpt-5.6-sol",
+                    "openai-codex/gpt-5.6-sol",
+                ]);
+            });
+
+            it("keeps unknown provider prefixes as a single passthrough key", () => {
+                expect(modelRefLookupOrder("custom-provider/model")).toEqual([
+                    "custom-provider/model",
+                ]);
+            });
+        });
     });
 });
 

package/src/shared/harness-provider-map.ts

@@ -77,6 +77,25 @@ export function resolveModelRefForPi(ref: string): string {
     return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
 }
 
+/**
+ * Return every known spelling of a model reference with the canonical shared
+ * form first. The raw input remains the first fallback, so a single config file
+ * works on every harness: canonical wins when both spellings are present, while
+ * Pi/OMP-native provider ids are still accepted at the read edge. Unknown
+ * providers pass through unchanged and therefore produce one candidate.
+ */
+export function modelRefLookupOrder(ref: string): string[] {
+    const canonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+    return [
+        ...new Set([
+            canonical,
+            ref,
+            resolveModelRefForPi(canonical),
+            resolveModelRefForOmp(canonical),
+        ]),
+    ];
+}
+
 /** OMP-native selector -> canonical shared-config model reference. */
 export function ompModelRefToCanonical(ref: string): string {
     return remapProviderPrefix(ref, OMP_TO_CANONICAL_PROVIDER);

package/src/shared/logger.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+type LoggerScenarioResult = {
+    exists: boolean;
+    content: string;
+    healthyDiagnostics: {
+        swallowedWriteCount: number;
+        lastErrorMessage: string | null;
+        lastErrorTime: string | null;
+    };
+    failedDiagnostics: {
+        swallowedWriteCount: number;
+        lastErrorMessage: string | null;
+        lastErrorTime: string | null;
+    };
+};
+
+const loggerScenario = `
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+
+const root = process.env.LOGGER_SCENARIO_ROOT;
+const loggerModuleUrl = process.env.LOGGER_MODULE_URL;
+if (!root || !loggerModuleUrl) throw new Error("logger scenario environment is incomplete");
+
+const logger = await import(loggerModuleUrl);
+const logPath = path.join(root, "nested", "magic-context.log");
+process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
+logger.log("first");
+logger.flushLogger();
+const healthyDiagnostics = logger.getLoggerDiagnostics();
+
+const logDirectory = path.dirname(logPath);
+if (process.env.LOGGER_SCENARIO === "recovery") {
+    const { rmSync } = await import("node:fs");
+    rmSync(logDirectory, { recursive: true, force: true });
+    logger.log("second");
+    logger.flushLogger();
+}
+
+// A directory used as the file target makes append fail deterministically on every platform.
+const failedPath = path.join(root, "unwritable-log-target");
+const { mkdirSync } = await import("node:fs");
+mkdirSync(failedPath, { recursive: true });
+process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
+logger.log("failed write");
+logger.flushLogger();
+const failedDiagnostics = logger.getLoggerDiagnostics();
+
+const content = existsSync(logPath) ? readFileSync(logPath, "utf8") : "";
+console.log(JSON.stringify({
+    exists: existsSync(logPath),
+    content,
+    healthyDiagnostics,
+    failedDiagnostics,
+}));
+`;
+
+const scenarioRoots: string[] = [];
+
+afterEach(() => {
+    for (const root of scenarioRoots.splice(0)) {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+async function runLoggerScenario(
+    scenario: "recovery" | "diagnostics",
+): Promise<LoggerScenarioResult> {
+    const root = mkdtempSync(path.join(os.tmpdir(), "magic-context-logger-test-"));
+    scenarioRoots.push(root);
+    const child = Bun.spawn({
+        cmd: ["bun", "--eval", loggerScenario],
+        cwd: import.meta.dir,
+        env: {
+            ...process.env,
+            NODE_ENV: "production",
+            LOGGER_MODULE_URL: new URL("./logger.ts", import.meta.url).href,
+            LOGGER_SCENARIO: scenario,
+            LOGGER_SCENARIO_ROOT: root,
+        },
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const [exitCode, stdout, stderr] = await Promise.all([
+        child.exited,
+        new Response(child.stdout).text(),
+        new Response(child.stderr).text(),
+    ]);
+    expect(exitCode, stderr).toBe(0);
+    return JSON.parse(stdout.trim()) as LoggerScenarioResult;
+}
+
+describe("logger", () => {
+    test("recreates a log directory removed while the process is running", async () => {
+        const result = await runLoggerScenario("recovery");
+
+        expect(result.exists).toBe(true);
+        expect(result.content).toContain("second");
+    });
+
+    test("reports swallowed writes while healthy writes leave the counter at zero", async () => {
+        const result = await runLoggerScenario("diagnostics");
+
+        expect(result.healthyDiagnostics).toEqual({
+            swallowedWriteCount: 0,
+            lastErrorMessage: null,
+            lastErrorTime: null,
+        });
+        expect(result.failedDiagnostics.swallowedWriteCount).toBe(1);
+        expect(result.failedDiagnostics.lastErrorMessage).toBeTruthy();
+        expect(result.failedDiagnostics.lastErrorTime).toMatch(
+            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
+        );
+    });
+});

package/src/shared/logger.ts

@@ -9,25 +9,30 @@ let flushTimer: ReturnType<typeof setTimeout> | null = null;
 const FLUSH_INTERVAL_MS = 500;
 const BUFFER_SIZE_LIMIT = 50;
 
-// Cache the last log directory we mkdir'd successfully so we only retry the
-// filesystem call when the resolved path actually changes. The path is
-// re-evaluated on every flush because `setHarness("pi")` runs after module
-// load on Pi; we MUST NOT freeze it at import time, or Pi's first flush
-// could land in the OpenCode subtree.
-let lastEnsuredDir: string | null = null;
+export interface LoggerDiagnostics {
+    swallowedWriteCount: number;
+    lastErrorMessage: string | null;
+    lastErrorTime: string | null;
+}
 
-function ensureDir(filePath: string): void {
-    const dir = path.dirname(filePath);
-    if (dir === lastEnsuredDir) return;
+let swallowedWriteCount = 0;
+let lastErrorMessage: string | null = null;
+let lastErrorTime: string | null = null;
+
+function recordSwallowedWrite(error: unknown): void {
     try {
-        fs.mkdirSync(dir, { recursive: true });
-        lastEnsuredDir = dir;
+        swallowedWriteCount++;
+        lastErrorMessage = error instanceof Error ? error.message : String(error);
+        lastErrorTime = new Date().toISOString();
     } catch {
-        // Intentional: logging must never throw. If mkdir fails we still
-        // try the append; failure there is also swallowed.
+        // Diagnostics must not make the logger throw either.
     }
 }
 
+function ensureDir(filePath: string): void {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
 function flush(): void {
     if (flushTimer) {
         clearTimeout(flushTimer);
@@ -40,8 +45,8 @@ function flush(): void {
         const logFile = getMagicContextLogPath();
         ensureDir(logFile);
         fs.appendFileSync(logFile, data);
-    } catch {
-        // Intentional: logging must never throw
+    } catch (error) {
+        recordSwallowedWrite(error);
     }
 }
 
@@ -78,6 +83,19 @@ export function sessionLog(sessionId: string, message: string, data?: unknown):
     log(`[magic-context][${sessionId}] ${message}`, data);
 }
 
+export function getLoggerDiagnostics(): LoggerDiagnostics {
+    return {
+        swallowedWriteCount,
+        lastErrorMessage,
+        lastErrorTime,
+    };
+}
+
+/** Flush buffered log entries immediately. Primarily useful to diagnostic readers and tests. */
+export function flushLogger(): void {
+    flush();
+}
+
 /**
  * Resolve the current log file path. The path is harness-aware (see
  * {@link getMagicContextLogPath}) and re-evaluated on every call, so callers

package/src/shared/models-dev-cache.test.ts

@@ -78,6 +78,23 @@ describe("output-token reservation", () => {
         ).toBe(1_048_576);
     });
 
+    test("output_reserve accepts both harness provider spellings with canonical precedence", () => {
+        const limit = { context: 100_000, output: 20_000 };
+        expect(
+            resolveLimit(limit, "openai-codex", "gpt-5.6-sol", {
+                default: 0,
+                "openai-codex/gpt-5.6-sol": 8_000,
+            }),
+        ).toBe(92_000);
+        expect(
+            resolveLimit(limit, "openai-codex", "gpt-5.6-sol", {
+                default: 0,
+                "openai-codex/gpt-5.6-sol": 8_000,
+                "openai/gpt-5.6-sol": 4_000,
+            }),
+        ).toBe(96_000);
+    });
+
     test("output_reserve overrides shared and separate quota defaults", () => {
         expect(resolveLimit({ context: 100_000, output: 20_000 }, "anthropic", "claude", 0)).toBe(
             100_000,