bareloop 0.42.0 → 0.44.0

package/src/panel/status.js

@@ -72,3 +72,36 @@ export function partStatusFor(part) {
   }
   return statusFor({ outcome: 'green' });
 }
+
+/**
+ * PRD v1.106 Part 5 (C, choice 9): the review door's words, ONE table. The door is the only human step bareloop has; there is no "you
+ * cancelled" (cancel is deleted). `decision` is the spine's `door-decision.decision`, or null while nothing has been decided.
+ */
+export const DOOR_WORDS = Object.freeze({
+  waiting: Object.freeze({ head: 'waiting for you', row: 'paused for you', last: 'none yet' }),
+  accept: Object.freeze({ head: 'you accepted', row: 'you accepted', last: 'you accepted' }),
+  rerun: Object.freeze({ head: 'you said rerun', row: 'you said rerun', last: 'you said rerun' }),
+  pause: Object.freeze({ head: 'paused', row: 'paused', last: 'paused' }),
+});
+
+/**
+ * The words one door wears: header phrase, the `last answer:` line (with the time `HH:MM` once decided) and the table rows.
+ * @param {{at: string|null, paths: string[], decision: string|null, text: string|null, decidedAt: string|null}} door
+ * @returns {{ head: string, last: string, rows: Array<{path: string|null, text: string, time: string|null}> }}
+ */
+export function doorViewOf(door) {
+  const key = door.decision === 'accept' || door.decision === 'rerun' || door.decision === 'pause' ? door.decision : 'waiting';
+  const w = DOOR_WORDS[key];
+  const path = door.paths.length === 0 ? null : door.paths.join(', ');
+  const hhmm = (/** @type {string|null} */ iso) => (iso && /T(\d\d:\d\d)/.exec(iso)?.[1]) || null;
+  const said = key === 'rerun' && door.text ? `${w.row}: "${door.text}"` : w.row;
+  /** @type {Array<{path: string|null, text: string, time: string|null}>} */
+  const rows = [{ path, text: DOOR_WORDS.waiting.row, time: door.at }];
+  if (key !== 'waiting') rows.push({ path, text: said, time: door.decidedAt });
+  const when = hhmm(door.decidedAt);
+  const last = key === 'waiting' ? w.last : `${key === 'rerun' && door.text ? said : w.last}${when ? ` · ${when}` : ''}`;
+  return { head: w.head, last, rows };
+}
+
+/** the marker a part wears for who did its work (PRD v1.106 Part 5 C/G): the model, or a person asked */
+export const ACTOR_MARKER = Object.freeze({ model: '[model]', human: '[human · ask]' });

package/src/panelmoney.js

@@ -0,0 +1,29 @@
+// The panel's ONE money spelling (hamr's ruling 2026-10-19, PRD "Part 6 rulings" (3)):
+//   - an amount of $0.01 or more: 2 decimals, rounded half-up ("$0.82", "$3.71");
+//   - a REAL positive amount under a cent: 4 decimals ("$0.0054"), never "<$0.01" and never "$0.00"
+//     (one too small for 4 decimals reads "<$0.0001"; one that rounds up to a cent reads "$0.01");
+//   - exact zero: "$0.00"; null/undefined/non-finite: "unknown" (never a fabricated $0).
+// `src/panel/index.html` carries a browser-script copy of this same function (`panelMoney`, it
+// cannot import a module); tests/panel-page.test.js pins the two to identical output. The CLI's own
+// 4-decimal `money()` (src/replay.js) is a different, unchanged spelling.
+
+/**
+ * @param {number|null|undefined} n a dollar amount
+ * @returns {string}
+ */
+export function panelMoney2(n) {
+  if (n === null || n === undefined) return 'unknown';
+  const v = Number(n);
+  if (!Number.isFinite(v)) return 'unknown';
+  // clean to 6-decimal precision first (the precision src/text.js sums to) so a float sitting just
+  // under an exact boundary is never mis-rounded
+  const clean = Math.round(v * 1e6) / 1e6;
+  if (clean > 0 && clean < 0.01) {
+    const units = Math.round(clean * 1e4 + 1e-6);
+    if (units <= 0) return '<$0.0001';
+    if (units >= 100) return '$0.01';
+    return `$${(units / 1e4).toFixed(4)}`;
+  }
+  const cents = Math.max(0, Math.round(clean * 100 + 1e-6));
+  return `$${(cents / 100).toFixed(2)}`;
+}

package/src/planrun.js

@@ -42,10 +42,11 @@ import { globToPrefix, redactSecrets, SECRET_PATTERNS } from './validate.js';
 import { validateBridge, loadGate, newestEligibleVersion, reuseEligibility, quarantinesCredit, QUARANTINED_CODE } from './bridges.js';
 import { extractArtifact, rateSourceFields } from './text.js';
 import { defaultJudgeLoop } from './judged.js';
+import { workerThinkingMode, thinkingCallOptions } from './thinking.js';
 export { rateSourceFields };
 import { createClock, isWallTimeout } from './clock.js';
 import { isDeclaredClose, runDeclaredStages, validateCloseDecl, closeGrade, HUMAN_PAUSE, HITL_PAUSE, HITL_DECISION_RED } from './declaredclose.js';
