bareloop 0.44.0 → 0.46.0

package/src/panel/index.html

@@ -926,6 +926,10 @@
                 <button class="chip" aria-pressed="false" data-view="flat" data-testid="audit-view-flat">Flat</button>
               </div>
             </div>
+            <div id="audit-learnings" class="audit-part" data-testid="audit-learnings" hidden>
+              <button type="button" id="audit-learnings-summary" class="btn audit-part-toggle" aria-expanded="false" data-testid="audit-learnings-summary">What the planner was told from earlier runs</button>
+              <div id="audit-learnings-list" class="audit-part-body" data-testid="audit-learnings-list" hidden></div>
+            </div>
             <div id="audit-groups" data-testid="audit-groups"></div>
             <div id="audit-flat-wrap" hidden>
               <div id="audit-empty" class="hint" data-testid="audit-empty" style="font-size:13px;padding:24px 0;">select a run first</div>
@@ -2828,6 +2832,98 @@
     // fetch, wired separately in selectRun below).
     lastLegDividers = Array.isArray(detail.legDividers) ? detail.legDividers : [];
     renderAuditGroups(detail);
+    renderAuditLearnings(detail);
+  }
+
+  // Cross-run learnings, READ-ONLY: what the planner was handed, one group per injection (the draft, the first replan). ONE fold for the
+  // whole section (the <details> in the Audit tab); opened, every hint shows at once as a title line + labelled rows, no inner toggles.
+  // The fields come from the server (learn.js parseHintBlock, the one reader of the block) - this page never splits the prose.
+  // No edit, no Reject, no button. Absent (the setting was off, or nothing was readable) = the section stays hidden.
+  // one row of a hint's table: the same label cell + value cell the schedule section body uses
+  function learnRow(tbody, testid, label, lines){
+    var tr = document.createElement("tr");
+    tr.setAttribute("data-testid", testid);
+    var lab = document.createElement("td");
+    lab.className = "hint";
+    lab.style.cssText = "white-space:nowrap";
+    lab.textContent = label;
+    var val = document.createElement("td");
+    val.style.cssText = "overflow-wrap:anywhere;white-space:pre-wrap";
+    val.textContent = lines.join("\n");
+    tr.appendChild(lab);
+    tr.appendChild(val);
+    tbody.appendChild(tr);
+  }
+  function learnHintLabel(h){
+    var bits = [h.n, h.level, "seen " + h.count + (h.count === 1 ? " time" : " times")];
+    if(h.check) bits.push(h.check);
+    if(h.kinds && h.kinds.length) bits.push(h.kinds.join(", "));
+    bits.push(h.fixed ? "fixed" : "never fixed");
+    return bits.join(" \u00B7 ");
+  }
+  function renderAuditLearnings(detail){
+    var box = document.getElementById("audit-learnings");
+    var list = document.getElementById("audit-learnings-list");
+    var sum = document.getElementById("audit-learnings-summary");
+    if(!box || !list) return;
+    var items = detail && Array.isArray(detail.learnings) ? detail.learnings : [];
+    list.innerHTML = "";
+    var head = "What the planner was told from earlier runs";
+    items.forEach(function(it, gi){
+      var hints = Array.isArray(it.hints) ? it.hints : [];
+      var when = it.phase === "replan" ? "first replan" : "draft";
+      if(items.length > 1){
+        var g = document.createElement("div");
+        g.className = "hint";
+        g.style.cssText = "margin-top:10px;font-weight:600;";
+        g.setAttribute("data-testid", "audit-learnings-group-" + it.phase);
+        g.textContent = it.phase === "replan" ? "At the first replan" : "At the draft";
+        list.appendChild(g);
+      }
+      var note = document.createElement("div");
+      note.className = "hint";
+      note.style.cssText = "margin:6px 0;overflow-wrap:anywhere;";
+      note.textContent = (gi === 0 ? "Read-only. " : "") + "Given to the planner at the " + when + " (" + Number(it.chars).toLocaleString("en-US") + " characters)." + (gi === 0 ? " No worker sees it." : "");
+      list.appendChild(note);
+      hints.forEach(function(h){
+        var hint = document.createElement("div");
+        hint.className = "audit-table-scroll";
+        hint.setAttribute("data-testid", "audit-learnings-hint-" + it.phase + "-" + h.n);
+        var table = document.createElement("table");
+        table.className = "rounds-table";
+        var tbody = document.createElement("tbody");
+        var trT = document.createElement("tr");
+        var title = document.createElement("td");
+        title.setAttribute("colspan", "2");
+        title.style.cssText = "font-weight:600;overflow-wrap:anywhere";
+        title.setAttribute("data-testid", "audit-learnings-hint-" + it.phase + "-" + h.n + "-title");
+        title.textContent = learnHintLabel(h);
+        trT.appendChild(title);
+        tbody.appendChild(trT);
+        var t = "audit-learnings-hint-" + it.phase + "-" + h.n + "-";
+        if(h.said) learnRow(tbody, t + "said", "It said:", [h.said]);
+        if(h.touched) learnRow(tbody, t + "touched", "Fix touched:", [h.touched]);
+        if(h.changed && h.changed.length) learnRow(tbody, t + "changed", "What changed:", h.changed.concat(h.moreChanged ? ["(+" + h.moreChanged + " more)"] : []));
+        table.appendChild(tbody);
+        hint.appendChild(table);
+        list.appendChild(hint);
+      });
+    });
+    if(sum){
+      var first = items.length ? (Array.isArray(items[0].hints) ? items[0].hints.length : 0) : 0;
+      var label = items.length ? head + " \u00B7 " + first + (first === 1 ? " hint" : " hints") : head;
+      // no arrow (hamr 2026-10-23): the state chip leads; aria-expanded carries open/closed. The same `[✓] word` state markup the schedule/step headers wear (stateDotHTML), then the plain-words title
+      var paint = function(){ sum.innerHTML = stateDotHTML(glyphClass("\u2713"), "learnings", "audit-learnings-state") + " " + escapeXml(label); };
+      paint();
+      // ONE fold, same as the other Audit sections: the header button toggles the body (wired once)
+      sum.onclick = function(){
+        var open = sum.getAttribute("aria-expanded") === "true";
+        sum.setAttribute("aria-expanded", open ? "false" : "true");
+        list.hidden = open;
+        paint();
+      };
+    }
+    box.hidden = items.length === 0;
   }
 
   // ONE spelling of a step's state: its dot + the bold state word — read by the Run tab's step cards AND the Audit tab's grouped rows
