bareloop 0.43.0 → 0.45.0

package/src/panel/jobplan.js

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

package/src/panel/runroutes.js

@@ -16,12 +16,15 @@ import {
   openSync, closeSync, writeFileSync, readFileSync, readdirSync,
 } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { checkHumanGuard, OLD_JOB_ACCEPT_WORDS, OLD_JOB_RESUME_WORDS } from './authorroutes.js';
+import {
+  checkHumanGuard, OLD_JOB_ACCEPT_WORDS, OLD_JOB_RESUME_WORDS, OLD_JOB_RERUN_WORDS, OLD_JOB_PAUSE_WORDS,
+} from './authorroutes.js';
 import { checkMonthlyRoom, monthlyRefusalText } from '../monthly.js';
 import { ConfigError } from '../config.js';
 import { keysForDoor } from '../keysfile.js';
 import { jobSpecHash, validateJob } from '../job.js';
 import { stopFilePath } from '../legs.js';
+import { panelMoney2 } from '../panelmoney.js';
 import { appendNeedsRemoved } from '../runlist.js';
 
 /** the tail of an engine log shown to the person when the engine refuses at start (bytes) */
@@ -65,7 +68,7 @@ function readLogTail(file) {
  * recorded...`, `CHECKPOINT EXPIRED — ...`); anything else (validator reds, exit statuses, stack traces, argv) becomes ONE fixed
  * sentence naming the log. The one owner for the Resume and Accept routes.
  * @param {string} tail the log tail
- * @param {'resume'|'accept'} kind
+ * @param {'resume'|'accept'|'rerun'|'pause'} kind
  * @param {string} logFile
  * @param {(stage: string) => string|null} [questionOf] stage name to the panel's plain question (`null` = none)
  * @returns {string}
@@ -85,9 +88,10 @@ export function engineRefusalWords(tail, kind, logFile, questionOf = () => null)
       return line;
     }
   }
-  return kind === 'resume'
-    ? `Resume did not start. Nothing was spent on it. The details are in ${logFile}.`
-    : `Accept did not go through. Nothing was recorded. The details are in ${logFile}.`;
+  if (kind === 'resume') return `Resume did not start. Nothing was spent on it. The details are in ${logFile}.`;
+  if (kind === 'rerun') return `Rerun did not start. Nothing was spent on it. The details are in ${logFile}.`;
+  if (kind === 'pause') return `Pause did not go through. Nothing was recorded. The details are in ${logFile}.`;
+  return `Accept did not go through. Nothing was recorded. The details are in ${logFile}.`;
 }
 
 /**
@@ -159,24 +163,30 @@ export function createRunRoutes(opts) {
   }
 
   /**
-   * T Part 8 — `POST /api/runs/:runid/accept`. The person's Accept of a run waiting at its REVIEW DOOR, recorded through the
-   * library's own door path and nothing else: `run-u --spec <signed spec> --door <runid> --decide accept --approve <hash>`
+   * T Part 8 + PRD v1.107 Part 6 — the person's answer to a run waiting at its REVIEW DOOR: `accept`, `rerun` (with their words) or `pause`, recorded through
+   * the library's own door path and nothing else: `run-u --spec <signed spec> --door <runid> --decide <accept|rerun|pause> [--text …] --approve <hash>`
    * (src/userrun.js, `answerReviewDoor`, src/reviewdoor.js). The panel invents no verdict path: the engine re-runs the MECHANICAL
-   * stages against the tree as it stands, a red there is `door-accept-red` and refuses, and only then is the disposition written
+   * stages against the tree as it stands for an accept (a red there is `door-accept-red` and refuses), and only then is the disposition written
    * to the run's own spine. The verdict the run minted is untouched. The engine's own words are what the page shows.
+   * An accept and a pause end when the engine does; a RERUN launches a fresh engagement (a paid run), so it answers like Resume: started, or the engine's refusal.
    * @param {import('node:http').IncomingMessage} req
    * @param {(code: number, obj: any) => void} send
    * @param {string} runid
+   * @param {'accept'|'rerun'|'pause'} decide
+   * @param {any} body the request body (`text` for a rerun)
    * @returns {boolean}
    */
-  function handleAccept(req, send, runid) {
+  function handleDoor(req, send, runid, decide, body) {
     const guard = checkHumanGuard(req, { token: opts.token, port: opts.port });
     if (!guard.ok) { send(403, { ok: false, error: `refused — ${guard.reason}` }); return true; }
     if (req.method !== 'POST') { send(405, { ok: false, error: 'POST only' }); return true; }
     const ctx = opts.getAcceptContext ? opts.getAcceptContext(runid) : null;
     if (!ctx) { send(404, { ok: false, error: 'no such run' }); return true; }
-    if (ctx.live) { send(409, { ok: false, error: 'This run is still running, so there is nothing to accept yet.' }); return true; }
-    if (!ctx.waiting) { send(409, { ok: false, error: 'This run is not waiting for your Accept (it opened no review door, the door was already answered, or it has expired).' }); return true; }
+    if (ctx.live) { send(409, { ok: false, error: decide === 'accept' ? 'This run is still running, so there is nothing to accept yet.' : `This run is still running, so there is nothing to ${decide} yet.` }); return true; }
+    if (!ctx.waiting) { send(409, { ok: false, error: decide === 'accept' ? 'This run is not waiting for your Accept (it opened no review door, the door was already answered, or it has expired).' : `This run is not waiting for your answer, so it cannot be ${decide === 'rerun' ? 'rerun' : 'paused'} (it opened no review door, the door was already answered, or it has expired).` }); return true; }
+    // a rerun's words ARE the gap the worker is given: empty words are refused here in plain words (the engine refuses them too, src/kinds.js normalizeHumanRuling)
+    const text = decide === 'rerun' && typeof body?.text === 'string' ? body.text.trim() : '';
+    if (decide === 'rerun' && text === '') { send(400, { ok: false, error: 'Write what you want done differently, then press Rerun. Your words are what the next attempt is given.' }); return true; }
     if (!ctx.specPath || !ctx.specHash) { send(409, { ok: false, error: "The signed job this run was judged by cannot be found on disk, so its door cannot be answered from here. Nothing was recorded." }); return true; }
     // RULED 2026-10-15: an old run whose saved job fails today's checks is refused at $0 in plain words, before any spawn
     /** @type {any} */
@@ -185,15 +195,21 @@ export function createRunRoutes(opts) {
     if (signed !== null) {
       let jv;
       try { jv = validateJob(signed, { shellCapUsd: signed.budgetUsd }); } catch { jv = { ok: false, reds: [] }; }
-      if (!jv.ok) { send(409, { ok: false, error: OLD_JOB_ACCEPT_WORDS, reds: jv.reds.map((r) => `${r.code} at ${r.path}`) }); return true; }
+      if (!jv.ok) {
+        const words = decide === 'accept' ? OLD_JOB_ACCEPT_WORDS : (decide === 'rerun' ? OLD_JOB_RERUN_WORDS : OLD_JOB_PAUSE_WORDS);
+        send(409, { ok: false, error: words, reds: jv.reds.map((r) => `${r.code} at ${r.path}`) });
+        return true;
+      }
     }
     const questionOf = (/** @type {string} */ n) => (signed !== null && opts.stageQuestionsOfSpec ? opts.stageQuestionsOfSpec(signed).get(n) ?? null : null);
     const dir = dirname(ctx.specPath);
-    const logFile = join(dir, `accept-${runid}-${Date.now()}.log`);
+    const logFile = join(dir, `${decide}-${runid}-${Date.now()}.log`);
     const args = [
-      '--wait', 'systemd-inhibit', '--why=bareloop panel accept',
+      '--wait', 'systemd-inhibit', `--why=bareloop panel ${decide}`,
       process.execPath, bareloopBin,
-      'run-u', '--spec', ctx.specPath, '--door', runid, '--decide', 'accept', '--approve', ctx.specHash,
+      'run-u', '--spec', ctx.specPath, '--door', runid, '--decide', decide, '--approve', ctx.specHash,
+      // last, so no flag lookup in the engine can land on the person's words
+      ...(decide === 'rerun' ? ['--text', text] : []),
     ];
     /** @type {number|null} */
     let logFd = null;
@@ -203,14 +219,18 @@ export function createRunRoutes(opts) {
     if (typeof child?.unref === 'function') child.unref();
     let done = false;
     const finish = (/** @type {number} */ code, /** @type {any} */ obj) => { if (!done) { done = true; send(code, obj); } };
-    // an accept that outlasts the wait is still going: say so (202), never claim it passed
-    const timer = setTimeout(() => finish(202, { ok: true, pending: true, runid, log: logFile }), opts.acceptWaitMs ?? DEFAULT_ACCEPT_WAIT_MS);
+    const answered = { accept: { accepted: true }, rerun: { rerunning: true }, pause: { paused: true } }[decide];
+    // an accept that outlasts the wait is still going: say so (202), never claim it passed. A rerun is a run: it is "started" once it outlives the settle window.
+    const timer = setTimeout(
+      () => (decide === 'rerun' ? finish(200, { ok: true, ...answered, runid, log: logFile }) : finish(202, { ok: true, pending: true, runid, log: logFile })),
+      decide === 'rerun' ? settleMs : (opts.acceptWaitMs ?? DEFAULT_ACCEPT_WAIT_MS),
+    );
     if (typeof timer.unref === 'function') timer.unref();
     if (typeof child?.once === 'function') {
       child.once('exit', (/** @type {number|null} */ code) => {
         clearTimeout(timer);
-        if (code === 0) finish(200, { ok: true, accepted: true, runid, log: logFile });
-        else finish(409, { ok: false, error: engineRefusalWords(readLogTail(logFile), 'accept', logFile, questionOf), log: logFile });
+        if (code === 0) finish(200, { ok: true, ...answered, runid, log: logFile });
+        else finish(409, { ok: false, error: engineRefusalWords(readLogTail(logFile), decide, logFile, questionOf), log: logFile });
       });
       child.once('error', (/** @type {Error} */ e) => {
         clearTimeout(timer);
@@ -256,15 +276,19 @@ export function createRunRoutes(opts) {
     const stopM = /^\/api\/runs\/([A-Za-z0-9._~-]+)\/stop$/.exec(pathname);
     const m = /^\/api\/runs\/([A-Za-z0-9._~-]+)\/resume$/.exec(pathname);
     const acceptM = /^\/api\/runs\/([A-Za-z0-9._~-]+)\/accept$/.exec(pathname);
+    const rerunM = /^\/api\/runs\/([A-Za-z0-9._~-]+)\/rerun$/.exec(pathname);
+    const pauseM = /^\/api\/runs\/([A-Za-z0-9._~-]+)\/pause$/.exec(pathname);
     const needsM = /^\/api\/runs\/([A-Za-z0-9._~-]+)\/needs-remove$/.exec(pathname);
-    if (!m && !stopM && !acceptM && !needsM) return false;
+    if (!m && !stopM && !acceptM && !needsM && !rerunM && !pauseM) return false;
     const send = (/** @type {number} */ code, /** @type {any} */ obj) => {
       const text = JSON.stringify(obj);
       res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'content-length': Buffer.byteLength(text) });
       res.end(text);
     };
     if (stopM) return handleStop(req, send, stopM[1]);
-    if (acceptM) return handleAccept(req, send, acceptM[1]);
+    if (acceptM) return handleDoor(req, send, acceptM[1], 'accept', body);
+    if (rerunM) return handleDoor(req, send, rerunM[1], 'rerun', body);
+    if (pauseM) return handleDoor(req, send, pauseM[1], 'pause', body);
     if (needsM) return handleNeedsRemove(req, send, needsM[1]);
     if (!m) return false;
     const guard = checkHumanGuard(req, { token: opts.token, port: opts.port });
@@ -300,7 +324,7 @@ export function createRunRoutes(opts) {
     // tighten-only: a cap at or below what the run has ALREADY used buys an immediate re-halt
     // (the engine only warns), so it is refused here at $0, before anything is written or spawned
     if (typeof plan.spentUsd === 'number' && spec.budgetUsd <= plan.spentUsd) {
-      send(400, { ok: false, error: `The money cap must be above what is already spent (${plan.spendComplete ? '' : 'at least '}$${plan.spentUsd.toFixed(2)}) — raise it, then Resume.` });
+      send(400, { ok: false, error: `The money cap must be above what is already spent (${plan.spendComplete ? '' : 'at least '}${panelMoney2(plan.spentUsd)}) — raise it, then Resume.` });
       return true;
     }
     if (typeof plan.wallUsedMs === 'number' && typeof spec.maxWallMs === 'number' && spec.maxWallMs <= plan.wallUsedMs) {