@konneal/engine 0.2.90 → 0.2.92

package/dist/{tools-26IJZX5M.js → tools-PI7IXAL4.js}

@@ -4,8 +4,9 @@ import {
   parseToolCall,
   runTool,
   toolNote
-} from "./chunk-A7QS2X3J.js";
+} from "./chunk-QBWZ6HVP.js";
 import "./chunk-LOBYXEVD.js";
+import "./chunk-LVZTWUVJ.js";
 import "./chunk-2PCUAJJO.js";
 import "./chunk-3FYJM7LH.js";
 export {

package/dist/tools-content.d.ts

@@ -3,4 +3,7 @@ export declare const unitsGet: ToolSpec;
 export declare const graphCites: ToolSpec;
 export declare const docsSection: ToolSpec;
 export declare const documentsFamily: ToolSpec;
+export declare const licensedSection: ToolSpec;
+export declare const verdictEvaluate: ToolSpec;
+export declare const conditionsCheck: ToolSpec;
 export declare const glossaryLookup: ToolSpec;

package/dist/worker_public/src/index.js

@@ -1,15 +1,15 @@
 import {
-  bindModelNode,
   checkQuoteAnchors,
   handleAsk,
   handleMemories,
-  modelGroundingBlock,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-KZV4I7ET.js";
+} from "../../chunk-EHABW23I.js";
 import {
-  TOOLS_REGISTRY
-} from "../../chunk-A7QS2X3J.js";
+  TOOLS_REGISTRY,
+  bindModelNode,
+  modelGroundingBlock
+} from "../../chunk-QBWZ6HVP.js";
 import {
   handleSearch
 } from "../../chunk-TJTEBS4S.js";
@@ -973,12 +973,12 @@ async function handleMcp(env, ctx, req, tier, key) {
       // 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-26IJZX5M.js");
+    const { runTool, TOOLS_REGISTRY: TOOLS_REGISTRY2 } = await import("../../tools-PI7IXAL4.js");
     if (TOOLS_REGISTRY2.some((t) => t.name === name && t.audiences.includes("mcp"))) {
       const r = await runTool({ ...env, DB: env.DB }, { name, args }, "mcp");
       return r ? { tool: r.name, query: r.query, result: r.output } : { error: { message: `tool ${name} returned nothing for the given arguments` } };
     }
-    const res = name === "ask" ? await (await import("../../ask-D6JV2R2R.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-G76DK4AF.js")).handleSearch(env, ctx, inner, tier, key);
+    const res = name === "ask" ? await (await import("../../ask-UG5UYRJV.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-G76DK4AF.js")).handleSearch(env, ctx, inner, tier, key);
     return res.json().catch(() => ({ error: { message: "tool transport failed", status: res.status } }));
   });
   if (out.ok && "accepted" in out) return new Response(null, { status: 202 });

package/package.json

@@ -27,7 +27,7 @@
     "playwright": "^1.62.1",
     "yaml": "^2.9.1"
   },
-  "version": "0.2.90",
+  "version": "0.2.92",
   "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

@@ -10,6 +10,10 @@ import { resolveBlocks } from "./refs.ts";
 import { portIndex, portModelRunner, hasLane } from "./env.ts";
 import { embed } from "./ai.ts";
 import { THRESHOLDS } from "./config.ts";
+import { standardKeysFrom } from "./requestScope.ts";
+import { licenseBoundaryRefusal, licensedEntryForDocNumber, licensedEntryForPackage } from "./modelplane.ts";
+import { evaluate as evaluateVerdict } from "./verdict.ts";
+import { evaluateConditionSets } from "./conditions.ts";
 
 const slug = (docidentifier: string) =>
   docidentifier
@@ -137,6 +141,204 @@ export const documentsFamily: ToolSpec = {
   },
 };
 
