bareloop 0.43.0 → 0.45.0

package/src/rubricstep.js

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
+import { readFile, lstat } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { createRubric, checkStep, renderGaps, numbersInQuote } from 'bareguard';
+import { dropRows, dropLine } from './pagedropwords.js';
 import { factPartOf, factShapeReds, factDecides, factClaims, factRows, plainFactItem, factBrief } from './facts.js';
 
 // PART 1a (docs/product/ITEM33-BUILD.md, "Addendum 2026-10-12"): the rubric job on LOCAL FILES — what one job line leaves
@@ -100,15 +101,35 @@ export function rubricGoal({ jobLines, files, confirmedGoal = null, closeDecl =
   const inputs = files.map((f) => `  - ${f.label}: ${f.rel}`).join('\n');
   const lines = jobLines.map((l) => `${l.n}. ${l.text}${l.rule ? `\n   rule: ${l.rule}` : ''}`).join('\n');
   return [
-    'Do the job below from the input files, then write one JSON file per numbered line.',
+    RUBRIC_GOAL_HEAD,
     `The input files (label: file):\n${inputs}`,
     stepFileContract(),
     `The job, line by line:\n${lines}`,
     ...(closeDecl ? lineBriefs(closeDecl).map((b) => b.text) : []),
-    ...(confirmedGoal ? [`The plan the person confirmed: ${confirmedGoal}`] : []),
+    ...(confirmedGoal ? [`${CONFIRMED_GOAL_PREFIX}${confirmedGoal}`] : []),
   ].join('\n\n');
 }
 
+/**
+ * What a rubric job's goal text is: the worker brief `rubricGoal` builds. The Job tab's "AI's summary" is only the one
+ * sentence the person confirmed, never this brief, so the first line and the confirmed-sentence prefix have ONE spelling.
+ */
+export const RUBRIC_GOAL_HEAD = 'Do the job below from the input files, then write one JSON file per numbered line.';
+const CONFIRMED_GOAL_PREFIX = 'The plan the person confirmed: ';
+
+/**
+ * The sentence the person confirmed, out of a goal text: for a rubric brief the rest of the `CONFIRMED_GOAL_PREFIX` line,
+ * or null when the brief has none; any other goal (a code job's) comes back unchanged.
+ * @param {string} goal
+ * @returns {string|null}
+ */
+export function confirmedGoalOf(goal) {
+  if (!goal.startsWith(RUBRIC_GOAL_HEAD)) return goal;
+  const line = goal.split('\n').find((l) => l.startsWith(CONFIRMED_GOAL_PREFIX));
+  const sentence = line ? line.slice(CONFIRMED_GOAL_PREFIX.length).trim() : '';
+  return sentence || null;
+}
+
 // ── the `rubric-step` stage: its parameters, and the rubric they build ───────────────────────────────────────────────
 //
 // A stage serves exactly ONE job line N and reads exactly one file, output/steps/N.json. Its parameters are
@@ -258,6 +279,46 @@ export function buildStepSpec(params, inputShas) {
 /** the sha256 of text, hex @param {string|Buffer} b @returns {string} */
 export const sha256Of = (b) => createHash('sha256').update(b).digest('hex');
 
+/**
+ * The files one named check READS, tree-relative: a `rubric-step` stage's own step file (`output/steps/N.json`). Any other kind reads
+ * none that a try's output can be told by, so `[]`. From the signed declaration, never guessed.
+ * @param {any} closeDecl @param {string|null|undefined} checkName
+ * @returns {string[]}
+ */
+export function judgedFilesOf(closeDecl, checkName) {
+  const stages = Array.isArray(closeDecl?.stages) ? closeDecl.stages : [];
+  const st = stages.find((/** @type {any} */ x) => x && x.name === checkName && x.kind === 'rubric-step');
+  return st && Number.isInteger(st.params?.step) ? [stepFileRel(st.params.step)] : [];
+}
+
+/**
+ * PRD v1.106 Part 5: what each file a try's `check-passes` checks read looked like WHEN it was judged: `{path, bytes, sha256}`. The step
+ * file is overwritten by the next try, so the spine's `output-judged` record is the only trace; the content itself is never written (hard
+ * line). A missing, non-regular or over-size file is skipped — nothing was judged there.
+ * @param {any} closeDecl @param {string} workdir @param {Array<{type?: string, name?: string}>} exits a step's declared exits
+ * @returns {Promise<Array<{path: string, bytes: number, sha256: string}>>}
+ */
+export async function outputJudgedRecords(closeDecl, workdir, exits) {
+  /** @type {Array<{path: string, bytes: number, sha256: string}>} */
+  const out = [];
+  const seen = new Set();
+  for (const e of Array.isArray(exits) ? exits : []) {
+    if (!e || e.type !== 'check-passes') continue;
+    for (const rel of judgedFilesOf(closeDecl, e.name)) {
+      if (seen.has(rel)) continue;
+      seen.add(rel);
+      try {
+        const abs = join(workdir, rel);
+        const ls = await lstat(abs);
+        if (!ls.isFile() || ls.size > STEP_MAX_BYTES) continue;
+        const buf = await readFile(abs);
+        out.push({ path: rel, bytes: buf.length, sha256: sha256Of(buf) });
+      } catch { /* not there: nothing was judged */ }
+    }
+  }
+  return out;
+}
+
 /**
  * The step file's bytes as the close reads them: the parsed JSON object, or WHY there is none. A file cut off mid-write
  * parses to nothing (reason `not-json`); text cut off INSIDE an otherwise valid JSON object cannot be told from a short
@@ -358,7 +419,9 @@ export function plainStepGap(step, why, g, params = null) {
  *   `inputs` maps each cited label to its frozen TEXT; its sha256 is taken here from that text, and bareguard compares it to
  *   the manifest's recorded sha via `inputShas`.
  * @param {Record<string, string>} inputShas the manifest's recorded sha256 per cited label
- * @returns {Promise<{verdict: 'green'|'red'|'stopped', gapLines: string[], fault: string|null, detail: Record<string, any>}>}
+ * @returns {Promise<{verdict: 'green'|'red'|'stopped', gapLines: string[], fault: string|null, detail: Record<string, any>,
+ *   evidence?: any[], evidenceTotal?: number}>} `evidence`/`evidenceTotal` are bareguard's `full.evidence` (what each `cited` check read), carried out
+ *   for the report-only `rubric-evidence` spine record; no verdict, gap or count above is derived from them
  */
 export async function gradeStep({ params, bytes, outputBytes, inputs, factQuotes = {}, factMissing = [] }, inputShas) {
   let rubric;
@@ -396,8 +459,12 @@ export async function gradeStep({ params, bytes, outputBytes, inputs, factQuotes
   const redCount = extraCount + r.full.gaps.reduce((/** @type {number} */ n, /** @type {any} */ g) => n + (g.check === 'cited' && g.kind === 'unsupported' && typeof g.measured === 'number' ? g.measured : 1), 0);
   const detail = { step: params.step, rubricSha: r.rubricSha, outputSha: r.outputSha, why: parsed.why, gaps: r.full.gaps.length, ...(r.verdict === 'red' || extra.length > 0 ? { redCount } : {}) };
   if (r.verdict === 'stopped') return { verdict: 'stopped', gapLines: [], fault: r.fault ? `${r.fault.kind}: ${r.fault.detail}` : 'the rubric stopped', detail };
-  if (r.verdict === 'green' && extra.length === 0) return { verdict: 'green', gapLines: [], fault: null, detail };
-  return { verdict: 'red', gapLines: [...extra, ...r.gaps.flatMap((g) => plainStepGap(params.step, parsed.why ?? 'empty', g, params).split('\n'))], fault: null, detail };
+  const seen = {
+    ...(Array.isArray(r.full.evidence) && r.full.evidence.length > 0 ? { evidence: r.full.evidence } : {}),
+    ...(typeof r.full.evidenceTotal === 'number' ? { evidenceTotal: r.full.evidenceTotal } : {}),
+  };
+  if (r.verdict === 'green' && extra.length === 0) return { verdict: 'green', gapLines: [], fault: null, detail, ...seen };
+  return { verdict: 'red', gapLines: [...extra, ...r.gaps.flatMap((g) => plainStepGap(params.step, parsed.why ?? 'empty', g, params).split('\n'))], fault: null, detail, ...seen };
 }
 
 // ── R11: the sorting rules, applied at DRAFTING ──────────────────────────────────────────────────────────────────────
@@ -546,12 +613,41 @@ 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). 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) => {
+  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(' ')}`;
+
 /**
  * PART 1b, RF16 + RF17 — the rules that need the person's own job lines. Only a close built for REQUIRED FACTS is held to them (a
  * close with a fact part, or any part that says which `~` rules it carries out): an older Part 1a close is left as it was signed.
@@ -581,12 +677,12 @@ export function checkRubricRules(stages, { jobLines = null, refused = null, red
     const fp = factPartOf(st.params);
     if (!fp || !Array.isArray(fp.facts)) continue;
     const jl = jobLines.find((l) => isRec(l) && l.n === st.params.step);
-    const said = jl ? `${jl.text ?? ''} ${lineRules(jl).join(' ')}` : null;
+    const said = jl ? wordsSaidOn(jl) : null;
     fp.facts.forEach((/** @type {any} */ f, /** @type {number} */ j) => {
       if (!isRec(f) || !isRec(f.rule)) return;
       const w = `stages[${i}].params.parts[${st.params.parts.indexOf(fp)}].facts[${j}]`;
       const bounds = f.rule.op === 'between' ? [f.rule.lo, f.rule.hi] : [f.rule.value];
-      if (said !== null && !f.aiProposal && bounds.some((b) => !boundSpellings(b).some((sp) => said.includes(sp)))) {
+      if (said !== null && !f.aiProposal && bounds.some((b) => !boundInWords(b, said))) {
         red('rubric-fact-unmarked', w, `line ${st.params.step}: the limit on fact "${f.name}" (${bounds.join(' to ')}) is not in the words the person wrote, so it is the AI's own number. Set "aiProposal": true on that fact so the card says "AI's proposal — check it". Nothing spent.`, { line: st.params.step });
       }
       if (f.aiProposal && f.shape === 'time' && f.rule.op !== 'between') {
@@ -620,12 +716,12 @@ export function settlePersonsWords(declaration, jobLines) {
     const jl = jobLines.find((l) => isRec(l) && l.n === st.params.step);
     if (!fp || !Array.isArray(fp.facts) || !jl) return st;
     const rules = lineRules(jl);
-    const said = `${jl.text ?? ''} ${rules.join(' ')}`;
+    const said = wordsSaidOn(jl);
     const ranges = rules.filter((r) => !NEGATING_RE.test(r)).map((r) => TIME_RANGE_RE.exec(r)).filter((m) => m !== null);
     const proposed = fp.facts.filter((/** @type {any} */ f) => isRec(f) && f.aiProposal === true && f.shape === 'time' && isRec(f.rule) && f.rule.op === 'between');
     const facts = fp.facts.map((/** @type {any} */ f) => {
       if (!isRec(f) || !isRec(f.rule) || f.aiProposal !== true) return f;
-      const own = (/** @type {unknown[]} */ bounds) => bounds.every((b) => boundSpellings(b).some((sp) => said.includes(sp)));
+      const own = (/** @type {unknown[]} */ bounds) => bounds.every((b) => boundInWords(b, said));
       const bounds = f.rule.op === 'between' ? [f.rule.lo, f.rule.hi] : [f.rule.value];
       const { aiProposal: _drop, ...rest } = f;
       if (own(bounds)) return rest;
@@ -667,6 +763,36 @@ export function withFactBindings(declaration) {
   return { ...declaration, stages };
 }
 
+/**
+ * NO SILENT DROP (idea A core, spec 4.4): code writes the Not checked rows for what the page rules removed, before the declaration is validated.
+ *   - a dropped FACT that carries a `~` rule no part carries and no `refused` entry names -> `closeDecl.refused` gets {line, rule, reason}
+ *     (shown under that line in the person's own rule words by {@link ruleNotChecked});
+ *   - any other drop (a fact from the job line itself, a rule another fact carries, a word dropped from a fact that is still checked, so a
+ *     narrower check is still said) -> one line in `closeDecl.notes`, shown as Not checked (the AI's own reading).
+ * Never a line-level `refused` entry without `rule` (that would silence every other rule red on the line). A rule the drafter already listed
+ * itself is never listed twice, and running this twice adds nothing. Pure; the input is untouched.
+ * @param {any} declaration @param {import('./pagerules.js').Dropped[]|null|undefined} dropped @param {any[]|null|undefined} jobLines @returns {any}
+ */
+export function withDropNotes(declaration, dropped, jobLines) {
+  if (!isRec(declaration) || !Array.isArray(dropped) || dropped.length === 0) return declaration;
+  const stages = Array.isArray(declaration.stages) ? declaration.stages : [];
+  const carried = (/** @type {number} */ line, /** @type {number} */ n) => stages.some((/** @type {any} */ st) => isRec(st) && st.kind === 'rubric-step' && isRec(st.params) && st.params.step === line
+    && Array.isArray(st.params.parts) && st.params.parts.some((/** @type {any} */ x) => isRec(x) && Array.isArray(x.rules) && x.rules.includes(n)));
+  const refused = Array.isArray(declaration.refused) ? [...declaration.refused] : [];
+  const notes = Array.isArray(declaration.notes) ? [...declaration.notes] : [];
+  for (const row of dropRows(dropped)) {
+    const named = row.rule !== undefined && refused.some((/** @type {any} */ r) => isRec(r) && r.line === row.line && r.rule === row.rule);
+    if (named) continue;
+    if (row.full && row.rule !== undefined && !carried(row.line, row.rule)) {
+      refused.push({ line: row.line, rule: row.rule, reason: row.sentences.join(' ') });
+      continue;
+    }
+    const text = dropLine(row, jobLines, lineRules);
+    if (!notes.includes(text)) notes.push(text);
+  }
+  return { ...declaration, ...(refused.length ? { refused } : {}), ...(notes.length ? { notes } : {}) };
+}
+
 /**
  * The ~ rules the drafter listed under Not checked (`refused` entries that name a `rule`), each as one line in the person's own
  * words: `line N: "<the rule as written>" — <the drafter's reason>` (PART 1b, RF6 / RF16).
@@ -686,9 +812,14 @@ export function ruleNotChecked(closeDecl, jobLines) {
  * @param {any} closeDecl @returns {string[]}
  */
 export function proseNotChecked(closeDecl) {
+  return proseNotCheckedItems(closeDecl).map((i) => i.text);
+}
+
+/** the same items as {@link proseNotChecked} with the job line each belongs to (the stage's own `step`) @param {any} closeDecl @returns {{line: number, text: string}[]} */
+export function proseNotCheckedItems(closeDecl) {
   const stages = isRec(closeDecl) && Array.isArray(closeDecl.stages) ? closeDecl.stages : [];
   return stages.filter((/** @type {any} */ st) => isRec(st) && st.kind === 'rubric-step' && isRec(st.params) && Array.isArray(st.params.parts) && !factPartOf(st.params))
-    .map((/** @type {any} */ st) => `line ${st.params.step}: what the text says — you judge it at Accept`);
+    .map((/** @type {any} */ st) => ({ line: st.params.step, text: `line ${st.params.step}: what the text says — you judge it at Accept` }));
 }
 
 // ── the sign-vs-run invariant: the checks the person is SHOWN are the checks the signed close RUNS ───────────────────
@@ -732,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/runlist.js

@@ -104,7 +104,8 @@ export function appendRun(row, opts = {}) {
 }
 
 /**
- * @typedef {{ runid: string, type: 'settled'|'released', by: string, at: string, reason?: string, spentUsd?: number, spendComplete?: boolean, leg?: number }} RunEvent
+ * @typedef {{ runid: string, type: 'settled'|'released', by: string, at: string, reason?: string, words?: string, spentUsd?: number, spendComplete?: boolean, leg?: number }} RunEvent
+ * `words` (2026-10-19): on a `settled` with `reason: 'refused before start'`, the plain refusal the panel shows for that run (it has no spine).
  * `leg` (P5-R): which leg of the run the write-back is about; absent = leg 1 (every entry written before P5-R).
  * A resumed run is ONE row, so `settled`/`released` are per leg: a later leg's `released` gives back THAT leg's
  * claim and never removes the run.

package/src/schedulewords.js

@@ -6,6 +6,7 @@
 // its ENDED block is `endedFor` in src/panel/server.js).
 import { basename } from 'node:path';
 import { panelMoney2 } from './panel/authorroutes.js';
+import { STATUS } from './panel/status.js';
 
 /** @typedef {import('./trigger.js').Trigger} Trigger */
 
@@ -272,11 +273,13 @@ export function retryNextWords(ms) {
 
 /**
  * RULED 2026-10-15: the sign on the head of the Audit's `schedule` section. ONE small rule (hamr may still adjust it): [▶] only while a
- * run of the job is running (as everywhere in the panel), [✗] when the SCHEDULE row is red, else [·] (on, waiting).
- * @param {{running: boolean, red: boolean}} f @returns {{sign: string}}
+ * run of the job is running (as everywhere in the panel), [✗] when the SCHEDULE row is red, else [·] (on, waiting). RULED 2026-10-18 (v1.106
+ * Part 4): the header reads `[sign] word schedule · ...`, the sign AND the word both from the one status table (src/panel/status.js), never typed here.
+ * @param {{running: boolean, red: boolean}} f @returns {{sign: string, word: string}}
  */
 export function scheduleSignFor(f) {
-  return { sign: f.running ? '▶' : f.red ? '✗' : '·' };
+  const { sign, word } = f.running ? STATUS.running : f.red ? STATUS.failed : STATUS.waiting;
+  return { sign, word };
 }
 
 /** Audit schedule section, the `this run` words of a run the schedule started (the head already says which schedule and from where). @param {any} rec `trigger.json` */

package/src/source.js

@@ -1388,3 +1388,21 @@ export async function refreezeUrlInputs({ into, fetchUrl = (u) => fetchPageText(
   await writeFile(join(resolve(into), 'source.json'), `${JSON.stringify(next, null, 2)}\n`);
   return { ok: true, refreshed: rows.map((/** @type {any} */ r) => r.label), seed };
 }
+
+/**
+ * PRD v1.106 Part 5 Q2: what `source.json` says about web inputs, read synchronously and never throwing: whether the copy has any web input
+ * (`inputs[].url`) and when the run-start refetch last finished (`refrozenAt`, written last by {@link refreezeUrlInputs}). The panel decides
+ * "fetching the page..." from this: it applies while a web input exists and no refetch has finished at or after `sinceIso`.
+ * @param {string} sourceJsonPath @param {string|null|undefined} sinceIso
+ * @returns {{ hasWeb: boolean, fetching: boolean }}
+ */
+export function webFetchState(sourceJsonPath, sinceIso) {
+  try {
+    const m = JSON.parse(readFileSync(sourceJsonPath, 'utf8'));
+    const hasWeb = Array.isArray(m?.inputs) && m.inputs.some((/** @type {any} */ r) => r && typeof r.url === 'string' && r.url !== '');
+    if (!hasWeb) return { hasWeb: false, fetching: false };
+    const done = typeof m.refrozenAt === 'string' ? Date.parse(m.refrozenAt) : NaN;
+    const since = typeof sinceIso === 'string' ? Date.parse(sinceIso) : NaN;
+    return { hasWeb: true, fetching: !(Number.isFinite(done) && (!Number.isFinite(since) || done >= since)) };
+  } catch { return { hasWeb: false, fetching: false }; }
+}

package/src/thinking.js

@@ -5,8 +5,9 @@
 // NOT switchable), `'unverified'` (not measured — the shape ladder is tried at runtime; if every shape fails with a client
 // validation error ONE plain request decides, and the call still runs, reported `thinkingStatus: 'unsupported'`).
 //
-// The tick is the person's, per job ("Thinking on", the signed optional `thinking` field; absent = off). It covers DRAFTING and the
-// rubric JUDGE; the WORKER is never handed a thinking option. PER-CALL options, never constructor options (the drafter's provider is
+// The tick is the person's, per job ("Thinking on", the signed optional `thinking` field; absent = off). It covers DRAFTING, the
+// rubric JUDGE and, as the think-everywhere override, every WORKER call. Without the tick the WORKER's mode is decided here too, in
+// code, from the phase and attempt (`workerThinkingMode`, PRD v1.106 Part 1) — never by the model. PER-CALL options, never constructor options (the drafter's provider is
 // the worker's instance, deliberately left as it was). The raw `thinking` option is never sent (bare-agent throws if both are set).
 import { createRequire } from 'node:module';
 
@@ -128,3 +129,63 @@ export function thinkingRowText({ mode, support, status }) {
   if (support === 'unverified') return `thinking ${mode} (not verified for this model)`;
   return `thinking ${mode}`;
 }
+
+/**
+ * THE one decision for a worker model call (PRD v1.106 Part 1): from the phase label and attempt iteration `mkWorker` already holds,
+ * and the job's tick (`job.thinking === true`). Decided in code, never by the model.
+ *   tick on                                   -> 'on' for every call
+ *   plan (draft, redraft, replan)             -> 'on'   (the planner is the hard part of a run)
+ *   scout                                     -> 'off'
+ *   step:<id> attempt 1                       -> 'off'
+ *   step:<id> attempt >= 2                    -> 'on'
+ *   fix (close-fix)                           -> 'on'
+ * A step or fix iteration that is not a whole number >= 1 throws (operator error), as does an unknown phase — never a guess.
+ * @param {{ phase: unknown, iteration?: unknown, tick?: unknown }} o
+ * @returns {'on'|'off'}
+ */
+export function workerThinkingMode({ phase, iteration, tick }) {
+  if (typeof phase !== 'string') throw new Error(`[thinking] worker phase must be a string, got ${JSON.stringify(phase)}`);
+  const isStep = phase.startsWith('step:');
+  if (isStep || phase === 'fix') {
+    if (!Number.isInteger(iteration) || /** @type {number} */ (iteration) < 1) {
+      throw new Error(`[thinking] ${isStep ? 'step' : 'fix'} iteration must be a whole number >= 1, got ${JSON.stringify(iteration)} (phase "${phase}")`);
+    }
+  } else if (phase !== 'scout' && phase !== 'plan') {
+    throw new Error(`[thinking] unknown worker phase ${JSON.stringify(phase)}`);
+  }
+  if (tick === true) return 'on';
+  if (phase === 'scout') return 'off';
+  if (isStep) return iteration === 1 ? 'off' : 'on';
+  return 'on';
+}
+
+/**
+ * PRD v1.106 Part 3 — the words one worker call carries in the Audit, READ from the run's own spine, never guessed. Finds the LAST
+ * `thinking-decision` of `phase` (and `iteration`, when given) whose seq lies strictly between `lo` and `hi`, pairs it with the first
+ * `thinking-status` of the same phase and iteration after it (before the next decision), and words both through {@link thinkingRowText}
+ * (drafting's own words). `null` when the window holds no decision: a run from before the records existed shows no thinking word.
+ * @param {any[]} spine the run's spine records (each with a numeric `seq`)
+ * @param {{ phase: string, lo?: number, hi?: number, iteration?: number|null }} q
+ * @returns {string|null}
+ */
+export function thinkingWordsFrom(spine, { phase, lo = -Infinity, hi = Infinity, iteration }) {
+  const seqOf = (/** @type {any} */ e) => (typeof e?.seq === 'number' ? e.seq : NaN);
+  const sameIteration = (/** @type {any} */ e) => iteration === undefined || e.iteration === iteration;
+  const decisions = spine.filter((e) => e?.type === 'thinking-decision' && e.phase === phase && sameIteration(e) && seqOf(e) > lo && seqOf(e) < hi && (e.mode === 'on' || e.mode === 'off'));
+  const dec = decisions[decisions.length - 1];
+  if (!dec) return null;
+  const nextDecision = spine.find((e) => e?.type === 'thinking-decision' && seqOf(e) > seqOf(dec));
+  const stop = nextDecision ? seqOf(nextDecision) : Infinity;
+  const st = spine.find((e) => e?.type === 'thinking-status' && e.phase === dec.phase && e.iteration === dec.iteration && seqOf(e) > seqOf(dec) && seqOf(e) < stop);
+  return thinkingRowText({ mode: dec.mode, status: typeof st?.thinkingStatus === 'string' ? st.thinkingStatus : undefined });
+}
+
+/**
+ * The Job tab's row words (PRD v1.106 Part 3): the default rule, or the job's "Thinking on" tick, but only for a run whose spine
+ * recorded a `thinking-decision`; a run from before the thinking rule reads `—`, never a guess from the job's tick (fwdloop M4d am28).
+ * @param {boolean} tick @param {boolean} recorded the run's spine holds at least one `thinking-decision` @returns {string}
+ */
+export function thinkingJobText(tick, recorded) {
+  if (!recorded) return '\u2014';
+  return tick ? 'always on' : 'on retries';
+}

package/src/userrun.js

@@ -304,6 +304,7 @@ class ExitSignal extends Error {
  * @property {string} seed
  * @property {string} spineName
  * @property {string} [into] see `RunOpts.into`
+ * @property {boolean} [refreeze] a FRESH `--spec` run: fetch the web inputs again AFTER the run is listed (never on resume/door/decide)
  * @property {string|null} model
  * @property {string|null} providerKey
  * @property {string|null} readShim
@@ -493,7 +494,8 @@ async function execute(ctx) {
   const REGISTRY_TAIL = (ctx.registry ?? null) !== null ? ` --registry ${(ctx.registry ?? null)} --workflow ${(ctx.workflow ?? null) ?? spec.job}` : '';
 
   const WORKDIR = target.workdir;
-  const SEED = target.seed;
+  // `let`: a fresh run's refetch of its web inputs commits a NEW seed (below, after the run is listed)
+  let SEED = target.seed;
   const specHash = jobSpecHash(spec);
   // the re-invocation commands this engine prints: a bundle names its own door and hash,
   // every other caller gets today's byte-identical strings.
@@ -1584,6 +1586,24 @@ async function execute(ctx) {
     err(`WARNING: could not add this run to ~/.config/bareloop/runs.jsonl (${e.message}) — the run continues; the panel's list will be missing this row.`);
   }
 
+  // RUN START REFETCH (PART 1c RF22; moved here 2026-10-19, run mvez8s54: the ~18 s barebrowse fetch ran in main() BEFORE this run was
+  // listed, so Sign & run showed nothing for 18 s). The run is listed FIRST (row above, with its pid and cap = the monthly claim), THEN
+  // fetches: the Run tab reads "fetching the page…" while source.json has no refrozenAt at or after the row. A refusal cannot be a
+  // `released` row (that unlists the run and its words); it SETTLES the claim at $0 and keeps the plain reason for the panel.
+  if (ctx.refreeze === true && ctx.into !== undefined) {
+    const fresh = await refreezeUrlInputs({ into: ctx.into, ...(deps.fetchUrl ? { fetchUrl: deps.fetchUrl } : {}) });
+    if (!fresh.ok) {
+      const words = /did not start/.test(fresh.error) ? fresh.error : `${fresh.error}. The run did not start. Nothing spent.`;
+      err(`${SELECTOR}: ${fresh.error}`);
+      if (claimedRow) {
+        try { appendRunEvent({ runid, type: 'settled', by: runid, reason: 'refused before start', words, spentUsd: 0, spendComplete: true, at: new Date().toISOString() }, { home: claimedRow.home }); } catch { /* the exit stands; the dead pid's claim is closed by the next run */ }
+        claimedRow = null; // settled, not released: a released leg-1 row is unlisted, and the person must see why
+      }
+      throw new ExitSignal(2);
+    }
+    if (fresh.refreshed.length > 0 && typeof fresh.seed === 'string' && fresh.seed) SEED = fresh.seed;
+  }
+
   const git = (/** @type {string[]} */ a) => execFileSync('git', ['-C', wd, ...a], { encoding: 'utf8' }).trim();
   if (dead) {
     // A RESUME is the OPPOSITE case from a cold launch: the halted run's edits are work
@@ -2054,7 +2074,7 @@ async function execute(ctx) {
   const legDraftSpentUsd = typeof jobStartRec?.draftSpentUsd === 'number' && jobStartRec.draftSpentUsd > 0 ? jobStartRec.draftSpentUsd : null;
   const legDraftSpendComplete = legDraftSpentUsd === null ? null : jobStartRec.draftSpendComplete !== false;
   const spendCore = je?.spentUsd == null ? 'UNKNOWN' : `${je.spendComplete === false ? '≥' : ''}$${je.spentUsd.toFixed(4)}`;
-  out(`spent     ${moneyWithDraft(spendCore, legDraftSpentUsd, spec.budgetUsd, legDraftSpendComplete)}`);
+  out(`spent     ${moneyWithDraft(spendCore, legDraftSpentUsd, spec.budgetUsd, legDraftSpendComplete, je?.spentUsd ?? null)}`);
   // FOLDED, exactly like the money line above it: on a resume the cap governs both legs
   // together, and a leg-only wall next to a folded spend is two framings on one cap with
   // no label to tell them apart (F83). The leg stays on the line beside it.
@@ -2516,6 +2536,7 @@ export async function main(argv, deps = {}) {
     /** how a "go edit the spec" hint renders — `jobs/<file>` for `--job`, the
      * spec's own path for `--spec` (it has no `jobs/` home to point at). */
     let SPEC_DESC;
+    let refreeze = false;
     let spec;
 
     if (jobArg !== null) {
@@ -2592,24 +2613,16 @@ export async function main(argv, deps = {}) {
           + 'with exactly one source-*/ sibling.');
       }
       const into = candidates[0];
-      let manifestRead = await readSourceManifest(into);
+      const manifestRead = await readSourceManifest(into);
       if (manifestRead.stop !== null) {
         die(`--spec ${specPath}: ${manifestRead.code} — ${manifestRead.stop}`);
       }
       if (!manifestRead.present || !manifestRead.manifest) {
         die(`--spec ${specPath}: ${into} carries no source.json — not a prepared copy this runner can trust`);
       }
-      // PART 1c (RF22): a FRESH run of a rubric job with web inputs fetches each address again and makes that text the run's frozen
-      // input BEFORE the worker starts (the drafting copy was only for the look). A resume / door / decision keeps the copy its
-      // first start froze. A refusal is plain words, $0.
-      if (argFlag('resume') === null && argFlag('door') === null && argFlag('decide') === null) {
-        const fresh = await refreezeUrlInputs({ into, ...(deps.fetchUrl ? { fetchUrl: deps.fetchUrl } : {}) });
-        if (!fresh.ok) die(`--spec ${specPath}: ${fresh.error}`);
-        if (fresh.refreshed.length > 0) {
-          manifestRead = await readSourceManifest(into);
-          if (manifestRead.stop !== null || !manifestRead.manifest) die(`--spec ${specPath}: the run copy's record could not be read after the fresh fetch`);
-        }
-      }
+      // PART 1c (RF22): a FRESH run with web inputs fetches each address again before the worker starts. That happens in execute(),
+      // AFTER the run is listed (`ctx.refreeze`); a resume / door / decision keeps the copy its first start froze.
+      refreeze = argFlag('resume') === null && argFlag('door') === null && argFlag('decide') === null;
       const seed = manifestRead.manifest.seed;
       if (typeof seed !== 'string' || !seed) {
         die(`--spec ${specPath}: ${into}/source.json carries no seed commit — not a prepared copy this runner can trust`);
@@ -2647,6 +2660,7 @@ export async function main(argv, deps = {}) {
       seed: target.seed,
       spineName: target.spine,
       ...(target.into === undefined ? {} : { into: target.into }),
+      ...(refreeze ? { refreeze: true } : {}),
       model: argFlag('model'),
       providerKey: argFlag('provider'),
       readShim: argFlag('read-shim'),

package/types/authorflow.d.ts

@@ -10,12 +10,16 @@ export function linesNamedByReds(reds: Red[], declaration: any, lineNums: number
  * 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: any, failedLines: number[]): {
     kept: {
         line: number;
         question: string;
+        rule?: number;
+        source?: string;
+        ask?: "reading" | "cant-check";
+        reading?: string;
     }[];
     dropped: {
         reason: string;
@@ -1093,8 +1097,8 @@ export const REVISE_RED_CAP: 20;
 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
  * two before it both failed validation (a mechanism, never a wish: the schema carries it on that one call and nowhere
@@ -1680,12 +1684,44 @@ export const PARAM_SCHEMAS: Readonly<{
                                 description: string;
                             };
                             unit: {
-                                type: string;
-                                minLength: number;
+                                anyOf: ({
+                                    type: string;
+                                    minLength: number;
+                                    minItems?: undefined;
+                                    maxItems?: undefined;
+                                    uniqueItems?: undefined;
+                                    items?: undefined;
+                                } | {
+                                    type: string;
+                                    minItems: number;
+                                    maxItems: number;
+                                    uniqueItems: boolean;
+                                    items: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                    minLength?: undefined;
+                                })[];
                                 description: string;
                             };
                             currency: {
-                                enum: string[];
+                                anyOf: ({
+                                    enum: string[];
+                                    type?: undefined;
+                                    minItems?: undefined;
+                                    maxItems?: undefined;
+                                    uniqueItems?: undefined;
+                                    items?: undefined;
+                                } | {
+                                    type: string;
+                                    minItems: number;
+                                    maxItems: number;
+                                    uniqueItems: boolean;
+                                    items: {
+                                        enum: string[];
+                                    };
+                                    enum?: undefined;
+                                })[];
                                 description: string;
                             };
                             phrase: {