@konneal/engine 0.2.98 → 0.2.99

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

@@ -1,7 +1,7 @@
 import {
   handleAsk
-} from "./chunk-BIX3SMC7.js";
-import "./chunk-A3ELAHKF.js";
+} from "./chunk-2SWMTCVX.js";
+import "./chunk-QNLFNEI4.js";
 import "./chunk-TXPWLKCI.js";
 import "./chunk-KNCRYAX3.js";
 import "./chunk-DTW4UW2E.js";

package/dist/{chunk-BIX3SMC7.js → chunk-2SWMTCVX.js}

@@ -18,7 +18,7 @@ import {
   tableRetyped,
   toolNote,
   verdictNote
-} from "./chunk-A3ELAHKF.js";
+} from "./chunk-QNLFNEI4.js";
 import {
   NO_CONTEXT,
   answerQuality,

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/{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,12 +4,12 @@ import {
   handleMemories,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-BIX3SMC7.js";
+} from "../../chunk-2SWMTCVX.js";
 import {
   TOOLS_REGISTRY,
   bindModelNode,
   modelGroundingBlock
-} from "../../chunk-A3ELAHKF.js";
+} from "../../chunk-QNLFNEI4.js";
 import {
   handleSearch
 } from "../../chunk-GY33RTEO.js";
@@ -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-W6NUC3MG.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-EQAOPFCC.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.99",
   "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/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