bareloop 0.43.0 → 0.45.0

package/src/pagerules.js

@@ -0,0 +1,318 @@
+// IDEA A CORE (docs/product/ITEM33-BUILD.md "Addendum 2026-10-18 — Idea A core: build spec", section 4.2): the plain code rules that
+// keep or drop each page word the AI's map named. The AI never grades: it names words, code keeps only what the saved page proves.
+// Pure - no I/O, no clock, no model. The rule bodies are PORTED from the frozen POC (.claude/scratch/idea-a-v2/rules.mjs and
+// rules-v3-candidate.mjs; sha256 recorded in commit 0bcc5fe), with the OUT branches (R2, R2a, R2b, R2c, R3, R3U, V4, pageClaims) deleted.
+
+import { lineRules } from './rubricstep.js';
+import { MAX_CURRENCIES, MAX_UNITS, MAX_UNIT_CHARS, FACT_OPS, boundOk } from './facts.js';
+import { countExact, countPhrase, squash } from './factwords.js';
+import { normLabel } from './labelscan.js';
+
+/**
+ * @typedef {{op: string, value?: string|number, lo?: string|number, hi?: string|number}} Reading what a `~` rule means as a limit (PRD v1.107 Part 5b): the same shape as a signed fact rule
+ * @typedef {{name: string, from?: string, shape: string, words?: string[], currency?: string[], unit?: string[], reading?: Reading}} MapFact the AI's map, one fact
+ * @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)
+ */
+
+/** @param {unknown} v @returns {v is Record<string, any>} */
+const isRec = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+/**
+ * Which job line, and which `~` rule under it, a map fact carries out. The map writes `from` as "line N", "line N rule M", "rule M" or
+ * "job line"; anything else is the first job line.
+ * @param {unknown} from @param {{n: number, text?: string, rule?: string, rules?: string[]}[]} jobLines
+ * @returns {{line: number, rule?: number}}
+ */
+export function tieOf(from, jobLines) {
+  const s = String(from ?? '');
+  const lineM = /line\s*(\d+)/i.exec(s);
+  const ruleM = /rule\s*(\d+)/i.exec(s);
+  const first = jobLines[0]?.n ?? 1;
+  let line = lineM && jobLines.some((l) => l.n === Number(lineM[1])) ? Number(lineM[1]) : null;
+  const rule = ruleM ? Number(ruleM[1]) : undefined;
+  if (line === null && rule !== undefined) line = jobLines.find((l) => lineRules(l).length >= rule)?.n ?? null;
+  const out = { line: line ?? first };
+  if (rule !== undefined && lineRules(jobLines.find((l) => l.n === out.line)).length >= rule) return { ...out, rule };
+  return out;
+}
+
+/**
+ * Is this a legal `reading` for a fact of this shape? Only a time or money fact carries one, with the op set and the bound types of a signed
+ * fact rule (src/facts.js): no other key, no missing bound. A malformed one makes the whole map answer malformed (no repair).
+ * @param {unknown} shape @param {unknown} r @returns {boolean}
+ */
+export function validReading(shape, r) {
+  if (shape !== 'time' && shape !== 'money') return false;
+  if (!isRec(r) || !FACT_OPS.includes(r.op)) return false;
+  const keys = Object.keys(r).sort().join();
+  return r.op === 'between' ? keys === 'hi,lo,op' && boundOk(shape, r.lo) && boundOk(shape, r.hi) : keys === 'op,value' && boundOk(shape, r.value);
+}
+
+/** @param {string} text @returns {string[]} the page's lines, white space squashed (the unit every per-line rule counts in) */
+export const linesOf = (text) => text.split('\n').map(squash);
+
+/**
+ * How many times a label occurs inside ONE page line, at most (plain indexOf on squashed lines, non-overlapping): the N2 measure.
+ * @param {string[]} lines @param {string} phrase @returns {number}
+ */
+function maxPerLine(lines, phrase) {
+  const p = squash(phrase).trim();
+  if (!p) return 0;
+  let max = 0;
+  for (const ln of lines) {
+    let n = 0;
+    for (let i = ln.indexOf(p); i !== -1; i = ln.indexOf(p, i + p.length)) n += 1;
+    if (n > max) max = n;
+  }
+  return max;
+}
+
+/** the value each shape reads right after a label: a money or number is digits (a sign may come first), a time is h:mm and AM/PM */
+const READ = {
+  money: /^\s*[$€£]?\s*(\d[\d,]*(?:\.\d+)?)/,
+  time: /^\s*(\d{1,2}:\d{2}[\s\u202f\u00a0]?[AaPp][Mm])/,
+  number: /^\s*(\d[\d,]*(?:\.\d+)?)/,
+};
+
+/**
+ * R1 reader: the set of values of a fact's shape written right after each occurrence of a label on the page.
+ * @param {string[]} lines @param {string} label @param {'money'|'time'|'number'} shape @returns {Set<string>}
+ */
+function valueSet(lines, label, shape) {
+  /** @type {Set<string>} */
+  const s = new Set();
+  const p = squash(label).trim();
+  if (!p) return s;
+  for (const ln of lines) {
+    for (let i = ln.indexOf(p); i !== -1; i = ln.indexOf(p, i + p.length)) {
+      const m = READ[shape].exec(ln.slice(i + p.length));
+      if (m) s.add(m[1]);
+    }
+  }
+  return s;
+}
+/** @param {Set<string>} a @param {Set<string>} b @returns {boolean} */
+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*$`);
+const AFTER = new RegExp(`^\\s*(?:[$€£]\\s*)?(${NUM})`);
+const AFTER_CUR = new RegExp(`^\\s*(${NUM})`);
+const stripCommas = (/** @type {string} */ s) => s.replace(/,/g, '');
+
+/** @param {string[]} lines @param {string} w @returns {[string, number][]} every occurrence of w as [its line, where it starts] */
+function occs(lines, w) {
+  /** @type {[string, number][]} */
+  const out = [];
+  for (const l of lines) for (let i = l.indexOf(w); i !== -1; i = l.indexOf(w, i + w.length)) out.push([l, i]);
+  return out;
+}
+
+/**
+ * U1: how many times a label has a number right BEFORE it (whitespace only between) and right AFTER it (whitespace and one currency sign
+ * between). A marker the page writes after the number ("490 total") has B > 0 and A = 0.
+ * @param {string[]} lines @param {string} label @returns {{B: number, A: number}}
+ */
+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 (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))));
+/** 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))));
+
+/** S1: a fact name that counts results ("the second flight") cannot be checked per result - one result is one record, ask for N results instead */
+const ORDINALS = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh', 'eighth', 'ninth', 'tenth', 'latest', 'earliest', 'newest', 'oldest', 'last', 'next', 'previous', 'final', 'nth'];
+
+/** the symbols a currency may be (src/facts.js); a code like "EUR" is a word read after the number, so it is a unit */
+const CURRENCY_SYMBOLS = ['$', '€', '£'];
+/** the shapes that read a value after a label */
+const VALUE_SHAPES = ['money', 'time', 'number'];
+
+/**
+ * Apply the rules to the AI's map over one saved page. Returns the kept facts and, for everything a rule removed, one `dropped` entry.
+ * The order of the rules is the POC's (apply-v3.mjs): found-on-page, then the rules that read the page. A place is read as a phrase.
+ * @param {string} text the frozen page text @param {PageMap} mapping @param {{n: number, text?: string, rule?: string, rules?: string[]}[]} jobLines
+ * @returns {{facts: KeptFact[], dropped: Dropped[]}}
+ */
+export function applyPageRules(text, mapping, jobLines) {
+  /** @type {Dropped[]} */
+  const dropped = [];
+  const all = Array.isArray(mapping?.facts) ? mapping.facts.filter(isRec) : [];
+  /** @type {Map<MapFact, {line: number, rule?: number}>} */
+  const ties = new Map(all.map((f) => [f, tieOf(f.from, jobLines)]));
+  const drop = (/** @type {MapFact} */ f, /** @type {string|undefined} */ word, /** @type {string} */ reason, /** @type {string|undefined} */ other = undefined) => {
+    const t = /** @type {{line: number, rule?: number}} */ (ties.get(f));
+    dropped.push({ line: t.line, ...(t.rule === undefined ? {} : { rule: t.rule }), fact: String(f.name ?? ''), ...(word === undefined ? {} : { word }), reason, ...(other === undefined ? {} : { other }) });
+  };
+
+  // ---- S1, name part: a fact whose name counts results is refused before anything else reads it ----
+  const list = all.filter((f) => {
+    const hit = String(f.name ?? '').toLowerCase().split(/[^a-z]+/).find((w) => ORDINALS.includes(w));
+    if (hit === undefined) return true;
+    drop(f, undefined, 's1-name');
+    return false;
+  });
+
+  // ---- found-on-page, then U1 and R1L for the facts that read an amount ----
+  const lines = linesOf(text);
+  /** @type {{f: MapFact, kept: string[], cur: string[], uni: string[], first?: string|null, anchorless?: boolean}[]} */
+  const pending = [];
+  for (const f of list) {
+    const words = (Array.isArray(f.words) ? f.words : []).map((w) => String(w)).filter((w) => w.trim() !== '');
+    if (f.shape === 'place' || f.shape === 'phrase') {
+      const kept = [];
+      for (const w of words) {
+        const n = f.shape === 'phrase' ? countPhrase(text, w) : countExact(text, w);
+        if (n >= 1) kept.push(w); else drop(f, w, 'not-on-page');
+      }
+      pending.push({ f, kept, cur: [], uni: [] });
+    } else if (VALUE_SHAPES.includes(String(f.shape))) {
+      const amount = f.shape === 'money' || f.shape === 'number';
+      /** labels the page holds (and, for an amount, that have a number right after them) */
+      const labels = [];
+      /** the AI's labels as U1 leaves them, a word the page does not hold included: the first of these is R1's reference */
+      const asListed = [];
+      /** U1: labels the page writes after the number */
+      const moved = [];
+      for (const w0 of words) {
+        const w = normLabel(w0);
+        if (!w) continue;
+        if (countExact(text, w) < 1) { asListed.push(w0); drop(f, w0, 'not-on-page'); continue; }
+        if (amount) {
+          const { B, A } = beforeAfter(lines, w);
+          if (A === 0 && B > 0) { moved.push(w); continue; }
+          if (A === 0 && B === 0) { drop(f, w, 'no-value'); continue; }
+        }
+        asListed.push(w0);
+        labels.push(w);
+      }
+      /** @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. 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) => {
+          if (!(CURRENCY_SYMBOLS.includes(u) && listedCurrencies.includes(u))) return true;
+          drop(f, u, 'sign-twice');
+          return false;
+        });
+        // 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 = [...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;
+        });
+        /** @type {{kind: 'unit'|'currency', w: string}[]} */
+        const forms = [...units.map((u) => /** @type {const} */ ({ kind: 'unit', w: u })), ...curs.map((c) => /** @type {const} */ ({ kind: 'currency', w: c }))];
+        if (forms.length) {
+          // R1L: every form reads the same set of numbers as the primary (the first form); one that reads more or fewer is dropped
+          const read = (/** @type {{kind: string, w: string}} */ x) => (x.kind === 'unit' ? unitSet(lines, x.w) : curSet(lines, x.w));
+          const ps = read(forms[0]);
+          const keep = [forms[0]];
+          // the same word listed as both a unit and a currency is ONE form: it is never compared with itself, only said (the unit, listed first, stays)
+          for (const x of forms.slice(1)) { if (x.w !== forms[0].w && sameSet(read(x), ps)) keep.push(x); else drop(f, x.w, 'r1l', forms[0].w); }
+          uni = keep.filter((x) => x.kind === 'unit').map((x) => x.w);
+          cur = keep.filter((x) => x.kind === 'currency').map((x) => x.w);
+        }
+        // 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; }
+          if (i >= MAX_UNITS) { drop(f, u, 'limit-unit'); return false; }
+          return true;
+        });
+        cur = cur.filter((c, i) => {
+          if (i < MAX_CURRENCIES) return true;
+          drop(f, c, 'limit-currency');
+          return false;
+        });
+      }
+      pending.push({ f, kept: labels, cur, uni, first: asListed.length ? normLabel(asListed[0]) : null, anchorless: amount && asListed.length === 0 });
+    } else drop(f, undefined, 'bad-shape');
+  }
+
+  // ---- R1, same-value: the labels after the AI's FIRST listed one are kept only if they read the same set of values as it does ----
+  for (const p of pending) {
+    if (!VALUE_SHAPES.includes(String(p.f.shape))) continue;
+    const shape = /** @type {'money'|'time'|'number'} */ (p.f.shape);
+    const ref = p.first ? valueSet(lines, p.first, shape) : new Set();
+    p.kept = p.kept.filter((w) => {
+      if (w === p.first) return true;
+      if (sameSet(valueSet(lines, w, shape), ref)) return true;
+      drop(p.f, w, 'r1', p.first ?? undefined);
+      return false;
+    });
+  }
+
+  // ---- N2, per line: a label written 2+ times inside one page line cannot say which value is meant, so it is unusable. (R2 grow-left is OUT.) ----
+  for (const p of pending) {
+    if (!VALUE_SHAPES.includes(String(p.f.shape))) continue;
+    p.kept = p.kept.filter((w) => {
+      if (maxPerLine(lines, w) <= 1) return true;
+      drop(p.f, w, 'n2');
+      return false;
+    });
+  }
+
+  // ---- the kept facts, in the POC's order: places, phrases, then values ----
+  /** @type {KeptFact[]} */
+  const signed = [];
+  const make = (/** @type {{f: MapFact, kept: string[], cur: string[], uni: string[]}} */ p) => {
+    const t = /** @type {{line: number, rule?: number}} */ (ties.get(p.f));
+    /** @type {KeptFact} */
+    const out = { line: t.line, name: String(p.f.name), shape: p.f.shape === 'place' ? 'phrase' : String(p.f.shape), from: String(p.f.from ?? ''), words: [...p.kept] };
+    if (p.f.shape === 'money') {
+      if (p.uni.length) out.unit = [...p.uni];
+      if (p.cur.length) out.currency = [...p.cur];
+    }
+    if (t.rule !== undefined) out.forRule = t.rule;
+    if (validReading(out.shape, p.f.reading)) out.reading = /** @type {Reading} */ ({ ...p.f.reading });
+    return out;
+  };
+  for (const kind of ['place', 'phrase', 'value']) {
+    for (const p of pending) {
+      const isValue = VALUE_SHAPES.includes(String(p.f.shape));
+      if (kind === 'value' ? !isValue : p.f.shape !== kind) continue;
+      // a fact left with no label is dropped, unless U1 moved every label to a unit/currency form of a money fact (it then reads that form
+      // alone); a money fact also needs a currency or a unit the page holds
+      const forms = p.cur.length + p.uni.length;
+      const ok = p.f.shape === 'money' ? forms > 0 && (p.kept.length > 0 || p.anchorless === true) : p.kept.length > 0;
+      if (!ok) { drop(p.f, undefined, 'no-label'); continue; }
+      signed.push(make(p));
+    }
+  }
+  // ---- S1, shape and label part: two facts of one result may not share a shape AND a label (they would read the same value and can never differ).
+  // The first one stays; a fact with no label is keyed by its first unit or currency, so two different amounts are never confused. ----
+  /** @type {Map<string, string>} */
+  const seen = new Map();
+  const kept = signed.filter((k) => {
+    const key = `${k.shape}\u0000${k.words[0] ?? k.unit?.[0] ?? k.currency?.[0] ?? ''}`;
+    const first = seen.get(key);
+    if (first === undefined) { seen.set(key, k.name); return true; }
+    const f = /** @type {MapFact} */ (all.find((x) => String(x.name) === k.name));
+    drop(f, undefined, 's1', first);
+    return false;
+  });
+  const order = list.map((f) => String(f.name));
+  return { facts: kept.sort((a, b) => order.findIndex((n) => a.name.startsWith(n)) - order.findIndex((n) => b.name.startsWith(n))), dropped };
+}

package/src/panel/authorroutes.js

@@ -19,24 +19,27 @@
 
 import { randomBytes } from 'node:crypto';
 import { spawn as realSpawn } from 'node:child_process';
-import { openSync } from 'node:fs';
+import { openSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { readFileSync } from 'node:fs';
 import { planMatchesClose } from '../rubricstep.js';
 import { createSession, validateJobCard, validateReuseCard, jobBoxesChanged, buildReuseSpec, cardFields, nextFreeJobName, startDestinationProblem, STEP_LABELS } from './authorsession.js';
 import { parseInputs } from '../jobblock.js';
-import { proveInputFiles, looksLikeRubricInput } from '../source.js';
+import { proveInputFiles, looksLikeRubricInput, webFetchState } from '../source.js';
 import { validateJob } from '../job.js';
 
 /** plain words for a run whose saved job no longer passes today's `validateJob` (RULED 2026-10-15): never the raw red codes */
 export const OLD_JOB_REUSE_WORDS = "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be reused. Start a new job instead.";
 export const OLD_JOB_RESUME_WORDS = "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be resumed. Use Reuse workflow on a newer run, or start a new job.";
 export const OLD_JOB_ACCEPT_WORDS = "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be accepted. Use Reuse workflow on a newer run, or start a new job.";
+export const OLD_JOB_RERUN_WORDS = "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be rerun. Use Reuse workflow on a newer run, or start a new job.";
+export const OLD_JOB_PAUSE_WORDS = "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be paused from here. Use Reuse workflow on a newer run, or start a new job.";
 import { checkMonthlyRoom, monthlyRefusalText } from '../monthly.js';
 import { ConfigError } from '../config.js';
 import { keysForDoor, keysHome } from '../keysfile.js';
 import { endpointOf, judgePick, keyValueOf, rowsForHome, tickedLines } from '../providerrows.js';
 import { thinkingForLine } from '../thinking.js';
+import { panelMoney2 } from '../panelmoney.js';
 import { apiKeyProblem, checkProviderReachable } from '../providers.js';
 
 /** @returns {string} a fresh per-process token — never persisted, never logged */
@@ -90,6 +93,18 @@ export function checkHumanGuard(req, { token, port }) {
  * one; a terminal session is kept (so its chat/hash stay readable) but no
  * longer counts against the one-at-a-time rule.
  */
+/**
+ * PRD v1.106 Part 5 Q2: the "fetching the page..." step is done once the run's own refetch has written `refrozenAt` (source.json, written last).
+ * Settled when the state is read, so nothing polls and the step never stays running after the fetch.
+ * @param {any} state
+ */
+export function settleFetchingStep(state) {
+  const st = Array.isArray(state?.steps) ? state.steps.find((/** @type {any} */ x) => x.id === 'fetching') : null;
+  if (!st || st.status !== 'running') return;
+  const file = join(String(state.outDir), 'source-seed', 'source.json');
+  if (existsSync(file) && !webFetchState(file, st.since).fetching) st.status = 'done';
+}
+
 const TERMINAL_PHASES = new Set(['refused', 'abandoned', 'error', 'signed', 'signing-failed']);
 
 /**
@@ -131,11 +146,17 @@ export function createAuthorRoutes(opts) {
    * @param {any} card the form (fields only)
    * @param {{spec: any, workflowKey: string}|null} reuse
    * @param {import('../jobblock.js').JobInput[]} inputs the parsed Inputs
-   * @param {{headless?: boolean, filesJob?: boolean}} [o]
+   * @param {{headless?: boolean}} [o]
    * @returns {Promise<{ok: true, session: ReturnType<typeof createSession>}|{ok: false, status: number, error: string}>}
    */
   function startSession(card, reuse, inputs, o = {}) {
-    return (o.filesJob ? Promise.resolve(/** @type {{ok: true}} */ ({ ok: true })) : proveInputFiles(inputs)).then((proof) => {
+    // ONE owner of "is this a rubric job on files": a reuse (and so a scheduled fire) reads it from the signed spec's verdict type,
+    // never from the card; a fresh job reads the card. A rubric job whose line 1 is a file or URL has no repo to prove inputs against;
+    // the session proves every line itself (`proveRubricInputs`), at $0, before any model call.
+    const rubric = reuse ? reuse.spec?.verdictType === 'soft-green' : card?.checkType === 'rubric';
+    if (reuse) card = { ...card, checkType: rubric ? 'rubric' : 'deterministic' };
+    const filesJob = rubric && inputs.length > 0 && looksLikeRubricInput(inputs[0].value);
+    return (filesJob ? Promise.resolve(/** @type {{ok: true}} */ ({ ok: true })) : proveInputFiles(inputs)).then((proof) => {
       if (!proof.ok) return { ok: /** @type {false} */ (false), status: 400, error: proof.error };
       if (!o.headless && hasLiveSession()) return { ok: /** @type {false} */ (false), status: 409, error: 'an authoring session is already live — one at a time' };
       // the SAME Destination check the session runs, at $0, BEFORE the session (and its folder) exists
@@ -299,6 +320,7 @@ export function createAuthorRoutes(opts) {
     if (pathname === '/api/author/live') {
       if (req.method !== 'GET') { send(405, { ok: false, error: 'GET only' }); return true; }
       const live = [...sessions.values()].find((s) => !TERMINAL_PHASES.has(s.state.phase));
+      if (live) settleFetchingStep(live.state);
       send(200, { ok: true, sessionId: live ? live.state.id : null, state: live ? live.state : null });
       return true;
     }
@@ -357,10 +379,7 @@ export function createAuthorRoutes(opts) {
       // A miss is a plain 400 naming the line, shown under the card exactly like every other refused start.
       const ip = parseInputs(card.inputs);
       if (!ip.ok) { send(400, { ok: false, error: ip.error }); return true; }
-      // Part 1a: a rubric job whose first input is a local FILE has no repo to prove inputs against; the session proves every
-      // line itself (`proveRubricInputs`), at $0, before any model call
-      const filesJob = reuse === null && card?.checkType === 'rubric' && looksLikeRubricInput(ip.inputs[0].value);
-      startSession(card, reuse, ip.inputs, { filesJob }).then((r) => {
+      startSession(card, reuse, ip.inputs).then((r) => {
         if (!r.ok) { send(r.status, { ok: false, error: r.error }); return; }
         send(200, { ok: true, sessionId: r.session.id, reuse: reuse !== null, state: r.session.state });
       });
@@ -375,6 +394,7 @@ export function createAuthorRoutes(opts) {
 
     if (sub === null) {
       if (req.method !== 'GET') { send(405, { ok: false, error: 'GET only' }); return true; }
+      settleFetchingStep(session.state);
       send(200, { ok: true, state: session.state });
       return true;
     }
@@ -417,28 +437,7 @@ export function createAuthorRoutes(opts) {
   };
 }
 
-/**
- * The panel's OWN 2-decimal money render for a chat line — hamr's ruling
- * 2026-09-28 (2nd addendum, panel money 2-decimals): a positive amount below
- * a cent reads `<$0.01`, never `$0.00` (a real cost must never read as
- * free). This is the server-side (Node, chat-text) sibling of
- * `src/panel/index.html`'s own inline `panelMoney` — the two can't share
- * code (one runs in the browser as inlined script, the other in Node), the
- * same duplication `src/replay.js`'s `money()`/`index.html`'s `money()`
- * already carry, so both apply the identical rule rather than drift.
- * @param {number} n a non-negative dollar amount
- * @returns {string}
- */
-export function panelMoney2(n) {
-  if (n > 0 && n < 0.01) return '<$0.01';
-  // two-step rounding (matching index.html's own panelMoney): clean to
-  // 6-decimal precision first (the same precision src/text.js's tallyCalls
-  // sums to) before rounding to cents, so a summed float landing just under
-  // an exact cent boundary is never mis-rounded.
-  const clean = Math.round(n * 1e6) / 1e6;
-  const cents = Math.round(clean * 100 + 1e-6);
-  return `$${(cents / 100).toFixed(2)}`;
-}
+export { panelMoney2 };
 
 /**
  * THE ONLY function in this file (or anywhere in the panel) that spawns a
@@ -520,5 +519,10 @@ export function signRun(session, claimedHash, o) {
     ? `drafting spent ${draftIncomplete ? 'at least ' : ''}${panelMoney2(draftSpentUsd)} (folds out of the run's own cap)`
     : '';
   if (Array.isArray(session.state.steps)) session.state.steps.push({ id: 'signed', label: STEP_LABELS.signed, status: 'done', detail: draftLine });
+  // PRD v1.106 Part 5 Q2: a run with a web input fetches the page again before its log exists (3-5 s of silence): say so, next to the sign step
+  const sinceIso = new Date().toISOString();
+  if (Array.isArray(session.state.steps) && webFetchState(join(session.state.outDir, 'source-seed', 'source.json'), sinceIso).hasWeb) {
+    session.state.steps.push({ id: 'fetching', label: STEP_LABELS.fetching, status: 'running', since: sinceIso });
+  }
   return { ok: true, job: session.state.resolvedSpecPath };
 }

