bareloop 0.44.0 → 0.46.0

package/src/learnstore.js

@@ -0,0 +1,154 @@
+// The thin reader/writer around src/learn.js (cross-run learnings, ITEM33-BUILD.md rev 2). All file IO lives here and
+// the pure rules live in learn.js; nothing in either file can reach a model.
+//
+// ONE ledger per user: `<keys home>/learn/ledger.json` (~/.config/bareloop/learn/ledger.json in production; tests inject a
+// scratch home and never create the real directory). It lives outside every person's repo, is written atomically
+// (temp file + rename) and mode 600, and every string in it passes the one secret inventory before it is written.
+
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync, chmodSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { keysHome } from './keysfile.js';
+import { readConfig } from './config.js';
+import { emptyLedger, redactDeep, countLedger, holdPending, releasePending, recordHealth, buildCards, placeOf, renderHints } from './learn.js';
+import { stageQuestionsByName } from './stagewords.js';
+
+/**
+ * `<home>/learn/ledger.json`.
+ * @param {string} [home] test seam; production never passes it
+ * @returns {string}
+ */
+export function ledgerPath(home) {
+  return join(keysHome(home), 'learn', 'ledger.json');
+}
+
+/**
+ * Read the ledger. A missing file is an empty ledger; an unreadable or wrong-shaped one is reported as `problem` (and the
+ * writer then refuses to replace it: an append-only record is never silently reset).
+ * @param {string} [home]
+ * @returns {{ledger: import('./learn.js').Ledger, exists: boolean, problem: string|null}}
+ */
+export function readLedger(home) {
+  const file = ledgerPath(home);
+  if (!existsSync(file)) return { ledger: emptyLedger(), exists: false, problem: null };
+  try {
+    const d = JSON.parse(readFileSync(file, 'utf8'));
+    if (!d || typeof d !== 'object' || d.version !== 1 || !Array.isArray(d.rows) || !Array.isArray(d.pending)) {
+      return { ledger: emptyLedger(), exists: true, problem: `${file} is not a version-1 learnings ledger — fix or remove it` };
+    }
+    return { ledger: { ...emptyLedger(), ...d }, exists: true, problem: null };
+  } catch (/** @type {any} */ e) {
+    return { ledger: emptyLedger(), exists: true, problem: `${file} is not readable JSON (${e?.code ?? 'parse error'}) — fix or remove it` };
+  }
+}
+
+/**
+ * Write the ledger atomically (temp + rename, mode 600), every string masked through the one secret inventory.
+ * @param {import('./learn.js').Ledger} ledger @param {string} [home]
+ * @returns {string} the file written
+ */
+export function writeLedger(ledger, home) {
+  const file = ledgerPath(home);
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  writeFileSync(tmp, `${JSON.stringify(redactDeep(ledger), null, 1)}\n`, { mode: 0o600 });
+  chmodSync(tmp, 0o600);
+  renameSync(tmp, file);
+  return file;
+}
+
+/**
+ * Fold ONE finished run into the ledger on disk: a deterministic job's cards COUNT now; a rubric job's cards are HELD
+ * until a human Accept (they are written to `pending`, never counted, never readable). The run's health line is recorded
+ * either way. Never throws on a bad ledger file: it reports `problem` and writes nothing.
+ * @param {{home?: string, runid: string, build: import('./learn.js').CardBuild, workflow: string, place: string|null, specHash: string|null, trust: 'deterministic'|'rubric', at: string, now?: Date}} o
+ * @returns {{wrote: boolean, counted: number, held: number, problem: string|null}}
+ */
+export function foldRunIntoLedger({ home, runid, build, workflow, place, specHash, trust, at, now = new Date() }) {
+  const cur = readLedger(home);
+  if (cur.problem) return { wrote: false, counted: 0, held: 0, problem: cur.problem };
+  let L = cur.ledger;
+  let counted = 0;
+  let held = 0;
+  if (trust === 'rubric') {
+    L = holdPending(L, { runid, cards: build.cards, workflow, place, specHash, at }, now);
+    held = build.cards.length;
+  } else {
+    const before = L.rows.reduce((n, r) => n + r.runIds.filter((x) => x === runid).length, 0);
+    L = countLedger(L, { runid, cards: build.cards, workflow, place, specHash, trust, now });
+    counted = L.rows.reduce((n, r) => n + r.runIds.filter((x) => x === runid).length, 0) - before;
+  }
+  L = recordHealth(L, runid, build, at, now);
+  writeLedger(L, home);
+  return { wrote: true, counted, held, problem: null };
+}
+
+/**
+ * The human Accept at the review door: release the run's held rubric cards so they count (only forward, only here).
+ * @param {{home?: string, runid: string, now?: Date}} o
+ * @returns {{released: number, problem: string|null}}
+ */
+export function releaseRun({ home, runid, now = new Date() }) {
+  const cur = readLedger(home);
+  if (cur.problem) return { released: 0, problem: cur.problem };
+  const r = releasePending(cur.ledger, runid, now);
+  if (r.ledger !== cur.ledger) writeLedger(r.ledger, home);
+  return { released: r.released, problem: null };
+}
+
+/**
+ * The ONE setting: `learningHints` in config.json. Ships OFF (absent = off). OFF still writes the tally ($0) and the planner
+ * is simply handed nothing, so an ON/OFF contrast has data at once. An unreadable config reads as OFF.
+ * @param {string} [home]
+ * @returns {boolean}
+ */
+export function learningHintsOn(home) {
+  const c = readConfig({ home });
+  return c.problem === null && c.config.learningHints === true;
+}
+
+/** @param {string} p @returns {any[]} the parsed rows of a JSONL file; missing or torn lines are skipped */
+function readJsonl(p) {
+  if (!existsSync(p)) return [];
+  /** @type {any[]} */
+  const rows = [];
+  for (const l of readFileSync(p, 'utf8').split('\n')) {
+    if (!l) continue;
+    try { rows.push(JSON.parse(l)); } catch { /* a torn line is skipped, never a crash */ }
+  }
+  return rows;
+}
+
+/** a path resolved to its real location when it exists, else as written @param {string} p */
+const realOr = (p) => { try { return realpathSync(p); } catch { return p; } };
+
+/**
+ * THE RUN-END TALLY ($0, code only, no model): turn the finished run's whole record into cards and fold them into the
+ * ledger (a rubric job's are held until Accept). Called once from the one engine's run-end block (src/userrun.js
+ * `execute`, shared by the panel, the CLI and the bundle runner), inside its own try/catch: it is a record, never a verdict,
+ * and can never change a run's outcome, exit code or spend. It runs whether the hints setting is on or off.
+ * @param {{home?: string, runid: string, events: any[], auditFiles?: string[], spec: any, specHash: string|null, workdir: string|null, trust: 'deterministic'|'rubric', now?: Date}} o
+ * @returns {{wrote: boolean, counted: number, held: number, problem: string|null, noise: string|null, cards: number}}
+ */
+export function learnAtRunEnd({ home, runid, events, auditFiles = [], spec, specHash, workdir, trust, now = new Date() }) {
+  const audit = auditFiles.flatMap(readJsonl);
+  const build = buildCards({ runid, events, audit, workdir, spec, questions: stageQuestionsByName(spec) });
+  const at = events.findLast((e) => e?.type === 'job-end')?.ts ?? now.toISOString();
+  const r = foldRunIntoLedger({
+    home, runid, build, workflow: String(spec.job), place: placeOf(spec, realOr), specHash, trust, at, now,
+  });
+  return { ...r, noise: build.noise, cards: build.cards.length };
+}
+
+/**
+ * The block the planner is handed for this job, made ONCE at run start from the ledger as it stood — empty when the
+ * setting is off, when there is no ledger, or when nothing is readable. The one `renderHints` render, never a second.
+ * @param {{home?: string, spec: any, specHash: string|null, now?: Date}} o
+ * @returns {{text: string, ids: string[]}|null}
+ */
+export function hintsForRun({ home, spec, specHash, now = new Date() }) {
+  if (!learningHintsOn(home)) return null;
+  const cur = readLedger(home);
+  if (cur.problem) return null;
+  const r = renderHints(cur.ledger, { workflow: String(spec.job), place: placeOf(spec, realOr), specHash, now });
+  return r.text ? r : null;
+}