+
+// The licensed library (the owner's 2026-10-04 direction): "return
+// clause X of document Y" for licensed standards, behind the SAME
+// entitlement predicate the ask path applies — the caller declares
+// keys, the deployment's declared whitelist validates them (a forged
+// key can never widen scope), and the unentitled caller receives the
+// boundary refusal: the standard's title and edition, the declare
+// pointer, never a word of the text. The entitled caller gets the
+// model plane's typed nodes for the clause — the computing form.
+export const licensedSection: ToolSpec = {
+  name: "licensed.section",
+  description:
+    "Fetch one clause of a licensed standard's typed model content — requirements, condition sets and parameters as structured data — behind the caller's license entitlement keys. An unentitled caller receives the license boundary: the standard's title and edition and the declare flow, never its text.",
+  params: [
+    { key: "doc", required: true, description: "the standard's document number, e.g. 60068-2-30 or 61000-4-2" },
+    { key: "clause", required: true, description: "the clause number inside the standard, e.g. 5 or 9" },
+    { key: "licensed_standards", required: true, description: 'the caller\'s license entitlement keys, e.g. ["std:iec-60068-2-30"] — validated against the licenses this deployment declares; keys it does not know drop' },
+  ],
+  audiences: ["mcp"],
+  handler: async (env, args) => {
+    const doc = String(args?.doc ?? "").trim();
+    const clause = String(args?.clause ?? "").trim();
+    if (doc.length < 3 || !clause) return null;
+    // "IEC 60068-2-30" / "ISO/IEC 17025" → the bare doc number the
+    // licensed registry keys on
+    const docNumber = doc.replace(/^(?:ISO\/IEC|ISO|IEC)\s+/i, "").trim();
+    const entry = licensedEntryForDocNumber(docNumber);
+    if (!entry) {
+      return {
+        name: "licensed.section",
+        query: `${doc} §${clause}`,
+        output: `"${doc}" is not among the licensed standards this deployment keys. For clauses of the public corpus use the docs.section tool instead. State this plainly.`,
+      };
+    }
+    const keys = standardKeysFrom({ licensed_standards: args?.licensed_standards });
+    if (!keys.has(entry.key)) {
+      const refusal = licenseBoundaryRefusal(docNumber, keys);
+      return {
+        name: "licensed.section",
+        query: `${doc} §${clause}`,
+        output: refusal ?? "License boundary — the caller's entitlement set does not cover this standard's text.",
+      };
+    }
+    try {
+      const rows = await env.DB.prepare(
+        "SELECT node_id, kind, name, clause_ref, content FROM model_nodes WHERE standard = ?1 AND clause_ref = ?2 ORDER BY node_id LIMIT 20",
+      )
+        .bind(entry.package, clause)
+        .all();
+      const nodes = ((rows.results ?? []) as { node_id: string; kind: string; name: string | null; clause_ref: string; content: string }[]);
+      if (!nodes.length) {
+        const c = await env.DB.prepare(
+          "SELECT DISTINCT clause_ref FROM model_nodes WHERE standard = ?1 ORDER BY clause_ref",
+        )
+          .bind(entry.package)
+          .all();
+        const clauses = ((c.results ?? []) as { clause_ref: string }[]).map((r) => r.clause_ref).filter(Boolean).join(", ");
+        return {
+          name: "licensed.section",
+          query: `${doc} §${clause}`,
+          output: `No typed nodes are indexed for ${doc} §${clause}.${clauses ? ` The clauses with typed nodes: ${clauses}.` : ""} State this plainly.`,
+        };
+      }
+      return {
+        name: "licensed.section",
+        query: `${doc} §${clause}`,
+        output: JSON.stringify(
+          nodes.map((n) => {
+            let content: unknown = n.content;
+            try { content = JSON.parse(n.content); } catch { /* verbatim when not JSON */ }
+            return { node_id: n.node_id, kind: n.kind, name: n.name, clause: n.clause_ref, content };
+          }),
+        ),
+      };
+    } catch {
+      return null;
+    }
+  },
+};
+
+
+// The deterministic engines as tools (the owner's 2026-10-04
+// direction): computing with the standard, not reading it. Both wrap
+// the engines the ask path already runs — no new evaluation logic
+// lives here; the tool is the door, the engine is the authority.
+// Void-when-parameters-miss is the honest contract: the tool states
+// WHICH parameters the question did not state, never guesses.
+
+export const verdictEvaluate: ToolSpec = {
+  name: "verdict.evaluate",
+  description:
+    "Deterministically evaluate a model-plane node's machine checks (OCL boolean expressions, threshold limits) against the quantities a question states. Returns pass/fail with every check's expression and values, or void with the missing parameter names when the question does not state enough. The machine computes; cite the node's clause.",
+  params: [
+    { key: "node_id", required: true, description: "the model-plane node id, e.g. /req/metrological/repeatability (node ids appear in answers' verdict blocks)" },
+    { key: "question", required: true, description: "the statement carrying the quantities, e.g. 'is mpe 0.02 with n_lc 3000 within the limit?'" },
+  ],
+  audiences: ["mcp"],
+  handler: async (env, args) => {
+    const node_id = String(args?.node_id ?? "").trim();
+    const question = String(args?.question ?? "").trim();
+    if (!node_id.startsWith("/") || question.length < 4) return null;
+    try {
+      // the same zero-or-ambiguous rule bindModelNode applies: a node
+      // id that indexes under exactly one standard resolves; several
+      // or none resolve to nothing — no silent pick
+      const rows = await env.DB.prepare(
+        "SELECT standard, kind, name, content FROM model_nodes WHERE node_id = ?1 LIMIT 2",
+      )
+        .bind(node_id)
+        .all();
+      const found = (rows.results ?? []) as { standard: string; kind: string; name: string | null; content: string }[];
+      if (found.length !== 1) {
+        return {
+          name: "verdict.evaluate",
+          query: node_id,
+          output: found.length
+            ? `The node id ${node_id} is indexed under several standards — name the standard to disambiguate. State this plainly.`
+            : `No model-plane node ${node_id} is indexed. State this plainly.`,
+        };
+      }
+      const node = found[0]!;
+      const entry = licensedEntryForPackage(node.standard);
+      if (entry) {
+        return {
+          name: "verdict.evaluate",
+          query: node_id,
+          output: licenseBoundaryRefusal(entry.doc_number, null) ?? "License boundary — the node belongs to a licensed standard the caller's entitlement set does not cover.",
+        };
+      }
+      let content: unknown;
+      try { content = JSON.parse(node.content); } catch { content = null; }
+      const v = evaluateVerdict(content, question);
+      if (!v) {
+        return {
+          name: "verdict.evaluate",
+          query: node_id,
+          output: `The node ${node_id} (${node.kind}) carries no machine-checkable expressions — it is not evaluatable by the verdict engine. State this plainly.`,
+        };
+      }
+      return {
+        name: "verdict.evaluate",
+        query: node_id,
+        output: JSON.stringify({ standard: node.standard, node_id, kind: node.kind, name: node.name, verdict: v.verdict, on_violation: v.on_violation, missing: v.missing, checks: v.checks }),
+      };
+    } catch {
+      return null;
+    }
+  },
+};
+
+export const conditionsCheck: ToolSpec = {
+  name: "conditions.check",
+  description:
+    "Check a stated combination of environmental quantities (temperature, humidity, duration, cycles) against the indexed severity/condition sets — the pass answer names the matched set and every band, the fail names the nearest set and its distance. Machine evaluation over the condition-set nodes; cite the matched set's clause.",
+  params: [
+    { key: "question", required: true, description: "the stated combination, e.g. 'damp heat cyclic test at 55 °C for 2 cycles of 24 h'" },
+    { key: "standard", required: false, description: "optional scope, the package id, e.g. iec-60068-2-30 (defaults to every indexed condition set the caller may see)" },
+    { key: "licensed_standards", required: false, description: 'license entitlement keys for licensed condition sets, validated against the deployment\'s declared licenses' },
+  ],
+  audiences: ["mcp"],
+  handler: async (env, args) => {
+    const question = String(args?.question ?? "").trim();
+    if (question.length < 4) return null;
+    const standard = args?.standard ? String(args.standard).trim() : null;
+    const keys = standardKeysFrom({ licensed_standards: args?.licensed_standards });
+    try {
+      const rows = standard
+        ? await env.DB.prepare("SELECT node_id, standard, content FROM model_nodes WHERE kind = 'condition_set' AND standard = ?1").bind(standard).all()
+        : await env.DB.prepare("SELECT node_id, standard, content FROM model_nodes WHERE kind = 'condition_set'").all();
+      const all = ((rows.results ?? []) as { node_id: string; standard: string; content: string }[]).map((r) => {
+        let content: unknown = r.content;
+        try { content = JSON.parse(r.content); } catch { /* verbatim */ }
+        return { node_id: r.node_id, standard: r.standard, content };
+      });
+      // the ask path's own gate: licensed condition sets compete only
+      // for entitled callers — the same licensedEntryForPackage filter
+      const visible = all.filter((n) => {
+        const entry = licensedEntryForPackage(n.standard);
+        return !entry || keys.has(entry.key);
+      });
+      if (!visible.length) {
+        return { name: "conditions.check", query: question, output: "No condition sets are indexed (or visible to this caller's entitlements). State this plainly." };
+      }
+      const v = evaluateConditionSets(visible, question);
+      if (!v) {
+        return { name: "conditions.check", query: question, output: "No quantities were recognized in the statement — state the values (temperature, humidity, duration, cycles). The engine checks stated numbers, never guesses." };
+      }
+      return {
+        name: "conditions.check",
+        query: question,
+        output: JSON.stringify({ verdict: v.verdict, matched: v.matched, checks: v.checks }),
+      };
+    } 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 } from "./tools-content.ts";
+import { unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck } from "./tools-content.ts";
 
-export const TOOLS_REGISTRY: ToolSpec[] = [certificatesSearch, unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily];
+export const TOOLS_REGISTRY: ToolSpec[] = [certificatesSearch, unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck];
 
 /** The agent loop's protocol declaration, GENERATED from the registry —
  *  the model's tool vocabulary is always the registry's, never a

package/dist/chunk-A7QS2X3J.js

@@ -1,279 +0,0 @@
-import {
-  embed,
-  hasLane,
-  portIndex,
-  portModelRunner
-} from "./chunk-LOBYXEVD.js";
-import {
-  THRESHOLDS
-} from "./chunk-2PCUAJJO.js";
-
-// workers/worker_public/src/refs.ts
-var REF = /\[\[(u:[A-Za-z0-9_-]+)\]\]/g;
-function availableUnitIds(hits) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const h of hits) {
-    const u = h.metadata?.unit_id;
-    if (u) ids.add(u);
-  }
-  return ids;
-}
-function parseRefs(text) {
-  return [...text.matchAll(REF)].map((m) => m[1]);
-}
-function sanitizeRefs(text, available) {
-  const dropped = [];
-  const out = text.replace(REF, (full, id) => {
-    if (available.has(id)) return full;
-    dropped.push(id);
-    return "";
-  });
-  return { text: out, dropped };
-}
-async function resolveBlocks(db, refs) {
-  if (!refs.length) return [];
-  const uniq = [...new Set(refs)].slice(0, 12);
-  const blocks = [];
-  for (let i = 0; i < uniq.length; i += 20) {
-    const batch = uniq.slice(i, i + 20);
-    const placeholders = batch.map((_, n) => `?${n + 1}`).join(",");
-    try {
-      const res = await db.prepare(`SELECT unit_id, type, docidentifier, edition, payload FROM unit_payloads WHERE unit_id IN (${placeholders})`).bind(...batch).all();
-      for (const r of res.results) {
-        let payload = {};
-        try {
-          payload = JSON.parse(String(r.payload));
-        } catch {
-          continue;
-        }
-        blocks.push({
-          unit_id: String(r.unit_id),
-          type: String(r.type),
-          docidentifier: String(r.docidentifier ?? ""),
-          edition: r.edition ? String(r.edition) : void 0,
-          payload
-        });
-      }
-    } catch (e) {
-      console.log("resolveBlocks failed:", String(e).slice(0, 150));
-    }
-  }
-  return blocks;
-}
-async function contractV2(db, answer, usedHits) {
-  const available = availableUnitIds(usedHits);
-  const { text, dropped } = sanitizeRefs(answer, available);
-  if (dropped.length) console.log("refs: dropped", dropped.length, "invalid (not in passages)");
-  const refs = parseRefs(text);
-  const blocks = await resolveBlocks(db, refs);
-  return { text, blocks, dropped };
-}
-function tableRetyped(text, availableTable) {
-  if (!availableTable) return false;
-  return /(^|\n)\s*\|[^\n]+\|\s*(\n\s*\|[-: |]+\|\s*)?(\n|$)/.test(text) && (text.match(/\|/g) ?? []).length >= 6;
-}
-
-// workers/worker_public/src/tools-content.ts
-var slug = (docidentifier) => docidentifier.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-var unitsGet = {
-  name: "units.get",
-  description: "Fetch typed Recommendation content \u2014 a table, formula or figure as structured data (columns, rows, MathML, caption), by its unit id. The machine-consumable form of a Recommendation's content, for computing with rather than reading.",
-  params: [{ key: "unit_id", required: true, description: "the unit id exactly as an answer's [[u:\u2026]] reference spells it" }],
-  audiences: ["mcp"],
-  handler: async (env, args) => {
-    const unit_id = String(args?.unit_id ?? "").trim().replace(/^\[?\[?u:/, "u:").replace(/]?\]?$/, "");
-    if (!/^u:[\w.-]+$/.test(unit_id)) return null;
-    const blocks = await resolveBlocks(env.DB, [unit_id]);
-    if (!blocks.length) {
-      return { name: "units.get", query: unit_id, output: `No typed unit "${unit_id}" exists in the indexed payloads. State this plainly.` };
-    }
-    return {
-      name: "units.get",
-      query: unit_id,
-      output: JSON.stringify(
-        blocks.map((b) => ({ unit_id: b.unit_id, type: b.type, docidentifier: b.docidentifier, payload: b.payload }))
-      )
-    };
-  }
-};
-var graphCites = {
-  name: "graph.cites",
-  description: "The bibliography edges: what a publication's own bibliography actually cites, extracted from its indexed bibliography sections. Returns the cited works' labels for a document (optionally scoped to an edition).",
-  params: [
-    { key: "doc", required: true, description: "the publication identifier, e.g. R 60-1:2021" },
-    { key: "edition", required: false, description: "an edition year to scope, e.g. 2021" }
-  ],
-  audiences: ["mcp"],
-  handler: async (env, args) => {
-    const doc = String(args?.doc ?? "").trim();
-    if (doc.length < 3) return null;
-    const edition = args?.edition ? String(args.edition).trim() : null;
-    const pat = `%${doc.replace(/[:\s]+/g, "%")}%${edition ? edition : ""}%`;
-    try {
-      const rows = await env.DB.prepare(
-        "SELECT DISTINCT n.label AS label FROM graph_edges e JOIN documents d ON e.src = d.canonical_id JOIN graph_nodes n ON e.dst = n.id WHERE d.docidentifier LIKE ?1 AND e.kind = 'cites' ORDER BY label LIMIT 60"
-      ).bind(pat).all();
-      const labels = (rows.results ?? []).map((r) => r.label).filter(Boolean);
-      return {
-        name: "graph.cites",
-        query: `${doc}${edition ? ` (${edition})` : ""}`,
-        output: labels.length ? `The publication's bibliography cites:
-${labels.map((l) => `- ${l}`).join("\n")}` : `No bibliography citations are indexed for "${doc}"${edition ? ` (${edition})` : ""}. State this plainly.`
-      };
-    } catch {
-      return null;
-    }
-  }
-};
-var docsSection = {
-  name: "docs.section",
-  description: "Fetch one clause of a publication's rendered document \u2014 its text and its permanent deep-link URL \u2014 for agents that need the human-formatted passage with its anchor.",
-  params: [
-    { key: "doc", required: true, description: "the publication identifier, e.g. R 60-1:2021" },
-    { key: "clause", required: true, description: "the clause anchor, e.g. 5.1.1 or annex-b" }
-  ],
-  audiences: ["mcp"],
-  handler: async (env, args) => {
-    const doc = String(args?.doc ?? "").trim();
-    const clause = String(args?.clause ?? "").trim();
-    if (doc.length < 3 || !clause) return null;
-    try {
-      const rows = await env.DB.prepare(
-        "SELECT docidentifier, clause_anchor, clause_title, text FROM chunks WHERE docidentifier LIKE ?1 AND REPLACE(clause_anchor, ' ', '') = ?2 LIMIT 1"
-      ).bind(`%${doc.replace(/[:\s]+/g, "%")}%`, clause).all();
-      const r = (rows.results ?? [])[0];
-      if (!r) {
-        return { name: "docs.section", query: `${doc} \xA7${clause}`, output: `No clause "${clause}" is indexed for "${doc}". State this plainly.` };
-      }
-      const url = `https://www.ommisa.org/docs/${slug(r.docidentifier)}.html#${r.clause_anchor}`;
-      return {
-        name: "docs.section",
-        query: `${r.docidentifier} \xA7${r.clause_anchor}`,
-        output: JSON.stringify({ docidentifier: r.docidentifier, clause: r.clause_anchor, title: r.clause_title, url, text: (r.text ?? "").slice(0, 4e3) })
-      };
-    } catch {
-      return null;
-    }
-  }
-};
-var documentsFamily = {
-  name: "documents.family",
-  description: "Look up the publication registry for a family: every edition with its derived status (in-force/superseded), which edition is ACTIVE (terminal of the successor chain), and supersession links. Use for current/latest-edition and edition-history questions.",
-  params: [{ key: "family", required: true, description: "the family key, e.g. R-60 (series letter and number)" }],
-  audiences: ["mcp"],
-  handler: async (env, args) => {
-    const family = String(args?.family ?? "").trim().toUpperCase();
-    if (!/^[A-Z]-\d{1,3}$/.test(family)) return null;
-    try {
-      const rows = await env.DB.prepare(
-        "SELECT d.docidentifier, d.derived_status, d.active, s.docidentifier AS succ FROM documents d LEFT JOIN documents s ON d.superseded_by = s.canonical_id WHERE d.family = ?1 ORDER BY d.part, d.edition"
-      ).bind(family).all();
-      const lines = (rows.results ?? []).map(
-        (r) => `${r.docidentifier} \u2014 ${r.derived_status}${r.active ? " [ACTIVE]" : ""}${r.succ ? ` \u2192 superseded by ${r.succ}` : ""}`
-      );
-      if (!lines.length) {
-        return { name: "documents.family", query: family, output: `No editions are registered for the family ${family}. State this plainly.` };
-      }
-      return { name: "documents.family", query: family, output: lines.join("\n") };
-    } 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.",
-  params: [{ key: "term", required: true, description: "the term or everyday phrase to bind, e.g. creep or load cell" }],
-  audiences: ["mcp"],
-  handler: async (env, args) => {
-    const term = String(args?.term ?? "").trim();
-    if (term.length < 2) return null;
-    if (!hasLane(env, "glossary")) return null;
-    try {
-      const vec = await embed(portModelRunner(env), "", term);
-      const cands = await portIndex(env, "glossary").query({ vector: vec, topK: 5 });
-      const hits = cands.filter((m) => m.score >= THRESHOLDS.glossaryCosineFloor).map((m) => ({
-        term: String(m.metadata?.clause_title ?? "").trim(),
-        definition: String(m.metadata?.chunk_text ?? "").split(" \u2014 ").slice(1).join(" \u2014 ").slice(0, 400),
-        docidentifier: String(m.metadata?.docidentifier ?? "")
-      })).filter((x) => x.term && x.definition);
-      if (!hits.length) {
-        return { name: "glossary.lookup", query: term, output: `No defined term matches "${term}" in the terminology datasets. State this plainly.` };
-      }
-      const seen = /* @__PURE__ */ new Set();
-      const uniq = hits.filter((h) => {
-        const k = h.term.toLowerCase().replace(/[^a-z0-9 ]/g, "").replace(/labeler\b/g, "labeller").replace(/\s+/g, " ").trim();
-        if (seen.has(k)) return false;
-        seen.add(k);
-        return true;
-      }).slice(0, 3);
-      return {
-        name: "glossary.lookup",
-        query: term,
-        output: uniq.map((h) => `- ${h.term} (${h.docidentifier}): ${h.definition}`).join("\n")
-      };
-    } catch {
-      return null;
-    }
-  }
-};
-
-// workers/worker_public/src/tools.ts
-function parseToolCall(text) {
-  const m = /^TOOL\s+([a-z_.]+)\s*(\{[^\n}]*\})?/m.exec(String(text ?? ""));
-  if (!m) return null;
-  let args = {};
-  if (m[2]) {
-    try {
-      args = JSON.parse(m[2]);
-    } catch {
-      return null;
-    }
-  } else if (/^TOOL\s+[a-z_.]+\s*\{/m.test(String(text ?? ""))) {
-    return null;
-  }
-  return { name: m[1].toLowerCase(), args };
-}
-var certificatesSearch = {
-  name: "certificates.search",
-  description: "Search the certificate register (a snapshot) by holder name, model designation, or a printed certificate number. Returns the matching rows \u2014 number, holder, model, issue year, status, and document links where on file \u2014 or the exact no-match statement for the string asked.",
-  params: [{ key: "query", required: true, description: "the holder, model, or printed certificate number to look up" }],
-  audiences: ["agent", "mcp"],
-  handler: async (env, args) => {
-    const query = String(args?.query ?? "").trim().slice(0, 160);
-    if (!query) return null;
-    const { searchRegister, registerNote, certificateLinks } = await import("./certificates-CO7KX2S2.js");
-    const reg = await searchRegister(env.DB, query, true);
-    const output = reg?.rows?.length ? [registerNote(reg.rows), certificateLinks(reg.rows)].filter(Boolean).join("\n") : `No certificate was found for "${query}" in the certificates database (the register snapshot). State this as the search's result, with the searched string visible.`;
-    return { name: "certificates.search", query, output };
-  }
-};
-var TOOLS_REGISTRY = [certificatesSearch, unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily];
-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) => {
-    const shape = `{${t.params.map((p) => `"${p.key}": "<${p.description}>"`).join(", ")}}`;
-    return `TOOL ${t.name} ${shape}`;
-  }),
-  "The worker runs it and returns the result attributed \u2014 phrase the tool's result as what it returned, with the searched string visible in your answer. Use a tool when the question turns on what it answers (including from a photograph). If you do not need it, answer directly without the line."
-].join("\n");
-async function runTool(env, call, audience = "agent") {
-  const spec = TOOLS_REGISTRY.find((t) => t.name === call.name && t.audiences.includes(audience));
-  if (!spec) return null;
-  return spec.handler(env, call.args ?? {});
-}
-function toolNote(r) {
-  return `The ${r.name} tool returned, for the query "${r.query}":
-${r.output}`;
-}
-
-export {
-  resolveBlocks,
-  contractV2,
-  tableRetyped,
-  parseToolCall,
-  TOOLS_REGISTRY,
-  TOOL_DECLARATION,
-  runTool,
-  toolNote
-};