merge-steward 0.32.4 → 0.32.6

package/dist/cli/commands/queue.js

@@ -51,7 +51,6 @@ async function readQueueSnapshot(config, eventLimit) {
                         lastTickOutcome: "idle",
                         lastTickError: null,
                     },
-                    queueBlock: null,
                     entries,
                     recentEvents: store.listRecentEvents(config.repoId, { limit: eventLimit }),
                 },
@@ -92,16 +91,6 @@ export function formatQueueStatusText(source, snapshot) {
                 ...(firstLine(snapshot.runtime.lastTickError) ? [`Last error: ${firstLine(snapshot.runtime.lastTickError)}`] : []),
             ]
             : []),
-        ...(snapshot.queueBlock
-            ? [
-                `Queue blocked: ${snapshot.queueBlock.reason} on ${snapshot.queueBlock.baseBranch}${snapshot.queueBlock.baseSha ? ` @ ${snapshot.queueBlock.baseSha.slice(0, 8)}` : ""}`,
-                `Missing required: ${snapshot.queueBlock.missingRequiredChecks.length > 0 ? snapshot.queueBlock.missingRequiredChecks.join(", ") : "(none)"}`,
-                `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/graceful-shutdown.d.ts

@@ -0,0 +1,11 @@
+export interface ShutdownLogger {
+    info(bindings: Record<string, unknown>, message: string): void;
+    warn(bindings: Record<string, unknown>, message: string): void;
+    error(bindings: Record<string, unknown>, message: string): void;
+}
+export declare function createGracefulShutdown(options: {
+    service: string;
+    logger: ShutdownLogger;
+    cleanup: () => Promise<void>;
+    terminate?: (code: number) => void;
+}): (trigger: string) => Promise<void>;

package/dist/graceful-shutdown.js

@@ -0,0 +1,29 @@
+export function createGracefulShutdown(options) {
+    let shutdownPromise;
+    let firstTrigger;
+    const terminate = options.terminate ?? ((code) => {
+        process.exitCode = code;
+        setImmediate(() => process.exit(code));
+    });
+    return (trigger) => {
+        if (shutdownPromise) {
+            options.logger.warn({ service: options.service, trigger, firstTrigger }, "Shutdown already in progress");
+            return shutdownPromise;
+        }
+        firstTrigger = trigger;
+        options.logger.info({ service: options.service, trigger }, "Shutdown requested");
+        shutdownPromise = options.cleanup()
+            .then(() => {
+            options.logger.info({ service: options.service, trigger }, "Shutdown complete");
+        })
+            .catch((error) => {
+            options.logger.error({
+                service: options.service,
+                trigger,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Shutdown failed");
+            terminate(1);
+        });
+        return shutdownPromise;
+    };
+}

package/dist/server.js

@@ -11,6 +11,7 @@ import { buildMultiRepoHttpServer } from "./http-multi.js";
 import { loadAllRepoConfigs } from "./install.js";
 import { parseHomeConfigObject } from "./steward-home.js";
 import { getMergeStewardPathLayout } from "./runtime-paths.js";
+import { createGracefulShutdown } from "./graceful-shutdown.js";
 import { createGitHubAppTokenManager, generateJwt, resolveGitHubAuthConfig, resolveAppSlug } from "./github-auth.js";
 import { discoverRepoSettings } from "./github-repo-discovery.js";
 import { resolveSecretWithSource } from "./resolve-secret.js";
@@ -193,24 +194,26 @@ export async function startMultiServer() {
         },
         logger,
     });
-    const shutdown = async () => {
-        shuttingDown = true;
-        logger.info("Shutting down...");
-        githubAppTokenManager?.stop();
-        setRuntimeGitHubAuthProvider(undefined);
-        for (const record of repos.values()) {
-            const inst = record.instance;
-            if (!inst) {
-                continue;
+    const shutdown = createGracefulShutdown({
+        service: "merge-steward",
+        logger,
+        cleanup: async () => {
+            shuttingDown = true;
+            githubAppTokenManager?.stop();
+            setRuntimeGitHubAuthProvider(undefined);
+            for (const record of repos.values()) {
+                const inst = record.instance;
+                if (!inst) {
+                    continue;
+                }
+                await inst.service.stop();
+                inst.store.close();
             }
-            await inst.service.stop();
-            inst.store.close();
-        }
-        await app.close();
-        process.exit(0);
-    };
-    process.on("SIGTERM", () => void shutdown());
-    process.on("SIGINT", () => void shutdown());
+            await app.close();
+        },
+    });
+    process.once("SIGTERM", () => void shutdown("SIGTERM"));
+    process.once("SIGINT", () => void shutdown("SIGINT"));
     await app.listen({ host: bind, port });
     logger.info({ bind, port, repos: repos.size }, "merge-steward listening");
     const initializeRepo = async (record) => {

package/dist/service-runtime.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from "pino";
 import type { GitOperations, CIRunner, GitHubPRApi, EvictionReporter, SpeculativeBranchBuilder } from "./interfaces.ts";
 import type { QueueStore } from "./store.ts";
-import type { QueueBlockState, QueueReconcileResult, QueueRuntimeStatus } from "./types.ts";
+import type { QueueReconcileResult, QueueRuntimeStatus } from "./types.ts";
 import type { StewardConfig } from "./config.ts";
 import type { GitHubPolicyCache } from "./github-policy.ts";
 export declare class MergeStewardRuntime {
@@ -23,13 +23,11 @@ export declare class MergeStewardRuntime {
     private lastTickOutcome;
     private lastTickError;
     private lastReconcileEvent;
-    private currentQueueBlock;
     constructor(config: StewardConfig, policy: GitHubPolicyCache, store: QueueStore, git: GitOperations, ci: CIRunner, github: GitHubPRApi, eviction: EvictionReporter, specBuilder: SpeculativeBranchBuilder, logger: Logger, beforeTick?: (() => Promise<void>) | undefined);
     start(): Promise<void>;
     stop(): Promise<void>;
     triggerReconcile(): Promise<QueueReconcileResult>;
     getRuntimeStatus(): QueueRuntimeStatus;
-    getCurrentQueueBlock(): QueueBlockState | null;
     getGitHubPolicy(): import("./github-policy.ts").GitHubPolicySnapshot;
     private scheduleNextTick;
     private getTickAgeMs;

package/dist/service-runtime.js

@@ -18,8 +18,6 @@ export class MergeStewardRuntime {
     lastTickOutcome = "idle";
     lastTickError = null;
     lastReconcileEvent = null;
-    // The queue never blocks on main CI, so this stays null; kept for status-shape stability.
-    currentQueueBlock = null;
     constructor(config, policy, store, git, ci, github, eviction, specBuilder, logger, beforeTick) {
         this.config = config;
         this.policy = policy;
@@ -71,9 +69,6 @@ export class MergeStewardRuntime {
             lastReconcileEvent: this.lastReconcileEvent,
         };
     }
-    getCurrentQueueBlock() {
-        return this.currentQueueBlock;
-    }
     getGitHubPolicy() {
         return this.policy.getSnapshot();
     }
@@ -153,13 +148,10 @@ export class MergeStewardRuntime {
                     this.logger[level]({ ...event }, `Queue: ${event.action} PR #${event.prNumber}`);
                 },
             });
