merge-steward 0.4.1 → 0.5.1

package/dist/cli/commands/queue.js

@@ -29,6 +29,7 @@ async function readQueueSnapshot(config, eventLimit) {
                         lastTickOutcome: "idle",
                         lastTickError: null,
                     },
+                    queueBlock: null,
                     entries,
                     recentEvents: store.listRecentEvents(config.repoId, { limit: eventLimit }),
                 },
@@ -94,6 +95,15 @@ export async function handleQueue(parsed, stdout) {
             `Queued: ${snapshot.summary.queued}  preparing: ${snapshot.summary.preparingHead}  validating: ${snapshot.summary.validating}  merging: ${snapshot.summary.merging}`,
             `Merged: ${snapshot.summary.merged}  evicted: ${snapshot.summary.evicted}  dequeued: ${snapshot.summary.dequeued}`,
             snapshot.summary.headPrNumber ? `Head PR: #${snapshot.summary.headPrNumber}` : "Head PR: none",
+            ...(snapshot.queueBlock
+                ? [
+                    `Queue blocked: ${snapshot.queueBlock.reason} on ${snapshot.queueBlock.baseBranch}${snapshot.queueBlock.baseSha ? ` @ ${snapshot.queueBlock.baseSha.slice(0, 8)}` : ""}`,
+                    `Base failures: ${snapshot.queueBlock.failingChecks.length > 0 ? snapshot.queueBlock.failingChecks.map((check) => check.name).join(", ") : "(none)"}`,
+                    ...(snapshot.queueBlock.pendingChecks.length > 0
+                        ? [`Base pending: ${snapshot.queueBlock.pendingChecks.map((check) => check.name).join(", ")}`]
+                        : []),
+                ]
+                : []),
             "",
             "Entries:",
             ...(snapshot.entries.length > 0

package/dist/github/pr-client.js

@@ -53,10 +53,9 @@ export class GitHubPRClient {
         try {
             const checks = JSON.parse(result.stdout);
             return checks
-                .filter((c) => c.conclusion !== null)
                 .map((c) => ({
                 name: c.name,
-                conclusion: mapRestConclusion(c.conclusion),
+                conclusion: mapRestConclusion(c.status, c.conclusion),
                 ...(c.html_url ? { url: c.html_url } : {}),
             }));
         }
@@ -100,8 +99,10 @@ export class GitHubPRClient {
         }
     }
 }
-/** Map GitHub REST API check-run conclusion (lowercase) to our union. */
-function mapRestConclusion(conclusion) {
+/** Map GitHub REST API check-run status/conclusion to our union. */
+function mapRestConclusion(status, conclusion) {
+    if (status !== "completed" || conclusion === null)
+        return "pending";
     switch (conclusion) {
         case "success":
         case "neutral":

package/dist/reconciler.js

@@ -75,11 +75,26 @@ export async function reconcile(ctx) {
 async function prepareHead(ctx, entry) {
     emit(ctx, entry, "fetch_started");
     await ctx.git.fetch();
+    const baseSha = await ctx.git.headSha(ref(ctx, ctx.baseBranch));
     // Gate: main CI must be green.
     if (ctx.ci.getMainStatus) {
         const mainStatus = await ctx.ci.getMainStatus(ctx.baseBranch);
         if (mainStatus === "fail") {
-            emit(ctx, entry, "main_broken");
+            let mainChecks = [];
+            try {
+                mainChecks = await ctx.github.listChecksForRef(ref(ctx, ctx.baseBranch));
+            }
+            catch {
+                mainChecks = [];
+            }
+            const failingChecks = mainChecks.filter((check) => check.conclusion === "failure");
+            const pendingChecks = mainChecks.filter((check) => check.conclusion === "pending");
+            emit(ctx, entry, "main_broken", {
+                baseSha,
+                failingChecks,
+                pendingChecks,
+                detail: describeMainBroken(failingChecks, pendingChecks),
+            });
             return;
         }
     }
@@ -90,7 +105,6 @@ async function prepareHead(ctx, entry) {
         ctx.store.updateHead(entry.id, currentRef);
         return;
     }
-    const baseSha = await ctx.git.headSha(ref(ctx, ctx.baseBranch));
     // Gate: budget exhausted after previous conflict.
     if (isBudgetExhausted(entry) && entry.lastFailedBaseSha !== null) {
         emit(ctx, entry, "budget_exhausted", { baseSha });
@@ -104,6 +118,23 @@ async function prepareHead(ctx, entry) {
     }
     await performRebase(ctx, entry, baseSha);
 }
+function describeMainBroken(failingChecks, pendingChecks) {
+    const parts = [];
+    if (failingChecks.length > 0) {
+        parts.push(`failing ${summarizeCheckNames(failingChecks)}`);
+    }
+    if (pendingChecks.length > 0) {
+        parts.push(`pending ${summarizeCheckNames(pendingChecks)}`);
+    }
+    return parts.length > 0 ? `main checks unhealthy: ${parts.join("; ")}` : "main checks unhealthy";
+}
+function summarizeCheckNames(checks, limit = 3) {
+    const names = [...new Set(checks.map((check) => check.name))];
+    if (names.length <= limit) {
+        return names.join(", ");
+    }
+    return `${names.slice(0, limit).join(", ")} +${names.length - limit} more`;
+}
 async function performRebase(ctx, entry, baseSha) {
     emit(ctx, entry, "rebase_started", { baseSha });
     const result = await ctx.git.rebase(entry.branch, ref(ctx, ctx.baseBranch));

package/dist/service.d.ts

@@ -23,7 +23,7 @@ export declare class MergeStewardService {
     private lastTickCompletedAt;
     private lastTickOutcome;
     private lastTickError;
-    private mainBrokenReported;
+    private currentQueueBlock;
     constructor(config: StewardConfig, store: QueueStore, git: GitOperations, ci: CIRunner, github: GitHubPRApi, eviction: EvictionReporter, specBuilder: import("./interfaces.ts").SpeculativeBranchBuilder | null, logger: Logger);
     /** Expose the GitHub client for webhook handler branch→PR lookups. */
     get githubApi(): GitHubPRApi;
@@ -69,5 +69,6 @@ export declare class MergeStewardService {
     acknowledgeExternalMerge(prNumber: number): void;
     private runTick;
     private scheduleNextTick;
+    private describeMainBroken;
 }
 export declare function buildSummary(entries: QueueEntry[]): QueueStatusSummary;

package/dist/service.js

@@ -21,7 +21,7 @@ export class MergeStewardService {
     lastTickCompletedAt = null;
     lastTickOutcome = "idle";
     lastTickError = null;
-    mainBrokenReported = false;
+    currentQueueBlock = null;
     constructor(config, store, git, ci, github, eviction, specBuilder, logger) {
         this.config = config;
         this.store = store;
@@ -127,6 +127,7 @@ export class MergeStewardService {
             baseBranch: this.config.baseBranch,
             summary: buildSummary(entries),
             runtime: this.getRuntimeStatus(),
+            queueBlock: this.currentQueueBlock,
             entries,
             recentEvents: this.store.listRecentEvents(this.config.repoId, { limit: options?.eventLimit ?? 40 }),
         };
@@ -241,6 +242,7 @@ export class MergeStewardService {
         this.lastTickOutcome = "running";
         this.lastTickError = null;
         try {
+            let tickQueueBlockEvent = null;
             await reconcile({
                 store: this.store,
                 repoId: this.config.repoId,
@@ -261,12 +263,12 @@ export class MergeStewardService {
                         || event.action === "fetch_started";
                     const level = isWarn ? "warn" : isDebug ? "debug" : "info";
                     this.logger[level]({ ...event }, `Queue: ${event.action} PR #${event.prNumber}`);
-                    if (event.action === "main_broken" && !this.mainBrokenReported) {
-                        this.mainBrokenReported = true;
+                    if (event.action === "main_broken" && tickQueueBlockEvent === null) {
+                        tickQueueBlockEvent = event;
                     }
                 },
             });
-            this.mainBrokenReported = false; // Reset after successful tick.
+            this.currentQueueBlock = tickQueueBlockEvent ? await this.describeMainBroken(tickQueueBlockEvent) : null;
             this.lastTickOutcome = "succeeded";
         }
         catch (error) {
@@ -288,6 +290,39 @@ export class MergeStewardService {
         this.tickTimer = setTimeout(() => void this.runTick(), this.config.pollIntervalMs);
         this.tickTimer.unref?.();
     }
+    async describeMainBroken(event) {
+        const baseRef = `origin/${this.config.baseBranch}`;
+        let baseSha = null;
+        try {
+            baseSha = await this.git.headSha(baseRef);
+        }
+        catch {
+            try {
+                baseSha = await this.git.headSha(this.config.baseBranch);
+            }
+            catch {
+                baseSha = event.baseSha ?? null;
+            }
+        }
+        const checkRef = event.baseSha ?? baseSha ?? baseRef;
+        let checks = [];
+        try {
+            checks = await this.github.listChecksForRef(checkRef);
+        }
+        catch {
+            checks = [];
+        }
+        return {
+            reason: "main_broken",
+            entryId: event.entryId,
+            headPrNumber: event.prNumber,
+            baseBranch: this.config.baseBranch,
+            baseSha,
+            observedAt: event.at,
+            failingChecks: event.failingChecks ?? checks.filter((check) => check.conclusion === "failure"),
+            pendingChecks: event.pendingChecks ?? checks.filter((check) => check.conclusion === "pending"),
+        };
+    }
 }
 /** Simple glob match: supports * as wildcard. */
 function matchGlob(pattern, value) {

package/dist/types.d.ts

@@ -117,12 +117,23 @@ export interface QueueStatusSummary {
     headEntryId: string | null;
     headPrNumber: number | null;
 }
+export interface QueueBlockState {
+    reason: "main_broken";
+    entryId: string;
+    headPrNumber: number | null;
+    baseBranch: string;
+    baseSha: string | null;
+    observedAt: string;
+    failingChecks: CheckResult[];
+    pendingChecks: CheckResult[];
+}
 export interface QueueWatchSnapshot {
     repoId: string;
     repoFullName: string;
     baseBranch: string;
     summary: QueueStatusSummary;
     runtime: QueueRuntimeStatus;
+    queueBlock: QueueBlockState | null;
     entries: QueueEntry[];
     recentEvents: QueueEventSummary[];
 }
@@ -169,6 +180,8 @@ export interface ReconcileEvent {
     baseSha?: string | undefined;
     ciRunId?: string | undefined;
     conflictFiles?: string[] | undefined;
+    failingChecks?: CheckResult[] | undefined;
+    pendingChecks?: CheckResult[] | undefined;
     failureClass?: string | undefined;
     dependsOn?: string | undefined;
 }

package/dist/watch/App.js

@@ -188,5 +188,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, selectedEntryId: selectedEntryId, recentEvents: snapshot?.recentEvents ?? [], headEntryId: snapshot?.summary.headEntryId ?? null })) : (_jsx(DetailView, { detail: detail, isHead: isHeadSelected, activeIndex: selectedActiveIndex, activeCount: activeEntries.length, headPrNumber: snapshot?.summary.headPrNumber ?? 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, 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.d.ts

@@ -1,10 +1,11 @@
-import type { QueueEntryDetail } from "../types.ts";
+import type { QueueBlockState, QueueEntryDetail } from "../types.ts";
 interface DetailViewProps {
     detail: QueueEntryDetail | null;
     isHead: boolean;
     activeIndex: number | null;
     activeCount: number;
     headPrNumber: number | null;
+    queueBlock: QueueBlockState | null;
 }
-export declare function DetailView({ detail, isHead, activeIndex, activeCount, headPrNumber, }: DetailViewProps): React.JSX.Element;
+export declare function DetailView({ detail, isHead, activeIndex, activeCount, headPrNumber, queueBlock, }: DetailViewProps): React.JSX.Element;
 export {};

package/dist/watch/DetailView.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { formatEntryEvent, progressBar, relativeTime, shortSha, statusColor } from "./format.js";
+import { formatEntryEvent, progressBar, relativeTime, shortSha, statusColor, summarizeQueueBlock } from "./format.js";
 import { EntryStateGraph } from "./EntryStateGraph.js";
 import { ExternalRepairObservation } from "./ExternalRepairObservation.js";
 import { buildEntryStateGraph, buildExternalRepairObservations } from "./state-visualization.js";
-export function DetailView({ detail, isHead, activeIndex, activeCount, headPrNumber, }) {
+export function DetailView({ detail, isHead, activeIndex, activeCount, headPrNumber, queueBlock, }) {
     if (!detail) {
         return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Loading entry detail..." }) }));
     }
@@ -15,6 +15,7 @@ export function DetailView({ detail, isHead, activeIndex, activeCount, headPrNum
         activeIndex,
         activeCount,
         headPrNumber,
+        queueBlock,
     });
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 2, children: [_jsxs(Text, { bold: true, children: ["#", entry.prNumber] }), _jsx(Text, { color: statusColor(entry.status), children: entry.status }), _jsxs(Text, { dimColor: true, children: ["pos ", entry.position] }), _jsxs(Text, { dimColor: true, children: ["generation ", entry.generation] }), _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.issueKey && _jsx(Text, { dimColor: true, children: entry.issueKey })] }), 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] }), _jsx(Text, { color: statusColor(entry.status), children: entry.status }), _jsxs(Text, { dimColor: true, children: ["pos ", entry.position] }), _jsxs(Text, { dimColor: true, children: ["generation ", entry.generation] }), _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.issueKey && _jsx(Text, { dimColor: true, children: entry.issueKey })] }), 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}`))))] })] }));
 }

package/dist/watch/QueueListView.d.ts

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

package/dist/watch/QueueListView.js

@@ -1,19 +1,23 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { Box, Text, useStdout } from "ink";
-import { formatEventSummary, relativeTime, statusColor, truncate } from "./format.js";
+import { formatEventSummary, relativeTime, statusColor, summarizeQueueBlock, truncate } from "./format.js";
 const CHROME_ROWS = 13;
-function QueueRow({ entry, selected, branchWidth, isHead, }) {
+function QueueRow({ entry, selected, branchWidth, isHead, queueBlock, }) {
     const retryText = `${entry.retryAttempts}/${entry.maxRetries}`;
     const ciText = entry.ciRetries > 0 ? ` ci:${entry.ciRetries}` : "";
-    return (_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : "gray", children: selected ? "›" : " " }), _jsx(Text, { color: isHead ? "green" : "gray", children: isHead ? "*" : " " }), _jsxs(Text, { children: [" ", String(entry.position).padStart(2, " "), " "] }), _jsxs(Text, { bold: true, children: ["#", String(entry.prNumber).padStart(4, " ")] }), _jsx(Text, { children: " " }), _jsx(Text, { color: statusColor(entry.status), children: entry.status.padEnd(14, " ") }), _jsx(Text, { children: " " }), _jsx(Text, { children: retryText.padEnd(4, " ") }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: relativeTime(entry.updatedAt).padStart(4, " ") }), _jsx(Text, { children: " " }), _jsx(Text, { children: truncate(entry.branch, branchWidth) }), _jsx(Text, { dimColor: true, children: ciText })] }));
+    const blockedOnMain = isHead && queueBlock?.reason === "main_broken" && queueBlock.headPrNumber === entry.prNumber;
+    const renderedStatus = blockedOnMain ? "blocked/main" : entry.status;
+    const renderedColor = blockedOnMain ? "red" : statusColor(entry.status);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : "gray", children: selected ? "›" : " " }), _jsx(Text, { color: blockedOnMain ? "red" : isHead ? "green" : "gray", children: blockedOnMain ? "!" : isHead ? "*" : " " }), _jsxs(Text, { children: [" ", String(entry.position).padStart(2, " "), " "] }), _jsxs(Text, { bold: true, children: ["#", String(entry.prNumber).padStart(4, " ")] }), _jsx(Text, { children: " " }), _jsx(Text, { color: renderedColor, children: renderedStatus.padEnd(14, " ") }), _jsx(Text, { children: " " }), _jsx(Text, { children: retryText.padEnd(4, " ") }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: relativeTime(entry.updatedAt).padStart(4, " ") }), _jsx(Text, { children: " " }), _jsx(Text, { children: truncate(entry.branch, branchWidth) }), _jsx(Text, { dimColor: true, children: ciText })] }));
 }
-export function QueueListView({ entries, selectedEntryId, recentEvents, headEntryId, }) {
+export function QueueListView({ entries, selectedEntryId, recentEvents, headEntryId, queueBlock, }) {
     const { stdout } = useStdout();
     const rows = stdout?.rows ?? 24;
     const cols = stdout?.columns ?? 100;
     const branchWidth = Math.max(12, cols - 36);
     const eventRows = Math.min(8, Math.max(4, rows - entries.length - CHROME_ROWS));
     const displayedEvents = useMemo(() => recentEvents.slice(-eventRows), [eventRows, recentEvents]);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: " s h pos pr    status          rt   ago branch" }), 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, branchWidth: branchWidth, isHead: entry.id === headEntryId }, 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}`))))] })] }));
