@konneal/engine 0.2.70 → 0.2.72

package/dist/{ask-S3SLIGA7.js → ask-UOTYZ5DC.js}

@@ -1,12 +1,12 @@
 import {
   handleAsk
-} from "./chunk-BMC5XBJV.js";
+} from "./chunk-UW5M2AXR.js";
 import "./chunk-TPV5GPY2.js";
 import "./chunk-SPKPH54J.js";
 import "./chunk-A3QHHUN5.js";
 import "./chunk-LVZTWUVJ.js";
 import "./chunk-2PCUAJJO.js";
-import "./chunk-VGVTIPFW.js";
+import "./chunk-3IRX4B7Q.js";
 import "./chunk-3FYJM7LH.js";
 export {
   handleAsk

package/dist/{certificates-DNRUOYRF.js → certificates-EMHFAUWC.js}

@@ -6,7 +6,7 @@ import {
   registerNote,
   registerTokens,
   searchRegister
-} from "./chunk-VGVTIPFW.js";
+} from "./chunk-3IRX4B7Q.js";
 import "./chunk-3FYJM7LH.js";
 export {
   buildRegisterQuery,

package/dist/{chunk-VGVTIPFW.js → chunk-3IRX4B7Q.js}

@@ -121,7 +121,7 @@ function registerNote(rows) {
   ].join("\n");
 }
 function certificateLinks(rows) {
-  const links = rows.filter((r) => r.pdf_key).map((r) => `- ${r.num}: https://www.oimlsmart.org/cert-pdf/${r.pdf_key}`);
+  const links = rows.filter((r) => r.pdf_key).map((r) => `- ${r.num}: https://www.ommisa.org/cert-pdf/${r.pdf_key}`);
   return links.length ? `The certificates' documents:
 ${links.join("\n")}` : "";
 }

package/dist/{chunk-BMC5XBJV.js → chunk-UW5M2AXR.js}

@@ -68,7 +68,7 @@ import {
   certificateLinks,
   registerNote,
   searchRegister
-} from "./chunk-VGVTIPFW.js";
+} from "./chunk-3IRX4B7Q.js";
 import {
   P
 } from "./chunk-3FYJM7LH.js";
@@ -1892,7 +1892,7 @@ 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-DNRUOYRF.js");
+  const { searchRegister: searchRegister2, registerNote: registerNote2 } = await import("./certificates-EMHFAUWC.js");
   const reg = await searchRegister2(db, query, true);
   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 };
