patchrelay 0.32.2 → 0.33.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.32.2",
-  "commit": "a1095c2643be",
-  "builtAt": "2026-04-01T21:58:19.644Z"
+  "version": "0.33.0",
+  "commit": "90189d83b85f",
+  "builtAt": "2026-04-02T00:44:41.741Z"
 }

package/dist/cli/watch/IssueDetailView.js

@@ -59,6 +59,17 @@ function buildPrStatusSummary(issue, issueContext) {
     else if (checkState) {
         summary.push(checkState);
     }
+    if (issue.prChecksSummary?.total) {
+        if (issue.prChecksSummary.failed > 0) {
+            summary.push(`${issue.prChecksSummary.failed}/${issue.prChecksSummary.total} checks failing`);
+        }
+        else if (issue.prChecksSummary.pending > 0) {
+            summary.push(`${issue.prChecksSummary.completed}/${issue.prChecksSummary.total} checks settled`);
+        }
+        else {
+            summary.push(`${issue.prChecksSummary.passed}/${issue.prChecksSummary.total} checks passed`);
+        }
+    }
     if (reviewState) {
         summary.push(`review ${reviewState}`);
     }
@@ -86,22 +97,31 @@ function resolvePrimaryBlocker(issue, issueContext) {
             color: "yellow",
         };
     }
