patchrelay 0.36.3 → 0.36.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.3",
-  "commit": "e132192dca38",
-  "builtAt": "2026-04-08T23:42:01.882Z"
+  "version": "0.36.5",
+  "commit": "1f30d4407cf6",
+  "builtAt": "2026-04-09T08:27:55.606Z"
 }

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

@@ -491,6 +491,25 @@ 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, {

package/dist/issue-session.js

@@ -79,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;
@@ -134,6 +134,34 @@ function appendTaskObjective(lines, issue) {
     }
     lines.push("");
 }
+function extractIssueSection(description, heading) {
+    if (!description)
+        return undefined;
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^## ${escaped}\\s*$([\\s\\S]*?)(?=^##\\s+|$)`, "im");
+    const match = description.match(pattern);
+    const body = match?.[1]?.trim();
+    return body && body.length > 0 ? body : undefined;
+}
+function appendScopeDiscipline(lines, issue) {
+    const description = issue.description?.trim();
+    const scope = extractIssueSection(description, "Scope");
+    const acceptance = extractIssueSection(description, "Acceptance criteria")
+        ?? extractIssueSection(description, "Success criteria");
+    const relevantCode = extractIssueSection(description, "Relevant code");
+    lines.push("## Scope Discipline", "");
+    lines.push("Stay inside the delegated task.", "Finish the issue completely enough to satisfy its stated scope and acceptance criteria, but do not widen it into unrelated product polish or follow-up cleanup.", "Only broaden to adjacent routes, copy, or supporting surfaces when the issue text or repository guidance explicitly says they are the same user flow.", "If you notice a worthwhile broader inconsistency that is not required to make this task correct, mention it in your summary as follow-up context instead of expanding the implementation.", "");
+    if (scope) {
+        lines.push("### In Scope", "", scope, "");
+    }
+    if (acceptance) {
+        lines.push("### Acceptance / Done", "", acceptance, "");
+    }
+    if (relevantCode) {
+        lines.push("### Relevant Code", "", relevantCode, "");
+    }
+    lines.push("### Likely Review Invariants", "", "- Check the surfaces explicitly named in the task before stopping.", "- If repository guidance says certain changed surfaces are one flow, verify that shared flow, but do not treat unrelated surrounding cleanup as part of this task.", "- A review repair should fix the concrete concern on the current head, not silently expand the Linear issue into a broader rewrite.", "");
+}
 function appendLinearContext(lines, context) {
     const promptContext = typeof context?.promptContext === "string" ? context.promptContext.trim() : "";
     const latestPrompt = typeof context?.promptBody === "string" ? context.promptBody.trim() : "";
@@ -404,6 +432,7 @@ function appendRequestedChangesInstructions(lines, runType, context) {
 export function buildInitialRunPrompt(issue, runType, repoPath, context) {
     const lines = buildPromptHeader(issue);
     appendTaskObjective(lines, issue);
+    appendScopeDiscipline(lines, issue);
     appendLinearContext(lines, context);
     // Add run-type-specific context for reactive runs
     switch (runType) {
@@ -440,6 +469,8 @@ export function buildInitialRunPrompt(issue, runType, repoPath, context) {
 export function buildFollowUpRunPrompt(issue, runType, repoPath, context) {
     const lines = buildPromptHeader(issue);
     appendFollowUpPromptPrelude(lines, issue, runType, context);
+    appendTaskObjective(lines, issue);
+    appendScopeDiscipline(lines, issue);
     // Add run-type-specific context for reactive runs
     switch (runType) {
         case "ci_repair": {
@@ -636,8 +667,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 +686,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 +1498,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 +1514,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.3",
+  "version": "0.36.5",
   "license": "MIT",
   "type": "module",
   "repository": {