patchrelay 0.36.9 → 0.36.10

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.9",
-  "commit": "0fdde7c6ee50",
-  "builtAt": "2026-04-09T13:31:10.488Z"
+  "version": "0.36.10",
+  "commit": "35d99f024954",
+  "builtAt": "2026-04-09T16:10:38.473Z"
 }

package/dist/cli/data.js

@@ -221,6 +221,7 @@ export class CliDataAccess extends CliOperatorApiClient {
             .reverse()
             .map((run) => {
             const summary = summarizeRun(run);
+            const eventCount = this.db.runs.listThreadEvents(run.id).length;
             return {
                 runId: run.id,
                 runType: run.runType,
@@ -230,7 +231,8 @@ export class CliDataAccess extends CliOperatorApiClient {
                 ...(run.parentThreadId ? { parentThreadId: run.parentThreadId } : {}),
                 ...(summary ? { summary } : {}),
                 ...(run.failureReason ? { failureReason: run.failureReason } : {}),
-                eventCount: this.db.runs.listThreadEvents(run.id).length,
+                eventCount,
+                eventCountAvailable: this.config.runner.codex.persistExtendedHistory || eventCount > 0,
                 startedAt: run.startedAt,
                 ...(run.endedAt ? { endedAt: run.endedAt } : {}),
                 isCurrentThread: run.threadId !== undefined && run.threadId === dbIssue.threadId,

package/dist/cli/formatters/text.js

@@ -106,7 +106,9 @@ export function formatSessionHistory(result, buildOpenForThread) {
         if (session.turnId) {
             lines.push(value("Turn", session.turnId));
         }
-        lines.push(value("Events", session.eventCount));
+        lines.push(value("Events", session.eventCountAvailable
+            ? session.eventCount
+            : "not persisted (persistExtendedHistory=false)"));
         if (session.summary) {
             lines.push(value("Summary", truncateLine(session.summary)));
         }

package/dist/github-webhook-handler.js

@@ -136,6 +136,7 @@ export class GitHubWebhookHandler {
             return;
         }
         const project = this.config.projects.find((p) => p.id === issue.projectId);
+        const immediateCheckStatus = this.deriveImmediatePrCheckStatus(issue, event, project);
         // Update PR state on the issue
         this.db.issues.upsertIssue({
             projectId: issue.projectId,
@@ -146,7 +147,7 @@ export class GitHubWebhookHandler {
             ...(event.headSha !== undefined ? { prHeadSha: event.headSha } : {}),
             ...(event.prAuthorLogin !== undefined ? { prAuthorLogin: event.prAuthorLogin } : {}),
             ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
-            ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
+            ...(immediateCheckStatus !== undefined ? { prCheckStatus: immediateCheckStatus } : {}),
             ...(event.reviewState === "changes_requested"
                 ? { lastBlockingReviewHeadSha: event.reviewCommitId ?? event.headSha ?? null }
                 : event.reviewState === "approved"
@@ -730,6 +731,21 @@ export class GitHubWebhookHandler {
         const normalized = event.checkName.trim().toLowerCase();
         return this.getGateCheckNames(project).some((entry) => entry.trim().toLowerCase() === normalized);
     }
+    deriveImmediatePrCheckStatus(issue, event, project) {
+        if (event.triggerEvent === "pr_synchronize") {
+            return "pending";
+        }
+        if (event.eventSource !== "check_run") {
+            return undefined;
+        }
+        if (!this.isGateCheckEvent(event, project)) {
+            return undefined;
+        }
+        if (this.isStaleGateEvent(issue, event)) {
+            return undefined;
+        }
+        return event.checkStatus;
+    }
     isStaleGateEvent(issue, event) {
         return Boolean(issue.lastGitHubCiSnapshotHeadSha
             && event.headSha

package/dist/idle-reconciliation.js

@@ -4,6 +4,7 @@ import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { execCommand } from "./utils.js";
+const DEFAULT_REVIEW_FIX_BUDGET = 12;
 function isFailingCheckStatus(status) {
     return status === "failed" || status === "failure";
 }
@@ -493,6 +494,16 @@ export class IdleIssueReconciler {
             });
             if ((issue.factoryState === "escalated" || issue.factoryState === "failed")
                 && (reactiveIntent?.runType === "review_fix" || reactiveIntent?.runType === "branch_upkeep")) {
+                if (issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+                    this.logger.debug({
+                        issueKey: issue.issueKey,
+                        prNumber: issue.prNumber,
+                        from: issue.factoryState,
+                        runType: reactiveIntent.runType,
+                        reviewFixAttempts: issue.reviewFixAttempts,
+                    }, "Reconciliation: leaving terminal requested-changes issue escalated because the repair budget is exhausted");
+                    return;
+                }
                 const pendingRunContext = reactiveIntent.runType === "branch_upkeep"
                     ? buildBranchUpkeepContext(issue.prNumber, project.github?.baseBranch ?? "main", pr.mergeStateStatus, pr.headRefOid)
                     : undefined;

package/dist/run-orchestrator.js

@@ -14,12 +14,20 @@ import { RunFinalizer } from "./run-finalizer.js";
 import { RunLauncher } from "./run-launcher.js";
 import { RunRecoveryService } from "./run-recovery-service.js";
 import { RunWakePlanner } from "./run-wake-planner.js";
+import { getRemainingZombieRecoveryDelayMs } from "./zombie-recovery.js";
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
 }
 function isRequestedChangesRunType(runType) {
     return runType === "review_fix" || runType === "branch_upkeep";
 }
+function shouldDelayZombieRecoveryLaunch(issue, issueSession, runType) {
+    if (issue.zombieRecoveryAttempts <= 0)
+        return 0;
+    if (issueSession?.lastRunType !== runType)
+        return 0;
+    return getRemainingZombieRecoveryDelayMs(issue.lastZombieRecoveryAt, issue.zombieRecoveryAttempts);
+}
 export class RunOrchestrator {
     config;
     db;
@@ -108,6 +116,12 @@ export class RunOrchestrator {
             return;
         }
         const { runType, context, resumeThread } = wake;
+        const remainingZombieDelayMs = shouldDelayZombieRecoveryLaunch(issue, issueSession, runType);
+        if (remainingZombieDelayMs > 0) {
+            this.logger.debug({ issueKey: issue.issueKey, runType, remainingZombieDelayMs }, "Deferring recovered run launch until zombie backoff elapses");
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
+            return;
+        }
         const effectiveContext = isRequestedChangesRunType(runType)
             ? await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context)
             : context;

package/dist/run-recovery-service.js

@@ -1,6 +1,6 @@
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
+import { getRemainingZombieRecoveryDelayMs } from "./zombie-recovery.js";
 const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
-const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000;
 export class RunRecoveryService {
     db;
     logger;
@@ -108,10 +108,12 @@ export class RunRecoveryService {
             return;
         }
         if (fresh.lastZombieRecoveryAt) {
-            const elapsed = Date.now() - new Date(fresh.lastZombieRecoveryAt).getTime();
-            const delay = ZOMBIE_RECOVERY_BASE_DELAY_MS * Math.pow(2, fresh.zombieRecoveryAttempts);
-            if (elapsed < delay) {
-                this.logger.debug({ issueKey: fresh.issueKey, attempts: fresh.zombieRecoveryAttempts, delay, elapsed }, "Recovery: backoff not elapsed, skipping");
+            const remainingDelayMs = getRemainingZombieRecoveryDelayMs(fresh.lastZombieRecoveryAt, fresh.zombieRecoveryAttempts);
+            if (remainingDelayMs > 0) {
+                this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                    this.appendWakeEventWithLease(lease, fresh, runType, undefined, `recovery:${attempts}`);
+                });
+                this.logger.debug({ issueKey: fresh.issueKey, attempts: fresh.zombieRecoveryAttempts, remainingDelayMs }, "Recovery: backoff not elapsed, deferring retry");
                 return;
             }
         }

package/dist/zombie-recovery.js

@@ -0,0 +1,13 @@
+const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000;
+export function getZombieRecoveryDelayMs(recoveryAttempts) {
+    return ZOMBIE_RECOVERY_BASE_DELAY_MS * Math.pow(2, recoveryAttempts);
+}
+export function getRemainingZombieRecoveryDelayMs(lastRecoveryAt, recoveryAttempts, now = Date.now()) {
+    if (!lastRecoveryAt)
+        return 0;
+    const recoveredAtMs = Date.parse(lastRecoveryAt);
+    if (!Number.isFinite(recoveredAtMs))
+        return 0;
+    const delay = getZombieRecoveryDelayMs(recoveryAttempts);
+    return Math.max(0, recoveredAtMs + delay - now);
+}

package/package.json

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