patchrelay 0.32.3 → 0.33.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.32.3",
-  "commit": "fbdb9010e964",
-  "builtAt": "2026-04-01T22:29:47.921Z"
+  "version": "0.33.0",
+  "commit": "90189d83b85f",
+  "builtAt": "2026-04-02T00:44:41.741Z"
 }

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/package.json

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