tumwater 0.4.0 → 0.4.2

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

@@ -151,6 +151,23 @@ 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("");
+  // 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
+  // them. A leading em dash or other non-letter upcases to itself, and an empty string stays
+  // empty.
+  const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+  // A whole-hour window length as "1 hour"/"N hours", or "1 day"/"N days" for a whole
+  // number of days — the shared span the activity feed's and History view's stepped-window
+  // bounds both print (each previously spelled out the modulo/pluralization inline). A minute
+  // count that isn't a whole number of days prints hours (a stepped window is always whole
+  // hours), and the singular drops the trailing s.
+  const timeSpan = (ms) => { const d = ms % 86400000 === 0; const n = d ? ms / 86400000 : ms / 3600000; return n + (d ? " day" : " hour") + (n === 1 ? "" : "s"); };
+  // The "between X and Y ago" window-length phrase a stepped window's two bounds both print
+  // (newer first) — the Activity feed's feedWindowPhrase and the History view's histWindowPhrase
+  // previously spelled out the span-and-framing inline, so the two could drift on the words
+  // around timeSpan. One home keeps the stepped-window phrasing identical everywhere.
+  const betweenAgo = (newerMs, olderMs) => "between " + timeSpan(newerMs) + " and " + timeSpan(olderMs) + " ago";
   // human-seconds-fmt:start
   // Whole-second s/m/h/d label: <60 → Ns, <3600 → rounded Nm, <86400 → rounded Nh, else
   // rounded Nd — datetime.ts's humanSeconds, shared by every relative time on the page. A
