merge-steward 0.5.2 → 0.5.4

package/dist/github/shell-git.d.ts

@@ -1,5 +1,5 @@
 import type { GitOperations, SpeculativeBranchBuilder } from "../interfaces.ts";
-import type { MergeResult, RebaseResult } from "../types.ts";
+import type { MergeResult } from "../types.ts";
 export declare class ShellGitOperations implements GitOperations, SpeculativeBranchBuilder {
     private readonly clonePath;
     private readonly repoFullName;
@@ -9,7 +9,7 @@ export declare class ShellGitOperations implements GitOperations, SpeculativeBra
     fetch(remote?: string): Promise<void>;
     headSha(branch: string): Promise<string>;
     isAncestor(ancestor: string, descendant: string): Promise<boolean>;
-    rebase(branch: string, onto: string): Promise<RebaseResult>;
+    mergeBaseInto(branch: string, base: string): Promise<MergeResult>;
     push(branch: string, force?: boolean): Promise<void>;
     buildSpeculative(prBranch: string, baseBranch: string, specName: string): Promise<MergeResult>;
     deleteSpeculative(specName: string): Promise<void>;

package/dist/github/shell-git.js

@@ -41,24 +41,22 @@ export class ShellGitOperations {
             return false;
         throw new Error(`git merge-base --is-ancestor failed: ${result.stderr || result.stdout}`);
     }
-    async rebase(branch, onto) {
+    async mergeBaseInto(branch, base) {
         const remoteBranchRef = `refs/remotes/origin/${branch}`;
         const remoteBranchExists = await this.git(["show-ref", "--verify", remoteBranchRef], { allowNonZero: true });
         if (remoteBranchExists.exitCode === 0) {
-            // Always start from the freshly fetched remote branch tip so stale local branches
-            // cannot reintroduce old commits into queue processing.
             await this.git(["checkout", "-B", branch, `origin/${branch}`]);
         }
         else {
             await this.git(["checkout", branch]);
         }
-        const result = await this.git(["rebase", onto], { allowNonZero: true });
+        const result = await this.git(["merge", "--no-ff", "--no-edit", base], { allowNonZero: true });
         if (result.exitCode !== 0) {
-            await this.git(["rebase", "--abort"], { allowNonZero: true });
+            await this.git(["merge", "--abort"], { allowNonZero: true });
             return { success: false, conflictFiles: parseConflicts(result.stderr) };
         }
         const newSha = await this.headSha("HEAD");
-        return { success: true, newHeadSha: newSha };
+        return { success: true, sha: newSha };
     }
     async push(branch, force = false) {
         const args = ["push"];

package/dist/interfaces.d.ts

@@ -1,4 +1,4 @@
-import type { CIStatus, CheckResult, IncidentRecord, MergeResult, PRStatus, QueueEntry, RebaseResult } from "./types.ts";
+import type { CIStatus, CheckResult, IncidentRecord, MergeResult, PRStatus, QueueEntry } from "./types.ts";
 /**
  * Git operations needed by the reconciler. The sim (GitSim) implements
  * additional methods for test harness setup, but the reconciler only uses these.
@@ -7,7 +7,7 @@ export interface GitOperations {
     fetch(remote?: string): Promise<void>;
     headSha(branch: string): Promise<string>;
     isAncestor(ancestor: string, descendant: string): Promise<boolean>;
-    rebase(branch: string, onto: string): Promise<RebaseResult>;
+    mergeBaseInto(branch: string, base: string): Promise<MergeResult>;
     push(branch: string, force?: boolean): Promise<void>;
 }
 /**

package/dist/reconciler.js

@@ -71,7 +71,7 @@ export async function reconcile(ctx) {
         }
     }
 }
-// ─── Head entry: fetch + gate + rebase ──────────────────────────
+// ─── Head entry: fetch + gate + branch refresh ──────────────────
 async function prepareHead(ctx, entry) {
     emit(ctx, entry, "fetch_started");
     await ctx.git.fetch();
@@ -116,7 +116,7 @@ async function prepareHead(ctx, entry) {
         emit(ctx, entry, "retry_gated", { baseSha, detail: "base unchanged since last conflict" });
         return;
     }
-    await performRebase(ctx, entry, baseSha);
+    await performBranchRefresh(ctx, entry, baseSha);
 }
 function describeMainBroken(failingChecks, pendingChecks) {
     const parts = [];
@@ -135,9 +135,9 @@ function summarizeCheckNames(checks, limit = 3) {
     }
     return `${names.slice(0, limit).join(", ")} +${names.length - limit} more`;
 }
-async function performRebase(ctx, entry, baseSha) {
+async function performBranchRefresh(ctx, entry, baseSha) {
     emit(ctx, entry, "rebase_started", { baseSha });
-    const result = await ctx.git.rebase(entry.branch, ref(ctx, ctx.baseBranch));
+    const result = await ctx.git.mergeBaseInto(entry.branch, ref(ctx, ctx.baseBranch));
     if (!result.success) {
         emit(ctx, entry, "rebase_conflict", { baseSha, conflictFiles: result.conflictFiles });
         if (isBudgetExhausted(entry)) {
@@ -153,28 +153,17 @@ async function performRebase(ctx, entry, baseSha) {
         }
         return;
     }
-    const headSha = result.newHeadSha ?? entry.headSha;
+    const headSha = result.sha ?? entry.headSha;
     await ctx.git.fetch();
     const latestRemoteHead = await ctx.git.headSha(ref(ctx, entry.branch));
-    const candidateKeepsLatestRemote = await ctx.git.isAncestor(latestRemoteHead, headSha);
-    if (!candidateKeepsLatestRemote) {
-        const detail = latestRemoteHead === entry.headSha
-            ? `candidate diverged from remote head: expected ${entry.headSha.slice(0, 8)}, ` +
-                `latest ${latestRemoteHead.slice(0, 8)}, candidate ${headSha.slice(0, 8)}`
-            : `remote advanced during rebase: expected ${entry.headSha.slice(0, 8)}, ` +
-                `latest ${latestRemoteHead.slice(0, 8)}, candidate ${headSha.slice(0, 8)}`;
+    if (latestRemoteHead !== entry.headSha) {
+        const detail = `remote advanced during refresh: expected ${entry.headSha.slice(0, 8)}, ` +
+            `latest ${latestRemoteHead.slice(0, 8)}, candidate ${headSha.slice(0, 8)}`;
         emit(ctx, entry, "branch_mismatch", { detail });
-        if (latestRemoteHead !== entry.headSha) {
-            ctx.store.updateHead(entry.id, latestRemoteHead);
-        }
-        else {
-            ctx.store.transition(entry.id, "queued", {
-                ...CLEAN_CI,
-            }, `stale local branch diverged from ${latestRemoteHead.slice(0, 8)}`);
-        }
+        ctx.store.updateHead(entry.id, latestRemoteHead);
         return;
     }
-    await ctx.git.push(entry.branch, true);
+    await ctx.git.push(entry.branch, false);
     emit(ctx, entry, "rebase_succeeded", { baseSha });
     // Build speculative branch for downstream entries.
     let specBranch = null;

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, progressBar, relativeTime, shortSha, statusColor, summarizeQueueBlock } from "./format.js";
+import { formatEntryEvent, humanStatus, nextStepLabel, progressBar, queueProgress, 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,5 +17,6 @@ export function DetailView({ detail, isHead, activeIndex, activeCount, headPrNum
         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 })] }), 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}`))))] })] }));
+    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) }), _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 })] }), _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) })] }), 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.js

@@ -1,23 +1,29 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { Box, Text, useStdout } from "ink";
-import { formatEventSummary, relativeTime, statusColor, summarizeQueueBlock, truncate } from "./format.js";
+import { formatEventSummary, humanStatus, nextStepLabel, progressBar, queueProgress, relativeTime, statusColor, summarizeQueueBlock, truncate } from "./format.js";
+const ENTRY_ROW_HEIGHT = 2;
 const CHROME_ROWS = 13;
-function QueueRow({ entry, selected, branchWidth, isHead, queueBlock, }) {
+function QueueRow({ entry, selected, infoWidth, isHead, queueBlock, }) {
     const retryText = `${entry.retryAttempts}/${entry.maxRetries}`;
-    const ciText = entry.ciRetries > 0 ? ` ci:${entry.ciRetries}` : "";
+    const ciText = entry.ciRetries > 0 ? `CI retries ${entry.ciRetries}` : null;
     const blockedOnMain = isHead && queueBlock?.reason === "main_broken" && queueBlock.headPrNumber === entry.prNumber;
-    const renderedStatus = blockedOnMain ? "blocked/main" : entry.status;
+    const renderedStatus = blockedOnMain ? "blocked by broken main" : humanStatus(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 })] }));
+    const progress = queueProgress(entry.status);
+    const branchLabel = truncate(entry.branch, Math.max(12, infoWidth - 34));
+    const nextStep = blockedOnMain
+        ? summarizeQueueBlock(queueBlock) ?? "waiting for main to recover"
+        : nextStepLabel(entry.status);
+    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: branchLabel }), _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] })] }));
 }
 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 infoWidth = Math.max(32, cols - 4);
+    const eventRows = Math.min(8, Math.max(4, rows - (entries.length * ENTRY_ROW_HEIGHT) - CHROME_ROWS));
     const displayedEvents = useMemo(() => recentEvents.slice(-eventRows), [eventRows, recentEvents]);
     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: " sel head pos pr    status          retry age 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}`))))] })] }));
+    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."] })] })), 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, infoWidth: infoWidth, 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

@@ -17,14 +17,19 @@ export function StatusBar({ snapshot, connected, filter, lastSnapshotReceivedAt,
     const avgWaitMs = activeEntries.length > 0
         ? activeEntries.reduce((sum, e) => sum + (Date.now() - new Date(e.enqueuedAt).getTime()), 0) / activeEntries.length
         : 0;
+    const queueHealth = queueBlockLabel
+        ? `paused on broken main`
+        : summary.headPrNumber !== null
+            ? `head #${summary.headPrNumber} active`
+            : "queue idle";
     const leftParts = [
         snapshot.repoFullName,
         `base:${snapshot.baseBranch}`,
         `${summary.total} entries ${summary.active} active`,
-        summary.headPrNumber !== null ? `head #${summary.headPrNumber}` : null,
-        queueBlockLabel ? `blocked ${queueBlockLabel}` : null,
+        queueHealth,
+        queueBlockLabel ?? null,
         avgWaitMs > 0 ? `wait ~${formatDuration(avgWaitMs)}` : null,
-        `tick ${runtimeLabel(runtime)} ${relativeTime(runtime.lastTickCompletedAt ?? runtime.lastTickStartedAt)}`,
+        `last tick ${runtimeLabel(runtime)} ${relativeTime(runtime.lastTickCompletedAt ?? runtime.lastTickStartedAt)}`,
         filter,
     ].filter(Boolean).join(" | ");
     const availableLeft = Math.max(1, width - 28);

package/dist/watch/format.d.ts

@@ -2,6 +2,12 @@ import type { CheckResult, QueueBlockState, QueueEntryStatus, QueueEventRecord,
 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";
+export declare function humanStatus(status: QueueEntryStatus): string;
+export declare function queueProgress(status: QueueEntryStatus): {
+    current: number;
+    total: number;
+};
+export declare function nextStepLabel(status: QueueEntryStatus): string;
 export declare function runtimeLabel(runtime: QueueRuntimeStatus): string;
 export declare function formatEventSummary(event: QueueEventSummary): string;
 export declare function formatEntryEvent(event: QueueEventRecord): string;

package/dist/watch/format.js

@@ -38,6 +38,57 @@ export function statusColor(status) {
             return "gray";
     }
 }
+export function humanStatus(status) {
+    switch (status) {
+        case "queued":
+            return "queued";
+        case "preparing_head":
+            return "refreshing branch";
+        case "validating":
+            return "running CI";
+        case "merging":
+            return "merging to main";
+        case "merged":
+            return "merged";
+        case "evicted":
+            return "removed from queue";
+        case "dequeued":
+            return "dequeued";
+    }
+}
+export function queueProgress(status) {
+    switch (status) {
+        case "queued":
+            return { current: 1, total: 4 };
+        case "preparing_head":
+            return { current: 2, total: 4 };
+        case "validating":
+            return { current: 3, total: 4 };
+        case "merging":
+        case "merged":
+        case "evicted":
+        case "dequeued":
+            return { current: 4, total: 4 };
+    }
+}
+export function nextStepLabel(status) {
+    switch (status) {
+        case "queued":
+            return "waiting for head-of-line turn";
+        case "preparing_head":
+            return "rebasing onto latest main";
+        case "validating":
+            return "waiting for CI result";
+        case "merging":
+            return "final GitHub merge";
+        case "merged":
+            return "landed on main";
+        case "evicted":
+            return "needs external repair";
+        case "dequeued":
+            return "removed manually";
+    }
+}
 export function runtimeLabel(runtime) {
     if (runtime.tickInProgress) {
         return "running";

package/package.json

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