tumwater 0.4.2 → 0.4.4

package/dist/src/ui/gui/gui-client-operator.js

@@ -65,7 +65,7 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
   // The subscription usage window (plans/agent-backends.md §8, PLANS.md part 6d/7): the
   // sidebar's spend card renders it beside the daily spend, or in its place for a
   // subscription-only team. The label/status/clock rules mirror badges.ts's
-  // subscriptionWindowBadge — the preformatted header fragment the TUI uses cannot be reused here
+  // window badge — the preformatted header fragment the TUI uses cannot be reused here
   // because the card lists EVERY window of EVERY block, not just the most constrained one.
   function windowLabel(type) {
     const m = /^(\w+)_(hour|day|week)$/.exec(String(type));
@@ -87,9 +87,9 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
     if (hours < 24) return "resets in " + hours + "h " + (minutes % 60) + "m";
     return "resets in " + Math.floor(hours / 24) + "d " + (hours % 24) + "h";
   }
-  // A window's consumed fraction as a whole-number percent, the same shape as node-side
-  // utilizationPct - the browser script keeps its inline copy, so the text percentage and
-  // the meter width share this one home instead of each rounding w.utilization by hand.
+  // A window's consumed fraction as a whole-number percent, the same shape as the node-side
+  // utilization percent — the browser script keeps its inline copy, so the text percentage
+  // and the meter width share this one home instead of each rounding w.utilization by hand.
   function windowPct(w) {
     return Math.round(w.utilization * 100);
   }