-import { inputLabelsOf } from './rubricstep.js';
+import { inputLabelsOf, outputJudgedRecords } from './rubricstep.js';
 import {
   seedAtHead, seedListing, changedSet, GAP_TRIM_MARKER, GATE_AUDIT_FILE, ARBITER_BOOK_STORES,
   HUMAN_KIND, HUMAN_DECISIONS, normalizeHumanRuling, resolveHumanRuling,
@@ -541,6 +542,10 @@ export const BOUND_REASON_MAX = 200;
 
 /** the recorded reason for a step attempt whose round was cut at the output cap (F122 2A b) */
 export const TRUNCATED_REASON = 'output cut at the token limit (max_tokens)';
+/** the red fed to the redraft when the first replan answer was cut off (plain words, from code) */
+const REPLAN_CUT_RED = 'Your previous answer was cut off at its length limit before the plan was complete. Answer again with a shorter plan that fits.';
+/** the plain sentence for a replan answer cut off at its length limit (hamr 2026-10-16, run mv9gm796) */
+export const REPLAN_CUT_WORDS = 'The replan answer was cut off at its length limit, so no new plan came back.';
 
 /**
  * What the NEXT attempt is told about the bound that cut the previous one.
@@ -1661,6 +1666,8 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
    * `null` for a command close, which has no baseline to measure against. */
   /** @type {{seedRef: string}|null} */
   let declaredCtx = null;
+  /** @type {number|null} the step try whose checks are running right now (the `rubric-evidence` record's `iteration`); null outside a step's judge */
+  let judgingIteration = null;
   /**
    * ONE close-execution seam, chosen once by which field the SIGNED spec carries.
    * Both executors return `runClose`'s verdict shape, so everything downstream —
@@ -1699,6 +1706,20 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // handed through as the FUNCTION (not a snapshot) so a retried locate call
       // re-reads the remaining time rather than reusing the first attempt's.
       callBounds,
+      // REPORT-ONLY: what a rubric-step stage's cited checks read (bareguard `full.evidence`), recorded as `rubric-evidence` for the Result
+      // tab's highlights. No verdict, gap, governor or money path reads it. Masked HERE with the run's one `scrub`: the `text` is a quote from
+      // the frozen page record, and the spine is append-only. Masking moves offsets, so an entry whose text changed keeps NO spans.
+      onRubricEvidence: (/** @type {any} */ e) => emit('rubric-evidence', {
+        step: e.step,
+        ...(judgingIteration !== null ? { iteration: judgingIteration } : {}),
+        evidence: e.evidence.map((/** @type {any} */ x) => {
+          if (typeof x?.text !== 'string') return x;
+          const text = scrub(x.text);
+          const spans = text === x.text && Array.isArray(x.spans) ? x.spans.map((/** @type {any} */ sp) => (typeof sp?.canon === 'string' ? { ...sp, canon: scrub(sp.canon) } : sp)) : [];
+          return { ...x, text, spans };
+        }),
+        ...(e.evidenceTotal !== undefined ? { evidenceTotal: e.evidenceTotal } : {}),
+      }),
       onJudgeCost: (/** @type {any} */ c) => emit('judge-round', {
         stage: c.stage, path: c.path, attempt: c.attempt, label: c.label, model: c.model,
         costUsd: c.costUsd, unpricedRounds: c.unpricedRounds,
@@ -2232,7 +2253,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
    * denied, the wallet as its budget), granted tools only (the menu IS the
    * grant), per-attempt round bound via loop.stop() (F20), every round metered
    * with a phase label (F12).
-   * @param {{granted: string[], phase: string, attemptRounds: number, attempts: number|null, writable: boolean, root?: ReturnType<typeof createRoot>|null, fence?: string[]|null, workerProvider?: any}} o
+   * @param {{granted: string[], phase: string, attemptRounds: number, attempts: number|null, writable: boolean, root?: ReturnType<typeof createRoot>|null, fence?: string[]|null, workerProvider?: any, truncatedBounded?: boolean}} o
    *   `root` (Layer R): when present, the worker's write-class actions are teed
    *   for the within-run ratchet — staged before the gate decides, discarded on
    *   deny/halt, settled to landed-or-not after execution (the two axes, F43/F7).
@@ -2242,7 +2263,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
    *   STRIKE LADDER (src/ladder.js), where that count does not exist by design — see
    *   the turn-allowance note below.
    */
-  async function mkWorker({ granted, phase, attemptRounds, attempts, writable, root = null, fence = null, workerProvider = null }) {
+  async function mkWorker({ granted, phase, attemptRounds, attempts, writable, root = null, fence = null, workerProvider = null, truncatedBounded = false }) {
     // THE HARD RULE, ENFORCED STRUCTURALLY (PRD v1.57 §3). This is the ONE seam
     // that grants write-class verbs — `writeScope` is empty for every other
     // worker, so a read-only phase cannot reach a file whatever it intends — and
@@ -2769,6 +2790,27 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       self = new Loop({ provider: loopProvider, system, policy, onLlmResult: metered, onToolResult: onToolOutcome, ...(rates ? { rates } : {}) });
       return self;
     };
+    /**
+     * PRD v1.106 Part 1 — what THIS call sends for thinking. The decision is src/thinking.js `workerThinkingMode` (the one owner: phase,
+     * attempt, the job's tick); the per-call option is `thinkingCallOptions` (support-aware: a model bare-agent says cannot switch, a test
+     * double or a clipipe is sent nothing). The decision is written to the spine BEFORE the call. A step/fix iteration that is not a whole
+     * number throws here as a plain operator error, outside any category map. A transport/rate-limit retry inside the call reuses these
+     * very options (the Proxy retries `generate` with the same args), so it carries the same decision.
+     * @returns {{thinkingMode: 'on'|'off'} | {}}
+     */
+    const thinkingForCall = () => {
+      const mode = workerThinkingMode({ phase, iteration: roundIteration, tick: job.thinking === true });
+      emit('thinking-decision', { phase, iteration: roundIteration ?? null, mode });
+      thinkingSent = mode;
+      return thinkingCallOptions(workerProvider ?? provider, mode);
+    };
+    /** bare-agent's own per-call verdict (applied | unsupported | ignored | unknown), recorded as drafting rounds record it; absent when no switch was sent
+     * @param {any} r a Loop.run() result */
+    const noteThinkingStatus = (r) => {
+      if (typeof r?.thinkingStatus === 'string') emit('thinking-status', { phase, iteration: roundIteration ?? null, mode: thinkingSent, thinkingStatus: r.thinkingStatus });
+    };
+    /** @type {'on'|'off'|null} */
+    let thinkingSent = null;
     /** @param {string} prompt @param {typeof toolDefs} [defs] */
     /**
      * F59 — continue an EXISTING conversation for exactly one TOOLLESS round.
@@ -2780,6 +2822,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
      * @param {string} prompt
      */
     const askFrom = async (msgs, prompt) => {
+      const thinkOpts = thinkingForCall();
       try {
         // `msgs` is a prior `loop.run()`'s returned transcript, which already has
         // the Loop's `system` PREPENDED (bare-agent Loop.run, loop.js ~482-486).
@@ -2791,8 +2834,9 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
         // bare-agent's own Loop.chat() (loop.js ~1321) strips a leading system
         // message before re-running for exactly this reason; do the same here.
         const rest = msgs[0]?.role === 'system' ? msgs.slice(1) : msgs;
-        const r = await stallWatch.watch((gen) => newLoop(gen).run([...rest, { role: 'user', content: prompt }], [], { cacheMessages: true, maxTokens: 32000, ...callBounds() }));
+        const r = await stallWatch.watch((gen) => newLoop(gen).run([...rest, { role: 'user', content: prompt }], [], { cacheMessages: true, maxTokens: 32000, ...callBounds(), ...thinkOpts }));
         throwIfStopped();
+        noteThinkingStatus(r);
         return r;
       } catch (e) {
         throw categorize(e).err;
@@ -2800,9 +2844,11 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     };
     const ask = async (prompt, defs = toolDefs) => {
       let r;
+      const thinkOpts = thinkingForCall();
       try {
-        r = await stallWatch.watch((gen) => newLoop(gen).run([{ role: 'user', content: prompt }], defs, { cacheMessages: true, maxTokens: 32000, ...callBounds() }));
+        r = await stallWatch.watch((gen) => newLoop(gen).run([{ role: 'user', content: prompt }], defs, { cacheMessages: true, maxTokens: 32000, ...callBounds(), ...thinkOpts }));
         throwIfStopped();
+        noteThinkingStatus(r);
       } catch (e) {
         throw categorize(e).err;
       }
@@ -2825,8 +2871,10 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // cut round's output is discarded (bare-agent already dropped it), its spend is booked
       // by the per-round meter, the tree is judged as it stands, and the step's strike
       // ladder (or the fix governor) applies unchanged (hamr ruling A extended it to `fix`
-      // after run muux1x96). Scout, drafter, replan keep the transport route below.
-      if (r.error && r.error.startsWith('truncated:') && (phase.startsWith('step:') || phase === 'fix')) {
+      // after run muux1x96). hamr 2026-10-16 (run mv9gm796) extended it to the REPLAN call: the
+      // replan drafter opts in with `truncatedBounded`. Scout and the first draft keep the
+      // transport route below (provider-red).
+      if (r.error && r.error.startsWith('truncated:') && (phase.startsWith('step:') || phase === 'fix' || truncatedBounded)) {
         attemptBounded = { iteration: roundIteration, cause: 'truncated', reason: TRUNCATED_REASON };
         emit('attempt-bounded', { phase, iteration: roundIteration, rounds: roundsThisAttempt, cap: attemptRounds, reason: TRUNCATED_REASON, stopReason: r.stopReason ?? null });
         return r;
@@ -3008,9 +3056,13 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
    * the hard line) — a drafter built once at full budget would let the replan
    * draft spend against money the steps had already consumed.
    * @param {string} phase @param {string|null} failure
-   * @param {string} [progress] the meter's read, replan only (A's adaptation channel) */
+   * @param {string} [progress] the meter's read, replan only (A's adaptation channel)
+   * @returns {Promise<{ok: boolean, reds: any[], plan?: any, truncated?: boolean}>} */
   const obtainPlan = async (phase, failure, progress) => {
-    const drafter = await mkWorker({ granted: [], phase: 'plan', attemptRounds: 2, attempts: 3, writable: false });
+    const drafter = await mkWorker({ granted: [], phase: 'plan', attemptRounds: 2, attempts: 3, writable: false, truncatedBounded: phase === 'replan' });
+    /** the LAST draftPlan call was a replan answer cut off at max_tokens: a bounded failed attempt,
+     * never provider-red (hamr 2026-10-16); reset at the start of every call */
+    let replanCut = false;
     // The BALANCE, read live at each draft — never a snapshot and never a rate
     // (addendum 2). At draft it is the whole budget (scale); at replan it is what
     // is actually left, which is the adaptation channel.
@@ -3039,7 +3091,12 @@ 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), []);
+      if (phase === 'replan' && typeof r.error === 'string' && r.error.startsWith('truncated:')) {
+        replanCut = true;
+        return '';
+      }
       return extractArtifact(r.text).code ?? '';
     };
     // Scrubbed HERE, once, before any consumer reads them — the judge() precedent
@@ -3056,10 +3113,17 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       return { ...v, reds: v.reds.map((r) => (typeof r.detail === 'string' ? { ...r, detail: scrub(r.detail) } : r)) };
     };
     let text = await draftPlan(null);
