merge-steward 0.28.0 → 0.30.0

package/README.md

@@ -14,7 +14,7 @@ PRs delivered through the queue are tested against `main` as it was at admission
 2. The steward notices through webhook wakeups or startup reconcile scans, and admits the PR to the queue.
 3. It builds a speculative branch — `main + PR` at the head, cumulative downstream (`main + A + B`, `main + A + B + C`).
 4. CI runs on that speculative SHA.
-5. If the head's speculative SHA is still a fast-forward from current `main`, the steward pushes that SHA to `main`; otherwise it retries.
+5. Once the speculative SHA's checks are green and it is still a fast-forward from current `main`, the steward pushes that SHA to `main` immediately. It does **not** wait for `main`'s own CI to settle, and **never** pauses the queue because `main` is red — the green speculative SHA *is* the next `main`.
 6. On CI failure: retry (gated on base SHA change), then evict with a durable incident record and GitHub check run.
 7. PatchRelay, the `ship-pr` skill, or any agent sees the check run failure and fixes the branch; when CI passes again the PR can be re-admitted.
 
@@ -79,6 +79,8 @@ The real gate is:
 
 `review-quill/verdict` only matters if you include it in the repo's required checks. Branch protection is useful as defense in depth, but the steward merges by fast-forwarding `main` to the already-tested speculative SHA — not by pressing GitHub's merge button. Successful merges therefore depend on the steward App being allowed to push to the protected branch. See [docs/merge-steward.md](../../docs/merge-steward.md) for the full App permission set.
 
+**`main`'s own CI is information-only.** The speculative SHA the steward tests *is* the exact tree that becomes `main`, so re-testing `main` after the push adds no signal — it only catches flakiness or out-of-band changes (direct pushes, hotfixes). The queue therefore **ignores `main`'s CI entirely** for advancement: it does not gate landing on `main` being green, does not wait for `main` CI before the next landing, and is never "paused" by a red `main`. A red `main` with a green speculative SHA simply means the red was flaky or is fixed by landing — so the steward lands. Use `main`'s CI as a project-health canary, not a queue control.
+
 ## Interaction with PatchRelay
 
 Independent services, GitHub as the shared bus:

package/dist/config.d.ts

@@ -30,6 +30,8 @@ export declare const stewardConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     admissionLabel: z.ZodDefault<z.ZodString>;
     priorityQueueLabel: z.ZodDefault<z.ZodString>;
+    queueTestingLabel: z.ZodDefault<z.ZodString>;
+    queueMergingLabel: z.ZodDefault<z.ZodString>;
     mergeQueueCheckName: z.ZodDefault<z.ZodString>;
     evictionCheckName: z.ZodDefault<z.ZodString>;
     specReadyCheckName: z.ZodDefault<z.ZodString>;

package/dist/config.js

@@ -31,6 +31,12 @@ export const stewardConfigSchema = z.object({
     }).default({ level: "info" }),
     admissionLabel: z.string().default("queue"),
     priorityQueueLabel: z.string().default("queue:priority"),
+    // Queue sub-state labels — applied/cleared by the reconciler so a PR's
+    // live position in the merge queue is visible on GitHub and readable by
+    // patchrelay for its Linear "In Merge Queue" status. `queue:testing` =
+    // spec CI validating; `queue:merging` = head, merge in progress.
+    queueTestingLabel: z.string().default("queue:testing"),
+    queueMergingLabel: z.string().default("queue:merging"),
     mergeQueueCheckName: z.string().default(DEFAULT_MERGE_QUEUE_CHECK_NAME),
     // Plan §2.4 — bus-contract artifact names exposed for cross-service
     // alignment. Defaults preserve current behavior. The steward writes

package/dist/github/pr-client.d.ts

@@ -29,4 +29,8 @@ export declare class GitHubPRClient implements GitHubPRApi {
     deleteBranch(prNumber: number): Promise<void>;
     findPRByBranch(branch: string): Promise<number | null>;
     listLabels(prNumber: number): Promise<string[]>;
+    setLabels(prNumber: number, opts: {
+        add?: string[];
+        remove?: string[];
+    }): Promise<void>;
 }

package/dist/github/pr-client.js

@@ -146,6 +146,17 @@ export class GitHubPRClient {
             return [];
         }
     }
