patchrelay 0.36.8 → 0.36.10

package/dist/run-orchestrator.js

@@ -1,36 +1,32 @@
-import { ACTIVE_RUN_STATES, TERMINAL_STATES } from "./factory-state.js";
+import { TERMINAL_STATES } from "./factory-state.js";
 import { extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread } from "./run-reporting.js";
 import { buildRunFailureActivity, buildRunStartedActivity, } from "./linear-session-reporting.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { resolveAuthoritativeLinearStopState, resolvePreferredCompletedLinearState } from "./linear-workflow.js";
-import { execCommand } from "./utils.js";
 import { getThreadTurns } from "./codex-thread-utils.js";
-import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { QueueHealthMonitor } from "./queue-health-monitor.js";
-import { resolveImplementationDeliveryMode, } from "./prompting/patchrelay.js";
 import { IdleIssueReconciler, resolveBranchOwnerForStateTransition } from "./idle-reconciliation.js";
 import { LinearSessionSync } from "./linear-session-sync.js";
 import { IssueSessionLeaseService } from "./issue-session-lease-service.js";
+import { InterruptedRunRecovery, resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
+import { RunCompletionPolicy } from "./run-completion-policy.js";
 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 resolveRequestedChangesMode(runType, context) {
-    if (runType === "branch_upkeep") {
-        return "branch_upkeep";
-    }
-    return context?.reviewFixMode === "branch_upkeep" || context?.branchUpkeepRequired === true
-        ? "branch_upkeep"
-        : "address_review_feedback";
-}
-function isBranchUpkeepRequired(context) {
-    return context?.branchUpkeepRequired === true;
+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;
@@ -52,6 +48,8 @@ export class RunOrchestrator {
     runLauncher;
     runRecovery;
     runWakePlanner;
+    interruptedRunRecovery;
+    runCompletionPolicy;
     activeSessionLeases;
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
@@ -66,9 +64,11 @@ export class RunOrchestrator {
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
         this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries));
         this.activeSessionLeases = this.leaseService.activeSessionLeases;
-        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, feed);
+        this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn));
+        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (run, message, nextState) => this.failRunAndClear(run, message, nextState), this.runCompletionPolicy, feed);
         this.runLauncher = new RunLauncher(config, db, codex, logger, this.worktreeManager);
