patchrelay 0.36.2 → 0.36.4

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.2",
-  "commit": "45b497cfbf8e",
-  "builtAt": "2026-04-08T23:32:38.896Z"
+  "version": "0.36.4",
+  "commit": "1202c3df2bcb",
+  "builtAt": "2026-04-09T07:03:52.765Z"
 }

package/dist/cli/cluster-health.js

@@ -327,6 +327,21 @@ async function evaluateGitHubIssueHealth(snapshot, config, runCommand, reviewQui
             },
         };
     }
+    if (gateCheckStatus === "success"
+        && reviewDecision === "CHANGES_REQUESTED"
+        && mergeConflictDetected
+        && issue.factoryState !== "changes_requested"
+        && issue.activeRunId === undefined
+        && ageMs >= RECONCILIATION_GRACE_MS) {
+        return {
+            ciEntry,
+            finding: {
+                status: "fail",
+                scope: "github:branch-upkeep",
+                message: "PR is still dirty after requested changes, but no branch-upkeep run is active",
+            },
+        };
+    }
     if (gateCheckStatus === "success"
         && reviewDecision === "CHANGES_REQUESTED"
         && latestBlockingReviewHeadSha === pr.headRefOid
@@ -423,6 +438,9 @@ function deriveCiOwner(params) {
             : "downstream";
     }
     if (params.reviewDecision === "CHANGES_REQUESTED") {
+        if (params.mergeConflictDetected) {
+            return params.factoryState === "changes_requested" ? "patchrelay" : "unknown";
+        }
         if (params.factoryState === "changes_requested")
             return "patchrelay";
         if (params.reviewQuillAttempt)
@@ -451,6 +469,9 @@ function describeCiOwnership(params) {
         && params.latestBlockingReviewHeadSha
         && params.currentHeadSha !== params.latestBlockingReviewHeadSha);
     if (params.owner === "patchrelay") {
+        if (params.mergeConflictDetected) {
+            return "PatchRelay owns the next branch-upkeep move";
+        }
         return params.gateCheckStatus === "failure"
             ? "PatchRelay owns the next CI repair move"
             : "PatchRelay owns the next requested-changes move";
@@ -479,6 +500,11 @@ function describeCiOwnership(params) {
             : "Waiting on external GitHub automation";
     }
     if (params.reviewDecision === "CHANGES_REQUESTED") {
+        if (params.mergeConflictDetected) {
+            return headAdvancedPastBlockingReview
+                ? "PR is still dirty after a newer pushed head and no branch-upkeep run is active"
+                : "PR is still dirty on the current blocked head and no branch-upkeep run is active";
+        }
         return blockingReviewTargetsCurrentHead
             ? "Requested changes still block the same head and no fix run is active"
             : "Waiting on review after a newer pushed head";

package/dist/db.js

@@ -357,6 +357,7 @@ export class PatchRelayDatabase {
           last_github_ci_snapshot_head_sha, last_github_ci_snapshot_gate_check_name, last_github_ci_snapshot_gate_check_status, last_github_ci_snapshot_json, last_github_ci_snapshot_settled_at,
           last_queue_signal_at, last_queue_incident_json,
           last_attempted_failure_head_sha, last_attempted_failure_signature,
+          ci_repair_attempts, queue_repair_attempts, review_fix_attempts, zombie_recovery_attempts, last_zombie_recovery_at,
           updated_at
         ) VALUES (
           @projectId, @linearIssueId, @issueKey, @title, @description, @url,
@@ -369,6 +370,7 @@ export class PatchRelayDatabase {
           @lastGitHubCiSnapshotHeadSha, @lastGitHubCiSnapshotGateCheckName, @lastGitHubCiSnapshotGateCheckStatus, @lastGitHubCiSnapshotJson, @lastGitHubCiSnapshotSettledAt,
           @lastQueueSignalAt, @lastQueueIncidentJson,
           @lastAttemptedFailureHeadSha, @lastAttemptedFailureSignature,
+          @ciRepairAttempts, @queueRepairAttempts, @reviewFixAttempts, @zombieRecoveryAttempts, @lastZombieRecoveryAt,
           @now
         )
       `).run({
@@ -415,6 +417,11 @@ export class PatchRelayDatabase {
                 lastQueueIncidentJson: params.lastQueueIncidentJson ?? null,
                 lastAttemptedFailureHeadSha: params.lastAttemptedFailureHeadSha ?? null,
                 lastAttemptedFailureSignature: params.lastAttemptedFailureSignature ?? null,
+                ciRepairAttempts: params.ciRepairAttempts ?? 0,
+                queueRepairAttempts: params.queueRepairAttempts ?? 0,
+                reviewFixAttempts: params.reviewFixAttempts ?? 0,
+                zombieRecoveryAttempts: params.zombieRecoveryAttempts ?? 0,
+                lastZombieRecoveryAt: params.lastZombieRecoveryAt ?? null,
                 now,
             });
         }

package/dist/idle-reconciliation.js

@@ -16,6 +16,22 @@ function isReviewDecisionChangesRequested(value) {
 function isReviewDecisionReviewRequired(value) {
     return value?.trim().toUpperCase() === "REVIEW_REQUIRED";
 }
+function buildBranchUpkeepContext(prNumber, baseBranch, mergeStateStatus, headSha) {
+    const promptContext = [
+        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${mergeStateStatus ?? "DIRTY"} against latest ${baseBranch}.`,
+        `This turn is branch upkeep on the existing PR branch: update onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push a newer head.`,
+        "Do not stop just because the requested code change is already present. Review can only move forward after a new pushed head.",
+    ].join(" ");
+    return {
+        branchUpkeepRequired: true,
+        reviewFixMode: "branch_upkeep",
+        wakeReason: "branch_upkeep",
+        promptContext,
+        ...(mergeStateStatus ? { mergeStateStatus } : {}),
+        ...(headSha ? { failingHeadSha: headSha } : {}),
+        baseBranch,
+    };
+}
 function hasCompletedReviewQuillVerdict(entries) {
     return (entries ?? []).some((entry) => entry.__typename === "CheckRun"
         && entry.name === "review-quill/verdict"
@@ -475,6 +491,42 @@ export class IdleIssueReconciler {
                 mergeConflictDetected,
                 downstreamOwned,
             });
+            if ((issue.factoryState === "escalated" || issue.factoryState === "failed")
+                && (reactiveIntent?.runType === "review_fix" || reactiveIntent?.runType === "branch_upkeep")) {
+                const pendingRunContext = reactiveIntent.runType === "branch_upkeep"
+                    ? buildBranchUpkeepContext(issue.prNumber, project.github?.baseBranch ?? "main", pr.mergeStateStatus, pr.headRefOid)
+                    : undefined;
+                this.logger.info({
+                    issueKey: issue.issueKey,
+                    prNumber: issue.prNumber,
+                    from: issue.factoryState,
+                    runType: reactiveIntent.runType,
+                    mergeStateStatus: pr.mergeStateStatus,
+                }, "Reconciliation: recovered terminal requested-changes issue from GitHub truth");
+                this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
+                    pendingRunType: reactiveIntent.runType,
+                    ...(pendingRunContext ? { pendingRunContext } : {}),
+                    clearFailureProvenance: true,
+                });
+                return;
+            }
+            if (reactiveIntent?.runType === "branch_upkeep" && mergeConflictDetected) {
+                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable, mergeStateStatus: pr.mergeStateStatus }, "Reconciliation: PR still needs branch upkeep after requested changes");
+                this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
+                    pendingRunType: reactiveIntent.runType,
+                    pendingRunContext: buildBranchUpkeepContext(issue.prNumber, project.github?.baseBranch ?? "main", pr.mergeStateStatus, pr.headRefOid),
+                });
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: reactiveIntent.compatibilityFactoryState,
+                    status: "branch_upkeep_queued",
+                    summary: `PR #${issue.prNumber} is still dirty after requested changes, dispatching branch upkeep`,
+                });
+                return;
+            }
             if (reactiveIntent?.runType === "queue_repair" && mergeConflictDetected) {
                 this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable }, "Reconciliation: PR needs queue repair from fresh GitHub truth");
                 this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