@@ -3599,6 +3695,7 @@
         items.map(function(x){ return "<li>" + escapeXml(x) + "</li>"; }).join("") + "</ul></details>";
     };
     h += fold("Not checked (the AI's own reading)", plan.notChecked, "plan-notchecked");
+    h += fold("How the page was read", plan.readNotes, "plan-readnotes");
     h += fold("Always checked", plan.alwaysOn, "plan-alwayson");
     return h + "</div>";
   }
@@ -3831,6 +3928,9 @@
     if((data.notChecked || []).length){
       h += '<div class="job-card"><h4>Not checked</h4>' + resultNotChecked("Not checked (the AI's own reading)", data.notChecked, "result-notchecked") + '</div>';
     }
+    if((data.readNotes || []).length){
+      h += '<div class="job-card"><h4>How the page was read</h4>' + resultNotChecked("How the page was read \u00b7 " + data.readNotes.length, data.readNotes, "result-readnotes") + '</div>';
+    }
     if(detail.accept === true && !detail.live) h += resultDoorHtml(data.door);
     if((data.delivered || []).length){
       h += '<div class="job-card" data-testid="result-saved"><h4>Saved</h4>' + data.delivered.map(function(d){

package/src/panel/jobplan.js

@@ -11,11 +11,12 @@
 // `cls` is 'machine check' | 'judge' | null (null = not known yet: the confirm card's checks are the model's plan, the
 // stage kinds exist only after drafting). Pure; no file IO.
 import { KIND_CATALOGUE } from '../authoring.js';
-import { checksOfClose, proseNotChecked, lineRules, confirmedGoalOf } from '../rubricstep.js';
+import { splitReadNotes } from '../pagedropwords.js';
+import { checksOfClose, signedFactNames, proseNotChecked, lineRules, confirmedGoalOf } from '../rubricstep.js';
 
 /** @typedef {{name: string, cls: 'machine check'|'judge'|null}} PlanCheck */
 /** @typedef {{n: number, text: string, rule: string, rules: string[], checks: PlanCheck[], refused: string[]}} PlanLine */
-/** @typedef {{lines: PlanLine[], loose: PlanCheck[], notChecked: string[], alwaysOn: string[], older: boolean, goal?: string}} JobPlan */
+/** @typedef {{lines: PlanLine[], loose: PlanCheck[], notChecked: string[], readNotes: string[], alwaysOn: string[], older: boolean, goal?: string}} JobPlan */
 
 /**
  * `machine check` for a kind a command decides, `judge` for one that needs judgement; `null` for a stage whose kind is
@@ -65,10 +66,12 @@ export function planFromSpec(spec) {
       .map((/** @type {any} */ s) => ({ name: s.name, cls: /** @type {'machine check'} */ ('machine check'), fromLine: null }));
   }
   // a prose step says what it does not check (PART 1b, RF5): the person judges the text at Accept
-  const notes = [
+  const allNotes = [
     ...(Array.isArray(spec?.closeDecl?.notes) ? spec.closeDecl.notes.filter((/** @type {any} */ n) => typeof n === 'string' && n) : []),
     ...proseNotChecked(spec?.closeDecl),
   ];
+  // code's notes on which written forms of a still-checked fact were not used are "How the page was read", not Not checked
+  const { notChecked: notes, readNotes } = splitReadNotes(allNotes, signedFactNames(spec?.closeDecl));
   const jl = Array.isArray(spec?.jobLines) ? spec.jobLines.filter((/** @type {any} */ l) => l && Number.isInteger(l.n) && typeof l.text === 'string') : [];
   if (jl.length === 0) {
     return {
@@ -76,7 +79,7 @@ export function planFromSpec(spec) {
         n: 1, text: typeof spec?.goal === 'string' && spec.goal ? spec.goal : '(no goal recorded)', rule: '', rules: [],
         checks: stages.map((s) => ({ name: s.name, cls: s.cls })), refused: [],
       }],
-      loose: [], notChecked: notes, alwaysOn: [], older: true,
+      loose: [], notChecked: notes, readNotes, alwaysOn: [], older: true,
     };
   }
   /** @type {PlanLine[]} */
