patchrelay 0.36.7 → 0.36.9

package/dist/github-webhook-handler.js

@@ -60,11 +60,11 @@ export class GitHubWebhookHandler {
     }
     async acceptGitHubWebhook(params) {
         // Deduplicate
-        if (this.db.isWebhookDuplicate(params.deliveryId)) {
+        if (this.db.webhookEvents.isWebhookDuplicate(params.deliveryId)) {
             return { status: 200, body: { ok: true, duplicate: true } };
         }
         // Store the event
-        const stored = this.db.insertWebhookEvent(params.deliveryId, new Date().toISOString());
+        const stored = this.db.webhookEvents.insertWebhookEvent(params.deliveryId, new Date().toISOString());
         // Parse payload
         const payload = safeJsonParse(params.rawBody.toString("utf8"));
         if (!payload) {
@@ -130,14 +130,14 @@ 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);
         // 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 } : {}),
@@ -158,28 +158,28 @@ 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.
             if (newState && newState !== afterMetadata.factoryState) {
-                this.db.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     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) {
-            this.db.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 ciRepairAttempts: 0,
@@ -240,7 +240,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 +252,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 +279,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 +300,7 @@ export class GitHubWebhookHandler {
             });
             return;
         }
-        this.db.upsertIssue({
+        this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             prCheckStatus: snapshot.gateCheckStatus,
@@ -340,8 +340,8 @@ export class GitHubWebhookHandler {
                 if (this.hasDuplicatePendingReactiveRun(issue, "queue_repair", failureContext)) {
                     return;
                 }
-                const hadPendingWake = this.db.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
-                this.db.upsertIssue({
+                const hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+                this.db.issues.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     lastGitHubFailureSource: "queue_eviction",
@@ -354,7 +354,7 @@ export class GitHubWebhookHandler {
                     lastQueueSignalAt: new Date().toISOString(),
                     lastQueueIncidentJson: JSON.stringify(queueRepairContext),
                 });
-                this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     eventType: "merge_steward_incident",
@@ -364,7 +364,7 @@ export class GitHubWebhookHandler {
                     }),
                     dedupeKey: failureContext.failureSignature,
                 });
-                this.db.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
+                this.db.issueSessions.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
                 const queuedRunType = hadPendingWake
                     ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
                     : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
@@ -397,9 +397,9 @@ export class GitHubWebhookHandler {
                 if (this.hasDuplicatePendingReactiveRun(issue, "ci_repair", failureContext)) {
                     return;
                 }
-                const hadPendingWake = this.db.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+                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",
@@ -411,7 +411,7 @@ export class GitHubWebhookHandler {
                     lastGitHubFailureAt: new Date().toISOString(),
                     lastQueueIncidentJson: null,
                 });
-                this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     eventType: "settled_red_ci",
@@ -422,7 +422,7 @@ export class GitHubWebhookHandler {
                     }),
                     dedupeKey: failureContext.failureSignature,
                 });
-                this.db.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
+                this.db.issueSessions.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
                 const queuedRunType = hadPendingWake
                     ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
                     : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
@@ -440,7 +440,7 @@ export class GitHubWebhookHandler {
             }
         }
         if (event.triggerEvent === "review_changes_requested") {
-            const hadPendingWake = this.db.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+            const hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
             const reviewComments = await this.fetchReviewCommentsForEvent(event).catch((error) => {
                 this.logger.warn({
                     issueKey: issue.issueKey,
@@ -450,7 +450,7 @@ export class GitHubWebhookHandler {
                 }, "Failed to fetch inline review comments for requested-changes event");
                 return undefined;
             });
-            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "review_changes_requested",
@@ -468,7 +468,7 @@ export class GitHubWebhookHandler {
                     event.reviewerName ?? "unknown-reviewer",
                 ].join("::"),
             });
-            this.db.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
+            this.db.issueSessions.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
             const queuedRunType = hadPendingWake
                 ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
                 : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