-    let pv = validate(text);
+    // A cut-off replan answer is treated like a BAD one: its half text is never validated (judging
+    // half an artifact would mint a plan-red the drafter never earned), it becomes one plain-words
+    // red fed to the redraft, and a cut REDRAFT (whatever the first answer was) is the bounded
+    // failed attempt the caller escalates in words.
+    let pv = replanCut
+      ? { ok: false, reds: [{ code: 'parse-error', path: '$', detail: REPLAN_CUT_RED }], plan: null }
+      : validate(text);
     emit('plan-validate', { ok: pv.ok, reds: pv.reds, phase: `${phase}-1` });
     if (!pv.ok) {
       text = await draftPlan(pv.reds);
+      if (replanCut) return { ok: false, reds: [], truncated: true };
       pv = validate(text);
       emit('plan-validate', { ok: pv.ok, reds: pv.reds, phase: `${phase}-2` });
     }
@@ -3377,7 +3441,11 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     };
     let lastGap = '';
     const judge = async () => {
-      const { pass, results: raw } = await evalExits(step.exit, { dir: workdir, snapshot, runCheck });
+      judgingIteration = iterationNow;
+      /** @type {any} */
+      let evaled;
+      try { evaled = await evalExits(step.exit, { dir: workdir, snapshot, runCheck }); } finally { judgingIteration = null; }
+      const { pass, results: raw } = evaled;
       // Scrubbed HERE, once, before the results are read by anyone. An exit detail is
       // supposed to be names and counts, but `json-valid` embeds `JSON.parse`'s own
       // message and V8 quotes a window of the SOURCE inside it (a body of 20 chars or
@@ -3392,6 +3460,9 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // results makes the leak inexpressible; scrubbing each consumer makes it
       // something the next consumer has to remember.
       const results = raw.map((r) => (typeof r.detail === 'string' ? { ...r, detail: scrub(r.detail) } : r));
+      // PRD v1.106 Part 5: what the check just read (path, size, sha256 — never the content), recorded BEFORE the exit-eval because the next try
+      // overwrites the file. The worker is idle between its turn and this judge, so these are the bytes the check read.
+      for (const o of await outputJudgedRecords(job.closeDecl, workdir, step.exit)) emit('output-judged', { step: step.id, iteration: iterationNow, ...o });
       emit('exit-eval', { step: step.id, iteration: iterationNow, results });
       // an instrument fault rides out by its runClose verdict NAME: ralph
       // escalates it through CLOSE_FAULTS (or F32-routes a crash after writes)
@@ -3659,6 +3730,16 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
         planExecuted();
         return relay(e, 'replan');
       }
