bareloop 0.42.0 → 0.44.0

package/src/panel/server.js

@@ -25,13 +25,19 @@
 // for every cap/threshold: a shell never widens what it was asked to do).
 
 import { createServer } from 'node:http';
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import {
+  readFileSync, existsSync, readdirSync, lstatSync, realpathSync,
+} from 'node:fs';
+import { createHash } from 'node:crypto';
 import {
   dirname, join, basename, relative, isAbsolute, sep,
 } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { readRunList, DIED_MTIME_MS, runIsAlive } from '../runlist.js';
-import { draftingPartFor } from '../draftspend.js';
+import { readRunList, readNeedsRemovals, DIED_MTIME_MS, runIsAlive } from '../runlist.js';
+import { webFetchState } from '../source.js';
+import { isWebUrl } from '../pagefetch.js';
+import { draftingPartFor, sessionDirForRow, readDraftSteps } from '../draftspend.js';
+import { readingOfQuestion, isAgree } from '../pagemap.js';
 import {
   replayOne, parseJsonl, resolveSiblings, isSidecarByName,
 } from '../replayio.js';
@@ -42,19 +48,30 @@ import { runBehaviour } from '../behaviour.js';
 import { SPEND_RECORD_TYPES, floorsFromRecords } from '../ledger.js';
 import { jobSpecHash, workflowKey } from '../job.js';
 import { confirmProtections } from '../authorflow.js';
+import { createScheduleDoor } from './schedules.js';
+import { createStarter } from './schedulestart.js';
+import { createScheduler } from './scheduler.js';
+import {
+  catchUpWords, dateTimeWords, jobScheduleWords, lowerFirst, scheduleSignFor, scheduledWords, sectionThisRunWords, skippedWords, startedAuditWords, startedWords, triesTailWords, SCHEDULE_WORDS,
+} from '../schedulewords.js';
+import { doorWaiting, heldScheduled } from '../reviewdoor.js';
 import { createAuthorRoutes, mintToken, checkHostGuard, panelMoney2 } from './authorroutes.js';
 import { createRunRoutes } from './runroutes.js';
 import { createImportRoutes, readImports, bundleStatus, IMPORT_CHANGED_LINE } from './importroutes.js';
 import { parseImportedRunId, safeSpinePath, spineStartedAt } from './importrun.js';
 import { checkBundleDeps, resolveBundleSpec } from '../bundle.js';
 import { checkCloseByteSignature } from '../close-integrity.js';
-import { keysHome } from '../keysfile.js';
+import { keysHome, keysForDoor } from '../keysfile.js';
 import { rowsForHome, findRow, modelChoiceFor, tickedLines, endpointOf } from '../providerrows.js';
 import { SHAPES } from '../providershapes.js';
 import { resolveProvider } from '../providers.js';
-import { REUSE_LOCKED_FIELDS, REUSE_OPEN_FIELDS } from './authorsession.js';
 import { readResume, checkpointAgeGate, CHECKPOINT_OUTCOMES } from '../reuse.js';
-import { statusFor, partStatusFor, GOAL_MET_LINE } from './status.js';
+import {
+  statusFor, partStatusFor, GOAL_MET_LINE, doorViewOf, ACTOR_MARKER, DOOR_WORDS,
+} from './status.js';
+import { thinkingJobText } from '../thinking.js';
+import { judgedFilesOf, lineRules, stepFileRel, proseNotCheckedItems } from '../rubricstep.js';
+import { factPartOf, factSentence, ruleWords, moneyAs } from '../facts.js';
 import { createSettingsRoutes } from './settingsroutes.js';
 import { planFromSpec } from './jobplan.js';
 
