patchrelay 0.36.7 → 0.36.9

package/dist/run-recovery-service.js

@@ -0,0 +1,209 @@
+import { buildRunFailureActivity } from "./linear-session-reporting.js";
+const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
+const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000;
+export class RunRecoveryService {
+    db;
+    logger;
+    linearSync;
+    withHeldLease;
+    getHeldLease;
+    appendWakeEventWithLease;
+    releaseLease;
+    enqueueIssue;
+    resolveBranchOwnerForStateTransition;
+    feed;
+    constructor(db, logger, linearSync, withHeldLease, getHeldLease, appendWakeEventWithLease, releaseLease, enqueueIssue, resolveBranchOwnerForStateTransition, feed) {
+        this.db = db;
+        this.logger = logger;
+        this.linearSync = linearSync;
+        this.withHeldLease = withHeldLease;
+        this.getHeldLease = getHeldLease;
+        this.appendWakeEventWithLease = appendWakeEventWithLease;
+        this.releaseLease = releaseLease;
+        this.enqueueIssue = enqueueIssue;
+        this.resolveBranchOwnerForStateTransition = resolveBranchOwnerForStateTransition;
+        this.feed = feed;
+    }
+    recoverOrEscalate(params) {
+        const { issue, runType, reason } = params;
+        const fresh = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
+        if (!fresh)
+            return;
+        if (params.isRequestedChangesRunType(runType)) {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
+                this.db.issueSessions.upsertIssueWithLease(lease, {
+                    projectId: fresh.projectId,
+                    linearIssueId: fresh.linearIssueId,
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                    factoryState: "escalated",
+                });
+                return true;
+            });
+            if (!updated) {
+                this.logger.warn({ issueKey: fresh.issueKey, reason }, "Skipping review-fix recovery escalation after losing issue-session lease");
+                this.releaseLease(fresh.projectId, fresh.linearIssueId);
+                return;
+            }
+            this.logger.warn({ issueKey: fresh.issueKey, reason }, "Requested-changes run failed before a new head was published - escalating");
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: fresh.issueKey,
+                projectId: fresh.projectId,
+                stage: runType,
+                status: "escalated",
+                summary: `Requested-changes run failed before publishing a new head (${reason})`,
+            });
+            this.releaseLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
+        if (fresh.prState === "merged") {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                this.db.issueSessions.upsertIssueWithLease(lease, {
+                    projectId: fresh.projectId,
+                    linearIssueId: fresh.linearIssueId,
+                    factoryState: "done",
+                    zombieRecoveryAttempts: 0,
+                    lastZombieRecoveryAt: null,
+                });
+                return true;
+            });
+            if (!updated) {
+                this.logger.warn({ issueKey: fresh.issueKey, reason }, "Skipping merged recovery completion after losing issue-session lease");
+                this.releaseLease(fresh.projectId, fresh.linearIssueId);
+                return;
+            }
+            this.logger.info({ issueKey: fresh.issueKey, reason }, "Recovery: PR already merged - transitioning to done");
+            this.releaseLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
+        const attempts = fresh.zombieRecoveryAttempts + 1;
+        if (attempts > DEFAULT_ZOMBIE_RECOVERY_BUDGET) {
+            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                this.db.issueSessions.upsertIssueWithLease(lease, {
+                    projectId: fresh.projectId,
+                    linearIssueId: fresh.linearIssueId,
+                    factoryState: "escalated",
+                });
+                return true;
+            });
+            if (!updated) {
+                this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Skipping recovery escalation after losing issue-session lease");
+                this.releaseLease(fresh.projectId, fresh.linearIssueId);
+                return;
+            }
+            this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: budget exhausted - escalating");
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: fresh.issueKey,
+                projectId: fresh.projectId,
+                stage: "escalated",
+                status: "budget_exhausted",
+                summary: `${reason} recovery failed after ${DEFAULT_ZOMBIE_RECOVERY_BUDGET} attempts`,
+            });
+            this.releaseLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
+        if (fresh.lastZombieRecoveryAt) {
+            const elapsed = Date.now() - new Date(fresh.lastZombieRecoveryAt).getTime();
+            const delay = ZOMBIE_RECOVERY_BASE_DELAY_MS * Math.pow(2, fresh.zombieRecoveryAttempts);
+            if (elapsed < delay) {
+                this.logger.debug({ issueKey: fresh.issueKey, attempts: fresh.zombieRecoveryAttempts, delay, elapsed }, "Recovery: backoff not elapsed, skipping");
+                return;
+            }
+        }
+        const requeued = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+            this.db.issueSessions.upsertIssueWithLease(lease, {
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                zombieRecoveryAttempts: attempts,
+                lastZombieRecoveryAt: new Date().toISOString(),
+            });
+            return this.appendWakeEventWithLease(lease, fresh, runType, undefined, `recovery:${attempts}`);
+        });
+        if (!requeued) {
+            this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Skipping recovery re-enqueue after losing issue-session lease");
+            this.releaseLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
+        this.enqueueIssue(fresh.projectId, fresh.linearIssueId);
+        this.logger.info({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: re-enqueued with backoff");
+    }
+    escalate(params) {
+        const { issue, runType, reason } = params;
+        this.logger.warn({ issueKey: issue.issueKey, runType, reason }, "Escalating to human");
+        const escalated = this.withHeldLease(issue.projectId, issue.linearIssueId, (lease) => {
+            if (issue.activeRunId) {
+                this.db.issueSessions.finishRunWithLease(lease, issue.activeRunId, { status: "released" });
+            }
+            this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
+            this.db.issueSessions.upsertIssueWithLease(lease, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                activeRunId: null,
+                factoryState: "escalated",
+            });
+            return true;
+        });
+        if (!escalated) {
+            this.logger.warn({ issueKey: issue.issueKey, runType }, "Skipping escalation write after losing issue-session lease");
+            this.releaseLease(issue.projectId, issue.linearIssueId);
+            return;
+        }
+        this.feed?.publish({
+            level: "error",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: runType,
+            status: "escalated",
+            summary: `Escalated: ${reason}`,
+        });
+        const escalatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        void this.linearSync.emitActivity(escalatedIssue, {
+            type: "error",
+            body: `PatchRelay needs human help to continue.\n\n${reason}`,
+        });
+        void this.linearSync.syncSession(escalatedIssue);
+        this.releaseLease(issue.projectId, issue.linearIssueId);
+    }
+    failRunAndClear(params) {
+        const { run, message, nextState } = params;
+        const updated = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+            this.db.runs.finishRun(run.id, { status: "failed", failureReason: message });
+            if (nextState === "failed" || nextState === "escalated" || nextState === "awaiting_input" || nextState === "done") {
+                this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
+            }
+            this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: null,
+                factoryState: nextState,
+            });
+            const branchOwner = this.resolveBranchOwnerForStateTransition(nextState);
+            if (branchOwner) {
+                const heldLease = this.getHeldLease(run.projectId, run.linearIssueId);
+                if (heldLease) {
+                    this.db.issueSessions.setBranchOwnerWithLease(heldLease, branchOwner);
+                }
+            }
+            return true;
+        });
+        if (!updated) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping failure cleanup after losing issue-session lease");
+        }
+        this.releaseLease(run.projectId, run.linearIssueId);
+    }
+    emitInterruptedFailure(runType, issue, message) {
+        const latest = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        void this.linearSync.emitActivity(latest, buildRunFailureActivity(runType, message));
+        void this.linearSync.syncSession(latest, { activeRunType: runType });
+    }
+}

