bareloop 0.43.0 → 0.45.0

package/src/authorreadout.js

@@ -24,6 +24,7 @@
 // not because they are readouts: the runner is a script, and a rule no test can
 // reach is a rule nothing checks.
 import { scrubRaw } from './text.js';
+import { panelMoney2 } from './panelmoney.js';
 import { redactSecrets } from './validate.js';
 import { judgedStages } from './kinds.js';
 import { CALIBRATION_SIZE } from './judged.js';
@@ -560,11 +561,6 @@ export function plainReasons(reds, { cases = null } = {}) {
   });
 }
 
-/** @param {number} n @returns {string} the panel's money spelling: 2 decimals, "<$0.01" under a cent */
-function moneyText(n) {
-  return n > 0 && n < 0.005 ? '<$0.01' : `$${n.toFixed(2)}`;
-}
-
 /**
  * The money clause: the measured figure, "at least" when a call was unpriced,
  * and `null` when there is no honest figure (the caller then says unknown or
@@ -574,7 +570,7 @@ function moneyText(n) {
  */
 function spendText(spend) {
   if (!spend || typeof spend.knownUsd !== 'number' || !Number.isFinite(spend.knownUsd)) return null;
-  return `${spend.spendComplete === false ? 'at least ' : ''}${moneyText(spend.knownUsd)}`;
+  return `${spend.spendComplete === false ? 'at least ' : ''}${panelMoney2(spend.knownUsd)}`;
 }
 
 /**
@@ -662,6 +658,16 @@ const SCOUT_REASON_RE = /^the survey is [^(]*\((.*)\) — an absent facts/s;
  */
 export function draftStopText({ stop, reds = null, refusal = null, spend = null, wholeJob = false }) {
   const spent = spendText(spend);
+  // PRD v1.107 Part 5b: too many early asks - the code-owned list (every ask and its reading) is the whole message, quoted in full
+  if (stop === 'look-asks-too-many') {
+    const detail = (Array.isArray(reds) ? reds : []).find((r) => r?.code === 'look-asks-too-many')?.detail;
+    if (detail) return `${redactSecrets(String(detail))}\nSpent so far: ${spent ?? 'unknown'}.`;
+  }
+  // F243: the fit check - the page does not show everything the job asks for; the not-found list (the code-made red detail) is the whole reason
+  if (stop === 'fit-stopped') {
+    const detail = (Array.isArray(reds) ? reds : []).find((r) => r?.code === 'fit-stopped')?.detail;
+    if (detail) return `Stopped before drafting: the page does not show everything the job asks for: ${redactSecrets(String(detail))}. Change the job or the page and draft again. Spent so far: ${spent ?? 'unknown'}.`;
+  }
   /** @type {Record<string, string>} */
   const heads = {
     'provider-red': 'The AI provider failed before a usable plan came back — a connection or service fault, not a problem with your job.',

package/src/authorrun.js

@@ -128,6 +128,7 @@ import { resolveProvider, buildRunnerProviders, apiKeyProblem } from './provider
 import { commandFor } from './invoke.js';
 import { readSourceManifest, missingDependencies, nonRepoSourceMessage, isRubricFilesManifest } from './source.js';
 import { tallyCalls } from './text.js';
+import { splitReadNotes } from './pagedropwords.js';
 import {
   declarationLines, rubricLines, calibrationLines, parseCeiling, ceilingLine, crashRecord, phaseLine,
   openQuestionLines, answeredQuestionLines, fellBackLines, PLAIN_PROPOSAL_STOPS, proposalStopText, signingStopText,
@@ -771,9 +772,14 @@ export async function main(argv, deps = {}) {
       for (const c of p.checks ?? []) out(`    · ${c}`);
       out('  protections (always-on guards, never named in the goal):');
       for (const g of p.protections ?? []) out(`    · ${g}`);
-      if ((p.notChecked ?? []).length) {
+      const { notChecked: unchecked, readNotes } = splitReadNotes(p.notChecked, p.signedFacts);
+      if (unchecked.length) {
         out('  you asked for these, but nothing checks them:');
-        for (const n of p.notChecked ?? []) out(`    · ${n}`);
+        for (const n of unchecked) out(`    · ${n}`);
+      }
+      if (readNotes.length) {
+        out(`  how the page was read · ${readNotes.length}:`);
+        for (const n of readNotes) out(`    · ${n}`);
       }
       if ((p.questions ?? []).length) {
         out('  open questions:');

package/src/declaredclose.js

@@ -576,13 +576,14 @@ function translate(r, redact) {
  *   judgeLoop?: ((o: {system: string}) => any)|null,
  *   judgeModel?: string|null,
  *   onJudgeCost?: ((c: any) => void)|null,
+ *   onRubricEvidence?: ((e: any) => void)|null,
  *   callBounds?: (() => {timeoutMs?: number, deadlineMs?: number})|null}} [opts]
  * @returns {Promise<any>}
  */
 export async function runDeclaredStages(stages, redact = (s) => s, opts = {}) {
   const {
     timeoutMs, cwd, seedRef, seedTrees: shared, gapCap, maxBuffer, baselineMode, humanRuling = null,
-    judgeLoop = null, judgeModel = null, onJudgeCost = null, callBounds = null,
+    judgeLoop = null, judgeModel = null, onJudgeCost = null, callBounds = null, onRubricEvidence = null,
   } = opts;
   if (!isNonEmptyString(cwd) || !isNonEmptyString(seedRef)) {
     // Refuse rather than guess. A declared close measures against a SEED; a
@@ -634,6 +635,8 @@ export async function runDeclaredStages(stages, redact = (s) => s, opts = {}) {
     // the honest absence (an adopter/test that wires no clock through), never a
     // defaulted number invented here.
     callBounds,
+    // REPORT-ONLY seam: what a rubric-step stage's cited checks read (bareguard `full.evidence`); the runner records it, nothing here reads it
+    onRubricEvidence,
     seedTrees,
   };
   try {

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/fitcheck.js

@@ -0,0 +1,166 @@
+// THE FIT CHECK (docs/product/ITEM33-BUILD.md "Addendum 2026-10-21 - fit check build spec", F243, fit POC v6). A rubric job, at drafting, once, after the
+// inputs are frozen and before the look: ONE paid AI call splits each job line into the short parts it asks for (words copied from that line) and says,
+// for each, whether the saved page shows it, with a quote copied from the page. The AI never decides: plain code checks every ask against its own
+// line and every quote against the page, and a part not found becomes one question to the person (never a stop by itself, never a count). Failure is
+// OPEN - a wrong stop is the costly mistake - so a call that does not finish is `absent` and drafting goes on. The call/book/retry pattern is
+// src/pagemap.js's `runPageMap`.
+
+import { createRequire } from 'node:module';
+import { priceOf, scrubRaw, tallyCalls, capStop, callCasualty } from './text.js';
+import { redactSecrets } from './validate.js';
+import { isTransportFailure } from './transport.js';
+import { isRateLimited, rateLimitWaitMs } from './ratelimit.js';
+import { isOutputCutOff } from './authorflow.js';
+import { AUTHOR_CALL_TIMEOUT_MS, AUTHOR_SCOUT_MAX_TOKENS, SURVEY_CAUSES } from './authorscout.js';
+
+const require = createRequire(import.meta.url);
+const { Loop } = require('bare-agent');
+
+/** the label of the one paid call, as the drafting book and the progress line see it */
+export const FIT_CALL_LABEL = 'fit-check';
+/** what the chat says when the check did not finish (drafting goes on) */
+export const FIT_ABSENT_NOTE = 'The fit check did not finish; drafting goes on.';
+/** the answer that keeps drafting after the fit question (any case, a closing full stop allowed) */
+export const FIT_GO_ON = 'go on';
+/** @param {unknown} text @returns {boolean} */
+export const isGoOn = (text) => norm(String(text ?? '').trim().replace(/\.$/, '')) === FIT_GO_ON;
+
+export const FIT_SYSTEM = 'You check whether saved web pages show what a job asks for. You never invent words: every ask must be copied from its job line and every quote must be copied from the page, character for character.';
+
+/** collapse whitespace, lower case: the one spelling every fit comparison uses @param {unknown} s @returns {string} */
+export const norm = (s) => String(s).replace(/\s+/g, ' ').trim().toLowerCase();
+
+/**
+ * What the AI is told: the job lines (the numbered text only, no `~` rules) and the WHOLE text of every input under its label. Adapted from the POC
+ * call (.claude/scratch/fit-poc6/run.mjs): the asks are copied from each job line instead of hand-written.
+ * @param {{jobLines: {n: number, text: string}[], texts: Record<string, string>}} o
+ * @returns {string}
+ */
+export function fitPrompt({ jobLines, texts }) {
+  const job = jobLines.map((l) => `LINE ${l.n}: ${l.text}`).join('\n');
+  const pages = Object.entries(texts).map(([label, text]) => `THE PAGE (the input "${label}"):\n${text}`).join('\n\n');
+  return `THE JOB:\n${job}\n\n${pages}\n\n`
+    + 'For EACH job line, split it into the short parts it asks for (for example where it starts, where it ends, a price, a time), using ONLY words copied from that line. '
+    + 'Every line has at least one part. For EACH part, say whether the page shows it the way the job means it. A page that shows the opposite (for example a flight that arrives where the job says it leaves from, or a different city) does NOT show it. '
+    + 'If found, copy a short piece of page text that shows it, character for character. If not found, quote is null. '
+    + 'Reply with JSON only, no prose, no code fence: {"asks":[{"line":<line number>,"ask":"<the part, copied from that line>","found":true|false,"quote":"<page text or null>"}]}';
+}
+
+/** @typedef {{line: number, ask: string, found: boolean, quote: string|null, madeUp: boolean, ignored?: 'number'}} FitAsk */
+
+/** an ask that is only a number (a count the job gives, not something the page shows): digits, optional spaces, commas, dots @param {string} ask @returns {boolean} */
+const isNumberOnly = (ask) => /^\d[\d\s,.]*$/.test(norm(ask));
+
+/**
+ * Read the AI's reply and decide, all in code. Malformed (no repair): not JSON, another form, a line that is not a job line, an ask not copied from its own
+ * line, found not a boolean, a quote neither text nor null, or a job line with no ask. An ask is found only if `found` is true AND its quote is on a page;
+ * `found` with a quote that is not on any page (or no quote) is made up and counts as not found.
+ * @param {unknown} text the reply
+ * @param {{n: number, text: string}[]} jobLines
+ * @param {Record<string, string>} texts the frozen input texts by label
+ * @returns {{status: 'malformed'}|{status: 'ok', state: 'fits'|'ask', asks: FitAsk[], notFound: {line: number, ask: string}[]}}
+ */
+export function decideFit(text, jobLines, texts) {
+  /** @type {any} */
+  let j;
+  try { j = JSON.parse(String(text ?? '').trim()); } catch { return { status: 'malformed' }; }
+  if (j === null || typeof j !== 'object' || Array.isArray(j) || !Array.isArray(j.asks)) return { status: 'malformed' };
+  const lines = new Map(jobLines.map((l) => [l.n, norm(l.text)]));
+  const pages = Object.values(texts).map(norm);
+  /** @type {FitAsk[]} */
+  const asks = [];
+  for (const a of j.asks) {
+    if (a === null || typeof a !== 'object' || Array.isArray(a)) return { status: 'malformed' };
+    if (!Number.isInteger(a.line) || !lines.has(a.line)) return { status: 'malformed' };
+    if (typeof a.ask !== 'string' || norm(a.ask) === '' || !(/** @type {string} */ (lines.get(a.line))).includes(norm(a.ask))) return { status: 'malformed' };
+    if (typeof a.found !== 'boolean') return { status: 'malformed' };
+    const quote = a.quote ?? null;
+    if (quote !== null && typeof quote !== 'string') return { status: 'malformed' };
+    const q = quote === null ? '' : norm(quote);
+    const onPage = q !== '' && pages.some((p) => p.includes(q));
+    // a bare number is ignored: kept in the record (flagged), never counted, never asked about
+    asks.push({ line: a.line, ask: a.ask, found: a.found && onPage, quote, madeUp: a.found && !onPage, ...(isNumberOnly(a.ask) ? { ignored: /** @type {'number'} */ ('number') } : {}) });
+  }
+  if (!jobLines.every((l) => asks.some((a) => a.line === l.n))) return { status: 'malformed' };
+  const notFound = asks.filter((a) => !a.ignored && !a.found).map((a) => ({ line: a.line, ask: a.ask }));
+  return { status: 'ok', state: notFound.length === 0 ? 'fits' : 'ask', asks, notFound };
+}
+
+/** the not-found asks as the person reads them: `<ask> (line N), <ask> (line N)` @param {{line: number, ask: string}[]} notFound @returns {string} */
+export const notFoundList = (notFound) => notFound.map((x) => `${x.ask} (line ${x.line})`).join(', ');
+
+/**
+ * The one question, worded by code.
+ * @param {{found: number, total: number, notFound: {line: number, ask: string}[]}} o
+ * @returns {string}
+ */
+export const fitQuestionText = ({ found, total, notFound }) => redactSecrets(
+  `I found ${found} of ${total} of your asks on this page. Not found: ${notFoundList(notFound)}. Type go on to keep drafting, or anything else to stop and change the job or the page.`,
+);
+
+/** the default loop seam - one spelling of how this repo drives a model */
+const defaultLoop = (/** @type {any} */ { system, onLlmResult, provider, rates }) =>
+  new Loop({ provider, system, onLlmResult, ...(rates ? { rates } : {}) });
+
+/**
+ * Run the fit check: one call (one retry on a malformed reply or a transport failure or a 429). Never throws on a call casualty; every failure is `absent`.
+ * @param {{jobLines: {n: number, text: string}[], texts: Record<string, string>, provider?: any, maxTokens?: number, ceilingUsd?: number|null,
+ *   callTimeoutMs?: number, onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string, raw?: string}) => void,
+ *   createLoop?: Function, rates?: {in: number, out: number}|null, callOptions?: Record<string, any>, sleep?: (ms: number) => Promise<void>}} o
+ * @returns {Promise<{state: 'fits'|'ask'|'absent', asks: FitAsk[], notFound: {line: number, ask: string}[], reason: string|null, cause: string|null,
+ *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[], budgetStop: 'cap-halt'|'pricing-red'|null}>}
+ */
+export async function runFitCheck({
+  jobLines, texts, provider = null, maxTokens = AUTHOR_SCOUT_MAX_TOKENS, ceilingUsd = null, callTimeoutMs = AUTHOR_CALL_TIMEOUT_MS,
+  onCall = () => {}, createLoop = defaultLoop, rates = null, callOptions = {}, sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+}) {
+  const callTimeout = Number.isFinite(Number(callTimeoutMs)) && Number(callTimeoutMs) > 0
+    ? Math.min(Math.trunc(Number(callTimeoutMs)), AUTHOR_CALL_TIMEOUT_MS) : AUTHOR_CALL_TIMEOUT_MS;
+  const priced = rates ? { rates } : {};
+  /** @type {{label: string, costUsd: number|null, unpricedRounds: number}[]} */
+  const calls = [];
+  let attempts = 0;
+  const record = (/** @type {any} */ r) => {
+    const call = { label: FIT_CALL_LABEL, ...priceOf(r) };
+    calls.push(call);
+    const raw = scrubRaw({ label: FIT_CALL_LABEL, attempt: attempts, text: r?.text });
+    onCall({ ...call, raw: raw.text, ...(r?.thinkingStatus === undefined ? {} : { thinkingStatus: r.thinkingStatus }) });
+  };
+  const absent = (/** @type {string} */ reason, /** @type {string} */ cause, /** @type {'cap-halt'|'pricing-red'|null} */ budgetStop = null) => ({
+    state: /** @type {'absent'} */ ('absent'), asks: [], notFound: [], reason, cause, calls, budgetStop,
+  });
+  const content = fitPrompt({ jobLines, texts });
+  let malformed = 0;
+  let transportRetried = false;
+  let rateRetried = false;
+  for (;;) {
+    // the cap is checked BEFORE every call, never inside one
+    const halt = capStop({ ceilingUsd, ...tallyCalls(calls) });
+    if (halt) return absent(halt === 'cap-halt' ? `the fit check was not made: the $${ceilingUsd} ceiling was already spent` : 'the fit check was not made: spend could not be priced, so the ceiling could not be enforced', SURVEY_CAUSES.NOT_FUNDED, halt);
+    attempts += 1;
+    const loop = createLoop({ system: FIT_SYSTEM, onLlmResult: undefined, provider, ...priced });
+    /** @type {any} */
+    let r;
+    try {
+      r = await loop.run([{ role: 'user', content }], [], { cacheMessages: true, maxTokens, timeoutMs: callTimeout, ...callOptions });
+    } catch (e) {
+      if (isRateLimited(e) && !rateRetried) {
+        const wait = rateLimitWaitMs(e);
+        if (wait !== null) { rateRetried = true; await sleep(wait); continue; }
+      }
+      const casualty = callCasualty(e) ?? (isTransportFailure(e) ? String(/** @type {any} */ (e)?.message ?? e) : null);
+      if (casualty === null) throw e;
+      // the failed attempt may already be billed: booked UNPRICED, so the spend stays "not complete" (never a $0)
+      record({ error: casualty });
+      if (!transportRetried) { transportRetried = true; continue; }
+      return absent(`the fit check call failed: ${redactSecrets(casualty)}`, SURVEY_CAUSES.CALL_FAILED);
+    }
+    record(r);
+    if (isOutputCutOff(r)) return absent('the fit check answer was cut off', SURVEY_CAUSES.UNPARSEABLE);
+    if (r?.error) return absent(`the fit check call failed: ${redactSecrets(String(r.error))}`, SURVEY_CAUSES.CALL_FAILED);
+    const d = decideFit(r?.text, jobLines, texts);
+    if (d.status === 'ok') return { state: d.state, asks: d.asks, notFound: d.notFound, reason: null, cause: null, calls, budgetStop: null };
+    malformed += 1;
+    if (malformed >= 2) return absent('the fit check answer was not readable twice', SURVEY_CAUSES.UNPARSEABLE);
+  }
+}

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')}`);