patchrelay 0.36.8 → 0.36.10

package/dist/run-recovery-service.js

@@ -1,18 +1,24 @@
 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;
     linearSync;
+    withHeldLease;
+    getHeldLease;
+    appendWakeEventWithLease;
     releaseLease;
     enqueueIssue;
     resolveBranchOwnerForStateTransition;
     feed;
-    constructor(db, logger, linearSync, releaseLease, enqueueIssue, resolveBranchOwnerForStateTransition, feed) {
+    constructor(db, logger, linearSync, withHeldLease, getHeldLease, appendWakeEventWithLease, releaseLease, enqueueIssue, resolveBranchOwnerForStateTransition, feed) {
         this.db = db;
         this.logger = logger;
         this.linearSync = linearSync;
+        this.withHeldLease = withHeldLease;
+        this.getHeldLease = getHeldLease;
+        this.appendWakeEventWithLease = appendWakeEventWithLease;
         this.releaseLease = releaseLease;
         this.enqueueIssue = enqueueIssue;
         this.resolveBranchOwnerForStateTransition = resolveBranchOwnerForStateTransition;
@@ -20,11 +26,11 @@ export class RunRecoveryService {
     }
     recoverOrEscalate(params) {
         const { issue, runType, reason } = params;
-        const fresh = this.db.getIssue(issue.projectId, issue.linearIssueId);
+        const fresh = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
         if (!fresh)
             return;
         if (params.isRequestedChangesRunType(runType)) {
-            const updated = params.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
                 this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
                 this.db.issueSessions.upsertIssueWithLease(lease, {
                     projectId: fresh.projectId,
@@ -54,7 +60,7 @@ export class RunRecoveryService {
             return;
         }
         if (fresh.prState === "merged") {
-            const updated = params.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
                 this.db.issueSessions.upsertIssueWithLease(lease, {
                     projectId: fresh.projectId,
                     linearIssueId: fresh.linearIssueId,
@@ -75,7 +81,7 @@ export class RunRecoveryService {
         }
         const attempts = fresh.zombieRecoveryAttempts + 1;
         if (attempts > DEFAULT_ZOMBIE_RECOVERY_BUDGET) {
-            const updated = params.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
                 this.db.issueSessions.upsertIssueWithLease(lease, {
                     projectId: fresh.projectId,
                     linearIssueId: fresh.linearIssueId,
@@ -102,14 +108,16 @@ 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;
             }
         }
-        const requeued = params.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+        const requeued = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
             this.db.issueSessions.upsertIssueWithLease(lease, {
                 projectId: fresh.projectId,
                 linearIssueId: fresh.linearIssueId,
@@ -118,7 +126,7 @@ export class RunRecoveryService {
                 zombieRecoveryAttempts: attempts,
                 lastZombieRecoveryAt: new Date().toISOString(),
             });
-            return params.appendWakeEventWithLease(lease, fresh, runType, undefined, `recovery:${attempts}`);
+            return this.appendWakeEventWithLease(lease, fresh, runType, undefined, `recovery:${attempts}`);
         });
         if (!requeued) {
             this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Skipping recovery re-enqueue after losing issue-session lease");
@@ -131,7 +139,7 @@ export class RunRecoveryService {
     escalate(params) {
         const { issue, runType, reason } = params;
         this.logger.warn({ issueKey: issue.issueKey, runType, reason }, "Escalating to human");
-        const escalated = params.withHeldLease(issue.projectId, issue.linearIssueId, (lease) => {
+        const escalated = this.withHeldLease(issue.projectId, issue.linearIssueId, (lease) => {
             if (issue.activeRunId) {
                 this.db.issueSessions.finishRunWithLease(lease, issue.activeRunId, { status: "released" });
             }
@@ -160,7 +168,7 @@ export class RunRecoveryService {
             status: "escalated",
             summary: `Escalated: ${reason}`,
         });
-        const escalatedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        const escalatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
         void this.linearSync.emitActivity(escalatedIssue, {
             type: "error",
             body: `PatchRelay needs human help to continue.\n\n${reason}`,
@@ -170,12 +178,12 @@ export class RunRecoveryService {
     }
     failRunAndClear(params) {
         const { run, message, nextState } = params;
-        const updated = params.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+        const updated = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
             this.db.runs.finishRun(run.id, { status: "failed", failureReason: message });
             if (nextState === "failed" || nextState === "escalated" || nextState === "awaiting_input" || nextState === "done") {
                 this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
             }
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: run.projectId,
                 linearIssueId: run.linearIssueId,
                 activeRunId: null,
@@ -183,7 +191,7 @@ export class RunRecoveryService {
             });
             const branchOwner = this.resolveBranchOwnerForStateTransition(nextState);
             if (branchOwner) {
-                const heldLease = params.getHeldLease(run.projectId, run.linearIssueId);
+                const heldLease = this.getHeldLease(run.projectId, run.linearIssueId);
                 if (heldLease) {
                     this.db.issueSessions.setBranchOwnerWithLease(heldLease, branchOwner);
                 }
@@ -196,7 +204,7 @@ export class RunRecoveryService {
         this.releaseLease(run.projectId, run.linearIssueId);
     }
     emitInterruptedFailure(runType, issue, message) {
-        const latest = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        const latest = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
         void this.linearSync.emitActivity(latest, buildRunFailureActivity(runType, message));
         void this.linearSync.syncSession(latest, { activeRunType: runType });
     }

package/dist/run-wake-planner.js

@@ -60,7 +60,7 @@ export class RunWakePlanner {
         });
         if (!updated)
             return issue;
-        return this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        return this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
     }
     budgetExceeded(issue, runType, isRequestedChangesRunType) {
         if (runType === "ci_repair" && issue.ciRepairAttempts >= DEFAULT_CI_REPAIR_BUDGET) {

package/dist/service.js

@@ -182,7 +182,7 @@ export class PatchRelayService {
         await this.runtime.stop();
     }
     async syncKnownAgentSessions() {
-        for (const issue of this.db.listIssues()) {
+        for (const issue of this.db.issues.listIssues()) {
             if (issue.factoryState === "done") {
                 continue;
             }
@@ -191,7 +191,7 @@ export class PatchRelayService {
                 : (() => {
                     const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
                     return recoveredAgentSessionId
-                        ? this.db.upsertIssue({
+                        ? this.db.issues.upsertIssue({
                             projectId: issue.projectId,
                             linearIssueId: issue.linearIssueId,
                             agentSessionId: recoveredAgentSessionId,
@@ -206,7 +206,7 @@ export class PatchRelayService {
         }
     }
     async recoverDelegatedIssueStateFromLinear() {
-        for (const issue of this.db.listIssuesWithAgentSessions()) {
+        for (const issue of this.db.issues.listIssuesWithAgentSessions()) {
             if (issue.factoryState === "done" || issue.activeRunId !== undefined) {
                 continue;
             }
@@ -222,7 +222,7 @@ export class PatchRelayService {
             if (!liveIssue) {
                 continue;
             }
-            this.db.replaceIssueDependencies({
+            this.db.issues.replaceIssueDependencies({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 blockers: liveIssue.blockedBy.map((blocker) => ({
@@ -234,11 +234,11 @@ export class PatchRelayService {
                 })),
             });
             const delegated = liveIssue.delegateId === installation.actorId;
-            const unresolvedBlockers = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+            const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const shouldRecoverAwaitingInput = delegated
                 && issue.factoryState === "awaiting_input"
                 && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
-            const updated = this.db.upsertIssue({
+            const updated = this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
@@ -520,7 +520,7 @@ export class PatchRelayService {
         });
     }
     async promptIssue(issueKey, text, source = "watch") {
-        const issue = this.db.getIssueByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
         // Publish to operator feed so all clients see the prompt
@@ -572,7 +572,7 @@ export class PatchRelayService {
         }
     }
     async stopIssue(issueKey) {
-        const issue = this.db.getIssueByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
         if (!issue.activeRunId)
@@ -613,7 +613,7 @@ export class PatchRelayService {
         return { stopped: true };
     }
     retryIssue(issueKey) {
-        const issue = this.db.getIssueByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
         if (issue.activeRunId)

package/dist/webhook-handler.js

@@ -190,17 +190,17 @@ export class WebhookHandler {
     }
     reconcileDependentReadiness(projectId, blockerLinearIssueId) {
         const newlyReady = [];
-        for (const dependent of this.db.listDependents(projectId, blockerLinearIssueId)) {
-            const issue = this.db.getIssue(projectId, dependent.linearIssueId);
+        for (const dependent of this.db.issues.listDependents(projectId, blockerLinearIssueId)) {
+            const issue = this.db.issues.getIssue(projectId, dependent.linearIssueId);
             if (!issue) {
                 continue;
             }
-            const unresolved = this.db.countUnresolvedBlockers(projectId, dependent.linearIssueId);
+            const unresolved = this.db.issues.countUnresolvedBlockers(projectId, dependent.linearIssueId);
             if (unresolved > 0) {
                 if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation"
                     && issue.activeRunId === undefined
                     && !this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
-                    this.db.upsertIssue({
+                    this.db.issues.upsertIssue({
                         projectId,
                         linearIssueId: dependent.linearIssueId,
                         pendingRunType: null,
@@ -213,7 +213,7 @@ export class WebhookHandler {
                 continue;
             }
             if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation") {
-                this.db.upsertIssue({
+                this.db.issues.upsertIssue({
                     projectId,
                     linearIssueId: dependent.linearIssueId,
                     pendingRunType: null,

package/dist/webhooks/agent-session-handler.js

@@ -24,24 +24,24 @@ export class AgentSessionHandler {
         const linear = await this.linearProvider.forProject(project.id);
         if (!linear)
             return;
-        const existingIssue = this.db.getIssue(project.id, normalized.issue.id);
+        const existingIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
         if (normalized.triggerEvent === "agentSessionCreated") {
             if (!delegated) {
-                const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+                const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
                 if (latestIssue ?? trackedIssue) {
                     await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType);
                 }
                 return;
             }
             if (wakeRunType) {
-                const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+                const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
                 await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { pendingRunType: wakeRunType });
                 await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(wakeRunType));
                 return;
             }
             if (activeRun) {
-                const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+                const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
                 await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { activeRunType: activeRun.runType });
                 await this.publishAgentActivity(linear, normalized.agentSession.id, buildAlreadyRunningThought(activeRun.runType));
                 return;
@@ -115,13 +115,13 @@ export class AgentSessionHandler {
             const queuedRunType = hadPendingWake
                 ? params.peekPendingSessionWakeRunType(project.id, normalized.issue.id)
                 : params.enqueuePendingSessionWake(project.id, normalized.issue.id);
-            const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+            const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
             await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { pendingRunType: queuedRunType ?? wakeRunType ?? (existingIssue.prReviewState === "changes_requested" ? "review_fix" : "implementation") });
             await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(queuedRunType ?? wakeRunType ?? "implementation"), { ephemeral: true });
             return;
         }
         if (wakeRunType) {
-            const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+            const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
             await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { pendingRunType: wakeRunType });
             await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(wakeRunType, "prompt"), { ephemeral: true });
         }
@@ -165,7 +165,7 @@ export class AgentSessionHandler {
             status: "stopped",
             summary: "Stop signal received - work halted",
         });
-        const updatedIssue = this.db.getIssue(params.project.id, issueId);
+        const updatedIssue = this.db.issues.getIssue(params.project.id, issueId);
         await this.publishAgentActivity(params.linear, sessionId, buildStopConfirmationActivity());
         await params.syncAgentSession(sessionId, updatedIssue ?? params.trackedIssue);
     }

package/dist/webhooks/comment-wake-handler.js

@@ -21,7 +21,7 @@ export class CommentWakeHandler {
         }
         if (!triggerEventAllowed(project, normalized.triggerEvent))
             return;
-        const issue = this.db.getIssue(project.id, normalized.issue.id);
+        const issue = this.db.issues.getIssue(project.id, normalized.issue.id);
         if (!issue)
             return;
         const trimmedBody = normalized.comment.body.trim();

package/dist/webhooks/desired-stage-recorder.js

@@ -14,7 +14,7 @@ export class DesiredStageRecorder {
         if (!normalizedIssue) {
             return { issue: undefined, wakeRunType: undefined, delegated: false };
         }
-        const existingIssue = this.db.getIssue(params.project.id, normalizedIssue.id);
+        const existingIssue = this.db.issues.getIssue(params.project.id, normalizedIssue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
         const delegated = this.isDelegatedToPatchRelay(params.project, params.normalized);
         const triggerAllowed = triggerEventAllowed(params.project, params.normalized.triggerEvent);
@@ -24,7 +24,7 @@ export class DesiredStageRecorder {
             return { issue: undefined, wakeRunType: undefined, delegated };
         }
         const hydratedIssue = await this.syncIssueDependencies(params.project.id, normalizedIssue);
-        const unresolvedBlockers = this.db.countUnresolvedBlockers(params.project.id, normalizedIssue.id);
+        const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(params.project.id, normalizedIssue.id);
         const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
         const desiredStage = decideRunIntent({
             delegated,
@@ -62,7 +62,7 @@ export class DesiredStageRecorder {
             delegated,
         });
         const commitIssueUpdate = () => {
-            const record = this.db.upsertIssue({
+            const record = this.db.issues.upsertIssue({
                 projectId: params.project.id,
                 linearIssueId: normalizedIssue.id,
                 ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
@@ -88,7 +88,7 @@ export class DesiredStageRecorder {
         };
         const activeLease = this.db.issueSessions.getActiveIssueSessionLease(params.project.id, normalizedIssue.id);
         const issue = activeLease
-            ? this.db.issueSessions.withIssueSessionLease(params.project.id, normalizedIssue.id, activeLease.leaseId, commitIssueUpdate) ?? (existingIssue ?? this.db.upsertIssue({
+            ? this.db.issueSessions.withIssueSessionLease(params.project.id, normalizedIssue.id, activeLease.leaseId, commitIssueUpdate) ?? (existingIssue ?? this.db.issues.upsertIssue({
                 projectId: params.project.id,
                 linearIssueId: normalizedIssue.id,
                 ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
@@ -160,7 +160,7 @@ export class DesiredStageRecorder {
             }
         }
         if (source.relationsKnown) {
-            this.db.replaceIssueDependencies({
+            this.db.issues.replaceIssueDependencies({
                 projectId,
                 linearIssueId: source.id,
                 blockers: source.blockedBy.map((blocker) => ({

package/dist/webhooks/issue-removal-handler.js

@@ -9,7 +9,7 @@ export class IssueRemovalHandler {
     async handle(params) {
         if (!params.trackedIssue)
             return;
-        const removedIssue = this.db.getIssue(params.projectId, params.issue.id);
+        const removedIssue = this.db.issues.getIssue(params.projectId, params.issue.id);
         const activeLease = this.db.issueSessions.getActiveIssueSessionLease(params.projectId, params.issue.id);
         const commitRemoval = () => {
             if (removedIssue?.activeRunId) {
@@ -17,7 +17,7 @@ export class IssueRemovalHandler {
                 if (run) {
                     this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue removed from Linear" });
                 }
-                return this.db.upsertIssue({
+                return this.db.issues.upsertIssue({
                     projectId: params.projectId,
                     linearIssueId: params.issue.id,
                     activeRunId: null,
@@ -26,7 +26,7 @@ export class IssueRemovalHandler {
                 });
             }
             if (removedIssue && !TERMINAL_STATES.has(removedIssue.factoryState)) {
-                return this.db.upsertIssue({
+                return this.db.issues.upsertIssue({
                     projectId: params.projectId,
                     linearIssueId: params.issue.id,
                     pendingRunType: null,

package/dist/worktree-manager.js

@@ -6,6 +6,75 @@ export class WorktreeManager {
     constructor(config) {
         this.config = config;
     }
+    async freshenWorktree(worktreePath, project, issue, logger) {
+        const gitBin = this.config.runner.gitBin;
+        const baseBranch = project.github?.baseBranch ?? "main";
+        const stashResult = await execCommand(gitBin, ["-C", worktreePath, "stash"], { timeoutMs: 30_000 });
+        const didStash = stashResult.exitCode === 0 && !stashResult.stdout?.includes("No local changes");
+        const fetchResult = await execCommand(gitBin, ["-C", worktreePath, "fetch", "origin", baseBranch], { timeoutMs: 60_000 });
+        if (fetchResult.exitCode !== 0) {
+            logger?.warn({ issueKey: issue.issueKey, stderr: fetchResult.stderr?.slice(0, 300) }, "Pre-run fetch failed, proceeding with current base");
+            if (didStash)
+                await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+            return;
+        }
+        const mergeBaseResult = await execCommand(gitBin, ["-C", worktreePath, "merge-base", "--is-ancestor", `origin/${baseBranch}`, "HEAD"], { timeoutMs: 10_000 });
+        if (mergeBaseResult.exitCode === 0) {
+            logger?.debug({ issueKey: issue.issueKey }, "Pre-run freshen: branch already up to date");
+            if (didStash)
+                await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+            return;
+        }
+        const rebaseResult = await execCommand(gitBin, ["-C", worktreePath, "rebase", `origin/${baseBranch}`], { timeoutMs: 120_000 });
+        if (rebaseResult.exitCode !== 0) {
+            await execCommand(gitBin, ["-C", worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
+            if (didStash)
+                await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+            logger?.warn({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebase conflict, agent will resolve");
+            return;
+        }
+        logger?.info({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebased locally onto latest base");
+        if (didStash)
+            await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+    }
+    async resetWorktreeToTrackedBranch(worktreePath, branchName, issue, logger) {
+        const gitBin = this.config.runner.gitBin;
+        const branchFetch = await execCommand(gitBin, ["-C", worktreePath, "fetch", "origin", branchName], { timeoutMs: 60_000 });
+        const hasRemoteBranch = branchFetch.exitCode === 0;
+        await execCommand(gitBin, ["-C", worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "merge", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "cherry-pick", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "am", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "reset", "--hard", "HEAD"], { timeoutMs: 30_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "clean", "-fd"], { timeoutMs: 30_000 });
+        const checkoutTarget = hasRemoteBranch ? `origin/${branchName}` : branchName;
+        const checkoutResult = await execCommand(gitBin, ["-C", worktreePath, "checkout", "-B", branchName, checkoutTarget], { timeoutMs: 30_000 });
+        if (checkoutResult.exitCode !== 0) {
+            throw new Error(`Failed to restore ${branchName} worktree state: ${checkoutResult.stderr?.slice(0, 300) ?? "git checkout failed"}`);
+        }
+        const resetTarget = hasRemoteBranch ? `origin/${branchName}` : "HEAD";
+        const resetResult = await execCommand(gitBin, ["-C", worktreePath, "reset", "--hard", resetTarget], { timeoutMs: 30_000 });
+        if (resetResult.exitCode !== 0) {
+            throw new Error(`Failed to reset ${branchName} worktree state: ${resetResult.stderr?.slice(0, 300) ?? "git reset failed"}`);
+        }
+        await execCommand(gitBin, ["-C", worktreePath, "clean", "-fd"], { timeoutMs: 30_000 });
+        logger?.debug({ issueKey: issue.issueKey, branchName, hasRemoteBranch }, "Reset issue worktree to tracked branch state");
+    }
+    async restoreIdleWorktree(issue, logger) {
+        if (!issue.worktreePath || !issue.branchName)
+            return;
+        try {
+            await this.resetWorktreeToTrackedBranch(issue.worktreePath, issue.branchName, issue, logger);
+        }
+        catch (error) {
+            logger?.warn({
+                issueKey: issue.issueKey,
+                branchName: issue.branchName,
+                worktreePath: issue.worktreePath,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to restore idle worktree after interrupted run");
+        }
+    }
     async ensureIssueWorktree(repoPath, worktreeRoot, worktreePath, branchName, options) {
         if (existsSync(worktreePath)) {
             await this.assertTrustedExistingWorktree(repoPath, worktreeRoot, worktreePath, options);

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.8",
+  "version": "0.36.10",
   "license": "MIT",
   "type": "module",
   "repository": {