@konneal/engine 0.2.119 → 0.2.120

package/dist/{ask-YVBM6IEV.js → ask-3BJKTVLY.js}

@@ -1,7 +1,7 @@
 import {
   handleAsk
-} from "./chunk-EGFTNES5.js";
-import "./chunk-32UDKBA2.js";
+} from "./chunk-SORXE55V.js";
+import "./chunk-FKG5VGOL.js";
 import "./chunk-IIQWESHC.js";
 import "./chunk-TH5XGPD5.js";
 import "./chunk-DJ65EF5G.js";

package/dist/{chunk-32UDKBA2.js → chunk-FKG5VGOL.js}

@@ -268,27 +268,47 @@ function parseNumber(raw) {
   s = s.replace(/\.(\d{3})$/, "$1");
   return Number(s.replace(/,(?=\d{3}\b)/g, ""));
 }
-function extractParams(query, symbols) {
-  const params = {};
+function extractParamsWithUnits(query, symbols) {
+  const values = {};
+  const units = {};
   for (const sym of symbols) {
     const leaf = sym.split(".").pop() ?? sym;
     const esc = leaf.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const re = new RegExp(`\\b${esc}\\b\\D{0,14}?([0-9][0-9 ,.]*[0-9])`, "iu");
+    const re = new RegExp(`\\b${esc}\\b\\D{0,14}?([0-9][0-9 ,.]*[0-9])\\s*(%|\\u00b0?[A-Za-z\\u00b5\\u03a9]{0,6})?`, "iu");
     const m = query.match(re);
     if (m) {
       const v = parseNumber(m[1]);
-      if (Number.isFinite(v)) params[sym] = v;
+      if (Number.isFinite(v)) {
+        values[sym] = v;
+        const u = (m[2] ?? "").trim();
+        if (u) units[sym] = u;
+      }
     }
   }
-  return params;
+  return { values, units };
+}
+function dimensionMismatch(check, units, dimensions) {
+  const dims = /* @__PURE__ */ new Map();
+  for (const [sym, unit] of Object.entries(units)) {
+    const leaf = sym.split(".").pop();
+    if (!leaf || !new RegExp(`\\b${leaf}\\b`, "i").test(check)) continue;
+    const dim = dimensions[unit.toLowerCase()];
+    if (dim) dims.set(sym, dim);
+  }
+  const distinct = [...new Set(dims.values())];
+  if (distinct.length <= 1) return null;
+  const parts = [...dims.entries()].map(([sym, dim]) => `${sym} is in ${dim}`);
+  return `the stated quantities mix dimensions: ${parts.join(" while ")}`;
 }
-function evaluate(content, query) {
+function evaluate(content, query, opts) {
   const c = content && typeof content === "object" ? content : {};
   const checks = extractChecks(content);
   if (!checks.length) return null;
   const symbols = symbolsIn(checks);
-  const params = extractParams(query, symbols);
+  const bound = extractParamsWithUnits(query, symbols);
+  const params = bound.values;
   const missing = symbols.filter((s) => params[s] === void 0);
+  let voidReason = null;
   const machine = checks.map((expression) => {
     const values = {};
     try {
@@ -297,10 +317,15 @@ function evaluate(content, query) {
     }
     let result = null;
     if (missing.length === 0) {
-      try {
-        result = !!parseAndEval(expression, params);
-      } catch {
-        result = null;
+      const mismatch = opts?.dimensions ? dimensionMismatch(expression, bound.units, opts.dimensions) : null;
+      if (mismatch) {
+        voidReason = voidReason ?? mismatch;
+      } else {
+        try {
+          result = !!parseAndEval(expression, params);
+        } catch {
+          result = null;
+        }
       }
     }
     return { expression, symbolic: expression, values, result };
@@ -310,7 +335,10 @@ function evaluate(content, query) {
   }
   const failed = machine.some((m) => m.result === false);
   const evaluable = machine.some((m) => m.result !== null);
-  if (!evaluable) return null;
+  if (!evaluable) {
+    if (voidReason) return { verdict: "void", missing: [], void_reason: voidReason, checks: machine };
+    return null;
+  }
   return {
     verdict: failed ? "fail" : "pass",
     on_violation: failed ? String(c.on_violation ?? "invalid") : void 0,
@@ -328,7 +356,7 @@ function verdictNote(v, node) {
     lines.push(`- ${c.expression}${vals ? `  [${vals}]` : ""} \u2192 ${c.result === null ? "not evaluated" : c.result ? "holds" : "VIOLATED"}`);
   }
   if (v.verdict === "void") {
-    lines.push(`VERDICT: VOID \u2014 the question does not state: ${v.missing.join(", ")}. Say exactly what is missing; never assume values.`);
+    lines.push(v.void_reason ? `VERDICT: VOID \u2014 ${v.void_reason}. State the mismatch plainly; the question cannot be decided as stated.` : `VERDICT: VOID \u2014 the question does not state: ${v.missing.join(", ")}. Say exactly what is missing; never assume values.`);
   } else if (v.verdict === "pass") {
     lines.push(`VERDICT: PASS \u2014 every machine check holds at the stated values. Present this verdict, the arithmetic above, and cite the node's clause.`);
   } else {
@@ -1179,6 +1207,9 @@ ${r.output}`;
 }
 
 export {
+  extractChecks,
+  symbolsIn,
+  extractParamsWithUnits,
   evaluate,
   verdictNote,
   standardForDocNumber,

package/dist/{chunk-EGFTNES5.js → chunk-SORXE55V.js}

@@ -5,6 +5,8 @@ import {
   contractV2,
   evaluate,
   evaluateConditionSets,
+  extractChecks,
+  extractParamsWithUnits,
   licenseBoundaryNote,
   licenseBoundaryRefusal,
   licensedEntryForPackage,
@@ -16,10 +18,11 @@ import {
   resolveBlocks,
   runTool,
   standardForDocNumber,
+  symbolsIn,
   tableRetyped,
   toolNote,
   verdictNote
-} from "./chunk-32UDKBA2.js";
+} from "./chunk-FKG5VGOL.js";
 import {
   NO_CONTEXT,
   STAGE_NAMES,
@@ -2195,7 +2198,22 @@ ${summary}` }] : [],
     console.log("model plane: bound", boundModel.node_id, `[${boundModel.standard}]`, boundModel.clause?.urn ?? "no-clause", boundModel.gated ? "(gated: license)" : "");
   }
   const modelNote = boundModel && !boundModel.gated ? modelGroundingBlock(boundModel) : void 0;
-  const machineVerdict = boundModel && !boundModel.gated && !ablate?.noVerdict ? evaluate(boundModel.content, q.query) : null;
+  let machineVerdict = boundModel && !boundModel.gated && !ablate?.noVerdict ? evaluate(boundModel.content, q.query) : null;
+  if (machineVerdict === null && boundModel && !boundModel.gated) {
+    try {
+      const unitTokens = [...new Set(Object.values(extractParamsWithUnits(q.query, symbolsIn(extractChecks(boundModel.content))).units).map((u) => u.toLowerCase()))];
+      if (unitTokens.length) {
+        const marks = unitTokens.map(() => "?").join(",");
+        const rows = await env.DB.prepare(
+          `SELECT lower(coalesce(json_extract(symbols, '$.ascii'), json_extract(symbols, '$.unicode'))) AS sym, dimension_ascii FROM units_db WHERE lower(coalesce(json_extract(symbols, '$.ascii'), json_extract(symbols, '$.unicode'))) IN (${marks})`
+        ).bind(...unitTokens).all().catch(() => ({ results: [] }));
+        const dimensions = {};
+        for (const r of rows.results ?? []) dimensions[String(r.sym)] = String(r.dimension_ascii ?? "");
+        machineVerdict = evaluate(boundModel.content, q.query, { dimensions });
+      }
+    } catch {
+    }
+  }
   const machineNote = machineVerdict && boundModel ? verdictNote(machineVerdict, boundModel) : void 0;
   const modelNodeRows = async (kind, docNum) => {
     const attempt = (num3) => {

package/dist/{tools-GSLHFD37.js → tools-CUKFOW7S.js}

@@ -4,7 +4,7 @@ import {
   parseToolCall,
   runTool,
   toolNote
-} from "./chunk-32UDKBA2.js";
+} from "./chunk-FKG5VGOL.js";
 import "./chunk-TH5XGPD5.js";
 import "./chunk-4NXH5ZI6.js";
 import "./chunk-VT7DR6NQ.js";

package/dist/verdict.d.ts

@@ -9,12 +9,30 @@ export interface Verdict {
     on_violation?: string;
     violation_meaning?: string;
     missing: string[];
+    /** why a fully-stated question still cannot evaluate (TODO.sota/04):
+     *  the stated quantities' units carry conflicting dimensions */
+    void_reason?: string;
     checks: MachineCheck[];
 }
 export declare function extractChecks(content: unknown): string[];
 export declare function symbolsIn(checks: string[]): string[];
 export declare function extractParams(query: string, symbols: string[]): Record<string, number>;
-export declare function evaluate(content: unknown, query: string): Verdict | null;
+/** The stated values WITH their unit tokens (TODO.sota/04's unit
+ *  semantics): "E_max 30000 v" binds e_max=30000 and the unit "v" —
+ *  the dimension check needs both. */
+export declare function extractParamsWithUnits(query: string, symbols: string[]): {
+    values: Record<string, number>;
+    units: Record<string, string>;
+};
+/** Dimension coherence (TODO.sota/04 item 2): the units plane gives
+ *  each unit token a dimension; a parameter set whose bound symbols
+ *  carry CONFLICTING known dimensions is incoherent — the check
+ *  compares quantities that are not comparable. Pure: the dimensions
+ *  map arrives from the caller (the units register at load). */
+export declare function dimensionMismatch(check: string, units: Record<string, string>, dimensions: Record<string, string>): string | null;
+export declare function evaluate(content: unknown, query: string, opts?: {
+    dimensions?: Record<string, string>;
+}): Verdict | null;
 /** The deterministic note the answer model narrates — never recomputes. */
 export declare function verdictNote(v: Verdict, node: {
     node_id: string;

package/dist/worker_public/src/index.js

@@ -4,12 +4,12 @@ import {
   handleMemories,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-EGFTNES5.js";
+} from "../../chunk-SORXE55V.js";
 import {
   TOOLS_REGISTRY,
   bindModelNode,
   modelGroundingBlock
-} from "../../chunk-32UDKBA2.js";
+} from "../../chunk-FKG5VGOL.js";
 import {
   handleSearch
 } from "../../chunk-C5L55VI7.js";
@@ -1043,13 +1043,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-GSLHFD37.js");
+    const { runTool, TOOLS_REGISTRY: TOOLS_REGISTRY2 } = await import("../../tools-CUKFOW7S.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-YVBM6IEV.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-JDSQPI3A.js")).handleSearch(env, ctx, inner, tier, key);
+      const res = name === "ask" ? await (await import("../../ask-3BJKTVLY.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-JDSQPI3A.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.119",
+  "version": "0.2.120",
   "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/ask.ts

@@ -23,7 +23,7 @@ import { completeTables, completeFigures } from "./completion";
 import { NO_CONTEXT, appliedContext, contextNote, namedDocumentIn, parseContext, resolveDocScope, syntheticUnderstanding } from "./context";
 import { liveDataConfig, liveTokenFor, opCfg, opTokenMember, resolveLiveAccount, type LiveRecord } from "./livedata";
 import { bindModelNode, bindConstraintByQuantities, licenseBoundaryNote, licenseBoundaryRefusal, licensedEntryForPackage, modelCitation, modelEcho, modelGroundingBlock, standardForDocNumber } from "./modelplane";
-import { evaluate as machineEvaluate, verdictNote } from "./verdict";
+import { evaluate as machineEvaluate, extractChecks, extractParamsWithUnits, symbolsIn, verdictNote } from "./verdict";
 import { evaluateConditionSets, quantitiesIn, type ConditionVerdict } from "./conditions";
 import { evaluateAggregation, type AggregationVerdict } from "./aggregation";
 import { matchLicensedTopic, boundaryNoteText } from "./boundary";
@@ -946,7 +946,29 @@ let convEntities: Array<{ entity: string; kind: string }> = [];
   // the worker EXECUTES the bound node's machine checks against the
   // question's stated values; the model narrates the computed verdict
   // and the verdict BLOCK is server-built — data, never generated prose
-  const machineVerdict = boundModel && !boundModel.gated && !ablate?.noVerdict ? machineEvaluate(boundModel.content, q.query) : null;
+  let machineVerdict = boundModel && !boundModel.gated && !ablate?.noVerdict ? machineEvaluate(boundModel.content, q.query) : null;
+  if (machineVerdict === null && boundModel && !boundModel.gated) {
+    // unit semantics (TODO.sota/04): the stated values' units reach the
+    // units register for their dimensions; a comparison mixing
+    // dimensions voids with the reason instead of answering a number
+    try {
+      const unitTokens = [...new Set(Object.values(extractParamsWithUnits(q.query, symbolsIn(extractChecks(boundModel.content))).units).map((u) => u.toLowerCase()))];
+      if (unitTokens.length) {
+        const marks = unitTokens.map(() => "?").join(",");
+        // the register keys symbols in the symbols JSON (ascii/unicode),
+        // not in `short` (full names) — D1's json_extract reads them
+        const rows = await env.DB.prepare(
+          `SELECT lower(coalesce(json_extract(symbols, '$.ascii'), json_extract(symbols, '$.unicode'))) AS sym, dimension_ascii FROM units_db WHERE lower(coalesce(json_extract(symbols, '$.ascii'), json_extract(symbols, '$.unicode'))) IN (${marks})`,
+        )
+          .bind(...unitTokens).all().catch(() => ({ results: [] }));
+        const dimensions: Record<string, string> = {};
+        for (const r of (rows.results ?? []) as any[]) dimensions[String(r.sym)] = String(r.dimension_ascii ?? "");
+        machineVerdict = machineEvaluate(boundModel.content, q.query, { dimensions });
+      }
+    } catch {
+      // the plain evaluation above already ran; nothing to salvage
+    }
+  }
   const machineNote = machineVerdict && boundModel ? verdictNote(machineVerdict, boundModel) : undefined;
   // ── condition-set membership (konneal/engine#90): the test-method
   // packages' severity menus as machine-verifiable membership. Fires

package/workers/worker_public/src/verdict.ts

@@ -20,6 +20,9 @@ export interface Verdict {
   on_violation?: string;
   violation_meaning?: string;
   missing: string[];
+  /** why a fully-stated question still cannot evaluate (TODO.sota/04):
+   *  the stated quantities' units carry conflicting dimensions */
+  void_reason?: string;
   checks: MachineCheck[];
 }
 
@@ -190,29 +193,72 @@ function parseNumber(raw: string): number {
 }
 
 export function extractParams(query: string, symbols: string[]): Record<string, number> {
-  const params: Record<string, number> = {};
+  return extractParamsWithUnits(query, symbols).values;
+}
+
+/** The stated values WITH their unit tokens (TODO.sota/04's unit
+ *  semantics): "E_max 30000 v" binds e_max=30000 and the unit "v" —
+ *  the dimension check needs both. */
+export function extractParamsWithUnits(
+  query: string,
+  symbols: string[],
+): { values: Record<string, number>; units: Record<string, string> } {
+  const values: Record<string, number> = {};
+  const units: Record<string, string> = {};
   for (const sym of symbols) {
     const leaf = sym.split(".").pop() ?? sym;
     const esc = leaf.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     // symbol, a short non-numeric gap (words like "were"/"of" allowed),
-    // then the number
-    const re = new RegExp(`\\b${esc}\\b\\D{0,14}?([0-9][0-9 ,.]*[0-9])`, "iu");
+    // then the number, then an optional unit token directly after
+    const re = new RegExp(`\\b${esc}\\b\\D{0,14}?([0-9][0-9 ,.]*[0-9])\\s*(%|\\u00b0?[A-Za-z\\u00b5\\u03a9]{0,6})?`, "iu");
     const m = query.match(re);
     if (m) {
       const v = parseNumber(m[1]!);
-      if (Number.isFinite(v)) params[sym] = v;
+      if (Number.isFinite(v)) {
+        values[sym] = v;
+        const u = (m[2] ?? "").trim();
+        if (u) units[sym] = u;
+      }
     }
   }
-  return params;
+  return { values, units };
+}
+
+/** Dimension coherence (TODO.sota/04 item 2): the units plane gives
+ *  each unit token a dimension; a parameter set whose bound symbols
+ *  carry CONFLICTING known dimensions is incoherent — the check
+ *  compares quantities that are not comparable. Pure: the dimensions
+ *  map arrives from the caller (the units register at load). */
+export function dimensionMismatch(
+  check: string,
+  units: Record<string, string>,
+  dimensions: Record<string, string>,
+): string | null {
+  // the symbols THIS check compares, each mapped through its stated
+  // unit's dimension; more than one distinct dimension in one
+  // comparison is incoherent (a length is not a voltage)
+  const dims = new Map<string, string>();
+  for (const [sym, unit] of Object.entries(units)) {
+    const leaf = sym.split(".").pop();
+    if (!leaf || !new RegExp(`\\b${leaf}\\b`, "i").test(check)) continue;
+    const dim = dimensions[unit.toLowerCase()];
+    if (dim) dims.set(sym, dim);
+  }
+  const distinct = [...new Set(dims.values())];
+  if (distinct.length <= 1) return null;
+  const parts = [...dims.entries()].map(([sym, dim]) => `${sym} is in ${dim}`);
+  return `the stated quantities mix dimensions: ${parts.join(" while ")}`;
 }
 
-export function evaluate(content: unknown, query: string): Verdict | null {
+export function evaluate(content: unknown, query: string, opts?: { dimensions?: Record<string, string> }): Verdict | null {
   const c = (content && typeof content === "object" ? content : {}) as Record<string, any>;
   const checks = extractChecks(content);
   if (!checks.length) return null;
   const symbols = symbolsIn(checks);
-  const params = extractParams(query, symbols);
+  const bound = extractParamsWithUnits(query, symbols);
+  const params = bound.values;
   const missing = symbols.filter((s) => params[s] === undefined);
+  let voidReason: string | null = null;
   const machine: MachineCheck[] = checks.map((expression) => {
     const values: Record<string, number> = {};
     try {
@@ -220,7 +266,14 @@ export function evaluate(content: unknown, query: string): Verdict | null {
     } catch { /* values stay partial */ }
     let result: boolean | null = null;
     if (missing.length === 0) {
-      try { result = !!parseAndEval(expression, params); } catch { result = null; }
+      // unit semantics (TODO.sota/04): a comparison mixing dimensions
+      // cannot evaluate — void with the reason, never a number answer
+      const mismatch = opts?.dimensions ? dimensionMismatch(expression, bound.units, opts.dimensions) : null;
+      if (mismatch) {
+        voidReason = voidReason ?? mismatch;
+      } else {
+        try { result = !!parseAndEval(expression, params); } catch { result = null; }
+      }
     }
     return { expression, symbolic: expression, values, result };
   });
@@ -229,7 +282,10 @@ export function evaluate(content: unknown, query: string): Verdict | null {
   }
   const failed = machine.some((m) => m.result === false);
   const evaluable = machine.some((m) => m.result !== null);
-  if (!evaluable) return null;
+  if (!evaluable) {
+    if (voidReason) return { verdict: "void", missing: [], void_reason: voidReason, checks: machine };
+    return null;
+  }
   return {
     verdict: failed ? "fail" : "pass",
     on_violation: failed ? String(c.on_violation ?? "invalid") : undefined,
@@ -249,7 +305,9 @@ export function verdictNote(v: Verdict, node: { node_id: string; clause?: { urn?
     lines.push(`- ${c.expression}${vals ? `  [${vals}]` : ""} → ${c.result === null ? "not evaluated" : c.result ? "holds" : "VIOLATED"}`);
   }
   if (v.verdict === "void") {
-    lines.push(`VERDICT: VOID — the question does not state: ${v.missing.join(", ")}. Say exactly what is missing; never assume values.`);
+    lines.push(v.void_reason
+      ? `VERDICT: VOID — ${v.void_reason}. State the mismatch plainly; the question cannot be decided as stated.`
+      : `VERDICT: VOID — the question does not state: ${v.missing.join(", ")}. Say exactly what is missing; never assume values.`);
   } else if (v.verdict === "pass") {
     lines.push(`VERDICT: PASS — every machine check holds at the stated values. Present this verdict, the arithmetic above, and cite the node's clause.`);
   } else {