bareloop 0.36.0 → 0.38.0

package/src/panel/server.js

@@ -53,7 +53,7 @@ import { rowsForHome, findRow, modelChoiceFor } from '../providerrows.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, GOAL_MET_LINE } from './status.js';
+import { statusFor, partStatusFor, GOAL_MET_LINE } from './status.js';
 import { createSettingsRoutes } from './settingsroutes.js';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -74,7 +74,7 @@ export const RUNID_RE = /^[A-Za-z0-9._~-]+$/;
 export const DEFAULT_PORT = 4700;
 
 /**
- * `[✓]`/`[✗]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
+ * `[✓]`/`[✗]`/`[■]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
  * (auto-memory `ui-verdict-words.md`: never the words green/red/soft-green
  * anywhere in the page). `null` (no `job-end` reached — a killed-mid-run or
  * still-running spine) reads `▶` — the same "in progress / unresolved" glyph
@@ -82,10 +82,10 @@ export const DEFAULT_PORT = 4700;
  * running attempt and an archived spine that never reached its own end are
  * the same fact from this read-only side: no verdict has been recorded yet.
  * @param {string|null} outcome
- * @returns {'✓'|'✗'|'▶'}
+ * @returns {'✓'|'✗'|'■'|'▶'}
  */
 export function glyphForOutcome(outcome) {
-  return /** @type {'✓'|'✗'|'▶'} */ (statusFor({ outcome }).sign);
+  return /** @type {'✓'|'✗'|'■'|'▶'} */ (statusFor({ outcome }).sign);
 }
 
 /**
@@ -417,7 +417,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 = endedBase(summary, death, o);
+  const base = withEditAction(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
@@ -432,21 +432,31 @@ export function endedFor(summary, death, o = {}) {
   return wt.exists ? { ...base, next: `${base.next} Your work is in ${wt.folder}.` } : base;
 }
 
+/**
+ * "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.
+ * @param {{reason: string, next: string, line: string, actions: {id: string, label: string}[]}|null} ended
+ */
+function withEditAction(ended) {
+  if (!ended || ended.actions.some((a) => a.id === 'reuse')) return ended;
+  return { ...ended, actions: [...ended.actions, { id: 'edit', label: 'Edit in chat' }] };
+}
+
 /** @param {any} summary @param {any} death @param {any} o */
 function endedBase(summary, death, o) {
   const resumeOk = !!(o.resume && o.resume.ok);
   /** @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: Clear the card and draft a new one" instead. */
+   *  run, never a rerun. Offered on GREEN rows only; every red row says "Change the job: press Edit in chat" instead. */
   const REUSE = [{ id: 'reuse', label: 'Reuse workflow' }];
-  const CHANGE = 'Change the job: Clear the card and draft a new one.';
+  const CHANGE = 'Change the job: press Edit in chat.';
   const detailOf = (/** @type {string|null} */ s) => {
     if (typeof s !== 'string' || s.length === 0) return '';
     return s.length > 120 ? `${s.slice(0, 120)}…` : s;
   };
   /** a resumable ending whose Resume the engine would refuse: say so, never offer the button */
-  const resumeOr = (/** @type {string} */ okNext) => (resumeOk ? okNext : `Resume is not available for this run${o.resume && o.resume.why ? ` (${o.resume.why})` : ''}.`);
+  const resumeOr = (/** @type {string} */ okNext) => (resumeOk ? okNext : `Resume is not available for this run${o.resume && o.resume.why ? ` (${o.resume.why})` : ''}. ${CHANGE}`);
 
   if (death.died) {
     return {
@@ -497,13 +507,20 @@ 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
+      const earned = outcome === 'green';
       return {
         reason: 'Goal met, but the output could not be delivered.',
-        next: 'Fix the destination, then Reuse workflow.',
+        next: earned ? 'Fix the destination, then Reuse workflow.' : CHANGE,
         line: `${GOAL_MET_LINE} — not delivered`,
-        actions: REUSE,
+        actions: earned ? REUSE : [],
       };
     }
+    // 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
+    // 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 };
   }
   if (outcome === 'cap-halt') {
@@ -545,7 +562,7 @@ function endedBase(summary, death, o) {
   if (outcome === 'step-stalled') {
     return {
       reason: 'A step stopped making progress.',
-      next: resumeOr('Resume, or change the job: Clear the card and draft a new one.'),
+      next: resumeOr('Resume, or change the job: press Edit in chat.'),
       line: resumeOk ? 'step stalled — resume' : 'step stalled',
       actions: resumeOk ? RESUME : [],
     };
@@ -897,7 +914,7 @@ function getRunDetailBody(runid, opts) {
   const timelineKind = summary.timelineKind;
   // 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 = draftingPartHere ? 1 : 0;
+  const draftingShiftHere = draftingShift(row, summary, opts);
   const enrichedParts = enrichPartsWithStageKind(summary.parts, stageKindMetaFromSpec(resolveSpecForRow(row)));
   const death = deriveDeath(row, rawSpineRecords, summary.outcome);
   const { ended, resume, status } = endedForRow(row, rawSpineRecords, summary, death, true);
@@ -1117,7 +1134,9 @@ function getRunDetailBody(runid, opts) {
     // {@link enrichPartsWithStageKind}. `kindMeta` is `null` (every stage
     // passes through unchanged) whenever no spec resolves at all, so the two
     // tabs still never disagree about order/counts/blocked-call figures.
-    parts: draftingPartHere && Array.isArray(enrichedParts) ? [draftingPartHere, ...enrichedParts] : enrichedParts,
+    // a run that DIED (no job-end, runner gone — `death`, decided once above) leaves its last part in flight: that part reads
+    // `died`, never the "happened, so passed" default. Replay alone cannot tell died from still running, so the verdict lives here.
+    parts: (draftingPartHere && Array.isArray(enrichedParts) ? [draftingPartHere, ...enrichedParts] : enrichedParts)?.map((p, i, all) => ({ ...p, status: partStatusFor(death.died && i === all.length - 1 && p.kind !== 'drafting' && p.outcome == null && !p.stopReason ? { ...p, stopReason: 'died' } : p) })),
     replans: summary.replans,
     close: summary.close,
     branch: summary.branch,
@@ -2406,7 +2425,7 @@ export function reuseLine(record) {
  * to copy: change the job: Clear the card). `null` when the runid is not listed.
  * @param {string} runid
  * @param {{ home?: string, model?: 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}, card: Record<string, any>, from: 'signed job',
+ * @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,
  *   specHash: string, workflowKey: string, spec: any, specPath: string,
  *   trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
@@ -2445,6 +2464,8 @@ 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,
     card,
     from: 'signed job',
     locked: REUSE_LOCKED_FIELDS,
@@ -2459,6 +2480,40 @@ export function getStartFrom(runid, opts = {}) {
   };
 }
 
+/**
+ * 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
+ * it to the existing start-from flow unchanged; `line` is `getStartFrom`'s own estimate line (never a second
+ * spelling). Local runs only — an imported job keeps its Reuse button in the Import view. $0, read-only.
+ * @param {{ home?: string, model?: string }} [opts] `model` passes through to the estimate line, as start-from's does
+ * @returns {{job: string, runid: string, checkType: 'deterministic'|'rubric', line: string}[]}
+ */
+export function listReuseJobs(opts = {}) {
+  const { rows } = readRunList(opts);
+  const seen = new Set();
+  /** @type {{job: string, runid: string, checkType: 'deterministic'|'rubric', line: string}[]} */
+  const jobs = [];
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    const row = rows[i];
+    if (!row || !existsSync(row.spine)) continue;
+    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;
+    const signed = signedSpecForRun(row, records);
+    if (!signed) continue;
+    const key = workflowKey(signed.spec);
+    if (seen.has(key)) continue;
+    const pre = getStartFrom(row.runid, opts);
+    if (!pre || !pre.ok) continue;
+    seen.add(key);
+    jobs.push({ job: pre.card.jobName, runid: row.runid, checkType: pre.card.checkType === 'rubric' ? 'rubric' : 'deterministic', line: pre.line });
+  }
+  return jobs;
+}
+
 /**
  * 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).
@@ -2636,7 +2691,15 @@ export function handleRequest(req, res, opts) {
         /** @type {any} */
         let body = null;
         if (raw.length > 0) { try { body = JSON.parse(raw); } catch { body = null; } }
-        routes.handle(req, res, pathname, body);
+        // this callback runs OUTSIDE createServer's try/catch (which covers only the synchronous GET path), so a
+        // synchronous throw in a route handler (a full disk, a permission fault) would be an uncaught exception that
+        // takes the whole panel down: answer 500 JSON instead and keep serving
+        try {
+          routes.handle(req, res, pathname, body);
+        } catch (e) {
+          if (res.headersSent) { res.end(); return; }
+          sendJson(res, 500, { ok: false, error: `internal error: ${/** @type {Error} */ (e)?.message ?? String(e)}` });
+        }
       });
       return;
     }
@@ -2801,6 +2864,7 @@ export function createPanelServer(opts = {}) {
         startFrom: {
           get: (runid, o = {}) => getStartFrom(runid, { home, ...o }),
           getImport: (id, o = {}) => getStartFromImport(id, { home, ...o }),
+          listJobs: (o = {}) => listReuseJobs({ home, ...o }),
         },
       });
       settingsRoutes = createSettingsRoutes({

package/src/panel/status.js

@@ -2,7 +2,7 @@
 // hamr's ruling 2026-10-04 (option A): every surface (run cards, expanded run rows, the right-side header, imported
 // rows) reads `status` from the server; the page never maps an outcome to a word itself.
 //
-//   [▶] running · [·] waiting · [✓] passed · [✗] failed · [✗] capped · [✗] stopped · [?] died
+//   [▶] running · [·] waiting · [✓] passed · [✗] failed · [✗] capped · [■] stopped · [?] died
 //
 // Outcome -> word (every outcome the panel knows; anything not listed is `failed`):
 //   green, already-green, satisfied                      -> passed
@@ -15,6 +15,8 @@
 //   and every other outcome (refusals, instrument stops)  -> failed
 // `waiting` is the step-level sign for a step that has not started; no run outcome maps to it.
 
+import { capKindOf } from '../legs.js';
+
 /** the sentence a passed run carries as its reason (the Ended block's `line`) */
 export const GOAL_MET_LINE = 'goal met';
 
@@ -27,7 +29,7 @@ export const STATUS = Object.freeze({
   passed: Object.freeze({ sign: '✓', word: 'passed' }),
   failed: Object.freeze({ sign: '✗', word: 'failed' }),
   capped: Object.freeze({ sign: '✗', word: 'capped' }),
-  stopped: Object.freeze({ sign: '✗', word: 'stopped' }),
+  stopped: Object.freeze({ sign: '■', word: 'stopped' }),
   died: Object.freeze({ sign: '?', word: 'died' }),
 });
 
@@ -44,8 +46,29 @@ export function statusFor(o) {
   if (o.died) key = 'died';
   else if (out === null || out === undefined) key = 'running';
   else if (out === 'green' || out === 'already-green' || out === 'satisfied') key = 'passed';
-  else if (out === 'cap-halt' || out === 'wall-halt') key = 'capped';
+  else if (capKindOf(o) !== null) key = 'capped';
   else if (out === 'stopped') key = 'stopped';
-  else if (out === 'escalated' && ((o.category === 'cap-halt' && o.moneyHalt) || o.category === 'wall-halt')) key = 'capped';
   return { key, ...STATUS[key] };
 }
+
+/**
+ * The word one PART of a run wears on the step map, the step cards and the Audit rows (hamr 2026-10-07: `[✓] passed` /
+ * `[✗] failed`, never "done"). Reads the same table; `running` is the page's call (it knows which part is live), so a
+ * part with no verdict and no cut-off is `passed` here.
+ *   drafting, green/satisfied/already-green outcome, or a part that simply happened (scout/plan/replan/judge) -> passed
+ *   a red outcome -> its run-outcome word (failed; a cap/stop outcome keeps capped/stopped)
+ *   a part its leg's halt cut off (`stopReason`): 'money cap' / 'time cap' -> capped, 'you stopped it' -> stopped,
+ *     'died' -> died, anything else (provider failed, step stalled, a raw outcome) -> failed
+ * @param {{kind?: string, outcome?: string|null, stopReason?: string|null}} part
+ * @returns {{key: StatusKey, sign: string, word: string}}
+ */
+export function partStatusFor(part) {
+  if (part.kind === 'drafting') return statusFor({ outcome: 'green' });
+  if (typeof part.outcome === 'string') return statusFor({ outcome: part.outcome });
+  const why = part.stopReason;
+  if (why) {
+    const key = why === 'money cap' || why === 'time cap' ? 'capped' : why === 'you stopped it' ? 'stopped' : why === 'died' ? 'died' : 'failed';
+    return { key, ...STATUS[key] };
+  }
+  return statusFor({ outcome: 'green' });
+}

package/src/planrun.js

@@ -970,10 +970,10 @@ ${scoutBlob || '(no scout notes)'}`;
  *   the resume-plan-red option, the fix-loop terminal) say "resume is `run-u`-only
  *   in v1" instead of naming a flag that would fail if typed.
  * @param {string|null} [opts.stopFile=null] P5 item 5 — the run's STOP REQUEST file
- *   (`stopFilePath(spine)`, src/legs.js). Read at ONE seam, the round boundary of a step worker
- *   (the `metered` callback, where the money cap binds): present = emit `stop-requested`, consume
+ *   (`stopFilePath(spine)`, src/legs.js). Read at ONE seam, the round boundary of EVERY worker
+ *   (scout, plan/replan drafter, step, close-fix: the `metered` callback, where the money cap binds): present = emit `stop-requested`, consume
  *   the file, end the Loop after that round, and end the leg `stopped` (a checkpoint outcome, filed
- *   the way a mid-step cap-halt is; resume re-enters that step). Nothing is in flight at that
+ *   the way a mid-step cap-halt is; resume re-enters that step, or continues the phase). Nothing is in flight at that
  *   point, so the spend is exact. `null` = no stop surface (the default).
  * @returns {Promise<string>} 'green' | 'already-green' | 'escalated' | 'plan-red' |
  *   'check-red' | 'close-red' | 'close-unsupported' | 'recipe-stale' | 'pricing-red' |
@@ -2745,11 +2745,12 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
           // (nothing in flight, the round just metered). It is the ONE owner of the stop request. The file is
           // consumed here; `self.stop()` ends the Loop after this round exactly as a bound does; `ask`/`askFrom`
           // then throw category `stopped`, which the step loop files as the checkpoint outcome `stopped` the way a
-          // mid-step cap-halt is filed. Step workers only (scout/plan/fix never read it).
-          if (stopFile !== null && !stopHit && phase.startsWith('step:') && existsSync(stopFile)) {
+          // mid-step cap-halt is filed. EVERY phase that runs rounds reads it here (scout, plan/replan drafter, step,
+          // close-fix) — the one seam the money cap binds at; `relay` files the non-ralph phases' throw as `stopped`.
+          if (stopFile !== null && !stopHit && existsSync(stopFile)) {
             try { unlinkSync(stopFile); } catch { /* already consumed */ }
             stopHit = true;
-            emit('stop-requested', { phase, step: phase.slice('step:'.length), iteration: roundIteration, round: roundsThisAttempt, meaning: 'the person asked to stop; the leg ends after this round and a resume re-enters this step' });
+            emit('stop-requested', { phase, ...(phase.startsWith('step:') ? { step: phase.slice('step:'.length) } : {}), iteration: roundIteration, round: roundsThisAttempt, meaning: 'the person asked to stop; the leg ends after this round and a resume continues the run' });
             self.stop();
           } else if (clock.expired()) {
             attemptBounded = { iteration: roundIteration, cause: 'wall', reason: null };
@@ -2903,6 +2904,8 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // instead and every such fault came back `provider-red` — a broken runner
       // reported as the provider's fault, and an upstream ask aimed at a library
       // for our own missing wiring (the step-stalled lesson).
+      // P5 item 5 — the PERSON's stop, honoured at a round boundary outside a step (scout, plan drafting, replan): nothing failed
+      'stopped': [`You stopped the run during ${phase}. Nothing is discarded: the work on disk stands, and a resume continues the run.`, ['resume (the same run continues)', 'abandon the task']],
       'interpreter-red': [`The ${phase} phase could not be set up — the runner or a primitive it was handed is not correctly bound.`, ['fix the wiring the detail names', 'retry the run', 'abandon the run']],
     };
     const [decision, options] = (Object.hasOwn(DECIDE, category) ? DECIDE[category] : undefined)
@@ -2914,7 +2917,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     // `step-stalled` rides out as ITSELF, not as provider-red. Naming the
     // escalation while returning a casualty label would launder a governance stop
     // into transport noise at exactly the layer the readout reads.
-    return category === 'cap-halt' || category === 'wall-halt' || category === 'step-stalled' || category === 'interpreter-red'
+    return category === 'cap-halt' || category === 'wall-halt' || category === 'step-stalled' || category === 'interpreter-red' || category === 'stopped'
       ? category : 'provider-red';
   };
 
@@ -4105,7 +4108,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // is not passed — it survives only inside the governor, as the bound for the
       // case the trend instrument is blind.
       middle, judge: async () => judgeClose(), ladder: fixGovernor, emit: emitL, redact: scrub,
-      closeTimeoutMs, cwd: workdir, workerWrites: w.workerWrites, closeDir,
+      closeTimeoutMs, cwd: workdir, workerWrites: w.workerWrites, closeDir, phase: 'fix',
     });
   } catch (e) {
     planExecuted();

package/src/ralph.js

@@ -562,9 +562,13 @@ export const CLOSE_FAULTS = Object.freeze({
  *   (PRD item 27/M3 Part B), forwarded to the raw `close` path's `runClose`
  *   call unchanged; a caller supplying `judge` instead already closed over
  *   its own `closeDir` and this param does nothing for it.
+ * @param {string} [opts.phase] the phase this loop runs in, when it is not the step loop
+ *   (the fix loop passes `'fix'`): the person's-stop text then names it ("during the fix
+ *   phase") instead of saying a resume re-enters "this step", which only the step loop has.
+ *   Text only — it changes no category, outcome or option.
  * @returns {Promise<'green'|'escalated'>}
  */
-export async function ralph({ middle, close, judge, capRuns, ladder, emit, redact, closeTimeoutMs, cwd, expect, judged, gapKeep, workerWrites, closeDir }) {
+export async function ralph({ middle, close, judge, capRuns, ladder, emit, redact, closeTimeoutMs, cwd, expect, judged, gapKeep, workerWrites, closeDir, phase }) {
   // PARAM GUARD (the BA-4 class — a caller's malformed argument, which is the one
   // thing this shell throws for; a WORKER's bad reach comes back as a refusal
   // RESULT instead, and that rule is about feedback, not about the API contract).
@@ -654,7 +658,9 @@ export async function ralph({ middle, close, judge, capRuns, ladder, emit, redac
             'revise the goal/spec so the work fits the time (same re-approval)',
             'abandon the task']],
         // P5 item 5 — the PERSON asked to stop at a round boundary: nothing failed, nothing is discarded.
-        'stopped': ['You stopped the run. Nothing is discarded: the work on disk stands, and a resume re-enters this step.',
+        'stopped': [phase
+          ? `You stopped the run during the ${phase} phase. Nothing is discarded: the work on disk stands, and a resume continues the run.`
+          : 'You stopped the run. Nothing is discarded: the work on disk stands, and a resume re-enters this step.',
           ['resume (the same run continues)', 'abandon the task']],
         // F66 — the STALL WATCHDOG gave up: no round completed for the stall window,
         // three times over, and reissuing the call did not recover it. It borrows both

package/src/replay.js

@@ -104,7 +104,7 @@
 import { runBehaviour, formatBehaviour } from './behaviour.js';
 import { shortSha } from './codeversion.js';
 import { SPEND_RECORD_TYPES, chainSpend } from './ledger.js';
-import { legsOf } from './legs.js';
+import { legsOf, capKindOf } from './legs.js';
 
 /**
  * @param {unknown} e
@@ -234,6 +234,16 @@ const ALL_REASON_MAX = 60;
  * record fired) — printed literally, never blank, never a fabricated 0. */
 const NONE_RECORDED = 'none recorded';
 
+/**
+ * Did this leg end on a cap? Reads the leg's own last escalation and `money-halt` record.
+ * @param {import('./legs.js').Leg} leg
+ * @returns {'money'|'time'|null}
+ */
+function legCapKind(leg) {
+  const esc = leg.outcome === 'escalated' ? leg.records.findLast((r) => r && r.type === 'escalation') : null;
+  return capKindOf({ outcome: leg.outcome, category: esc?.category ?? null, moneyHalt: leg.records.some((r) => r && r.type === 'money-halt') });
+}
+
 /**
  * `stopReason` for a non-green outcome: `category — decision — detail`, every
  * part present that the escalation actually carries (see the field-site
@@ -737,11 +747,21 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
     // why this leg stopped the step (code-owned words); null for a step that ended itself or is still running
     /** @type {string|null} */
     let stopReason = null;
+    // a single-leg run has no leg boundary to cut a step, but a cap still ends it: its open step reads capped too
+    // (hamr 2026-10-08), from the same rule (`capKindOf`) the run's own status word uses
+    if (!end && myLeg === null) {
+      const only = legs[0];
+      const capKind = only ? legCapKind(only) : null;
+      if (capKind !== null) stopReason = capKind === 'money' ? 'money cap' : 'time cap';
+    }
     if (!end && myLeg !== null) {
       const o = myLeg.outcome;
       const isLastLeg = myLegIdx === legs.length - 1;
       if (cutByLeg || (isLastLeg && o !== null && o !== 'green' && o !== 'already-green')) {
-        stopReason = o === 'cap-halt' ? 'money cap' : o === 'wall-halt' ? 'time cap' : o === 'provider-red' ? 'provider failed'
+        // hamr 2026-10-08: a leg that ended `escalated` on a money-halt / wall-halt reads as the cap, exactly as the
+        // run's own status word does (src/panel/status.js statusFor) — derived HERE so every surface follows
+        const capKind = legCapKind(myLeg);
+        stopReason = capKind === 'money' ? 'money cap' : capKind === 'time' ? 'time cap' : o === 'provider-red' ? 'provider failed'
           : o === 'step-stalled' ? 'step stalled' : o === 'stopped' ? 'you stopped it' : o === null ? 'died' : o;
       }
     }
@@ -832,7 +852,7 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
     return {
       id,
       occurrence: idOccurrence.get(id),
-      ...(myLeg === null ? {} : { stopReason, continued, tryNumber }),
+      ...(myLeg === null && stopReason === null ? {} : { stopReason, continued, tryNumber }),
       outcome: end ? (end.outcome ?? null) : null,
       ...buildOccurrenceMetrics(startSeq, startTs, endSeq, endTs, roundsInWindow),
       checks: { passed, failed },

package/src/source.js

@@ -1148,3 +1148,15 @@ export function frontDoorFromManifest(read) {
   if (typeof destination !== 'string' || !destination) return null;
   return { destination };
 }
+
+/**
+ * The $0 refusal for a non-repo source, worded by the kind the source door recorded (`prep.manifest.kind`) — a single
+ * file is not a "folder", and Source must be the repo folder with the file named in Destination (hamr 2026-10-05).
+ * @param {string} kind `prep.manifest.kind`: 'file' | 'folder' | 'url' (a 'repo' never reaches this)
+ * @returns {string}
+ */
+export function nonRepoSourceMessage(kind) {
+  if (kind === 'file') return 'Source is a single file. Source must be the repo folder — put the file in Destination, like src/digest.js. Nothing spent.';
+  if (kind === 'folder') return "Source is a plain folder, not a code project (no git repo found). bareloop can't check this kind of job yet. Nothing spent.";
+  return "Source is not a code project (no git repo found). bareloop can't check this kind of job yet. Nothing spent.";
+}

package/types/legs.d.ts

@@ -56,6 +56,18 @@ export function watchdogNotePath(spineFile: string, leg: number): string;
  * @returns {string}
  */
 export function stopFilePath(spineFile: string): string;
+/**
+ * Did a run (or one leg) END on a cap? The ONE spelling of the rule every surface follows (hamr 2026-10-08): the
+ * outcome is `cap-halt` / `wall-halt`, or it is `escalated` and the last escalation's category names the cap —
+ * `wall-halt`, or `cap-halt` backed by a `money-halt` record (a strike-ladder `cap-halt` is not the money cap).
+ * @param {{outcome: string|null|undefined, category?: string|null, moneyHalt?: boolean}} o
+ * @returns {'money'|'time'|null}
+ */
+export function capKindOf(o: {
+    outcome: string | null | undefined;
+    category?: string | null;
+    moneyHalt?: boolean;
+}): "money" | "time" | null;
 /** The marker record's `type`. */
 export const LEG_RESUME: "leg-resume";
 export type Leg = {

package/types/panel/authorroutes.d.ts

@@ -41,7 +41,7 @@ export function checkHumanGuard(req: import("node:http").IncomingMessage, { toke
  * @param {{ port: number, token: string, env?: Record<string,string|undefined>,
  *   sessionsRoot?: string, spawnFn?: typeof realSpawn, bareloopBin?: string,
  *   jobsDir?: string, fetchImpl?: typeof fetch, home?: string,
- *   startFrom?: {get: (runid: string, o?: {model?: string}) => any, getImport: (id: string, o?: {model?: string}) => any} }} opts
+ *   startFrom?: {get: (runid: string, o?: {model?: string}) => any, getImport: (id: string, o?: {model?: string}) => any, listJobs?: (o?: {model?: string}) => any[]} }} opts
  */
 export function createAuthorRoutes(opts: {
     port: number;
@@ -60,6 +60,9 @@ export function createAuthorRoutes(opts: {
         getImport: (id: string, o?: {
             model?: string;
         }) => any;
+        listJobs?: (o?: {
+            model?: string;
+        }) => any[];
     };
 }): {
     handle: (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, pathname: string, body: any) => boolean;

package/types/panel/authorsession.d.ts

@@ -67,13 +67,6 @@ export function validateReuseCard(card: any, opts?: {
     ok: false;
     error: string;
 };
-/**
- * The $0 refusal for a non-repo source, worded by the kind the source door recorded (`prep.manifest.kind`) — a single
- * file is not a "folder", and Source must be the repo folder with the file named in Destination (hamr 2026-10-05).
- * @param {string} kind `prep.manifest.kind`: 'file' | 'folder' | 'url' (a 'repo' never reaches this)
- * @returns {string}
- */
-export function nonRepoSourceMessage(kind: string): string;
 /**
  * The ONE Destination rule for a REPO source (fresh card and Reuse card alike): there Destination is the write fence,
  * relative to the repo, so an absolute path is refused — at $0, before any copy or model call. A FOLDER source (or a
@@ -153,9 +146,11 @@ export const CARD_FIELDS: readonly string[];
 export const REUSE_OPEN_FIELDS: readonly string[];
 /** every card field that is NOT open on a reuse card, in card order */
 export const REUSE_LOCKED_FIELDS: readonly string[];
+export { nonRepoSourceMessage };
 export type StepLine = {
     id: string;
     label: string;
     status: "running" | "done" | "failed";
     detail: string;
 };
+import { nonRepoSourceMessage } from '../source.js';

package/types/panel/server.d.ts

@@ -1,5 +1,5 @@
 /**
- * `[✓]`/`[✗]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
+ * `[✓]`/`[✗]`/`[■]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
  * (auto-memory `ui-verdict-words.md`: never the words green/red/soft-green
  * anywhere in the page). `null` (no `job-end` reached — a killed-mid-run or
  * still-running spine) reads `▶` — the same "in progress / unresolved" glyph
@@ -7,9 +7,9 @@
  * running attempt and an archived spine that never reached its own end are
  * the same fact from this read-only side: no verdict has been recorded yet.
  * @param {string|null} outcome
- * @returns {'✓'|'✗'|'▶'}
+ * @returns {'✓'|'✗'|'■'|'▶'}
  */
-export function glyphForOutcome(outcome: string | null): "\u2713" | "\u2717" | "\u25B6";
+export function glyphForOutcome(outcome: string | null): "\u2713" | "\u2717" | "\u25A0" | "\u25B6";
 /**
  * `deterministic` (green) / `rubric` (soft-green) / `unknown` (a class this
  * reader doesn't recognize) — the settled UI wording (PANEL-BUILD.md §6),
@@ -381,7 +381,7 @@ export function reuseLine(record: {
  * to copy: change the job: Clear the card). `null` when the runid is not listed.
  * @param {string} runid
  * @param {{ home?: string, model?: 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}, card: Record<string, any>, from: 'signed job',
+ * @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,
  *   specHash: string, workflowKey: string, spec: any, specPath: string,
  *   trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
@@ -395,6 +395,7 @@ export function getStartFrom(runid: string, opts?: {
         runid: string;
         job: string;
     };
+    outcome: string | null;
     card: Record<string, any>;
     from: "signed job";
     locked: readonly string[];
@@ -410,6 +411,23 @@ export function getStartFrom(runid: string, opts?: {
     ok: false;
     error: string;
 } | null;
+/**
+ * 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
+ * it to the existing start-from flow unchanged; `line` is `getStartFrom`'s own estimate line (never a second
+ * spelling). Local runs only — an imported job keeps its Reuse button in the Import view. $0, read-only.
+ * @param {{ home?: string, model?: string }} [opts] `model` passes through to the estimate line, as start-from's does
+ * @returns {{job: string, runid: string, checkType: 'deterministic'|'rubric', line: string}[]}
+ */
+export function listReuseJobs(opts?: {
+    home?: string;
+    model?: string;
+}): {
+    job: string;
+    runid: string;
+    checkType: "deterministic" | "rubric";
+    line: string;
+}[];
 /**
  * Reuse workflow, for an IMPORTED job: the bundle is read AGAIN now and must be clean (`readBundle` — its own hash
  * covers every close script, so a swapped script is `bundle-tampered` here), must resolve its own `bareloop`

package/types/panel/status.d.ts

@@ -14,6 +14,26 @@ export function statusFor(o: {
     sign: string;
     word: string;
 };
+/**
+ * The word one PART of a run wears on the step map, the step cards and the Audit rows (hamr 2026-10-07: `[✓] passed` /
+ * `[✗] failed`, never "done"). Reads the same table; `running` is the page's call (it knows which part is live), so a
+ * part with no verdict and no cut-off is `passed` here.
+ *   drafting, green/satisfied/already-green outcome, or a part that simply happened (scout/plan/replan/judge) -> passed
+ *   a red outcome -> its run-outcome word (failed; a cap/stop outcome keeps capped/stopped)
+ *   a part its leg's halt cut off (`stopReason`): 'money cap' / 'time cap' -> capped, 'you stopped it' -> stopped,
+ *     'died' -> died, anything else (provider failed, step stalled, a raw outcome) -> failed
+ * @param {{kind?: string, outcome?: string|null, stopReason?: string|null}} part
+ * @returns {{key: StatusKey, sign: string, word: string}}
+ */
+export function partStatusFor(part: {
+    kind?: string;
+    outcome?: string | null;
+    stopReason?: string | null;
+}): {
+    key: StatusKey;
+    sign: string;
+    word: string;
+};
 /** the sentence a passed run carries as its reason (the Ended block's `line`) */
 export const GOAL_MET_LINE: "goal met";
 /** @typedef {'running'|'waiting'|'passed'|'failed'|'capped'|'stopped'|'died'} StatusKey */
@@ -40,7 +60,7 @@ export const STATUS: Readonly<{
         word: "capped";
     }>;
     stopped: Readonly<{
-        sign: "✗";
+        sign: "■";
         word: "stopped";
     }>;
     died: Readonly<{

package/types/planrun.d.ts

@@ -397,10 +397,10 @@ export function planPrompt(job: any, scoutBlob: string, reds: any[] | null, maxS
  *   the resume-plan-red option, the fix-loop terminal) say "resume is `run-u`-only
  *   in v1" instead of naming a flag that would fail if typed.
  * @param {string|null} [opts.stopFile=null] P5 item 5 — the run's STOP REQUEST file
- *   (`stopFilePath(spine)`, src/legs.js). Read at ONE seam, the round boundary of a step worker
- *   (the `metered` callback, where the money cap binds): present = emit `stop-requested`, consume
+ *   (`stopFilePath(spine)`, src/legs.js). Read at ONE seam, the round boundary of EVERY worker
+ *   (scout, plan/replan drafter, step, close-fix: the `metered` callback, where the money cap binds): present = emit `stop-requested`, consume
  *   the file, end the Loop after that round, and end the leg `stopped` (a checkpoint outcome, filed
- *   the way a mid-step cap-halt is; resume re-enters that step). Nothing is in flight at that
+ *   the way a mid-step cap-halt is; resume re-enters that step, or continues the phase). Nothing is in flight at that
  *   point, so the spend is exact. `null` = no stop surface (the default).
  * @returns {Promise<string>} 'green' | 'already-green' | 'escalated' | 'plan-red' |
  *   'check-red' | 'close-red' | 'close-unsupported' | 'recipe-stale' | 'pricing-red' |

package/types/ralph.d.ts

@@ -242,9 +242,13 @@ export function boundGap(s: string, keepPattern?: string): string;
  *   (PRD item 27/M3 Part B), forwarded to the raw `close` path's `runClose`
  *   call unchanged; a caller supplying `judge` instead already closed over
  *   its own `closeDir` and this param does nothing for it.
+ * @param {string} [opts.phase] the phase this loop runs in, when it is not the step loop
+ *   (the fix loop passes `'fix'`): the person's-stop text then names it ("during the fix
+ *   phase") instead of saying a resume re-enters "this step", which only the step loop has.
+ *   Text only — it changes no category, outcome or option.
  * @returns {Promise<'green'|'escalated'>}
  */
-export function ralph({ middle, close, judge, capRuns, ladder, emit, redact, closeTimeoutMs, cwd, expect, judged, gapKeep, workerWrites, closeDir }: {
+export function ralph({ middle, close, judge, capRuns, ladder, emit, redact, closeTimeoutMs, cwd, expect, judged, gapKeep, workerWrites, closeDir, phase }: {
     middle: (iteration: number, gap?: string) => void | Promise<void>;
     close?: string[] | undefined;
     judge?: (() => Promise<{
@@ -270,6 +274,7 @@ export function ralph({ middle, close, judge, capRuns, ladder, emit, redact, clo
     gapKeep?: string | undefined;
     workerWrites?: (() => string[]) | undefined;
     closeDir?: string | null | undefined;
+    phase?: string | undefined;
 }): Promise<"green" | "escalated">;
 /**
  * What the close child must NOT be able to read (operator ruling, 2026-07-31: