bareloop 0.45.0 → 0.46.1

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';
@@ -67,13 +68,14 @@ import { SHAPES } from '../providershapes.js';
 import { resolveProvider } from '../providers.js';
 import { readResume, checkpointAgeGate, CHECKPOINT_OUTCOMES } from '../reuse.js';
 import {
-  statusFor, partStatusFor, GOAL_MET_LINE, doorViewOf, ACTOR_MARKER, DOOR_WORDS,
+  statusFor, partStatusFor, GOAL_MET_LINE, doorViewOf, ACTOR_MARKER, DOOR_WORDS, isReusableGreen,
 } from './status.js';
 import { thinkingJobText } from '../thinking.js';
 import { judgedFilesOf, lineRules, stepFileRel, proseNotCheckedItems } from '../rubricstep.js';
 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));
 
@@ -540,7 +542,7 @@ function endedBase(summary, death, o) {
     if (o.destinationRefused) {
       // Reuse workflow only on a run that earned its green (hamr 2026-10-08, as below); every ending offers Reuse workflow
       // (withReuseAction adds it) and is told to change the job
-      const earned = outcome === 'green';
+      const earned = isReusableGreen(outcome);
       return {
         reason: 'Goal met, but the output could not be delivered.',
         next: earned ? 'Fix the destination, then Reuse workflow.' : CHANGE,
@@ -548,10 +550,9 @@ function endedBase(summary, death, o) {
         actions: earned ? REUSE : [],
       };
     }
-    // hamr 2026-10-08: already-green (the check passed before any work) is not a reusable job — only a run that
-    // earned its green offers Reuse workflow; every ending offers Reuse workflow (withReuseAction adds it). `satisfied` is a
-    // close VERDICT, never a run outcome (ralph and the job-end emitters write `green`), so it rides with already-green.
-    if (outcome !== 'green') return { reason: 'Goal met.', next: CHANGE, line: GOAL_MET_LINE, actions: [] };
+    // a reusable green (isReusableGreen: green or already-green, hamr 2026-10-15) says nothing is left to do; every ending offers
+    // Reuse workflow (withReuseAction adds it). `satisfied` is a close VERDICT, never a run outcome, so it is not one.
+    if (!isReusableGreen(outcome)) return { reason: 'Goal met.', next: CHANGE, line: GOAL_MET_LINE, actions: [] };
     return { reason: 'Goal met.', next: 'Nothing to do.', line: GOAL_MET_LINE, actions: REUSE };
   }
   if (outcome === 'cap-halt') {
@@ -1528,7 +1529,8 @@ function scheduleExtrasFor(runid, job, rows, nos, opts, view) {
             }
             const got = hit ?? fallback;
             const no = got ? nos.get(got.r.runid) : undefined;
-            const word = got ? summarizeRow(got.r).status?.word : undefined;
+            // events: a fire refused at the run-start fetch has no spine, only its settled event; without them it has no status word
+            const word = got ? summarizeRow(got.r, Date.now(), undefined, readRunList(opts).events).status?.word : undefined;
             lastWords = `last ${dateTimeWords(Number(lastRow.at))}${no ? ` · run-${no}` : ''}${word ? ` · ${word}` : ''}${got?.rec.catchUp === true ? ' · catch-up' : ''}`;
           } else {
             lastWords = `last ${dateTimeWords(Number(lastRow.at))} · ${skippedWords(lastRow, true)}`;
@@ -1849,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),
@@ -2593,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,
@@ -2724,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) {
@@ -2744,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) : [],
     });
