patchrelay 0.52.2 → 0.52.3

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.3",
+  "commit": "76e8fb03067d",
+  "builtAt": "2026-04-22T19:20:36.664Z"
 }

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/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.3",
   "license": "MIT",
   "type": "module",
   "repository": {