bareloop 0.36.0 → 0.37.0

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to bareloop are documented here. Format:
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning:
 [SemVer](https://semver.org/spec/v2.0.0.html). Pre-1.0: **minor** = a ladder rung or
 feature lands, **patch** = docs, fixes, scaffolding.
+## [0.37.0] - 2026-10-07
+
+### Added
+
+- **Reuse workflow picker.** The panel's Check type is one radio group of three, the third being Reuse workflow: a search list of jobs that have a green local run. Picking one goes through the existing reuse door (change and leave-reuse included); the Start button is gated on a pick. The origin line is retired. Backed by `GET /api/author/reuse-jobs`, one entry per job with its newest green run id and the same estimate line "Start from this" shows.
+
+### Fixed
+
+- **Stop is honoured at every round seam.** The stop request was read only in step rounds; the scout, plan and close-fix rounds ignored it while the page said "stopping". It is now read at each of them (found on run mup3h70u).
+- A throwing panel POST handler answers a 500 JSON error instead of killing the panel.
+- Settings: a price row with exactly one of the two boxes filled saves nothing in that row and says "Fill both price boxes or clear both."
+- A died run's in-flight part on the Run map reads `[?] died`, not passed.
+- Panel status wording comes from the one status table: a step box reads `[sign] word` (passed / failed / capped / stopped / died), never "done"; step cards and Audit rows show the word only (the attempt glyph is their sign).
+- The drafting progress line reads "drafting (retry N of M)" on a drafting call after the first.
+- The CLI `run-author` non-repo refusal uses the same message as the panel (`nonRepoSourceMessage`, now in `src/source.js`).
+- A `tree-changed` close detail on a single-file write scope names the file, not the glob path.
+- The Providers table row's closing `</tr>` is no longer missing.
+
+### Changed
+
+- Refactors with unchanged output: `getRunDetailBody` takes its drafting shift from `draftingShift` (one owner); the dead `orphanCalls` accumulator in `readDraftSteps` is dropped.
+- Tests: page-extraction pins follow the picker; the drafting part is pinned on a running panel-authored run; the resumed already-green worktree path is pinned (it held, no fix needed). Docs: PRD addenda pointer to v1.89; `bareloop.context.md` and docs sweeps.
+
 
 ## [0.36.0] - 2026-10-06
 

package/bareloop.context.md

@@ -1118,7 +1118,8 @@ prefix, F212: a readdir on a file used to read as an empty tree forever). `evalE
 and never short-circuits — the result names EVERY failing wall (`{ pass, results }`,
 each result `{ type, pass, detail?, fault? }`). `tree-changed` reads OUTCOME (bytes vs
 the snapshot): an identical re-write is NOT a change (F43) and git status is never
-consulted (F45). `artifact-written` rejects zero-byte files. `check-passes` delegates
+consulted (F45). A single-file scope's pass detail names the file (`src/x.js changed`); a folder scope keeps
+`N file(s) changed under <scope>`. `artifact-written` rejects zero-byte files. `check-passes` delegates
 through the `runCheck` seam (the runner wires runClose); an unwired or crashed seam
 fails CLOSED with `fault` carrying a runClose verdict name — an instrument fault
 escalates through `CLOSE_FAULTS`, never masquerades as worker feedback. Failing details are
@@ -3386,7 +3387,8 @@ key you want first (the panel picks the row by the Model menu).
   GET/HEAD answers only when its `Host` header is the panel's own `127.0.0.1:<port>` (`checkHostGuard`,
   `src/panel/authorroutes.js`; any other Host is `403`, no token needed to read). Every
   P1 endpoint is GET/HEAD only (anything else — including every write verb — is `405`, outside the
-  two human-click-guarded write families `/api/author/*` and `/api/settings/*` below); a URL
+  two human-click-guarded write families `/api/author/*` and `/api/settings/*` below; a POST handler that throws answers `500
+  {ok:false,error}` and the panel keeps serving); a URL
   never joins a path segment into a filesystem read — a runid is looked up in the run list
   first (`RUNID_RE`, `src/panel/server.js` — accepts a `~2`-style backfill-disambiguated
   suffix too, and every endpoint echoes back the LISTED runid, never a filename-derived one
@@ -3508,6 +3510,14 @@ key you want first (the panel picks the row by the Model menu).
   `job-end` timestamp, null while live or died). `GET /api/imports` rows and `GET /api/imports/:id` carry `runStatus`
   (passed, or null when the bundle shows no green) and `runReason` (`goal met`). The Ended block's lines for died and
   stopped runs are `no ending recorded` and `you pressed Stop` (each `— resume` when Resume is offered).
+  Every PART of a run detail (`parts[]`) also carries its own `status` `{key, sign, word}` from the same table
+  (`partStatusFor`, `src/panel/status.js`): drafting, a green outcome and a part with no verdict and no cut-off → passed; a red
+  outcome → its run-outcome word; a part its leg's halt cut off → capped (money cap / time cap), stopped (you stopped it),
+  died, else failed. A run that DIED (no `job-end`, runner gone) leaves its last part in flight: when that part has no outcome
+  and no cut-off, the server marks it `died` (`[?] died`), never the "happened, so passed" default — replay alone cannot tell
+  died from still running, so `getRunDetail` decides it from the same `death` verdict as the run's status. A live run's open
+  part stays running; a part that finished before the death keeps its own status. The page's map box reads `[sign] word` (the live part reads `[▶] running`); the step cards and Audit rows
+  show the word only; no surface says "done".
   **Resume (item 2)** → `POST /api/runs/:runid/resume` (`src/panel/runroutes.js`), behind
   `checkHumanGuard` (token + own address, like `/api/author/*`); body `{budgetUsd?, maxWallMin?}`
   (blank = the signed caps). `404` unknown run; `409` when `resumePlanFor` says the engine would
@@ -3530,26 +3540,30 @@ key you want first (the panel picks the row by the Model menu).
   spelling), and signals nothing. `404` unknown run; `409` when the run's LATEST leg is not live
   (`runIsAlive`) or its spine does not exist yet (still starting). The ENGINE half is library code, so
   CLI runs honour the file too (no new CLI command): `runJob`/`runPlan` take `stopFile`, and `run-u`/the
-  panel's spawn pass `<spine>.stop`. The seam is the ROUND BOUNDARY of a step worker — where the money cap binds
+  panel's spawn pass `<spine>.stop`. The seam is the ROUND BOUNDARY of EVERY worker (scout, plan/replan drafter, step,
+  close-fix) — where the money cap binds
   (`src/planrun.js`, the `metered` round callback): file present = delete it, emit `stop-requested
-  {phase, step, iteration, round}`, end the Loop after that round; `ask` then throws category `stopped`
-  and the step loop files it as job-end outcome `stopped` the way a mid-step cap-halt is filed
+  {phase, step?, iteration, round}` (`step` only on a step phase), end the Loop after that round; `ask` then throws category `stopped`
+  and the step loop files it as job-end outcome `stopped` the way a mid-step cap-halt is filed (the scout, plan, replan and
+  close-fix phases file it through `relay`, which returns `stopped` as itself, never `provider-red`)
   (`spendComplete` exact — nothing is in flight at a round boundary). One owner, one check: a one-step run
-  and a long step both stop within one turn. Resume re-enters that step. The request file is cleared three times: when honoured, when the
+  and a long step both stop within one turn. Resume re-enters that step, or continues the phase. The request file is cleared three times: when honoured, when the
   leg ends (`finally`), and at the start of the next leg (a click that raced a leg's end never stops a
   resume). `stopped` is in `CHECKPOINT_OUTCOMES`: resumable like a `cap-halt`, the same run continues as a
   new leg at the next step. `GET /api/runs/:runid` carries `live` and `stopping` (a stop request is on
   disk and the leg is live); Ended row `stopped` = "You stopped it." / "Resume." / `[Resume]`, card line
   `stopped — resume`, Audit divider `stopped: you stopped it · resumed <when>`. The page shows `[Stop]`
   in the Run tab's action area while live, "stopping after this turn…" after the click, and the same
-  `[Resume]` there once the engine would accept one. The seam reads the file in STEP workers only
-  (`phase` `step:<id>`): the scout, plan and close-fix rounds never read it, so a Stop clicked while the run
-  is in one of those phases is not honoured until a step round runs again, and is otherwise cleared when
-  the leg ends — the money and time caps still bind throughout.
+  `[Resume]` there once the engine would accept one. A Stop clicked while the run is in the
+  scout, plan or close-fix phase is honoured at that phase's next round boundary, the same as in a step (it used to be read in
+  step workers only).
   **Reuse workflow (replaces P5 item 3's Start from this, 2026-10-03)** — a button on GREEN runs only (the Run tab's
   action row and the Ended block; `ended.actions` carries `{id:'reuse', label:'Reuse workflow'}` on green and
   green-with-destination-refused rows, and on no other: a red row's next line is "Change the job: Clear the card and draft a new one.", and
-  stopped/capped/died rows offer `resume` only) and on every imported job. It opens the Chat tab's New job card
+  stopped/capped/died rows offer `resume` only) and on every imported job; the Chat card's Check type is one radio group of three
+  (Deterministic · Rubric · Reuse workflow), and the third opens a search picker over `GET /api/author/reuse-jobs` (below) that
+  fills the card through this same path (a pick, then `change` returns to the empty search; Deterministic or Rubric leaves reuse).
+  It opens the Chat tab's New job card
   filled from the SIGNED job: a NEW run (new runid), never a rerun, nothing drafted ($0). **Only five boxes are
   open — Source, Destination, Model, $ cap, Time cap**; every other box (check type, model, job name, goal, success,
   guardrails, judge examples) is the signed workflow, greyed, and the SERVER refuses a start that changed one
@@ -3561,7 +3575,10 @@ key you want first (the panel picks the row by the Model menu).
   there is nothing to copy: no log, the run's signed job is not on disk, or an imported job that changed, lost its
   dependency or no longer matches its signed bytes); `POST /api/author/start` accepts `startFrom: <runid>` or
   `startFrom: {importId}` beside the card and answers `{ok, sessionId, reuse, state}`. The old
-  `POST /api/author/start-from-check` and the "Changed — new job" mode are gone. **Identity, two keys:** the
+  `POST /api/author/start-from-check` and the "Changed — new job" mode are gone. `GET /api/author/reuse-jobs[?model=<Name>]` →
+  `{ok, jobs:[{job, runid, checkType:'deterministic'|'rubric', line}]}` is the Chat card's Reuse workflow picker list: one entry per
+  job (same `workflowKey`) with at least one GREEN local run, `runid` = its newest green run (hand it to `start-from`), `line` =
+  start-from's own estimate line, newest green first; imported jobs are not listed. **Identity, two keys:** the
   signature hash `jobSpecHash` is unchanged (it covers the caps and the write fence — what the person signs);
   `workflowKey(spec)` (`src/job.js`, not exported from the package root) is a sha256 over the signed spec WITHOUT
   `source`, `destination`, `writeScope`, `budgetUsd` and `maxWallMs` (`REUSE_OPEN_SPEC_FIELDS`) AND without `provider`,
@@ -3587,7 +3604,8 @@ key you want first (the panel picks the row by the Model menu).
   is still written beside `resolved-spec.json` when a session reaches `prepared`.
   **The progress list (2026-10-04)** — `GET /api/author/:id` state carries `steps: [{id, label, status:
   'running'|'done'|'failed', detail}]`, one entry per pipeline step in first-seen order, updated in place (ids/labels:
-  `STEP_LABELS`, `src/panel/authorsession.js`); `progressLabel` is the running step's label. A refusal sets
+  `STEP_LABELS`, `src/panel/authorsession.js`); `progressLabel` is the running step's label. A drafting call after the first
+  relabels the ONE drafting line `drafting (retry N of M)` (same line, never a second one). A refusal sets
   `state.error` and fails exactly one step with the same text as its `detail`; pipeline text is never a chat message
   (`messages` holds person/model turns only). Two last steps, `hash` ("generating hash", detail `spec hash <full hash>`, done at sign-prepare) and `signed` ("signed hash", pushed by `signRun` when the sign is accepted); the old "SIGNING PREPARED" / "signed — … run starting detached" thread bubbles are gone. The page draws each step's `detail` on its own `> ` line under the step. Destination follows the Source: for a repo source it is the write
   fence (relative `writeScope` globs, never proven as a directory); for a folder source an absolute directory. Both
@@ -3595,7 +3613,7 @@ key you want first (the panel picks the row by the Model menu).
   Destination on a repo source → `Destination must be a path inside the repo, like src/digest.js` (before the
   copy); a source that is not a git repo → a plain refusal worded by the kind the source door recorded (a single
   file: "Source must be the repo folder — put the file in Destination"; a plain folder or a URL: "not a code
-  project (no git repo found)").
+  project (no git repo found)") — `nonRepoSourceMessage` (`src/source.js`), the one spelling the CLI `run-author` uses too.
   **Import, read only (item 4)** — `src/panel/importroutes.js`. The Workflows toolbar's `[Import]` opens a folder
   browser plus a paste box; an imported job is an exported bundle folder the person can LOOK at: nothing runs,
   nothing is signed, the folder is never written. Routes, all behind `checkHumanGuard` (token + own address —
@@ -3858,7 +3876,8 @@ URL** (blank = the shape's own host), **Test**, **Tokens used** (total, display
 (DeepSeek fetched, Anthropic a typed note). Saves on change to `config.json`
 `keys.<ENV NAME> = { name, shape, baseUrl, priceInPerM?, priceOutPerM? }`. The last two columns are the customer's own price
 (**In $/1M**, **Out $/1M**, plain boxes; blank = not set, a number >= 0 otherwise; the server refuses a half-set pair with a plain
-error and saves nothing, and the page leaves a half-typed pair out of the save until both boxes are filled or both cleared).
+error and saves nothing, and the page saves NOTHING in a row with exactly one price box filled, showing "Fill both price boxes
+or clear both." when the person leaves that box, until both boxes are filled or both cleared).
 **Open keys folder** (`POST /api/settings/open-keys-folder`) opens `~/.config/bareloop` in the file manager (`xdg-open` / `open`,
 argv array, never the file itself); where it cannot, the page shows the path as text. Defaults for a key with no saved entry:
 `ANTHROPIC_API_KEY` claude-sonnet-5 / Anthropic; `DEEPSEEK_API_KEY` deepseek-flash /

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bareloop",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "description": "Workflows that earn their own design, with receipts — agent-authored workflows for repeated, long, verifiable jobs that improve across runs under an un-gameable gate.",
   "type": "module",
   "main": "./src/index.js",

package/src/authorrun.js

@@ -124,7 +124,7 @@ import { moveFile } from './movefile.js';
 import { closeJudges, GATE_AUDIT_FILE } from './kinds.js';
 import { resolveProvider, buildRunnerProviders, apiKeyProblem } from './providers.js';
 import { commandFor } from './invoke.js';
-import { readSourceManifest, missingDependencies } from './source.js';
+import { readSourceManifest, missingDependencies, nonRepoSourceMessage } from './source.js';
 import { tallyCalls } from './text.js';
 import {
   declarationLines, rubricLines, calibrationLines, parseCeiling, ceilingLine, crashRecord, phaseLine,
@@ -836,8 +836,7 @@ export async function main(argv, deps = {}) {
   // confirm turn, no model call — a plain folder's spine is exactly
   // `author-start` → `author-end{outcome:'not-authored', stop:'non-code-source'}`.
   if (!IS_REPO_SOURCE) {
-    const message = "This is a plain folder, not a code project. bareloop can't check this kind of "
-      + 'job yet. Nothing was spent. Your source was not changed.';
+    const message = nonRepoSourceMessage(manifestRead.manifest.kind);
     out(`\n${message}`);
     const red = {
       code: 'request-red', path: 'source', verb: 'non-code-source', lib: 'bareloop',

package/src/draftspend.js

@@ -136,8 +136,6 @@ export function readDraftSteps(dir) {
   try { text = readFileSync(join(dir, DRAFT_LOG_FILE), 'utf8'); } catch { return []; }
   /** @type {Map<number, any>} */
   const byNo = new Map();
