bareloop 0.43.0 → 0.44.0

package/src/draftspend.js

@@ -25,6 +25,8 @@ export const DRAFT_LOG_FILE = 'draft-log.jsonl';
  *  - `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" / "can't change it" / "not confirmed")
+ *  - `human`       {no, source: 'confirm'|'try-3'|'look', question, answer, line?, at}: one question the person was asked and what they answered (the answer is secret-masked
+ *    before it is written; the row is written only when BOTH exist, so a question nobody answered leaves no row)
  *  - `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)
@@ -126,12 +128,26 @@ export function sessionDirForRow(row, opts = {}) {
   return null;
 }
 
+/**
+ * PRD v1.106 Part 5 Q1: one answered question as the two lines the Audit's drafting table shows under its step. ONE place owns the words.
+ * @param {{question: string, answer: string, source?: string, line?: number, at?: string}} h
+ * @returns {{question: string, answer: string, source: string, line?: number, at?: string, askedText: string, saidText: string}}
+ */
+export function humanRowWords(h) {
+  return {
+    question: h.question, answer: h.answer, source: typeof h.source === 'string' ? h.source : 'confirm',
+    ...(Number.isInteger(h.line) ? { line: h.line } : {}), ...(h.at ? { at: h.at } : {}),
+    askedText: `you were asked: ${h.question}`, saidText: `you said: ${h.answer}`,
+  };
+}
+
 /**
  * Fold `<dir>/draft-log.jsonl` into one record per drafting step, each with its calls. A line that cannot be parsed is
  * skipped (a torn last line must not hide the rest).
  * @param {string} dir
  * @returns {{no: number, id: string, label: string, status: 'running'|'done'|'failed', startedAt: string, endedAt: string|null, wallMs: number|null,
- *   calls: {label: string, model: string|null, costUsd: number|null, unpricedRounds: number, at: string}[]}[]}
+ *   calls: {label: string, model: string|null, costUsd: number|null, unpricedRounds: number, at: string}[],
+ *   humans: ReturnType<typeof humanRowWords>[]}[]}
  */
 export function readDraftSteps(dir) {
   /** @type {string} */
@@ -145,7 +161,7 @@ export function readDraftSteps(dir) {
     try { ev = JSON.parse(line); } catch { continue; }
     if (!ev || typeof ev !== 'object' || !Number.isInteger(ev.no)) continue;
     if (ev.kind === 'step-start') {
-      byNo.set(ev.no, { no: ev.no, id: String(ev.id), label: String(ev.label), status: 'running', startedAt: ev.at, endedAt: null, wallMs: null, calls: [] });
+      byNo.set(ev.no, { no: ev.no, id: String(ev.id), label: String(ev.label), status: 'running', startedAt: ev.at, endedAt: null, wallMs: null, calls: [], humans: [] });
     } else if (ev.kind === 'step-end' && byNo.has(ev.no)) {
       const x = byNo.get(ev.no);
       x.status = ev.status === 'failed' ? 'failed' : 'done';
@@ -157,6 +173,8 @@ export function readDraftSteps(dir) {
       const x = byNo.get(ev.no);
       x.status = 'running';
       x.endedAt = null;
+    } else if (ev.kind === 'human' && byNo.has(ev.no) && typeof ev.question === 'string' && typeof ev.answer === 'string') {
+      byNo.get(ev.no).humans.push(humanRowWords({ question: ev.question, answer: ev.answer, source: ev.source, ...(Number.isInteger(ev.line) ? { line: ev.line } : {}), at: ev.at }));
     } else if (ev.kind === 'call') {
       const c = { label: String(ev.label), model: typeof ev.model === 'string' ? ev.model : null, costUsd: typeof ev.costUsd === 'number' ? ev.costUsd : null, unpricedRounds: Number(ev.unpricedRounds) || 0, at: String(ev.at) };
       byNo.get(ev.no)?.calls.push(c);

package/src/facts.js

@@ -24,6 +24,22 @@ 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}$/;
 
+/** the limits bareguard 0.24 puts on a money fact's lists (ruling #65), enforced here first so the red is ours and plain */
+export const MAX_CURRENCIES = 3;
+export const MAX_UNITS = 10;
+export const MAX_UNIT_CHARS = 100;
+const CURRENCY_SIGNS = ['$', '€', '£'];
+
+/**
+ * A money fact's `unit` / `currency` is ONE string (every spec signed before lists) or a non-empty list of them; a string is read exactly as a
+ * one-element list. Nothing is rewritten, so an old spec's bytes and hash stay as they were.
+ * @param {unknown} v @returns {string[]}
+ */
+export const asList = (v) => (Array.isArray(v) ? v.map(String) : (typeof v === 'string' ? [v] : []));
+
+/** @param {any} f a money fact @returns {string[]} every form the page writes the amount in: the units first (as R1L reads them), then the currency signs */
+export const moneyForms = (f) => [...asList(f.unit), ...asList(f.currency)];
+
 /** @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} */
@@ -36,7 +52,7 @@ export function factPartOf(params) {
 }
 
 /** @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 !== '');
+export 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
@@ -72,10 +88,27 @@ export function factShapeReds(part, w, red) {
       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 "£")');
+        if (!has('unit') && !has('currency')) red('invalid-value', `${fw}.unit`, 'money names at least one of unit (words the input writes after the amount, e.g. "US dollars") or currency ("$", "€" or "£"); each may be one value or a list');
       } 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 (has('unit')) {
+        const us = f.unit;
+        if (Array.isArray(us) ? us.length === 0 || us.some((/** @type {unknown} */ u) => !nonEmpty(u)) : !nonEmpty(us)) red('invalid-value', `${fw}.unit`, 'a non-empty string copied from the input, or a non-empty list of them');
+        else {
+          const list = asList(us);
+          if (list.length > MAX_UNITS) red('invalid-value', `${fw}.unit`, `at most ${MAX_UNITS} units (${list.length} given)`);
+          else if (list.some((u) => u.length > MAX_UNIT_CHARS)) red('invalid-value', `${fw}.unit`, `a unit is at most ${MAX_UNIT_CHARS} characters`);
+          else if (new Set(list).size !== list.length) red('invalid-value', `${fw}.unit`, 'the units are not repeated');
+        }
+      }
+      if (has('currency')) {
+        const cs = f.currency;
+        if (Array.isArray(cs) ? cs.length === 0 || cs.some((/** @type {unknown} */ c) => !CURRENCY_SIGNS.includes(/** @type {string} */ (c))) : !CURRENCY_SIGNS.includes(cs)) red('invalid-value', `${fw}.currency`, 'one of $ | € | £, or a list of them');
+        else {
+          const list = asList(cs);
+          if (list.length > MAX_CURRENCIES) red('invalid-value', `${fw}.currency`, `at most ${MAX_CURRENCIES} currencies (${list.length} given)`);
+          else if (new Set(list).size !== list.length) red('invalid-value', `${fw}.currency`, 'the currencies are not repeated');
+        }
+      }
       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');
