@konneal/engine 0.2.136 → 0.2.138

package/dist/{chunk-J6LBR6GI.js → chunk-RKNN3WAV.js}

@@ -1,10 +1,6 @@
 import {
-  embed,
-  hasLane,
-  portIndex,
-  portModelRunner,
-  portStore
-} from "./chunk-TH5XGPD5.js";
+  embed
+} from "./chunk-NI4CIK6W.js";
 import {
   standardKeysFrom
 } from "./chunk-4NXH5ZI6.js";
@@ -14,6 +10,12 @@ import {
 import {
   P
 } from "./chunk-3FYJM7LH.js";
+import {
+  hasLane,
+  portIndex,
+  portModelRunner,
+  portStore
+} from "./chunk-LSZTJI7V.js";
 
 // workers/worker_public/src/refs.ts
 var REF = /\[\[(u:[A-Za-z0-9_-]+)\]\]/g;
@@ -1157,21 +1159,279 @@ var glossaryLookup = {
   }
 };
 
+// workers/worker_public/src/dbtools.ts
+var DB_CATALOG = [
+  {
+    name: "certificates",
+    description: "The certificate register (a snapshot, not live certification status): one row per issued certificate across the recommendation families.",
+    columns: [
+      { name: "num", type: "text", description: "the printed certificate number, e.g. R60/2021-A-NL1-26.12 (family/prefix per recommendation)" },
+      { name: "family", type: "text", description: "the recommendation family number, e.g. '60' for R 60" },
+      { name: "holder", type: "text", description: "the certificate holder (manufacturer)" },
+      { name: "model", type: "text", description: "the instrument model designation" },
+      { name: "year", type: "number", description: "the issue year", numeric_cast: true },
+      { name: "status", type: "text", description: "Valid | Suspended | Withdrawn" },
+      { name: "pdf_key", type: "text", description: "the /cert-pdf path suffix when the PDF is on file, else empty" }
+    ],
+    default_select: ["num", "family", "holder", "model", "year", "status", "pdf_key"]
+  },
+  {
+    name: "documents",
+    description: "The document identity registry: every publication edition with its family, part, and derived edition status (an edition with a successor is superseded regardless of any copied status field).",
+    columns: [
+      { name: "canonical_id", type: "text", description: "doc:<family>-<edition> slug" },
+      { name: "docidentifier", type: "text", description: "the full identifier with edition" },
+      { name: "family", type: "text", description: "the family key, e.g. R-60" },
+      { name: "part", type: "text", description: "1 | 2 | 3 | A | annexes | sup | empty" },
+      { name: "edition", type: "number", description: "the edition year", numeric_cast: true },
+      { name: "status", type: "text", description: "in-force | superseded | withdrawn (as recorded)" },
+      { name: "derived_status", type: "text", description: "the successor-edge derivation result" },
+      { name: "active", type: "number", description: "1 = the active edition of its family+part" },
+      { name: "superseded_by", type: "text", description: "the successor's canonical_id, else empty" },
+      { name: "title", type: "text", description: "the publication title" }
+    ],
+    default_select: ["canonical_id", "docidentifier", "family", "part", "edition", "derived_status", "active", "superseded_by", "title"]
+  },
+  {
+    name: "graph_nodes",
+    description: "The public citation-graph nodes: documents, families, and vocabulary concepts.",
+    columns: [
+      { name: "id", type: "text", description: "doc:<identifier-slug> | family:<number> | concept:<id>" },
+      { name: "kind", type: "text", description: "doc | family | concept" },
+      { name: "label", type: "text", description: "the display label" }
+    ],
+    default_select: ["id", "kind", "label"]
+  },
+  {
+    name: "graph_edges",
+    description: "The public citation-graph edges between nodes.",
+    columns: [
+      { name: "src", type: "text", description: "the source node id" },
+      { name: "dst", type: "text", description: "the destination node id" },
+      { name: "kind", type: "text", description: "part_of | variant_of | successor | amends | defines" }
+    ],
+    default_select: ["src", "kind", "dst"]
+  },
+  {
+    name: "model_nodes",
+    description: "The Recommendation model plane (per-standard requirement/conformance graphs): the machine-readable nodes behind the verdict engine.",
+    columns: [
+      { name: "standard", type: "text", description: "the standard key, e.g. r60" },
+      { name: "node_id", type: "text", description: "/req/metrological/mpe" },
+      { name: "kind", type: "text", description: "requirement | conformance_test | term | constraint | characteristic | state_machine | dimension" },
+      { name: "name", type: "text", description: "the node's display name" },
+      { name: "clause_doc", type: "text", description: "the provenance document urn" },
+      { name: "clause_ref", type: "text", description: "the clause inside it, e.g. 5.3.2" },
+      { name: "content", type: "text", description: "the node's JSON projection (the checks, thresholds, parameters)", wide: true },
+      { name: "content_hash", type: "text", description: "sha256 of content" }
+    ],
+    default_select: ["standard", "node_id", "kind", "name", "clause_doc", "clause_ref"]
+  },
+  {
+    name: "unit_payloads",
+    description: "Typed retrievable units (tables, formulas, figures, terms) with their producer payloads.",
+    columns: [
+      { name: "unit_id", type: "text", description: "u:table-1" },
+      { name: "doc_id", type: "text", description: "the owning document id" },
+      { name: "docidentifier", type: "text", description: "the publication identifier with part" },
+      { name: "edition", type: "text", description: "the edition year" },
+      { name: "clause_anchor", type: "text", description: "the clause the unit lives in" },
+      { name: "type", type: "text", description: "table | formula | figure | term | requirement" },
+      { name: "payload", type: "text", description: "the producer payload JSON (the table's rows, the formula's math)", wide: true }
+    ],
+    default_select: ["unit_id", "doc_id", "docidentifier", "edition", "clause_anchor", "type"]
+  },
+  {
+    name: "chunks",
+    description: "The indexed corpus chunks (one row per clause-level passage) \u2014 use for exact metadata questions; semantic search is NOT this tool's job.",
+    columns: [
+      { name: "id", type: "text", description: "the chunk id" },
+      { name: "doc_id", type: "text", description: "the source document slug" },
+      { name: "docidentifier", type: "text", description: "the publication identifier with part" },
+      { name: "doctype", type: "text", description: "R | D | B | G | E" },
+      { name: "doc_number", type: "text", description: "60" },
+      { name: "edition", type: "text", description: "the edition year" },
+      { name: "language", type: "text", description: "en | fr | \u2026" },
+      { name: "clause_anchor", type: "text", description: "the clause anchor" },
+      { name: "clause_title", type: "text", description: "the clause title" },
+      { name: "status", type: "text", description: "in-force | superseded" },
+      { name: "superseded_by", type: "text", description: "the superseding docidentifier, else empty" },
+      { name: "corpus", type: "text", description: "clean | dirty" },
+      { name: "tier", type: "text", description: "the quality tier" },
+      { name: "text", type: "text", description: "the passage body (wide \u2014 select only when needed)", wide: true },
+      { name: "fts_text", type: "text", description: "context preamble + body (wide)", wide: true }
+    ],
+    default_select: ["id", "doc_id", "docidentifier", "doctype", "doc_number", "edition", "language", "clause_anchor", "clause_title", "status", "corpus"]
+  }
+];
+function publishedTable(name) {
+  return DB_CATALOG.find((t) => t.name === name);
+}
+var FIND_OPS = ["eq", "ne", "lt", "le", "gt", "ge", "in", "like", "between"];
+var MAX_LIMIT = 25;
+var DEFAULT_LIMIT = 10;
+var NUMERIC_OPS = ["lt", "le", "gt", "ge", "between"];
+function compileFind(args) {
+  const table = publishedTable(String(args?.table ?? ""));
+  if (!table) {
+    return {
+      ok: false,
+      error: `unknown table "${String(args?.table ?? "")}". Published tables: ${DB_CATALOG.map((t) => t.name).join(", ")}.`
+    };
+  }
+  const colNames = table.columns.map((c) => c.name);
+  const colByName = new Map(table.columns.map((c) => [c.name, c]));
+  const params = [];
+  const phrases = [];
+  const p = (n) => `?${n}`;
+  const colRef = (col) => {
+    const c = colByName.get(col);
+    return c.numeric_cast ? `CAST(${col} AS INTEGER)` : col;
+  };
+  for (const w of Array.isArray(args?.where) ? args.where : []) {
+    const col = String(w?.col ?? "");
+    const colDef = colByName.get(col);
+    if (!colDef) {
+      return {
+        ok: false,
+        error: `table "${table.name}" has no column "${col}". Valid columns: ${colNames.join(", ")}.`
+      };
+    }
+    const op = String(w?.op ?? "");
+    if (!FIND_OPS.includes(op)) {
+      return { ok: false, error: `unknown op "${op}". Valid ops: ${FIND_OPS.join(", ")}.` };
+    }
+    const v = w?.value;
+    if (NUMERIC_OPS.includes(op) && !colDef.numeric_cast && colDef.type !== "number") {
+      return { ok: false, error: `op "${op}" needs a numeric column; "${col}" is ${colDef.type}.` };
+    }
+    const ref = colRef(col);
+    if (op === "in") {
+      const list = Array.isArray(v) ? v.map((x) => String(x)) : [String(v)];
+      if (!list.length) return { ok: false, error: `op "in" needs a non-empty value list.` };
+      const holders = list.map((x) => p(params.push(x))).join(", ");
+      phrases.push(`${ref} IN (${holders})`);
+    } else if (op === "between") {
+      const pair = Array.isArray(v) ? v : [void 0, void 0];
+      if (pair.length !== 2) return { ok: false, error: `op "between" needs a two-element value [lo, hi].` };
+      phrases.push(`${ref} BETWEEN ${p(params.push(pair[0]))} AND ${p(params.push(pair[1]))}`);
+    } else if (op === "like") {
+      phrases.push(`${ref} LIKE ${p(params.push(String(v)))}`);
+    } else {
+      const sqlOp = { eq: "=", ne: "!=", lt: "<", le: "<=", gt: ">", ge: ">=" }[op];
+      phrases.push(`${ref} ${sqlOp} ${p(params.push(v))}`);
+    }
+  }
+  const select = (Array.isArray(args?.select) && args.select.length ? args.select : table.default_select).map(String);
+  for (const s of select) {
+    if (!colNames.includes(s)) {
+      return { ok: false, error: `table "${table.name}" has no column "${s}". Valid columns: ${colNames.join(", ")}.` };
+    }
+  }
+  let head;
+  if (args?.agg?.fn) {
+    const fn = String(args.agg.fn);
+    if (!["count", "sum", "avg", "min", "max"].includes(fn)) {
+      return { ok: false, error: `unknown agg fn "${fn}". Valid: count, sum, avg, min, max.` };
+    }
+    let aggExpr = "COUNT(*)";
+    if (fn !== "count") {
+      const acol = String(args.agg.col ?? "");
+      const adef = colByName.get(acol);
+      if (!adef) return { ok: false, error: `agg column "${acol}" is not a column of "${table.name}". Valid columns: ${colNames.join(", ")}.` };
+      aggExpr = `${fn.toUpperCase()}(${colRef(acol)})`;
+    }
+    head = `SELECT ${args?.group_by?.length ? `${args.group_by.map(String).join(", ")}, ` : ""}${aggExpr} AS agg FROM ${table.name}`;
+    for (const g of args?.group_by ?? []) {
+      if (!colNames.includes(String(g))) {
+        return { ok: false, error: `table "${table.name}" has no column "${String(g)}". Valid columns: ${colNames.join(", ")}.` };
+      }
+    }
+  } else {
+    head = `SELECT ${select.join(", ")} FROM ${table.name}`;
+  }
+  const where = phrases.length ? ` WHERE ${phrases.join(" AND ")}` : "";
+  let tail = "";
+  if (args?.group_by?.length) tail += ` GROUP BY ${args.group_by.map(String).join(", ")}`;
+  if (args?.order_by?.col) {
+    const ocol = String(args.order_by.col);
+    if (!colNames.includes(ocol)) {
+      return { ok: false, error: `table "${table.name}" has no column "${ocol}". Valid columns: ${colNames.join(", ")}.` };
+    }
+    const dir = String(args.order_by.dir ?? "desc").toLowerCase() === "asc" ? "ASC" : "DESC";
+    tail += ` ORDER BY ${colRef(ocol)} ${dir}`;
+  }
+  const limit = Math.max(1, Math.min(MAX_LIMIT, Number(args?.limit ?? DEFAULT_LIMIT) || DEFAULT_LIMIT));
+  tail += ` LIMIT ${limit}`;
+  const echo = [
+    `db.find ${table.name}`,
+    args?.where?.length ? `where ${args.where.map((w) => `${w.col} ${w.op} ${JSON.stringify(w.value ?? null)}`).join(" AND ")}` : "all rows",
+    args?.agg?.fn ? `${args.agg.fn}${args.agg.col ? ` ${args.agg.col}` : ""}` : ""
+  ].filter(Boolean).join(" \xB7 ");
+  return {
+    ok: true,
+    sql: `${head}${where}${tail}`,
+    params,
+    echo
+  };
+}
+async function runFind(env, args) {
+  const compiled = compileFind(args);
+  if (!compiled.ok) {
+    return {
+      name: "db.find",
+      query: String(args?.table ?? ""),
+      output: `The query was rejected: ${compiled.error} Correct the predicates and call again.`
+    };
+  }
+  try {
+    const { portStore: portStore2 } = await import("./env-LMHGNJTN.js");
+    const res = await portStore2(env).prepare(compiled.sql).bind(...compiled.params).all();
+    const rows = res?.results ?? [];
+    const body = rows.length ? rows.map((r) => JSON.stringify(r)).join("\n") : "No rows matched. Either the predicates are too narrow or the data is absent \u2014 state which, and consider widening.";
+    const aggNote = args?.agg?.fn ? " (aggregate)" : "";
+    return { name: "db.find", query: compiled.echo, output: `${compiled.echo}${aggNote} \u2192 ${rows.length} row(s):
+${body}` };
+  } catch (e) {
+    return { name: "db.find", query: compiled.echo, output: `The query failed to run: ${String(e?.message ?? e).slice(0, 200)}` };
+  }
+}
+function runSchema(table) {
+  const tables = table ? [publishedTable(String(table))].filter(Boolean) : DB_CATALOG;
+  if (!tables.length) {
+    return {
+      name: "db.schema",
+      query: String(table),
+      output: `Unknown table "${table}". Published tables: ${DB_CATALOG.map((t) => t.name).join(", ")}.`
+    };
+  }
+  const output = tables.map((t) => {
+    const cols = t.columns.map((c) => `  ${c.name} (${c.type}${c.numeric_cast ? ", numeric-cast" : ""}${c.wide ? ", wide" : ""}) \u2014 ${c.description}`).join("\n");
+    return `${t.name} \u2014 ${t.description}
+${cols}
+  default select: ${t.default_select.join(", ")}`;
+  }).join("\n\n");
+  return {
+    name: "db.schema",
+    query: table ? String(table) : "catalog",
+    output: `Published tables (compose TOOL db.find with where: [{col, op, value}]; ops: ${FIND_OPS.join(" ")}; values bind safely; like accepts % and _ wildcards):
+
+${output}`
+  };
+}
+
 // workers/worker_public/src/tools.ts
 function parseToolCall(text) {
-  const m = /^TOOL\s+([a-z_.]+)\s*(\{[^\n}]*\})?/m.exec(String(text ?? ""));
+  const m = /^TOOL\s+([a-z_.]+)[ \t]*(\{.*)?$/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 ?? ""))) {
+  const rest = (m[2] ?? "").trim();
+  if (!rest) return { name: m[1].toLowerCase(), args: {} };
+  if (!rest.startsWith("{")) return null;
+  try {
+    return { name: m[1].toLowerCase(), args: JSON.parse(rest) };
+  } catch {
     return null;
   }
-  return { name: m[1].toLowerCase(), args };
 }
 var certificatesSearch = {
   name: "certificates.search",
@@ -1187,14 +1447,50 @@ var certificatesSearch = {
     return { name: "certificates.search", query, output };
   }
 };