package/dist/run-wake-planner.js

@@ -0,0 +1,101 @@
+const DEFAULT_CI_REPAIR_BUDGET = 3;
+const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
+const DEFAULT_REVIEW_FIX_BUDGET = 12;
+export class RunWakePlanner {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    resolveRunWake(issue) {
+        const sessionWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+        if (!sessionWake)
+            return undefined;
+        return {
+            runType: sessionWake.runType,
+            context: sessionWake.context,
+            wakeReason: sessionWake.wakeReason,
+            resumeThread: sessionWake.resumeThread,
+            eventIds: sessionWake.eventIds,
+        };
+    }
+    appendWakeEventWithLease(lease, issue, runType, context, dedupeScope) {
+        let eventType;
+        let dedupeKey;
+        if (runType === "queue_repair") {
+            eventType = "merge_steward_incident";
+            dedupeKey = `${dedupeScope ?? "wake"}:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`;
+        }
+        else if (runType === "ci_repair") {
+            eventType = "settled_red_ci";
+            dedupeKey = `${dedupeScope ?? "wake"}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`;
+        }
+        else if (runType === "review_fix" || runType === "branch_upkeep") {
+            eventType = "review_changes_requested";
+            dedupeKey = `${dedupeScope ?? "wake"}:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`;
+        }
+        else {
+            eventType = "delegated";
+            dedupeKey = `${dedupeScope ?? "wake"}:implementation:${issue.linearIssueId}`;
+        }
+        return Boolean(this.db.issueSessions.appendIssueSessionEventWithLease(lease, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType,
+            ...(context ? { eventJson: JSON.stringify(context) } : {}),
+            dedupeKey,
+        }));
+    }
+    materializeLegacyPendingWake(issue, lease) {
+        if (!issue.pendingRunType)
+            return issue;
+        const context = issue.pendingRunContextJson
+            ? JSON.parse(issue.pendingRunContextJson)
+            : undefined;
+        this.appendWakeEventWithLease(lease, issue, issue.pendingRunType, context, "legacy_pending");
+        const updated = this.db.issueSessions.upsertIssueWithLease(lease, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            pendingRunType: null,
+            pendingRunContextJson: null,
+        });
+        if (!updated)
+            return issue;
+        return this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+    }
+    budgetExceeded(issue, runType, isRequestedChangesRunType) {
+        if (runType === "ci_repair" && issue.ciRepairAttempts >= DEFAULT_CI_REPAIR_BUDGET) {
+            return `CI repair budget exhausted (${DEFAULT_CI_REPAIR_BUDGET} attempts)`;
+        }
+        if (runType === "queue_repair" && issue.queueRepairAttempts >= DEFAULT_QUEUE_REPAIR_BUDGET) {
+            return `Queue repair budget exhausted (${DEFAULT_QUEUE_REPAIR_BUDGET} attempts)`;
+        }
+        if (isRequestedChangesRunType(runType) && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+            return `Requested-changes budget exhausted (${DEFAULT_REVIEW_FIX_BUDGET} attempts)`;
+        }
+        return undefined;
+    }
+    incrementAttemptCounters(issue, lease, runType, isRequestedChangesRunType) {
+        if (runType === "ci_repair") {
+            return Boolean(this.db.issueSessions.upsertIssueWithLease(lease, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ciRepairAttempts: issue.ciRepairAttempts + 1,
+            }));
+        }
+        if (runType === "queue_repair") {
+            return Boolean(this.db.issueSessions.upsertIssueWithLease(lease, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                queueRepairAttempts: issue.queueRepairAttempts + 1,
+            }));
+        }
+        if (isRequestedChangesRunType(runType)) {
+            return Boolean(this.db.issueSessions.upsertIssueWithLease(lease, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                reviewFixAttempts: issue.reviewFixAttempts + 1,
+            }));
+        }
+        return true;
+    }
+}

