merge-steward 0.8.2 → 0.8.4

package/dist/github/shell-git.js

@@ -1,5 +1,5 @@
 import { exec } from "../exec.js";
-/** Extract conflict file names from git rebase/merge stderr. */
+/** Extract conflict file names from git merge stderr. */
 function parseConflicts(stderr) {
     const files = stderr
         .split("\n")

package/dist/interfaces.d.ts

@@ -7,7 +7,6 @@ export interface GitOperations {
     fetch(remote?: string): Promise<void>;
     headSha(branch: string): Promise<string>;
     isAncestor(ancestor: string, descendant: string): Promise<boolean>;
-    mergeBaseInto(branch: string, base: string): Promise<MergeResult>;
     push(branch: string, force?: boolean, targetBranch?: string): Promise<void>;
 }
 /**

package/dist/reconciler.js

@@ -118,6 +118,15 @@ async function prepareEntry(ctx, entry, isHead, prevEntry) {
     if (!base)
         return; // Non-head: prev hasn't built its spec yet, wait.
     const baseSha = await ctx.git.headSha(base);
+    // ── Branch mismatch gate (all entries) ─────────────────────────
+    // Detect external pushes to the PR branch. If webhooks missed
+    // a force-push, catch it here before building a spec from stale content.
+    const currentRef = await ctx.git.headSha(ref(ctx, entry.branch));
+    if (currentRef !== entry.headSha) {
+        emit(ctx, entry, "branch_mismatch", { detail: `expected ${entry.headSha.slice(0, 8)}, got ${currentRef.slice(0, 8)}` });
+        ctx.store.updateHead(entry.id, currentRef);
+        return;
+    }
     // ── Head-only gates ───────────────────────────────────────────
     if (isHead) {
         // Gate: main CI must be green.
@@ -142,13 +151,6 @@ async function prepareEntry(ctx, entry, isHead, prevEntry) {
                 return;
             }
         }
-        // Gate: detect external pushes to the PR branch.
-        const currentRef = await ctx.git.headSha(ref(ctx, entry.branch));
-        if (currentRef !== entry.headSha) {
-            emit(ctx, entry, "branch_mismatch", { detail: `expected ${entry.headSha.slice(0, 8)}, got ${currentRef.slice(0, 8)}` });
-            ctx.store.updateHead(entry.id, currentRef);
-            return;
-        }
         // Gate: budget exhausted after previous conflict.
         if (isBudgetExhausted(entry) && entry.lastFailedBaseSha !== null) {
             emit(ctx, entry, "budget_exhausted", { baseSha });
@@ -197,7 +199,7 @@ async function prepareEntry(ctx, entry, isHead, prevEntry) {
         return;
     }
     if (!result.success) {
-        emit(ctx, entry, "rebase_conflict", { baseSha, conflictFiles: result.conflictFiles });
+        emit(ctx, entry, "spec_build_conflict", { baseSha, conflictFiles: result.conflictFiles });
         if (isBudgetExhausted(entry)) {
             emit(ctx, entry, "budget_exhausted");
             await evictEntry(ctx, entry, "integration_conflict", result.conflictFiles ? { conflictFiles: result.conflictFiles } : undefined);
@@ -219,7 +221,7 @@ async function prepareEntry(ctx, entry, isHead, prevEntry) {
     ctx.store.transition(entry.id, "validating", {
         baseSha, ciRunId: runId, lastFailedBaseSha: null,
         specBranch: specName, specSha, specBasedOn: isHead ? null : prevEntry.id,
-    }, `spec ${specName} ready, CI ${runId}`);
+    }, `spec ready, CI ${runId.slice(0, 12)}`);
 }
 function describeMainBroken(failingChecks, pendingChecks) {
     const parts = [];
@@ -245,7 +247,7 @@ async function checkValidation(ctx, entry, allActive, index) {
         const sha = entry.specSha ?? entry.headSha;
         const runId = await ctx.ci.triggerRun(branch, sha);
         emit(ctx, entry, "ci_triggered", { ciRunId: runId });
-        ctx.store.transition(entry.id, "validating", { ciRunId: runId }, `CI triggered: ${runId}`);
+        ctx.store.transition(entry.id, "validating", { ciRunId: runId }, `CI triggered: ${runId.slice(0, 12)}`);
         return;
     }
     const status = await ctx.ci.getStatus(entry.ciRunId);
@@ -302,10 +304,10 @@ async function mergeHead(ctx, entry) {
         return;
     }
     if (!prStatus.reviewApproved) {
-        emit(ctx, entry, "merge_rejected", { detail: "approval withdrawn" });
-        const allActive = ctx.store.listActive(ctx.repoId);
-        await evictEntry(ctx, entry, "policy_blocked");
-        await invalidateDownstream(ctx, allActive, 0);
+        // Don't evict immediately — reviewer may re-approve after re-review.
+        // Stay in merging and re-check on the next tick. Operator can dequeue
+        // manually if the approval never comes back.
+        emit(ctx, entry, "merge_waiting_approval", { detail: "approval withdrawn, waiting for re-approval" });
         return;
     }
     if (prStatus.headSha !== entry.headSha) {

package/dist/service.js

@@ -281,8 +281,8 @@ export class MergeStewardService {
                 eviction: this.eviction,
                 flakyRetries: this.config.flakyRetries,
                 onEvent: (event) => {
-                    const isWarn = event.action === "evicted" || event.action === "rebase_conflict"
-                        || event.action === "spec_build_conflict" || event.action === "ci_failed"
+                    const isWarn = event.action === "evicted" || event.action === "spec_build_conflict"
+                        || event.action === "ci_failed"
                         || event.action === "merge_rejected" || event.action === "budget_exhausted";
                     const isDebug = event.action === "ci_pending" || event.action === "retry_gated"
                         || event.action === "fetch_started";

package/dist/types.d.ts

@@ -173,7 +173,7 @@ export interface QueueConfig {
     pollIntervalMs: number;
     requiredChecks: string[];
 }
-export type ReconcileAction = "promoted" | "fetch_started" | "main_broken" | "branch_mismatch" | "rebase_started" | "rebase_succeeded" | "rebase_conflict" | "spec_build_started" | "spec_build_succeeded" | "spec_build_conflict" | "ci_triggered" | "ci_pending" | "ci_passed" | "ci_failed" | "ci_flaky_retry" | "merge_revalidating" | "merge_succeeded" | "merge_rejected" | "merge_external" | "evicted" | "invalidated" | "retry_gated" | "budget_exhausted" | "sanitized_closed" | "sanitized_duplicate" | "branch_unreachable";
+export type ReconcileAction = "promoted" | "fetch_started" | "main_broken" | "branch_mismatch" | "spec_build_started" | "spec_build_succeeded" | "spec_build_conflict" | "ci_triggered" | "ci_pending" | "ci_passed" | "ci_failed" | "ci_flaky_retry" | "merge_revalidating" | "merge_succeeded" | "merge_rejected" | "merge_external" | "evicted" | "invalidated" | "retry_gated" | "budget_exhausted" | "merge_waiting_approval" | "sanitized_closed" | "sanitized_duplicate" | "branch_unreachable";
 export interface ReconcileEvent {
     at: string;
     entryId: string;

package/dist/watch/App.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
+import { buildDisplayEntries } from "./display-filter.js";
 import { dequeueEntry, fetchEntryDetail, fetchSnapshot, triggerReconcile } from "./api.js";
 import { DetailView } from "./DetailView.js";
 import { HelpBar } from "./HelpBar.js";
@@ -31,18 +32,7 @@ export function App({ baseUrl, initialPrNumber }) {
     const [view, setView] = useState("list");
     const [filter, setFilter] = useState("active");
     const [flashMessage, setFlashMessage] = useState(null);
-    const visibleEntries = useMemo(() => {
-        const entries = snapshot?.entries ?? [];
-        return filter === "active" ? entries.filter(isActiveEntry) : entries;
-    }, [filter, snapshot?.entries]);
-    // Recently completed entries: terminal entries within the last 60 seconds.
-    const recentlyCompleted = useMemo(() => {
-        if (filter !== "active")
-            return [];
-        const entries = snapshot?.entries ?? [];
-        const cutoff = Date.now() - 60_000;
-        return entries.filter((e) => !isActiveEntry(e) && new Date(e.updatedAt).getTime() > cutoff);
-    }, [filter, snapshot?.entries]);
+    const visibleEntries = useMemo(() => buildDisplayEntries(snapshot?.entries ?? [], filter), [filter, snapshot?.entries]);
     const selectedEntry = useMemo(() => visibleEntries.find((entry) => entry.id === selectedEntryId) ?? null, [selectedEntryId, visibleEntries]);
     const activeEntries = useMemo(() => (snapshot?.entries ?? []).filter(isActiveEntry), [snapshot?.entries]);
     const selectedActiveIndex = useMemo(() => {
@@ -196,5 +186,5 @@ export function App({ baseUrl, initialPrNumber }) {
             setSelectedEntryId(nextSelection(visibleEntries, selectedEntryId, "prev"));
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { snapshot: snapshot, connected: connected, filter: filter, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: REFRESH_INTERVAL_MS * 2 }), view === "detail" && selectedEntry && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Queue" }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsxs(Text, { bold: true, children: ["#", selectedEntry.prNumber] }), _jsxs(Text, { dimColor: true, children: [" (", selectedEntry.status, ")"] })] })), view === "list" ? (_jsx(QueueListView, { entries: visibleEntries, recentlyCompleted: recentlyCompleted, selectedEntryId: selectedEntryId, recentEvents: snapshot?.recentEvents ?? [], headEntryId: snapshot?.summary.headEntryId ?? null, queueBlock: snapshot?.queueBlock ?? null })) : (_jsx(DetailView, { detail: detail, isHead: isHeadSelected, activeIndex: selectedActiveIndex, activeCount: activeEntries.length, headPrNumber: snapshot?.summary.headPrNumber ?? null, queueBlock: snapshot?.queueBlock ?? null })), flashMessage && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: flashMessage }) })), _jsx(HelpBar, { view: view })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { snapshot: snapshot, connected: connected, filter: filter, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: REFRESH_INTERVAL_MS * 2 }), view === "detail" && selectedEntry && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Queue" }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsxs(Text, { bold: true, children: ["#", selectedEntry.prNumber] }), _jsxs(Text, { dimColor: true, children: [" (", selectedEntry.status, ")"] })] })), view === "list" ? (_jsx(QueueListView, { entries: visibleEntries, allEntries: snapshot?.entries ?? [], selectedEntryId: selectedEntryId, recentEvents: snapshot?.recentEvents ?? [], headEntryId: snapshot?.summary.headEntryId ?? null, queueBlock: snapshot?.queueBlock ?? null })) : (_jsx(DetailView, { detail: detail, isHead: isHeadSelected, activeIndex: selectedActiveIndex, activeCount: activeEntries.length, headPrNumber: snapshot?.summary.headPrNumber ?? null, queueBlock: snapshot?.queueBlock ?? null })), flashMessage && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: flashMessage }) })), _jsx(HelpBar, { view: view })] }));
 }

package/dist/watch/DetailView.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { formatEntryEvent, humanStatus, nextStepLabel, progressBar, queueProgress, relativeTime, shortSha, statusColor, summarizeQueueBlock } from "./format.js";
+import { formatEntryEvent, humanStatus, nextStepLabel, relativeTime, shortSha, statusColor, summarizeQueueBlock } from "./format.js";
 import { EntryStateGraph } from "./EntryStateGraph.js";
 import { ExternalRepairObservation } from "./ExternalRepairObservation.js";
 import { buildEntryStateGraph, buildExternalRepairObservations } from "./state-visualization.js";
@@ -17,6 +17,5 @@ export function DetailView({ detail, isHead, activeIndex, activeCount, headPrNum
         headPrNumber,
         queueBlock,
     });
-    const pipeline = queueProgress(entry.status);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 2, children: [_jsxs(Text, { bold: true, children: ["#", entry.prNumber] }), entry.issueKey ? _jsx(Text, { children: entry.issueKey }) : null, _jsx(Text, { color: statusColor(entry.status), children: humanStatus(entry.status, entry) }), _jsxs(Text, { dimColor: true, children: ["pos ", entry.position] }), _jsxs(Text, { dimColor: true, children: ["retry ", entry.retryAttempts, "/", entry.maxRetries] })] }), _jsx(Text, { children: entry.branch }), _jsxs(Box, { gap: 2, children: [_jsxs(Text, { dimColor: true, children: ["head ", shortSha(entry.headSha)] }), _jsxs(Text, { dimColor: true, children: ["base ", shortSha(entry.baseSha)] })] }), entry.specBranch && (_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: "spec" }), _jsx(Text, { children: entry.specBranch }), _jsx(Text, { dimColor: true, children: shortSha(entry.specSha) }), _jsx(Text, { dimColor: true, children: "\u2190" }), _jsx(Text, { dimColor: true, children: entry.specBasedOn ? `entry ${shortSha(entry.specBasedOn)}` : "main" })] })), _jsxs(Box, { gap: 1, marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "progress" }), _jsx(Text, { children: progressBar(pipeline.current, pipeline.total, 12) }), _jsx(Text, { dimColor: true, children: nextStepLabel(entry.status, entry) })] }), isHead && queueBlock && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["Queue paused: ", summarizeQueueBlock(queueBlock) ?? "main branch is unhealthy", "."] }), _jsxs(Text, { dimColor: true, children: [queueBlock.baseBranch, queueBlock.baseSha ? ` @ ${shortSha(queueBlock.baseSha)}` : ""] }), _jsxs(Text, { dimColor: true, children: ["Head PR #", queueBlock.headPrNumber ?? entry.prNumber, " will resume automatically once main recovers."] })] })), entry.maxRetries > 0 && (_jsxs(Box, { gap: 1, marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "retry" }), _jsx(Text, { children: progressBar(entry.retryAttempts, entry.maxRetries, 10) }), _jsxs(Text, { dimColor: true, children: [entry.retryAttempts, "/", entry.maxRetries] })] })), _jsx(EntryStateGraph, { main: graph.main, exits: graph.exits }), _jsx(ExternalRepairObservation, { observations: observations }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Incidents" }), incidents.length === 0 ? (_jsx(Text, { dimColor: true, children: "No incidents." })) : (incidents.map((incident) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: relativeTime(incident.at).padStart(4, " ") }), _jsx(Text, { color: "red", children: incident.failureClass }), _jsx(Text, { dimColor: true, children: incident.outcome })] }, incident.id))))] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Events" }), events.length === 0 ? (_jsx(Text, { dimColor: true, children: "No events yet." })) : (events.slice(-16).map((event) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: relativeTime(event.at).padStart(4, " ") }), _jsx(Text, { children: formatEntryEvent(event) })] }, event.id ?? `${event.entryId}-${event.at}`))))] })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 2, children: [_jsxs(Text, { bold: true, children: ["#", entry.prNumber] }), entry.issueKey ? _jsx(Text, { children: entry.issueKey }) : null, _jsx(Text, { color: statusColor(entry.status), children: humanStatus(entry.status, entry) }), _jsxs(Text, { dimColor: true, children: ["\\u00b7 ", nextStepLabel(entry.status, entry)] })] }), _jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: entry.branch }), _jsxs(Text, { dimColor: true, children: ["head ", shortSha(entry.headSha)] }), _jsxs(Text, { dimColor: true, children: ["base ", shortSha(entry.baseSha)] })] }), entry.specBranch && (_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: "tested as" }), _jsx(Text, { children: entry.specBranch }), _jsxs(Text, { dimColor: true, children: ["(", shortSha(entry.specSha), " \\u2190 ", entry.specBasedOn ? "PR ahead" : "main", ")"] })] })), entry.retryAttempts > 0 && (_jsxs(Text, { color: "yellow", children: ["retry ", entry.retryAttempts, "/", entry.maxRetries] })), isHead && queueBlock && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["Queue paused: ", summarizeQueueBlock(queueBlock) ?? "main CI is unhealthy", "."] }), _jsxs(Text, { dimColor: true, children: ["Will resume automatically once ", queueBlock.baseBranch, " is green."] })] })), _jsx(EntryStateGraph, { main: graph.main, exits: graph.exits }), _jsx(ExternalRepairObservation, { observations: observations }), incidents.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Incidents" }), incidents.map((incident) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: relativeTime(incident.at).padStart(4) }), _jsx(Text, { color: "red", children: incident.failureClass }), _jsx(Text, { dimColor: true, children: incident.outcome })] }, incident.id)))] })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Events" }), events.length === 0 ? (_jsx(Text, { dimColor: true, children: "No events yet." })) : (events.slice(-16).map((event) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: relativeTime(event.at).padStart(4) }), _jsx(Text, { children: formatEntryEvent(event) })] }, event.id ?? `${event.entryId}-${event.at}`))))] })] }));
 }

package/dist/watch/EntryStateGraph.js

@@ -1,31 +1,12 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-function statusColor(status) {
-    switch (status) {
-        case "current":
-            return "cyan";
-        case "visited":
-            return "green";
-        case "upcoming":
-            return "gray";
-    }
-}
-function statusPrefix(status) {
-    switch (status) {
-        case "current":
-            return "*";
-        case "visited":
-            return "+";
-        case "upcoming":
-            return " ";
-    }
-}
-function NodePill({ node }) {
-    return (_jsxs(Text, { color: statusColor(node.status), bold: node.status === "current", children: ["[", statusPrefix(node.status), " ", node.label, "]"] }));
-}
-function NodeRow({ label, nodes, connector = " -> ", }) {
-    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: label.padEnd(8, " ") }), nodes.map((node, index) => (_jsxs(Box, { children: [index > 0 && _jsx(Text, { dimColor: true, children: connector }), _jsx(NodePill, { node: node })] }, node.state)))] }));
-}
 export function EntryStateGraph({ main, exits }) {
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Entry Graph" }), _jsx(NodeRow, { label: "main", nodes: main }), _jsx(NodeRow, { label: "exits", nodes: exits, connector: "   " })] }));
+    const visibleExits = exits.filter((n) => n.status !== "upcoming");
+    return (_jsxs(Box, { marginTop: 1, gap: 0, children: [main.map((node, i) => {
+                const dot = node.status === "upcoming" ? "\u25cb" : "\u25cf"; // ○ or ●
+                const color = node.status === "current" ? "cyan"
+                    : node.status === "visited" ? "green"
+                        : "gray";
+                return (_jsxs(Box, { gap: 0, children: [i > 0 && _jsx(Text, { dimColor: true, children: " \\u2192 " }), _jsx(Text, { color: color, bold: node.status === "current", children: dot }), _jsx(Text, { color: color, bold: node.status === "current", children: ` ${node.label}` })] }, node.state));
+            }), visibleExits.map((node) => (_jsxs(Box, { gap: 0, children: [_jsx(Text, { dimColor: true, children: "  " }), _jsx(Text, { color: "red", children: `\u25cf ${node.label}` })] }, node.state)))] }));
 }

package/dist/watch/QueueListView.d.ts

@@ -1,11 +1,11 @@
 import type { QueueBlockState, QueueEntry, QueueEventSummary } from "../types.ts";
 interface QueueListViewProps {
     entries: QueueEntry[];
-    recentlyCompleted: QueueEntry[];
+    allEntries: QueueEntry[];
     selectedEntryId: string | null;
     recentEvents: QueueEventSummary[];
     headEntryId: string | null;
     queueBlock: QueueBlockState | null;
 }
-export declare function QueueListView({ entries, recentlyCompleted, selectedEntryId, recentEvents, headEntryId, queueBlock, }: QueueListViewProps): React.JSX.Element;
+export declare function QueueListView({ entries, allEntries, selectedEntryId, recentEvents, headEntryId, queueBlock, }: QueueListViewProps): React.JSX.Element;
 export {};

package/dist/watch/QueueListView.js

@@ -1,63 +1,40 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { Box, Text, useStdout } from "ink";
-import { ciStatusIcon, formatEventSummary, humanStatus, nextStepLabel, progressBar, queueProgress, relativeTime, specChainLabel, statusColor, summarizeQueueBlock, truncate } from "./format.js";
 import { TERMINAL_STATUSES } from "../types.js";
-const ENTRY_ROW_HEIGHT = 2;
+import { buildChainEntries } from "./display-filter.js";
+import { ciStatusIcon, formatEventSummary, humanStatus, nextStepLabel, relativeTime, statusColor, summarizeQueueBlock, truncate } from "./format.js";
 const CHROME_ROWS = 13;
-const RECENTLY_COMPLETED_MAX_AGE_MS = 60_000;
-function QueueRow({ entry, selected, infoWidth, isHead, queueBlock, allEntries, }) {
-    const retryText = `${entry.retryAttempts}/${entry.maxRetries}`;
-    const ciText = entry.ciRetries > 0 ? `CI retries ${entry.ciRetries}` : null;
+function QueueRow({ entry, selected, isHead, queueBlock, }) {
+    const isTerminal = TERMINAL_STATUSES.includes(entry.status);
+    if (isTerminal) {
+        const icon = entry.status === "merged" ? "\u2713" : "\u2717";
+        const iconColor = entry.status === "merged" ? "green" : "red";
+        return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " " }), _jsx(Text, { dimColor: true, children: ` #${entry.prNumber}` }), entry.issueKey ? _jsx(Text, { dimColor: true, children: ` ${entry.issueKey}` }) : null, _jsx(Text, { dimColor: true, children: `  ${relativeTime(entry.updatedAt).padStart(4)}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: iconColor, children: `${icon} ${humanStatus(entry.status)}` })] }));
+    }
     const blockedOnMain = isHead && queueBlock?.reason === "main_broken" && queueBlock.headPrNumber === entry.prNumber;
-    const renderedStatus = blockedOnMain ? "blocked by broken main" : humanStatus(entry.status, entry);
-    const renderedColor = blockedOnMain
-        ? "red"
+    const status = blockedOnMain ? "main CI failing" : humanStatus(entry.status, entry);
+    const color = blockedOnMain ? "red"
         : entry.status === "preparing_head" && entry.lastFailedBaseSha ? "yellow"
             : statusColor(entry.status);
-    const progress = queueProgress(entry.status);
-    const specLabel = entry.specBranch
-        ? specChainLabel(entry, allEntries)
-        : truncate(entry.branch, Math.max(12, infoWidth - 34));
     const nextStep = blockedOnMain
         ? summarizeQueueBlock(queueBlock) ?? "waiting for main to recover"
         : nextStepLabel(entry.status, entry);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : "gray", children: selected ? "›" : " " }), _jsx(Text, { color: blockedOnMain ? "red" : isHead ? "green" : "gray", children: blockedOnMain ? "!" : isHead ? "#" : " " }), _jsx(Text, { bold: true, children: ` #${entry.prNumber}` }), entry.issueKey ? _jsx(Text, { children: ` ${entry.issueKey}` }) : null, _jsx(Text, { dimColor: true, children: `  pos ${entry.position}` }), _jsx(Text, { dimColor: true, children: `  ${relativeTime(entry.updatedAt)}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: renderedColor, children: renderedStatus })] }), _jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { dimColor: true, children: progressBar(progress.current, progress.total, 8) }), _jsx(Text, { dimColor: true, children: specLabel }), _jsx(Text, { dimColor: true, children: "|" }), _jsx(Text, { dimColor: true, children: nextStep }), _jsx(Text, { dimColor: true, children: ` | retry ${retryText}` }), ciText ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "|" }), _jsx(Text, { dimColor: true, children: ciText })] })) : null] })] }));
+    // Only show retry counter when retries have actually happened.
+    const retryNote = entry.retryAttempts > 0 ? ` \u00b7 retry ${entry.retryAttempts}/${entry.maxRetries}` : "";
+    return (_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : "gray", children: selected ? "\u25b8" : " " }), _jsx(Text, { ...(isHead ? { color: "green" } : {}), bold: true, children: ` #${entry.prNumber}` }), entry.issueKey ? _jsx(Text, { children: ` ${entry.issueKey}` }) : null, _jsx(Text, { dimColor: true, children: `  ${relativeTime(entry.updatedAt).padStart(4)}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: color, children: status }), _jsx(Text, { dimColor: true, children: ` \u00b7 ${nextStep}${retryNote}` })] }));
 }
-export function QueueListView({ entries, recentlyCompleted, selectedEntryId, recentEvents, headEntryId, queueBlock, }) {
+export function QueueListView({ entries, allEntries, selectedEntryId, recentEvents, headEntryId, queueBlock, }) {
     const { stdout } = useStdout();
     const rows = stdout?.rows ?? 24;
-    const cols = stdout?.columns ?? 100;
-    const infoWidth = Math.max(32, cols - 4);
-    const totalRows = entries.length + recentlyCompleted.length;
-    const eventRows = Math.min(8, Math.max(4, rows - (totalRows * ENTRY_ROW_HEIGHT) - CHROME_ROWS));
+    // All entries are 1 row now.
+    const eventRows = Math.min(8, Math.max(4, rows - entries.length - CHROME_ROWS));
     const displayedEvents = useMemo(() => recentEvents.slice(-eventRows), [eventRows, recentEvents]);
     const queueBlockLabel = summarizeQueueBlock(queueBlock);
-    // Spec chain: main ─ #A ✓ ─ #B ● ─ #C ○
-    // Includes recently completed entries so the cascade stays visible.
-    // Deduplicates by prNumber (not entry ID) so re-admitted PRs don't
-    // appear twice — the active entry wins over the terminal one.
-    const chainEntries = useMemo(() => {
-        const seenPR = new Set();
-        const all = [];
-        // Active entries take priority.
-        for (const e of entries) {
-            if (!TERMINAL_STATUSES.includes(e.status) && !seenPR.has(e.prNumber)) {
-                all.push(e);
-                seenPR.add(e.prNumber);
-            }
-        }
-        // Recently completed fill in — only if no active entry for that PR.
-        for (const e of recentlyCompleted) {
-            if (!seenPR.has(e.prNumber)) {
-                all.push(e);
-                seenPR.add(e.prNumber);
-            }
-        }
-        return all.sort((a, b) => a.position - b.position);
-    }, [entries, recentlyCompleted]);
+    // Chain header always shows the live queue, regardless of display filter.
+    const chainEntries = useMemo(() => buildChainEntries(allEntries), [allEntries]);
     return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [chainEntries.length > 0 && (_jsxs(Box, { marginBottom: 1, gap: 0, children: [_jsx(Text, { dimColor: true, children: "main" }), chainEntries.map((entry) => {
                         const ci = ciStatusIcon(entry);
                         return (_jsxs(Box, { gap: 0, children: [_jsx(Text, { dimColor: true, children: " \u2500 " }), _jsxs(Text, { bold: true, children: ["#", entry.prNumber] }), _jsx(Text, { color: ci.color, children: ` ${ci.icon}` })] }, entry.id));
-                    })] })), queueBlock && (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["Queue paused: ", queueBlockLabel ?? "main is unhealthy", queueBlock.baseSha ? ` at ${truncate(queueBlock.baseSha, 10)}` : "", "."] }), _jsxs(Text, { dimColor: true, children: ["Head PR #", queueBlock.headPrNumber ?? "?", " will resume automatically once main recovers."] })] })), entries.length === 0 && recentlyCompleted.length === 0 ? (_jsx(Text, { dimColor: true, children: "No queue entries in this filter." })) : (_jsxs(_Fragment, { children: [entries.map((entry) => (_jsx(QueueRow, { entry: entry, selected: entry.id === selectedEntryId, infoWidth: infoWidth, isHead: entry.id === headEntryId, queueBlock: queueBlock, allEntries: entries }, entry.id))), recentlyCompleted.length > 0 && (_jsx(_Fragment, { children: recentlyCompleted.map((entry) => (_jsx(Box, { flexDirection: "column", children: _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  " }), _jsx(Text, { color: entry.status === "merged" ? "green" : "red", children: entry.status === "merged" ? "\u2713" : "\u2717" }), _jsx(Text, { dimColor: true, children: ` #${entry.prNumber}` }), entry.issueKey ? _jsx(Text, { dimColor: true, children: ` ${entry.issueKey}` }) : null, _jsx(Text, { dimColor: true, children: `  ${humanStatus(entry.status, entry)}  ${relativeTime(entry.updatedAt)}` })] }) }, entry.id))) }))] })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Recent Events" }), displayedEvents.length === 0 ? (_jsx(Text, { dimColor: true, children: "No queue events yet." })) : (displayedEvents.map((event) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: relativeTime(event.at).padStart(4, " ") }), _jsx(Text, { children: formatEventSummary(event) })] }, event.id ?? `${event.entryId}-${event.at}`))))] })] }));
+                    })] })), queueBlock && (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["Queue paused: ", queueBlockLabel ?? "main is unhealthy", queueBlock.baseSha ? ` at ${truncate(queueBlock.baseSha, 10)}` : "", "."] }), _jsxs(Text, { dimColor: true, children: ["Head PR #", queueBlock.headPrNumber ?? "?", " will resume automatically once main recovers."] })] })), entries.length === 0 ? (_jsx(Text, { dimColor: true, children: "No queue entries in this filter." })) : (entries.map((entry) => (_jsx(QueueRow, { entry: entry, selected: entry.id === selectedEntryId, isHead: entry.id === headEntryId, queueBlock: queueBlock }, entry.id)))), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Recent Events" }), displayedEvents.length === 0 ? (_jsx(Text, { dimColor: true, children: "No queue events yet." })) : (displayedEvents.map((event) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: relativeTime(event.at).padStart(4, " ") }), _jsx(Text, { children: formatEventSummary(event) })] }, event.id ?? `${event.entryId}-${event.at}`))))] })] }));
 }

package/dist/watch/display-filter.d.ts

@@ -0,0 +1,14 @@
+import type { QueueEntry } from "../types.ts";
+/**
+ * Build the display row list for the queue watch. In "active" mode,
+ * includes active entries plus recently-terminal entries (within 60s),
+ * deduplicated by prNumber (active wins over terminal for re-admissions).
+ * In "all" mode, returns all entries as-is.
+ */
+export declare function buildDisplayEntries(entries: QueueEntry[], filter: "active" | "all"): QueueEntry[];
+/**
+ * Build the spec chain header entries. Always shows the current live
+ * chain: active entries plus recently-merged entries (for cascade
+ * visibility), regardless of the display filter. One entry per PR.
+ */
+export declare function buildChainEntries(entries: QueueEntry[]): QueueEntry[];

package/dist/watch/display-filter.js

@@ -0,0 +1,45 @@
+import { TERMINAL_STATUSES } from "../types.js";
+const RECENTLY_COMPLETED_MS = 60_000;
+/**
+ * Build the display row list for the queue watch. In "active" mode,
+ * includes active entries plus recently-terminal entries (within 60s),
+ * deduplicated by prNumber (active wins over terminal for re-admissions).
+ * In "all" mode, returns all entries as-is.
+ */
+export function buildDisplayEntries(entries, filter) {
+    if (filter !== "active")
+        return entries;
+    const cutoff = Date.now() - RECENTLY_COMPLETED_MS;
+    const byPR = new Map();
+    for (const e of entries) {
+        const isActive = !TERMINAL_STATUSES.includes(e.status);
+        const isRecent = !isActive && new Date(e.updatedAt).getTime() > cutoff;
+        if (!isActive && !isRecent)
+            continue;
+        const existing = byPR.get(e.prNumber);
+        if (!existing || (isActive && TERMINAL_STATUSES.includes(existing.status))) {
+            byPR.set(e.prNumber, e);
+        }
+    }
+    return [...byPR.values()].sort((a, b) => a.position - b.position);
+}
+/**
+ * Build the spec chain header entries. Always shows the current live
+ * chain: active entries plus recently-merged entries (for cascade
+ * visibility), regardless of the display filter. One entry per PR.
+ */
+export function buildChainEntries(entries) {
+    const cutoff = Date.now() - RECENTLY_COMPLETED_MS;
+    const byPR = new Map();
+    for (const e of entries) {
+        const isActive = !TERMINAL_STATUSES.includes(e.status);
+        const isRecent = !isActive && new Date(e.updatedAt).getTime() > cutoff;
+        if (!isActive && !isRecent)
+            continue;
+        const existing = byPR.get(e.prNumber);
+        if (!existing || (isActive && TERMINAL_STATUSES.includes(existing.status))) {
+            byPR.set(e.prNumber, e);
+        }
+    }
+    return [...byPR.values()].sort((a, b) => a.position - b.position);
+}

package/dist/watch/format.js

@@ -41,21 +41,21 @@ export function statusColor(status) {
 export function humanStatus(status, entry) {
     switch (status) {
         case "queued":
-            return "queued";
+            return "waiting in queue";
         case "preparing_head":
             if (entry?.lastFailedBaseSha)
-                return "retry-gated";
-            return "building spec";
+                return "has conflicts";
+            return "preparing";
         case "validating":
-            return "running CI";
+            return "testing";
         case "merging":
-            return "merging to main";
+            return "merging";
         case "merged":
             return "merged";
         case "evicted":
-            return "removed from queue";
+            return "needs repair";
         case "dequeued":
-            return "dequeued";
+            return "removed";
     }
 }
 export function queueProgress(status) {
@@ -76,21 +76,23 @@ export function queueProgress(status) {
 export function nextStepLabel(status, entry) {
     switch (status) {
         case "queued":
-            return "waiting for head-of-line turn";
+            return "starting shortly";
         case "preparing_head":
             if (entry?.lastFailedBaseSha)
-                return "waiting for base to advance";
-            return "building cumulative spec branch";
+                return "conflicts with main, will retry when queue advances";
+            return "building test branch with PRs ahead";
         case "validating":
-            return "waiting for CI on spec branch";
+            return entry?.specBasedOn
+                ? "CI running, tested together with PRs ahead"
+                : "CI running on combined changes";
         case "merging":
-            return "pushing spec to main";
+            return "landing on main";
         case "merged":
             return "landed on main";
         case "evicted":
-            return "needs external repair";
+            return "needs branch repair before re-admission";
         case "dequeued":
-            return "removed manually";
+            return "removed from queue";
     }
 }
 /** Describe the spec chain for a queue entry. */
@@ -114,12 +116,28 @@ export function runtimeLabel(runtime) {
     }
     return runtime.lastTickOutcome;
 }
+const STATUS_DISPLAY = {
+    queued: "queued",
+    preparing_head: "preparing",
+    validating: "testing",
+    merging: "merging",
+    merged: "merged",
+    evicted: "evicted",
+    dequeued: "removed",
+};
+function displayStatus(status) {
+    return STATUS_DISPLAY[status] ?? status;
+}
 export function formatEventSummary(event) {
-    const transition = event.fromStatus ? `${event.fromStatus} -> ${event.toStatus}` : `entered ${event.toStatus}`;
+    const from = event.fromStatus ? displayStatus(event.fromStatus) : null;
+    const to = displayStatus(event.toStatus);
+    const transition = from ? `${from} \u2192 ${to}` : to;
     return `#${event.prNumber} ${transition}${event.detail ? ` (${event.detail})` : ""}`;
 }
 export function formatEntryEvent(event) {
-    const transition = event.fromStatus ? `${event.fromStatus} -> ${event.toStatus}` : `entered ${event.toStatus}`;
+    const from = event.fromStatus ? displayStatus(event.fromStatus) : null;
+    const to = displayStatus(event.toStatus);
+    const transition = from ? `${from} \u2192 ${to}` : to;
     return `${transition}${event.detail ? ` (${event.detail})` : ""}`;
 }
 export function formatDuration(ms) {

package/dist/watch/state-visualization.js

@@ -2,12 +2,12 @@ const MAIN_STATES = ["queued", "preparing_head", "validating", "merging", "merge
 const EXIT_STATES = ["evicted", "dequeued"];
 const STATE_LABELS = {
     queued: "queued",
-    preparing_head: "preparing_head",
-    validating: "validating",
+    preparing_head: "preparing",
+    validating: "testing",
     merging: "merging",
     merged: "merged",
     evicted: "evicted",
-    dequeued: "dequeued",
+    dequeued: "removed",
 };
 function labelForState(state) {
     return STATE_LABELS[state] ?? state;
@@ -43,85 +43,61 @@ export function buildEntryStateGraph(detail) {
 export function buildExternalRepairObservations(detail, options) {
     const { entry, incidents } = detail;
     const observations = [];
+    // What is this entry doing right now?
     if (entry.status === "merged") {
-        observations.push({
-            tone: "success",
-            text: "Merged by steward; no further queue action is required for this entry.",
-        });
+        observations.push({ tone: "success", text: "Landed on main." });
     }
     else if (entry.status === "dequeued") {
-        observations.push({
-            tone: "info",
-            text: "Removed from the queue without merge; steward will not advance this entry further.",
-        });
+        observations.push({ tone: "info", text: "Removed from queue." });
     }
     else if (entry.status === "evicted") {
-        observations.push({
-            tone: "warn",
-            text: "Evicted after steward retries; external branch repair is expected before any later re-admission.",
-        });
+        observations.push({ tone: "warn", text: "Removed after failed retries. Branch needs repair before re-admission." });
     }
     else if (options.isHead && options.queueBlock?.reason === "main_broken") {
         const failingNames = options.queueBlock.failingChecks.map((check) => check.name);
         observations.push({
             tone: "warn",
-            text: `Head-of-line entry is paused because ${options.queueBlock.baseBranch} is unhealthy${failingNames.length > 0 ? ` (${failingNames.join(", ")})` : ""}.`,
+            text: `Queue paused: ${options.queueBlock.baseBranch} CI is failing${failingNames.length > 0 ? ` (${failingNames.join(", ")})` : ""}. Will resume when main is green.`,
         });
     }
     else if (options.isHead) {
-        observations.push({
-            tone: "info",
-            text: "Head-of-line entry; steward can advance this PR on the next reconcile tick.",
-        });
+        observations.push({ tone: "info", text: "First in queue. Will advance on the next tick." });
     }
     else if (options.activeIndex !== null && options.headPrNumber !== null) {
         observations.push({
             tone: "info",
-            text: `Waiting behind current head #${options.headPrNumber} as active entry ${options.activeIndex} of ${options.activeCount}.`,
+            text: `Position ${options.activeIndex} of ${options.activeCount}. Being tested together with PRs ahead.`,
         });
     }
     else {
-        observations.push({
-            tone: "info",
-            text: "Queued for serial processing by the steward.",
-        });
+        observations.push({ tone: "info", text: "Waiting in queue." });
     }
+    // What went wrong last time?
     const latestIncident = incidents[incidents.length - 1];
     if (latestIncident) {
         observations.push({
             tone: latestIncident.outcome === "open" ? "warn" : "info",
-            text: `Latest failure class: ${latestIncident.failureClass} (${latestIncident.outcome}).`,
+            text: `Last failure: ${latestIncident.failureClass} (${latestIncident.outcome}).`,
         });
     }
+    // What is blocking progress?
     if (entry.lastFailedBaseSha) {
         observations.push({
             tone: "warn",
-            text: `Retry-gated: conflict on base ${entry.lastFailedBaseSha.slice(0, 7)}. Waiting for base to advance before rebuilding spec.`,
+            text: "Conflicts with main. Will retry automatically when another PR merges and main advances.",
         });
     }
     else if (entry.status === "validating") {
-        const specNote = entry.specBranch
-            ? `CI running on spec branch ${entry.specBranch}.`
-            : "Waiting on CI for the spec branch.";
         const cascadeNote = entry.specBasedOn
-            ? " Will merge automatically when head clears (cascade)."
+            ? " Tests pass → merges automatically when PRs ahead finish."
             : "";
         observations.push({
             tone: "info",
-            text: `${specNote}${cascadeNote}`,
+            text: `CI running on combined changes.${cascadeNote}`,
         });
     }
     else if (entry.status === "merging") {
-        observations.push({
-            tone: "info",
-            text: "CI passed; pushing spec branch to main (fast-forward).",
-        });
-    }
-    if (entry.generation > 0) {
-        observations.push({
-            tone: "info",
-            text: `Observed ${entry.generation} branch head update${entry.generation === 1 ? "" : "s"} since first admission.`,
-        });
+        observations.push({ tone: "info", text: "CI passed. Landing on main." });
     }
     return observations.slice(0, 4);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-steward",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Serial merge queue for GitHub — rebase, CI-gate, and merge PRs one at a time",
   "type": "module",
   "repository": {