patchrelay 0.76.0 → 0.78.0

package/dist/pr-facts-derivation.js

@@ -0,0 +1,81 @@
+import { resolveFactoryStateFromGitHub } from "./factory-state.js";
+import { isFailingCheckStatus, isReviewDecisionApproved, isReviewDecisionReviewRequired, } from "./idle-reconciliation-helpers.js";
+/**
+ * Pure factory-state derivation shared by the webhook projector and the idle
+ * reconciler. Returns the state the issue should move to, or `undefined`
+ * when the observation is a no-op for the current state.
+ */
+export function deriveFactoryStateFromPrFacts(observed, current) {
+    if (observed.triggerEvent !== undefined) {
+        return deriveFromTriggerEvent(observed.triggerEvent, observed, current);
+    }
+    return deriveFromPolledLevel(observed, current);
+}
+// ── Delta observations (webhook trigger events) ─────────────────────
+// The transition-rule table in factory-state.ts is the spec; this wrapper
+// adds the awaiting_input/delegated lifting that the webhook path applies
+// before consulting the table.
+function deriveFromTriggerEvent(triggerEvent, observed, current) {
+    if (triggerEvent === "pr_closed") {
+        // The terminal-PR handler owns the closed-PR decision on the webhook path.
+        return undefined;
+    }
+    const effectiveCurrentState = (current.factoryState === "awaiting_input" || current.factoryState === "delegated")
+        && (observed.prState === "open" || observed.prNumber !== undefined)
+        ? "pr_open"
+        : current.factoryState;
+    const resolved = resolveFactoryStateFromGitHub(triggerEvent, effectiveCurrentState, {
+        prReviewState: current.prReviewState,
+        activeRunId: current.activeRunId,
+        failureSource: observed.failureSource,
+        ...(current.activeRunType ? { activeRunType: current.activeRunType } : {}),
+        ...(current.activeRunSourceHeadSha ? { activeRunSourceHeadSha: current.activeRunSourceHeadSha } : {}),
+        ...(observed.approvalHeadSha ? { approvalHeadSha: observed.approvalHeadSha } : {}),
+    });
+    if (resolved !== undefined) {
+        return resolved;
+    }
+    if (effectiveCurrentState !== current.factoryState) {
+        return effectiveCurrentState;
+    }
+    return undefined;
+}
+// ── Level observations (polled snapshot) ────────────────────────────
+function deriveFromPolledLevel(observed, current) {
+    if (observed.prState === "closed") {
+        if (observed.closedPrDisposition === "done")
+            return "done";
+        if (observed.closedPrDisposition === "terminal")
+            return undefined;
+        return "delegated";
+    }
+    if (observed.prState === "merged") {
+        // Mirrors the pr_merged transition rule: with an active run the
+        // finalizer owns the completion; deploy tracking may map "done" to
+        // "deploying" at the call site.
+        return current.activeRunId === undefined ? "done" : undefined;
+    }
+    if (current.factoryState === "escalated" || current.factoryState === "failed") {
+        // Terminal recovery: newer GitHub truth reopens a stuck terminal issue.
+        // No fall-through to the generic approved rule — an escalated issue with
+        // a red gate stays escalated (the failure provenance keeps the repair
+        // routable; auto-reopening would swallow it).
+        if (isReviewDecisionApproved(observed.reviewDecision) && !isFailingCheckStatus(observed.gateCheckStatus)) {
+            return "awaiting_queue";
+        }
+        if (observed.gateCheckStatus === "pending") {
+            return "pr_open";
+        }
+        if (observed.headAdvanced && !isFailingCheckStatus(observed.gateCheckStatus)) {
+            return "pr_open";
+        }
+        if (isReviewDecisionReviewRequired(observed.reviewDecision) && !isFailingCheckStatus(observed.gateCheckStatus)) {
+            return "pr_open";
+        }
+        return undefined;
+    }
+    if (isReviewDecisionApproved(observed.reviewDecision)) {
+        return "awaiting_queue";
+    }
+    return undefined;
+}

