tumwater 0.1.2 → 0.2.0

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

@@ -3,10 +3,10 @@ import { DIRECTOR_ROLE, OBSERVER_ROLES } from "../roles/roles.js";
 import { baseRoleOf } from "../roles/loop-ids.js";
 import { ERROR_BACKOFF, pushYieldOutcome, scheduleAtMinInterval, scheduleBackoff, } from "../scheduling/backoff.js";
 import { firstReason } from "../text/phrases.js";
-/** The state machine that applies a finished tick or landing to the loop's state: the
+/** The state machine that applies a finished tick or merge to the loop's state: the
  * outcome application (applyTickOutcome — which outcomes count which streaks, when a
- * cut-off or quiet-killed session resumes and when it is abandoned), its landing sibling
- * (applyLandingOutcome), the error-streak thresholds, the resume limits, and the
+ * cut-off or quiet-killed session resumes and when it is abandoned), its merge sibling
+ * (applyMergeOutcome), the error-streak thresholds, the resume limits, and the
  * review-verdict record the next tick's prompt reads. Split out of tick-outcome.ts — which
  * keeps the TickResult/TickOutcome vocabulary the dashboards and call sites share — because
  * "what an outcome is" and "what applying it records" are different concerns that happen to
@@ -19,13 +19,13 @@ export function recordReview(s, verdict, reasons, head) {
     s.lastReview = { verdict, reasons, ...(head === undefined ? {} : { head }), at: Date.now() };
 }
 /** Drop a stale review rejection once the change it objected to is superseded (BUGS.md
- * 2026-10-07): the review-exempt and refusal-note landings record no new verdict, so a reject
+ * 2026-10-07): the review-exempt and refusal-note merges record no new verdict, so a reject
  * would otherwise ride every later tick prompt as if it were the role's last review outcome.
- * Called from the points a change lands (`applyLandingOutcome`'s changed branch and
- * `handleRefusal`'s note merge), never while a revision is still owed: a landing that leaves
+ * Called from the points a change merges (`applyMergeOutcome`'s changed branch and
+ * `handleRefusal`'s note merge), never while a revision is still owed: a merge that leaves
  * `state.revision` set — a per-role user-request tick did not apply the rejected change — did
  * not resolve it, and its next revision tick still needs the objections (loop-tick.ts's revision
- * note). A model-reviewed landing already overwrote `lastReview` with its approve; this only
+ * note). A model-reviewed merge already overwrote `lastReview` with its approve; this only
  * clears a standing `reject`. */
 export function clearSupersededRejection(s) {
     if (s.revision === undefined && s.lastReview?.verdict === "reject")
@@ -33,7 +33,7 @@ export function clearSupersededRejection(s) {
 }
 /** Consecutive failed ticks after which the loop raises a harness warning and its state
  * cell reads "failing" (BUGS.md 2026-09-15: every loop failing identically looked like a
- * quiet fleet). Small on purpose — at 3 the error ladder has already doubled twice and
+ * quiet team). Small on purpose — at 3 the error ladder has already doubled twice and
  * the failure is clearly not transient. */
 export const ERROR_STREAK_WARN = 3;
 /** Consecutive failed ticks after which the error-streak circuit breaker (src/gates/streak-gate.ts)
@@ -53,7 +53,7 @@ const CUT_OFF_RESUME_LIMIT = 3;
  * and takes a fresh tick on the idle ladder. A session the backend defers past the quiet
  * watchdog every attempt would otherwise re-send the same input immediately and forever,
  * burning an hour of slot time per retry with no output (BUGS.md 2026-09-18: 41 quiet kills
- * consumed 44% of the fleet over two days). Mirrors CUT_OFF_RESUME_LIMIT; the streak itself
+ * consumed 44% of the team over two days). Mirrors CUT_OFF_RESUME_LIMIT; the streak itself
  * keeps counting (LoopState.quietKillStreak) so one warning per episode can be raised. */
 export const QUIET_KILL_RESUME_LIMIT = 3;
 /** Record a finished tick on the loop's state and schedule its next run from the outcome.
@@ -61,30 +61,31 @@ export const QUIET_KILL_RESUME_LIMIT = 3;
  * promptly, which back off and on which ladder, how cut-off resumes are bounded — sits with
  * the other scheduling helpers here instead of inline in the tick lifecycle. Mutates `s` in place:
  * the caller's state object is authoritative across an in-flight tick (see resetCounters).
- * `cfg` is the role-resolved config (configForRole): its minTickIntervalSeconds carries any
+ * `cfg` is the role-resolved config (configForRole): its minRunIntervalSeconds carries any
  * per-role slow clock, and idleBackoff passes through it unchanged from the top level. */
 export function applyTickOutcome(s, cfg, role, outcome) {
     s.running = false;
     s.parkedSince = undefined;
+    s.parkedOn = undefined;
     // The cut-off streak counts EVERY consecutive tick truncated at the context ceiling, past the
     // resume limit too: the next fresh tick'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;
     // The error streak counts consecutive failed ticks; any other result resets it
     // (BUGS.md 2026-09-15: 44 identical failures raised no alarm). A tick whose leftover
-    // recovery re-queued a pin its last landing failed to land counts too, even though the tick
+    // recovery re-queued a pin its last merge failed counts too, even though the tick
     // itself ends `queued` (outcome.recoveryFailure): a dead reviewer backend would otherwise
     // reset the streak every tick and never raise the alarm (BUGS.md 2026-09-21).
     // tick-finalize.ts emits one warning when the streak crosses ERROR_STREAK_WARN — once per
     // episode, since the reset re-arms it — and the dashboards read "failing" from the same field.
     // A plain `queued` tick is not yet a verdict about anything: it committed and enqueued, and
-    // its LANDING resolves the streak — applyLandingOutcome resets it when the change lands and
+    // its MERGE resolves the streak — applyMergeOutcome resets it when the change merges and
     // counts a review rejection into it (BUGS.md 2026-09-30: review-rejected authoring, the
-    // digest's #1 loss cause, fell straight through — the tick's `queued` reset and the landing's
+    // digest's #1 loss cause, fell straight through — the tick's `queued` reset and the merge's
     // `rejected` increment met nowhere, so the streak read 0 through the whole episode and the
     // re-author ran at min interval, warning-free and pause-proof). Resetting here would pin a
     // rejection streak at 1 forever, since every authoring tick in a rejection episode ends
-    // `queued` before its landing is decided.
+    // `queued` before its merge is decided.
     const failed = outcome.result === "error" || outcome.recoveryFailure !== undefined;
     if (failed)
         s.consecutiveErrors = (s.consecutiveErrors ?? 0) + 1;
@@ -94,7 +95,16 @@ export function applyTickOutcome(s, cfg, role, outcome) {
     // tick-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;
-    // The yield ring records the result beside the streaks: a landing or a counted empty
+    // The no-change streak counts consecutive completed ticks that ended `no_change` (the
+    // resting state cell's ` · no change ×N` suffix — status-model.ts loopPhase). Any other
+    // completed result resets it, so a loop that merges between no-ops never shows a stale
+    // streak. Every completed result reaches this block (tick-finalize.ts calls
+    // applyTickOutcome for every outcome), so `changed`/`queued`/`error`/`aborted`/
+    // `quiet_killed`/`user_aborted` all reset it and only a `no_change` tick grows it.
+    // Observational only — never warns, unlike the error/quiet-kill streaks: a legitimately
+    // idle maintenance loop with an empty backlog can hold a long streak and that is expected.
+    s.noChangeStreak = outcome.result === "no_change" ? (s.noChangeStreak ?? 0) + 1 : 0;
+    // The yield ring records the result beside the streaks: a merge or a counted empty
     // stretches the role's min-tick gap (yieldMultiplier, read by isEligible), an error-class
     // result is skipped entirely — no evidence either way (yield-scaled clocks, PLANS.md).
     pushYieldOutcome(s, outcome.result);
@@ -105,18 +115,18 @@ export function applyTickOutcome(s, cfg, role, outcome) {
     // already committed.
     if (outcome.result !== "aborted")
         s.phase = undefined;
-    s.lastTickEndedAt = Date.now();
+    s.lastRunEndedAt = Date.now();
     // `lastResult`/`lastSummary` are the last COMPLETED result, the pair the dashboards' "last
     // result" cell renders, and they must describe ONE tick: a completed outcome without a
     // summary CLEARS `lastSummary`, so a summary-less result never renders beside another
     // tick's work description (BUGS.md 2026-09-30: a no_change tick read "No change — Implement
-    // the … plan" beside work that had landed, because the prior summary was retained).
+    // the … plan" beside work that had merged, because the prior summary was retained).
     // A `queued` tick is not a completed result: its change is committed but in flight —
-    // the state column shows that (`landing <elapsed>`, the land-queue badge) — so the pair
+    // the state column shows that (`merge <elapsed>`, the merge-queue badge) — so the pair
     // keeps the prior outcome WITH its own summary while the change waits (BUGS.md 2026-09-23),
-    // and the tick's summary is stashed under the pinned sha for applyLandingOutcome to pair with
-    // the landing's result. Every other outcome is completed and clears the stash: a role with a
-    // queued or in-flight landing never ticks (the orchestrator's interlock), so a stash that
+    // and the tick's summary is stashed under the pinned sha for applyMergeOutcome to pair with
+    // the merge's result. Every other outcome is completed and clears the stash: a role with a
+    // queued or in-flight merge never ticks (the orchestrator's interlock), so a stash that
     // survives to a later tick names a change that is no longer waiting.
     if (outcome.result === "queued") {
         s.queuedSummary =
@@ -129,12 +139,12 @@ export function applyTickOutcome(s, cfg, role, outcome) {
     }
     if (outcome.result === "changed" || outcome.result === "queued") {
         // "queued" schedules exactly like "changed" — the tick committed and enqueued — but the
-        // commit count waits for the landing: `commits` keeps meaning "landed on main", and
-        // applyLandingOutcome increments it when the change actually lands. The phase-clear above
+        // commit count waits for the merge: `commits` keeps meaning "merged to main", and
+        // applyMergeOutcome increments it when the change actually merges. The phase-clear above
         // (`result !== "aborted"`) covers both.
         if (outcome.result === "changed")
             s.commits += 1;
-        // A landed change's patch-id approval has done its job: the same patch authored again
+        // A merged change's patch-id approval has done its job: the same patch authored again
         // later (after a revert, say) is a new change and gets its own review.
         if (outcome.result === "changed")
             s.lastApprovedPatchId = undefined;
@@ -146,7 +156,7 @@ export function applyTickOutcome(s, cfg, role, outcome) {
     else if (outcome.result === "rejected") {
         // The reviewer objected and the gate already reset the branch: the author should address
         // the recorded reasons on its next eligible tick, not sleep through them — schedule like
-        // a change without counting a commit (nothing landed).
+        // a change without counting a commit (nothing merged).
         s.backoffSeconds = 0;
         scheduleAtMinInterval(s, cfg);
     }
@@ -205,7 +215,7 @@ export function applyTickOutcome(s, cfg, role, outcome) {
         // value, so an error streak capped at the error ceiling never sleeps LESS than the loop
         // already was sleeping, and the idle ladder picks up from there if the failures stop.
         // A subscription claude usage-window rejection is a transient hold, not a failure of the
-        // session: the fleet hold keeps ticks from starting until `resetsAt` (plans/agent-backends.md
+        // session: the team hold keeps ticks from starting until `resetsAt` (plans/agent-backends.md
         // §8, part 6c), and the kept session and worktree edits resume when it lifts (part 6e).
         // The named cause is what the bridge prompt reads, so it does not tell the session the
         // harness merely restarted.
@@ -228,7 +238,7 @@ export function applyTickOutcome(s, cfg, role, outcome) {
     else if (OBSERVER_ROLES.has(baseRoleOf(role))) {
         // An observer's no_change is a success ("checked, all well"), not an idle verdict: it must
         // not climb the idle ladder, which would punish the role monotonically for the product
-        // being healthy. With no ladder, minTickIntervalSeconds is the sole, honest cadence
+        // being healthy. With no ladder, minRunIntervalSeconds is the sole, honest cadence
         // (plans/observer-roles.md). The error/user_aborted arms above are untouched — a broken
         // toolchain and a deliberate operator stop still back off like any other role.
         s.backoffSeconds = 0;
@@ -243,7 +253,7 @@ export function applyTickOutcome(s, cfg, role, outcome) {
     // outcome abandons them (the next fresh tick resets the worktree to main), so the hand-back
     // is spent: clear the record, or it would make a later change's cap conflict discard the
     // pin instead of handing it back (PLANS.md "Robust conflict landing, part 2/2"). `changed`
-    // clears too — the resolved change landed in-tick, so its life is over. This runs after the
+    // clears too — the resolved change merged in-tick, so its life is over. This runs after the
     // resume branches above have set `resumePending`.
     if (s.conflictHandback &&
         outcome.result !== "queued" &&
@@ -251,71 +261,88 @@ export function applyTickOutcome(s, cfg, role, outcome) {
         s.conflictHandback = undefined;
     }
 }
-/** Record a completed LANDING on the authoring loop's state (plans/merge-queue.md 3/5):
- * the orchestrator calls this on the state object the landing ran against — the runner's live
+/** Record a completed MERGE on the authoring loop's state (plans/merge-queue.md 3/5):
+ * the orchestrator calls this on the state object the merge ran against — the runner's live
  * copy when one exists, a disk load otherwise — then saves it, the same in-place discipline
  * applyTickOutcome has (the caller's state object is authoritative; a role with a queued or
- * in-flight landing never ticks, so no other writer holds it meanwhile). Sets `lastResult`
- * to the lander's outcome, increments `commits` only on a success (the "landed on main"
- * counter applyTickOutcome's "queued" branch left to the landing), and clears `phase` — the
+ * in-flight merge never ticks, so no other writer holds it meanwhile). Sets `lastResult`
+ * to the merger's outcome, increments `commits` only on a success (the "merged to main"
+ * counter applyTickOutcome's "queued" branch left to the merge), and clears `phase` — the
  * gate persisted `phase = "review"` on this same state object during the run, exactly as it
- * did inside a tick, so the label must not linger past the landing (mirroring
- * applyTickOutcome's rule: every outcome except "aborted" clears it — an aborted landing
+ * did inside a tick, so the label must not linger past the merge (mirroring
+ * applyTickOutcome's rule: every outcome except "aborted" clears it — an aborted merge
  * keeps it, because the interruption hit mid-review and the next launch must recover and
- * re-review the pinned work). `lastSummary` becomes the summary of the change this landing
- * resolved — `change` is its land-queue entry — so the landing's result, success or failure,
+ * re-review the pinned work). `lastSummary` becomes the summary of the change this merge
+ * resolved — `change` is its merge-queue entry — so the merge's result, success or failure,
  * reads beside the work it names (BUGS.md 2026-09-23: the queued tick held its summary back
  * rather than pair it with the prior result). The tick's stashed `queuedSummary` wins when it
  * names this sha: it is the text the tick reported, high-friction annotation included. The
  * entry's own summary (the commit subject) covers a stash that is missing or names another
- * change — a crash between enqueue and the tick's state save, or a landing that finished before
+ * change — a crash between enqueue and the tick's state save, or a merge that finished before
  * its tick's outcome was applied. Either way the stash is consumed. The failure detail rides
- * in `lastReview` and the landed/land_failed events. */
-export function applyLandingOutcome(s, result, change) {
+ * in `lastReview` and the merge_done/merge_failed events. */
+export function applyMergeOutcome(s, result, change) {
     s.lastResult = result;
     s.lastSummary = s.queuedSummary?.sha === change.sha ? s.queuedSummary.summary : change.summary;
     s.queuedSummary = undefined;
     if (result === "changed") {
         s.commits += 1;
+        // The last-merged timestamp: set only on a successful merge, so the rendered age means
+        // "time since the loop last actually merged to main" — a rejected/merge_conflict/aborted
+        // merge, like a no_change tick, leaves the prior value standing (PLANS.md "Each loop's
+        // last-landed age").
+        s.lastMergedAt = Date.now();
         s.lastApprovedPatchId = undefined; // see applyTickOutcome
-        // A landing supersedes a stale rejection: a model-reviewed landing has already overwritten
-        // lastReview with its approve, but a review-exempt (or review-disabled) landing records no
+        // A merge supersedes a stale rejection: a model-reviewed merge has already overwritten
+        // lastReview with its approve, but a review-exempt (or review-disabled) merge records no
         // verdict, so a stale reject would otherwise ride every later tick prompt (BUGS.md
         // 2026-10-07). Cleared only with no revision pending — see clearSupersededRejection.
         clearSupersededRejection(s);
-        // A landed change resets the error streak exactly as an error-free tick does (BUGS.md
+        // A merged change resets the error streak exactly as an error-free tick does (BUGS.md
         // 2026-09-30): the queued tick that authored it preserved the streak — a rejection counts
-        // into it below — so the landing, the episode's only clean verdict, ends it.
+        // into it below — so the merge, the episode's only clean verdict, ends it.
         s.consecutiveErrors = 0;
     }
     if (result === "rejected") {
-        // A review rejection is a failure the streak must count (BUGS.md 2026-09-30): the
-        // authoring tick ended `queued`, which no longer resets the streak (see applyTickOutcome),
-        // so this landing outcome is the episode's accumulation point — the same field the warn,
-        // the breaker (src/gates/streak-gate.ts), and the error-storm observation
-        // (src/fleet/fleet-polls.ts) already read. No new machinery, no new constants: the warn
+        // A review rejection is a failure the streak must count ONLY when it is final (BUGS.md
+        // 2026-10-14): recordRejectedChange (src/merge/merge-core.ts) already decided finality
+        // by the time this runs — it sets `state.revision` when the change goes back for another
+        // round and clears it when the chain is exhausted (or never sets it for a role that cannot
+        // revise, the director). A rejection that leaves a revision to work on is not a verdict
+        // about the author yet: counting every round of ONE change made an exhausted chain's third
+        // round cross the warn bar and flash a red "failing tick after tick" alert that needed
+        // nothing from the operator and was gone before it could be read (0–30 s). Counting only
+        // final rejections makes a streak of 3 mean three changes ended rejected (or errored) —
+        // the non-converging author the 2026-09-30 fix meant to catch — while a chain's rounds
+        // leave the streak unchanged and keep the fast minimum-interval retry the queued tick
+        // scheduled. This merge outcome is the accumulation point (the authoring tick ends
+        // `queued`, which no longer resets the streak, see applyTickOutcome) — the same field the
+        // warn, the breaker (src/gates/streak-gate.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.
-        s.consecutiveErrors = (s.consecutiveErrors ?? 0) + 1;
-        const lastReasons = s.lastReview?.verdict === "reject" ? s.lastReview.reasons : undefined;
-        s.lastError = `review rejected: ${firstReason(lastReasons).slice(0, 200)}`;
-        // Past the warn bar the re-author backs off on the error ladder instead of the minimum
-        // interval the queued tick scheduled: the fast first retries stay — the rejected branch's
-        // design intent, letting the author address the recorded reasons at once — but a
-        // non-converging author slows down instead of re-authoring at full price all day. The
-        // rung derives from the streak (not from backoffSeconds, which every queued tick zeroes
-        // on its way out, pinning a state-derived ladder at its first rung), and never pulls
-        // nextRunAt earlier than the already-scheduled minimum interval.
-        const streak = s.consecutiveErrors;
-        if (streak >= ERROR_STREAK_WARN) {
-            const rung = Math.min(ERROR_BACKOFF.initialSeconds * 2 ** (streak - ERROR_STREAK_WARN), ERROR_BACKOFF.maxSeconds);
-            s.backoffSeconds = rung;
-            s.nextRunAt = Math.max(s.nextRunAt ?? 0, Date.now() + rung * 1000);
+        if (s.revision === undefined) {
+            s.consecutiveErrors = (s.consecutiveErrors ?? 0) + 1;
+            const lastReasons = s.lastReview?.verdict === "reject" ? s.lastReview.reasons : undefined;
+            s.lastError = `review rejected: ${firstReason(lastReasons).slice(0, 200)}`;
+            // Past the warn bar the re-author backs off on the error ladder instead of the minimum
+            // interval the queued tick scheduled: the fast first retries stay — the rejected branch's
+            // design intent, letting the author address the recorded reasons at once — but a
+            // non-converging author slows down instead of re-authoring at full price all day. The
+            // rung derives from the streak (not from backoffSeconds, which every queued tick zeroes
+            // on its way out, pinning a state-derived ladder at its first rung), and never pulls
+            // nextRunAt earlier than the already-scheduled minimum interval.
+            const streak = s.consecutiveErrors;
+            if (streak >= ERROR_STREAK_WARN) {
+                const rung = Math.min(ERROR_BACKOFF.initialSeconds * 2 ** (streak - ERROR_STREAK_WARN), ERROR_BACKOFF.maxSeconds);
+                s.backoffSeconds = rung;
+                s.nextRunAt = Math.max(s.nextRunAt ?? 0, Date.now() + rung * 1000);
+            }
         }
     }
-    // A landing or a rejection is the end of the change's life; a merge_conflict keeps its pin.
+    // A merge or a rejection is the end of the change's life; a merge_conflict keeps its pin.
     // The per-change markers below all clear on this one outcome set, so name it once.
     const changeGone = result === "changed" || result === "rejected";
-    // The conflict streak counts failed resolutions of one pinned sha; a landing or a rejection
+    // The conflict streak counts failed resolutions of one pinned sha; a merge or a rejection
     // ends that pin's life. Every other outcome kept the pin as it was, so its count stands.
     if (result === "merge_conflict") {
         const prior = s.mergeConflicts?.sha === change.sha ? s.mergeConflicts.count : 0;
@@ -324,13 +351,15 @@ export function applyLandingOutcome(s, result, change) {
     else if (changeGone) {
         s.mergeConflicts = undefined;
     }
-    // Likewise the red-landing-check streak (keyed by patch-id): its change is gone either way.
-    if (changeGone)
-        s.landingCheckFailures = undefined;
-    // A permanent-reviewer-config hold ends with its pin's life: landed, or rejected away.
+    // Likewise the red-merge-check streak (keyed by patch-id): its change is gone either way.
+    if (changeGone) {
+        s.mergeCheckFailures = undefined;
+        s.mergeFlakeExcused = undefined;
+    }
+    // A permanent-reviewer-config hold ends with its pin's life: merged, or rejected away.
     if (changeGone)
-        s.landingReviewError = undefined;
-    // A hand-back ends with its change's life too: once the resolved change lands or is rejected,
+        s.mergeReviewError = undefined;
+    // A hand-back ends with its change's life too: once the resolved change merges or is rejected,
     // a later change gets its own one-hand-back budget (PLANS.md "Robust conflict landing, part
     // 2/2"). A merge_conflict keeps it, so the resolved change's own cap discard fires.
     if (changeGone)

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

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** Collection half of `tumwater tick <role> <n>`: one completed tick's full event block,
  * distilled from the event log into a TickDetail payload. The collector-in-core convention
  * beside history-data.ts and src/report/report-data.ts — a pure read over root, so core
@@ -7,58 +8,58 @@
  * Every datum rides the events the harness already writes, so this is a distillation of the
  * existing record, not a new one. The rendering half — the summary header, formatEvent, the
  * CLI command — lives in tick-detail.ts. */
-import { HISTORY_SCAN_MAX_EVENTS } from "../history/history-data.js";
+import { HISTORY_SCAN_MAX_EVENTS, bucketMergeEvents, resolveQueuedResult } from "../history/history-data.js";
 import { eventUsage, readEvents, tickSpanMs, tickStartMap } from "../events/event-read.js";
 import { outcomeText, usageText } from "../events/event-format.js";
 /** The event block of `role`'s tick `n`, or null when the scanned window holds no such tick.
- * The newest `tick_start` the log retains for `${role}#${n}` wins (a counter reset can make an
+ * The newest `run_start` the log retains for `${role}#${n}` wins (a counter reset can make an
  * old tick number recur; the operator asking by number means the most recent one), and the
- * block closes at the first `tick_end` for that tick after the start — or, when that end is
- * missing (in flight, or its tail lost to rotation), at the loop's next `tick_start`, so a
+ * block closes at the first `run_end` for that tick after the start — or, when that end is
+ * missing (in flight, or its tail lost to rotation), at the loop's next `run_start`, so a
  * rotation-cut block never leaks the following tick's events into this one. When even the
- * start is gone but a matching `tick_end` survives, the end-alone block still answers with
+ * start is gone but a matching `run_end` survives, the end-alone block still answers with
  * `startTs` null and a null duration (the unpaired rule); nothing at all in the scan is the
  * not-found case the caller renders as a not-found line. */
 export function readTickDetail(root, role, tick) {
     // The scan rides history-data.ts's shared one-ask ceiling (HISTORY_SCAN_MAX_EVENTS): one
-    // tick's block is small, but it can sit arbitrarily far back in a long-lived fleet's log,
+    // tick's block is small, but it can sit arbitrarily far back in a long-lived team's log,
     // and readTailText reads bytes proportional to the limit's line count — so the cap is also
     // the largest byte read one command can cost, and every read-only view scans under the
     // same bound.
-    const events = readEvents(root, HISTORY_SCAN_MAX_EVENTS).filter((e) => e.loop === role);
-    // Newest tick_start for this loop+tick: the block's lower bound.
+    const events = readEvents(root, HISTORY_SCAN_MAX_EVENTS).filter((e) => e.source === role);
+    // Newest run_start for this loop+tick: the block's lower bound.
     let startIdx = -1;
     for (let i = events.length - 1; i >= 0; i--) {
         const e = events[i];
-        if (e.type === "tick_start" && e.tick === tick) {
+        if (e.type === "run_start" && e.run === tick) {
             startIdx = i;
             break;
         }
     }
     if (startIdx < 0) {
-        // The start is gone (rotation) or the tick never ran. A surviving tick_end for the same
+        // The start is gone (rotation) or the tick never ran. A surviving run_end for the same
         // number still answers — unpaired, undated at the front — else there is no such tick here.
         for (let i = events.length - 1; i >= 0; i--) {
             const e = events[i];
-            if (e.type === "tick_end" && e.tick === tick)
+            if (e.type === "run_end" && e.run === tick)
                 return detailFrom(role, tick, events, [e], e, null);
         }
         return null;
     }
     const start = events[startIdx];
-    // The block's upper bound: the first tick_end for this tick after the start ends it; a
-    // later tick_start (this tick's end lost to rotation) closes the block exclusive — the
+    // The block's upper bound: the first run_end for this tick after the start ends it; a
+    // later run_start (this tick's end lost to rotation) closes the block exclusive — the
     // events after it belong to the next tick, not this one. No end and no next start reads as
     // in flight: everything since the start belongs to the open tick.
     let end = null;
     let nextStart = null;
     for (let i = startIdx + 1; i < events.length; i++) {
         const e = events[i];
-        if (e.type === "tick_end" && e.tick === tick) {
+        if (e.type === "run_end" && e.run === tick) {
             end = e;
             break;
         }
-        if (e.type === "tick_start") {
+        if (e.type === "run_start") {
             nextStart = e;
             break;
         }
@@ -74,21 +75,34 @@ export function readTickDetail(root, role, tick) {
     }
     return detailFrom(role, tick, events, block, end, start.ts);
 }
-/** Fill the payload around a collected block: usage from the tick_end via eventUsage/usageText,
+/** Fill the payload around a collected block: usage from the run_end via eventUsage/usageText,
  * duration via tickSpanMs against the loop'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(role, tick, scoped, block, end, startTs) {
     const usageNums = end === null ? { tokens: 0, costUsd: 0 } : eventUsage(end);
+    let result = end === null ? null : outcomeText(end);
+    let merge = null;
+    if (end !== null && result === "queued") {
+        // A fresh claim cursor suits one tick: the walk starts at the newest pin at or before this
+        // tick's end, which is its own pin, since later ticks' pins sit after it.
+        const { mergeQueuedByLoop, outcomeByLoop } = bucketMergeEvents(scoped);
+        const resolved = resolveQueuedResult(end, mergeQueuedByLoop, outcomeByLoop, new Map(), tickStartMap(scoped), null);
+        if (resolved !== null) {
+            result = resolved.result;
+            merge = resolved.outcome;
+        }
+    }
     return {
         role,
-        tick,
+        run: tick,
         startTs,
         endTs: end === null ? null : end.ts,
         durationMs: end === null ? null : tickSpanMs(end, tickStartMap(scoped)),
-        result: end === null ? null : outcomeText(end),
+        result,
         tokens: usageNums.tokens,
         costUsd: usageNums.costUsd,
         usage: end === null ? "" : usageText(end),
         events: block,
+        merge,
     };
 }

package/dist/src/tick/tick-detail.js

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** Rendering + command half of `tumwater tick <role> <n>`: one completed tick's full event
  * block printed as a short summary header followed by the tick's events through the shared
  * formatEvent. The payload itself is collected by tick-detail-data.ts (the collector-in-core
@@ -10,13 +11,17 @@ import { knownRoleIdsCached } from "../config/config.js";
 import { readTickRows } from "../history/history-data.js";
 import { readTickDetail } from "./tick-detail-data.js";
 import { formatEvent } from "../events/event-format.js";
+import { eventTypeLabel } from "../events/event-labels.js";
+import { roleLabel } from "../roles/role-labels.js";
 import { unknownRoleMessage } from "../roles/roles.js";
 import { shortSpanPhrase } from "../text/phrases.js";
 import { shortSha } from "../text/format.js";
+import { gitTry } from "../git/git-run.js";
+import { canonicalRoleId } from "../roles/legacy-role-ids.js";
 /** The tick command's synopsis, word for word what cli.ts's dispatcher gate and cmdTick's own
  * arity and unknown-role guards fail with — one string so the three sites cannot drift apart
  * when the command's shape changes. */
-export const TICK_USAGE = "tumwater tick <role> [<n>] [--last] [--json]";
+export const TICK_USAGE = "tumwater history <role> [<n>] [--last] [--stat] [--json]";
 /** The shared not-found frame both wordings complete — what the scan looked for, the loop,
  * and that the scanned window (not the world) is what came up empty. Exactly two consumers,
  * the not-found wordings below (the numbered form's exported message and the --last form's
@@ -25,41 +30,76 @@ function tickNotFoundPhrase(role, what) {
     return `no ${what} for ${role} in the scanned window (the retained log may have rotated past it)`;
 }
 /** The not-found wording a missed tick lookup owes its surface — `tumwater tick <role> <n>`'s
- * stdout line and the GUI /api/tick endpoint's 404 JSON error, one template so the CLI's prose
+ * stdout line and the GUI /api/run endpoint's 404 JSON error, one template so the CLI's prose
  * and the browser's error card cannot drift when the phrasing moves. Names the shape a user
  * can act on: the tick number, the loop, and that the scanned window (not the world) is what
  * came up empty. */
 export function tickNotFoundMessage(role, tick) {
-    return tickNotFoundPhrase(role, `tick #${tick}`);
+    return tickNotFoundPhrase(role, `run #${tick}`);
 }
 /** The not-found wording for `tumwater tick <role> --last`, sibling of tickNotFoundMessage —
  * the same surfaces but naming what the last-form scan actually asked for: the newest
- * completed tick, not a number the user supplied. Module-local: the GUI's /api/tick 404 only
+ * completed tick, not a number the user supplied. Module-local: the GUI's /api/run 404 only
  * ever serves the numbered form, so this wording has no second consumer. */
 function tickNotFoundLastMessage(role) {
-    return tickNotFoundPhrase(role, "completed tick");
+    return tickNotFoundPhrase(role, "completed run");
+}
+/** The commit a tick pinned: the `commit` of the first `merge_queued`/`merge_done` event in its
+ * block carrying a non-empty one, else null. The one rule both the header's sha and --stat use. */
+function tickCommitSha(d) {
+    const queued = d.events.find((e) => (e.type === "merge_queued" || e.type === "merge_done") && typeof e.commit === "string" && e.commit !== "");
+    return queued === undefined ? null : queued.commit;
+}
+/** The per-file `git show --stat` summary of a tick's pinned commit. The sha is the authored
+ * commit the tick pinned: a merge that rebased gives main a different sha with the same
+ * changes, so this describes what the tick changed. */
+async function tickCommitStat(root, sha) {
+    if (sha === null)
+        return "(no commit: this run sent nothing to merge)";
+    const out = await gitTry(root, "show", "--stat", "--format=", sha);
+    if (out === null)
+        return `(commit ${shortSha(sha)} is not in this repository)`;
+    return out.trimEnd();
+}
+/** The pinned commit's stat text for a tick, shared by `tick --stat` and GET /api/run so both
+ * apply one rule for the sha and the "(no commit …)" / "(commit … is not in this repository)"
+ * texts. */
+export function tickDetailStat(root, d) {
+    return tickCommitStat(root, tickCommitSha(d));
 }
 /** The human view of a TickDetail: one summary line — result (or the in-flight/unpaired
- * marker), duration, usage, and the pinned commit sha when the block's `land_queued`/`landed`
+ * marker), duration, usage, and 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. */
+ * TUI use, so the trail reads exactly like the feed it came from. A queued tick 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 renderTickDetail(d) {
     const summary = [];
     if (d.endTs === null)
         summary.push(d.startTs === null ? "unpaired" : "in flight");
     else
-        summary.push(d.result || "?");
+        summary.push(d.result ? eventTypeLabel(d.result) : "?");
     if (d.durationMs !== null)
         summary.push(shortSpanPhrase(d.durationMs));
     if (d.usage !== "")
         summary.push(d.usage);
-    const queued = d.events.find((e) => (e.type === "land_queued" || e.type === "landed") && typeof e.commit === "string" && e.commit !== "");
-    let header = `${d.role} tick #${d.tick} — ${summary.join(" · ")}`;
-    if (queued !== undefined)
-        header += ` · commit ${shortSha(queued.commit)}`;
-    return [header, ...d.events.map(formatEvent)].join("\n");
+    const sha = tickCommitSha(d);
+    let header = `${roleLabel(d.role)} run #${d.run} — ${summary.join(" · ")}`;
+    if (sha !== null)
+        header += ` · commit ${shortSha(sha)}`;
+    const trail = d.events.map(formatEvent);
+    if (d.merge !== null) {
+        const first = d.events[0];
+        if (first !== undefined && d.merge.ts < first.ts)
+            trail.unshift(formatEvent(d.merge));
+        else
+            trail.push(formatEvent(d.merge));
+    }
+    return [header, ...trail].join("\n");
 }
-/** `tumwater tick <role> [<n>] [--last] [--json]`: print one completed tick's full event
+/** `tumwater tick <role> [<n>] [--last] [--stat] [--json]`: print one completed tick's full event
  * trail. Read-only: stdout only, no state file created — a tick the scan cannot find prints a
  * not-found line and exits 0 (history's empty-output convention: an absent record is an
  * answer, not a failure), and under --json it prints the JSON document `null` instead — the
@@ -69,7 +109,7 @@ export function renderTickDetail(d) {
  * numbered form would — the summary header and event rendering are shared, only the number's
  * provenance differs (readTickRows' newest-first scan, not the user's argument). --last and a
  * numeric <n> are rivals: exactly one positional under --last, exactly two without. */
-export async function cmdTick(root, positionals, json, last = false) {
+export async function cmdTick(root, positionals, json, last = false, stat = false) {
     // Positional arity by form: cli.ts has already peeled the flags off and gated them (only
     // --json and --last are admitted), so anything left over that does not fit the chosen form
     // is a mistake. --last takes exactly one positional (<role>); the numeric path keeps
@@ -77,7 +117,7 @@ export async function cmdTick(root, positionals, json, last = false) {
     const arity = last ? 1 : 2;
     if (positionals.length !== arity)
         fail(`usage: ${TICK_USAGE}`);
-    const role = positionals[0];
+    const role = canonicalRoleId(positionals[0]);
     // The role is validated like every role-targeting command's --role (knownRoleIdsCached: the
     // built-ins plus user-defined loops, read through the never-throwing cached loader so a
     // transiently broken tumwater.json cannot take a read-only view down), with the shared
@@ -91,8 +131,8 @@ export async function cmdTick(root, positionals, json, last = false) {
     // number, read from readTickRows' newest-first scan for the role. An empty scan is not
     // found by construction, so the not-found path below takes it with the last-form wording.
     const tick = last
-        ? (readTickRows(root, 1, role)[0]?.tick ?? null)
-        : parseCountFlag("tick <n>", positionals[1]);
+        ? (readTickRows(root, 1, role)[0]?.run ?? null)
+        : parseCountFlag("history <n>", positionals[1]);
     const detail = tick === null ? null : readTickDetail(root, role, tick);
     if (tick === null) {
         // The --last scan came up empty: not found by construction, the last-form wording.
@@ -106,7 +146,7 @@ export async function cmdTick(root, positionals, json, last = false) {
         // Not found stays exit 0 in both renderings, but --json still owes a parseable document in
         // every exit-0 case (the report --json precedent, the invariant this command's own doc
         // comment claims): `null` is the JSON answer for a single-record lookup that missed — the
-        // prose line would end a jq pipe mid-fleet-incident.
+        // prose line would end a jq pipe mid-team-incident.
         if (json)
             sayJson(null);
         else
@@ -115,8 +155,9 @@ export async function cmdTick(root, positionals, json, last = false) {
     }
     // --json swaps the renderer for the collector's own payload, exactly as history --json: a
     // JSON document in every exit-0 case, never prose.
+    const statText = stat ? await tickDetailStat(root, detail) : null;
     if (json)
-        sayJson(detail);
+        sayJson(statText === null ? detail : { ...detail, stat: statText });
     else
-        say(renderTickDetail(detail));
+        say(statText === null ? renderTickDetail(detail) : `${renderTickDetail(detail)}\n\n${statText}`);
 }