@@ -112,7 +145,7 @@ export function factDecides(part) {
     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.shape === 'money') { if (f.unit !== undefined) d.unit = f.unit; if (f.currency !== undefined) d.currency = f.currency; }
     if (f.anchor !== undefined) d.anchor = f.anchor;
     if (f.until !== undefined) d.until = f.until;
     if (f.rule) {
@@ -151,12 +184,24 @@ export function factClaims(part, results) {
 
 /** @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}`;
+  if (shape === 'money') return moneyAs(f, /** @type {string|number} */ (n), false);
   return String(n);
 }
 
+/**
+ * One amount of a money fact in the fact's OWN signed forms, never a hardcoded sign: `symbolFirst` puts the currency sign before the amount
+ * ("$144") when the fact has one, else the unit after it ("144 US dollars"); not `symbolFirst` (a rule's bound) prefers the unit.
+ * @param {any} f a money fact @param {string|number} n @param {boolean} symbolFirst @returns {string}
+ */
+export function moneyAs(f, n, symbolFirst) {
+  const cur = asList(f.currency)[0];
+  const uni = asList(f.unit)[0];
+  if (symbolFirst) return cur !== undefined ? `${cur}${n}` : `${n} ${uni}`;
+  return uni !== undefined ? `${n} ${uni}` : `${cur}${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) {
+export 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)}`;
@@ -173,7 +218,7 @@ export function factSentence(f, source) {
   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);
+    bits.push(f.shape === 'money' ? `money in ${moneyForms(f).join(' or ')}` : 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}"`);
@@ -190,7 +235,7 @@ export function factSentence(f, source) {
 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}`];
+  const bits = [f.shape === 'money' ? `an amount in ${moneyForms(f).join(' or ')}` : `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)}`);

package/src/factwords.js

@@ -7,6 +7,8 @@
 // page) is one space on both sides.
 
 import { labelOnList, normLabel, scanLabels } from './labelscan.js';
+import { asList } from './facts.js';
+import { dropSentence } from './pagedropwords.js';
 
 const WS = /[\s   ]+/g;
 const escapeRe = (/** @type {string} */ s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -46,19 +48,63 @@ export function countPhrase(source, words) {
 /** @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');
 
+
+/**
+ * What the page-word map (src/pagemap.js) KEPT and DROPPED for one input: the sets the second proof reads. A look from the old search-and-read
+ * path has no `dropped` list, so it gives null and the label is proved against the code-made list as before.
+ * @param {{facts?: any[], dropped?: (import('./pagerules.js').Dropped & {source?: string})[]}|null|undefined} look @param {string} source
+ * @returns {{labels: Set<string>, units: Set<string>, currencies: Set<string>, words: Set<string>, dropped: Map<string, import('./pagerules.js').Dropped>}|null}
+ */
+export function keptSetOf(look, source) {
+  if (!look || !Array.isArray(look.dropped)) return null;
+  const facts = (Array.isArray(look.facts) ? look.facts : []).filter((f) => f && f.source === source && Array.isArray(f.words));
+  const set = (/** @type {string[]} */ a) => new Set(a.map((w) => normLabel(String(w))));
+  /** @type {Map<string, import('./pagerules.js').Dropped>} */
+  const dropped = new Map();
+  for (const d of look.dropped) if (d.source === source && typeof d.word === 'string' && !dropped.has(normLabel(d.word))) dropped.set(normLabel(d.word), d);
+  return {
+    labels: set(facts.filter((f) => f.shape !== 'phrase').flatMap((f) => f.words)),
+    units: set(facts.flatMap((f) => f.unit ?? [])),
+    currencies: set(facts.flatMap((f) => f.currency ?? [])),
+    words: set(facts.flatMap((f) => [...f.words, ...(f.unit ?? []), ...(f.currency ?? [])])),
+    dropped,
+  };
+}
+
 /**
  * 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
+ * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan, kept?: ReturnType<typeof keptSetOf>}} o
  * @returns {{code: string, detail: string}[]}
  */
-export function checkFactWords({ part, text, line, scan = scanLabels(text) }) {
+export function checkFactWords({ part, text, line, scan = scanLabels(text), kept = null }) {
   /** @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') {
+    // a word the page rules DROPPED (and no other fact kept) can never come back through the drafter (idea A core, spec 4.3)
+    const dropRed = (/** @type {string} */ what, /** @type {unknown} */ w) => {
+      const n = normLabel(String(w));
+      const d = kept?.dropped.get(n);
+      if (!kept || !d || kept.words.has(n)) return false;
+      red('rubric-fact-word-dropped', `${who}: the ${what} ${JSON.stringify(n)} cannot be used. ${dropSentence(d)}`);
+      return true;
+    };
+    if (f.anchor !== undefined && f.shape !== 'phrase' && kept) {
+      // a page input read by the page-word map: the label must be one the map KEPT (the code-made list cannot hold a marker after a number)
+      const label = normLabel(String(f.anchor));
+      if (dropRed('label', f.anchor)) { /* said above */ } else if (!kept.labels.has(label)) {
+        const some = [...kept.labels].slice(0, 12).map((l) => JSON.stringify(l)).join(', ');
+        red('rubric-fact-label-off-list', `${who}: the label ${JSON.stringify(label)} is not one of the labels the page words for "${src}" kept. A label is picked from those, never typed${some ? `: ${some}` : ' (there are none - leave the label out)'}.`);
+      } else if (countExact(text, label) < 1) {
+        red('rubric-fact-word-missing', `${who}: the label ${JSON.stringify(label)} is not in the input "${src}".`);
+      } else if (Number.isInteger(part.count?.min) && countExact(text, label) < part.count.min) {
+        const n = part.count.min;
+        const seen = countExact(text, label);
+        red('rubric-fact-label-rare', `${who}: the label ${JSON.stringify(label)} is in the input "${src}" only ${seen} time${seen === 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 that is counted ${n} or more times.`);
+      }
+    } else if (f.anchor !== undefined && f.shape !== 'phrase') {
       const list = listOf(f.shape);
       const row = labelOnList(scan, list, f.anchor);
       if (!row) {
@@ -73,6 +119,7 @@ export function checkFactWords({ part, text, line, scan = scanLabels(text) }) {
         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) dropRed('closing label', f.until);
     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);
@@ -84,7 +131,11 @@ export function checkFactWords({ part, text, line, scan = scanLabels(text) }) {
         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.`);
