bareloop 0.37.0 → 0.38.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@ 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

package/bareloop.context.md

@@ -3503,16 +3503,16 @@ 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), stopped (you stopped it),
+  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
@@ -3534,7 +3534,9 @@ 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
@@ -3556,11 +3558,18 @@ key you want first (the panel picks the row by the Model menu).
   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. 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; the Chat card's Check type is one radio group of three
+  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
@@ -3574,10 +3583,12 @@ 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
+  `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 GREEN local run, `runid` = its newest green run (hand it to `start-from`), `line` =
+  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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bareloop",
-  "version": "0.37.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/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

@@ -254,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

@@ -641,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.

package/src/panel/index.html

@@ -140,6 +140,8 @@
   .dot::before{content:"[·]";color:var(--grey-dot);}
   .dot.green::before{content:"[✓]";color:var(--green);}
   .dot.red::before{content:"[✗]";color:var(--red);}
+  /* stopped (hamr 2026-10-07): the person pressed Stop — its own sign, same red as [✗] */
+  .dot.stopped::before{content:"[■]";color:var(--red);}
   /* Panel build P3 addition (2026-09-27, "yes, go"): the part cards below the
      step map (`partResultGlyph`/`attemptGlyph`) and the chat job card render
      their result glyph as PLAIN inline text inside a larger string (never
@@ -295,10 +297,6 @@
   .wf-resumed{color:var(--amber);}
   .audit-leg-divider{text-align:center;color:var(--text-dim);font-size:12px;margin:10px 0;overflow-wrap:anywhere;}
   .audit-leg-divider-row td{text-align:center;color:var(--text-dim);font-size:12px;background:var(--panel2);}
-  /* Resume opens the run's own Job tab: only the two caps turn into inputs, everything else stays read-only */
-  .resume-job{border:1px dashed var(--border-strong);margin-top:12px;padding:10px;display:grid;gap:8px;}
-  .resume-cap{display:flex;gap:6px;align-items:center;flex-wrap:wrap;}
-  .resume-cap input{width:7em;max-width:100%;min-height:36px;background:var(--panel);color:var(--text);border:1px solid var(--border-strong);padding:4px 8px;font:inherit;}
   .summary-box.red{border-color:var(--red);}
   .summary-box.amber{border-color:var(--amber);}
   .summary-box.magenta{border-color:var(--magenta);}
@@ -374,6 +372,9 @@
   .job-card{position:relative;border:1px solid var(--border-strong);padding:14px 10px 10px;background:var(--panel2);margin-top:10px;margin-bottom:10px;}
   .job-card h4{margin:0 0 8px;font-size:13px;position:absolute;top:-10px;left:10px;background:var(--panel2);padding:0 6px;}
   .job-card .card-clear{position:absolute;top:-13px;right:10px;padding:1px 8px;font-size:11px;line-height:1.4;background:var(--panel2);}
+  .job-card .origin-line{font-size:12px;padding:6px 8px;border-left:3px solid var(--amber);background:var(--panel);color:var(--text-dim);margin-bottom:6px;overflow-wrap:anywhere;}
+  .job-card .origin-line.res{border-color:var(--accent, var(--text));}
+  .job-card .chat-resume-box{display:grid;gap:8px;margin-top:10px;}
   .job-card h4::before{content:"┤ ";color:var(--text-faint);}
   .job-card h4::after{content:" ├";color:var(--text-faint);}
   .field{margin-bottom:10px;}
@@ -533,6 +534,7 @@
             <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="hint" id="chat-startfrom-note" data-testid="startfrom-note" hidden></div>
+            <div class="origin-line" id="chat-origin-line" data-testid="origin-line" hidden></div>
 
             <div class="field">
               <label id="jf-verdict-label">Check type</label>
@@ -598,6 +600,11 @@
               </div>
             </div>
             <div class="hint" id="chat-card-error" data-testid="chat-card-error"></div>
+            <div id="chat-resume-box" class="chat-resume-box" data-testid="resume-box" hidden>
+              <div class="hint" id="chat-resume-spent" data-testid="resume-spent"></div>
+              <div class="ended-actions"><button class="btn primary" type="button" id="chat-resume-sign" data-testid="btn-sign-resume">Sign &amp; resume</button> <button class="btn" type="button" id="chat-resume-cancel" data-testid="btn-resume-cancel">Cancel</button></div>
+              <div class="resume-err" id="chat-resume-err" data-testid="resume-err" hidden></div>
+            </div>
           </div>
 
           <div class="chat-thread" id="chat-thread" data-testid="chat-thread"></div>
@@ -723,8 +730,8 @@
             <div class="field"><label>Check type</label><div class="ro-value" id="details-verdict">—</div></div>
             <div class="field"><label>Model</label><div class="ro-value" id="details-model">—</div></div>
             <div class="field-row">
-              <div class="field"><label id="details-cap-money-label">$ cap</label><div class="ro-value" id="details-cap-money">—</div></div>
-              <div class="field"><label id="details-cap-time-label">Time cap</label><div class="ro-value" id="details-cap-time">—</div></div>
+              <div class="field"><label>$ cap</label><div class="ro-value" id="details-cap-money">—</div></div>
+              <div class="field"><label>Time cap</label><div class="ro-value" id="details-cap-time">—</div></div>
             </div>
             <div class="field" id="details-description-field"><label>Description</label><div class="ro-value" id="details-description">—</div></div>
             <div class="field"><label>Goal</label><div class="ro-value scroll" id="details-goal">—</div></div>
@@ -734,7 +741,6 @@
             <div class="field"><label>Destination</label><div class="ro-value" id="details-dest">—</div></div>
             <div class="field"><label>Tools</label><div class="ro-value" id="details-tools">—</div></div>
             <div class="hint" id="job-note"></div>
-            <div id="resume-job" class="resume-job" data-testid="resume-job" hidden></div>
           </div>
         </section>
 
@@ -1267,6 +1273,7 @@
   function glyphClass(g){
     if(g === "✓") return "green";
     if(g === "✗") return "red";
+    if(g === "■") return "stopped";
     if(g === "▶") return "amber";
     if(g === "?") return "magenta";
     return "grey";
@@ -1499,6 +1506,17 @@
   // is a normal, expected action.
   var wfExpanded = {};
 
+  // hamr 2026-10-08 (display only, nothing deleted): with NO search/filter active an expanded job shows at most its
+  // latest WF_SUB_CAP other runs (g.runs is latest-first). A selected older run beyond the cap (picked from History) is
+  // appended after them rather than hidden. With search/filters active every matching sub-card shows.
+  var WF_SUB_CAP = 7;
+  function capSubRuns(childRuns, active, selectedRunid){
+    if(active || childRuns.length <= WF_SUB_CAP) return {shown: childRuns, more: false};
+    var shown = childRuns.slice(0, WF_SUB_CAP);
+    var sel = selectedRunid ? childRuns.slice(WF_SUB_CAP).filter(function(r){ return r.runid === selectedRunid; }) : [];
+    return {shown: shown.concat(sel), more: true};
+  }
+
   function renderWorkflows(jobs){
     var el = document.getElementById("wf-list");
     el.innerHTML = "";
@@ -1585,7 +1603,15 @@
       if(expanded){
         var runsWrap = document.createElement("div");
         runsWrap.className = "wf-runs";
-        childRuns.forEach(function(r){ runsWrap.appendChild(buildRunRowEl(r, true)); });
+        var capped = capSubRuns(childRuns, active, olderSelected);
+        capped.shown.forEach(function(r){ runsWrap.appendChild(buildRunRowEl(r, true)); });
+        if(capped.more){
+          var olderHint = document.createElement("div");
+          olderHint.className = "hint";
+          olderHint.setAttribute("data-testid", "wf-older-" + g.job);
+          olderHint.textContent = "older: use search.";
+          runsWrap.appendChild(olderHint);
+        }
         wrap.appendChild(runsWrap);
       }
       el.appendChild(wrap);
@@ -1654,7 +1680,8 @@
     var q = (filters && filters.search) || "";
     return (runs || []).filter(function(r){
       if(ct.length && ct.indexOf(r.checkType) === -1) return false;
-      if(rs.length && rs.indexOf(r.glyph) === -1) return false;
+      // a stopped run ([■]) was a [✗] before hamr's 2026-10-07 sign ruling — the fail chip still finds it
+      if(rs.length && rs.indexOf(r.glyph) === -1 && !(r.glyph === "\u25A0" && rs.indexOf("\u2717") !== -1)) return false;
       if(!matchesSearch(r.job, r.runid, r.model, q, r.runNo)) return false;
       if(time !== "all"){
         var days = time === "7d" ? 7 : 30;
@@ -1966,7 +1993,6 @@
     clearSelection();
     currentRunid = null;
     runIsLive = false;
-    resumeMode = null;
     currentImportId = id;
     document.querySelectorAll("#import-list .wf-row").forEach(function(r){
       var on = r.getAttribute("data-testid") === "import-row-" + id;
@@ -2363,11 +2389,9 @@
   // The sentences are CODE-OWNED on the server (`endedFor`, src/panel/server.js) — this only
   // paints them. `detail.ended` is null while a run is live (no block while running).
   var lastEndedSig = null;
-  // P5-R (hamr 2026-10-02): Resume opens the run's OWN Job tab. There ONLY the money cap and the time cap are
-  // editable; every other field is the signed job, shown read-only exactly as the tab already shows it. The click
-  // on [Sign & resume] is the signature when a cap changed. A resume is the SAME run: no new card, no new job.
-  var resumeMode = null;
-  var lastJobShown = null;
+  // Resume (P5-R, hamr 2026-10-02: opened the run's own Job tab) MOVED to the left Chat card (hamr 2026-10-07): the card
+  // in RESUME mode, only the money cap and the time cap open (applyResume / signResume). The Job tab is read-only on
+  // every run — values only, no inputs, no buttons. A resume is the SAME run: no new card, no new job.
   function renderEnded(detail){
     var box = document.getElementById("ended-block");
     var e = detail.ended;
@@ -2384,7 +2408,7 @@
       '<div class="ended-row"><span class="ended-label">NEXT</span><span class="ended-text" data-testid="ended-next">' + escapeXml(e.next) + '</span></div>';
   }
   // ---- P5 item 5: the run's ACTION AREA (Run tab, above the counters) — Stop while the run is live, Resume once
-  // it ended in a way the engine would accept (the SAME button as the Ended block's, same Job-tab resume mode).
+  // it ended in a way the engine would accept (opens the Chat card's resume mode), Edit in chat on every non-green ending.
   // The Ended block (Audit tab) is text only and carries no buttons.
   var stopAsked = {};
   // Reuse workflow (replaces P5 item 3's Start from this) — ask the server for the prefill (the signed job), then
@@ -2397,6 +2421,33 @@
       document.dispatchEvent(new CustomEvent("bareloop-reuse", {detail: {runid: runid, prefill: r}}));
     }).catch(function(x){ window.alert("could not reach the panel: " + x.message); });
   }
+  // Edit in chat (hamr 2026-10-07, option A) — the same prefill door as Reuse workflow (`start-from`, the ONE reader of a
+  // run's signed job), but the Chat card opens with EVERY box open and the normal [Start drafting] path: it drafts a new job.
+  // The origin line is code-owned fixed text; run name and status word come from the same helpers the run header uses.
+  function editInChat(detail){
+    var origin = "Copied from " + detail.job + " (" + runLabel(detail.runNo, detail.runid) + ") \u2014 " +
+      ((detail.status && detail.status.word) || "ended") +
+      ". Every box is open. Change anything and it drafts as a new job; change nothing and it is another run of the same job.";
+    authorGet("/api/author/start-from?runid=" + encodeURIComponent(detail.runid)).then(function(r){
+      document.getElementById("tab-chat").click();
+      document.dispatchEvent(new CustomEvent("bareloop-edit", {detail: (r && r.ok) ? {runid: detail.runid, prefill: r, origin: origin} : {error: (r && r.error) || "nothing to copy"}}));
+    }).catch(function(x){
+      document.getElementById("tab-chat").click();
+      document.dispatchEvent(new CustomEvent("bareloop-edit", {detail: {error: "could not reach the panel: " + x.message}}));
+    });
+  }
+  // Resume (hamr 2026-10-07, option B — moved from the run's Job tab): the Chat card opens in RESUME mode, filled from the
+  // SAME prefill (`start-from`), everything locked but the two caps. The card posts /api/runs/<id>/resume; a resume never
+  // drafts and never makes a new card, job or run id (one run = one id).
+  function resumeInChat(detail){
+    authorGet("/api/author/start-from?runid=" + encodeURIComponent(detail.runid)).then(function(r){
+      document.getElementById("tab-chat").click();
+      document.dispatchEvent(new CustomEvent("bareloop-resume", {detail: (r && r.ok) ? {runid: detail.runid, prefill: r, resume: detail.resume || {}, title: detail.job + " (" + runLabel(detail.runNo, detail.runid) + ")"} : {error: (r && r.error) || "nothing to resume"}}));
+    }).catch(function(x){
+      document.getElementById("tab-chat").click();
+      document.dispatchEvent(new CustomEvent("bareloop-resume", {detail: {error: "could not reach the panel: " + x.message}}));
+    });
+  }
   function renderRunActions(detail){
     var bar = document.getElementById("run-actions");
     var html = "";
@@ -2412,6 +2463,10 @@
       var canResume = !!detail.resume && !!detail.ended && (detail.ended.actions || []).some(function(a){ return a.id === "resume"; });
       if(canResume) html = '<button class="btn primary" type="button" data-testid="btn-resume-run">Resume</button>';
     }
+    // Edit in chat: every non-green ending (the server's Ended block says so) — a died run included
+    if(!live && !!detail.ended && (detail.ended.actions || []).some(function(a){ return a.id === "edit"; })){
+      html += '<button class="btn" type="button" data-testid="btn-edit-chat">Edit in chat</button>';
+    }
     // Reuse workflow: on a GREEN run only (the server's Ended block says so) — a new run of the same signed job
     if(!live && !detail.died && !!detail.ended && (detail.ended.actions || []).some(function(a){ return a.id === "reuse"; })){
       html += '<button class="btn" type="button" data-testid="btn-reuse">Reuse workflow</button>';
@@ -2420,6 +2475,8 @@
     bar.hidden = html === "";
     var reuseBtn = bar.querySelector('[data-testid="btn-reuse"]');
     if(reuseBtn) reuseBtn.addEventListener("click", function(){ reuseWorkflow(detail.runid); });
+    var editBtn = bar.querySelector('[data-testid="btn-edit-chat"]');
+    if(editBtn) editBtn.addEventListener("click", function(){ editInChat(detail); });
     var stopBtn = bar.querySelector('[data-testid="btn-stop"]');
     if(stopBtn){
       stopBtn.addEventListener("click", function(){
@@ -2431,82 +2488,7 @@
       });
     }
     var resBtn = bar.querySelector('[data-testid="btn-resume-run"]');
-    if(resBtn) resBtn.addEventListener("click", function(){ openResumeOnJobTab(detail); });
-  }
-  function openResumeOnJobTab(detail){
-    var r = detail.resume || {};
-    resumeMode = {
-      runid: detail.runid, spentUsd: r.spentUsd, spendComplete: r.spendComplete,
-      wallUsedMs: r.wallUsedMs,
-      budget: (r.budgetUsd === null || r.budgetUsd === undefined) ? "" : String(r.budgetUsd),
-      wall: typeof r.maxWallMin === "number" ? String(r.maxWallMin) : null,
-      painted: false,
-    };
-    document.getElementById("tab-details").click();
-    paintResumeMode();
-  }
-  // Turns the Job tab's two cap values into inputs (and shows the Sign box) while a resume is open on this run;
-  // called again after every Job re-render so a re-render never drops the typed numbers.
-  function paintResumeMode(){
-    var box = document.getElementById("resume-job");
-    var moneyLabel = document.getElementById("details-cap-money-label");
-    var timeLabel = document.getElementById("details-cap-time-label");
-    if(!resumeMode || resumeMode.runid !== currentRunid){
-      box.hidden = true; box.innerHTML = "";
-      moneyLabel.textContent = "$ cap"; timeLabel.textContent = "Time cap";
-      return;
-    }
-    var m = resumeMode;
-    // the unit lives in the caption, never as loose text around the input
-    moneyLabel.textContent = "Money cap ($)";
-    timeLabel.textContent = "Time cap (min)";
-    document.getElementById("details-cap-money").innerHTML =
-      '<span class="resume-cap"><input type="number" min="0" step="0.01" id="resume-budget" data-testid="resume-budget" value="' + escapeXml(m.budget) + '"></span>';
-    if(m.wall !== null){
-      document.getElementById("details-cap-time").innerHTML =
-        '<span class="resume-cap"><input type="number" min="1" step="1" id="resume-wall" data-testid="resume-wall" value="' + escapeXml(m.wall) + '"></span>';
-    }
-    var budgetEl = document.getElementById("resume-budget");
-    budgetEl.addEventListener("input", function(){ m.budget = budgetEl.value; });
-    var wallEl = document.getElementById("resume-wall");
-    if(wallEl) wallEl.addEventListener("input", function(){ m.wall = wallEl.value; });
-    box.hidden = false;
-    if(m.painted) return;
-    m.painted = true;
-    var spent = (m.spentUsd === null || m.spentUsd === undefined) ? "unknown" : ((m.spendComplete ? "" : "at least ") + panelMoney(m.spentUsd));
-    box.innerHTML =
-      '<div data-testid="resume-intro">Resume run ' + escapeXml(m.runid) + ' &mdash; the same run, not a new one. Only the money cap and the time cap can change; everything else is the signed job.</div>' +
-      '<div class="hint" data-testid="resume-spent">spent so far ' + escapeXml(spent) +
-        (typeof m.wallUsedMs === "number" && isFinite(m.wallUsedMs) ? ' &middot; time used so far ' + Math.ceil(m.wallUsedMs / 60000) + ' min' : '') + '</div>' +
-      '<div class="ended-actions"><button class="btn primary" type="button" data-testid="btn-sign-resume">Sign &amp; resume</button> ' +
-      '<button class="btn" type="button" data-testid="btn-resume-cancel">Cancel</button></div>' +
-      '<div class="resume-err" id="resume-err" data-testid="resume-err" hidden></div>';
-    var resumeSignBtn = box.querySelector('[data-testid="btn-sign-resume"]');
-    box.querySelector('[data-testid="btn-resume-cancel"]').addEventListener("click", function(){
-      resumeMode = null;
-      renderJob(lastJobShown);
-    });
-    resumeSignBtn.addEventListener("click", function(){
-      var err = document.getElementById("resume-err");
-      err.hidden = true;
-      resumeSignBtn.disabled = true;
-      var body = {budgetUsd: document.getElementById("resume-budget").value};
-      var wall = document.getElementById("resume-wall");
-      if(wall){ body.maxWallMin = wall.value; }
-      return authorPost("/api/runs/" + encodeURIComponent(m.runid) + "/resume", body).then(function(res){
-        if(res.body && res.body.ok){
-          // the SAME run goes on: back to its Run tab, which follows it until it is live again
-          resumeMode = null;
-          renderJob(lastJobShown);
-          document.getElementById("tab-run").click();
-          afterResumeRefresh(m.runid, 8);
-        } else {
-          resumeSignBtn.disabled = false;
-          err.textContent = (res.body && res.body.error) || ("refused (" + res.status + ")");
-          err.hidden = false;
-        }
-      }).catch(function(x){ resumeSignBtn.disabled = false; err.textContent = "could not reach the panel: " + x.message; err.hidden = false; });
-    });
+    if(resBtn) resBtn.addEventListener("click", function(){ resumeInChat(detail); });
   }
   // After a resume starts, the open run's own page follows it: re-select once the run reads live again (the spine's
   // new leg appears a moment after the engine starts), a few tries, never forever.
@@ -2600,7 +2582,7 @@
       " &middot; " + wallPhrase;
 
     var box = document.getElementById("run-summary");
-    box.className = "summary-box " + (detail.died ? "magenta" : (detail.glyph === "✗" ? "red" : (detail.glyph === "▶" ? "amber" : "")));
+    box.className = "summary-box " + (detail.died ? "magenta" : ((detail.glyph === "✗" || detail.glyph === "■") ? "red" : (detail.glyph === "▶" ? "amber" : "")));
     // F196: a synthetic placeholder box (e.g. "died during planning") is a
     // LABEL, not a real step — excluded from this count so a run that died
     // before any step started reads "0 of 0 done" / "none started", never
@@ -2679,7 +2661,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")));
+    var cls = box.state === "done" ? "green" : (box.state === "stopped" ? (box.status && box.status.sign === "\u25A0" ? "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(boxStatusWord(box)) + '</b></span>';
   }
   // build item C: Audit tab attempt row -> its rounds (server-built,
@@ -3269,7 +3251,6 @@
   function renderJob(job){
     var empty = document.getElementById("job-empty");
     var card = document.getElementById("job-card-readonly");
-    lastJobShown = job;
     if(!job){ empty.hidden = false; card.hidden = true; return; }
     empty.hidden = true;
     card.hidden = false;
@@ -3292,7 +3273,6 @@
     document.getElementById("job-note").textContent = job.note || "";
     lastJobToolsList = Array.isArray(job.toolsList) ? job.toolsList : null;
     paintOfferedRow();
-    paintResumeMode();
   }
 
   // ---- selection + loading ----
@@ -3312,7 +3292,6 @@
     document.querySelectorAll(siblingSelector).forEach(function(r){ r.classList.remove("selected"); r.setAttribute("aria-pressed","false"); });
     if(rowEl){ rowEl.classList.add("selected"); rowEl.setAttribute("aria-pressed","true"); }
     currentRunid = runid;
-    resumeMode = null;
     lastLegDividers = [];
     lastJobToolsList = null;
     lastRunDetailSig = null;
@@ -3731,32 +3710,39 @@
     var autoSigned = false;
     var sfLine = document.getElementById("chat-startfrom-line");
     var sfNote = document.getElementById("chat-startfrom-note");
+    var originLine = document.getElementById("chat-origin-line");
     // the locked boxes of a reuse card: the signed workflow, greyed and not editable (the server refuses a change anyway)
     var LOCKED_IDS = ["jf-name", "jf-goal", "jf-success", "jf-guardrails", "jf-judge"];
     // hamr 2026-10-05: while a drafting session is live NOTHING on the card is editable (the session was started from
     // these values). The reuse rule (only Source/Destination/caps open) applies before the start. ONE function owns it.
     var OPEN_IDS = ["jf-source", "jf-dest", "jf-cap-money", "jf-cap-time", "jf-model"];
     var reuseOn = false;
+    // Resume mode (hamr 2026-10-07): the card shows the signed job of one run, every box locked except the two caps.
+    // `resumeRun` = {runid, noTime} while it is on, else null. Never set together with a drafting session or a reuse pick.
+    var resumeRun = null;
+    var CAP_IDS = ["jf-cap-money", "jf-cap-time"];
     function syncCardLock(){
       var live = sessionLive;
+      var resuming = resumeRun !== null;
       var setLock = function(id, on){ var el = document.getElementById(id); el.readOnly = on; el.classList.toggle("locked", on); };
-      LOCKED_IDS.forEach(function(id){ setLock(id, reuseOn || live); });
-      OPEN_IDS.forEach(function(id){ setLock(id, live); });
-      document.getElementById("jf-model").disabled = 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; });
+      LOCKED_IDS.forEach(function(id){ setLock(id, reuseOn || live || resuming); });
+      OPEN_IDS.forEach(function(id){ setLock(id, live || (resuming && CAP_IDS.indexOf(id) === -1)); });
+      document.getElementById("jf-model").disabled = live || resuming;
+      // the Check type radios stay clickable on a reuse card (Deterministic / Rubric = leave reuse); a live session or a resume freezes them
+      document.querySelectorAll('input[name="jf-verdict"]').forEach(function(r){ r.disabled = live || resuming; });
       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"; }
+      if(!reuseOn && !live && !resuming){ var ck = document.querySelector('input[name="jf-verdict"]:checked'); document.getElementById("jf-judge").disabled = !ck || ck.value !== "rubric"; }
     }
     function setReuseLocked(on){ reuseOn = on; syncCardLock(); }
-    function clearStartFrom(){
-      // Clear after a reuse starts a genuinely new job: the reused values do not linger in the boxes
-      if(startFrom){
+    function clearStartFrom(keepBoxes){
+      // Clear after a reuse starts a genuinely new job: the reused values do not linger in the boxes — except when a Check type
+      // radio click leaves reuse (keepBoxes): a radio never blanks what the person has on the card
+      if(startFrom && !keepBoxes){
         ["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; reuseCheckType = "deterministic";
-      sfLine.hidden = true; sfNote.hidden = true;
+      sfLine.hidden = true; sfNote.hidden = true; originLine.hidden = true;
       setReuseLocked(false);
       renderPicker();
       renderMain();
@@ -3807,6 +3793,7 @@
     function renderReuseList(){
       var q = rwQ.value.trim();
       var all = rwJobs || [];
+      var loading = rwJobs === null && !rwFailed;
       rwShown = all.filter(function(j){ return j.job.toLowerCase().indexOf(q.toLowerCase()) !== -1; });
       if(rwHl >= rwShown.length) rwHl = 0;
       if(rwShown.length){
@@ -3815,7 +3802,7 @@
         }).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>";
+          : loading ? "Loading\u2026" : (all.length === 0 ? "No green jobs yet." : 'No green job matches "' + escapeXml(q) + '".')) + "</div>";
       }
     }
     function loadReuseJobs(){
@@ -3826,9 +3813,10 @@
       }).catch(function(){ rwFailed = true; rwJobs = null; renderReuseList(); });
     }
     // the empty search state: card emptied, nothing picked, Sign & run disabled until a job is picked
+    // (the boxes are NOT cleared here: clicking the Reuse radio never blanks typing; only a pick fills the card)
     function openPicker(){
-      clearCardBoxes();
       rwQ.value = ""; rwHl = 0;
+      rwJobs = null; rwFailed = false; // a fresh open shows "Loading…", never the previous list
       document.getElementById("jf-judge").disabled = true;
       renderPicker();
       renderReuseList();
@@ -3854,8 +3842,22 @@
       openPicker();
     }
     document.getElementById("rw-change").addEventListener("click", unpickReuse);
+    // leaving resume mode: the title, the hidden drafting chrome, the time box and the resume box all come back
+    function exitResumeMode(){
+      resumeRun = null;
+      originLine.classList.remove("res");
+      document.getElementById("job-card-title").textContent = "Job card \u2014 draft";
+      document.getElementById("chat-resume-box").hidden = true;
+      document.getElementById("chat-resume-err").hidden = true;
+      document.getElementById("jf-cap-time").parentNode.hidden = false;
+      document.getElementById("chat-clear-btn").hidden = false;
+      ["chat-main-btn", "chat-main-hint"].forEach(function(id){ document.getElementById(id).hidden = false; });
+      document.querySelector(".chat-input-row").hidden = false;
+    }
     function openNewCard(){
       card.hidden = false;
+      originLine.hidden = true;
+      exitResumeMode();
       thread.innerHTML = "";
       errEl.textContent = "";
       actionErrEl.textContent = "";
@@ -3961,12 +3963,11 @@
     // 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).
+    // Rubric while the picker is showing (picked or not) LEAVES reuse — boxes untouched (clearStartFrom(true)).
     function onVerdictChange(v){
       if(v === "reuse"){ if(rwBox.hidden) openPicker(); return; }
       if(!rwBox.hidden){
-        clearStartFrom();
-        clearCardBoxes();
+        clearStartFrom(true);
         setVerdict(v);
         renderPicker();
       }
@@ -4314,7 +4315,7 @@
       poll();
     }
     function reattachLive(){
-      if(sessionId || sessionLive) return;
+      if(sessionId || sessionLive || resumeRun !== null) return;
       authorGet("/api/author/live").then(function(j){
         if(sessionId || sessionLive || !j || !j.ok || !j.sessionId || !j.state) return;
         attachSession(j);
@@ -4356,6 +4357,90 @@
     }
     document.addEventListener("bareloop-reuse", function(e){ applyReuse(e.detail || {}); });
 
+    // Edit in chat — the card opens filled from the SIGNED job with EVERY box open; the button stays the normal
+    // [Start drafting] (startFrom / reuse state are never set: no borrowed track record). A live drafting session is
+    // handled exactly as applyReuse does (clearStartFrom + openNewCard). A refused prefill opens nothing, error only.
+    function applyEdit(d){
+      if(d.error){ errEl.textContent = d.error; return; }
+      var c = (d.prefill || {}).card || {};
+      clearStartFrom();
+      openNewCard();
+      setVerdict(c.checkType === "rubric" ? "rubric" : "deterministic");
+      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);
+      setVal("jf-judge", c.judgeExamples); setVal("jf-cap-money", c.capUsd);
+      setVal("jf-cap-time", typeof c.maxWallMs === "number" ? Math.round(c.maxWallMs / 60000) : "");
+      document.getElementById("jf-judge").disabled = c.checkType !== "rubric";
+      originLine.textContent = d.origin || "";
+      originLine.hidden = !d.origin;
+      renderPicker();
+      refreshModelStatus();
+      refreshCapNote();
+      refreshStartEnabled();
+    }
+    document.addEventListener("bareloop-edit", function(e){ applyEdit(e.detail || {}); });
+
+    // Resume — the card in RESUME mode: the signed job filled and locked, only Cap $ and Time cap open (prefilled from the
+    // engine's own resume plan, the values the Job tab used to show). A live drafting session is handled exactly as
+    // applyReuse does. A refused prefill opens nothing, error only.
+    function applyResume(d){
+      if(d.error){ errEl.textContent = d.error; return; }
+      var c = (d.prefill || {}).card || {};
+      var r = d.resume || {};
+      clearStartFrom();
+      openNewCard();
+      resumeRun = {runid: d.runid, noTime: typeof r.maxWallMin !== "number"};
+      document.getElementById("job-card-title").textContent = "RESUME " + (d.title || d.runid);
+      setVerdict(c.checkType === "rubric" ? "rubric" : "deterministic");
+      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);
+      setVal("jf-judge", c.judgeExamples);
+      setVal("jf-cap-money", r.budgetUsd);
+      setVal("jf-cap-time", resumeRun.noTime ? "" : r.maxWallMin);
+      document.getElementById("jf-cap-time").parentNode.hidden = resumeRun.noTime;
+      document.getElementById("jf-judge").disabled = c.checkType !== "rubric";
+      originLine.textContent = "The same run goes on, not a new one. Only the money cap and the time cap can change; everything else is the signed job.";
+      originLine.classList.add("res");
+      originLine.hidden = false;
+      var spent = (r.spentUsd === null || r.spentUsd === undefined) ? "unknown" : ((r.spendComplete ? "" : "at least ") + panelMoney(r.spentUsd));
+      document.getElementById("chat-resume-spent").textContent = "spent so far " + spent +
+        (typeof r.wallUsedMs === "number" && isFinite(r.wallUsedMs) ? " \u00B7 time used so far " + Math.ceil(r.wallUsedMs / 60000) + " min" : "");
+      document.getElementById("chat-resume-box").hidden = false;
+      document.getElementById("chat-clear-btn").hidden = true;
+      ["chat-main-btn", "chat-main-hint"].forEach(function(id){ document.getElementById(id).hidden = true; });
+      document.querySelector(".chat-input-row").hidden = true;
+      renderPicker();
+      refreshModelStatus();
+      refreshStartEnabled();
+    }
+    document.addEventListener("bareloop-resume", function(e){ applyResume(e.detail || {}); });
+    document.getElementById("chat-resume-cancel").addEventListener("click", function(){ resetCard(); });
+    var resumeSignBtn = document.getElementById("chat-resume-sign");
+    function signResume(){
+      var run = resumeRun;
+      if(run === null) return;
+      var err = document.getElementById("chat-resume-err");
+      err.hidden = true;
+      resumeSignBtn.disabled = true;
+      var body = {budgetUsd: document.getElementById("jf-cap-money").value};
+      if(!run.noTime){ body.maxWallMin = document.getElementById("jf-cap-time").value; }
+      return authorPost("/api/runs/" + encodeURIComponent(run.runid) + "/resume", body).then(function(res){
+        resumeSignBtn.disabled = false;
+        if(res.body && res.body.ok){
+          // the SAME run goes on: the card goes back to empty, the right side to its Run tab, which follows it until it is live again
+          resetCard();
+          document.getElementById("tab-run").click();
+          afterResumeRefresh(run.runid, 8);
+        } else {
+          err.textContent = (res.body && res.body.error) || ("refused (" + res.status + ")");
+          err.hidden = false;
+        }
+      }).catch(function(x){ resumeSignBtn.disabled = false; err.textContent = "could not reach the panel: " + x.message; err.hidden = false; });
+    }
+    resumeSignBtn.addEventListener("click", signResume);
+
     // build item 1 — the "lost answer" fix. ROOT CAUSE: `renderActions`
     // (fed by the every-2s `poll()`) unconditionally overwrites
     // `#chat-card-error` on every tick (`errEl.textContent = state.error ||