@@ -179,12 +196,15 @@ const FORMAT_JS = String.raw `  // format:start
   const isActivePhase = (phase) => ACTIVE_PHASE_PREFIXES.some((p) => phase.startsWith(p));
   // active-phase-fmt:end
   // last-run-fmt:start
+  // Whole seconds between two epoch-ms instants, clamped at zero and rounded to the nearest
+  // second — datetime.ts's secondsSince/secondsUntil (the browser runtime cannot import
+  // them), shared by every relative time on the page so the clamp cannot drift between
+  // fmtLastRun, fmtAgo, and the spliced views' pause/wake/queue ages.
+  const secsSince = (sinceMs, now) => Math.max(0, Math.round((now - sinceMs) / 1000));
+  const secsUntil = (atMs, now) => Math.max(0, Math.round((atMs - now) / 1000));
   // The absolute local time of a run end with its age ("14:32:05 · 3m ago"), prefixed MM-DD
   // once older than a day; "-" when never ran — status-render.ts's lastRunCell.
-  // Whole elapsed seconds since an instant, clamped at zero and rounded to the nearest
-  // second — datetime.ts's secondsSince (the browser runtime cannot import it), shared by
-  // fmtLastRun and fmtAgo below so the clamp cannot drift between the page's ages.
-  const ageSec = (ts) => Math.max(0, Math.round((Date.now() - ts) / 1000));
+  const ageSec = (ts) => secsSince(ts, Date.now());
   const fmtLastRun = (ts) => {
     if (!ts) return "-";
     const d = new Date(ts);
@@ -222,6 +242,10 @@ const FORMAT_JS = String.raw `  // format:start
     return sec < 60 ? "just now" : humanSeconds(sec) + " ago";
   };
   const fmtClock = (ts) => new Date(ts).toLocaleString([], { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  // The local wall-clock HH:MM of an instant — datetime.ts's clockHm, shared by the operator
+  // view's window clock (returnsAt/heldUntil/~cap-at stamps) and the role drawer's ~cap-at
+  // stamp, which each spelled the two-digit getHours/getMinutes join inline.
+  const clockHm = (ms) => { const d = new Date(ms); return String(d.getHours()).padStart(2, "0") + ":" + String(d.getMinutes()).padStart(2, "0"); };
   // A run's duration: seconds under two minutes, then minutes, then hours. Each bucket is
   // chosen from the rounded count so a span just under a cutoff never prints "120s" or "120m".
   const fmtSpan = (ms) => {
@@ -238,6 +262,11 @@ const FORMAT_JS = String.raw `  // format:start
   // Server text sometimes carries ISO instants (a restart cooldown's deadline); show them in
   // the viewer's local time.
   const localizeInstants = (s) => String(s).replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/g, (iso) => fmtClock(Date.parse(iso)));
+  // Collapse runs of whitespace to a single space and trim — text.ts's squash, kept as this
+  // browser twin because the page cannot import the server module. The one shared home of the
+  // squash the drawer-config verbatim value's single-line clamp and the pending view's status
+  // suffix+clamp each spelled inline, so the two cannot drift on the collapse rule.
+  const squash = (s) => String(s).replace(/\s+/g, " ").trim();
   // format:end
 `;
 /** Shared DOM helpers: icons, pills, panels that repaint only on change, local preferences,

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

@@ -4,6 +4,12 @@
  * the browser script receives ICON_PATHS as data and builds the same markup for everything it
  * renders. */
 const FILLED = 'fill="currentColor" stroke="none"';
+/** The fixed icon set, keyed by the name every renderer passes: a `Record<string, string>`
+ * here would let a typo'd icon name (a misspelled key in `iconSvg`'s argument) compile and
+ * silently render an empty SVG in the dashboard — the literal key union below turns that
+ * into a compile error at every call site. The browser script still embeds the whole map
+ * (gui-client.ts JSON.stringify) and looks names up dynamically, so a dynamic name there is
+ * unchecked the same way its other data-driven lookups are. */
 export const ICON_PATHS = {
     grid: '<rect x="4" y="4" width="7" height="7" rx="1.5"/><rect x="13" y="4" width="7" height="7" rx="1.5"/><rect x="4" y="13" width="7" height="7" rx="1.5"/><rect x="13" y="13" width="7" height="7" rx="1.5"/>',
     list: `<path d="M9 6h11M9 12h11M9 18h11"/><circle cx="4.5" cy="6" r="1.2" ${FILLED}/><circle cx="4.5" cy="12" r="1.2" ${FILLED}/><circle cx="4.5" cy="18" r="1.2" ${FILLED}/>`,
@@ -36,7 +42,7 @@ export const ICON_PATHS = {
 };
 /** One icon's markup — the same shape the browser script's icon() builds. */
 export function iconSvg(name, extraClass = "") {
-    return `<svg class="i${extraClass ? ` ${extraClass}` : ""}" viewBox="0 0 24 24" aria-hidden="true">${ICON_PATHS[name] ?? ""}</svg>`;
+    return `<svg class="i${extraClass ? ` ${extraClass}` : ""}" viewBox="0 0 24 24" aria-hidden="true">${ICON_PATHS[name]}</svg>`;
 }
 /** The tumwater mark: two waves on a teal tile (the name is Chinook Jargon for "thumping water").
  * Also the page's favicon (as a data URI). */

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

@@ -86,7 +86,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-agent.ts), read for its
+ * here too. `tumwater_run` is the harness's own marker (src/agent/run-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. */
@@ -251,7 +251,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-agent.ts), so after seeding from the tail window once we only read and parse
+ * (src/agent/run-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. */

package/dist/src/ui/run-progress-model.js

@@ -59,11 +59,11 @@ function progressOfRun(s, p) {
  * <tool>" and "no agent output for <duration>" to the head — as a regex SOURCE string plus the
  * compiled matcher, single-homed beside the code that renders those phrases. Every consumer
  * that must recognize a stall inside a rendered phase label goes through these two, so the
- * server-side alert (team-alerts.ts) and the dashboard's browser twin (gui-client-model.ts,
+ * server-side alert (team-alert-status.ts) and the dashboard's browser twin (gui-client-model.ts,
  * interpolating the source into its String.raw script) cannot drift from the wording the cell
  * actually renders. */
 export const STALL_SOURCE = String.raw `tool call stalled[^·]*|no agent output for [^·]*`;
-/** STALL_SOURCE compiled — the server-side matcher (team-alerts.ts's stuck alert). */
+/** STALL_SOURCE compiled — the server-side matcher (team-alert-status.ts's stuck alert). */
 export const STALL_RE = new RegExp(STALL_SOURCE);
 /** The shared parts assembly for an in-flight state cell: `head` (the phase label with its
  * own elapsed — inFlightLabel for a run, the merge branch's own for a merge) plus turn,

package/dist/src/ui/status-model.js

@@ -1,7 +1,7 @@
 import { DIRECTOR_ROLE } from "../roles/roles.js";
 import { baseRoleOf } from "../roles/runner-ids.js";
 import { heldByMainRed } from "../status/status-polls.js";
-import { ERROR_STREAK_WARN, QUIET_KILL_RESUME_LIMIT } from "../run/run-apply.js";
+import { errorStreakAtWarn, QUIET_KILL_RESUME_LIMIT } from "../run/run-apply.js";
 import { readLiveProgress } from "./progress-data.js";
 import { quietWindowEnd } from "../scheduling/quiet-hours.js";
 import { yieldMultiplierFor } from "../scheduling/backoff.js";
@@ -76,12 +76,12 @@ export function idleClaimText(s, _phase) {
 export function onErrorStreak(s) {
     // An error streak at or past the warning threshold (run-apply.ts's ERROR_STREAK_WARN), or
     // a quiet-kill streak at the give-up threshold (BUGS.md 2026-09-18): the exact condition
-    // that makes rolePhase read "failing", split out so the team alert (team-alerts.ts) can
+    // that makes rolePhase read "failing", split out so the team alert (team-alert-status.ts) can
     // key its red "failing run after run" banner on the streak rather than on the rendered
     // phase — an in-flight run hides the streak behind a `working`/`merge` label (rolePhase
     // ranks running work above failing), but the alert must stay up while the role's next
     // run is in flight and clear only when the streak resets (BUGS.md 2026-10-14).
-    return ((s.consecutiveErrors ?? 0) >= ERROR_STREAK_WARN ||
+    return (errorStreakAtWarn(s) ||
         (s.lastResult === "quiet_killed" && (s.quietKillStreak ?? 0) >= QUIET_KILL_RESUME_LIMIT));
 }
 export function rolePhase(s, orchestratorRunning, root, budgetPaused = false, live, userPaused = false, merge, mainCheck, capPaused = false, quietHold, diskHeld = false, bootstrapHeld = false, maintenanceQuotaHold, permits, pausedUntilMs) {
@@ -190,14 +190,14 @@ export function rolePhase(s, orchestratorRunning, root, budgetPaused = false, li
     // snapshot's holder, like roleQuietPaused's window.
     if (maintenanceQuotaHold)
         return maintenanceQuotaHold;
-    // Main's own suite is known red at this role's last run: code-producing roles are blocked
-    // from authoring until main is green (the red-main baseline check). Shown before sleep/queue
+    // Main's own suite is known red at this role's last run: main_red is the last completed
+    // outcome. Shown before sleep/queue
     // because it explains why the role keeps waking and merge nothing; self-correcting, since
-    // each blocked run re-records main_red while red and a green wake overwrites lastResult.
+    // each run re-records main_red while red and a green wake overwrites lastResult.
     // Except a green wake that queues a change: `queued` is in flight, not a completed result,
     // so it leaves the main_red pair in place until its merge resolves (run-apply.ts's
-    // applyRunOutcome) — its stashed summary is the tell that the role's latest run got past
-    // the red-main gate, so main was green then and "main red" would be stale.
+    // applyRunOutcome) — its stashed summary is the tell that the role's latest run saw
+    // main green, so "main red" would be stale.
     // Except too when main's newest merge-scope check PASSED after this role's red run ended:
     // the team-level verdict is fresher than the role's own, so the label is stale until the
     // role's next run — which can be hours away (BUGS.md 2026-09-30). A check older than the
@@ -263,11 +263,21 @@ export function rolePhase(s, orchestratorRunning, root, budgetPaused = false, li
                 cell = "due";
         }
     }
-    // Two or more consecutive no-change runs earn the suffix (N=1 is a single quiet run —
-    // ordinary, not yet a pattern).
-    const streak = s.noChangeStreak ?? 0;
-    if (streak >= 2)
-        cell += ` · no change ×${streak}`;
+    // Two or more consecutive runs earn the suffix (N=1 is a single run — ordinary, not yet
+    // a pattern). A cut-off run is itself a `no_change`, so noChangeStreak counts a
+    // context-ceiling episode too — but the plain suffix would mislabel a window-burning
+    // episode as a benign idle one, so when the cut-off streak reads 2+ it wins: it names the
+    // costly cause (operator should split the task or raise the model's context window before
+    // the give-up). Observational only, like the no-change suffix — it never warns from here
+    // (the once-per-episode crossing warning comes from run-finalize.ts).
+    const cutOff = s.cutOffStreak ?? 0;
+    if (cutOff >= 2)
+        cell += ` · cut off ×${cutOff}`;
+    else {
+        const streak = s.noChangeStreak ?? 0;
+        if (streak >= 2)
+            cell += ` · no change ×${streak}`;
+    }
     return cell;
 }
 /** One role row's display derivation — the block both observer surfaces re-ran per role
@@ -337,7 +347,7 @@ function isBindingLimit(permits, key) {
 }
 /** Is this phase one of the PERMIT-HOLDER in-flight states — the rows an operator counts
  * against maxConcurrent? The three labels come from rolePhase: `working …`, `reviewing …`,
- * and the marker-driven `merge …` (merge queue 4/5) — a approved change waiting for the merge
+ * and the marker-driven `merge …` (merge queue 4/5) — an approved change waiting for the merge
  * slot (`approved, awaiting merge`) runs nothing, so it is not in flight. The running director's
  * `director working …` label is deliberately outside the set: the director never calls
  * `semaphore.acquire`, so the cap-mirroring rows are exactly the permit holders (BUGS.md
@@ -352,9 +362,9 @@ export function isActivePhase(phase) {
 /** A role's rank in the rendered tables, from its phase label (rolePhase): -1 a RUNNING
  * DIRECTOR — live work of its own, outside the maxConcurrent cap it bypasses, so it groups
  * apart and never inflates the permit-holder count (BUGS.md 2026-10-06); 0 live work —
- * working, reviewing, merge (isActivePhase); 1 work waiting in the pipeline — a approved change
+ * working, reviewing, merge (isActivePhase); 1 work waiting in the pipeline — an approved change
  * awaiting the merge slot, or a run parked awaiting a permit; 2 needs attention — failing, or
- * blocked by a red main; 3 paused — by the operator, by the budget, or by the role's own
+ * its last run read main red; 3 paused — by the operator, by the budget, or by the role's own
  * per-role cap; 4 everything else (idle: sleeping, queued, the director waiting for prompts, a
  * stopped team). The dashboard groups its role table by these ranks; the TUI/status table
  * orders by them.