+    // a unit (one string, or every one of a list) must be found as whole words; a currency sign (each of a list) must be found as written
+    for (const u of asList(f.unit)) dropRed('unit', u);
+    for (const c of asList(f.currency)) dropRed('currency', c);
+    for (const u of asList(f.unit)) if (countPhrase(text, u) < 1) red('rubric-fact-word-missing', `${who}: the unit ${JSON.stringify(u)} is not in the input "${src}". Copy the words the input really uses.`);
+    for (const c of asList(f.currency)) if (countExact(text, c) < 1) red('rubric-fact-word-missing', `${who}: the currency ${JSON.stringify(c)} is not in the input "${src}". Copy the sign the input really uses.`);
   }
   return reds;
 }
@@ -93,9 +144,10 @@ export function checkFactWords({ part, text, line, scan = scanLabels(text) }) {
  * 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
+ * @param {{facts?: any[], dropped?: any[]}|null} [look] the page-word map's report: what it kept and dropped (null = no map, the code-made list is the proof)
  * @returns {{code: string, path: string, detail: string}[]}
  */
-export function checkDeclarationWords(declaration, texts) {
+export function checkDeclarationWords(declaration, texts, look = null) {
   /** @type {{code: string, path: string, detail: string}[]} */
   const reds = [];
   if (!declaration || !Array.isArray(declaration.stages)) return reds;
@@ -114,7 +166,7 @@ export function checkDeclarationWords(declaration, texts) {
         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 });
+      for (const r of checkFactWords({ part: p, text, line: st.params.step, scan: scans.get(p.source), kept: keptSetOf(look, p.source) })) reds.push({ code: r.code, path: at, detail: r.detail });
     });
   });
   return reds;