@@ -3632,7 +3514,7 @@ export function getStartFrom(runid, opts = {}) {
     // T D.2: a SCHEDULED run's green reads `green-held` until the person accepts it, so that same refusal holds it unchanged
     outcome: (() => {
       const o = legsOf(records).at(-1)?.outcome ?? null;
-      return o === 'green' && heldScheduled(records, triggerRecordOf(row)) ? 'green-held' : o;
+      return isReusableGreen(o) && heldScheduled(records, triggerRecordOf(row)) ? 'green-held' : o;
     })(),
     card,
     from: 'signed job',
@@ -3697,7 +3579,7 @@ export function listReuseJobs(opts = {}) {
     try { records = parseJsonl(row.spine).records; } catch { continue; }
     const outcome = legsOf(records).at(-1)?.outcome ?? null;
     // a real green or an already-green (hamr 2026-10-15: if it is already fixed and nothing is to be done, it is green and can be reused)
-    if (outcome !== 'green' && outcome !== 'already-green') continue;
+    if (!isReusableGreen(outcome)) continue;
     if (heldScheduled(records, triggerRecordOf(row))) continue; // T D.2: a scheduled green waits for the person's Accept
     const signed = signedSpecForRun(row, records);
     if (!signed) continue;

package/src/panel/status.js

@@ -20,6 +20,17 @@ import { capKindOf } from '../legs.js';
 /** the sentence a passed run carries as its reason (the Ended block's `line`) */
 export const GOAL_MET_LINE = 'goal met';
 
+/**
+ * ONE spelling of "this run's outcome is a green that can be reused" (the Reuse picker, the Reuse start/prefill, the Ended block's
+ * next line). hamr 2026-10-15: an `already-green` (fixed before any work) counts. `satisfied` is a close verdict, never a run outcome.
+ * The SCHEDULE gate (schedules.js greenFor) deliberately stays on a real `green` only (T3).
+ * @param {string|null|undefined} outcome
+ * @returns {boolean}
+ */
+export function isReusableGreen(outcome) {
+  return outcome === 'green' || outcome === 'already-green';
+}
+
 /** @typedef {'running'|'waiting'|'passed'|'failed'|'capped'|'stopped'|'died'} StatusKey */
 
 /** the table: key -> sign + word */

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/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/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

package/src/schedulewords.js

@@ -232,7 +232,7 @@ export function startedAuditWords(rec, originNo) {
 
 /** a refusal's own words without its trailing "Nothing started." @param {unknown} why */
 function reasonOf(why) {
-  return String(why ?? '').replace(/\s*Nothing (started|spent)\.\s*$/, '').trim().replace(/\.$/, '');
+  return String(why ?? '').replace(/(?<!\s)\s*Nothing (started|spent)\.\s*$/, '').trim().replace(/\.$/, '');
 }
 
 /**

package/src/source.js

@@ -1273,7 +1273,7 @@ export async function proveRubricInputs({ inputs, into, destination, fetchUrl =
     labels.add(label.toLowerCase());
     if (isWebUrl(value)) {
       const got = await fetchUrl(value.trim());
-      if (!got.ok) return bad('input-url-unreadable', n, `${got.error.replace(/[.\s]+$/, '')}.`);
+      if (!got.ok) return bad('input-url-unreadable', n, `${got.error.replace(/(?<![.\s])[.\s]+$/, '')}.`);
       const pageBuf = Buffer.from(got.text, 'utf8');
       const leak = secretPatternNames(got.text);
       if (leak.length) return bad('input-url-secret', n, `the page at ${got.url} carries a known secret shape (${leak.join(', ')}) - refused, secrets never enter a job.`);

package/src/stagewords.js

@@ -0,0 +1,145 @@
+// The ONE owner of a stage's plain question ("did it change any file?", "no failing tests?"). Moved out of
+// src/panel/server.js (verbatim) so the Audit/step map AND the learnings cards read the same sentence from the same
+// code — a second spelling is how two screens come to disagree about one check. Pure; no file IO, no model.
+
+/** the genre-owned noun for the count a TYPES-genre typecheck stage measures (see {@link stageQuestionText}) */
+export 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} */
+export 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]);
+}
+
+/**
+ * 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}
+ */
+export 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;
+}
+
+/**
+ * Stage name to its plain question, off a signed spec's `closeDecl.stages` — the one pass that gathers every
+ * `command-exit` stage's cmd+args FIRST (so the failing-test-count half of `suite-green`'s pair can be told from a
+ * genuine typecheck stage) and then asks {@link stageQuestionText} per stage. `null` for a stage with no honest
+ * question; an empty map for a spec with no declared stages.
+ * @param {any} spec
+ * @returns {Map<string, string|null>}
+ */
+export function stageQuestionsByName(spec) {
+  /** @type {Map<string, string|null>} */
+  const out = new Map();
+  if (!spec || typeof spec !== 'object' || !spec.closeDecl || !Array.isArray(spec.closeDecl.stages)) return out;
+  const genre = typeof spec.closeDecl.genre === 'string' ? spec.closeDecl.genre : null;
+  /** @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);
+    }
+  }
+  for (const s of spec.closeDecl.stages) {
+    if (!s || typeof s.name !== 'string' || s.name.length === 0) continue;
+    const kind = typeof s.kind === 'string' ? s.kind : null;
+    const params = s.params && typeof s.params === 'object' ? s.params : null;
+    out.set(s.name, stageQuestionText({ kind, params, genre, suiteCmdKeys }));
+  }
+  return out;
+}

package/src/text.js

@@ -42,10 +42,12 @@ const FENCE_PREAMBLE_LINES = 5;
  */
 export function extractArtifact(t) {
   const text = String(t ?? '');
-  const m = text.match(/```[^\n`]*\n?([\s\S]*?)```/);
+  // (?=([^\n`]*))\1 reads the info string atomically: giving characters back can never find a closing fence the full read missed (a fence starts with a
+  // backtick, which the info string excludes), so an unclosed "```aaaa..." fails once instead of once per giveback (quadratic). The body is group 2.
+  const m = text.match(/```(?=([^\n`]*))\1\n?([\s\S]*?)```/);
   if (m) {
     if (text.slice(0, /** @type {number} */ (m.index)).split('\n').length - 1 < FENCE_PREAMBLE_LINES) {
-      const code = m[1].trim();
+      const code = m[2].trim();
       return code ? { code, red: null } : { code: null, red: 'empty fenced block' };
     }
     // deep fence = the artifact's own content: verbatim, NO fence strips — the