+      if (pv.truncated) {
+        // a bounded failed attempt in plain words, filed as plan-red (a judged no, not a casualty)
+        // with the code-owned sentence on the escalation; the panel reads `cause` to say it
+        emit('escalation', {
+          category: 'plan-red', cause: 'truncated', decisionReady: true, phase: 'replan',
+          decision: REPLAN_CUT_WORDS, options: ['change the job and run it again', 'abandon the run'], detail: TRUNCATED_REASON,
+        });
+        planExecuted();
+        return 'plan-red';
+      }
       if (!pv.ok) {
         for (const r of pv.reds) emit('plan-red', r);
         planExecuted();

package/src/promptregisters.js

@@ -61,6 +61,10 @@ export const PROMPT_REGISTERS = Object.freeze([
   Object.freeze({ file: 'src/cardauthor.js', name: 'COMPILE_SYSTEM' }),
   Object.freeze({ file: 'src/cardauthor.js', name: 'cardCasesPrompt() (inline template, not a const)' }),
 
+  // src/pagemap.js - the page-word map call (idea A core): the AI names the page's own words for the person's job
+  Object.freeze({ file: 'src/pagemap.js', name: 'MAP_SYSTEM' }),
+  Object.freeze({ file: 'src/pagemap.js', name: 'mapPrompt() (inline template, not a const)' }),
+
   // src/readshim.js — the capped/deduplicating read shim's worker-facing strategy
   Object.freeze({ file: 'src/readshim.js', name: 'READ_SHIM_STRATEGY' }),
   Object.freeze({ file: 'src/readshim.js', name: 'READ_SHIM_DIFF_STRATEGY' }),

package/src/providerrows.js

@@ -9,7 +9,7 @@
 //
 // This module is also THE one owner of "model -> key + shape + URL": Chat's Model menu,
 // the author doors and the run doors all resolve through `findRow` / `keyNameFor` /
-// `applyConfiguredKey` / `modelChoiceFor` below — no second lookup exists. Key VALUES
+// `keyValueOf` / `modelChoiceFor` below — no second lookup exists. Key VALUES
 // never pass through here — only names.
 import { readConfig } from './config.js';
 import { filledKeyNames } from './keysfile.js';
@@ -388,8 +388,8 @@ export function judgeRowFor(rows, judge, workerProvider, workerRow) {
  * the worker's own provider it calls the worker's endpoint, so a row on that endpoint with a line
  * NAMED for the judge's model prices it ({@link ratesFor}); a judge model that is absent or names
  * no line there keeps the worker's price (the worker's row, or none = the guess). A different
- * provider resolves with no endpoint. The judge's KEY is chosen elsewhere (`applyConfiguredKey`,
- * by the worker's model), so the two can come from different rows.
+ * provider resolves with no endpoint. The judge's KEY is chosen elsewhere (`judgeRowFor`:
+ * the worker's own row when the judge shares its provider), so the two can come from different rows.
  * @param {{ provider: string, model?: string|null }} judge
  * @param {string|null|undefined} workerProvider
  * @param {string|null|undefined} workerBaseUrl

package/src/replay.js

@@ -35,6 +35,8 @@
 //     `plan` / `fix` for the other worker phases — src/planrun.js:2735,2515,3359.
 //     `costUsd` is `arg?.costUsd ?? null` — a null is an HONEST unpriced round
 //     (F6), never summed as $0 by this module.
+//   rubric-evidence {step, iteration?, evidence, evidenceTotal?}  REPORT-ONLY: what a rubric step's cited checks read (bareguard
+//                  `full.evidence`); read by the Result tab only, by no verdict, governor or money path. src/planrun.js onRubricEvidence
 //   exit-eval      {step, iteration, results: [{type, pass, detail?}]}
 //                                                                  src/planrun.js:2897
 //     each `results[i].type` is one of plan.js's EXIT_TYPES; `check-passes`
@@ -105,6 +107,7 @@ import { runBehaviour, formatBehaviour } from './behaviour.js';
 import { shortSha } from './codeversion.js';
 import { SPEND_RECORD_TYPES, chainSpend } from './ledger.js';
 import { legsOf, capKindOf } from './legs.js';
+import { thinkingWordsFrom } from './thinking.js';
 
 /**
  * @param {unknown} e
@@ -586,6 +589,12 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
   // re-spelled so the two can never drift apart.
   const spendRecords = spine.filter((e) => SPEND_RECORD_TYPES.includes(e.type));
   const exitEvals = spine.filter((e) => e.type === 'exit-eval');
+  // PRD v1.106 Part 5 (D1): which check each `check-passes` result was — the `check-run` record just before its exit-eval
+  const checkRuns = spine.filter((e) => e.type === 'check-run');
+  // the file each try's check read (new runs only; an old spine has none, and then no judged-file line is shown)
+  const outputJudgedRecs = spine.filter((e) => e.type === 'output-judged');
+  // D2: the iterations that began (a try with an iteration-start and no exit-eval was cut off before its checks ran)
+  const iterationStarts = spine.filter((e) => e.type === 'iteration-start');
 
   // F119: every `transport-retry` record on this spine, and the (derived,
   // never guessed) reason(s) behind a `spendComplete:false` job-end — see
@@ -800,7 +809,7 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
     // `/api/runs/:runid/rounds` endpoint (`src/panel/server.js`) to slice
     // this attempt's own rounds/tool-calls out of the full spine+gate-audit,
     // never recomputed a second way there either.
-    /** @type {Array<{n: number, iteration: number|null, outcome: 'green'|'red', startSeq: number, endSeq: number, startTs: number|null, endTs: number|null, exitEvalDetail: string|null}>} */
+    /** @type {Array<{n: number, iteration: number|null, outcome: 'green'|'red', startSeq: number, endSeq: number, startTs: number|null, endTs: number|null, exitEvalDetail: string|null, checks: Array<{type: string, pass: boolean, detail: string|null, name: string|null}>, outputJudged: Array<{path: string|null, bytes: number|null, sha256: string|null}>}>} */
     const attemptWindows = [];
     const stepExitEvals = exitEvals
       .filter((ee) => ee.step === id && typeof ee.seq === 'number' && ee.seq > startSeq && ee.seq < endSeq)
@@ -827,6 +836,27 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
         iteration: typeof ee.iteration === 'number' ? ee.iteration : null,
         outcome: allPass ? 'green' : 'red',
       });
+      // the try's checks AS THEY RAN (D1): each exit-eval result in order; a `check-passes` result is named by the `check-run`
+      // record just before this exit-eval (same window), taken in order. `detail` is already scrubbed at capture.
+      const lo = prevBoundSeq;
+      const namesHere = checkRuns
+        .filter((c) => typeof c.seq === 'number' && c.seq > lo && c.seq < eeSeq && typeof c.name === 'string')
+        .sort((a, b) => a.seq - b.seq);
+      let nameAt = 0;
+      const tryChecks = results.map((r) => {
+        const type = typeof r.type === 'string' ? r.type : 'unknown';
+        const name = type === 'check-passes' ? (namesHere[nameAt++]?.name ?? null) : null;
+        return {
+          type, pass: r.pass === true, detail: typeof r.detail === 'string' ? r.detail : null, name,
+        };
+      });
+      const judgedHere = outputJudgedRecs
+        .filter((o) => o.step === id && (typeof ee.iteration !== 'number' || o.iteration === ee.iteration) && typeof o.seq === 'number' && o.seq > lo && o.seq < eeSeq)
+        .map((o) => ({
+          path: typeof o.path === 'string' ? o.path : null,
+          bytes: typeof o.bytes === 'number' ? o.bytes : null,
+          sha256: typeof o.sha256 === 'string' ? o.sha256 : null,
+        }));
       attemptWindows.push({
         n: attemptWindows.length + 1,
         iteration: typeof ee.iteration === 'number' ? ee.iteration : null,
@@ -836,11 +866,30 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
         startTs: prevBoundTs,
         endTs: eeTs,
         exitEvalDetail: detailSource && typeof detailSource.detail === 'string' ? detailSource.detail : null,
+        checks: tryChecks,
+        outputJudged: judgedHere,
       });
       prevBoundSeq = eeSeq;
       prevBoundTs = eeTs ?? prevBoundTs;
     }
 
