patchrelay 0.36.7 → 0.36.8

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) {
@@ -163,7 +163,7 @@ export class GitHubWebhookHandler {
             // 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,
@@ -179,7 +179,7 @@ export class GitHubWebhookHandler {
         // 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,
@@ -340,7 +340,7 @@ export class GitHubWebhookHandler {
                 if (this.hasDuplicatePendingReactiveRun(issue, "queue_repair", failureContext)) {
                     return;
                 }
-                const hadPendingWake = this.db.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+                const hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
                 this.db.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
@@ -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,7 +397,7 @@ 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({
                     projectId: issue.projectId,
@@ -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,7 +513,7 @@ 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"
@@ -527,14 +527,14 @@ export class GitHubWebhookHandler {
                 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);
+        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
         const updatedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
         if (event.triggerEvent === "pr_merged") {
             await this.completeLinearIssueAfterMerge(updatedIssue);
@@ -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
@@ -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

@@ -153,13 +153,13 @@ export class IdleIssueReconciler {
         for (const issue of this.db.listBlockedDelegatedIssues()) {
             const unresolved = this.db.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);
                 }
             }
@@ -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({

package/dist/issue-query-service.js

@@ -29,7 +29,7 @@ export class IssueQueryService {
         return await this.codex.readThread(run.threadId, true).catch(() => undefined);
     }
     buildRuns(projectId, linearIssueId) {
-        return this.db.listRunsForIssue(projectId, linearIssueId).map((run) => ({
+        return this.db.runs.listRunsForIssue(projectId, linearIssueId).map((run) => ({
             id: run.id,
             runType: run.runType,
             status: run.status,
@@ -41,7 +41,7 @@ export class IssueQueryService {
                 return report ? { report } : {};
             })(),
             ...(() => {
-                const events = this.db.listThreadEvents(run.id).flatMap((event) => {
+                const events = this.db.runs.listThreadEvents(run.id).flatMap((event) => {
                     try {
                         const parsed = JSON.parse(event.eventJson);
                         return [{
@@ -66,7 +66,7 @@ export class IssueQueryService {
         }));
     }
     async getIssueOverview(issueKey) {
-        const session = this.db.getIssueSessionByKey(issueKey);
+        const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
         if (!session) {
             const legacy = this.db.getIssueOverview(issueKey);
             if (!legacy)
@@ -74,8 +74,8 @@ export class IssueQueryService {
             const issueRecord = this.db.getIssueByKey(issueKey);
             const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
             const activeRun = activeStatus?.run ?? legacy.activeRun;
-            const latestRun = this.db.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
-            const latestEvent = this.db.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
+            const latestRun = this.db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
+            const latestEvent = this.db.issueSessions.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
             const runs = this.buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
             const runCount = runs.length;
             const liveThread = await this.readLiveThread(activeRun);
@@ -130,9 +130,9 @@ export class IssueQueryService {
         const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
         const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
         const activeRun = activeStatus?.run
-            ?? (session.activeRunId !== undefined ? this.db.getRun(session.activeRunId) : undefined);
-        const latestRun = this.db.getLatestRunForIssue(session.projectId, session.linearIssueId);
-        const latestEvent = this.db.listIssueSessionEvents(session.projectId, session.linearIssueId, { limit: 1 }).at(-1);
+            ?? (session.activeRunId !== undefined ? this.db.runs.getRunById(session.activeRunId) : undefined);
+        const latestRun = this.db.runs.getLatestRunForIssue(session.projectId, session.linearIssueId);
+        const latestEvent = this.db.issueSessions.listIssueSessionEvents(session.projectId, session.linearIssueId, { limit: 1 }).at(-1);
         const runs = this.buildRuns(session.projectId, session.linearIssueId);
         const runCount = runs.length;
         const liveThread = await this.readLiveThread(activeRun);
@@ -166,7 +166,7 @@ export class IssueQueryService {
                 factoryState: issueRecord?.factoryState ?? "delegated",
                 ...(activeRun ? { activeRunId: activeRun.id } : {}),
                 blockedByCount: unresolvedBlockedBy.length,
-                hasPendingWake: this.db.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
+                hasPendingWake: this.db.issueSessions.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
                 hasLegacyPendingRun: issueRecord?.pendingRunType !== undefined,
                 ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),
                 ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),

package/dist/issue-session-lease-service.js

@@ -0,0 +1,143 @@
+import { randomUUID } from "node:crypto";
+import { getThreadTurns } from "./codex-thread-utils.js";
+const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
+export class IssueSessionLeaseService {
+    db;
+    logger;
+    workerId;
+    readThreadWithRetry;
+    activeSessionLeases = new Map();
+    constructor(db, logger, workerId, readThreadWithRetry) {
+        this.db = db;
+        this.logger = logger;
+        this.workerId = workerId;
+        this.readThreadWithRetry = readThreadWithRetry;
+    }
+    hasLocalLease(projectId, linearIssueId) {
+        return this.activeSessionLeases.has(this.issueSessionLeaseKey(projectId, linearIssueId));
+    }
+    getHeldLease(projectId, linearIssueId) {
+        const leaseId = this.activeSessionLeases.get(this.issueSessionLeaseKey(projectId, linearIssueId));
+        if (!leaseId)
+            return undefined;
+        return { projectId, linearIssueId, leaseId };
+    }
+    withHeldLease(projectId, linearIssueId, fn) {
+        const lease = this.getHeldLease(projectId, linearIssueId);
+        if (!lease)
+            return undefined;
+        return this.db.issueSessions.withIssueSessionLease(projectId, linearIssueId, lease.leaseId, () => fn(lease));
+    }
+    acquire(projectId, linearIssueId) {
+        const leaseId = randomUUID();
+        const leasedUntil = new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString();
+        const acquired = this.db.issueSessions.acquireIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            workerId: this.workerId,
+            leasedUntil,
+        });
+        if (!acquired)
+            return undefined;
+        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
+        return leaseId;
+    }
+    forceAcquire(projectId, linearIssueId) {
+        const leaseId = randomUUID();
+        const leasedUntil = new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString();
+        const acquired = this.db.issueSessions.forceAcquireIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            workerId: this.workerId,
+            leasedUntil,
+        });
+        if (!acquired)
+            return undefined;
+        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
+        return leaseId;
+    }
+    claimForReconciliation(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        if (this.activeSessionLeases.has(key)) {
+            return "owned";
+        }
+        const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
+        if (!session)
+            return "skip";
+        const leasedUntilMs = session.leasedUntil ? Date.parse(session.leasedUntil) : undefined;
+        if (leasedUntilMs !== undefined && Number.isFinite(leasedUntilMs) && leasedUntilMs > Date.now()) {
+            return "skip";
+        }
+        return this.acquire(projectId, linearIssueId) ? true : "skip";
+    }
+    async reclaimForeignRecoveryLeaseIfSafe(run, issue) {
+        const key = this.issueSessionLeaseKey(run.projectId, run.linearIssueId);
+        if (this.activeSessionLeases.has(key)) {
+            return false;
+        }
+        const session = this.db.issueSessions.getIssueSession(run.projectId, run.linearIssueId);
+        if (!session?.leaseId || !session.workerId || session.workerId === this.workerId) {
+            return false;
+        }
+        if (issue.activeRunId !== run.id) {
+            return false;
+        }
+        let safeToReclaim = !run.threadId;
+        if (!safeToReclaim && run.threadId) {
+            try {
+                const thread = await this.readThreadWithRetry(run.threadId, 1);
+                const latestTurn = getThreadTurns(thread).at(-1);
+                safeToReclaim = thread.status === "notLoaded"
+                    || latestTurn?.status === "interrupted"
+                    || latestTurn?.status === "completed";
+            }
+            catch {
+                safeToReclaim = true;
+            }
+        }
+        if (!safeToReclaim) {
+            return false;
+        }
+        const leaseId = this.forceAcquire(run.projectId, run.linearIssueId);
+        if (!leaseId) {
+            return false;
+        }
+        this.logger.info({
+            issueKey: issue.issueKey,
+            runId: run.id,
+            previousWorkerId: session.workerId,
+            previousLeaseId: session.leaseId,
+            reclaimedLeaseId: leaseId,
+        }, "Reclaimed foreign issue-session lease for active-run recovery");
+        return true;
+    }
+    heartbeat(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        const leaseId = this.activeSessionLeases.get(key) ?? this.db.issueSessions.getIssueSession(projectId, linearIssueId)?.leaseId;
+        if (!leaseId)
+            return false;
+        const renewed = this.db.issueSessions.renewIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            leasedUntil: new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString(),
+        });
+        if (renewed) {
+            this.activeSessionLeases.set(key, leaseId);
+            return true;
+        }
+        this.activeSessionLeases.delete(key);
+        return false;
+    }
+    release(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        const leaseId = this.activeSessionLeases.get(key);
+        this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, leaseId);
+        this.activeSessionLeases.delete(key);
+    }
+    issueSessionLeaseKey(projectId, linearIssueId) {
+        return `${projectId}:${linearIssueId}`;
+    }
+}

package/dist/linear-session-sync.js

@@ -22,7 +22,7 @@ export class LinearSessionSync {
         if (issue.agentSessionId) {
             return issue;
         }
-        const recoveredAgentSessionId = this.db.findLatestAgentSessionIdForIssue(issue.linearIssueId);
+        const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
         if (!recoveredAgentSessionId)
             return issue;
         this.logger.info({ issueKey: issue.issueKey, agentSessionId: recoveredAgentSessionId }, "Recovered missing Linear agent session id from webhook history");
@@ -229,9 +229,9 @@ function resolveProgressActivity(notification) {
     return undefined;
 }
 function renderStatusComment(db, issue, trackedIssue, options) {
-    const activeRun = issue.activeRunId ? db.getRun(issue.activeRunId) : undefined;
-    const latestRun = db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
-    const latestEvent = db.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1);
+    const activeRun = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;
+    const latestRun = db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    const latestEvent = db.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1);
     const activeRunType = issue.activeRunId !== undefined
         ? (options?.activeRunType ?? activeRun?.runType)
         : undefined;

package/dist/queue-health-monitor.js

@@ -107,7 +107,7 @@ export class QueueHealthMonitor {
                 lastAttemptedFailureHeadSha: headRefOid,
                 lastAttemptedFailureSignature: signature,
             });
-            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",
@@ -115,7 +115,7 @@ export class QueueHealthMonitor {
                 dedupeKey: `queue_health:queue_repair:${issue.linearIssueId}:${signature}`,
             });
             this.advancer.advanceIdleIssue(issue, "repairing_queue");
-            if (this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
                 this.advancer.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
             this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");

package/dist/run-finalizer.js

@@ -0,0 +1,161 @@
+import { buildStageReport, countEventMethods } from "./run-reporting.js";
+import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
+export class RunFinalizer {
+    db;
+    logger;
+    linearSync;
+    enqueueIssue;
+    feed;
+    constructor(db, logger, linearSync, enqueueIssue, feed) {
+        this.db = db;
+        this.logger = logger;
+        this.linearSync = linearSync;
+        this.enqueueIssue = enqueueIssue;
+        this.feed = feed;
+    }
+    async finalizeCompletedRun(params) {
+        const { run, issue, thread, threadId } = params;
+        const trackedIssue = this.db.issueToTrackedIssue(issue);
+        const report = buildStageReport({ ...run, status: "completed" }, trackedIssue, thread, countEventMethods(this.db.runs.listThreadEvents(run.id)));
+        const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        const verifiedRepairError = await params.verifyReactiveRunAdvancedBranch(run, freshIssue);
+        if (verifiedRepairError) {
+            const holdState = params.resolveRecoverableRunState(freshIssue) ?? "failed";
+            params.failRunAndClear(run, verifiedRepairError, holdState);
+            const heldIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "warn",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "branch_not_advanced",
+                summary: verifiedRepairError,
+            });
+            void this.linearSync.emitActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
+            void this.linearSync.syncSession(heldIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            params.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        const missingReviewFixHeadError = await params.verifyReviewFixAdvancedHead(run, freshIssue);
+        if (missingReviewFixHeadError) {
+            params.failRunAndClear(run, missingReviewFixHeadError, "escalated");
+            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "error",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "same_head_review_handoff_blocked",
+                summary: missingReviewFixHeadError,
+            });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, missingReviewFixHeadError));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            params.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        const publishedOutcomeError = await params.verifyPublishedRunOutcome(run, freshIssue);
+        if (publishedOutcomeError) {
+            params.failRunAndClear(run, publishedOutcomeError, "failed");
+            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "warn",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "publish_incomplete",
+                summary: publishedOutcomeError,
+            });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, publishedOutcomeError));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            if (params.source === "notification") {
+                params.releaseLease(run.projectId, run.linearIssueId);
+            }
+            return;
+        }
+        const refreshedIssue = await params.refreshIssueAfterReactivePublish(run, freshIssue);
+        const postRunFollowUp = await params.resolvePostRunFollowUp(run, refreshedIssue);
+        const postRunState = postRunFollowUp?.factoryState ?? params.resolveCompletedRunState(refreshedIssue, run);
+        const completed = params.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+            this.db.runs.finishRun(run.id, {
+                status: "completed",
+                threadId,
+                ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
+                summaryJson: JSON.stringify({ latestAssistantMessage: report.assistantMessages.at(-1) ?? null }),
+                reportJson: JSON.stringify(report),
+            });
+            this.db.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: null,
+                ...(postRunState ? { factoryState: postRunState } : {}),
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                ...(postRunFollowUp ? {} : (postRunState === "awaiting_queue" || postRunState === "done"
+                    ? {
+                        lastGitHubFailureSource: null,
+                        lastGitHubFailureHeadSha: null,
+                        lastGitHubFailureSignature: null,
+                        lastGitHubFailureCheckName: null,
+                        lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureContextJson: null,
+                        lastGitHubFailureAt: null,
+                        lastQueueIncidentJson: null,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
+                    }
+                    : {})),
+            });
+            if (postRunFollowUp) {
+                return params.appendWakeEventWithLease(lease, issue, postRunFollowUp.pendingRunType, postRunFollowUp.context, "post_run");
+            }
+            return true;
+        });
+        if (!completed) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping completion writes after losing issue-session lease");
+            this.linearSync.clearProgress(run.id);
+            params.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        if (postRunFollowUp) {
+            this.feed?.publish({
+                level: "info",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: run.projectId,
+                stage: postRunFollowUp.factoryState,
+                status: "follow_up_queued",
+                summary: postRunFollowUp.summary,
+            });
+            this.enqueueIssue(run.projectId, run.linearIssueId);
+        }
+        this.feed?.publish({
+            level: "info",
+            kind: "turn",
+            issueKey: issue.issueKey,
+            projectId: run.projectId,
+            stage: run.runType,
+            status: "completed",
+            summary: params.source === "notification"
+                ? `Turn completed for ${run.runType}`
+                : `Reconciliation: ${run.runType} completed${postRunState ? ` -> ${postRunState}` : ""}`,
+            ...(report.assistantMessages.at(-1) ? { detail: report.assistantMessages.at(-1) } : {}),
+        });
+        const updatedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+        const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
+        void this.linearSync.emitActivity(updatedIssue, buildRunCompletedActivity({
+            runType: run.runType,
+            completionSummary,
+            postRunState: updatedIssue.factoryState,
+            ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
+        }));
+        void this.linearSync.syncSession(updatedIssue);
+        this.linearSync.clearProgress(run.id);
+        params.releaseLease(run.projectId, run.linearIssueId);
+    }
+}