+    async setLabels(prNumber, opts) {
+        const args = ["pr", "edit", String(prNumber), "--repo", this.repoFullName];
+        for (const label of opts.add ?? [])
+            args.push("--add-label", label);
+        for (const label of opts.remove ?? [])
+            args.push("--remove-label", label);
+        // Nothing to change beyond the base args — skip the call.
+        if (args.length === 5)
+            return;
+        await exec("gh", args, { allowNonZero: true, githubRepoFullName: this.repoFullName });
+    }
 }
 /** Map GitHub REST API check-run status/conclusion to our union. */
 function mapRestConclusion(status, conclusion) {

package/dist/interfaces.d.ts

@@ -50,6 +50,11 @@ export interface GitHubPRApi {
     listChecks(prNumber: number): Promise<CheckResult[]>;
     listChecksForRef(ref: string): Promise<CheckResult[]>;
     listLabels(prNumber: number): Promise<string[]>;
+    /** Add and/or remove labels on a PR in a single edit. */
+    setLabels(prNumber: number, opts: {
+        add?: string[];
+        remove?: string[];
+    }): Promise<void>;
     /** List open PRs for restart-time eligibility scans. */
     listOpenPRs(): Promise<Array<{
         number: number;

package/dist/reconciler-core.d.ts

@@ -15,6 +15,13 @@ export interface ReconcileContext {
     speculativeDepth: number;
     flakyRetries: number;
     policy: GitHubPolicyCache;
+    /** Queue sub-state label names. When set, the reconciler keeps the
+     * `testing`/`merging` labels on each PR in sync with its phase so the
+     * queue position is visible on GitHub. Omit to disable label sync. */
+    queueStateLabels?: {
+        testing: string;
+        merging: string;
+    };
     onEvent: (event: ReconcileEvent) => void;
 }
 export declare const SPEC_BRANCH_PREFIX = "mq-spec-";

package/dist/reconciler-merge.js

@@ -1,7 +1,6 @@
 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";
 const DEFAULT_PR_MERGED_POLL_ATTEMPTS = 6;
 const DEFAULT_PR_MERGED_POLL_DELAY_MS = 2_000;
 function delay(ms) {
@@ -183,43 +182,12 @@ export async function mergeHead(ctx, entry) {
     catch {
         // Can't verify — proceed and let push fail if needed.
     }
-    if (ctx.ci.getMainStatus && entry.priority <= 0) {
-        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
-            // passed CI, so keep the spec + CI state and retry next tick.
-            // Throwing the spec away here would force a rebuild + re-run of
-            // CI that produces the same tree — wasting the speculation.
-            emit(ctx, entry, "merge_waiting_main", { detail: "main checks still pending, holding merge" });
-            ctx.store.transition(entry.id, "merging", { waitDetail: "main checks still pending, holding merge" }, "main checks still pending, holding merge");
-            return;
-        }
-        if (mainStatus.status === "fail") {
-            try {
-                const refresh = await ctx.policy.refreshOnIssue("main_unhealthy_at_merge");
-                if (refresh.attempted && refresh.changed) {
-                    emit(ctx, entry, "policy_changed", {
-                        detail: `GitHub required checks changed from [${refresh.previousRequiredChecks.join(", ") || "(none)"}] to [${refresh.requiredChecks.join(", ") || "(none)"}]`,
-                    });
-                }
-            }
-            catch {
-                // Keep using cached GitHub policy and pause the queue conservatively.
-            }
-            emit(ctx, entry, "main_broken", { detail: "main unhealthy at merge time, re-preparing" });
-            ctx.store.transition(entry.id, "preparing_head", { ...CLEAN_CI, ...CLEAN_SPEC }, "main unhealthy at merge time");
-            return;
-        }
-    }
+    // The queue gates only on its own spec CI. main's CI status is irrelevant to
+    // landing: the spec was built on current main (the fast-forward check above
+    // guarantees main hasn't diverged) and its checks passed, so pushing it advances
+    // main to a green SHA. We never wait for main's own CI to settle, and never pause
+    // the queue because main is red — a red main is either flaky or fixed by landing
+    // this green spec. main CI is information-only (out-of-band breakage canary).
     try {
         await ctx.git.push(entry.specBranch, false, ctx.baseBranch);
     }

package/dist/reconciler-prepare.js

@@ -1,36 +1,5 @@
 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) {
-        return names.join(", ");
-    }
-    return `${names.slice(0, limit).join(", ")} +${names.length - limit} more`;
-}
-function normalizeCheckName(name) {
-    return name.trim().toLowerCase();
-}
-function getMissingRequiredChecks(requiredChecks, checks) {
-    if (requiredChecks.length === 0) {
-        return [];
-    }
-    const available = new Set(checks.map((check) => normalizeCheckName(check.name)).filter(Boolean));
-    return requiredChecks.filter((check) => !available.has(normalizeCheckName(check)));
-}
-function describeMainBroken(failingChecks, pendingChecks, missingRequiredChecks) {
-    const parts = [];
-    if (missingRequiredChecks.length > 0) {
-        parts.push(`missing required ${missingRequiredChecks.join(", ")}`);
-    }
-    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";
-}
 export async function prepareEntry(ctx, entry, isHead, prevEntry) {
     emit(ctx, entry, "fetch_started");
     await ctx.git.fetch();
@@ -57,53 +26,8 @@ export async function prepareEntry(ctx, entry, isHead, prevEntry) {
         return;
     }
     if (isHead) {
-        const bypassMainBlock = entry.priority > 0;
-        if (ctx.ci.getMainStatus && !bypassMainBlock) {
-            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));
-                }
-                catch {
-                    mainChecks = [];
-                }
-                const failingChecks = mainChecks.filter((check) => check.conclusion === "failure");
-                const pendingChecks = mainChecks.filter((check) => check.conclusion === "pending");
-                let missingRequiredChecks = getMissingRequiredChecks(ctx.policy.getRequiredChecks(), mainChecks);
-                if (missingRequiredChecks.length > 0) {
-                    try {
-                        const refresh = await ctx.policy.refreshOnIssue("main_missing_required_checks");
-                        if (refresh.attempted && refresh.changed) {
-                            missingRequiredChecks = getMissingRequiredChecks(ctx.policy.getRequiredChecks(), mainChecks);
-                            emit(ctx, entry, "policy_changed", {
-                                detail: `GitHub required checks changed from [${refresh.previousRequiredChecks.join(", ") || "(none)"}] to [${refresh.requiredChecks.join(", ") || "(none)"}]`,
-                            });
-                            if (missingRequiredChecks.length === 0 && failingChecks.length === 0 && pendingChecks.length === 0) {
-                                return;
-                            }
-                        }
-                    }
-                    catch {
-                        // Keep using the last known GitHub policy and surface the current block.
-                    }
-                }
-                emit(ctx, entry, "main_broken", {
-                    baseSha,
-                    failingChecks,
-                    pendingChecks,
-                    missingRequiredChecks,
-                    detail: describeMainBroken(failingChecks, pendingChecks, missingRequiredChecks),
-                });
-                return;
-            }
-        }
+        // Preparing/validating the head never waits on main's CI: the spec is built on
+        // current main and gated solely on its own checks. main's health is information-only.
         if (isBudgetExhausted(entry) && entry.lastFailedBaseSha !== null) {
             emit(ctx, entry, "budget_exhausted", { baseSha });
             await evictEntry(ctx, entry, "integration_conflict");

package/dist/reconciler-queue-labels.d.ts

@@ -0,0 +1,18 @@
+import type { ReconcileContext } from "./reconciler-core.ts";
+import type { QueueEntry } from "./types.ts";
+/**
+ * Edge-triggered GitHub label sync for queue sub-state.
+ *
+ * The label is a pure function of the entry's phase, so a PR's live
+ * position in the merge queue is obvious from GitHub — and readable by
+ * patchrelay to drive its Linear "In Merge Queue" status:
+ *
+ *   validating → testing label  (spec CI is running / awaiting turn)
+ *   merging    → merging label  (head of queue, merge in progress)
+ *   everything else (queued, preparing_head, merged, evicted, …) → neither
+ *
+ * Idempotent: reads the PR's current labels and only edits the delta, so
+ * it is safe to call every tick and after a restart. Cosmetic-only — any
+ * GitHub error is swallowed so it can never break the reconcile loop.
+ */
+export declare function syncQueueStateLabels(ctx: ReconcileContext, entry: QueueEntry): Promise<void>;

package/dist/reconciler-queue-labels.js

@@ -0,0 +1,48 @@
+import { emit } from "./reconciler-core.js";
+/**
+ * Edge-triggered GitHub label sync for queue sub-state.
+ *
+ * The label is a pure function of the entry's phase, so a PR's live
+ * position in the merge queue is obvious from GitHub — and readable by
+ * patchrelay to drive its Linear "In Merge Queue" status:
+ *
+ *   validating → testing label  (spec CI is running / awaiting turn)
+ *   merging    → merging label  (head of queue, merge in progress)
+ *   everything else (queued, preparing_head, merged, evicted, …) → neither
+ *
+ * Idempotent: reads the PR's current labels and only edits the delta, so
+ * it is safe to call every tick and after a restart. Cosmetic-only — any
+ * GitHub error is swallowed so it can never break the reconcile loop.
+ */
+export async function syncQueueStateLabels(ctx, entry) {
+    const labels = ctx.queueStateLabels;
+    if (!labels)
+        return;
+    const managed = [labels.testing, labels.merging];
+    const desired = entry.status === "validating" ? labels.testing
+        : entry.status === "merging" ? labels.merging
+            : null;
+    let current;
+    try {
+        current = await ctx.github.listLabels(entry.prNumber);
+    }
+    catch {
+        return;
+    }
+    const add = desired && !current.includes(desired) ? [desired] : [];
+    const remove = managed.filter((l) => l !== desired && current.includes(l));
+    if (add.length === 0 && remove.length === 0)
+        return;
+    try {
+        await ctx.github.setLabels(entry.prNumber, { add, remove });
+        const parts = [];
+        if (add.length)
+            parts.push(`+${add.join(",")}`);
+        if (remove.length)
+            parts.push(`-${remove.join(",")}`);
+        emit(ctx, entry, "queue_label_synced", { detail: `${entry.status}: ${parts.join(" ")}` });
+    }
+    catch {
+        // best-effort; the next tick retries
+    }
+}

package/dist/reconciler.js

@@ -7,6 +7,7 @@ import { mergeHead } from "./reconciler-merge.js";
 import { cleanupSpec } from "./reconciler-evict.js";
 import { INVALIDATION_PATCH } from "./invalidation.js";
 import { verifyPostMergeStatus } from "./reconciler-post-merge.js";
+import { syncQueueStateLabels } from "./reconciler-queue-labels.js";
 // ─── Main reconcile loop ────────────────────────────────────────
 export async function reconcile(ctx) {
     const allActive = ctx.store.listActive(ctx.repoId);
@@ -21,8 +22,14 @@ export async function reconcile(ctx) {
         if (!entry || TERMINAL_STATUSES.includes(entry.status))
             continue;
         // Truth guard: verify entry against GitHub before processing.
-        if (await sanitizeEntry(ctx, entry))
+        if (await sanitizeEntry(ctx, entry)) {
+            // Entry may have been terminalized (closed/duplicate) — clear any
+            // stale queue sub-state label it still carries.
+            const sanitized = ctx.store.getEntry(entry.id);
+            if (sanitized)
+                await syncQueueStateLabels(ctx, sanitized);
             continue;
+        }
         // Stale dependency guard: if this entry's spec was built on top of
         // another entry that was dequeued or evicted (without downstream
         // invalidation), the spec is contaminated with the removed entry's
@@ -74,6 +81,12 @@ export async function reconcile(ctx) {
                 wrapped.stack = error.stack;
             throw wrapped;
         }
+        // Sync the GitHub queue sub-state label to the (possibly just
+        // transitioned) phase: queue:testing while validating, queue:merging
+        // while merging, cleared once merged/preparing/terminal.
+        const post = ctx.store.getEntry(entry.id);
+        if (post)
+            await syncQueueStateLabels(ctx, post);
     }
     await verifyMergedEntriesPostPush(ctx);
 }

package/dist/service-runtime.d.ts

@@ -24,8 +24,6 @@ export declare class MergeStewardRuntime {
     private lastTickError;
     private lastReconcileEvent;
     private currentQueueBlock;
-    private readonly waitingMainInfoAt;
-    private static readonly WAITING_MAIN_INFO_INTERVAL_MS;
     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>;
@@ -38,6 +36,4 @@ export declare class MergeStewardRuntime {
     private scheduleStaleTickWarning;
     private clearStaleTickTimer;
     private runTick;
-    private describeMainBroken;
-    private getMissingRequiredChecks;
 }

package/dist/service-runtime.js

@@ -18,13 +18,8 @@ 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;
-    // Per-entry timestamp of the last info-level `merge_waiting_main` log.
-    // The event fires every tick while the gate waits, so subsequent ticks
-    // log at debug to avoid spamming; a re-emission of info every ~5 min keeps
-    // long waits visible in `service logs` without drowning it out.
-    waitingMainInfoAt = new Map();
-    static WAITING_MAIN_INFO_INTERVAL_MS = 5 * 60 * 1000;
     constructor(config, policy, store, git, ci, github, eviction, specBuilder, logger, beforeTick) {
         this.config = config;
         this.policy = policy;
@@ -130,7 +125,6 @@ export class MergeStewardRuntime {
         this.scheduleStaleTickWarning(this.lastTickStartedAt);
         try {
             await this.beforeTick?.();
-            let tickQueueBlockEvent = null;
             await reconcile({
                 store: this.store,
                 repoId: this.config.repoId,
@@ -144,6 +138,10 @@ export class MergeStewardRuntime {
                 eviction: this.eviction,
                 flakyRetries: this.config.flakyRetries,
                 policy: this.policy,
+                queueStateLabels: {
+                    testing: this.config.queueTestingLabel,
+                    merging: this.config.queueMergingLabel,
+                },
                 onEvent: (event) => {
                     this.lastReconcileEvent = summarizeReconcileEvent(event);
                     const isWarn = event.action === "evicted" || event.action === "spec_build_conflict"
@@ -151,29 +149,12 @@ export class MergeStewardRuntime {
                         || event.action === "merge_rejected" || event.action === "budget_exhausted";
                     const isDebug = event.action === "ci_pending" || event.action === "retry_gated"
                         || event.action === "fetch_started";
-                    let level = isWarn ? "warn" : isDebug ? "debug" : "info";
-                    if (event.action === "merge_waiting_main") {
-                        // The event fires every ~tick while the gate waits on main's own
-                        // CI.  Log at info the first time (so an operator can see *why*
-                        // the head entry is parked in merging) and once every interval
-                        // after, debug on the intermediate ticks to avoid spamming.
-                        const last = this.waitingMainInfoAt.get(event.entryId);
-                        const now = Date.now();
-                        if (last === undefined || now - last >= MergeStewardRuntime.WAITING_MAIN_INFO_INTERVAL_MS) {
-                            level = "info";
-                            this.waitingMainInfoAt.set(event.entryId, now);
-                        }
-                        else {
-                            level = "debug";
-                        }
-                    }
+                    const level = isWarn ? "warn" : isDebug ? "debug" : "info";
                     this.logger[level]({ ...event }, `Queue: ${event.action} PR #${event.prNumber}`);
-                    if (event.action === "main_broken" && tickQueueBlockEvent === null) {
-                        tickQueueBlockEvent = event;
-                    }
                 },
             });
-            this.currentQueueBlock = tickQueueBlockEvent ? await this.describeMainBroken(tickQueueBlockEvent) : null;
+            // The queue never blocks on main CI — main health is information-only.
+            this.currentQueueBlock = null;
             this.lastTickOutcome = "succeeded";
         }
         catch (error) {
@@ -192,48 +173,6 @@ export class MergeStewardRuntime {
         }
         return true;
     }
-    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"),
-            missingRequiredChecks: event.missingRequiredChecks ?? this.getMissingRequiredChecks(checks),
-        };
-    }
-    getMissingRequiredChecks(checks) {
-        const requiredChecks = this.policy.getRequiredChecks();
-        if (requiredChecks.length === 0) {
-            return [];
-        }
-        const available = new Set(checks.map((check) => check.name.trim().toLowerCase()).filter(Boolean));
-        return requiredChecks.filter((check) => !available.has(check.trim().toLowerCase()));
-    }
 }
 function summarizeReconcileEvent(event) {
     return {

package/dist/types.d.ts

@@ -242,7 +242,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" | "main_pending_bypassed" | "pr_branch_cleanup_deferred" | "pr_branch_cleanup_failed" | "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" | "pr_branch_cleanup_deferred" | "pr_branch_cleanup_failed" | "sanitized_closed" | "sanitized_duplicate" | "post_merge_verification_started" | "post_merge_verification_completed" | "queue_label_synced" | "branch_unreachable";
 export interface ReconcileEvent {
     at: string;
     entryId: string;

package/dist/watch/state-visualization.js

@@ -112,9 +112,6 @@ export function buildExternalRepairObservations(detail, options) {
         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 if (entry.waitDetail?.toLowerCase().includes("main")) {
-            observations.push({ tone: "info", text: "CI passed. Waiting for main verification before landing." });
-        }
         else {
             observations.push({ tone: "info", text: "CI passed. Landing on main." });
         }

package/package.json

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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,
-    };
-}