-            // The queue never blocks on main CI — main health is information-only.
-            this.currentQueueBlock = null;
             this.lastTickOutcome = "succeeded";
         }
         catch (error) {
             this.lastTickOutcome = "failed";
-            this.currentQueueBlock = null;
             this.lastTickError = error instanceof Error
                 ? `${error.message}${error.stack ? `\n${error.stack}` : ""}`
                 : String(error);

package/dist/service-watch.js

@@ -29,7 +29,6 @@ export class MergeStewardWatchQueries {
             githubPolicy: this.runtime.getGitHubPolicy(),
             summary: buildQueueSummary(entries),
             runtime: this.runtime.getRuntimeStatus(),
-            queueBlock: this.runtime.getCurrentQueueBlock(),
             entries,
             recentEvents: this.store.listRecentEvents(this.config.repoId, { limit: options?.eventLimit ?? 40 }),
         };

package/dist/types.d.ts

@@ -181,17 +181,6 @@ 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[];
-    missingRequiredChecks: string[];
-}
 export interface GitHubPolicyState {
     requiredChecks: string[];
     requireAllChecksOnEmptyRequiredSet: boolean;
@@ -206,7 +195,6 @@ export interface QueueWatchSnapshot {
     githubPolicy: GitHubPolicyState;
     summary: QueueStatusSummary;
     runtime: QueueRuntimeStatus;
-    queueBlock: QueueBlockState | null;
     entries: QueueEntry[];
     recentEvents: QueueEventSummary[];
 }

package/dist/watch/dashboard-model.js

@@ -1,5 +1,5 @@
 import { TERMINAL_STATUSES } from "../types.js";
-import { mergeWaitState, queueBlockMatchesEntry } from "./format.js";
+import { mergeWaitState } from "./format.js";
 const DECIDED_WINDOW_MS = 24 * 60 * 60 * 1000;
 const GLYPH = {
     running: "\u25cf",
@@ -61,13 +61,10 @@ function entryKind(entry) {
             return "cancelled";
     }
 }
-function entryPhrase(entry, opts) {
-    if (opts.isHead && opts.queueBlocked) {
-        return "main broken";
-    }
+function entryPhrase(entry, isHead) {
     switch (entry.status) {
         case "queued":
-            return opts.isHead ? "queued" : "behind head";
+            return isHead ? "queued" : "behind head";
         case "preparing_head":
             return entry.lastFailedBaseSha ? "has conflicts" : "preparing";
         case "validating":
@@ -116,17 +113,11 @@ function tokenSortOrder(kind) {
             return 3;
     }
 }
-function overrideKind(kind, override) {
-    if (override === "main_broken")
-        return "error";
-    return kind;
-}
 function repoEntriesFromSnapshot(snapshot, cutoff, now) {
     const latest = pickLatestPerPR(snapshot.entries);
     const head = latest
         .filter((entry) => isActive(entry.status))
         .sort((a, b) => a.position - b.position)[0] ?? null;
-    const queueBlocked = queueBlockMatchesEntry(snapshot.queueBlock, head);
     // Resolve speculative stacking: an entry's spec can be built on top of
     // another entry's spec (specBasedOn -> that entry's id). Map ids to PR
     // numbers so the views can show "stacked on #N". Only surface the link
@@ -142,11 +133,10 @@ function repoEntriesFromSnapshot(snapshot, cutoff, now) {
         if (entry.status === "dequeued")
             continue;
         const isHead = head !== null && entry.id === head.id;
-        const rawKind = entryKind(entry);
-        const kind = overrideKind(rawKind, isHead && queueBlocked ? "main_broken" : null);
+        const kind = entryKind(entry);
         const glyph = GLYPH[kind];
         const color = COLOR[kind];
-        const phrase = entryPhrase(entry, { isHead, queueBlocked });
+        const phrase = entryPhrase(entry, isHead);
         const parent = entry.specBasedOn ? idToEntry.get(entry.specBasedOn) ?? null : null;
         const stackedOnPr = parent && isActive(parent.status) ? parent.prNumber : null;
         // decidedAt is the terminal-transition time (never bumped by post-merge

package/dist/watch/format.d.ts

@@ -1,9 +1,4 @@
-import type { CheckResult, PostMergeStatus, QueueBlockState, QueueEntryStatus, QueueEventRecord, QueueEventSummary, QueueRuntimeStatus } from "../types.ts";
-export declare function isPendingMainVerification(block: QueueBlockState | null | undefined): boolean;
-export declare function queueBlockMatchesEntry(block: QueueBlockState | null | undefined, entry: {
-    id: string;
-    prNumber: number;
-} | null | undefined): block is QueueBlockState;
+import type { CheckResult, PostMergeStatus, QueueEntryStatus, QueueEventRecord, QueueEventSummary, QueueRuntimeStatus } from "../types.ts";
 export declare function shortSha(value: string | null | undefined): string;
 export declare function relativeTime(iso: string | number | null | undefined): string;
 export declare function formatTokenAge(eventAt: number): string;
@@ -71,4 +66,3 @@ export declare function ciStatusIcon(entry: {
     icon: string;
     color: string;
 };
-export declare function summarizeQueueBlock(block: QueueBlockState | null | undefined): string | null;

package/dist/watch/format.js

@@ -6,21 +6,6 @@ const QUEUE_SYMBOLS = {
     checkPending: "\u25cf",
     checkUnknown: "\u25cb",
 };
-export function isPendingMainVerification(block) {
-    return Boolean(block
-        && block.failingChecks.length === 0
-        && block.pendingChecks.length > 0
-        && block.missingRequiredChecks.length === 0);
-}
-export function queueBlockMatchesEntry(block, entry) {
-    if (!block || !entry) {
-        return false;
-    }
-    if (block.entryId) {
-        return block.entryId === entry.id;
-    }
-    return block.headPrNumber === entry.prNumber;
-}
 export function shortSha(value) {
     if (!value) {
         return "-";
@@ -341,34 +326,3 @@ export function ciStatusIcon(entry) {
             return { icon: QUEUE_SYMBOLS.checkUnknown, color: "gray" };
     }
 }
-export function summarizeQueueBlock(block) {
-    if (!block)
-        return null;
-    const missing = block.missingRequiredChecks.length > 0
-        ? `operator fix needed on ${block.baseBranch}: missing required ${block.missingRequiredChecks.join(", ")}`
-        : null;
-    const failing = block.failingChecks.length > 0 ? `failing ${summarizeCheckNames(block.failingChecks)}` : null;
-    const pending = block.pendingChecks.length > 0 ? `${summarizeCheckNames(block.pendingChecks)} pending` : null;
-    if (missing && failing && pending) {
-        return `${missing}; ${failing}; ${pending}`;
-    }
-    if (missing && failing) {
-        return `${missing}; ${failing}`;
-    }
-    if (missing && pending) {
-        return `${missing}; ${pending}`;
-    }
-    if (missing) {
-        return missing;
-    }
-    if (failing && pending) {
-        return `waiting for ${block.baseBranch}: ${failing}; ${pending}`;
-    }
-    if (failing) {
-        return `waiting for ${block.baseBranch} recovery: ${failing}`;
-    }
-    if (pending) {
-        return `waiting for ${block.baseBranch} verification: ${pending}`;
-    }
-    return `waiting for ${block.baseBranch} checks`;
-}

package/infra/merge-steward.service

@@ -21,7 +21,7 @@ LoadCredentialEncrypted=merge-steward-webhook-secret:/etc/credstore.encrypted/me
 LoadCredentialEncrypted=merge-steward-github-app-pem:/etc/credstore.encrypted/merge-steward-github-app-pem.cred
 
 ExecStart=/usr/bin/env merge-steward serve
-Restart=on-failure
+Restart=always
 RestartSec=5
 
 NoNewPrivileges=true

package/package.json

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

package/dist/watch/DetailView.d.ts

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

package/dist/watch/DetailView.js

@@ -1,23 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-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";
-export function DetailView({ detail, isHead, activeIndex, activeCount, headPrNumber, queueBlock, githubPolicy, }) {
-    if (!detail) {
-        return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Loading entry detail..." }) }));
-    }
-    const { entry, events, incidents } = detail;
-    const graph = buildEntryStateGraph(detail);
-    const observations = buildExternalRepairObservations(detail, {
-        isHead,
-        activeIndex,
-        activeCount,
-        headPrNumber,
-        queueBlock,
-    });
-    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, entry), children: humanStatus(entry.status, entry) }), _jsx(Text, { dimColor: true, children: `· ${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 }), _jsx(Text, { dimColor: true, children: `(${shortSha(entry.specSha)} ← ${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) ?? `waiting for ${queueBlock.baseBranch} checks`, "."] }), _jsx(Text, { dimColor: true, children: queueBlock.missingRequiredChecks.length > 0
-                            ? `Fix ${queueBlock.baseBranch} first, then reconcile this repo to resume the queue.`
-                            : `Will resume automatically once ${queueBlock.baseBranch} is healthy.` })] })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "GitHub Policy" }), _jsxs(Text, { dimColor: true, children: ["Required checks: ", githubPolicy.requiredChecks.length > 0 ? githubPolicy.requiredChecks.join(", ") : "(none)"] }), githubPolicy.fetchedAt ? _jsxs(Text, { dimColor: true, children: ["Fetched: ", githubPolicy.fetchedAt] }) : null, githubPolicy.lastRefreshReason ? (_jsxs(Text, { dimColor: true, children: ["Last refresh: ", githubPolicy.lastRefreshReason, githubPolicy.lastRefreshChanged === null ? "" : githubPolicy.lastRefreshChanged ? " (changed)" : " (unchanged)"] })) : null] }), _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.d.ts