@@ -193,6 +210,8 @@ function describeLastRecord(r) {
     'scout-start': () => 'starting the scout',
     'scout-result': () => 'the scout finishing',
     'check-run': () => 'a check run',
+    'output-judged': () => 'recording the file a check read',
+    'rubric-evidence': () => 'recording the words a check read',
     'check-preflight': () => 'a preflight check',
     'check-menu': () => 'building the check menu',
     'step-start': (rec) => `starting step ${rec.step ?? '?'}`,
@@ -420,7 +439,7 @@ const GOAL_NOT_MET = new Set(['plan-red', 'check-red', 'step-red', 'escalated'])
  *
  * The table (outcome → reason / next / buttons) is PANEL-BUILD.md P5 item 1. The
  * Resume button appears only when `o.resume` says the engine would accept it; "Reuse workflow"
- * (replaces P5 item 3, 2026-10-03) is offered on green rows only, and starts a NEW run.
+ * (replaces P5 item 3, 2026-10-03; one door on every ending since 2026-10-15) starts a NEW run.
  * @param {{outcome: string|null, stopReason: string|null, spentUsd: number|null, budgetUsd: number|null, lastEscalation?: any}} summary
  * @param {{died: boolean, lastThing: string|null}} death
  * @param {{resume?: {ok: boolean, why?: string}|null, destinationRefused?: string|null, moneyHalt?: boolean,
@@ -429,7 +448,7 @@ const GOAL_NOT_MET = new Set(['plan-red', 'check-red', 'step-red', 'escalated'])
  * @returns {{reason: string, next: string, line: string, actions: {id: string, label: string}[]}|null}
  */
 export function endedFor(summary, death, o = {}) {
-  const base = withEditAction(endedBase(summary, death, o));
+  const base = withReuseAction(endedBase(summary, death, o));
   const wt = o.worktree;
   if (!base || !wt) return base;
   // P6 item 1 — the run worked on a worktree in the person's own repo. GREEN: the branch carries the work (the folder is
@@ -445,13 +464,13 @@ export function endedFor(summary, death, o = {}) {
 }
 
 /**
- * "Edit in chat" (hamr 2026-10-07): offered on EVERY non-green ending (failed, capped, stopped, died, every other red),
- * after Resume when both show; a green ending keeps Reuse workflow only. ONE place, so no ending branch can forget it.
+ * ONE door (hamr 2026-10-15, v1.101): "Reuse workflow" is offered on EVERY ending (green, failed, capped, stopped, died, every other
+ * red), after Resume when both show. ONE place, so no ending branch can forget it.
  * @param {{reason: string, next: string, line: string, actions: {id: string, label: string}[]}|null} ended
  */
-function withEditAction(ended) {
+function withReuseAction(ended) {
   if (!ended || ended.actions.some((a) => a.id === 'reuse')) return ended;
-  return { ...ended, actions: [...ended.actions, { id: 'edit', label: 'Edit in chat' }] };
+  return { ...ended, actions: [...ended.actions, { id: 'reuse', label: 'Reuse workflow' }] };
 }
 
 /** @param {any} summary @param {any} death @param {any} o */
@@ -460,9 +479,9 @@ function endedBase(summary, death, o) {
   /** @type {{id: string, label: string}[]} */
   const RESUME = [{ id: 'resume', label: 'Resume' }];
   /** Reuse workflow (replaces P5 item 3's Start from this, hamr 2026-10-03): the same signed job on a new source — a NEW
-   *  run, never a rerun. Offered on GREEN rows only; every red row says "Change the job: press Edit in chat" instead. */
+   *  run, never a rerun. Offered on GREEN rows only; every red row says "Change the job: press Reuse workflow" instead. */
   const REUSE = [{ id: 'reuse', label: 'Reuse workflow' }];
-  const CHANGE = 'Change the job: press Edit in chat.';
+  const CHANGE = 'Change the job: press Reuse workflow.';
   const detailOf = (/** @type {string|null} */ s) => {
     if (typeof s !== 'string' || s.length === 0) return '';
     return s.length > 120 ? `${s.slice(0, 120)}…` : s;
@@ -519,8 +538,8 @@ function endedBase(summary, death, o) {
 
   if (outcome === 'green' || outcome === 'already-green' || outcome === 'satisfied') {
     if (o.destinationRefused) {
-      // Reuse workflow only on a run that earned its green (hamr 2026-10-08, as below); the rest take Edit in chat
-      // (withEditAction adds it) and are told to change the job, not to reuse it
+      // Reuse workflow only on a run that earned its green (hamr 2026-10-08, as below); every ending offers Reuse workflow
+      // (withReuseAction adds it) and is told to change the job
       const earned = outcome === 'green';
       return {
         reason: 'Goal met, but the output could not be delivered.',
@@ -530,7 +549,7 @@ function endedBase(summary, death, o) {
       };
     }
     // hamr 2026-10-08: already-green (the check passed before any work) is not a reusable job — only a run that
-    // earned its green offers Reuse workflow; the rest take Edit in chat (withEditAction adds it). `satisfied` is a
+    // earned its green offers Reuse workflow; every ending offers Reuse workflow (withReuseAction adds it). `satisfied` is a
     // close VERDICT, never a run outcome (ralph and the job-end emitters write `green`), so it rides with already-green.
     if (outcome !== 'green') return { reason: 'Goal met.', next: CHANGE, line: GOAL_MET_LINE, actions: [] };
     return { reason: 'Goal met.', next: 'Nothing to do.', line: GOAL_MET_LINE, actions: REUSE };
@@ -574,11 +593,21 @@ function endedBase(summary, death, o) {
   if (outcome === 'step-stalled') {
     return {
       reason: 'A step stopped making progress.',
-      next: resumeOr('Resume, or change the job: press Edit in chat.'),
+      next: resumeOr('Resume, or change the job: press Reuse workflow.'),
       line: resumeOk ? 'step stalled — resume' : 'step stalled',
       actions: resumeOk ? RESUME : [],
     };
   }
+  // hamr 2026-10-16: a replan answer cut off at its length limit is a bounded failed attempt in plain words, not the
+  // provider's fault and not "the checks said no" (the engine files it as a plan-red escalation with cause 'truncated')
+  if (outcome === 'plan-red' && esc?.cause === 'truncated' && esc?.phase === 'replan') {
+    return {
+      reason: 'The replan answer was cut off at its length limit, so no new plan came back.',
+      next: CHANGE,
+      line: 'replan cut off',
+      actions: [],
+    };
+  }
   if (GOAL_NOT_MET.has(outcome)) {
     const d = detailOf(summary.stopReason);
     return {
@@ -624,6 +653,29 @@ function lastJobEndTs(/** @type {any[]} */ records) {
   return null;
 }
 
+/** the timestamp of the spine's LAST record that carries one, or null (a died run has no job-end: this is when it went quiet) */
+function lastRecordTs(/** @type {any[]} */ records) {
+  for (let i = records.length - 1; i >= 0; i -= 1) {
+    const r = records[i];
+    if (r && typeof r === 'object' && typeof r.ts === 'string') return r.ts;
+  }
+  return null;
+}
+
+/**
+ * A live run's plain "why" for the runs list: `step N of M` (the step it is on, of the plan's steps), or null while no plan is accepted yet
+ * (the card then says only `running`). Same words the Run tab's header uses.
+ * @param {any[]} records @param {any} summary
+ * @returns {string|null}
+ */
+function liveStepWhy(records, summary) {
+  const plan = records.findLast((r) => r && r.type === 'plan-accepted');
+  const total = Array.isArray(plan?.plan?.steps) ? plan.plan.steps.length : 0;
+  if (total === 0) return null;
+  const done = new Set((summary.steps ?? []).filter((/** @type {any} */ u) => u && u.outcome !== null && u.outcome !== undefined && !u.stopReason).map((/** @type {any} */ u) => u.id)).size;
+  return `step ${Math.min(done + 1, total)} of ${total}`;
+}
+
 function endedForRow(row, records, summary, death, withWorktree = false) {
   const out = summary.outcome;
   const maybeResumable = death.died || out === 'escalated' || (typeof out === 'string' && CHECKPOINT_OUTCOMES.includes(out));
@@ -648,17 +700,29 @@ function endedForRow(row, records, summary, death, withWorktree = false) {
  * exist YET: the runner appends the row first, then opens the spine. It is `starting`,
  * never `file missing`. Carries the same field names a normal row/detail does so every
  * client reader (filters, groups) sees a live `▶` run, with every figure honestly null.
- * @param {{ runid: string, job: string, at: string, via: string }} row
+ * @param {{ runid: string, job: string, at: string, via: string, spine: string }} row
  * @returns {any}
  */
 function startingStub(row) {
+  // PRD v1.106 Part 5 Q2 (moved after the listing 2026-10-19, run mvez8s54): while the run's own refetch of a web input is still going
+  // (source.json has a web input and no refrozenAt at or after the row), the words are the server's: "fetching the page…"
+  const near = sourceNearSpine(row.spine);
+  const fetching = near.sourceJsonPath !== null && webFetchState(near.sourceJsonPath, row.at).fetching;
   return {
+    startingWord: fetching ? 'fetching the page…' : 'starting…',
+    startingNote: fetching ? 'the run has not started yet' : 'the run has not written its log yet',
     runid: row.runid,
     job: row.job,
     at: row.at,
     via: row.via,
     fileMissing: false,
     starting: true,
+    live: true,
+    liveWhy: null,
+    needs: null,
+    stoppedAt: null,
+    liveSince: typeof row.at === 'string' ? row.at : null,
+    priorWallMs: 0,
     died: false,
     glyph: '▶',
     status: statusFor({ outcome: null }),
@@ -684,19 +748,63 @@ function startingStub(row) {
   };
 }
 
+/**
+ * A run that REFUSED before it started (its refetch of a web input was refused, run mvez8s54 shape): listed, settled at $0, no spine.
+ * The status word is the table's `failed` (statusFor: "refusals, instrument stops -> failed"); the plain words ride on `endedLine`.
+ * @param {{ runid: string, job: string, at: string, via: string }} row @param {string} words
+ * @returns {any}
+ */
+function refusedStub(row, words) {
+  return {
+    runid: row.runid, job: row.job, at: row.at, via: row.via, fileMissing: false, refused: true, live: false, needs: null, stoppedAt: null,
+    died: false, glyph: statusFor({ outcome: 'refused-before-start' }).sign, status: statusFor({ outcome: 'refused-before-start' }),
+    outcome: 'refused-before-start', endedLine: words, ended: null, resume: null, checkType: 'unknown', checkTypeTitle: null, model: null,
+    spend: '$0', wall: '', date: typeof row.at === 'string' ? row.at.slice(0, 10) : null, spentUsd: 0, spendComplete: true,
+    spendFloorUsd: null, wallFloorMs: null, draftSpentUsd: null, draftSpendComplete: null, budgetUsd: null, steps: [], parts: [],
+  };
+}
+
+/** the plain words of a run that settled as "refused before start" (leg 1), or null @param {any[]} events @param {{runid: string}} row */
+function refusalWordsOf(events, row) {
+  const e = events.find((x) => x && x.type === 'settled' && x.runid === row.runid && x.reason === 'refused before start' && !(x.leg > 1));
+  return e && typeof e.words === 'string' && e.words !== '' ? e.words : null;
+}
+
+/**
+ * RULED 2026-10-15 (Remove from Needs you): the ONE place a run's Needs-you state is decided. `Accept` (a live door) is never removable and never ages out.
+ * A `Resume` tag leaves when the person removed it AFTER (or at) the stop it is for — a removal covers only the ending it was made on, so a later stop
+ * brings the run back — or after `needsYouDays`. `removedMs` is the newest removal that covers the current ending (or null), `expired` is true when only
+ * the age rule took a Resume run out.
+ * @param {{live: boolean, records: any[], resume: {ok?: boolean}|null|undefined, stoppedAt: string|null, nowMs: number, removedMs?: number}} f
+ * @returns {{needs: 'Accept'|'Resume'|null, removedMs: number|null, expired: boolean}}
+ */
+export function needsStateFor(f) {
+  if (!f.live && doorWaiting(f.records, { now: () => f.nowMs })) return { needs: 'Accept', removedMs: null, expired: false };
+  const stopMs = typeof f.stoppedAt === 'string' ? Date.parse(f.stoppedAt) : NaN;
+  const covers = typeof f.removedMs === 'number' && (!Number.isFinite(stopMs) || f.removedMs >= stopMs);
+  const tag = needsTag(f.resume, f.stoppedAt, f.nowMs);
+  const canResume = !f.live && !!f.resume && f.resume.ok === true;
+  if (covers && canResume) return { needs: null, removedMs: /** @type {number} */ (f.removedMs), expired: false };
+  return { needs: tag, removedMs: null, expired: canResume && tag === null };
+}
+
 /**
  * One `/api/runs` row, or `{ ...row, fileMissing: true }` when the row's
  * spine no longer exists on disk — never silently listed as if it were
  * still there (the same rule {@link import('../runlist.js').formatRunRow}
  * already applies to the CLI's own listing).
  * @param {import('../runlist.js').RunRow} row
+ * @param {number} [nowMs] @param {Map<string, number>} [removals] `readNeedsRemovals`: when each run was taken out of Needs you
+ * @param {any[]} [events] the run list's settled/released events (a run that refused before it started has no spine; its words are here)
  * @returns {any}
  */
-function summarizeRow(row) {
+function summarizeRow(row, nowMs = Date.now(), removals = undefined, events = []) {
   if (!existsSync(row.spine)) {
+    const refusal = refusalWordsOf(events, row);
+    if (refusal !== null) return refusedStub(row, refusal);
     if (runIsAlive(row)) return startingStub(row);
     return {
-      runid: row.runid, job: row.job, at: row.at, via: row.via, fileMissing: true,
+      runid: row.runid, job: row.job, at: row.at, via: row.via, fileMissing: true, live: false, needs: null, stoppedAt: null,
     };
   }
   let summary;
@@ -707,17 +815,33 @@ function summarizeRow(row) {
   } catch (e) {
     return {
       runid: row.runid, job: row.job, at: row.at, via: row.via, fileMissing: false, readError: String(/** @type {Error} */ (e).message),
+      live: false, needs: null, stoppedAt: null,
     };
   }
   const line = summarizeForAllLine(summary);
   const death = deriveDeath(row, rawRecords, summary.outcome);
-  const { ended, status } = endedForRow(row, rawRecords, summary, death);
+  const { ended, status, resume } = endedForRow(row, rawRecords, summary, death);
+  // P9 v2: the server decides every state the runs list draws (the page works out nothing).
+  const live = !death.died && (summary.outcome === null || summary.outcome === undefined) && runIsAlive(row);
+  const stoppedAt = live ? null : (lastJobEndTs(rawRecords) ?? (death.died ? lastRecordTs(rawRecords) : null));
+  const legs = legsOf(rawRecords);
+  const priorWall = legs.length <= 1 ? { ms: 0, complete: true } : legsWallMs(legs.slice(0, -1));
+  const liveStart = live ? legs.at(-1)?.startMs ?? null : null;
   return {
     runid: row.runid,
     job: row.job,
     at: row.at,
     via: row.via,
     fileMissing: false,
+    live,
+    liveWhy: live ? liveStepWhy(rawRecords, summary) : null,
+    // a run waiting at its review door needs the person's Accept (never ages out, T10); else the Resume rule
+    needs: needsStateFor({ live, records: rawRecords, resume, stoppedAt, nowMs, removedMs: removals ? removals.get(row.runid) : undefined }).needs,
+    stoppedAt,
+    // a live run's wall counts up from the start of its CURRENT leg; earlier legs add `priorWallMs` (the gap between legs is nobody's).
+    // `priorWallMs` is null when the earlier legs' wall is not exact: the card then shows this leg's wall only, and says so.
+    liveSince: liveStart === null ? (live && typeof row.at === 'string' ? row.at : null) : new Date(liveStart).toISOString(),
+    priorWallMs: live ? (priorWall.complete ? priorWall.ms : null) : null,
     died: death.died,
     endedLine: ended ? ended.line : null,
     // P5-R: one card per run — how many times it was resumed (a resumed run is the same run, never a second card)
@@ -784,6 +908,21 @@ export function getStopContext(runid, opts = {}) {
   return { row, live: runIsAlive(row), spineExists: existsSync(row.spine) };
 }
 
+/**
+ * The Remove-from-Needs-you route's reader (RULED 2026-10-15): the listed row and the Needs-you tag the runs list shows for it right now
+ * (`summarizeRow`, the one rule). `null` when the runid is not listed.
+ * @param {string} runid
+ * @param {{ home?: string, now?: number }} [opts]
+ * @returns {{row: any, needs: 'Accept'|'Resume'|null}|null}
+ */
+export function getNeedsContext(runid, opts = {}) {
+  const { rows } = readRunList(opts);
+  const row = rows.find((r) => r && r.runid === runid);
+  if (!row) return null;
+  const nowMs = typeof opts.now === 'number' ? opts.now : Date.now();
+  return { row, needs: summarizeRow(row, nowMs, readNeedsRemovals(opts)).needs ?? null };
+}
+
 /**
  * @param {any} r
  * @returns {number}
@@ -818,6 +957,57 @@ function runNumbers(rows) {
   return out;
 }
 
+/** The named limits of the runs list, in ONE place (P9 v2 D.13): quiet after 30 days, 7 older runs shown, a Resume tag ages out after 7 days. Sent in `GET /api/runs`; the page reads them from there. */
+export const RUNS_LIST_LIMITS = Object.freeze({ quietDays: 30, olderRuns: 7, needsYouDays: 7 });
+
+/**
+ * The ONE rule for a run's Needs-you tag (P9 v2 E): `Resume` when the engine would accept a resume (the SAME `resumePlanFor` answer the Run
+ * tab's Resume card shows, already asked once per row by `endedForRow`), until the run has been stopped `needsYouDays` (exactly that old is out;
+ * no readable stop time stays in). `Accept` comes from {@link doorWaiting} (T Part 8), asked in `summarizeRow`, never here.
+ * @param {{ok?: boolean}|null|undefined} resume @param {string|null} stoppedAt @param {number} nowMs
+ * @returns {'Accept'|'Resume'|null}
+ */
+export function needsTag(resume, stoppedAt, nowMs) {
+  if (!resume || resume.ok !== true) return null;
+  const t = typeof stoppedAt === 'string' ? Date.parse(stoppedAt) : NaN;
+  if (Number.isFinite(t) && nowMs - t >= RUNS_LIST_LIMITS.needsYouDays * 86_400_000) return null;
+  return 'Resume';
+}
+
+/**
+ * One entry per job, newest activity first: `headRunid` is the job's newest run BY TIME (never "the first row in server order"), `activityMs` the
+ * newest KNOWN time over its runs (`stoppedAt`, else `at`), `quiet` only when that time is known and older than the quiet limit. A job with a live
+ * run is never quiet; an unknown age is never guessed into quiet.
+ * @param {any[]} rows `listRuns` rows @param {number} nowMs
+ * @returns {{job: string, headRunid: string|null, quiet: boolean, activityMs: number|null}[]}
+ */
+export function summarizeJobs(rows, nowMs) {
+  /** @type {Map<string, {head: any, headMs: number, act: number|null, live: boolean}>} */
+  const by = new Map();
+  const ms = (/** @type {any} */ x) => { const t = typeof x === 'string' ? Date.parse(x) : NaN; return Number.isFinite(t) ? t : null; };
+  for (const r of rows) {
+    if (!r || typeof r.job !== 'string') continue;
+    const e = by.get(r.job) ?? { head: null, headMs: -Infinity, act: null, live: false };
+    const at = ms(r.at);
+    if (e.head === null || (at !== null && at > e.headMs)) { e.head = r; e.headMs = at ?? -Infinity; }
+    const t = Math.max(at ?? -Infinity, ms(r.stoppedAt) ?? -Infinity);
+    if (t > -Infinity && (e.act === null || t > e.act)) e.act = t;
+    if (r.live === true) e.live = true;
+    by.set(r.job, e);
+  }
+  const quietMs = RUNS_LIST_LIMITS.quietDays * 86_400_000;
+  return [...by.entries()]
+    .map(([job, e]) => ({ job, headRunid: e.head ? e.head.runid : null, quiet: !e.live && e.act !== null && nowMs - e.act > quietMs, activityMs: e.act }))
+    .sort((a, b) => {
+      if (a.activityMs !== b.activityMs) {
+        if (a.activityMs === null) return 1;
+        if (b.activityMs === null) return -1;
+        return b.activityMs - a.activityMs;
+      }
+      return a.job < b.job ? -1 : a.job > b.job ? 1 : 0;
+    });
+}
+
 /**
  * `GET /api/runs` — every listed run, NEWEST FIRST BY `at` (never by file/
  * append order — a backfill scan appends rows in sorted-PATH order, which
@@ -831,16 +1021,38 @@ function runNumbers(rows) {
  * SAME payload by job client-side (`groupRunsByJob` in `index.html`) rather
  * than a second server-side endpoint, so the glyph/checkType mapping is
  * still computed in exactly one place.
- * @param {{ home?: string }} [opts]
+ * @param {{ home?: string, now?: number }} [opts] `now` (ms) is injectable for the Needs-you age rule
  * @returns {any[]}
  */
 export function listRuns(opts = {}) {
-  const { rows } = readRunList(opts);
+  const { rows, events } = readRunList(opts);
+  const nowMs = typeof opts.now === 'number' ? opts.now : Date.now();
   const nos = runNumbers(rows);
+  const removals = readNeedsRemovals(opts);
   return rows
     .map((row, index) => ({ row, index })) // index: stable tie-break, see doc above
     .sort((a, b) => (atMs(b.row) - atMs(a.row)) || (a.index - b.index))
-    .map(({ row }) => ({ ...summarizeRow(row), runNo: nos.get(row.runid) }));
+    .map(({ row }) => ({ ...summarizeRow(row, nowMs, removals, events), runNo: nos.get(row.runid) }));
+}
+
+/**
+ * `GET /api/runs` (P9 v2 F): `{runs, jobs, limits}`. The server decides every state the left list draws — `live`, `needs`, each job's head run and
+ * quiet flag, the limits — and the page works out nothing. `scheduled` is the triggers piece (PRD v1.99, T Part 7).
+ * @param {{ home?: string, now?: number, schedules?: ReturnType<typeof createScheduleDoor> }} [opts]
+ */
+export function runsListPayload(opts = {}) {
+  const nowMs = typeof opts.now === 'number' ? opts.now : Date.now();
+  const runs = listRuns({ ...opts, now: nowMs });
+  const jobs = summarizeJobs(runs, nowMs);
+  // T Part 7: the Scheduled section, `[{job, at, in, words, runId}]`; runId = the job's HEAD run by time (summarizeJobs), never the first in server order
+  const scheduled0 = opts.schedules ? opts.schedules.listScheduled(new Map(jobs.map((j) => [j.job, j.headRunid]))) : [];
+  // RULED 2026-10-15: schedules that gave up wait in Needs you; the server builds the cards (job, pill, words, date, the head run to open)
+  const gaveUp0 = opts.schedules ? opts.schedules.listGaveUp(new Map(jobs.map((j) => [j.job, j.headRunid]))) : [];
+  // RULED 2026-10-15: both cards name the run they open (`job · run-N`), the number from the run list
+  const noOf = (/** @type {any} */ x) => { const r = runs.find((q) => q.runid === x.runId); return r && typeof r.runNo === 'number' ? { ...x, runNo: r.runNo } : x; };
+  const gaveUp = gaveUp0.map(noOf);
+  const scheduled = scheduled0.map(noOf);
+  return { runs, jobs, scheduled, gaveUp, limits: RUNS_LIST_LIMITS };
 }
 
 /**
@@ -880,6 +1092,391 @@ function findRunRow(runid, opts) {
   return readRunList(opts).rows.find((r) => r && r.runid === runid);
 }
 
+/**
+ * T Part 7 — `detail.schedule`: `{scheduled, canSchedule, words, text?, next?, nextRed?}` from the schedule door's ONE read of the
+ * schedule files and ledger (A.12). `waitingRunNo` = the job's NEWEST run when it waits for the person's Accept: ONE spine parse,
+ * never a run context per run. A job that cannot be read has no schedule block.
+ * @param {string} job @param {any[]} rows the run list @param {Map<string, number>} nos @param {{ schedules?: ReturnType<typeof createScheduleDoor> }} opts
+ */
+function scheduleDetailFor(job, rows, nos, opts) {
+  try {
+    const door = /** @type {ReturnType<typeof createScheduleDoor>} */ (opts.schedules);
+    let newest = null;
+    for (const r of rows) if (r && r.job === job && (newest === null || atMs(r) >= atMs(newest))) newest = r;
+    let waitingRunNo = null;
+    if (newest && existsSync(newest.spine) && door.readSchedule(job) && !runIsAlive(newest)) {
+      const records = parseJsonl(newest.spine).records;
+      if (doorWaiting(records)) waitingRunNo = nos.get(newest.runid) ?? null;
+    }
+    return door.view(job, { waitingRunNo });
+  } catch { return null; }
+}
+
+/**
+ * The record `trigger.json` a SCHEDULED start wrote beside its signed spec (why the run started), or null for every hand run.
+ * @param {{ spine: string }} row @returns {any|null}
+ */
+function triggerRecordOf(row) {
+  const near = sourceNearSpine(row.spine);
+  if (!near.specPath) return null;
+  try { return JSON.parse(readFileSync(join(dirname(near.specPath), 'trigger.json'), 'utf8')); } catch { return null; }
+}
+
+/**
+ * T Part 8 — what the Accept route needs: the run's row, whether its runner is alive, whether it waits at its review door
+ * ({@link doorWaiting}), and the signed spec it was judged by (the file and hash `run-u --door --approve` takes).
+ * @param {string} runid @param {{ home?: string }} opts
+ * @returns {{row: any, live: boolean, waiting: boolean, specPath: string|null, specHash: string|null}|null}
+ */
+export function getAcceptContext(runid, opts = {}) {
+  const row = findRunRow(runid, opts);
+  if (!row || row.via === 'import') return null;
+  if (!existsSync(row.spine)) return { row, live: runIsAlive(row), waiting: false, specPath: null, specHash: null };
+  const records = parseJsonl(row.spine).records;
+  const signed = signedSpecForRun(row, records);
+  return { row, live: runIsAlive(row), waiting: doorWaiting(records), specPath: signed ? signed.specPath : null, specHash: signed ? signed.specHash : null };
+}
+
+// ── PRD v1.107 Part 6: the Result tab (rubric jobs only) ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * The files a run delivered: its own `destination-written` spine records (userrun.js, on a minted green only), one per path, the last record of a
+ * path winning. This is the ONLY source of a delivered path anywhere in the panel — no request ever names one.
+ * @param {any[]} records
+ * @returns {{path: string, bytes: number|null, sha256: string|null}[]}
+ */
+export function deliveredOf(records) {
+  /** @type {Map<string, {path: string, bytes: number|null, sha256: string|null}>} */
+  const byPath = new Map();
+  for (const r of records) {
+    if (!r || r.type !== 'destination-written' || typeof r.path !== 'string' || !isAbsolute(r.path)) continue;
+    byPath.set(r.path, { path: r.path, bytes: typeof r.bytes === 'number' ? r.bytes : null, sha256: typeof r.sha256 === 'string' ? r.sha256 : null });
+  }
+  return [...byPath.values()];
+}
+
+/** @param {any} spec @returns {any[]} the signed close's rubric-step stages, in declared order */
+function rubricStagesOf(spec) {
+  const stages = Array.isArray(spec?.closeDecl?.stages) ? spec.closeDecl.stages : [];
+  return stages.filter((/** @type {any} */ s) => s && s.kind === 'rubric-step' && s.params && Number.isInteger(s.params.step));
+}
+
+/** what the Result tab's open door asks, after the door's own head words */
+export const RESULT_DOOR_ASK = 'the checks passed; is this what you wanted?';
+
+/** the two sentences for a delivered file that is no longer what the run wrote (code-owned, one spelling) */
+export const RESULT_FILE_GONE = 'the saved file is gone';
+export const RESULT_FILE_CHANGED = 'the saved file changed after the run';
+/** the same two states for a red run's file, which is the last one the check read (not a delivered file) */
+export const RESULT_JUDGED_GONE = 'the file is gone';
+export const RESULT_JUDGED_CHANGED = 'the file changed after the check';
+/** what a red run's rows are, said once above them */
+export const RESULT_JUDGED_NOTE = 'a red run delivers nothing; these rows are the last file the check read';
+
+/**
+ * One delivered file, read for the Result tab or a download: it must still be a regular file at the recorded path whose sha256 equals the
+ * record's. A mismatch or a missing file is a state, never content — stale bytes are never returned.
+ * @param {{path: string, sha256: string|null}} rec a record from {@link deliveredOf}
+ * @returns {{state: 'ok', buf: Buffer}|{state: 'gone'|'changed', buf: null}}
+ */
+function readDelivered(rec) {
+  let st;
+  try { st = lstatSync(rec.path); } catch { return { state: 'gone', buf: null }; }
+  if (!st.isFile()) return { state: 'gone', buf: null };
+  let buf;
+  try { buf = readFileSync(rec.path); } catch { return { state: 'gone', buf: null }; }
+  if (rec.sha256 === null || createHash('sha256').update(buf).digest('hex') !== rec.sha256) return { state: 'changed', buf: null };
+  return { state: 'ok', buf };
+}
+
+/**
+ * A red run's rows: the file the LAST check judged for job line `n`, from the run's own `output-judged` spine record `{step, iteration, path,
+ * bytes, sha256}` (src/planrun.js, one per check run, written before the next try overwrites the file). The spine step id is a step NAME, so the
+ * line is matched by the path the signed close judges (`stepFileRel(n)`), never by a path taken from a record or a request. It is resolved against
+ * the run's own tree root (`treeRootForRun`: `row.patient`, else the source-seed `tree/`), must stay inside it, and must still match the record's
+ * sha256 — stale content is never returned. `none` = no such record (an old spine, or a try that never reached its check).
+ * @param {any[]} records @param {number} n @param {string|null} root
+ * @returns {{state: 'ok', buf: Buffer}|{state: 'gone'|'changed'|'none', buf: null}}
+ */
+function readJudged(records, n, root) {
+  const rel = stepFileRel(n);
+  const rec = records.findLast((r) => r && r.type === 'output-judged' && r.path === rel && typeof r.sha256 === 'string');
+  if (!rec) return { state: 'none', buf: null };
+  if (root === null) return { state: 'gone', buf: null };
+  let abs;
+  try {
+    abs = realpathSync(join(root, rel));
+    const base = realpathSync(root);
+    if (!abs.startsWith(base + sep)) return { state: 'gone', buf: null };
+  } catch { return { state: 'gone', buf: null }; }
+  const got = readDelivered({ path: abs, sha256: rec.sha256 });
+  return got.state === 'ok' ? got : { state: got.state, buf: null };
+}
+
+/** a delivered step file's job line: `steps/<n>-YYYY-MM-DD[-k].json` (copyOut's dated name of `output/steps/<n>.json`), else null */
+function stepOfDelivered(path) {
+  const m = /^(\d+)-\d{4}-\d{2}-\d{2}(?:-\d+)?\.json$/.exec(basename(path));
+  return m ? Number(m[1]) : null;
+}
+
+/**
+ * Did this stage's check pass in the run's own record? The latest `check-run` for the stage says `satisfied` AND the run's last job-end is green.
+ * Read only — the Result tab never decides anything.
+ * @param {any[]} records @param {string} stageName
+ * @returns {boolean}
+ */
+function stagePassedIn(records, stageName) {
+  const end = records.findLast((r) => r && r.type === 'job-end');
+  if (!end || end.outcome !== 'green') return false;
+  const run = records.findLast((r) => r && r.type === 'check-run' && r.name === stageName);
+  return !!run && run.verdict === 'satisfied';
+}
+
+/** the words beside a Result-tab page link: the page is read again from the web, so it can differ from what the run read */
+export const RESULT_PAGE_MAY_CHANGE = 'The page may have changed since this run.';
+
+/**
+ * The web address each input LABEL was read from, off the run's own `source.json` (`inputs[].url`, written at drafting and rewritten at run start).
+ * Only http(s) addresses; a file or repo input has no `url` and so no entry. No source.json beside the run = an empty map (no link, nothing guessed).
+ * @param {string} spinePath @returns {Map<string, string>}
+ */
+function pageUrlsByLabel(spinePath) {
+  /** @type {Map<string, string>} */
+  const out = new Map();
+  const { sourceJsonPath } = sourceNearSpine(spinePath);
+  if (sourceJsonPath === null) return out;
+  try {
+    const m = JSON.parse(readFileSync(sourceJsonPath, 'utf8'));
+    for (const r of Array.isArray(m?.inputs) ? m.inputs : []) {
+      if (r && typeof r.label === 'string' && typeof r.url === 'string' && isWebUrl(r.url)) out.set(r.label, r.url.trim());
+    }
+  } catch { /* unreadable record: no link */ }
+  return out;
+}
+
+/**
+ * What a result's check read, from the run's own `rubric-evidence` record (report-only; bareguard 0.25 `full.evidence`), for the proof fold.
+ * `null` = no evidence (an old run, a malformed claim, or a quote that is not the one the check read): the page shows the plain quote.
+ * `text` is bareguard's normalized quote; `marks` are `[start, end]` UTF-16 offsets into it, sorted, overlaps merged. Which spans: every span the
+ * check read EXCEPT a bind-only membership token that is not this claim's (`canon` present, `matched` absent) - hamr 2026-10-19, ruled A.
+ * The offsets are bareguard's; nothing here searches the quote for anything.
+ * @param {any} ev one `evidence` entry @param {unknown} quote the result's own quote as the file holds it
+ * @returns {{text: string, marks: number[][]}|null}
+ */
+function proofOf(ev, quote) {
+  if (!ev || typeof ev.text !== 'string' || !Array.isArray(ev.spans) || typeof quote !== 'string') return null;
+  // the entry must be about THIS quote (bareguard's normalization: marks removed, whitespace collapsed, trimmed), else it is another try's
+  if (quote.replace(/\*\*|__/g, '').replace(/\s+/g, ' ').trim() !== ev.text) return null;
+  const spans = ev.spans
+    .filter((/** @type {any} */ sp) => sp && Number.isInteger(sp.start) && Number.isInteger(sp.end) && sp.start >= 0 && sp.end > sp.start && sp.end <= ev.text.length
+      && !(sp.canon !== undefined && sp.matched !== true))
+    .map((/** @type {any} */ sp) => [sp.start, sp.end])
+    .sort((/** @type {number[]} */ x, /** @type {number[]} */ y) => x[0] - y[0] || x[1] - y[1]);
+  /** @type {number[][]} */
+  const marks = [];
+  for (const sp of spans) {
+    const last = marks[marks.length - 1];
+    if (last && sp[0] < last[1]) last[1] = Math.max(last[1], sp[1]);
+    else marks.push([sp[0], sp[1]]);
+  }
+  return { text: ev.text, marks };
+}
+
+/**
+ * A money fact's amount exactly as the page wrote it ("144 US dollars", "€344"): the quote's text from the first to the last of the value's own
+ * currency/unit/value spans in bareguard's evidence for this claim (a membership token that is not the claim's own is left out). `null` = nothing
+ * located, or more than a short run: the caller keeps today's text. Offsets are bareguard's; nothing is searched.
+ * @param {any} ev one `evidence` entry (already known to be about this result's quote) @param {number} j the fact's index (bareguard's decide index)
+ * @returns {string|null}
+ */
+function moneyAsRead(ev, j) {
+  const own = ev.spans.filter((/** @type {any} */ sp) => sp && sp.decide === j && ['value', 'currency', 'unit'].includes(sp.role)
+    && Number.isInteger(sp.start) && Number.isInteger(sp.end) && sp.start >= 0 && sp.end > sp.start && sp.end <= ev.text.length
+    && !(sp.canon !== undefined && sp.matched !== true));
+  if (own.length === 0) return null;
+  const t = ev.text.slice(Math.min(...own.map((/** @type {any} */ sp) => sp.start)), Math.max(...own.map((/** @type {any} */ sp) => sp.end))).trim();
+  return t !== '' && t.length <= 40 ? t : null;
+}
+
+/** a fact's cell: a money amount in the fact's own signed currency/unit (src/facts.js moneyAs), anything else as the file wrote it */
+function resultCell(f, v) {
+  const t = cellText(v);
+  return f.shape === 'money' && /^\d[\d.,]*$/.test(t.trim()) ? moneyAs(f, t.trim(), true) : t;
+}
+
+/** the words after a fact whose limit the person agreed to in a Part 5b look ask */
+export const RESULT_YOU_CONFIRMED = '(you confirmed)';
+
+/**
+ * The facts of line `n` whose limit came from a Part 5b `agree` answer, read from the drafting session's `human` rows (source 'look', this line,
+ * the answer `agree`): the ask proposed `<fact name> <ruleWords>`, and `agree` wrote exactly that as a `~` rule on the line. A fact is confirmed only
+ * when that proposal equals what the SIGNED fact says now AND the line's signed `~` rules hold it word for word. No draft log (a Reuse run, a CLI
+ * run, a deleted session) = nothing is confirmed; nothing is guessed.
+ * @param {any} row @param {any} jobLine the signed job line @param {any} fp the signed fact part @param {{ home?: string, sessionsRoot?: string }} opts
+ * @returns {Set<string>} fact names
+ */
+function confirmedFactNames(row, jobLine, fp, opts) {
+  const names = new Set();
+  const dir = sessionDirForRow(row, opts);
+  if (!dir || !jobLine) return names;
+  const written = lineRules(jobLine);
+  const humans = readDraftSteps(dir).flatMap((st) => st.humans);
+  for (const h of humans) {
+    if (h.source !== 'look' || h.line !== jobLine.n || !isAgree(h.answer)) continue;
+    const reading = readingOfQuestion(h.question);
+    if (reading === null || !written.includes(reading)) continue;
+    for (const f of fp.facts) if (f.rule && reading === `${f.name} ${ruleWords(f)}`) names.add(f.name);
+  }
+  return names;
+}
+
+/** a result value as the file wrote it, for a table cell */
+function cellText(v) {
+  if (typeof v === 'string') return v;
+  if (typeof v === 'number' && Number.isFinite(v)) return String(v);
+  return '';
+}
+
+/**
+ * `GET /api/runs/:runid/result` — the Result tab: for each rubric job line, its words and `~` rules from the signed spec, the facts it requires
+ * (worded by {@link factSentence}), and — read from the run's own delivered step file, sha256-checked against its `destination-written`
+ * record — one row per result with each fact's cell. `passed` is read from the run's own `check-run` record; the tab never re-decides. A red run
+ * delivers nothing, so it has no rows: it carries the check's own first gap instead. `null` = no such run or no result tab for it.
+ * @param {string} runid @param {{ home?: string }} opts
+ */
+export function getRunResult(runid, /** @type {{ home?: string, sessionsRoot?: string }} */ opts = {}) {
+  const row = findRunRow(runid, opts);
+  if (!row || row.via === 'import' || !existsSync(row.spine)) return null;
+  const records = parseJsonl(row.spine).records;
+  const spec = resolveSpecForRow(row);
+  const stages = rubricStagesOf(spec);
+  if (stages.length === 0) return null;
+  const delivered = deliveredOf(records);
+  const read = delivered.map((d) => readDelivered(d));
+  const jobLines = Array.isArray(spec?.jobLines) ? spec.jobLines : [];
+  // Not checked, split by the line the SIGNED plan ties each item to: a refusal carries its line (closeDecl.refused[].line, planFromSpec's
+  // `lines[].refused`), a prose step carries its stage's step. What the plan ties to no line stays in `notChecked` (the bottom). Together they are
+  // exactly the Job tab's items (its per-line "not checked" rows plus its Not checked fold) — never a second spelling.
+  const plan = planFromSpec(spec);
+  const proseByLine = proseNotCheckedItems(spec?.closeDecl);
+  const prosePool = proseByLine.map((i) => i.text);
+  const tiedToLine = (/** @type {number} */ n) => [...(plan.lines.find((l) => l.n === n)?.refused ?? []), ...proseByLine.filter((i) => i.line === n).map((i) => i.text)];
+  const bottom = [...plan.notChecked];
+  for (const t of prosePool) { const k = bottom.indexOf(t); if (k >= 0) bottom.splice(k, 1); }
+  const pageUrls = pageUrlsByLabel(row.spine);
+  const greenEnd = records.findLast((r) => r && r.type === 'job-end')?.outcome === 'green';
+  const lines = stages.map((/** @type {any} */ st) => {
+    const n = st.params.step;
+    const jl = jobLines.find((/** @type {any} */ l) => l && l.n === n) ?? null;
+    const fp = factPartOf(st.params);
+    const di = delivered.map((d, i) => ({ d, i })).filter(({ d }) => stepOfDelivered(d.path) === n).pop() ?? null;
+    const passed = stagePassedIn(records, st.name);
+    /** @type {any} */
+    const out = {
+      notChecked: tiedToLine(n),
+      n, text: jl && typeof jl.text === 'string' ? jl.text : '', rules: jl ? lineRules(jl) : [], kind: fp ? 'facts' : 'text', passed,
+      file: di ? { i: di.i, state: read[di.i].state, words: read[di.i].state === 'gone' ? RESULT_FILE_GONE : (read[di.i].state === 'changed' ? RESULT_FILE_CHANGED : null) } : null,
+    };
+    let obj = null;
+    if (di && read[di.i].buf) { try { obj = JSON.parse(/** @type {Buffer} */ (read[di.i].buf).toString('utf8')); } catch { obj = null; } }
+    if (!di && !greenEnd) {
+      // a red run: the last file the check judged (never a ✓: `passed` is false for it)
+      const j = readJudged(records, n, treeRootForRun(row));
+      if (j.state !== 'none') {
+        out.file = { i: null, state: j.state, words: j.state === 'gone' ? RESULT_JUDGED_GONE : (j.state === 'changed' ? RESULT_JUDGED_CHANGED : null), judged: true, note: RESULT_JUDGED_NOTE };
+        if (j.buf) { try { obj = JSON.parse(j.buf.toString('utf8')); } catch { obj = null; } }
+      }
+    } else if (di && !read[di.i].buf) {
+      // the delivered file is gone or changed: that is said ONCE, in the Saved card. The line shows the rows of the file the check read, if the
+      // run's own tree still holds exactly it (sha256 against the output-judged record), else the page says there is no saved result to show
+      const j = readJudged(records, n, treeRootForRun(row));
+      if (j.buf) { try { obj = JSON.parse(j.buf.toString('utf8')); out.fromCheck = true; } catch { obj = null; } }
+    }
+    if (fp) {
+      out.source = fp.source;
+      out.page = pageUrls.get(fp.source) ?? null;
+      const confirmed = confirmedFactNames(row, jl, fp, opts);
+      out.facts = fp.facts.map((/** @type {any} */ f) => ({
+        name: f.name, kind: f.shape === 'phrase' ? 'phrase' : 'value', sentence: factSentence(f, fp.source),
+        ...(confirmed.has(f.name) ? { note: RESULT_YOU_CONFIRMED } : {}),
+      }));
+      const results = obj && Array.isArray(obj.results) ? obj.results : null;
+      // what the check read, from the run's last `rubric-evidence` record for this line (the claim index IS the result's index in `results[]`)
+      const evRec = records.findLast((r) => r && r.type === 'rubric-evidence' && r.step === n && Array.isArray(r.evidence));
+      const evCheck = `p${st.params.parts.indexOf(fp) + 1}-facts`;
+      out.rows = results === null ? null : results.map((/** @type {any} */ r, /** @type {number} */ k) => {
+        const values = r && typeof r === 'object' && r.values && typeof r.values === 'object' ? r.values : {};
+        const quote = r && typeof r === 'object' && typeof r.quote === 'string' ? r.quote : '';
+        const ev = evRec ? evRec.evidence.find((/** @type {any} */ e) => e && e.check === evCheck && e.claim === k) : null;
+        const proof = proofOf(ev, quote);
+        return {
+          n: k + 1,
+          quote,
+          ...(proof ? { proof } : {}),
+          // a money amount is shown the way the check read it off the page; without evidence (or nothing located) it is the fact's own spelling
+          cells: fp.facts.map((/** @type {any} */ f, /** @type {number} */ j) => (f.shape === 'phrase' ? String(f.phrase)
+            : ((f.shape === 'money' && proof ? moneyAsRead(ev, j) : null) ?? resultCell(f, values[f.name])))),
+        };
+      });
+    } else if (obj && typeof obj === 'object') {
+      out.answer = typeof obj.text === 'string' ? obj.text : null;
+      const cites = obj.cites && typeof obj.cites === 'object' ? obj.cites : {};
+      out.cites = Object.entries(cites).filter(([, list]) => Array.isArray(list)).map(([label, list]) => ({
+        label,
+        items: /** @type {any[]} */ (list).map((c) => ({ claim: cellText(c?.claim), quote: cellText(c?.quote) })),
+      }));
+    }
+    return out;
+  });
+  const end = records.findLast((r) => r && r.type === 'job-end');
+  // a run that did not end green delivered nothing: say the check's own first gap (the Audit's try line words), never rows
+  let gap = null;
+  if (!end || end.outcome !== 'green') {
+    const ev = records.findLast((r) => r && r.type === 'exit-eval' && Array.isArray(r.results) && r.results.some((/** @type {any} */ x) => x && x.type === 'check-passes' && x.pass === false));
+    const bad = ev ? ev.results.find((/** @type {any} */ x) => x && x.type === 'check-passes' && x.pass === false) : null;
+    const g = bad ? gapOneLine(bad.detail) : null;
+    gap = g ? { line: g.line, more: g.more, moreText: g.more > 0 ? `(+${g.more} more)` : null } : null;
+  }
+  // the distinct web pages the results read, in line order: ONE = the page draws a single link at the top, 2+ = each line carries its own `page`
+  const pages = [...new Set(lines.map((/** @type {any} */ l) => l.page).filter((/** @type {any} */ u) => typeof u === 'string'))];
+  return {
+    runid,
+    lines,
+    pages,
+    pageNote: pages.length ? RESULT_PAGE_MAY_CHANGE : null,
+    notChecked: bottom,
+    // the door's words, from the one table (src/panel/status.js DOOR_WORDS); the page types none of them
+    door: { head: DOOR_WORDS.waiting.head, ask: RESULT_DOOR_ASK },
+    delivered: delivered.map((d, i) => ({
+      i, path: d.path, name: basename(d.path), bytes: d.bytes, state: read[i].state,
+      words: read[i].state === 'gone' ? RESULT_FILE_GONE : (read[i].state === 'changed' ? RESULT_FILE_CHANGED : null),
+    })),
+    gap,
+  };
+}
+
+/** download content types by extension; anything else is plain bytes */
+const DOWNLOAD_TYPES = { '.json': 'application/json', '.md': 'text/plain', '.txt': 'text/plain', '.csv': 'text/csv' };
+
+/**
+ * `GET /api/runs/:runid/download?i=<n>` — delivered file `n` (an index into the run's own `destination-written` list), or why not. The path is
+ * the record's, never the request's; the sha256 must still match the record.
+ * @param {string} runid @param {unknown} index @param {{ home?: string }} opts
+ * @returns {{ok: true, name: string, type: string, buf: Buffer}|{ok: false, code: number, error: string}}
+ */
+export function getRunDownload(runid, index, opts = {}) {
+  const row = findRunRow(runid, opts);
+  if (!row || row.via === 'import' || !existsSync(row.spine)) return { ok: false, code: 404, error: 'no such run' };
+  const delivered = deliveredOf(parseJsonl(row.spine).records);
+  const i = typeof index === 'string' && /^\d{1,6}$/.test(index) ? Number(index) : -1;
+  if (i < 0 || i >= delivered.length) return { ok: false, code: 404, error: 'this run saved no such file' };
+  const got = readDelivered(delivered[i]);
+  if (got.state !== 'ok') return { ok: false, code: 409, error: got.state === 'gone' ? RESULT_FILE_GONE : RESULT_FILE_CHANGED };
+  const name = basename(delivered[i].path);
+  const ext = name.includes('.') ? name.slice(name.lastIndexOf('.')).toLowerCase() : '';
+  return { ok: true, name, type: Object.hasOwn(DOWNLOAD_TYPES, ext) ? /** @type {Record<string,string>} */ (DOWNLOAD_TYPES)[ext] : 'application/octet-stream', buf: got.buf };
+}
+
 /**
  * `GET /api/runs/:runid` — the full replay for the Run tab: steps (or
  * iterations), counters, summary-box fields. Looks `runid` up in the run
@@ -887,25 +1484,95 @@ function findRunRow(runid, opts) {
  * header); `null` when the runid is not in the list at all (caller renders
  * 404).
  * @param {string} runid
- * @param {{ home?: string }} [opts]
+ * @param {{ home?: string, schedules?: ReturnType<typeof createScheduleDoor> }} [opts]
  * @returns {any|null}
  */
 export function getRunDetail(runid, opts = {}) {
   const d = getRunDetailBody(runid, opts);
   if (!d) return d;
-  const runNo = runNumbers(readRunList(opts).rows).get(runid);
-  return runNo === undefined ? d : { ...d, runNo };
+  const { rows } = readRunList(opts);
+  const nos = runNumbers(rows);
+  const runNo = nos.get(runid);
+  // T Part 7: what the Run tab shows of the job's schedule — the SERVER decides every state and word (the page works out nothing)
+  const schedule = opts.schedules && typeof d.job === 'string' ? scheduleDetailFor(d.job, rows, nos, opts) : null;
+  const extra = opts.schedules && typeof d.job === 'string' ? scheduleExtrasFor(runid, d.job, rows, nos, opts, schedule) : {};
+  return { ...d, ...(runNo === undefined ? {} : { runNo }), ...(schedule ? { schedule: extra.schedule ?? schedule } : {}), ...(extra.audit ?? {}) };
+}
+
+/**
+ * Aligned with fwdloop M9 am7: the SCHEDULE row's second line and the Audit's schedule rows, made on the server from the door's data.
+ * `schedule` = the door's view with `line2`, `problem` (and no raw ledger row); `audit` = `{scheduleSection}` or, for a run a cancelled schedule started, `{startedAudit}`.
+ * @param {string} runid @param {string} job @param {any[]} rows @param {Map<string, number>} nos @param {any} opts @param {any} view
+ * @returns {{schedule?: any, audit?: {startedAudit?: string, scheduleSection?: any}}}
+ */
+function scheduleExtrasFor(runid, job, rows, nos, opts, view) {
+  try {
+    const door = /** @type {ReturnType<typeof createScheduleDoor>} */ (opts.schedules);
+    /** @type {any} */
+    let schedule;
+    if (view) {
+      const { lastRow, nextWords, accept, ...rest } = view;
+      schedule = { ...rest, line2: null };
+      if (view.scheduled) {
+        let lastWords = null;
+        if (lastRow) {
+          if (lastRow.kind === 'started') {
+            const mine = rows.filter((r) => r && r.job === job).sort((a, b) => atMs(b) - atMs(a)).slice(0, 25);
+            let hit = null; let fallback = null;
+            for (const r of mine) {
+              const rec = triggerRecordOf(r);
+              if (!rec) continue;
+              if (fallback === null) fallback = { r, rec };
+              if (rec.sessionId && rec.sessionId === lastRow.sessionId) { hit = { r, rec }; break; }
+            }
+            const got = hit ?? fallback;
+            const no = got ? nos.get(got.r.runid) : undefined;
+            const word = got ? summarizeRow(got.r).status?.word : undefined;
+            lastWords = `last ${dateTimeWords(Number(lastRow.at))}${no ? ` · run-${no}` : ''}${word ? ` · ${word}` : ''}${got?.rec.catchUp === true ? ' · catch-up' : ''}`;
+          } else {
+            lastWords = `last ${dateTimeWords(Number(lastRow.at))} · ${skippedWords(lastRow, true)}`;
+          }
+        }
+        schedule.line2 = [lastWords ?? 'no run yet', accept ? SCHEDULE_WORDS.acceptWaiting : null, nextWords].filter(Boolean).join(' · ');
+      }
+    }
+    const row = rows.find((r) => r && r.runid === runid);
+    const rec = row ? triggerRecordOf(row) : null;
+    const cur = door.readSchedule(job);
+    if (!cur) {
+      // no schedule now: a run a cancelled schedule started keeps its one old line; a hand run has nothing
+      const origin = rec ? (rec.originRunid ?? null) : null;
+      return { ...(schedule ? { schedule } : {}), audit: rec ? { startedAudit: startedAuditWords(rec, origin ? (nos.get(origin) ?? null) : null) } : {} };
+    }
+    // RULED 2026-10-15 (v1.104): ONE `schedule` section on every run of a job that has a schedule now, folded when the page opens
+    const originNo = nos.get(cur.originRunid) ?? null;
+    const tries = door.skippedFor(job);
+    const running = rows.some((r) => r && r.job === job && r.via !== 'import' && runIsAlive(r));
+    const { sign, word } = scheduleSignFor({ running, red: !!(view && view.problem) });
+    const words = scheduledWords(cur.trigger, door.userHome);
+    const head = [lowerFirst(words ?? ''), originNo === null ? null : `from run-${originNo}`, triesTailWords(tries.length) || null].filter(Boolean).join(' · ');
+    const when = row ? dateTimeWords(atMs(row)) : '';
+    const thisRun = rec ? sectionThisRunWords(rec) : `by hand.${runid === cur.originRunid ? ' The schedule was set from this run.' : ''}`;
+    const shown = tries.slice(0, 7).map((x, i) => ({ label: i === 0 ? 'tries' : '', text: x.line }));
+    const scheduleSection = {
+      title: SCHEDULE_WORDS.scheduleGroup, sign, word, head,
+      rows: [{ label: 'this run', text: `${when}  ${thisRun}` }, ...(shown.length > 0 ? shown : [{ label: 'tries', text: 'none' }])],
+    };
+    return { ...(schedule ? { schedule } : {}), audit: { scheduleSection } };
+  } catch { return {}; }
 }
 
 /**
  * @param {string} runid
- * @param {{ home?: string }} opts
+ * @param {{ home?: string, now?: number }} opts
  * @returns {any|null}
  */
 function getRunDetailBody(runid, opts) {
   const row = findRunRow(runid, opts);
   if (!row) return null;
   if (!existsSync(row.spine)) {
+    const refusal = refusalWordsOf(readRunList(opts).events, row);
+    if (refusal !== null) return refusedStub(row, refusal);
     if (runIsAlive(row)) return startingStub(row);
     return {
       runid, job: row.job, at: row.at, via: row.via, fileMissing: true,
@@ -927,7 +1594,8 @@ function getRunDetailBody(runid, opts) {
   // the drafting part (see draftingFor) heads the parts list; the enrichment below touches the spine's own parts only
   const draftingPartHere = draftingFor(row, summary, opts);
   const draftingShiftHere = draftingShift(row, summary, opts);
-  const enrichedParts = enrichPartsWithStageKind(summary.parts, stageKindMetaFromSpec(resolveSpecForRow(row)));
+  const specForParts = resolveSpecForRow(row);
+  const enrichedParts = enrichPartsWithStageKind(summary.parts, stageKindMetaFromSpec(specForParts), specForParts);
   const death = deriveDeath(row, rawSpineRecords, summary.outcome);
   const { ended, resume, status } = endedForRow(row, rawSpineRecords, summary, death, true);
   // judgeModel (Summary box "judge:" line): the FIRST `judge-round`'s own
@@ -1091,6 +1759,12 @@ function getRunDetailBody(runid, opts) {
     // numbers the Resume confirm box prefills (the signed caps, spent so far); `null`
     // whenever Resume is not offered.
     ended,
+    // aligned with fwdloop M9 am7: `MM/DD HH:MM · <outcome word> · <reason>` (local end time); null while the run is live
+    endedText: (() => {
+      const ts = lastJobEndTs(rawSpineRecords) ?? (death.died ? lastRecordTs(rawSpineRecords) : null);
+      const ms = ts === null ? NaN : Date.parse(ts);
+      return ended && Number.isFinite(ms) ? `${dateTimeWords(ms)} · ${status.word} · ${ended.reason}` : null;
+    })(),
     // P5 item 5: is the run's LATEST leg live (the page offers Stop only then), and has a stop been asked for
     // (the request file exists beside the spine) — the page reads "stopping after this turn…" until the leg ends
     live: row.via !== 'import' && runIsAlive(row),
@@ -1174,7 +1848,33 @@ function getRunDetailBody(runid, opts) {
     // carries no contamination risk); `null` when the spine carries no
     // `memory-cache` record at all (never armed on this run).
     behaviour: scopedBehaviour(row, rawSpineRecords),
+    // PRD v1.106 Part 5 F: the two Run summary rows, worded here (the page prints them)
+    callsLine: callsLineOf(rawSpineRecords, scopedBehaviour(row, rawSpineRecords)),
+    checksLine: checksLineOf(rawSpineRecords, enrichedParts),
     memoryCache: summary.memoryCache,
+    // T Part 8: is this run waiting for the person's Accept? The SAME answer fills the runs list's Needs-you tag (`doorWaiting`, one owner)
+    accept: !runIsAlive(row) && doorWaiting(rawSpineRecords),
+    // PRD v1.107 Part 6: the Result tab shows for a rubric run whose signed close has a rubric-step stage, never otherwise; `delivered` is the
+    // files the run's own `destination-written` records name (the Result tab's downloads index into this list, never a path from a request)
+    hasResult: checkTypeLabel(summary.verdictType, row.at) === 'rubric' && rubricStagesOf(specForParts).length > 0,
+    delivered: deliveredOf(rawSpineRecords).map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 })),
+    // T Part 7: why a SCHEDULED run started (the words `trigger.json` carried) and the fixed catch-up sentence; null on every hand run
+    ...(() => {
+      const trig = triggerRecordOf(row);
+      return { startedBy: trig && typeof trig.reason === 'string' ? trig.reason : null, catchUp: catchUpWords(trig) };
+    })(),
+    // RULED 2026-10-15 (Remove from Needs you): the server says whether the button shows (a Resume card only, never a live Accept) and the Audit line
+    ...(() => {
+      const nowMs = typeof opts.now === 'number' ? opts.now : Date.now();
+      const live = !death.died && (summary.outcome === null || summary.outcome === undefined) && runIsAlive(row);
+      const stoppedAt = live ? null : (lastJobEndTs(rawSpineRecords) ?? (death.died ? lastRecordTs(rawSpineRecords) : null));
+      const st = needsStateFor({ live, records: rawSpineRecords, resume, stoppedAt, nowMs, removedMs: readNeedsRemovals(opts).get(row.runid) });
+      /** @type {string|null} */
+      let needsAudit = null;
+      if (st.removedMs !== null) needsAudit = `removed from Needs you by you · ${dateTimeWords(st.removedMs)}`;
+      else if (st.expired) needsAudit = `removed from Needs you after ${RUNS_LIST_LIMITS.needsYouDays} days`;
+      return { canRemoveFromNeeds: st.needs === 'Resume', needsAudit };
+    })(),
   };
 }
 
@@ -1594,7 +2294,7 @@ export const ROUNDS_PAGE_MAX = 200;
  * resolve to a real window, or the spine file is missing — the caller
  * renders 404, same posture as {@link getRunAudit}/{@link getRunJob}.
  * @param {string} runid
- * @param {{ part?: number, attempt?: number, offset?: number, limit?: number }} query
+ * @param {{ all?: boolean, part?: number, attempt?: number, offset?: number, limit?: number }} query
  * @param {{ home?: string }} [opts]
  * @returns {any|null}
  */
@@ -1616,6 +2316,11 @@ export function getRunRounds(runid, query = {}, opts = {}) {
   if (shift && partIndex === 0) return null;
   const part = Array.isArray(summary.parts) ? summary.parts[partIndex - shift] : null;
   if (!part) return null;
+  // PRD v1.106 Part 5 (C): a plan step with graded tries shows ONE table for the whole step (a Try column, round numbers from 1 per step,
+  // a check row after each try, 20 rows a page); `all=1` asks for it. Every other part keeps its per-attempt table.
+  if (query.all === true && part.kind === 'step' && Array.isArray(part.attempts) && part.attempts.some((x) => Array.isArray(x.checks))) {
+    return stepRoundsPage(runid, row, part, { partIndex, offset, limit: Number.isInteger(query.limit) && /** @type {number} */ (query.limit) > 0 ? Math.min(/** @type {number} */ (query.limit), ROUNDS_PAGE_MAX) : STEP_ROWS_PAGE }, opts);
+  }
   const a = Array.isArray(part.attempts) ? part.attempts[attempt - 1] : null;
   if (!a) return null;
   /** @type {{startSeq: number, endSeq: number, outcome: string|null, detail: string|null}} */
@@ -1677,6 +2382,90 @@ export function getRunRounds(runid, query = {}, opts = {}) {
   };
 }
 
+/** the Audit step table's page size (PRD v1.106 Part 5 choice 3): rows, not rounds */
+export const STEP_ROWS_PAGE = 20;
+
+/** the Round table's check row: the sign and the plain words, ONE place (PRD v1.106 Part 5 C) @param {number} passed @param {number} failed */
+export function checkRowWords(passed, failed) {
+  return failed > 0 ? { sign: '✗', text: `${failed} failed, ${passed} passed` } : { sign: '✓', text: `${passed} passed` };
+}
+
+/**
+ * One plan step's whole Round table (PRD v1.106 Part 5 C): every model call, every tool call and one check row per graded try, in order, each
+ * with its Try; round numbers restart at 1 inside the step (the flat Audit view keeps the run-wide numbers). A page is `limit` ROWS.
+ * @param {string} runid @param {any} row @param {any} part @param {{partIndex: number, offset: number, limit: number}} q @param {{ home?: string }} opts
+ */
+function stepRoundsPage(runid, row, part, q, opts) {
+  const attempts = part.attempts.filter((/** @type {any} */ x) => Array.isArray(x.checks));
+  const cut = part.cutOffTry ?? null;
+  /** @type {Array<{n: number, startSeq: number, endSeq: number, a: any}>} */
+  const windows = attempts.map((/** @type {any} */ a) => ({ n: a.n, startSeq: a.startSeq, endSeq: a.endSeq, a }));
+  if (cut) windows.push({ n: cut.n, startSeq: cut.startSeq, endSeq: cut.endSeq, a: null });
+  const lo = windows[0].startSeq;
+  const hi = windows[windows.length - 1].endSeq;
+  const tryOfSeq = (/** @type {number} */ seq) => windows.find((w) => seq > w.startSeq && seq <= w.endSeq)?.n ?? windows[windows.length - 1].n;
+  const { records: spineRecords } = parseJsonl(row.spine);
+  const roundOf = makeRoundLookup(spineRecords);
+  const spend = spineRecords
+    .filter((/** @type {any} */ r) => r && SPEND_RECORD_TYPES.includes(r.type) && typeof r.seq === 'number' && r.seq > lo && r.seq <= hi)
+    .sort((/** @type {any} */ a, /** @type {any} */ b) => a.seq - b.seq);
+  const auditResult = getRunAudit(runid, opts);
+  const toolLogSaved = !!auditResult && auditResult.reason !== 'no-sidecar';
+  /** @type {Map<number, any[]>} */
+  const toolsByRound = new Map();
+  if (toolLogSaved && auditResult) {
+    for (const r of auditResult.rows) {
+      if (r.kind !== 'tool-call' || typeof r.round !== 'number') continue;
+      const bucket = toolsByRound.get(r.round) ?? [];
+      bucket.push(r);
+      toolsByRound.set(r.round, bucket);
+    }
+  }
+  const spec = resolveSpecForRow(row);
+  const exitTs = new Map(spineRecords.filter((/** @type {any} */ r) => r && r.type === 'exit-eval' && typeof r.seq === 'number').map((/** @type {any} */ r) => [r.seq, r.ts]));
+  /** @type {Array<{seq: number, rows: any[]}>} */
+  const blocks = [];
+  spend.forEach((/** @type {any} */ r, i) => {
+    const runWide = roundOf(r.ts);
+    const tryN = tryOfSeq(r.seq);
+    const local = i + 1;
+    const modelCall = toolLogSaved && auditResult ? auditResult.rows.find((x) => x.kind === 'model-call' && x.round === runWide) : null;
+    const rows = [{
+      kind: 'model', round: local, try: tryN, time: typeof r.ts === 'string' ? r.ts : null,
+      costUsd: typeof r.costUsd === 'number' && Number.isFinite(r.costUsd) ? r.costUsd : null,
+      tokens: typeof r.tokens === 'number' && Number.isFinite(r.tokens) ? r.tokens : null,
+      durationMs: modelCall ? modelCall.durationMs : null,
+    }];
+    for (const tc of (runWide === null ? [] : (toolsByRound.get(runWide) ?? []))) rows.push({ ...tc, kind: 'tool', round: local, try: tryN });
+    blocks.push({ seq: r.seq, rows });
+  });
+  for (const w of windows) {
+    if (!w.a) continue; // a try cut off before its checks ran has no check row
+    const passed = w.a.checks.filter((/** @type {any} */ c) => c.pass).length;
+    const failed = w.a.checks.length - passed;
+    const named = w.a.checks.find((/** @type {any} */ c) => c.type === 'check-passes');
+    const judgedPath = named && named.name ? judgedFilesOf(spec?.closeDecl, named.name)[0] ?? null : null;
+    blocks.push({
+      seq: w.endSeq,
+      rows: [{ kind: 'check', round: null, try: w.n, time: exitTs.get(w.endSeq) ?? null, path: judgedPath, ...checkRowWords(passed, failed) }],
+    });
+  }
+  blocks.sort((a, b) => a.seq - b.seq);
+  const all = blocks.flatMap((b) => b.rows);
+  return {
+    runid,
+    part: q.partIndex,
+    partKind: 'step',
+    mode: 'step',
+    step: partDisplayLabel(part),
+    rows: all.slice(q.offset, q.offset + q.limit),
+    totalRows: all.length,
+    offset: q.offset,
+    limit: q.limit,
+    toolLogSaved,
+  };
+}
+
 /**
  * The `↳ close:`-style text for one iteration's OWN close-verdict — same
  * shape as `src/replay.js`'s private `closeStageLine`, but that helper is
@@ -1930,7 +2719,7 @@ function stageQuestionText({
  * ran. `null` when the spec has no `closeDecl.stages` array at all (a
  * command-close spec, or no spec resolved).
  * @param {any} spec
- * @returns {Map<string, {kind: string|null, direction: string|null, baselineKind: 'seed'|0|null, question: string|null}>|null}
+ * @returns {Map<string, {kind: string|null, direction: string|null, baselineKind: 'seed'|0|null, question: string|null, fromLine: number[]}>|null}
  */
 function stageKindMetaFromSpec(spec) {
   if (!spec || typeof spec !== 'object' || !spec.closeDecl || !Array.isArray(spec.closeDecl.stages)) return null;
@@ -1946,7 +2735,7 @@ function stageKindMetaFromSpec(spec) {
       if (key !== null) suiteCmdKeys.add(key);
     }
   }
-  /** @type {Map<string, {kind: string|null, direction: string|null, baselineKind: 'seed'|0|null, question: string|null}>} */
+  /** @type {Map<string, {kind: string|null, direction: string|null, baselineKind: 'seed'|0|null, question: string|null, fromLine: number[]}>} */
   const map = new Map();
   for (const s of spec.closeDecl.stages) {
     if (!s || typeof s.name !== 'string' || s.name.length === 0) continue;
@@ -1958,12 +2747,21 @@ function stageKindMetaFromSpec(spec) {
       kind, params, genre, suiteCmdKeys,
     });
     map.set(s.name, {
-      kind, direction, baselineKind, question,
+      kind, direction, baselineKind, question, fromLine: Array.isArray(s.fromLine) ? s.fromLine.filter(Number.isInteger) : [],
     });
   }
   return map;
 }
 
+/**
+ * Stage name to the panel's plain question, off a signed spec — the SAME owner ({@link stageKindMetaFromSpec}) the step map and Audit use.
+ * @param {any} spec
+ * @returns {Map<string, string|null>}
+ */
+function stageQuestionsOfSpec(spec) {
+  return new Map([...(stageKindMetaFromSpec(spec) ?? new Map())].map(([n, m]) => [n, m.question]));
+}
+
 /**
  * Attaches one stage's `{kind, direction, baselineKind, question}` (from
  * {@link stageKindMetaFromSpec}'s map) onto its already-recorded runtime
@@ -2019,21 +2817,261 @@ function attachStageKind(stage, kindMeta) {
  * @param {Map<string, any>|null} kindMeta
  * @returns {any[]|null|undefined}
  */
-function enrichPartsWithStageKind(parts, kindMeta) {
+function enrichPartsWithStageKind(parts, kindMeta, spec = null) {
   if (!Array.isArray(parts)) return parts;
   const declaredStagesTotal = kindMeta ? kindMeta.size : null;
   const declaredStages = kindMeta
     ? Array.from(kindMeta, ([name, meta]) => ({ name, question: meta.question }))
     : null;
-  return parts.map((part) => ({
-    ...part,
-    attempts: Array.isArray(part.attempts) ? part.attempts.map((a) => ({
-      ...a,
-      stages: (kindMeta && Array.isArray(a.stages)) ? a.stages.map((s) => attachStageKind(s, kindMeta)) : a.stages,
-      ...(declaredStagesTotal ? { declaredStagesTotal } : {}),
-      ...(declaredStages ? { declaredStages } : {}),
-    })) : part.attempts,
+  return parts.map((part) => {
+    const attempts = Array.isArray(part.attempts) ? part.attempts.map((a) => {
+      // PRD v1.106 Part 5 (D1): a plan step's attempt carries the checks its try RAN (replay), worded here; they also stand in as the attempt's
+      // `stages`, which is what the page's headline and check list read (before this they were null, so every check read "not run")
+      const checks = Array.isArray(a.checks) ? tryChecksOf(a.checks, kindMeta, spec) : null;
+      return {
+        ...a,
+        ...(checks ? { checks, judged: (Array.isArray(a.outputJudged) ? a.outputJudged : []).map(judgedFileLine), stages: checks.map(stageOfCheck) } : { stages: (kindMeta && Array.isArray(a.stages)) ? a.stages.map((s) => attachStageKind(s, kindMeta)) : a.stages }),
+        ...(declaredStagesTotal ? { declaredStagesTotal } : {}),
+        ...(declaredStages ? { declaredStages } : {}),
+      };
+    }) : part.attempts;
+    return {
+      ...part,
+      attempts,
+      ...(part.kind === 'step' ? (() => { const tries = triesOf(attempts, part.cutOffTry); return { tries, triesLine: triesLineOf(tries), marker: ACTOR_MARKER.model, tally: toolsTallyLine(part.byTool, part.blocked) }; })() : {}),
+      ...(part.kind === 'door' && part.door ? { marker: ACTOR_MARKER.human, doorView: doorViewOf(part.door) } : {}),
+    };
+  });
+}
+
+/** the words for a try the wall (or a cap, or a stop) ended before any of its checks ran (D2) */
+const CUT_OFF_WORDS = 'cut off before its checks ran';
+
+/**
+ * "71 model · 91 tool · 0 denied" — the Run summary's `calls:` row (PRD v1.106 Part 5 F). Model calls are the run's own spend records
+ * (`worker-round`, `judge-round`; the attempt-level `worker-result` echoes are not rounds and drafting is not the run's), tool and denied come
+ * from the gate-audit rows scoped to this run (the same figure `tools:` shows). No tool log saved says so, never a zero.
+ * @param {any[]} records the run's raw spine @param {{totalCalls: number, denied: number}|null} behaviour
+ * @returns {string}
+ */
+export function callsLineOf(records, behaviour) {
+  const model = records.filter((r) => r && (r.type === 'worker-round' || r.type === 'judge-round')).length;
+  return behaviour
+    ? `${model} model · ${behaviour.totalCalls} tool · ${behaviour.denied} denied`
+    : `${model} model · tool calls: no log saved`;
+}
+
+/** "1-5", "2", "1-2, 4" from try numbers @param {number[]} ns */
+function tryRanges(ns) {
+  const out = [];
+  for (let i = 0; i < ns.length; i += 1) {
+    let j = i;
+    while (j + 1 < ns.length && ns[j + 1] === ns[j] + 1) j += 1;
+    out.push(j > i ? `${ns[i]}-${ns[j]}` : String(ns[i]));
+    i = j;
+  }
+  return out.join(', ');
+}
+
+/**
+ * "16 run · 8 passed · 8 failed (write-flight-facts tries 1-5, then tries 1-3)" — counts of what ran, never a fraction (the "checks N/M"
+ * headline stays withdrawn). Every `exit-eval` result plus every graded `outer-close` stage; the parenthesis names the steps and try ranges
+ * that failed, from the same `tries[]` the Audit reads. A run with neither says `not recorded`.
+ * @param {any[]} records the run's raw spine @param {any[]|null|undefined} parts the enriched parts
+ * @returns {string}
+ */
+export function checksLineOf(records, parts) {
+  let run = 0;
+  let passed = 0;
+  let outerFailed = false;
+  for (const r of records) {
+    if (!r) continue;
+    if (r.type === 'exit-eval' && Array.isArray(r.results)) {
+      for (const x of r.results) { run += 1; if (x && x.pass === true) passed += 1; }
+    } else if (r.type === 'outer-close' && Array.isArray(r.stages)) {
+      for (const x of r.stages) { run += 1; if (x && x.verdict === 'satisfied') passed += 1; else outerFailed = true; }
+    }
+  }
+  if (run === 0) return 'not recorded';
+  /** @type {string[]} */
+  const named = [];
+  /** @type {Set<string>} */
+  const seenLabel = new Set();
+  for (const p of parts ?? []) {
+    if (p.kind !== 'step' || !Array.isArray(p.tries)) continue;
+    const bad = p.tries.filter((/** @type {any} */ t) => t.failed > 0).map((/** @type {any} */ t) => t.n);
+    if (bad.length === 0) continue;
+    const text = `tries ${tryRanges(bad)}`;
+    named.push(seenLabel.has(p.label) ? `then ${text}` : `${p.label} ${text}`);
+    seenLabel.add(p.label);
+  }
+  if (outerFailed) named.push('the outer close');
+  const failed = run - passed;
+  return `${run} run · ${passed} passed · ${failed} failed${named.length ? ` (${named.join(', ')})` : ''}`;
+}
+
+/** 1 -> "1st", 4 -> "4th", 12 -> "12th" @param {number} n */
+function ordinal(n) {
+  const v = n % 100;
+  if (v >= 11 && v <= 13) return `${n}th`;
+  return `${n}${({ 1: 'st', 2: 'nd', 3: 'rd' })[/** @type {1|2|3} */ (n % 10)] ?? 'th'}`;
+}
+
+/**
+ * The step card's extra line (PRD v1.106 Part 5 G): "5 tries · last try: 1 check passed, 1 failed", with the cut-off try named when there is one
+ * ("4 tries (the 4th cut off before its checks ran) · last try: no checks ran"). Words for what passed and failed, never a fraction. `null`
+ * when the step has no graded try (an old spine).
+ * @param {Array<{n: number, cutOff: boolean, passed: number, failed: number, ran: number}>} tries
+ * @returns {string|null}
+ */
+export function triesLineOf(tries) {
+  if (!Array.isArray(tries) || tries.length === 0) return null;
+  const last = tries[tries.length - 1];
+  const count = `${tries.length} ${tries.length === 1 ? 'try' : 'tries'}${last.cutOff ? ` (the ${ordinal(last.n)} ${CUT_OFF_WORDS})` : ''}`;
+  const checks = (/** @type {number} */ n) => `${n} ${n === 1 ? 'check' : 'checks'}`;
+  let lastWords;
+  if (last.cutOff || last.ran === 0) lastWords = 'no checks ran';
+  else if (last.failed === 0) lastWords = `${checks(last.passed)} passed`;
+  else if (last.passed === 0) lastWords = `${checks(last.failed)} failed`;
+  else lastWords = `${checks(last.passed)} passed, ${last.failed} failed`;
+  return `${count} · last try: ${lastWords}`;
+}
+
+/** tool kinds in the order the Audit tally lists them; anything else follows alphabetically */
+const TALLY_ORDER = ['read', 'grep', 'write', 'edit'];
+
+/**
+ * "tools: read 16 · grep 22 · write 5 · denied 0" — the step's tool calls by kind, then how many the gate denied (PRD v1.106 Part 5 C). The
+ * `shell_`/`ctx_` prefixes are stripped like the rest of the page. `null` when no tool log was saved (nothing honest to count).
+ * @param {Record<string, number>|null|undefined} byTool @param {number|null|undefined} blocked
+ * @returns {string|null}
+ */
+export function toolsTallyLine(byTool, blocked) {
+  if (!byTool || typeof byTool !== 'object') return null;
+  const named = Object.entries(byTool).map(([k, n]) => [k.replace(/^shell_/, '').replace(/^ctx_/, ''), n]);
+  named.sort((a, b) => {
+    const ia = TALLY_ORDER.indexOf(String(a[0]));
+    const ib = TALLY_ORDER.indexOf(String(b[0]));
+    return (ia === -1 ? 99 : ia) - (ib === -1 ? 99 : ib) || String(a[0]).localeCompare(String(b[0]));
+  });
+  return `tools: ${[...named.map(([k, n]) => `${k} ${n}`), `denied ${typeof blocked === 'number' ? blocked : 0}`].join(' · ')}`;
+}
+
+/**
+ * A step's tries in order: each graded try (it ran checks) and, last, the one cut off before its checks ran (D2). `ran` is how many checks ran,
+ * `passed`/`failed` how they went; a cut-off try ran none. The Audit, the step card and the Run summary all read this one list.
+ * @param {any[]} attempts @param {any} cutOffTry
+ * @returns {Array<{words?: string, n: number, cutOff: boolean, outcome: string|null, iteration: number|null, ran: number, passed: number, failed: number, thinking: string|null}>}
+ */
+function triesOf(attempts, cutOffTry) {
+  const graded = (Array.isArray(attempts) ? attempts : []).filter((a) => Array.isArray(a.checks)).map((a) => ({
+    n: a.n,
+    cutOff: false,
+    outcome: a.outcome ?? null,
+    iteration: typeof a.iteration === 'number' ? a.iteration : null,
+    ran: a.checks.length,
+    passed: a.checks.filter((/** @type {any} */ c) => c.pass).length,
+    failed: a.checks.filter((/** @type {any} */ c) => !c.pass).length,
+    thinking: typeof a.thinking === 'string' ? a.thinking : null,
   }));
+  if (!cutOffTry) return graded;
+  return [...graded, {
+    words: CUT_OFF_WORDS, n: graded.length + 1, cutOff: true, outcome: null, iteration: typeof cutOffTry.iteration === 'number' ? cutOffTry.iteration : null, ran: 0, passed: 0, failed: 0, thinking: typeof cutOffTry.thinking === 'string' ? cutOffTry.thinking : null,
+  }];
+}
+
+/** the words for a `check-passes` result that no `check-run` named (an old spine), and the one tree-changed question, both code-owned here */
+const FILES_CHANGED_QUESTION = 'did it change any file?';
+
+/**
+ * A rule line's failing reasons, one per `close: <stage>: …` line of a check's detail, each with that prefix (and the `line N: ` the check row
+ * already names) removed. A detail with no `close:` lines is one reason: its own first line.
+ * @param {string|null|undefined} detail
+ * @returns {string[]}
+ */
+function reasonsOf(detail) {
+  if (typeof detail !== 'string' || detail.trim() === '') return [];
+  const lines = detail.split('\n').map((l) => l.trim()).filter((l) => l !== '');
+  const closeLines = lines.filter((l) => l.startsWith('close: '));
+  if (closeLines.length === 0) return [lines[0]];
+  return closeLines.map((l) => l.replace(/^close: [^:]+: /, '').replace(/^line \d+: /, ''));
+}
+
+/**
+ * The try line's gap: the first failing reason, and how many more there are (PRD v1.106 Part 5 C). ONE function, beside {@link stageQuestionText}.
+ * @param {string|null|undefined} detail
+ * @returns {{ line: string, more: number }|null}
+ */
+export function gapOneLine(detail) {
+  const reasons = reasonsOf(detail);
+  return reasons.length === 0 ? null : { line: reasons[0], more: reasons.length - 1 };
+}
+
+/**
+ * "from line 1 ~ under $450; not a red-eye" — the job line(s) a check serves and the `~` rules written under them (the signed `jobLines`).
+ * `null` when the stage serves no job line (a mandatory guard).
+ * @param {number[]} fromLine @param {any} spec
+ * @returns {string|null}
+ */
+export function fromLineText(fromLine, spec) {
+  if (!Array.isArray(fromLine) || fromLine.length === 0) return null;
+  const lines = Array.isArray(spec?.jobLines) ? spec.jobLines : [];
+  return fromLine.map((n) => {
+    const rule = lines.find((l) => l && l.n === n)?.rule;
+    return `from line ${n}` + (typeof rule === 'string' && rule !== '' ? ` ~ ${rule}` : '');
+  }).join(' · ');
+}
+
+/**
+ * One try's checks in the order they RAN (choice 6), worded: `{n, type, name, question, pass, detail, gap, more, reasons, from}`.
+ * A `tree-changed` result is the declared `files-changed` stage; a `check-passes` result is the stage its `check-run` named.
+ * @param {Array<{type: string, pass: boolean, detail: string|null, name: string|null}>} checks
+ * @param {Map<string, any>|null} kindMeta @param {any} spec
+ */
+function tryChecksOf(checks, kindMeta, spec) {
+  const metas = kindMeta ? [...kindMeta] : [];
+  const filesChanged = metas.find(([, m]) => m.kind === 'files-changed') ?? null;
+  const others = metas.filter(([, m]) => m.kind !== 'files-changed');
+  return checks.map((c, i) => {
+    let name = c.name;
+    let meta = name && kindMeta ? kindMeta.get(name) ?? null : null;
+    if (c.type === 'tree-changed' && filesChanged) { name = filesChanged[0]; meta = filesChanged[1]; }
+    if (c.type === 'check-passes' && !meta && others.length === 1) { name = others[0][0]; meta = others[0][1]; }
+    const reasons = c.pass ? [] : reasonsOf(c.detail);
+    const gap = c.pass ? null : gapOneLine(c.detail);
+    return {
+      n: i + 1,
+      type: c.type,
+      name: name ?? c.type,
+      question: c.type === 'tree-changed' ? FILES_CHANGED_QUESTION : (meta?.question ?? null),
+      pass: c.pass,
+      // a files-changed result names its count; a failing check-passes names its reasons (folded on the page), a passing one nothing
+      note: c.type === 'tree-changed' ? c.detail : (c.pass ? null : `${reasons.length} reason${reasons.length === 1 ? '' : 's'}`),
+      gap: gap ? gap.line : null,
+      more: gap ? gap.more : 0,
+      moreText: gap && gap.more > 0 ? `(+${gap.more} more)` : null,
+      reasonsLabel: reasons.length > 1 ? `the ${reasons.length} reasons` : null,
+      reasons,
+      from: meta ? fromLineText(meta.fromLine, spec) : null,
+    };
+  });
+}
+
+/**
+ * "output judged: output/steps/1.json · 2.1 KB · sha256 674b…30" — the file a try's check read (PRD v1.106 Part 5 choice 14). ONE place owns
+ * these words. `size` is bytes under 1 KB, else KB with one decimal; the hash shows its first 4 and last 2 characters.
+ * @param {{path: string|null, bytes: number|null, sha256: string|null}} o
+ * @returns {string}
+ */
+export function judgedFileLine(o) {
+  const size = typeof o.bytes === 'number' ? (o.bytes < 1024 ? `${o.bytes} B` : `${(o.bytes / 1024).toFixed(1)} KB`) : null;
+  const sha = typeof o.sha256 === 'string' && o.sha256.length >= 8 ? `sha256 ${o.sha256.slice(0, 4)}…${o.sha256.slice(-2)}` : null;
+  return ['output judged:', [o.path ?? 'a file', size, sha].filter(Boolean).join(' · ')].join(' ');
+}
+
+/** a worded check as the `{name, verdict, question}` stage shape the attempt headline reads */
+function stageOfCheck(c) {
+  return { name: c.name, verdict: c.pass ? 'satisfied' : 'needs_revision', question: c.question };
 }
 
 /**
@@ -2185,10 +3223,50 @@ function jobsDir() {
  * from the resolved SPEC only (a) (b) (c) — a job-start record and `none()`
  * carry no close/writeScope/tools at all, so those stay `'not recorded'`.
  * @param {string} runid
- * @param {{ home?: string }} [opts]
+ * @param {{ home?: string, schedules?: ReturnType<typeof createScheduleDoor> }} [opts]
  * @returns {any|null}
  */
 export function getRunJob(runid, opts = {}) {
+  const body = withThinkingRow(getRunJobBody(runid, opts), runid, opts);
+  if (!body || !opts.schedules) return body;
+  try {
+    const door = /** @type {ReturnType<typeof createScheduleDoor>} */ (opts.schedules);
+    const { rows } = readRunList(opts);
+    const row = rows.find((r) => r && r.runid === runid);
+    const job = row ? row.job : body.job;
+    const nos = runNumbers(rows);
+    const cur = door.readSchedule(job);
+    const started = startedWords(row ? triggerRecordOf(row) : null, row ? atMs(row) : null);
+    const spec = cur ? cur.spec : null;
+    const schedule = jobScheduleWords({
+      trigger: cur ? cur.trigger : null, originNo: cur ? (nos.get(cur.originRunid) ?? null) : null,
+      model: spec && typeof spec.model === 'string' ? spec.model : null,
+      destination: cur ? (typeof cur.destination === 'string' && cur.destination !== '' ? cur.destination : (Array.isArray(spec?.writeScope) ? spec.writeScope.join(', ') : null)) : null,
+      home: door.userHome,
+    });
+    return { ...body, started, schedule };
+  } catch { return body; }
+}
+
+/**
+ * PRD v1.106 Part 3 — the Job tab's `Thinking` row, worded by src/thinking.js and ALWAYS present (hamr 2026-10-18). The rule shown is
+ * the job's signed "Thinking on" tick for a run whose spine recorded thinking decisions, `—` for a run from before the thinking rule; a tick that cannot be read counts as not ticked (the default), never an empty row.
+ * @param {any|null} body the Job tab body @param {string} runid @param {{ home?: string }} opts
+ * @returns {any|null}
+ */
+function withThinkingRow(body, runid, opts) {
+  if (!body) return body;
+  const { thinkingTick, ...rest } = body;
+  let recorded = false;
+  try {
+    const row = findRunRow(runid, opts);
+    recorded = !!row && existsSync(row.spine) && parseJsonl(row.spine).records.some((/** @type {any} */ r) => r?.type === 'thinking-decision');
+  } catch { /* an unreadable spine has no records: the row reads — */ }
+  return { ...rest, thinking: thinkingJobText(thinkingTick === true, recorded) };
+}
+
+/** @param {string} runid @param {{ home?: string }} opts */
+function getRunJobBody(runid, opts) {
   const row = findRunRow(runid, opts);
   if (!row) return null;
 
@@ -2262,6 +3340,7 @@ export function getRunJob(runid, opts = {}) {
     guardrails: notRecorded(guardrailsFromSpec(spec)),
     tools: notRecorded(toolsFromSpec(spec)),
     toolsList: toolsListFromSpec(spec),
+    thinkingTick: spec.thinking === true,
     note,
   });
   const none = () => ({
@@ -2283,6 +3362,7 @@ export function getRunJob(runid, opts = {}) {
     guardrails: 'not recorded',
     tools: 'not recorded',
     toolsList: null,
+    thinkingTick: false,
     note: 'no resolvable spec for this run (only bareloop-run bundle-layout runs carry one; a run-u run has none on disk)',
   });
 
@@ -2497,14 +3577,14 @@ export function reuseLine(record) {
 
 /**
  * `start-from` (the route keeps its name) for one listed run: the card prefilled from the run's SIGNED job, which
- * boxes are locked and which are open, and the track record. Locked boxes carry the signed values, read by the
+ * the track record (v1.101: nothing is locked, every box is open). The job boxes carry the signed values, read by the
  * SAME readers the Job tab uses (`successFromSpec`/`guardrailsFromSpec`); the open four — Source, Destination, the
  * $ cap and the Time cap — start at what the run had. `ok:false` when the run's signed job is not on disk (nothing
  * to copy: change the job: Clear the card). `null` when the runid is not listed.
  * @param {string} runid
  * @param {{ home?: string, model?: string, provider?: string }} [opts] `model` = the Model box's current Name (the estimate counts only runs on that worker); absent = the card's own Model
  * @returns {{ok: true, origin: {runid: string, job: string}, outcome: string|null, card: Record<string, any>, from: 'signed job',
- *   locked: readonly string[], open: readonly string[], note: string|null,
+ *   note: string|null,
  *   specHash: string, workflowKey: string, spec: any, specPath: string, specNamesModel: boolean,
  *   specWorker: {provider: string, endpoint: string, label: string},
  *   trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
@@ -2537,6 +3617,9 @@ export function getStartFrom(runid, opts = {}) {
     source: typeof saved.source === 'string' && saved.source ? saved.source : (typeof manifest?.source === 'string' ? manifest.source : (typeof row.patient === 'string' ? row.patient : '')),
     // a card saved by P7 or later keeps the Inputs text the person typed
     inputs: typeof saved.inputs === 'string' && saved.inputs ? saved.inputs : '',
+    // a plain-files job delivers to an absolute folder the SPEC does not hold (its fence is `output/` inside the run's tree): the
+    // Destination opens with the folder the origin run was given, never with that fence
+    destination: [saved.destination, manifest?.destination].find((d) => typeof d === 'string' && /^(\/|[a-zA-Z]:[\\/])/.test(d)) ?? '',
     jobName: row.job,
   });
   const key = workflowKey(spec);
@@ -2544,12 +3627,14 @@ export function getStartFrom(runid, opts = {}) {
   return {
     ok: true,
     origin: { runid, job: row.job },
-    // the run's terminal outcome — the Reuse start (POST /api/author/start) refuses anything but a real green
-    outcome: legsOf(records).at(-1)?.outcome ?? null,
+    // the run's terminal outcome — the Reuse start (POST /api/author/start) reuses a green or already-green run only.
+    // T D.2: a SCHEDULED run's green reads `green-held` until the person accepts it, so that same refusal holds it unchanged
+    outcome: (() => {
+      const o = legsOf(records).at(-1)?.outcome ?? null;
+      return o === 'green' && heldScheduled(records, triggerRecordOf(row)) ? 'green-held' : o;
+    })(),
     card,
     from: 'signed job',
-    locked: REUSE_LOCKED_FIELDS,
-    open: REUSE_OPEN_FIELDS,
     note: Array.isArray(spec.jobLines) && spec.jobLines.length ? null : 'older job — numbered lines were not saved',
     specHash: signed.specHash,
     workflowKey: key,
@@ -2568,6 +3653,29 @@ export function getStartFrom(runid, opts = {}) {
   };
 }
 
+/**
+ * T Part 3: a job's listed runs, newest first, each with its signed spec (null when not on disk), its terminal outcome and
+ * its parsed spine. The schedule door's gate (`greenFor`) reads this; nothing here builds a run context.
+ * @param {string} job
+ * @param {{ home?: string }} [opts]
+ * @returns {{runid: string, outcome: string|null, spec: any, records: any[]}[]}
+ */
+export function jobRunsOf(job, opts = {}) {
+  const { rows } = readRunList(opts);
+  /** @type {{runid: string, outcome: string|null, spec: any, records: any[]}[]} */
+  const out = [];
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    const row = rows[i];
+    if (!row || row.job !== job || !existsSync(row.spine)) continue;
+    let records;
+    try { records = parseJsonl(row.spine).records; } catch { continue; }
+    const outcome = legsOf(records).at(-1)?.outcome ?? null;
+    // T D.2: a scheduled run's green is HELD until accepted, so it is not a good run for the schedule gate either
+    out.push({ runid: row.runid, outcome: outcome === 'green' && heldScheduled(records, triggerRecordOf(row)) ? 'green-held' : outcome, spec: signedSpecForRun(row, records)?.spec ?? null, records });
+  }
+  return out;
+}
+
 /**
  * The Reuse workflow picker's list: one entry per JOB (same-job identity = `workflowKey`, the one `getStartFrom` uses)
  * that has at least one GREEN local run, newest green first. `runid` = that job's newest green run, so the page hands
@@ -2587,9 +3695,9 @@ export function listReuseJobs(opts = {}) {
     let records;
     try { records = parseJsonl(row.spine).records; } catch { continue; }
     const outcome = legsOf(records).at(-1)?.outcome ?? null;
-    // only a REAL green (hamr 2026-10-08): `already-green` means the check passed before any work, so there is nothing to reuse
-    // (src/reuse.js 'green-predates-run'). Narrower than the Run tab's Reuse button on purpose.
-    if (outcome !== 'green') continue;
+    // a real green or an already-green (hamr 2026-10-15: if it is already fixed and nothing is to be done, it is green and can be reused)
+    if (outcome !== 'green' && outcome !== 'already-green') continue;
+    if (heldScheduled(records, triggerRecordOf(row))) continue; // T D.2: a scheduled green waits for the person's Accept
     const signed = signedSpecForRun(row, records);
     if (!signed) continue;
     const key = workflowKey(signed.spec);
@@ -2606,7 +3714,7 @@ export function listReuseJobs(opts = {}) {
  * The reuse card for a signed spec: locked boxes from the spec through the Job tab's own readers, open boxes from
  * the spec's own fence and caps (Source and the saved text from the caller — a spec carries neither).
  * @param {any} spec
- * @param {{model: string, source: string, inputs?: string, jobName: string}} extra `inputs` = the Inputs text the person saved (else built from the spec's inputs, else `repo: <source>`)
+ * @param {{model: string, source: string, inputs?: string, jobName: string, destination?: string}} extra `destination` = an absolute per-run folder (a plain-files job), else the spec's fence; `inputs` = the Inputs text the person saved (else built from the spec's inputs, else `repo: <source>`)
  * @returns {Record<string, any>}
  */
 function reuseCardFromSpec(spec, extra) {
@@ -2616,8 +3724,9 @@ function reuseCardFromSpec(spec, extra) {
     checkType: spec.verdictType === 'soft-green' ? 'rubric' : 'deterministic',
     model: typeof spec.model === 'string' && spec.model && !extra.model ? spec.model : extra.model,
     jobText: jobTextFromSpec(spec),
+    thinking: spec.thinking === true,
     inputs: extra.inputs || inputsTextFromSpec(spec, extra.source),
-    destination: writeScope.join(', '),
+    destination: extra.destination || writeScope.join(', '),
     capUsd: typeof spec.budgetUsd === 'number' ? spec.budgetUsd : null,
     maxWallMs: typeof spec.maxWallMs === 'number' ? spec.maxWallMs : undefined,
   };
@@ -2656,7 +3765,7 @@ function describeSpec(spec) {
  * @param {string} id
  * @param {{ home?: string, model?: string, provider?: string }} [opts] `model` as for {@link getStartFrom}
  * @returns {{ok: true, origin: {runid: null, job: string, importId: string}, card: Record<string, any>, from: 'imported job',
- *   locked: readonly string[], open: readonly string[], note: string|null, specHash: string, workflowKey: string, spec: any,
+ *   note: string|null, specHash: string, workflowKey: string, spec: any,
  *   specPath: null, trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
  */
 export function getStartFromImport(id, opts = {}) {
@@ -2682,8 +3791,6 @@ export function getStartFromImport(id, opts = {}) {
     origin: { runid: null, job: row.job, importId: id },
     card,
     from: 'imported job',
-    locked: REUSE_LOCKED_FIELDS,
-    open: REUSE_OPEN_FIELDS,
     note: 'a Source is needed — an exported job carries none; it is checked and signed on this machine',
     specHash: jobSpecHash(spec),
     workflowKey: key,
@@ -2723,7 +3830,7 @@ function sendText(res, code, text) {
  * only `createPanelServer` below always supplies one.
  * @param {import('node:http').IncomingMessage} req
  * @param {import('node:http').ServerResponse} res
- * @param {{ home?: string, packageJsonPath?: string, port: number, token?: string, authorRoutes?: ReturnType<typeof createAuthorRoutes>, settingsRoutes?: ReturnType<typeof createSettingsRoutes>, runRoutes?: ReturnType<typeof createRunRoutes>, importRoutes?: ReturnType<typeof createImportRoutes> }} opts
+ * @param {{ home?: string, sessionsRoot?: string, packageJsonPath?: string, port: number, token?: string, authorRoutes?: ReturnType<typeof createAuthorRoutes>, settingsRoutes?: ReturnType<typeof createSettingsRoutes>, runRoutes?: ReturnType<typeof createRunRoutes>, importRoutes?: ReturnType<typeof createImportRoutes>, schedules?: ReturnType<typeof createScheduleDoor> }} opts
  */
 export function handleRequest(req, res, opts) {
   /** the ONE writable route family for a path, or null — `/api/author/*` (authoring) or
@@ -2732,7 +3839,7 @@ export function handleRequest(req, res, opts) {
   function routesFor(o, p) {
     if (o.authorRoutes && p.startsWith('/api/author')) return o.authorRoutes;
     if (o.settingsRoutes && p.startsWith('/api/settings')) return o.settingsRoutes;
-    if (o.runRoutes && /^\/api\/runs\/[^/]+\/(resume|stop)$/.test(p)) return o.runRoutes;
+    if (o.runRoutes && /^\/api\/runs\/[^/]+\/(resume|stop|accept|rerun|pause|needs-remove)$/.test(p)) return o.runRoutes;
     if (o.importRoutes && (p === '/api/fs/list' || p === '/api/imports' || p.startsWith('/api/imports/'))) return o.importRoutes;
     return null;
   }
@@ -2837,9 +3944,9 @@ export function handleRequest(req, res, opts) {
     return;
   }
 
-  if (pathname === '/api/runs') { send(200, { runs: listRuns({ home: opts.home }) }); return; }
+  if (pathname === '/api/runs') { send(200, runsListPayload({ home: opts.home, schedules: opts.schedules })); return; }
 
-  const runMatch = /^\/api\/runs\/([^/]+)(\/(audit|job|rounds))?$/.exec(pathname);
+  const runMatch = /^\/api\/runs\/([^/]+)(\/(audit|job|rounds|result|download))?$/.exec(pathname);
   if (runMatch) {
     const rawRunid = runMatch[1];
     const sub = runMatch[3] ?? null;
@@ -2856,15 +3963,36 @@ export function handleRequest(req, res, opts) {
       return;
     }
     if (sub === 'job') {
-      const result = getRunJob(runid, { home: opts.home });
+      const result = getRunJob(runid, { home: opts.home, schedules: opts.schedules });
       if (!result) { sendText(res, 404, 'no such run'); return; }
       send(200, result);
       return;
     }
+    if (sub === 'result') {
+      const result = getRunResult(runid, { home: opts.home, sessionsRoot: opts.sessionsRoot });
+      if (!result) { sendText(res, 404, 'no such run, or it has no result tab'); return; }
+      send(200, result);
+      return;
+    }
+    if (sub === 'download') {
+      const got = getRunDownload(runid, url.searchParams.get('i'), { home: opts.home });
+      if (!got.ok) { sendText(res, got.code, got.error); return; }
+      // the name is the delivered file's own basename; quotes and control characters never reach the header
+      const plain = got.name.replace(/[^A-Za-z0-9._-]/g, '_');
+      res.writeHead(200, {
+        'content-type': `${got.type}; charset=utf-8`,
+        'content-length': got.buf.length,
+        'content-disposition': `attachment; filename="${plain}"; filename*=UTF-8''${encodeURIComponent(got.name)}`,
+        'x-content-type-options': 'nosniff',
+      });
+      if (method === 'HEAD') res.end(); else res.end(got.buf);
+      return;
+    }
     if (sub === 'rounds') {
       /** @param {string|null} v @returns {number|undefined} */
       const num = (v) => (v !== null && /^\d+$/.test(v) ? Number(v) : undefined);
       const query = {
+        all: url.searchParams.get('all') === '1',
         part: num(url.searchParams.get('part')),
         attempt: num(url.searchParams.get('attempt')),
         offset: num(url.searchParams.get('offset')),
@@ -2875,7 +4003,7 @@ export function handleRequest(req, res, opts) {
       send(200, result);
       return;
     }
-    const result = getRunDetail(runid, { home: opts.home });
+    const result = getRunDetail(runid, { home: opts.home, schedules: opts.schedules });
     if (!result) { sendText(res, 404, 'no such run'); return; }
     send(200, result);
     return;
@@ -2903,8 +4031,9 @@ export function handleRequest(req, res, opts) {
  * @param {{ port?: number, home?: string, env?: Record<string,string|undefined>,
  *   sessionsRoot?: string, spawnFn?: (...a: any[]) => any, bareloopBin?: string,
  *   fetchImpl?: typeof fetch, settleMs?: number, userHome?: string,
- *   openFolderSpawn?: (cmd: string, args: string[], o: object) => any, platform?: string, packageJsonPath?: string }} [opts]
- * @returns {Promise<{ server: import('node:http').Server, port: number, token: string, close: () => Promise<void> }>}
+ *   openFolderSpawn?: (cmd: string, args: string[], o: object) => any, platform?: string, packageJsonPath?: string,
+ *   scheduleNow?: () => number, sessionDeps?: Record<string, any>, schedulerIntervalMs?: number, acceptWaitMs?: number }} [opts] `scheduleNow`, `sessionDeps` and `schedulerIntervalMs` are TEST SEAMS (the schedule clock; createSession's stubs; the scheduler's timer, 0 = none)
+ * @returns {Promise<{ server: import('node:http').Server, port: number, token: string, schedules: ReturnType<typeof createScheduleDoor>, scheduler: ReturnType<typeof createScheduler>, close: () => Promise<void> }>}
  */
 export function createPanelServer(opts = {}) {
   const requestedPort = opts.port ?? DEFAULT_PORT;
@@ -2925,10 +4054,14 @@ export function createPanelServer(opts = {}) {
     let runRoutes;
     /** @type {ReturnType<typeof createImportRoutes>|undefined} */
     let importRoutes;
+    /** @type {ReturnType<typeof createScheduler>|undefined} */
+    let scheduler;
+    /** @type {ReturnType<typeof createScheduleDoor>|undefined} */
+    let schedulesRef;
     const server = createServer((req, res) => {
       try {
         handleRequest(req, res, {
-          home, port: boundPort, token, authorRoutes, settingsRoutes, runRoutes, importRoutes, packageJsonPath: opts.packageJsonPath,
+          home, sessionsRoot: opts.sessionsRoot, port: boundPort, token, authorRoutes, settingsRoutes, runRoutes, importRoutes, packageJsonPath: opts.packageJsonPath, schedules: schedulesRef,
         });
       } catch (e) {
         sendText(res, 500, `internal error: ${/** @type {Error} */ (e).message}`);
@@ -2942,7 +4075,22 @@ export function createPanelServer(opts = {}) {
     server.listen(requestedPort, '127.0.0.1', () => {
       const addr = server.address();
       boundPort = typeof addr === 'object' && addr !== null ? addr.port : requestedPort;
+      const rowsFor = () => rowsForHome(keysHome(home), keysForDoor({ env: opts.env, keysHome: home }).env);
+      const schedules = createScheduleDoor({
+        home,
+        ...(opts.userHome ? { userHome: opts.userHome } : {}),
+        ...(opts.scheduleNow ? { now: opts.scheduleNow } : {}),
+        sessionsRoot: opts.sessionsRoot,
+        jobRuns: (job) => jobRunsOf(job, { home }),
+        startFrom: (runid) => getStartFrom(runid, { home }),
+        jobOfRun: (runid) => readRunList({ home }).rows.find((r) => r && r.runid === runid)?.job ?? null,
+        rowsFor,
+      });
+      schedulesRef = schedules;
       authorRoutes = createAuthorRoutes({
+        schedules,
+        runJobNames: () => readRunList({ home }).rows.flatMap((r) => (r && typeof r.job === 'string' ? [r.job] : [])),
+        ...(opts.sessionDeps ? { sessionDeps: opts.sessionDeps } : {}),
         port: boundPort,
         token,
         env: opts.env,
@@ -2957,6 +4105,18 @@ export function createPanelServer(opts = {}) {
           listJobs: (o = {}) => listReuseJobs({ home, ...o }),
         },
       });
+      schedules.attachStarter(createStarter({
+        door: schedules, startSession: authorRoutes.startSession, envNow: authorRoutes.envNow, spawnFn: authorRoutes.spawnFn,
+        bareloopBin: authorRoutes.bareloopBin, sessionsRoot: opts.sessionsRoot, home, rowsFor, startFrom: (runid) => getStartFrom(runid, { home }),
+        forgetSession: authorRoutes.forgetHeadless,
+        ...(opts.scheduleNow ? { now: opts.scheduleNow } : {}), // the SAME clock the scheduler reads, so lateMs and startedAt agree with the slot
+        ranSince: (job, sinceMs) => readRunList({ home }).rows.some((r) => r && r.job === job && Date.parse(r.at) >= sinceMs - 1000),
+      }));
+      // T Part 5: the scheduler runs the clock and the folder watch while THIS server is up (panel only, T6); stopped on close
+      scheduler = createScheduler({
+        door: schedules, ...(opts.scheduleNow ? { now: opts.scheduleNow } : {}), ...(opts.schedulerIntervalMs !== undefined ? { intervalMs: opts.schedulerIntervalMs } : {}),
+      });
+      scheduler.start();
       settingsRoutes = createSettingsRoutes({
         port: boundPort, token, home, env: opts.env, fetchImpl: opts.fetchImpl,
         openFolderSpawn: opts.openFolderSpawn, platform: opts.platform,
@@ -2971,6 +4131,10 @@ export function createPanelServer(opts = {}) {
         settleMs: opts.settleMs,
         getResumeContext: (runid) => getResumeContext(runid, { home }),
         getStopContext: (runid) => getStopContext(runid, { home }),
+        getAcceptContext: (runid) => getAcceptContext(runid, { home }),
+        stageQuestionsOfSpec,
+        getNeedsContext: (runid) => getNeedsContext(runid, { home }),
+        ...(opts.acceptWaitMs !== undefined ? { acceptWaitMs: opts.acceptWaitMs } : {}),
       });
       importRoutes = createImportRoutes({
         port: boundPort, token, home, userHome: opts.userHome, describeSpec,
@@ -2979,7 +4143,9 @@ export function createPanelServer(opts = {}) {
         server,
         port: boundPort,
         token,
-        close: () => new Promise((res2) => { server.close(() => res2(undefined)); }),
+        schedules,
+        scheduler: /** @type {ReturnType<typeof createScheduler>} */ (scheduler),
+        close: () => new Promise((res2) => { scheduler?.stop(); server.close(() => res2(undefined)); }),
       });
     });
   });