@cortexkit/opencode-magic-context 0.41.3 → 0.41.4

package/src/config/index.ts

@@ -1,6 +1,15 @@
 import { existsSync } from "node:fs";
 
-import { detectConfigFile, isPrototypePollutionKey, parseJsonc } from "../shared/jsonc-parser";
+import {
+    CONFIG_WARNING_CLASS,
+    type ConfigParseFailure,
+    type ConfigWarningDetail,
+} from "../shared/config-diagnostics";
+import {
+    detectConfigFile,
+    isPrototypePollutionKey,
+    parseJsoncRecovering,
+} from "../shared/jsonc-parser";
 import { setOutputReserveConfig } from "../shared/models-dev-cache";
 import type { PromptSurfaceConfig } from "../shared/prompt-surface";
 import { setWindowOverlayPath } from "../shared/window-geometry";
@@ -28,6 +37,11 @@ import { substituteConfigVariables } from "./variable";
 
 export interface MagicContextPluginConfig extends MagicContextConfig {
     disabled_hooks?: string[];
+    /** Runtime-only diagnostics; never read from user config. */
+    configParseFailures?: ConfigParseFailure[];
+    configWarningDetails?: ConfigWarningDetail[];
+    /** Whether cache_ttl existed in resolved raw config rather than coming from Zod defaults. */
+    cacheTtlConfigured?: boolean;
     command?: Record<
         string,
         {
@@ -74,6 +88,8 @@ interface LoadedConfigFile {
     config: Record<string, unknown>;
     /** Warnings from {env:} / {file:} substitution, with config-path prefix applied. */
     warnings: string[];
+    parseFailures: ConfigParseFailure[];
+    warningDetails: ConfigWarningDetail[];
 }
 
 export type LoadOutcome =
@@ -95,6 +111,9 @@ export interface LoadResultDetailed {
     };
     substitutionFailures: Array<{ keyPath: string; source: "user" | "project"; message: string }>;
     recoveredTopLevelKeys: string[];
+    configParseFailures: ConfigParseFailure[];
+    warningDetails: ConfigWarningDetail[];
+    cacheTtlConfigured: boolean;
 }
 
 interface LoadedConfigFileDetailed extends LoadedConfigFile {
@@ -118,10 +137,13 @@ function loadConfigFileDetailed(
         rawText = raw.text;
         rawWarnings = raw.warnings;
     } catch (error) {
+        const message = `failed to read config: ${error instanceof Error ? error.message : String(error)}`;
         return {
             config: {},
-            warnings: [
-                `${configPath}: failed to read config: ${error instanceof Error ? error.message : String(error)}`,
+            warnings: [`${configPath}: ${message}`],
+            parseFailures: [],
+            warningDetails: [
+                { warningClass: CONFIG_WARNING_CLASS.FILE_IO, source, path: configPath, message },
             ],
             outcome: "project-file-io-error",
             source,
@@ -135,32 +157,71 @@ function loadConfigFileDetailed(
             isProjectConfig: source === "project",
         });
         const rejectedKeyPaths: string[] = [];
-        const config = parseJsonc<Record<string, unknown>>(substituted.text, {
+        const parsed = parseJsoncRecovering<Record<string, unknown>>(substituted.text, {
             onRejectedKey: (path) => rejectedKeyPaths.push(path.join(".")),
         });
+        const config =
+            parsed.value && typeof parsed.value === "object" && !Array.isArray(parsed.value)
+                ? parsed.value
+                : {};
         const unsafeKeyWarnings = rejectedKeyPaths.map(
             (path) =>
                 `Ignored unsafe config key "${path}" (security: prototype-pollution keys are not allowed).`,
         );
+        const firstIssue = parsed.issues[0];
+        const recovered = firstIssue !== undefined && Object.keys(config).length > 0;
+        const parseFailures: ConfigParseFailure[] = firstIssue
+            ? [
+                  {
+                      warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+                      source,
+                      path: configPath,
+                      line: firstIssue.line,
+                      column: firstIssue.column,
+                      message: firstIssue.message,
+                      recovered,
+                      warning: `${configPath}:${firstIssue.line}:${firstIssue.column}: ${firstIssue.message}; ${recovered ? "recovered values were applied, but the file must be fixed." : "using defaults for this file."}`,
+                  },
+              ]
+            : [];
         return {
             config,
-            warnings: [...rawWarnings, ...substituted.warnings, ...unsafeKeyWarnings].map(
-                (warning) => `${configPath}: ${warning}`,
-            ),
+            warnings: [
+                ...parseFailures.map((failure) => failure.warning),
+                ...rawWarnings.map((warning) => `${configPath}: ${warning}`),
+                ...substituted.warnings.map((warning) => `${configPath}: ${warning}`),
+                ...unsafeKeyWarnings.map((warning) => `${configPath}: ${warning}`),
+            ],
+            parseFailures,
+            warningDetails: parseFailures,
             outcome:
-                rejectedKeyPaths.length > 0
-                    ? "schema-recovery"
-                    : substituted.warnings.length > 0
-                      ? "substitution-failure"
-                      : "ok",
+                parseFailures.length > 0
+                    ? "project-file-parse-error"
+                    : rejectedKeyPaths.length > 0
+                      ? "schema-recovery"
+                      : substituted.warnings.length > 0
+                        ? "substitution-failure"
+                        : "ok",
             source,
         };
     } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const warning = `${configPath}:1:1: ${message}; using defaults for this file.`;
+        const failure: ConfigParseFailure = {
+            warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+            source,
+            path: configPath,
+            line: 1,
+            column: 1,
+            message,
+            recovered: false,
+            warning,
+        };
         return {
             config: {},
-            warnings: [
-                `${configPath}: failed to load config: ${error instanceof Error ? error.message : String(error)}`,
-            ],
+            warnings: [warning],
+            parseFailures: [failure],
+            warningDetails: [failure],
             outcome: "project-file-parse-error",
             source,
         };
@@ -621,10 +682,12 @@ export function loadPluginConfigDetailed(directory: string): LoadResultDetailed
     }
 
     const recoveredTopLevelKeys: string[] = [];
+    const cacheTtlConfigured = Object.hasOwn(mergedRaw, "cache_ttl");
     const config = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
     if (profileResolution.activeProfile) config.profile = profileResolution.activeProfile;
     setOutputReserveConfig(config.output_reserve);
     setWindowOverlayPath(config.models?.window_overlay_path);
+    const leafValidationWarnings = [...(config.configWarnings ?? [])];
     if (config.configWarnings?.length) {
         allWarnings.push(
             ...config.configWarnings.map((w) => {
@@ -653,6 +716,21 @@ export function loadPluginConfigDetailed(directory: string): LoadResultDetailed
         ...bindSubstitutionFailures(userLoaded),
         ...bindSubstitutionFailures(projectLoaded),
     ];
+    const configParseFailures = [
+        ...(userLoaded?.parseFailures ?? []),
+        ...(projectLoaded?.parseFailures ?? []),
+    ];
+    const warningDetails: ConfigWarningDetail[] = [
+        ...(userLoaded?.warningDetails ?? []),
+        ...(projectLoaded?.warningDetails ?? []),
+        ...leafValidationWarnings.map((message) => ({
+            warningClass: CONFIG_WARNING_CLASS.INVALID_LEAF,
+            message,
+        })),
+    ];
+    config.configParseFailures = configParseFailures;
+    config.configWarningDetails = warningDetails;
+    config.cacheTtlConfigured = cacheTtlConfigured;
     const sources = {
         userConfig:
             userLoaded?.outcome ??
@@ -669,5 +747,8 @@ export function loadPluginConfigDetailed(directory: string): LoadResultDetailed
         sources,
         substitutionFailures,
         recoveredTopLevelKeys,
+        configParseFailures,
+        warningDetails,
+        cacheTtlConfigured,
     };
 }

package/src/shared/cache-ttl-display.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "bun:test";
+
+import { initializeDatabase } from "../features/magic-context/storage-db";
+import { getOrCreateSessionMeta, updateSessionMeta } from "../features/magic-context/storage-meta";
+import { resolveCacheTtlDisplay } from "./cache-ttl-display";
+import { seedSessionCacheTtlIfUnsynced } from "./cache-ttl-seed";
+import { Database } from "./sqlite";
+
+const modelKey = "anthropic/claude-opus-5";
+
+describe("resolveCacheTtlDisplay", () => {
+    it("shows config before the first message_end sync", () => {
+        expect(
+            resolveCacheTtlDisplay({
+                configured: { default: "5m", [modelKey]: "1h" },
+                configuredExplicitly: true,
+                modelKey,
+                sessionValue: "5m",
+                sessionModelKey: null,
+            }),
+        ).toEqual({ value: "1h", source: "config", modelKey });
+    });
+
+    it("discriminates config, session, and guessed default provenance", () => {
+        const configured = resolveCacheTtlDisplay({
+            configured: "1h",
+            configuredExplicitly: true,
+            modelKey,
+            sessionValue: "5m",
+            sessionModelKey: null,
+        });
+        const session = resolveCacheTtlDisplay({
+            configured: "1h",
+            configuredExplicitly: true,
+            modelKey,
+            sessionValue: "45m",
+            sessionModelKey: modelKey,
+        });
+        const fallback = resolveCacheTtlDisplay({
+            configured: "5m",
+            configuredExplicitly: false,
+            modelKey,
+            sessionValue: "5m",
+            sessionModelKey: null,
+        });
+
+        expect(configured.source).toBe("config");
+        expect(session).toEqual({ value: "45m", source: "session", modelKey });
+        expect(fallback).toEqual({ value: "5m", source: "default", modelKey });
+    });
+
+    it("seeds only an unsynced row and leaves a scheduler-owned row unchanged", () => {
+        const db = new Database(":memory:");
+        initializeDatabase(db);
+        try {
+            expect(
+                seedSessionCacheTtlIfUnsynced({
+                    db,
+                    sessionId: "ses-seed",
+                    configured: { default: "5m", [modelKey]: "1h" },
+                    modelKey,
+                }),
+            ).toBe(true);
+            expect(getOrCreateSessionMeta(db, "ses-seed").cacheTtl).toBe("1h");
+
+            updateSessionMeta(db, "ses-seed", {
+                cacheTtl: "45m",
+                lastObservedModelKey: modelKey,
+                lastResponseTime: 1,
+            });
+            expect(
+                seedSessionCacheTtlIfUnsynced({
+                    db,
+                    sessionId: "ses-seed",
+                    configured: "2h",
+                    modelKey,
+                }),
+            ).toBe(false);
+            expect(getOrCreateSessionMeta(db, "ses-seed").cacheTtl).toBe("45m");
+        } finally {
+            db.close();
+        }
+    });
+});

package/src/shared/cache-ttl-display.ts

@@ -0,0 +1,64 @@
+import type { MagicContextConfig } from "../config/schema/magic-context";
+import { resolveModelConfigValue } from "./prompt-surface";
+
+export type CacheTtlDisplaySource = "config" | "session" | "default";
+
+export interface CacheTtlDisplay {
+    value: string;
+    source: CacheTtlDisplaySource;
+    modelKey: string | undefined;
+}
+
+export interface ResolveCacheTtlDisplayArgs {
+    configured: MagicContextConfig["cache_ttl"];
+    configuredExplicitly: boolean;
+    modelKey: string | undefined;
+    sessionValue: string;
+    /** Model key persisted with the last completed assistant response. */
+    sessionModelKey: string | null;
+}
+
+/**
+ * Resolve status-only TTL text without changing the scheduler's persisted truth.
+ * Use the session value only when its persisted model key matches the model being
+ * displayed; otherwise use live config because the session value may be for another model.
+ */
+export function resolveCacheTtlDisplay(args: ResolveCacheTtlDisplayArgs): CacheTtlDisplay {
+    if (
+        (args.sessionModelKey && (!args.modelKey || args.sessionModelKey === args.modelKey)) ||
+        (!args.modelKey && !args.sessionModelKey && args.sessionValue !== "5m")
+    ) {
+        return {
+            value: args.sessionValue || "5m",
+            source: "session",
+            modelKey: args.modelKey ?? args.sessionModelKey ?? undefined,
+        };
+    }
+
+    if (typeof args.configured === "string") {
+        return {
+            value: args.configured,
+            source: args.configuredExplicitly ? "config" : "default",
+            modelKey: args.modelKey,
+        };
+    }
+
+    const matched = resolveModelConfigValue(args.configured, args.modelKey);
+    if (matched) {
+        return { value: matched.value, source: "config", modelKey: args.modelKey };
+    }
+
+    return {
+        value: args.configured.default ?? "5m",
+        source: "default",
+        modelKey: args.modelKey,
+    };
+}
+
+export function formatCacheTtlDisplay(display: CacheTtlDisplay): string {
+    if (display.source === "session") return `Cache TTL: ${display.value} (session)`;
+    if (display.source === "config") {
+        return `Cache TTL: ${display.value} (config for ${display.modelKey ?? "current model"})`;
+    }
+    return `Cache TTL: ${display.value} (default — no cache_ttl for ${display.modelKey ?? "unknown model"})`;
+}

package/src/shared/cache-ttl-seed.ts

@@ -0,0 +1,23 @@
+import type { MagicContextConfig } from "../config/schema/magic-context";
+import { getOrCreateSessionMeta, updateSessionMeta } from "../features/magic-context/storage-meta";
+import { resolveModelConfigValue } from "./prompt-surface";
+import type { Database } from "./sqlite";
+
+/** Seed only before a completed assistant response has made the session row authoritative. */
+export function seedSessionCacheTtlIfUnsynced(args: {
+    db: Database;
+    sessionId: string;
+    configured: MagicContextConfig["cache_ttl"];
+    modelKey: string;
+}): boolean {
+    const meta = getOrCreateSessionMeta(args.db, args.sessionId);
+    if (meta.lastResponseTime !== 0 || meta.lastObservedModelKey !== null) return false;
+    const cacheTtl =
+        typeof args.configured === "string"
+            ? args.configured
+            : (resolveModelConfigValue(args.configured, args.modelKey)?.value ??
+              args.configured.default ??
+              "5m");
+    updateSessionMeta(args.db, args.sessionId, { cacheTtl });
+    return true;
+}

package/src/shared/config-diagnostics.test.ts

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+
+import {
+    type ConfigParseFailure,
+    claimConfigParseFailuresOnce,
+    resetClaimedConfigParseFailuresForTesting,
+} from "./config-diagnostics";
+
+const failure: ConfigParseFailure = {
+    warningClass: "file-parse",
+    source: "user",
+    path: "/tmp/magic-context.jsonc",
+    line: 1,
+    column: 1,
+    message: "invalid symbol",
+    recovered: true,
+    warning: "/tmp/magic-context.jsonc:1:1: invalid symbol",
+};
+
+describe("config parse warning notice claims", () => {
+    beforeEach(resetClaimedConfigParseFailuresForTesting);
+
+    it("emits each parse failure once per harness surface", () => {
+        expect(claimConfigParseFailuresOnce("opencode", [failure])).toEqual([failure]);
+        expect(claimConfigParseFailuresOnce("opencode", [failure])).toEqual([]);
+        expect(claimConfigParseFailuresOnce("pi", [failure])).toEqual([failure]);
+        expect(claimConfigParseFailuresOnce("pi", [failure])).toEqual([]);
+    });
+});

package/src/shared/config-diagnostics.ts

@@ -0,0 +1,64 @@
+export const CONFIG_WARNING_CLASS = {
+    FILE_PARSE: "file-parse",
+    FILE_IO: "file-io",
+    INVALID_LEAF: "invalid-leaf",
+} as const;
+
+export type ConfigWarningClass = (typeof CONFIG_WARNING_CLASS)[keyof typeof CONFIG_WARNING_CLASS];
+
+export interface ConfigParseFailure {
+    warningClass: typeof CONFIG_WARNING_CLASS.FILE_PARSE;
+    source: "user" | "project";
+    path: string;
+    line: number;
+    column: number;
+    message: string;
+    recovered: boolean;
+    warning: string;
+}
+
+export interface ConfigWarningDetail {
+    warningClass: ConfigWarningClass;
+    source?: "user" | "project";
+    path?: string;
+    line?: number;
+    column?: number;
+    message: string;
+}
+
+export function formatConfigParseStatusLine(failure: ConfigParseFailure): string {
+    const disposition = failure.recovered
+        ? "recovered values applied; fix the file"
+        : "running on defaults";
+    return `Config: PARSE FAILED (${failure.path}:${failure.line}:${failure.column}) — ${disposition}`;
+}
+
+export function formatConfigParseNotice(failures: readonly ConfigParseFailure[]): string {
+    const lines = failures.map(
+        (failure) => `${formatConfigParseStatusLine(failure)}\n${failure.message}`,
+    );
+    return ["⚠️ Magic Context config parse failure", ...lines].join("\n\n");
+}
+
+const claimedFailures = new Set<string>();
+
+function failureKey(surface: string, failure: ConfigParseFailure): string {
+    return `${surface}\0${failure.path}\0${failure.line}\0${failure.column}\0${failure.message}`;
+}
+
+/** Claim parse-failure notices once for each runtime surface in this process. */
+export function claimConfigParseFailuresOnce(
+    surface: "opencode" | "pi",
+    failures: readonly ConfigParseFailure[],
+): ConfigParseFailure[] {
+    return failures.filter((failure) => {
+        const key = failureKey(surface, failure);
+        if (claimedFailures.has(key)) return false;
+        claimedFailures.add(key);
+        return true;
+    });
+}
+
+export function resetClaimedConfigParseFailuresForTesting(): void {
+    claimedFailures.clear();
+}

package/src/shared/config-warning-surface.ts

@@ -0,0 +1,28 @@
+import type { ConfigParseFailure } from "./config-diagnostics";
+import { formatConfigParseStatusLine } from "./config-diagnostics";
+
+export function buildOpenCodeConfigWarningBanner(
+    warnings: readonly string[],
+    parseFailures: readonly ConfigParseFailure[],
+    allParseFailures: readonly ConfigParseFailure[] = parseFailures,
+): string {
+    const parseWarningStrings = new Set(allParseFailures.map((failure) => failure.warning));
+    const ordinaryWarnings = warnings.filter(
+        (warning) =>
+            ![...parseWarningStrings].some((parseWarning) => warning.includes(parseWarning)),
+    );
+    const entries = [
+        ...parseFailures.map(
+            (failure) =>
+                `- **TOP SEVERITY:** ${formatConfigParseStatusLine(failure)} — ${failure.message}`,
+        ),
+        ...ordinaryWarnings.map((warning) => `- ${warning}`),
+    ];
+    return [
+        "## ⚠️ Magic Context Config Warning",
+        "",
+        ...entries,
+        "",
+        "Fix the reported `magic-context.jsonc` file; Magic Context remains enabled.",
+    ].join("\n");
+}

package/src/shared/data-path.ts

@@ -13,16 +13,17 @@ export function getDataDir(): string {
  * Layout:
  *   - OpenCode: `${os.tmpdir()}/opencode/magic-context/`
  *   - Pi:       `${os.tmpdir()}/pi/magic-context/`
+ *   - OMP:      `${os.tmpdir()}/omp/magic-context/`
  *
  * Why a per-harness subtree of `os.tmpdir()`:
  *   1. OpenCode Desktop runs as an Electron app with a permission sandbox.
  *      Writing to arbitrary tmp paths can trigger user-visible permission
  *      prompts; the `${tmpdir}/opencode/` subtree is allow-listed by
  *      OpenCode, so anything we put under it never asks for permission.
- *   2. Splitting OpenCode from Pi keeps their logs and historian dump
- *      directories cleanly separated. `doctor --issue` for each harness
- *      reports diagnostics from the matching subtree, so an OpenCode
- *      issue report never includes Pi log noise (and vice versa).
+ *   2. Splitting harnesses keeps their logs and historian dump directories
+ *      cleanly separated. `doctor --issue` for each harness reports diagnostics
+ *      from the matching subtree, so issue reports do not include another
+ *      harness's log noise.
  *   3. Pi has no permission sandbox, so the path choice is purely
  *      cosmetic for Pi — it just keeps the layout symmetric.
  *
@@ -37,13 +38,13 @@ export function getMagicContextTempDir(harness: HarnessId = getHarness()): strin
 }
 
 /**
- * Standard log file path the plugin writes to. Pi and OpenCode write to
- * SEPARATE logs under their respective harness subtrees so a single
- * machine running both harnesses doesn't interleave session traces.
+ * Standard log file path the plugin writes to. Each harness writes to a
+ * separate log under its own subtree so a machine running multiple harnesses
+ * does not interleave session traces.
  *
  * The plugin's buffered logger calls this on every flush rather than
- * caching, so `setHarness("pi")` taking effect after module load is
- * reflected in the next flush.
+ * caching, so the boot-time `setHarness()` call is reflected in the next
+ * flush.
  */
 export function getMagicContextLogPath(harness: HarnessId = getHarness()): string {
     // An explicit override wins over the harness temp-dir default, so users on

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

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import {
+    canonicalModelIdentity,
     modelRefLookupOrder,
     ompModelRefToCanonical,
     piModelRefToCanonical,
@@ -8,6 +9,21 @@ import {
 } from "./harness-provider-map";
 
 describe("harness-provider-map", () => {
+    describe("canonicalModelIdentity", () => {
+        it("collapses Astra route aliases without changing unrelated Copilot models", () => {
+            for (const ref of [
+                "openai/gpt-6-astra",
+                "openai-codex/gpt-6-astra",
+                "github-copilot/gpt-6-astra",
+            ]) {
+                expect(canonicalModelIdentity(ref)).toBe("openai/gpt-6-astra");
+            }
+            expect(canonicalModelIdentity("github-copilot/claude-opus-5")).toBe(
+                "github-copilot/claude-opus-5",
+            );
+        });
+    });
+
     describe("resolveModelRefForPi (canonical -> Pi, used when spawning)", () => {
         it("maps the diverging auth-plugin providers, preserving the model id", () => {
             expect(resolveModelRefForPi("openai/gpt-5.5")).toBe("openai-codex/gpt-5.5");

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

@@ -58,6 +58,10 @@ const OMP_TO_CANONICAL_PROVIDER: Readonly<Record<string, string>> = {
     "opencode-zen": "opencode",
 };
 
+const CANONICAL_MODEL_IDENTITY_ALIASES: Readonly<Record<string, string>> = {
+    "github-copilot/gpt-6-astra": "openai/gpt-6-astra",
+};
+
 /** Remap only the provider prefix (text before the first "/"), preserving the
  *  model id verbatim. No "/", empty provider, or unmapped provider -> unchanged.
  *  Lookups are own-property only, so provider ids that collide with
@@ -72,6 +76,17 @@ function remapProviderPrefix(ref: string, map: Readonly<Record<string, string>>)
     return `${map[provider]}${ref.slice(slash)}`;
 }
 
+/**
+ * Canonicalize only for identity comparisons and cache policy; callers must not
+ * use the result as a provider spawn route. Provider-wide Pi/OMP aliases are
+ * normalized first; model-specific aliases stay explicit because GitHub Copilot
+ * also serves non-OpenAI model families.
+ */
+export function canonicalModelIdentity(ref: string): string {
+    const harnessCanonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+    return CANONICAL_MODEL_IDENTITY_ALIASES[harnessCanonical.toLowerCase()] ?? harnessCanonical;
+}
+
 /** Pi-native `provider/model` -> canonical (OpenCode). Identity when unmapped.
  *  Used by the Pi setup wizard so configs it writes stay OpenCode-readable. */
 export function piModelRefToCanonical(ref: string): string {

package/src/shared/jsonc-parser.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 
-import { parseJsonc } from "./jsonc-parser";
+import { parseJsonc, parseJsoncRecovering } from "./jsonc-parser";
 
 describe("parseJsonc prototype-pollution hardening", () => {
     it("rejects dangerous keys recursively, including inside arrays", () => {
@@ -30,4 +30,17 @@ describe("parseJsonc prototype-pollution hardening", () => {
         expect(Object.getPrototypeOf(items[0])).toBe(Object.prototype);
         expect("polluted" in items[0]).toBe(false);
     });
+
+    it("preserves hardening when tolerant recovery encounters __proto__", () => {
+        const rejected: string[] = [];
+        const parsed = parseJsoncRecovering<Record<string, unknown>>(
+            '\\{\n"__proto__":{"polluted":true},"cache_ttl":"1h"}',
+            { onRejectedKey: (path) => rejected.push(path.join(".")) },
+        );
+
+        expect(parsed.value).toEqual({ cache_ttl: "1h" });
+        expect(parsed.issues[0]).toMatchObject({ line: 1, column: 1 });
+        expect(rejected).toContain("__proto__");
+        expect(({} as { polluted?: boolean }).polluted).toBeUndefined();
+    });
 });