package/src/inputlook.js

@@ -11,6 +11,7 @@
 import { scanLabels, labelOnList, renderLabelList, normLabel, LABEL_SHAPES } from './labelscan.js';
 import { FACT_SHAPES, FACT_OPS } from './facts.js';
 import { lineRules } from './rubricstep.js';
+import { dropRows, dropLine } from './pagedropwords.js';
 
 /** the name of the answer tool - the one place the AI's report enters */
 export const LOOK_REPORT_TOOL = 'report_look';
@@ -149,13 +150,31 @@ export function lookPrompt({ jobLines, labels, lists }) {
     + `Report only through ${LOOK_REPORT_TOOL}.`;
 }
 
-/** @typedef {{line: number, name: string, shape: string, source: string, label?: string, labelId?: string, value?: string, phrase?: string, example: string, rule?: any, aiProposal?: boolean, forRule?: number}} LookFact */
+/** @typedef {{line: number, name: string, shape: string, source: string, label?: string, labelId?: string, value?: string, phrase?: string, example: string, rule?: any, aiProposal?: boolean, forRule?: number, reading?: import('./pagerules.js').Reading,
+ *   words?: string[], labels?: string[], unit?: string[], currency?: string[]}} LookFact  `words` / `labels` / `unit` / `currency`: what the page-word map kept (idea A core) */
 /** @typedef {{line: number, rule?: number, words?: string, why: string}} LookNotFound */