+    // D2: a try that BEGAN (an `iteration-start` after the last exit-eval) in a step that has ended, and never reached its checks, was cut off
+    // (the wall, a cap, a stop). A step still running has an in-flight try, not a cut-off one. Never a numbered attempt: it ran no check.
+    const endedHere = end !== null || stopReason !== null;
+    const lastIter = iterationStarts
+      .filter((it) => typeof it.seq === 'number' && it.seq > prevBoundSeq && it.seq < endSeq)
+      .sort((a, b) => b.seq - a.seq)[0] ?? null;
+    const cutOffTry = endedHere && lastIter
+      ? {
+        n: attemptWindows.length + 1,
+        iteration: typeof lastIter.iteration === 'number' ? lastIter.iteration : null,
+        startSeq: prevBoundSeq,
+        endSeq: end && typeof end.seq === 'number' ? end.seq : (Number.isFinite(endSeq) ? endSeq : prevBoundSeq),
+        startTs: prevBoundTs,
+        endTs,
+      }
+      : null;
+
     idOccurrence.set(id, (idOccurrence.get(id) ?? 0) + 1);
     // the SAME step continuing across a leg boundary (the previous occurrence of this id was cut off by its leg's
     // halt, and this one starts in a later leg) is "continued", never a retry; `tryNumber` counts real retries only