@@ -1,7 +0,0 @@
-import type { VisualizationNode } from "./state-visualization.ts";
-interface EntryStateGraphProps {
-    main: VisualizationNode[];
-    exits: VisualizationNode[];
-}
-export declare function EntryStateGraph({ main, exits }: EntryStateGraphProps): React.JSX.Element;
-export {};

package/dist/watch/EntryStateGraph.js

@@ -1,12 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-export function EntryStateGraph({ main, exits }) {
-    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: " → " }), _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/ExternalRepairObservation.d.ts

@@ -1,6 +0,0 @@
-import type { ObservationLine } from "./state-visualization.ts";
-interface ExternalRepairObservationProps {
-    observations: ObservationLine[];
-}
-export declare function ExternalRepairObservation({ observations }: ExternalRepairObservationProps): React.JSX.Element;
-export {};

package/dist/watch/ExternalRepairObservation.js

@@ -1,15 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-function toneColor(tone) {
-    switch (tone) {
-        case "success":
-            return "green";
-        case "warn":
-            return "yellow";
-        case "info":
-            return "cyan";
-    }
-}
-export function ExternalRepairObservation({ observations }) {
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "External Repair" }), observations.map((observation, index) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: toneColor(observation.tone), children: "-" }), _jsx(Text, { children: observation.text })] }, `external-repair-${index}`)))] }));
-}