-    if (issue.prCheckStatus === "failed") {
-        const failedCheck = issueContext?.latestFailureCheckName ?? issue.latestFailureCheckName;
+    if (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure") {
+        const failedChecks = issue.prChecksSummary?.failedNames ?? [];
+        const failedCheck = issueContext?.latestFailureCheckName
+            ?? issue.latestFailureCheckName
+            ?? (failedChecks.length > 0 ? failedChecks.slice(0, 2).join(", ") : undefined);
         return {
             text: failedCheck ? `Blocked by failed check: ${failedCheck}` : "Blocked by failed PR checks",
             color: "red",
         };
     }
+    if (issue.prCheckStatus === "pending" || issue.prCheckStatus === "in_progress" || issue.prCheckStatus === "queued") {
+        return { text: "Waiting for PR checks to finish", color: "yellow" };
+    }
     if (issue.prReviewState === "changes_requested") {
         return { text: "Blocked by requested review changes", color: "yellow" };
     }
-    if (issue.prNumber !== undefined && !issue.prReviewState && issue.factoryState !== "done") {
-        return { text: "Blocked pending review approval", color: "yellow" };
+    if (issue.factoryState === "repairing_queue") {
+        return { text: "Blocked by merge queue refresh failure", color: "yellow" };
     }
     if (issue.factoryState === "awaiting_queue") {
         return { text: "Waiting in merge queue", color: "yellow" };
     }
+    if (issue.prNumber !== undefined && !issue.prReviewState && issue.factoryState !== "done") {
+        return { text: "Blocked pending review approval", color: "yellow" };
+    }
     return null;
 }
 function ElapsedTime({ startedAt }) {

package/dist/cli/watch/IssueRow.js

@@ -148,10 +148,10 @@ function buildChecksProgressChip(issue) {
     if (!summary || summary.total <= 0)
         return null;
     const text = summary.failed > 0
-        ? `checks ${summary.completed}/${summary.total} failed`
+        ? `checks ${summary.failed}/${summary.total} failed`
         : summary.pending > 0
-            ? `checks ${summary.completed}/${summary.total} running`
-            : `checks ${summary.completed}/${summary.total} passed`;
+            ? `checks ${summary.completed}/${summary.total} settled`
+            : `checks ${summary.passed}/${summary.total} passed`;
     const color = summary.failed > 0 ? "red" : summary.pending > 0 ? "yellow" : "green";
     return { text, color };
 }
@@ -181,22 +181,31 @@ function buildPrimaryBlocker(issue) {
             color: "yellow",
         };
     }
-    if (issue.prCheckStatus === "failed") {
-        const failedCheck = issue.latestFailureCheckName ?? "PR checks";
+    if (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure") {
+        const failedChecks = issue.prChecksSummary?.failedNames ?? [];
+        const failedCheck = issue.latestFailureCheckName
+            ?? (failedChecks.length > 0 ? failedChecks.slice(0, 2).join(", ") : undefined)
+            ?? "PR checks";
         return {
             text: `${failedCheck} failed`,
             color: "red",
         };
     }
+    if (issue.prCheckStatus === "pending" || issue.prCheckStatus === "in_progress" || issue.prCheckStatus === "queued") {
+        return {
+            text: "Waiting for PR checks to finish",
+            color: "yellow",
+        };
+    }
     if (issue.prReviewState === "changes_requested") {
         return {
             text: "Review changes requested",
             color: "yellow",
         };
     }
-    if (issue.prNumber !== undefined && !issue.prReviewState && issue.factoryState !== "done") {
+    if (issue.factoryState === "repairing_queue") {
         return {
-            text: "Waiting for review approval",
+            text: "Merge queue reported a branch refresh failure",
             color: "yellow",
         };
     }
@@ -206,6 +215,12 @@ function buildPrimaryBlocker(issue) {
             color: "yellow",
         };
     }
+    if (issue.prNumber !== undefined && !issue.prReviewState && issue.factoryState !== "done") {
+        return {
+            text: "Waiting for review approval",
+            color: "yellow",
+        };
+    }
     return null;
 }
 function buildPipelineProgress(issue) {

package/dist/db.js

@@ -484,6 +484,20 @@ export class PatchRelayDatabase {
             .all();
         return rows.map(mapIssueRow);
     }
+    /**
+     * Issues waiting in the merge queue with no active or pending run.
+     * Used by the queue health monitor to probe GitHub for stuck PRs.
+     */
+    listAwaitingQueueIssues() {
+        const rows = this.connection
+            .prepare(`SELECT * FROM issues
+         WHERE factory_state = 'awaiting_queue'
+         AND active_run_id IS NULL
+         AND pending_run_type IS NULL
+         AND pr_number IS NOT NULL`)
+            .all();
+        return rows.map(mapIssueRow);
+    }
     listIssuesByState(projectId, state) {
         const rows = this.connection
             .prepare("SELECT * FROM issues WHERE project_id = ? AND factory_state = ? ORDER BY pr_number ASC")

package/dist/run-orchestrator.js

@@ -17,6 +17,12 @@ const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
 const DEFAULT_REVIEW_FIX_BUDGET = 3;
 const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
 const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000; // 15s, 30s, 60s, 120s, 240s
+// Queue health monitor: wait before probing a freshly-queued PR.
+// TODO: replace updatedAt with a true factory_state_changed_at timestamp —
+// updatedAt can reset on unrelated row mutations (e.g. webhook metadata).
+const QUEUE_HEALTH_GRACE_MS = 120_000;
+// Suppress repeated probe-failure feed events — at most one per issue per window.
+const QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS = 300_000; // 5 minutes
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -98,6 +104,8 @@ export class RunOrchestrator {
     feed;
     worktreeManager;
     progressThrottle = new Map();
+    /** Tracks last probe-failure feed event per issue to avoid spamming the operator feed. */
+    probeFailureFeedTimes = new Map();
     activeThreadId;
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
@@ -555,10 +563,112 @@ export class RunOrchestrator {
         for (const run of this.db.listRunningRuns()) {
             await this.reconcileRun(run);
         }
+        // Preemptively detect stuck merge-queue PRs (conflicts visible on
+        // GitHub) and dispatch queue_repair before the Steward evicts.
+        await this.reconcileQueueHealth();
         // Advance issues stuck in pr_open whose stored PR metadata already
         // shows they should transition (e.g. approved PR, missed webhook).
         await this.reconcileIdleIssues();
     }
+    // ─── Queue Health Monitor ──────────────────────────────────────────
+    async reconcileQueueHealth() {
+        for (const issue of this.db.listAwaitingQueueIssues()) {
+            await this.probeQueuedIssue(issue);
+        }
+    }
+    async probeQueuedIssue(issue) {
+        if (!issue.prNumber)
+            return;
+        const project = this.config.projects.find((p) => p.id === issue.projectId);
+        if (!project?.github?.repoFullName)
+            return;
+        // Grace period — don't probe PRs that just entered the queue.
+        const age = Date.now() - Date.parse(issue.updatedAt);
+        if (age < QUEUE_HEALTH_GRACE_MS)
+            return;
+        const protocol = resolveMergeQueueProtocol(project);
+        let pr;
+        try {
+            const { stdout } = await execCommand("gh", [
+                "pr", "view", String(issue.prNumber),
+                "--repo", project.github.repoFullName,
+                "--json", "state,mergeable,mergeStateStatus,headRefOid,labels",
+            ], { timeoutMs: 10_000 });
+            pr = JSON.parse(stdout);
+        }
+        catch (error) {
+            this.logger.debug({ issueKey: issue.issueKey, prNumber: issue.prNumber, error: error instanceof Error ? error.message : String(error) }, "Queue health: failed to probe GitHub PR state");
+            // Throttle feed events — at most one per issue per cooldown window.
+            const issueKey = `${issue.projectId}::${issue.linearIssueId}`;
+            const lastFeedAt = this.probeFailureFeedTimes.get(issueKey) ?? 0;
+            if (Date.now() - lastFeedAt >= QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS) {
+                this.probeFailureFeedTimes.set(issueKey, Date.now());
+                this.feed?.publish({
+                    level: "info",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "awaiting_queue",
+                    status: "queue_health_probe_failed",
+                    summary: `Queue health: failed to probe PR #${issue.prNumber}`,
+                });
+            }
+            return;
+        }
+        // Successful probe — clear any probe-failure throttle for this issue.
+        this.probeFailureFeedTimes.delete(`${issue.projectId}::${issue.linearIssueId}`);
+        // Missed merge webhook — advance to done.
+        if (pr.state === "MERGED") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+            this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+            return;
+        }
+        // Non-open PRs (closed, draft) — don't enter repair logic.
+        if (pr.state !== "OPEN")
+            return;
+        // Verify admission label is still present — if the Steward removed it
+        // (eviction, dequeue) but PatchRelay missed the webhook, we should not
+        // treat a DIRTY PR as a queue-health problem.
+        const hasQueueLabel = pr.labels?.some((l) => l.name === protocol.admissionLabel) ?? false;
+        if (!hasQueueLabel)
+            return;
+        // Conflict detected — dispatch preemptive queue repair.
+        if (pr.mergeStateStatus === "DIRTY" || pr.mergeable === "CONFLICTING") {
+            const headRefOid = pr.headRefOid ?? "unknown";
+            // TODO: include baseSha in signature (headRefOid + baseSha) so that a
+            // main-only advance with the same PR head is recognized as a new conflict.
+            const signature = `preemptive_queue_conflict:${headRefOid}`;
+            const pendingRunContext = {
+                source: "queue_health_monitor",
+                failureReason: "preemptive_conflict",
+                failureHeadSha: headRefOid,
+                failureSignature: signature,
+            };
+            if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                return;
+            }
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastAttemptedFailureHeadSha: headRefOid,
+                lastAttemptedFailureSignature: signature,
+            });
+            this.advanceIdleIssue(issue, "repairing_queue", {
+                pendingRunType: "queue_repair",
+                pendingRunContext,
+            });
+            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid }, "Queue health: merge conflict detected, dispatching preemptive repair");
+            this.feed?.publish({
+                level: "warn",
+                kind: "github",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: "repairing_queue",
+                status: "queue_health_conflict_detected",
+                summary: `Queue health: merge conflict detected on PR #${issue.prNumber}, dispatching preemptive repair`,
+            });
+        }
+    }
     async reconcileIdleIssues() {
         for (const issue of this.db.listIdleNonTerminalIssues()) {
             // PR already merged — advance to done regardless of current state

package/dist/service.js

@@ -35,22 +35,26 @@ function extractStatusNote(summaryJson, reportJson) {
     }
     return undefined;
 }
-function parseCiSnapshotSummary(snapshotJson) {
+export function parseCiSnapshotSummary(snapshotJson) {
     if (!snapshotJson)
         return undefined;
     try {
         const snapshot = JSON.parse(snapshotJson);
-        const checks = Array.isArray(snapshot.checks) ? snapshot.checks : [];
+        const rawChecks = Array.isArray(snapshot.checks) ? snapshot.checks : [];
+        const checks = collapseEffectiveChecks(rawChecks);
         if (checks.length === 0)
             return undefined;
         let passed = 0;
         let failed = 0;
         let pending = 0;
+        const failedNames = [];
         for (const check of checks) {
             if (check.status === "success")
                 passed++;
-            else if (check.status === "failure")
+            else if (check.status === "failure") {
                 failed++;
+                failedNames.push(check.name);
+            }
             else
                 pending++;
         }
@@ -61,12 +65,23 @@ function parseCiSnapshotSummary(snapshotJson) {
             failed,
             pending,
             overall: snapshot.gateCheckStatus,
+            ...(failedNames.length > 0 ? { failedNames } : {}),
         };
     }
     catch {
         return undefined;
     }
 }
+function collapseEffectiveChecks(checks) {
+    const effective = new Map();
+    for (const check of checks) {
+        const name = typeof check?.name === "string" ? check.name.trim() : "";
+        if (!name || effective.has(name))
+            continue;
+        effective.set(name, check);
+    }
+    return [...effective.values()];
+}
 export class PatchRelayService {
     config;
     db;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.32.2",
+  "version": "0.33.0",
   "license": "MIT",
   "type": "module",
   "repository": {