@konneal/engine 0.2.56 → 0.2.57

package/dist/{ask-5XMD22SJ.js → ask-26DGSVFW.js}

@@ -1,11 +1,12 @@
 import {
   handleAsk
-} from "./chunk-ZVMQHCNL.js";
+} from "./chunk-MNEUEHO7.js";
 import "./chunk-TPV5GPY2.js";
 import "./chunk-SPKPH54J.js";
 import "./chunk-A3QHHUN5.js";
 import "./chunk-LVZTWUVJ.js";
 import "./chunk-2PCUAJJO.js";
+import "./chunk-Z6JAGZAM.js";
 import "./chunk-3FYJM7LH.js";
 export {
   handleAsk

package/dist/certificates-DZJJLRGU.js

@@ -0,0 +1,17 @@
+import {
+  buildRegisterQuery,
+  isRegisterShaped,
+  queryFamily,
+  registerNote,
+  registerTokens,
+  searchRegister
+} from "./chunk-Z6JAGZAM.js";
+import "./chunk-3FYJM7LH.js";
+export {
+  buildRegisterQuery,
+  isRegisterShaped,
+  queryFamily,
+  registerNote,
+  registerTokens,
+  searchRegister
+};

package/dist/{chunk-ZVMQHCNL.js → chunk-MNEUEHO7.js}

@@ -64,6 +64,10 @@ import {
   roleModel,
   sha256Hex
 } from "./chunk-2PCUAJJO.js";
+import {
+  registerNote,
+  searchRegister
+} from "./chunk-Z6JAGZAM.js";
 import {
   P
 } from "./chunk-3FYJM7LH.js";
@@ -1864,119 +1868,37 @@ function exactCacheKey(indexVersion, gen, ns, queryHash) {
   return `a:${indexVersion}:g${gen}:${ns}:${queryHash}`;
 }
 
-// workers/worker_public/src/certificates.ts
-function isRegisterShaped(query) {
-  return /\bcertif(ied|icates?|ication)s?\b/i.test(query) && /\b(is|are|still|currently|valid|status|suspended|revoked|was|were|have|has|hold|holds|possess|carry|got)\b/i.test(query);
-}
-function queryFamily(query) {
-  const m = /\b([RDMB])\s?-?(\d{2,3})\b/i.exec(query);
-  return m ? `${m[1].toUpperCase()}${m[2].padStart(2, "0")}` : null;
-}
-function registerTokens(query) {
-  const stop = /* @__PURE__ */ new Set([
-    "the",
-    "a",
-    "an",
-    "is",
-    "are",
-    "was",
-    "were",
-    "still",
-    "currently",
-    "in",
-    "on",
-    "for",
-    "of",
-    "and",
-    "or",
-    "certificate",
-    "certificates",
-    "certified",
-    "certification",
-    "register",
-    "status",
-    "valid",
-    "suspended",
-    "revoked",
-    "recommendation",
-    "per",
-    "under",
-    "by",
-    "with",
-    "what",
-    "which",
-    "who",
-    "does",
-    "do",
-    "load",
-    "cell",
-    "model",
-    "manufacturer",
-    "holder",
-    "company",
-    "r",
-    "how",
-    "to",
-    "list",
-    "show"
-  ]);
-  const tokens2 = [];
-  const publisherWord = P().publisher.name.toLowerCase();
-  for (const w of query.split(/[^A-Za-z0-9&-]+/)) {
-    if (w.length < 2) continue;
-    if (stop.has(w.toLowerCase())) continue;
-    if (w.toLowerCase() === publisherWord) continue;
-    if (/^\d+$/.test(w) && w.length < 2) continue;
-    if (!tokens2.includes(w)) tokens2.push(w);
-  }
-  return tokens2.slice(0, 6);
-}
-function buildRegisterQuery(tokens2) {
-  const params = [];
-  const clauses = tokens2.map((t) => {
-    if (/^\d+$/.test(t)) {
-      const padded = `% ${t.toLowerCase()} %`;
-      params.push(t, t, padded);
-      const n1 = params.length - 2;
-      const n2 = params.length;
-      return `(model = ?${n1} OR num = ?${n1} OR (' ' || REPLACE(REPLACE(REPLACE(LOWER(model), '-', ' '), ',', ' '), '.', ' ') || ' ') LIKE ?${n2})`;
-    }
-    params.push(`%${t}%`);
-    const n = params.length;
-    return `(holder LIKE ?${n} OR model LIKE ?${n} OR num LIKE ?${n})`;
-  });
-  return {
-    sql: `SELECT num, family, holder, model, year, status FROM certificates WHERE ${clauses.join(" OR ")} LIMIT 6`,
-    params
-  };
-}
-async function searchRegister(db, query) {
-  if (!isRegisterShaped(query)) return null;
-  const tokens2 = registerTokens(query);
-  if (!tokens2.length) return null;
-  const built = buildRegisterQuery(tokens2);
-  let { sql, params } = built;
-  const family = queryFamily(query);
-  if (family) {
-    sql = sql.replace(" WHERE ", " WHERE family = ?0 AND ");
-    params.unshift(family);
-  }
-  try {
-    const res = await db.prepare(sql).bind(...params).all();
-    return { rows: res.results ?? [], tokens: tokens2 };
-  } catch {
-    return { rows: [], tokens: tokens2 };
+// 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 };
 }
-function registerNote(rows) {
-  if (!rows.length) {
-    return `Certificate register: NO certificate matching the asked holder or model appears in the ${P().publisher.name}-CS register snapshot. State plainly that no such certificate is in this register, and that the register is a snapshot rather than the live certification status.`;
-  }
-  const lines = rows.map((r) => `- ${r.num}: holder ${r.holder}, model "${r.model}"${r.year ? `, issued ${r.year}` : ""} \u2014 status ${r.status}`);
-  return [
-    "Certificate register \u2014 the following certificates matched the asked holder or model. Quote the certificate number, the holder and the status verbatim; the register is a snapshot, so qualify any statement about current certification accordingly.",
-    ...lines
-  ].join("\n");
+var TOOL_DECLARATION = `You may use one tool before answering, by writing a single line:
+TOOL register_search {"query": "manufacturer and model to look up"}
+The worker runs it against the certificate register (a snapshot) and returns the matching rows, or the exact no-match statement for the string you asked. Use it when the question turns on certification standing and the holder is known \u2014 including from a photograph. Then answer, phrasing the tool's result as what it returned (the searched string stays visible in your answer). If you do not need the tool, answer directly without the line.`;
+async function runTool(db, call) {
+  if (call.name !== "register_search") return null;
+  const query = String(call.args?.query ?? "").trim().slice(0, 160);
+  if (!query) return null;
+  const { searchRegister: searchRegister2, registerNote: registerNote2 } = await import("./certificates-DZJJLRGU.js");
+  const reg = await searchRegister2(db, query);
+  const output = reg?.rows?.length ? registerNote2(reg.rows) : `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: call.name, query, output };
+}
+function toolNote(r) {
+  return `The ${r.name} tool returned, for the query "${r.query}":
+${r.output}`;
 }
 
 // workers/worker_public/prompts/nameplate.md
@@ -2743,6 +2665,27 @@ Answer account questions from these records ONLY: name the record when you use i
     budget
   );
   await attachFigureImages(env, messages, usedHits, q.query);
+  if (/certificate|certified|certification/i.test(q.query) && env.DB) {
+    try {
+      const probe = await env.AI.run(model, {
+        messages: [...messages.slice(0, -1), { role: "user", content: `${TOOL_DECLARATION}
+
+${q.query}` }],
+        max_tokens: 300,
+        reasoning_effort: "low"
+      });
+      const probeText = typeof probe?.response === "string" ? probe.response : probe?.choices?.[0]?.message?.content ?? "";
+      const call = parseToolCall(probeText);
+      if (call) {
+        const result = await runTool(env.DB, call);
+        if (result) {
+          messages.push({ role: "system", content: toolNote(result) });
+          console.log("agent-tool:", result.name, JSON.stringify(result.query), "->", result.output.slice(0, 80));
+        }
+      }
+    } catch {
+    }
+  }
   if (withImage) {
     const wantsMarkings = /\b(mark(ing|ings)?|nameplate|label|inscription|engrav|sticker|plate)\b|certificat/i.test(q.query);
     const last = messages[messages.length - 1];

package/dist/chunk-Z6JAGZAM.js

@@ -0,0 +1,127 @@
+import {
+  P
+} from "./chunk-3FYJM7LH.js";
+
+// workers/worker_public/src/certificates.ts
+function isRegisterShaped(query) {
+  return /\bcertif(ied|icates?|ication)s?\b/i.test(query) && /\b(is|are|still|currently|valid|status|suspended|revoked|was|were|have|has|hold|holds|possess|carry|got)\b/i.test(query);
+}
+function queryFamily(query) {
+  const m = /\b([RDMB])\s?-?(\d{2,3})\b/i.exec(query);
+  return m ? `${m[1].toUpperCase()}${m[2].padStart(2, "0")}` : null;
+}
+function registerTokens(query) {
+  const stop = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "still",
+    "currently",
+    "in",
+    "on",
+    "for",
+    "of",
+    "and",
+    "or",
+    "certificate",
+    "certificates",
+    "certified",
+    "certification",
+    "register",
+    "status",
+    "valid",
+    "suspended",
+    "revoked",
+    "recommendation",
+    "per",
+    "under",
+    "by",
+    "with",
+    "what",
+    "which",
+    "who",
+    "does",
+    "do",
+    "load",
+    "cell",
+    "model",
+    "manufacturer",
+    "holder",
+    "company",
+    "r",
+    "how",
+    "to",
+    "list",
+    "show"
+  ]);
+  const tokens = [];
+  const publisherWord = P().publisher.name.toLowerCase();
+  for (const w of query.split(/[^A-Za-z0-9&-]+/)) {
+    if (w.length < 2) continue;
+    if (stop.has(w.toLowerCase())) continue;
+    if (w.toLowerCase() === publisherWord) continue;
+    if (/^\d+$/.test(w) && w.length < 2) continue;
+    if (!tokens.includes(w)) tokens.push(w);
+  }
+  return tokens.slice(0, 6);
+}
+function buildRegisterQuery(tokens) {
+  const params = [];
+  const clauses = tokens.map((t) => {
+    if (/^\d+$/.test(t)) {
+      const padded = `% ${t.toLowerCase()} %`;
+      params.push(t, t, padded);
+      const n1 = params.length - 2;
+      const n2 = params.length;
+      return `(model = ?${n1} OR num = ?${n1} OR (' ' || REPLACE(REPLACE(REPLACE(LOWER(model), '-', ' '), ',', ' '), '.', ' ') || ' ') LIKE ?${n2})`;
+    }
+    params.push(`%${t}%`);
+    const n = params.length;
+    return `(holder LIKE ?${n} OR model LIKE ?${n} OR num LIKE ?${n})`;
+  });
+  return {
+    sql: `SELECT num, family, holder, model, year, status FROM certificates WHERE ${clauses.join(" OR ")} LIMIT 6`,
+    params
+  };
+}
+async function searchRegister(db, query) {
+  if (!isRegisterShaped(query)) return null;
+  const tokens = registerTokens(query);
+  if (!tokens.length) return null;
+  const built = buildRegisterQuery(tokens);
+  let { sql, params } = built;
+  const family = queryFamily(query);
+  if (family) {
+    sql = sql.replace(" WHERE ", " WHERE family = ?0 AND ");
+    params.unshift(family);
+  }
+  try {
+    const res = await db.prepare(sql).bind(...params).all();
+    return { rows: res.results ?? [], tokens };
+  } catch {
+    return { rows: [], tokens };
+  }
+}
+function registerNote(rows) {
+  if (!rows.length) {
+    return `Certificate register: NO certificate matching the asked holder or model appears in the ${P().publisher.name}-CS register snapshot. State plainly that no such certificate is in this register, and that the register is a snapshot rather than the live certification status.`;
+  }
+  const lines = rows.map((r) => `- ${r.num}: holder ${r.holder}, model "${r.model}"${r.year ? `, issued ${r.year}` : ""} \u2014 status ${r.status}`);
+  return [
+    "Certificate register \u2014 the following certificates matched the asked holder or model. Quote the certificate number, the holder and the status verbatim; the register is a snapshot, so qualify any statement about current certification accordingly.",
+    ...lines
+  ].join("\n");
+}
+
+export {
+  isRegisterShaped,
+  queryFamily,
+  registerTokens,
+  buildRegisterQuery,
+  searchRegister,
+  registerNote
+};

package/dist/tools.d.ts

@@ -0,0 +1,18 @@
+export interface ToolCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+export interface ToolResult {
+    name: string;
+    query: string;
+    output: string;
+}
+/** The strict protocol: a line `TOOL register_search {"query": "…"}`.
+ *  Plain regex parse — no JSON mode needed, tolerant of surrounding
+ *  prose (the model may talk around the call). */
+export declare function parseToolCall(text: string): ToolCall | null;
+export declare const TOOL_DECLARATION = "You may use one tool before answering, by writing a single line:\nTOOL register_search {\"query\": \"manufacturer and model to look up\"}\nThe worker runs it against the certificate register (a snapshot) and returns the matching rows, or the exact no-match statement for the string you asked. Use it when the question turns on certification standing and the holder is known \u2014 including from a photograph. Then answer, phrasing the tool's result as what it returned (the searched string stays visible in your answer). If you do not need the tool, answer directly without the line.";
+export declare function runTool(db: any, call: ToolCall): Promise<ToolResult | null>;
+/** The attributed injection: the answer model sees what the tool
+ *  returned, for the string it asked — never a standing claim. */
+export declare function toolNote(r: ToolResult): string;

package/dist/worker_public/src/index.js

@@ -1,6 +1,3 @@
-import {
-  handleSearch
-} from "../../chunk-FLNX4O7C.js";
 import {
   bindModelNode,
   checkQuoteAnchors,
@@ -9,7 +6,10 @@ import {
   modelGroundingBlock,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-ZVMQHCNL.js";
+} from "../../chunk-MNEUEHO7.js";
+import {
+  handleSearch
+} from "../../chunk-FLNX4O7C.js";
 import {
   buildMessages,
   cfBlobs,
@@ -63,6 +63,7 @@ import {
   sha256Hex,
   today
 } from "../../chunk-2PCUAJJO.js";
+import "../../chunk-Z6JAGZAM.js";
 import {
   P,
   setProfile
@@ -958,7 +959,7 @@ 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 res = name === "ask" ? await (await import("../../ask-5XMD22SJ.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-PBOODCMQ.js")).handleSearch(env, ctx, inner, tier, key);
+    const res = name === "ask" ? await (await import("../../ask-26DGSVFW.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-PBOODCMQ.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.56",
+  "version": "0.2.57",
   "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

@@ -40,6 +40,7 @@ import { json, err, corsHeaders, readJson, validateQuery, type ApiKey } from "./
 import { clientIp, checkQuota, telemetry } from "./quota";
 import { graphExpand, editionNote } from "./graph";
 import { registerNote, searchRegister } from "./certificates";
+import { TOOL_DECLARATION, parseToolCall, runTool, toolNote } from "./tools";
 import { extractNameplate, nameplateRegisterQuery } from "./nameplate.ts";
 import { P } from "./profile.ts";
 
@@ -1147,6 +1148,31 @@ let convEntities: Array<{ entity: string; kind: string }> = [];
     budget,
   );
   await attachFigureImages(env, messages, usedHits, q.query);
+  // the agent loop (the owner's 2026-09-28 direction): ONE bounded tool
+  // round, armed only where a tool can help. The model may call
+  // register_search through the strict line protocol; the worker
+  // executes it deterministically and the ATTRIBUTED result joins the
+  // messages — what the tool returned, for the string it asked.
+  if (/certificate|certified|certification/i.test(q.query) && env.DB) {
+    try {
+      const probe = await (env as any).AI.run(model, {
+        messages: [...messages.slice(0, -1), { role: "user", content: `${TOOL_DECLARATION}\n\n${q.query}` }],
+        max_tokens: 300,
+        reasoning_effort: "low",
+      });
+      const probeText = typeof probe?.response === "string" ? probe.response : probe?.choices?.[0]?.message?.content ?? "";
+      const call = parseToolCall(probeText);
+      if (call) {
+        const result = await runTool(env.DB, call);
+        if (result) {
+          messages.push({ role: "system", content: toolNote(result) });
+          console.log("agent-tool:", result.name, JSON.stringify(result.query), "->", result.output.slice(0, 80));
+        }
+      }
+    } catch {
+      /* the loop is optional — the answer proceeds without the tool */
+    }
+  }
   if (withImage) {
     // the user's own image rides on the question message — retrieval stays
     // text-driven; the answer model reads the image as question context.

package/workers/worker_public/src/tools.ts

@@ -0,0 +1,55 @@
+// The agent interface's tool plane (the owner's 2026-09-28 direction): a
+// bounded tool loop on the serving path. The model may invoke named
+// tools through a strict line protocol; the worker executes each
+// deterministically and the result rides back ATTRIBUTED — every tool
+// output is phrased as what the tool returned, and the searched string
+// is always visible in the answer. One round per ask, armed only where
+// a tool can help (the certificate intent, v1).
+
+export interface ToolCall {
+  name: string;
+  args: Record<string, unknown>;
+}
+
+export interface ToolResult {
+  name: string;
+  query: string;
+  output: string;
+}
+
+/** The strict protocol: a line `TOOL register_search {"query": "…"}`.
+ *  Plain regex parse — no JSON mode needed, tolerant of surrounding
+ *  prose (the model may talk around the call). */
+export function parseToolCall(text: string): ToolCall | null {
+  const m = /^TOOL\s+([a-z_]+)\s*(\{[^\n}]*\})?/m.exec(String(text ?? "")); // line-anchored, case-sensitive: prose never trips it
+  if (!m) return null;
+  let args: Record<string, unknown> = {};
+  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; // a malformed call (opened, never closed) is not a call
+  }
+  return { name: m[1].toLowerCase(), args };
+}
+
+export const TOOL_DECLARATION = `You may use one tool before answering, by writing a single line:
+TOOL register_search {"query": "manufacturer and model to look up"}
+The worker runs it against the certificate register (a snapshot) and returns the matching rows, or the exact no-match statement for the string you asked. Use it when the question turns on certification standing and the holder is known — including from a photograph. Then answer, phrasing the tool's result as what it returned (the searched string stays visible in your answer). If you do not need the tool, answer directly without the line.`;
+
+export async function runTool(db: any, call: ToolCall): Promise<ToolResult | null> {
+  if (call.name !== "register_search") return null;
+  const query = String(call.args?.query ?? "").trim().slice(0, 160);
+  if (!query) return null;
+  const { searchRegister, registerNote } = await import("./certificates");
+  const reg = await searchRegister(db, query);
+  const output = reg?.rows?.length
+    ? registerNote(reg.rows)
+    : `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: call.name, query, output };
+}
+
+/** The attributed injection: the answer model sees what the tool
+ *  returned, for the string it asked — never a standing claim. */
+export function toolNote(r: ToolResult): string {
+  return `The ${r.name} tool returned, for the query "${r.query}":\n${r.output}`;
+}