@cortexkit/opencode-magic-context 0.41.1 → 0.41.3

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.1",
+  "version": "0.41.3",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -35,9 +35,10 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p ../retina-local-fs/tsconfig.build.json && bun run build:tui && rm -f dist/index.js dist/transformers-web.js dist/*-*.js && bun build src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun build src/index.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --external onnxruntime-node --external onnxruntime-web --external sharp --external bun:sqlite --external node:sqlite && tsc --emitDeclarationOnly",
+    "build": "tsc -p ../retina-local-fs/tsconfig.build.json && bun run build:tui && rm -f dist/index.js dist/transformers-web.js dist/transformers-node-wasm.js dist/*-*.js && bun build src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun scripts/build-transformers-node-wasm.ts dist && bun build src/index.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --external onnxruntime-node --external onnxruntime-web --external sharp --external bun:sqlite --external node:sqlite && tsc --emitDeclarationOnly",
     "build:tui": "bun scripts/build-tui.ts",
     "check:tui-compiled": "bun run build:tui && git diff --exit-code -- src/tui-compiled && test -z \"$(git status --porcelain -- src/tui-compiled)\"",
+    "check:transformers-node-wasm": "bun scripts/verify-transformers-node-wasm.ts",
     "typecheck": "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit && tsc -p tsconfig.scripts.json",
     "test": "bun install --frozen-lockfile && bun test --parallel --timeout 30000",
     "test:serial": "bun install --frozen-lockfile && bun test --timeout 30000",
@@ -66,7 +67,7 @@
   },
   "optionalDependencies": {
     "onnxruntime-node": "1.24.3",
-    "sharp": "^0.34.5"
+    "sharp": "^0.35.0"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "3.0.82",

package/src/config/index.test.ts

@@ -5,6 +5,11 @@ import { join } from "node:path";
 
 import { resolveHistorianModel } from "../shared/model-resolution";
 import { createTestTempDir } from "../shared/test-temp-dir";
+import {
+    getWindowOverlay,
+    reloadWindowOverlay,
+    setWindowOverlayPath,
+} from "../shared/window-geometry";
 import { loadPluginConfig, loadPluginConfigDetailed } from "./index";
 import { resolveConfigProfile } from "./profiles";
 import { DEFAULT_LOCAL_EMBEDDING_MODEL } from "./schema/magic-context";
@@ -113,6 +118,42 @@ function loadWithUserAndProjectConfig(
     }
 }
 
+describe("loadPluginConfig — Fusiform overlay reload", () => {
+    it("does not invalidate a same-path overlay during routine config reads", () => {
+        const overlayDir = mkdtempSync(join(tmpdir(), "mc-config-overlay-"));
+        const overlayPath = join(overlayDir, "window-overlay.json");
+        const configText = JSON.stringify({ models: { window_overlay_path: overlayPath } });
+        const writeOverlay = (modelId: string) =>
+            writeFileSync(
+                overlayPath,
+                JSON.stringify({
+                    schema: "fusiform-window-overlay/v1",
+                    generated_at: "2026-09-01T00:00:00Z",
+                    minted_provider_ids: [],
+                    cells: [{ provider_id: "hunt-provider", model_id: modelId, facts: {} }],
+                }),
+            );
+
+        try {
+            writeOverlay("before-rewrite");
+            loadWithUserConfig(configText);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            writeOverlay("after-rewrite");
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            loadWithUserConfig(configText);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            reloadWindowOverlay(overlayPath);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("after-rewrite");
+        } finally {
+            setWindowOverlayPath(undefined);
+            rmSync(overlayDir, { recursive: true, force: true });
+        }
+    });
+});
+
 describe("loadPluginConfig — preload user-config isolation", () => {
     it("resolves schema-default embedding config for a fixture with no config (#388)", () => {
         const projectDir = mkdtempSync(join(tmpdir(), "mc-config-preload-fixture-"));
@@ -1468,3 +1509,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/latch-permanence-guard.test.ts

@@ -27,6 +27,11 @@ const KNOWN_SLOTS: Record<string, KnownSlot> = {
         classification: "VERDICT",
         reason: "Correct: a missing or unloadable native binding needs an install repair, which this process cannot observe.",
     },
+    "packages/plugin/src/features/magic-context/memory/embedding-local.ts:localEmbeddingProcessFailure":
+        {
+            classification: "DIAGNOSTIC",
+            reason: "Most-recent local runtime diagnostic: successful initialization and test reset both clear it; the separate runtime-mode slot owns the process verdict.",
+        },
     "packages/plugin/src/features/magic-context/memory/embedding-synapse.ts:sharedClientPromise": {
         classification: "VERDICT",
         reason: "DEFECT: a rejected connection promise remains shared after the daemon recovers.",