@@ -102,14 +105,15 @@ export function planFromSpec(spec) {
   // the model's signed goal sentence rides along: the page draws it as the "AI's summary" row (an older job shows it as line 1 instead)
   // (a rubric job's signed goal is the whole worker brief: only the sentence the person confirmed is the summary)
   const summary = typeof spec?.goal === 'string' && spec.goal ? confirmedGoalOf(spec.goal) : null;
-  return { lines, loose, notChecked: notes, alwaysOn, older: false, ...(summary ? { goal: summary } : {}) };
+  return { lines, loose, notChecked: notes, readNotes, alwaysOn, older: false, ...(summary ? { goal: summary } : {}) };
 }
 
 /**
  * The plan of the confirm turn, before anything is drafted: the person's own job lines, the model's checks under the
  * line each names, its own "not checked" words, and the real protections (code-owned) as "Always checked".
  * @param {{n: number, text: string, rule: string, rules?: string[]}[]|null|undefined} jobLines
- * @param {{checkItems?: {text: string, fromLine: number[]|null}[], checks?: string[], notChecked?: string[], protections?: string[]}} plan
+ * @param {{checkItems?: {text: string, fromLine: number[]|null}[], checks?: string[], notChecked?: string[], protections?: string[], signedFacts?: string[]}} plan
+ * `signedFacts` = the names of the facts the look signs (so an S1 copy of a signed fact reads as a note, not Not checked)
  * @returns {JobPlan}
  */
 export function planFromConfirm(jobLines, plan) {
@@ -126,7 +130,8 @@ export function planFromConfirm(jobLines, plan) {
     for (const line of served) line.checks.push({ name: c.text, cls: null });
     if (served.length === 0) loose.push({ name: c.text, cls: null });
   }
+  const { notChecked, readNotes } = splitReadNotes(plan?.notChecked, plan?.signedFacts);
   return {
-    lines, loose, notChecked: [...(plan?.notChecked ?? [])], alwaysOn: [...(plan?.protections ?? [])], older: false,
+    lines, loose, notChecked, readNotes, alwaysOn: [...(plan?.protections ?? [])], older: false,
   };
 }

package/src/panel/server.js

@@ -47,6 +47,7 @@ import { chainSpend } from '../ledger.js';
 import { runBehaviour } from '../behaviour.js';
 import { SPEND_RECORD_TYPES, floorsFromRecords } from '../ledger.js';
 import { jobSpecHash, workflowKey } from '../job.js';
+import { parseHintBlock } from '../learn.js';
 import { confirmProtections } from '../authorflow.js';
 import { createScheduleDoor } from './schedules.js';
 import { createStarter } from './schedulestart.js';
@@ -74,6 +75,7 @@ import { judgedFilesOf, lineRules, stepFileRel, proseNotCheckedItems } from '../
 import { factPartOf, factSentence, ruleWords, moneyAs } from '../facts.js';
 import { createSettingsRoutes } from './settingsroutes.js';
 import { planFromSpec } from './jobplan.js';
