patchrelay 0.52.2 → 0.52.4

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.52.2",
-  "commit": "44bb9d45502d",
-  "builtAt": "2026-04-22T17:29:32.600Z"
+  "version": "0.52.4",
+  "commit": "5fd50d353ab4",
+  "builtAt": "2026-04-22T20:52:16.943Z"
 }

package/dist/implementation-outcome-policy.js

@@ -38,7 +38,7 @@ export class ImplementationOutcomePolicy {
         return await this.describeLocalImplementationOutcome(issue, baseBranch);
     }
     async detectPublishedPrState(run, issue, repoFullName) {
-        if (issue.prNumber && issue.prState && issue.prState !== "closed") {
+        if (issue.prNumber && isOpenPrState(issue.prState)) {
             return "open";
         }
         if (!repoFullName || !issue.branchName) {
@@ -61,24 +61,30 @@ export class ImplementationOutcomePolicy {
                 return "unknown";
             }
             const matches = JSON.parse(stdout);
-            const pr = matches[0];
+            const pr = matches.find((candidate) => isOpenPrState(candidate.state)) ?? matches[0];
             if (!pr?.number) {
+                this.clearObservedPrIfLeaseHeld(issue, "published PR verification found no PRs for branch");
                 return "none";
             }
             const state = pr.state?.toLowerCase();
-            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                prNumber: pr.number,
-                ...(pr.url ? { prUrl: pr.url } : {}),
-                ...(state ? { prState: state } : {}),
-                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
-            }, "published PR verification refresh");
-            if (state !== "closed" && isMainRepairIssue(issue)) {
+            if (isOpenPrState(state)) {
+                this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    prNumber: pr.number,
+                    ...(pr.url ? { prUrl: pr.url } : {}),
+                    ...(state ? { prState: state } : {}),
+                    ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                    ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
+                }, "published PR verification refresh");
+            }
+            else {
+                this.clearObservedPrIfLeaseHeld(issue, "published PR verification found only historical PRs for branch");
+            }
+            if (isOpenPrState(state) && isMainRepairIssue(issue)) {
                 await this.ensurePriorityQueueLabel(run.projectId, pr.number, repoFullName);
             }
-            return state === "closed" ? "closed" : "open";
+            return isOpenPrState(state) ? "open" : "closed";
         }
         catch (error) {
             this.logger.debug({
@@ -97,6 +103,20 @@ export class ImplementationOutcomePolicy {
         }
         return updated;
     }
+    clearObservedPrIfLeaseHeld(issue, context) {
+        this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            prNumber: null,
+            prUrl: null,
+            prState: null,
+            prIsDraft: null,
+            prHeadSha: null,
+            prAuthorLogin: null,
+            prReviewState: null,
+            prCheckStatus: null,
+        }, context);
+    }
     async describeLocalImplementationOutcome(issue, baseBranch) {
         if (!issue.worktreePath) {
             return undefined;
@@ -177,3 +197,9 @@ export class ImplementationOutcomePolicy {
         }
     }
 }
+function isOpenPrState(state) {
+    if (!state)
+        return false;
+    const normalized = state.trim().toLowerCase();
+    return normalized !== "closed" && normalized !== "merged";
+}

package/dist/main-branch-health-monitor.js