@@ -510,7 +562,7 @@ export class IdleIssueReconciler {
                 return;
             }
             if (mergeConflictDetected) {
-                this.logger.debug({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable, mergeStateStatus: pr.mergeStateStatus }, "Reconciliation: PR is dirty but not yet queue-admitted; leaving PatchRelay in review state");
+                this.logger.debug({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable, mergeStateStatus: pr.mergeStateStatus }, "Reconciliation: PR is dirty but no automation owner was derived");
             }
         }
         catch (error) {

package/dist/issue-session.js

@@ -59,6 +59,13 @@ export function deriveIssueSessionReactiveIntent(params) {
         };
     }
     if (params.prReviewState === "changes_requested") {
+        if (params.mergeConflictDetected) {
+            return {
+                runType: "branch_upkeep",
+                wakeReason: "branch_upkeep",
+                compatibilityFactoryState: "changes_requested",
+            };
+        }
         return {
             runType: "review_fix",
             wakeReason: "review_changes_requested",
@@ -72,12 +79,15 @@ export function isIssueSessionReadyForExecution(params) {
         return false;
     if (params.blockedByCount > 0)
         return false;
-    if (params.sessionState === "done" || params.sessionState === "failed" || params.sessionState === "waiting_input") {
+    if (params.sessionState === "done" || params.sessionState === "waiting_input") {
         return false;
     }
     if (params.hasPendingWake) {
         return true;
     }
+    if (params.sessionState === "failed") {
+        return false;
+    }
     if (!params.hasLegacyPendingRun) {
         return false;
     }

package/dist/run-orchestrator.js

@@ -12,7 +12,7 @@ import { getThreadTurns } from "./codex-thread-utils.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 const DEFAULT_CI_REPAIR_BUDGET = 3;
 const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
-const DEFAULT_REVIEW_FIX_BUDGET = 3;
+const DEFAULT_REVIEW_FIX_BUDGET = 6;
 const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
 const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000; // 15s, 30s, 60s, 120s, 240s
 const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
@@ -636,8 +636,8 @@ export class RunOrchestrator {
             this.escalate(issue, runType, `Queue repair budget exhausted (${DEFAULT_QUEUE_REPAIR_BUDGET} attempts)`);
             return;
         }
-        if (runType === "review_fix" && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
-            this.escalate(issue, runType, `Review fix budget exhausted (${DEFAULT_REVIEW_FIX_BUDGET} attempts)`);
+        if (isRequestedChangesRunType(runType) && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+            this.escalate(issue, runType, `Requested-changes budget exhausted (${DEFAULT_REVIEW_FIX_BUDGET} attempts)`);
             return;
         }
         // Increment repair counters
@@ -655,7 +655,7 @@ export class RunOrchestrator {
                 return;
             }
         }
-        if (runType === "review_fix") {
+        if (isRequestedChangesRunType(runType)) {
             const updated = this.db.upsertIssueWithLease({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, leaseId }, { projectId: issue.projectId, linearIssueId: issue.linearIssueId, reviewFixAttempts: issue.reviewFixAttempts + 1 });
             if (!updated) {
                 this.releaseIssueSessionLease(item.projectId, item.issueId);
@@ -1467,13 +1467,6 @@ export class RunOrchestrator {
                         queueRepairAttempts: issue.queueRepairAttempts - 1,
                     });
                 }
-                else if (run.runType === "review_fix" && issue.reviewFixAttempts > 0) {
-                    this.db.upsertIssueWithLease(lease, {
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        reviewFixAttempts: issue.reviewFixAttempts - 1,
-                    });
-                }
                 if (run.runType === "ci_repair" || run.runType === "queue_repair") {
                     this.db.upsertIssueWithLease(lease, {
                         projectId: issue.projectId,
@@ -1490,21 +1483,56 @@ export class RunOrchestrator {
                 return;
             }
             if (isRequestedChangesRunType(run.runType)) {
+                const refreshedIssue = await this.refreshIssueAfterReactivePublish(run, this.db.getIssue(run.projectId, run.linearIssueId) ?? issue);
+                const project = this.config.projects.find((entry) => entry.id === run.projectId);
+                const retryContext = project
+                    ? await this.resolveRequestedChangesWakeContext(refreshedIssue, run.runType, run.runType === "branch_upkeep"
+                        ? {
+                            branchUpkeepRequired: true,
+                            reviewFixMode: "branch_upkeep",
+                            wakeReason: "branch_upkeep",
+                        }
+                        : undefined, project)
+                    : undefined;
+                const retryRunType = resolveRequestedChangesMode(run.runType, retryContext) === "branch_upkeep"
+                    ? "branch_upkeep"
+                    : "review_fix";
+                const recoveredState = resolveRecoverablePostRunState(refreshedIssue) ?? "failed";
                 const interruptedMessage = "Requested-changes run was interrupted before PatchRelay could verify that a new PR head was published";
-                this.failRunAndClear(run, interruptedMessage, "escalated");
+                this.failRunAndClear(run, interruptedMessage, recoveredState);
                 await this.restoreIdleWorktree(issue);
-                const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-                this.feed?.publish({
-                    level: "error",
-                    kind: "workflow",
-                    issueKey: issue.issueKey,
-                    projectId: run.projectId,
-                    stage: "review_fix",
-                    status: "escalated",
-                    summary: interruptedMessage,
-                });
-                void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, interruptedMessage));
-                void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+                const recoveredIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+                if (recoveredState === "changes_requested") {
+                    this.db.upsertIssue({
+                        projectId: run.projectId,
+                        linearIssueId: run.linearIssueId,
+                        pendingRunType: retryRunType,
+                        pendingRunContextJson: retryContext ? JSON.stringify(retryContext) : null,
+                    });
+                    this.feed?.publish({
+                        level: "warn",
+                        kind: "workflow",
+                        issueKey: issue.issueKey,
+                        projectId: run.projectId,
+                        stage: run.runType,
+                        status: "retry_queued",
+                        summary: "Requested-changes run was interrupted; PatchRelay will retry from fresh GitHub truth",
+                    });
+                    this.enqueueIssue(run.projectId, run.linearIssueId);
+                }
+                else {
+                    this.feed?.publish({
+                        level: "error",
+                        kind: "workflow",
+                        issueKey: issue.issueKey,
+                        projectId: run.projectId,
+                        stage: run.runType,
+                        status: "escalated",
+                        summary: interruptedMessage,
+                    });
+                }
+                void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, interruptedMessage));
+                void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
                 this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
                 return;
             }

package/package.json

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