@@ -859,6 +908,7 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
       treeChanged,
       attempts,
       attemptWindows,
+      cutOffTry,
       stepStartSeq: startSeq,
       stepEndSeq: endSeq,
       // `stepStartTs`/`stepEndTs` (panel item 2 follow-up, F195/F-audit-step):
@@ -877,7 +927,6 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
   // `phase` filter on the rounds: the seq window between one iteration-start
   // and the next close-verdict/run-end/escalation already isolates that
   // iteration's own rounds.
-  const iterationStarts = spine.filter((e) => e.type === 'iteration-start');
   const timelineKind = /** @type {'steps'|'iterations'} */ (stepStarts.length > 0 ? 'steps' : (iterationStarts.length > 0 ? 'iterations' : 'steps'));
   const boundaries = spine.filter((e) => e.type === 'close-verdict' || e.type === 'run-end' || e.type === 'escalation');
 
@@ -1320,7 +1369,7 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
       // same as a scout/plan/replan/judge/run part already does.
       const stepAttempts = step.attemptWindows.length > 0
         ? step.attemptWindows.map((aw) => ({
-          n: aw.n, outcome: aw.outcome, verdict: null, stages: null, detail: aw.exitEvalDetail, startSeq: aw.startSeq, endSeq: aw.endSeq, startTs: aw.startTs, endTs: aw.endTs,
+          n: aw.n, outcome: aw.outcome, verdict: null, stages: null, detail: aw.exitEvalDetail, startSeq: aw.startSeq, endSeq: aw.endSeq, startTs: aw.startTs, endTs: aw.endTs, iteration: aw.iteration, checks: aw.checks, outputJudged: aw.outputJudged,
         }))
         : wholePartAttempt(step.stepStartSeq, step.stepStartTs, step.stepEndSeq, step.stepEndTs);
       parts.push({
@@ -1340,6 +1389,7 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
         // P5-R (resumed runs only): why its leg's halt cut this step off, whether it is the same step continuing
         // from the leg before, and its retry count not counting continuations
         ...(step.stopReason === undefined ? {} : { stopReason: step.stopReason, continued: step.continued, tryNumber: step.tryNumber }),
+        ...(step.cutOffTry ? { cutOffTry: step.cutOffTry } : {}),
         attempts: step.stopReason ? stepAttempts.map((a) => (a.outcome === null || a.outcome === undefined ? { ...a, outcome: 'stopped' } : a)) : stepAttempts,
       });
     }