package/dist/run-budgets.js

@@ -1,12 +1,46 @@
-export const DEFAULT_CI_REPAIR_BUDGET = 10;
-export const DEFAULT_QUEUE_REPAIR_BUDGET = 10;
-export const DEFAULT_REVIEW_FIX_BUDGET = 10;
+export const DEFAULT_RUN_BUDGETS = {
+    ciRepair: 10,
+    queueRepair: 10,
+    reviewFix: 10,
+    zombieRecovery: 5,
+};
+export function resolveRunBudgets(project) {
+    return {
+        ciRepair: project?.repairBudgets?.ciRepair ?? DEFAULT_RUN_BUDGETS.ciRepair,
+        queueRepair: project?.repairBudgets?.queueRepair ?? DEFAULT_RUN_BUDGETS.queueRepair,
+        reviewFix: project?.repairBudgets?.reviewFix ?? DEFAULT_RUN_BUDGETS.reviewFix,
+        // No per-project override exists for zombie recovery yet; add one to
+        // ProjectConfig.repairBudgets if a project ever needs it.
+        zombieRecovery: DEFAULT_RUN_BUDGETS.zombieRecovery,
+    };
+}
 export function getCiRepairBudget(project) {
-    return project?.repairBudgets?.ciRepair ?? DEFAULT_CI_REPAIR_BUDGET;
+    return resolveRunBudgets(project).ciRepair;
 }
 export function getQueueRepairBudget(project) {
-    return project?.repairBudgets?.queueRepair ?? DEFAULT_QUEUE_REPAIR_BUDGET;
+    return resolveRunBudgets(project).queueRepair;
 }
 export function getReviewFixBudget(project) {
-    return project?.repairBudgets?.reviewFix ?? DEFAULT_REVIEW_FIX_BUDGET;
+    return resolveRunBudgets(project).reviewFix;
+}
+export function getZombieRecoveryBudget(project) {
+    return resolveRunBudgets(project).zombieRecovery;
+}
+// ─── Zombie-recovery backoff schedule (formerly zombie-recovery.ts) ──
+//
+// Exponential backoff between retries of a run that died without doing
+// its work. Owned here with the budgets so the whole retry discipline
+// (how many attempts, how far apart) reads in one place.
+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/dist/run-completion-policy.js

@@ -1,18 +1,59 @@
 import { ACTIVE_RUN_STATES } from "./factory-state.js";
 import { ImplementationOutcomePolicy } from "./implementation-outcome-policy.js";
 import { ReactiveRunPolicy } from "./reactive-run-policy.js";
