patchrelay 0.52.1 → 0.52.3

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.52.1",
-  "commit": "ce226d1e6424",
-  "builtAt": "2026-04-22T15:51:04.485Z"
+  "version": "0.52.3",
+  "commit": "76e8fb03067d",
+  "builtAt": "2026-04-22T19:20:36.664Z"
 }

package/dist/cli/data.js

@@ -6,6 +6,7 @@ import { extractCompletionCheck } from "../completion-check.js";
 import { getThreadTurns } from "../codex-thread-utils.js";
 import { PatchRelayDatabase } from "../db.js";
 import { buildManualRetryAttemptReset, resolveRetryTarget } from "../manual-issue-actions.js";
+import { buildOperatorRetryEvent } from "../operator-retry-event.js";
 import { WorktreeManager } from "../worktree-manager.js";
 import { parseDelegationObservedPayload, parseRunReleasedAuthorityPayload } from "../delegation-audit.js";
 import { CliOperatorApiClient } from "./operator-client.js";
@@ -386,61 +387,10 @@ export class CliDataAccess extends CliOperatorApiClient {
         };
     }
     appendRetryWake(issue, runType) {
-        if (runType === "queue_repair") {
-            const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
-            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "merge_steward_incident",
-                eventJson: JSON.stringify({
-                    ...(queueIncident ?? {}),
-                    ...(failureContext ?? {}),
-                    source: "operator_retry",
-                }),
-                dedupeKey: `operator_retry:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`,
-            });
-            return;
-        }
-        if (runType === "ci_repair") {
-            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "settled_red_ci",
-                eventJson: JSON.stringify({
-                    ...(failureContext ?? {}),
-                    source: "operator_retry",
-                }),
-                dedupeKey: `operator_retry:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`,
-            });
-            return;
-        }
-        if (runType === "review_fix" || runType === "branch_upkeep") {
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "review_changes_requested",
-                eventJson: JSON.stringify({
-                    reviewBody: runType === "branch_upkeep"
-                        ? "Operator requested retry of branch upkeep after requested changes."
-                        : "Operator requested retry of review-fix work.",
-                    ...(runType === "branch_upkeep" ? { branchUpkeepRequired: true, wakeReason: "branch_upkeep" } : {}),
-                    source: "operator_retry",
-                }),
-                dedupeKey: `operator_retry:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
-            });
-            return;
-        }
         this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
-            eventType: "delegated",
-            eventJson: JSON.stringify({
-                promptContext: "Operator requested retry of PatchRelay work.",
-                source: "operator_retry",
-            }),
-            dedupeKey: `operator_retry:implementation:${issue.linearIssueId}`,
+            ...buildOperatorRetryEvent(issue, runType),
         });
     }
     list(options) {

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/dist/operator-retry-event.js

@@ -38,9 +38,9 @@ export function buildOperatorRetryEvent(issue, runType, source = "operator_retry
         return {
             eventType: "review_changes_requested",
             eventJson: JSON.stringify({
-                reviewBody: runType === "branch_upkeep"
-                    ? `${humanizeSource(source)} requested retry of branch upkeep after requested changes.`
-                    : `${humanizeSource(source)} requested retry of review-fix work.`,
+                ...(runType === "branch_upkeep"
+                    ? { reviewBody: `${humanizeSource(source)} requested retry of branch upkeep after requested changes.` }
+                    : { promptContext: `${humanizeSource(source)} requested retry of review-fix work.` }),
                 ...(runType === "branch_upkeep" ? { branchUpkeepRequired: true, wakeReason: "branch_upkeep" } : {}),
                 source,
             }),

package/dist/reactive-run-policy.js

@@ -1,4 +1,5 @@
 import { buildReviewFixBranchUpkeepContext, isDirtyMergeStateStatus, isRequestedChangesRunType, readReactivePrSnapshot, } from "./reactive-pr-state.js";
+import { readLatestRequestedChangesReviewContext } from "./remote-pr-review.js";
 export class ReactiveRunPolicy {
     config;
     db;
@@ -136,6 +137,7 @@ export class ReactiveRunPolicy {
             const snapshot = await readReactivePrSnapshot(this.config, issue.projectId, issue.prNumber);
             if (!snapshot)
                 return context;
+            const refreshedContext = await this.hydrateRequestedChangesContext(issue.projectId, issue.prNumber, snapshot.repoFullName, snapshot.headSha, context);
             this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
@@ -144,12 +146,12 @@ export class ReactiveRunPolicy {
                 ...(snapshot.reviewState ? { prReviewState: snapshot.reviewState } : {}),
             }, "review-fix wake refresh");
             if (snapshot.prState !== "open")
-                return context;
+                return refreshedContext;
             if (snapshot.reviewState && snapshot.reviewState !== "changes_requested")
-                return context;
+                return refreshedContext;
             if (!isDirtyMergeStateStatus(snapshot.pr.mergeStateStatus))
-                return context;
-            return buildReviewFixBranchUpkeepContext(issue.prNumber, snapshot.baseBranch, snapshot.pr, context);
+                return refreshedContext;
+            return buildReviewFixBranchUpkeepContext(issue.prNumber, snapshot.baseBranch, snapshot.pr, refreshedContext);
         }
         catch (error) {
             this.logger.debug({
@@ -210,4 +212,44 @@ export class ReactiveRunPolicy {
         }
         return updated;
     }
+    async hydrateRequestedChangesContext(projectId, prNumber, repoFullName, headSha, context) {
+        const merged = {
+            ...(context ?? {}),
+            ...(headSha ? { headSha } : {}),
+        };
+        if (hasStructuredReviewContext(merged)) {
+            return merged;
+        }
+        const liveReview = await readLatestRequestedChangesReviewContext(repoFullName, prNumber);
+        if (!liveReview) {
+            return Object.keys(merged).length > 0 ? merged : context;
+        }
+        return {
+            ...merged,
+            ...(liveReview.reviewId !== undefined ? { reviewId: liveReview.reviewId } : {}),
+            ...(liveReview.reviewCommitId ? { reviewCommitId: liveReview.reviewCommitId } : {}),
+            ...(liveReview.reviewUrl ? { reviewUrl: liveReview.reviewUrl } : {}),
+            ...(liveReview.reviewerName ? { reviewerName: liveReview.reviewerName } : {}),
+            ...(liveReview.reviewBody ? { reviewBody: liveReview.reviewBody } : {}),
+            ...(liveReview.reviewComments ? { reviewComments: liveReview.reviewComments } : {}),
+        };
+    }
+}
+function hasStructuredReviewContext(context) {
+    if (!context)
+        return false;
+    const reviewBody = typeof context.reviewBody === "string" ? context.reviewBody.trim() : "";
+    const isOperatorRetryPlaceholder = typeof context.source === "string"
+        && context.source === "operator_retry"
+        && /^operator requested retry of review-fix work\.?$/i.test(reviewBody);
+    if (isOperatorRetryPlaceholder) {
+        return false;
+    }
+    if (reviewBody)
+        return true;
+    if (typeof context.reviewUrl === "string" && context.reviewUrl.trim())
+        return true;
+    if (typeof context.reviewerName === "string" && context.reviewerName.trim())
+        return true;
+    return Array.isArray(context.reviewComments) && context.reviewComments.length > 0;
 }

package/dist/remote-pr-review.js

@@ -0,0 +1,60 @@
+import { execCommand, safeJsonParse } from "./utils.js";
+export async function readLatestRequestedChangesReviewContext(repoFullName, prNumber) {
+    const [owner, repo] = repoFullName.split("/", 2);
+    if (!owner || !repo) {
+        return undefined;
+    }
+    const reviewsResult = await execCommand("gh", [
+        "api",
+        `repos/${owner}/${repo}/pulls/${prNumber}/reviews?per_page=100`,
+    ], { timeoutMs: 10_000 });
+    if (reviewsResult.exitCode !== 0) {
+        return undefined;
+    }
+    const reviews = safeJsonParse(reviewsResult.stdout);
+    if (!Array.isArray(reviews)) {
+        return undefined;
+    }
+    const review = [...reviews].reverse().find((entry) => entry?.state?.trim().toUpperCase() === "CHANGES_REQUESTED");
+    if (!review?.id) {
+        return undefined;
+    }
+    const comments = await readReviewComments(owner, repo, prNumber, review.id);
+    return {
+        reviewId: review.id,
+        ...(typeof review.commit_id === "string" && review.commit_id.trim() ? { reviewCommitId: review.commit_id.trim() } : {}),
+        ...(typeof review.html_url === "string" && review.html_url.trim() ? { reviewUrl: review.html_url.trim() } : {}),
+        ...(typeof review.body === "string" && review.body.trim() ? { reviewBody: review.body.trim() } : {}),
+        ...(typeof review.user?.login === "string" && review.user.login.trim() ? { reviewerName: review.user.login.trim() } : {}),
+        ...(comments.length > 0 ? { reviewComments: comments } : {}),
+    };
+}
+async function readReviewComments(owner, repo, prNumber, reviewId) {
+    const commentsResult = await execCommand("gh", [
+        "api",
+        `repos/${owner}/${repo}/pulls/${prNumber}/reviews/${reviewId}/comments?per_page=100`,
+    ], { timeoutMs: 10_000 });
+    if (commentsResult.exitCode !== 0) {
+        return [];
+    }
+    const comments = safeJsonParse(commentsResult.stdout);
+    if (!Array.isArray(comments)) {
+        return [];
+    }
+    return comments.flatMap((entry) => {
+        const body = typeof entry.body === "string" ? entry.body.trim() : "";
+        if (!body) {
+            return [];
+        }
+        return [{
+                body,
+                ...(typeof entry.path === "string" ? { path: entry.path } : {}),
+                ...(typeof entry.line === "number" ? { line: entry.line } : {}),
+                ...(typeof entry.side === "string" ? { side: entry.side } : {}),
+                ...(typeof entry.start_line === "number" ? { startLine: entry.start_line } : {}),
+                ...(typeof entry.start_side === "string" ? { startSide: entry.start_side } : {}),
+                ...(typeof entry.html_url === "string" ? { url: entry.html_url } : {}),
+                ...(typeof entry.user?.login === "string" ? { authorLogin: entry.user.login } : {}),
+            }];
+    });
+}

package/dist/run-launcher.js

@@ -18,6 +18,16 @@ function shouldCompactThread(issue, threadGeneration, context) {
 export function shouldReuseIssueThread(params) {
     return Boolean(params.existingThreadId) && !params.compactThread && params.resumeThread;
 }
+export function shouldFreshenWorktreeBeforeLaunch(params) {
+    if (params.runType === "queue_repair") {
+        return false;
+    }
+    if (params.runType === "review_fix") {
+        return params.effectiveContext?.branchUpkeepRequired === true
+            || params.effectiveContext?.reviewFixMode === "branch_upkeep";
+    }
+    return true;
+}
 export class RunLauncher {
     config;
     db;
@@ -125,7 +135,10 @@ export class RunLauncher {
                 });
             }
             await this.worktreeManager.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue, this.logger);
-            if (params.runType !== "queue_repair") {
+            if (shouldFreshenWorktreeBeforeLaunch({
+                runType: params.runType,
+                ...(params.effectiveContext ? { effectiveContext: params.effectiveContext } : {}),
+            })) {
                 await this.worktreeManager.freshenWorktree(params.worktreePath, params.project, params.issue, this.logger);
             }
             const hookEnv = buildHookEnv(params.issue.issueKey ?? params.issue.linearIssueId, params.branchName, params.runType, params.worktreePath);

package/package.json

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