@konneal/engine 0.2.144 → 0.2.146

package/dist/{ask-A54GAMZR.js → ask-RIWVOI3D.js}

@@ -1,12 +1,12 @@
 import {
   handleAsk
-} from "./chunk-Y5T6V5CB.js";
+} from "./chunk-VISPFCQP.js";
 import "./chunk-ECOYO7EX.js";
-import "./chunk-363Q6FOL.js";
+import "./chunk-VYEMFSU5.js";
 import "./chunk-XH5QGX2O.js";
 import "./chunk-NI4CIK6W.js";
 import "./chunk-W7J5SFXJ.js";
-import "./chunk-XBZIJMS7.js";
+import "./chunk-ETLSWSZ7.js";
 import "./chunk-4NXH5ZI6.js";
 import "./chunk-VT7DR6NQ.js";
 import "./chunk-3FYJM7LH.js";

package/dist/{chunk-XBZIJMS7.js → chunk-ETLSWSZ7.js}

@@ -101,10 +101,14 @@ function cacheableAnswer(answer, scope) {
   if (answer.includes(refusalAnswer())) return false;
   return canonicalRefusal(answer, scope) === answer;
 }
+function refusalShaped(answer, scope) {
+  return !cacheableAnswer(answer, scope);
+}
 
 export {
   refusalAnswer,
   canonicalRefusal,
   exciseMisplacedPin,
-  cacheableAnswer
+  cacheableAnswer,
+  refusalShaped
 };

package/dist/{chunk-Y5T6V5CB.js → chunk-VISPFCQP.js}

@@ -32,7 +32,7 @@ import {
   tableRetyped,
   toolNote,
   verdictNote
-} from "./chunk-363Q6FOL.js";
+} from "./chunk-VYEMFSU5.js";
 import {
   NO_CONTEXT,
   STAGE_NAMES,
@@ -91,8 +91,9 @@ import {
   cacheableAnswer,
   canonicalRefusal,
   exciseMisplacedPin,
-  refusalAnswer
-} from "./chunk-XBZIJMS7.js";
+  refusalAnswer,
+  refusalShaped
+} from "./chunk-ETLSWSZ7.js";
 import {
   entitlementScope,
   requestSalt,
@@ -2640,7 +2641,7 @@ Answer account questions from these records ONLY: name the record when you use i
             type: "done",
             model,
             query_hash: queryHash,
-            follow_ups: understanding?.follow_ups ?? [],
+            follow_ups: refusalShaped(canonical0, refusalScope(answerCites(full))) ? [] : understanding?.follow_ups ?? [],
             blocks: [...c2.blocks, ...verdictBlock ? [verdictBlock] : [], ...conditionBlock ? [conditionBlock] : [], ...aggregationBlock ? [aggregationBlock] : []],
             context_applied: ctxApplied,
             read: readAs(),
@@ -2822,7 +2823,7 @@ Answer account questions from these records ONLY: name the record when you use i
       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: 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 } };
+  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 } };
   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/dist/{chunk-363Q6FOL.js → chunk-VYEMFSU5.js}

@@ -270,14 +270,60 @@ function parseNumber(raw) {
   s = s.replace(/\.(\d{3})$/, "$1");
   return Number(s.replace(/,(?=\d{3}\b)/g, ""));
 }