package/src/panel/authorsession.js

@@ -51,8 +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';
@@ -85,6 +87,7 @@ export const STEP_LABELS = Object.freeze({
   gates: 'checking signing gates',
   hash: 'generating hash',
   signed: 'signed hash',
+  fetching: 'fetching the page…',
 });
 
 /**
@@ -116,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',
@@ -164,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[]}}}
  */
@@ -402,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
@@ -539,13 +545,27 @@ export function createSession(card, deps = {}) {
    * @param {{kind: string, [k: string]: any}} step
    * @returns {Promise<string|null>}
    */
-  const ask = (step) => new Promise((resolveFn) => {
+  const ask = (step) => new Promise((resolveFn0) => {
+    // PRD v1.106 Part 5 Q1: every question the person answers (the confirm card's, the early look ask, the last-try ask) is one `human` row in the
+    // drafting log, with the answer secret-masked BEFORE it is written. Written only when the answer exists (a blank one re-asks and leaves nothing).
+    const resolveFn = step.kind !== 'answer' ? resolveFn0 : (/** @type {string|null} */ value) => {
+      const said = value === null ? '' : redactSecrets(String(value).trim());
+      if (said !== '' && typeof step.question === 'string') {
+        const running = state.steps.findLastIndex((/** @type {any} */ x) => x.status === 'running');
+        appendDraftLog(outDir, {
+          kind: 'human', no: running === -1 ? Math.max(0, state.steps.length - 1) : running, source: typeof step.source === 'string' ? step.source : 'confirm',
+          question: redactSecrets(step.question), answer: said, ...(Number.isInteger(step.line) ? { line: step.line } : {}), at: new Date().toISOString(),
+        });
+      }
+      resolveFn0(value);
+    };
     state.pendingAsk = step;
     resolvePending = resolveFn;
     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.');
   });
 
@@ -560,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
@@ -639,6 +672,8 @@ export function createSession(card, deps = {}) {
       kind: 'call', no: callNo, step: state.steps[callNo]?.id ?? null, label: call.label, model: draftIdentity?.model ?? null,
       thinking: draftThinkingPlan === null ? null : draftThinkingPlan.mode, thinkingSupport: draftThinkingPlan === null ? null : draftThinkingPlan.support,
       ...(call.thinkingStatus === undefined ? {} : { thinkingStatus: call.thinkingStatus }),
+      // idea A core: the page-word map's scrubbed answer (src/pagemap.js) - unsigned, kept so a run can be replayed at $0
+      ...(typeof call.raw === 'string' ? { raw: call.raw } : {}),
       costUsd: call.costUsd ?? null, unpricedRounds: call.unpricedRounds ?? 0, at: nowIso,
     });
     try {
@@ -1021,27 +1056,44 @@ export function createSession(card, deps = {}) {
     // ask path as every other (the chat box + Send); the answer is REQUIRED (a blank one asks again, there is no skip) and is
     // added WORD FOR WORD as a `~` rule on the job line it names — never rewritten. The lines are mutated in place, so the
     // signed `jobLines`, the answers text and the plan card all read the same words.
-    const answerQuestions = async (/** @type {{questions: {line: number, question: string}[], dropped: {reason: string, raw: any}[], confirmed: any}} */ o) => {
+    const answerQuestions = async (/** @type {{questions: {line: number, question: string, rule?: number, source?: string, ask?: string, reading?: string}[], dropped: {reason: string, raw: any}[], confirmed: any}} */ o) => {
       if (o.dropped.length) appendDraftLog(outDir, { kind: 'questions-dropped', no: Math.max(0, state.steps.length - 1), dropped: o.dropped, at: new Date().toISOString() });
       const total = o.questions.length;
+      /** @type {{line: number, rule: number}[]} */
+      const left = [];
       for (let k = 0; k < total; k += 1) {
         const q = o.questions[k];
         let text = '';
         for (;;) {
-          const a = await ask({ kind: 'answer', index: k + 1, total, question: q.question, line: q.line });
+          const a = await ask({ kind: 'answer', source: typeof q.source === 'string' ? q.source : 'try-3', index: k + 1, total, question: q.question, line: q.line });
           if (a === null) return null;
           // one `~` line is one line: the person's own words, newlines folded to spaces, nothing else touched
           text = String(a).replace(/\s*\n\s*/g, ' ').trim();
           if (text) break;
           say('bot', 'An answer is needed here — there is no skip. Type it in the box below and press Send.');
         }
+        // PRD v1.107 Part 5b: a code-forced look question about a `~` rule. A can't-check ask answered "drop it" adds NO rule; the caller puts that
+        // rule on the look's Not checked list. A reading ask answered "agree" adds the code's reading, in plain words, as the `~` rule (so the
+        // bound is now the person's own words); anything else typed is the person's own rule, word for word.
+        if (q.source === 'look' && q.ask === 'reading' && typeof q.reading === 'string' && isAgree(text)) text = q.reading;
+        if (q.source === 'look' && q.ask === 'cant-check' && Number.isInteger(q.rule) && isDropIt(text)) { left.push({ line: q.line, rule: /** @type {number} */ (q.rule) }); continue; }
         const line = jobLines.find((l) => l.n === q.line);
         if (line) { line.rule = line.rule ? `${line.rule}; ${text}` : text; line.rules.push(text); }
       }
       draft.jobLines = signedJobLines(jobLines);
       answers[1] = renderJobLines(jobLines);
-      state.messages.push({ ...planMessage(o.confirmed ?? {}, jobLines), text: 'Your answers are in as ~ rules on those job lines. Drafting again.' });
-      return { jobLines, answers };
+      state.messages.push({ ...planMessage(o.confirmed ?? {}, jobLines), text: left.length === total ? 'Noted: those stay Not checked. Drafting.' : 'Your answers are in as ~ rules on those job lines. Drafting again.' });
+      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';
@@ -1063,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 } : {}),
     });
 
@@ -1111,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') {
@@ -1120,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.',
       });
     }