bareloop 0.36.0 → 0.38.0

package/CHANGELOG.md

@@ -4,6 +4,50 @@ 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.38.0] - 2026-10-08
+
+### Added
+
+- **Edit in chat on every run that did not finish green.** The Chat card opens filled from the run's signed job with every box open; Start drafting works as for any new job. The Ended block's NEXT line points at the button, and a refused Resume says so too.
+- **Resume moves to the left Chat card.** Resume mode locks the signed job and opens only the two caps (money and time); Sign & resume posts the same body as before.
+- **Expanded jobs show their latest 7 other runs;** older runs are reached by search.
+
+### Changed
+
+- The run page's Job tab is read-only on every run; the Job-tab resume mode is gone.
+- A stopped run wears `[■]` (red), not `[✗]`, on every surface.
+- Reuse workflow is offered only from a run that earned its green. The Reuse list shows only jobs with a real green run; an already-green run offers Edit in chat instead; `POST /api/author/start` refuses a reuse of any local run that did not finish green (the server owns the rule, not just the pickers); and a delivery-refused ending offers Reuse only on a run that earned its green.
+- The Reuse picker reads "Loading…" until its list arrives, and switching the Check type radios no longer blanks the New job boxes.
+
+### Fixed
+
+- A run cut by the money or wall cap reads `capped` on every surface: a leg that ended escalated on a money-halt or wall-halt, and a cap-cut open step on a single-leg run, no longer read as failed. One helper (`capKindOf`) owns the rule.
+- A Stop clicked in the fix loop reads "during the fix phase ... a resume continues the run" instead of the step text "a resume re-enters this step", which was wrong where no step exists (found on run muxwwrgs).
+- Small cleanups with unchanged behaviour: the `npm ci` comment matches the code, a dead pid above `pid_max` is handled, and tests follow the new panel behaviour.
+
+## [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
@@ -3501,13 +3503,21 @@ key you want first (the panel picks the row by the Model menu).
   result glyphs are unchanged. The reuse button is described under Reuse workflow, below.
   **Status words (click-through 2026-10-04)** → every run row, run detail and imported row carries `status`
   `{key, sign, word}` from ONE table (`src/panel/status.js`): `[▶] running · [·] waiting · [✓] passed · [✗] failed ·
-  [✗] capped · [✗] stopped · [?] died`; `glyph` is that sign. Mapping: green/already-green/satisfied → passed; no
+  [✗] capped · [■] stopped · [?] died`; `glyph` is that sign (the Runs `✗` filter chip also finds a `[■]` run). Mapping: green/already-green/satisfied → passed; no
   job-end + runner alive → running, gone → died; cap-halt, wall-halt, and an escalation that is a money-halt or wall-halt
-  → capped; `stopped` → stopped; every other outcome (plan-red, check-red, step-red, close-red, provider-red,
+  → capped (ONE rule, `capKindOf` in `src/legs.js`, shared by the run status, a leg's stop reason and the part cards); `stopped` → stopped; every other outcome (plan-red, check-red, step-red, close-red, provider-red,
   step-stalled, other escalations, refusals) → failed. The detail also carries `startedAt` and `endedAt` (the last
   `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 — also a leg that ended `escalated` on a money-halt or wall-halt, and the open step of a single-leg run that ended on a 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
@@ -3524,32 +3534,45 @@ key you want first (the panel picks the row by the Model menu).
   the log tail is returned as `error` verbatim; otherwise `{ok:true, runid, specHash, capsChanged,
   log}`. The run keeps its runid and its one list row: the resumed leg appends to the same spine (P5-R,
   `leg-start` in the run list), it never appears as a new run. The page's Resume button opens the
-  caps form (prefilled, "spent so far") and `Sign & resume` is the human click.
+  Chat card in RESUME mode (title `RESUME <job> (run-N)`, filled from `GET /api/author/start-from`, every box locked
+  except the two caps, "spent so far" shown, Clear/Start drafting hidden) and `Sign & resume` on that card is the human
+  click, posting this same route; the run's Job tab is read-only on every run.
   **Stop (item 5)** → `POST /api/runs/:runid/stop` (`src/panel/runroutes.js`, `checkHumanGuard`, no body).
   It writes the run's STOP REQUEST, a file `<spine>.stop` (`stopFilePath(spine)`, `src/legs.js` — the one
   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.
