@konneal/engine 0.2.98 → 0.2.100

package/dist/{ask-4G24T25V.js → ask-KP42T6DH.js}

@@ -1,8 +1,8 @@
 import {
   handleAsk
-} from "./chunk-BIX3SMC7.js";
-import "./chunk-A3ELAHKF.js";
-import "./chunk-TXPWLKCI.js";
+} from "./chunk-GYCUMFOA.js";
+import "./chunk-QNLFNEI4.js";
+import "./chunk-BBKAETKM.js";
 import "./chunk-KNCRYAX3.js";
 import "./chunk-DTW4UW2E.js";
 import "./chunk-A3QHHUN5.js";

package/dist/{chunk-TXPWLKCI.js → chunk-BBKAETKM.js}

@@ -114,6 +114,69 @@ var STOP = /* @__PURE__ */ new Set([
   "their",
   "there"
 ]);
+function rowMeta(r) {
+  return {
+    doc_id: String(r.doc_id ?? ""),
+    docidentifier: String(r.docidentifier ?? ""),
+    doctype: String(r.doctype ?? ""),
+    doc_number: String(r.doc_number ?? ""),
+    edition: String(r.edition ?? ""),
+    language: String(r.language ?? "en"),
+    clause_anchor: String(r.clause_anchor ?? ""),
+    clause_title: String(r.clause_title ?? ""),
+    tier: String(r.tier ?? ""),
+    corpus: String(r.corpus ?? ""),
+    text_ref: "",
+    status: String(r.status ?? "unknown"),
+    superseded_by: String(r.superseded_by ?? ""),
+    // contract v2 over the lexical lane: typed chunks arriving via BM25
+    // keep their unit identity ([[u:…]] refs, typed pin, retyping check)
+    unit_id: String(r.unit_id ?? "") || void 0,
+    block: String(r.block ?? "") || void 0
+  };
+}
+function rowsToHits(rows) {
+  return rows.map((r) => {
+    const bm25 = typeof r.rank === "number" ? r.rank : 0;
+    return {
+      id: String(r.id),
+      score: 1 / (1 + Math.max(0, bm25)),
+      metadata: rowMeta(r),
+      text: String(r.text ?? "")
+    };
+  });
+}
+function rowsToMatches(rows) {
+  return rows.map((r) => {
+    const bm25 = typeof r.rank === "number" ? Math.max(0, r.rank) : 0;
+    return {
+      id: String(r.id),
+      score: 1 / (1 + bm25),
+      metadata: { ...rowMeta(r), chunk_text: String(r.text ?? "") }
+    };
+  });
+}
+async function lexicalWithin(env, query, docNumbers, k = 12) {
+  const match2 = ftsMatchQuery(query);
+  if (!match2 || !docNumbers.length) return [];
+  try {
+    const placeholders = docNumbers.map((_, i) => `?${i + 2}`).join(",");
+    const res = await env.DB.prepare(
+      `SELECT c.id, c.doc_id, c.docidentifier, c.doctype, c.doc_number, c.edition,
+              c.language, c.clause_anchor, c.clause_title, c.status, c.superseded_by,
+              c.corpus, c.tier, c.text, c.unit_id, c.block, bm25(chunks_fts) AS rank
+         FROM chunks_fts
+         JOIN chunks c ON c.rowid = chunks_fts.rowid
+        WHERE chunks_fts MATCH ?1 AND c.doc_number IN (${placeholders})
+        ORDER BY rank
+        LIMIT ?${docNumbers.length + 2}`
+    ).bind(match2, ...docNumbers, k).all();
+    return rowsToMatches(res.results ?? []);
+  } catch (e) {
+    console.log("lexical-within failed:", String(e).slice(0, 200));
+    return [];
+  }
+}
 async function lexicalPrefilter(env, query, k = LEXICAL_K) {
   const match2 = ftsMatchQuery(query);
   if (!match2) return [];
@@ -129,34 +192,7 @@ async function lexicalPrefilter(env, query, k = LEXICAL_K) {
         LIMIT ?2`
     ).bind(match2, k).all();
     const rows = res.results ?? [];
-    return rows.map((r, i) => {
-      const meta = {
-        doc_id: String(r.doc_id ?? ""),
-        docidentifier: String(r.docidentifier ?? ""),
-        doctype: String(r.doctype ?? ""),
-        doc_number: String(r.doc_number ?? ""),
-        edition: String(r.edition ?? ""),
-        language: String(r.language ?? "en"),
-        clause_anchor: String(r.clause_anchor ?? ""),
-        clause_title: String(r.clause_title ?? ""),
-        tier: String(r.tier ?? ""),
-        corpus: String(r.corpus ?? ""),
-        text_ref: "",
-        status: String(r.status ?? "unknown"),
-        superseded_by: String(r.superseded_by ?? ""),
-        // contract v2 over the lexical lane: typed chunks arriving via BM25
-        // keep their unit identity ([[u:…]] refs, typed pin, retyping check)
-        unit_id: String(r.unit_id ?? "") || void 0,
-        block: String(r.block ?? "") || void 0
-      };
-      const bm25 = typeof r.rank === "number" ? r.rank : i;
-      return {
-        id: String(r.id),
-        score: 1 / (1 + Math.max(0, bm25)),
-        metadata: meta,
-        text: String(r.text ?? "")
-      };
-    });
+    return rowsToHits(rows);
   } catch (e) {
     console.log("lexical prefilter failed:", String(e).slice(0, 200));
     return [];
@@ -21935,7 +21971,14 @@ var oimlPubid = {
 var plainSlug = {
   parse: () => null,
   scanQuestion: () => null,
-  graphDocNumber: () => null,
+  // the graph node id scheme (doc:OIML-<TYPE>-<NUM>-<EDITION>) is the
+  // GRAPH's own identity, estate-wide — not publisher-flavored — so the
+  // plain codec parses it too (a null here silenced the concept-graph
+  // lane's resolution for its whole life)
+  graphDocNumber: (nodeId) => {
+    const m = nodeId.match(/^doc:OIML-[A-Z]-(\d+)-/);
+    return m ? m[1] : null;
+  },
   familyOf: () => null
 };
 var REGISTRY = {
@@ -22477,14 +22520,10 @@ var conceptGraph = {
       }
     }
     if (numbers.size) {
-      const gc = await c.env.VECTORIZE.query(c.vector, {
-        topK: 12,
-        returnMetadata: "all",
-        filter: { doc_number: { $in: [...numbers] } }
-      });
+      const gc = await lexicalWithin(c.env, c.rq || c.query, [...numbers], 12);
       const seenIds0 = new Set(c.matches.map((m) => m.id));
       let merged0 = 0;
-      for (const m of (gc.matches ?? []).slice(0, 6)) {
+      for (const m of gc.slice(0, 6)) {
         if (!seenIds0.has(m.id)) {
           c.matches.push({ id: m.id, score: m.score * THRESHOLDS.conceptGraphDiscount, metadata: m.metadata });
           seenIds0.add(m.id);
@@ -22502,24 +22541,20 @@ var graphLane = {
   failure: "additive",
   when: (c) => !!c.opts.graphDocNumbers?.length && c.vector.length > 0,
   prefetch: (c) => {
-    c.lane["graph-lane"] = c.env.VECTORIZE.query(c.vector, {
-      topK: 15,
-      returnMetadata: "all",
-      filter: { doc_number: { $in: c.opts.graphDocNumbers } }
-    });
+    c.lane["graph-lane"] = lexicalWithin(c.env, c.rq || c.query, c.opts.graphDocNumbers, 15);
   },
   run: async (c) => {
     const g = await c.lane["graph-lane"];
     const seenIds = new Set(c.matches.map((m) => m.id));
     let merged = 0;
-    for (const m of (g.matches ?? []).slice(0, 10)) {
+    for (const m of (g ?? []).slice(0, 10)) {
       if (!seenIds.has(m.id)) {
         c.matches.push({ id: m.id, score: m.score * THRESHOLDS.graphLaneDiscount, metadata: m.metadata });
         seenIds.add(m.id);
         merged++;
       }
     }
-    console.log("graph lane:", g.matches?.length ?? 0, "hits,", merged, "merged");
+    console.log("graph lane:", g?.length ?? 0, "hits,", merged, "merged");
   }
 };
 

package/dist/{chunk-BIX3SMC7.js → chunk-GYCUMFOA.js}

@@ -18,7 +18,7 @@ import {
   tableRetyped,
   toolNote,
   verdictNote
-} from "./chunk-A3ELAHKF.js";
+} from "./chunk-QNLFNEI4.js";
 import {
   NO_CONTEXT,
   answerQuality,
@@ -56,7 +56,7 @@ import {
   tokenBudget,
   understandQuery,
   usageTotal
-} from "./chunk-TXPWLKCI.js";
+} from "./chunk-BBKAETKM.js";
 import {
   embed,
   generateOnce,

package/dist/{chunk-GY33RTEO.js → chunk-OREMF5LK.js}

@@ -6,7 +6,7 @@ import {
   sessionFrom,
   telemetry,
   understandQuery
-} from "./chunk-TXPWLKCI.js";
+} from "./chunk-BBKAETKM.js";
 import {
   portModelRunner
 } from "./chunk-KNCRYAX3.js";

package/dist/{chunk-A3ELAHKF.js → chunk-QNLFNEI4.js}

@@ -2,7 +2,8 @@ import {
   embed,
   hasLane,
   portIndex,
-  portModelRunner
+  portModelRunner,
+  portStore
 } from "./chunk-KNCRYAX3.js";
 import {
   standardKeysFrom
@@ -920,6 +921,140 @@ var bibEntry = {
     }
   }
 };
+async function unitByTerm(store, term) {
+  const t = term.trim();
+  if (!t) return null;
+  const q = (where, bind) => store.prepare(`SELECT * FROM units_db WHERE ${where} LIMIT 1`).bind(...bind).all().catch(() => ({ results: [] }));
+  const exact = await q("code = ?1 OR short = ?1 OR LOWER(name_en) = LOWER(?1)", [t]);
+  let rows = exact.results ?? [];
+  if (rows.length) return rows[0];
+  const sym = await q("LOWER(json_extract(symbols, '$.ascii')) = LOWER(?1)", [t]);
+  rows = sym.results ?? [];
+  if (rows.length) return rows[0];
+  const like = await q("LOWER(short) LIKE LOWER(?1) OR LOWER(name_en) LIKE LOWER(?1)", [`%${t}%`]);
+  rows = like.results ?? [];
+  return rows[0] ?? null;
+}
+async function resolveWithPrefix(store, term) {
+  const direct = await unitByTerm(store, term);
+  if (direct) return { unit: direct, prefixFactor: 1, prefixName: null };
+  const t = term.trim();
+  for (let cut = 1; cut < Math.min(t.length, 3); cut++) {
+    const pSym = t.slice(0, cut);
+    const rest = t.slice(cut);
+    if (!rest) continue;
+    const pres = await store.prepare("SELECT id, name_en, symbol, base, power FROM unit_prefixes WHERE symbol = ?1 AND base IS NOT NULL AND power IS NOT NULL").bind(pSym).all().catch(() => ({ results: [] }));
+    const prefix = (pres.results ?? [])[0];
+    if (!prefix) continue;
+    const unit = await unitByTerm(store, rest);
+    if (unit) return { unit, prefixFactor: Math.pow(prefix.base, prefix.power), prefixName: prefix.name_en };
+  }
+  return null;
+}
+var unitsLookup = {
+  name: "units.lookup",
+  description: "Look up a measurement unit in the unitsdb plane: its names and symbols, its dimension, its quantity kinds, and its SI decomposition. Bind a symbol or an everyday unit name to the dataset's canonical unit before computing with it.",
+  params: [{ key: "term", required: true, description: "a unit's code, short name, symbol or plain name, e.g. m, Pa, pascal, meter per second" }],
+  audiences: ["mcp"],
+  handler: async (env, args) => {
+    const term = String(args?.term ?? "").trim();
+    if (term.length < 1) return null;
+    try {
+      const store = portStore(env);
+      const unit = await unitByTerm(store, term);
+      if (!unit) {
+        return { name: "units.lookup", query: term, output: `No unit matches "${term}" in the unitsdb plane. State this plainly.` };
+      }
+      const qtyNames = [];
+      for (const qid of JSON.parse(unit.quantity_ids || "[]")) {
+        const r = await store.prepare("SELECT name_en FROM unit_quantities WHERE id = ?1").bind(qid).all().catch(() => ({ results: [] }));
+        const n = (r.results ?? [])[0]?.name_en;
+        if (n) qtyNames.push(n);
+      }
+      const roots = JSON.parse(unit.root_units || "[]");
+      const rootNames = await Promise.all(
+        roots.map(async (r) => {
+          const row = await unitByTerm(store, r.code);
+          return `${row?.short ?? r.code}^${r.power}`;
+        })
+      );
+      const symbols = JSON.parse(unit.symbols || "null");
+      return {
+        name: "units.lookup",
+        query: term,
+        output: JSON.stringify({
+          code: unit.code,
+          name_en: unit.name_en,
+          name_fr: unit.name_fr,
+          symbol: symbols?.ascii ?? null,
+          si_root: !!unit.root,
+          unit_system: unit.unit_system,
+          dimension: unit.dimension_ascii,
+          quantities: qtyNames.slice(0, 4),
+          si_decomposition: rootNames,
+          scale: unit.scale
+        })
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+var unitsConvert = {
+  name: "units.convert",
+  description: "Convert a value between two measurement units through the unitsdb plane. SI-coherent units convert exactly (prefix powers over the same dimension); a non-SI unit is stated honestly \u2014 the dataset defines a ratio scale for it, not a factor, and none is invented.",
+  params: [
+    { key: "value", required: true, description: "the numeric value to convert" },
+    { key: "from_unit", required: true, description: "the source unit, e.g. kPa, km, m" },
+    { key: "to_unit", required: true, description: "the target unit, e.g. Pa, m" }
+  ],
+  audiences: ["mcp"],
+  handler: async (env, args) => {
+    const value = Number(args?.value);
+    const fromTerm = String(args?.from_unit ?? "").trim();
+    const toTerm = String(args?.to_unit ?? "").trim();
+    if (!Number.isFinite(value) || !fromTerm || !toTerm) return null;
+    try {
+      const store = portStore(env);
+      const from = await resolveWithPrefix(store, fromTerm);
+      const to = await resolveWithPrefix(store, toTerm);
+      if (!from || !to) {
+        const missing = !from ? fromTerm : toTerm;
+        return { name: "units.convert", query: `${value} ${fromTerm} \u2192 ${toTerm}`, output: `No unit matches "${missing}" in the unitsdb plane. State this plainly.` };
+      }
+      if ((from.unit.dimension_ascii ?? "") !== (to.unit.dimension_ascii ?? "")) {
+        return {
+          name: "units.convert",
+          query: `${value} ${fromTerm} \u2192 ${toTerm}`,
+          output: `Not convertible: ${fromTerm} carries dimension ${from.unit.dimension_ascii ?? "unknown"} and ${toTerm} carries ${to.unit.dimension_ascii ?? "unknown"}. State this plainly.`
+        };
+      }
+      const coherent = (u) => !!u.unit_system && u.unit_system.toLowerCase().startsWith("si");
+      if (!coherent(from.unit) || !coherent(to.unit)) {
+        const nonSi = !coherent(from.unit) ? fromTerm : toTerm;
+        return {
+          name: "units.convert",
+          query: `${value} ${fromTerm} \u2192 ${toTerm}`,
+          output: `The dataset defines no numeric factor for ${nonSi} (a non-SI unit carried on a ${from.unit.scale ?? to.unit.scale ?? "ratio"} scale) \u2014 no factor is invented. State this plainly; the caller may supply the factor itself.`
+        };
+      }
+      const result = value * from.prefixFactor / to.prefixFactor;
+      return {
+        name: "units.convert",
+        query: `${value} ${fromTerm} \u2192 ${toTerm}`,
+        output: JSON.stringify({
+          value,
+          from: `${from.prefixName ? from.prefixName + " " : ""}${from.unit.name_en}`,
+          to: `${to.prefixName ? to.prefixName + " " : ""}${to.unit.name_en}`,
+          dimension: from.unit.dimension_ascii,
+          result
+        })
+      };
+    } catch {
+      return null;
+    }
+  }
+};
 var glossaryLookup = {
   name: "glossary.lookup",
   description: "Look up a defined term in the terminology datasets \u2014 the concept's definition and its defining publication. Bind everyday words to the defined term before interpreting a question.",
@@ -988,7 +1123,7 @@ var certificatesSearch = {
     return { name: "certificates.search", query, output };
   }
 };
-var TOOLS_REGISTRY = [certificatesSearch, unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck, bibEntry];
+var TOOLS_REGISTRY = [certificatesSearch, unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck, bibEntry, unitsLookup, unitsConvert];
 var TOOL_DECLARATION = [
   "You may use one tool before answering, by writing a single line:",
   ...TOOLS_REGISTRY.filter((t) => t.audiences.includes("agent")).map((t) => {

package/dist/lexical.d.ts

@@ -2,6 +2,18 @@ import type { Hit } from "./pipeline";
 /** Build a safe FTS5 MATCH query from user text: alphanumeric tokens,
  *  joined with OR so jargon hits don't require full-phrase match. */
 export declare function ftsMatchQuery(query: string): string | null;
+/** Lexical ranking WITHIN a document set (the graph lanes' identity
+ *  resolution): BM25 over the corpus's own FTS, restricted to the
+ *  documents' doc_number values. This is the working substitute for
+ *  Vectorize metadata filtering, which is dead on this index (measured
+ *  2026-10-05: filters return empty for values proven present). */
+export declare function lexicalWithin(env: {
+    DB: D1Database;
+}, query: string, docNumbers: string[], k?: number): Promise<{
+    id: string;
+    score: number;
+    metadata: Record<string, unknown>;
+}[]>;
 export declare function lexicalPrefilter(env: {
     DB: D1Database;
 }, query: string, k?: number): Promise<Hit[]>;

package/dist/{search-EQAOPFCC.js → search-4CBKKNBJ.js}

@@ -1,7 +1,7 @@
 import {
   handleSearch
-} from "./chunk-GY33RTEO.js";
-import "./chunk-TXPWLKCI.js";
+} from "./chunk-OREMF5LK.js";
+import "./chunk-BBKAETKM.js";
 import "./chunk-KNCRYAX3.js";
 import "./chunk-DTW4UW2E.js";
 import "./chunk-A3QHHUN5.js";

package/dist/{tools-YHEXFX6V.js → tools-ZNQY6ZMC.js}

@@ -4,7 +4,7 @@ import {
   parseToolCall,
   runTool,
   toolNote
-} from "./chunk-A3ELAHKF.js";
+} from "./chunk-QNLFNEI4.js";
 import "./chunk-KNCRYAX3.js";
 import "./chunk-U4ERFUOK.js";
 import "./chunk-BOAITSVV.js";

package/dist/tools-content.d.ts

@@ -7,4 +7,6 @@ export declare const licensedSection: ToolSpec;
 export declare const verdictEvaluate: ToolSpec;
 export declare const conditionsCheck: ToolSpec;
 export declare const bibEntry: ToolSpec;
+export declare const unitsLookup: ToolSpec;
+export declare const unitsConvert: ToolSpec;
 export declare const glossaryLookup: ToolSpec;

package/dist/worker_public/src/index.js

@@ -4,15 +4,15 @@ import {
   handleMemories,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-BIX3SMC7.js";
+} from "../../chunk-GYCUMFOA.js";
 import {
   TOOLS_REGISTRY,
   bindModelNode,
   modelGroundingBlock
-} from "../../chunk-A3ELAHKF.js";
+} from "../../chunk-QNLFNEI4.js";
 import {
   handleSearch
-} from "../../chunk-GY33RTEO.js";
+} from "../../chunk-OREMF5LK.js";
 import {
   buildMessages,
   citations,
@@ -34,7 +34,7 @@ import {
   sessionFrom,
   telemetry,
   understandQuery
-} from "../../chunk-TXPWLKCI.js";
+} from "../../chunk-BBKAETKM.js";
 import {
   cfBlobs,
   embed,
@@ -990,13 +990,13 @@ async function callToolOnce(env, ctx, _req, tier, key, name, args, t0) {
       // stream:false forces the JSON lane (anon defaults to SSE)
       body: JSON.stringify({ ...args, stream: false })
     });
-    const { runTool, TOOLS_REGISTRY: TOOLS_REGISTRY2 } = await import("../../tools-YHEXFX6V.js");
+    const { runTool, TOOLS_REGISTRY: TOOLS_REGISTRY2 } = await import("../../tools-ZNQY6ZMC.js");
     let payload;
     if (TOOLS_REGISTRY2.some((t) => t.name === name && t.audiences.includes("mcp"))) {
       const r = await runTool({ ...env, DB: env.DB }, { name, args }, "mcp");
       payload = r ? { tool: r.name, query: r.query, result: r.output } : { error: { message: `tool ${name} returned nothing for the given arguments` } };
     } else {
-      const res = name === "ask" ? await (await import("../../ask-4G24T25V.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-EQAOPFCC.js")).handleSearch(env, ctx, inner, tier, key);
+      const res = name === "ask" ? await (await import("../../ask-KP42T6DH.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-4CBKKNBJ.js")).handleSearch(env, ctx, inner, tier, key);
       payload = await res.json().catch(() => ({ error: { message: "tool transport failed", status: res.status } }));
     }
     telemetry(env, ctx, tier, `mcp:${name}`, null, !payload?.error, JSON.stringify(payload).length, await sha256Hex(`${name}:${JSON.stringify(args ?? {})}`), void 0, void 0, { durationMs: Date.now() - t0 });

package/package.json

@@ -27,7 +27,7 @@
     "playwright": "^1.62.1",
     "yaml": "^2.9.1"
   },
-  "version": "0.2.98",
+  "version": "0.2.100",
   "description": "The Konneal engine: the publisher-agnostic build pipeline and API plane for standards intelligence (retrieval, answer contract, verdicts, evaluation).",
   "license": "BSD-3-Clause",
   "type": "module",

package/workers/worker_public/src/codecs.ts

@@ -142,7 +142,14 @@ export const oimlPubid: RefCodec = {
 export const plainSlug: RefCodec = {
   parse: () => null,
   scanQuestion: () => null,
-  graphDocNumber: () => null,
+  // the graph node id scheme (doc:OIML-<TYPE>-<NUM>-<EDITION>) is the
+  // GRAPH's own identity, estate-wide — not publisher-flavored — so the
+  // plain codec parses it too (a null here silenced the concept-graph
+  // lane's resolution for its whole life)
+  graphDocNumber: (nodeId) => {
+    const m = nodeId.match(/^doc:OIML-[A-Z]-(\d+)-/);
+    return m ? m[1] : null;
+  },
   familyOf: () => null,
 };
 

package/workers/worker_public/src/lexical.ts

@@ -31,6 +31,89 @@ const STOP = new Set([
   "about", "into", "than", "then", "its", "it", "their", "there",
 ]);
 
+function rowMeta(r: any): ChunkMeta {
+  return {
+    doc_id: String(r.doc_id ?? ""),
+    docidentifier: String(r.docidentifier ?? ""),
+    doctype: String(r.doctype ?? ""),
+    doc_number: String(r.doc_number ?? ""),
+    edition: String(r.edition ?? ""),
+    language: String(r.language ?? "en"),
+    clause_anchor: String(r.clause_anchor ?? ""),
+    clause_title: String(r.clause_title ?? ""),
+    tier: String(r.tier ?? ""),
+    corpus: String(r.corpus ?? ""),
+    text_ref: "",
+    status: String(r.status ?? "unknown"),
+    superseded_by: String(r.superseded_by ?? ""),
+    // contract v2 over the lexical lane: typed chunks arriving via BM25
+    // keep their unit identity ([[u:…]] refs, typed pin, retyping check)
+    unit_id: String(r.unit_id ?? "") || undefined,
+    block: String(r.block ?? "") || undefined,
+  };
+}
+
+function rowsToHits(rows: any[]): Hit[] {
+  return rows.map((r: any) => {
+    // rank is bm25 (lower better) → convert to positive score that RRF can ignore
+    // (RRF uses rank position, not score). score kept for logging only.
+    const bm25 = typeof r.rank === "number" ? r.rank : 0;
+    return {
+      id: String(r.id),
+      score: 1 / (1 + Math.max(0, bm25)),
+      metadata: rowMeta(r),
+      text: String(r.text ?? ""),
+    } satisfies Hit;
+  });
+}
+
+/** Lexical matches for the lane merges: match-shaped, with the text
+ *  riding the metadata (toHits reads chunk_text out of it). */
+function rowsToMatches(rows: any[]): { id: string; score: number; metadata: Record<string, unknown> }[] {
+  return rows.map((r: any) => {
+    const bm25 = typeof r.rank === "number" ? Math.max(0, r.rank) : 0;
+    return {
+      id: String(r.id),
+      score: 1 / (1 + bm25),
+      metadata: { ...rowMeta(r), chunk_text: String(r.text ?? "") },
+    };
+  });
+}
+
+/** Lexical ranking WITHIN a document set (the graph lanes' identity
+ *  resolution): BM25 over the corpus's own FTS, restricted to the
+ *  documents' doc_number values. This is the working substitute for
+ *  Vectorize metadata filtering, which is dead on this index (measured
+ *  2026-10-05: filters return empty for values proven present). */
+export async function lexicalWithin(
+  env: { DB: D1Database },
+  query: string,
+  docNumbers: string[],
+  k = 12,
+): Promise<{ id: string; score: number; metadata: Record<string, unknown> }[]> {
+  const match = ftsMatchQuery(query);
+  if (!match || !docNumbers.length) return [];
+  try {
+    const placeholders = docNumbers.map((_, i) => `?${i + 2}`).join(",");
+    const res = await env.DB.prepare(
+      `SELECT c.id, c.doc_id, c.docidentifier, c.doctype, c.doc_number, c.edition,
+              c.language, c.clause_anchor, c.clause_title, c.status, c.superseded_by,
+              c.corpus, c.tier, c.text, c.unit_id, c.block, bm25(chunks_fts) AS rank
+         FROM chunks_fts
+         JOIN chunks c ON c.rowid = chunks_fts.rowid
+        WHERE chunks_fts MATCH ?1 AND c.doc_number IN (${placeholders})
+        ORDER BY rank
+        LIMIT ?${docNumbers.length + 2}`,
+    )
+      .bind(match, ...docNumbers, k)
+      .all();
+    return rowsToMatches(res.results ?? []);
+  } catch (e) {
+    console.log("lexical-within failed:", String(e).slice(0, 200));
+    return [];
+  }
+}
+
 export async function lexicalPrefilter(env: { DB: D1Database }, query: string, k = LEXICAL_K): Promise<Hit[]> {
   const match = ftsMatchQuery(query);
   if (!match) return [];
@@ -49,36 +132,7 @@ export async function lexicalPrefilter(env: { DB: D1Database }, query: string, k
       .bind(match, k)
       .all();
     const rows = res.results ?? [];
-    return rows.map((r: any, i: number) => {
-      const meta: ChunkMeta = {
-        doc_id: String(r.doc_id ?? ""),
-        docidentifier: String(r.docidentifier ?? ""),
-        doctype: String(r.doctype ?? ""),
-        doc_number: String(r.doc_number ?? ""),
-        edition: String(r.edition ?? ""),
-        language: String(r.language ?? "en"),
-        clause_anchor: String(r.clause_anchor ?? ""),
-        clause_title: String(r.clause_title ?? ""),
-        tier: String(r.tier ?? ""),
-        corpus: String(r.corpus ?? ""),
-        text_ref: "",
-        status: String(r.status ?? "unknown"),
-        superseded_by: String(r.superseded_by ?? ""),
-        // contract v2 over the lexical lane: typed chunks arriving via BM25
-        // keep their unit identity ([[u:…]] refs, typed pin, retyping check)
-        unit_id: String(r.unit_id ?? "") || undefined,
-        block: String(r.block ?? "") || undefined,
-      };
-      // rank is bm25 (lower better) → convert to positive score that RRF can ignore
-      // (RRF uses rank position, not score). score kept for logging only.
-      const bm25 = typeof r.rank === "number" ? r.rank : i;
-      return {
-        id: String(r.id),
-        score: 1 / (1 + Math.max(0, bm25)),
-        metadata: meta,
-        text: String(r.text ?? ""),
-      } satisfies Hit;
-    });
+    return rowsToHits(rows);
   } catch (e) {
     console.log("lexical prefilter failed:", String(e).slice(0, 200));
     return [];

package/workers/worker_public/src/stages/conceptGraph.ts

@@ -20,6 +20,7 @@
 import { THRESHOLDS } from "../config.ts";
 import type { Stage } from "./types.ts";
 import { refCodec } from "../codecs.ts";
+import { lexicalWithin } from "../lexical.ts";
 
 export const conceptGraph: Stage = {
   name: "concept-graph",
@@ -49,14 +50,14 @@ export const conceptGraph: Stage = {
       }
     }
     if (numbers.size) {
-      const gc = await c.env.VECTORIZE.query(c.vector, {
-        topK: 12,
-        returnMetadata: "all",
-        filter: { doc_number: { $in: [...numbers] } },
-      });
+      // identity resolution: the linked documents' query-relevant
+      // candidates rank by the corpus's own BM25 within the set — the
+      // index filter this lane used returned empty for its whole life
+      // (Vectorize metadata filtering is dead on this index)
+      const gc = await lexicalWithin(c.env, c.rq || c.query, [...numbers], 12);
       const seenIds0 = new Set(c.matches.map((m: any) => m.id));
       let merged0 = 0;
-      for (const m of (gc.matches ?? []).slice(0, 6)) {
+      for (const m of gc.slice(0, 6)) {
         if (!seenIds0.has(m.id)) {
           c.matches.push({ id: m.id, score: m.score * THRESHOLDS.conceptGraphDiscount, metadata: m.metadata });
           seenIds0.add(m.id);

package/workers/worker_public/src/stages/graphLane.ts

@@ -1,7 +1,15 @@
 // Graph lane (additive): the caller-resolved document numbers (relaton
-// family/successor resolution done in index.ts) merge their top
-// candidates at a discount.
+// family/successor resolution done in index.ts) merge their
+// query-relevant candidates at a discount.
+//
+// Identity resolution, not index filtering: the candidates rank by the
+// corpus's own BM25 WITHIN the document set (lexicalWithin) — Vectorize
+// metadata filtering is dead on this index (measured 2026-10-05:
+// filters return empty for values proven present), so the filter this
+// lane used for its whole life merged nothing. The lexical rows carry
+// their own text and metadata; no index round trip is needed at all.
 import { THRESHOLDS } from "../config.ts";
+import { lexicalWithin } from "../lexical.ts";
 import type { Stage } from "./types.ts";
 
 export const graphLane: Stage = {
@@ -9,23 +17,19 @@ export const graphLane: Stage = {
   failure: "additive",
   when: (c) => !!c.opts.graphDocNumbers?.length && c.vector.length > 0,
   prefetch: (c) => {
-    c.lane["graph-lane"] = c.env.VECTORIZE.query(c.vector, {
-      topK: 15,
-      returnMetadata: "all",
-      filter: { doc_number: { $in: c.opts.graphDocNumbers } },
-    });
+    c.lane["graph-lane"] = lexicalWithin(c.env, c.rq || c.query, c.opts.graphDocNumbers!, 15);
   },
   run: async (c) => {
     const g = (await c.lane["graph-lane"]!) as any;
     const seenIds = new Set(c.matches.map((m: any) => m.id));
     let merged = 0;
-    for (const m of (g.matches ?? []).slice(0, 10)) {
+    for (const m of (g ?? []).slice(0, 10)) {
       if (!seenIds.has(m.id)) {
         c.matches.push({ id: m.id, score: m.score * THRESHOLDS.graphLaneDiscount, metadata: m.metadata });
         seenIds.add(m.id);
         merged++;
       }
     }
-    console.log("graph lane:", g.matches?.length ?? 0, "hits,", merged, "merged");
+    console.log("graph lane:", g?.length ?? 0, "hits,", merged, "merged");
   },
 };

package/workers/worker_public/src/tools-content.ts

@@ -7,7 +7,7 @@
 // tool-selection quality degrades with menu size.
 import type { ToolSpec } from "./tools.ts";
 import { resolveBlocks } from "./refs.ts";
-import { portIndex, portModelRunner, hasLane } from "./env.ts";
+import { portIndex, portModelRunner, hasLane, portStore } from "./env.ts";
 import { embed } from "./ai.ts";
 import { THRESHOLDS } from "./config.ts";
 import { standardKeysFrom } from "./requestScope.ts";
@@ -428,6 +428,178 @@ export const bibEntry: ToolSpec = {
   },
 };
 
+
+// The unitsdb plane (the owner's 2026-10-05 direction): measurement
+// units as machine-shaped data — the dataset's typed projection in D1
+// (units_db / unit_quantities / unit_prefixes), served as tools agents
+// compute with. Conversion is honest about its scope: SI-coherent
+// units convert through prefix powers; the dataset defines no numeric
+// factors for non-SI units (foot, pound) — a ratio scale is not a
+// factor — and the tool says so instead of inventing one.
+
+interface UnitRow {
+  code: string;
+  short: string | null;
+  name_en: string | null;
+  name_fr: string | null;
+  root: number;
+  symbols: string | null;
+  root_units: string | null;
+  dimension_id: string | null;
+  dimension_ascii: string | null;
+  quantity_ids: string | null;
+  unit_system: string | null;
+  scale: string | null;
+}
+
+async function unitByTerm(store: any, term: string): Promise<UnitRow | null> {
+  const t = term.trim();
+  if (!t) return null;
+  const q = (where: string, bind: unknown[]) =>
+    store.prepare(`SELECT * FROM units_db WHERE ${where} LIMIT 1`).bind(...bind).all().catch(() => ({ results: [] }));
+  const exact = await q("code = ?1 OR short = ?1 OR LOWER(name_en) = LOWER(?1)", [t]);
+  let rows = (exact.results ?? []) as UnitRow[];
+  if (rows.length) return rows[0]!;
+  const sym = await q("LOWER(json_extract(symbols, '$.ascii')) = LOWER(?1)", [t]);
+  rows = (sym.results ?? []) as UnitRow[];
+  if (rows.length) return rows[0]!;
+  const like = await q("LOWER(short) LIKE LOWER(?1) OR LOWER(name_en) LIKE LOWER(?1)", [`%${t}%`]);
+  rows = (like.results ?? []) as UnitRow[];
+  return rows[0] ?? null;
+}
+
+/** A prefixed input ("kPa", "km"): the first symbols name a prefix,
+ *  the remainder a unit — the dataset does not enumerate prefixed
+ *  variants, they are derived. Returns the factor the prefix carries. */
+async function resolveWithPrefix(store: any, term: string): Promise<{ unit: UnitRow; prefixFactor: number; prefixName: string | null } | null> {
+  const direct = await unitByTerm(store, term);
+  if (direct) return { unit: direct, prefixFactor: 1, prefixName: null };
+  const t = term.trim();
+  for (let cut = 1; cut < Math.min(t.length, 3); cut++) {
+    const pSym = t.slice(0, cut);
+    const rest = t.slice(cut);
+    if (!rest) continue;
+    const pres = await store
+      .prepare("SELECT id, name_en, symbol, base, power FROM unit_prefixes WHERE symbol = ?1 AND base IS NOT NULL AND power IS NOT NULL")
+      .bind(pSym)
+      .all()
+      .catch(() => ({ results: [] }));
+    const prefix = (pres.results ?? [])[0] as { id: string; name_en: string | null; symbol: string; base: number; power: number } | undefined;
+    if (!prefix) continue;
+    const unit = await unitByTerm(store, rest);
+    if (unit) return { unit, prefixFactor: Math.pow(prefix.base, prefix.power), prefixName: prefix.name_en };
+  }
+  return null;
+}
+
+export const unitsLookup: ToolSpec = {
+  name: "units.lookup",
+  description:
+    "Look up a measurement unit in the unitsdb plane: its names and symbols, its dimension, its quantity kinds, and its SI decomposition. Bind a symbol or an everyday unit name to the dataset's canonical unit before computing with it.",
+  params: [{ key: "term", required: true, description: "a unit's code, short name, symbol or plain name, e.g. m, Pa, pascal, meter per second" }],
+  audiences: ["mcp"],
+  handler: async (env, args) => {
+    const term = String(args?.term ?? "").trim();
+    if (term.length < 1) return null;
+    try {
+      const store = portStore(env);
+      const unit = await unitByTerm(store, term);
+      if (!unit) {
+        return { name: "units.lookup", query: term, output: `No unit matches "${term}" in the unitsdb plane. State this plainly.` };
+      }
+      const qtyNames: string[] = [];
+      for (const qid of JSON.parse(unit.quantity_ids || "[]") as string[]) {
+        const r = await store.prepare("SELECT name_en FROM unit_quantities WHERE id = ?1").bind(qid).all().catch(() => ({ results: [] }));
+        const n = ((r.results ?? [])[0] as any)?.name_en;
+        if (n) qtyNames.push(n);
+      }
+      const roots: { code: string; power: number }[] = JSON.parse(unit.root_units || "[]");
+      const rootNames = await Promise.all(
+        roots.map(async (r) => {
+          const row = await unitByTerm(store, r.code);
+          return `${row?.short ?? r.code}^${r.power}`;
+        }),
+      );
+      const symbols = JSON.parse(unit.symbols || "null");
+      return {
+        name: "units.lookup",
+        query: term,
+        output: JSON.stringify({
+          code: unit.code,
+          name_en: unit.name_en,
+          name_fr: unit.name_fr,
+          symbol: symbols?.ascii ?? null,
+          si_root: !!unit.root,
+          unit_system: unit.unit_system,
+          dimension: unit.dimension_ascii,
+          quantities: qtyNames.slice(0, 4),
+          si_decomposition: rootNames,
+          scale: unit.scale,
+        }),
+      };
+    } catch {
+      return null;
+    }
+  },
+};
+
+export const unitsConvert: ToolSpec = {
+  name: "units.convert",
+  description:
+    "Convert a value between two measurement units through the unitsdb plane. SI-coherent units convert exactly (prefix powers over the same dimension); a non-SI unit is stated honestly — the dataset defines a ratio scale for it, not a factor, and none is invented.",
+  params: [
+    { key: "value", required: true, description: "the numeric value to convert" },
+    { key: "from_unit", required: true, description: "the source unit, e.g. kPa, km, m" },
+    { key: "to_unit", required: true, description: "the target unit, e.g. Pa, m" },
+  ],
+  audiences: ["mcp"],
+  handler: async (env, args) => {
+    const value = Number(args?.value);
+    const fromTerm = String(args?.from_unit ?? "").trim();
+    const toTerm = String(args?.to_unit ?? "").trim();
+    if (!Number.isFinite(value) || !fromTerm || !toTerm) return null;
+    try {
+      const store = portStore(env);
+      const from = await resolveWithPrefix(store, fromTerm);
+      const to = await resolveWithPrefix(store, toTerm);
+      if (!from || !to) {
+        const missing = !from ? fromTerm : toTerm;
+        return { name: "units.convert", query: `${value} ${fromTerm} → ${toTerm}`, output: `No unit matches "${missing}" in the unitsdb plane. State this plainly.` };
+      }
+      if ((from.unit.dimension_ascii ?? "") !== (to.unit.dimension_ascii ?? "")) {
+        return {
+          name: "units.convert",
+          query: `${value} ${fromTerm} → ${toTerm}`,
+          output: `Not convertible: ${fromTerm} carries dimension ${from.unit.dimension_ascii ?? "unknown"} and ${toTerm} carries ${to.unit.dimension_ascii ?? "unknown"}. State this plainly.`,
+        };
+      }
+      const coherent = (u: UnitRow) => !!u.unit_system && u.unit_system.toLowerCase().startsWith("si");
+      if (!coherent(from.unit) || !coherent(to.unit)) {
+        const nonSi = !coherent(from.unit) ? fromTerm : toTerm;
+        return {
+          name: "units.convert",
+          query: `${value} ${fromTerm} → ${toTerm}`,
+          output: `The dataset defines no numeric factor for ${nonSi} (a non-SI unit carried on a ${from.unit.scale ?? to.unit.scale ?? "ratio"} scale) — no factor is invented. State this plainly; the caller may supply the factor itself.`,
+        };
+      }
+      const result = (value * from.prefixFactor) / to.prefixFactor;
+      return {
+        name: "units.convert",
+        query: `${value} ${fromTerm} → ${toTerm}`,
+        output: JSON.stringify({
+          value,
+          from: `${from.prefixName ? from.prefixName + " " : ""}${from.unit.name_en}`,
+          to: `${to.prefixName ? to.prefixName + " " : ""}${to.unit.name_en}`,
+          dimension: from.unit.dimension_ascii,
+          result,
+        }),
+      };
+    } catch {
+      return null;
+    }
+  },
+};
+
 export const glossaryLookup: ToolSpec = {
   name: "glossary.lookup",
   description:

package/workers/worker_public/src/tools.ts

@@ -64,9 +64,9 @@ const certificatesSearch: ToolSpec = {
   },
 };
 
-import { unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck, bibEntry } from "./tools-content.ts";
+import { unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck, bibEntry, unitsLookup, unitsConvert } from "./tools-content.ts";
 
-export const TOOLS_REGISTRY: ToolSpec[] = [certificatesSearch, unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck, bibEntry];
+export const TOOLS_REGISTRY: ToolSpec[] = [certificatesSearch, unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck, bibEntry, unitsLookup, unitsConvert];
 
 /** The agent loop's protocol declaration, GENERATED from the registry —
  *  the model's tool vocabulary is always the registry's, never a