bareloop 0.40.0 → 0.42.0

package/src/declaredclose.js

@@ -70,7 +70,7 @@
 
 import { runStage, makeSeedTrees, STOP_FAULTS, EXIT_RED, JUDGED_FLOOR_KIND, judgedStages } from './kinds.js';
 import {
-  validateDeclaration, classGuards, genreOwnedEnvNames, ungroundedGenreEnv, GENRE_LANGUAGES, TYPES_GENRE,
+  validateDeclaration, classGuards, genreOwnedEnvNames, ungroundedGenreEnv, DECLARABLE_LANGUAGES, TYPES_GENRE, catalogueForLang, KIND_CATALOGUE, TEXT_GENRE, genreForLang,
   VERDICT_CLASSES, LIVE_CLASSES, NEVER_OFFERED_KINDS,
 } from './authoring.js';
 // the calibration set's own gate lives beside the rulebook it is graded against
@@ -83,7 +83,7 @@ import { isObj, isNonEmptyString } from './validate.js';
 
 /** The genres a `closeDecl` may name. v1 admits exactly one (D13) — a genre
  * classifier is designed the day there is a second genre to classify. */
-export const DECLARED_GENRES = Object.freeze([TYPES_GENRE.name]);
+export const DECLARED_GENRES = Object.freeze([TYPES_GENRE.name, TEXT_GENRE]);
 /**
  * The exact field set of a `closeDecl` — anything else is a smuggle channel, the
  * same rule `STAGE_FIELDS` enforces on a command stage.
@@ -272,13 +272,14 @@ export function declaredStages(closeDecl) {
  *
  * @param {any} closeDecl
  * @param {{at?: string, listing?: string[]|null, deferListing?: boolean,
- *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null}} [opts]
+ *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null,
+ *   inputLabels?: string[]|null}} [opts]
  * @returns {{ok: boolean, reds: Red[], closeDecl: any, grounded: boolean,
  *   scoped: {scoped: boolean, via: string|null},
  *   ceiling: {class: string, kind: string, stage: string|null, locked: boolean}|null}}
  */
 export function validateCloseDecl(closeDecl, opts = {}) {
-  const { at = 'closeDecl', listing = null, catalogue, verdictType = null, writeScope = null, jobLines = null } = opts;
+  const { at = 'closeDecl', listing = null, catalogue, verdictType = null, writeScope = null, jobLines = null, inputLabels = null } = opts;
   const deferListing = opts.deferListing === true;
   /** @type {Red[]} */
   const reds = [];
@@ -320,13 +321,15 @@ export function validateCloseDecl(closeDecl, opts = {}) {
         + `land here); fields: ${CLOSE_DECL_FIELDS.join(', ')}`);
     }
   }