-  **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
+  `[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). A stop in the close-fix loop reads "You stopped the run during the fix phase … a resume continues the
+  run" (`ralph`'s `phase` option; the step loop keeps "a resume re-enters this step").
+  **Edit in chat (2026-10-08)** — `ended.actions` carries `{id:'edit', label:'Edit in chat'}` on EVERY ending that is not a
+  real green (failed, capped, stopped, died, every other red, and an already-green or delivery-refused already-green),
+  after `resume` when both show. The button reads `GET /api/author/start-from` and opens the Chat card filled from the
+  signed job with EVERY box open and the normal Start drafting path (no reuse state, no borrowed track record), under a
+  code-owned origin line ("Copied from <job> (run-N) — <status word>. …").
+  **Reuse workflow (replaces P5 item 3's Start from this, 2026-10-03)** — a button on runs that EARNED their green 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 `green` rows, and on no other: an `already-green` run (the check passed before any
+  work) offers Edit in chat instead, and a red row's next line is "Change the job: press Edit in chat."; stopped/capped/died
+  rows offer `resume` and `edit`) 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
@@ -3560,8 +3583,13 @@ key you want first (the panel picks the row by the Model menu).
   green, notGreen, live, finished, avgSpendUsd, avgWallMs}, line}` (`404` unknown, `409` with an `error` when
   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
+  `startFrom: {importId}` beside the card and answers `{ok, sessionId, reuse, state}`; a local `startFrom: <runid>` whose
+  latest outcome is not `green` (`start-from` carries that `outcome`) is refused `409 "only a run that finished green can
+  be reused — this one did not"` — the server owns the rule, not just the pickers. The old
+  `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 real `green` local run (`already-green` is not a reuse source), `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 +3615,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 +3624,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 +3887,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.38.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/legs.js

@@ -169,3 +169,18 @@ export function watchdogNotePath(spineFile, leg) {
 export function stopFilePath(spineFile) {
   return `${spineFile}.stop`;
 }
+
+/**
+ * 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) {
+  if (o.outcome === 'cap-halt') return 'money';
+  if (o.outcome === 'wall-halt') return 'time';
+  if (o.outcome !== 'escalated') return null;
+  if (o.category === 'wall-halt') return 'time';
+  return o.category === 'cap-halt' && o.moneyHalt ? 'money' : null;
+}

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') {
@@ -243,6 +254,13 @@ export function createAuthorRoutes(opts) {
         const pre = opts.startFrom ? (fromImport !== null ? opts.startFrom.getImport(fromImport) : opts.startFrom.get(fromRunid)) : null;
         if (pre === null || pre === undefined) { send(404, { ok: false, error: 'no such run to reuse' }); return true; }
         if (!pre.ok) { send(409, pre); return true; }
+        // only a run that earned a real green is a reuse source (hamr 2026-10-08) — the pickers already filter, but a
+        // hand-made POST must not sign a reuse of an already-green, red or still-running run. Imports are green by ruling;
+        // Edit in chat and Resume only READ start-from (GET) and never post a startFrom, so this gate never touches them.
+        if (fromImport === null && pre.outcome !== 'green') {
+          send(409, { ok: false, error: 'only a run that finished green can be reused — this one did not' });
+          return true;
+        }
         const locked = lockedFieldChanged(card, pre.card);
         if (locked !== null) { send(400, { ok: false, error: `${locked} is locked on a reused workflow — Clear the card to change it` }); return true; }
         const rv = validateReuseCard(card, { rows });

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.
@@ -644,10 +641,11 @@ export function createSession(card, deps = {}) {
       // a detached checkout of the person's current commit, inside their
       // repo), so a JS/TS repo's tree never carries `node_modules` until
       // someone installs there. Refusing outright here was ITSELF the F182
-      // class of bug one layer up. bareloop still never runs an install
-      // itself — this only re-checks the SAME worktree on demand, via the
-      // "Check again" button (`checkDeps()`, below), instead of ending the
-      // session. (P6 item 3: for an npm lock file bareloop runs `npm ci` itself first, above.)
+      // class of bug one layer up. For an npm lock file bareloop
+      // runs `npm ci --ignore-scripts` itself first (P6 item 3, below); any other
+      // gap (or a failed install) waits on the person: this re-checks the SAME
+      // worktree on demand, via the "Check again" button (`checkDeps()`, below),
+      // instead of ending the session.
       let depsGap = missingDependencies(prep.tree, prep.manifest.sourceSubdir ?? '');
       // P6 item 3: a committed npm lock file -> bareloop runs `npm ci --ignore-scripts` itself, $0, before
       // any model call. Any failure (or another lock file) falls through to the wait below, unchanged.