package/src/modellist.js

@@ -55,7 +55,7 @@ export function idsOf(shape, body) {
  * @returns {Promise<ListResult>}
  */
 export async function listModels({ shape, baseUrl, key, fetchImpl = fetch, timeoutMs = LIST_TIMEOUT_MS }) {
-  const base = typeof baseUrl === 'string' ? baseUrl.trim().replace(/\/+$/, '') : '';
+  const base = typeof baseUrl === 'string' ? baseUrl.trim().replace(/(?<!\/)\/+$/, '') : '';
   if (base === '') return { ok: false, why: 'Type a Base URL.', status: 'no-base-url' };
   const url = `${base}/models`;
   const started = Date.now();

package/src/pagedropwords.js

@@ -21,7 +21,8 @@ const WORDS = /** @type {Record<string, (d: Dropped) => string>} */ ({
   '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.`,
+  'reads-no-result': () => "the price rule could not read a price in the page's results, so it is not checked.",
+  'phrase-no-result': (d) => `"${d.other}" is on the page but in none of its results, so it is not checked.`,
   '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.`,
 });
@@ -62,3 +63,48 @@ export function dropLine(row, jobLines, rulesOf) {
   const rule = row.rule === undefined || !jl ? undefined : rulesOf(jl)[row.rule - 1];
   return `line ${row.line}: "${rule ?? row.fact}" — ${row.sentences.join(' ')}`;
 }
+
+// HOW THE PAGE WAS READ (run mvij7kuk, flight-c1): a drop of ONE WORD whose fact is still checked is a NOTE about the form code did not use, not
+// something left unchecked. The sentences for those reasons are WORD-level; every other sentence (a whole fact left out) keeps the line under
+// Not checked. Classified from the line's own words, so it holds for a signed spec already on disk.
+const WORD_REASONS = ['not-on-page', 'no-value', 'n2', 'r1', 'sign-twice', 'r1l', 'limit-currency', 'limit-unit', 'unit-too-long'];
+/** @param {string} s */
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const SENTENCE_RE = (() => {
+  const [W, O] = ['\u0001w\u0001', '\u0001o\u0001'];
+  /** @type {string[]} */
+  const alts = [];
+  for (const reason of WORD_REASONS) {
+    const probes = reason === 'r1l' ? [{ word: W, other: W }, { word: W, other: O }] : [{ word: W, other: O }];
+    for (const p of probes) alts.push(esc(WORDS[reason](/** @type {any} */ ({ ...p, reason, line: 0, fact: 'f' }))).split(esc(W)).join('[^"]+').split(esc(O)).join('[^"]+'));
+  }
+  return new RegExp(`^(?:(?:${alts.join('|')})(?: |$))+$`);
+})();
+
+/** the s1 sentence as a pattern whose one capture is the OTHER fact's name (the sentence is built from the one WORDS table) */
+const S1_RE = (() => {
+  const [F, O] = ['\u0001f\u0001', '\u0001o\u0001'];
+  return new RegExp(esc(WORDS['s1'](/** @type {any} */ ({ fact: F, other: O, reason: 's1', line: 0 }))).split(esc(F)).join('[^"]+').split(esc(O)).join('([^"]+)'), 'g');
+})();
+
+/**
+ * An `s1` drop (a second fact that would read the same value as one already kept) is a NOTE when that OTHER fact is still signed: the guardrail
+ * is checked by it. With the other fact not signed, or no signed list given, the sentence stays Not checked. Every sentence of a row must qualify.
+ * @param {string} text one Not-checked line @param {string[]|null|undefined} [signed] the names of the facts the plan signs
+ * @returns {boolean} true when the line only says which written forms of a still-checked fact were not used
+ */
+export function isReadNote(text, signed) {
+  const m = /^line \d+: "[^"]*" \u2014 (.+)$/s.exec(String(text));
+  if (m === null) return false;
+  const names = new Set(Array.isArray(signed) ? signed : []);
+  let found = 0;
+  const rest = m[1].replace(S1_RE, (all, other) => { if (!names.has(other)) return all; found += 1; return ''; }).replace(/\s+/g, ' ').trim();
+  return rest === '' ? found > 0 : SENTENCE_RE.test(rest);
+}
+
+/** @param {string[]|null|undefined} items @param {string[]|null|undefined} [signed] names of the signed facts (see isReadNote)
+ * @returns {{notChecked: string[], readNotes: string[]}} the lines split: what is left unchecked, and how the page was read */
+export function splitReadNotes(items, signed) {
+  const all = Array.isArray(items) ? items : [];
+  return { notChecked: all.filter((t) => !isReadNote(t, signed)), readNotes: all.filter((t) => isReadNote(t, signed)) };
+}

package/src/pagedry.js

@@ -0,0 +1,124 @@
+// MONEY BUILD v2 (docs/product/ITEM33-BUILD.md "Addendum 2026-10-21 — money build spec v2", part 2): "CAN IT READ". After the page rules, a $0 dry
+// read asks of each kept money fact whether the REAL run-time checker can read a price on the page's own result lines. For every result line it
+// grades an HONEST claim (quote = that line, value = the line's amount) with `gradeStep` (src/rubricstep.js), the one reader the run itself
+// uses - no copy of its logic here. A fact that reads no result line is dropped as `reads-no-result` and shows under Not checked.
+// No limits, no counts, no pass bar: only "can it read". Async (gradeStep is), so it sits beside applyPageRules, not inside it: the caller is
+// src/pagemap.js `runPageMap`. No I/O, no clock, no model.
+
+import { createHash } from 'node:crypto';
+import { gradeStep } from './rubricstep.js';
+import { linesOf, numberAtEnd } from './pagerules.js';
+
+/** @typedef {import('./pagerules.js').KeptFact} KeptFact @typedef {import('./pagerules.js').Dropped} Dropped */
+
+/** a number as the page writes it, thousands commas allowed */
+const NUM = '\\d[\\d,]*(?:\\.\\d+)?';
+const AFTER_LABEL = new RegExp(`^\\s*(?:[$€£]\\s*)?(${NUM})`);
+/** the label every dry-read claim is made under (the checker only needs one name; the fact's own is not read) */
+const CLAIM = 'price';
+const SOURCE = 'page';
+
+/**
+ * The result lines of a kept money fact: with a label, every page line where a kept label is followed by a number (one sign between allowed);
+ * with no label (U1 moved it to a unit, e.g. "€533 total"), every line where a number is followed by a kept unit.
+ * @param {string} text @param {KeptFact} k @returns {{quote: string, value: string}[]}
+ */
+export function moneyResultLines(text, k) {
+  const raw = text.split('\n');
+  const squashed = linesOf(text);
+  /** @type {{quote: string, value: string}[]} */
+  const out = [];
+  squashed.forEach((ln, i) => {
+    /** @type {string|undefined} */
+    let amount;
+    if (k.words.length) {
+      for (const w of k.words) {
+        for (let at = ln.indexOf(w); at !== -1 && amount === undefined; at = ln.indexOf(w, at + w.length)) amount = AFTER_LABEL.exec(ln.slice(at + w.length))?.[1];
+        if (amount !== undefined) break;
+      }
+    } else {
+      for (const u of k.unit ?? []) {
+        for (let at = ln.indexOf(u); at !== -1 && amount === undefined; at = ln.indexOf(u, at + u.length)) amount = numberAtEnd(ln.slice(0, at));
+        if (amount !== undefined) break;
+      }
+    }
+    if (amount !== undefined) out.push({ quote: raw[i].trim(), value: amount.replace(/,/g, '') });
+  });
+  return out;
+}
+
+/**
+ * The fact as a run would sign it, for the dry read: the primary label is the anchor (none when U1 moved every label), then the kept units and currencies.
+ * @param {KeptFact} k @returns {Record<string, any>}
+ */
+const signedOf = (k) => ({ name: CLAIM, shape: 'money', ...(k.words.length ? { anchor: k.words[0] } : {}), ...(k.currency ? { currency: k.currency } : {}), ...(k.unit ? { unit: k.unit } : {}) });
+
+/**
+ * Dry-read every kept money fact; drop (as `reads-no-result`) the ones whose forms read no result line. Other facts pass through untouched.
+ * @param {string} text the frozen page text @param {KeptFact[]} facts what applyPageRules kept
+ * @returns {Promise<{facts: KeptFact[], dropped: Dropped[], reads: Record<string, number>, results: Record<string, number>}>}
+ *   `reads` / `results` = result lines the checker read / lines found, per fact name (for tests and reports; no verdict derives from the numbers)
+ */
+export async function dryReadMoney(text, facts) {
+  const sha = createHash('sha256').update(text).digest('hex');
+  /** @type {KeptFact[]} */
+  const kept = [];
+  /** @type {Dropped[]} */
+  const dropped = [];
+  /** @type {Record<string, number>} */
+  const reads = {};
+  /** @type {Record<string, number>} */
+  const results = {};
+  for (const k of facts) {
+    if (k.shape !== 'money') { kept.push(k); continue; }
+    const fact = signedOf(k);
+    const lines = moneyResultLines(text, k);
+    let n = 0;
+    for (const r of lines) {
+      const params = { step: 1, parts: [{ text: 'dry read', class: 'fact', source: SOURCE, covers: [1], facts: [fact] }] };
+      const g = await gradeStep({ params, bytes: JSON.stringify({ results: [{ quote: r.quote, values: { [CLAIM]: r.value } }] }), outputBytes: null, inputs: { [SOURCE]: text } }, { [SOURCE]: sha });
+      if (g.verdict === 'green') n += 1;
+    }
+    reads[k.name] = n;
+    results[k.name] = lines.length;
+    if (n > 0) { kept.push(k); continue; }
+    dropped.push({ line: k.line, ...(k.forRule === undefined ? {} : { rule: k.forRule }), fact: k.name, reason: 'reads-no-result' });
+  }
+  return { facts: kept, dropped, reads, results };
+}
+
+/**
+ * The same "can it read" for PHRASE facts (hamr ruled 3a, run m10-walk-flights-3: "Rome" was on the page only in "Track prices from Madrid to
+ * Rome" switches, in none of the 18 result lines, so no result could ever say it). A kept phrase fact is read against the page's RESULT LINES =
+ * the lines the job's kept money facts read (`moneyResultLines`), each graded as an honest claim by the real `gradeStep` (quote = that line;
+ * a phrase has no value to write). A phrase that reads no result line is dropped whole as `phrase-no-result` and shows under Not checked.
+ * With no kept money fact the result lines are unknown, so phrase facts pass through untouched (nothing is guessed about what a result is).
+ * @param {string} text the frozen page text @param {KeptFact[]} facts what the money dry read kept
+ * @returns {Promise<{facts: KeptFact[], dropped: Dropped[], reads: Record<string, number>}>} `reads` = result lines that said the phrase, per fact name
+ */
+export async function dryReadPhrases(text, facts) {
+  const sha = createHash('sha256').update(text).digest('hex');
+  /** @type {Map<string, true>} */
+  const quotes = new Map();
+  for (const k of facts) if (k.shape === 'money') for (const r of moneyResultLines(text, k)) quotes.set(r.quote, true);
+  /** @type {KeptFact[]} */
+  const kept = [];
+  /** @type {Dropped[]} */
+  const dropped = [];
+  /** @type {Record<string, number>} */
+  const reads = {};
+  for (const k of facts) {
+    if (k.shape !== 'phrase' || quotes.size === 0 || !k.words.length) { kept.push(k); continue; }
+    const fact = { name: k.name, shape: 'phrase', phrase: k.words[0] };
+    let n = 0;
+    for (const quote of quotes.keys()) {
+      const params = { step: 1, parts: [{ text: 'dry read', class: 'fact', source: SOURCE, covers: [1], facts: [fact] }] };
+      const g = await gradeStep({ params, bytes: JSON.stringify({ results: [{ quote, values: {} }] }), outputBytes: null, inputs: { [SOURCE]: text } }, { [SOURCE]: sha });
+      if (g.verdict === 'green') n += 1;
+    }
+    reads[k.name] = n;
+    if (n > 0) { kept.push(k); continue; }
+    dropped.push({ line: k.line, ...(k.forRule === undefined ? {} : { rule: k.forRule }), fact: k.name, other: k.words[0], reason: 'phrase-no-result' });
+  }
+  return { facts: kept, dropped, reads };
+}

package/src/pagefetch.js

@@ -10,6 +10,7 @@
 // fetch is a plain-words stop, never a silent empty input. Nothing here touches a model.
 
 import { SECRET_PATTERNS } from './validate.js';
+import { TAG } from './labelscan.js';
 
 /** the session options (incognito: no auth ever enters; blockPrivateNetwork: SSRF guard); ONE frozen object so a test can pin them */
 export const CONNECT_OPTIONS = Object.freeze({ incognito: true, blockPrivateNetwork: true });
@@ -59,7 +60,7 @@ export function pageContentChars(text) {
       skipIndent = -1;
     }
     if (m && CHROME_ROLES.has(m[2])) { skipIndent = indent; continue; }
-    n += raw.replace(/\[[A-Za-z]+=[^\]\s]*\]/g, ' ').replace(/^\s*-\s*/, '').replace(/\s+/g, ' ').trim().length;
+    n += raw.replace(TAG, ' ').replace(/^\s*-\s*/, '').replace(/\s+/g, ' ').trim().length;
   }
   return n;
 }