-  if (!DECLARED_GENRES.includes(closeDecl.genre)) {
-    red('invalid-value', `${at}.genre`, `menu: ${DECLARED_GENRES.join('|')} — v1 admits exactly one genre (D13), and a `
-      + 'genre with no guard battery must refuse rather than author a close without the guards it cannot supply');
+  // PART 1a: a genre is bound to its language — code languages are TYPES, the rubric-files language is TEXT, and neither may
+  // wear the other's label (`lang` is checked just below; an unknown lang reds there)
+  if (!DECLARED_GENRES.includes(closeDecl.genre) || closeDecl.genre !== genreForLang(closeDecl.lang)) {
+    red('invalid-value', `${at}.genre`, `menu: ${DECLARED_GENRES.join('|')} — a close's genre follows its language (${genreForLang(closeDecl.lang)} for "${String(closeDecl.lang)}"), `
+      + 'and a genre with no guard battery must refuse rather than author a close without the guards it cannot supply');
   }
-  const langOk = GENRE_LANGUAGES.includes(closeDecl.lang);
+  const langOk = DECLARABLE_LANGUAGES.includes(closeDecl.lang);
   if (!langOk) {
-    red('invalid-value', `${at}.lang`, `menu: ${GENRE_LANGUAGES.join('|')} — the language selects the genre's guard `
+    red('invalid-value', `${at}.lang`, `menu: ${DECLARABLE_LANGUAGES.join('|')} — the language selects the genre's guard `
       + 'battery and its environment, both of which are ours and neither of which has a default');
   }
   // `notes` is NOT checked here. It is M2's rule now (`validateDeclaration`),
@@ -391,7 +394,9 @@ export function validateCloseDecl(closeDecl, opts = {}) {
   }
 
   const v = validateDeclaration(closeDecl, {
-    ...(catalogue ? { catalogue } : {}),
+    // PART 1a: the kinds a close may use depend on its language — a rubric-files ("text") close sees its own two kinds, every
+    // code close never sees a rubric-only one. A caller-supplied catalogue is narrowed the same way.
+    catalogue: catalogueForLang(closeDecl.lang, catalogue ?? KIND_CATALOGUE),
     // BOTH are forwarded, always. Forwarding only one would hide the case M2
     // reds as `listing-conflict` — a caller that defers the tree-grounded half
     // AND hands over a tree does not know which gate it is running, and silently
@@ -403,6 +408,7 @@ export function validateCloseDecl(closeDecl, opts = {}) {
     verdictType: picked,
     writeScope,
     jobLines,
+    inputLabels,
     envOwned: owned,
     // POST-injection: an owned name is accepted only when its value is EXACTLY
     // the recorded one. `{}` (nothing recorded) keeps the pre-injection rule, so
@@ -486,7 +492,7 @@ export function validateCloseDecl(closeDecl, opts = {}) {
  * @param {any} closeDecl @param {string} verdictType @returns {string[]}
  */
 export function guardNames(closeDecl, verdictType) {
-  if (!isObj(closeDecl) || !GENRE_LANGUAGES.includes(closeDecl.lang)) return [];
+  if (!isObj(closeDecl) || !DECLARABLE_LANGUAGES.includes(closeDecl.lang)) return [];
   if (!LIVE_CLASSES.includes(String(verdictType))) return [];
   return classGuards({ verdictType: String(verdictType), lang: closeDecl.lang }).map((g) => g.name);
 }
@@ -592,6 +598,7 @@ export async function runDeclaredStages(stages, redact = (s) => s, opts = {}) {
   }
   const owned = !shared;
   const seedTrees = shared ?? makeSeedTrees();
+  const textClose = stages.some((st) => st?.kind === 'rubric-step');
   /** @type {any} */
   const ctx = {
     workdir: cwd,
@@ -633,10 +640,14 @@ export async function runDeclaredStages(stages, redact = (s) => s, opts = {}) {
     /** @type {any[]} */
     const ran = [];
     /** @type {any} */
-    let last = { verdict: 'satisfied', judgedCount: 1 };
+    /** @type {any} */
+    let last = textClose ? { verdict: 'satisfied' } : { verdict: 'satisfied', judgedCount: 1 };
     for (const st of stages) {
       const r = await runStage(st, ctx);
       const t = translate(r, redact);
+      // PART 1a: `judgedCount` marks a judgment rendered by the close's judging kinds. A rubric-files (TEXT) close renders only
+      // mechanical verdicts and runs no judge, so none of its records may claim one
+      if (textClose) delete t.judgedCount;
       ran.push({
         name: st?.name ?? null,
         verdict: t.verdict,

package/src/draftspend.js

@@ -24,10 +24,10 @@ export const DRAFT_LOG_FILE = 'draft-log.jsonl';
  * One line of the drafting log. `no` = the step's position in the session's progress list (a step id can repeat).
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
- *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway")
- *  - `call`        {no, step, label, model, thinking, thinkingApplied?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
- *    (`thinking` = what was asked and sent: off | on | not-switchable | unverified; `thinkingApplied` = bare-agent's own verdict for the
- *    call's run (true | false | null), present only when thinkingMode was sent)
+ *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
+ *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)
  *    (no token counts: the call path does not carry them without reworking the library, so none are recorded)
  * @typedef {{kind: string, no: number, at: string, [k: string]: any}} DraftEvent
  */

package/src/facts.js

@@ -0,0 +1,317 @@
+// PART 1b (docs/product/ITEM33-BUILD.md, "Addendum 2026-10-13 — Part 1b: required facts"): the FACT step.
+//
+// A job line the person phrased as "find / list / look up" leaves behind a step file that holds ONLY filled facts:
+//
+//     { "results": [ { "quote": "<words copied from the input>", "values": { "<fact name>": "<value as the quote writes it>" } } ] }
+//
+// What each result must hold is the signed list of REQUIRED FACTS on the line's `fact` part (name, shape, rule, source
+// input). The check is bareguard's `cited` + `decides`, built here by code from the signed part: the quote is really in the
+// frozen input, every value really is in the quote (compared exactly by shape), every value meets its rule. No model is in
+// the check. The claim TEXT that bareguard's number scan reads is written by code from the values, never by the worker.
+
+import { rubricVocabulary } from 'bareguard';
+
+/** the shapes a fact may have (bareguard's value kinds, plus `phrase` = a presence decide) */
+export const FACT_SHAPES = Object.freeze(['money', 'number', 'date', 'time', 'phrase', 'text']);
+/** the comparison ops a rule may use (bareguard's) */
+export const FACT_OPS = Object.freeze(['lt', 'lte', 'gt', 'gte', 'between']);
+/** bareguard signs at most this many decides on one `cited` check */
+export const MAX_FACTS = 10;
+/** every field a fact may carry */
+const FACT_FIELDS = Object.freeze(['name', 'shape', 'unit', 'currency', 'phrase', 'anchor', 'until', 'rule', 'aiProposal']);
+/** every field a part of class `fact` may carry (the shared ones are checked by rubricStepShapeReds) */
+export const FACT_PART_FIELDS = Object.freeze(['source', 'facts', 'count']);
+/** a fact's name appears in the claim text bareguard scans for numbers, so it carries letters only (no digit can red the claim) */
+const NAME_RE = /^[A-Za-z][A-Za-z _-]{0,63}$/;
+
+/** @param {unknown} v @returns {v is Record<string, any>} */
+const isRec = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+/** @param {unknown} v @returns {v is string} */
+const nonEmpty = (v) => typeof v === 'string' && v.trim() !== '';
+
+/** the `fact` part of a step's parameters, or null (a step has at most one) @param {any} params @returns {any|null} */
+export function factPartOf(params) {
+  const parts = Array.isArray(params?.parts) ? params.parts : [];
+  return parts.find((/** @type {any} */ p) => isRec(p) && p.class === 'fact') ?? null;
+}
+
+/** @param {any} v @returns {boolean} a rule bound has the type its shape needs: a number for number/money, a string for date/time */
+const boundOk = (/** @type {string} */ shape, /** @type {unknown} */ v) => (shape === 'number' || shape === 'money' ? typeof v === 'number' && Number.isFinite(v) : typeof v === 'string' && v !== '');
+
+/**
+ * The SHAPE of a `fact` part (what it may carry), pushed as reds in the same form `rubricStepShapeReds` uses. Whether the
+ * bareguard rubric it builds is signable is asked of bareguard itself (`checkRubricParts` builds it once at drafting).
+ * @param {any} part @param {string} w the path prefix @param {(code: string, path: string, detail: string) => void} red
+ */
+export function factShapeReds(part, w, red) {
+  for (const k of Object.keys(part)) {
+    if (!['text', 'class', 'covers', 'rules', 'source', 'facts', 'count'].includes(k)) {
+      red('invalid-value', `${w}.${k}`, `"${k}" is not a field of a fact part — fields: text, class, covers, rules, ${FACT_PART_FIELDS.join(', ')}`);
+    }
+  }
+  if (!(nonEmpty(part.source) && part.source.length <= 128)) red('invalid-value', `${w}.source`, 'the label of the input the quotes come from');
+  if (!Array.isArray(part.facts) || part.facts.length === 0 || part.facts.length > MAX_FACTS) {
+    red('invalid-value', `${w}.facts`, `a list of 1 to ${MAX_FACTS} facts {name, shape, ...}`);
+  } else {
+    /** @type {Set<string>} */
+    const seen = new Set();
+    part.facts.forEach((/** @type {any} */ f, /** @type {number} */ j) => {
+      const fw = `${w}.facts[${j}]`;
+      if (!isRec(f)) { red('invalid-value', fw, '{name, shape, ...}'); return; }
+      for (const k of Object.keys(f)) {
+        if (FACT_FIELDS.includes(k)) continue;
+        // L4 (smv710w8c3wdh, 3 of 3 tries): "covers" / "rules" are fields of the PART, written once, never of a fact inside it
+        red('invalid-value', `${fw}.${k}`, k === 'covers' || k === 'rules'
+          ? `"${k}" is a field of the PART, not of a fact - write the numbers once on the fact part ("${k}": [..]) and take it off every fact. Fact fields: ${FACT_FIELDS.join(', ')}`
+          : `"${k}" is not a field of a fact — fields: ${FACT_FIELDS.join(', ')}`);
+      }
+      if (!(typeof f.name === 'string' && NAME_RE.test(f.name))) red('invalid-value', `${fw}.name`, 'the fact\'s name: letters, spaces, "_" or "-" only (no digits), at most 64 characters');
+      else if (seen.has(f.name)) red('invalid-value', `${fw}.name`, `the name "${f.name}" is used twice on this line`);
+      else seen.add(f.name);
+      if (!FACT_SHAPES.includes(f.shape)) { red('invalid-value', `${fw}.shape`, `one of ${FACT_SHAPES.join(' | ')}`); return; }
+      if (Object.hasOwn(f, 'aiProposal') && typeof f.aiProposal !== 'boolean') red('invalid-value', `${fw}.aiProposal`, 'true when the AI turned the person\'s words into this number');
+      const has = (/** @type {string} */ k) => Object.hasOwn(f, k);
+      if (f.shape === 'money') {
+        if (has('unit') === has('currency')) red('invalid-value', `${fw}.unit`, 'money names exactly one of unit (words the input writes after the amount, e.g. "US dollars") or currency ("$", "€" or "£")');
+      } else if (has('unit') || has('currency')) red('invalid-value', `${fw}.${has('unit') ? 'unit' : 'currency'}`, 'only money has a unit or a currency');
+      if (has('unit') && !nonEmpty(f.unit)) red('invalid-value', `${fw}.unit`, 'a non-empty string copied from the input');
+      if (has('currency') && !['$', '€', '£'].includes(f.currency)) red('invalid-value', `${fw}.currency`, 'one of $ | € | £');
+      if (f.shape === 'phrase') {
+        if (!nonEmpty(f.phrase)) red('invalid-value', `${fw}.phrase`, 'the fixed words the quote must contain, copied from the input');
+        for (const k of ['anchor', 'until', 'rule']) if (has(k)) red('invalid-value', `${fw}.${k}`, 'a phrase is fixed words the quote must contain; it has no anchor, until or rule');
+      } else if (has('phrase')) red('invalid-value', `${fw}.phrase`, 'only a phrase fact carries phrase');
+      if (has('anchor') && !nonEmpty(f.anchor)) red('invalid-value', `${fw}.anchor`, 'a label copied VERBATIM from the input');
+      if (has('until') && !nonEmpty(f.until)) red('invalid-value', `${fw}.until`, 'a label copied VERBATIM from the input');
+      if (has('until') && !has('anchor') && f.shape !== 'phrase') red('invalid-value', `${fw}.until`, 'until needs an anchor');
+      if (has('until') && f.shape !== 'text' && f.shape !== 'phrase') red('invalid-value', `${fw}.until`, 'until closes a text fact only');
+      if (has('rule') && f.shape !== 'phrase') {
+        const r = f.rule;
+        if (f.shape === 'text') red('invalid-value', `${fw}.rule`, 'a text fact is bind only: it has no rule');
+        else if (!isRec(r) || !FACT_OPS.includes(r.op)) red('invalid-value', `${fw}.rule`, `{op: ${FACT_OPS.join(' | ')}, value} or {op: "between", lo, hi}`);
+        else if (r.op === 'between' ? !(boundOk(f.shape, r.lo) && boundOk(f.shape, r.hi) && !Object.hasOwn(r, 'value')) : !(boundOk(f.shape, r.value) && !Object.hasOwn(r, 'lo') && !Object.hasOwn(r, 'hi'))) {
+          red('invalid-value', `${fw}.rule`, r.op === 'between' ? 'between needs lo and hi (numbers for number/money, strings for date/time) and no value' : 'a comparison needs value (a number for number/money, a string for date/time)');
+        }
+      }
+    });
+  }
+  if (Object.hasOwn(part, 'count')) {
+    const c = part.count;
+    const ok = isRec(c) && Object.keys(c).every((k) => k === 'min' || k === 'max') && (Object.hasOwn(c, 'min') || Object.hasOwn(c, 'max'))
+      && ['min', 'max'].every((k) => !Object.hasOwn(c, k) || (Number.isInteger(c[k]) && c[k] >= 1))
+      && (!Object.hasOwn(c, 'min') || !Object.hasOwn(c, 'max') || c.min <= c.max);
+    if (!ok) red('invalid-value', `${w}.count`, '{min?, max?} — how many results the person asked for (integers, 1 or more, min no more than max)');
+  }
+}
+
+/**
+ * bareguard's `decides` list for a fact part: one decide per fact, in the fact order (so `d<j>` is the fact's own index).
+ * @param {any} part @returns {Record<string, any>[]}
+ */
+export function factDecides(part) {
+  return part.facts.map((/** @type {any} */ f) => {
+    if (f.shape === 'phrase') return { phrases: [f.phrase] };
+    /** @type {Record<string, any>} */
+    const d = { valueKind: f.shape };
+    if (f.shape === 'money') { if (f.unit !== undefined) d.unit = f.unit; else d.currency = f.currency; }
+    if (f.anchor !== undefined) d.anchor = f.anchor;
+    if (f.until !== undefined) d.until = f.until;
+    if (f.rule) {
+      d.op = f.rule.op;
+      if (f.rule.op === 'between') { d.lo = f.rule.lo; d.hi = f.rule.hi; } else d.value = f.rule.value;
+    }
+    return d;
+  });
+}
+
+/**
+ * The claims bareguard reads for a fact step, built from the step file's `results`. The claim TEXT is written here, by code,
+ * from the values the worker gave (the worker writes no claim text): `name: value; name: value`. A phrase fact contributes its
+ * own signed words. A result that is not an object, or has no string quote, still becomes a claim — an empty one — so
+ * bareguard reds it by name rather than the result vanishing.
+ * @param {any} part @param {unknown} results @returns {{claim: string, quote: string, values?: Record<string, string>}[]}
+ */
+export function factClaims(part, results) {
+  const list = Array.isArray(results) ? results : [];
+  return list.map((/** @type {any} */ r) => {
+    const given = isRec(r) && isRec(r.values) ? r.values : null;
+    /** @type {Record<string, string>} */
+    const values = {};
+    /** @type {string[]} */
+    const said = [];
+    part.facts.forEach((/** @type {any} */ f, /** @type {number} */ j) => {
+      if (f.shape === 'phrase') { said.push(`${f.name}: ${f.phrase}`); return; }
+      const v = given && Object.hasOwn(given, f.name) ? given[f.name] : undefined;
+      // a JSON number is the value as written ("389"): converted, never repaired; anything else is left for bareguard to red
+      const s = typeof v === 'number' && Number.isFinite(v) ? String(v) : v;
+      if (typeof s === 'string') { values[`d${j}`] = s; said.push(`${f.name}: ${s}`); } else if (s !== undefined) { /** @type {any} */ (values)[`d${j}`] = s; }
+    });
+    return { claim: said.join('; '), quote: isRec(r) && typeof r.quote === 'string' ? r.quote : '', values };
+  });
+}
+
+/** @param {unknown} n @param {string} shape @param {any} f @returns {string} one bound, as the person would say it */
+function sayBound(n, shape, f) {
+  if (shape === 'money') return f.unit !== undefined ? `${n} ${f.unit}` : `${f.currency}${n}`;
+  return String(n);
+}
+
+/** @param {any} f a fact with a rule @returns {string} the rule in words, e.g. "at most 450 US dollars" */
+function ruleWords(f) {
+  const r = f.rule;
+  return r.op === 'between' ? `between ${sayBound(r.lo, f.shape, f)} and ${sayBound(r.hi, f.shape, f)}`
+    : `${{ lt: 'under', lte: 'at most', gt: 'over', gte: 'at least' }[/** @type {'lt'|'lte'|'gt'|'gte'} */ (r.op)]} ${sayBound(r.value, f.shape, f)}`;
+}
+
+/**
+ * One fact as a plain row, written by code from the signed fields:
+ * `fact · price — money, at most 450 US dollars, after "Price", quoted from "Flights"`.
+ * @param {any} f @param {string} source
+ * @returns {string}
+ */
+export function factSentence(f, source) {
+  /** @type {string[]} */
+  const bits = [];
+  if (f.shape === 'phrase') bits.push('phrase', `must say "${f.phrase}"`);
+  else {
+    bits.push(f.shape === 'money' ? `money in ${f.unit !== undefined ? f.unit : f.currency}` : f.shape);
+    if (f.rule) bits.push(ruleWords(f));
+    else if (f.anchor === undefined) bits.push('as the quote writes it');
+    if (f.anchor !== undefined) bits.push(f.until !== undefined ? `the words after "${f.anchor}" up to "${f.until}"` : `after "${f.anchor}"`);
+  }
+  bits.push(`quoted from "${source}"`);
+  return `fact · ${f.name} — ${bits.join(', ')}${f.aiProposal ? ' — AI\'s proposal — check it' : ''}`;
+}
+
+/**
+ * One fact as the WORKER is told it (item 7): what to write for it and where in the quote it sits, in plain words, from the signed
+ * fields. A phrase fact has no value to write — the quote has to say it.
+ * @param {any} f @returns {string}
+ */
+export function factBrief(f) {
+  if (f.shape === 'phrase') return `${f.name} — no value to write; the quote you copy must say "${f.phrase}"`;
+  /** @type {string[]} */
+  const bits = [f.shape === 'money' ? `an amount in ${f.unit !== undefined ? f.unit : f.currency}` : `a ${f.shape}`];
+  if (f.shape === 'text') bits[0] = 'words';
+  if (f.anchor !== undefined) bits.push(f.until !== undefined ? `the words right after "${f.anchor}" up to "${f.until}"` : `right after "${f.anchor}"`);
+  if (f.rule) bits.push(`must be ${ruleWords(f)}`);
+  return `${f.name} — ${bits.join(', ')}`;
+}
+
+/** the "N results" row of a fact part, or null @param {any} part @returns {string|null} */
+export function countSentence(part) {
+  const c = isRec(part.count) ? part.count : null;
+  if (!c) return null;
+  const n = (/** @type {number} */ v) => `${v} result${v === 1 ? '' : 's'}`;
+  if (c.min !== undefined && c.max !== undefined) return c.min === c.max ? `fact · results — exactly ${n(c.min)}, each quoted from "${part.source}"` : `fact · results — ${c.min} to ${c.max} results, each quoted from "${part.source}"`;
+  return c.min !== undefined ? `fact · results — at least ${n(c.min)}, each quoted from "${part.source}"` : `fact · results — at most ${n(c.max)}, each quoted from "${part.source}"`;
+}
+
+/**
+ * Every plan-card row a fact part carries: its facts, then its count.
+ * @param {any} part @returns {string[]}
+ */
+export function factRows(part) {
+  const rows = (Array.isArray(part.facts) ? part.facts : []).map((/** @type {any} */ f) => factSentence(f, part.source));
+  const c = countSentence(part);
+  return [...rows, ...(c ? [c] : [])];
+}
+
+/**
+ * One bareguard `cited` item (`#<result>:d<j>:<reason>[:<detail>]`, or `#<result>:<reason>`) as a sentence the worker can act
+ * on. The names and numbers are bareguard's measurements and the person's signed facts, never inferred here.
+ * @param {string} item @param {any} part @returns {string}
+ */
+export function plainFactItem(item, part) {
+  const m = /^#(\d+):(?:d(\d+):)?([a-z-]+)(?::([\s\S]*))?$/.exec(item);
+  if (!m) return item;
+  const at = `result ${Number(m[1]) + 1}`;
+  const f = m[2] !== undefined && Array.isArray(part.facts) ? part.facts[Number(m[2])] : null;
+  const who = f ? `${at}, fact "${f.name}"` : at;
+  const detail = m[4] ?? '';
+  const say = (/** @type {string} */ s) => `${who}: ${s}`;
+  switch (m[3]) {
+    case 'quote-not-found': return `${at}: the quote is not found word for word in "${part.source}"`;
+    case 'empty-quote': return `${at}: the quote is empty — copy the words from "${part.source}" that hold the facts`;
+    case 'quote-too-long': return `${at}: the quote is too long — copy only that one result's own words, not more`;
+    case 'numbers': return `${at}: the number ${detail} is not in the quote the way the value writes it — write each value as the quote writes it (for example "9:27 AM", not "09:27")`;
+    case 'value-over': case 'value-under': return say(`the value in the quote is ${m[3] === 'value-over' ? 'above' : 'below'} what the rule allows${f && f.rule ? ` (${ruleWords(f)})` : ''}`);
+    case 'value-none': return say(`the quote holds no ${f ? f.shape : 'value'}${f && f.anchor !== undefined ? ` after "${f.anchor}"` : ''}`);
+    case 'value-many': return say(`the quote holds more than one ${f ? f.shape : 'value'} — quote only the words that hold this one`);
+    case 'value-malformed': return say(`a ${f ? f.shape : 'value'} in the quote is not written in a form the check can read`);
+    case 'anchor-missing': return say(`the label "${f ? f.anchor : ''}" is not in the quote`);
+    case 'anchor-ambiguous': return say(`the label "${f ? f.anchor : ''}" is in the quote more than once`);
+    case 'until-missing': return say(`"${f ? f.until : ''}" does not follow the label "${f ? f.anchor : ''}" in the quote`);
+    case 'phrase-missing': return say(`the quote does not say "${detail}"`);
+    case 'claim-value-missing': return say('no value was given in "values"');
+    case 'claim-value-malformed': return say('the value is not written as a value of this kind');
+    case 'claim-value-absent': return say('the value is not in the quote as a whole word');
+    case 'claim-value-unknown': return say('this value is not one of the signed facts');
+    case 'claim-value-mismatch': return say(`the value is not what the quote holds (${detail.replace('!=', ' is not ')})`);
+    default: return `${who}: ${m[3]}${detail ? ` ${detail}` : ''}`;
+  }
+}
+
+// ── which shape takes which fields (live fix B2) ─────────────────────────────────────────────────────────────────────────────
+//
+// The drafter put `until` on a money fact and `anchor`/`until`/`rule` on a phrase (smv6k6l8dxkzs). What a shape takes is bareguard's
+// to say, so the table the drafter is shown is READ OFF `rubricVocabulary` (the `cited` rule's decide shapes and their stated
+// conditions), never hand-typed. If bareguard's wording of a condition changes so that it cannot be read, this throws at load time
+// and the test that pins it fails: a stale guide is never shown quietly.
+
+/**
+ * The fields each fact shape takes, in the fact part's own names (`rule` = bareguard's op/value/lo/hi; `unit`/`currency`; `phrase`
+ * = the presence decide's phrases), read off bareguard's rubric vocabulary.
+ * @returns {Record<string, string[]>} shape -> the fields it takes besides name and shape
+ */
+export function factShapeFields() {
+  const decides = /** @type {any} */ (rubricVocabulary).rules?.cited?.fields?.decides?.shapes;
+  const value = decides?.value;
+  const presence = decides?.presence;
+  const kinds = /** @type {string[]} */ (value?.fields?.valueKind?.enum);
+  /** @type {string[]} */
+  const conditions = value?.conditions ?? [];
+  const find = (/** @type {RegExp} */ re) => {
+    for (const c of conditions) { const m = re.exec(c); if (m) return m; }
+    throw new Error(`bareguard's rubric vocabulary no longer states the condition ${re} — update src/facts.js factShapeFields`);
+  };
+  if (!Array.isArray(kinds) || !presence?.fields?.phrases) throw new Error('bareguard\'s rubric vocabulary has no cited decide shapes — update src/facts.js factShapeFields');
+  const bindOnlyKind = find(/^valueKind (\w+) is bind-only: it refuses op, value, lo, hi, currency and unit/)[1];
+  const untilKind = find(/^until is allowed only on a (\w+) decide that also signs an anchor/)[1];
+  const moneyKind = find(/^(\w+) needs (?:exactly|at least) one of currency or unit/)[1];
+  /** @type {Record<string, string[]>} */
+  const out = {};
+  for (const k of kinds) {
+    /** @type {string[]} */
+    const f = [];
+    if (k !== bindOnlyKind) f.push('rule');
+    if (value.fields.anchor) f.push('anchor');
+    if (k === untilKind) f.push('until');
+    if (k === moneyKind) f.push('unit or currency');
+    out[k] = f;
+  }
+  out.phrase = ['phrase'];
+  return out;
+}
+
+/**
+ * The lines the drafter is shown about which shape takes which fields, generated from {@link factShapeFields} (shapes with the same
+ * fields are listed together). One owner: the composer brief and the confirm note both print this.
+ * @returns {string}
+ */
+export function factShapeGuide() {
+  const by = factShapeFields();
+  /** @type {Map<string, string[]>} */
+  const groups = new Map();
+  for (const shape of FACT_SHAPES) {
+    const key = (by[shape] ?? []).join(' | ');
+    groups.set(key, [...(groups.get(key) ?? []), shape]);
+  }
+  const all = [...new Set(Object.values(by).flat())];
+  const lines = [];
+  for (const [key, shapes] of groups) {
+    const takes = key === '' ? [] : key.split(' | ');
+    const never = all.filter((f) => !takes.includes(f));
+    lines.push(`${shapes.join(' / ')}: takes ${takes.length ? takes.join(', ') : 'no extra field'}${never.length ? `; never ${never.join(', ')}` : ''}`);
+  }
+  return lines.map((l) => ` - ${l}`).join('\n');
+}

package/src/factwords.js

@@ -0,0 +1,129 @@
+// THE FOUND-ONCE CHECK (PART 1c, docs/product/ITEM33-BUILD.md "3. The look", PRD item 33 RF20): code proves, at $0, that every word a fact
+// check depends on is really in the person's source - ONCE is enough - and that every label (anchor) is one PICKED from the list code
+// made from that source (src/labelscan.js), never typed. A word that is not found is a red naming the word and the input. Nothing is
+// graded here and no model is involved: the AI proposes the words, code proves they are there.
+//
+// Compared WHITE-SPACE BLIND: any run of white space (U+202F and U+00A0 included - Google writes U+202F before AM/PM, 259 times in one
+// page) is one space on both sides.
+
+import { labelOnList, normLabel, scanLabels } from './labelscan.js';
+
+const WS = /[\s   ]+/g;
+const escapeRe = (/** @type {string} */ s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/** @param {string} t @returns {string} the source with every run of white space made one space */
+export const squash = (t) => String(t ?? '').replace(WS, ' ');
+/** @param {string} t @returns {string} lower case, markdown marks dropped, white space squashed - how a phrase or unit is compared */
+const loose = (t) => squash(t).replace(/[*_`]/g, '').trim().toLowerCase();
+
+/**
+ * How many times exact words occur in a source, white space blind. Zero for empty words.
+ * @param {string} source the raw source text @param {string} words
+ * @returns {number}
+ */
+export function countExact(source, words) {
+  const w = squash(words).trim();
+  if (w === '') return 0;
+  const hay = squash(source);
+  let n = 0;
+  for (let i = hay.indexOf(w); i !== -1; i = hay.indexOf(w, i + w.length)) n += 1;
+  return n;
+}
+
+/**
+ * How many times a phrase or unit occurs as WHOLE words, case and spacing aside ("SFO" is not found inside "sfocus").
+ * @param {string} source @param {string} words @returns {number}
+ */
+export function countPhrase(source, words) {
+  const w = loose(words);
+  if (w === '') return 0;
+  const re = new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRe(w)}(?=$|[^\\p{L}\\p{N}])`, 'gu');
+  let n = 0;
+  for (const _m of loose(source).matchAll(re)) n += 1;
+  return n;
+}
+
+/** @param {string} shape @returns {'money'|'number'|'date'|'time'|'text'} the label list a fact's anchor is picked from */
+const listOf = (shape) => /** @type {any} */ (['money', 'number', 'date', 'time'].includes(shape) ? shape : 'text');
+
+/**
+ * The reds for ONE fact part against its frozen source text.
+ * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan}} o
+ * @returns {{code: string, detail: string}[]}
+ */
+export function checkFactWords({ part, text, line, scan = scanLabels(text) }) {
+  /** @type {{code: string, detail: string}[]} */
+  const reds = [];
+  const src = part.source;
+  const red = (/** @type {string} */ code, /** @type {string} */ msg) => reds.push({ code, detail: `line ${line}: ${msg} Nothing was signed.` });
+  for (const f of Array.isArray(part.facts) ? part.facts : []) {
+    const who = `fact "${f.name}"`;
+    if (f.anchor !== undefined && f.shape !== 'phrase') {
+      const list = listOf(f.shape);
+      const row = labelOnList(scan, list, f.anchor);
+      if (!row) {
+        const some = scan[list].slice(0, 12).map((r) => JSON.stringify(r.label)).join(', ');
+        red('rubric-fact-label-off-list', `${who}: the label ${JSON.stringify(normLabel(String(f.anchor)))} is not one of the labels the input "${src}" holds before a ${f.shape === 'text' ? 'text value' : f.shape}. A label is picked from that list, never typed${some ? `: ${some}` : ' (the list is empty - leave the label out)'}.`);
+      } else if (countExact(text, row.label) < 1) {
+        red('rubric-fact-word-missing', `${who}: the label ${JSON.stringify(row.label)} is not in the input "${src}".`);
+      } else if (Number.isInteger(part.count?.min) && row.count < part.count.min) {
+        // M1: a label that starts each result must repeat as often as results were asked for; one that sits once on the page
+        // (a sort tab, a switch) is in no result, so no one-result quote can hold it
+        const n = part.count.min;
+        red('rubric-fact-label-rare', `${who}: the label ${JSON.stringify(row.label)} is in the input "${src}" only ${row.count} time${row.count === 1 ? '' : 's'}, but this line asks for ${n} results, so a label that sits in each result must be there at least ${n} times. Pick a label from the list that is counted ${n} or more times.`);
+      }
+    }
+    if (f.until !== undefined && countExact(text, f.until) < 1) red('rubric-fact-word-missing', `${who}: ${JSON.stringify(f.until)} is not in the input "${src}". Copy the closing words from the input, or leave them out.`);
+    if (f.shape === 'phrase' && typeof f.phrase === 'string') {
+      const seen = countPhrase(text, f.phrase);
+      if (seen < 1) red('rubric-fact-word-missing', `${who}: ${JSON.stringify(f.phrase)} is not in the input "${src}". Copy the words the input really uses, or remove the check.`);
+      else if (Number.isInteger(part.count?.min) && seen < part.count.min) {
+        // M4: the words each result's quote must say must repeat as often as results were asked for; page-header words (counted
+        // once or twice) are in no result, so no one-result quote can say them
+        const n = part.count.min;
+        red('rubric-fact-phrase-rare', `${who}: the words ${JSON.stringify(f.phrase)} are in the input "${src}" only ${seen} time${seen === 1 ? '' : 's'}, but this line asks for ${n} results - each result's own quote must say them. Pick words every result says, or drop this check.`);
+      }
+    }
+    if (typeof f.unit === 'string' && countPhrase(text, f.unit) < 1) red('rubric-fact-word-missing', `${who}: the unit ${JSON.stringify(f.unit)} is not in the input "${src}". Copy the words the input really uses.`);
+  }
+  return reds;
+}
+
+/**
+ * The reds for every fact part of a declaration. A fact part whose input text is not at hand is a red: a check whose words were never
+ * proved against the source is never signed.
+ * @param {any} declaration @param {Record<string, string>|null} texts label -> frozen text
+ * @returns {{code: string, path: string, detail: string}[]}
+ */
+export function checkDeclarationWords(declaration, texts) {
+  /** @type {{code: string, path: string, detail: string}[]} */
+  const reds = [];
+  if (!declaration || !Array.isArray(declaration.stages)) return reds;
+  /** @type {Map<string, import('./labelscan.js').LabelScan>} */
+  const scans = new Map();
+  declaration.stages.forEach((/** @type {any} */ st, /** @type {number} */ i) => {
+    const parts = st?.kind === 'rubric-step' && Array.isArray(st.params?.parts) ? st.params.parts : [];
+    parts.forEach((/** @type {any} */ p, /** @type {number} */ k) => {
+      if (p?.class !== 'fact') return;
+      const at = `stages[${i}].params.parts[${k}]`;
+      const text = texts ? texts[p.source] : undefined;
+      /** @param {string} code @param {string} detail */
+      const red = (code, detail) => reds.push({ code, path: at, detail });
+      if (typeof text !== 'string') {
+        red('rubric-fact-unread', `line ${st.params.step}: the input "${p.source}" could not be read here to prove the words against it. Nothing was signed.`);
+        return;
+      }
+      if (!scans.has(p.source)) scans.set(p.source, scanLabels(text));
+      for (const r of checkFactWords({ part: p, text, line: st.params.step, scan: scans.get(p.source) })) reds.push({ code: r.code, path: at, detail: r.detail });
+    });
+  });
+  return reds;
+}
+
+/**
+ * The look's own proof hook: how often a phrase the look built is in an input.
+ * @param {Record<string, string>} texts @returns {(source: string, phrase: string) => number}
+ */
+export function proverOf(texts) {
+  return (source, phrase) => (typeof texts[source] === 'string' ? countPhrase(texts[source], phrase) : 0);
+}

package/src/index.js

@@ -148,16 +148,14 @@ export { answerReviewDoor } from './reviewdoor.js';
 // SOFTGREEN module 1 — the judged floor's core. The pieces an adopter (and an
 // integrating UI) genuinely needs: `resolveJudge` (PRD item 32.1 — WHICH model
 // grades a job: the spec's signed `judge` override, else the job's own worker
-// model, and no library fall-back), `JUDGE_MODEL` (the pre-item-32 pin, kept
-// exported for adopters and still the right default for an anthropic-api job,
-// but no longer read by any grading path), the rulebook a card SELECTS from,
+// model, and no library fall-back; the old pinned-model constant is gone), the rulebook a card SELECTS from,
 // the card gate, and the two halves themselves so a calibration harness can
 // grade the whole pipe without running a close.
 // `defaultJudgeLoop` (src/judged.js) is the one spelling of how this repo drives a
 // judge; the runner reaches it through `runPlan`'s `judgeProvider`. It is internal:
 // the package root does not export it.
 export {
-  JUDGE_MODEL, resolveJudge, JUDGE_RULES, JUDGE_RULE_IDS,
+  resolveJudge, JUDGE_RULES, JUDGE_RULE_IDS,
   runLocate, decide,
   // SOFTGREEN module 4 — what a legal SIGNED calibration set is. The SIZE is
   // hamr's own ruling and a size change is a spec-level threshold change;