-var TOOLS_REGISTRY = [certificatesSearch, unitsGet, graphCites, docsSection, glossaryLookup, documentsFamily, licensedSection, verdictEvaluate, conditionsCheck, bibEntry, unitsLookup, unitsConvert];
+var dbSchema = {
+  name: "db.schema",
+  description: "The published data map: every queryable table (the certificate register, the document registry, the citation graph, the model plane, typed units, the corpus chunks) with its columns, types, and meanings. Call this first whenever a question turns on structured data; then compose db.find.",
+  params: [{ key: "table", required: false, description: "one table's detail; omit for the whole catalog" }],
+  audiences: ["agent", "mcp"],
+  handler: async (_env, args) => {
+    const t = args?.table ? String(args.table) : void 0;
+    return runSchema(t);
+  }
+};
+var dbFind = {
+  name: "db.find",
+  description: "Query a published table with typed predicates you compose: where: [{col, op, value}] with ops eq|ne|lt|le|gt|ge|in|like|between, optional select, order_by {col, dir}, limit (\u226425), group_by + agg {fn: count|sum|avg|min|max, col}. Values bind safely; identifiers validate against the schema (errors name the valid columns). Returns the matching rows or aggregate with the query echoed.",
+  params: [
+    { key: "table", required: true, description: "a published table (db.schema lists them)" },
+    { key: "where", required: false, description: "[{col, op, value}] predicates, ANDed" },
+    { key: "select", required: false, description: "columns to return; default per table" },
+    { key: "order_by", required: false, description: "{col, dir: asc|desc}" },
+    { key: "limit", required: false, description: "row cap, \u226425" },
+    { key: "agg", required: false, description: "{fn, col?} aggregate instead of rows; with group_by: [cols]" }
+  ],
+  audiences: ["agent", "mcp"],
+  handler: async (env, args) => {
+    const findArgs = {
+      table: String(args?.table ?? ""),
+      where: Array.isArray(args?.where) ? args.where : [],
+      select: Array.isArray(args?.select) ? args.select : void 0,
+      order_by: args?.order_by && typeof args.order_by === "object" ? args.order_by : void 0,
+      limit: args?.limit != null ? Number(args.limit) : void 0,
+      group_by: Array.isArray(args?.group_by) ? args.group_by : void 0,
+      agg: args?.agg && typeof args.agg === "object" ? args.agg : void 0
+    };
+    if (!findArgs.table) return null;
+    return runFind(env, findArgs);
+  }
+};
+var TOOLS_REGISTRY = [dbSchema, dbFind, 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:",
+  "You may query data before answering, by writing ONE line per call:",
   ...TOOLS_REGISTRY.filter((t) => t.audiences.includes("agent")).map((t) => {
-    const shape = `{${t.params.map((p) => `"${p.key}": "<${p.description}>"`).join(", ")}}`;
+    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."
+  "The worker runs each call and returns the result attributed; you may issue up to three calls across the turns, one per turn, each on its own single line (compact JSON, no line breaks). Structured questions \u2014 counts, latest, filters, per-holder or per-year breakdowns over the register, document editions, model-plane requirements \u2014 start from TOOL db.schema (it lists the queryable tables and their columns), then compose TOOL db.find predicates. Each result arrives attributed: phrase it as what the tool returned, with your query visible in the answer. When you have enough, answer WITHOUT a TOOL line; if no tool helps, answer directly."
 ].join("\n");
 async function runTool(env, call, audience = "agent") {
   const spec = TOOLS_REGISTRY.find((t) => t.name === call.name && t.audiences.includes(audience));

package/dist/{chunk-7AXXR7GD.js → chunk-XH5QGX2O.js}

@@ -1,11 +1,7 @@
 import {
   embed,
-  hasLane,
-  portIndex,
-  portModelRunner,
-  portStore,
   rerank
-} from "./chunk-TH5XGPD5.js";
+} from "./chunk-NI4CIK6W.js";
 import {
   bubbleConfirmPage,
   isAllowedBubbleOrigin
@@ -23,6 +19,12 @@ import {
 import {
   P
 } from "./chunk-3FYJM7LH.js";
+import {
+  hasLane,
+  portIndex,
+  portModelRunner,
+  portStore
+} from "./chunk-LSZTJI7V.js";
 
 // node_modules/@pubid/pubid/dist/grammar/engine.js
 var ParseFailed = class extends Error {

package/dist/dbtools.d.ts

@@ -0,0 +1,67 @@
+export interface CatalogColumn {
+    name: string;
+    type: "text" | "number";
+    description: string;
+    /** ordering/comparison compiles CAST(col AS INTEGER) — textual columns
+     *  carrying numeric content (certificates.year is TEXT in D1) */
+    numeric_cast?: boolean;
+    /** excluded from the default select (heavy bodies); still selectable by name */
+    wide?: boolean;
+}
+export interface CatalogTable {
+    name: string;
+    description: string;
+    columns: CatalogColumn[];
+    default_select: string[];
+}
+export declare const DB_CATALOG: CatalogTable[];
+export declare function publishedTable(name: string): CatalogTable | undefined;
+export declare const FIND_OPS: readonly ["eq", "ne", "lt", "le", "gt", "ge", "in", "like", "between"];
+export type FindOp = (typeof FIND_OPS)[number];
+export interface FindPredicate {
+    col: string;
+    op: FindOp;
+    value: unknown;
+}
+export interface FindArgs {
+    table: string;
+    where?: FindPredicate[];
+    select?: string[];
+    order_by?: {
+        col: string;
+        dir?: "asc" | "desc";
+    };
+    limit?: number;
+    group_by?: string[];
+    agg?: {
+        fn: "count" | "sum" | "avg" | "min" | "max";
+        col?: string;
+    };
+}
+export type Compiled = {
+    ok: true;
+    sql: string;
+    params: unknown[];
+    echo: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** Compile validated identifiers + bound parameters. Returns a
+ *  schema-linked error (naming the valid columns) on any mismatch —
+ *  the model corrects from the error, the loop continues. */
+export declare function compileFind(args: FindArgs): Compiled;
+/** The db.find handler: compile, run on D1, format deterministically.
+ *  Every output carries the predicate echo — the answer attributes the
+ *  rows to the query that produced them. */
+export declare function runFind(env: any, args: FindArgs): Promise<{
+    name: string;
+    query: string;
+    output: string;
+} | null>;
+/** The db.schema handler: the published map, one table or the catalog. */
+export declare function runSchema(table?: string): {
+    name: string;
+    query: string;
+    output: string;
+};

package/dist/env-LMHGNJTN.js

@@ -0,0 +1,18 @@
+import {
+  hasLane,
+  portBlobs,
+  portIndex,
+  portKv,
+  portModelRunner,
+  portRuntime,
+  portStore
+} from "./chunk-LSZTJI7V.js";
+export {
+  hasLane,
+  portBlobs,
+  portIndex,
+  portKv,
+  portModelRunner,
+  portRuntime,
+  portStore
+};

package/dist/mcp-proto.d.ts

@@ -1,4 +1,10 @@
 export declare const PROTOCOL_VERSION = "2025-06-18";
+/** Registry tool name → the MCP-presented name. */
+export declare function mcpName(registryName: string): string;
+/** MCP-presented name → the name the handlers dispatch on. Raw
+ *  registry names pass through (transition tolerance for early
+ *  consumers of the unprefixed surface). */
+export declare function registryName(presented: string): string;
 export interface McpTool {
     name: string;
     description: string;

package/dist/{search-LFS5HHMZ.js → search-VEGQBEFC.js}

@@ -1,13 +1,14 @@
 import {
   handleSearch
-} from "./chunk-MWOY24B6.js";
-import "./chunk-7AXXR7GD.js";
-import "./chunk-TH5XGPD5.js";
+} from "./chunk-5WITTJQD.js";
+import "./chunk-XH5QGX2O.js";
+import "./chunk-NI4CIK6W.js";
 import "./chunk-W7J5SFXJ.js";
 import "./chunk-XBZIJMS7.js";
 import "./chunk-4NXH5ZI6.js";
 import "./chunk-VT7DR6NQ.js";
 import "./chunk-3FYJM7LH.js";
+import "./chunk-LSZTJI7V.js";
 export {
   handleSearch
 };

package/dist/{tools-O4JYGVSR.js → tools-EZRLYLTM.js}

@@ -4,11 +4,12 @@ import {
   parseToolCall,
   runTool,
   toolNote
-} from "./chunk-J6LBR6GI.js";
-import "./chunk-TH5XGPD5.js";
+} from "./chunk-RKNN3WAV.js";
+import "./chunk-NI4CIK6W.js";
 import "./chunk-4NXH5ZI6.js";
 import "./chunk-VT7DR6NQ.js";
 import "./chunk-3FYJM7LH.js";
+import "./chunk-LSZTJI7V.js";
 export {
   TOOLS_REGISTRY,
   TOOL_DECLARATION,

package/dist/tools.d.ts

@@ -7,9 +7,10 @@ export interface ToolResult {
     query: string;
     output: string;
 }
-/** The strict protocol: a line `TOOL certificates.search {"query": "…"}`.
- *  Plain regex parse — no JSON mode needed, tolerant of surrounding
- *  prose (the model may talk around the call). */
+/** The strict protocol: a line `TOOL <name> {…json…}`. Line-anchored,
+ *  case-sensitive (prose never trips it); the args are the WHOLE rest
+ *  of the line parsed as JSON — nested objects (db.find predicates)
+ *  are legal, and a malformed or unterminated object is not a call. */
 export declare function parseToolCall(text: string): ToolCall | null;
 export interface ToolSpec {
     /** canonical on every surface */