@konneal/engine 0.2.168 → 0.2.170

package/dist/worker_mcp/src/index.js

@@ -1,7 +1,7 @@
 import {
   authenticate
-} from "../../chunk-QY556RJM.js";
-import "../../chunk-4FZNJR5Q.js";
+} from "../../chunk-O2XMNKCK.js";
+import "../../chunk-5UIMQAJZ.js";
 import {
   P,
   setProfile

package/dist/worker_public/src/config.js

@@ -16,7 +16,7 @@ import {
   roleModel,
   sha256Hex,
   today
-} from "../../chunk-4FZNJR5Q.js";
+} from "../../chunk-5UIMQAJZ.js";
 import "../../chunk-3FYJM7LH.js";
 export {
   DATASETS,

package/dist/worker_public/src/index.js

@@ -4,16 +4,16 @@ import {
   handleMemories,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-AGL4NGXY.js";
+} from "../../chunk-PO3UBDNZ.js";
 import "../../chunk-ECOYO7EX.js";
 import {
   TOOLS_REGISTRY,
   bindModelNode,
   modelGroundingBlock
-} from "../../chunk-PTY2OSC4.js";
+} from "../../chunk-QS6V53RO.js";
 import {
   handleSearch
-} from "../../chunk-BFOCWZ7U.js";
+} from "../../chunk-6KEWBP7O.js";
 import {
   buildMessages,
   citations,
@@ -38,11 +38,11 @@ import {
   sessionFrom,
   telemetry,
   understandQuery
-} from "../../chunk-LIZJLRXZ.js";
+} from "../../chunk-RZLEHCIA.js";
 import {
   embed,
   generateOnce
-} from "../../chunk-LU7VIMD7.js";
+} from "../../chunk-XWSZWFYP.js";
 import {
   authenticate,
   corsHeaders,
@@ -51,14 +51,14 @@ import {
   readJson,
   validateQuery,
   withCors
-} from "../../chunk-QY556RJM.js";
+} from "../../chunk-O2XMNKCK.js";
 import {
   canonicalRefusal
 } from "../../chunk-ETLSWSZ7.js";
 import {
   entitlementScope,
   standardKeysFrom
-} from "../../chunk-Y7LWT24U.js";
+} from "../../chunk-PQDAL4MX.js";
 import {
   LIMITS,
   MODELS,
@@ -69,7 +69,7 @@ import {
   roleModel,
   sha256Hex,
   today
-} from "../../chunk-4FZNJR5Q.js";
+} from "../../chunk-5UIMQAJZ.js";
 import {
   P,
   setProfile
@@ -77,7 +77,7 @@ import {
 import {
   cfBlobs,
   portModelRunner
-} from "../../chunk-LSZTJI7V.js";
+} from "../../chunk-KINFFYQH.js";
 
 // workers/worker_public/src/conversations.ts
 var ID_RE = /^[a-zA-Z0-9_-]{8,64}$/;
@@ -1119,13 +1119,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-3RP7DHGI.js");
+    const { runTool, TOOLS_REGISTRY: TOOLS_REGISTRY2 } = await import("../../tools-HK5RXHBQ.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-RUMLIO35.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-Y4Y46Y57.js")).handleSearch(env, ctx, inner, tier, key);
+      const res = name === "ask" ? await (await import("../../ask-BKWQEMSY.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-RNCRT5BR.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/dist/worker_public/src/requestScope.js

@@ -4,8 +4,8 @@ import {
   requestSalt,
   resolveRequestScope,
   standardKeysFrom
-} from "../../chunk-Y7LWT24U.js";
-import "../../chunk-4FZNJR5Q.js";
+} from "../../chunk-PQDAL4MX.js";
+import "../../chunk-5UIMQAJZ.js";
 import "../../chunk-3FYJM7LH.js";
 export {
   entitlementScope,

package/package.json

@@ -27,7 +27,7 @@
     "playwright": "^1.62.1",
     "yaml": "^2.9.1"
   },
-  "version": "0.2.168",
+  "version": "0.2.170",
   "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/ablate.ts

@@ -39,6 +39,9 @@ export interface AblateConfig {
    *  budget before the answer model reads it. Off in serving; the grid
    *  arms it per ask (the row's accuracy-at-token-budget gate). */
   compress: boolean;
+  /** The decision pass (TODO.decisions/01): per-request stand-down for
+   *  the measurement — the serving switch is DECISIONS_ENABLED. */
+  noDecisions: boolean;
 }
 
 export type AblateParse =
@@ -61,10 +64,11 @@ export function parseAblate(
   const rawRoute = body?.ablate_route;
   const speculative = body?.ablate_speculative === true;
   const compress = body?.ablate_compress === true;
+  const noDecisions = body?.ablate_no_decisions === true;
   const namesAblation = rawStages !== undefined && rawStages !== null;
   const routeAblation = rawRoute !== undefined && rawRoute !== null && rawRoute !== "adaptive";
 
-  if (!namesAblation && !noVerdict && !routeAblation && !speculative && !compress) return { ok: true, config: null };
+  if (!namesAblation && !noVerdict && !routeAblation && !speculative && !compress && !noDecisions) return { ok: true, config: null };
 
   if (!adminToken || presentedToken !== adminToken) {
     return {
@@ -99,5 +103,5 @@ export function parseAblate(
     stages = [...new Set(rawStages as string[])];
   }
 
-  return { ok: true, config: { stages, noVerdict, route, speculative, compress } };
+  return { ok: true, config: { stages, noVerdict, route, speculative, compress, noDecisions } };
 }

package/workers/worker_public/src/ask.ts

@@ -35,6 +35,8 @@ import { entitlementScope, resolveRequestScope, requestSalt, standardKeysFrom }
 import { rawSessionToken, type SessionClaims } from "./session";
 import { cacheKeyMaterial, corpusGen, exactCacheKey, freshRequested } from "./answercache";
 import { parseAblate } from "./ablate";
+import { decisionsEnabled, gateQuestion, runDecisionPass } from "./decisionWire";
+import type { DecisionItem } from "./decisions";
 import { STAGE_NAMES } from "./stages/index.ts";
 import { routeFor, fastRouteStages } from "./route.ts";
 import { partitionSubsets, type Partitionable } from "./speculative.ts";
@@ -1303,6 +1305,11 @@ let convEntities: Array<{ entity: string; kind: string }> = [];
   // report it (TODO.sota/14.6 v2) — the coarse retrieval grade and the
   // corrective retry's firing/acceptance
   const crag: { grade: string | null; corrective: { fired: boolean; accepted: boolean; grade: string | null } | null } = { grade: null, corrective: null };
+  // the decision pass's gate (TODO.decisions/01): one cheap clef-flash
+  // noul over the question, prefetched in parallel with retrieval — the
+  // pass itself runs only if the gate clears and the ops switch is on
+  const decisionsArmed = decisionsEnabled(env) && !(ablate as any)?.noDecisions;
+  const decisionsGatePromise = decisionsArmed ? gateQuestion(env, q.query) : Promise.resolve(null);
   try {
     const tR = Date.now();
     // ── The "my account" live read (TODO.ai-platform/03) — resolved
@@ -1502,6 +1509,20 @@ let convEntities: Array<{ entity: string; kind: string }> = [];
     budget,
     ablate?.compress === true,
   );
+  // the decision pass (TODO.decisions/01): starts here so its calls run
+  // concurrently with generation — the checklist section arrives the
+  // moment the model's last token lands, never delaying the answer
+  const decisionPromise = decisionsArmed && decisionsGatePromise
+    ? decisionsGatePromise.then((g) =>
+        g != null && g >= THRESHOLDS.decisionsGateMin
+          ? runDecisionPass(env, {
+              question: q.query,
+              gate: g,
+              passages: usedHits.map((h: Hit) => h.text),
+              docidentifier: understanding?.docidentifier ?? null,
+            })
+          : null)
+    : Promise.resolve(null);
   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
@@ -1697,12 +1718,36 @@ let convEntities: Array<{ entity: string; kind: string }> = [];
           }
           // the misplaced-pin wall rides the streamed path too: a
           // CITED stream is not a refusal
-          const canonical0 = exciseMisplacedPin(canonicalRefusal(full.replace(/^TOOL [a-z_.]+.*$\n?/gm, "").replace(/^\n+/, ""), refusalScope(answerCites(full))), answerCites(full));
+          let canonical0 = exciseMisplacedPin(canonicalRefusal(full.replace(/^TOOL [a-z_.]+.*$\n?/gm, "").replace(/^\n+/, ""), refusalScope(answerCites(full))), answerCites(full));
           // answer contract v2: validate [[u:]] refs, resolve typed blocks
           const c2 = canonical0.includes(refusalAnswer())
             ? { text: canonical0, blocks: [], dropped: [] as string[] }
             : await contractV2(env.DB, canonical0, usedHits);
-          send({ type: "done", model, query_hash: queryHash, follow_ups: refusalShaped(canonical0, refusalScope(answerCites(full))) ? [] : (understanding?.follow_ups ?? []), blocks: [...c2.blocks, ...(verdictBlock ? [verdictBlock] : []), ...(conditionBlock ? [conditionBlock] : []), ...(aggregationBlock ? [aggregationBlock] : [])], context_applied: ctxApplied, read: readAs(),
+          // the completions ride the streamed lane too (parity: the UI's
+          // bubble IS this lane — the table/figure blocks never reached it
+          // before): additive D1 reads after the tokens are out, refusal
+          // answers carry nothing to complete
+          let streamedCompletionBlocks: Awaited<ReturnType<typeof completeTables>> = [];
+          // the decision pass's section streams as the answer's tail
+          // (the pass ran concurrently with generation — its arrival is
+          // instant here), before the completions and the done event
+          if (decisionPromise && !canonical0.includes(refusalAnswer())) {
+            const dp = await decisionPromise;
+            if (dp) {
+              canonical0 += dp.section;
+              send({ type: "token", v: dp.section });
+              full += dp.section;
+              console.log("decisions: streamed the checklist section (" + dp.items.length + " items, mode " + dp.mode + ")");
+            }
+          }
+          if (!canonical0.includes(refusalAnswer())) {
+            try {
+              streamedCompletionBlocks = await completeTables(env.DB, canonical0, usedHits);
+              streamedCompletionBlocks.push(...(await completeFigures(env.DB, canonical0, [...c2.blocks, ...streamedCompletionBlocks], usedHits, q.query)));
+              if (streamedCompletionBlocks.length) console.log("streamed completion:", streamedCompletionBlocks.length, "block(s) attached");
+            } catch { /* additive — the answer stands without the blocks */ }
+          }
+          send({ type: "done", model, query_hash: queryHash, follow_ups: refusalShaped(canonical0, refusalScope(answerCites(full))) ? [] : (understanding?.follow_ups ?? []), blocks: [...c2.blocks, ...(verdictBlock ? [verdictBlock] : []), ...(conditionBlock ? [conditionBlock] : []), ...(aggregationBlock ? [aggregationBlock] : []), ...streamedCompletionBlocks], context_applied: ctxApplied, read: readAs(),
             // the evidence view's ground truth: the exact passages this
             // answer was built from, compact — cache hits carry none,
             // because the cache stores the answer and never the passages
@@ -2035,7 +2080,15 @@ let convEntities: Array<{ entity: string; kind: string }> = [];
       if (v.support !== "supported") console.log("entailment:", v.support, raced!.score, raced!.ungrounded_claims?.slice(0, 2));
     }
   }
-  const out = { answer, citations: finalCites, ...(jsonQuality ? { source_quality: jsonQuality!, confidence_note: entailmentNote || qualityNote(jsonQuality!), ...(entailment ? { entailment } : {}), ...(jsonQuality === "ocr" ? { experimental_sources: experimentalSourceLabels(finalCites) } : {}) } : {}), model: MODELS.member, query_hash: queryHash, follow_ups: refusalShaped(answer!, refusalScope(answerCites(answer!))) ? [] : (understanding?.follow_ups ?? []), blocks: [...c2ns.blocks, ...(verdictBlock ? [verdictBlock] : []), ...(conditionBlock ? [conditionBlock] : []), ...(aggregationBlock ? [aggregationBlock] : []), ...(registerBlock ? [registerBlock] : []), ...completionBlocks], context_applied: ctxApplied, ...(liveRecords ? { records: liveRecords } : {}), ...(ablate ? { ablate } : {}), route: { route: routed.route, features: routed.features } };
+  let decisionsOut: { mode: string; gate: number; items: DecisionItem[] } | undefined;
+  if (decisionPromise) {
+    const dp = await decisionPromise;
+    if (dp && answer && !answer!.includes(refusalAnswer())) {
+      answer = answer! + dp.section;
+      decisionsOut = { mode: dp.mode, gate: dp.gate, items: dp.items };
+    }
+  }
+  const out = { answer, citations: finalCites, ...(jsonQuality ? { source_quality: jsonQuality!, confidence_note: entailmentNote || qualityNote(jsonQuality!), ...(entailment ? { entailment } : {}), ...(jsonQuality === "ocr" ? { experimental_sources: experimentalSourceLabels(finalCites) } : {}) } : {}), model: MODELS.member, query_hash: queryHash, follow_ups: refusalShaped(answer!, refusalScope(answerCites(answer!))) ? [] : (understanding?.follow_ups ?? []), blocks: [...c2ns.blocks, ...(verdictBlock ? [verdictBlock] : []), ...(conditionBlock ? [conditionBlock] : []), ...(aggregationBlock ? [aggregationBlock] : []), ...(registerBlock ? [registerBlock] : []), ...completionBlocks], context_applied: ctxApplied, ...(liveRecords ? { records: liveRecords } : {}), ...(decisionsOut ? { decisions: decisionsOut } : {}), ...(ablate ? { ablate } : {}), route: { route: routed.route, features: routed.features } };
   const cacheable = !contextual && !declaredCtx && !ablate && cacheableAnswer(answer!, refusalScope(answerCites(answer!))) && finalAnchors.violations.length === 0;
   if (cacheable) {
     const ck = exactCacheKey(env.INDEX_VERSION, gen, ns, await sha256Hex(cacheKeyMaterial(q.query, q.lang, salt)));

package/workers/worker_public/src/config.ts

@@ -11,6 +11,10 @@ export const MODELS = {
   // vision-capable MoE scores figure IMAGES against figure-seeking
   // questions — one bounded call per figure question, ablatable stage
   vlmFigure: "@cf/deepseek-ai/deepseek-v4.1-flash-1017",
+  // the decision pass (TODO.decisions/01): clef-flash gates the
+  // requirement-shaped questions, clef decides the derived checklist
+  decisionsGate: "@cf/cloudflare/clef-flash",
+  decisionsModel: "@cf/cloudflare/clef",
   // hot-path understanding/summarize stays on the cheap Qwen (cost-first lane)
   understand: "@cf/qwen/qwen3-30b-a3b-fp8",
   // the api_call act's intent-to-act mapping (TODO.ai-platform/09) — the
@@ -90,6 +94,12 @@ export const THRESHOLDS = {
   // re-query runs at this depth and scopes in code (the native filter is
   // dead — measured 2026-10-05)
   denseStarveK: 100,
+  // the decision pass (TODO.decisions): the gate fires at decisionsGateMin
+  // noul; the bands assemble met / not clearly stated / not met
+  decisionsGateMin: 0.5,
+  decisionsMetBand: 0.8,
+  decisionsRefuteBand: 0.2,
+  decisionsRequirementsMax: 12,
   entailmentGate: true,
   entailmentBudgetMs: 6000,
   entailmentSupportedFloor: 0.9,

package/workers/worker_public/src/decisionWire.ts

@@ -0,0 +1,124 @@
+// The decision pass orchestrator (TODO.decisions/01): gate → derive →
+// decide → hand back the items + the deterministic section. All I/O
+// through the ports; the pure math lives in decisions.ts. Fired only
+// when DECISIONS_ENABLED, not ablated, not a refusal, no verdict block
+// bound, and the gate's noul clears decisionsGateMin.
+import { portModelRunner } from "./env.ts";
+import { MODELS, THRESHOLDS } from "./config.ts";
+import {
+  buildDecisionQuestions, matchAnswers, parseDerivation,
+  assembleSection, type DecisionItem, type DecisionMode,
+} from "./decisions.ts";
+import type { Env } from "./env";
+
+export interface DecisionPassResult {
+  mode: DecisionMode;
+  gate: number;
+  items: DecisionItem[];
+  section: string;
+}
+
+export function decisionsEnabled(env: Env): boolean {
+  return String((env as any).DECISIONS_ENABLED ?? "true") !== "false";
+}
+
+/** The gate: one clef-flash noul over the question — "is this a
+ *  requirement-shaped question?" Cheap; prefetched in parallel with
+ *  retrieval by the caller. Returns the probability, or null on any
+ *  failure (fail-open: the pass just doesn't fire). */
+export async function gateQuestion(env: Env, question: string): Promise<number | null> {
+  try {
+    const res = await portModelRunner(env).run({
+      model: (env as any).DECISIONS_GATE_MODEL || MODELS.decisionsGate,
+      input: {
+        state: question.slice(0, 500),
+        questions: {
+          requirements: {
+            type: "noul",
+            instructions: "Is this question asking whether requirements are met, or asking what requirements apply to something?",
+            criteria: {
+              true: "the asker wants requirements listed or their own values/products checked against requirements",
+              false: "a definitional, lookup, how-to, or conversational question",
+            },
+          },
+        },
+      },
+      maxTokens: 512,
+    });
+    const parsed = JSON.parse(res.text ?? "{}") as Record<string, any>;
+    const p = parsed?.requirements?.noul;
+    return typeof p === "number" ? p : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The full pass: derive the checklist candidates from the used
+ *  passages, decide them in one batched Clef call, assemble the
+ *  deterministic section. Returns null when the pass stands down. */
+export async function runDecisionPass(
+  env: Env,
+  opts: {
+    question: string;
+    gate: number;
+    passages: string[];
+    docidentifier: string | null;
+    statedValues?: string;
+    userDocs?: boolean;
+  },
+): Promise<DecisionPassResult | null> {
+  const gateMin = THRESHOLDS.decisionsGateMin;
+  if (opts.gate == null || opts.gate < gateMin) return null;
+  const passages = opts.passages.filter(Boolean).slice(0, 8).map((p) => p.slice(0, 1600));
+  if (!passages.length) return null;
+  try {
+    // 1. derive the checklist candidates from the used passages
+    const deriveModel = (env as any).DECISIONS_EXTRACT_MODEL || MODELS.member;
+    const derived = await portModelRunner(env).run({
+      model: deriveModel,
+      messages: [
+        { role: "system", content: "You extract requirement checklists from legal-metrology text. Reply with ONLY JSON, no prose." },
+        {
+          role: "user",
+          content:
+            `User question: ${opts.question}\n\n` +
+            (opts.statedValues ? `The user's stated values: ${opts.statedValues}\n\n` : "") +
+            `Passages:\n${passages.map((p, i) => `[${i + 1}] ${p}`).join("\n")}\n\n` +
+            `List the DISTINCT requirements relevant to the question as JSON: ` +
+            `{"mode":"check"|"list","requirements":[{"text":"...","clause":"..."}]} — ` +
+            `"check" when the user's question or values ask whether requirements are MET; ` +
+            `"list" when the user asks what the requirements ARE. Max ${THRESHOLDS.decisionsRequirementsMax}. ` +
+            `Each requirement's clause = the clause anchor it comes from. If nothing qualifies, return {"mode":"list","requirements":[]}.`,
+        },
+      ],
+      maxTokens: 1536,
+      temperature: 0,
+    });
+    const { mode, requirements } = parseDerivation(derived.text, THRESHOLDS.decisionsRequirementsMax);
+    if (!requirements.length) return null;
+
+    // 2. decide: one batched Clef call over the derived requirements
+    const decideModel = (env as any).DECISIONS_MODEL || MODELS.decisionsModel;
+    const decided = await portModelRunner(env).run({
+      model: decideModel,
+      input: {
+        state:
+          `User question: ${opts.question}\n` +
+          (opts.statedValues ? `Stated values: ${opts.statedValues}\n` : "") +
+          `Corpus passages:\n${passages.join("\n")}`.slice(0, 12000),
+        questions: buildDecisionQuestions(mode, requirements, opts.question, opts.statedValues ?? ""),
+      },
+      maxTokens: 4096,
+    });
+    const answers = JSON.parse(decided.text ?? "{}") as Record<string, any>;
+
+    // 3. band and assemble
+    const items = matchAnswers(mode, requirements, answers, THRESHOLDS.decisionsMetBand, THRESHOLDS.decisionsRefuteBand);
+    if (!items.length) return null;
+    const section = assembleSection(mode, items);
+    if (!section) return null;
+    return { mode, gate: opts.gate, items, section };
+  } catch {
+    return null; // additive — the essay answer ships
+  }
+}

package/workers/worker_public/src/decisions.ts

@@ -0,0 +1,148 @@
+// The decision pass core (TODO.decisions/01): requirement-shaped
+// questions are answered as CHECKLISTS, not essays. Pure and
+// dependency-free — the I/O orchestrator (decisionWire.ts) calls these
+// with the model outputs; everything here is deterministic and
+// node-testable. Every failure of the live pass degrades to the essay
+// answer; nothing in this module can break an ask.
+
+export interface DerivedRequirement {
+  text: string;
+  clause: string;
+}
+
+export interface DecisionItem {
+  text: string;
+  clause: string;
+  band: "met" | "not-met" | "unclear";
+  probability: number;
+}
+
+export type DecisionMode = "check" | "list";
+
+/** Parse the derivation model's reply: JSON with
+ *  {mode: "check"|"list", requirements: [{text, clause}]}.
+ *  Tolerant of prose around the JSON, of trailing commas-free objects,
+ *  and of missing clauses (empty string). Returns [] when nothing
+ *  sane survives — the pass then stands down. */
+export function parseDerivation(text: string | null | undefined, cap: number): {
+  mode: DecisionMode;
+  requirements: DerivedRequirement[];
+} {
+  const fallback = { mode: "list" as DecisionMode, requirements: [] as DerivedRequirement[] };
+  if (!text) return fallback;
+  const cleaned = text.replace(/```json|```/g, "").trim();
+  const start = cleaned.indexOf("{");
+  const end = cleaned.lastIndexOf("}");
+  if (start === -1 || end <= start) return fallback;
+  let parsed: any;
+  try {
+    parsed = JSON.parse(cleaned.slice(start, end + 1));
+  } catch {
+    return fallback;
+  }
+  const reqs = Array.isArray(parsed?.requirements) ? parsed.requirements : [];
+  const requirements: DerivedRequirement[] = [];
+  for (const r of reqs) {
+    const t = typeof r?.text === "string" ? r.text.trim() : "";
+    if (t.length < 8) continue;
+    requirements.push({ text: t.slice(0, 300), clause: typeof r?.clause === "string" ? r.clause.trim().slice(0, 40) : "" });
+    if (requirements.length >= cap) break;
+  }
+  if (!requirements.length) return fallback;
+  const mode: DecisionMode = parsed?.mode === "check" ? "check" : "list";
+  return { mode, requirements };
+}
+
+/** Build the Clef questions map from the derived requirements. In
+ *  "check" mode each requirement becomes a noul (met-or-not given the
+ *  user's stated values); in "list" mode a noul on whether the
+ *  requirement is genuinely stated in the corpus text. */
+export function buildDecisionQuestions(
+  mode: DecisionMode,
+  requirements: DerivedRequirement[],
+  userQuestion: string,
+  statedValues: string,
+): Record<string, { type: "noul"; instructions: string; criteria?: { true: string; false: string } }> {
+  const questions: Record<string, { type: "noul"; instructions: string; criteria?: { true: string; false: string } }> = {};
+  requirements.forEach((r, i) => {
+    const id = `r${i + 1}`;
+    if (mode === "check") {
+      questions[id] = {
+        type: "noul",
+        instructions:
+          `Requirement: "${r.text}" (clause ${r.clause || "n/a"}). ` +
+          `The user asks: "${userQuestion}". ` +
+          `Stated values: ${statedValues || "(none stated — judge whether the state text answers it)"}. ` +
+          `Is this requirement met, based only on what the state contains?`,
+        criteria: {
+          true: "the state shows the requirement is satisfied",
+          false: "the state shows it is not satisfied, or the state says nothing about it",
+        },
+      };
+    } else {
+      questions[id] = {
+        type: "noul",
+        instructions: `Is this a genuine, self-contained requirement statement: "${r.text}"?`,
+        criteria: {
+          true: "a real requirement a reader could check",
+          false: "a fragment, duplicate, or not a requirement",
+        },
+      };
+    }
+  });
+  return questions;
+}
+
+export function bandFor(p: number, metBand: number, refuteBand: number): DecisionItem["band"] {
+  if (p >= metBand) return "met";
+  if (p <= refuteBand) return "not-met";
+  return "unclear";
+}
+
+/** Match the Clef answers (keyed r1..rN) back onto the requirements and
+ *  band them. Unmatched/missing answers drop (absence is honest). */
+export function matchAnswers(
+  mode: DecisionMode,
+  requirements: DerivedRequirement[],
+  answers: Record<string, any>,
+  metBand: number,
+  refuteBand: number,
+): DecisionItem[] {
+  const items: DecisionItem[] = [];
+  requirements.forEach((r, i) => {
+    const a = answers[`r${i + 1}`];
+    let probability: number;
+    if (a && a.type === "noul" && typeof a.noul === "number") {
+      probability = a.noul;
+    } else if (a && typeof a === "number") {
+      probability = a;
+    } else {
+      return;
+    }
+    if (probability < 0 || probability > 1) return;
+    items.push({
+      text: r.text,
+      clause: r.clause,
+      band: mode === "check" ? bandFor(probability, metBand, refuteBand) : "met",
+      probability: Math.round(probability * 100) / 100,
+    });
+  });
+  return items;
+}
+
+const MARK: Record<DecisionItem["band"], string> = { met: "✓", "not-met": "✗", unclear: "?" };
+const WORD: Record<DecisionItem["band"], string> = { met: "met", "not-met": "not met", unclear: "not clearly stated" };
+
+/** The deterministic checklist section appended to the answer. The
+ *  model never writes this — the server composes it from the decisions. */
+export function assembleSection(mode: DecisionMode, items: DecisionItem[]): string {
+  if (!items.length) return "";
+  const title = mode === "check" ? "Requirements check (automated)" : "Requirements (from the cited clauses)";
+  const lines = items.map((it) => {
+    const mark = mode === "check" ? MARK[it.band] : "•";
+    const clause = it.clause ? ` — ${it.clause}` : "";
+    const prob = mode === "check" ? ` (${Math.round(it.probability * 100)}%)` : "";
+    return `- ${mark} ${it.text}${clause}${prob}${mode === "check" ? ` — ${WORD[it.band]}` : ""}`;
+  });
+  return `\n\n${title}:\n${lines.join("\n")}`;
+}

package/workers/worker_public/src/ports/cloudflare/adapters.ts

@@ -101,7 +101,9 @@ export function cfModelRunner(ai: unknown): ModelRunner {
       return null;
     },
     async run(req: GenerateRequest): Promise<GenerateResult> {
-      const res: any = await (ai as any).run(req.model, {
+      // the decision models' native shape ({state, questions}) passes
+      // through verbatim — the adapter adds no sampling shaping to it
+      const payload: any = req.input !== undefined ? req.input : {
         messages: req.messages,
         max_tokens: req.maxTokens,
         ...(req.effort ? { reasoning_effort: req.effort } : {}),
@@ -109,9 +111,15 @@ export function cfModelRunner(ai: unknown): ModelRunner {
         ...(req.topP != null ? { top_p: req.topP } : {}),
         ...(req.topK != null ? { top_k: req.topK } : {}),
         ...(req.stream ? { stream: true } : {}),
-      });
+      };
+      const res: any = await (ai as any).run(req.model, payload);
       if (req.stream && res && typeof res.getReader === "function") return { text: null, stream: res };
       if (req.stream && res?.body && typeof res.body.getReader === "function") return { text: null, stream: res.body };
+      // the decision models answer with a typed answers object — the
+      // lossless form is its JSON, which the caller parses
+      if (res && typeof res === "object" && res.answers && typeof res.answers === "object") {
+        return { text: JSON.stringify(res.answers) };
+      }
       const text = typeof res?.response === "string" ? res.response : res?.choices?.[0]?.message?.content;
       return { text: typeof text === "string" ? text : null };
     },

package/workers/worker_public/src/ports/model.ts

@@ -6,7 +6,14 @@
  *  multi-SDO / multi-cloud: docs/konneal-extraction-plan.md §5. */
 export interface GenerateRequest {
   model: string;
-  messages: unknown[];
+  /** The messages payload — required unless `input` carries a native
+   *  non-messages shape (the decision models). */
+  messages?: unknown[];
+  /** Native-shape passthrough for models whose contract is not
+   *  messages-based (the decision models: {state, questions}). When
+   *  present it REPLACES the messages payload verbatim — the adapter
+   *  adds no sampling shaping. */
+  input?: unknown;
   effort?: string;
   maxTokens?: number;
   temperature?: number;

package/dist/ask-RUMLIO35.js

@@ -1,16 +0,0 @@
-import {
-  handleAsk
-} from "./chunk-AGL4NGXY.js";
-import "./chunk-ECOYO7EX.js";
-import "./chunk-PTY2OSC4.js";
-import "./chunk-LIZJLRXZ.js";
-import "./chunk-LU7VIMD7.js";
-import "./chunk-QY556RJM.js";
-import "./chunk-ETLSWSZ7.js";
-import "./chunk-Y7LWT24U.js";
-import "./chunk-4FZNJR5Q.js";
-import "./chunk-3FYJM7LH.js";
-import "./chunk-LSZTJI7V.js";
-export {
-  handleAsk
-};

package/dist/search-Y4Y46Y57.js

@@ -1,14 +0,0 @@
-import {
-  handleSearch
-} from "./chunk-BFOCWZ7U.js";
-import "./chunk-LIZJLRXZ.js";
-import "./chunk-LU7VIMD7.js";
-import "./chunk-QY556RJM.js";
-import "./chunk-ETLSWSZ7.js";
-import "./chunk-Y7LWT24U.js";
-import "./chunk-4FZNJR5Q.js";
-import "./chunk-3FYJM7LH.js";
-import "./chunk-LSZTJI7V.js";
-export {
-  handleSearch
-};