+    const queueBlockLabel = summarizeQueueBlock(queueBlock);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [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."] })] })), _jsx(Text, { dimColor: true, children: " s h pos pr    status          rt   ago branch" }), 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, branchWidth: branchWidth, 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/StatusBar.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useStdout } from "ink";
-import { formatDuration, relativeTime, runtimeLabel, truncate } from "./format.js";
+import { formatDuration, relativeTime, runtimeLabel, summarizeQueueBlock, truncate } from "./format.js";
 import { FreshnessBadge } from "./FreshnessBadge.js";
 const TERMINAL = new Set(["merged", "evicted", "dequeued"]);
 export function StatusBar({ snapshot, connected, filter, lastSnapshotReceivedAt, expectedFreshMs, }) {
@@ -12,6 +12,7 @@ export function StatusBar({ snapshot, connected, filter, lastSnapshotReceivedAt,
         return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: truncate(left, availableLeft) }), _jsx(FreshnessBadge, { connected: connected, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: expectedFreshMs })] }));
     }
     const { summary, runtime } = snapshot;
+    const queueBlockLabel = summarizeQueueBlock(snapshot.queueBlock);
     const activeEntries = snapshot.entries.filter((e) => !TERMINAL.has(e.status));
     const avgWaitMs = activeEntries.length > 0
         ? activeEntries.reduce((sum, e) => sum + (Date.now() - new Date(e.enqueuedAt).getTime()), 0) / activeEntries.length