package/src/pagemap.js

@@ -15,6 +15,7 @@ import { isOutputCutOff } from './authorflow.js';
 import { AUTHOR_CALL_TIMEOUT_MS, AUTHOR_SCOUT_MAX_TOKENS, SURVEY_CAUSES } from './authorscout.js';
 import { lineRules, boundInWords, wordsSaidOn } from './rubricstep.js';
 import { applyPageRules, validReading } from './pagerules.js';
+import { dryReadMoney, dryReadPhrases } from './pagedry.js';
 import { ruleWords } from './facts.js';
 import { lookFactOf } from './inputlook.js';
 
@@ -164,8 +165,12 @@ export async function runPageMap({
       if (malformed >= 2) return absent(MAP_UNREADABLE, SURVEY_CAUSES.UNPARSEABLE);
     }
     const kept = applyPageRules(texts[label], mapping, jobLines);
-    for (const f of kept.facts) facts.push(lookFactOf(f, label));
-    for (const d of kept.dropped) dropped.push({ ...d, source: label });
+    // money build v2: "can it read" - a money fact whose forms read no result line of the page, by the run's own checker, is Not checked
+    const read = await dryReadMoney(texts[label], kept.facts);
+    // hamr 3a: a phrase fact is read against the same result lines (only when the job keeps a money fact)
+    const phr = await dryReadPhrases(texts[label], read.facts);
+    for (const f of phr.facts) facts.push(lookFactOf(f, label));
+    for (const d of [...kept.dropped, ...read.dropped, ...phr.dropped]) dropped.push({ ...d, source: label });
     maps.push({ source: label, facts: mapping.facts.length });
     looks.push(label);
   }