+import { stageQuestionsByName } from '../stagewords.js';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -1445,6 +1447,7 @@ export function getRunResult(runid, /** @type {{ home?: string, sessionsRoot?: s
     pages,
     pageNote: pages.length ? RESULT_PAGE_MAY_CHANGE : null,
     notChecked: bottom,
+    readNotes: plan.readNotes,
     // the door's words, from the one table (src/panel/status.js DOOR_WORDS); the page types none of them
     door: { head: DOOR_WORDS.waiting.head, ask: RESULT_DOOR_ASK },
     delivered: delivered.map((d, i) => ({
@@ -1848,6 +1851,9 @@ function getRunDetailBody(runid, opts) {
     // carries no contamination risk); `null` when the spine carries no
     // `memory-cache` record at all (never armed on this run).
     behaviour: scopedBehaviour(row, rawSpineRecords),
+    // Cross-run learnings, READ-ONLY (ITEM33 rev 2, RULING 8): the exact block the planner was handed, as the spine recorded it at
+    // injection (the draft, and the first replan); `hints` = the same text split into fields by learn.js's parseHintBlock (the one reader). Empty when the setting was off or nothing was readable.
+    learnings: rawSpineRecords.filter((e) => e?.type === 'learnings' && typeof e.text === 'string').map((e) => ({ phase: String(e.phase), text: e.text, chars: e.text.length, ids: Array.isArray(e.ids) ? e.ids : [], hints: parseHintBlock(e.text) })),
     // PRD v1.106 Part 5 F: the two Run summary rows, worded here (the page prints them)
     callsLine: callsLineOf(rawSpineRecords, scopedBehaviour(row, rawSpineRecords)),
     checksLine: checksLineOf(rawSpineRecords, enrichedParts),
@@ -2592,116 +2598,6 @@ function resolveSpecForRow(row) {
   return null;
 }
 
-/**
- * THE PLAIN-QUESTION OWNER (plain-checks build, 2026-09-28, hamr's ruling:
- * the "checks N/M" headline is WITHDRAWN — "confusing, reads like 6 failed
- * when 5 never ran"). ONE pure function mapping a declared stage's own
- * signed `kind`+`params` (plus the close's own `genre`, also a signed field)
- * to a short plain-English question a person can read without knowing the
- * catalogue — never a second spelling on the client, and never anything the
- * model authored (the catalogue's kinds/params are the whole vocabulary this
- * reads).
- *
- * Every branch is traced straight off `src/kinds.js`'s runner semantics and
- * the TYPES genre template (`src/authoring.js` `TYPES_GENRE_TEMPLATE`,
- * `classGuards`'s `MECHANICAL_GUARDS`) — never guessed:
- *   - `files-changed` is always the `changed-from-seed` guard: "did it
- *     change any file?"
- *   - `pattern-absent-in-diff` is always the `no-suppressions` guard: "no
- *     casts or silencers added?"
- *   - `rubric-step` (Part 1a) is one job line's output file: "line N — does its output pass the line's checks?"
- *   - `command-exit` is the genre's `suite-green` stage (the only shipped use
- *     of this kind): "does the test suite pass?"
- *   - `count-not-worse` splits three ways on its own declared
- *     `direction`/`baseline` (never the runtime number — see
- *     {@link stageKindMetaFromSpec}'s own doc for why the baseline KIND must
- *     travel separately from the measured figure):
- *       - `higher-is-better` + `baseline: 'seed'` is the genre's `tests-kept`
- *         floor: "did all the old tests still exist?"
- *       - `lower-is-better` + `baseline: 0` is the genre's in-scope
- *         `typecheck` stage — UNLESS its own `cmd`+`args` is the SAME
- *         command a `command-exit` stage in the same close already runs
- *         (`suiteCmdKeys`, below): the TYPES template's `suite-green` is "the
- *         suite exits clean AND reports zero failing tests — TWO assertions"
- *         over ONE population (the same `npm test`/`pytest` invocation), so a
- *         `count-not-worse` stage sharing that exact command is the failing-
- *         test-count half of that pair, never a typecheck stage: "no failing
- *         tests?" — derived from the same cmd+args correlation (the stage
- *         counts the suite's own failing tests), never from the stage's own
- *         name string. The live check that found this (run mul5fofw's own
- *         `suite-zero-failing-tests`, cmd `npm test`, same as its sibling
- *         `suite-green` command-exit stage) would otherwise have read "test/
- *         has 0 type errors?", which is false: its parser counts FAILING
- *         TESTS (`^# fail (\d+)$`), not type-checker output. hamr's ruling:
- *         name this half honestly rather than reusing "type errors" for a
- *         population it was never about, or falling back to the stage's raw
- *         name. When the command differs from every sibling `command-exit`
- *         stage, the declared `scope.includePrefixes` naming exactly ONE path
- *         is quoted verbatim (a signed param, never invented): "<path> has 0
- *         type errors?" — otherwise the generic "type errors is 0?", never a
- *         guessed filename.
- *       - `lower-is-better` + `baseline: 'seed'` with a non-empty
- *         `scope.excludePrefixes` is the genre's `typecheck-outside` ceiling:
- *         "other files didn't get more type errors?"
- * The "type errors" wording is genre-owned (`GENRE_WHAT`), because TYPES is
- * the only genre this catalogue admits today (doc-genre kinds are not yet
- * built) — an unrecognised genre, or a `count-not-worse` shape none of the
- * three above matches, returns `null` rather than invent a fourth shape.
- *
- * `null` means "no honest plain question" — the caller (buildAttemptsList,
- * partLine1Text's `attemptChecksLine`) falls back to the stage's OWN name,
- * exactly as it already does for a stage with no resolvable kind at all.
- * @param {{kind: string|null, params: any, genre: string|null, suiteCmdKeys: Set<string>}} o
- * @returns {string|null}
- */
-const GENRE_WHAT = Object.freeze({ TYPES: 'type errors' });
-
-/** `cmd`+`args`, as a comparable key — the one signal (besides `kind`
- * itself) that two stages measure the SAME command's output, used to tell a
- * genuine typecheck stage apart from the TYPES genre's other `lower-is-
- * better`/`baseline: 0` stage (the failing-test-count half of `suite-green`'s
- * "two assertions"), which shares that stage's own shape but not its
- * population. `null` for a stage whose `cmd` isn't a non-empty string —
- * never matches anything, so it never falsely suppresses a real typecheck
- * question.
- * @param {any} params @returns {string|null} */
-function cmdKey(params) {
-  if (!params || typeof params.cmd !== 'string' || params.cmd.length === 0) return null;
-  const args = Array.isArray(params.args) ? params.args : [];
-  return JSON.stringify([params.cmd, args]);
-}
-
-function stageQuestionText({
-  kind, params, genre, suiteCmdKeys,
-}) {
-  if (kind === 'files-changed') return 'did it change any file?';
-  if (kind === 'pattern-absent-in-diff') return 'no casts or silencers added?';
-  if (kind === 'command-exit') return 'does the test suite pass?';
-  // Part 1a: one rubric-step stage = one job line's output file
-  if (kind === 'rubric-step') return params && Number.isInteger(params.step) ? `line ${params.step} — does its output pass the line's checks?` : null;
-  if (kind !== 'count-not-worse' || !params || typeof params !== 'object') return null;
-  const what = Object.hasOwn(GENRE_WHAT, String(genre)) ? GENRE_WHAT[String(genre)] : null;
-  if (params.direction === 'higher-is-better' && params.baseline === 'seed') {
-    return 'did all the old tests still exist?';
-  }
-  if (!what) return null;
-  const scope = params.scope && typeof params.scope === 'object' ? params.scope : null;
-  if (params.direction === 'lower-is-better' && params.baseline === 0) {
-    const key = cmdKey(params);
-    if (key !== null && suiteCmdKeys instanceof Set && suiteCmdKeys.has(key)) return 'no failing tests?';
-    const include = scope && Array.isArray(scope.includePrefixes) ? scope.includePrefixes : null;
-    if (include && include.length === 1 && typeof include[0] === 'string' && include[0].length > 0) {
-      return `${include[0]} has 0 ${what}?`;
-    }
-    return `${what} is 0?`;
-  }
-  if (params.direction === 'lower-is-better' && params.baseline === 'seed') {
-    const exclude = scope && Array.isArray(scope.excludePrefixes) ? scope.excludePrefixes : null;
-    if (exclude && exclude.length > 0) return `other files didn't get more ${what}?`;
-    return null;
-  }
-  return null;
-}
 
 /**
  * Per-stage `{kind, direction, baselineKind, question}`, keyed by stage NAME,
@@ -2723,18 +2619,7 @@ function stageQuestionText({
  */
 function stageKindMetaFromSpec(spec) {
   if (!spec || typeof spec !== 'object' || !spec.closeDecl || !Array.isArray(spec.closeDecl.stages)) return null;
-  const genre = typeof spec.closeDecl.genre === 'string' ? spec.closeDecl.genre : null;
-  // every command-exit stage's own cmd+args, gathered FIRST (a separate pass)
-  // so stageQuestionText can tell the failing-test-count half of suite-green's
-  // "two assertions" apart from a genuine typecheck stage — see its own doc.
-  /** @type {Set<string>} */
-  const suiteCmdKeys = new Set();
-  for (const s of spec.closeDecl.stages) {
-    if (s && s.kind === 'command-exit') {
-      const key = cmdKey(s.params);
-      if (key !== null) suiteCmdKeys.add(key);
-    }
-  }
+  const questions = stageQuestionsByName(spec);
   /** @type {Map<string, {kind: string|null, direction: string|null, baselineKind: 'seed'|0|null, question: string|null, fromLine: number[]}>} */
   const map = new Map();
   for (const s of spec.closeDecl.stages) {
@@ -2743,9 +2628,7 @@ function stageKindMetaFromSpec(spec) {
     const params = s.params && typeof s.params === 'object' ? s.params : null;
     const direction = params && typeof params.direction === 'string' ? params.direction : null;
     const baselineKind = params && (params.baseline === 'seed' || params.baseline === 0) ? params.baseline : null;
-    const question = stageQuestionText({
-      kind, params, genre, suiteCmdKeys,
-    });
+    const question = questions.get(s.name) ?? null;
     map.set(s.name, {
       kind, direction, baselineKind, question, fromLine: Array.isArray(s.fromLine) ? s.fromLine.filter(Number.isInteger) : [],
     });

package/src/planrun.js

@@ -39,6 +39,7 @@ import { TOOL_BY_VERB, CTX_TOOLS, createCtxTools, toolAction, PERSONA_TOOLS, str
 import { anySuppressionWarning } from './authoring.js';
 import { createReadShim, readShimArm, readShimStrategy } from './readshim.js';
 import { globToPrefix, redactSecrets, SECRET_PATTERNS } from './validate.js';
+import { startAttemptDiff } from './attemptdiff.js';
 import { validateBridge, loadGate, newestEligibleVersion, reuseEligibility, quarantinesCredit, QUARANTINED_CODE } from './bridges.js';
 import { extractArtifact, rateSourceFields } from './text.js';
 import { defaultJudgeLoop } from './judged.js';
@@ -338,6 +339,17 @@ function materialsBlock(m) {
   return `\nWhat this run has left to spend — plan within it:\n${lines.join('\n')}\nThese are totals for the run, not per-step allowances. Nothing here is a rate: a step's cost depends on what it does.\n`;
 }
 
+/**
+ * Cross-run learnings (ITEM33-BUILD.md rev 2, RULING 7): the block `renderHints` (src/learn.js) made, rendered verbatim into
+ * the PLANNER's prompt and nowhere else — a worker (scout, step, close-fix) is never handed ledger text. Absent or empty
+ * renders '' so every prompt without hints is byte-identical to what it was.
+ * @param {string|null|undefined} text
+ */
+function hintsBlock(text) {
+  if (typeof text !== 'string' || !text.trim()) return '';
+  return `\n${text}\n`;
+}
+
 /**
  * MODULE 8 — the signer's words, when this leg is a RERUN taken at a previous run's
  * review door (PRD v1.71 §3.4: *"redo/rerun comes with new authoring"*).
@@ -632,8 +644,10 @@ export function boundedNote(bounded, rounds) {
  *   is STATED as well as enforced (the mailbox precedent again: a law only the validator
  *   knows costs a redraft per draft). The arms without it — `false` and `'diff'` — render
  *   byte-identically to the pre-shim prompt.
+ * @param {string|null} [hints] the cross-run learnings block (src/learn.js `renderHints`), verbatim; null/empty
+ *   renders byte-identically to the prompt without it. Only ever passed for the draft and the first replan.
  */
-export function planPrompt(job, scoutBlob, reds, maxStepRounds, failure, scopes, materials, startingDraft = null, checkFacts = {}, doorNote = null, readShim = false) {
+export function planPrompt(job, scoutBlob, reds, maxStepRounds, failure, scopes, materials, startingDraft = null, checkFacts = {}, doorNote = null, readShim = false, hints = null) {
   const scopeMenu = Array.isArray(scopes) && scopes.length ? scopes : legalScopes(job.writeScope ?? []);
   const ceiling = Array.isArray(job.tools) ? job.tools : [...TOOL_MENU];
   // The shape-lottery laws, stated where the check menu is offered (the mailbox
@@ -723,7 +737,7 @@ ${scopeMenu.map((s) => `  ${JSON.stringify(s)}`).join('\n')}
 
 Goal:
 ${job.goal}
-${doorNoteBlock(doorNote)}${materialsBlock(materials)}
+${doorNoteBlock(doorNote)}${materialsBlock(materials)}${hintsBlock(hints)}
 Repository survey (from a read-only scout):
 ${scoutBlob || '(no scout notes)'}`;
   let p = doc;
@@ -982,12 +996,16 @@ ${scoutBlob || '(no scout notes)'}`;
  *   the file, end the Loop after that round, and end the leg `stopped` (a checkpoint outcome, filed
  *   the way a mid-step cap-halt is; resume re-enters that step, or continues the phase). Nothing is in flight at that
  *   point, so the spend is exact. `null` = no stop surface (the default).
+ * @param {{text: string, ids: string[]}|null} [opts.learnHints=null] cross-run learnings (src/learn.js `renderHints`, made once at
+ *   run start from the ledger as it stood). Handed to the PLANNER only: the first draft and the FIRST replan. No worker ever
+ *   receives it, and a later replan gets nothing. Each injection is recorded on the spine as a `learnings` record (the exact
+ *   text) so the Audit can show it and the byte check can compare it with a fresh render. `null` = no hints (the default).
  * @returns {Promise<string>} 'green' | 'already-green' | 'escalated' | 'plan-red' |
  *   'check-red' | 'close-red' | 'close-unsupported' | 'recipe-stale' | 'pricing-red' |
  *   'branch-red' | 'cap-halt' | 'wall-halt' | 'stopped' | 'provider-red' | 'interpreter-red' |
  *   'step-stalled' | 'hitl-pause' | 'hitl-decision-red' | `step-red:<id>`
  */
-export async function runPlan(job, { workdir, provider, nativeProvider, providerFor, judgeProvider = null, judgeModel = null, rates = null, judgeRates = null, emit, remainingUsd, isUnpriced = () => false, spendComplete = () => true, capRuns = 3, strikeLimit = STRIKE_LIMIT, closeTimeoutMs, closeDir = null, maxStepRounds = 40, layerRoot = false, readShim = false, scout = true, scoutRounds = SCOUT_ROUNDS, bridge = null, now, priorWallMs = 0, resumeSeed = null, resumeGrades = [], resumeReplans = null, resumeBranch = null, humanRuling = null, heldRuling = null, priorSpentUsd = 0, reviewDoor = null, doorRerun = null, resumable = true, stopFile = null }) {
+export async function runPlan(job, { workdir, provider, nativeProvider, providerFor, judgeProvider = null, judgeModel = null, rates = null, judgeRates = null, emit, remainingUsd, isUnpriced = () => false, spendComplete = () => true, capRuns = 3, strikeLimit = STRIKE_LIMIT, closeTimeoutMs, closeDir = null, maxStepRounds = 40, layerRoot = false, readShim = false, scout = true, scoutRounds = SCOUT_ROUNDS, bridge = null, now, priorWallMs = 0, resumeSeed = null, resumeGrades = [], resumeReplans = null, resumeBranch = null, humanRuling = null, heldRuling = null, priorSpentUsd = 0, reviewDoor = null, doorRerun = null, resumable = true, stopFile = null, learnHints = null }) {
   // MEMORY-CACHE: what the read shim (src/readshim.js) saved THIS run, summed across
   // every mkWorker's own shim instance (scout, drafter, each step's worker, the fix
   // worker) — one accumulator closed over by all of them, because the shim's ledger
@@ -3068,6 +3086,10 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     // is actually left, which is the adaptation channel.
     const materials = { balanceUsd: remainingUsd(), remainingMs: clock.bounded ? clock.remainingMs() : null, ...(progress ? { progress } : {}) };
     emit('materials', { phase, ...materials });
+    // Cross-run learnings: the planner at the draft and at the FIRST replan, nobody else. The spine keeps the exact text it was
+    // handed (a record, never a verdict), so the Audit can show it and the byte check can compare it with a fresh render.
+    const hints = learnHints && learnHints.text && (phase === 'draft' || (phase === 'replan' && replans === 1)) ? learnHints : null;
+    if (hints) emit('learnings', { phase, text: hints.text, ids: hints.ids, chars: hints.text.length });
     // D5 — the bridge rides into the FIRST draft phase ONLY. A replan drafts from the
     // RUN'S OWN STATE (what failed, what is left): re-handing the recipe there would
     // answer the replan's question with the material the run just demonstrated does not
@@ -3092,7 +3114,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     const draftPlan = async (/** @type {any[]|null} */ reds) => {
       drafter.setIteration(reds ? 'redraft' : 'draft');
       replanCut = false;
-      const r = await drafter.ask(planPrompt(job, scoutBlob, reds, maxStepRounds, failure, scopeMenu, materials, starting, checkFacts, doorWords?.text ?? null, readShim), []);
+      const r = await drafter.ask(planPrompt(job, scoutBlob, reds, maxStepRounds, failure, scopeMenu, materials, starting, checkFacts, doorWords?.text ?? null, readShim, hints?.text ?? null), []);
       if (phase === 'replan' && typeof r.error === 'string' && r.error.startsWith('truncated:')) {
         replanCut = true;
         return '';
@@ -3425,7 +3447,10 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // read ONCE: the note and the "was it the attempt just before this one" test
       // are two questions about the same record, and two reads is how they drift
       const bound = w.wasBounded();
-      const r = await w.ask([
+      // attempt-diff: what THIS try changed, recorded to the spine only (never a prompt)
+      const tryDiff = await startAttemptDiff({ workdir, fence: step.scope !== undefined ? [resolve(workdir, globToPrefix(step.scope))] : fencePrefixes, redact: scrub });
+      let r;
+      try { r = await w.ask([
         step.action,
         `Repository root (absolute): ${workdir}\nEvery path you pass to a tool MUST be absolute and inside this root — a relative path resolves against a different directory and will be denied by the gate.`,
         step.target && `Write your deliverable to: ${resolve(workdir, step.target)}`,
@@ -3437,6 +3462,10 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
         bound?.iteration === iteration - 1 && boundedNote(bound, step.rounds),
         rootInj && rootInj.note,
       ].filter(Boolean).join('\n\n'));
+      } finally {
+        const d = await tryDiff.finish();
+        if (d) emit('attempt-diff', { phase: `step:${step.id}`, step: step.id, iteration, ...d });
+      }
       lastText = scrub(r.text ?? '').slice(0, ARTIFACT_MAX);
     };
     let lastGap = '';
@@ -4172,7 +4201,8 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // same iteration numbering as the step loop: `w.setIteration(iteration)` above
       // stamps the bound, so "the attempt just before this one" is `iteration - 1`
       const bound = w.wasBounded();
-      await w.ask([
+      const tryDiff = await startAttemptDiff({ workdir, fence: fencePrefixes, redact: scrub });
+      try { await w.ask([
         'The job\'s final verification is failing. Fix the repository so it passes.',
         `Repository root (absolute): ${workdir}\nEvery path you pass to a tool MUST be absolute and inside this root.`,
         artifacts.length > 0 && `Working context (read-only) — the plan's steps produced:\n${artifacts.map((a) => `[${a.id}] ${a.text}`).join('\n\n')}`,
@@ -4182,6 +4212,10 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
         bound?.iteration === iteration - 1 && boundedNote(bound, maxStepRounds),
         rootInj && rootInj.note,
       ].filter(Boolean).join('\n\n'));
+      } finally {
+        const d = await tryDiff.finish();
+        if (d) emit('attempt-diff', { phase: 'fix', step: null, iteration, ...d });
+      }
     };
     fixOutcome = await ralph({
       // the staged close rides in as the JUDGE seam (one verdict, every stage in

package/src/promptregisters.js

@@ -65,6 +65,10 @@ export const PROMPT_REGISTERS = Object.freeze([
   Object.freeze({ file: 'src/pagemap.js', name: 'MAP_SYSTEM' }),
   Object.freeze({ file: 'src/pagemap.js', name: 'mapPrompt() (inline template, not a const)' }),
 
+  // src/fitcheck.js - the fit check call (F243): the AI splits each job line into asks and quotes the page for each
+  Object.freeze({ file: 'src/fitcheck.js', name: 'FIT_SYSTEM' }),
+  Object.freeze({ file: 'src/fitcheck.js', name: 'fitPrompt() (inline template, not a const)' }),
+
   // src/readshim.js — the capped/deduplicating read shim's worker-facing strategy
   Object.freeze({ file: 'src/readshim.js', name: 'READ_SHIM_STRATEGY' }),
   Object.freeze({ file: 'src/readshim.js', name: 'READ_SHIM_DIFF_STRATEGY' }),

package/src/providerrows.js

@@ -170,8 +170,8 @@ export function endpointOf(provider, baseUrl) {
   if (raw === '') return '';
   try {
     const u = new URL(raw);
-    return `${u.protocol}//${u.host}${u.pathname.replace(/\/+$/, '')}`;
-  } catch { return raw.replace(/\/+$/, ''); }
+    return `${u.protocol}//${u.host}${u.pathname.replace(/(?<!\/)\/+$/, '')}`;
+  } catch { return raw.replace(/(?<!\/)\/+$/, ''); }
 }
 
 /**
@@ -318,7 +318,7 @@ export function keyValueOf(env, envName) {
 function perMoney(n) {
   const shown = String(n);
   if (!shown.includes('e') && (shown.split('.')[1] ?? '').length >= 2) return `$${shown}`;
-  if (shown.includes('e')) return `$${n.toFixed(12).replace(/0+$/, '').replace(/\.$/, '')}`;
+  if (shown.includes('e')) return `$${n.toFixed(12).replace(/(?<!0)0+$/, '').replace(/\.$/, '')}`;
   return `$${n.toFixed(2)}`;
 }
 

package/src/rubricstep.js

@@ -613,18 +613,37 @@ export function lineRules(l) {
   return isRec(l) && typeof l.rule === 'string' && l.rule ? l.rule.split('; ').filter(Boolean) : [];
 }
 
-/** @param {unknown} b @returns {string[]} the spellings a rule bound can have in the person's own words */
-const boundSpellings = (b) => {
-  const s = String(b);
-  return [s, s.replace(/^0+(?=\d)/, ''), s.replace(/\.0+$/, '')];
+/** @param {string} t @returns {string} a time token as compared: no spaces, lower case, no leading zero on the hour */
+const timeKey = (t) => t.replace(/\s+/g, '').toLowerCase().replace(/^0(?=\d:)/, '');
+
+/**
+ * The person's words read by KIND, so a digit inside a time, a date or an amount belongs to that token only (F242).
+ * @param {string} text @returns {{bare: Set<number>, amount: Set<number>, time: Set<string>, date: Set<string>}}
+ */
+const tokensSaid = (text) => {
+  const out = { bare: new Set(), amount: new Set(), time: new Set(), date: new Set() };
+  const re = /(\d{1,2}:\d{2}(?:\s?[AaPp][Mm])?)|(\d{4}-\d{1,2}-\d{1,2}|\d{1,2}[/.]\d{1,2}[/.]\d{2,4})|([$\u20ac\u00a3]\s?\d[\d,]*(?:\.\d+)?|\d[\d,]*(?:\.\d+)?\s?(?:US\s)?(?:dollars?|euros?|pounds?|USD|EUR|GBP)\b)|(\d[\d,]*(?:\.\d+)?)/gi;
+  for (const m of text.matchAll(re)) {
+    if (m[1]) out.time.add(timeKey(m[1]));
+    else if (m[2]) out.date.add(m[2]);
+    else if (m[3]) out.amount.add(Number(m[3].match(/\d[\d,]*(?:\.\d+)?/)?.[0].replace(/,/g, '')));
+    else out.bare.add(Number(m[4].replace(/,/g, '')));
+  }
+  return out;
 };
 
 /**
  * Is this rule bound in the words the person wrote? The ONE test for "a number the AI made" (`rubric-fact-unmarked`, the L3 settle, and
- * the early ask of PRD v1.107 Part 5b all read it; never a second spelling).
+ * the early ask of PRD v1.107 Part 5b all read it; never a second spelling). By kind: a number is said only as a bare number or an
+ * amount's number; a time only as a time token (hour leading zero ignored); a date only as a date token. Never a piece of a token.
  * @param {unknown} b @param {string} said @returns {boolean}
  */
-export const boundInWords = (b, said) => boundSpellings(b).some((sp) => said.includes(sp));
+export const boundInWords = (b, said) => {
+  const t = tokensSaid(said);
+  if (typeof b === 'number') return t.bare.has(b) || t.amount.has(b);
+  if (typeof b !== 'string') return false;
+  return /^\s*\d{1,2}:\d{2}/.test(b) ? t.time.has(timeKey(b)) : t.date.has(b.trim());
+};
 
 /** @param {any} jl one job line @returns {string} the words the person wrote on it: the line and its `~` rules */
 export const wordsSaidOn = (jl) => `${jl.text ?? ''} ${lineRules(jl).join(' ')}`;
@@ -844,6 +863,17 @@ export function checksOfClose(closeDecl) {
     : []));
 }
 
+/**
+ * The names of the facts a signed close checks (every fact part of every rubric-step stage). Pure.
+ * @param {any} closeDecl @returns {string[]}
+ */
+export function signedFactNames(closeDecl) {
+  const stages = isRec(closeDecl) && Array.isArray(closeDecl.stages) ? closeDecl.stages : [];
+  return stages.flatMap((/** @type {any} */ st) => (isRec(st) && st.kind === 'rubric-step' && isRec(st.params) && Array.isArray(st.params.parts)
+    ? st.params.parts.filter((/** @type {any} */ p) => isRec(p) && p.class === 'fact' && Array.isArray(p.facts)).flatMap((/** @type {any} */ p) => p.facts.filter((/** @type {any} */ f) => isRec(f) && typeof f.name === 'string').map((/** @type {any} */ f) => f.name))
+    : []));
+}
+
 /**
  * Reconcile the CONFIRMED plan with the close the composer actually wrote. The plan card after drafting shows exactly
  * the close's own checks (`checksOfClose`); every confirmed check that no part carries out (no part lists its number in

package/src/run.js

@@ -259,6 +259,8 @@ async function primitiveSmoke(workdir) {
  * @param {string|null} [opts.stopFile=null] P5 item 5 — the run's STOP REQUEST file
  *   (`stopFilePath(spine)`, src/legs.js), forwarded verbatim to the plan flow, which reads it at the
  *   round-boundary seam (where the money cap binds) and ends the leg `stopped`. `null` = no stop surface.
+ * @param {{text: string, ids: string[]}|null} [opts.learnHints=null] cross-run learnings for the PLANNER only (the draft and the
+ *   first replan); forwarded verbatim to the plan flow, which records what it handed over as a `learnings` spine record.
  * @returns {Promise<string>} outcome: 'green' | 'already-green' | 'escalated' |
  *   'unapproved-spec' | 'job-red' | 'smoke-red' | 'plan-red' | 'check-red' |
  *   'close-red' | 'close-unsupported' | 'recipe-stale' | 'branch-red' | 'pricing-red' | 'provider-red' |
@@ -273,7 +275,7 @@ async function primitiveSmoke(workdir) {
  *   deliberately NOT in the resumable/checkpoint set (`src/reuse.js`) — an
  *   unknown in-flight state is not a known-safe resume point.
  */
-export async function runJob(rawSpec, { approvals, workdir, provider, nativeProvider, providerFor, judgeProvider = null, judgeModel = null, rates = null, judgeRates = null, emit, capRuns = 3, strikeLimit, shellCapUsd = 2, closeTimeoutMs, closeDir = null, layerRoot = false, readShim = false, scout = true, bridge = null, draftSpentUsd = 0, draftSpendComplete = true, priorSpentUsd = 0, priorSpendComplete = true, priorWallMs = 0, resumeSeed = null, resumeGrades = [], resumeReplans = null, resumeBranch = null, humanRuling = null, heldRuling = null, reviewDoor = null, doorRerun = null, resumable = true, stopFile = null }) {
+export async function runJob(rawSpec, { approvals, workdir, provider, nativeProvider, providerFor, judgeProvider = null, judgeModel = null, rates = null, judgeRates = null, emit, capRuns = 3, strikeLimit, shellCapUsd = 2, closeTimeoutMs, closeDir = null, layerRoot = false, readShim = false, scout = true, bridge = null, draftSpentUsd = 0, draftSpendComplete = true, priorSpentUsd = 0, priorSpendComplete = true, priorWallMs = 0, resumeSeed = null, resumeGrades = [], resumeReplans = null, resumeBranch = null, humanRuling = null, heldRuling = null, reviewDoor = null, doorRerun = null, resumable = true, stopFile = null, learnHints = null }) {
   // THE READ SHIM's ARM, resolved at the door — the FIRST thing this entry does,
   // before the ledger, before the approval gate, before a byte of the spec is read.
   // An unrecognised spelling throws here at zero cost instead of being coerced by
@@ -540,7 +542,7 @@ export async function runJob(rawSpec, { approvals, workdir, provider, nativeProv
   // accounts it natively (F12) and the job-end money contract is unchanged.
   {
     const outcome = await runPlan(job, {
-      workdir, provider, nativeProvider, providerFor, judgeProvider, judgeModel, rates, judgeRates, emit: meter, capRuns, ...(strikeLimit !== undefined ? { strikeLimit } : {}), closeTimeoutMs, closeDir, layerRoot, readShim, scout, bridge, priorWallMs: chainWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, reviewDoor, doorRerun, priorSpentUsd: chainFoldUsd, resumable, stopFile,
+      workdir, provider, nativeProvider, providerFor, judgeProvider, judgeModel, rates, judgeRates, emit: meter, capRuns, ...(strikeLimit !== undefined ? { strikeLimit } : {}), closeTimeoutMs, closeDir, layerRoot, readShim, scout, bridge, priorWallMs: chainWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, reviewDoor, doorRerun, priorSpentUsd: chainFoldUsd, resumable, stopFile, learnHints,
       // hamr's ruling 2026-09-28 — ONE cap covers drafting + run: the run's
       // enforced ceiling is the signed `budgetUsd` (unchanged, still in the
       // spec hash) MINUS whatever drafting already spent on this job before