-        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (projectId, issueId) => this.enqueueIssue(projectId, issueId), (newState, pendingRunType) => this.resolveBranchOwnerForStateTransition(newState, pendingRunType), feed);
+        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (projectId, issueId) => this.enqueueIssue(projectId, issueId), (newState, pendingRunType) => this.resolveBranchOwnerForStateTransition(newState, pendingRunType), feed);
+        this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (run, message, nextState) => this.failRunAndClear(run, message, nextState), (issue) => this.restoreIdleWorktree(issue), this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.runWakePlanner = new RunWakePlanner(db);
         this.idleReconciler = new IdleIssueReconciler(db, config, {
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
@@ -95,7 +95,7 @@ export class RunOrchestrator {
         if (this.leaseService.hasLocalLease(item.projectId, item.issueId)) {
             return;
         }
-        const issue = this.db.getIssue(item.projectId, item.issueId);
+        const issue = this.db.issues.getIssue(item.projectId, item.issueId);
         if (!issue || issue.activeRunId !== undefined)
             return;
         const issueSession = this.db.issueSessions.getIssueSession(item.projectId, item.issueId);
@@ -116,8 +116,14 @@ 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.resolveRequestedChangesWakeContext(issue, runType, context, project)
+            ? await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context)
             : context;
         const sourceHeadSha = typeof effectiveContext?.failureHeadSha === "string"
             ? effectiveContext.failureHeadSha
@@ -179,8 +185,6 @@ export class RunOrchestrator {
             leaseId,
             ...(this.botIdentity ? { botIdentity: this.botIdentity } : {}),
             assertLaunchLease: (targetRun, phase) => this.assertLaunchLease(targetRun, phase),
-            resetWorktreeToTrackedBranch: (targetWorktreePath, targetBranchName, targetIssue) => this.resetWorktreeToTrackedBranch(targetWorktreePath, targetBranchName, targetIssue),
-            freshenWorktree: (targetWorktreePath, targetProject, targetIssue) => this.freshenWorktree(targetWorktreePath, targetProject, targetIssue),
             linearSync: this.linearSync,
             releaseLease: (projectId, issueId) => this.releaseIssueSessionLease(projectId, issueId),
             isRequestedChangesRunType,
@@ -203,98 +207,15 @@ export class RunOrchestrator {
         }
         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;
+        const freshIssue = this.db.issues.getIssue(item.projectId, item.issueId) ?? issue;
         void this.linearSync.emitActivity(freshIssue, buildRunStartedActivity(runType));
         void this.linearSync.syncSession(freshIssue, { activeRunType: runType });
     }
-    // ─── Pre-run branch freshening ────────────────────────────────────
-    /**
-     * Fetch origin and rebase the worktree onto the latest base branch.
-     *
-     * Risks mitigated:
-     * - Dirty worktree from interrupted run → stash before, pop after
-     * - Conflicts → abort rebase, throw so the run fails with a clear reason
-     * - Already up-to-date → no-op
-     * - Keep publishing explicit: the orchestrator updates the local worktree
-     *   only; the agent/run owns any later branch push.
-     */
-    async freshenWorktree(worktreePath, project, issue) {
-        const gitBin = this.config.runner.gitBin;
-        const baseBranch = project.github?.baseBranch ?? "main";
-        // Stash any uncommitted changes from a previous interrupted run
-        const stashResult = await execCommand(gitBin, ["-C", worktreePath, "stash"], { timeoutMs: 30_000 });
-        const didStash = stashResult.exitCode === 0 && !stashResult.stdout?.includes("No local changes");
-        // Fetch latest base
-        const fetchResult = await execCommand(gitBin, ["-C", worktreePath, "fetch", "origin", baseBranch], { timeoutMs: 60_000 });
-        if (fetchResult.exitCode !== 0) {
-            this.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;
-        }
-        // Check if rebase is needed: is HEAD already on top of origin/baseBranch?
-        const mergeBaseResult = await execCommand(gitBin, ["-C", worktreePath, "merge-base", "--is-ancestor", `origin/${baseBranch}`, "HEAD"], { timeoutMs: 10_000 });
-        if (mergeBaseResult.exitCode === 0) {
-            // Already up-to-date — no rebase needed
-            this.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;
-        }
-        // 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 — 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 });
-            this.logger.warn({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebase conflict, agent will resolve");
-            return;
-        }
-        this.logger.info({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebased locally onto latest base");
-        // Restore stashed changes
-        if (didStash)
-            await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
-    }
     async resetWorktreeToTrackedBranch(worktreePath, branchName, issue) {
-        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 });
-        this.logger.debug({ issueKey: issue.issueKey, branchName, hasRemoteBranch }, "Reset issue worktree to tracked branch state");
+        await this.worktreeManager.resetWorktreeToTrackedBranch(worktreePath, branchName, issue, this.logger);
     }
     async restoreIdleWorktree(issue) {
-        if (!issue.worktreePath || !issue.branchName)
-            return;
-        try {
-            await this.resetWorktreeToTrackedBranch(issue.worktreePath, issue.branchName, issue);
-        }
-        catch (error) {
-            this.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");
-        }
+        await this.worktreeManager.restoreIdleWorktree(issue, this.logger);
     }
     // ─── Notification handler ─────────────────────────────────────────
     async handleCodexNotification(notification) {
@@ -331,7 +252,7 @@ export class RunOrchestrator {
         this.linearSync.maybeEmitProgress(notification, run);
         // Sync codex plan to Linear session when it updates
         if (notification.method === "turn/plan/updated") {
-            const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+            const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
             if (issue) {
                 void this.linearSync.syncCodexPlan(issue, notification.params);
             }
@@ -339,7 +260,7 @@ export class RunOrchestrator {
         if (notification.method !== "turn/completed")
             return;
         const thread = await this.readThreadWithRetry(threadId);
-        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
             return;
         const completedTurnId = extractTurnId(notification.params);
@@ -375,7 +296,7 @@ export class RunOrchestrator {
                 status: "failed",
                 summary: `Turn failed for ${run.runType}`,
             });
-            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
             void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType));
             void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
             this.linearSync.clearProgress(run.id);
@@ -390,23 +311,13 @@ export class RunOrchestrator {
             thread,
             threadId,
             ...(completedTurnId ? { completedTurnId } : {}),
-            withHeldLease: (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn),
-            releaseLease: (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId),
-            failRunAndClear: (targetRun, message, nextState) => this.failRunAndClear(targetRun, message, nextState),
-            verifyReactiveRunAdvancedBranch: (targetRun, targetIssue) => this.verifyReactiveRunAdvancedBranch(targetRun, targetIssue),
-            verifyReviewFixAdvancedHead: (targetRun, targetIssue) => this.verifyReviewFixAdvancedHead(targetRun, targetIssue),
-            verifyPublishedRunOutcome: (targetRun, targetIssue) => this.verifyPublishedRunOutcome(targetRun, targetIssue),
-            refreshIssueAfterReactivePublish: (targetRun, targetIssue) => this.refreshIssueAfterReactivePublish(targetRun, targetIssue),
-            resolvePostRunFollowUp: (targetRun, targetIssue) => this.resolvePostRunFollowUp(targetRun, targetIssue),
-            resolveCompletedRunState,
             resolveRecoverableRunState: resolveRecoverablePostRunState,
-            appendWakeEventWithLease: (lease, targetIssue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, targetIssue, runType, context, dedupeScope),
         });
         this.activeThreadId = undefined;
     }
     // ─── Active status for query ──────────────────────────────────────
     async getActiveRunStatus(issueKey) {
-        const issue = this.db.getIssueByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue?.activeRunId)
             return undefined;
         const run = this.db.runs.getRunById(issue.activeRunId);
@@ -434,7 +345,7 @@ export class RunOrchestrator {
         await this.reconcileMergedLinearCompletion();
     }
     async reconcileMergedLinearCompletion() {
-        for (const issue of this.db.listIssues()) {
+        for (const issue of this.db.issues.listIssues()) {
             if (issue.prState !== "merged")
                 continue;
             if (issue.currentLinearStateType?.trim().toLowerCase() === "completed")
@@ -449,7 +360,7 @@ export class RunOrchestrator {
                     continue;
                 const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
                 if (normalizedCurrent === targetState.trim().toLowerCase()) {
-                    this.db.upsertIssue({
+                    this.db.issues.upsertIssue({
                         projectId: issue.projectId,
                         linearIssueId: issue.linearIssueId,
                         ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
@@ -458,7 +369,7 @@ export class RunOrchestrator {
                     continue;
                 }
                 const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-                this.db.upsertIssue({
+                this.db.issues.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
@@ -485,12 +396,10 @@ export class RunOrchestrator {
             runType,
             reason,
             isRequestedChangesRunType,
-            withHeldLease: (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn),
-            appendWakeEventWithLease: (lease, targetIssue, pendingRunType, context, dedupeScope) => this.appendWakeEventWithLease(lease, targetIssue, pendingRunType, context, dedupeScope),
         });
     }
     async reconcileRun(run) {
-        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
             return;
         let recoveryLease = this.claimLeaseForReconciliation(run.projectId, run.linearIssueId);
@@ -505,10 +414,10 @@ export class RunOrchestrator {
         if (TERMINAL_STATES.has(issue.factoryState)) {
             this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.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.db.issues.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");
-            const releasedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            const releasedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
             void this.linearSync.syncSession(releasedIssue, { activeRunType: run.runType });
             this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
             return;
@@ -518,10 +427,10 @@ export class RunOrchestrator {
             this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
             this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "failed", failureReason: "Zombie: never started (no thread after restart)" });
-                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
+                this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
             this.recoverOrEscalate(issue, run.runType, "zombie");
-            const recoveredIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
             void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, "The Codex turn never started before PatchRelay restarted."));
             void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
             this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
@@ -536,10 +445,10 @@ export class RunOrchestrator {
             this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
             this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "failed", failureReason: "Stale thread after restart" });
-                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
+                this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
             this.recoverOrEscalate(issue, run.runType, "stale_thread");
-            const recoveredIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
             void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, "PatchRelay lost the active Codex thread after restart and needs to recover."));
             void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
             this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
@@ -554,7 +463,7 @@ export class RunOrchestrator {
                 if (stopState?.isFinal) {
                     this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
                         this.db.runs.finishRun(run.id, { status: "released" });
-                        this.db.upsertIssue({
+                        this.db.issues.upsertIssue({
                             projectId: run.projectId,
                             linearIssueId: run.linearIssueId,
                             activeRunId: null,
@@ -571,7 +480,7 @@ export class RunOrchestrator {
                         status: "reconciled",
                         summary: `Linear state ${stopState.stateName} \u2192 done`,
                     });
-                    const doneIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+                    const doneIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
                     void this.linearSync.syncSession(doneIssue, { activeRunType: run.runType });
                     this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
                     return;
@@ -583,112 +492,7 @@ export class RunOrchestrator {
         // The agent may have partially completed work (commits, PR) before interruption.
         // Reactive loops (CI repair, review fix) will handle follow-up if needed.
         if (latestTurn?.status === "interrupted") {
-            this.logger.warn({ issueKey: issue.issueKey, runType: run.runType, threadId: run.threadId }, "Run has interrupted turn — marking as failed");
-            // Interrupted runs are not real failures — undo the budget increment.
-            const repairedCounters = this.withHeldIssueSessionLease(issue.projectId, issue.linearIssueId, (lease) => {
-                if (run.runType === "ci_repair" && issue.ciRepairAttempts > 0) {
-                    this.db.issueSessions.upsertIssueWithLease(lease, {
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        ciRepairAttempts: issue.ciRepairAttempts - 1,
-                    });
-                }
-                else if (run.runType === "queue_repair" && issue.queueRepairAttempts > 0) {
-                    this.db.issueSessions.upsertIssueWithLease(lease, {
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        queueRepairAttempts: issue.queueRepairAttempts - 1,
-                    });
-                }
-                if (run.runType === "ci_repair" || run.runType === "queue_repair") {
-                    this.db.issueSessions.upsertIssueWithLease(lease, {
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        lastAttemptedFailureHeadSha: null,
-                        lastAttemptedFailureSignature: null,
-                    });
-                }
-                return true;
-            });
-            if (!repairedCounters) {
-                this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping interrupted-run recovery after losing issue-session lease");
-                this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
-                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, recoveredState);
-                await this.restoreIdleWorktree(issue);
-                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;
-            }
-            const recoveredState = resolveRecoverablePostRunState(this.db.getIssue(run.projectId, run.linearIssueId) ?? issue);
-            this.failRunAndClear(run, "Codex turn was interrupted", recoveredState);
-            await this.restoreIdleWorktree(issue);
-            const failedIssue = this.db.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 \u2192 ${recoveredState}`,
-                });
-            }
-            else {
-                void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, "The Codex turn was interrupted."));
-            }
-            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
-            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+            await this.interruptedRunRecovery.handle(run, issue);
             return;
         }
         // Handle completed turn discovered during reconciliation
@@ -700,17 +504,7 @@ export class RunOrchestrator {
                 thread,
                 threadId: run.threadId,
                 ...(latestTurn.id ? { completedTurnId: latestTurn.id } : {}),
-                withHeldLease: (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn),
-                releaseLease: (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId),
-                failRunAndClear: (targetRun, message, nextState) => this.failRunAndClear(targetRun, message, nextState),
-                verifyReactiveRunAdvancedBranch: (targetRun, targetIssue) => this.verifyReactiveRunAdvancedBranch(targetRun, targetIssue),
-                verifyReviewFixAdvancedHead: (targetRun, targetIssue) => this.verifyReviewFixAdvancedHead(targetRun, targetIssue),
-                verifyPublishedRunOutcome: (targetRun, targetIssue) => this.verifyPublishedRunOutcome(targetRun, targetIssue),
-                refreshIssueAfterReactivePublish: (targetRun, targetIssue) => this.refreshIssueAfterReactivePublish(targetRun, targetIssue),
-                resolvePostRunFollowUp: (targetRun, targetIssue) => this.resolvePostRunFollowUp(targetRun, targetIssue),
-                resolveCompletedRunState,
                 resolveRecoverableRunState: resolveRecoverablePostRunState,
-                appendWakeEventWithLease: (lease, targetIssue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, targetIssue, runType, context, dedupeScope),
             });
             return;
         }
@@ -723,7 +517,6 @@ export class RunOrchestrator {
             issue,
             runType,
             reason,
-            withHeldLease: (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn),
         });
     }
     failRunAndClear(run, message, nextState = "failed") {
@@ -731,342 +524,13 @@ export class RunOrchestrator {
             run,
             message,
             nextState,
-            withHeldLease: (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn),
-            getHeldLease: (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId),
         });
     }
     resolveBranchOwnerForStateTransition(newState, pendingRunType) {
         return resolveBranchOwnerForStateTransition(newState, pendingRunType);
     }
-    async verifyReactiveRunAdvancedBranch(run, issue) {
-        if (run.runType !== "ci_repair" && run.runType !== "queue_repair") {
-            return undefined;
-        }
-        if (!issue.prNumber || issue.prState !== "open" || !issue.lastGitHubFailureHeadSha) {
-            return undefined;
-        }
-        const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        if (!project?.github?.repoFullName) {
-            return undefined;
-        }
-        try {
-            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
-            if (!pr || pr.state?.toUpperCase() !== "OPEN")
-                return undefined;
-            if (!pr.headRefOid || pr.headRefOid !== issue.lastGitHubFailureHeadSha)
-                return undefined;
-            return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
-        }
-        catch (error) {
-            this.logger.debug({
-                issueKey: issue.issueKey,
-                prNumber: issue.prNumber,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to verify PR head advancement after repair");
-            return undefined;
-        }
-    }
-    async verifyReviewFixAdvancedHead(run, issue) {
-        if (!isRequestedChangesRunType(run.runType)) {
-            return undefined;
-        }
-        if (!issue.prNumber || issue.prState !== "open") {
-            return undefined;
-        }
-        if (!run.sourceHeadSha) {
-            return `Requested-changes run finished for PR #${issue.prNumber} without a recorded starting head SHA. PatchRelay cannot verify that a new head was published.`;
-        }
-        const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        if (!project?.github?.repoFullName) {
-            return undefined;
-        }
-        try {
-            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
-            if (!pr || pr.state?.toUpperCase() !== "OPEN")
-                return undefined;
-            if (!pr.headRefOid) {
-                return `Requested-changes run finished for PR #${issue.prNumber} but GitHub did not report a current head SHA.`;
-            }
-            if (pr.headRefOid === run.sourceHeadSha) {
-                return `Requested-changes run finished for PR #${issue.prNumber} without pushing a new head; PatchRelay must not hand the same SHA back to review.`;
-            }
-            return undefined;
-        }
-        catch (error) {
-            this.logger.debug({
-                issueKey: issue.issueKey,
-                prNumber: issue.prNumber,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to verify PR head advancement after requested-changes work");
-            return undefined;
-        }
-    }
-    async refreshIssueAfterReactivePublish(run, issue) {
-        if (run.runType !== "ci_repair" && run.runType !== "queue_repair" && !isRequestedChangesRunType(run.runType)) {
-            return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        }
-        if (!issue.prNumber) {
-            return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        }
-        const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        const repoFullName = project?.github?.repoFullName;
-        if (!repoFullName) {
-            return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        }
-        try {
-            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
-            if (!pr) {
-                return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-            }
-            const nextPrState = normalizeRemotePrState(pr.state);
-            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
-            const gateCheckName = project?.gateChecks?.find((entry) => entry.trim())?.trim() ?? "verify";
-            const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== issue.lastGitHubFailureHeadSha);
-            const reviewFixHeadAdvanced = isRequestedChangesRunType(run.runType)
-                && Boolean(pr.headRefOid && run.sourceHeadSha && pr.headRefOid !== run.sourceHeadSha);
-            this.upsertIssueIfLeaseHeld(run.projectId, run.linearIssueId, {
-                projectId: run.projectId,
-                linearIssueId: run.linearIssueId,
-                ...(nextPrState ? { prState: nextPrState } : {}),
-                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
-                ...((headAdvanced || reviewFixHeadAdvanced)
-                    ? {
-                        prCheckStatus: "pending",
-                        lastGitHubFailureSource: null,
-                        lastGitHubFailureHeadSha: null,
-                        lastGitHubFailureSignature: null,
-                        lastGitHubFailureCheckName: null,
-                        lastGitHubFailureCheckUrl: null,
-                        lastGitHubFailureContextJson: null,
-                        lastGitHubFailureAt: null,
-                        lastQueueIncidentJson: null,
-                        lastAttemptedFailureHeadSha: null,
-                        lastAttemptedFailureSignature: null,
-                        lastGitHubCiSnapshotHeadSha: pr.headRefOid ?? null,
-                        lastGitHubCiSnapshotGateCheckName: gateCheckName,
-                        lastGitHubCiSnapshotGateCheckStatus: "pending",
-                        lastGitHubCiSnapshotJson: null,
-                        lastGitHubCiSnapshotSettledAt: null,
-                    }
-                    : {}),
-            }, "reactive publish refresh");
-        }
-        catch (error) {
-            this.logger.debug({
-                issueKey: issue.issueKey,
-                prNumber: issue.prNumber,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to refresh PR state after reactive publish");
-        }
-        return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-    }
-    async loadRemotePrState(repoFullName, prNumber) {
-        const { stdout, exitCode } = await execCommand("gh", [
-            "pr", "view", String(prNumber),
-            "--repo", repoFullName,
-            "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
-        ], { timeoutMs: 10_000 });
-        if (exitCode !== 0)
-            return undefined;
-        return JSON.parse(stdout);
-    }
-    async resolveRequestedChangesWakeContext(issue, runType, context, project) {
-        if (runType === "branch_upkeep" || isBranchUpkeepRequired(context)) {
-            return context;
-        }
-        if (!issue.prNumber || issue.prState !== "open" || issue.prReviewState !== "changes_requested") {
-            return context;
-        }
-        const repoFullName = project.github?.repoFullName;
-        if (!repoFullName) {
-            return context;
-        }
-        try {
-            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
-            if (!pr)
-                return context;
-            const nextPrState = normalizeRemotePrState(pr.state);
-            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
-            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                ...(nextPrState ? { prState: nextPrState } : {}),
-                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
-            }, "review-fix wake refresh");
-            if (nextPrState !== "open")
-                return context;
-            if (nextReviewState && nextReviewState !== "changes_requested")
-                return context;
-            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
-                return context;
-            return buildReviewFixBranchUpkeepContext(issue.prNumber, project.github?.baseBranch ?? "main", pr, context);
-        }
-        catch (error) {
-            this.logger.debug({
-                issueKey: issue.issueKey,
-                prNumber: issue.prNumber,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to resolve requested-changes wake context");
-            return context;
-        }
-    }
-    async resolvePostRunFollowUp(run, issue, projectOverride) {
-        if (run.runType !== "review_fix") {
-            return undefined;
-        }
-        if (!issue.prNumber || issue.prState !== "open") {
-            return undefined;
-        }
-        if (issue.prReviewState !== "changes_requested") {
-            return undefined;
-        }
-        const project = projectOverride ?? this.config.projects.find((entry) => entry.id === run.projectId);
-        const repoFullName = project?.github?.repoFullName;
-        if (!repoFullName) {
-            return undefined;
-        }
-        try {
-            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
-            if (!pr)
-                return undefined;
-            const nextPrState = normalizeRemotePrState(pr.state);
-            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
-            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                ...(nextPrState ? { prState: nextPrState } : {}),
-                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
-            }, "post-run follow-up refresh");
-            if (nextPrState !== "open")
-                return undefined;
-            if (nextReviewState && nextReviewState !== "changes_requested")
-                return undefined;
-            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
-                return undefined;
-            return {
-                pendingRunType: "branch_upkeep",
-                factoryState: "changes_requested",
-                context: buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr),
-                summary: `PR #${issue.prNumber} is still dirty after review fix; queued branch upkeep`,
-            };
-        }
-        catch (error) {
-            this.logger.debug({
-                issueKey: issue.issueKey,
-                prNumber: issue.prNumber,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to resolve post-run PR upkeep");
-            return undefined;
-        }
-    }
-    async verifyPublishedRunOutcome(run, issue, projectOverride) {
-        if (run.runType !== "implementation") {
-            return undefined;
-        }
-        const project = projectOverride ?? this.config.projects.find((entry) => entry.id === run.projectId);
-        const baseBranch = project?.github?.baseBranch ?? "main";
-        const deliveryMode = resolveImplementationDeliveryMode(issue, undefined, run.promptText);
-        if (deliveryMode === "linear_only") {
-            if (issue.prNumber !== undefined) {
-                return `Planning-only implementation should not open a PR, but PR #${issue.prNumber} was observed`;
-            }
-            return this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
-        }
-        if (issue.prNumber && issue.prState && issue.prState !== "closed") {
-            return undefined;
-        }
-        if (project?.github?.repoFullName && issue.branchName) {
-            try {
-                const { stdout, exitCode } = await execCommand("gh", [
-                    "pr",
-                    "list",
-                    "--repo",
-                    project.github.repoFullName,
-                    "--head",
-                    issue.branchName,
-                    "--state",
-                    "all",
-                    "--json",
-                    "number,url,state,author,headRefOid",
-                ], { timeoutMs: 10_000 });
-                if (exitCode === 0) {
-                    const matches = JSON.parse(stdout);
-                    const pr = matches[0];
-                    if (pr?.number) {
-                        this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
-                            projectId: issue.projectId,
-                            linearIssueId: issue.linearIssueId,
-                            prNumber: pr.number,
-                            ...(pr.url ? { prUrl: pr.url } : {}),
-                            ...(pr.state ? { prState: pr.state.toLowerCase() } : {}),
-                            ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                            ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
-                        }, "published PR verification refresh");
-                        return undefined;
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.debug({
-                    issueKey: issue.issueKey,
-                    branchName: issue.branchName,
-                    repoFullName: project.github.repoFullName,
-                    error: error instanceof Error ? error.message : String(error),
-                }, "Failed to verify published PR state after implementation");
-            }
-        }
-        const details = await this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
-        return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
-    }
-    async describeLocalImplementationOutcome(issue, baseBranch, deliveryMode = "publish_pr") {
-        if (!issue.worktreePath) {
-            return undefined;
-        }
-        try {
-            const status = await execCommand(this.config.runner.gitBin, [
-                "-C",
-                issue.worktreePath,
-                "status",
-                "--short",
-            ], { timeoutMs: 10_000 });
-            const dirtyEntries = status.exitCode === 0
-                ? status.stdout.split("\n").map((line) => line.trim()).filter(Boolean)
-                : [];
-            if (dirtyEntries.length > 0) {
-                if (deliveryMode === "linear_only") {
-                    return `Planning-only implementation should not modify the repo; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
-                }
-                return `Implementation completed without opening a PR; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
-            }
-        }
-        catch {
-            // Best effort only.
-        }
-        try {
-            const ahead = await execCommand(this.config.runner.gitBin, [
-                "-C",
-                issue.worktreePath,
-                "rev-list",
-                "--count",
-                `origin/${baseBranch}..HEAD`,
-            ], { timeoutMs: 10_000 });
-            if (ahead.exitCode === 0) {
-                const count = Number(ahead.stdout.trim());
-                if (Number.isFinite(count) && count > 0) {
-                    if (deliveryMode === "linear_only") {
-                        return `Planning-only implementation should not create repo commits; worktree is ${count} local commit(s) ahead of origin/${baseBranch}`;
-                    }
-                    return `Implementation completed with ${count} local commit(s) ahead of origin/${baseBranch} but no PR was observed`;
-                }
-            }
-        }
-        catch {
-            // Best effort only.
-        }
-        return undefined;
+    async resolveRequestedChangesWakeContext(issue, runType, context) {
+        return await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context);
     }
     async readThreadWithRetry(threadId, maxRetries = 3) {
         for (let attempt = 0; attempt < maxRetries; attempt++) {
@@ -1087,18 +551,6 @@ export class RunOrchestrator {
     withHeldIssueSessionLease(projectId, linearIssueId, fn) {
         return this.leaseService.withHeldLease(projectId, linearIssueId, fn);
     }
-    upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
-        const lease = this.getHeldIssueSessionLease(projectId, linearIssueId);
-        if (!lease) {
-            this.logger.warn({ projectId, linearIssueId, context }, "Skipping issue write without a held issue-session lease");
-            return undefined;
-        }
-        const updated = this.db.issueSessions.upsertIssueWithLease(lease, params);
-        if (!updated) {
-            this.logger.warn({ projectId, linearIssueId, context }, "Skipping issue write after losing issue-session lease");
-        }
-        return updated;
-    }
     assertLaunchLease(run, phase) {
         if (this.heartbeatIssueSessionLease(run.projectId, run.linearIssueId)) {
             return;
@@ -1108,12 +560,6 @@ export class RunOrchestrator {
         this.logger.warn({ runId: run.id, issueId: run.linearIssueId, phase }, "Aborting run launch after losing issue-session lease");
         throw error;
     }
-    acquireIssueSessionLease(projectId, linearIssueId) {
-        return this.leaseService.acquire(projectId, linearIssueId);
-    }
-    forceAcquireIssueSessionLease(projectId, linearIssueId) {
-        return this.leaseService.forceAcquire(projectId, linearIssueId);
-    }
     claimLeaseForReconciliation(projectId, linearIssueId) {
         return this.leaseService.claimForReconciliation(projectId, linearIssueId);
     }
@@ -1127,87 +573,3 @@ export class RunOrchestrator {
         this.leaseService.release(projectId, linearIssueId);
     }
 }
-/**
- * Determine post-run factory state from current PR metadata.
- * Used by both the normal completion path and reconciliation.
- */
-function resolvePostRunState(issue) {
-    if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
-        // Check merged first — a merged PR is both approved and merged,
-        // and "done" must take priority over "awaiting_queue".
-        if (issue.prState === "merged")
-            return "done";
-        if (issue.prReviewState === "approved")
-            return "awaiting_queue";
-        return "pr_open";
-    }
-    return undefined;
-}
-function resolveCompletedRunState(issue, run) {
-    if (run.runType === "implementation" && resolveImplementationDeliveryMode(issue, undefined, run.promptText) === "linear_only") {
-        return "done";
-    }
-    return resolvePostRunState(issue);
-}
-function resolveRecoverablePostRunState(issue) {
-    if (!issue.prNumber) {
-        return resolvePostRunState(issue);
-    }
-    if (issue.prState === "merged")
-        return "done";
-    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";
-    }
-    return resolvePostRunState(issue);
-}
-function normalizeRemotePrState(value) {
-    const normalized = value?.trim().toUpperCase();
-    if (normalized === "OPEN")
-        return "open";
-    if (normalized === "CLOSED")
-        return "closed";
-    if (normalized === "MERGED")
-        return "merged";
-    return undefined;
-}
-function normalizeRemoteReviewDecision(value) {
-    const normalized = value?.trim().toUpperCase();
-    if (normalized === "APPROVED")
-        return "approved";
-    if (normalized === "CHANGES_REQUESTED")
-        return "changes_requested";
-    if (normalized === "REVIEW_REQUIRED")
-        return "commented";
-    return undefined;
-}
-function isDirtyMergeStateStatus(value) {
-    return value?.trim().toUpperCase() === "DIRTY";
-}
-function buildReviewFixBranchUpkeepContext(prNumber, baseBranch, pr, context) {
-    const promptContext = [
-        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${String(pr.mergeStateStatus)} against latest ${baseBranch}.`,
-        `This turn is branch upkeep on the existing PR branch: update onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push a newer head.`,
-        "Do not stop just because the requested code change is already present. Review can only move forward after a new pushed head.",
-    ].join(" ");
-    return {
-        ...(context ?? {}),
-        branchUpkeepRequired: true,
-        reviewFixMode: "branch_upkeep",
-        wakeReason: "branch_upkeep",
-        promptContext,
-        ...(pr.mergeStateStatus ? { mergeStateStatus: pr.mergeStateStatus } : {}),
-        ...(pr.headRefOid ? { failingHeadSha: pr.headRefOid } : {}),
-        baseBranch,
-    };
-}