package/src/pagerules.js

@@ -14,7 +14,7 @@ import { normLabel } from './labelscan.js';
  * @typedef {{facts: MapFact[]}} PageMap
  * @typedef {{line: number, name: string, shape: string, from: string, words: string[], unit?: string[], currency?: string[], forRule?: number, reading?: Reading}} KeptFact
  *   `words` = what the page proves: the labels of a money/number/time fact, or the alternative phrases of a phrase fact (a place is a phrase)
- * @typedef {{line: number, rule?: number, fact: string, word?: string, reason: string, other?: string}} Dropped  `other` = what the drop is compared to: the first label (R1), the primary form (R1L), the fact it would have repeated (S1)
+ * @typedef {{line: number, rule?: number, fact: string, word?: string, reason: string, other?: string}} Dropped  `other` = what the drop is compared to: the first label (R1), the primary form (R1L), the fact it would have repeated (S1), the phrase it looked for (phrase-no-result)
  */
 
 /** @param {unknown} v @returns {v is Record<string, any>} */
@@ -99,7 +99,30 @@ const sameSet = (a, b) => a.size === b.size && [...a].every((x) => b.has(x));
 
 /** a number as the page writes it: digits, thousands commas, optional decimals (a currency sign next to it is not part of it) */
 const NUM = '\\d[\\d,]*(?:\\.\\d+)?';