-/** @typedef {{facts: LookFact[], prose: {line: number, text?: string}[], notFound: LookNotFound[]}} LookReport */
+/** @typedef {{facts: LookFact[], prose: {line: number, text?: string}[], notFound: LookNotFound[], dropped?: import('./pagerules.js').Dropped[]}} LookReport */
 
 /** @param {unknown} v @returns {v is Record<string, any>} */
 const isRec = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
 
+/**
+ * A fact the page-word map kept (src/pagerules.js `KeptFact`), as the look report carries it: a phrase fact holds its alternative
+ * phrases; any other holds its labels (the first is the primary), and a money fact its units and currencies.
+ * @param {import('./pagerules.js').KeptFact} k @param {string} source @returns {LookFact}
+ */
+export function lookFactOf(k, source) {
+  /** @type {LookFact} */
+  const out = { line: k.line, name: k.name, shape: k.shape, source, example: '', words: [...k.words] };
+  if (k.shape === 'phrase') out.phrase = k.words[0];
+  else { out.labels = [...k.words]; if (k.words.length) out.label = k.words[0]; }
+  if (k.unit) out.unit = [...k.unit];
+  if (k.currency) out.currency = [...k.currency];
+  if (k.forRule !== undefined) out.forRule = k.forRule;
+  if (k.reading) out.reading = { ...k.reading };
+  return out;
+}
+
 /**
  * Turn the AI's raw report into a VERIFIED one, by code, at $0. A fact is carried only when: its shape is a real shape, its source is
  * a real input, and its label is ON THE LIST for that input and shape (an id is resolved to its exact words). Anything else is moved
@@ -225,7 +244,17 @@ export function renderLookReport(report) {
   const add = (/** @type {number} */ n, /** @type {string} */ s) => byLine.set(n, [...(byLine.get(n) ?? []), s]);
   for (const f of report.facts) {
     const bits = [`${f.name} - ${f.shape}`, `from "${f.source}"`];
-    if (f.phrase !== undefined) bits.push(`the quote must say ${JSON.stringify(f.phrase)}`);
+    if (Array.isArray(f.words)) {
+      // a fact the page-word map kept (idea A core): the words the page holds, each one proven by code; the first is the main one
+      const quote = (/** @type {string[]|undefined} */ a) => (a ?? []).map((w) => JSON.stringify(w)).join(' or ');
+      if (f.shape === 'phrase') bits.push(`the quote must say ${f.words.length > 1 ? 'ONE of these page words, copied exactly' : 'this page word'}: ${quote(f.words)}`);
+      else {
+        if (f.words.length) bits.push(`label ${quote(f.words)}${f.words.length > 1 ? ' (the first is the main one)' : ''}`);
+        else bits.push('no label (read by its unit or sign alone)');
+        if (f.unit?.length) bits.push(`unit ${quote(f.unit)}`);
+        if (f.currency?.length) bits.push(`currency ${quote(f.currency)}`);
+      }
+    } else if (f.phrase !== undefined) bits.push(`the quote must say ${JSON.stringify(f.phrase)}`);
     else if (f.label !== undefined) bits.push(`label ${JSON.stringify(f.label)} (id ${f.labelId})`);
     else bits.push('no label (the value as the quote writes it)');
     if (f.example) bits.push(`seen: ${JSON.stringify(f.example)}`);
@@ -234,6 +263,12 @@ export function renderLookReport(report) {
     if (f.forRule !== undefined) bits.push(`carries ~ rule ${f.forRule}`);
     add(f.line, `CAN CHECK: ${bits.join(', ')}`);
   }
+  // NO SILENT DROP: a word, fact or rule the page rules removed is said to the drafter too, so it is never written back as a check
+  for (const row of dropRows(report.dropped)) {
+    add(row.line, row.full
+      ? `NOT CHECKED${row.rule !== undefined ? ` (rule ${row.rule})` : ''}: "${row.fact}" - ${row.sentences.join(' ')}`
+      : `LEFT OUT of "${row.fact}" (the rest is still checked): ${row.sentences.join(' ')}`);
+  }
   for (const p of report.prose) add(p.line, 'WRITTEN TEXT (not looked up; keep its word/section counts)');
   for (const n of report.notFound) add(n.line, `NOT FOUND${n.rule ? ` (rule ${n.rule})` : ''}: ${n.words ? `${JSON.stringify(n.words)} - ` : ''}${n.why}`);
   const lines = [...byLine.keys()].sort((a, b) => a - b).map((n) => `line ${n}:\n${byLine.get(n).map((/** @type {string} */ s) => `  ${s}`).join('\n')}`);

package/src/job.js

@@ -345,7 +345,7 @@ export function validateJob(input, { shellCapUsd = 2 } = {}) {
     red('invalid-value', 'model', 'non-empty string — the exact model id of a line ticked in Settings > Providers');
   }
   // THINKING (P8) — the job's "Thinking on" tick, OPTIONAL: absent means off (and an old spec keeps the hash it always had); present it is
-  // signed like `model`. It covers DRAFTING and the rubric JUDGE only — the worker is never handed a thinking option. A boolean, nothing else.
+  // signed like `model`. It covers DRAFTING and the rubric JUDGE, and makes every WORKER call think (src/thinking.js `workerThinkingMode`; without it the worker's mode is decided from phase and attempt). A boolean, nothing else.
   if (spec.thinking !== undefined && typeof spec.thinking !== 'boolean') {
     red('invalid-value', 'thinking', 'true or false — the job\'s "Thinking on" tick (absent = off)');
   }

package/src/kinds.js

@@ -304,6 +304,7 @@ export function mechanicalStages(stages) {
  *   onJudgeCost?: (c: {stage: string|null, kind: string|null, path: string, attempt: number,
  *     label: string, model: string, costUsd: number|null, unpricedRounds: number}) => void,
  *   callBounds?: () => {timeoutMs?: number, deadlineMs?: number},
+ *   onRubricEvidence?: (e: {step: number, evidence: any[], evidenceTotal?: number}) => void,
  *   onStage?: (row: {stage: string|null, kind: string|null, verdict: string, durationMs: number}) => void}} Ctx
  *   The arbiter's half of a stage run. Every field here is operator/runner
  *   territory: a declaration parameterises kinds, never the contracts.