-  /** @type {any[]} */
-  const orphanCalls = [];
   for (const line of text.split('\n')) {
     if (!line.trim()) continue;
     let ev;
@@ -156,7 +154,7 @@ export function readDraftSteps(dir) {
       x.endedAt = null;
     } else if (ev.kind === 'call') {
       const c = { label: String(ev.label), model: typeof ev.model === 'string' ? ev.model : null, costUsd: typeof ev.costUsd === 'number' ? ev.costUsd : null, unpricedRounds: Number(ev.unpricedRounds) || 0, at: String(ev.at) };
-      (byNo.get(ev.no)?.calls ?? orphanCalls).push(c);
+      byNo.get(ev.no)?.calls.push(c);
     }
   }
   const steps = [...byNo.values()].sort((a, b) => a.no - b.no);

package/src/exits.js

@@ -145,6 +145,9 @@ async function evalOne(e, { dir, snapshot, runCheck }) {
     if (changed === 0) {
       return { type: e.type, pass: false, detail: `0 files changed under ${e.scope} — the tree is byte-identical to the step start (an identical re-write is not a change)` };
     }
+    // a file-valued writeScope (`src/x.js/**`) snapshots that one file keyed by the prefix itself: name the file,
+    // never the glob path that does not exist on disk
+    if (snapshot.has(prefix) || now.has(prefix)) return { type: e.type, pass: true, detail: `${prefix} changed` };
     return { type: e.type, pass: true, detail: `${changed} file(s) changed under ${e.scope}` };
   }
 