-const BEFORE = new RegExp(`(${NUM})\\s*$`);
+/**
+ * The number written at the very end of `s` (only whitespace after it): the leftmost match of NUM followed by `\s*$`. Shared with src/pagedry.js (one copy). Scans back from the end, so a
+ * long run of digits and commas costs O(n) where a backtracking regex is quadratic.
+ * @param {string} s @returns {string|undefined}
+ */
+export function numberAtEnd(s) {
+  let e = s.length;
+  while (e > 0 && /\s/.test(s[e - 1])) e--;
+  /** the first digit of the digit/comma run ending at `end`, or -1 if the run holds none; a start never follows a digit, so it is the run's first digit */
+  const firstDigit = (/** @type {number} */ end) => {
+    let l = end;
+    while (l > 0 && /[\d,]/.test(s[l - 1])) l--;
+    while (l < end && s[l] === ',') l++;
+    return l < end ? l : -1;
+  };
+  let d = e;
+  while (d > 0 && /\d/.test(s[d - 1])) d--;
+  if (d < e && s[d - 1] === '.') {
+    const p = firstDigit(d - 1);
+    if (p !== -1) return s.slice(p, e);
+  }
+  const p = firstDigit(e);
+  return p === -1 ? undefined : s.slice(p, e);
+}
 const AFTER = new RegExp(`^\\s*(?:[$€£]\\s*)?(${NUM})`);
 const AFTER_CUR = new RegExp(`^\\s*(${NUM})`);
 const stripCommas = (/** @type {string} */ s) => s.replace(/,/g, '');
