merge-steward 0.26.1 → 0.26.2

package/dist/reconciler-evict.js

@@ -32,11 +32,20 @@ export async function evictEntry(ctx, entry, failureClass, extra) {
     const retryHistory = [];
     for (const event of events) {
         const eventBaseSha = event.baseSha || "unknown";
+        const detail = event.detail ?? "";
         if (event.fromStatus === "preparing_head" && event.toStatus === "validating") {
             retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "passed_to_validation" });
         }
         else if (event.fromStatus === "validating" && event.toStatus === "preparing_head") {
-            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "ci_failed_retry" });
+            const outcome = detail.startsWith("invalidated:")
+                ? "invalidated"
+                : detail.toLowerCase().includes("ci failed")
+                    ? "ci_failed_retry"
+                    : "validation_reset";
+            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome });
+        }
+        else if (event.fromStatus === "merging" && event.toStatus === "preparing_head") {
+            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "push_failed_retry" });
         }
         else if (event.fromStatus === "preparing_head" && event.toStatus === "preparing_head") {
             retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "conflict_retry" });

package/dist/reconciler-merge.js

@@ -7,6 +7,136 @@ const DEFAULT_PR_MERGED_POLL_DELAY_MS = 2_000;
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function shortSha(sha) {
+    return sha ? sha.slice(0, 8) : "unknown";
+}
+function sanitizeCommandOutput(value) {
+    return value
+        .replace(/x-access-token:[^@\s]+@/g, "x-access-token:[redacted]@")
+        .replace(/\bgh[psu]_[A-Za-z0-9_]+\b/g, "[redacted-token]")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 1200);
+}
+function describeError(error) {
+    if (!(error instanceof Error)) {
+        return sanitizeCommandOutput(String(error));
+    }
+    const failure = error;
+    const parts = [
+        failure.stderr,
+        failure.stdout,
+        error.message,
+        typeof failure.exitCode === "number" ? `exit code ${failure.exitCode}` : undefined,
+        failure.signal ? `signal ${failure.signal}` : undefined,
+    ].filter((part) => Boolean(part && part.trim()));
+    return sanitizeCommandOutput(parts.join(" "));
+}
+function classifyPushFailure(error, detail) {
+    const failure = error instanceof Error ? error : undefined;
+    const lower = detail.toLowerCase();
+    if (failure?.timedOut || lower.includes("timed out")) {
+        return "timeout";
+    }
+    if (lower.includes("refusing to allow a github app to create or update workflow")) {
+        return "workflow_permission";
+    }
+    if (lower.includes("non-fast-forward")
+        || lower.includes("fetch first")
+        || lower.includes("stale info")
+        || lower.includes("cannot lock ref")) {
+        return "non_fast_forward";
+    }
+    if (lower.includes("protected branch")
+        || lower.includes("gh006")
+        || lower.includes("required status check")
+        || lower.includes("required approving review")
+        || lower.includes("changes must be made through a pull request")) {
+        return "protected_branch";
+    }
+    if (lower.includes("authentication failed")
+        || lower.includes("permission denied")
+        || lower.includes("write access")
+        || lower.includes("403")
+        || lower.includes("not authorized")) {
+        return "auth_or_permission";
+    }
+    return "github_push_rejected";
+}
+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 summarizeChecks(checks, missingRequiredChecks) {
+    const visible = checks
+        .filter((check) => check.name.trim())
+        .map((check) => `${check.name}=${check.conclusion}`);
+    const parts = [];
+    if (visible.length > 0) {
+        parts.push(`spec checks ${visible.slice(0, 5).join(", ")}`);
+        if (visible.length > 5) {
+            parts.push(`+${visible.length - 5} more`);
+        }
+    }
+    else {
+        parts.push("no spec checks visible");
+    }
+    if (missingRequiredChecks.length > 0) {
+        parts.push(`missing required ${missingRequiredChecks.join(", ")}`);
+    }
+    return parts.join("; ");
+}
+async function inspectSpecChecks(ctx, specSha) {
+    if (!specSha) {
+        return {
+            detail: "spec checks unavailable: no spec SHA",
+            failingChecks: [],
+            pendingChecks: [],
+            missingRequiredChecks: ctx.policy.getRequiredChecks(),
+        };
+    }
+    try {
+        const checks = await ctx.github.listChecksForRef(specSha);
+        const failingChecks = checks.filter((check) => check.conclusion === "failure");
+        const pendingChecks = checks.filter((check) => check.conclusion === "pending");
+        const missingRequiredChecks = getMissingRequiredChecks(ctx.policy.getRequiredChecks(), checks);
+        return {
+            detail: summarizeChecks(checks, missingRequiredChecks),
+            failingChecks,
+            pendingChecks,
+            missingRequiredChecks,
+        };
+    }
+    catch (error) {
+        return {
+            detail: `spec checks unavailable: ${describeError(error)}`,
+            failingChecks: [],
+            pendingChecks: [],
+            missingRequiredChecks: ctx.policy.getRequiredChecks(),
+        };
+    }
+}
+async function verifySpecStillFastForwards(ctx, specSha) {
+    try {
+        await ctx.git.fetch();
+        const currentBase = await ctx.git.headSha(ref(ctx, ctx.baseBranch));
+        const isFastForward = await ctx.git.isAncestor(currentBase, specSha);
+        return { currentBase, isFastForward };
+    }
+    catch (error) {
+        return {
+            currentBase: null,
+            isFastForward: null,
+            detail: `fast-forward verification unavailable: ${describeError(error)}`,
+        };
+    }
+}
 export async function mergeHead(ctx, entry) {
     emit(ctx, entry, "merge_revalidating");
     const prStatus = await ctx.github.getStatus(entry.prNumber);
@@ -93,7 +223,12 @@ export async function mergeHead(ctx, entry) {
     try {
         await ctx.git.push(entry.specBranch, false, ctx.baseBranch);
     }
-    catch {
+    catch (error) {
+        const pushErrorDetail = describeError(error);
+        const pushFailureKind = classifyPushFailure(error, pushErrorDetail);
+        const fastForward = entry.specSha
+            ? await verifySpecStillFastForwards(ctx, entry.specSha)
+            : { currentBase: null, isFastForward: null, detail: "fast-forward verification unavailable: no spec SHA" };
         try {
             const refresh = await ctx.policy.refreshOnIssue("merge_push_rejected");
             if (refresh.attempted && refresh.changed) {
@@ -109,20 +244,52 @@ export async function mergeHead(ctx, entry) {
         catch {
             // Fall through to the normal push failure handling when policy refresh is unavailable.
         }
-        emit(ctx, entry, "merge_rejected", { detail: "push to main failed" });
-        const allActive = ctx.store.listActive(ctx.repoId);
-        if (isBudgetExhausted(entry)) {
-            emit(ctx, entry, "budget_exhausted");
-            await evictEntry(ctx, entry, "integration_conflict");
+        const checkState = await inspectSpecChecks(ctx, entry.specSha);
+        const detail = [
+            `push to ${ctx.baseBranch} failed (${pushFailureKind})`,
+            `spec ${shortSha(entry.specSha)}`,
+            `main ${shortSha(fastForward.currentBase ?? currentBase)}`,
+            fastForward.isFastForward === null
+                ? fastForward.detail
+                : `spec fast-forward ${fastForward.isFastForward ? "yes" : "no"}`,
+            checkState.detail,
+            pushErrorDetail,
+        ].filter((part) => Boolean(part && part.trim())).join("; ");
+        emit(ctx, entry, "merge_rejected", {
+            detail,
+            baseSha: fastForward.currentBase ?? currentBase ?? undefined,
+            failingChecks: checkState.failingChecks,
+            pendingChecks: checkState.pendingChecks,
+            missingRequiredChecks: checkState.missingRequiredChecks,
+        });
+        const mustRebuild = pushFailureKind === "non_fast_forward" || fastForward.isFastForward === false;
+        if (mustRebuild) {
+            const allActive = ctx.store.listActive(ctx.repoId);
+            if (isBudgetExhausted(entry)) {
+                emit(ctx, entry, "budget_exhausted", {
+                    detail: "push retry budget exhausted after non-fast-forward rejection",
+                });
+                await evictEntry(ctx, entry, "integration_conflict");
+            }
+            else {
+                ctx.store.transition(entry.id, "preparing_head", {
+                    retryAttempts: entry.retryAttempts + 1,
+                    ...CLEAN_CI,
+                    ...CLEAN_SPEC,
+                }, `push failed, retry ${entry.retryAttempts + 1}/${entry.maxRetries}`);
+            }
+            await invalidateDownstream(ctx, allActive, 0);
+            return;
         }
-        else {
-            ctx.store.transition(entry.id, "preparing_head", {
-                retryAttempts: entry.retryAttempts + 1,
-                ...CLEAN_CI,
-                ...CLEAN_SPEC,
-            }, `push failed, retry ${entry.retryAttempts + 1}/${entry.maxRetries}`);
+        if (isBudgetExhausted(entry)) {
+            emit(ctx, entry, "budget_exhausted", {
+                detail: "push retry budget exhausted; keeping validated spec for GitHub recovery",
+            });
         }
-        await invalidateDownstream(ctx, allActive, 0);
+        ctx.store.transition(entry.id, "merging", {
+            retryAttempts: Math.min(entry.retryAttempts + 1, entry.maxRetries),
+            waitDetail: detail,
+        }, `push failed, keeping validated spec: ${detail}`);
         return;
     }
     emit(ctx, entry, "merge_succeeded");

package/package.json

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