merge-steward 0.21.0 → 0.22.0

package/dist/db/sqlite-store.d.ts

@@ -15,6 +15,7 @@ export declare class SqliteStore implements QueueStore {
     transition(entryId: string, to: QueueEntryStatus, patch?: Partial<Pick<QueueEntry, "headSha" | "baseSha" | "ciRunId" | "ciRetries" | "retryAttempts" | "lastFailedBaseSha" | "specBranch" | "specSha" | "specBasedOn" | "waitDetail" | "postMergeStatus" | "postMergeSha" | "postMergeSummary" | "postMergeCheckedAt">>, detail?: string): void;
     dequeue(entryId: string): void;
     updateHead(entryId: string, newHeadSha: string): void;
+    updatePriority(entryId: string, priority: number, detail?: string): void;
     insertIncident(incident: IncidentRecord): void;
     listIncidents(entryId: string): IncidentRecord[];
     getIncident(incidentId: string): IncidentRecord | undefined;

package/dist/db/sqlite-store.js

@@ -227,6 +227,21 @@ export class SqliteStore {
             this.writeEvent(entryId, from, "queued", `updateHead: generation ${newGen}`);
         })();
     }
+    updatePriority(entryId, priority, detail) {
+        this.conn.transaction(() => {
+            const current = this.conn.prepare("SELECT status, priority FROM queue_entries WHERE id = ?").get(entryId);
+            if (!current)
+                return;
+            const from = String(current.status);
+            if (Number(current.priority) === priority)
+                return;
+            this.conn.prepare(`UPDATE queue_entries SET
+          priority = ?,
+          updated_at = ?
+         WHERE id = ?`).run(priority, isoNow(), entryId);
+            this.writeEvent(entryId, from, from, detail ?? `priority updated to ${priority}`);
+        })();
+    }
     insertIncident(incident) {
         this.conn.prepare(`INSERT INTO queue_incidents (id, entry_id, at, failure_class, context_json, outcome)
        VALUES (?, ?, ?, ?, ?, ?)`).run(incident.id, incident.entryId, incident.at, incident.failureClass, JSON.stringify(incident.context), incident.outcome);

package/dist/reconciler-main-status.d.ts

@@ -0,0 +1,8 @@
+import type { CIStatus } from "./types.ts";
+import type { ReconcileContext } from "./reconciler-core.ts";
+export interface EffectiveMainStatus {
+    status: CIStatus;
+    trustedMergedEntryId?: string | undefined;
+    trustedMergedPrNumber?: number | undefined;
+}
+export declare function getEffectiveMainStatus(ctx: ReconcileContext, baseSha: string): Promise<EffectiveMainStatus>;

package/dist/reconciler-main-status.js

@@ -0,0 +1,17 @@
+export async function getEffectiveMainStatus(ctx, baseSha) {
+    const status = await ctx.ci.getMainStatus?.(ctx.baseBranch) ?? "pass";
+    if (status !== "pending") {
+        return { status };
+    }
+    const trustedMergedEntry = ctx.store.listAll(ctx.repoId).find((entry) => entry.status === "merged"
+        && entry.postMergeStatus === "pass"
+        && entry.postMergeSha === baseSha);
+    if (!trustedMergedEntry) {
+        return { status };
+    }
+    return {
+        status: "pass",
+        trustedMergedEntryId: trustedMergedEntry.id,
+        trustedMergedPrNumber: trustedMergedEntry.prNumber,
+    };
+}

package/dist/reconciler-merge.js

@@ -1,6 +1,7 @@
 import { CLEAN_CI, CLEAN_SPEC, emit, isBudgetExhausted, ref } from "./reconciler-core.js";
 import { cleanupSpec, evictEntry, invalidateDownstream } from "./reconciler-evict.js";
 import { verifyPostMergeStatus } from "./reconciler-post-merge.js";
+import { getEffectiveMainStatus } from "./reconciler-main-status.js";
 export async function mergeHead(ctx, entry) {
     emit(ctx, entry, "merge_revalidating");
     const prStatus = await ctx.github.getStatus(entry.prNumber);
@@ -31,9 +32,10 @@ export async function mergeHead(ctx, entry) {
         ctx.store.transition(entry.id, "preparing_head", { ...CLEAN_CI, ...CLEAN_SPEC }, "no spec branch, re-prepare");
         return;
     }
+    let currentBase = null;
     try {
         await ctx.git.fetch();
-        const currentBase = await ctx.git.headSha(ref(ctx, ctx.baseBranch));
+        currentBase = await ctx.git.headSha(ref(ctx, ctx.baseBranch));
         const isFF = await ctx.git.isAncestor(currentBase, entry.specSha);
         if (!isFF) {
             emit(ctx, entry, "branch_mismatch", { detail: `spec is not a fast-forward from main (${currentBase.slice(0, 8)})` });
@@ -47,8 +49,15 @@ export async function mergeHead(ctx, entry) {
         // Can't verify — proceed and let push fail if needed.
     }
     if (ctx.ci.getMainStatus && entry.priority <= 0) {
-        const mainStatus = await ctx.ci.getMainStatus(ctx.baseBranch);
-        if (mainStatus === "pending") {
+        const mainStatus = currentBase
+            ? await getEffectiveMainStatus(ctx, currentBase)
+            : { status: await ctx.ci.getMainStatus(ctx.baseBranch) };
+        if (mainStatus.trustedMergedEntryId) {
+            emit(ctx, entry, "main_pending_bypassed", {
+                detail: `main checks pending for already-validated merge of PR #${mainStatus.trustedMergedPrNumber}`,
+            });
+        }
+        if (mainStatus.status === "pending") {
             // Main is still verifying itself (typically post-merge CI from the
             // previous entry).  The spec was built on top of main-as-it-was
             // (isFF check above guarantees main hasn't diverged) and already
@@ -59,7 +68,7 @@ export async function mergeHead(ctx, entry) {
             ctx.store.transition(entry.id, "merging", { waitDetail: "main checks still pending, holding merge" }, "main checks still pending, holding merge");
             return;
         }
-        if (mainStatus === "fail") {
+        if (mainStatus.status === "fail") {
             try {
                 const refresh = await ctx.policy.refreshOnIssue("main_unhealthy_at_merge");
                 if (refresh.attempted && refresh.changed) {

package/dist/reconciler-prepare.js

@@ -1,5 +1,6 @@
 import { CLEAN_CI, CLEAN_SPEC, emit, isBudgetExhausted, isRetryGated, ref, specBranchName } from "./reconciler-core.js";
 import { evictEntry } from "./reconciler-evict.js";
+import { getEffectiveMainStatus } from "./reconciler-main-status.js";
 function summarizeCheckNames(checks, limit = 3) {
     const names = [...new Set(checks.map((check) => check.name))];
     if (names.length <= limit) {
@@ -46,8 +47,14 @@ export async function prepareEntry(ctx, entry, isHead, prevEntry) {
     if (isHead) {
         const bypassMainBlock = entry.priority > 0;
         if (ctx.ci.getMainStatus && !bypassMainBlock) {
-            const mainStatus = await ctx.ci.getMainStatus(ctx.baseBranch);
-            if (mainStatus !== "pass") {
+            const mainStatus = await getEffectiveMainStatus(ctx, baseSha);
+            if (mainStatus.trustedMergedEntryId) {
+                emit(ctx, entry, "main_pending_bypassed", {
+                    baseSha,
+                    detail: `main checks pending for already-validated merge of PR #${mainStatus.trustedMergedPrNumber}`,
+                });
+            }
+            if (mainStatus.status !== "pass") {
                 let mainChecks = [];
                 try {
                     mainChecks = await ctx.github.listChecksForRef(ref(ctx, ctx.baseBranch));

package/dist/service-queue.d.ts

@@ -25,10 +25,13 @@ export declare class MergeStewardQueueCommands {
         scanned: number;
         admitted: number;
     }>;
+    updatePriorityByPR(prNumber: number, priority: number): boolean;
     tryAdmit(prNumber: number, branch: string, headSha: string): Promise<boolean>;
     dequeueByPR(prNumber: number): void;
     updateHeadByPR(prNumber: number, headSha: string): void;
     acknowledgeExternalMerge(prNumber: number): void;
     private invalidateDownstreamOf;
+    private findAffectedEntriesAfterPriorityChange;
+    private requeueAffectedEntries;
     private nextPosition;
 }

package/dist/service-queue.js

@@ -105,6 +105,22 @@ export class MergeStewardQueueCommands {
         }
         return { scanned: open.length, admitted };
     }
+    updatePriorityByPR(prNumber, priority) {
+        const entry = this.store.getEntryByPR(this.config.repoId, prNumber);
+        if (!entry) {
+            return false;
+        }
+        if (entry.priority === priority) {
+            return true;
+        }
+        const before = this.store.listActive(this.config.repoId);
+        this.store.updatePriority(entry.id, priority, `priority lane ${priority > 0 ? "enabled" : "disabled"}`);
+        const after = this.store.listActive(this.config.repoId);
+        const affected = this.findAffectedEntriesAfterPriorityChange(before, after);
+        this.requeueAffectedEntries(affected, `priority changed for entry ${entry.id.slice(0, 8)}`);
+        this.logger.info({ prNumber, entryId: entry.id, priority }, "Updated queued PR priority");
+        return true;
+    }
     async tryAdmit(prNumber, branch, headSha) {
         if (this.config.excludeBranches.some((pattern) => matchGlob(pattern, branch))) {
             this.logger.debug({ prNumber, branch }, "Branch excluded from admission");
@@ -226,6 +242,31 @@ export class MergeStewardQueueCommands {
             this.logger.info({ removedEntryId: removedEntry.id, invalidated: targets.length }, "Invalidated downstream entries after dequeue");
         }
     }
+    findAffectedEntriesAfterPriorityChange(before, after) {
+        const maxLength = Math.max(before.length, after.length);
+        let firstChangedIndex = -1;
+        for (let index = 0; index < maxLength; index += 1) {
+            if (before[index]?.id !== after[index]?.id) {
+                firstChangedIndex = index;
+                break;
+            }
+        }
+        if (firstChangedIndex < 0) {
+            return [];
+        }
+        return after.slice(firstChangedIndex);
+    }
+    requeueAffectedEntries(entries, reason) {
+        for (const affected of entries) {
+            if (affected.specBranch) {
+                this.specBuilder.deleteSpeculative(affected.specBranch).catch(() => { });
+            }
+            this.store.transition(affected.id, "queued", INVALIDATION_PATCH, reason);
+        }
+        if (entries.length > 0) {
+            this.logger.info({ affectedEntries: entries.length, reason }, "Requeued affected entries after priority change");
+        }
+    }
     nextPosition() {
         const existing = this.store.listAll(this.config.repoId);
         let next = 1;

package/dist/service.d.ts

@@ -39,6 +39,7 @@ export declare class MergeStewardService {
     updateEntryHead(entryId: string, headSha: string): boolean;
     dequeueByPR(prNumber: number): void;
     updateHeadByPR(prNumber: number, headSha: string): void;
+    updatePriorityByPR(prNumber: number, priority: number): boolean;
     acknowledgeExternalMerge(prNumber: number): void;
     getStatus(): QueueEntry[];
     getIncident(incidentId: string): IncidentRecord | undefined;

package/dist/service.js

@@ -73,6 +73,9 @@ export class MergeStewardService {
     updateHeadByPR(prNumber, headSha) {
         this.queueCommands.updateHeadByPR(prNumber, headSha);
     }
+    updatePriorityByPR(prNumber, priority) {
+        return this.queueCommands.updatePriorityByPR(prNumber, priority);
+    }
     acknowledgeExternalMerge(prNumber) {
         this.queueCommands.acknowledgeExternalMerge(prNumber);
     }

package/dist/store.d.ts

@@ -14,6 +14,7 @@ export interface QueueStore {
     transition(entryId: string, to: QueueEntryStatus, patch?: Partial<Pick<QueueEntry, "headSha" | "baseSha" | "ciRunId" | "ciRetries" | "retryAttempts" | "lastFailedBaseSha" | "specBranch" | "specSha" | "specBasedOn" | "waitDetail" | "postMergeStatus" | "postMergeSha" | "postMergeSummary" | "postMergeCheckedAt">>, detail?: string): void;
     dequeue(entryId: string): void;
     updateHead(entryId: string, newHeadSha: string): void;
+    updatePriority(entryId: string, priority: number, detail?: string): void;
     insertIncident(incident: IncidentRecord): void;
     listIncidents(entryId: string): IncidentRecord[];
     getIncident(incidentId: string): IncidentRecord | undefined;

package/dist/types.d.ts

@@ -196,7 +196,7 @@ export interface QueueConfig {
     flakyRetries: number;
     pollIntervalMs: number;
 }
-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" | "policy_changed" | "evicted" | "invalidated" | "retry_gated" | "budget_exhausted" | "merge_waiting_approval" | "merge_waiting_main" | "sanitized_closed" | "sanitized_duplicate" | "post_merge_verification_started" | "post_merge_verification_completed" | "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" | "policy_changed" | "evicted" | "invalidated" | "retry_gated" | "budget_exhausted" | "merge_waiting_approval" | "merge_waiting_main" | "main_pending_bypassed" | "sanitized_closed" | "sanitized_duplicate" | "post_merge_verification_started" | "post_merge_verification_completed" | "branch_unreachable";
 export interface ReconcileEvent {
     at: string;
     entryId: string;

package/dist/watch/QueueListView.js

@@ -3,7 +3,7 @@ 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, relativeTime, statusColor, summarizeQueueBlock, truncate } from "./format.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);
@@ -15,7 +15,7 @@ function QueueRow({ entry, selected, isHead, queueBlock, }) {
             : "";
         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 && queueBlock?.reason === "main_broken" && queueBlock.headPrNumber === entry.prNumber;
+    const blockedOnMain = isHead && queueBlockMatchesEntry(queueBlock, entry);
     const pendingMainVerification = blockedOnMain && isPendingMainVerification(queueBlock);
     const status = blockedOnMain
         ? pendingMainVerification ? "verifying main" : "waiting for main"
@@ -36,13 +36,14 @@ export function QueueListView({ entries, allEntries, selectedEntryId, recentEven
     // 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);
+    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));
-                    })] })), queueBlock && (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["Queue paused: ", queueBlockLabel ?? "waiting for main checks", queueBlock.baseSha ? ` at ${truncate(queueBlock.baseSha, 10)}` : "", "."] }), _jsx(Text, { dimColor: true, children: queueBlock.missingRequiredChecks.length > 0
-                            ? `Head PR #${queueBlock.headPrNumber ?? "?"} is waiting for an operator fix on ${queueBlock.baseBranch}.`
-                            : `Head PR #${queueBlock.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: 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}`))))] })] }));
+                    })] })), 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/dashboard-model.js

@@ -1,5 +1,5 @@
 import { TERMINAL_STATUSES } from "../types.js";
-import { mergeWaitState } from "./format.js";
+import { mergeWaitState, queueBlockMatchesEntry } from "./format.js";
 const DECIDED_WINDOW_MS = 24 * 60 * 60 * 1000;
 const GLYPH = {
     running: "\u25cf",
@@ -126,7 +126,7 @@ function repoEntriesFromSnapshot(snapshot, cutoff) {
     const head = latest
         .filter((entry) => isActive(entry.status))
         .sort((a, b) => a.position - b.position)[0] ?? null;
-    const queueBlocked = Boolean(snapshot.queueBlock);
+    const queueBlocked = queueBlockMatchesEntry(snapshot.queueBlock, head);
     const byPr = new Map();
     for (const entry of latest) {
         const active = isActive(entry.status);

package/dist/watch/format.d.ts

@@ -1,5 +1,9 @@
 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;
 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;

package/dist/watch/format.js

@@ -11,6 +11,15 @@ export function isPendingMainVerification(block) {
         && 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 "-";

package/dist/watch/state-visualization.js

@@ -1,3 +1,4 @@
+import { queueBlockMatchesEntry } from "./format.js";
 const MAIN_STATES = ["queued", "preparing_head", "validating", "merging", "merged"];
 const EXIT_STATES = ["evicted", "dequeued"];
 const STATE_LABELS = {
@@ -53,7 +54,7 @@ export function buildExternalRepairObservations(detail, options) {
     else if (entry.status === "evicted") {
         observations.push({ tone: "warn", text: "Removed after failed retries. Branch needs repair before re-admission." });
     }
-    else if (options.isHead && options.queueBlock?.reason === "main_broken") {
+    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;

package/dist/webhook-handler.js

@@ -110,10 +110,17 @@ export async function processWebhookEvent(event, service, config, logger) {
             if (event.label !== config.admissionLabel && event.label !== config.priorityQueueLabel)
                 return;
             logger.info({ prNumber: event.prNumber, label: event.label }, "Queue label added, checking eligibility");
+            if (event.label === config.priorityQueueLabel && service.updatePriorityByPR(event.prNumber, 1)) {
+                break;
+            }
             await service.tryAdmit(event.prNumber, event.branch, event.headSha);
             break;
         }
         case "pr_unlabeled": {
+            if (event.label === config.priorityQueueLabel) {
+                service.updatePriorityByPR(event.prNumber, 0);
+                break;
+            }
             if (event.label !== config.admissionLabel)
                 return;
             // Label removed — dequeue if active.

package/package.json

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