bareloop 0.42.0 → 0.44.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 ──────────────────────────────────────────────────────────────────────
@@ -552,6 +619,16 @@ const boundSpellings = (b) => {
   return [s, s.replace(/^0+(?=\d)/, ''), s.replace(/\.0+$/, '')];
 };
 
+/**
+ * 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).
+ * @param {unknown} b @param {string} said @returns {boolean}
+ */
+export const boundInWords = (b, said) => boundSpellings(b).some((sp) => said.includes(sp));
+
+/** @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 +658,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 +697,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 +744,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 +793,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 ───────────────────

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.
@@ -128,6 +129,41 @@ export function appendRunEvent(event, opts = {}) {
   try { chmodSync(path, 0o600); } catch { /* best-effort perms */ }
 }
 
+/**
+ * RULED 2026-10-15 ("Remove from Needs you"): the person took a stopped run's card out of the Needs-you list. ONE row
+ * `{runid, type:'needs-removed', at}` appended beside the run rows; it is not a run, a claim or an event ({@link readRunList}
+ * ignores it, so the monthly limit, the run counter and the scheduler never see it). Nothing is rewritten.
+ * @param {string} runid
+ * @param {{ home?: string, now?: () => number }} [opts]
+ * @returns {string} the `at` written
+ */
+export function appendNeedsRemoved(runid, opts = {}) {
+  const at = new Date((opts.now ?? Date.now)()).toISOString();
+  const path = runlistPath(opts.home);
+  mkdirSync(runlistHome(opts.home), { recursive: true, mode: 0o700 });
+  appendFileSync(path, `${JSON.stringify({ runid, type: 'needs-removed', at })}\n`);
+  try { chmodSync(path, 0o600); } catch { /* best-effort perms */ }
+  return at;
+}
+
+/**
+ * The newest `needs-removed` time (ms) per run id. An absent file is an empty map; a row with no readable time is not a removal.
+ * @param {{ home?: string }} [opts]
+ * @returns {Map<string, number>}
+ */
+export function readNeedsRemovals(opts = {}) {
+  /** @type {Map<string, number>} */
+  const out = new Map();
+  const path = runlistPath(opts.home);
+  if (!existsSync(path)) return out;
+  for (const r of parseJsonl(path).records) {
+    if (!r || r.type !== 'needs-removed' || typeof r.runid !== 'string') continue;
+    const t = typeof r.at === 'string' ? Date.parse(r.at) : NaN;
+    if (Number.isFinite(t) && t >= (out.get(r.runid) ?? -Infinity)) out.set(r.runid, t);
+  }
+  return out;
+}
+
 /**
  * @typedef {{ type: 'leg-start', runid: string, leg: number, pid?: number, capUsd?: number, at: string }} LegStart
  * A resumed run's NEW claim (P5-R, hamr 2026-10-02: one run, one id, one row): appended beside the run's row

package/src/schedulewords.js

@@ -0,0 +1,299 @@
+// T Part 3 (PANEL-BUILD.md T addendum, C.3 / C.6): the WORDS of a schedule. ONE owner of these strings. Pure
+// functions: typed facts in, a fixed sentence out. No model text ever reaches a sentence (the only slot-fills are
+// numbers, a file or folder name and the person's own path). `home` is injected (never a default inside a test).
+// Rewritten from fwdloop src/summary-words.js (`scheduledWords`, `slotWords`, `nextTimeWords`, `nextInWords`,
+// `scheduledNextFor`, `catchUpWords`), minus `endedWords` and every ask (bareloop has neither:
+// 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 */
+
+const DAY_PLURAL = { mon: 'Mondays', tue: 'Tuesdays', wed: 'Wednesdays', thu: 'Thursdays', fri: 'Fridays', sat: 'Saturdays', sun: 'Sundays' };
+const DAY_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const MONTH_SHORT = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+/** @param {number} n */
+const two = (n) => String(n).padStart(2, '0');
+/** @param {{hour: number, minute: number}} s */
+const hhmm = (s) => `${two(s.hour)}:${two(s.minute)}`;
+
+/** A path with the home folder shown as `~`. @param {string} p @param {string|undefined} home */
+function tilde(p, home) {
+  if (home && (p === home || p.startsWith(`${home}/`))) return `~${p.slice(home.length)}`;
+  return p;
+}
+
+/**
+ * Every schedule button/word the page shows lives here, so a reword is ONE edit (hamr will reword on his walk).
+ * The server sends this table with the run detail and the schedule card; the page reads every label from it.
+ */
+export const SCHEDULE_WORDS = Object.freeze({
+  byHand: 'By hand',
+  cancelSchedule: 'Cancel schedule',
+  cancelWords: 'Cancel schedule',
+  // the Run tab's buttons (never relabelled in place: a different state is a different button)
+  scheduleRun: 'Schedule run',
+  cancelModify: 'Cancel / modify schedule',
+  // the one main button of the schedule card
+  signSchedule: 'Sign schedule',
+  nothingChanged: 'Nothing changed yet. This card only sets or adjusts the schedule; it never runs the job.',
+  confirmPrefix: 'Confirm: ',
+  // the When field and the blocks
+  whenLabel: 'When',
+  nowPrefix: 'Now: ',
+  scheduledLabel: 'SCHEDULE',
+  nextLabel: 'NEXT',
+  options: Object.freeze({
+    hand: 'By hand',
+    daily: 'Every day at HH:MM',
+    weekdays: 'Weekdays at HH:MM',
+    weekly: 'Every <day> at HH:MM',
+    'file-updated': 'When <file> is updated',
+    'new-file': 'When a new file arrives in <folder>',
+  }),
+  // RULED 2026-10-15: the Needs-you pill of a schedule that gave up (hamr may reword)
+  gaveUpPill: 'Check',
+  // RULED 2026-10-15 (aligned with fwdloop M9 am7): the SCHEDULE row's second line when the last fire started nothing
+  problemNext: 'next: fix it in Cancel / modify schedule',
+  monthNext: 'next: raise the limit in Settings, or it starts on the 1st',
+  acceptWaiting: 'waiting for your Accept (the next run does not wait)',
+  scheduleGroup: 'schedule',
+  notGreen: 'This job has not had a good run yet. Run it by hand and get it right first; then you can set when it runs. A rubric job also needs your Accept once. Nothing was changed.',
+  stale: 'What you were shown is not what is on the card now. Nothing was signed. Look again, then sign.',
+});
+
+/**
+ * What starts the job, in words. `null` (by hand) has no sentence.
+ * @param {Trigger|null|undefined} t @param {string} [home]
+ * @returns {string|null}
+ */
+export function scheduledWords(t, home) {
+  if (!t) return null;
+  if (t.kind === 'daily') return `Every day at ${hhmm(t)}`;
+  if (t.kind === 'weekdays') return `Weekdays at ${hhmm(t)}`;
+  if (t.kind === 'weekly') return `${DAY_PLURAL[/** @type {keyof typeof DAY_PLURAL} */ (t.day)] ?? t.day} at ${hhmm(t)}`;
+  if (t.kind === 'file-updated') return `When ${basename(t.path)} is updated`;
+  const folder = tilde(/** @type {{folder: string}} */ (t).folder, home);
+  return `When a new file arrives in ${folder.endsWith('/') ? folder : `${folder}/`}`;
+}
+
+/** "Mon 13 Oct, 09:00" — local time, fixed English names (never the machine's locale). @param {number} ms */
+export function slotWords(ms) {
+  const d = new Date(ms);
+  return `${DAY_SHORT[d.getDay()]} ${d.getDate()} ${MONTH_SHORT[d.getMonth()]}, ${two(d.getHours())}:${two(d.getMinutes())}`;
+}
+
+/**
+ * The Scheduled card's first line: "today 17:00", "tomorrow 09:00", else the date the NEXT line already says
+ * ("Tue 20 Oct, 09:05"). Local time, by calendar day. @param {number} ms the next run @param {number} now
+ */
+export function nextTimeWords(ms, now) {
+  const d = new Date(ms);
+  const day = (/** @type {Date} */ x) => new Date(x.getFullYear(), x.getMonth(), x.getDate()).getTime();
+  const apart = Math.round((day(d) - day(new Date(now))) / 86_400_000);
+  if (apart === 0) return `today ${two(d.getHours())}:${two(d.getMinutes())}`;
+  if (apart === 1) return `tomorrow ${two(d.getHours())}:${two(d.getMinutes())}`;
+  return slotWords(ms);
+}
+
+/** "next in 20m" / "next in 3h" / "next in 3d" (whole units, rounded down, never "0m"). @param {number} ms @param {number} now */
+export function nextInWords(ms, now) {
+  const mins = Math.max(1, Math.floor((ms - now) / 60_000));
+  if (mins < 60) return `next in ${mins}m`;
+  const hours = Math.floor(mins / 60);
+  return hours < 48 ? `next in ${hours}h` : `next in ${Math.floor(hours / 24)}d`;
+}
+
+/**
+ * NEXT of a scheduled job: one sentence, first match wins.
+ *  1. a run of this job is waiting for the person's Accept (the next scheduled run does NOT wait for it, T7);
+ *  2. the latest outcome this month is `monthly-exhausted` (amounts from the row), RED;
+ *  3. a clock kind with a next slot; 4. a file kind that is armed; 5. not armed yet.
+ * A last outcome of `refused` goes in front of 3-5, so a trigger that cannot start is never silent.
+ * `red` is the typed flag for "the person must act": the page paints it and never guesses from the text.
+ * @param {{trigger: Trigger, armed: boolean, nextSlotMs: number|null, lastOutcome: any, waitingRunNo: number|null, now: number, retryInMs?: number|null, gaveUp?: any}} f
+ *   `lastOutcome` = the newest outcome row of the CURRENT signing (`kind`, `at` in ms, `why`, `leftUsd`, `needUsd`, `atLeast`)
+ * @returns {{text: string, red: boolean}}
+ */
+export function scheduledNextFor(f) {
+  const { trigger, armed, nextSlotMs, lastOutcome, waitingRunNo, now, retryInMs = null, gaveUp = null } = f;
+  /** @param {string} text @param {boolean} [red] */
+  const say = (text, red = false) => ({ text, red });
+  if (waitingRunNo !== null) return say(`Run ${waitingRunNo} is waiting for your Accept. The next scheduled run does not wait for it.`);
+  if (gaveUp && typeof gaveUp === 'object') return say(gaveUpNextWords(gaveUp.why), true);
+  const last = lastOutcome && typeof lastOutcome === 'object' ? lastOutcome : null;
+  const sameMonth = last !== null && sameMonthAs(last.at, now);
+  if (last !== null && last.kind === 'monthly-exhausted' && sameMonth && typeof last.leftUsd === 'number' && typeof last.needUsd === 'number') {
+    const left = last.atLeast === true ? `at most ${panelMoney2(last.leftUsd)} left` : `${panelMoney2(last.leftUsd)} left`;
+    return say(`Paused: not enough money left this month (${left}, a run needs up to ${panelMoney2(last.needUsd)}). Raise the monthly limit in Settings, or it starts again on the 1st.`, true);
+  }
+  const lead = last !== null && last.kind === 'refused' && typeof last.why === 'string' && last.why !== '' ? `The last try did not start: ${last.why} ${retryWords(retryInMs)}` : '';
+  const red = lead !== '';
+  if (!armed) return say(`${lead}Not armed yet: the panel arms it on its next check.`, red);
+  if (trigger.kind === 'file-updated') return say(`${lead}Watching for it. A run starts when its contents change.`, red);
+  if (trigger.kind === 'new-file') return say(`${lead}Watching for it. A run starts for each new file.`, red);
+  if (nextSlotMs === null) return say(`${lead}Not armed yet: the panel arms it on its next check.`, red);
+  return say(`${lead}Next run ${slotWords(nextSlotMs)}.`, red);
+}
+
+/** Is `atMs` in the same local calendar month as `nowMs`? A non-number is never. @param {unknown} atMs @param {number} nowMs */
+export function sameMonthAs(atMs, nowMs) {
+  if (typeof atMs !== 'number' || !Number.isFinite(atMs)) return false;
+  const a = new Date(atMs); const n = new Date(nowMs);
+  return a.getFullYear() === n.getFullYear() && a.getMonth() === n.getMonth();
+}
+
+/** RULED 2026-10-15: the red NEXT of a schedule that gave up. @param {unknown} why the refusal's own words */
+export function gaveUpNextWords(why) {
+  const w = typeof why === 'string' ? why.trim().replace(/\.$/, '') : '';
+  return `Stopped trying after 60 minutes: ${w}. Fix it, then Cancel / modify schedule to start again.`;
+}
+
+/** The give-up date on the Needs-you card, local `MM/DD HH:MM`. @param {number} ms */
+export function gaveUpDateWords(ms) {
+  const d = new Date(ms);
+  return `${two(d.getMonth() + 1)}/${two(d.getDate())} ${two(d.getHours())}:${two(d.getMinutes())}`;
+}
+
+/** RULED 2026-10-15: after an install-needed refusal, the wait that is left, in whole minutes rounded up; '' when no wait. @param {number|null|undefined} ms */
+export function retryWords(ms) {
+  if (typeof ms !== 'number' || !(ms > 0)) return '';
+  const m = Math.ceil(ms / 60_000);
+  return `Trying again in ${m} minute${m === 1 ? '' : 's'}. `;
+}
+
+/** The fixed catch-up sentence from a run's `trigger.json`. @param {any} rec */
+export function catchUpWords(rec) {
+  return rec && typeof rec === 'object' && rec.catchUp === true ? 'This run was a catch-up: it started more than 2 minutes after its set time (the panel was off).' : null;
+}
+
+/**
+ * A spawn error AFTER the consuming row: `tries` releases so far, `max` the bound. Under the bound it will be tried again;
+ * at the bound it stays consumed and says so. @param {string} why @param {number} tries @param {number} max
+ */
+export function lateRefusalWords(why, tries, max) {
+  return tries < max ? `${why} It will be tried again.` : `${why} It was tried ${max} times and is given up on.`;
+}
+
+// ---------------------------------------------------------------------------------------------------------------------------
+// RULED 2026-10-15 (aligned with fwdloop M9 am7): the schedule on the Run, Job and Audit tabs. ONE owner of these sentences.
+
+/** "10/15 13:40" — local time. @param {number} ms */
+export const dateTimeWords = (ms) => gaveUpDateWords(ms);
+
+/** @param {string} s */
+export const lowerFirst = (s) => (s === '' ? s : s[0].toLowerCase() + s.slice(1));
+
+/** "Thu 10/16 08:15" — local time, fixed English day names. @param {number} ms */
+export function nextSlotShort(ms) {
+  const d = new Date(ms);
+  return `${DAY_SHORT[d.getDay()]} ${two(d.getMonth() + 1)}/${two(d.getDate())} ${two(d.getHours())}:${two(d.getMinutes())}`;
+}
+
+/** @param {any} rec a run's `trigger.json` @returns {boolean} */
+function isNewFile(rec) {
+  if (rec.triggerKind) return rec.triggerKind === 'new-file';
+  return typeof rec.trigger === 'string' && rec.trigger.startsWith('When a new file arrives');
+}
+
+/**
+ * Job tab, "Started": how the run began, then its local start time. `rec` = the run's `trigger.json` (null on a hand run).
+ * @param {any} rec @param {number|null} atMs the run's start
+ */
+export function startedWords(rec, atMs) {
+  const when = atMs === null ? '' : ` · ${dateTimeWords(atMs)}`;
+  if (!rec || typeof rec !== 'object') return `${SCHEDULE_WORDS.byHand}${when}`;
+  const trig = typeof rec.trigger === 'string' ? rec.trigger : '';
+  let how;
+  if (rec.kind === 'file') {
+    const name = basename(String(rec.file ?? ''));
+    how = isNewFile(rec) ? `By a new file: ${name}` : `By a file update: ${name}`;
+  } else {
+    how = `By the schedule: ${lowerFirst(trig)}`;
+    if (rec.catchUp === true) {
+      const min = typeof rec.lateMs === 'number' && rec.lateMs > 0 ? Math.round(rec.lateMs / 60_000) : null;
+      how += min === null ? ' · catch-up' : ` · catch-up, ${min} min late`;
+    }
+  }
+  return `${how}${when}`;
+}
+
+/**
+ * Audit, first row of a run a schedule started. @param {any} rec `trigger.json` @param {number|null} originNo the origin run's number
+ */
+export function startedAuditWords(rec, originNo) {
+  const from = originNo === null ? '' : ` · from run-${originNo}`;
+  if (rec.kind === 'file') return `started by the schedule · ${isNewFile(rec) ? 'new file' : 'file update'} ${basename(String(rec.file ?? ''))}${from}`;
+  const slot = typeof rec.slot === 'number' ? ` · slot ${two(new Date(rec.slot).getHours())}:${two(new Date(rec.slot).getMinutes())}` : '';
+  return `started by the schedule · ${lowerFirst(String(rec.trigger ?? ''))}${slot}${from}${rec.catchUp === true ? ' · catch-up' : ''}`;
+}
+
+/** 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(/\.$/, '');
+}
+
+/**
+ * A fire that started nothing, in plain words. `short` = the SCHEDULE row's `last` reason; else the Audit group's line.
+ * @param {any} row a ledger row (`busy` | `monthly-exhausted` | `refused` | `gave-up`) @param {boolean} [short]
+ */
+export function skippedWords(row, short = false) {
+  if (row.kind === 'busy') return short ? 'busy: a run of this job was still working' : 'busy: a run of this job was still working. Nothing started.';
+  if (row.kind === 'monthly-exhausted') {
+    const left = typeof row.leftUsd === 'number' ? `${row.atLeast === true ? 'at most ' : ''}${panelMoney2(row.leftUsd)}` : 'little';
+    const need = typeof row.needUsd === 'number' ? panelMoney2(row.needUsd) : 'more';
+    return short ? `month used up: ${left} left, needs ${need}` : `month used up: ${left} left, needs ${need}. Nothing spent.`;
+  }
+  const r = lowerFirst(reasonOf(row.why));
+  return short ? `refused: ${r}` : `refused: ${r}. Nothing started.`;
+}
+
+/**
+ * Job tab, "Schedule": the job's schedule NOW and what it is bound to. The first part IS the Run tab's line ({@link scheduledWords}),
+ * first letter lowered, so the two can never disagree.
+ * @param {{trigger: Trigger|null, originNo: number|null, model: string|null, destination: string|null, home?: string}} f
+ */
+export function jobScheduleWords(f) {
+  const w = f.trigger ? scheduledWords(f.trigger, f.home) : null;
+  if (w === null) return 'none';
+  const parts = [lowerFirst(w)];
+  if (f.originNo !== null) parts.push(`from run-${f.originNo}`);
+  if (f.model) parts.push(f.model);
+  if (f.destination) parts.push(tilde(f.destination, f.home));
+  return parts.join(' · ');
+}
+
+/** RULED 2026-10-15: the SCHEDULE row's `next` while an install-needed refusal is waiting to be tried again. @param {number} ms */
+export function retryNextWords(ms) {
+  const m = Math.max(1, Math.ceil(ms / 60_000));
+  return `next: tries again in ${m} min`;
+}
+
+/**
+ * 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). 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) {
+  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` */
+export function sectionThisRunWords(rec) {
+  if (rec.kind === 'file') return `started by the schedule · ${isNewFile(rec) ? 'new file' : 'file update'} ${basename(String(rec.file ?? ''))}`;
+  let late = '';
+  if (rec.catchUp === true) {
+    const min = typeof rec.lateMs === 'number' && rec.lateMs > 0 ? Math.round(rec.lateMs / 60_000) : null;
+    late = min === null ? ' · catch-up' : ` · catch-up, ${min} min late`;
+  }
+  return `started by the schedule · ${lowerFirst(String(rec.trigger ?? ''))}${late}`;
+}
+
+/** Audit schedule section, folded tail: `1 try started nothing` / `N tries started nothing`; '' for none. @param {number} n */
+export function triesTailWords(n) {
+  return n > 0 ? `${n} ${n === 1 ? 'try' : 'tries'} started nothing` : '';
+}

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 }; }
+}