bareloop 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -5,6 +5,56 @@ All notable changes to bareloop are documented here. Format:
 [SemVer](https://semver.org/spec/v2.0.0.html). Pre-1.0: **minor** = a ladder rung or
 feature lands, **patch** = docs, fixes, scaffolding.
 
+## [0.30.0] — 2026-09-27
+
+### Added
+
+- **Panel step map draws the retry loop** — a multi-attempt step (and the post-step fix loop)
+  now renders its "try N" curve and label on the map, alongside a pulsing amber dot on the
+  live-running box (same geometry as `design/panel-mockup.html`).
+- **Runs list and open run poll live** — a single poll owner refreshes the Runs list every
+  tick and the open run's own detail while it is still live (`▶`), stopping once it dies
+  (`?`) or gets a real `✓`/`✗` verdict; polling pauses on a hidden tab and catches up on
+  return. Re-renders are skipped when the fetched payload is unchanged, and scroll position
+  is preserved across poll-driven rebuilds.
+- `scripts/replay-live.mjs` (**dev-only, not shipped** — excluded from the published
+  package) paces an archived spine into a live-looking run for panel development and
+  screenshot proof, without touching the source spine or `~/.config/bareloop`.
+
+### Changed
+
+- **Job tab field order**: Check type, Model, `$` cap / Time cap, then the rest — moved per
+  hamr's ruling.
+- Job tab no longer shows a separate Job name field; the run's own card title already
+  carries it.
+
+### Fixed
+
+- The retry loop's "try N" curve and label now stay inside their own step box at every
+  width, including narrow/mobile widths (previously could render past the box's left edge
+  at widths like 350px).
+- An open (still-running) attempt on a live run now reads `▶` everywhere — map, part cards,
+  and Audit tab — never the died `?`, which is reserved for a genuinely died attempt.
+- The `[▶]` glyph now pulses for a live run everywhere it appears (runs list rows,
+  Workflows, the run header).
+- A running step's own in-progress attempt no longer leaks into a phantom fix-loop part on
+  the map.
+- A live fix-loop attempt whose window is still open now reports its outcome as unknown
+  rather than a fabricated red, so the map correctly shows it as running (with its pulsing
+  dot) instead of prematurely stopped.
+- A live run's Audit tab and tool-call/cache summary now fall back to the during-run
+  tree/worktree gate-audit path, so tool calls are visible while a run is still in progress,
+  not only after it finishes.
+
+### Notes
+
+- F195 (open): `/api/runs` re-replays every archived spine on every call (~457ms CPU at 250
+  rows, no per-row cache). Mitigated in this release by throttling the Runs list poll to
+  10s; the root cause is still open.
+- F196 (parked): a finished bundle run's tool log can be unreadable due to a sidecar naming
+  mismatch between `spine.jsonl` and its renamed gate-audit sidecar. Not fixed in this
+  release.
+
 ## [0.29.0] — 2026-09-26
 
 ### Added

package/bareloop.context.md

@@ -3243,6 +3243,28 @@ interviews of their own. All three are dispatched by name only: `bareloop run-u
   its own. Chat/Settings/authoring (P3/P4) are not built yet; the page says so rather than
   hiding the gap.
 
+- **Panel P2 (live run view, `docs/product/PANEL-BUILD.md` Addendum 2026-09-27)** → the page
+  polls, it does not push (no SSE/websocket). One `setInterval` (2s) drives two throttled
+  fetches: the OPEN run's own detail (`GET /api/runs/:runid`) refetches every 2s while its
+  glyph is live `▶`, and stops the instant it reaches a real `✓`/`✗` or dies `?`; the left
+  Runs list refetches on a separate 10s throttle inside the same tick (`RUNS_LIST_POLL_MS`,
+  lowered from the original 2s per F195 — `listRuns()` re-replays every archived spine on
+  every call, ~457ms CPU at 250 rows, open/escalated), except the tick right after the open
+  run stops being live, which forces one immediate list refresh so that row's glyph doesn't
+  wait up to 10s. Both fetches skip re-rendering when the payload's JSON is byte-identical to
+  the last one, restore each pane's scroll position across a poll-driven rebuild, and pause
+  while the tab is hidden (`document.hidden`), catching up immediately on
+  `visibilitychange`. The Audit tab does **not** join this loop — it refetches only when
+  opened/switched to. A live run's gate-audit sidecar (before `run-u`/`bareloop run`'s
+  end-of-run rename) is read from its DURING-RUN path (`<row.patient>/gate-audit.jsonl`) via
+  `resolveAuditPathForRow` (`src/panel/server.js`), the one shared owner the Run tab's tools
+  summary and the Audit tab both read through — tried only while the run's own spine has no
+  `job-end` yet, so a finished run never risks reading a stale leftover file at that path.
+  `scripts/replay-live.mjs <sourceSpine> <outDir> [--speed N]` is a dev-only, unshipped ($0,
+  no provider call) instrument that paces a real archived spine's records back out under a
+  new runid so the panel can be exercised against a "live" run without a paid run — it is not
+  a substitute for watching a real run start-to-end, which stays a separately authorized step.
+
 - **`bareloop run-u <flags…>`** (PANEL-BUILD.md P0 task 2/4) → the person-path run flow
   (the JOBS-table/`--spec` runner, resume, the review door — `docs/logs/FINDINGS.md`'s
   U-mode). `src/cli.js`'s `run-u` dispatch hands `rest` straight to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bareloop",
-  "version": "0.29.0",
+  "version": "0.30.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/panel/index.html

@@ -132,7 +132,22 @@
   .dot::before{content:"[·]";color:var(--grey-dot);}
   .dot.green::before{content:"[✓]";color:var(--green);}
   .dot.red::before{content:"[✗]";color:var(--red);}
-  .dot.amber::before{content:"[▶]";color:var(--amber);}
+  /* Panel P2 defect 1 (hamr-watched run mujjtrvd, 2026-09-27): the [▶] glyph
+     itself pulses wherever a LIVE run shows it (runs list rows, the
+     Workflows job row when its represented run is live, the run header) —
+     `.dot.amber` is minted ONLY for glyph "▶" (glyphForOutcome,
+     src/panel/server.js: outcome null -> "▶", never for a died [?] or a
+     finished [✓]/[✗] run), so scoping the animation to this one selector
+     already excludes every other state, no extra "is it live" check needed
+     here. Same rhythm as the map box's own running-part dot (this file,
+     `buildMapSvg`'s `s.state === "running"` branch): opacity 1 -> 0.3 -> 1,
+     1.2s, matching design/panel-mockup.html's pulsing amber dot exactly —
+     one fixed rhythm, never re-derived per call site. */
+  @keyframes pulse-glyph{0%,100%{opacity:1;}50%{opacity:0.3;}}
+  .dot.amber::before{content:"[▶]";color:var(--amber);animation:pulse-glyph 1.2s ease-in-out infinite;}
+  @media (prefers-reduced-motion: reduce){
+    .dot.amber::before{animation:none;}
+  }
   .dot.grey::before{content:"[·]";color:var(--grey-dot);}
   /* died (hamr's ruling B, 2026-09-25): no ending was ever recorded — a
      DIFFERENT fact from a real [✗] close/arbiter "no", so it gets its own
@@ -320,7 +335,7 @@
         <button role="tab" id="tab-runs" aria-controls="panel-runs" aria-selected="false" data-testid="left-tab-runs">Runs</button>
       </div>
 
-      <div class="pane-body">
+      <div class="pane-body" id="left-pane-body">
 
         <section id="panel-chat" class="tabpanel active" role="tabpanel" aria-labelledby="tab-chat">
           <div class="chat-thread">
@@ -361,7 +376,7 @@
         <button role="tab" id="tab-details" aria-controls="panel-details" aria-selected="false" data-testid="right-tab-details">Job</button>
       </div>
 
-      <div class="pane-body">
+      <div class="pane-body" id="right-pane-body">
 
         <section id="panel-run" class="tabpanel active" role="tabpanel" aria-labelledby="tab-run">
           <div id="run-empty" class="hint" style="font-size:13px;padding:24px 0;">select a run from Workflows or History</div>
@@ -412,7 +427,10 @@
             <h4 id="details-title">Job card — signed</h4>
             <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"><label>Job name</label><div class="ro-value" id="details-jobname">—</div></div>
+            <div class="field-row">
+              <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>
             <div class="field"><label>Success</label><div class="ro-value" id="details-success">—</div></div>
@@ -420,10 +438,6 @@
             <div class="field"><label>Source</label><div class="ro-value" id="details-source">—</div></div>
             <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="field-row">
-              <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="hint" id="job-note"></div>
           </div>
         </section>
@@ -496,14 +510,27 @@
   // "attempt 1 [✗] · attempt 2 [✓]" — appended to the box's own title text
   // (the existing wrapTitleLines 2-line wrap handles overflow the same way
   // it already does for a long step id; no third renderer, no new box shape).
-  function attemptGlyph(outcome){ return outcome === "green" ? "✓" : (outcome === null || outcome === undefined ? "?" : "✗"); }
-  function attemptsInlineText(attempts){
+  // item 1 (2026-09-27, panel P2 defect): an attempt's own outcome is null
+  // in exactly two situations — its window is still open on a LIVE run (the
+  // box carrying it is the run's own live/`running` part), or the run DIED
+  // before that window ever closed. hamr's glyph ruling reserves "?" for
+  // DIED only; a live open attempt reads the same "▶" the run glyph itself
+  // uses for "in progress / unresolved". `boxIsLive` is the ONE place that
+  // context is decided (every caller passes its own box's `state ===
+  // "running"` — never re-derives the rule itself), so a finished or died
+  // run's attempts (boxIsLive always false there) render exactly as before.
+  function attemptGlyph(outcome, boxIsLive){
+    if(outcome === "green") return "✓";
+    if(outcome === null || outcome === undefined) return boxIsLive ? "▶" : "?";
+    return "✗";
+  }
+  function attemptsInlineText(attempts, boxIsLive){
     if(!attempts || !attempts.length) return "";
-    return attempts.map(function(a){ return "attempt " + a.n + " " + attemptGlyph(a.outcome); }).join(" · ");
+    return attempts.map(function(a){ return "attempt " + a.n + " " + attemptGlyph(a.outcome, boxIsLive); }).join(" · ");
   }
   function stepTitleText(idx, s){
     var base = s.noNumber ? s.title : (idx + 1) + ' ' + s.title;
-    var at = attemptsInlineText(s.attempts);
+    var at = attemptsInlineText(s.attempts, s.state === "running");
     return at ? base + ' — ' + at : base;
   }
   // item 5 (F197): a box's step NUMBER must count only over boxes without
@@ -550,9 +577,10 @@
   // reads the part's own outcome.
   function partResultGlyph(part, box){
     if(partHasNoVerdict(part)) return null;
-    if(box.attempts.length > 1) return box.attempts.map(function(a){ return attemptGlyph(a.outcome); }).join("");
+    var boxIsLive = box.state === "running";
+    if(box.attempts.length > 1) return box.attempts.map(function(a){ return attemptGlyph(a.outcome, boxIsLive); }).join("");
     var outcome = (part.outcome !== null && part.outcome !== undefined) ? part.outcome : (box.attempts[0] ? box.attempts[0].outcome : null);
-    return attemptGlyph(outcome);
+    return attemptGlyph(outcome, boxIsLive);
   }
   function buildOrderedBoxes(parts, isLive){
     var list = Array.isArray(parts) ? parts : [];
@@ -607,6 +635,23 @@
     var line2 = words.slice(i).join(' ');
     return line2 ? [line1, line2] : [line1];
   }
+  // ONE shared rule for "does this box draw a retry loop, and what try number" — a multi-attempt
+  // box (a re-run step, or the fix loop; `run` on an old-shape spine falls in here too, naturally,
+  // never special-cased) gets a dashed self-loop labelled with its final try number; anything
+  // else (incl. every no-verdict kind, whose attempts is already forced to [] upstream) gets 0.
+  function boxRetryTry(box){
+    var attempts = Array.isArray(box.attempts) ? box.attempts : [];
+    return attempts.length > 1 ? attempts.length : 0;
+  }
+  // item 2 (2026-09-27): the ONE place a retry loop's x-coordinate (curve
+  // start/control/end, and the "try N" label) is kept inside the box that
+  // owns it — MIN_BOX_W (100) is comfortably wider than 2*RETRY_INSET, so
+  // this never inverts the clamp range.
+  var RETRY_INSET = 4;
+  function clampRetryX(v, boxX, boxW){
+    var lo = boxX + RETRY_INSET, hi = boxX + boxW - RETRY_INSET;
+    return Math.min(hi, Math.max(lo, v));
+  }
   function buildStepMapSVG(steps, availWidth){
     var n = steps.length;
     var naturalW = naturalBoxWidth(steps);
@@ -626,6 +671,8 @@
       '<defs>' +
         '<marker id="' + uid + '-arrow" markerWidth="8" markerHeight="8" refX="6" refY="3" orient="auto">' +
           '<path d="M0,0 L6,3 L0,6 z" fill="var(--text-dim)"></path></marker>' +
+        '<marker id="' + uid + '-arrow-grey" markerWidth="8" markerHeight="8" refX="6" refY="3" orient="auto">' +
+          '<path d="M0,0 L6,3 L0,6 z" fill="var(--text-faint)"></path></marker>' +
       '</defs>';
     steps.forEach(function(s, idx){
       var row = Math.floor(idx / perRow);
@@ -636,6 +683,8 @@
       var y = 30 + row * rowH;
       var colors = stepMapColors(s.state);
       var lines = titleLines[idx];
+      var nextRow = idx < n - 1 ? Math.floor((idx + 1) / perRow) : null;
+      var hasDrop = nextRow !== null && nextRow !== row;
       var stateY = y + boxH - 18;
       var partIdxAttr = typeof s.partIndex === "number" ? (' data-part-index="' + s.partIndex + '" style="cursor:pointer;"') : '';
       body += '<rect x="' + x + '" y="' + y + '" width="' + boxW + '" height="' + boxH +
@@ -655,8 +704,44 @@
       }
       body += '<text x="' + (x + boxW / 2) + '" y="' + stateY +
         '" text-anchor="middle" font-size="10" fill="' + colors.textFill + '">' + escapeXml(s.state) + '</text>';
+      // P2 (2026-09-27 ruling): a running box gets the mockup's pulsing
+      // amber dot (design/panel-mockup.html ~line 1648) — same fixed color
+      // and animation, never re-derived from the state's own stroke color.
+      if(s.state === "running"){
+        body += '<circle cx="' + (x + 20) + '" cy="' + (y + 12) + '" r="4" fill="#b8860b">' +
+          '<animate attributeName="opacity" values="1;0.3;1" dur="1.2s" repeatCount="indefinite"></animate></circle>';
+      }
+      var retryTry = boxRetryTry(s);
+      if(retryTry){
+        // dashed self-loop under the box, same proportions as the design mockup's curve,
+        // scaled to this box's own width. When this same box also carries the row-to-row
+        // snake drop (which leaves from dead-center, x=cx), shift the loop's start away from
+        // center by a fixed pixel offset so the two never begin at the same point.
+        // item 2 (2026-09-27): at a narrow box width, subtracting that same
+        // fixed pixel shift from proportionally-small x-fractions (e.g. the
+        // curve's own endpoint at 2.8% of boxW) can push the coordinate past
+        // the box's own left edge — the fixed shift was sized for desktop
+        // widths and never scaled down with boxW. clampRetryX is the ONE
+        // place every retry x-coordinate (curve start/control/end AND the
+        // "try N" label) is kept inside [x + RETRY_INSET, x + boxW -
+        // RETRY_INSET] — never re-clamped ad hoc per coordinate — so the
+        // whole loop and its label always stay inside the box that owns it,
+        // at every width, while keeping the mockup's proportions untouched
+        // wherever they already fit (every desktop-width box already fits).
+        var retryShift = hasDrop ? 14 : 0;
+        var bottom = y + boxH;
+        var sx = clampRetryX(x + boxW * 0.50 - retryShift, x, boxW);
+        var sy = bottom + 5;
+        var c1x = clampRetryX(x + boxW * 0.278 - retryShift, x, boxW), c1y = bottom + 30;
+        var c2x = clampRetryX(x + boxW * 0.167 - retryShift, x, boxW), c2y = bottom + 30;
+        var ex = clampRetryX(x + boxW * 0.028 - retryShift, x, boxW), ey = bottom + 2;
+        var labelX = clampRetryX(x + boxW * 0.267 - retryShift, x, boxW);
+        body += '<path d="M ' + sx + ' ' + sy + ' C ' + c1x + ' ' + c1y + ', ' + c2x + ' ' + c2y + ', ' + ex + ' ' + ey +
+          '" fill="none" stroke="var(--text-faint)" stroke-width="1.5" stroke-dasharray="3,3" marker-end="url(#' + uid + '-arrow-grey)"></path>';
+        body += '<text x="' + labelX + '" y="' + (bottom + 32) +
+          '" text-anchor="middle" font-size="10" fill="var(--text-faint)">try ' + retryTry + '</text>';
+      }
       if(idx < n - 1){
-        var nextRow = Math.floor((idx + 1) / perRow);
         if(nextRow === row){
           var midY = y + boxH / 2;
           if(!rtl){
@@ -684,6 +769,7 @@
       '<span><span class="dot red"></span>stopped</span>' +
       '<span><span class="dot grey"></span>waiting</span>' +
       '<span><span class="dot magenta"></span>died</span>' +
+      '<span>⤾ dashed = retry</span>' +
       '</div>';
   }
   var lastSteps = null;
@@ -1498,7 +1584,7 @@
 
   // build item C: Audit tab attempt row -> its rounds (server-built,
   // lazy-fetched on expand via /api/runs/:runid/rounds?part=<i>&attempt=<n>).
-  function buildAttemptsList(container, partIndex, attempts){
+  function buildAttemptsList(container, partIndex, attempts, boxIsLive){
     container.innerHTML = "";
     attempts.forEach(function(a){
       var row = document.createElement("div");
@@ -1506,7 +1592,7 @@
       row.setAttribute("data-testid", "audit-attempt-" + partIndex + "-" + a.n);
       row.innerHTML =
         '<button class="btn small attempt-toggle" type="button" aria-expanded="false">' +
-          'attempt ' + a.n + ' ' + attemptGlyph(a.outcome) +
+          'attempt ' + a.n + ' ' + attemptGlyph(a.outcome, boxIsLive) +
         '</button>' +
         '<div class="rounds-list" hidden></div>';
       container.appendChild(row);
@@ -1699,7 +1785,7 @@
           var attemptsWrap = document.createElement("div");
           attemptsWrap.className = "attempts-list";
           body.appendChild(attemptsWrap);
-          buildAttemptsList(attemptsWrap, idx, attempts);
+          buildAttemptsList(attemptsWrap, idx, attempts, box.state === "running");
         } else {
           // parts with NO sub-loop (scout, plan, replan, judge, run, or a
           // single-attempt step) expand STRAIGHT to their rounds table.
@@ -1830,7 +1916,6 @@
     var verdictEl = document.getElementById("details-verdict");
     if(job.checkTypeTitle){ verdictEl.title = job.checkTypeTitle; } else { verdictEl.removeAttribute("title"); }
     document.getElementById("details-model").textContent = job.model;
-    document.getElementById("details-jobname").textContent = job.job;
     var descField = document.getElementById("details-description-field");
     if(job.description){ descField.hidden = false; document.getElementById("details-description").textContent = job.description; }
     else { descField.hidden = true; }
@@ -1849,23 +1934,182 @@
 
   // ---- selection + loading ----
   var currentRunid = null;
+  // P2: guards a stale in-flight response (detail/audit/job, OR the poll
+  // loop's own run-detail refetch) from overwriting whatever run is
+  // actually selected by the time it resolves — bumped on every selectRun
+  // call, checked before any of those responses touch the DOM.
+  var selectToken = 0;
+  // P2: true while the OPEN run's own detail poll should keep firing (set
+  // from the run's own `glyph`/`died` fields, same rule `renderRun` already
+  // uses for `isLive` — never re-derived a second way).
+  var runIsLive = false;
   function selectRun(runid, rowEl, siblingSelector){
     clearSelection();
     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;
     lastJobToolsList = null;
-    getJSON("/api/runs/" + encodeURIComponent(runid)).then(renderRun).catch(function(e){
+    lastRunDetailSig = null;
+    runIsLive = false;
+    var myToken = ++selectToken;
+    getJSON("/api/runs/" + encodeURIComponent(runid)).then(function(detail){
+      if(myToken !== selectToken) return; // a different run was selected before this resolved
+      lastRunDetailSig = sig(detail);
+      runIsLive = detail.glyph === "▶" && !detail.died;
+      renderRun(detail);
+    }).catch(function(e){
+      if(myToken !== selectToken) return;
       document.getElementById("run-empty").hidden = false;
       document.getElementById("run-empty").textContent = "failed to load run: " + e.message;
       document.getElementById("run-content").hidden = true;
     });
-    getJSON("/api/runs/" + encodeURIComponent(runid) + "/audit").then(renderAudit).catch(function(){ renderAudit(null); });
-    getJSON("/api/runs/" + encodeURIComponent(runid) + "/job").then(renderJob).catch(function(){ renderJob(null); });
+    getJSON("/api/runs/" + encodeURIComponent(runid) + "/audit").then(function(result){
+      if(myToken !== selectToken) return;
+      renderAudit(result);
+    }).catch(function(){ if(myToken === selectToken) renderAudit(null); });
+    getJSON("/api/runs/" + encodeURIComponent(runid) + "/job").then(function(job){
+      if(myToken !== selectToken) return;
+      renderJob(job);
+    }).catch(function(){ if(myToken === selectToken) renderJob(null); });
+  }
+
+  // Q2 (2026-09-27 ruling): the Audit tab does NOT live-refresh on the 2s
+  // poll — it re-fetches only when the person opens/switches to it.
+  document.getElementById("tab-audit").addEventListener("click", function(){
+    if(!currentRunid) return;
+    var myToken = selectToken;
+    getJSON("/api/runs/" + encodeURIComponent(currentRunid) + "/audit").then(function(result){
+      if(myToken !== selectToken) return;
+      renderAudit(result);
+    }).catch(function(){});
+  });
+
+  // ---- P2: live polling — ONE owner for both the left Runs list and the
+  // open live run's map/cards/counters/summary (hamr's ruling, 2026-09-27:
+  // 2s interval for the open run's own detail; the open run's own detail
+  // refetch stops once it is no longer live; the Audit tab is wired
+  // separately above and never joins this loop). A single `setInterval`
+  // drives both fetches — never two independent timers that could race
+  // each other. ----
+  //
+  // F195 (docs/logs/FINDINGS.md): /api/runs re-replays every spine on
+  // every call (~457ms CPU at 250 rows). hamr's ruling B, 2026-09-27:
+  // "refresh less often, up to 30s at most, choose the lesser when
+  // possible" — the Runs list polls every 10s (RUNS_LIST_POLL_MS) instead
+  // of every 2s tick; the open run's own detail is unaffected. The 2s
+  // `pollTick` still fires the list check every tick, but `refreshRunsList`
+  // itself skips the fetch unless RUNS_LIST_POLL_MS has elapsed since the
+  // last one — one timer, one owner, just a throttle inside it. The one
+  // exception: the instant the open run's own poll sees it stop being live
+  // (a real verdict or died), `pollTick` forces ONE immediate list refresh
+  // so that run's left-list glyph flips right away instead of waiting up
+  // to 10s.
+  var POLL_MS = 2000;
+  var RUNS_LIST_POLL_MS = 10000;
+  var pollTimer = null;
+  var lastRunsSig = null;
+  var lastRunDetailSig = null;
+  var lastRunsListRefreshAt = 0;
+  var pollFailStreak = 0;
+
+  function sig(obj){
+    try { return JSON.stringify(obj); } catch(e){ return null; }
+  }
+
+  // Saves/restores scrollTop of the given element ids around a re-render —
+  // both `.pane-body` scroll containers keep their offset across a poll-
+  // driven rebuild instead of snapping back to the top.
+  function withScrollPreserved(ids, fn){
+    var saved = ids.map(function(id){
+      var el = document.getElementById(id);
+      return el ? el.scrollTop : null;
+    });
+    fn();
+    ids.forEach(function(id, i){
+      if(saved[i] === null) return;
+      var el = document.getElementById(id);
+      if(el) el.scrollTop = saved[i];
+    });
+  }
+
+  function refreshRunsList(force){
+    var now = Date.now();
+    if(!force && (now - lastRunsListRefreshAt) < RUNS_LIST_POLL_MS) return Promise.resolve();
+    lastRunsListRefreshAt = now;
+    return getJSON("/api/runs").then(function(result){
+      pollFailStreak = 0;
+      var runs = result.runs || [];
+      var next = sig(runs);
+      if(next === lastRunsSig) return; // unchanged payload — never rebuild the DOM for nothing
+      lastRunsSig = next;
+      withScrollPreserved(["left-pane-body"], function(){
+        // setItems re-runs the SAME filter/search state and view mode
+        // (runsFilterFn/runsApplyFn close over runsViewMode and the filter
+        // bar's own state) — a poll tick never resets either.
+        runsFilterBar.setItems(runs);
+      });
+    }).catch(function(){
+      pollFailStreak++;
+      // Keep the last good render; a transient failure is invisible. Only a
+      // PERSISTENT failure (3+ ticks, ~6s) gets a quiet, non-alarming note —
+      // the page itself is never wiped.
+      if(pollFailStreak === 3){
+        var countEl = document.getElementById("runs-filter-count");
+        if(countEl) countEl.textContent = "runs list: fetch failing, showing last known data";
+      }
+    });
   }
 
+  function refreshOpenRun(){
+    if(!currentRunid || !runIsLive) return Promise.resolve();
+    var runid = currentRunid;
+    var myToken = selectToken;
+    return getJSON("/api/runs/" + encodeURIComponent(runid)).then(function(detail){
+      // stale guard: a different run was selected (or re-selected) while
+      // this request was in flight — never let it overwrite what's open now.
+      if(myToken !== selectToken || runid !== currentRunid) return;
+      var next = sig(detail);
+      var changed = next !== lastRunDetailSig;
+      lastRunDetailSig = next;
+      runIsLive = detail.glyph === "▶" && !detail.died;
+      if(changed){
+        withScrollPreserved(["right-pane-body"], function(){ renderRun(detail); });
+      }
+    }).catch(function(){ /* keep last good render; retry next tick */ });
+  }
+
+  function pollTick(forceList){
+    if(document.hidden) return;
+    refreshRunsList(forceList);
+    var wasLive = runIsLive;
+    return refreshOpenRun().then(function(){
+      // the open run just stopped being live (real verdict or died) —
+      // don't make the left-list glyph wait up to RUNS_LIST_POLL_MS to
+      // catch up; force one immediate refresh.
+      if(wasLive && !runIsLive) refreshRunsList(true);
+    });
+  }
+
+  function startPolling(){
+    if(pollTimer) return;
+    pollTimer = setInterval(pollTick, POLL_MS);
+  }
+  function stopPolling(){
+    if(!pollTimer) return;
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+  // Pause while the tab is hidden (cheap, standard); resume — with an
+  // immediate catch-up tick, forcing BOTH fetches regardless of the list's
+  // 10s throttle — on return, rather than waiting a full 2s (or up to 10s
+  // for the list).
+  document.addEventListener("visibilitychange", function(){
+    if(!document.hidden) pollTick(true);
+  });
+
   getJSON("/api/runs").then(function(result){
     var runs = result.runs || [];
+    lastRunsSig = sig(runs);
     runsFilterBar.setItems(runs);
     if(runs.length && !runs[0].fileMissing){
       document.getElementById("tab-runs").click();
@@ -1877,9 +2121,11 @@
       document.getElementById("tab-run").click();
       runsFilterBar.refresh();
     }
+    startPolling();
   }).catch(function(e){
     document.getElementById("wf-list").innerHTML = '<div class="hint">failed to load: ' + escapeXml(e.message) + '</div>';
     document.getElementById("history-list").innerHTML = '<div class="hint">failed to load: ' + escapeXml(e.message) + '</div>';
+    startPolling(); // still start — a transient initial failure shouldn't block all future polling
   });
 
   // theme toggle

package/src/panel/server.js

@@ -556,7 +556,7 @@ export function getRunDetail(runid, opts = {}) {
     // `replayRun` (a single spine record, never audit-sidecar-sourced, so it
     // carries no contamination risk); `null` when the spine carries no
     // `memory-cache` record at all (never armed on this run).
-    behaviour: scopedBehaviour(row.spine, rawSpineRecords),
+    behaviour: scopedBehaviour(row, rawSpineRecords),
     memoryCache: summary.memoryCache,
   };
 }
@@ -633,6 +633,55 @@ function makeRoundLookup(spineRecords) {
   };
 }
 
+/**
+ * One owner for "where does THIS run's gate-audit sidecar live on disk right
+ * now" — used by both {@link scopedBehaviour} (Run tab) and {@link
+ * getRunAudit} (Audit tab), so the two can never disagree. Two cases:
+ *  (a) the FINISHED convention ({@link resolveSiblings}: `<spine-stem>-
+ *      gate-audit.jsonl` beside the spine) — `run-u`'s end-of-run rename
+ *      (`src/userrun.js:1727-1729`) and every existing archived-run test
+ *      already reads this shape;
+ *  (b) LIVE fallback (panel P2 defect 3, hamr-watched run mujjtrvd,
+ *      2026-09-27): while a run has no `job-end` yet, its sidecar is still
+ *      sitting at its DURING-RUN path, `<row.patient>/gate-audit.jsonl` —
+ *      `run-u` writes it at `wd` (`src/userrun.js:1727`'s `auditSrc`) and
+ *      `bareloop run`/`via:'bundle'` writes it at the worktree
+ *      (`src/cli.js:448`'s `auditSrc`); `row.patient` already carries
+ *      exactly that path for both (`src/userrun.js:1355`, `src/cli.js:418`),
+ *      so this one fallback covers both without knowing which via wrote it.
+ *      Only tried when (a) found nothing AND this run's own spine carries no
+ *      `job-end` yet, so a finished run never pays the extra stat and never
+ *      risks reading a stale leftover file ((a)'s rename already moved it
+ *      away by the time job-end lands). `row.patient` is `null` on a
+ *      `backfill` row (never a live run) and on some pre-cutoff `run-u` rows
+ *      — both correctly fall through to `null` here.
+ * Callers still scope the rows they read from this file by this run's own
+ * job-start..job-end ts window ({@link runAuditWindow}) — a shared tree/
+ * worktree gate-audit file can carry another run's rows too (this file's own
+ * header comment on `runAuditWindow`), live or finished.
+ *
+ * NOT handled here (a separate, pre-existing gap, out of this fix's scope):
+ * a FINISHED `via:'bundle'` run's sidecar is renamed to a bare
+ * `gate-audit.jsonl` inside its own `runs/<runid>/` dir (`src/cli.js:449`),
+ * but its spine is named `spine.jsonl`, so {@link resolveSiblings} looks for
+ * `spine-gate-audit.jsonl` and never finds it — a finished bundle run reads
+ * `no-sidecar`/`toolLogSaved:false` even though its tool log really was
+ * saved. Reported, not fixed here (a naming mismatch in `src/cli.js`'s own
+ * rename target, not a panel-server read-path bug).
+ * @param {{spine: string, patient: string|null}} row
+ * @param {any[]} spineRecords
+ * @returns {string|null}
+ */
+function resolveAuditPathForRow(row, spineRecords) {
+  const { auditPath } = resolveSiblings(row.spine);
+  if (auditPath) return auditPath;
+  const hasJobEnd = spineRecords.some((r) => r && r.type === 'job-end');
+  if (hasJobEnd) return null;
+  if (typeof row.patient !== 'string' || row.patient.length === 0) return null;
+  const live = join(row.patient, 'gate-audit.jsonl');
+  return existsSync(live) ? live : null;
+}
+
 /**
  * `runBehaviour`, fed only the gate-audit rows inside this run's own ts
  * window (see {@link runAuditWindow}) — the panel-side fix for the same
@@ -641,12 +690,14 @@ function makeRoundLookup(spineRecords) {
  * can never disagree with each other about which rows belong to this run.
  * `null` when no gate-audit sidecar exists at all (never a fake all-zero
  * object — same rule `replayRun`'s own `auditAvailable` already follows).
- * @param {string} spinePath
+ * `auditPath` resolution (finished sibling, or the live during-run fallback)
+ * is {@link resolveAuditPathForRow} — the one shared owner.
+ * @param {{spine: string, patient: string|null}} row
  * @param {any[]} spineRecords
  * @returns {ReturnType<typeof runBehaviour>|null}
  */
-function scopedBehaviour(spinePath, spineRecords) {
-  const { auditPath } = resolveSiblings(spinePath);
+function scopedBehaviour(row, spineRecords) {
+  const auditPath = resolveAuditPathForRow(row, spineRecords);
   if (!auditPath || !existsSync(auditPath)) return null;
   const { records } = parseJsonl(auditPath);
   const { startTs, endTs } = runAuditWindow(spineRecords);
@@ -803,13 +854,18 @@ export function getRunAudit(runid, opts = {}) {
       runid, rows: [], raw: '', empty: true, reason: 'no-sidecar',
     };
   }
-  const { auditPath } = resolveSiblings(row.spine);
+  const { records: spineRecords, skipped: spineSkipped } = parseJsonl(row.spine);
+  // {@link resolveAuditPathForRow} needs `spineRecords` (to know whether this
+  // run has reached `job-end` yet) before it can decide whether the LIVE
+  // during-run fallback is even worth trying — so the spine is parsed once,
+  // here, before the sidecar path is resolved (moved up from right after the
+  // old `resolveSiblings`-only check this replaces).
+  const auditPath = resolveAuditPathForRow(row, spineRecords);
   if (!auditPath || !existsSync(auditPath)) {
     return {
       runid, rows: [], raw: '', empty: true, reason: 'no-sidecar',
     };
   }
-  const { records: spineRecords, skipped: spineSkipped } = parseJsonl(row.spine);
   const { startTs, endTs } = runAuditWindow(spineRecords);
   const roundOf = makeRoundLookup(spineRecords);
   const roundRecords = sortedRoundRecords(spineRecords);

package/src/replay.js

@@ -799,8 +799,40 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
   // plan run whose close was satisfied on the first outer-close precheck
   // never enters a fix loop, and this field must read exactly as it did
   // before this addition for that run).
+  // F196 (2026-09-27, live-observed on mujjtrvd): a step still RUNNING (no
+  // `step-end` on the spine yet) has its own in-flight micro-loop
+  // (`ralph({judge,...})`, src/planrun.js) that emits its OWN
+  // `iteration-start` — e.g. step 2's attempt 1 on mujjtrvd (seq 71,
+  // `strict-clean-whole-src`'s own step-start at seq 69, no step-end). The
+  // old `lastStepEndSeq` (the LAST *ended* step's own boundary — seq 68,
+  // step 1 `type-checks-jsdoc`'s step-end) left that still-running step's
+  // seq range wide open, so its iteration-start leaked in below as a fake
+  // fix-loop attempt: the Run tab showed step 2 as `[done]` with 0
+  // calls/`?` (`end` never found for it in the `steps` map) plus a phantom
+  // `FIX [running]` box after it. An un-ended step is its own right
+  // boundary: the fix loop can only start once the run's LAST-STARTED step
+  // (`steps[steps.length-1]` — `steps` preserves spine order, so this is
+  // the step with the highest `stepStartSeq` across the whole file,
+  // including every concatenated leg of a resumed chain) has reached its
+  // own step-end.
+  //
+  // Deliberately checks only the LAST step, never "every step" (measured
+  // and rejected: a first pass checking `steps.some(s => s.stepEndSeq ===
+  // Infinity)` broke a genuinely FINISHED resumed-chain archive,
+  // litectx-u-bareloop/reuse-msc6w93z.jsonl — its first leg's
+  // `fix-index-js-strict` attempt (step-start seq 34) crashed with no
+  // step-end before the chain resumed and re-ran that same step from seq
+  // 77 onward to a real step-end at seq 115; the file's LAST step
+  // (`achieve-strict-typecheck`, step-end seq 611) did end, and this run's
+  // real fixLoop must still be read). Checking only the last-started step
+  // preserves that file's output unchanged while still nulling fixLoop on
+  // mujjtrvd (last step `strict-clean-whole-src` never step-ends in the
+  // mid-run slice) and on every other archived spine this fix was diffed
+  // against that turned out to be a truncated/killed file with no
+  // `job-end` at all (its last step-start likewise never step-ended) —
+  // see the F196 commit's report for the full before/after list.
   let fixLoop = null;
-  if (timelineKind === 'steps' && stepStarts.length > 0) {
+  if (timelineKind === 'steps' && stepStarts.length > 0 && steps[steps.length - 1].stepEndSeq !== Infinity) {
     const lastStepEndSeq = stepEnds.reduce((max, se) => (typeof se.seq === 'number' && se.seq > max ? se.seq : max), -Infinity);
     const outerClosesAfter = spine
       .filter((e) => e.type === 'outer-close' && typeof e.seq === 'number' && e.seq > lastStepEndSeq)
@@ -869,7 +901,21 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
           iteration: typeof is.iteration === 'number' ? is.iteration : null,
           verdict,
           stages: end && end.type === 'close-verdict' && Array.isArray(end.stages) ? end.stages : null,
-          outcome: /** @type {'green'|'red'} */ (verdict === 'satisfied' || verdict === 'green' || verdict === 'already-green' ? 'green' : 'red'),
+          // `end === null` means this iteration's own window hasn't closed
+          // yet (no close-verdict/run-end/escalation boundary has landed on
+          // the spine after its iteration-start) — a LIVE run reading this
+          // mid-iteration, never a finished one (a finished spine's last
+          // iteration always has a boundary). Fabricating 'red' here (as
+          // `verdict === null` used to fall through to) reads a still-running
+          // fix-loop attempt as an already-failed one; `null` (the same
+          // "unresolved" value every other in-progress outcome in this file
+          // uses) is the honest read. Fixed here, the one place this outcome
+          // is minted, rather than in the panel's `partBoxState` (which reads
+          // this field but has no ordering info to tell "genuinely red" from
+          // "still open" apart if this field itself already lies).
+          outcome: end
+            ? /** @type {'green'|'red'} */ (verdict === 'satisfied' || verdict === 'green' || verdict === 'already-green' ? 'green' : 'red')
+            : /** @type {null} */ (null),
           ...buildOccurrenceMetrics(startSeq, startTs, endSeq, endTs, roundsInWindow),
           windowStartSeq: startSeq,
           windowEndSeq: endSeq,