@@ -37,12 +37,7 @@ export class MainBranchHealthMonitor {
             return;
         const baseBranch = project.github.baseBranch ?? "main";
         const branchName = buildMainRepairBranchName(baseBranch);
-        const existing = this.db.listIssues().find((issue) => (issue.projectId === projectId
-            && issue.branchName === branchName
-            && isMainRepairIssue(issue)
-            && issue.factoryState !== "done"
-            && issue.factoryState !== "failed"
-            && issue.factoryState !== "escalated"));
+        const existing = this.findExistingMainRepair(projectId, branchName);
         const summary = await this.readMainBranchFailure(project.github.repoFullName, baseBranch);
         if (!summary) {
             if (existing) {
@@ -114,6 +109,33 @@ export class MainBranchHealthMonitor {
             detail: summary.failingChecks.map((check) => check.name).join(", "),
         });
     }
+    findExistingMainRepair(projectId, branchName) {
+        const candidates = this.db.listIssues()
+            .filter((issue) => (issue.projectId === projectId
+            && issue.branchName === branchName
+            && isMainRepairIssue(issue)
+            && issue.factoryState !== "done"))
+            .sort((left, right) => this.compareMainRepairCandidates(left, right));
+        return candidates[0];
+    }
+    compareMainRepairCandidates(left, right) {
+        const leftPriority = this.rankMainRepairCandidate(left);
+        const rightPriority = this.rankMainRepairCandidate(right);
+        if (leftPriority !== rightPriority)
+            return leftPriority - rightPriority;
+        return Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+    }
+    rankMainRepairCandidate(issue) {
+        if (issue.activeRunId !== undefined)
+            return 0;
+        if (issue.prState === "open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "pr_open")
+            return 1;
+        if (issue.factoryState === "delegated" || issue.factoryState === "implementing")
+            return 2;
+        if (issue.factoryState === "failed" || issue.factoryState === "escalated")
+            return 3;
+        return 4;
+    }
     queueExistingMainRepair(issue, summary, priorityLabel) {
         if (issue.activeRunId !== undefined)
             return;
@@ -121,6 +143,15 @@ export class MainBranchHealthMonitor {
             return;
         if (issue.prState === "open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "pr_open")
             return;
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            delegatedToPatchRelay: true,
+            factoryState: "delegated",
+            pendingRunType: null,
+            pendingRunContextJson: null,
+            activeRunId: null,
+        });
         this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
@@ -131,6 +162,7 @@ export class MainBranchHealthMonitor {
                 failingChecks: summary.failingChecks,
                 pendingChecks: summary.pendingChecks,
                 priorityLabel,
+                promptContext: buildMainRepairPromptContext(this.config.projects.find((project) => project.id === issue.projectId) ?? { id: issue.projectId }, summary, priorityLabel),
             }),
             dedupeKey: `main_repair:${issue.projectId}:${summary.baseSha}:${summary.failingChecks.map((check) => check.name).join("|")}`,
         });

package/dist/no-pr-completion-check.js

@@ -170,6 +170,51 @@ export async function handleNoPrCompletionCheck(params) {
             });
             return;
         }
+        if (params.run.runType === "main_repair") {
+            const continued = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
+                params.db.runs.finishRun(params.run.id, runUpdate);
+                params.db.runs.saveCompletionCheck(params.run.id, {
+                    ...completionCheck,
+                    outcome: "continue",
+                    summary: "Main repair cannot finish without a published repair PR; continuing automatically until the fix is published or main recovers externally.",
+                    why: completionCheck.summary,
+                });
+                params.db.issues.upsertIssue({
+                    projectId: params.run.projectId,
+                    linearIssueId: params.run.linearIssueId,
+                    activeRunId: null,
+                    factoryState: "delegated",
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                });
+                return Boolean(params.db.issueSessions.appendIssueSessionEventWithLease(lease, {
+                    projectId: params.run.projectId,
+                    linearIssueId: params.run.linearIssueId,
+                    eventType: "completion_check_continue",
+                    eventJson: JSON.stringify({
+                        runType: params.run.runType,
+                        summary: params.publishedOutcomeError,
+                    }),
+                    dedupeKey: `completion_check_continue:${params.run.id}`,
+                }));
+            });
+            if (!continued) {
+                params.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping main-repair completion-check continue writes after losing issue-session lease");
+                params.clearProgressAndRelease(params.run);
+                return;
+            }
+            params.syncCompletionCheckOutcome({
+                run: params.run,
+                fallbackIssue: params.issue,
+                level: "info",
+                status: "completion_check_continue",
+                summary: "No repair PR found; continuing automatically",
+                detail: "Main repair cannot close until PatchRelay publishes a repair PR or main recovers externally.",
+                activity: buildCompletionCheckActivity("continue"),
+                enqueue: true,
+            });
+            return;
+        }
         const orchestrationOpenChildren = params.issue.issueClass === "orchestration"
             ? params.db.issues.countOpenChildIssues(params.run.projectId, params.run.linearIssueId)
             : 0;

package/package.json

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