+var TOL_SEP_SRC = "\\u00b1|\\bpm\\b|\\+/-";
+var NUM_SRC = "[0-9][0-9 ,.]*[0-9]";
+var UNIT_SRC = "%|\\u00b0?[A-Za-z\\u00b5\\u03a9]{0,6}";
+function statedUncertainty(value, tolRaw, tolUnitRaw, valueUnit) {
+  const tolNum = parseNumber(tolRaw);
+  const tolUnit = (tolUnitRaw ?? "").trim();
+  const relative = tolUnit === "%";
+  return {
+    tol: relative ? Math.abs(value) * tolNum / 100 : tolNum,
+    stated: relative ? `\xB1 ${tolRaw} %` : `\xB1 ${tolRaw}${tolUnit ? ` ${tolUnit}` : ""}`,
+    relative,
+    unit: relative ? valueUnit : tolUnit || valueUnit
+  };
+}
 function extractParamsWithUnits(query, symbols) {
   const values = {};
   const units = {};
+  const uncertainties = {};
   for (const sym of symbols) {
     const leaf = sym.split(".").pop() ?? sym;
     const esc = leaf.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const re = new RegExp(`\\b${esc}\\b\\D{0,14}?([0-9][0-9 ,.]*[0-9])\\s*(%|\\u00b0?[A-Za-z\\u00b5\\u03a9]{0,6})?`, "iu");
-    const m = query.match(re);
+    const reTolFirst = new RegExp(
+      `\\b${esc}\\b\\D{0,14}?(${NUM_SRC})\\s*(?:${TOL_SEP_SRC})\\s*(${NUM_SRC})\\s*(${UNIT_SRC})?`,
+      "iu"
+    );
+    const reTolAfter = new RegExp(
+      `\\b${esc}\\b\\D{0,14}?(${NUM_SRC})\\s*(${UNIT_SRC})\\s*(?:${TOL_SEP_SRC})\\s*(${NUM_SRC})\\s*(${UNIT_SRC})?`,
+      "iu"
+    );
+    const rePlain = new RegExp(
+      `\\b${esc}\\b\\D{0,14}?(${NUM_SRC})\\s*(${UNIT_SRC})?`,
+      "iu"
+    );
+    const mFirst = query.match(reTolFirst);
+    const mAfter = mFirst ? null : query.match(reTolAfter);
+    const mTol = mFirst ?? mAfter;
+    if (mTol) {
+      const value = parseNumber(mTol[1]);
+      if (!Number.isFinite(value)) continue;
+      values[sym] = value;
+      let unit;
+      let u;
+      if (mFirst) {
+        unit = (mFirst[3] ?? "").trim() || void 0;
+        u = statedUncertainty(value, mFirst[2], mFirst[3], unit);
+      } else {
+        unit = (mAfter[2] ?? "").trim() || void 0;
+        u = statedUncertainty(value, mAfter[3], mAfter[4], unit || void 0);
+      }
+      if (unit) units[sym] = unit;
+      uncertainties[sym] = u;
+      continue;
+    }
+    const m = query.match(rePlain);
     if (m) {
       const v = parseNumber(m[1]);
       if (Number.isFinite(v)) {
@@ -287,7 +333,7 @@ function extractParamsWithUnits(query, symbols) {
       }
     }
   }
-  return { values, units };
+  return { values, units, uncertainties };
 }
 function dimensionMismatch(check, units, dimensions) {
   const dims = /* @__PURE__ */ new Map();
@@ -313,11 +359,14 @@ function evaluate(content, query, opts) {
   let voidReason = null;
   const machine = checks.map((expression) => {
     const values = {};
+    const ids = [];
     try {
-      for (const t of tokenize(expression)) if (t.t === "id" && params[t.v] !== void 0) values[t.v] = params[t.v];
+      for (const t of tokenize(expression)) if (t.t === "id") ids.push(t.v);
     } catch {
     }
+    for (const t of new Set(ids)) if (params[t] !== void 0) values[t] = params[t];
     let result = null;
+    let uncertainty;
     if (missing.length === 0) {
       const mismatch = opts?.dimensions ? dimensionMismatch(expression, bound.units, opts.dimensions) : null;
       if (mismatch) {
@@ -328,9 +377,38 @@ function evaluate(content, query, opts) {
         } catch {
           result = null;
         }
+        const bandSyms = [...new Set(ids)].filter((s) => bound.uncertainties[s] !== void 0).slice(0, 3);
+        if (bandSyms.length && result !== null) {
+          const corners = [];
+          for (let mask = 0; mask < 1 << bandSyms.length; mask++) {
+            const corner = { ...params };
+            bandSyms.forEach((s, i) => {
+              corner[s] = corner[s] + (mask >> i & 1 ? 1 : -1) * bound.uncertainties[s].tol;
+            });
+            try {
+              corners.push(!!parseAndEval(expression, corner));
+            } catch {
+              corners.push(null);
+            }
+          }
+          const first = bandSyms[0];
+          const un = bound.uncertainties[first];
+          uncertainty = {
+            symbol: first,
+            stated: un.stated,
+            tol: un.tol,
+            unit: un.unit,
+            nominal: result,
+            corners
+          };
+          const decided = corners.filter((c2) => c2 !== null);
+          if (decided.length && decided.some((c2) => c2 !== result)) {
+            voidReason = voidReason ?? `the stated uncertainty (${un.stated}) on ${first.split(".").pop()} crosses the decision boundary \u2014 the check evaluates ${result ? "true" : "false"} at the stated value but ${decided.find((c2) => c2 !== result) ? "true" : "false"} at the band edge; the question cannot be decided as stated`;
+          }
+        }
       }
     }
-    return { expression, symbolic: expression, values, result };
+    return { expression, symbolic: expression, values, result, uncertainty };
   });
   if (missing.length) {
     return { verdict: "void", missing, checks: machine };
@@ -341,6 +419,7 @@ function evaluate(content, query, opts) {
     if (voidReason) return { verdict: "void", missing: [], void_reason: voidReason, checks: machine };
     return null;
   }
+  if (voidReason) return { verdict: "void", missing: [], void_reason: voidReason, checks: machine };
   return {
     verdict: failed ? "fail" : "pass",
     on_violation: failed ? String(c.on_violation ?? "invalid") : void 0,
@@ -356,6 +435,11 @@ function verdictNote(v, node) {
   for (const c of v.checks) {
     const vals = Object.entries(c.values).map(([k, n]) => `${k}=${n}`).join(", ");
     lines.push(`- ${c.expression}${vals ? `  [${vals}]` : ""} \u2192 ${c.result === null ? "not evaluated" : c.result ? "holds" : "VIOLATED"}`);
+    if (c.uncertainty) {
+      const u = c.uncertainty;
+      const edges = u.corners.map((r) => r === null ? "not evaluated" : r ? "holds" : "VIOLATED").join("; ");
+      lines.push(`  band ${u.stated}${u.unit && !u.stated.includes(u.unit) ? ` ${u.unit}` : ""} on ${u.symbol}: ${edges} across the band`);
+    }
   }
   if (v.verdict === "void") {
     lines.push(v.void_reason ? `VERDICT: VOID \u2014 ${v.void_reason}. State the mismatch plainly; the question cannot be decided as stated.` : `VERDICT: VOID \u2014 the question does not state: ${v.missing.join(", ")}. Say exactly what is missing; never assume values.`);

package/dist/refusal.d.ts

@@ -40,3 +40,9 @@ export declare function exciseMisplacedPin(answer: string, cites: boolean): stri
  *  every later ask). An answer is cacheable only when it carries no
  *  pin AND the wall would not rewrite it. */
 export declare function cacheableAnswer(answer: string, scope?: RefusalScope): boolean;
+/** The follow-up-chips law (2026-10-13): the understanding stage's
+ *  follow_ups are generated BEFORE retrieval and answer — after a
+ *  refusal they advertise the very topic the corpus does not carry.
+ *  Chips serve only when the answer is not refusal-shaped (carries no
+ *  pin and the wall would not rewrite it). */
+export declare function refusalShaped(answer: string, scope?: RefusalScope): boolean;

package/dist/{search-VEGQBEFC.js → search-2PKZJMUV.js}

@@ -4,7 +4,7 @@ import {
 import "./chunk-XH5QGX2O.js";
 import "./chunk-NI4CIK6W.js";
 import "./chunk-W7J5SFXJ.js";
-import "./chunk-XBZIJMS7.js";
+import "./chunk-ETLSWSZ7.js";
 import "./chunk-4NXH5ZI6.js";
 import "./chunk-VT7DR6NQ.js";
 import "./chunk-3FYJM7LH.js";

package/dist/{tools-5Y763UWT.js → tools-CWPQQTBQ.js}

@@ -4,7 +4,7 @@ import {
   parseToolCall,
   runTool,
   toolNote
-} from "./chunk-363Q6FOL.js";
+} from "./chunk-VYEMFSU5.js";
 import "./chunk-NI4CIK6W.js";
 import "./chunk-4NXH5ZI6.js";
 import "./chunk-VT7DR6NQ.js";

package/dist/verdict.d.ts

@@ -3,6 +3,16 @@ export interface MachineCheck {
     symbolic: string;
     values: Record<string, number>;
     result: boolean | null;
+    /** present when the question states a tolerance on a symbol this
+     *  check reads: the band's corner evaluations beside the nominal */
+    uncertainty?: {
+        symbol: string;
+        stated: string;
+        tol: number;
+        unit?: string;
+        nominal: boolean;
+        corners: (boolean | null)[];
+    };
 }
 export interface Verdict {
     verdict: "pass" | "fail" | "void";
@@ -17,12 +27,24 @@ export interface Verdict {
 export declare function extractChecks(content: unknown): string[];
 export declare function symbolsIn(checks: string[]): string[];
 export declare function extractParams(query: string, symbols: string[]): Record<string, number>;
+/** A stated uncertainty: "± 60 v" / "pm 60 v" / "± 0.2 %". `tol` is
+ *  absolute (a relative statement resolves against the stated value);
+ *  `stated` quotes the source form for narration. */
+export interface StatedUncertainty {
+    tol: number;
+    stated: string;
+    relative: boolean;
+    unit?: string;
+}
 /** The stated values WITH their unit tokens (TODO.sota/04's unit
  *  semantics): "E_max 30000 v" binds e_max=30000 and the unit "v" —
- *  the dimension check needs both. */
+ *  the dimension check needs both. A tolerance after the value —
+ *  "30000 ± 60 v", "30000 v ± 60", "± 0.2 %", or the AsciiMath
+ *  spelling "30000 pm 60 v" — binds a first-class uncertainty. */
 export declare function extractParamsWithUnits(query: string, symbols: string[]): {
     values: Record<string, number>;
     units: Record<string, string>;
+    uncertainties: Record<string, StatedUncertainty>;
 };
 /** Dimension coherence (TODO.sota/04 item 2): the units plane gives
  *  each unit token a dimension; a parameter set whose bound symbols

package/dist/worker_public/src/index.js

@@ -4,13 +4,13 @@ import {
   handleMemories,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-Y5T6V5CB.js";
+} from "../../chunk-VISPFCQP.js";
 import "../../chunk-ECOYO7EX.js";
 import {
   TOOLS_REGISTRY,
   bindModelNode,
   modelGroundingBlock
-} from "../../chunk-363Q6FOL.js";
+} from "../../chunk-VYEMFSU5.js";
 import {
   handleSearch
 } from "../../chunk-5WITTJQD.js";
@@ -53,7 +53,7 @@ import {
 } from "../../chunk-W7J5SFXJ.js";
 import {
   canonicalRefusal
-} from "../../chunk-XBZIJMS7.js";
+} from "../../chunk-ETLSWSZ7.js";
 import {
   entitlementScope,
   standardKeysFrom
@@ -1073,13 +1073,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-5Y763UWT.js");
+    const { runTool, TOOLS_REGISTRY: TOOLS_REGISTRY2 } = await import("../../tools-CWPQQTBQ.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-A54GAMZR.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-VEGQBEFC.js")).handleSearch(env, ctx, inner, tier, key);
+      const res = name === "ask" ? await (await import("../../ask-RIWVOI3D.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-2PKZJMUV.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/refusal.js

@@ -2,12 +2,14 @@ import {
   cacheableAnswer,
   canonicalRefusal,
   exciseMisplacedPin,
-  refusalAnswer
-} from "../../chunk-XBZIJMS7.js";
+  refusalAnswer,
+  refusalShaped
+} from "../../chunk-ETLSWSZ7.js";
 import "../../chunk-3FYJM7LH.js";
 export {
   cacheableAnswer,
   canonicalRefusal,
   exciseMisplacedPin,
-  refusalAnswer
+  refusalAnswer,
+  refusalShaped
 };

package/docs/API.md

@@ -410,7 +410,11 @@ never an invented grounding).
 
 `similar: true` means the answer came from the semantic cache (a
 near-identical recent question). `follow_ups` are suggested next
-questions (present when understanding produced them).
+questions (present when understanding produced them) — and are
+withheld entirely on refusal-shaped answers: the chips are generated
+before retrieval, so after an out-of-corpus refusal they would
+advertise the very topic the corpus does not carry. Honest absence
+extends to the conversation's next step.
 
 **Citation object** (also the shape in the `done`/JSON responses):
 ```jsonc

package/package.json

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

@@ -17,7 +17,7 @@ import { reflect } from "./reflect";
 import { scoreFaithfulness } from "./faithfulness";
 import { entailmentVerdict } from "./entailment";
 import { checkQuoteAnchors, ANCHOR_CORRECTION_NOTE } from "./anchors";
-import { cacheableAnswer, canonicalRefusal, exciseMisplacedPin } from "./refusal";
+import { cacheableAnswer, canonicalRefusal, exciseMisplacedPin, refusalShaped } from "./refusal";
 import { contractV2, tableRetyped } from "./refs";
 import { completeTables, completeFigures } from "./completion";
 import { NO_CONTEXT, appliedContext, contextNote, namedDocumentIn, parseContext, resolveDocScope, syntheticUnderstanding } from "./context";
@@ -1578,7 +1578,7 @@ let convEntities: Array<{ entity: string; kind: string }> = [];
           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: understanding?.follow_ups ?? [], blocks: [...c2.blocks, ...(verdictBlock ? [verdictBlock] : []), ...(conditionBlock ? [conditionBlock] : []), ...(aggregationBlock ? [aggregationBlock] : [])], context_applied: ctxApplied, read: readAs(),
+          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 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
@@ -1849,7 +1849,7 @@ 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: 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 } };
+  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 } };
   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/refusal.ts

@@ -158,3 +158,12 @@ export function cacheableAnswer(answer: string, scope?: RefusalScope): boolean {
   if (answer.includes(refusalAnswer())) return false;
   return canonicalRefusal(answer, scope) === answer;
 }
+
+/** The follow-up-chips law (2026-10-13): the understanding stage's
+ *  follow_ups are generated BEFORE retrieval and answer — after a
+ *  refusal they advertise the very topic the corpus does not carry.
+ *  Chips serve only when the answer is not refusal-shaped (carries no
+ *  pin and the wall would not rewrite it). */
+export function refusalShaped(answer: string, scope?: RefusalScope): boolean {
+  return !cacheableAnswer(answer, scope);
+}

package/workers/worker_public/src/verdict.ts

@@ -7,12 +7,28 @@
 // on_violation word ("invalid"/"void") when any fails; "void" plus the
 // missing parameter names when the question does not state enough —
 // honest degradation, never a guess.
+//
+// Uncertainty ranges (values stated with a tolerance — "30000 ± 60 v",
+// "30000 pm 0.2 %", the AsciiMath spelling included) are first-class:
+// the check is evaluated across the stated band, and a band that spans
+// both outcomes voids with its reason — guarded acceptance, never a
+// silent worst-case ruling.
 
 export interface MachineCheck {
   expression: string;
   symbolic: string;
   values: Record<string, number>;
   result: boolean | null; // null: could not evaluate (missing params)
+  /** present when the question states a tolerance on a symbol this
+   *  check reads: the band's corner evaluations beside the nominal */
+  uncertainty?: {
+    symbol: string;
+    stated: string;
+    tol: number;
+    unit?: string;
+    nominal: boolean;
+    corners: (boolean | null)[];
+  };
 }
 
 export interface Verdict {
@@ -196,22 +212,94 @@ export function extractParams(query: string, symbols: string[]): Record<string,
   return extractParamsWithUnits(query, symbols).values;
 }
 
+/** A stated uncertainty: "± 60 v" / "pm 60 v" / "± 0.2 %". `tol` is
+ *  absolute (a relative statement resolves against the stated value);
+ *  `stated` quotes the source form for narration. */
+export interface StatedUncertainty {
+  tol: number;
+  stated: string;
+  relative: boolean;
+  unit?: string;
+}
+
+const TOL_SEP_SRC = "\\u00b1|\\bpm\\b|\\+/-";
+const NUM_SRC = "[0-9][0-9 ,.]*[0-9]";
+const UNIT_SRC = "%|\\u00b0?[A-Za-z\\u00b5\\u03a9]{0,6}";
+
+function statedUncertainty(
+  value: number,
+  tolRaw: string,
+  tolUnitRaw: string | undefined,
+  valueUnit: string | undefined,
+): StatedUncertainty {
+  const tolNum = parseNumber(tolRaw);
+  const tolUnit = (tolUnitRaw ?? "").trim();
+  const relative = tolUnit === "%";
+  return {
+    tol: relative ? Math.abs(value) * tolNum / 100 : tolNum,
+    stated: relative ? `± ${tolRaw} %` : `± ${tolRaw}${tolUnit ? ` ${tolUnit}` : ""}`,
+    relative,
+    unit: relative ? valueUnit : (tolUnit || valueUnit),
+  };
+}
+
 /** The stated values WITH their unit tokens (TODO.sota/04's unit
  *  semantics): "E_max 30000 v" binds e_max=30000 and the unit "v" —
- *  the dimension check needs both. */
+ *  the dimension check needs both. A tolerance after the value —
+ *  "30000 ± 60 v", "30000 v ± 60", "± 0.2 %", or the AsciiMath
+ *  spelling "30000 pm 60 v" — binds a first-class uncertainty. */
 export function extractParamsWithUnits(
   query: string,
   symbols: string[],
-): { values: Record<string, number>; units: Record<string, string> } {
+): {
+  values: Record<string, number>;
+  units: Record<string, string>;
+  uncertainties: Record<string, StatedUncertainty>;
+} {
   const values: Record<string, number> = {};
   const units: Record<string, string> = {};
+  const uncertainties: Record<string, StatedUncertainty> = {};
   for (const sym of symbols) {
     const leaf = sym.split(".").pop() ?? sym;
     const esc = leaf.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    // symbol, a short non-numeric gap (words like "were"/"of" allowed),
-    // then the number, then an optional unit token directly after
-    const re = new RegExp(`\\b${esc}\\b\\D{0,14}?([0-9][0-9 ,.]*[0-9])\\s*(%|\\u00b0?[A-Za-z\\u00b5\\u03a9]{0,6})?`, "iu");
-    const m = query.match(re);
+    // tolerance first ("value ± tol unit" — the tol's unit names the
+    // shared unit when the value carries none), then value and unit
+    // side by side with a trailing tolerance, then the plain form
+    const reTolFirst = new RegExp(
+      `\\b${esc}\\b\\D{0,14}?(${NUM_SRC})\\s*(?:${TOL_SEP_SRC})\\s*(${NUM_SRC})\\s*(${UNIT_SRC})?`,
+      "iu",
+    );
+    const reTolAfter = new RegExp(
+      `\\b${esc}\\b\\D{0,14}?(${NUM_SRC})\\s*(${UNIT_SRC})\\s*(?:${TOL_SEP_SRC})\\s*(${NUM_SRC})\\s*(${UNIT_SRC})?`,
+      "iu",
+    );
+    const rePlain = new RegExp(
+      `\\b${esc}\\b\\D{0,14}?(${NUM_SRC})\\s*(${UNIT_SRC})?`,
+      "iu",
+    );
+    const mFirst = query.match(reTolFirst);
+    const mAfter = mFirst ? null : query.match(reTolAfter);
+    const mTol = mFirst ?? mAfter;
+    if (mTol) {
+      const value = parseNumber(mTol[1]!);
+      if (!Number.isFinite(value)) continue;
+      values[sym] = value;
+      let unit: string | undefined;
+      let u: StatedUncertainty;
+      if (mFirst) {
+        // [2]=tol, [3]=tol unit (shared with the value when present)
+        unit = (mFirst[3] ?? "").trim() || undefined;
+        u = statedUncertainty(value, mFirst[2]!, mFirst[3], unit);
+      } else {
+        // [2]=value unit, [3]=tol, [4]=tol unit (defaults to the value's)
+        unit = (mAfter![2] ?? "").trim() || undefined;
+        u = statedUncertainty(value, mAfter![3]!, mAfter![4], unit || undefined);
+      }
+      if (unit) units[sym] = unit;
+      uncertainties[sym] = u;
+      continue;
+    }
+    const m = query.match(rePlain);
     if (m) {
       const v = parseNumber(m[1]!);
       if (Number.isFinite(v)) {
@@ -221,7 +309,7 @@ export function extractParamsWithUnits(
       }
     }
   }
-  return { values, units };
+  return { values, units, uncertainties };
 }
 
 /** Dimension coherence (TODO.sota/04 item 2): the units plane gives
@@ -261,10 +349,13 @@ export function evaluate(content: unknown, query: string, opts?: { dimensions?:
   let voidReason: string | null = null;
   const machine: MachineCheck[] = checks.map((expression) => {
     const values: Record<string, number> = {};
+    const ids: string[] = [];
     try {
-      for (const t of tokenize(expression)) if (t.t === "id" && params[t.v] !== undefined) values[t.v] = params[t.v];
+      for (const t of tokenize(expression)) if (t.t === "id") ids.push(t.v);
     } catch { /* values stay partial */ }
+    for (const t of new Set(ids)) if (params[t] !== undefined) values[t] = params[t];
     let result: boolean | null = null;
+    let uncertainty: MachineCheck["uncertainty"];
     if (missing.length === 0) {
       // unit semantics (TODO.sota/04): a comparison mixing dimensions
       // cannot evaluate — void with the reason, never a number answer
@@ -273,9 +364,39 @@ export function evaluate(content: unknown, query: string, opts?: { dimensions?:
         voidReason = voidReason ?? mismatch;
       } else {
         try { result = !!parseAndEval(expression, params); } catch { result = null; }
+        // uncertainty band: the check re-evaluates at every corner of
+        // the stated tolerances (2^k ≤ 8); a band spanning both
+        // outcomes is undecidable as stated — void with its reason
+        const bandSyms = [...new Set(ids)].filter((s) => bound.uncertainties[s] !== undefined).slice(0, 3);
+        if (bandSyms.length && result !== null) {
+          const corners: (boolean | null)[] = [];
+          for (let mask = 0; mask < 1 << bandSyms.length; mask++) {
+            const corner = { ...params };
+            bandSyms.forEach((s, i) => { corner[s] = corner[s]! + ((mask >> i) & 1 ? 1 : -1) * bound.uncertainties[s]!.tol; });
+            try { corners.push(!!parseAndEval(expression, corner)); } catch { corners.push(null); }
+          }
+          const first = bandSyms[0]!;
+          const un = bound.uncertainties[first]!;
+          uncertainty = {
+            symbol: first,
+            stated: un.stated,
+            tol: un.tol,
+            unit: un.unit,
+            nominal: result,
+            corners,
+          };
+          const decided = corners.filter((c): c is boolean => c !== null);
+          if (decided.length && decided.some((c) => c !== result)) {
+            voidReason = voidReason ?? (
+              `the stated uncertainty (${un.stated}) on ${first.split(".").pop()} crosses the decision boundary — ` +
+              `the check evaluates ${result ? "true" : "false"} at the stated value but ` +
+              `${decided.find((c) => c !== result) ? "true" : "false"} at the band edge; the question cannot be decided as stated`
+            );
+          }
+        }
       }
     }
-    return { expression, symbolic: expression, values, result };
+    return { expression, symbolic: expression, values, result, uncertainty };
   });
   if (missing.length) {
     return { verdict: "void", missing, checks: machine };
@@ -286,6 +407,9 @@ export function evaluate(content: unknown, query: string, opts?: { dimensions?:
     if (voidReason) return { verdict: "void", missing: [], void_reason: voidReason, checks: machine };
     return null;
   }
+  // a stated uncertainty spanning both outcomes — guarded acceptance:
+  // void with the reason, never a silent worst-case ruling
+  if (voidReason) return { verdict: "void", missing: [], void_reason: voidReason, checks: machine };
   return {
     verdict: failed ? "fail" : "pass",
     on_violation: failed ? String(c.on_violation ?? "invalid") : undefined,
@@ -303,6 +427,11 @@ export function verdictNote(v: Verdict, node: { node_id: string; clause?: { urn?
   for (const c of v.checks) {
     const vals = Object.entries(c.values).map(([k, n]) => `${k}=${n}`).join(", ");
     lines.push(`- ${c.expression}${vals ? `  [${vals}]` : ""} → ${c.result === null ? "not evaluated" : c.result ? "holds" : "VIOLATED"}`);
+    if (c.uncertainty) {
+      const u = c.uncertainty;
+      const edges = u.corners.map((r) => (r === null ? "not evaluated" : r ? "holds" : "VIOLATED")).join("; ");
+      lines.push(`  band ${u.stated}${u.unit && !u.stated.includes(u.unit) ? ` ${u.unit}` : ""} on ${u.symbol}: ${edges} across the band`);
+    }
   }
   if (v.verdict === "void") {
     lines.push(v.void_reason