fix: tighten embeddingModelsMatch to token-boundary containment (D2)

The substitution guard's match test was a plain substring check
(a.includes(b) || b.includes(a)). That's loose in both directions: a broadly-
configured model id like `qwen3-embedding` would MATCH an unrelated served model
that merely contains it as an interior token — e.g. served
`text-embedding-qwen3-embedding-0.6b` → store 0.6b vectors under the broad
identity (wrong-dimension corruption, the exact failure the guard exists to stop).

Now the shorter name must align on a `-`/`/` boundary as a genuine PREFIX (vendor-
trim: `openai/X` ↔ `X`) or SUFFIX (version-expansion: `…-small` → `…-small-v1`)
of the longer — never an interior fragment. Keeps the legitimate tolerance,
closes the corruption hole. +6 unit tests (incl. the interior-token rejection and
a non-boundary prefix collision). Pi inherits via core.

Gate: plugin embedding tests 26/0, Pi tsc clean.

Author: ualtinok

packages/plugin/src/features/magic-context/memory/embedding-openai.test.ts

@@ -1,5 +1,43 @@
 import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import { OpenAICompatibleEmbeddingProvider } from "./embedding-openai";
+import { embeddingModelsMatch, OpenAICompatibleEmbeddingProvider } from "./embedding-openai";
+
+describe("embeddingModelsMatch token-boundary semantics", () => {
+    test("exact match", () => {
+        expect(embeddingModelsMatch("qwen3-embedding-4b", "qwen3-embedding-4b")).toBe(true);
+    });
+    test("version-expansion suffix on a boundary matches", () => {
+        expect(embeddingModelsMatch("text-embedding-3-small-v1", "text-embedding-3-small")).toBe(
+            true,
+        );
+    });
+    test("vendor-prefix trim on a boundary matches (either direction)", () => {
+        expect(
+            embeddingModelsMatch("openai/text-embedding-3-small", "text-embedding-3-small"),
+        ).toBe(true);
+        expect(
+            embeddingModelsMatch("text-embedding-3-small", "openai/text-embedding-3-small"),
+        ).toBe(true);
+    });
+    test("REJECTS a broad configured name contained as an interior token (corruption hole)", () => {
+        // The bug: served `…-qwen3-embedding-0.6b` contains configured `qwen3-embedding`
+        // but `0.6b` is a distinct model token, not a version suffix.
+        expect(embeddingModelsMatch("text-embedding-qwen3-embedding-0.6b", "qwen3-embedding")).toBe(
+            false,
+        );
+        expect(
+            embeddingModelsMatch("qwen3-embedding-4b-dwq", "text-embedding-qwen3-embedding-0.6b"),
+        ).toBe(false);
+    });
+    test("REJECTS a non-boundary prefix collision (small vs smaller)", () => {
+        expect(embeddingModelsMatch("text-embedding-3-smallish", "text-embedding-3-small")).toBe(
+            false,
+        );
+    });
+    test("empty served or requested cannot be compared → not rejected", () => {
+        expect(embeddingModelsMatch("", "anything")).toBe(true);
+        expect(embeddingModelsMatch("anything", "")).toBe(true);
+    });
+});
 
 type FetchLike = typeof fetch;
 

packages/plugin/src/features/magic-context/memory/embedding-openai.ts

@@ -35,17 +35,33 @@ function normalizeEndpoint(endpoint?: string): string {
 /**
  * Whether the model an endpoint served is the model we asked for.
  *
- * Exact match after trim+lowercase, with prefix/suffix tolerance so a server
- * that version-expands a name (`text-embedding-3-small` → `…-small-v1`) or
- * trims a vendor prefix still counts as a match. A genuine substitution to a
- * DIFFERENT model (e.g. requested `qwen3-embedding-4b-dwq`, served
- * `text-embedding-qwen3-embedding-0.6b` — neither contains the other) does not.
+ * Exact match after trim+lowercase, with TOKEN-BOUNDARY prefix/suffix tolerance
+ * so a server that version-expands a name (`text-embedding-3-small` →
+ * `…-small-v1`) or trims a vendor prefix (`openai/text-embedding-3-small` →
+ * `text-embedding-3-small`) still counts as a match.
+ *
+ * Crucially this is NOT a plain substring test. A loose `a.includes(b)` would
+ * MATCH a broadly-configured name against an unrelated served model that merely
+ * contains it as a middle token — e.g. configured `qwen3-embedding`, served
+ * `text-embedding-qwen3-embedding-0.6b` → store 0.6b vectors under the broad
+ * identity (wrong-dim corruption, the exact failure this guard exists to stop).
+ * So the shorter name must align on a `-`/`/` boundary as a genuine PREFIX or
+ * SUFFIX of the longer, never as an interior fragment.
  */
 export function embeddingModelsMatch(served: string, requested: string): boolean {
     const a = served.trim().toLowerCase();
     const b = requested.trim().toLowerCase();
     if (a.length === 0 || b.length === 0) return true; // can't compare → don't reject
-    return a === b || a.includes(b) || b.includes(a);
+    if (a === b) return true;
+    const longer = a.length >= b.length ? a : b;
+    const shorter = a.length >= b.length ? b : a;
+    const isBoundary = (ch: string) => ch === "-" || ch === "/";
+    // Version-expansion: longer = shorter + boundary + suffix (e.g. `…-small` → `…-small-v1`).
+    if (longer.startsWith(shorter) && isBoundary(longer.charAt(shorter.length))) return true;
+    // Vendor-prefix trim: longer = prefix + boundary + shorter (e.g. `openai/X` ↔ `X`).
+    if (longer.endsWith(shorter) && isBoundary(longer.charAt(longer.length - shorter.length - 1)))
+        return true;
+    return false;
 }
 
 /**