patchrelay 0.23.4 → 0.23.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.23.4",
-  "commit": "650e9c85fdcf",
-  "builtAt": "2026-03-26T13:49:43.718Z"
+  "version": "0.23.5",
+  "commit": "65abb29863f7",
+  "builtAt": "2026-03-26T16:08:25.878Z"
 }

package/dist/db/migrations.js

@@ -141,6 +141,9 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "description", "TEXT");
     addColumnIfMissing(connection, "issues", "priority", "INTEGER");
     addColumnIfMissing(connection, "issues", "estimate", "REAL");
+    // Zombie/stale recovery backoff
+    addColumnIfMissing(connection, "issues", "zombie_recovery_attempts", "INTEGER NOT NULL DEFAULT 0");
+    addColumnIfMissing(connection, "issues", "last_zombie_recovery_at", "TEXT");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/db.js

@@ -173,6 +173,14 @@ export class PatchRelayDatabase {
                 sets.push("pending_merge_prep = @pendingMergePrep");
                 values.pendingMergePrep = params.pendingMergePrep ? 1 : 0;
             }
+            if (params.zombieRecoveryAttempts !== undefined) {
+                sets.push("zombie_recovery_attempts = @zombieRecoveryAttempts");
+                values.zombieRecoveryAttempts = params.zombieRecoveryAttempts;
+            }
+            if (params.lastZombieRecoveryAt !== undefined) {
+                sets.push("last_zombie_recovery_at = @lastZombieRecoveryAt");
+                values.lastZombieRecoveryAt = params.lastZombieRecoveryAt;
+            }
             this.connection.prepare(`UPDATE issues SET ${sets.join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`).run(values);
         }
         else {
@@ -424,6 +432,8 @@ function mapIssueRow(row) {
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
         mergePrepAttempts: Number(row.merge_prep_attempts ?? 0),
         pendingMergePrep: Boolean(row.pending_merge_prep),
+        zombieRecoveryAttempts: Number(row.zombie_recovery_attempts ?? 0),
+        ...(row.last_zombie_recovery_at !== null && row.last_zombie_recovery_at !== undefined ? { lastZombieRecoveryAt: String(row.last_zombie_recovery_at) } : {}),
     };
 }
 function mapRunRow(row) {

package/dist/github-webhook-handler.js

@@ -1,4 +1,4 @@
-import { resolveFactoryStateFromGitHub } from "./factory-state.js";
+import { resolveFactoryStateFromGitHub, TERMINAL_STATES } from "./factory-state.js";
 import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
@@ -202,6 +202,10 @@ export class GitHubWebhookHandler {
         // Don't trigger if there's already an active run
         if (issue.activeRunId !== undefined)
             return;
+        // Don't trigger on terminal issues — late-arriving webhooks (e.g.
+        // merge_group_failed after pr_merged) must not resurrect done issues.
+        if (TERMINAL_STATES.has(issue.factoryState))
+            return;
         if (event.triggerEvent === "check_failed" && issue.prState === "open") {
             this.db.upsertIssue({
                 projectId: issue.projectId,

package/dist/run-orchestrator.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { ACTIVE_RUN_STATES } from "./factory-state.js";
+import { ACTIVE_RUN_STATES, TERMINAL_STATES } from "./factory-state.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
@@ -12,6 +12,8 @@ import { execCommand } from "./utils.js";
 const DEFAULT_CI_REPAIR_BUDGET = 3;
 const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
 const DEFAULT_REVIEW_FIX_BUDGET = 3;
+const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
+const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000; // 15s, 30s, 60s, 120s, 240s
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -191,7 +193,10 @@ export class RunOrchestrator {
             // Freshen the worktree: fetch + rebase onto latest base branch.
             // This prevents branch contamination when local main has drifted
             // and avoids scope-bundling review rejections from stale commits.
-            await this.freshenWorktree(worktreePath, project, issue);
+            // Skip for queue_repair — its entire purpose is to resolve rebase conflicts.
+            if (runType !== "queue_repair") {
+                await this.freshenWorktree(worktreePath, project, issue);
+            }
             // Run prepare-worktree hook
             const hookEnv = buildHookEnv(issue.issueKey ?? issue.linearIssueId, branchName, runType, worktreePath);
             const prepareResult = await runProjectHook(project.repoPath, "prepare-worktree", { cwd: worktreePath, env: hookEnv });
@@ -244,6 +249,15 @@ export class RunOrchestrator {
             throw error;
         }
         this.db.updateRunThread(run.id, { threadId, turnId });
+        // Reset zombie recovery counter — this run started successfully
+        if (issue.zombieRecoveryAttempts > 0) {
+            this.db.upsertIssue({
+                projectId: item.projectId,
+                linearIssueId: item.issueId,
+                zombieRecoveryAttempts: 0,
+                lastZombieRecoveryAt: null,
+            });
+        }
         this.logger.info({ issueKey: issue.issueKey, runType, threadId, turnId }, `Started ${runType} run`);
         // Emit Linear activity + plan
         const freshIssue = this.db.getIssue(item.projectId, item.issueId) ?? issue;
@@ -286,11 +300,14 @@ export class RunOrchestrator {
         // Rebase onto latest base
         const rebaseResult = await execCommand(gitBin, ["-C", worktreePath, "rebase", `origin/${baseBranch}`], { timeoutMs: 120_000 });
         if (rebaseResult.exitCode !== 0) {
-            // Abort the failed rebase and restore state
+            // Abort the failed rebase and restore state — then let the agent run
+            // proceed. The agent can resolve the conflict itself (the workflow
+            // prompt tells it to rebase and handle conflicts).
             await execCommand(gitBin, ["-C", worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
             if (didStash)
                 await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
-            throw new Error(`Pre-run rebase onto origin/${baseBranch} failed with conflicts — escalate or resolve manually`);
+            this.logger.warn({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebase conflict, agent will resolve");
+            return;
         }
         // Push the rebased branch (force-with-lease to protect against concurrent pushes)
         const pushResult = await execCommand(gitBin, ["-C", worktreePath, "push", "--force-with-lease"], { timeoutMs: 60_000 });
@@ -563,26 +580,91 @@ export class RunOrchestrator {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }
+    /**
+     * After a zombie/stale run is cleared, decide whether to re-enqueue
+     * or escalate. Checks: PR already merged → done; budget exhausted →
+     * escalate; backoff delay not elapsed → skip.
+     */
+    recoverOrEscalate(issue, runType, reason) {
+        // Re-read issue after the run was cleared (activeRunId is now null)
+        const fresh = this.db.getIssue(issue.projectId, issue.linearIssueId);
+        if (!fresh)
+            return;
+        // If PR already merged, transition to done — no retry needed
+        if (fresh.prState === "merged") {
+            this.db.upsertIssue({
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                factoryState: "done",
+                zombieRecoveryAttempts: 0,
+                lastZombieRecoveryAt: null,
+            });
+            this.logger.info({ issueKey: fresh.issueKey, reason }, "Recovery: PR already merged — transitioning to done");
+            return;
+        }
+        // Budget check
+        const attempts = fresh.zombieRecoveryAttempts + 1;
+        if (attempts > DEFAULT_ZOMBIE_RECOVERY_BUDGET) {
+            this.db.upsertIssue({
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                factoryState: "escalated",
+            });
+            this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: budget exhausted — escalating");
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: fresh.issueKey,
+                projectId: fresh.projectId,
+                stage: "escalated",
+                status: "budget_exhausted",
+                summary: `${reason} recovery failed after ${DEFAULT_ZOMBIE_RECOVERY_BUDGET} attempts`,
+            });
+            return;
+        }
+        // Exponential backoff — skip if delay hasn't elapsed
+        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");
+                return;
+            }
+        }
+        // Re-enqueue with backoff tracking
+        this.db.upsertIssue({
+            projectId: fresh.projectId,
+            linearIssueId: fresh.linearIssueId,
+            pendingRunType: runType,
+            pendingRunContextJson: null,
+            zombieRecoveryAttempts: attempts,
+            lastZombieRecoveryAt: new Date().toISOString(),
+        });
+        this.enqueueIssue(fresh.projectId, fresh.linearIssueId);
+        this.logger.info({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: re-enqueued with backoff");
+    }
     async reconcileRun(run) {
         const issue = this.db.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
             return;
+        // If the issue reached a terminal state while this run was active
+        // (e.g. pr_merged processed, DB manually edited), just release the run.
+        if (TERMINAL_STATES.has(issue.factoryState)) {
+            this.db.transaction(() => {
+                this.db.finishRun(run.id, { status: "released", failureReason: "Issue reached terminal state during active run" });
+                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
+            });
+            this.logger.info({ issueKey: issue.issueKey, runId: run.id, factoryState: issue.factoryState }, "Reconciliation: released run on terminal issue");
+            return;
+        }
         // Zombie run: claimed in DB but Codex never started (no thread).
-        // This happens when the service crashes between claiming the run
-        // and starting the Codex turn. Re-enqueue instead of failing.
         if (!run.threadId) {
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread) — clearing and re-enqueueing");
+            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
             this.db.transaction(() => {
                 this.db.finishRun(run.id, { status: "failed", failureReason: "Zombie: never started (no thread after restart)" });
-                this.db.upsertIssue({
-                    projectId: run.projectId,
-                    linearIssueId: run.linearIssueId,
-                    activeRunId: null,
-                    pendingRunType: run.runType,
-                    pendingRunContextJson: null,
-                });
+                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.enqueueIssue(run.projectId, run.linearIssueId);
+            this.recoverOrEscalate(issue, run.runType, "zombie");
             return;
         }
         // Read Codex state — thread may not exist after app-server restart.
@@ -591,18 +673,12 @@ export class RunOrchestrator {
             thread = await this.readThreadWithRetry(run.threadId);
         }
         catch {
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation — clearing and re-enqueueing");
+            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
             this.db.transaction(() => {
                 this.db.finishRun(run.id, { status: "failed", failureReason: "Stale thread after restart" });
-                this.db.upsertIssue({
-                    projectId: run.projectId,
-                    linearIssueId: run.linearIssueId,
-                    activeRunId: null,
-                    pendingRunType: run.runType,
-                    pendingRunContextJson: null,
-                });
+                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.enqueueIssue(run.projectId, run.linearIssueId);
+            this.recoverOrEscalate(issue, run.runType, "stale_thread");
             return;
         }
         // Check Linear state (non-fatal — token refresh may fail)

package/dist/worktree-manager.js

@@ -12,7 +12,13 @@ export class WorktreeManager {
             return;
         }
         await ensureDir(path.dirname(worktreePath));
-        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "worktree", "add", "--force", "-B", branchName, worktreePath, "HEAD"], {
+        // Fetch latest main so the branch forks from a clean, up-to-date base.
+        // This prevents branch contamination when local HEAD has drifted.
+        // freshenWorktree in run-orchestrator acts as a secondary safety net.
+        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "fetch", "origin", "main"], {
+            timeoutMs: 60_000,
+        });
+        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "worktree", "add", "--force", "-B", branchName, worktreePath, "origin/main"], {
             timeoutMs: 120_000,
         });
     }

package/package.json

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