@cortexkit/opencode-magic-context 0.41.2 → 0.41.4

package/dist/{transformers.node-b1wa0hgx.js → transformers.node-dpmf3wpx.js}

@@ -1,6 +1,6 @@
 import {
   __require
-} from "./index-1yh8g550.js";
+} from "./index-22jkk6wg.js";
 
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/dist/transformers.node.mjs
 import fs from "fs";
@@ -4257,18 +4257,18 @@ var Environment = class {
     }
   }
 };
-function setupGlobals(env22) {
-  env22.set("false", false);
-  env22.set("true", true);
-  env22.set("none", null);
-  env22.set("raise_exception", (args) => {
+function setupGlobals(env2) {
+  env2.set("false", false);
+  env2.set("true", true);
+  env2.set("none", null);
+  env2.set("raise_exception", (args) => {
     throw new Error(args);
   });
-  env22.set("range", range);
-  env22.set("strftime_now", strftime_now);
-  env22.set("True", true);
-  env22.set("False", false);
-  env22.set("None", null);
+  env2.set("range", range);
+  env2.set("strftime_now", strftime_now);
+  env2.set("True", true);
+  env2.set("False", false);
+  env2.set("None", null);
 }
 function getAttributeValue(item, attributePath) {
   const parts = attributePath.split(".");
@@ -4333,8 +4333,8 @@ function compareRuntimeValues(a, b, caseSensitive = false) {
 }
 var Interpreter = class {
   global;
-  constructor(env22) {
-    this.global = env22 ?? new Environment;
+  constructor(env2) {
+    this.global = env2 ?? new Environment;
   }
   run(program) {
     return this.evaluate(program, this.global);
@@ -5417,14 +5417,14 @@ var Template = class {
     this.parsed = parse(tokens);
   }
   render(items) {
-    const env22 = new Environment;
-    setupGlobals(env22);
+    const env2 = new Environment;
+    setupGlobals(env2);
     if (items) {
       for (const [key, value] of Object.entries(items)) {
-        env22.set(key, value);
+        env2.set(key, value);
       }
     }
-    const interpreter = new Interpreter(env22);
+    const interpreter = new Interpreter(env2);
     const result = interpreter.run(this.parsed);
     return result.value;
   }
@@ -6071,8 +6071,8 @@ function getFetchHeaders(urlOrPath) {
   const headers = new Headers;
   if (isNode) {
     const IS_CI = !!process.env?.TESTING_REMOTELY;
-    const version2 = env3.version;
-    headers.set("User-Agent", `transformers.js/${version2}; is_ci/${IS_CI};`);
+    const version = env3.version;
+    headers.set("User-Agent", `transformers.js/${version}; is_ci/${IS_CI};`);
     const isHFURL = isValidUrl(urlOrPath, ["http:", "https:"], ["huggingface.co", "hf.co"]);
     if (isHFURL) {
       const token = process.env?.HF_TOKEN ?? process.env?.HF_ACCESS_TOKEN;
@@ -6835,7 +6835,7 @@ function dynamic_time_warping(matrix) {
   const outputShape = [output_length + 1, input_length + 1];
   const cost = Array.from({ length: outputShape[0] }, () => Array(outputShape[1]).fill(Infinity));
   cost[0][0] = 0;
-  const trace2 = Array.from({ length: outputShape[0] }, () => Array(outputShape[1]).fill(-1));
+  const trace = Array.from({ length: outputShape[0] }, () => Array(outputShape[1]).fill(-1));
   for (let j2 = 1;j2 < outputShape[1]; ++j2) {
     for (let i2 = 1;i2 < outputShape[0]; ++i2) {
       const c0 = cost[i2 - 1][j2 - 1];
@@ -6853,14 +6853,14 @@ function dynamic_time_warping(matrix) {
         t = 2;
       }
       cost[i2][j2] = matrix[i2 - 1][j2 - 1] + c;
-      trace2[i2][j2] = t;
+      trace[i2][j2] = t;
     }
   }
   for (let i2 = 0;i2 < outputShape[1]; ++i2) {
-    trace2[0][i2] = 2;
+    trace[0][i2] = 2;
   }
   for (let i2 = 0;i2 < outputShape[0]; ++i2) {
-    trace2[i2][0] = 1;
+    trace[i2][0] = 1;
   }
   let i = output_length;
   let j = input_length;
@@ -6869,7 +6869,7 @@ function dynamic_time_warping(matrix) {
   while (i > 0 || j > 0) {
     text_indices.push(i - 1);
     time_indices.push(j - 1);
-    switch (trace2[i][j]) {
+    switch (trace[i][j]) {
       case 0:
         --i;
         --j;
@@ -9513,7 +9513,7 @@ async function es(a = {}) {
       };
     }, r.ad = (b, E) => {
       var I = E.buffer;
-      let { byteOffset: F, byteLength: j } = E;
+      let F = E.byteOffset, j = E.byteLength;
       if (E = 16 * Math.ceil(Number(j) / 16), b = L(b), !n) {
         var te = Dr(o);
         n = L(te);
@@ -13018,9 +13018,9 @@ function reshape(data, dimensions) {
   }
   return reshapedArray[0];
 }
-function permute(tensor2, axes) {
-  const [permutedData, shape] = permute_data(tensor2.data, tensor2.dims, axes);
-  return new Tensor22(tensor2.type, permutedData, shape);
+function permute(tensor, axes) {
+  const [permutedData, shape] = permute_data(tensor.data, tensor.dims, axes);
+  return new Tensor22(tensor.type, permutedData, shape);
 }
 function interpolate(input, [out_height, out_width], mode = "bilinear", align_corners = false) {
   const in_channels = input.dims.at(-3) ?? 1;
@@ -13180,8 +13180,8 @@ function cat(tensors, dim = 0) {
   const resultType = tensors[0].type;
   if (dim === 0) {
     let offset = 0;
-    for (const tensor2 of tensors) {
-      const tensorData = tensor2.data;
+    for (const tensor of tensors) {
+      const tensorData = tensor.data;
       result.set(tensorData, offset);
       offset += tensorData.length;
     }
@@ -13304,20 +13304,20 @@ function full(size, fill_value) {
   }
   return fullHelper(size, fill_value, dtype, typedArrayCls);
 }
-function full_like(tensor2, fill_value) {
-  return full(tensor2.dims, fill_value);
+function full_like(tensor, fill_value) {
+  return full(tensor.dims, fill_value);
 }
 function ones(size) {
   return fullHelper(size, 1n, "int64", BigInt64Array);
 }
-function ones_like(tensor2) {
-  return ones(tensor2.dims);
+function ones_like(tensor) {
+  return ones(tensor.dims);
 }
 function zeros(size) {
   return fullHelper(size, 0n, "int64", BigInt64Array);
 }
-function zeros_like(tensor2) {
-  return zeros(tensor2.dims);
+function zeros_like(tensor) {
+  return zeros(tensor.dims);
 }
 function rand(size) {
   const length = size.reduce((a, b) => a * b, 1);
@@ -13327,11 +13327,11 @@ function randn(size) {
   const length = size.reduce((a, b) => a * b, 1);
   return new Tensor22("float32", Float32Array.from({ length }, () => random.gauss()), size);
 }
-function quantize_embeddings(tensor2, precision) {
-  if (tensor2.dims.length !== 2) {
+function quantize_embeddings(tensor, precision) {
+  if (tensor.dims.length !== 2) {
     throw new Error("The tensor must have 2 dimensions");
   }
-  if (tensor2.dims.at(-1) % 8 !== 0) {
+  if (tensor.dims.at(-1) % 8 !== 0) {
     throw new Error("The last dimension of the tensor must be a multiple of 8");
   }
   if (!["binary", "ubinary"].includes(precision)) {
@@ -13340,7 +13340,7 @@ function quantize_embeddings(tensor2, precision) {
   const signed = precision === "binary";
   const dtype = signed ? "int8" : "uint8";
   const cls = signed ? Int8Array : Uint8Array;
-  const inputData = tensor2.data;
+  const inputData = tensor.data;
   const outputData = new cls(inputData.length / 8);
   for (let i = 0;i < inputData.length; ++i) {
     const bit = inputData[i] > 0 ? 1 : 0;
@@ -13351,7 +13351,7 @@ function quantize_embeddings(tensor2, precision) {
       outputData[arrayIndex] -= 128;
     }
   }
-  return new Tensor22(dtype, outputData, [tensor2.dims[0], tensor2.dims[1] / 8]);
+  return new Tensor22(dtype, outputData, [tensor.dims[0], tensor.dims[1] / 8]);
 }
 async function get_tokenizer_files(modelId) {
   if (!modelId) {
@@ -13367,16 +13367,16 @@ async function loadTokenizer(pretrained_model_name_or_path, options) {
   const tokenizerFiles = await get_tokenizer_files(pretrained_model_name_or_path);
   return await Promise.all(tokenizerFiles.map((file) => getModelJSON(pretrained_model_name_or_path, file, true, options)));
 }
-function prepareTensorForDecode(tensor2) {
-  const dims = tensor2.dims;
+function prepareTensorForDecode(tensor) {
+  const dims = tensor.dims;
   switch (dims.length) {
     case 1:
-      return tensor2.tolist();
+      return tensor.tolist();
     case 2:
       if (dims[0] !== 1) {
         throw new Error("Unable to decode tensor with `batch size !== 1`. Use `tokenizer.batch_decode(...)` for batched inputs.");
       }
-      return tensor2.tolist()[0];
+      return tensor.tolist()[0];
     default:
       throw new Error(`Expected tensor to have 1-2 dimensions, got ${dims.length}.`);
   }
@@ -15934,26 +15934,26 @@ var RawImage = class _RawImage {
       return await loadImageFunction(img);
     }
   }
-  static fromTensor(tensor2, channel_format = "CHW") {
-    if (tensor2.dims.length !== 3) {
-      throw new Error(`Tensor should have 3 dimensions, but has ${tensor2.dims.length} dimensions.`);
+  static fromTensor(tensor, channel_format = "CHW") {
+    if (tensor.dims.length !== 3) {
+      throw new Error(`Tensor should have 3 dimensions, but has ${tensor.dims.length} dimensions.`);
     }
     if (channel_format === "CHW") {
-      tensor2 = tensor2.transpose(1, 2, 0);
+      tensor = tensor.transpose(1, 2, 0);
     } else if (channel_format === "HWC") {} else {
       throw new Error(`Unsupported channel format: ${channel_format}`);
     }
-    if (!(tensor2.data instanceof Uint8ClampedArray || tensor2.data instanceof Uint8Array)) {
-      throw new Error(`Unsupported tensor type: ${tensor2.type}`);
+    if (!(tensor.data instanceof Uint8ClampedArray || tensor.data instanceof Uint8Array)) {
+      throw new Error(`Unsupported tensor type: ${tensor.type}`);
     }
-    switch (tensor2.dims[2]) {
+    switch (tensor.dims[2]) {
       case 1:
       case 2:
       case 3:
       case 4:
-        return new _RawImage(tensor2.data, tensor2.dims[1], tensor2.dims[0], tensor2.dims[2]);
+        return new _RawImage(tensor.data, tensor.dims[1], tensor.dims[0], tensor.dims[2]);
       default:
-        throw new Error(`Unsupported number of channels: ${tensor2.dims[2]}`);
+        throw new Error(`Unsupported number of channels: ${tensor.dims[2]}`);
     }
   }
   grayscale() {
@@ -16240,13 +16240,13 @@ var RawImage = class _RawImage {
     return await canvas.convertToBlob({ type, quality });
   }
   toTensor(channel_format = "CHW") {
-    let tensor2 = new Tensor22("uint8", new Uint8Array(this.data), [this.height, this.width, this.channels]);
+    let tensor = new Tensor22("uint8", new Uint8Array(this.data), [this.height, this.width, this.channels]);
     if (channel_format === "HWC") {} else if (channel_format === "CHW") {
-      tensor2 = tensor2.permute(2, 0, 1);
+      tensor = tensor.permute(2, 0, 1);
     } else {
       throw new Error(`Unsupported channel format: ${channel_format}`);
     }
-    return tensor2;
+    return tensor;
   }
   toCanvas() {
     if (!apis.IS_WEB_ENV) {
@@ -19530,25 +19530,25 @@ async function sessionRun(session, inputs) {
   const checkedInputs = validateInputs(session, inputs);
   try {
     const ortFeed = Object.fromEntries(Object.entries(checkedInputs).map(([k2, v]) => {
-      const tensor2 = v.ort_tensor;
+      const tensor = v.ort_tensor;
       if (apis.IS_NODE_ENV) {
-        if (typeof Float16Array !== "undefined" && tensor2.cpuData instanceof Float16Array) {
-          tensor2.cpuData = new Uint16Array(tensor2.cpuData.buffer);
+        if (typeof Float16Array !== "undefined" && tensor.cpuData instanceof Float16Array) {
+          tensor.cpuData = new Uint16Array(tensor.cpuData.buffer);
         }
       }
-      return [k2, tensor2];
+      return [k2, tensor];
     }));
     const output = await runInferenceSession(session, ortFeed);
     return replaceTensors(output);
   } catch (e) {
-    const formatted = Object.fromEntries(Object.entries(checkedInputs).map(([k2, tensor2]) => {
+    const formatted = Object.fromEntries(Object.entries(checkedInputs).map(([k2, tensor]) => {
       const unpacked = {
-        type: tensor2.type,
-        dims: tensor2.dims,
-        location: tensor2.location
+        type: tensor.type,
+        dims: tensor.dims,
+        location: tensor.location
       };
       if (unpacked.location !== "gpu-buffer") {
-        unpacked.data = tensor2.data;
+        unpacked.data = tensor.data;
       }
       return [k2, unpacked];
     }));
@@ -19561,12 +19561,12 @@ function validateInputs(session, inputs) {
   const checkedInputs = /* @__PURE__ */ Object.create(null);
   const missingInputs = [];
   for (const inputName of session.inputNames) {
-    const tensor2 = inputs[inputName];
-    if (!(tensor2 instanceof Tensor22)) {
+    const tensor = inputs[inputName];
+    if (!(tensor instanceof Tensor22)) {
       missingInputs.push(inputName);
       continue;
     }
-    checkedInputs[inputName] = isONNXProxy() ? tensor2.clone() : tensor2;
+    checkedInputs[inputName] = isONNXProxy() ? tensor.clone() : tensor;
   }
   if (missingInputs.length > 0) {
     throw new Error(`An error occurred during model execution: "Missing the following inputs: ${missingInputs.join(", ")}.`);
@@ -20965,9 +20965,9 @@ var PreTrainedModel = class extends Callable {
     const sequences = new Tensor22("int64", all_input_ids.flat(), [all_input_ids.length, all_input_ids[0].length]);
     const past_key_values = getPastKeyValues(outputs, model_inputs.past_key_values);
     const cachedTensors = new Set(Object.values(past_key_values));
-    for (const tensor2 of Object.values(outputs)) {
-      if (tensor2.location === "gpu-buffer" && !cachedTensors.has(tensor2)) {
-        tensor2.dispose();
+    for (const tensor of Object.values(outputs)) {
+      if (tensor.location === "gpu-buffer" && !cachedTensors.has(tensor)) {
+        tensor.dispose();
       }
     }
     const keepCacheAlive = "past_key_values" in kwargs || generation_config.return_dict_in_generate;
@@ -23824,8 +23824,8 @@ var MultiModalityCausalLM = class extends MultiModalityPreTrainedModel {
     });
     const clamped = decoded_image.add_(1).mul_(255 / 2).clamp_(0, 255).to("uint8");
     const images = [];
-    for (const tensor2 of clamped) {
-      const img = RawImage.fromTensor(tensor2);
+    for (const tensor of clamped) {
+      const img = RawImage.fromTensor(tensor);
       images.push(img);
     }
     return images;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.41.2",
+  "version": "0.41.4",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/config/index.test.ts

@@ -3,6 +3,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { buildOpenCodeConfigWarningBanner } from "../shared/config-warning-surface";
 import { resolveHistorianModel } from "../shared/model-resolution";
 import { createTestTempDir } from "../shared/test-temp-dir";
 import {
@@ -192,6 +193,49 @@ describe("loadPluginConfig — preload user-config isolation", () => {
     });
 });
 
+describe("loadPluginConfig — parse failure diagnostics", () => {
+    it("recovers the reporter's stray leading character and keeps a loud location warning", () => {
+        const result = loadWithUserConfig('\\{\n  "cache_ttl": "1h"\n}');
+
+        expect(result.cache_ttl).toBe("1h");
+        expect(result.configParseFailures).toHaveLength(1);
+        expect(result.configParseFailures?.[0]).toMatchObject({
+            warningClass: "file-parse",
+            line: 1,
+            column: 1,
+            recovered: true,
+            message: "invalid symbol",
+        });
+        expect(result.configWarnings?.[0]).toContain(":1:1: invalid symbol");
+    });
+
+    it("keeps file parse and invalid-leaf warning classes distinct", () => {
+        const parseResult = loadWithUserConfig('\\{\n  "cache_ttl": "1h"\n}');
+        const leafResult = loadWithUserConfig('{"protected_tags":"bogus"}');
+
+        expect(parseResult.configWarningDetails?.[0]?.warningClass).toBe("file-parse");
+        expect(
+            leafResult.configWarningDetails?.some(
+                (detail) => detail.warningClass === "invalid-leaf",
+            ),
+        ).toBe(true);
+    });
+
+    it("puts a recovered parse failure first in the OpenCode warning banner", () => {
+        const result = loadWithUserConfig('\\{\n  "cache_ttl": "1h"\n}');
+        const failures = result.configParseFailures ?? [];
+        const banner = buildOpenCodeConfigWarningBanner(
+            result.configWarnings ?? [],
+            failures,
+            failures,
+        );
+
+        expect(banner).toStartWith("## ⚠️ Magic Context Config Warning");
+        expect(banner.indexOf("PARSE FAILED")).toBeLessThan(banner.indexOf("Fix the reported"));
+        expect(banner).toContain(":1:1");
+    });
+});
+
 describe("loadPluginConfig — graduated mural config", () => {
     it("adopts legacy experimental.mural at the top-level and warns once", () => {
         const result = loadWithUserConfig(
@@ -1509,3 +1553,31 @@ describe("loadPluginConfigDetailed — prompt-surface registration owner", () =>
         }
     });
 });
+
+describe("shared per-harness config loading", () => {
+    it("lets OpenCode load Pi and OMP agent blocks without schema recovery warnings", () => {
+        const config = loadWithUserConfig(
+            JSON.stringify({
+                historian: {
+                    opencode: { model: "anthropic/opencode-historian" },
+                    pi: { model: "anthropic/pi-historian", thinking_level: "high" },
+                    omp: { model: "anthropic/omp-historian", thinking_level: "auto" },
+                },
+                dreamer: {
+                    opencode: { model: "anthropic/opencode-dreamer" },
+                    pi: { model: "anthropic/pi-dreamer", thinking_level: "medium" },
+                    omp: { model: "anthropic/omp-dreamer", thinking_level: "inherit" },
+                },
+            }),
+        );
+
+        expect(config.configWarnings).toBeUndefined();
+        expect(config.historian?.omp).toEqual({
+            model: "anthropic/omp-historian",
+            thinking_level: "auto",
+        });
+        expect(resolveHistorianModel(config, "opencode").primary?.model).toBe(
+            "anthropic/opencode-historian",
+        );
+    });
+});

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