package/dist/watch/QueueListView.d.ts

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

package/dist/watch/QueueListView.js

@@ -1,49 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from "react";
-import { Box, Text, useStdout } from "ink";
-import { TERMINAL_STATUSES } from "../types.js";
-import { buildChainEntries } from "./display-filter.js";
-import { ciStatusIcon, formatEventSummary, humanStatus, isPendingMainVerification, nextStepLabel, postMergeStatusLine, queueBlockMatchesEntry, relativeTime, statusColor, summarizeQueueBlock, truncate } from "./format.js";
-const CHROME_ROWS = 13;
-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";
-        const statusSuffix = entry.status === "merged"
-            ? ` \u00b7 ${postMergeStatusLine(entry)}`
-            : "";
-        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)}${statusSuffix}` })] }));
-    }
-    const blockedOnMain = isHead && queueBlockMatchesEntry(queueBlock, entry);
-    const pendingMainVerification = blockedOnMain && isPendingMainVerification(queueBlock);
-    const status = blockedOnMain
-        ? pendingMainVerification ? "verifying main" : "waiting for main"
-        : humanStatus(entry.status, entry);
-    const color = blockedOnMain ? (pendingMainVerification ? "yellow" : "red")
-        : entry.status === "preparing_head" && entry.lastFailedBaseSha ? "yellow"
-            : statusColor(entry.status);
-    const nextStep = blockedOnMain
-        ? summarizeQueueBlock(queueBlock) ?? "waiting for main checks to settle"
-        : nextStepLabel(entry.status, entry);
-    // 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 ? ">" : " " }), _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, allEntries, selectedEntryId, recentEvents, headEntryId, queueBlock, }) {
-    const { stdout } = useStdout();
-    const rows = stdout?.rows ?? 24;
-    // 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 effectiveQueueBlock = queueBlock && queueBlock.entryId === headEntryId ? queueBlock : null;
-    const queueBlockLabel = summarizeQueueBlock(effectiveQueueBlock);
-    // 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));
-                    })] })), effectiveQueueBlock && (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["Queue paused: ", queueBlockLabel ?? "waiting for main checks", effectiveQueueBlock.baseSha ? ` at ${truncate(effectiveQueueBlock.baseSha, 10)}` : "", "."] }), _jsx(Text, { dimColor: true, children: effectiveQueueBlock.missingRequiredChecks.length > 0
-                            ? `Head PR #${effectiveQueueBlock.headPrNumber ?? "?"} is waiting for an operator fix on ${effectiveQueueBlock.baseBranch}.`
-                            : `Head PR #${effectiveQueueBlock.headPrNumber ?? "?"} will resume automatically once main is healthy.` })] })), 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: effectiveQueueBlock }, 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/state-visualization.d.ts