@@ -121,13 +144,13 @@ function beforeAfter(lines, label) {
   let B = 0;
   let A = 0;
   for (const [l, i] of occs(lines, label)) {
-    if (BEFORE.test(l.slice(0, i))) B += 1;
+    if (numberAtEnd(l.slice(0, i)) !== undefined) B += 1;
     if (AFTER.test(l.slice(i + label.length))) A += 1;
   }
   return { B, A };
 }
 /** R1L: the numbers a UNIT form reads - the one right before each occurrence @param {string[]} lines @param {string} u @returns {Set<string>} */
-const unitSet = (lines, u) => new Set(occs(lines, u).map(([l, i]) => BEFORE.exec(l.slice(0, i))?.[1]).filter((v) => typeof v === 'string').map((v) => stripCommas(/** @type {string} */ (v))));
+const unitSet = (lines, u) => new Set(occs(lines, u).map(([l, i]) => numberAtEnd(l.slice(0, i))).filter((v) => typeof v === 'string').map((v) => stripCommas(/** @type {string} */ (v))));
 /** R1L: the numbers a CURRENCY form reads - the one right after each occurrence @param {string[]} lines @param {string} c @returns {Set<string>} */
 const curSet = (lines, c) => new Set(occs(lines, c).map(([l, i]) => AFTER_CUR.exec(l.slice(i + c.length))?.[1]).filter((v) => typeof v === 'string').map((v) => stripCommas(/** @type {string} */ (v))));
 