@@ -1906,17 +1906,101 @@ ${r.output}`;
 function isOperationIntent(query) {
   return /\b(operations?|endpoints?)\b/i.test(query);
 }
+var ACTION_STEMS = [
+  "updat",
+  "upsert",
+  "writ",
+  "put",
+  "delet",
+  "remov",
+  "read",
+  "fetch",
+  "get",
+  "creat",
+  "declar",
+  "confirm",
+  "approv",
+  "declin",
+  "decide",
+  "revok",
+  "grant",
+  "notify",
+  "advanc",
+  "announc",
+  "download"
+];
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "which",
+  "what",
+  "where",
+  "when",
+  "how",
+  "why",
+  "who",
+  "does",
+  "did",
+  "can",
+  "the",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "are",
+  "was",
+  "were",
+  "has",
+  "have",
+  "had",
+  "not",
+  "but",
+  "all",
+  "any",
+  "platform",
+  "operation",
+  "operations",
+  "endpoint",
+  "endpoints",
+  "api"
+]);
+function anchorWords(anchor) {
+  return anchor.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+var singular = (w) => w.length > 3 && w.endsWith("s") ? w.slice(0, -1) : w;
+function matchOperations(query, rows) {
+  const q = query.toLowerCase();
+  const stems = ACTION_STEMS.filter((s) => q.includes(s));
+  const objects = query.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w)).map(singular);
+  const scored = [];
+  for (const r of rows) {
+    const hay = `${r.anchor} ${r.text}`.toLowerCase();
+    const verbScore = stems.filter((s) => hay.includes(s)).length * 3;
+    const words = anchorWords(r.anchor).map(singular);
+    const objectScore = objects.filter((o) => words.includes(o)).length * 10;
+    if (objectScore + verbScore > 0) scored.push({ ...r, score: objectScore + verbScore, objectScore });
+  }
+  const named = scored.filter((s) => s.objectScore > 0);
+  const pool = named.length ? named : scored;
+  return pool.sort((a, b) => b.score - a.score).slice(0, 4);
+}
 function catalogNote(anchors) {
   if (!anchors.length) return "";
-  return `The platform's indexed operations (the COMPLETE surface \u2014 every operation the system exposes; the answer must name the operation from this list when one matches the question):
+  return `The COMPLETE name index of the platform's operations:
 ${anchors.map((a) => `- ${a}`).join("\n")}`;
 }
 async function operationsCatalogNote(db, query) {
   if (!isOperationIntent(query)) return void 0;
   try {
-    const rows = (await db.prepare("SELECT clause_anchor FROM chunks WHERE corpus = 'smart-ops' AND clause_anchor IS NOT NULL ORDER BY clause_anchor").all()).results ?? [];
-    const note = catalogNote(rows.map((r) => r.clause_anchor).filter(Boolean));
-    return note || void 0;
+    const rows = (await db.prepare("SELECT clause_anchor AS anchor, substr(text, 1, 300) AS text FROM chunks WHERE corpus = 'smart-ops' AND clause_anchor IS NOT NULL ORDER BY clause_anchor").all()).results ?? [];
+    const opRows = rows.map((r) => ({ anchor: String(r.anchor ?? ""), text: String(r.text ?? "") })).filter((r) => r.anchor);
+    const matched = matchOperations(query, opRows);
+    const parts = [];
+    if (matched.length) {
+      parts.push(`Operations whose name or description matches the question (AUTHORITATIVE \u2014 if one matches, the answer MUST name it and cite its line; never answer that the information is missing):
+${matched.map((m) => `- ${m.text}`).join("\n")}`);
+    }
+    parts.push(catalogNote(opRows.map((r) => r.anchor)));
+    return parts.filter(Boolean).join("\n\n") || void 0;
   } catch {
     return void 0;
   }

package/dist/operations.d.ts

@@ -1,3 +1,14 @@
 export declare function isOperationIntent(query: string): boolean;
+/** camelCase/snake anchors meet the question's words: "updates an
+ *  entity record" must reach putEntityRecord even when its description
+ *  words the action differently ("replaces the stored…"). */
+export declare function anchorWords(anchor: string): string[];
+export declare function matchOperations(query: string, rows: {
+    anchor: string;
+    text: string;
+}[]): {
+    anchor: string;
+    text: string;
+}[];
 export declare function catalogNote(anchors: string[]): string;
 export declare function operationsCatalogNote(db: any, query: string): Promise<string | undefined>;

package/dist/worker_public/src/index.js

@@ -6,7 +6,7 @@ import {
   modelGroundingBlock,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-BMC5XBJV.js";
+} from "../../chunk-UW5M2AXR.js";
 import {
   handleSearch
 } from "../../chunk-FLNX4O7C.js";
@@ -63,7 +63,7 @@ import {
   sha256Hex,
   today
 } from "../../chunk-2PCUAJJO.js";
-import "../../chunk-VGVTIPFW.js";
+import "../../chunk-3IRX4B7Q.js";
 import {
   P,
   setProfile
@@ -959,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-S3SLIGA7.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-UOTYZ5DC.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.70",
+  "version": "0.2.72",
   "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/certificates.ts

@@ -134,7 +134,7 @@ export function registerNote(rows: RegisterRow[]): string {
  *  is in the R2 plane (TODO 7) — the user gets the document, not just
  *  the fact. */
 export function certificateLinks(rows: RegisterRow[]): string {
-  const links = rows.filter((r) => r.pdf_key).map((r) => `- ${r.num}: https://www.oimlsmart.org/cert-pdf/${r.pdf_key}`);
+  const links = rows.filter((r) => r.pdf_key).map((r) => `- ${r.num}: https://www.ommisa.org/cert-pdf/${r.pdf_key}`);
   return links.length ? `The certificates' documents:\n${links.join("\n")}` : "";
 }
 

package/workers/worker_public/src/operations.ts

@@ -1,26 +1,85 @@
 // The operations catalog lane (TODO.new-era/6's platform surface): the
-// smart-ops corpus is SMALL (169 operations) and name-addressable. When
-// a question is operation-intent, the ENTIRE operation-name index rides
-// the notes channel — the model matches "updates an entity record" to
-// putEntityRecord semantically from the complete surface, instead of
-// gambling on which sibling passage retrieval happens to surface.
-// Pure composition lives here; the D1 call is a thin wrapper.
+// smart-ops corpus is SMALL (169 operations) and name-addressable. An
+// operation-intent question gets (1) the operations whose NAME carries
+// the question's object words and whose description carries its action
+// stems — with their full lines, and (2) the complete name index. The
+// note is AUTHORITATIVE: the model must name the operation from it,
+// never answer from the passages' silence. Pure composition lives
+// here; the D1 call is a thin wrapper.
 
 export function isOperationIntent(query: string): boolean {
   return /\b(operations?|endpoints?)\b/i.test(query);
 }
 
+/** The action stems the register's descriptions use, mapped from the
+ *  words a question actually asks ("updates" → updat; "upserts" shares
+ *  the stem). */
+const ACTION_STEMS = [
+  "updat", "upsert", "writ", "put", "delet", "remov", "read", "fetch", "get", "creat", "declar",
+  "confirm", "approv", "declin", "decide", "revok", "grant", "notify", "advanc", "announc", "download",
+];
+
+const STOP_WORDS = new Set([
+  "which", "what", "where", "when", "how", "why", "who", "does", "did", "can", "the", "and", "for",
+  "with", "that", "this", "are", "was", "were", "has", "have", "had", "not", "but", "all", "any",
+  "platform", "operation", "operations", "endpoint", "endpoints", "api",
+]);
+
+/** camelCase/snake anchors meet the question's words: "updates an
+ *  entity record" must reach putEntityRecord even when its description
+ *  words the action differently ("replaces the stored…"). */
+export function anchorWords(anchor: string): string[] {
+  return anchor
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+}
+
+const singular = (w: string) => (w.length > 3 && w.endsWith("s") ? w.slice(0, -1) : w);
+
+export function matchOperations(query: string, rows: { anchor: string; text: string }[]): { anchor: string; text: string }[] {
+  const q = query.toLowerCase();
+  const stems = ACTION_STEMS.filter((s) => q.includes(s));
+  const objects = query
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((w) => w.length > 2 && !STOP_WORDS.has(w))
+    .map(singular);
+  const scored: { anchor: string; text: string; score: number; objectScore: number }[] = [];
+  for (const r of rows) {
+    const hay = `${r.anchor} ${r.text}`.toLowerCase();
+    const verbScore = stems.filter((s) => hay.includes(s)).length * 3;
+    const words = anchorWords(r.anchor).map(singular);
+    const objectScore = objects.filter((o) => words.includes(o)).length * 10;
+    if (objectScore + verbScore > 0) scored.push({ ...r, score: objectScore + verbScore, objectScore });
+  }
+  // A question that names its object ("entity record") has found its
+  // target by name — verb-only mentions are the noise that displaced
+  // the answer with an unrelated sibling (the 2026-09-29 "blob upload"
+  // answers).
+  const named = scored.filter((s) => s.objectScore > 0);
+  const pool = named.length ? named : scored;
+  return pool.sort((a, b) => b.score - a.score).slice(0, 4);
+}
+
 export function catalogNote(anchors: string[]): string {
   if (!anchors.length) return "";
-  return `The platform's indexed operations (the COMPLETE surface — every operation the system exposes; the answer must name the operation from this list when one matches the question):\n${anchors.map((a) => `- ${a}`).join("\n")}`;
+  return `The COMPLETE name index of the platform's operations:\n${anchors.map((a) => `- ${a}`).join("\n")}`;
 }
 
 export async function operationsCatalogNote(db: any, query: string): Promise<string | undefined> {
   if (!isOperationIntent(query)) return undefined;
   try {
-    const rows = (await db.prepare("SELECT clause_anchor FROM chunks WHERE corpus = 'smart-ops' AND clause_anchor IS NOT NULL ORDER BY clause_anchor").all()).results ?? [];
-    const note = catalogNote((rows as any[]).map((r) => r.clause_anchor).filter(Boolean));
-    return note || undefined;
+    const rows = (await db.prepare("SELECT clause_anchor AS anchor, substr(text, 1, 300) AS text FROM chunks WHERE corpus = 'smart-ops' AND clause_anchor IS NOT NULL ORDER BY clause_anchor").all()).results ?? [];
+    const opRows = (rows as any[]).map((r) => ({ anchor: String(r.anchor ?? ""), text: String(r.text ?? "") })).filter((r) => r.anchor);
+    const matched = matchOperations(query, opRows);
+    const parts: string[] = [];
+    if (matched.length) {
+      parts.push(`Operations whose name or description matches the question (AUTHORITATIVE — if one matches, the answer MUST name it and cite its line; never answer that the information is missing):\n${matched.map((m) => `- ${m.text}`).join("\n")}`);
+    }
+    parts.push(catalogNote(opRows.map((r) => r.anchor)));
+    return parts.filter(Boolean).join("\n\n") || undefined;
   } catch {
     return undefined; // the lane is optional
   }