patchrelay 0.36.8 → 0.36.10

package/dist/github-webhook-handler.js

@@ -130,14 +130,15 @@ export class GitHubWebhookHandler {
             return;
         }
         // Route to issue via branch name
-        const issue = this.db.getIssueByBranch(event.branchName);
+        const issue = this.db.issues.getIssueByBranch(event.branchName);
         if (!issue) {
             this.logger.debug({ branchName: event.branchName, triggerEvent: event.triggerEvent }, "GitHub webhook: no matching issue for branch");
             return;
         }
         const project = this.config.projects.find((p) => p.id === issue.projectId);
+        const immediateCheckStatus = this.deriveImmediatePrCheckStatus(issue, event, project);
         // Update PR state on the issue
-        this.db.upsertIssue({
+        this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             ...(event.prNumber !== undefined ? { prNumber: event.prNumber } : {}),
@@ -146,7 +147,7 @@ export class GitHubWebhookHandler {
             ...(event.headSha !== undefined ? { prHeadSha: event.headSha } : {}),
             ...(event.prAuthorLogin !== undefined ? { prAuthorLogin: event.prAuthorLogin } : {}),
             ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
-            ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
+            ...(immediateCheckStatus !== undefined ? { prCheckStatus: immediateCheckStatus } : {}),
             ...(event.reviewState === "changes_requested"
                 ? { lastBlockingReviewHeadSha: event.reviewCommitId ?? event.headSha ?? null }
                 : event.reviewState === "approved"
@@ -158,7 +159,7 @@ export class GitHubWebhookHandler {
         const queueEvictionCheck = this.isQueueEvictionFailure(issue, event, project);
         if (!isMetadataOnlyCheckEvent(event) || queueEvictionCheck) {
             // Re-read issue after PR metadata upsert so guards see fresh prReviewState
-            const afterMetadata = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+            const afterMetadata = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
             const newState = this.resolveFactoryStateForEvent(afterMetadata, event, project);
             // Only transition and notify when the state actually changes.
             // Multiple check_suite events can arrive for the same outcome.
@@ -169,13 +170,13 @@ export class GitHubWebhookHandler {
                     factoryState: newState,
                 });
                 this.logger.info({ issueKey: issue.issueKey, from: afterMetadata.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
-                const transitionedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+                const transitionedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
                 void this.emitLinearActivity(transitionedIssue, newState, event);
                 void this.syncLinearSession(transitionedIssue);
             }
         }
         // Re-read issue after all upserts so reactive run logic sees current state
-        const freshIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        const freshIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
         // Reset repair counters on new push — but only when no repair run is active,
         // since Codex pushes during repair and resetting mid-run would bypass budgets.
         if (event.triggerEvent === "pr_synchronize" && !freshIssue.activeRunId) {
@@ -240,7 +241,7 @@ export class GitHubWebhookHandler {
     }
     async updateCiSnapshot(issue, event, project) {
         if (event.triggerEvent === "pr_merged") {
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastGitHubCiSnapshotHeadSha: null,
@@ -252,7 +253,7 @@ export class GitHubWebhookHandler {
             return;
         }
         if (event.triggerEvent === "pr_synchronize") {
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
@@ -279,7 +280,7 @@ export class GitHubWebhookHandler {
             gateCheckNames: this.getGateCheckNames(project),
         });
         if (!snapshot) {
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
@@ -300,7 +301,7 @@ export class GitHubWebhookHandler {
             });
             return;
         }
-        this.db.upsertIssue({
+        this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             prCheckStatus: snapshot.gateCheckStatus,
@@ -341,7 +342,7 @@ export class GitHubWebhookHandler {
                     return;
                 }
                 const hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
-                this.db.upsertIssue({
+                this.db.issues.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     lastGitHubFailureSource: "queue_eviction",
@@ -399,7 +400,7 @@ export class GitHubWebhookHandler {
                 }
                 const hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
                 const snapshot = this.getRelevantCiSnapshot(issue, event);
-                this.db.upsertIssue({
+                this.db.issues.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     lastGitHubFailureSource: "branch_ci",
@@ -520,7 +521,7 @@ export class GitHubWebhookHandler {
                         : "Pull request closed during active run",
                 });
             }
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 activeRunId: null,
@@ -535,7 +536,7 @@ export class GitHubWebhookHandler {
             this.db.transaction(commitTerminalUpdate);
         }
         this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        const updatedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        const updatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
         if (event.triggerEvent === "pr_merged") {
             await this.completeLinearIssueAfterMerge(updatedIssue);
         }
@@ -554,7 +555,7 @@ export class GitHubWebhookHandler {
             }
             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 } : {}),
@@ -563,7 +564,7 @@ export class GitHubWebhookHandler {
                 return;
             }
             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 } : {}),
@@ -587,7 +588,7 @@ export class GitHubWebhookHandler {
             const failureContext = source === "queue_eviction"
                 ? this.buildQueueFailureContext(issue, event)
                 : await this.resolveBranchFailureContext(issue, event, project);
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastGitHubFailureSource: source,
@@ -614,7 +615,7 @@ export class GitHubWebhookHandler {
             if (event.triggerEvent === "check_passed" && !this.canClearFailureProvenance(issue, event, project)) {
                 return;
             }
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastGitHubFailureSource: null,
@@ -730,6 +731,21 @@ export class GitHubWebhookHandler {
         const normalized = event.checkName.trim().toLowerCase();
         return this.getGateCheckNames(project).some((entry) => entry.trim().toLowerCase() === normalized);
     }
+    deriveImmediatePrCheckStatus(issue, event, project) {
+        if (event.triggerEvent === "pr_synchronize") {
+            return "pending";
+        }
+        if (event.eventSource !== "check_run") {
+            return undefined;
+        }
+        if (!this.isGateCheckEvent(event, project)) {
+            return undefined;
+        }
+        if (this.isStaleGateEvent(issue, event)) {
+            return undefined;
+        }
+        return event.checkStatus;
+    }
     isStaleGateEvent(issue, event) {
         return Boolean(issue.lastGitHubCiSnapshotHeadSha
             && event.headSha
@@ -763,7 +779,7 @@ export class GitHubWebhookHandler {
         return !issue.lastGitHubFailureHeadSha || issue.lastGitHubFailureHeadSha === event.headSha;
     }
     getRelevantCiSnapshot(issue, event) {
-        const snapshot = this.db.getLatestGitHubCiSnapshot(issue.projectId, issue.linearIssueId);
+        const snapshot = this.db.issues.getLatestGitHubCiSnapshot(issue.projectId, issue.linearIssueId);
         if (!snapshot)
             return undefined;
         if (snapshot.headSha !== event.headSha)
@@ -904,7 +920,7 @@ export class GitHubWebhookHandler {
         const prNumber = typeof issuePayload.number === "number" ? issuePayload.number : undefined;
         if (!prNumber)
             return;
-        const issue = this.db.getIssueByPrNumber(prNumber);
+        const issue = this.db.issues.getIssueByPrNumber(prNumber);
         if (!issue)
             return;
         if (!this.isPatchRelayOwnedPr(issue))

package/dist/idle-reconciliation.js

@@ -4,6 +4,7 @@ import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { execCommand } from "./utils.js";
+const DEFAULT_REVIEW_FIX_BUDGET = 12;
 function isFailingCheckStatus(status) {
     return status === "failed" || status === "failure";
 }
@@ -110,7 +111,7 @@ export class IdleIssueReconciler {
         this.feed = feed;
     }
     async reconcile() {
-        for (const issue of this.db.listIdleNonTerminalIssues()) {
+        for (const issue of this.db.issues.listIdleNonTerminalIssues()) {
             if (issue.prState === "merged") {
                 this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
                 continue;
@@ -145,13 +146,13 @@ export class IdleIssueReconciler {
                 await this.reconcileFromGitHub(issue);
             }
         }
-        for (const issue of this.db.listIssues()) {
+        for (const issue of this.db.issues.listIssues()) {
             if (!this.shouldProbeTerminalIssueFromGitHub(issue))
                 continue;
             await this.reconcileFromGitHub(issue);
         }
-        for (const issue of this.db.listBlockedDelegatedIssues()) {
-            const unresolved = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+        for (const issue of this.db.issues.listBlockedDelegatedIssues()) {
+            const unresolved = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
                 this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                     projectId: issue.projectId,
@@ -179,7 +180,7 @@ export class IdleIssueReconciler {
             return;
         }
         this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
-        this.db.upsertIssue({
+        this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             factoryState: newState,
@@ -206,7 +207,7 @@ export class IdleIssueReconciler {
         });
         const branchOwner = resolveBranchOwnerForStateTransition(newState, options?.pendingRunType);
         if (branchOwner) {
-            this.db.setBranchOwner(issue.projectId, issue.linearIssueId, branchOwner);
+            this.db.issues.setBranchOwner(issue.projectId, issue.linearIssueId, branchOwner);
         }
         if (options?.pendingRunType) {
             this.appendWakeEvent(issue, options.pendingRunType, options.pendingRunContext, "idle_reconciliation");
@@ -309,7 +310,7 @@ export class IdleIssueReconciler {
             ?? (inferred === "queue_eviction" && failureHeadSha && checkName
                 ? ["queue_eviction", failureHeadSha, checkName].join("::")
                 : null);
-        this.db.upsertIssue({
+        this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             lastGitHubFailureSource: inferred,
@@ -317,7 +318,7 @@ export class IdleIssueReconciler {
             ...(checkName ? { lastGitHubFailureCheckName: checkName } : {}),
             ...(failureSignature ? { lastGitHubFailureSignature: failureSignature } : {}),
         });
-        const refreshed = this.db.getIssue(issue.projectId, issue.linearIssueId);
+        const refreshed = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
         if (!refreshed)
             return issue;
         this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, inferred, factoryState: issue.factoryState }, "Recovered missing failure provenance from GitHub state");
@@ -337,7 +338,7 @@ export class IdleIssueReconciler {
         const checkName = issue.lastGitHubFailureCheckName ?? protocol.evictionCheckName;
         const failureSignature = issue.lastGitHubFailureSignature
             ?? (failureHeadSha && checkName ? ["queue_eviction", failureHeadSha, checkName].join("::") : null);
-        this.db.upsertIssue({
+        this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             lastGitHubFailureSource: "queue_eviction",
@@ -345,7 +346,7 @@ export class IdleIssueReconciler {
             ...(checkName ? { lastGitHubFailureCheckName: checkName } : {}),
             ...(failureSignature ? { lastGitHubFailureSignature: failureSignature } : {}),
         });
-        const refreshed = this.db.getIssue(issue.projectId, issue.linearIssueId);
+        const refreshed = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
         if (!refreshed)
             return issue;
         this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reclassified stale branch failure as queue repair from GitHub state");
@@ -410,7 +411,7 @@ export class IdleIssueReconciler {
             const previousHeadSha = issue.prHeadSha;
             const gateCheckNames = getGateCheckNames(project);
             const gateCheckStatus = deriveGateCheckStatusFromRollup(pr.statusCheckRollup, gateCheckNames);
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
@@ -433,13 +434,13 @@ export class IdleIssueReconciler {
                     : {}),
             });
             if (pr.state === "MERGED") {
-                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+                this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
                 this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
                 return;
             }
             if (pr.state === "CLOSED") {
                 this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed, re-delegating for implementation");
-                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "closed" });
+                this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "closed" });
                 this.advanceIdleIssue(issue, "delegated", {
                     pendingRunType: "implementation",
                     clearFailureProvenance: true,
@@ -481,7 +482,7 @@ export class IdleIssueReconciler {
             }
             const downstreamOwned = issue.factoryState === "awaiting_queue" || issue.prReviewState === "approved" || pr.reviewDecision === "APPROVED";
             const mergeConflictDetected = pr.mergeable === "CONFLICTING" || pr.mergeStateStatus === "DIRTY";
-            const refreshedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+            const refreshedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
             const reactiveIntent = deriveIssueSessionReactiveIntent({
                 prNumber: refreshedIssue.prNumber,
                 prState: refreshedIssue.prState,
@@ -493,6 +494,16 @@ export class IdleIssueReconciler {
             });
             if ((issue.factoryState === "escalated" || issue.factoryState === "failed")
                 && (reactiveIntent?.runType === "review_fix" || reactiveIntent?.runType === "branch_upkeep")) {
+                if (issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+                    this.logger.debug({
+                        issueKey: issue.issueKey,
+                        prNumber: issue.prNumber,
+                        from: issue.factoryState,
+                        runType: reactiveIntent.runType,
+                        reviewFixAttempts: issue.reviewFixAttempts,
+                    }, "Reconciliation: leaving terminal requested-changes issue escalated because the repair budget is exhausted");
+                    return;
+                }
                 const pendingRunContext = reactiveIntent.runType === "branch_upkeep"
                     ? buildBranchUpkeepContext(issue.prNumber, project.github?.baseBranch ?? "main", pr.mergeStateStatus, pr.headRefOid)
                     : undefined;
@@ -549,7 +560,7 @@ export class IdleIssueReconciler {
                 return;
             }
             if (isReviewDecisionApproved(pr.reviewDecision)) {
-                this.db.upsertIssue({
+                this.db.issues.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     prReviewState: "approved",

package/dist/interrupted-run-recovery.js

@@ -0,0 +1,176 @@
+import { ACTIVE_RUN_STATES } from "./factory-state.js";
+import { buildRunFailureActivity } from "./linear-session-reporting.js";
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
+function isRequestedChangesRunType(runType) {
+    return runType === "review_fix" || runType === "branch_upkeep";
+}
+function resolveRetryRunType(runType, context) {
+    if (runType === "branch_upkeep") {
+        return "branch_upkeep";
+    }
+    return context?.reviewFixMode === "branch_upkeep" || context?.branchUpkeepRequired === true
+        ? "branch_upkeep"
+        : "review_fix";
+}
+function resolvePostRunState(issue) {
+    if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
+        if (issue.prState === "merged")
+            return "done";
+        if (issue.prReviewState === "approved")
+            return "awaiting_queue";
+        return "pr_open";
+    }
+    return undefined;
+}
+export 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);
+}
+export class InterruptedRunRecovery {
+    db;
+    logger;
+    linearSync;
+    withHeldLease;
+    releaseLease;
+    failRunAndClear;
+    restoreIdleWorktree;
+    completionPolicy;
+    enqueueIssue;
+    feed;
+    constructor(db, logger, linearSync, withHeldLease, releaseLease, failRunAndClear, restoreIdleWorktree, completionPolicy, enqueueIssue, feed) {
+        this.db = db;
+        this.logger = logger;
+        this.linearSync = linearSync;
+        this.withHeldLease = withHeldLease;
+        this.releaseLease = releaseLease;
+        this.failRunAndClear = failRunAndClear;
+        this.restoreIdleWorktree = restoreIdleWorktree;
+        this.completionPolicy = completionPolicy;
+        this.enqueueIssue = enqueueIssue;
+        this.feed = feed;
+    }
+    async handle(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) => {
+            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.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        if (isRequestedChangesRunType(run.runType)) {
+            await this.handleInterruptedRequestedChangesRun(run, issue);
+            return;
+        }
+        const recoveredState = resolveRecoverablePostRunState(this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue);
+        this.failRunAndClear(run, "Codex turn was interrupted", recoveredState);
+        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 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 = 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.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+        if (recoveredState === "changes_requested") {
+            this.db.issues.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.releaseLease(run.projectId, run.linearIssueId);
+    }
+}

package/dist/issue-query-service.js

@@ -71,7 +71,7 @@ export class IssueQueryService {
             const legacy = this.db.getIssueOverview(issueKey);
             if (!legacy)
                 return undefined;
-            const issueRecord = this.db.getIssueByKey(issueKey);
+            const issueRecord = this.db.issues.getIssueByKey(issueKey);
             const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
             const activeRun = activeStatus?.run ?? legacy.activeRun;
             const latestRun = this.db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
@@ -123,8 +123,8 @@ export class IssueQueryService {
                     : {}),
             };
         }
-        const issueRecord = this.db.getIssueByKey(issueKey);
-        const blockedBy = this.db.listIssueDependencies(session.projectId, session.linearIssueId);
+        const issueRecord = this.db.issues.getIssueByKey(issueKey);
+        const blockedBy = this.db.issues.listIssueDependencies(session.projectId, session.linearIssueId);
         const unresolvedBlockedBy = blockedBy.filter((entry) => (entry.blockerCurrentLinearStateType !== "completed"
             && entry.blockerCurrentLinearState?.trim().toLowerCase() !== "done"));
         const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
@@ -231,7 +231,7 @@ export class IssueQueryService {
         const overview = await this.getIssueOverview(issueKey);
         if (!overview)
             return undefined;
-        const issueRecord = this.db.getIssueByKey(issueKey);
+        const issueRecord = this.db.issues.getIssueByKey(issueKey);
         const latestRunReport = parseStageReport(overview.latestRun?.reportJson, overview.latestRun?.status ?? "unknown");
         const runs = (overview.runs ?? this.buildRuns(overview.issue.projectId, overview.issue.linearIssueId)).map((run) => ({
             run: {

package/dist/issue-session-projector.js

@@ -0,0 +1,114 @@
+import { isoNow } from "./db/shared.js";
+import { buildTrackedIssueRecord } from "./tracked-issue-projector.js";
+import { extractLatestAssistantSummary, } from "./issue-session-events.js";
+import { deriveIssueSessionState, deriveIssueSessionWakeReason, } from "./issue-session.js";
+export function syncIssueSessionFromIssue(params) {
+    const { connection, issues, issueSessions, runs, issue, options } = params;
+    const existing = issueSessions.getIssueSession(issue.projectId, issue.linearIssueId);
+    const latestRun = runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    const latestRunType = options?.lastRunType ?? latestRun?.runType ?? existing?.lastRunType;
+    const summaryText = resolveIssueSessionSummary(issue, runs, latestRun, existing?.summaryText, options?.summaryText);
+    const activeThreadId = issue.threadId ?? existing?.activeThreadId;
+    const threadGeneration = activeThreadId && activeThreadId !== existing?.activeThreadId
+        ? (existing?.threadGeneration ?? 0) + 1
+        : (existing?.threadGeneration ?? (activeThreadId ? 1 : 0));
+    const sessionState = deriveIssueSessionState({
+        ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
+        factoryState: issue.factoryState,
+    });
+    const tracked = buildTrackedIssueRecord({
+        issue,
+        session: existing,
+        blockedBy: issues.listIssueDependencies(issue.projectId, issue.linearIssueId),
+        hasPendingWake: issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
+        latestRun,
+        latestEvent: issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1),
+    });
+    const lastWakeReason = options?.lastWakeReason
+        ?? deriveIssueSessionWakeReason({
+            pendingRunType: issue.pendingRunType,
+            factoryState: issue.factoryState,
+            prNumber: issue.prNumber,
+            prState: issue.prState,
+            prReviewState: issue.prReviewState,
+            prCheckStatus: issue.prCheckStatus,
+            latestFailureSource: issue.lastGitHubFailureSource,
+        })
+        ?? existing?.lastWakeReason;
+    const now = isoNow();
+    if (existing) {
+        connection.prepare(`
+      UPDATE issue_sessions SET
+        issue_key = ?,
+        repo_id = ?,
+        branch_name = ?,
+        worktree_path = ?,
+        pr_number = ?,
+        pr_head_sha = ?,
+        pr_author_login = ?,
+        session_state = ?,
+        waiting_reason = ?,
+        summary_text = ?,
+        active_thread_id = ?,
+        thread_generation = ?,
+        active_run_id = ?,
+        last_run_type = ?,
+        last_wake_reason = ?,
+        ci_repair_attempts = ?,
+        queue_repair_attempts = ?,
+        review_fix_attempts = ?,
+        updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ?
+    `).run(issue.issueKey ?? null, issue.projectId, issue.branchName ?? null, issue.worktreePath ?? null, issue.prNumber ?? null, issue.prHeadSha ?? null, issue.prAuthorLogin ?? null, sessionState, tracked.waitingReason ?? null, summaryText ?? null, activeThreadId ?? null, threadGeneration, issue.activeRunId ?? null, latestRunType ?? null, lastWakeReason ?? null, issue.ciRepairAttempts, issue.queueRepairAttempts, issue.reviewFixAttempts, now, issue.projectId, issue.linearIssueId);
+        return;
+    }
+    connection.prepare(`
+    INSERT INTO issue_sessions (
+      project_id, linear_issue_id, issue_key, repo_id, branch_name, worktree_path,
+      pr_number, pr_head_sha, pr_author_login, session_state, waiting_reason, summary_text,
+      active_thread_id, thread_generation, active_run_id, last_run_type, last_wake_reason,
+      ci_repair_attempts, queue_repair_attempts, review_fix_attempts,
+      created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(issue.projectId, issue.linearIssueId, issue.issueKey ?? null, issue.projectId, issue.branchName ?? null, issue.worktreePath ?? null, issue.prNumber ?? null, issue.prHeadSha ?? null, issue.prAuthorLogin ?? null, sessionState, tracked.waitingReason ?? null, summaryText ?? null, activeThreadId ?? null, threadGeneration, issue.activeRunId ?? null, latestRunType ?? null, lastWakeReason ?? null, issue.ciRepairAttempts, issue.queueRepairAttempts, issue.reviewFixAttempts, now, now);
+}
+function resolveIssueSessionSummary(issue, runs, latestRun, existingSummaryText, explicitSummaryText) {
+    if (explicitSummaryText?.trim()) {
+        return explicitSummaryText;
+    }
+    const latestSummary = extractLatestAssistantSummary(latestRun);
+    if (latestRun && (latestRun.status === "queued" || latestRun.status === "running")) {
+        return latestSummary;
+    }
+    if (shouldKeepPreviousIssueSummary(issue, latestRun)) {
+        return findLatestCompletedRunSummary(runs, issue.projectId, issue.linearIssueId)
+            ?? existingSummaryText
+            ?? latestSummary;
+    }
+    return latestSummary ?? existingSummaryText;
+}
+function shouldKeepPreviousIssueSummary(issue, latestRun) {
+    if (!latestRun || latestRun.status !== "failed") {
+        return false;
+    }
+    if (latestRun.summaryJson || latestRun.reportJson) {
+        return false;
+    }
+    return issue.factoryState === "pr_open"
+        || issue.factoryState === "awaiting_queue"
+        || issue.factoryState === "done";
+}
+function findLatestCompletedRunSummary(runs, projectId, linearIssueId) {
+    const issueRuns = runs.listRunsForIssue(projectId, linearIssueId);
+    for (let index = issueRuns.length - 1; index >= 0; index -= 1) {
+        const run = issueRuns[index];
+        if (!run || run.status !== "completed") {
+            continue;
+        }
+        const summary = extractLatestAssistantSummary(run);
+        if (summary?.trim()) {
+            return summary;
+        }
+    }
+    return undefined;
+}