@@ -489,14 +489,14 @@ export class GitHubWebhookHandler {
     }
     async handleTerminalPrEvent(issue, event) {
         const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
-        this.db.appendIssueSessionEvent({
+        this.db.issueSessions.appendIssueSessionEvent({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             eventType,
             dedupeKey: [eventType, issue.prNumber ?? event.prNumber ?? "unknown-pr", issue.prHeadSha ?? event.headSha ?? "unknown-sha"].join("::"),
         });
-        this.db.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        const run = issue.activeRunId ? this.db.getRun(issue.activeRunId) : undefined;
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        const run = issue.activeRunId ? this.db.runs.getRunById(issue.activeRunId) : undefined;
         if (run?.threadId && run.turnId) {
             try {
                 await this.codex.steerTurn({
@@ -513,29 +513,29 @@ export class GitHubWebhookHandler {
         }
         const commitTerminalUpdate = () => {
             if (run) {
-                this.db.finishRun(run.id, {
+                this.db.runs.finishRun(run.id, {
                     status: "released",
                     failureReason: event.triggerEvent === "pr_merged"
                         ? "Pull request merged during active run"
                         : "Pull request closed during active run",
                 });
             }
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 activeRunId: null,
                 factoryState: event.triggerEvent === "pr_merged" ? "done" : "failed",
             });
         };
-        const activeLease = this.db.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
+        const activeLease = this.db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
         if (activeLease) {
-            this.db.withIssueSessionLease(issue.projectId, issue.linearIssueId, activeLease.leaseId, commitTerminalUpdate);
+            this.db.issueSessions.withIssueSessionLease(issue.projectId, issue.linearIssueId, activeLease.leaseId, commitTerminalUpdate);
         }
         else {
             this.db.transaction(commitTerminalUpdate);
         }
-        this.db.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        const updatedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        const updatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
         if (event.triggerEvent === "pr_merged") {
             await this.completeLinearIssueAfterMerge(updatedIssue);
         }
@@ -554,7 +554,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 +563,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 +587,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 +614,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,
@@ -685,7 +685,7 @@ export class GitHubWebhookHandler {
             : typeof failureContext.headSha === "string" ? failureContext.headSha : undefined;
         if (!signature)
             return false;
-        const pendingWake = this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+        const pendingWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
         if (pendingWake?.runType === runType) {
             const existing = pendingWake.context;
             if (existing?.failureSignature === signature
@@ -763,7 +763,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 +904,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))
@@ -920,7 +920,7 @@ export class GitHubWebhookHandler {
             detail: body.slice(0, 200),
         });
         if (issue.activeRunId) {
-            const run = this.db.getRun(issue.activeRunId);
+            const run = this.db.runs.getRunById(issue.activeRunId);
             if (run?.threadId && run.turnId) {
                 try {
                     await this.codex.steerTurn({
@@ -937,7 +937,7 @@ export class GitHubWebhookHandler {
                 }
             }
         }
-        this.db.appendIssueSessionEvent({
+        this.db.issueSessions.appendIssueSessionEvent({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             eventType: "followup_comment",
@@ -961,10 +961,10 @@ export class GitHubWebhookHandler {
         return response.statusText || `GitHub API responded with ${response.status}`;
     }
     peekPendingSessionWakeRunType(projectId, issueId) {
-        return this.db.peekIssueSessionWake(projectId, issueId)?.runType;
+        return this.db.issueSessions.peekIssueSessionWake(projectId, issueId)?.runType;
     }
     enqueuePendingSessionWake(projectId, issueId) {
-        const wake = this.db.peekIssueSessionWake(projectId, issueId);
+        const wake = this.db.issueSessions.peekIssueSessionWake(projectId, issueId);
         if (!wake) {
             return undefined;
         }

package/dist/idle-reconciliation.js

@@ -110,7 +110,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,21 +145,21 @@ 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.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     eventType: "delegated",
                     dedupeKey: `delegated:${issue.linearIssueId}`,
                 });
-                if (this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
                     this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
                 }
             }
@@ -179,7 +179,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 +206,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");
@@ -220,7 +220,7 @@ export class IdleIssueReconciler {
             status: "reconciled",
             summary: `Reconciliation: ${issue.factoryState} \u2192 ${newState}`,
         });
-        if (options?.pendingRunType && this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+        if (options?.pendingRunType && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
             this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }
@@ -243,7 +243,7 @@ export class IdleIssueReconciler {
             eventType = "delegated";
             dedupeKey = `${dedupeScope}:implementation:${issue.linearIssueId}`;
         }
-        this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             eventType,
@@ -254,7 +254,7 @@ export class IdleIssueReconciler {
     async routeFailedIssue(issue) {
         issue = await this.refreshMissingFailureProvenance(issue);
         issue = await this.reclassifyStaleBranchFailure(issue);
-        const latestRun = this.db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+        const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
         const ignoreDuplicateAttempt = latestRun?.status === "failed"
             && latestRun.failureReason === "Codex turn was interrupted";
         const reactiveIntent = deriveIssueSessionReactiveIntent({
@@ -309,7 +309,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 +317,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 +337,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 +345,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 +410,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 +433,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 +481,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,
@@ -549,7 +549,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);
+    }
+}