bareloop 0.42.0 → 0.44.0

package/src/authorflow.js

@@ -87,7 +87,8 @@ import {
 import { buildSeedListing, cleanEntry, SURVEY_CAUSES, AUTHOR_CALL_TIMEOUT_MS } from './authorscout.js';
 import { extractArtifact, priceOf, scrubRaw, tallyCalls, capStop, callCasualty } from './text.js';
 import { redactSecrets } from './validate.js';
-import { stepFileContract, inputLabelsOf, stepFileRel, readFrozenInputs, withFactBindings, settlePersonsWords } from './rubricstep.js';
+import { stepFileContract, inputLabelsOf, stepFileRel, readFrozenInputs, withFactBindings, settlePersonsWords, withDropNotes, lineRules } from './rubricstep.js';
+import { dropRows, dropLine } from './pagedropwords.js';
 import { factShapeGuide } from './facts.js';
 import { renderLookReport, labelListsOf } from './inputlook.js';
 import { checkDeclarationWords } from './factwords.js';
@@ -116,8 +117,8 @@ export const AUTHOR_MAX_TOKENS = 32000;
 /** the one slot the model fills on an injected guard */
 export const FILL_MARKER = '<FILL IN>';
 
-/** P7 item 5 (fwdloop am24/25): the most questions the MACHINE keeps from the try-3 drafter. The drafter is never told this number. */
-export const MAX_QUESTIONS = 2;
+/** P7 item 5 (fwdloop am24/25): the most questions the MACHINE keeps from the try-3 drafter. The drafter is never told this number. PRD v1.107 Part 5b: three (hamr's ruling), shared with the code-forced early asks. */
+export const MAX_QUESTIONS = 3;
 
 /**
  * The model-visible words of the optional `questions` property — offered ONLY on the last drafting try and only after the
@@ -158,10 +159,10 @@ export function linesNamedByReds(reds, declaration, lineNums) {
  * The machine's keep-or-drop of the try-3 questions. Kept only when its line is one the previous try's reds named and its
  * text is non-blank, at most {@link MAX_QUESTIONS}; every drop comes back with its reason, for the draft's log.
  * @param {any} raw @param {number[]} failedLines
- * @returns {{kept: {line: number, question: string}[], dropped: {reason: string, raw: any}[]}}
+ * @returns {{kept: {line: number, question: string, rule?: number, source?: string, ask?: 'reading'|'cant-check', reading?: string}[], dropped: {reason: string, raw: any}[]}}
  */
 export function normalizeQuestions(raw, failedLines) {
-  /** @type {{line: number, question: string}[]} */
+  /** @type {{line: number, question: string, rule?: number, source?: string, ask?: 'reading'|'cant-check', reading?: string}[]} */
   const kept = [];
   /** @type {{reason: string, raw: any}[]} */
   const dropped = [];
@@ -172,7 +173,13 @@ export function normalizeQuestions(raw, failedLines) {
     if (!failedLines.includes(q.line)) { dropped.push({ reason: `line ${q.line} is not a line the previous try's checks failed on`, raw: q }); continue; }
     if (typeof q.question !== 'string' || q.question.trim() === '') { dropped.push({ reason: 'blank question', raw: q }); continue; }
     if (kept.length >= MAX_QUESTIONS) { dropped.push({ reason: 'beyond the machine\'s limit', raw: q }); continue; }
-    kept.push({ line: q.line, question: redactSecrets(q.question.trim()) });
+    kept.push({
+      line: q.line, question: redactSecrets(q.question.trim()),
+      // PRD v1.106 Part 5 Q3: a code-forced question (the early look ask) names the `~` rule it is about and says so; a model's question has neither
+      ...(Number.isInteger(q.rule) ? { rule: q.rule } : {}), ...(typeof q.source === 'string' ? { source: q.source } : {}),
+      // PRD v1.107 Part 5b: the kind of a code-forced ask, and (reading asks) the plain words `agree` writes as the `~` rule
+      ...(q.ask === 'reading' || q.ask === 'cant-check' ? { ask: q.ask } : {}), ...(q.ask === 'reading' && typeof q.reading === 'string' ? { reading: redactSecrets(q.reading) } : {}),
+    });
   }
   return { kept, dropped };
 }
@@ -838,8 +845,8 @@ export const PARAM_SCHEMAS = Object.freeze({
             properties: {
               name: { type: 'string', minLength: 1, description: 'what the fact is called: letters and spaces only, no digits' },
               shape: { enum: ['money', 'number', 'date', 'time', 'phrase', 'text'], description: 'money / number / date / time may carry a rule; phrase = fixed words the quote must contain; text = words the quote holds, as it writes them' },
-              unit: { type: 'string', minLength: 1, description: 'money: the words the input writes after the amount, copied verbatim (or give currency instead)' },
-              currency: { enum: ['$', '€', '£'], description: 'money: the symbol the input writes before the amount (or give unit instead)' },
+              unit: { anyOf: [{ type: 'string', minLength: 1 }, { type: 'array', minItems: 1, maxItems: 10, uniqueItems: true, items: { type: 'string', minLength: 1 } }], description: 'money: the words the input writes after the amount, copied verbatim - one, or a list of up to 10 (give unit, currency, or both)' },
+              currency: { anyOf: [{ enum: ['$', '€', '£'] }, { type: 'array', minItems: 1, maxItems: 3, uniqueItems: true, items: { enum: ['$', '€', '£'] } }], description: 'money: the symbol the input writes before the amount - one, or a list of up to 3 (give unit, currency, or both)' },
               phrase: { type: 'string', minLength: 1, description: 'phrase only: the fixed words, copied verbatim from the input' },
               anchor: { type: 'string', minLength: 1, description: 'a label copied VERBATIM from the input that sits right before the value (picks the right one when a result holds several)' },
               until: { type: 'string', minLength: 1, description: 'text with an anchor: the label copied VERBATIM that ends the value' },
@@ -1433,6 +1440,11 @@ export const REQUIRED_FACTS_BRIEF = 'REQUIRED FACTS — what a line that finds,
   + 'as the look gives it (the look\'s phrase facts become phrase facts with the same words), and say in "notes" when you used the input\'s '
   + 'words instead of the person\'s. A label (anchor) is PICKED from the labels the look found in the input, never typed; one that is not '
   + 'among them is refused at $0. What the look could not find is not checked: list it under "refused" in the person\'s words.\n'
+  + ' - A money fact names at least one of "unit" (the words the input writes after the amount) or "currency" (a sign: $, € or £), and may name both. Each is one value or a list: '
+  + 'at most 3 currencies and 10 units, none repeated, a unit at most 100 characters. A code like EUR is a unit (it is read after the number), never a currency. '
+  + 'Copy the forms the look gives for the fact, in its order (the first is the main one); a form the look does not give is refused at $0.\n'
+  + ' - A word the look lists under NOT CHECKED or LEFT OUT is never used in a fact - not as a label, a closing label, a unit or a currency - and is refused at $0 with the reason if you do. '
+  + 'A fact or ~ rule listed under NOT CHECKED is not turned into a check: code lists it under Not checked for the person, so you do not write it into "refused" yourself.\n'
   + ' - When one result holds several values of one kind (leaves / arrives, subtotal / total) give the fact an anchor, the label that sits right before the value you mean.\n'
   + ' - Set aiProposal true on a fact whose number you made out of their words.\n'
   + RUBRIC_RULES + '\n'
@@ -2378,7 +2390,7 @@ export async function runConfirmTurn({
     for (let i = 0; i < qs.length; i += 1) {
       const question = qs[i];
       for (;;) {
-        const raw = await ask({ kind: 'answer', field: ANSWER_QUESTION_FIELD, question, index: i + 1, total: qs.length });
+        const raw = await ask({ kind: 'answer', source: 'confirm', field: ANSWER_QUESTION_FIELD, question, index: i + 1, total: qs.length });
         if (raw === null) return null;
         const trimmed = redactSecrets(String(raw).trim());
         if (trimmed === '') continue; // blank is not an answer — re-ask the same question
@@ -2426,7 +2438,10 @@ export async function runConfirmTurn({
     // the list the model was prompted with is byte-identical to the list
     // shown at confirm-done and recorded on acceptance. `notChecked` is the
     // model's own honest gap list, carried through unchanged.
+    // NO SILENT DROP (idea A core, spec 4.5): what the page rules removed is said HERE too, in the same words as the signed plan, before
+    // drafting is paid for. The words come from the one table (src/pagedropwords.js).
     const notChecked = [...(r.plan.notChecked ?? [])];
+    for (const row of dropRows(facts?.look?.dropped)) { const text = dropLine(row, jobLines, lineRules); if (!notChecked.includes(text)) notChecked.push(text); }
     const checkItems = normalizeChecks(r.plan.checks);
     r.plan = { ...r.plan, checks: checkItems.map((c) => c.text), checkItems };
     const plan = { ...r.plan, protections, notChecked };
@@ -2941,12 +2956,12 @@ export async function authorClose({
       previous = ask.declaration;
 
       // PART 1b: code puts the number tie on every prose step that follows a fact step, before anything is validated or signed
-      let v = validateDeclaration(withFactBindings(settlePersonsWords(ask.declaration, jobLines)), { catalogue, listing: seedFiles, guards, envOwned: ownedEnvNames, verdictType, writeScope, jobLines, inputLabels: inputLabelsOf(inputs) });
+      let v = validateDeclaration(withFactBindings(withDropNotes(settlePersonsWords(ask.declaration, jobLines), facts?.look?.dropped, jobLines)), { catalogue, listing: seedFiles, guards, envOwned: ownedEnvNames, verdictType, writeScope, jobLines, inputLabels: inputLabelsOf(inputs) });
       // PART 1c: code proves, at $0, that every label is PICKED from the input's own list and every word a fact depends on is really
       // in the source (white-space blind, once is enough). A word that is not found is a red naming the word and the input; the
       // drafter revises like it does for any validation red.
       if (v.ok && lang === RUBRIC_LANG) {
-        const words = checkDeclarationWords(v.declaration, inputTexts);
+        const words = checkDeclarationWords(v.declaration, inputTexts, facts?.look ?? null);
         if (words.length > 0) v = { ...v, ok: false, reds: [...v.reds, ...words], declaration: null };
       }
       // SCRUBBED HERE, once, where the reds enter this module's records — the same

package/src/authoring.js

@@ -355,7 +355,7 @@ export const KIND_CATALOGUE = Object.freeze({
     shape: 'step: integer (the job line number), parts: [{text: string, class: "countable" | "fact" | "judged" | "guard" | "none", '
       + 'check?: "maxWords" | "minWords" | "maxLines" | "sections" | "sectionWords" | "cited" | "minClaims" | "maxClaims", value?: integer, names?: string[], '
       + 'wordsPerSection?: integer, source?: string (an input label), domains?: string[], covers?: integer[], rules?: integer[], '
-      + 'fact parts: facts?: [{name, shape: "money"|"number"|"date"|"time"|"phrase"|"text", unit?|currency?, phrase?, anchor?, until?, '
+      + 'fact parts: facts?: [{name, shape: "money"|"number"|"date"|"time"|"phrase"|"text", unit?|currency? (each one value or a list; money names at least one), phrase?, anchor?, until?, '
       + 'rule?: {op, value | lo+hi}, aiProposal?: boolean}], count?: {min?, max?}}]',
     asserts: 'the file output/<step>.json under output/steps/ exists, is a JSON object, and its "text" is present and within the '
       + 'limits the person asked for. Write ONE rubric-step stage per numbered job line (step = that line number, fromLine = [that line]). '

package/src/authorjob.js

@@ -100,7 +100,7 @@
 
 import { jobSpecHash, validateJob } from './job.js';
 import { seedAtHead, seedListing, seedRead as runSeedRead, makeSeedTrees, judgedStages, closeJudges } from './kinds.js';
-import { inputLabelsOf, readFrozenInputs } from './rubricstep.js';
+import { inputLabelsOf, readFrozenInputs, lineRules } from './rubricstep.js';
 import { proverOf } from './factwords.js';
 // SOFTGREEN modules 4 and 5 — the compile the interview's Q6/Q7 answers land in,
 // and the gate that decides whether the ruler they describe is a ruler.
@@ -113,12 +113,12 @@ import {
 } from './authoring.js';
 import {
   QUESTION_SETS, questionsFor, requiredAnswersFor, authorClose, makeCostBook,
-  runConfirmTurn, LANGUAGE_PICK_FIELD, normalizeQuestions,
+  runConfirmTurn, LANGUAGE_PICK_FIELD, normalizeQuestions, MAX_QUESTIONS,
 } from './authorflow.js';
-import { ruleQuestions } from './inputlook.js';
 import { thinkingCallOptions, assertThinkingMode } from './thinking.js';
 import { pageContentChars } from './pagefetch.js';
-import { runAuthorScout, runInputLook, buildSeedListing, SCOUT_ATTEMPTS } from './authorscout.js';
+import { runAuthorScout, buildSeedListing, SCOUT_ATTEMPTS } from './authorscout.js';
+import { runPageMap, askableFromLook, tooManyAsksText } from './pagemap.js';
 import {
   DECLARED_GAP_PREFIX, DECLARED_GENRES, guardNames, isDeclaredClose, validateCloseDecl,
 } from './declaredclose.js';
@@ -433,8 +433,8 @@ function composerRefusal(reds) {
  *   authorFn?: Function, authorOpts?: object, writeScope?: string[]|null,
  *   signerFix?: Function|any, proposeFn?: Function, compileOpts?: object,
  *   ask?: ((step: {kind: string, [k: string]: any}) => Promise<string|null>)|null,
- *   answerQuestions?: ((o: {questions: {line: number, question: string}[], dropped: {reason: string, raw: any}[], confirmed: any}) =>
- *     Promise<{jobLines: {n: number, text: string, rule?: string}[], answers: Record<string|number, any>}|null>)|null,
+ *   answerQuestions?: ((o: {questions: {line: number, question: string, rule?: number, source?: string, ask?: string, reading?: string}[], dropped: {reason: string, raw: any}[], confirmed: any}) =>
+ *     Promise<{jobLines: {n: number, text: string, rule?: string}[], answers: Record<string|number, any>, left?: {line: number, rule: number}[]}|null>)|null,
  *   confirmGenerate?: Function|null, isRepo?: boolean,
  *   langResult?: {kind: string, candidates?: string[], [k: string]: any}|null}} o
  * @returns {Promise<{ok: boolean, refusal: Refusal|null, verdictType: string|null,
@@ -470,9 +470,9 @@ export async function authorCloseForJob({
   // callback back, and no decision in this file or below it depends on one.
   onPhase = () => {}, onCall = () => {},
   seedFn = seedAtHead, scoutFn = runAuthorScout, listingFn = buildSeedListing,
-  // PART 1c - the look at a rubric job's inputs (src/authorscout.js `runInputLook`). `null` is an explicit "no look" (a test seam, like
-  // a caller-supplied `scout`); the shipped default is the real, paid, read-only look.
-  lookFn = runInputLook,
+  // PART 1c / IDEA A CORE - the look at a rubric job's inputs: the default is the page-word map (src/pagemap.js `runPageMap`, one paid AI
+  // call per page input, its words kept by code). `null` is an explicit "no look" (a test seam, like a caller-supplied `scout`).
+  lookFn = runPageMap,
   authorFn = authorClose, authorOpts = {},
   // SOFTGREEN modules 4+5. `signerFix` is the D5 seam: a function (or a value)
   // carrying the SIGNER's corrected artifacts back. Absent means the proposal is
@@ -645,12 +645,18 @@ export async function authorCloseForJob({
     onPhase('scout-done', { state: survey?.state ?? null, facts: Object.keys(survey?.facts ?? {}).length });
   }
 
-  // PART 1c, I1 (hamr 2026-10-13): the look found that the person's intent on a particular `~` rule was NOT captured (its words or
-  // meaning are not in the source) - ask about THAT rule at once, before any plan or draft is paid for. The question gate is the
-  // existing one (`answerQuestions`: answer required, no skip, the answer becomes a `~` rule on its line; `normalizeQuestions` keeps
-  // at most MAX_QUESTIONS, each on a line the look named). Everything else the look could not find asks nothing piecemeal.
-  if (answerQuestions && lang === RUBRIC_LANG && survey?.state === 'PRESENT' && Array.isArray(survey.facts?.look?.notFound) && Array.isArray(jobLines)) {
-    const candidates = ruleQuestions(survey.facts.look.notFound, jobLines);
+  // PRD v1.106 Part 5 Q3 (T2) + v1.107 Part 5b: CODE forces the early asks, from the look's own result, before any plan or draft is paid for
+  // (src/pagemap.js `askableFromLook`; the model never decides whether to ask). Two kinds: a READING the code made of a `~` rule whose limit the
+  // person did not write (agree / type their own), and a rule the page cannot check (drop it / type how). More than MAX_QUESTIONS asks is a job to
+  // rewrite, not a questionnaire: nothing is asked, nothing more is spent, and the stop lists every ask with its reading. The question gate is the
+  // existing one (`answerQuestions`: answer required, no skip, the answer becomes a `~` rule on its line; `normalizeQuestions` keeps at most
+  // MAX_QUESTIONS). The answer "drop it" adds no rule: the rule is put on the look's own dropped list, so it reads Not checked on the
+  // confirm card, in the signed plan and in the drafter's block, and can never be written back as a check.
+  if (answerQuestions && lang === RUBRIC_LANG && survey?.state === 'PRESENT' && survey.facts?.look && typeof survey.facts.look === 'object' && Array.isArray(jobLines)) {
+    const candidates = askableFromLook(survey.facts.look, jobLines);
+    if (candidates.length > MAX_QUESTIONS) {
+      return { ...base, interview, verdictType: picked, seedRef: seed, reds: [{ code: 'look-asks-too-many', path: 'jobLines', detail: tooManyAsksText(candidates) }], stop: 'look-asks-too-many', cost: null };
+    }
     const kept = normalizeQuestions(candidates, [...new Set(candidates.map((q) => q.line))]);
     if (kept.kept.length > 0) {
       onPhase('look-ask', { questions: kept.kept.length });
@@ -658,6 +664,12 @@ export async function authorCloseForJob({
       if (updated === null) return { ...base, interview, verdictType: picked, seedRef: seed, reds: [], stop: 'confirm-abandoned', cost: null };
       jobLines = updated.jobLines;
       interview.answers = updated.answers;
+      for (const lf of Array.isArray(updated.left) ? updated.left : []) {
+        const ruleText = lineRules(jobLines.find((l) => l.n === lf.line) ?? {})[lf.rule - 1];
+        if (ruleText === undefined) continue;
+        const look = survey.facts.look;
+        look.dropped = [...(Array.isArray(look.dropped) ? look.dropped : []), { line: lf.line, rule: lf.rule, fact: ruleText, reason: 'person-left', source: 'person' }];
+      }
     }
   }
 
@@ -1026,6 +1038,12 @@ export function assembleSpec(specDraft, { closeDecl, verdictType }) {
       + 'this fold writes it. Merging would drop or overwrite what the draft says, and a signed spec that does not '
       + 'contain what its author typed is the one failure nobody can see. Remove the field(s) from the draft');
   }
+  // T (PRD v1.99, the agent never sets a trigger): a schedule is the person's own two-click act in the panel, never a
+  // draft field. Refused by name, like the authored half.
+  if (draft.trigger !== undefined) {
+    throw new Error('the spec draft carries trigger — a schedule is set only by the person, in the panel\'s two-click schedule '
+      + 'door, never by a draft. Remove the field from the draft');
+  }
   return { ...draft, verdictType, closeDecl };
 }
 

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,11 @@ 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'}.`;
+  }
   /** @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/declaredclose.js

@@ -107,7 +107,7 @@ export const CLOSE_DECL_FIELDS = Object.freeze(['genre', 'lang', 'stages', 'note
 /** what a stored calibration set carries, ENUMERATED: the frozen cases and the judge
  * tier that graded them. Both are inside the spec, so `jobSpecHash` covers both — which
  * is the whole mechanism behind "a judge-model bump forces a full recalibration"
- * (src/judged.js, `JUDGE_MODEL`): the field moves, the hash moves, the signature dies,
+ * (src/judged.js, `resolveJudge`): the field moves, the hash moves, the signature dies,
  * and the re-sign re-runs the gate. Anything else in there is a field nobody reads. */
 export const CALIBRATION_FIELDS = Object.freeze(['cases', 'judgeModel']);
 
@@ -447,7 +447,7 @@ export function validateCloseDecl(closeDecl, opts = {}) {
       // WHICH TIER GRADED THIS SET, and it is REQUIRED rather than optional. A
       // stored set is only worth the judge that graded it (§4.2's safety argument
       // is BA-20's haiku-4.5 injection evidence and nothing else), so a set with
-      // no model beside it is a set nobody can attribute — and the `JUDGE_MODEL`
+      // no model beside it is a set nobody can attribute — and the `CALIBRATION_FIELDS`
       // docstring's promise that a bump forces recalibration has nothing to fire
       // on. Required HERE and not at the stage, for the same reason the SET's own
       // presence is the signing gate's call and not this validator's: this gate
@@ -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;