@@ -1593,6 +1594,10 @@ async function runRubricStep(stage, ctx) {
   }
   const graded = await gradeStep({ params: p, bytes: notRegular ? null : bytes, outputBytes: notRegular ? null : bytes, inputs, factQuotes, factMissing }, inputShas);
   if (graded.verdict === 'stopped') return stop(`the rubric stopped: ${graded.fault}`, STOP_FAULTS.CRASHED);
+  // REPORT-ONLY: what each cited check read, handed to the runner's seam (the spine's `rubric-evidence`); nothing below reads it
+  if (graded.evidence && typeof ctx.onRubricEvidence === 'function') {
+    ctx.onRubricEvidence({ step, evidence: graded.evidence, ...(graded.evidenceTotal !== undefined ? { evidenceTotal: graded.evidenceTotal } : {}) });
+  }
   const gap = new Gap(ctx.gapKeep, ctx.gapCap);
   if (notRegular) gap.push(`${stage.name}: line ${step}: ${stepFileRel(step)} is not a regular file`);
   for (const l of graded.gapLines) gap.push(`${stage.name}: ${l}`);

package/src/pagedropwords.js

@@ -0,0 +1,64 @@
+// IDEA A CORE (docs/product/ITEM33-BUILD.md "Addendum 2026-10-18 — Idea A core: build spec", sections 4.6 and 7): NO SILENT DROP. The ONE place
+// that writes the sentence for a word, fact or rule that a page rule dropped. The plan card, the Job tab, the confirm card and the drafter's
+// block all read these words; no other file writes a drop reason (a test greps for it). Plain words, written by CODE from the drop's reason
+// code, never a raw code and never model-written. `<label>` is the page's own word.
+
+/** @typedef {import('./pagerules.js').Dropped} Dropped */
+
+/** reason code -> the plain sentence (`d.word` = the page's word, `d.fact` = the fact's name, `d.other` = what it was compared to) */
+const WORDS = /** @type {Record<string, (d: Dropped) => string>} */ ({
+  'not-on-page': (d) => `"${d.word}" is not written on the page.`,
+  'no-value': (d) => `The page never shows a number right after or right before "${d.word}".`,
+  'n2': (d) => `"${d.word}" is written more than once inside one line of the page, so one result cannot show it once.`,
+  'r1': (d) => `"${d.word}" does not show the same values as "${d.other}", so it was not used as a second way to read it.`,
+  'sign-twice': (d) => `"${d.word}" was listed twice, as a unit and as a currency; it is used once, as the currency.`,
+  'r1l': (d) => d.word === d.other
+    ? `"${d.word}" was listed twice, as a unit and as a currency; it is used once, as the first way to write the price.`
+    : `"${d.word}" does not show the same amounts as "${d.other}", so it was not used as a second way to write the price.`,
+  's1-name': () => 'One result is one record; ask for N results instead.',
+  's1': (d) => `"${d.fact}" would read the same value as "${d.other}". The page gives no second label for it.`,
+  'no-label': (d) => `No word on this page reads "${d.fact}" safely.`,
+  'limit-currency': (d) => `Only the first 3 currencies are used; "${d.word}" was left out.`,
+  'limit-unit': (d) => `Only the first 10 units are used; "${d.word}" was left out.`,
+  'unit-too-long': (d) => `"${d.word}" is longer than 100 characters, so it was not used.`,
+  'currency-not-symbol': (d) => `"${d.word}" is not a currency sign ($, € or £); a word the page writes after the amount is read as a unit.`,
+  'person-left': () => 'You chose to leave it Not checked.',
+  'bad-shape': (d) => `The AI named a kind of value for "${d.fact}" that a check cannot read.`,
+});
+
+/** @param {Dropped} d @returns {string} the plain sentence for one drop */
+export function dropSentence(d) {
+  const f = WORDS[d.reason];
+  return f ? f(d) : `"${d.word ?? d.fact}" was left out.`;
+}
+
+/**
+ * One row per fact that lost something: the sentences (one per dropped word, then the fact's own), and whether the whole fact went.
+ * @param {Dropped[]|undefined|null} dropped
+ * @returns {{line: number, rule?: number, fact: string, full: boolean, sentences: string[]}[]}
+ */
+export function dropRows(dropped) {
+  /** @type {Map<string, {line: number, rule?: number, fact: string, full: boolean, sentences: string[]}>} */
+  const rows = new Map();
+  for (const d of Array.isArray(dropped) ? dropped : []) {
+    const key = `${d.line}\u0000${d.rule ?? ''}\u0000${d.fact}`;
+    let row = rows.get(key);
+    if (!row) { row = { line: d.line, ...(d.rule === undefined ? {} : { rule: d.rule }), fact: d.fact, full: false, sentences: [] }; rows.set(key, row); }
+    if (d.word === undefined) row.full = true;
+    const sentence = dropSentence(d);
+    if (!row.sentences.includes(sentence)) row.sentences.push(sentence);
+  }
+  // a fact's own sentence ("No word ... reads it safely") reads last, after the words that were lost
+  return [...rows.values()].map((r) => ({ ...r, sentences: [...r.sentences.filter((s) => !/^No word on this page reads /.test(s)), ...r.sentences.filter((s) => /^No word on this page reads /.test(s))] }));
+}
+
+/**
+ * A row as one Not-checked line, in the person's own words: `line N: "<the ~ rule as written, or the fact's name>" — <sentences>`.
+ * @param {{line: number, rule?: number, fact: string, sentences: string[]}} row @param {any[]|null|undefined} jobLines @param {(l: any) => string[]} rulesOf
+ * @returns {string}
+ */
+export function dropLine(row, jobLines, rulesOf) {
+  const jl = (jobLines ?? []).find((/** @type {any} */ l) => l && l.n === row.line);
+  const rule = row.rule === undefined || !jl ? undefined : rulesOf(jl)[row.rule - 1];
+  return `line ${row.line}: "${rule ?? row.fact}" — ${row.sentences.join(' ')}`;
+}