tumwater 0.4.2 → 0.4.3

package/dist/src/run/acceptance-greps.js

@@ -39,56 +39,99 @@ export function emptyGrepCriteria(body) {
  * shell syntax (an unquoted `|;&<>$()` or backtick) or leaves a quote open. Nothing runs through
  * a shell, so `*` stays literal. */
 export function grepArgv(cmd) {
-    const words = [];
-    let cur = "";
-    let inWord = false;
-    let quote = null;
-    for (let i = 0; i < cmd.length; i++) {
-        const c = cmd[i];
-        if (quote === "'") {
-            if (c === "'")
-                quote = null;
-            else
-                cur += c;
-        }
-        else if (quote === '"') {
-            const next = cmd[i + 1];
-            if (c === "\\" && (next === '"' || next === "\\")) {
-                cur += next;
-                i++;
-            }
-            else if (c === '"')
-                quote = null;
-            else
-                cur += c;
-        }
-        else if (c === "'" || c === '"') {
-            quote = c;
-            inWord = true;
-        }
-        else if (c === "\\") {
-            if (i + 1 < cmd.length)
-                cur += cmd[++i];
-            inWord = true;
-        }
-        else if (/[|;&<>$()`]/.test(c)) {
-            return undefined;
-        }
-        else if (/\s/.test(c)) {
-            if (inWord)
-                words.push(cur);
-            cur = "";
-            inWord = false;
+    const words = splitShellWords(cmd);
+    return words === undefined ? undefined : grepInvocation(words);
+}
+/** Take one character at `i` inside a single-quoted run (`s.quote === "'"`): a `'` closes the
+ * quote, anything else stays literal. Returns the index after the character. Inside single
+ * quotes everything is literal. */
+function takeSingleQuoted(cmd, i, s) {
+    const c = cmd[i];
+    if (c === "'")
+        s.quote = null;
+    else
+        s.cur += c;
+    return i + 1;
+}
+/** Take one character at `i` inside a double-quoted run (`s.quote === '"'`): a `\\`-escaped
+ * `"` or `\\` appends the escaped character and consumes two characters, a `"` closes the
+ * quote, anything else stays literal. Returns the index after the consumed character(s). Double
+ * quotes honour only `\"` and `\\`. */
+function takeDoubleQuoted(cmd, i, s) {
+    const c = cmd[i];
+    const next = cmd[i + 1];
+    if (c === "\\" && (next === '"' || next === "\\")) {
+        s.cur += next;
+        return i + 2;
+    }
+    if (c === '"')
+        s.quote = null;
+    else
+        s.cur += c;
+    return i + 1;
+}
+/** Take one character at `i` outside any quote, or return `undefined` when it is refused shell
+ * syntax: an unquoted `'`/`"` opens the quote and marks a word, an unquoted `\\` appends the
+ * next character (if any) and marks a word, an unquoted `|;&<>$()` or backtick refuses the
+ * command, whitespace ends a word (pushing `cur` when one is open) and resets the buffer, and
+ * anything else appends and marks a word. Returns the index after the consumed character(s), or
+ * `undefined` for the shell refusal. */
+function takeUnquoted(cmd, i, s) {
+    const c = cmd[i];
+    if (c === "'" || c === '"') {
+        s.quote = c;
+        s.inWord = true;
+        return i + 1;
+    }
+    if (c === "\\") {
+        if (i + 1 < cmd.length) {
+            s.cur += cmd[i + 1];
+            s.inWord = true;
+            return i + 2;
         }
+        s.inWord = true;
+        return i + 1;
+    }
+    if (/[|;&<>$()`]/.test(c))
+        return undefined;
+    if (/\s/.test(c)) {
+        if (s.inWord)
+            s.words.push(s.cur);
+        s.cur = "";
+        s.inWord = false;
+        return i + 1;
+    }
+    s.cur += c;
+    s.inWord = true;
+    return i + 1;
+}
+/** Walk the whole command, dispatching each character to the quote-aware helper, and reject an
+ * unterminated quote. Returns the word list. */
+function splitShellWords(cmd) {
+    const s = { words: [], cur: "", inWord: false, quote: null };
+    let i = 0;
+    while (i < cmd.length) {
+        if (s.quote === "'")
+            i = takeSingleQuoted(cmd, i, s);
+        else if (s.quote === '"')
+            i = takeDoubleQuoted(cmd, i, s);
         else {
-            cur += c;
-            inWord = true;
+            const next = takeUnquoted(cmd, i, s);
+            if (next === undefined)
+                return undefined;
+            i = next;
         }
     }
-    if (quote !== null)
+    if (s.quote !== null)
         return undefined;
-    if (inWord)
-        words.push(cur);
+    if (s.inWord)
+        s.words.push(s.cur);
+    return s.words;
+}
+/** The shape pick: what invocation does this word list name? `git grep …` gives file `git` and
+ * the args after `git`; `grep …` gives file `grep` and the args after `grep`; anything else is
+ * not a grep we run. */
+function grepInvocation(words) {
     if (words[0] === "git" && words[1] === "grep")
         return { file: "git", args: words.slice(1) };
     if (words[0] === "grep")

package/dist/src/run/run-apply.js

@@ -46,7 +46,7 @@ export const ERROR_STREAK_WARN = 3;
 export function errorStreakAtWarn(s) {
     return (s.consecutiveErrors ?? 0) >= ERROR_STREAK_WARN;
 }
-/** Consecutive failed runs after which the error-streak circuit breaker (src/gates/streak-gate.ts)
+/** Consecutive failed runs after which the error-streak circuit breaker (src/gates/streak-gates.ts)
  * auto-pauses the role through the per-role pause marker — the same act-on-it escalation the
  * budget gate and the pause gates perform, applied to a role failing on its own cause. Ten,
  * not the warn bar: at 3 the failure is diagnosed but possibly transient, and by run 4 the
@@ -68,6 +68,13 @@ export const CUT_OFF_RESUME_LIMIT = 3;
  * consumed 44% of the team over two days). Mirrors CUT_OFF_RESUME_LIMIT; the streak itself
  * keeps counting (RunnerState.quietKillStreak) so one warning per episode can be raised. */
 export const QUIET_KILL_RESUME_LIMIT = 3;
+/** Bump a streak counter to `current + 1` when `hit`, and reset it to 0 otherwise — the one
+ * home of the cut-off, quiet-kill and no-change streaks' shared shape in applyRunOutcome, so
+ * the three count identically. (The consecutive-error streak does NOT share it: it resumes
+ * from a `queued`-ended run rather than resetting, so it keeps its own longer arm.) */
+function bumpOrResetStreak(current, hit) {
+    return hit ? (current ?? 0) + 1 : 0;
+}
 /** Record a finished run on the role's state and schedule its next run from the outcome.
  * Split out of RoleRunner.run() (runner.ts) so the scheduling policy — which outcomes retry
  * promptly, which back off and on which ladder, how cut-off resumes are bounded — sits with
@@ -78,11 +85,10 @@ export const QUIET_KILL_RESUME_LIMIT = 3;
 export function applyRunOutcome(s, cfg, role, outcome) {
     s.running = false;
     s.parkedSince = undefined;
-    s.parkedOn = undefined;
     // The cut-off streak counts EVERY consecutive run truncated at the context ceiling, past the
     // resume limit too: the next fresh run's prompt names how many attempts the window has eaten
     // (buildCutOffNote), so the count must not freeze at the limit. Any other outcome resets it.
-    s.cutOffStreak = outcome.cutOff ? (s.cutOffStreak ?? 0) + 1 : 0;
+    s.cutOffStreak = bumpOrResetStreak(s.cutOffStreak, outcome.cutOff);
     // The error streak counts consecutive failed runs; any other result resets it
     // (BUGS.md 2026-09-15: 44 identical failures raised no alarm). A run whose leftover
     // recovery re-queued a pin its last merge failed counts too, even though the run
@@ -106,7 +112,7 @@ export function applyRunOutcome(s, cfg, role, outcome) {
     // The quiet-kill streak counts consecutive watchdog kills; any other result resets it.
     // run-finalize.ts warns once when it crosses QUIET_KILL_RESUME_LIMIT, and the branch below uses
     // it to bound how many times a starved session is resumed (BUGS.md 2026-09-18).
-    s.quietKillStreak = outcome.result === "quiet_killed" ? (s.quietKillStreak ?? 0) + 1 : 0;
+    s.quietKillStreak = bumpOrResetStreak(s.quietKillStreak, outcome.result === "quiet_killed");
     // The no-change streak counts consecutive completed runs that ended `no_change` (the
     // resting state cell's ` · no change ×N` suffix — status-model.ts rolePhase). Any other
     // completed result resets it, so a role that merges between no-ops never shows a stale
@@ -115,7 +121,7 @@ export function applyRunOutcome(s, cfg, role, outcome) {
     // `quiet_killed`/`user_aborted` all reset it and only a `no_change` run grows it.
     // Observational only — never warns, unlike the error/quiet-kill streaks: a legitimately
     // idle maintenance role with an empty backlog can hold a long streak and that is expected.
-    s.noChangeStreak = outcome.result === "no_change" ? (s.noChangeStreak ?? 0) + 1 : 0;
+    s.noChangeStreak = bumpOrResetStreak(s.noChangeStreak, outcome.result === "no_change");
     // The yield ring records the result beside the streaks: a merge or a counted empty
     // stretches the role's min-run gap (yieldMultiplier, read by isEligible), an error-class
     // result is skipped entirely — no evidence either way (yield-scaled clocks, PLANS.md).
@@ -329,7 +335,7 @@ export function applyMergeOutcome(s, result, change) {
         // leave the streak unchanged and keep the fast minimum-interval retry the queued run
         // scheduled. This merge outcome is the accumulation point (the authoring run ends
         // `queued`, which no longer resets the streak, see applyRunOutcome) — the same field the
-        // warn, the breaker (src/gates/streak-gate.ts), and the error-storm observation
+        // warn, the breaker (src/gates/streak-gates.ts), and the error-storm observation
         // (src/team/team-polls.ts) already read. No new machinery, no new constants: the warn
         // bar and the breaker bar are ERROR_STREAK_WARN and ERROR_STREAK_BREAKER themselves.
         if (s.revision === undefined) {

package/dist/src/run/run-detail-data.js

@@ -46,45 +46,59 @@ export function readRunDetail(root, role, runNumber) {
     // same bound.
     const all = readEvents(root, HISTORY_SCAN_MAX_EVENTS);
     const events = all.filter((e) => e.source === role);
-    // Newest run_start for this role+run: the block's lower bound.
-    let startIdx = -1;
-    for (let i = events.length - 1; i >= 0; i--) {
-        const e = events[i];
-        if (e.type === "run_start" && e.run === runNumber) {
-            startIdx = i;
-            break;
-        }
-    }
+    const startIdx = newestRunStartIndex(events, runNumber);
     if (startIdx < 0) {
         // The start is gone (rotation) or the run never ran. A surviving run_end for the same
         // number still answers — unpaired, undated at the front — else there is no such run here.
-        for (let i = events.length - 1; i >= 0; i--) {
-            const e = events[i];
-            if (e.type === "run_end" && e.run === runNumber)
-                return detailFrom(root, role, runNumber, all, events, [e], e, null);
-        }
+        const loneEnd = newestRunEnd(events, runNumber);
+        if (loneEnd !== null)
+            return detailFrom(root, role, runNumber, all, events, [loneEnd], loneEnd, null);
         return null;
     }
     const start = events[startIdx];
-    // The block's upper bound: the first run_end for this run after the start ends it; a
-    // later run_start (this run's end lost to rotation) closes the block exclusive — the
-    // events after it belong to the next run, not this one. No end and no next start reads as
-    // in flight: everything since the start belongs to the open run.
-    let end = null;
-    let nextStart = null;
+    const { end, nextStart } = runBlockBounds(events, startIdx, runNumber);
+    const block = collectRunBlock(events, startIdx, end, nextStart);
+    return detailFrom(root, role, runNumber, all, events, block, end, start);
+}
+/** The newest run_start for this role+run — the block's lower bound — or -1 when none (the
+ * start rotated out or the run never ran). A backward scan: a counter reset can repeat a run
+ * number, and the operator asking by number means the most recent one. */
+function newestRunStartIndex(events, runNumber) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.type === "run_start" && e.run === runNumber)
+            return i;
+    }
+    return -1;
+}
+/** The newest surviving run_end for this role+run, or null. Read only on the no-start path:
+ * the start is gone (rotation) or the run never ran, but a surviving run_end still answers —
+ * unpaired, undated at the front — else there is no such run here. */
+function newestRunEnd(events, runNumber) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.type === "run_end" && e.run === runNumber)
+            return e;
+    }
+    return null;
+}
+/** The block's upper bound for the run opened by `startIdx`: the first run_end for this run
+ * after it ends the block; else a later run_start (this run's end lost to rotation) closes it
+ * exclusive — the events after belong to the next run, not this one. Neither afterwards reads
+ * as in flight: everything since the start belongs to the open run. */
+function runBlockBounds(events, startIdx, runNumber) {
     for (let i = startIdx + 1; i < events.length; i++) {
         const e = events[i];
-        if (e.type === "run_end" && e.run === runNumber) {
-            end = e;
-            break;
-        }
-        if (e.type === "run_start") {
-            nextStart = e;
-            break;
-        }
+        if (e.type === "run_end" && e.run === runNumber)
+            return { end: e, nextStart: null };
+        if (e.type === "run_start")
+            return { end: null, nextStart: e };
     }
-    // The block itself: the start event plus everything this role logged up to the bound —
-    // inclusive at a paired end, exclusive at a next run's start.
+    return { end: null, nextStart: null };
+}
+/** The block itself: the start event plus everything this role logged up to the bound —
+ * inclusive at a paired end, exclusive at a next run's start. */
+function collectRunBlock(events, startIdx, end, nextStart) {
     const block = [];
     for (let i = startIdx; i < events.length; i++) {
         const e = events[i];
@@ -92,19 +106,12 @@ export function readRunDetail(root, role, runNumber) {
             break;
         block.push(e);
     }
-    return detailFrom(root, role, runNumber, all, events, block, end, start);
+    return block;
 }
-/** Fill the payload around a collected block: usage from the run_end via eventUsage/usageText,
- * duration via runSpanMs against the role's own start map (the shared pairing helper, so this
- * view and the history rows cannot drift on what a span is), events oldest-first. */
-function detailFrom(root, role, runNumber, all, scoped, block, end, start) {
-    const usageNums = end === null ? { tokens: 0, costUsd: 0 } : eventUsage(end);
-    // The run_end's prompt-token total and its cache-read subset, corrupt-field-guarded reads
-    // (nonNegativeNumber, the same guard peakContextTokens applies) with the cache subset
-    // clamped to the total so the rendered share never exceeds 100%; 0 on an in-flight run.
-    const promptTokens = end === null ? 0 : nonNegativeNumber(end.promptTokens, 0);
-    const cacheReadTokens = end === null ? 0 : Math.min(nonNegativeNumber(end.cacheReadTokens, 0), promptTokens);
-    const preEditPromptTokens = end === null ? 0 : Math.min(nonNegativeNumber(end.preEditPromptTokens, 0), promptTokens);
+/** The verdict a run reports: the `run_end`'s outcome text, resolved through its merge for a
+ * run that ended `queued` (its result becomes the merge's result and `merge` the merge_done/
+ * merge_failed event carrying it) — the same fresh claim cursor walk the history rows use. */
+function runResultOf(end, scoped) {
     let result = end === null ? null : outcomeText(end);
     let merge = null;
     if (end !== null && result === "queued") {
@@ -117,42 +124,88 @@ function detailFrom(root, role, runNumber, all, scoped, block, end, start) {
             merge = resolved.outcome;
         }
     }
-    const mergedEvent = mergedEventOf(result, merge, scoped, block);
-    const detail = {
-        role,
-        run: runNumber,
+    return { result, merge };
+}
+/** The token and cost totals from the run_end; both zero on an in-flight run. */
+function runUsageOf(end) {
+    if (end === null)
+        return { tokens: 0, costUsd: 0 };
+    const { tokens, costUsd } = eventUsage(end);
+    return { tokens, costUsd };
+}
+/** The run's start/end timestamps and its span: `startTs`/`endTs` null when rotation cut that
+ * side, `durationMs` null whenever the pair is incomplete (no fabricated span). */
+function runTimesOf(start, end, scoped) {
+    return {
         startTs: start === null ? null : start.ts,
-        model: typeof start?.model === "string" && start.model.length > 0 ? start.model : null,
         endTs: end === null ? null : end.ts,
         durationMs: end === null ? null : runSpanMs(end, runStartMap(scoped)),
-        result,
-        tokens: usageNums.tokens,
-        costUsd: usageNums.costUsd,
-        usage: end === null ? "" : usageText(end),
-        // The peak is a corrupt-field-guarded read of the run_end (nonNegativeNumber, the same
-        // guard promptStatsFor applies); the window comes from the shared seamContextWindowForRole —
-        // same seam the role view and status table print — with loadConfigSafe falling back to
-        // defaults, so a broken tumwater.json yields a null window rather than failing this read-only
-        // view.
-        peakContextTokens: end === null ? 0 : nonNegativeNumber(end.peakContextTokens, 0),
-        // The run's prompt-token total and its cache-read subset, spread so a prompt-free or
-        // in-flight run keeps today's exact payload (no prompt/cache keys) and a cache subset > 0.
+    };
+}
+/** The model the run's `run_start` named, or null when it carried none or sits outside the scan. */
+function runModelOf(start) {
+    return typeof start?.model === "string" && start.model.length > 0 ? start.model : null;
+}
+/** The run's usage as its header line; empty when the run carries neither total. */
+function runUsageTextOf(end) {
+    return end === null ? "" : usageText(end);
+}
+/** The run_end's prompt-token total and its cache-read and pre-edit subsets, corrupt-field-
+ * guarded reads (nonNegativeNumber) with the subsets clamped to the total so the rendered share
+ * never exceeds 100%; all three keys absent on a prompt-free or in-flight run. */
+function runPromptFields(end) {
+    const promptTokens = end === null ? 0 : nonNegativeNumber(end.promptTokens, 0);
+    const cacheReadTokens = end === null ? 0 : Math.min(nonNegativeNumber(end.cacheReadTokens, 0), promptTokens);
+    const preEditPromptTokens = end === null ? 0 : Math.min(nonNegativeNumber(end.preEditPromptTokens, 0), promptTokens);
+    return {
         ...(promptTokens > 0 ? { promptTokens } : {}),
         ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
         ...(preEditPromptTokens > 0 ? { preEditPromptTokens } : {}),
-        // The run_end's ceiling-truncation flag, spread so an in-flight, older, or normal run
-        // keeps today's exact payload (no cutOff key).
-        ...(end !== null && end.cutOff === true ? { cutOff: true } : {}),
+    };
+}
+/** The run_end's ceiling-truncation flag, absent when the run did not cut off. */
+function runCutOffField(end) {
+    return end !== null && end.cutOff === true ? { cutOff: true } : {};
+}
+/** The run's peak context, a corrupt-field-guarded read of the run_end; 0 when in flight. */
+function runPeakContextOf(end) {
+    return end === null ? 0 : nonNegativeNumber(end.peakContextTokens, 0);
+}
+/** The end-of-run → on-main landing latency (the landing `merged` event's ts minus the run
+ * end's), absent without both an end and a landing event — or a landing before the end, or a
+ * negative difference. */
+function runMergeLatencyField(end, mergedEvent) {
+    return end !== null && mergedEvent !== null && mergedEvent.ts - end.ts >= 0
+        ? { mergeAfterRunMs: mergedEvent.ts - end.ts }
+        : {};
+}
+/** Fill the payload around a collected block: each concern resolves in its own named helper
+ * (runResultOf, runUsageOf, runTimesOf, runModelOf, runUsageTextOf, runPromptFields,
+ * runCutOffField, runPeakContextOf, runMergeLatencyField), and this assembles their results.
+ * Events stay oldest-first; usage/duration pair through the shared event-read helpers so this
+ * view and the history rows cannot drift on what a span is. */
+function detailFrom(root, role, runNumber, all, scoped, block, end, start) {
+    const { result, merge } = runResultOf(end, scoped);
+    const mergedEvent = mergedEventOf(result, merge, scoped, block);
+    const detail = {
+        role,
+        run: runNumber,
+        ...runTimesOf(start, end, scoped),
+        model: runModelOf(start),
+        ...runUsageOf(end),
+        usage: runUsageTextOf(end),
+        result,
+        // The window comes from the shared seamContextWindowForRole — same seam the role view and
+        // status table print — with loadConfigSafe falling back to defaults, so a broken
+        // tumwater.json yields a null window rather than failing this read-only view.
+        peakContextTokens: runPeakContextOf(end),
+        ...runPromptFields(end),
+        ...runCutOffField(end),
         contextWindow: seamContextWindowForRole(loadConfigSafe(root).config ?? defaultConfig(), role, root),
         events: block,
         merge,
         mergedSha: mergedShaOf(result, merge, scoped, block),
-        // The end-of-run → on-main landing latency (the landing `merged` event's ts minus the run
-        // end's), spread so a run without both an end and a landing event — or a landing before its
-        // end, or a negative difference — keeps today's exact payload (no key).
-        ...(end !== null && mergedEvent !== null && mergedEvent.ts - end.ts >= 0
-            ? { mergeAfterRunMs: mergedEvent.ts - end.ts }
-            : {}),
+        ...runMergeLatencyField(end, mergedEvent),
         reverted: null,
     };
     detail.reverted = revertedOf(detail, all);

package/dist/src/run/run-detail-render.js

@@ -31,30 +31,41 @@ export function runDetailStat(root, d) {
 export function runDetailPatch(root, d) {
     return runCommitShow(root, runCommitSha(d), "--patch");
 }
-/** The human view of a RunDetail: one summary line — result (or the in-flight/unpaired
- * marker), duration, usage, and the model the run started on when its `run_start` carried one
- * (after the usage, before the pinned-commit sha), plus the pinned commit sha when the block's
- * `merge_queued`/`merge_done` event carries one — then each event through formatEvent, the
- * shared renderer `logs` and the
- * TUI use, so the trail reads exactly like the feed it came from. A queued run whose merge
- * has finished shows that verdict in the header and ends with the merge's outcome line; a
- * leftover-recovery run's verdict is the failed attempt it re-queued (resolveQueuedResult),
- * logged before the run began, so that outcome line leads the trail instead — the trail stays
- * in time order. */
-export function renderRunDetail(d) {
-    const summary = [];
+/** The run's result cell, always present: the outcome label when the run finished, the
+ * in-flight/unpaired marker when it has not. Owns the first summary cell. */
+function runResultCell(d) {
     if (d.endTs === null)
-        summary.push(d.startTs === null ? "unpaired" : "in flight");
-    else
-        summary.push(d.result ? eventTypeLabel(d.result) : "?");
+        return d.startTs === null ? "unpaired" : "in flight";
+    return d.result ? eventTypeLabel(d.result) : "?";
+}
+/** The run's cut-off cell, the ceiling-truncation marker straight after the result cell. It
+ * only rides a completed end (cutOff is set from the run_end), so it can never follow in
+ * flight/unpaired. */
+function runCutOffCell(d) {
     // The ceiling-truncation marker, straight after the result cell. It only rides a
     // completed end (cutOff is set from the run_end), so it can never follow in flight/unpaired.
-    if (d.cutOff === true)
-        summary.push("cut off at the context ceiling");
-    if (d.durationMs !== null)
-        summary.push(shortSpanPhrase(d.durationMs));
-    if (d.usage !== "")
-        summary.push(d.usage);
+    if (d.cutOff !== true)
+        return null;
+    return "cut off at the context ceiling";
+}
+/** The run's duration cell. */
+function runDurationCell(d) {
+    if (d.durationMs === null)
+        return null;
+    return shortSpanPhrase(d.durationMs);
+}
+/** The run's usage cell. */
+function runUsageCell(d) {
+    if (d.usage === "")
+        return null;
+    return d.usage;
+}
+/** The run's prompt cell: the prompt-token total and the share the backend served from cache,
+ * the input side a cost-only header hides. The `${n}% cached` wording and rounding are the
+ * usage report's `Prompt tokens by role` share; a run with prompt tokens but no cache reads
+ * shows no parenthetical, and a run that reported neither keeps today's header byte-identical
+ * (the omit-when-zero convention). */
+function runPromptCell(d) {
     // The run's prompt-token total and the share the backend served from cache, the input
     // side a cost-only header hides. The `${n}% cached` wording and rounding are the usage
     // report's `Prompt tokens by role` share; a run with prompt tokens but no cache reads
@@ -62,37 +73,71 @@ export function renderRunDetail(d) {
     // byte-identical (the omit-when-zero convention).
     const prompt = d.promptTokens ?? 0;
     const cached = Math.min(d.cacheReadTokens ?? 0, prompt);
-    if (prompt > 0)
-        summary.push(cached > 0 ? `prompt ${compactTokens(prompt)} tok (${Math.round((100 * cached) / prompt)}% cached)` : `prompt ${compactTokens(prompt)} tok`);
+    if (prompt <= 0)
+        return null;
+    return cached > 0 ? `prompt ${compactTokens(prompt)} tok (${Math.round((100 * cached) / prompt)}% cached)` : `prompt ${compactTokens(prompt)} tok`;
+}
+/** The run's pre-edit prompt-token share, the `… before first edit` signal a cost-only header
+ * hides: how much of the prompt budget went out before the run made its first edit. Clamped
+ * to the total (run-detail-data.ts), written after the prompt cell and before the
+ * peak-context cell; a run that reported no pre-edit reading — and an in-flight run — keeps
+ * today's header byte-identical. */
+function runPreEditCell(d) {
     // The run's pre-edit prompt-token share, the `… before first edit` signal a cost-only
     // header hides: how much of the prompt budget went out before the run made its first
     // edit. Clamped to the total (run-detail-data.ts), written after the prompt cell and
     // before the peak-context cell; a run that reported no pre-edit reading — and an
     // in-flight run — keeps today's header byte-identical.
+    const prompt = d.promptTokens ?? 0;
     const preEdit = Math.min(d.preEditPromptTokens ?? 0, prompt);
-    if (preEdit > 0)
-        summary.push(`pre-edit ${compactTokens(preEdit)} tok`);
+    if (preEdit <= 0)
+        return null;
+    return `pre-edit ${compactTokens(preEdit)} tok`;
+}
+/** The run's peak-context cell against the seam's declared window, the one header every surface
+ * renders. Omitted when the run reported no peak (byte-identical to today's header). */
+function runPeakContextCell(d) {
     // The run's peak context against the seam's declared window, the one header every surface
     // renders. Omitted when the run reported no peak (byte-identical to today's header).
-    if ((d.peakContextTokens ?? 0) > 0)
-        summary.push(`peak ctx ${contextShareLabel(d.peakContextTokens ?? 0, d.contextWindow)}`);
-    if (d.model !== null)
-        summary.push(d.model);
+    if ((d.peakContextTokens ?? 0) <= 0)
+        return null;
+    return `peak ctx ${contextShareLabel(d.peakContextTokens ?? 0, d.contextWindow)}`;
+}
+/** The run's model cell, the model the run started on. */
+function runModelCell(d) {
+    if (d.model === null)
+        return null;
+    return d.model;
+}
+/** The summary cells in today's push order — result, cut-off, duration, usage, prompt,
+ * pre-edit, peak-context, model — each present only when its guard omits nothing. */
+function runSummaryCells(d) {
+    return [runResultCell(d), runCutOffCell(d), runDurationCell(d), runUsageCell(d), runPromptCell(d), runPreEditCell(d), runPeakContextCell(d), runModelCell(d)].filter((cell) => cell !== null);
+}
+/** The header's ` · `-separated suffix cells after the summary: the pinned commit, `merged
+ * as`, end-of-run landing latency, and the deliberate-revert verdict. */
+function runHeaderSuffixCells(d) {
     const sha = runCommitSha(d);
-    let header = `${roleLabel(d.role)} run #${d.run} — ${summary.join(" · ")}`;
+    const cells = [];
     if (sha !== null)
-        header += ` · commit ${shortSha(sha)}`;
+        cells.push(`commit ${shortSha(sha)}`);
     if (d.mergedSha !== null && d.mergedSha !== sha)
-        header += ` · merged as ${shortSha(d.mergedSha)}`;
+        cells.push(`merged as ${shortSha(d.mergedSha)}`);
     // The end-of-run → on-main landing latency, the per-change twin of the day report's `Merge
     // wait median`. shortSpanPhrase is the duration cell's renderer, so both spans read alike; a
     // run without the field (rejected/failed merge, in flight, landing rotated out, no-op
     // fast-forward) keeps today's header byte-identical.
     if (d.mergeAfterRunMs !== undefined)
-        header += ` · merged ${shortSpanPhrase(d.mergeAfterRunMs)} after the run`;
+        cells.push(`merged ${shortSpanPhrase(d.mergeAfterRunMs)} after the run`);
     if (d.reverted !== null) {
-        header += ` · reverted ${shortSha(d.reverted.sha)} (by operator)`; // vocabulary-ok: the deliberate-revert writer this header names
+        cells.push(`reverted ${shortSha(d.reverted.sha)} (by operator)`); // vocabulary-ok: the deliberate-revert writer this header names
     }
+    return cells;
+}
+/** The trail lines: the run's events through the shared formatEvent, with the merge outcome
+ * line placed before the first event when it predates it (a leftover-recovery run) and after
+ * the last otherwise, keeping the trail in time order. */
+function runTrailLines(d) {
     const trail = d.events.map(formatEvent);
     if (d.merge !== null) {
         const first = d.events[0];
@@ -101,7 +146,19 @@ export function renderRunDetail(d) {
         else
             trail.push(formatEvent(d.merge));
     }
-    return [header, ...trail].join("\n");
+    return trail;
+}
+/** The human view of a RunDetail: one summary line assembled from the per-cell and
+ * per-trail-step helpers — the result (or in-flight/unpaired marker), cut-off, duration,
+ * usage, prompt, pre-edit, peak-context and model cells, then the committed sha, `merged as`,
+ * merge-latency and reverted suffix cells — and each event through formatEvent. A queued run
+ * whose merge has finished shows that verdict in the header and ends with the merge's outcome
+ * line; a leftover-recovery run's verdict is the failed attempt it re-queued
+ * (resolveQueuedResult), logged before the run began, so that outcome line leads the trail
+ * instead — the trail stays in time order. */
+export function renderRunDetail(d) {
+    const header = [`${roleLabel(d.role)} run #${d.run} — ${runSummaryCells(d).join(" · ")}`, ...runHeaderSuffixCells(d)].join(" · ");
+    return [header, ...runTrailLines(d)].join("\n");
 }
 /** The transcript block of `--transcript`: the rendered lines of the agent runs that started in the
  * run's window, or `found: []` plus the `note` the text view prints in their place. The