package/src/panel/server.js

@@ -74,7 +74,7 @@ export const RUNID_RE = /^[A-Za-z0-9._~-]+$/;
 export const DEFAULT_PORT = 4700;
 
 /**
- * `[✓]`/`[✗]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
+ * `[✓]`/`[✗]`/`[■]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
  * (auto-memory `ui-verdict-words.md`: never the words green/red/soft-green
  * anywhere in the page). `null` (no `job-end` reached — a killed-mid-run or
  * still-running spine) reads `▶` — the same "in progress / unresolved" glyph
@@ -82,10 +82,10 @@ export const DEFAULT_PORT = 4700;
  * running attempt and an archived spine that never reached its own end are
  * the same fact from this read-only side: no verdict has been recorded yet.
  * @param {string|null} outcome
- * @returns {'✓'|'✗'|'▶'}
+ * @returns {'✓'|'✗'|'■'|'▶'}
  */
 export function glyphForOutcome(outcome) {
-  return /** @type {'✓'|'✗'|'▶'} */ (statusFor({ outcome }).sign);
+  return /** @type {'✓'|'✗'|'■'|'▶'} */ (statusFor({ outcome }).sign);
 }
 
 /**
@@ -417,7 +417,7 @@ const GOAL_NOT_MET = new Set(['plan-red', 'check-red', 'step-red', 'escalated'])
  * @returns {{reason: string, next: string, line: string, actions: {id: string, label: string}[]}|null}
  */
 export function endedFor(summary, death, o = {}) {
-  const base = endedBase(summary, death, o);
+  const base = withEditAction(endedBase(summary, death, o));
   const wt = o.worktree;
   if (!base || !wt) return base;
   // P6 item 1 — the run worked on a worktree in the person's own repo. GREEN: the branch carries the work (the folder is
@@ -432,21 +432,31 @@ export function endedFor(summary, death, o = {}) {
   return wt.exists ? { ...base, next: `${base.next} Your work is in ${wt.folder}.` } : base;
 }
 
+/**
+ * "Edit in chat" (hamr 2026-10-07): offered on EVERY non-green ending (failed, capped, stopped, died, every other red),
+ * after Resume when both show; a green ending keeps Reuse workflow only. ONE place, so no ending branch can forget it.
+ * @param {{reason: string, next: string, line: string, actions: {id: string, label: string}[]}|null} ended
+ */
+function withEditAction(ended) {
+  if (!ended || ended.actions.some((a) => a.id === 'reuse')) return ended;
+  return { ...ended, actions: [...ended.actions, { id: 'edit', label: 'Edit in chat' }] };
+}
+
 /** @param {any} summary @param {any} death @param {any} o */
 function endedBase(summary, death, o) {
   const resumeOk = !!(o.resume && o.resume.ok);
   /** @type {{id: string, label: string}[]} */
   const RESUME = [{ id: 'resume', label: 'Resume' }];
   /** Reuse workflow (replaces P5 item 3's Start from this, hamr 2026-10-03): the same signed job on a new source — a NEW
-   *  run, never a rerun. Offered on GREEN rows only; every red row says "Change the job: Clear the card and draft a new one" instead. */
+   *  run, never a rerun. Offered on GREEN rows only; every red row says "Change the job: press Edit in chat" instead. */
   const REUSE = [{ id: 'reuse', label: 'Reuse workflow' }];
-  const CHANGE = 'Change the job: Clear the card and draft a new one.';
+  const CHANGE = 'Change the job: press Edit in chat.';
   const detailOf = (/** @type {string|null} */ s) => {
     if (typeof s !== 'string' || s.length === 0) return '';
     return s.length > 120 ? `${s.slice(0, 120)}…` : s;
   };
   /** a resumable ending whose Resume the engine would refuse: say so, never offer the button */
-  const resumeOr = (/** @type {string} */ okNext) => (resumeOk ? okNext : `Resume is not available for this run${o.resume && o.resume.why ? ` (${o.resume.why})` : ''}.`);
+  const resumeOr = (/** @type {string} */ okNext) => (resumeOk ? okNext : `Resume is not available for this run${o.resume && o.resume.why ? ` (${o.resume.why})` : ''}. ${CHANGE}`);
 
   if (death.died) {
     return {
@@ -497,13 +507,20 @@ function endedBase(summary, death, o) {
 
   if (outcome === 'green' || outcome === 'already-green' || outcome === 'satisfied') {
     if (o.destinationRefused) {
+      // Reuse workflow only on a run that earned its green (hamr 2026-10-08, as below); the rest take Edit in chat
+      // (withEditAction adds it) and are told to change the job, not to reuse it
+      const earned = outcome === 'green';
       return {
         reason: 'Goal met, but the output could not be delivered.',
-        next: 'Fix the destination, then Reuse workflow.',
+        next: earned ? 'Fix the destination, then Reuse workflow.' : CHANGE,
         line: `${GOAL_MET_LINE} — not delivered`,
-        actions: REUSE,
+        actions: earned ? REUSE : [],
       };
     }
+    // hamr 2026-10-08: already-green (the check passed before any work) is not a reusable job — only a run that
+    // earned its green offers Reuse workflow; the rest take Edit in chat (withEditAction adds it). `satisfied` is a
+    // close VERDICT, never a run outcome (ralph and the job-end emitters write `green`), so it rides with already-green.
+    if (outcome !== 'green') return { reason: 'Goal met.', next: CHANGE, line: GOAL_MET_LINE, actions: [] };
     return { reason: 'Goal met.', next: 'Nothing to do.', line: GOAL_MET_LINE, actions: REUSE };
   }
   if (outcome === 'cap-halt') {
@@ -545,7 +562,7 @@ function endedBase(summary, death, o) {
   if (outcome === 'step-stalled') {
     return {
       reason: 'A step stopped making progress.',
-      next: resumeOr('Resume, or change the job: Clear the card and draft a new one.'),
+      next: resumeOr('Resume, or change the job: press Edit in chat.'),
       line: resumeOk ? 'step stalled — resume' : 'step stalled',
       actions: resumeOk ? RESUME : [],
     };
@@ -2408,7 +2425,7 @@ export function reuseLine(record) {
  * to copy: change the job: Clear the card). `null` when the runid is not listed.
  * @param {string} runid
  * @param {{ home?: string, model?: string }} [opts] `model` = the Model box's current Name (the estimate counts only runs on that worker); absent = the card's own Model
- * @returns {{ok: true, origin: {runid: string, job: string}, card: Record<string, any>, from: 'signed job',
+ * @returns {{ok: true, origin: {runid: string, job: string}, outcome: string|null, card: Record<string, any>, from: 'signed job',
  *   locked: readonly string[], open: readonly string[], note: string|null,
  *   specHash: string, workflowKey: string, spec: any, specPath: string,
  *   trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
@@ -2447,6 +2464,8 @@ export function getStartFrom(runid, opts = {}) {
   return {
     ok: true,
     origin: { runid, job: row.job },
+    // the run's terminal outcome — the Reuse start (POST /api/author/start) refuses anything but a real green
+    outcome: legsOf(records).at(-1)?.outcome ?? null,
     card,
     from: 'signed job',
     locked: REUSE_LOCKED_FIELDS,
@@ -2480,8 +2499,9 @@ export function listReuseJobs(opts = {}) {
     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;
+    // only a REAL green (hamr 2026-10-08): `already-green` means the check passed before any work, so there is nothing to reuse
+    // (src/reuse.js 'green-predates-run'). Narrower than the Run tab's Reuse button on purpose.
+    if (outcome !== 'green') continue;
     const signed = signedSpecForRun(row, records);
     if (!signed) continue;
     const key = workflowKey(signed.spec);

package/src/panel/status.js

@@ -2,7 +2,7 @@
 // hamr's ruling 2026-10-04 (option A): every surface (run cards, expanded run rows, the right-side header, imported
 // rows) reads `status` from the server; the page never maps an outcome to a word itself.
 //
-//   [▶] running · [·] waiting · [✓] passed · [✗] failed · [✗] capped · [✗] stopped · [?] died
+//   [▶] running · [·] waiting · [✓] passed · [✗] failed · [✗] capped · [■] stopped · [?] died
 //
 // Outcome -> word (every outcome the panel knows; anything not listed is `failed`):
 //   green, already-green, satisfied                      -> passed
@@ -15,6 +15,8 @@
 //   and every other outcome (refusals, instrument stops)  -> failed
 // `waiting` is the step-level sign for a step that has not started; no run outcome maps to it.
 
+import { capKindOf } from '../legs.js';
+
 /** the sentence a passed run carries as its reason (the Ended block's `line`) */
 export const GOAL_MET_LINE = 'goal met';
 
@@ -27,7 +29,7 @@ export const STATUS = Object.freeze({
   passed: Object.freeze({ sign: '✓', word: 'passed' }),
   failed: Object.freeze({ sign: '✗', word: 'failed' }),
   capped: Object.freeze({ sign: '✗', word: 'capped' }),
-  stopped: Object.freeze({ sign: '✗', word: 'stopped' }),
+  stopped: Object.freeze({ sign: '■', word: 'stopped' }),
   died: Object.freeze({ sign: '?', word: 'died' }),
 });
 
@@ -44,9 +46,8 @@ export function statusFor(o) {
   if (o.died) key = 'died';
   else if (out === null || out === undefined) key = 'running';
   else if (out === 'green' || out === 'already-green' || out === 'satisfied') key = 'passed';
-  else if (out === 'cap-halt' || out === 'wall-halt') key = 'capped';
+  else if (capKindOf(o) !== null) key = 'capped';
   else if (out === 'stopped') key = 'stopped';
-  else if (out === 'escalated' && ((o.category === 'cap-halt' && o.moneyHalt) || o.category === 'wall-halt')) key = 'capped';
   return { key, ...STATUS[key] };
 }
 

package/src/planrun.js

@@ -4108,7 +4108,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // is not passed — it survives only inside the governor, as the bound for the
       // case the trend instrument is blind.
       middle, judge: async () => judgeClose(), ladder: fixGovernor, emit: emitL, redact: scrub,
-      closeTimeoutMs, cwd: workdir, workerWrites: w.workerWrites, closeDir,
+      closeTimeoutMs, cwd: workdir, workerWrites: w.workerWrites, closeDir, phase: 'fix',
     });
   } catch (e) {
     planExecuted();

package/src/ralph.js

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

package/src/replay.js

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

package/types/legs.d.ts

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

package/types/panel/server.d.ts

@@ -1,5 +1,5 @@
 /**
- * `[✓]`/`[✗]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
+ * `[✓]`/`[✗]`/`[■]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
  * (auto-memory `ui-verdict-words.md`: never the words green/red/soft-green
  * anywhere in the page). `null` (no `job-end` reached — a killed-mid-run or
  * still-running spine) reads `▶` — the same "in progress / unresolved" glyph
@@ -7,9 +7,9 @@
  * running attempt and an archived spine that never reached its own end are
  * the same fact from this read-only side: no verdict has been recorded yet.
  * @param {string|null} outcome
- * @returns {'✓'|'✗'|'▶'}
+ * @returns {'✓'|'✗'|'■'|'▶'}
  */
-export function glyphForOutcome(outcome: string | null): "\u2713" | "\u2717" | "\u25B6";
+export function glyphForOutcome(outcome: string | null): "\u2713" | "\u2717" | "\u25A0" | "\u25B6";
 /**
  * `deterministic` (green) / `rubric` (soft-green) / `unknown` (a class this
  * reader doesn't recognize) — the settled UI wording (PANEL-BUILD.md §6),
@@ -381,7 +381,7 @@ export function reuseLine(record: {
  * to copy: change the job: Clear the card). `null` when the runid is not listed.
  * @param {string} runid
  * @param {{ home?: string, model?: string }} [opts] `model` = the Model box's current Name (the estimate counts only runs on that worker); absent = the card's own Model
- * @returns {{ok: true, origin: {runid: string, job: string}, card: Record<string, any>, from: 'signed job',
+ * @returns {{ok: true, origin: {runid: string, job: string}, outcome: string|null, card: Record<string, any>, from: 'signed job',
  *   locked: readonly string[], open: readonly string[], note: string|null,
  *   specHash: string, workflowKey: string, spec: any, specPath: string,
  *   trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
@@ -395,6 +395,7 @@ export function getStartFrom(runid: string, opts?: {
         runid: string;
         job: string;
     };
+    outcome: string | null;
     card: Record<string, any>;
     from: "signed job";
     locked: readonly string[];

package/types/panel/status.d.ts

@@ -60,7 +60,7 @@ export const STATUS: Readonly<{
         word: "capped";
     }>;
     stopped: Readonly<{
-        sign: "✗";
+        sign: "■";
         word: "stopped";
     }>;
     died: Readonly<{

package/types/ralph.d.ts

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