@@ -200,7 +223,9 @@ export function applyPageRules(text, mapping, jobLines) {
       /** @type {string[]} */ let uni = [];
       /** @type {string[]} */ let cur = [];
       if (f.shape === 'money') {
-        // the forms: units first (the U1-moved words, then the AI's listed units), then currency signs
+        // the forms: units first (the U1-moved words, then the AI's listed units), then currency signs. SORT, never drop for the box (money
+        // build v2): the box is position only - a sign (before the number) is a currency, any other form (a word after it) is a unit - so every
+        // form the AI listed in either box is pooled and moved to the box its own shape belongs to
         const listedCurrencies = (Array.isArray(f.currency) ? f.currency : []).map(String);
         // a currency SIGN listed in BOTH unit and currency is said once: the unit copy goes (fwd F71 drafts)
         const listedUnits = (Array.isArray(f.unit) ? f.unit : []).map(String).filter((u) => {
@@ -208,12 +233,15 @@ export function applyPageRules(text, mapping, jobLines) {
           drop(f, u, 'sign-twice');
           return false;
         });
-        const units = [...new Set([...moved, ...listedUnits])].filter((u) => {
+        // a WORD listed in both boxes is one form, said once (a record of the double listing is kept, as R1L always said it)
+        for (const w of new Set(listedCurrencies.filter((c) => !CURRENCY_SYMBOLS.includes(c) && listedUnits.includes(c)))) drop(f, w, 'r1l', w);
+        const pool = [...moved, ...listedUnits, ...listedCurrencies];
+        const units = [...new Set(pool.filter((w) => !CURRENCY_SYMBOLS.includes(w)))].filter((u) => {
           if (countPhrase(text, u) >= 1) return true;
           drop(f, u, 'not-on-page');
           return false;
         });
-        const curs = listedCurrencies.filter((c) => {
+        const curs = [...new Set(pool.filter((w) => CURRENCY_SYMBOLS.includes(w)))].filter((c) => {
           if (countExact(text, c) >= 1) return true;
           drop(f, c, 'not-on-page');
           return false;
@@ -230,12 +258,6 @@ export function applyPageRules(text, mapping, jobLines) {
           uni = keep.filter((x) => x.kind === 'unit').map((x) => x.w);
           cur = keep.filter((x) => x.kind === 'currency').map((x) => x.w);
         }
-        // a currency that is a word ("US dollars") is read after the number, so it is a unit, never a currency sign
-        cur = cur.filter((c) => {
-          if (CURRENCY_SYMBOLS.includes(c)) return true;
-          drop(f, c, 'currency-not-symbol');
-          return false;
-        });
         // the guard's list limits (src/facts.js), applied here so a longer list is cut by code and SAID, never refused later: the first forms stay
         uni = uni.filter((u, i) => {
           if (u.length > MAX_UNIT_CHARS) { drop(f, u, 'unit-too-long'); return false; }

package/src/panel/authorroutes.js

@@ -422,7 +422,7 @@ export function createAuthorRoutes(opts) {
     }
     if (sub === 'sign') {
       const claimedHash = String(body?.specHash ?? '');
-      const r = signRun(session, claimedHash, { env: envNow(), spawnFn, bareloopBin, sessionsRoot: opts.sessionsRoot, home: opts.home, ...(opts.schedules ? { schedules: opts.schedules } : {}) });
+      const r = signRun(session, claimedHash, { env: envNow(), spawnFn, bareloopBin, sessionsRoot: opts.sessionsRoot, home: opts.home });
       send(r.ok ? 200 : 400, r);
       return true;
     }

package/src/panel/authorsession.js

@@ -51,9 +51,10 @@ import { resolveJobJudge, defaultJudgeLoop } from '../judged.js';
 import { assertThinkingMode, thinkingPlanFor, thinkingRowText } from '../thinking.js';
 import { closeJudges } from '../kinds.js';
 import { RUBRIC_LANG } from '../authoring.js';
-import { rubricGoal, reconcileRubricPlan } from '../rubricstep.js';
+import { rubricGoal, reconcileRubricPlan, signedFactNames } from '../rubricstep.js';
 import { redactSecrets } from '../validate.js';
 import { isDropIt, isAgree } from '../pagemap.js';
+import { FIT_ABSENT_NOTE } from '../fitcheck.js';
 import { tallyCalls } from '../text.js';
 import { writeDraftSpend, appendDraftLog } from '../draftspend.js';
 import { PLAIN_PROPOSAL_STOPS, proposalStopText, signingStopText, draftStopText, redsRecord, declarationRecord, calibrationSummary, tryRefusedText } from '../authorreadout.js';
@@ -118,6 +119,9 @@ export const PHASE_STEP = Object.freeze({
   'scout-done': 'scout',
   look: 'look',
   'look-done': 'look',
+  // F243: the fit check's one call is counted in the look's line, like the look
+  'fit-check': 'look',
+  'fit-check-done': 'look',
   confirm: 'confirm',
   'confirm-turn-done': 'confirm',
   listing: 'listing',
@@ -166,7 +170,7 @@ export const PLAN_FOOTER = 'Sign & run to confirm this plan, or Revise to edit t
  * The confirm turn's plan as a chat message (P7): a STRUCTURED `{role:'bot', kind:'plan', plan}` the page draws with the
  * same renderer the Job tab uses — each numbered job line, its `~` rule, its drafted checks folded; the AI's own "not
  * checked"; the always-on guards. `questions` (what the plan still asks) ride inside the plan. One owner of the shape.
- * @param {{goal?: string, checks?: string[], checkItems?: {text: string, fromLine: number[]|null}[], notChecked?: string[], questions?: string[], protections?: string[]}} p the confirm turn's plan
+ * @param {{goal?: string, checks?: string[], checkItems?: {text: string, fromLine: number[]|null}[], notChecked?: string[], questions?: string[], protections?: string[], signedFacts?: string[]}} p the confirm turn's plan
  * @param {{n: number, text: string, rule: string}[]|null} jobLines
  * @returns {{role: 'bot', kind: 'plan', text: string, plan: ReturnType<typeof planFromConfirm> & {goal: string, questions: string[]}}}
  */
@@ -404,7 +408,7 @@ export function validateJobCard(card, opts = {}) {
  * @param {any} card the validated job card (see {@link validateJobCard})
  * @param {{env?: Record<string,string|undefined>, sessionsRoot?: string, home?: string, timeoutMs?: number,
  *   scout?: any, generate?: Function, confirmGenerate?: Function, authorFn?: Function,
- *   prepareSigningFn?: Function, npmCiFn?: Function, lookFn?: Function|null, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>, draftThinking?: "on"|"off", reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
+ *   prepareSigningFn?: Function, npmCiFn?: Function, lookFn?: Function|null, fitFn?: Function|null, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>, draftThinking?: "on"|"off", reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
  *   TEST SEAMS ONLY — see the note just above where each is read, below. `reuse` (Reuse workflow) is NOT a seam: the
  *   caller (`/api/author/start`) sets it only when the server's own same-job rule held.
  * @returns {any} the session object
@@ -560,7 +564,8 @@ export function createSession(card, deps = {}) {
     if (step.kind === 'language') say('bot', `${step.field?.prompt ?? 'Which language is this job about?'} (${(step.candidates ?? []).join(', ')})`);
     else if (step.kind === 'menu') {
       sayPlan(step.plan ?? {});
-    } else if (step.kind === 'answer') say('bot', `A question the plan raised (${step.index} of ${step.total})${Number.isInteger(step.line) ? `, about job line ${step.line}` : ''}: ${step.question}`);
+    } else if (step.kind === 'answer' && step.source === 'fit-check') say('bot', step.question);
+    else if (step.kind === 'answer') say('bot', `A question the plan raised (${step.index} of ${step.total})${Number.isInteger(step.line) ? `, about job line ${step.line}` : ''}: ${step.question}`);
     else if (step.kind === 'goal') say('bot', 'Type the goal sentence yourself.');
   });
 
@@ -575,6 +580,19 @@ export function createSession(card, deps = {}) {
   };
 
   let lastTryRefused = false;
+  // F243: the fit check's result is one drafting-log row (the asks, what was found, what the quote proved); an `absent` check says so in chat
+  // (a seam of its own - onPhase never posts a chat message)
+  const onFit = (/** @type {any} */ data) => {
+    const running = state.steps.findLastIndex((/** @type {any} */ x) => x.status === 'running');
+    appendDraftLog(outDir, {
+      kind: 'fit-check', no: running === -1 ? Math.max(0, state.steps.length - 1) : running, state: String(data.state ?? 'absent'),
+      asks: (Array.isArray(data.asks) ? data.asks : []).map((/** @type {any} */ a) => ({
+        line: a.line, ask: redactSecrets(String(a.ask)), found: a.found === true, quote: typeof a.quote === 'string' ? redactSecrets(a.quote) : null, madeUp: a.madeUp === true, ...(a.ignored === 'number' ? { ignored: 'number' } : {}),
+      })),
+      notFound: (Array.isArray(data.notFound) ? data.notFound : []).map((/** @type {any} */ x) => ({ line: x.line, ask: redactSecrets(String(x.ask)) })), at: new Date().toISOString(),
+    });
+    if (data.state === 'absent') say('bot', FIT_ABSENT_NOTE);
+  };
   const onPhase = (name, data = {}) => {
     // COLLAPSED INTO THE PROGRESS INDICATOR ONLY (build item 3) — this used
     // to also `say('system', `… ${name}`)`, one jargon chat bubble per
@@ -1068,6 +1086,16 @@ export function createSession(card, deps = {}) {
       return { jobLines, answers, left };
     };
 
+    // F243: the fit check's one question, through the same `ask` (the chat box + Send; a blank answer asks again, there is no skip)
+    const fitAsk = async (/** @type {string} */ question) => {
+      for (;;) {
+        const a = await ask({ kind: 'answer', source: 'fit-check', index: 1, total: 1, question });
+        if (a === null) return null;
+        if (String(a).trim()) return String(a);
+        say('bot', 'An answer is needed here — there is no skip. Type it in the box below and press Send.');
+      }
+    };
+
     state.phase = 'drafting';
     // no early "drafting" line: the real author phase (PHASE_STEP) starts it, carrying draftDetail (see onPhase)
     // build item 4 — the DISPLAY id (card.model, e.g. "deepseek-flash"), not
@@ -1087,6 +1115,9 @@ export function createSession(card, deps = {}) {
       ...(deps.scout ? { scout: deps.scout } : {}),
       // PART 1c: a test that replaces the model boundary (`generate`) must not reach the real paid look; `deps.lookFn` brings its own
       ...(deps.lookFn !== undefined ? { lookFn: deps.lookFn } : (deps.generate ? { lookFn: null } : {})),
+      // F243: the fit check asks through the ordinary ask path; like the look, a test that replaces the model boundary never reaches the real paid call
+      fitAsk, onFit,
+      ...(deps.fitFn !== undefined ? { fitFn: deps.fitFn } : (deps.generate ? { fitFn: null } : {})),
       ...(authorFnOverride ? { authorFn: authorFnOverride } : {}),
     });
 
@@ -1135,7 +1166,7 @@ export function createSession(card, deps = {}) {
       const rec = reconcileRubricPlan({
         confirmed: authored.confirmed?.checkItems ?? [], notChecked: authored.confirmed?.notChecked ?? [], closeDecl: spec.closeDecl, jobLines,
       });
-      state.finalPlan = { goal: String(draft.goal ?? ''), checkItems: rec.checkItems, notChecked: rec.notChecked, protections: authored.confirmed?.protections ?? [], moved: rec.moved };
+      state.finalPlan = { goal: String(draft.goal ?? ''), checkItems: rec.checkItems, notChecked: rec.notChecked, protections: authored.confirmed?.protections ?? [], moved: rec.moved, signedFacts: signedFactNames(spec.closeDecl) };
     }
     await finish(spec, authored.seedRef);
     if (state.finalPlan && state.phase === 'prepared') {
@@ -1144,7 +1175,7 @@ export function createSession(card, deps = {}) {
       // dropped, so drafter prose can never sit above (and be read instead of) the code's sentences (run mv5e1ktb).
       state.messages = state.messages.filter((/** @type {any} */ m) => m.kind !== 'plan');
       state.messages.push({
-        ...planMessage({ checkItems: state.finalPlan.checkItems, checks: state.finalPlan.checkItems.map((/** @type {any} */ c) => c.text), notChecked: state.finalPlan.notChecked, protections: state.finalPlan.protections, questions: [] }, jobLines),
+        ...planMessage({ checkItems: state.finalPlan.checkItems, checks: state.finalPlan.checkItems.map((/** @type {any} */ c) => c.text), notChecked: state.finalPlan.notChecked, protections: state.finalPlan.protections, signedFacts: state.finalPlan.signedFacts, questions: [] }, jobLines),
         text: 'These are the checks the signed close will run, and what it will not check. Sign & run to accept them, or Revise to edit the boxes and draft again.',
       });
     }