@@ -1420,6 +1470,63 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
     }
   }
 
+  // PRD v1.106 Part 5 (C, choice 9): a run that reached its review door gets one more part, the only human step bareloop has. `door` carries what
+  // the spine recorded (when it opened, which files, what the person decided and when); the panel server words it (src/panel/status.js).
+  const doorRec = spine.findLast((e) => e.type === 'review-door');
+  if (doorRec) {
+    const decided = spine.findLast((e) => e.type === 'door-decision' && e.honoured === true && typeof e.seq === 'number' && typeof doorRec.seq === 'number' && e.seq > doorRec.seq);
+    const paths = Array.isArray(doorRec.changed?.paths) ? doorRec.changed.paths.filter((/** @type {any} */ x) => typeof x === 'string') : [];
+    parts.push({
+      id: 'door',
+      kind: 'door',
+      label: 'door',
+      number: null,
+      occurrence: null,
+      rounds: 0,
+      toolCalls: 0,
+      byTool: null,
+      blocked: 0,
+      wallMs: null,
+      spentUsd: 0,
+      unpricedRounds: 0,
+      outcome: null,
+      attempts: [],
+      door: {
+        at: typeof doorRec.ts === 'string' ? doorRec.ts : null,
+        paths,
+        decision: decided && typeof decided.decision === 'string' ? decided.decision : null,
+        text: decided && typeof decided.text === 'string' ? decided.text : null,
+        decidedAt: decided && typeof decided.ts === 'string' ? decided.ts : null,
+      },
+    });
+  }
+
+  // PRD v1.106 Part 3: the thinking each call was SENT, from the spine's own `thinking-decision` / `thinking-status` records, worded by
+  // src/thinking.js. A part with one attempt (plan, scout, replan, a single-attempt step) carries it as `part.thinking`; an attempt that made a
+  // worker call carries `attempt.thinking`. A spine with no such record gets no field at all (an older run shows no thinking word).
+  if (spine.some((e) => e.type === 'thinking-decision')) {
+    const firstStepSeq = stepStarts.reduce((m, ss) => (typeof ss.seq === 'number' && ss.seq < m ? ss.seq : m), Infinity);
+    for (const p of parts) {
+      const atts = Array.isArray(p.attempts) ? p.attempts : [];
+      for (const a of atts) {
+        let words = null;
+        if (p.kind === 'step') words = thinkingWordsFrom(spine, { phase: `step:${p.label}`, lo: a.startSeq, hi: a.endSeq });
+        else if (p.kind === 'fix') words = thinkingWordsFrom(spine, { phase: 'fix', lo: a.startSeq, hi: a.endSeq });
+        if (words !== null) a.thinking = words;
+      }
+      if (p.kind === 'step' && p.cutOffTry) {
+        const words = thinkingWordsFrom(spine, { phase: `step:${p.label}`, lo: p.cutOffTry.startSeq, hi: p.cutOffTry.endSeq });
+        if (words !== null) p.cutOffTry.thinking = words;
+      }
+      let part = null;
+      if (p.kind === 'scout') part = thinkingWordsFrom(spine, { phase: 'scout', hi: firstStepSeq });
+      else if (p.kind === 'plan') part = thinkingWordsFrom(spine, { phase: 'plan', hi: firstStepSeq });
+      else if (p.kind === 'replan' && atts[0]) part = thinkingWordsFrom(spine, { phase: 'plan', lo: atts[0].startSeq, hi: atts[0].endSeq });
+      else if ((p.kind === 'step' || p.kind === 'fix') && atts.length === 1) part = atts[0].thinking ?? null;
+      if (part !== null) p.thinking = part;
+    }
+  }
+
   // P5-R: which LEG each part belongs to, and where a resume picked up — only for a resumed run (a spine with
   // no marker keeps its parts byte-for-byte). A step part is dated by its own step-start; a replan by its
   // marker; every other part by the end of its last attempt (its own window's far edge), falling back to the