@@ -21,6 +22,7 @@ export function StatusBar({ snapshot, connected, filter, lastSnapshotReceivedAt,
         `base:${snapshot.baseBranch}`,
         `${summary.total} entries ${summary.active} active`,
         summary.headPrNumber !== null ? `head #${summary.headPrNumber}` : null,
+        queueBlockLabel ? `blocked ${queueBlockLabel}` : null,
         avgWaitMs > 0 ? `wait ~${formatDuration(avgWaitMs)}` : null,
         `tick ${runtimeLabel(runtime)} ${relativeTime(runtime.lastTickCompletedAt ?? runtime.lastTickStartedAt)}`,
         filter,

package/dist/watch/format.d.ts

@@ -1,4 +1,4 @@
-import type { QueueEntryStatus, QueueEventRecord, QueueEventSummary, QueueRuntimeStatus } from "../types.ts";
+import type { CheckResult, QueueBlockState, QueueEntryStatus, QueueEventRecord, QueueEventSummary, QueueRuntimeStatus } from "../types.ts";
 export declare function shortSha(value: string | null | undefined): string;
 export declare function relativeTime(iso: string | null | undefined): string;
 export declare function statusColor(status: QueueEntryStatus): "yellow" | "cyan" | "green" | "red" | "gray";
@@ -8,3 +8,5 @@ export declare function formatEntryEvent(event: QueueEventRecord): string;
 export declare function formatDuration(ms: number): string;
 export declare function progressBar(current: number, total: number, width: number): string;
 export declare function truncate(value: string, width: number): string;
+export declare function summarizeCheckNames(checks: CheckResult[], limit?: number): string;
+export declare function summarizeQueueBlock(block: QueueBlockState | null | undefined): string | null;

package/dist/watch/format.js

@@ -80,3 +80,19 @@ export function truncate(value, width) {
         return value.slice(0, width);
     return `${value.slice(0, width - 1)}…`;
 }
+export function summarizeCheckNames(checks, limit = 3) {
+    const names = [...new Set(checks.map((check) => check.name))];
+    if (names.length === 0)
+        return "unknown checks";
+    if (names.length <= limit)
+        return names.join(", ");
+    return `${names.slice(0, limit).join(", ")} +${names.length - limit} more`;
+}
+export function summarizeQueueBlock(block) {
+    if (!block)
+        return null;
+    const failing = block.failingChecks.length > 0 ? `failing ${summarizeCheckNames(block.failingChecks)}` : null;
+    const pending = block.pendingChecks.length > 0 ? `pending ${summarizeCheckNames(block.pendingChecks)}` : null;
+    const suffix = [failing, pending].filter(Boolean).join("; ");
+    return suffix ? `main broken: ${suffix}` : "main broken";
+}

package/dist/watch/state-visualization.d.ts

@@ -1,4 +1,4 @@
-import type { QueueEntryDetail } from "../types.ts";
+import type { QueueBlockState, QueueEntryDetail } from "../types.ts";
 export type VisualizationNodeStatus = "current" | "visited" | "upcoming";
 export interface VisualizationNode {
     state: string;
@@ -18,4 +18,5 @@ export declare function buildExternalRepairObservations(detail: QueueEntryDetail
     activeIndex: number | null;
     activeCount: number;
     headPrNumber: number | null;
+    queueBlock: QueueBlockState | null;
 }): ObservationLine[];

package/dist/watch/state-visualization.js

@@ -61,6 +61,13 @@ export function buildExternalRepairObservations(detail, options) {
             text: "Evicted after steward retries; external branch repair is expected before any later 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(", ")})` : ""}.`,
+        });
+    }
     else if (options.isHead) {
         observations.push({
             tone: "info",

package/package.json

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