@@ -1,22 +0,0 @@
-import type { QueueBlockState, QueueEntryDetail } from "../types.ts";
-export type VisualizationNodeStatus = "current" | "visited" | "upcoming";
-export interface VisualizationNode {
-    state: string;
-    label: string;
-    status: VisualizationNodeStatus;
-}
-export interface ObservationLine {
-    tone: "info" | "warn" | "success";
-    text: string;
-}
-export declare function buildEntryStateGraph(detail: QueueEntryDetail): {
-    main: VisualizationNode[];
-    exits: VisualizationNode[];
-};
-export declare function buildExternalRepairObservations(detail: QueueEntryDetail, options: {
-    isHead: boolean;
-    activeIndex: number | null;
-    activeCount: number;
-    headPrNumber: number | null;
-    queueBlock: QueueBlockState | null;
-}): ObservationLine[];

package/dist/watch/state-visualization.js

@@ -1,120 +0,0 @@
-import { queueBlockMatchesEntry } from "./format.js";
-const MAIN_STATES = ["queued", "preparing_head", "validating", "merging", "merged"];
-const EXIT_STATES = ["evicted", "dequeued"];
-const STATE_LABELS = {
-    queued: "queued",
-    preparing_head: "preparing",
-    validating: "testing",
-    merging: "merging",
-    merged: "merged",
-    evicted: "evicted",
-    dequeued: "removed",
-};
-function labelForState(state) {
-    return STATE_LABELS[state] ?? state;
-}
-function buildNodes(states, visited, currentStatus) {
-    return states.map((state) => ({
-        state,
-        label: labelForState(state),
-        status: currentStatus === state
-            ? "current"
-            : visited.has(state)
-                ? "visited"
-                : "upcoming",
-    }));
-}
-function collectVisitedStates(detail) {
-    const visited = new Set([detail.entry.status]);
-    for (const event of detail.events) {
-        if (event.fromStatus) {
-            visited.add(event.fromStatus);
-        }
-        visited.add(event.toStatus);
-    }
-    return visited;
-}
-export function buildEntryStateGraph(detail) {
-    const visited = collectVisitedStates(detail);
-    return {
-        main: buildNodes(MAIN_STATES, visited, detail.entry.status),
-        exits: buildNodes(EXIT_STATES, visited, detail.entry.status),
-    };
-}
-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: "Landed on main." });
-    }
-    else if (entry.status === "dequeued") {
-        observations.push({ tone: "info", text: "Removed from queue." });
-    }
-    else if (entry.status === "evicted") {
-        observations.push({ tone: "warn", text: "Removed after failed retries. Branch needs repair before re-admission." });
-    }
-    else if (options.isHead && queueBlockMatchesEntry(options.queueBlock, entry)) {
-        const failingNames = options.queueBlock.failingChecks.map((check) => check.name);
-        const pendingNames = options.queueBlock.pendingChecks.map((check) => check.name);
-        const missingNames = options.queueBlock.missingRequiredChecks;
-        const detail = [
-            missingNames.length > 0 ? `missing required ${missingNames.join(", ")}` : null,
-            failingNames.length > 0 ? `failing ${failingNames.join(", ")}` : null,
-            pendingNames.length > 0 ? `pending ${pendingNames.join(", ")}` : null,
-        ].filter(Boolean).join("; ");
-        observations.push({
-            tone: "warn",
-            text: missingNames.length > 0
-                ? `Queue paused: ${options.queueBlock.baseBranch} is missing required checks${detail ? ` (${detail})` : ""}. Operator action is required on main before the queue can continue.`
-                : pendingNames.length > 0 && failingNames.length === 0
-                    ? `Queue paused: ${options.queueBlock.baseBranch} is still verifying${detail ? ` (${detail})` : ""}. Will resume when checks settle.`
-                    : `Queue paused: ${options.queueBlock.baseBranch} is unhealthy${detail ? ` (${detail})` : ""}. Will resume when main is healthy.`,
-        });
-    }
-    else if (options.isHead) {
-        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: `Position ${options.activeIndex} of ${options.activeCount}. Being tested together with PRs ahead.`,
-        });
-    }
-    else {
-        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: `Last failure: ${latestIncident.failureClass} (${latestIncident.outcome}).`,
-        });
-    }
-    // What is blocking progress?
-    if (entry.lastFailedBaseSha) {
-        observations.push({
-            tone: "warn",
-            text: "Conflicts with main. Will retry automatically when another PR merges and main advances.",
-        });
-    }
-    else if (entry.status === "validating") {
-        const cascadeNote = entry.specBasedOn
-            ? " Tests pass → merges automatically when PRs ahead finish."
-            : "";
-        observations.push({
-            tone: "info",
-            text: `CI running on combined changes.${cascadeNote}`,
-        });
-    }
-    else if (entry.status === "merging") {
-        if (entry.waitDetail?.toLowerCase().includes("approval") || entry.waitDetail?.toLowerCase().includes("review")) {
-            observations.push({ tone: "warn", text: "CI passed. Merge is blocked until GitHub approval returns." });
-        }
-        else {
-            observations.push({ tone: "info", text: "CI passed. Landing on main." });
-        }
-    }
-    return observations.slice(0, 4);
-}