@@ -1587,16 +1694,20 @@ function money2(n) {
  * @param {boolean|null} [draftSpendComplete] whether the drafting fold above was EXACT;
  *   `null`/`undefined`/`true` all read as exact (never a new enum value elsewhere) —
  *   only an explicit `false` triggers the floor wording.
+ * @param {number|null} [runUsd] the run's own spend as a number (excluding drafting), so the sum can be written
  * @returns {string}
  */
-export function moneyWithDraft(spendCore, draftSpentUsd, budgetUsd, draftSpendComplete) {
+export function moneyWithDraft(spendCore, draftSpentUsd, budgetUsd, draftSpendComplete, runUsd) {
   const hasDraft = draftSpentUsd !== null && draftSpentUsd !== undefined;
   const draftFloor = hasDraft && draftSpendComplete === false;
   const coreAlreadyFloor = /^(at least |≥)/.test(spendCore);
   const core = draftFloor && !coreAlreadyFloor ? `at least ${spendCore}` : spendCore;
-  const draftPart = hasDraft ? ` (${draftFloor ? 'at least ' : ''}${money(draftSpentUsd)} drafting)` : '';
   const capPart = budgetUsd === undefined ? '' : ` of ${money2(budgetUsd)}`;
-  return `${core}${draftPart}${capPart}`;
+  if (!hasDraft) return `${core}${capPart}`;
+  // PRD v1.106 Part 5 Q4: the run's figure EXCLUDES drafting, so the line says so and adds the sum — "$0.0054 run + $0.0035 drafting =
+  // $0.0089 of $1.00". A floor on either part makes the total a floor too ("at least"). Without the run's number the sum is left out.
+  const total = typeof runUsd === 'number' && Number.isFinite(runUsd) ? ` = ${draftFloor || coreAlreadyFloor ? 'at least ' : ''}${money(runUsd + draftSpentUsd)}` : '';
+  return `${core} run + ${draftFloor ? 'at least ' : ''}${money(draftSpentUsd)} drafting${total}${capPart}`;
 }
 
 /**
@@ -2045,7 +2156,7 @@ export function summarizeForAllLine(summary) {
     // shown on a run with zero retries.
     outcome: `${summary.outcome ?? 'unknown'}${summary.transportRetryCount > 0 ? ` ⟲${summary.transportRetryCount}` : ''}`,
     hadTransportRetries: summary.transportRetryCount > 0,
-    spend: moneyWithDraft(money(summary.spentUsd), summary.draftSpentUsd, undefined, summary.draftSpendComplete),
+    spend: moneyWithDraft(money(summary.spentUsd), summary.draftSpentUsd, undefined, summary.draftSpendComplete, summary.spentUsd),
     wall: duration(summary.wallMs),
     steps: stepsCol,
     reason,

package/src/reviewdoor.js

@@ -50,6 +50,43 @@ export function doorRecordOf(events) {
   return events.findLast?.((e) => e?.type === REVIEW_DOOR) ?? null;
 }
 
+/**
+ * Was this run's door ACCEPTED, honoured? A `door-decision` record with `decision: 'accept'` and `honoured: true`
+ * (written by {@link answerReviewDoor}, whichever surface asked: the CLI, or the panel's Accept). Pure, off the
+ * run's spine. A refused accept (`honoured: false`) does not count.
+ * @param {any[]} events the run's spine, parsed
+ * @returns {boolean}
+ */
+export function doorAccepted(events) {
+  return Array.isArray(events) && events.some((e) => e?.type === 'door-decision' && e.decision === 'accept' && e.honoured === true);
+}
+
+/**
+ * T D.2 — a SCHEDULED run's green is held until the person accepts it (T10): a run that carries a `trigger.json` (a scheduled
+ * start wrote it) and holds no honoured accept. One shared predicate: `getStartFrom` reads its outcome as `'green-held'` (so
+ * the Reuse start refuses it unchanged), `listReuseJobs` skips it, and the schedule gate does not count it. A hand run is never held.
+ * @param {any[]} events the run's spine, parsed @param {any} triggerRec the run's `trigger.json`, or null
+ * @returns {boolean}
+ */
+export function heldScheduled(events, triggerRec) {
+  return !!triggerRec && typeof triggerRec === 'object' && !doorAccepted(events);
+}
+
+/**
+ * Is this run WAITING for the person's Accept? Its spine holds a door record, the door has not expired ({@link doorAgeGate}),
+ * and no honoured `accept` or `rerun` decision follows it (a `pause` keeps the same three doors open). One owner: the runs
+ * list's Needs-you `Accept` tag, the Run tab's Accept button and the scheduled NEXT line all read this.
+ * @param {any[]} events the run's spine, parsed
+ * @param {{now?: () => number}} [opts]
+ * @returns {boolean}
+ */
+export function doorWaiting(events, opts = {}) {
+  const door = doorRecordOf(events);
+  if (!door || !doorAgeGate(door, opts.now ? { now: opts.now } : {}).ok) return false;
+  const at = events.lastIndexOf(door);
+  return !events.slice(at + 1).some((e) => e?.type === 'door-decision' && e.honoured === true && (e.decision === 'accept' || e.decision === 'rerun'));
+}
+
 /**
  * IS THE DOOR STILL OPEN? The same 60-day TTL a hitl checkpoint keeps
  * (`PAUSE_TTL_MS`) and deliberately the same NUMBER — the door replaced `cancel`