tumwater 0.1.2 → 0.2.0

package/dist/src/history/history-data.js

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** Collection half of `tumwater history`: read the event log and distill the last N completed
  * ticks into TickRow — one row per tick, newest first, with the paired duration and the raw
  * usage numbers. The Markdown/table rendering of this data lives in history.ts, a pure
@@ -7,34 +8,71 @@
  * which change for different reasons — and keeps core data collection out of the
  * presentation layer, so a core consumer (as the GUI's /api/history already is) never
  * forces a core→ui import. */
-import { eventRole, eventTick, eventUsage, readEvents, tickSpanMs, tickStartMap } from "../events/event-read.js";
+import { eventRole, eventTick, eventUsage, readEvents, tickSpanMs, tickStartMap, tickStartModel, tickStartModelMap } from "../events/event-read.js";
 import { readEventsSinceJoined } from "../events/event-window.js";
 import { formatTimestamp } from "../text/datetime.js";
+import { eventTypeLabel } from "../events/event-labels.js";
+import { roleLabel } from "../roles/role-labels.js";
 import { squash, textOr } from "../text/text.js";
 import { shortSpanPhrase } from "../text/phrases.js";
 import { outcomeText, usageText } from "../events/event-format.js";
-import { groupBy } from "../collections.js";
+import { compareCodeUnits, groupBy } from "../collections.js";
 /** `history`'s default row count and ceiling. The default shows a working hour of a quiet
- * fleet; the ceiling bounds how much log one ask re-reads — more rows only re-read more log
+ * team; the ceiling bounds how much log one ask re-reads — more rows only re-read more log
  * with no added signal, so an explicit flag above it fails fast (the report's --days pattern). */
 export const HISTORY_DEFAULT_TICKS = 20;
 export const HISTORY_MAX_TICKS = 200;
 /** The outcome classes `tumwater history --result` and the dashboard's History filter both
- * speak: Changes (the tick landed or queued work), No change (it did nothing on purpose, or
- * the operator aborted it), Problems (everything else, e.g. error/rejected). The one canonical
+ * speak: Changes (the tick merged or queued work), No change (it did nothing on purpose, or
+ * the operator aborted it), Refused (a run that deliberately declined its entry), Problems
+ * (everything else, e.g. error/rejected). The one canonical
  * rule; the browser's copy in gui-client-history.ts is pinned to it by
  * test/gui-client-history.test.ts, so the two cannot drift. */
-export const HISTORY_RESULT_CLASSES = ["changes", "none", "problems"];
+export const HISTORY_RESULT_CLASSES = ["changes", "none", "refused", "problems"];
+/** The spelling each class has on `--result` and in the TUI filter: `changes` reads `merged`. */
+export const HISTORY_RESULT_FLAG_NAMES = { changes: "merged", none: "none", refused: "refused", problems: "problems" };
+/** Parse a `--result` value: a flag name, or a class name (so `changes` stays a hidden alias). */
+export function parseHistoryResultClass(raw) {
+    return HISTORY_RESULT_CLASSES.find((c) => raw === c || raw === HISTORY_RESULT_FLAG_NAMES[c]) ?? null;
+}
 /** Which outcome class a tick result falls in (the HISTORY_RESULT_CLASSES rule): `changed` and
- * `queued` are `changes`; `no_change`, `skipped`, and `user_aborted` are `none`; every other
- * result is `problems`. Pure; the canonical home the dashboard's client-side filter mirrors. */
+ * `queued` are `changes`; `no_change`, `skipped`, and `user_aborted` are `none`; `refused` is
+ * `refused`; every other result is `problems`. Pure; the canonical home the dashboard's
+ * client-side filter mirrors. */
 export function historyClass(result) {
     if (result === "changed" || result === "queued")
         return "changes";
     if (result === "no_change" || result === "skipped" || result === "user_aborted")
         return "none";
+    if (result === "refused")
+        return "refused";
     return "problems";
 }
+/** Tally rows per loop by historyClass, each row counted once. Loops come back in plain string
+ * order (not localeCompare) so the order is deterministic; `total` sums every loop. Pure. */
+export function summarizeTickRows(rows) {
+    const blank = (role) => ({ role, runs: 0, changes: 0, none: 0, refused: 0, problems: 0, tokens: 0, costUsd: 0, lastChangeTs: null });
+    const byLoop = new Map();
+    const total = blank("total");
+    for (const row of rows) {
+        let entry = byLoop.get(row.role);
+        if (!entry)
+            byLoop.set(row.role, (entry = blank(row.role)));
+        const cls = historyClass(row.result);
+        for (const t of [entry, total]) {
+            t.runs += 1;
+            t[cls] += 1;
+            t.tokens += row.tokens;
+            t.costUsd += row.costUsd;
+            if (row.durationMs !== null)
+                t.durationMs = (t.durationMs ?? 0) + row.durationMs;
+            if (cls === "changes")
+                t.lastChangeTs = Math.max(t.lastChangeTs ?? row.ts, row.ts);
+        }
+    }
+    const roles = [...byLoop.values()].sort((a, b) => compareCodeUnits(a.role, b.role));
+    return { roles, total };
+}
 /** How much of a tick's summary or error a row keeps. Long enough to name the work, short
  * enough that the row stays one terminal line next to its other columns. */
 const DETAIL_MAX = 72;
@@ -49,7 +87,7 @@ const DETAIL_MAX = 72;
 export const HISTORY_SCAN_MAX_EVENTS = 20_000;
 /** How far behind a since-shaped scan's cutoff the queued-row join reads its evidence: the
  * row set is ts-filtered to the cutoff, but a queued tick whose tick SPANS the cutoff logged
- * its `land_queued` pin before it (the pin is logged during the tick, the tick_end after it)
+ * its `merge_queued` pin before it (the pin is logged during the tick, the run_end after it)
  * — so the join evidence needs its own read reaching further back. Six hours outlasts any
  * tick the harness runs (every stage inside a tick is timeout-bounded); a tick that somehow
  * queued later than that keeps the raw label, the conservative fallback. The wider read shares
@@ -58,25 +96,28 @@ export const HISTORY_SCAN_MAX_EVENTS = 20_000;
 const TICK_ROW_JOIN_BACKSLACK_MS = 6 * 60 * 60 * 1000;
 export function tickRowCells(row) {
     return {
-        loop: row.loop,
-        tick: String(row.tick),
-        result: row.result,
+        loop: roleLabel(row.role),
+        tick: String(row.run),
+        result: eventTypeLabel(row.result),
+        model: row.model ?? "",
         duration: row.durationMs === null ? "—" : shortSpanPhrase(row.durationMs),
         usage: row.usage,
     };
 }
-/** One tick row's line: its timestamp, the five tickRowCells values, then the free-text detail,
- * joined by two spaces and stripped of trailing padding. This is the one home for the row's
- * column order and separator; renderRow (history.ts) passes a per-column padding function to
- * align the CLI table, while tickRowGrepHaystack below passes none. The tick cell's "#" prefix
- * rides outside the padding, so its column width measures the number alone. */
+/** One tick row's line: its timestamp, the six tickRowCells values (the model cell between
+ * the result and the duration), then the free-text detail, joined by two spaces and stripped
+ * of trailing padding. This is the one home for the row's column order and separator;
+ * renderRow (history-render.ts) passes a per-column padding function to align the CLI table,
+ * while tickRowGrepHaystack below passes none. The tick cell's "#" prefix rides outside the
+ * padding, so its column width measures the number alone. */
 export function tickRowLine(row, pad = (_c, v) => v) {
     const c = tickRowCells(row);
     return [
         row.time,
-        pad("loop", c.loop),
-        `#${pad("tick", c.tick)}`,
+        pad("loop", c.loop), // vocabulary-ok: column key, not shown
+        `#${pad("tick", c.tick)}`, // vocabulary-ok: column key, not shown
         pad("result", c.result),
+        pad("model", c.model),
         pad("duration", c.duration),
         pad("usage", c.usage),
         row.detail,
@@ -85,13 +126,15 @@ export function tickRowLine(row, pad = (_c, v) => v) {
         .trimEnd();
 }
 /** The `--grep` haystack for one rendered history row: tickRowLine's canonical unpadded row
- * line prefixed with the raw event type so stable ids (`tick_end`) are greppable the way logs
- * --grep's haystack carries `e.type`. Built per row because the filter runs before the widths of
- * the rows actually shown are known, and shared by `tumwater history --grep` and the dashboard's
+ * line prefixed with the raw event type so stable ids (`run_end`) are greppable the way logs
+ * --grep's haystack carries `e.type`, and followed by the raw role id and result code, which
+ * the row shows as `feature #2` and `no change`, so a script's grep on the code still
+ * matches. Built per row because the filter runs before the widths of the rows actually shown
+ * are known, and shared by `tumwater history --grep` and the dashboard's
  * /api/history?grep so the two cannot disagree on the rule. The row's cells and column order
  * come from tickRowCells and tickRowLine, the one home for each. */
 export function tickRowGrepHaystack(row) {
-    return `tick_end ${tickRowLine(row)}`;
+    return `run_end ${tickRowLine(row)} ${row.role} ${row.result}`;
 }
 /** The shared tick-grep rule: a case-insensitive substring match over tickRowGrepHaystack.
  * Four call sites apply it — `tumwater history --grep`, /api/history's window and count
@@ -101,95 +144,145 @@ export function tickRowsMatchingGrep(rows, pattern) {
     const needle = pattern.toLowerCase();
     return rows.filter((r) => tickRowGrepHaystack(r).toLowerCase().includes(needle));
 }
-/** The landing bookkeeping resolveQueuedResult joins over: per loop, the `land_queued` pins
- * and the `landed`/`land_failed` outcomes, each list oldest-first (the scan order). Exported
+/** The merge bookkeeping resolveQueuedResult joins over: per loop, the `merge_queued` pins
+ * and the `merge_done`/`merge_failed` outcomes, each list oldest-first (the scan order). Exported
  * as one helper with exactly two call sites — readTickRows' history-row join and the failure
  * digest's time-and-spend fold (time-spend.ts) — so the two collectors cannot disagree about
- * which events feed the join or in what order they sit: a third landing-bookkeeping event
+ * which events feed the join or in what order they sit: a third merge-bookkeeping event
  * type, or a changed order rule, is edited once here. Callers bucket only the events they
  * need; the digest folds its `review_rejected` reasons with its own pass.
  * Roles or cutoffs are the caller's concern: pass a role-scoped or wider-read event list and
  * the maps carry exactly that list's evidence. */
-export function bucketLandingEvents(events) {
-    const landQueuedByLoop = groupBy(events.filter((e) => e.type === "land_queued"), (e) => e.loop);
-    const outcomeByLoop = groupBy(events.filter((e) => e.type === "landed" || e.type === "land_failed"), (e) => e.loop);
-    return { landQueuedByLoop, outcomeByLoop };
+export function bucketMergeEvents(events) {
+    const mergeQueuedByLoop = groupBy(events.filter((e) => e.type === "merge_queued"), (e) => e.source);
+    const outcomeByLoop = groupBy(events.filter((e) => e.type === "merge_done" || e.type === "merge_failed"), (e) => e.source);
+    return { mergeQueuedByLoop, outcomeByLoop };
 }
-/** Resolve one queued tick row's eventual landing verdict: a "queued" tick_end carries no
- * result until its landing batch lands or fails, so the row joins its `end` tick_end to the
- * tick's land_queued pin and that pin's landed/land_failed outcome (both from the
- * bucketLandingEvents maps, oldest-first per loop). The claim cursor `claimTop` (mutated in
+/** Resolve one queued tick row's eventual merge verdict: a "queued" run_end carries no
+ * result until its merge batch merges or fails, so the row joins its `end` run_end to the
+ * tick's merge_queued pin and that pin's merge_done/merge_failed outcome (both from the
+ * bucketMergeEvents maps, oldest-first per loop). The claim cursor `claimTop` (mutated in
  * place) walks the pin list newest-first and hands each queued tick the newest unclaimed pin
- * at or before its end, so several queued ticks cannot claim one pin. Within that pin's
- * change the row takes the LAST landing attempt's verdict, not the first: a retriable result
- * (RETRIABLE_LANDING_RESULTS: review_error, merge_conflict, merge_blocked) keeps the pin and
- * leftover recovery re-enqueues it for another attempt, so a later recovery pin — and its
- * landed/land_failed — owns the real verdict. When main moved before the retry the vet's
- * syncPinToMain rebased the ref (landing-core.ts), so the recovery pin carries the rebased sha
- * while each attempt's own landed/land_failed logs its entry's authored sha (landing-slot.ts's
- * entry.sha): the attempts' shas differ, so the walk follows the pin sequence (isRecoveryPin),
- * not sha equality alone. It stops at a pin that is not a recovery re-enqueue — a fresh change
- * after a conflict-cap discard — so the row never credits a different change's verdict
- * (BUGS.md 2026-10-10). `joinStarts` maps loop#tick to its tick_start's ts; when `floorTs` (a
- * since-window's cutoff, null in the count view) sits after that start, the row's join
- * evidence is not whole in the windowed read and the row keeps its raw "queued" label (null).
- * A MISSING start needs no guard — it joins, because rotation drops a prefix, so every pin
- * older than the lost start is lost with it and nothing can be mis-claimed (and a skipped
- * tick has no start at all but is never queued). A landing with no outcome event in the join
- * set also keeps the raw label: the conservative fallback for a verdict simply not visible
- * here. Returns the outcome's result text and the landed sha, or null to keep the raw label.
- * Pure apart from the cursor it owns. */
-export function resolveQueuedResult(end, landQueuedByLoop, outcomeByLoop, claimTop, joinStarts, floorTs) {
+ * at or before its end, so several queued ticks cannot claim one pin.
+ *
+ * One change can take several merge attempts: a retriable result (RETRIABLE_MERGE_RESULTS:
+ * review_error, merge_conflict, merge_blocked) keeps the pin, and the role's next run — a
+ * leftover-recovery run that does no work of its own and ends in about a second — re-enqueues
+ * it (isRecoveryPin). The authoring run and the recovery runs resolve by different rules, so
+ * every attempt's verdict shows on exactly one row:
+ * - The run that authored the change (its pin is not a re-enqueue of a kept attempt) takes
+ *   the change's FINAL verdict, not its first attempt's: a retriable failure that recovery
+ *   later merges reads "changed" (BUGS.md 2026-10-10). While a re-enqueued attempt is still
+ *   pending the row keeps the raw "queued" label — the change is waiting to merge again, and
+ *   the failure before it already shows on the recovery run's row.
+ * - A recovery run takes the verdict of the attempt it re-enqueued — the retriable failure
+ *   that kept the pin and made the run happen (recoveredAttemptVerdict). So a change that
+ *   timed out in review seven times and was then rejected reads "rejected" once (the
+ *   authoring row) and "review failed" seven times (the authoring attempt's and six
+ *   recoveries' timeouts, each on the recovery row that followed it), not "rejected" on all
+ *   eight rows.
+ * When main moved before a retry the verification's syncPinToMain rebased the ref
+ * (merge-core.ts), so the recovery pin carries the rebased sha while each attempt's own
+ * merge_done/merge_failed logs its entry's sha (merge-slot.ts's entry.sha): the attempts' shas
+ * differ, so the authoring row's walk follows the pin sequence (isRecoveryPin), not sha
+ * equality alone. It stops at a pin that is not a recovery re-enqueue — a fresh change after a
+ * conflict-cap discard — so the row never credits a different change's verdict (BUGS.md
+ * 2026-10-10). A recovery pin whose previous attempt shows no retriable verdict (a crash
+ * left the commit unpinned or the merge unfinished, or that attempt sits outside the read) is
+ * the change's first visible attempt, so its row takes the authoring rule.
+ *
+ * `joinStarts` maps loop#tick to its run_start's ts; when `floorTs` (a since-window's cutoff,
+ * null in the count view) sits after that start, the row's join evidence is not whole in the
+ * windowed read and the row keeps its raw "queued" label (null). A MISSING start needs no
+ * guard — it joins, because rotation drops a prefix, so every pin older than the lost start is
+ * lost with it and nothing can be mis-claimed (and a skipped tick has no start at all but is
+ * never queued). A merge with no outcome event in the join set also keeps the raw label: the
+ * conservative fallback for a verdict simply not visible here. Returns the verdict's result
+ * text plus the pin and outcome of the attempt that produced it (and that pin's sha), or null
+ * to keep the raw label. Pure apart from the cursor it owns. */
+export function resolveQueuedResult(end, mergeQueuedByLoop, outcomeByLoop, claimTop, joinStarts, floorTs) {
     if (floorTs !== null) {
-        const startTs = joinStarts.get(`${end.loop}#${end.tick}`);
+        const startTs = joinStarts.get(`${end.source}#${end.run}`);
         if (startTs !== undefined && startTs < floorTs)
             return null;
     }
-    const queuedList = landQueuedByLoop.get(end.loop);
+    const queuedList = mergeQueuedByLoop.get(end.source);
     if (!queuedList || queuedList.length === 0)
         return null;
-    let top = claimTop.get(end.loop) ?? queuedList.length - 1;
+    let top = claimTop.get(end.source) ?? queuedList.length - 1;
     while (top >= 0 && queuedList[top].ts > end.ts)
         top--;
     if (top < 0)
         return null;
-    claimTop.set(end.loop, top - 1);
-    const outcomes = outcomeByLoop.get(end.loop) ?? [];
-    // One change can span several pins: a retriable landing failure keeps the pin and leftover
-    // recovery re-enqueues the ref for another attempt, so walk forward while the next pin is a
-    // recovery re-enqueue and resolve to the last attempt's verdict. `findLast` picks the newest
-    // same-sha outcome so an un-rebased retry (recovery re-enqueues the identical sha, logged by
-    // both pins) does not re-match the first attempt's outcome inside the recovery pin's walk.
-    // The returned pin/outcome ride the result so a caller correlating sibling evidence (the
-    // failure digest's review-failure message) can key on THIS attempt's position, not a sha a
-    // pre-review rebase may have moved (BUGS.md 2026-10-10).
+    claimTop.set(end.source, top - 1);
+    const outcomes = outcomeByLoop.get(end.source) ?? [];
+    // A recovery run's row: the attempt it re-enqueued, not the change's final verdict, so the
+    // final verdict shows once (on the authoring row) and each retriable failure once (here).
+    const recovered = recoveredAttemptVerdict(queuedList, top, outcomes);
+    if (recovered !== null)
+        return recovered;
+    // The authoring row: walk forward while the next pin is a recovery re-enqueue and resolve to
+    // the last attempt's verdict. `findLast` picks the newest same-sha outcome so an un-rebased
+    // retry (recovery re-enqueues the identical sha, logged by both pins) does not re-match the
+    // first attempt's outcome inside the recovery pin's walk. The returned pin/outcome ride the
+    // result so a caller correlating sibling evidence (the failure digest's review-failure
+    // message) can key on THIS attempt's position, not a sha a pre-review rebase may have moved
+    // (BUGS.md 2026-10-10).
     let idx = top;
     let resolved = null;
     for (;;) {
         const pin = queuedList[idx];
         const outcome = outcomes.findLast((o) => o.ts >= pin.ts && textOr(o.commit, "") === textOr(pin.commit, ""));
-        // No outcome on the tick's own pin: nothing visible yet, so keep the raw label. No outcome
-        // on a recovery pin the walk reached: the previous attempt's non-terminal verdict is still
-        // the last one visible, so return it rather than the raw label.
+        // No outcome on the tick's own pin, or on a recovery pin the walk reached: that attempt is
+        // still pending, so the change is waiting to merge — keep the raw label. The previous
+        // attempt's retriable verdict already shows on the recovery run's row.
         if (!outcome)
+            return null;
+        const verdict = attemptVerdict(pin, outcome);
+        if (verdict === null)
             return resolved;
-        const result = textOr(outcome.result, outcome.type === "landed" ? "changed" : "");
-        if (!result)
-            return resolved;
-        const verdict = { result, sha: textOr(pin.commit, ""), pin, outcome };
-        // A landing or a rejection ends the change (the pin is discarded, so no recovery pin can
+        // A merge or a rejection ends the change (the pin is discarded, so no recovery pin can
         // follow); any other verdict kept the pin, and the walk continues only if the next pin is
         // the recovery re-enqueue that kept it. Otherwise this attempt's verdict is the final one
         // visible.
-        const terminal = result === "changed" || result === "rejected";
-        if (terminal || !isRecoveryPin(queuedList[idx + 1]))
+        if (endsChange(verdict.result) || !isRecoveryPin(queuedList[idx + 1]))
             return verdict;
         resolved = verdict;
         idx += 1;
     }
 }
+/** The verdict one attempt's outcome carries, or null for a torn outcome with no result (a
+ * merge_failed whose result is missing or not text). A merge_done with no result is a merge. */
+function attemptVerdict(pin, outcome) {
+    const result = textOr(outcome.result, outcome.type === "merge_done" ? "changed" : "");
+    return result ? { result, sha: textOr(pin.commit, ""), pin, outcome } : null;
+}
+/** True when a verdict ends its change: a merge or a rejection discards the pin, so no recovery
+ * re-enqueue can follow it. Every other verdict (the retriable ones) kept the pin. The one rule
+ * both directions of resolveQueuedResult's chain read — the authoring row's walk forward and a
+ * recovery row's step back — so the two cannot disagree on where a change ends. */
+function endsChange(result) {
+    return result === "changed" || result === "rejected";
+}
+/** A recovery run's own row verdict: when the pin at `idx` is a recovery re-enqueue and the
+ * previous pin's attempt ended in a retriable verdict (the kept pin this run re-enqueued), that
+ * verdict, carrying the previous attempt's pin and outcome. The outcome is the newest one for
+ * the previous pin's sha logged between the two pins: recovery runs only after the previous
+ * attempt's outcome is written, and bounding at this pin keeps an un-rebased retry (both pins
+ * share a sha) from matching a LATER attempt's outcome. Null when the pin is not a recovery
+ * re-enqueue, or is one with no retriable attempt visible before it — a crash's unpinned or
+ * unfinished commit, or a previous pin outside the read — so the row takes the authoring rule. */
+function recoveredAttemptVerdict(queuedList, idx, outcomes) {
+    const pin = queuedList[idx];
+    const prev = queuedList[idx - 1];
+    if (prev === undefined || !isRecoveryPin(pin))
+        return null;
+    const outcome = outcomes.findLast((o) => o.ts >= prev.ts && o.ts <= pin.ts && textOr(o.commit, "") === textOr(prev.commit, ""));
+    const verdict = outcome === undefined ? null : attemptVerdict(prev, outcome);
+    return verdict === null || endsChange(verdict.result) ? null : verdict;
+}
 /** True when a pin re-enqueues the previous attempt's kept pin rather than starting a fresh
- * change. `recoverLeftover` (src/loop/leftover.ts) is the one `land_queued` producer whose
+ * change. `recoverLeftover` (src/loop/leftover.ts) is the one `merge_queued` producer whose
  * summary starts with this label, so a fresh change's pin after a conflict-cap discard ends
  * `resolveQueuedResult`'s walk. */
 function isRecoveryPin(pin) {
@@ -199,33 +292,35 @@ function isRecoveryPin(pin) {
  * readEvents returns them), filtered to `role` when given, newest first. Pure: the CLI, the
  * GUI, and the tests share this collector, and none of them writes anything. */
 export function tickRows(events, limit, role, join) {
-    const scoped = role === null ? events : events.filter((e) => e.loop === role);
+    const scoped = role === null ? events : events.filter((e) => e.source === role);
     // The start pairing is the shared helper (events.ts), so history's dash-on-unpaired rule
     // and the digest's fold cannot drift into different notions of a tick's span.
     const starts = tickStartMap(scoped);
-    // The landing bookkeeping resolveQueuedResult joins over: per loop, the land_queued pins
-    // (oldest first) and the landed/land_failed outcomes (oldest first). Both ride the role
+    const models = tickStartModelMap(scoped);
+    // The merge bookkeeping resolveQueuedResult joins over: per loop, the merge_queued pins
+    // (oldest first) and the merge_done/merge_failed outcomes (oldest first). Both ride the role
     // filter with their tick, so the scoped events hold them exactly when they hold the row.
     // A since-shaped scan hands a WIDER join read instead (readTickRowsSince): its cutoff cut
     // the pins of ticks that span it, so the maps read the unfiltered-by-cutoff evidence and
-    // resolveQueuedResult guards each claim on the row's tick_start being whole in that read.
+    // resolveQueuedResult guards each claim on the row's run_start being whole in that read.
     const joinScoped = join
         ? role === null
             ? join.events
-            : join.events.filter((e) => e.loop === role)
+            : join.events.filter((e) => e.source === role)
         : scoped;
     const joinStarts = join ? tickStartMap(joinScoped) : starts;
+    const joinModels = join ? tickStartModelMap(joinScoped) : models;
     const floorTs = join ? join.floorTs : null;
-    const { landQueuedByLoop, outcomeByLoop } = bucketLandingEvents(joinScoped);
+    const { mergeQueuedByLoop, outcomeByLoop } = bucketMergeEvents(joinScoped);
     const claimTop = new Map();
     const rows = [];
     for (let i = scoped.length - 1; i >= 0 && rows.length < limit; i--) {
         const e = scoped[i];
-        if (e?.type !== "tick_end")
+        if (e?.type !== "run_end")
             continue;
         const rawResult = outcomeText(e);
         const result = rawResult === "queued"
-            ? (resolveQueuedResult(e, landQueuedByLoop, outcomeByLoop, claimTop, joinStarts, floorTs)
+            ? (resolveQueuedResult(e, mergeQueuedByLoop, outcomeByLoop, claimTop, joinStarts, floorTs)
                 ?.result ?? rawResult)
             : rawResult;
         const usage = eventUsage(e);
@@ -234,9 +329,10 @@ export function tickRows(events, limit, role, join) {
             time: formatTimestamp(e.ts),
             tokens: usage.tokens,
             costUsd: usage.costUsd,
-            loop: eventRole(e),
-            tick: eventTick(e),
+            role: eventRole(e),
+            run: eventTick(e),
             result,
+            model: tickStartModel(e, join ? joinModels : models),
             durationMs: tickSpanMs(e, starts),
             usage: usageText(e),
             detail: squash(textOr(e.summary, textOr(e.error, "")), DETAIL_MAX),
@@ -246,23 +342,23 @@ export function tickRows(events, limit, role, join) {
 }
 /** The last `limit` completed ticks read from root's event log, filtered to `role` when
  * given (newest first) — the scan cmdHistory and the GUI's handleHistory share, so the two
- * surfaces cannot drift. A window twice the ask plus slack: tick_start lines and unrelated
- * events interleave with the tick_end rows scanned for, and a skipped tick's end rides a start
+ * surfaces cannot drift. A window twice the ask plus slack: run_start lines and unrelated
+ * events interleave with the run_end rows scanned for, and a skipped tick's end rides a start
  * that may sit outside any smaller window. Two shortfalls grow the window (and re-read) while
  * the scan filled it — `events.length >= window` means the log may hold older events — under
  * the same HISTORY_SCAN_MAX_EVENTS bound so one ask cannot scan without end:
  * - Rows fall short. A role filter dilutes the window (every other loop's events occupy it
- *   too), so a quiet role in a busy fleet must still get its last `limit` ticks whenever the
+ *   too), so a quiet role in a busy team must still get its last `limit` ticks whenever the
  *   retained log holds them — never a bare "no ticks yet" for a role whose ticks sit just
  *   past the first window.
- * - A row's tick_start went unpaired. The window boundary can cut inside a tick's own event
- *   block: every tick_end of the ask sits within the window but the oldest one's tick_start
+ * - A row's run_start went unpaired. The window boundary can cut inside a tick's own event
+ *   block: every run_end of the ask sits within the window but the oldest one's run_start
  *   sits just before it, so the row renders a dash though the log holds the start. Every
- *   tick_end the harness logs follows its tick_start (tick() logs the start before runTick,
+ *   run_end the harness logs follows its run_start (tick() logs the start before runTick,
  *   skipped results included), so an unpaired start is either just past the window or lost
  *   to rotation — growing re-pairs the former, and the latter only costs the bounded scan.
- *   (A queued row's landing verdict needs no growth: the landed/land_failed event sits
- *   after its tick_end, so any tail window holding the row holds the verdict too — or there
+ *   (A queued row's merge verdict needs no growth: the merge_done/merge_failed event sits
+ *   after its run_end, so any tail window holding the row holds the verdict too — or there
  *   is none yet, the genuinely-pending case that keeps the raw label.) */
 export function readTickRows(root, limit, role) {
     const key = `${root}\u0000${role ?? ""}\u0000${limit}`;
@@ -304,8 +400,8 @@ const TICK_ROW_WINDOW_MEMO_MAX = 256;
  * and coverage derived from the wide scan, so neither windowed surface can claim coverage the
  * other would hedge or key its read differently. The rows read the cutoff-filtered events, but
  * their queued-row join reads WIDER evidence (TICK_ROW_JOIN_BACKSLACK_MS): a queued tick whose
- * tick spans the cutoff logged its land_queued pin before the cutoff, and without the wider
- * read the row would either keep "Queued to land" after its change landed or misclaim an older
+ * tick spans the cutoff logged its merge_queued pin before the cutoff, and without the wider
+ * read the row would either keep "Queued to land" after its change merged or misclaim an older
  * tick's pin (BUGS.md 2026-09-30). The rows reuse the pure tickRows with limit =
  * events.length, so pairing, role filtering, and the dash-on-unpaired rule stay exactly the
  * count view's. Pure over root: reads the event log, writes nothing. */

package/dist/src/history/history-render.js

@@ -0,0 +1,76 @@
+// vocabulary: plain
+/** Rendering half of `tumwater history`: format a `TickRow[]`/summary — collected by
+ * history-data.ts — into the aligned table or `--summary` text `cmdHistory` (history.ts)
+ * prints. The sibling observing view report does the same (src/report/report.ts prints
+ * src/report/report-render.ts's Markdown), and this split keeps the same separation
+ * "what happened / how it prints" that report and failure draw: the command owns argument
+ * parsing and stdout, this module owns column widths and cell wording. The rows themselves
+ * live in history-data.ts because the grep haystack shares the row line. */
+import { formatTimestamp, humanSeconds } from "../text/datetime.js";
+import { roleLabel } from "../roles/role-labels.js";
+import { displayWidth, padToWidth } from "../text/text-width.js";
+import { compactTokens, usd } from "../text/format.js";
+import { tickRowCells, tickRowLine } from "./history-data.js";
+/** Each column's width from its unpadded cell. Text cells measure terminal display columns
+ * (displayWidth), not UTF-16 code units: a loop name holding CJK or emoji renders two columns
+ * per code point, and a code-unit padEnd lets that row's later columns drift right of its
+ * ASCII neighbors. The tick cell measures before its "#" prefix is added (the prefix rides
+ * outside the pad), and duration is ASCII, so both take plain length. */
+function widthsOf(cells) {
+    return {
+        loop: displayWidth(cells.loop),
+        tick: cells.tick.length,
+        result: displayWidth(cells.result),
+        model: displayWidth(cells.model),
+        duration: cells.duration.length,
+        usage: displayWidth(cells.usage),
+    };
+}
+/** The per-column maxima over every row the table shows — the widths derive from the rows
+ * actually shown, so a single-row table has no padding gap. */
+export function widestWidths(rows) {
+    const widths = { loop: 0, tick: 0, result: 0, model: 0, duration: 0, usage: 0 };
+    for (const row of rows) {
+        const w = widthsOf(tickRowCells(row));
+        widths.loop = Math.max(widths.loop, w.loop);
+        widths.tick = Math.max(widths.tick, w.tick);
+        widths.result = Math.max(widths.result, w.result);
+        widths.model = Math.max(widths.model, w.model);
+        widths.duration = Math.max(widths.duration, w.duration);
+        widths.usage = Math.max(widths.usage, w.usage);
+    }
+    return widths;
+}
+/** One aligned table line: fixed-width columns over the row set, then the free-text detail.
+ * Every cell is padded to its column's width even when empty — usage is the one cell that can
+ * be empty (a tick with neither tokens nor cost), and dropping it would pull the detail left,
+ * misaligning that row against its neighbors; tickRowLine strips only the trailing pad. The
+ * row's column order rides history-data.ts's tickRowLine, shared with the grep haystack so the
+ * two cannot disagree about which field sits where. */
+export function renderRow(row, widths) {
+    return tickRowLine(row, (column, value) => padToWidth(value, widths[column]));
+}
+/** The `--summary` text: a header, one line per loop, then the total line. The loop column pads to
+ * display width; each number column right-aligns under its header; the `time` column is the sum of
+ * each role's run spans, `—` when none of the role's rows carried a span; the last column,
+ * `last change`, is the newest change's timestamp (`—` when none) and is left-aligned, unpadded. */
+export function renderSummary(summary) {
+    const all = [...summary.roles, summary.total];
+    const loopWidth = Math.max(...["role", ...all.map((r) => roleLabel(r.role))].map(displayWidth));
+    const cols = ["runs", "changes", "none", "refused", "problems", "tokens", "cost", "time"];
+    const cell = (r, c) => c === "tokens"
+        ? compactTokens(r.tokens)
+        : c === "cost"
+            ? usd(r.costUsd)
+            : c === "time"
+                ? r.durationMs === undefined
+                    ? "—"
+                    : humanSeconds(r.durationMs / 1000)
+                : String(c === "runs" ? r.runs : r[c]);
+    const widths = cols.map((c) => Math.max(c.length, ...all.map((r) => cell(r, c).length)));
+    const line = (loop, cells, lastChange) => [padToWidth(loop, loopWidth), ...cells.map((c, i) => c.padStart(widths[i] ?? 0)), lastChange].join("  ").trimEnd();
+    return [
+        line("role", [...cols], "last change"),
+        ...all.map((r) => line(roleLabel(r.role), cols.map((c) => cell(r, c)), r.lastChangeTs === null ? "—" : formatTimestamp(r.lastChangeTs))),
+    ].join("\n");
+}