@@ -171,7 +171,9 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
   function renderBudgetBadge(d) {
     if (budgetEditing) return; // the open editor owns the slot until save or cancel
     const b = d && d.budget;
-    paintPanel("budgetwrap", b ? budgetCardHtml(b, d && d.subscriptionWindows, d && d.subscriptionOnly, d && d.chain) : "");
+    // The subscription-window block and its only flag no longer ride the status payload
+    // (Subtract 5x/6); the window card is dormant, so the budget card renders chain only.
+    paintPanel("budgetwrap", b ? budgetCardHtml(b, undefined, undefined, d && d.chain) : "");
   }
   function openBudgetEditor() {
     const b = lastStatus && lastStatus.budget;

package/dist/src/ui/gui/gui-client-pending.js

@@ -58,7 +58,7 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingTeam = null;
     if (!team || !Array.isArray(team.roles) || team.roles.length === 0)
       return "<div class='empty'><strong>No roles yet</strong>Roles appear here once the team is configured.</div>";
     if (team.roles.every((r) => r.state === "no-base"))
-      return "<div class='empty'><strong>Main branch " + esc(team.mainBranch) + " does not exist</strong>There is no base to compare unmerged work against.</div>";
+      return "<div class='empty'><strong>" + mainBranchMissingPhrase(team.mainBranch) + "</strong>There is no base to compare unmerged work against.</div>";
     const rows = team.roles.map((r) =>
       "<tr class='clickable' data-open='" + esc(r.role) + "'>" +
       "<td class='mono'>" + esc(roleLabel(r.role)) + "</td>" +
@@ -202,7 +202,7 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingTeam = null;
     let body;
     let head = "<div class='card-head'><h2>Overlapping files</h2></div>";
     if (ok && view.state === "no-base") {
-      body = "<div class='empty'>Main branch " + esc(view.mainBranch) + " does not exist</div>";
+      body = "<div class='empty'>" + mainBranchMissingPhrase(view.mainBranch) + "</div>";
     } else if (!ok || !Array.isArray(view.overlaps) || view.overlaps.length === 0) {
       body = "<div class='empty'>No file is touched by two pending changes</div>";
     } else {
@@ -267,6 +267,7 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingTeam = null;
       case "fixed":
         return "[fixed — the repair " + shortSha(e.fixed) + " already merged on main]";
       case "rejected":
+        if (!e.rejected || e.rejected.length === 0) return "[rejected]";
         return "[rejected — " + e.rejected.map((r) => squashText(r, 60)).join("; ") + "]";
       case "failing":
         if (e && typeof e.lastFailure === "string" && e.lastFailure.length > 0) {
@@ -388,7 +389,7 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingTeam = null;
       // A Merge queue row's Move to top: a single click posts /api/queue-top by sha, moving
       // that entry to the head of the queue and refetching (the move is reversible and
       // non-destructive, so it needs no two-step arm).
-      const t = e.target.closest("[data-top]");
+      const t = clickClosest(e, "[data-top]");
       if (t) {
         const sha = t.getAttribute("data-top");
         if (sha) {
@@ -397,7 +398,7 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingTeam = null;
         }
         return;
       }
-      const b = e.target.closest("[data-cancel]");
+      const b = clickClosest(e, "[data-cancel]");
       if (!b) return;
       const sha = b.getAttribute("data-cancel");
       if (!sha) return;
@@ -415,7 +416,7 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingTeam = null;
     // (repainting that button as Confirm accept), a second on the armed commit within 5 s posts
     // /api/post-review-accept then clears the arm and refetches so the removed row disappears.
     $("pendingreviews").addEventListener("click", async (e) => {
-      const b = e.target.closest("[data-accept]");
+      const b = clickClosest(e, "[data-accept]");
       if (!b) return;
       const commit = b.getAttribute("data-accept");
       if (!commit) return;
@@ -445,7 +446,7 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingTeam = null;
       }
     });
     $("pendingoverlaps").addEventListener("click", (e) => {
-      const b = e.target.closest("[data-overlap]");
+      const b = clickClosest(e, "[data-overlap]");
       if (b) togglePendingOverlap(Number(b.dataset.overlap));
     });
     $("pendingoverlaps").addEventListener("change", (e) => {

package/dist/src/ui/gui/gui-client-report-chart.js

@@ -48,7 +48,7 @@ export const GUI_CLIENT_REPORT_CHART_JS = String.raw `
   // Object.prototype key whose inherited value would otherwise seed the counter and satisfy
   // the membership test (the browser twin of addTo's fix; BUGS.md 2026-10-10).
   function reportRoleOrder(data) {
-    return tallyAcross(data.series, ["runsByRole"], ["costByRole", "notionalByRole", "rejectionsByRole", "revisionsByRole", "refusalsByRole", "fallbacksByRole", "failedRunsByRole", "mergeFailedByRole", "commitsByRole", "mergedByRole"]);
+    return tallyAcross(data.series, ["runsByRole"], ["costByRole", "notionalByRole", "rejectionsByRole", "revisionsByRole", "refusalsByRole", "imageReroutesByRole", "failedRunsByRole", "mergeFailedByRole", "commitsByRole", "mergedByRole"]);
   }
 
   // X-axis labels: MM-DD, thinned to at most seven, counted back from the newest day so today
@@ -371,10 +371,10 @@ export const GUI_CLIENT_REPORT_CHART_JS = String.raw `
   function chartRefusalsByRole(data) {
     return roleStackChart(data, "refusalsByRole", (n) => plural(n, "refusal"), countAxis, true);
   }
-  // The team's model-fallback episodes, per role, on the same count axis: one segment per
-  // (day, role) with a fallback.
-  function chartFallbacksByRole(data) {
-    return roleStackChart(data, "fallbacksByRole", (n) => plural(n, "fallback"), countAxis, true);
+  // Image reroutes per role, drawn like the other role stacks: one segment per (day, role)
+  // with a reroute.
+  function chartImageReroutesByRole(data) {
+    return roleStackChart(data, "imageReroutesByRole", (n) => plural(n, "image reroute"), countAxis, true);
   }
   // Runs that ended in an error, per role, drawn the same way.
   function chartFailedRunsByRole(data) {

package/dist/src/ui/gui/gui-client-report.js

@@ -335,7 +335,7 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-tip:start
         (seriesHasAny(d, "postMergeRejectionsByRole") ? block("Post-merge rejections by role", chartPostMergeRejectionsByRole(d)) : "") +
         (seriesHasAny(d, "revisionsByRole") ? block("Revisions by role", chartRevisionsByRole(d)) : "") +
         (seriesHasAny(d, "refusalsByRole") ? block("Refusals by role", chartRefusalsByRole(d)) : "") +
-        (seriesHasAny(d, "fallbacksByRole") ? block("Fallbacks by role", chartFallbacksByRole(d)) : "") +
+        (seriesHasAny(d, "imageReroutesByRole") ? block("Image reroutes by role", chartImageReroutesByRole(d)) : "") +
         (seriesHasAny(d, "failedRunsByRole") ? block("Failed runs by role", chartFailedRunsByRole(d)) : "") +
         (seriesHasAny(d, "mergedByRole") ? block("Merged by role", chartMergedByRole(d)) : "") +
         (!d.role && seriesHasAny(d, "runsByModel") ? block("Runs by model", chartRunsByModel(d)) : "") +

package/dist/src/ui/gui/gui-client-roles.js

@@ -163,7 +163,6 @@ export const GUI_CLIENT_ROLES_JS = String.raw `
     const name = "<div class='role-name'><button type='button' class='linkish role' data-open='" + esc(l.role) + "' title='Open " + esc(roleLabel(l.role)) + "'>" + esc(roleLabel(l.role)) + "</button>" +
       (l.custom ? "<span class='tag' title='A custom role from tumwater.json'>custom</span>" : "") +
       (l.modelTier ? "<span class='tag' title='The model tier this role resolves at'>" + esc(l.modelTier) + "</span>" : "") +
-      (l.fallback ? "<span class='tag t-amber' title='Running on the model fallback while its primary keeps failing provider-class errors'>fallback</span>" : "") +
       (queued ? "<span class='tag t-indigo' title='" + esc(plural(queued, "message") + " in this role's inbox") + "'>" + icon("chat") + queued + "</span>" : "") +
       "</div><div class='sub'>" + esc(plural(l.commits, "commit") + " · " + plural(l.runs, "run") + " · merged " + (l.lastMergedAt ? fmtAgo(l.lastMergedAt) : "never")) + (l.model ? " · " + esc(l.model) : "") +
       (l.modelFromPi ? " <span class='tag' title='pi&#39;s own default model, from its settings.json: tumwater.json names no model'>(pi default)</span>" : "") + "</div>";

package/dist/src/ui/gui/gui-client-settings.js

@@ -34,10 +34,8 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
     ["fallback", "Fallback (free at the spend cap)"],
     ["maxDailyCostUsd", "Daily spend cap (USD)"],
     ["maxConcurrent", "Max concurrent runs"],
-    ["maxConcurrentPerProvider", "Provider concurrency caps (JSON)"],
     ["maxConcurrentChecks", "Max concurrent checks"],
     ["worktreeSlots", "Worktree slots"],
-    ["claudeWindowReserve", "Claude window reserve (backends.claude.windowReserve)"],
     ["quietHours", "Quiet hours"],
     ["notify", "Notify hook"],
     ["backends", "Agent backends (JSON)"],
@@ -162,13 +160,7 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
   // The row's Enable button: re-enable the role through POST /api/role-enable (writing
   // roles.<base>.enabled), flash the server's message, and refetch so the card drops the row.
   async function enableRole(role) {
-    try {
-      const d = await postJson("/api/role-enable", { role: role });
-      showFlash(d.message);
-    } catch (err) {
-      showFlash("error: " + clientErrorMessage(err));
-    }
-    await fetchRetirable();
+    await postSetting("/api/role-enable", { role: role }, fetchRetirable, (d) => d.message);
   }
   // First click arms the role's button; a second within the confirm window posts the retire.
   async function confirmRetire(role) {
@@ -177,13 +169,42 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
       return;
     }
     retireSlot.disarm();
+    await postSetting("/api/retire", { role: role }, fetchRetirable, (d) => d.message);
+  }
+  // POST one Settings action and flash its outcome, then refetch the card it changed — the
+  // try/catch tail every Enable/Retire/Health-button handler shares, so the thrown-error
+  // coercion and the success/error wording live in one place. news derives the success line
+  // from the endpoint's answer: the default is the team-wide "ok: / error: " prefix, Enable
+  // and Retire pass the server's message through verbatim, and Retire-leftovers overrides the
+  // none-left fallback. Deliberately not named postAction (gui-client.ts's core helper, which
+  // closes menus, refreshes the standing poll, and does not refetch on failure — this one
+  // refetches the card its action changed even when the post failed).
+  async function postSetting(path, body, refetch, news) {
     try {
-      const d = await postJson("/api/retire", { role: role });
-      showFlash(d.message);
+      const d = await postJson(path, body);
+      showFlash(news ? news(d) : (d.ok ? "" : "error: ") + d.message);
     } catch (err) {
       showFlash("error: " + clientErrorMessage(err));
     }
-    await fetchRetirable();
+    await refetch();
+  }
+  // POST one two-click Health-card action after its slot was armed by a prior click: the first
+  // click only arms the slot (the handler's button repaints to "Confirm …") and returns; a
+  // second click within the confirm window disarms, repaints, flashes the action line, posts,
+  // and re-runs the card's checks. The Health card's four repair buttons (Kill orphans, Drop
+  // broken pins, Retire leftovers, Archive backlog) share this one confirm shape: only the slot
+  // key, the paint fn, the flash line, the endpoint, and an optional news override (passed
+  // through to postSetting, e.g. Retire-leftovers' outcome-line override) differ, so they fold
+  // into this one helper instead of four copies of the arm/disarm/paint/flash/postSetting tail.
+  async function postConfirmedHealthAction(slot, key, paint, flash, path, news) {
+    if (!slot.armed(key)) {
+      slot.arm(key);
+      return;
+    }
+    slot.disarm();
+    paint();
+    showFlash(flash);
+    await postSetting(path, {}, fetchDoctor, news);
   }
   // The Health card's Kill orphans button: a two-click confirm, then POST /api/kill-orphans runs
   // the same kill as "tumwater doctor --kill-orphans" and the card re-runs its checks.
@@ -193,20 +214,7 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
   }
   const killSlot = confirmSlot(paintKillButton);
   async function killOrphansClick() {
-    if (!killSlot.armed("orphans")) {
-      killSlot.arm("orphans");
-      return;
-    }
-    killSlot.disarm();
-    paintKillButton();
-    showFlash("Killing orphaned processes…");
-    try {
-      const d = await postJson("/api/kill-orphans", {});
-      showFlash((d.ok ? "" : "error: ") + d.message);
-    } catch (err) {
-      showFlash("error: " + clientErrorMessage(err));
-    }
-    await fetchDoctor();
+    await postConfirmedHealthAction(killSlot, "orphans", paintKillButton, "Killing orphaned processes…", "/api/kill-orphans");
   }
   // The Health card's Drop broken pins button: a two-click confirm, then POST
   // /api/doctor-drop-broken-pins runs the same drop as "tumwater doctor --drop-broken-pins" and
@@ -217,20 +225,7 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
   }
   const dropSlot = confirmSlot(paintDropButton);
   async function dropBrokenPinsClick() {
-    if (!dropSlot.armed("broken-pins")) {
-      dropSlot.arm("broken-pins");
-      return;
-    }
-    dropSlot.disarm();
-    paintDropButton();
-    showFlash("Dropping broken pins…");
-    try {
-      const d = await postJson("/api/doctor-drop-broken-pins", {});
-      showFlash((d.ok ? "" : "error: ") + d.message);
-    } catch (err) {
-      showFlash("error: " + clientErrorMessage(err));
-    }
-    await fetchDoctor();
+    await postConfirmedHealthAction(dropSlot, "broken-pins", paintDropButton, "Dropping broken pins…", "/api/doctor-drop-broken-pins");
   }
   // The Health card's Retire leftovers button: a two-click confirm, then POST
   // /api/doctor-retire-leftovers runs the same reap as "tumwater doctor --retire-leftovers" and
@@ -242,22 +237,11 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
   }
   const retireLeftoversSlot = confirmSlot(paintRetireLeftoversButton);
   async function retireLeftoversClick() {
-    if (!retireLeftoversSlot.armed("retire-leftovers")) {
-      retireLeftoversSlot.arm("retire-leftovers");
-      return;
-    }
-    retireLeftoversSlot.disarm();
-    paintRetireLeftoversButton();
-    showFlash("Retiring every disabled role's leftovers…");
-    try {
-      const d = await postJson("/api/doctor-retire-leftovers", {});
-      // The shared leftoverRetireLines join is empty when nothing is retirable, so the
-      // button falls back to the same none-left sentence the TUI Health key flashes.
-      showFlash((d.ok ? "" : "error: ") + (d.message || "no leftover roles to retire"));
-    } catch (err) {
-      showFlash("error: " + clientErrorMessage(err));
-    }
-    await fetchDoctor();
+    // The news override's none-left fallback matches the none-left sentence the TUI Health key
+    // flashes when nothing is retirable: the shared leftoverRetireLines join is empty when
+    // nothing is retirable, so the button falls back to that same sentence.
+    await postConfirmedHealthAction(retireLeftoversSlot, "retire-leftovers", paintRetireLeftoversButton, "Retiring every disabled role's leftovers…", "/api/doctor-retire-leftovers",
+      (d) => (d.ok ? "" : "error: ") + (d.message || "no leftover roles to retire"));
   }
   // The Health card's Archive backlog button: a two-click confirm, then POST
   // /api/doctor-archive-backlog runs the same archive as "tumwater archive" (holding the merge
@@ -270,20 +254,7 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
   }
   const archiveBacklogSlot = confirmSlot(paintArchiveBacklogButton);
   async function archiveBacklogClick() {
-    if (!archiveBacklogSlot.armed("archive-backlog")) {
-      archiveBacklogSlot.arm("archive-backlog");
-      return;
-    }
-    archiveBacklogSlot.disarm();
-    paintArchiveBacklogButton();
-    showFlash("Archiving the finished backlog entries…");
-    try {
-      const d = await postJson("/api/doctor-archive-backlog", {});
-      showFlash((d.ok ? "" : "error: ") + d.message);
-    } catch (err) {
-      showFlash("error: " + clientErrorMessage(err));
-    }
-    await fetchDoctor();
+    await postConfirmedHealthAction(archiveBacklogSlot, "archive-backlog", paintArchiveBacklogButton, "Archiving the finished backlog entries…", "/api/doctor-archive-backlog");
   }
   // The Health card's Commit backlog button: a single click, because the commit is the doctor's
   // own recommended repair and is reversible (unlike the two-click Kill orphans arm), POSTing
@@ -292,13 +263,7 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
   // clean), then re-running the checks so the uncommitted-backlog row repaints.
   async function commitBacklogClick() {
     showFlash("Committing the uncommitted backlog/brief files…");
-    try {
-      const d = await postJson("/api/doctor-commit-backlog", {});
-      showFlash((d.ok ? "" : "error: ") + d.message);
-    } catch (err) {
-      showFlash("error: " + clientErrorMessage(err));
-    }
-    await fetchDoctor();
+    await postSetting("/api/doctor-commit-backlog", {}, fetchDoctor);
   }
   // The Health card's Re-sync install button: a single click, because the re-sync is the doctor's
   // own recommended repair and is a no-op when the install already matches the lockfile, POSTing
@@ -307,13 +272,7 @@ export const GUI_CLIENT_SETTINGS_JS = String.raw `  // settings-view:start
   // the checks so the root-install row and the install amber alert clear once the drift is gone.
   async function resyncInstallClick() {
     showFlash("Re-syncing the root install…");
-    try {
-      const d = await postJson("/api/doctor-resync-install", {});
-      showFlash((d.ok ? "" : "error: ") + d.message);
-    } catch (err) {
-      showFlash("error: " + clientErrorMessage(err));
-    }
-    await fetchDoctor();
+    await postSetting("/api/doctor-resync-install", {}, fetchDoctor);
   }
   async function fetchSettings() {
     buildSettingsView();

package/dist/src/ui/gui/gui-client-team.js

@@ -48,8 +48,14 @@ export const GUI_CLIENT_TEAM_JS = String.raw `  // ---- sidebar: project, team s
         // markup alertParts() emits for the build alert; a fresh build's icon stays inert
         // decoration.
         const lead = stale ? restartButton(icon("refresh")) : icon("refresh");
-        rows += row(stale ? (d.build.restartBlocked ? "amber" : "blue") : "", lead,
-          "Version <span class='mono'>" + esc(shortSha(d.build.sha)) + "</span>" + (stale ? " · " + esc(plural(d.build.aheadCommits || 0, "commit")) + " behind" : ""),
+        // Main's tip moved the code on but no newer commit has passed main's check, so redeploy has
+        // nothing to move to (BuildStatus.waitingForCheck): amber, and the Main row below says why.
+        // No restart button — a forced restart would land on this same build.
+        const waiting = !stale && d.build.waitingForCheck;
+        rows += row(stale ? (d.build.restartBlocked ? "amber" : "blue") : waiting ? "amber" : "", lead,
+          "Version <span class='mono'>" + esc(shortSha(d.build.sha)) + "</span>" +
+            (stale ? " · " + esc(plural(d.build.aheadCommits || 0, "commit")) + " behind"
+              : waiting ? " · update waits for main's check" : ""),
           localizeInstants(("Running version" + (d.buildBadge || "").replace(/^, build/, "")).trim()));
       }
       if (d.mainCheck) {
@@ -95,13 +101,13 @@ export const GUI_CLIENT_TEAM_JS = String.raw `  // ---- sidebar: project, team s
               : "");
       }
       // The permit pool (plans/provider-concurrency.md §8): the payload's preformatted
-      // permitsBadge — running 5 of 8 · omlx 3/3 · claude 2/6 — upcased for the row's label
-      // style, the same reading the TUI/status header carries, so the two surfaces cannot
-      // drift. Empty on a map-less team, so the sidebar stays unchanged.
+      // permitsBadge — running 5 of 8 — upcased for the row's label style, the same reading
+      // the TUI/status header carries, so the two surfaces cannot drift. Present for any
+      // team with a published permit snapshot.
       if (d.permitsBadge) {
         const tok = String(d.permitsBadge).replace(/^ · /, "");
         rows += row("blue", icon("gauge"), esc(tok),
-          "Roles running at once out of the team limit, then each capped provider's own running/cap; a role waits to start when its provider is at its cap.");
+          "Roles running at once out of the team limit (maxConcurrent); a role waits to start when the team is at its limit.");
       }
       // The check-permit pool: the payload's checksBadge, present only while a check runs or waits.
       if (d.checksBadge) {

package/dist/src/ui/gui/gui-client.js

@@ -151,6 +151,12 @@ const FORMAT_JS = String.raw `  // format:start
   // section had the byte-identical map; a missing or non-array list paints nothing.
   const commitRowsHtml = (commits) =>
     (Array.isArray(commits) ? commits : []).map((c) => "<div class='mono clamp1'>" + esc(c.sha) + " " + esc(c.subject || "—") + "</div>").join("");
+  // The empty state for a missing main branch, shared by the Pending roster, its
+  // overlapping-files card, and the role drawer's Pending change section so the esced branch
+  // name and the wording cannot drift between them — change-render.ts's mainMissingPhrase,
+  // whose terminal spelling is lowercase/unescaped. The browser client cannot import that TS
+  // module, so this is its own copy, capitalized and esced for the HTML sentence it leads.
+  const mainBranchMissingPhrase = (mainBranch) => "Main branch " + esc(mainBranch) + " does not exist";
   // Title-case a phrase's first character and keep the rest — backend-traits.ts's
   // backendDisplayName rule, the one home of the upcasing gui-client-model.ts's result labels
   // and gui-client-history.ts's window options each inlined, so a label cannot drift between
@@ -226,7 +232,7 @@ const FORMAT_JS = String.raw `  // format:start
     // phase rather than throwing: the browser copy is untyped, and its sibling phaseInfo/
     // roleRank already coerce the same way, so one bad row must not blank the whole table.
     const phase = String(l.phase || "");
-    const active = isActivePhase(phase) || phase.startsWith("waiting to start") || phase.startsWith("waiting for ") || phase.startsWith("director working");
+    const active = isActivePhase(phase) || phase.startsWith("waiting to start") || phase.startsWith("director working");
     if (!teamRunning || active) return "-";
     const sec = Math.round((l.nextRunAt - Date.now()) / 1000);
     const suffix = l.yieldMultiplier > 1 ? " ×" + l.yieldMultiplier : "";

package/dist/src/ui/progress-data.js

@@ -1,10 +1,10 @@
 import path from "node:path";
-import { applyToolExecutionEvent, parsePiEventLine, toolCallCommand, } from "../pi/pi-event-line.js";
+import { applyToolExecutionEvent, foldPendingReply, messageUpdateHasContent, parsePiEventLine, piEventType, toolCallCommand, } from "../pi/pi-event-line.js";
 import { bufferedCommandStallMs, callBuffersOutput } from "../pi/command-shape.js";
 import { describeToolCall } from "../text/phrases.js";
 import { squash } from "../text/text.js";
 import { defaultConfig, liveConfig } from "../config/config.js";
-import { nonNegativeNumber } from "../files/json-object.js";
+import { nonNegativeNumber, parseJsonObject } from "../files/json-object.js";
 import { worktreesDir } from "../paths.js";
 import { statRoleLog, readCompleteLines, withTail } from "../files/tail.js";
 /** How much log tail a first observation scans initially (or after rotation); findSeedOffset
@@ -78,6 +78,7 @@ function freshProgress(quietMs, agent) {
         // stalledTool is deliberately NOT part of fresh: it is derived from wall-clock time on
         // every read, never folded from lines.
         openToolCalls: undefined,
+        pendingReply: undefined,
         currentWork: undefined,
         agent,
         quietMs,
@@ -86,7 +87,7 @@ function freshProgress(quietMs, agent) {
 /** The event types feedLine acts on — everything else (streaming deltas, turn/agent
  * bookkeeping) is ignored. Also passed as parsePiEventLine's pre-filter to skip JSON.parse for
  * pi lines whose type is verifiably not one of these; a new case in the switch must be added
- * here too. `tumwater_run` is the harness's own marker (src/agent/run-spawn.ts), read for its
+ * here too. `tumwater_run` is the harness's own marker (src/agent/agent-spawn.ts), read for its
  * run kind: a kind-bearing marker flips the demux and starts that accumulator fresh before
  * its `session` event lands, and a legacy label-only marker ("review") still flips the demux
  * to gate. */
@@ -96,59 +97,103 @@ const PROGRESS_TYPES = new Set([
     "tool_execution_start",
     "tool_execution_update",
     "tool_execution_end",
+    "message_start",
     "message_end",
 ]);
+/** pi's compact serialization of a message_start, up to the role's value. */
+const MESSAGE_START_ROLE = '{"type":"message_start","message":{"role":"';
+/** A new run starts: everything before it was a previous run — restore the at-time-zero state. */
+function applySessionEvent(progress) {
+    Object.assign(progress, freshProgress(progress.quietMs));
+}
+/** A tool execution starts: count the call, record its label as the last tool, and seed the
+ * open-call entry the stall flag reads. Track the open call for the stall flag — pi runs a
+ * message's tool calls concurrently by default, so several can be open at once and end in
+ * completion order. The state machine is shared with runPi's stall warning
+ * (src/pi/pi-watchdogs.ts); only the fallback label differs here. The full raw command rides
+ * along because the flag classifies the command's shape, and describeToolCall's label
+ * truncates at 32 chars — an operator past that point would be invisible there. */
+function applyToolStart(progress, event) {
+    progress.toolCalls += 1;
+    const label = event.toolName ? describeToolCall(event.toolName, event.args) : undefined;
+    if (label)
+        progress.lastTool = label;
+    applyToolExecutionEvent(progress.openToolCalls ??= [], event.type, event.toolCallId, event.partialResult, label ?? "tool", toolCallCommand(event.args));
+}
+/** A tool update or end folds through the same call: `applyToolExecutionEvent` reads `event.type`
+ * to decide what to do (a content-bearing update moves the activity clock; end closes the
+ * call), and both no-op when no call is tracked. Only content-bearing updates prove the
+ * command is alive — bash emits one empty-content update right after start, and a
+ * content-free keepalive must not mask a hang — a rule applyToolExecutionEvent owns. */
+function applyToolProgress(progress, event) {
+    if (progress.openToolCalls)
+        applyToolExecutionEvent(progress.openToolCalls, event.type, event.toolCallId, event.partialResult);
+}
+/** An assistant message ends: count the turn and fold usage/peak/context and the first work item.
+ * Guard each count like pi-stream's usageNumber does: a string-serialized or corrupt wire value
+ * would otherwise poison the live cell — `+=` would concatenate output into a string and
+ * Math.max would yield NaN. An unusable total keeps the previous context (this cell is "latest
+ * value"), while output and the peak floor treat it as absent. The first text the role speaks
+ * in this run is its work item ("I'll implement plan X"); later messages never replace it. */
+function applyAssistantTurn(progress, event) {
+    if (event.message?.role !== "assistant")
+        return;
+    progress.turns += 1;
+    const usage = event.message.usage;
+    if (usage) {
+        progress.contextTokens = nonNegativeNumber(usage.totalTokens, progress.contextTokens);
+        progress.outputTokens += nonNegativeNumber(usage.output, 0);
+        progress.peakContextTokens = Math.max(progress.peakContextTokens, nonNegativeNumber(usage.totalTokens, 0));
+    }
+    if (!progress.currentWork)
+        progress.currentWork = workItemFromContent(event.message.content);
+}
 /** Apply one parsed progress event to a progress object (mutates it). */
 function feedLine(progress, event) {
     switch (event.type) {
         case "session": // A new run starts: everything before it was a previous run — restore the at-time-zero state.
-            Object.assign(progress, freshProgress(progress.quietMs));
+            applySessionEvent(progress);
             break;
-        case "tool_execution_start": {
-            progress.toolCalls += 1;
-            const label = event.toolName ? describeToolCall(event.toolName, event.args) : undefined;
-            if (label)
-                progress.lastTool = label;
-            // Track the open call for the stall flag — pi runs a message's tool calls concurrently
-            // by default, so several can be open at once and end in completion order. The state
-            // machine is shared with runPi's stall warning (src/pi/pi-watchdogs.ts); only the
-            // fallback label differs here. The full raw command rides along because the flag
-            // classifies the command's shape, and describeToolCall's label truncates at 32 chars —
-            // an operator past that point would be invisible there.
-            applyToolExecutionEvent(progress.openToolCalls ??= [], event.type, event.toolCallId, event.partialResult, label ?? "tool", toolCallCommand(event.args));
+        case "tool_execution_start":
+            applyToolStart(progress, event);
             break;
-        }
-        // Updates and ends fold through the same call: `applyToolExecutionEvent` reads `event.type`
-        // to decide what to do (a content-bearing update moves the activity clock; end closes the
-        // call), and both no-op when no call is tracked. Only content-bearing updates prove the
-        // command is alive — bash emits one empty-content update right after start, and a
-        // content-free keepalive must not mask a hang — a rule applyToolExecutionEvent owns.
         case "tool_execution_update":
         case "tool_execution_end":
-            if (progress.openToolCalls)
-                applyToolExecutionEvent(progress.openToolCalls, event.type, event.toolCallId, event.partialResult);
+            applyToolProgress(progress, event);
+            break;
+        case "message_start":
+            applyReplyEvent(progress, event);
             break;
         case "message_end":
-            if (event.message?.role === "assistant") {
-                progress.turns += 1;
-                const usage = event.message.usage;
-                if (usage) {
-                    // Guard each count like pi-stream's usageNumber does: a string-serialized or corrupt
-                    // wire value would otherwise poison the live cell — `+=` would concatenate output into
-                    // a string and Math.max would yield NaN. An unusable total keeps the previous context
-                    // (this cell is "latest value"), while output and the peak floor treat it as absent.
-                    progress.contextTokens = nonNegativeNumber(usage.totalTokens, progress.contextTokens);
-                    progress.outputTokens += nonNegativeNumber(usage.output, 0);
-                    progress.peakContextTokens = Math.max(progress.peakContextTokens, nonNegativeNumber(usage.totalTokens, 0));
-                }
-                // The first text the role speaks in this run is its work item ("I'll implement plan X");
-                // later messages never replace it.
-                if (!progress.currentWork)
-                    progress.currentWork = workItemFromContent(event.message.content);
-            }
+            applyAssistantTurn(progress, event);
+            applyReplyEvent(progress, event);
             break;
     }
 }
+/** A message starts or ends: fold it into the pending-reply state. A request opened before this
+ * observer attached is stamped with pi's own timestamp on the message, not with "now", so a
+ * dashboard started mid-wait still shows the whole wait. */
+function applyReplyEvent(progress, event) {
+    const sent = event.message?.timestamp;
+    const now = typeof sent === "number" && Number.isFinite(sent) ? sent : Date.now();
+    progress.pendingReply = foldPendingReply(progress.pendingReply, event, { now });
+}
+/** The raw-line step both feeds take before parsing (`line` already trimmed), true when the line
+ * needs nothing more. A streaming delta (most of a pi log) is consumed without a parse unless a
+ * model request is still waiting on its answer: then the first content-bearing delta is that
+ * answer. A message_start whose compact prefix verifiably names a non-assistant role (a user or
+ * tool-result message, whose content can run to tens of KB) is consumed unparsed too: only an
+ * assistant message_start opens a request. */
+function consumedUnparsed(progress, line) {
+    if (piEventType(line) === "message_update") {
+        if (progress.pendingReply) {
+            const hasContent = messageUpdateHasContent(parseJsonObject(line));
+            progress.pendingReply = foldPendingReply(progress.pendingReply, { type: "message_update" }, { hasContent });
+        }
+        return true;
+    }
+    return line.startsWith(MESSAGE_START_ROLE) && !line.startsWith('assistant"', MESSAGE_START_ROLE.length);
+}
 /** Parse pi event lines of ONE run (the `tumwater_run` marker is ignored; the run's
  * `session` event resets the accumulator). Exported for tests; readLiveProgress routes
  * through feedDemuxed instead, since a real role log can interleave two runs' lines. A
@@ -156,7 +201,10 @@ function feedLine(progress, event) {
 export function parseProgress(lines, quietMs) {
     const progress = freshProgress(quietMs);
     for (const line of lines) {
-        const event = parsePiEventLine(line, PROGRESS_TYPES);
+        const trimmed = line.trim();
+        if (consumedUnparsed(progress, trimmed))
+            continue;
+        const event = parsePiEventLine(trimmed, PROGRESS_TYPES);
         if (event)
             feedLine(progress, event);
     }
@@ -164,6 +212,7 @@ export function parseProgress(lines, quietMs) {
     // exists here so callers that pass a hand-built tail through workingDetail see the same
     // shape readLiveProgress returns.
     progress.stalledTool = stalledToolLabel(progress.openToolCalls);
+    progress.unansweredReply = unansweredReply(progress.pendingReply);
     return progress;
 }
 /** The configured threshold for flagging an open tool call as stalled, in ms (0 when
@@ -200,6 +249,16 @@ export function stalledToolLabel(open, now = Date.now(), stallMs = defaultConfig
     }
     return undefined;
 }
+/** How long `pending` has waited and over how many attempts, once that wait reaches `stallMs` —
+ * the in-flight cell's "no model reply" flag, on the same threshold runPi's unanswered-request
+ * warning uses (src/pi/pi-watchdogs.ts), so the state cell and the event feed agree. `now` and
+ * `stallMs` are injectable for tests. */
+export function unansweredReply(pending, now = Date.now(), stallMs = defaultConfig().toolCallStallSeconds * 1000) {
+    if (!pending || stallMs <= 0)
+        return undefined;
+    const waitedMs = now - pending.since;
+    return waitedMs >= stallMs ? { waitedMs, attempts: pending.attempts } : undefined;
+}
 /** Fold one raw log line into a role log's per-kind tail state (mutates it): the harness's
  * `tumwater_run` marker or a `session` event switches which accumulator following lines fold
  * into. A marker carries the run's kind, so a `session` preceded by one keeps that kind even
@@ -210,7 +269,10 @@ export function stalledToolLabel(open, now = Date.now(), stallMs = defaultConfig
  * run's turns/context can never show in the new run's cell. Everything else folds into the
  * current kind's accumulator. Non-JSON noise is skipped. */
 function feedDemuxed(tail, line, gateCwd) {
-    const event = parsePiEventLine(line, PROGRESS_TYPES);
+    const trimmed = line.trim();
+    if (consumedUnparsed(tail[tail.cur], trimmed))
+        return;
+    const event = parsePiEventLine(trimmed, PROGRESS_TYPES);
     if (!event)
         return; // Blank, unparseable, or a type this feed does not act on.
     if (event.type === "session") {
@@ -251,7 +313,7 @@ function feedDemuxed(tail, line, gateCwd) {
  * run in the role's own worktree, the default; `gate` — the review gate's runs in a leased pool
  * slot, what the reviewing cell shows), or null when there is no log yet. The raw log is
  * append-only while pi runs and every run starts with a `tumwater_run` marker
- * (src/agent/run-spawn.ts), so after seeding from the tail window once we only read and parse
+ * (src/agent/agent-spawn.ts), so after seeding from the tail window once we only read and parse
  * bytes appended since the last poll — observers that call this every second (TUI, GUI) stop
  * rescanning up to TAIL_BYTES
  * of JSON per role per poll. */
@@ -269,6 +331,7 @@ export function readLiveProgress(root, role, kind = "author") {
     // observer first saw the log stamps "now" at seed, so it cannot be flagged retroactively;
     // the mtime-based "no pi output" flag covers late observers.
     progress.stalledTool = stalledToolLabel(progress.openToolCalls, Date.now(), toolCallStallMs(root), progress.agent);
+    progress.unansweredReply = unansweredReply(progress.pendingReply, Date.now(), toolCallStallMs(root));
     // Copy the open-call entries: feedLine mutates the stored tail value in place — an
     // un-copied collection would alias one mutable structure across every frame ever returned
     // AND with the live tail state.