package/dist/service.js

@@ -132,7 +132,7 @@ export class PatchRelayService {
         });
     }
     async start() {
-        this.db.releaseExpiredIssueSessionLeases();
+        this.db.issueSessions.releaseExpiredIssueSessionLeases();
         const repairedInstallations = this.db.linearInstallations.repairProjectInstallations(this.config.projects.map((project) => project.id));
         for (const repair of repairedInstallations) {
             this.logger.info({ projectId: repair.projectId, installationId: repair.installationId, reason: repair.reason }, "Repaired Linear project installation link");
@@ -182,16 +182,16 @@ export class PatchRelayService {
         await this.runtime.stop();
     }
     async syncKnownAgentSessions() {
-        for (const issue of this.db.listIssues()) {
+        for (const issue of this.db.issues.listIssues()) {
             if (issue.factoryState === "done") {
                 continue;
             }
             const syncedIssue = issue.agentSessionId
                 ? issue
                 : (() => {
-                    const recoveredAgentSessionId = this.db.findLatestAgentSessionIdForIssue(issue.linearIssueId);
+                    const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
                     return recoveredAgentSessionId
-                        ? this.db.upsertIssue({
+                        ? this.db.issues.upsertIssue({
                             projectId: issue.projectId,
                             linearIssueId: issue.linearIssueId,
                             agentSessionId: recoveredAgentSessionId,
@@ -201,12 +201,12 @@ export class PatchRelayService {
             if (!syncedIssue.agentSessionId) {
                 continue;
             }
-            const activeRun = syncedIssue.activeRunId ? this.db.getRun(syncedIssue.activeRunId) : undefined;
+            const activeRun = syncedIssue.activeRunId ? this.db.runs.getRunById(syncedIssue.activeRunId) : undefined;
             await this.orchestrator.linearSync.syncSession(syncedIssue, activeRun ? { activeRunType: activeRun.runType } : undefined);
         }
     }
     async recoverDelegatedIssueStateFromLinear() {
-        for (const issue of this.db.listIssuesWithAgentSessions()) {
+        for (const issue of this.db.issues.listIssuesWithAgentSessions()) {
             if (issue.factoryState === "done" || issue.activeRunId !== undefined) {
                 continue;
             }
@@ -222,7 +222,7 @@ export class PatchRelayService {
             if (!liveIssue) {
                 continue;
             }
-            this.db.replaceIssueDependencies({
+            this.db.issues.replaceIssueDependencies({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 blockers: liveIssue.blockedBy.map((blocker) => ({
@@ -234,11 +234,11 @@ export class PatchRelayService {
                 })),
             });
             const delegated = liveIssue.delegateId === installation.actorId;
-            const unresolvedBlockers = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+            const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const shouldRecoverAwaitingInput = delegated
                 && issue.factoryState === "awaiting_input"
-                && this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
-            const updated = this.db.upsertIssue({
+                && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
+            const updated = this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
@@ -255,13 +255,13 @@ export class PatchRelayService {
                 continue;
             }
             if (unresolvedBlockers === 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.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
                 }
                 this.logger.info({ issueKey: updated.issueKey }, "Recovered delegated issue from stale awaiting_input state and re-queued implementation");
@@ -427,7 +427,7 @@ export class PatchRelayService {
             const blockedByCount = Number(row.blocked_by_count ?? 0);
             const hasPendingSessionEvents = Number(row.pending_session_event_count ?? 0) > 0;
             const hasPendingWake = hasPendingSessionEvents
-                || this.db.peekIssueSessionWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
+                || this.db.issueSessions.peekIssueSessionWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
             const readyForExecution = isIssueSessionReadyForExecution({
                 ...(typeof row.session_state === "string" ? { sessionState: String(row.session_state) } : {}),
                 factoryState: String(row.factory_state ?? "delegated"),
@@ -473,7 +473,7 @@ export class PatchRelayService {
                     startedAt: String(row.updated_at),
                 }
                 : undefined;
-            const latestEvent = this.db.listIssueSessionEvents(String(row.project_id), String(row.linear_issue_id), { limit: 1 }).at(-1);
+            const latestEvent = this.db.issueSessions.listIssueSessionEvents(String(row.project_id), String(row.linear_issue_id), { limit: 1 }).at(-1);
             const statusNoteCandidate = deriveIssueStatusNote({
                 issue: { factoryState: String(row.factory_state ?? "delegated") },
                 sessionSummary,
@@ -520,7 +520,7 @@ export class PatchRelayService {
         });
     }
     async promptIssue(issueKey, text, source = "watch") {
-        const issue = this.db.getIssueByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
         // Publish to operator feed so all clients see the prompt
@@ -536,7 +536,7 @@ export class PatchRelayService {
         });
         // If no active run, queue as pending context for the next run
         if (!issue.activeRunId) {
-            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "operator_prompt",
@@ -545,7 +545,7 @@ export class PatchRelayService {
             this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
             return { delivered: false, queued: true };
         }
-        const run = this.db.getRun(issue.activeRunId);
+        const run = this.db.runs.getRunById(issue.activeRunId);
         if (!run?.threadId || !run.turnId) {
             return { error: "Active run has no thread or turn yet" };
         }
@@ -561,7 +561,7 @@ export class PatchRelayService {
             // Turn may have completed between check and steer — queue for next run
             const msg = error instanceof Error ? error.message : String(error);
             this.logger.warn({ issueKey, error: msg }, "steerTurn failed, queuing prompt for next run");
-            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "operator_prompt",
@@ -572,12 +572,12 @@ export class PatchRelayService {
         }
     }
     async stopIssue(issueKey) {
-        const issue = this.db.getIssueByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
         if (!issue.activeRunId)
             return { error: "No active run to stop" };
-        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({
@@ -590,14 +590,14 @@ export class PatchRelayService {
                 // Turn may already be done
             }
         }
-        this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             eventType: "stop_requested",
             dedupeKey: `operator_stop:${issue.linearIssueId}`,
         });
-        this.db.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        this.db.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             factoryState: "awaiting_input",
@@ -613,14 +613,14 @@ export class PatchRelayService {
         return { stopped: true };
     }
     retryIssue(issueKey) {
-        const issue = this.db.getIssueByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
         if (issue.activeRunId)
             return { error: "Issue already has an active run" };
-        const issueSession = this.db.getIssueSession(issue.projectId, issue.linearIssueId);
+        const issueSession = this.db.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId);
         if (issue.prState === "merged") {
-            this.db.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 factoryState: "done",
@@ -650,7 +650,7 @@ export class PatchRelayService {
             factoryState = "implementing";
         }
         this.appendOperatorRetryEvent(issue, runType);
-        this.db.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             factoryState: factoryState,
@@ -664,7 +664,7 @@ export class PatchRelayService {
             status: "retry",
             summary: `Retry queued: ${runType}`,
         });
-        if (this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
             this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
         return { issueKey, runType };
@@ -673,7 +673,7 @@ export class PatchRelayService {
         if (runType === "queue_repair") {
             const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
             const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            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",
@@ -688,7 +688,7 @@ export class PatchRelayService {
         }
         if (runType === "ci_repair") {
             const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            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",
@@ -701,7 +701,7 @@ export class PatchRelayService {
             return;
         }
         if (runType === "review_fix" || runType === "branch_upkeep") {
-            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",
@@ -716,7 +716,7 @@ export class PatchRelayService {
             });
             return;
         }
-        this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             eventType: "delegated",
@@ -733,7 +733,7 @@ export class PatchRelayService {
             stores: {
                 webhookEvents: {
                     insertWebhookEvent: (p) => {
-                        const r = this.db.insertFullWebhookEvent(p);
+                        const r = this.db.webhookEvents.insertFullWebhookEvent(p);
                         return { id: r.id, dedupeStatus: r.dedupeStatus };
                     },
                 },

package/dist/tracked-issue-projector.js

@@ -0,0 +1,69 @@
+import { parseGitHubFailureContext } from "./github-failure-context.js";
+import { isIssueSessionReadyForExecution } from "./issue-session.js";
+import { deriveIssueStatusNote } from "./status-note.js";
+import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+export function isResolvedLinearState(stateType, stateName) {
+    return stateType === "completed" || stateName?.trim().toLowerCase() === "done";
+}
+export function buildTrackedIssueRecord(params) {
+    const unresolvedBlockedBy = params.blockedBy.filter((entry) => !isResolvedLinearState(entry.blockerCurrentLinearStateType, entry.blockerCurrentLinearState));
+    const failureContext = parseGitHubFailureContext(params.issue.lastGitHubFailureContextJson);
+    const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
+    const waitingReason = derivePatchRelayWaitingReason({
+        ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
+        blockedByKeys,
+        factoryState: params.issue.factoryState,
+        pendingRunType: params.issue.pendingRunType,
+        prNumber: params.issue.prNumber,
+        prHeadSha: params.issue.prHeadSha,
+        prReviewState: params.issue.prReviewState,
+        prCheckStatus: params.issue.prCheckStatus,
+        lastBlockingReviewHeadSha: params.issue.lastBlockingReviewHeadSha,
+        latestFailureCheckName: params.issue.lastGitHubFailureCheckName,
+    });
+    const statusNote = deriveIssueStatusNote({
+        issue: params.issue,
+        sessionSummary: params.session?.summaryText,
+        latestRun: params.latestRun,
+        latestEvent: params.latestEvent,
+        failureSummary: failureContext?.summary,
+        blockedByKeys,
+        waitingReason,
+    });
+    return {
+        id: params.issue.id,
+        projectId: params.issue.projectId,
+        linearIssueId: params.issue.linearIssueId,
+        ...(params.issue.issueKey ? { issueKey: params.issue.issueKey } : {}),
+        ...(params.issue.title ? { title: params.issue.title } : {}),
+        ...(params.issue.url ? { issueUrl: params.issue.url } : {}),
+        ...(statusNote ? { statusNote } : {}),
+        ...(params.issue.currentLinearState ? { currentLinearState: params.issue.currentLinearState } : {}),
+        ...(params.session?.sessionState ? { sessionState: params.session.sessionState } : {}),
+        factoryState: params.issue.factoryState,
+        blockedByCount: unresolvedBlockedBy.length,
+        blockedByKeys,
+        readyForExecution: isIssueSessionReadyForExecution({
+            sessionState: params.session?.sessionState,
+            factoryState: params.issue.factoryState,
+            activeRunId: params.issue.activeRunId,
+            blockedByCount: unresolvedBlockedBy.length,
+            hasPendingWake: params.hasPendingWake,
+            hasLegacyPendingRun: params.issue.pendingRunType !== undefined,
+            ...(params.issue.prNumber !== undefined ? { prNumber: params.issue.prNumber } : {}),
+            ...(params.issue.prState ? { prState: params.issue.prState } : {}),
+            ...(params.issue.prReviewState ? { prReviewState: params.issue.prReviewState } : {}),
+            ...(params.issue.prCheckStatus ? { prCheckStatus: params.issue.prCheckStatus } : {}),
+            ...(params.issue.lastGitHubFailureSource ? { latestFailureSource: params.issue.lastGitHubFailureSource } : {}),
+        }),
+        ...(params.issue.lastGitHubFailureSource ? { latestFailureSource: params.issue.lastGitHubFailureSource } : {}),
+        ...(params.issue.lastGitHubFailureHeadSha ? { latestFailureHeadSha: params.issue.lastGitHubFailureHeadSha } : {}),
+        ...(params.issue.lastGitHubFailureCheckName ? { latestFailureCheckName: params.issue.lastGitHubFailureCheckName } : {}),
+        ...(failureContext?.stepName ? { latestFailureStepName: failureContext.stepName } : {}),
+        ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
+        ...(waitingReason ? { waitingReason } : {}),
+        ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
+        ...(params.issue.agentSessionId ? { activeAgentSessionId: params.issue.agentSessionId } : {}),
+        updatedAt: params.issue.updatedAt,
+    };
+}