-function resolvePostRunState(issue) {
-    if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
+// Plan §B3: the one post-run factory-state resolver. Unifies the former
+// `resolveCompletedRunState` (run-completion-policy) and
+// `resolveRecoverablePostRunState` (interrupted-run-recovery).
+//
+// Shared rule (both old functions agreed):
+//   - no PR on the issue → undefined (nothing to resolve from PR truth);
+//   - approved open/closed PR → awaiting_queue; otherwise pr_open;
+//   - merged PR (while the issue is in an active-run state) → done.
+//
+// The two old functions genuinely disagreed in two places, and the
+// disagreement is semantic, so it survives as the `outcome` option rather
+// than being averaged away:
+//   - outcome "completed" (the run did its work, default): gate every write
+//     on ACTIVE_RUN_STATES so a state advanced concurrently by webhooks
+//     (e.g. deploying, awaiting_queue) is never clobbered, and never
+//     re-derive a reactive repair state — the stale GitHub verdict
+//     (changes_requested / red CI) refers to the head the run just
+//     replaced, and routing it again would loop the fix forever.
+//   - outcome "recovered" (the run died without doing its work): GitHub
+//     truth is authoritative regardless of the local factory state —
+//     merged → done unconditionally, and an open PR re-derives the
+//     reactive intent (repairing_ci / repairing_queue / changes_requested)
+//     so the original problem is routed again.
+export function resolvePostRunFactoryState(issue, _run, options) {
+    if (!issue.prNumber)
+        return undefined;
+    if (options?.outcome === "recovered") {
         if (issue.prState === "merged")
             return "done";
-        if (issue.prReviewState === "approved")
-            return "awaiting_queue";
-        return "pr_open";
+        if (issue.prState === "open") {
+            const reactiveIntent = deriveIssueSessionReactiveIntent({
+                prNumber: issue.prNumber,
+                prState: issue.prState,
+                prReviewState: issue.prReviewState,
+                prCheckStatus: issue.prCheckStatus,
+                latestFailureSource: issue.lastGitHubFailureSource,
+            });
+            if (reactiveIntent)
+                return reactiveIntent.compatibilityFactoryState;
+            if (issue.prReviewState === "approved")
+                return "awaiting_queue";
+            return "pr_open";
+        }
+        // Closed (or unknown) PR: fall through to the factory-state-gated rule.
     }
-    return undefined;
-}
-export function resolveCompletedRunState(issue, _run) {
-    return resolvePostRunState(issue);
+    if (!ACTIVE_RUN_STATES.has(issue.factoryState))
+        return undefined;
+    if (issue.prState === "merged")
+        return "done";
+    if (issue.prReviewState === "approved")
+        return "awaiting_queue";
+    return "pr_open";
 }
 export class RunCompletionPolicy {
     reactive;

package/dist/run-failure-policy.js

@@ -0,0 +1,463 @@
+import { buildRunFailureActivity } from "./linear-session-reporting.js";
+import { getRemainingZombieRecoveryDelayMs, getZombieRecoveryBudget } from "./run-budgets.js";
+import { resolvePostRunFactoryState } from "./run-completion-policy.js";
+import { isRequestedChangesRunType } from "./reactive-pr-state.js";
+import { settleRun } from "./run-settlement.js";
+const WRITER = "run-failure-policy";
+// Roll back the attempt counter consumed by the interrupted run and clear the
+// attempted-failure provenance for repair runs, as a single issue update so
+// the whole repair commits (and conflict-recomputes) atomically.
+function buildInterruptedAttemptRepairUpdate(runType, issue) {
+    const counter = runType === "ci_repair" && issue.ciRepairAttempts > 0
+        ? { ciRepairAttempts: issue.ciRepairAttempts - 1 }
+        : runType === "queue_repair" && issue.queueRepairAttempts > 0
+            ? { queueRepairAttempts: issue.queueRepairAttempts - 1 }
+            : isRequestedChangesRunType(runType) && issue.reviewFixAttempts > 0
+                ? { reviewFixAttempts: issue.reviewFixAttempts - 1 }
+                : undefined;
+    const provenance = runType === "ci_repair" || runType === "queue_repair"
+        ? {
+            lastAttemptedFailureHeadSha: null,
+            lastAttemptedFailureSignature: null,
+            lastAttemptedFailureAt: null,
+        }
+        : undefined;
+    if (!counter && !provenance)
+        return undefined;
+    return {
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        ...counter,
+        ...provenance,
+    };
+}
+function resolveRetryRunType(runType, context) {
+    if (runType === "branch_upkeep") {
+        return "branch_upkeep";
+    }
+    return context?.reviewFixMode === "branch_upkeep" || context?.branchUpkeepRequired === true
+        ? "branch_upkeep"
+        : "review_fix";
+}
+// Plan §B4: the one run-failure policy. Merges the former
+// RunRecoveryService (zombie retry/escalate + backoff) and
+// InterruptedRunRecovery (interrupted-turn handling, counter decrements,
+// re-enqueue) into a single module that answers: given a stranded or
+// failed run + its issue — retry (with which backoff/budget), re-enqueue
+// (which runType/context), or escalate?
+//
+// Ownership: run-reconciler and service-startup-recovery only DETECT
+// stranded states and hand them here; this policy DECIDES; execution of
+// the run/slot writes goes through settleRun, and dispatch of follow-up
+// work goes through the WakeDispatcher.
+export class RunFailurePolicy {
+    db;
+    logger;
+    linearSync;
+    withHeldLease;
+    releaseLease;
+    appendWakeEventWithLease;
+    wakeDispatcher;
+    restoreIdleWorktree;
+    completionPolicy;
+    resolveProject;
+    feed;
+    constructor(db, logger, linearSync, withHeldLease, releaseLease, appendWakeEventWithLease, wakeDispatcher, restoreIdleWorktree, completionPolicy, resolveProject, feed) {
+        this.db = db;
+        this.logger = logger;
+        this.linearSync = linearSync;
+        this.withHeldLease = withHeldLease;
+        this.releaseLease = releaseLease;
+        this.appendWakeEventWithLease = appendWakeEventWithLease;
+        this.wakeDispatcher = wakeDispatcher;
+        this.restoreIdleWorktree = restoreIdleWorktree;
+        this.completionPolicy = completionPolicy;
+        this.resolveProject = resolveProject;
+        this.feed = feed;
+    }
+    // ─── Stranded runs (zombie / stale thread) ───────────────────────
+    /**
+     * Detector entry point: the reconciler found a run that can never make
+     * progress (no Codex thread after a restart, or the thread is gone).
+     * Settle the run (mark failed, release the slot) and decide retry vs
+     * escalate via the zombie budget/backoff.
+     */
+    settleStrandedRunAndRecover(params) {
+        const { run, issue } = params;
+        this.withHeldLease(run.projectId, run.linearIssueId, (lease) => settleRun({
+            db: this.db,
+            run,
+            finish: { status: "failed", failureReason: params.failureReason },
+            lease,
+        }));
+        this.recoverOrEscalate({ issue, runType: run.runType, reason: params.reason });
+    }
+    /**
+     * Decide what happens after a run died without doing its work: PR
+     * already merged → done; zombie budget exhausted → escalate; backoff
+     * not elapsed → keep the wake but defer; otherwise consume one budget
+     * unit, append a recovery wake, and dispatch.
+     */
+    recoverOrEscalate(params) {
+        const { issue, runType, reason } = params;
+        const fresh = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
+        if (!fresh)
+            return;
+        if (isRequestedChangesRunType(runType)) {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    lease,
+                    update: {
+                        projectId: fresh.projectId,
+                        linearIssueId: fresh.linearIssueId,
+                        pendingRunType: null,
+                        pendingRunContextJson: null,
+                        factoryState: "escalated",
+                    },
+                });
+                return true;
+            });
+            if (!updated) {
+                this.logger.warn({ issueKey: fresh.issueKey, reason }, "Skipping review-fix recovery escalation after losing issue-session lease");
+                this.releaseLease(fresh.projectId, fresh.linearIssueId);
+                return;
+            }
+            this.logger.warn({ issueKey: fresh.issueKey, reason }, "Requested-changes run failed before a new head was published - escalating");
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: fresh.issueKey,
+                projectId: fresh.projectId,
+                stage: runType,
+                status: "escalated",
+                summary: `Requested-changes run failed before publishing a new head (${reason})`,
+            });
+            this.releaseLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
+        if (fresh.prState === "merged") {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    lease,
+                    update: {
+                        projectId: fresh.projectId,
+                        linearIssueId: fresh.linearIssueId,
+                        factoryState: "done",
+                        zombieRecoveryAttempts: 0,
+                        lastZombieRecoveryAt: null,
+                    },
+                });
+                return true;
+            });
+            if (!updated) {
+                this.logger.warn({ issueKey: fresh.issueKey, reason }, "Skipping merged recovery completion after losing issue-session lease");
+                this.releaseLease(fresh.projectId, fresh.linearIssueId);
+                return;
+            }
+            this.logger.info({ issueKey: fresh.issueKey, reason }, "Recovery: PR already merged - transitioning to done");
+            this.releaseLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
+        const zombieRecoveryBudget = getZombieRecoveryBudget(this.resolveProject(fresh.projectId));
+        const attempts = fresh.zombieRecoveryAttempts + 1;
+        if (attempts > zombieRecoveryBudget) {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    lease,
+                    update: {
+                        projectId: fresh.projectId,
+                        linearIssueId: fresh.linearIssueId,
+                        factoryState: "escalated",
+                    },
+                });
+                return true;
+            });
+            if (!updated) {
+                this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Skipping recovery escalation after losing issue-session lease");
+                this.releaseLease(fresh.projectId, fresh.linearIssueId);
+                return;
+            }
+            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 ${zombieRecoveryBudget} attempts`,
+            });
+            this.releaseLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
+        if (fresh.lastZombieRecoveryAt) {
+            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 = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+            // `attempts` is read-modify-write against the fresh row read above; on
+            // conflict recompute the counter from the current row.
+            const buildRequeueUpdate = (record) => ({
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                zombieRecoveryAttempts: record.zombieRecoveryAttempts + 1,
+                lastZombieRecoveryAt: new Date().toISOString(),
+            });
+            this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                lease,
+                expectedVersion: fresh.version,
+                update: buildRequeueUpdate(fresh),
+                onConflict: (current) => buildRequeueUpdate(current),
+            });
+            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");
+            this.releaseLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
+        this.wakeDispatcher.dispatchIfWakePending(fresh.projectId, fresh.linearIssueId);
+        this.logger.info({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: re-enqueued with backoff");
+    }
+    // ─── Terminal decisions ──────────────────────────────────────────
+    escalate(params) {
+        const { issue, runType, reason } = params;
+        this.logger.warn({ issueKey: issue.issueKey, runType, reason }, "Escalating to human");
+        const escalated = this.withHeldLease(issue.projectId, issue.linearIssueId, (lease) => {
+            // Escalation is an operator-facing decision: the issue write and the
+            // run release ride in the held-lease transaction. When a run still
+            // holds the slot, settleRun owns the paired run-release + slot-clear;
+            // it refuses to clear a slot that was re-pointed at another run.
+            const escalateFields = {
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                factoryState: "escalated",
+            };
+            if (issue.activeRunId !== undefined) {
+                const settled = settleRun({
+                    db: this.db,
+                    run: { id: issue.activeRunId, projectId: issue.projectId, linearIssueId: issue.linearIssueId },
+                    finish: { status: "released" },
+                    lease,
+                    buildIssueUpdate: () => escalateFields,
+                });
+                if (!settled.slotCleared)
+                    return false;
+            }
+            else {
+                const commit = this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    lease,
+                    update: {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        ...escalateFields,
+                    },
+                });
+                if (commit.outcome !== "applied")
+                    return false;
+            }
+            this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
+            return true;
+        });
+        if (!escalated) {
+            this.logger.warn({ issueKey: issue.issueKey, runType }, "Skipping escalation write after losing issue-session lease");
+            this.releaseLease(issue.projectId, issue.linearIssueId);
+            return;
+        }
+        this.feed?.publish({
+            level: "error",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: runType,
+            status: "escalated",
+            summary: `Escalated: ${reason}`,
+        });
+        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}`,
+        });
+        void this.linearSync.syncSession(escalatedIssue);
+        this.releaseLease(issue.projectId, issue.linearIssueId);
+    }
+    failRunAndClear(params) {
+        const { run, message, nextState } = params;
+        const updated = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+            settleRun({
+                db: this.db,
+                run,
+                finish: { status: "failed", failureReason: message },
+                lease,
+                buildIssueUpdate: () => ({ factoryState: nextState }),
+            });
+            if (nextState === "failed" || nextState === "escalated" || nextState === "awaiting_input" || nextState === "done") {
+                this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
+            }
+            return true;
+        });
+        if (!updated) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping failure cleanup after losing issue-session lease");
+        }
+        this.releaseLease(run.projectId, run.linearIssueId);
+    }
+    // ─── Interrupted turns (formerly InterruptedRunRecovery) ─────────
+    async handleInterruptedRun(run, issue) {
+        this.logger.warn({ issueKey: issue.issueKey, runType: run.runType, threadId: run.threadId }, "Run has interrupted turn - marking as failed");
+        const repairedCounters = this.withHeldLease(issue.projectId, issue.linearIssueId, (lease) => {
+            // The decrement is read-modify-write against an issue row read before
+            // the awaits that led here; on conflict, recompute from the fresh row.
+            const update = buildInterruptedAttemptRepairUpdate(run.runType, issue);
+            if (update) {
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    lease,
+                    expectedVersion: issue.version,
+                    update,
+                    onConflict: (current) => buildInterruptedAttemptRepairUpdate(run.runType, current),
+                });
+            }
+            return true;
+        });
+        if (!repairedCounters) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping interrupted-run recovery after losing issue-session lease");
+            this.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        if (isRequestedChangesRunType(run.runType)) {
+            await this.handleInterruptedRequestedChangesRun(run, issue);
+            return;
+        }
+        if (run.runType === "implementation" && !issue.prNumber) {
+            await this.handleInterruptedImplementationRun(run, issue);
+            return;
+        }
+        const recoveredState = resolvePostRunFactoryState(this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue, run, { outcome: "recovered" });
+        this.failRunAndClear({ run, message: "Codex turn was interrupted", nextState: recoveredState ?? "failed" });
+        await this.restoreIdleWorktree(issue);
+        const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        if (recoveredState) {
+            this.feed?.publish({
+                level: "info",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: run.projectId,
+                stage: recoveredState,
+                status: "reconciled",
+                summary: `Interrupted ${run.runType} recovered -> ${recoveredState}`,
+            });
+        }
+        else {
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, "The Codex turn was interrupted."));
+        }
+        void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+        this.releaseLease(run.projectId, run.linearIssueId);
+    }
+    async handleInterruptedImplementationRun(run, issue) {
+        const interruptedMessage = "Implementation run was interrupted before PatchRelay could publish a PR";
+        this.failRunAndClear({ run, message: "Codex turn was interrupted", nextState: "delegated" });
+        await this.restoreIdleWorktree(issue);
+        const refreshedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(run.projectId, run.linearIssueId, {
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            eventType: "delegated",
+            dedupeKey: `interrupted_implementation:implementation:${run.linearIssueId}`,
+        });
+        if (!this.db.workflowWakes.peekIssueWake(run.projectId, run.linearIssueId)) {
+            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: issue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "escalated",
+                summary: interruptedMessage,
+            });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, interruptedMessage));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        this.feed?.publish({
+            level: "warn",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: run.projectId,
+            stage: run.runType,
+            status: "retry_queued",
+            summary: "Implementation run was interrupted; PatchRelay will retry automatically",
+        });
+        const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+        void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
+        this.wakeDispatcher.dispatchIfWakePending(run.projectId, run.linearIssueId);
+        this.releaseLease(run.projectId, run.linearIssueId);
+    }
+    async handleInterruptedRequestedChangesRun(run, issue) {
+        const freshIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        const refreshedIssue = await this.completionPolicy.refreshIssueAfterReactivePublish(run, freshIssue);
+        const retryContext = await this.completionPolicy.resolveRequestedChangesWakeContext(refreshedIssue, run.runType, run.runType === "branch_upkeep"
+            ? {
+                branchUpkeepRequired: true,
+                reviewFixMode: "branch_upkeep",
+                wakeReason: "branch_upkeep",
+            }
+            : undefined);
+        const retryRunType = resolveRetryRunType(run.runType, retryContext);
+        const recoveredState = resolvePostRunFactoryState(refreshedIssue, run, { outcome: "recovered" }) ?? "failed";
+        const interruptedMessage = "Requested-changes run was interrupted before PatchRelay could verify that a new PR head was published";
+        this.failRunAndClear({ run, message: interruptedMessage, nextState: recoveredState });
+        await this.restoreIdleWorktree(issue);
+        const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+        if (recoveredState === "changes_requested") {
+            this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    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.wakeDispatcher.dispatchIfWakePending(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.releaseLease(run.projectId, run.linearIssueId);
+    }
+}