package/src/panel/authorroutes.js

@@ -91,7 +91,7 @@ const TERMINAL_PHASES = new Set(['refused', 'abandoned', 'error', 'signed', 'sig
  * @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) {
   // the RAW env with the keys file re-merged on every use, so an edited file takes effect
@@ -217,6 +217,17 @@ export function createAuthorRoutes(opts) {
       return true;
     }
 
+    // The Reuse workflow picker's list: one entry per job with a green local run (newest green's runid + the SAME
+    // estimate line start-from returns). $0, read-only; `?model=` passes through exactly as start-from's does.
+    if (pathname === '/api/author/reuse-jobs') {
+      if (!opts.startFrom || !opts.startFrom.listJobs) { send(404, { ok: false, error: 'not found' }); return true; }
+      if (req.method !== 'GET') { send(405, { ok: false, error: 'GET only' }); return true; }
+      const sp = new URL(/** @type {string} */ (req.url), 'http://127.0.0.1').searchParams;
+      const asModel = sp.has('model') ? { model: sp.get('model') ?? '' } : {};
+      send(200, { ok: true, jobs: opts.startFrom.listJobs(asModel) });
+      return true;
+    }
+
     // A refreshed page re-attaches to the one live (non-terminal) session: its id and state (card, messages, steps),
     // or `null`. The server's session map is the only truth; nothing is stored page-side.
     if (pathname === '/api/author/live') {

package/src/panel/authorsession.js

@@ -27,7 +27,7 @@ import {
 } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import {
-  prepareSource, proveDestination, missingDependencies, looksLikeRepoSource, nearestGitAncestor,
+  prepareSource, proveDestination, missingDependencies, looksLikeRepoSource, nearestGitAncestor, nonRepoSourceMessage,
 } from '../source.js';
 import {
   worktreePath, uncommittedCount, shortHead, removeWorktree,
@@ -258,17 +258,7 @@ export function validateReuseCard(card, opts = {}) {
 /** A Destination written as an absolute path (POSIX or a Windows drive path). @param {string} destination @returns {boolean} */
 const isAbsoluteDestination = (destination) => /^(\/|[a-zA-Z]:[\\/])/.test(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.";
-}
+export { nonRepoSourceMessage };
 
 /**
  * The ONE Destination rule for a REPO source (fresh card and Reuse card alike): there Destination is the write fence,
@@ -491,6 +481,13 @@ export function createSession(card, deps = {}) {
     // person needs to read; the step-by-step detail lives in one line.
     // ONE owner of the drafting line's detail (model + cap): the drafting line is started here, by the real author phase
     if (PHASE_STEP[name]) stepStart(PHASE_STEP[name], PHASE_STEP[name] === 'draft' ? `${card.model}, $${card.capUsd.toFixed(2)} cap` : undefined);
+    // a drafting call after the first (`author-call` i >= 1, of up to `of + 1`) is a RETRY: the line says so in plain words, so a
+    // long silence on call 2 of 3 does not read as a hang. The same one line, relabelled — never a second line.
+    if (name === 'author-call' && Number.isInteger(data.i) && data.i >= 1 && Number.isInteger(data.of)) {
+      const label = `${STEP_LABELS.draft} (retry ${data.i + 1} of ${data.of + 1})`;
+      stepLabel('draft', label);
+      state.progressLabel = label;
+    }
   };
   // ABANDON (hamr's ruling 2026-10-05): once abandoned the phase is frozen at 'abandoned' — whatever the in-flight
   // run() does afterwards (a late refuse, a phase write) never overwrites it, so the one-at-a-time lock stays released.

package/src/panel/index.html

@@ -272,10 +272,21 @@
   .import-view .imp-row{display:flex;gap:10px;flex-wrap:wrap;align-items:baseline;}
   .import-view .imp-label{color:var(--text-faint);font-size:11px;letter-spacing:0.08em;min-width:84px;}
   .import-view .imp-text{flex:1 1 220px;min-width:0;overflow-wrap:anywhere;}
-  .startfrom-line{margin:2px 0 8px;font-size:12px;color:var(--accent);overflow-wrap:anywhere;}
+  .startfrom-line{margin:4px 0 0;font-size:11px;color:var(--text-dim);overflow-wrap:anywhere;}
   .job-card .locked{opacity:.55;cursor:not-allowed;}
-  .job-card.reuse .radio-row label{opacity:.55;cursor:not-allowed;}
-  .startfrom-origin{font-size:12px;font-weight:600;color:var(--text-dim);margin:0 0 4px;padding-right:112px;overflow-wrap:anywhere;}
+  /* Reuse workflow picker (hamr 2026-10-06): the third Check type radio; search box + list, then the picked box */
+  .radio-row label{white-space:nowrap;}
+  .rw-box{position:relative;margin-top:6px;}
+  .rw-box input{width:100%;box-sizing:border-box;}
+  .rw-list{list-style:none;margin:0;padding:0;border:1px solid var(--border-strong);border-top:none;background:var(--bg);max-height:220px;overflow:auto;}
+  .rw-list li{padding:7px 8px;border-bottom:1px dotted var(--border);cursor:pointer;}
+  .rw-list li:hover,.rw-list li.hl{background:var(--panel2);}
+  .rw-name{font-weight:700;overflow-wrap:anywhere;} .rw-name mark{background:none;color:var(--accent);text-decoration:underline;}
+  .rw-meta{font-size:11px;color:var(--text-dim);margin-top:2px;overflow-wrap:anywhere;}
+  .rw-empty{padding:7px 8px;font-size:12px;color:var(--text-dim);}
+  .rw-picked{display:flex;justify-content:space-between;align-items:center;gap:8px;margin-top:6px;padding:6px 8px;border:1px solid var(--accent);}
+  .rw-picked span{overflow-wrap:anywhere;}
+  .rw-picked a{font-size:12px;cursor:pointer;flex:none;}
   .run-actions{display:flex;gap:10px;align-items:center;flex-wrap:wrap;margin-bottom:12px;}
   .run-actions[hidden]{display:none;}
   .run-actions .stopping{color:var(--amber);font-size:13px;overflow-wrap:anywhere;}
@@ -519,10 +530,8 @@
           <!-- hamr 2026-10-05: the empty card is ALWAYS there when Chat opens (no + New). The top-right button reads
                "Abandon" while a session is live and unsigned, else "Clear"; both leave an empty card. -->
           <div class="job-card compact" id="job-card" data-testid="job-card">
-            <div class="startfrom-origin" id="chat-startfrom-origin" data-testid="startfrom-origin" hidden></div>
             <h4 id="job-card-title">Job card — draft</h4>
             <button class="btn card-clear" type="button" id="chat-clear-btn" data-testid="chat-clear">Clear</button>
-            <div class="startfrom-line" id="chat-startfrom-line" data-testid="startfrom-line" hidden></div>
             <div class="hint" id="chat-startfrom-note" data-testid="startfrom-note" hidden></div>
 
             <div class="field">
@@ -530,6 +539,15 @@
               <div class="radio-row" role="radiogroup" aria-labelledby="jf-verdict-label">
                 <label><input type="radio" name="jf-verdict" value="deterministic" checked> Deterministic</label>
                 <label><input type="radio" name="jf-verdict" value="rubric"> Rubric</label>
+                <label><input type="radio" name="jf-verdict" value="reuse" data-testid="jf-verdict-reuse"> Reuse workflow</label>
+              </div>
+              <div id="rw" data-testid="rw" hidden>
+                <div class="rw-box" id="rw-search" data-testid="rw-search">
+                  <input id="rw-q" data-testid="rw-q" type="text" placeholder="type a job name…" autocomplete="off">
+                  <ul class="rw-list" id="rw-list" data-testid="rw-list"></ul>
+                </div>
+                <div class="rw-picked" id="rw-picked" data-testid="rw-picked" hidden><span id="rw-picked-txt" data-testid="rw-picked-txt"></span><a id="rw-change" data-testid="rw-change" role="button" tabindex="0">change</a></div>
+                <div class="startfrom-line" id="chat-startfrom-line" data-testid="startfrom-line" hidden></div>
               </div>
             </div>
             <div class="field">
@@ -955,6 +973,7 @@
     if(part.outcome === "green" || part.outcome === "satisfied" || part.outcome === "already-green") return "done";
     if(typeof part.outcome === "string") return "stopped";
     // P5-R: its leg's halt cut this part off — the map's existing "stopped" state, never "done"
+    if(part.status && part.status.key === "died") return "died";
     if(part.stopReason) return "stopped";
     if(isLastLivePart) return "running";
     return "done"; // scout/plan/replan/judge: no per-part verdict, but the part itself already happened
@@ -993,6 +1012,8 @@
         partIndex: idx,
         title: part.label + occSuffix,
         state: partBoxState(part, isLastLivePart),
+        // the word this box wears: the server's table entry for the part (src/panel/status.js partStatusFor), except the live part, which is running
+        status: isLastLivePart && partBoxState(part, true) === "running" ? {sign:"\u25B6", word:"running"} : (part.status || null),
         noNumber: part.kind !== "step",
         // display-only attempts (map inline text + card/audit result glyph
         // fallback) — [] for a no-verdict part kind even though `part.attempts`
@@ -1007,6 +1028,14 @@
       };
     });
   }
+  // ONE spelling of a part's shown state: `[sign] word` from the server's table; the raw state only when no table entry came
+  function boxStatusWord(box){
+    return box.status && box.status.word ? box.status.word : String(box.state);
+  }
+  // the map box adds the sign; step cards and Audit rows show the word only (an attempt glyph already sits beside them)
+  function boxStatusText(box){
+    return box.status && box.status.word ? "[" + box.status.sign + "] " + boxStatusWord(box) : boxStatusWord(box);
+  }
   function naturalBoxWidth(steps){
     var numIdx = stepNumberIndices(steps);
     var maxChars = 0;
@@ -1107,7 +1136,7 @@
           '" text-anchor="middle" font-size="12" fill="var(--text)">' + escapeXml(lines[1]) + '</text>';
       }
       body += '<text x="' + (x + boxW / 2) + '" y="' + stateY +
-        '" text-anchor="middle" font-size="10" fill="' + colors.textFill + '">' + escapeXml(s.state) + '</text>';
+        '" text-anchor="middle" font-size="10" fill="' + colors.textFill + '">' + escapeXml(boxStatusText(s)) + '</text>';
       // P2 (2026-09-27 ruling): a running box gets the mockup's pulsing
       // amber dot (design/panel-mockup.html ~line 1648) — same fixed color
       // and animation, never re-derived from the state's own stroke color.
@@ -2360,8 +2389,9 @@
   var stopAsked = {};
   // Reuse workflow (replaces P5 item 3's Start from this) — ask the server for the prefill (the signed job), then
   // hand it to the Chat tab's New job card. The page decides nothing: the server owns what is locked and what is open.
-  function reuseWorkflow(runid){
-    authorGet("/api/author/start-from?runid=" + encodeURIComponent(runid)).then(function(r){
+  // `model` (optional) = the Chat card's Model box, when the picker asks: the estimate line then counts only that worker's runs.
+  function reuseWorkflow(runid, model){
+    authorGet("/api/author/start-from?runid=" + encodeURIComponent(runid) + (model ? "&model=" + encodeURIComponent(model) : "")).then(function(r){
       if(!r || !r.ok){ window.alert((r && r.error) || "nothing to start from"); return; }
       document.getElementById("tab-chat").click();
       document.dispatchEvent(new CustomEvent("bareloop-reuse", {detail: {runid: runid, prefill: r}}));
@@ -2650,7 +2680,7 @@
   // ONE spelling of a step's state: its dot + the bold state word — read by the Run tab's step cards AND the Audit tab's grouped rows
   function stepStateHTML(box, testid){
     var cls = box.state === "done" ? "green" : (box.state === "stopped" ? "red" : (box.state === "running" ? "amber" : (box.state === "died" ? "magenta" : "grey")));
-    return '<span class="step-state" data-testid="' + testid + '"><span class="dot ' + cls + '"></span><b class="st-word">' + escapeXml(box.state) + '</b></span>';
+    return '<span class="step-state" data-testid="' + testid + '"><span class="dot ' + cls + '"></span><b class="st-word">' + escapeXml(boxStatusWord(box)) + '</b></span>';
   }
   // build item C: Audit tab attempt row -> its rounds (server-built,
   // lazy-fetched on expand via /api/runs/:runid/rounds?part=<i>&attempt=<n>).
@@ -3569,7 +3599,7 @@
             + '<td data-testid="pv-tokens-' + e + '">' + escapeXml(tokensText(row.tokens)) + "</td>"
             + "<td>" + bal + "</td>"
             + '<td class="pv-price-cell"><input type="text" inputmode="decimal" class="pv-price-in" data-testid="pv-price-in-' + e + '" placeholder="not set" value="' + (row.priceInPerM === null ? "" : escapeXml(String(row.priceInPerM))) + '"></td>'
-            + '<td class="pv-price-cell"><input type="text" inputmode="decimal" class="pv-price-out" data-testid="pv-price-out-' + e + '" placeholder="not set" value="' + (row.priceOutPerM === null ? "" : escapeXml(String(row.priceOutPerM))) + '"></td>';
+            + '<td class="pv-price-cell"><input type="text" inputmode="decimal" class="pv-price-out" data-testid="pv-price-out-' + e + '" placeholder="not set" value="' + (row.priceOutPerM === null ? "" : escapeXml(String(row.priceOutPerM))) + '"></td></tr>';
         }).join("") : '<tr><td colspan="9" class="hint" data-testid="pv-empty">no keys with a value yet — add NAME=key to the keys file, then Reload keys</td></tr>';
         pvRows.querySelectorAll(".pv-balance-fetch").forEach(function(fetchEl){
           authorGet("/api/settings/providers/balance?env=" + encodeURIComponent(fetchEl.getAttribute("data-env"))).then(function(b){
@@ -3584,15 +3614,15 @@
         document.dispatchEvent(new CustomEvent("bareloop-providers-changed"));
       }).catch(function(){ pvNote.textContent = "could not read providers"; });
     }
-    // The row's POST body. A price is both boxes or neither (the server refuses a half-set one), so while exactly one
-    // is filled — the normal middle of typing a price — the price fields are LEFT OUT (the server keeps what is saved)
-    // and the other boxes still save; the price posts once both are filled, or both are cleared.
+    // The row's POST body, or null when exactly ONE price box is filled: a price is both boxes or neither (the server
+    // refuses a half-set one), so nothing in that row saves. This runs only when a save would happen (the row's
+    // change event), so typing the first box never flashes the message; it shows when the person leaves that box.
+    var PV_HALF_PRICE = "Fill both price boxes or clear both.";
     function pvRowBody(env, v){
       var pin = String(v.priceIn).trim();
       var pout = String(v.priceOut).trim();
-      var body = { envName: env, name: v.name, shape: v.shape, baseUrl: v.baseUrl };
-      if((pin === "") === (pout === "")){ body.priceInPerM = pin; body.priceOutPerM = pout; }
-      return body;
+      if((pin === "") !== (pout === "")) return null;
+      return { envName: env, name: v.name, shape: v.shape, baseUrl: v.baseUrl, priceInPerM: pin, priceOutPerM: pout };
     }
     pvRows.addEventListener("change", function(e){
       var t = e.target;
@@ -3606,13 +3636,15 @@
       }
       if(!(t.classList.contains("pv-name") || t.classList.contains("pv-shape") || t.classList.contains("pv-url") || t.classList.contains("pv-price-in") || t.classList.contains("pv-price-out"))) return;
       var env = tr.getAttribute("data-env");
-      authorPost("/api/settings/providers/row", pvRowBody(env, {
+      var rowBody = pvRowBody(env, {
         name: tr.querySelector(".pv-name").value,
         shape: tr.querySelector(".pv-shape").value,
         baseUrl: tr.querySelector(".pv-url").value,
         priceIn: tr.querySelector(".pv-price-in").value,
         priceOut: tr.querySelector(".pv-price-out").value,
-      })).then(function(r){
+      });
+      if(!rowBody){ pvNote.textContent = PV_HALF_PRICE; return; }
+      authorPost("/api/settings/providers/row", rowBody).then(function(r){
         pvNote.textContent = r.body && r.body.ok ? ("Saved — " + env + ".") : ((r.body && r.body.error) || "could not save");
         // no re-render: it would steal focus mid-edit; Chat's Model menu just re-reads
         document.dispatchEvent(new CustomEvent("bareloop-providers-changed"));
@@ -3692,9 +3724,11 @@
     // Reuse workflow — set when the card was opened by [Reuse workflow]: the run (or imported job) it came from.
     // Only Source, Destination and the two caps are open on that card; the SERVER refuses any other change.
     var startFrom = null;
+    // the picked job's OWN check type: with the Check type radio on "Reuse workflow" the card's checkType comes from here, never from the radio
+    var reuseCheckType = "deterministic";
+    var reusePickedName = "";
     var reuseSession = false;
     var autoSigned = false;
-    var sfOrigin = document.getElementById("chat-startfrom-origin");
     var sfLine = document.getElementById("chat-startfrom-line");
     var sfNote = document.getElementById("chat-startfrom-note");
     // the locked boxes of a reuse card: the signed workflow, greyed and not editable (the server refuses a change anyway)
@@ -3709,7 +3743,8 @@
       LOCKED_IDS.forEach(function(id){ setLock(id, reuseOn || live); });
       OPEN_IDS.forEach(function(id){ setLock(id, live); });
       document.getElementById("jf-model").disabled = live;
-      document.querySelectorAll('input[name="jf-verdict"]').forEach(function(r){ r.disabled = reuseOn || live; });
+      // the Check type radios stay clickable on a reuse card (Deterministic / Rubric = leave reuse); only a live session freezes them
+      document.querySelectorAll('input[name="jf-verdict"]').forEach(function(r){ r.disabled = live; });
       document.getElementById("job-card").classList.toggle("reuse", reuseOn);
       if(!reuseOn && !live){ var ck = document.querySelector('input[name="jf-verdict"]:checked'); document.getElementById("jf-judge").disabled = !ck || ck.value !== "rubric"; }
     }
@@ -3720,11 +3755,105 @@
         ["jf-name", "jf-goal", "jf-source", "jf-dest", "jf-success", "jf-guardrails", "jf-judge", "jf-cap-money", "jf-cap-time"].forEach(function(id){ document.getElementById(id).value = ""; });
         document.querySelectorAll('input[name="jf-verdict"]').forEach(function(r){ r.checked = (r.value === "deterministic"); });
       }
-      startFrom = null; reuseSession = false; autoSigned = false;
-      sfOrigin.hidden = true; sfLine.hidden = true; sfNote.hidden = true;
+      startFrom = null; reuseSession = false; autoSigned = false; reuseCheckType = "deterministic";
+      sfLine.hidden = true; sfNote.hidden = true;
       setReuseLocked(false);
+      renderPicker();
       renderMain();
     }
+    // ---- Reuse workflow picker (hamr 2026-10-06): Check type is ONE radio group of three; "Reuse workflow" shows a search
+    // box over the jobs that have a green local run (GET /api/author/reuse-jobs), a pick fills the card through the SAME
+    // path the Run tab's button uses (reuseWorkflow -> bareloop-reuse -> applyReuse), then a picked box with `change`.
+    var CARD_BOX_IDS = ["jf-name", "jf-goal", "jf-source", "jf-dest", "jf-success", "jf-guardrails", "jf-judge", "jf-cap-money", "jf-cap-time"];
+    var rwBox = document.getElementById("rw");
+    var rwSearch = document.getElementById("rw-search");
+    var rwQ = document.getElementById("rw-q");
+    var rwList = document.getElementById("rw-list");
+    var rwPicked = document.getElementById("rw-picked");
+    var rwPickedTxt = document.getElementById("rw-picked-txt");
+    var rwJobs = null;
+    var rwFailed = false;
+    var rwShown = [];
+    var rwHl = 0;
+    function verdictValue(){
+      var ck = document.querySelector('input[name="jf-verdict"]:checked');
+      return ck ? ck.value : "deterministic";
+    }
+    function setVerdict(v){
+      document.querySelectorAll('input[name="jf-verdict"]').forEach(function(r){ r.checked = (r.value === v); });
+    }
+    function clearCardBoxes(){
+      CARD_BOX_IDS.forEach(function(id){ document.getElementById(id).value = ""; });
+      document.getElementById("jf-cap-note").textContent = "";
+    }
+    // ONE function shows/hides the picker: visible only while the radio is on Reuse workflow; the search box before a
+    // pick, the picked box (+ the estimate line under it) after. A re-attached reuse session shows as picked too.
+    function renderPicker(){
+      var on = verdictValue() === "reuse";
+      var picked = on && (startFrom !== null || reuseSession);
+      rwBox.hidden = !on;
+      rwSearch.hidden = picked;
+      rwPicked.hidden = !picked;
+      rwPickedTxt.innerHTML = picked ? "<b>" + escapeXml(reusePickedName) + "</b>" : "";
+      if(!picked) sfLine.hidden = true;
+    }
+    function rwMark(name, q){
+      var i = q ? name.toLowerCase().indexOf(q.toLowerCase()) : -1;
+      if(i < 0) return escapeXml(name);
+      return escapeXml(name.slice(0, i)) + "<mark>" + escapeXml(name.slice(i, i + q.length)) + "</mark>" + escapeXml(name.slice(i + q.length));
+    }
+    // the server's estimate line, prefixed with the job's check type (the line itself does not carry it)
+    function rwMeta(j){ return j.checkType + " · " + String(j.line || "").replace(/^Same job — /, ""); }
+    function renderReuseList(){
+      var q = rwQ.value.trim();
+      var all = rwJobs || [];
+      rwShown = all.filter(function(j){ return j.job.toLowerCase().indexOf(q.toLowerCase()) !== -1; });
+      if(rwHl >= rwShown.length) rwHl = 0;
+      if(rwShown.length){
+        rwList.innerHTML = rwShown.map(function(j, i){
+          return '<li data-i="' + i + '" data-testid="rw-item" class="' + (i === rwHl ? "hl" : "") + '"><div class="rw-name">' + rwMark(j.job, q) + '</div><div class="rw-meta">' + escapeXml(rwMeta(j)) + "</div></li>";
+        }).join("");
+      } else {
+        rwList.innerHTML = '<div class="rw-empty" data-testid="rw-empty">' + (rwFailed ? "Could not load the job list."
+          : (all.length === 0 ? "No green jobs yet." : 'No green job matches "' + escapeXml(q) + '".')) + "</div>";
+      }
+    }
+    function loadReuseJobs(){
+      authorGet("/api/author/reuse-jobs" + (modelSelect.value ? "?model=" + encodeURIComponent(modelSelect.value) : "")).then(function(r){
+        rwFailed = !(r && r.ok);
+        rwJobs = rwFailed ? null : r.jobs;
+        renderReuseList();
+      }).catch(function(){ rwFailed = true; rwJobs = null; renderReuseList(); });
+    }
+    // the empty search state: card emptied, nothing picked, Sign & run disabled until a job is picked
+    function openPicker(){
+      clearCardBoxes();
+      rwQ.value = ""; rwHl = 0;
+      document.getElementById("jf-judge").disabled = true;
+      renderPicker();
+      renderReuseList();
+      loadReuseJobs();
+      refreshStartEnabled();
+      rwQ.focus();
+    }
+    function pickReuseJob(j){ if(j) reuseWorkflow(j.runid, modelSelect.value); }
+    rwQ.addEventListener("input", function(){ rwHl = 0; renderReuseList(); });
+    rwQ.addEventListener("keydown", function(e){
+      if(e.key === "ArrowDown"){ rwHl = Math.min(rwHl + 1, rwShown.length - 1); renderReuseList(); e.preventDefault(); }
+      else if(e.key === "ArrowUp"){ rwHl = Math.max(rwHl - 1, 0); renderReuseList(); e.preventDefault(); }
+      else if(e.key === "Enter" && rwShown[rwHl]){ e.preventDefault(); pickReuseJob(rwShown[rwHl]); }
+    });
+    rwList.addEventListener("click", function(e){
+      var li = e.target.closest ? e.target.closest("li") : null;
+      if(li) pickReuseJob(rwShown[Number(li.getAttribute("data-i"))]);
+    });
+    // `change` = back to the empty search state; the radio stays on Reuse workflow
+    function unpickReuse(){
+      clearStartFrom();
+      setVerdict("reuse");
+      openPicker();
+    }
+    document.getElementById("rw-change").addEventListener("click", unpickReuse);
     function openNewCard(){
       card.hidden = false;
       thread.innerHTML = "";
@@ -3755,12 +3884,12 @@
     // back to a fresh empty card: every box, check type deterministic, the default (first) Model, origin/estimate/notes
     // hidden, progress list and thread cleared, reuse lock lifted
     function resetCard(){
-      ["jf-name", "jf-goal", "jf-source", "jf-dest", "jf-success", "jf-guardrails", "jf-judge", "jf-cap-money", "jf-cap-time"].forEach(function(id){ document.getElementById(id).value = ""; });
-      document.querySelectorAll('input[name="jf-verdict"]').forEach(function(r){ r.checked = (r.value === "deterministic"); });
+      clearCardBoxes();
+      setVerdict("deterministic");
       document.getElementById("jf-judge").disabled = true;
       modelSelect.selectedIndex = 0;
       msgInput.value = "";
-      document.getElementById("jf-cap-note").textContent = "";
+      rwQ.value = "";
       lastPhase = null;
       clearStartFrom();
       openNewCard();
@@ -3782,7 +3911,8 @@
       var moneyCap = Number(document.getElementById("jf-cap-money").value);
       var timeCapMin = document.getElementById("jf-cap-time").value.trim();
       return {
-        checkType: document.querySelector('input[name="jf-verdict"]:checked').value === "rubric" ? "rubric" : "deterministic",
+        // on "Reuse workflow" the type is the picked job's own, never the radio's
+        checkType: (verdictValue() === "reuse" ? reuseCheckType : verdictValue()) === "rubric" ? "rubric" : "deterministic",
         model: document.getElementById("jf-model").value,
         jobName: document.getElementById("jf-name").value.trim(),
         goal: document.getElementById("jf-goal").value.trim(),
@@ -3806,7 +3936,8 @@
     function refreshStartEnabled(){
       var v = Number(moneyCapInput.value);
       var capOk = moneyCapInput.value.trim() !== "" && Number.isFinite(v) && v > 0;
-      startOk = capOk && !sessionLive && keyOk;
+      // on Reuse workflow nothing starts before a job is picked
+      startOk = capOk && !sessionLive && keyOk && (verdictValue() !== "reuse" || startFrom !== null);
       syncCardLock();
       renderMain();
       refreshClearBtn();
@@ -3829,11 +3960,21 @@
     });
     // the limit changed in Settings: re-read the note for whatever cap is typed
     document.addEventListener("bareloop-limit-changed", refreshCapNote);
+    // Check type: Deterministic / Rubric / Reuse workflow. Reuse opens the picker on an empty card; Deterministic or
+    // Rubric while the picker is showing (picked or not) LEAVES reuse — the empty card on that type (clearStartFrom).
+    function onVerdictChange(v){
+      if(v === "reuse"){ if(rwBox.hidden) openPicker(); return; }
+      if(!rwBox.hidden){
+        clearStartFrom();
+        clearCardBoxes();
+        setVerdict(v);
+        renderPicker();
+      }
+      document.getElementById("jf-judge").disabled = v !== "rubric";
+      refreshStartEnabled();
+    }
     document.querySelectorAll('input[name="jf-verdict"]').forEach(function(r){
-      r.addEventListener("change", function(){
-        var isRubric = document.querySelector('input[name="jf-verdict"]:checked').value === "rubric";
-        document.getElementById("jf-judge").disabled = !isRubric;
-      });
+      r.addEventListener("change", function(){ onVerdictChange(r.value); });
     });
 
     // build item 7 / build item 5 (2026-09-28) — key + reachability, $0,
@@ -3906,10 +4047,11 @@
       var q = (startFrom.importId ? "import=" + encodeURIComponent(startFrom.importId) : "runid=" + encodeURIComponent(startFrom.runid)) +
         "&model=" + encodeURIComponent(modelSelect.value);
       authorGet("/api/author/start-from?" + q).then(function(r){
-        if(startFrom && r && r.ok){ sfLine.textContent = r.line || ""; }
+        if(startFrom && r && r.ok){ sfLine.textContent = r.line ? rwMeta({checkType: reuseCheckType, line: r.line}) : ""; }
       }).catch(function(){ /* the line keeps what it had */ });
     }
     modelSelect.addEventListener("change", refreshReuseLine);
+    modelSelect.addEventListener("change", function(){ if(!rwBox.hidden && startFrom === null && !reuseSession) loadReuseJobs(); });
     // P4b — the Model menu IS the Settings rows: every Name, in keys-file order (a blank Name
     // is never offered). Re-read whenever Settings loads or saves, keeping the pick if it survives.
     function loadModels(){
@@ -4028,7 +4170,7 @@
       var open = askBoxOpenFor(st);
       msgInput.disabled = !open;
       if(!open) msgInput.value = "";
-      var b = mainButtonFor(st, !msgInput.value.trim(), !!startFrom);
+      var b = mainButtonFor(st, !msgInput.value.trim(), !!startFrom || verdictValue() === "reuse");
       mainBtn.textContent = b.text;
       mainBtn.disabled = b.disabled;
       mainAction = b.action;
@@ -4148,7 +4290,9 @@
       reuseSession = st.reuse === true;
       autoSigned = false;
       signClickedOnce = reuseSession;
-      document.querySelectorAll('input[name="jf-verdict"]').forEach(function(r){ r.checked = (r.value === (c.checkType === "rubric" ? "rubric" : "deterministic")); });
+      reuseCheckType = c.checkType === "rubric" ? "rubric" : "deterministic";
+      reusePickedName = c.jobName || "job";
+      setVerdict(reuseSession ? "reuse" : reuseCheckType);
       if(c.model){
         if(!Array.prototype.some.call(modelSelect.options, function(o){ return o.value === c.model; })){
           modelSelect.insertAdjacentHTML("beforeend", '<option value="' + escapeXml(c.model) + '">' + escapeXml(c.model) + "</option>");
@@ -4161,6 +4305,7 @@
       setVal("jf-cap-time", typeof c.maxWallMs === "number" ? Math.round(c.maxWallMs / 60000) : "");
       document.getElementById("jf-judge").disabled = c.checkType !== "rubric";
       if(reuseSession) setReuseLocked(true);
+      renderPicker();
       fitCardBoxes();
       renderMessages(st);
       renderActions(st);
@@ -4180,15 +4325,17 @@
 
     // ---- Reuse workflow — the card opens filled from the SIGNED job: four open boxes, the rest greyed ----
     function setVal(id, v){ document.getElementById(id).value = (v === undefined || v === null) ? "" : String(v); }
-    document.addEventListener("bareloop-reuse", function(e){
-      var d = e.detail || {};
+    // ONE owner of the reuse fill: the Run tab's / Import view's button and the picker both arrive here (the
+    // `bareloop-reuse` event), so the card ends up in the same picked state whichever door was used.
+    function applyReuse(d){
       var pre = d.prefill || {};
       var c = pre.card || {};
       clearStartFrom();
       openNewCard();
       startFrom = d.importId ? {importId: d.importId} : {runid: d.runid};
-      var radios = document.querySelectorAll('input[name="jf-verdict"]');
-      radios.forEach(function(r){ r.checked = (r.value === (c.checkType === "rubric" ? "rubric" : "deterministic")); });
+      reuseCheckType = c.checkType === "rubric" ? "rubric" : "deterministic";
+      reusePickedName = c.jobName || (pre.origin && pre.origin.job) || "job";
+      setVerdict("reuse");
       if(c.model){ modelSelect.value = c.model; }
       setVal("jf-name", c.jobName); setVal("jf-goal", c.goal); setVal("jf-source", c.source);
       setVal("jf-dest", c.destination); setVal("jf-success", c.success); setVal("jf-guardrails", c.guardrails);
@@ -4196,10 +4343,9 @@
       setVal("jf-cap-time", typeof c.maxWallMs === "number" ? Math.round(c.maxWallMs / 60000) : "");
       document.getElementById("jf-judge").disabled = c.checkType !== "rubric";
       setReuseLocked(true);
-      sfOrigin.hidden = false;
-      sfOrigin.textContent = "Reuse: " + ((pre.origin && pre.origin.job) || "job") + (d.runid ? " (run " + d.runid + ")" : " (imported)");
+      renderPicker();
       sfLine.hidden = false;
-      sfLine.textContent = pre.line || "";
+      sfLine.textContent = pre.line ? rwMeta({checkType: reuseCheckType, line: pre.line}) : "";
       sfLine.className = "startfrom-line";
       sfNote.hidden = !pre.note;
       sfNote.textContent = pre.note || "";
@@ -4207,7 +4353,8 @@
       refreshReuseLine();
       refreshCapNote();
       refreshStartEnabled();
-    });
+    }
+    document.addEventListener("bareloop-reuse", function(e){ applyReuse(e.detail || {}); });
 
     // build item 1 — the "lost answer" fix. ROOT CAUSE: `renderActions`
     // (fed by the every-2s `poll()`) unconditionally overwrites

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));
@@ -897,7 +897,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 +1117,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,
@@ -2459,6 +2461,39 @@ 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;
+    // the same endings the Run tab's own Reuse button is offered on (`endedBase`)
+    if (outcome !== 'green' && outcome !== 'already-green' && outcome !== 'satisfied') 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 +2671,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 +2844,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

@@ -49,3 +49,25 @@ export function statusFor(o) {
   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';
   };
 

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/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

@@ -410,6 +410,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 */

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/source.d.ts

@@ -297,6 +297,13 @@ export function frontDoorFromManifest(read: {
 }): {
     destination: string;
 } | null;
+/**
+ * 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;
 /**
  * a named, non-throwing stop
  */