patchrelay 0.75.2 → 0.76.0

package/dist/github-webhook-state-projector.js

@@ -5,6 +5,7 @@ import { canClearFailureProvenance, deriveImmediatePrCheckStatus, getGateCheckNa
 import { buildGitHubQueueFailureContext, resolveGitHubBranchFailureContext, } from "./github-webhook-failure-context.js";
 import { emitGitHubLinearActivity, syncGitHubLinearSession } from "./github-linear-session-sync.js";
 import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
+const WRITER = "github-webhook-state-projector";
 export async function projectGitHubWebhookState(deps, issue, event, project, linkedBy) {
     const failureContextResolver = deps.failureContextResolver ?? createGitHubFailureContextResolver();
     const ciSnapshotResolver = deps.ciSnapshotResolver ?? createGitHubCiSnapshotResolver();
@@ -15,26 +16,31 @@ export async function projectGitHubWebhookState(deps, issue, event, project, lin
     // the field when a base ref reverts to the default (e.g. parent
     // landed and GitHub auto-retargeted) or when the PR closes.
     const parentPrBranch = computeParentPrBranchUpdate(event, project);
-    deps.db.issues.upsertIssue({
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
-        ...(event.prNumber !== undefined ? { prNumber: event.prNumber } : {}),
-        ...(event.prUrl !== undefined ? { prUrl: event.prUrl } : {}),
-        ...(event.prState !== undefined ? { prState: event.prState } : {}),
-        ...(event.headSha !== undefined ? { prHeadSha: event.headSha } : {}),
-        ...(event.prAuthorLogin !== undefined ? { prAuthorLogin: event.prAuthorLogin } : {}),
-        ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
-        ...(immediateCheckStatus !== undefined ? { prCheckStatus: immediateCheckStatus } : {}),
-        ...(linkedBy === "issue_key" ? { branchName: event.branchName } : {}),
-        ...(parentPrBranch !== undefined ? { parentPrBranch } : {}),
-        ...(event.reviewState === "changes_requested"
-            ? { lastBlockingReviewHeadSha: event.reviewCommitId ?? event.headSha ?? null }
-            : event.reviewState === "approved"
-                ? { lastBlockingReviewHeadSha: null }
+    // Unconditional commit: every field below is a fact carried by the webhook
+    // payload itself, not derived from a prior read of the issue row.
+    deps.db.issueSessions.commitIssueState({
+        writer: WRITER,
+        update: {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(event.prNumber !== undefined ? { prNumber: event.prNumber } : {}),
+            ...(event.prUrl !== undefined ? { prUrl: event.prUrl } : {}),
+            ...(event.prState !== undefined ? { prState: event.prState } : {}),
+            ...(event.headSha !== undefined ? { prHeadSha: event.headSha } : {}),
+            ...(event.prAuthorLogin !== undefined ? { prAuthorLogin: event.prAuthorLogin } : {}),
+            ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
+            ...(immediateCheckStatus !== undefined ? { prCheckStatus: immediateCheckStatus } : {}),
+            ...(linkedBy === "issue_key" ? { branchName: event.branchName } : {}),
+            ...(parentPrBranch !== undefined ? { parentPrBranch } : {}),
+            ...(event.reviewState === "changes_requested"
+                ? { lastBlockingReviewHeadSha: event.reviewCommitId ?? event.headSha ?? null }
+                : event.reviewState === "approved"
+                    ? { lastBlockingReviewHeadSha: null }
+                    : {}),
+            ...(event.triggerEvent === "pr_closed"
+                ? buildClosedPrCleanupFields()
                 : {}),
-        ...(event.triggerEvent === "pr_closed"
-            ? buildClosedPrCleanupFields()
-            : {}),
+        },
     });
     await updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotResolver);
     await updateGitHubFailureProvenance(deps, issue, event, project, failureContextResolver);
@@ -51,66 +57,96 @@ export async function projectGitHubWebhookState(deps, issue, event, project, lin
             }
             : undefined);
         if (newState && newState !== afterMetadata.factoryState) {
-            deps.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                factoryState: newState,
-            });
-            deps.logger.info({ issueKey: issue.issueKey, from: afterMetadata.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
-            // Plan §4.4: when the transition fired *because* an approval
-            // landed during a review_fix run on the same head (the
-            // mid-run-approval rule), the run's premise is gone. Mark it
-            // superseded and set the publication-suppression flag so the
-            // finalizer cannot push a cosmetic patch-id-equivalent commit.
-            maybeSupersedeActiveRun({
-                db: deps.db,
-                logger: deps.logger,
-                feed: deps.feed,
-                issue: afterMetadata,
-                newState,
-                event,
-                activeRun,
-            });
-            const transitionedIssue = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-            void emitGitHubLinearActivity({
-                linearProvider: deps.linearProvider,
-                logger: deps.logger,
-                feed: deps.feed,
-                issue: transitionedIssue,
-                newState,
-                event,
-            });
-            void syncGitHubLinearSession({
-                config: deps.config,
-                linearProvider: deps.linearProvider,
-                logger: deps.logger,
-                issue: transitionedIssue,
+            const transitionCommit = deps.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                expectedVersion: afterMetadata.version,
+                update: {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    factoryState: newState,
+                },
+                // Conflict: another writer landed since `afterMetadata` was read.
+                // Re-resolve the transition against the fresh row so we never
+                // regress a state someone else just advanced.
+                onConflict: (current) => {
+                    const recomputed = resolveGitHubFactoryStateForEvent(current, event, project, activeRun
+                        ? {
+                            ...(activeRun.runType ? { runType: activeRun.runType } : {}),
+                            ...(activeRun.sourceHeadSha ? { sourceHeadSha: activeRun.sourceHeadSha } : {}),
+                        }
+                        : undefined);
+                    if (!recomputed || recomputed === current.factoryState)
+                        return undefined;
+                    return {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        factoryState: recomputed,
+                    };
+                },
             });
+            const appliedState = transitionCommit.outcome === "applied"
+                ? transitionCommit.issue.factoryState
+                : undefined;
+            if (appliedState) {
+                deps.logger.info({ issueKey: issue.issueKey, from: afterMetadata.factoryState, to: appliedState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
+                // Plan §4.4: when the transition fired *because* an approval
+                // landed during a review_fix run on the same head (the
+                // mid-run-approval rule), the run's premise is gone. Mark it
+                // superseded and set the publication-suppression flag so the
+                // finalizer cannot push a cosmetic patch-id-equivalent commit.
+                maybeSupersedeActiveRun({
+                    db: deps.db,
+                    logger: deps.logger,
+                    feed: deps.feed,
+                    issue: afterMetadata,
+                    newState: appliedState,
+                    event,
+                    activeRun,
+                });
+                const transitionedIssue = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+                void emitGitHubLinearActivity({
+                    linearProvider: deps.linearProvider,
+                    logger: deps.logger,
+                    feed: deps.feed,
+                    issue: transitionedIssue,
+                    newState: appliedState,
+                    event,
+                });
+                void syncGitHubLinearSession({
+                    config: deps.config,
+                    linearProvider: deps.linearProvider,
+                    logger: deps.logger,
+                    issue: transitionedIssue,
+                });
+            }
         }
     }
     const freshIssue = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
     if (event.triggerEvent === "pr_synchronize" && !freshIssue.activeRunId) {
-        deps.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ciRepairAttempts: 0,
-            queueRepairAttempts: 0,
-            lastGitHubFailureSource: null,
-            lastGitHubFailureHeadSha: null,
-            lastGitHubFailureSignature: null,
-            lastGitHubFailureCheckName: null,
-            lastGitHubFailureCheckUrl: null,
-            lastGitHubFailureContextJson: null,
-            lastGitHubFailureAt: null,
-            lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
-            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
-            lastGitHubCiSnapshotGateCheckStatus: "pending",
-            lastGitHubCiSnapshotJson: null,
-            lastGitHubCiSnapshotSettledAt: null,
-            lastQueueIncidentJson: null,
-            lastAttemptedFailureHeadSha: null,
-            lastAttemptedFailureSignature: null,
-            lastAttemptedFailureAt: null,
+        deps.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ciRepairAttempts: 0,
+                queueRepairAttempts: 0,
+                lastGitHubFailureSource: null,
+                lastGitHubFailureHeadSha: null,
+                lastGitHubFailureSignature: null,
+                lastGitHubFailureCheckName: null,
+                lastGitHubFailureCheckUrl: null,
+                lastGitHubFailureContextJson: null,
+                lastGitHubFailureAt: null,
+                lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
+                lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+                lastGitHubCiSnapshotGateCheckStatus: "pending",
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: null,
+                lastQueueIncidentJson: null,
+                lastAttemptedFailureHeadSha: null,
+                lastAttemptedFailureSignature: null,
+                lastAttemptedFailureAt: null,
+            },
         });
     }
     deps.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
@@ -181,27 +217,33 @@ function maybeSupersedeActiveRun(params) {
 }
 async function updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotResolver) {
     if (event.triggerEvent === "pr_merged") {
-        deps.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            lastGitHubCiSnapshotHeadSha: null,
-            lastGitHubCiSnapshotGateCheckName: null,
-            lastGitHubCiSnapshotGateCheckStatus: null,
-            lastGitHubCiSnapshotJson: null,
-            lastGitHubCiSnapshotSettledAt: null,
+        deps.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubCiSnapshotHeadSha: null,
+                lastGitHubCiSnapshotGateCheckName: null,
+                lastGitHubCiSnapshotGateCheckStatus: null,
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: null,
+            },
         });
         return;
     }
     if (event.triggerEvent === "pr_synchronize") {
-        deps.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            prCheckStatus: "pending",
-            lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
-            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
-            lastGitHubCiSnapshotGateCheckStatus: "pending",
-            lastGitHubCiSnapshotJson: null,
-            lastGitHubCiSnapshotSettledAt: null,
+        deps.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                prCheckStatus: "pending",
+                lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
+                lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+                lastGitHubCiSnapshotGateCheckStatus: "pending",
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: null,
+            },
         });
         return;
     }
@@ -216,32 +258,42 @@ async function updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotRes
     if (isStaleGateEvent(issue, event))
         return;
     if (event.triggerEvent === "check_pending") {
-        deps.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            prCheckStatus: "pending",
-            lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
-            lastGitHubCiSnapshotGateCheckName: event.checkName ?? getPrimaryGateCheckName(project),
-            lastGitHubCiSnapshotGateCheckStatus: "pending",
-            lastGitHubCiSnapshotJson: null,
-            lastGitHubCiSnapshotSettledAt: null,
+        deps.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                prCheckStatus: "pending",
+                lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
+                lastGitHubCiSnapshotGateCheckName: event.checkName ?? getPrimaryGateCheckName(project),
+                lastGitHubCiSnapshotGateCheckStatus: "pending",
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: null,
+            },
         });
         return;
     }
+    // Version read just before the async snapshot resolution: a conflict on the
+    // write below means another writer landed while we were calling GitHub.
+    const preResolveVersion = (deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue).version;
     const snapshot = await ciSnapshotResolver.resolve({
         repoFullName: project?.github?.repoFullName ?? event.repoFullName,
         event,
         gateCheckNames: getGateCheckNames(project),
     });
     if (!snapshot) {
-        deps.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
-            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
-            lastGitHubCiSnapshotGateCheckStatus: "pending",
-            lastGitHubCiSnapshotJson: null,
-            lastGitHubCiSnapshotSettledAt: null,
+        deps.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            expectedVersion: preResolveVersion,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
+                lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+                lastGitHubCiSnapshotGateCheckStatus: "pending",
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: null,
+            },
         });
         deps.logger.warn({ issueKey: issue.issueKey, repoFullName: project?.github?.repoFullName ?? event.repoFullName, headSha: event.headSha }, "Could not resolve settled CI snapshot; waiting before CI repair");
         deps.feed?.publish({
@@ -255,15 +307,19 @@ async function updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotRes
         });
         return;
     }
-    deps.db.issues.upsertIssue({
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
-        prCheckStatus: snapshot.gateCheckStatus,
-        lastGitHubCiSnapshotHeadSha: snapshot.headSha,
-        lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName ?? getPrimaryGateCheckName(project),
-        lastGitHubCiSnapshotGateCheckStatus: snapshot.gateCheckStatus,
-        lastGitHubCiSnapshotJson: JSON.stringify(snapshot),
-        lastGitHubCiSnapshotSettledAt: snapshot.settledAt ?? null,
+    deps.db.issueSessions.commitIssueState({
+        writer: WRITER,
+        expectedVersion: preResolveVersion,
+        update: {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            prCheckStatus: snapshot.gateCheckStatus,
+            lastGitHubCiSnapshotHeadSha: snapshot.headSha,
+            lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName ?? getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: snapshot.gateCheckStatus,
+            lastGitHubCiSnapshotJson: JSON.stringify(snapshot),
+            lastGitHubCiSnapshotSettledAt: snapshot.settledAt ?? null,
+        },
     });
 }
 async function updateGitHubFailureProvenance(deps, issue, event, project, failureContextResolver) {
@@ -275,6 +331,8 @@ async function updateGitHubFailureProvenance(deps, issue, event, project, failur
         if (source === "branch_ci" && !isSettledBranchFailure(deps.db, issue, event, project)) {
             return;
         }
+        // Version read before the (possibly async) failure-context resolution.
+        const preResolveVersion = (deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue).version;
         const failureContext = source === "queue_eviction"
             ? buildGitHubQueueFailureContext(event, project, buildQueueRepairContextFromEvent(event))
             : await resolveGitHubBranchFailureContext({
@@ -284,24 +342,28 @@ async function updateGitHubFailureProvenance(deps, issue, event, project, failur
                 project,
                 failureContextResolver,
             });
-        deps.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            lastGitHubFailureSource: source,
-            lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? event.headSha ?? null,
-            lastGitHubFailureSignature: failureContext.failureSignature ?? null,
-            lastGitHubFailureCheckName: failureContext.checkName ?? event.checkName ?? null,
-            lastGitHubFailureCheckUrl: failureContext.checkUrl ?? event.checkUrl ?? null,
-            lastGitHubFailureContextJson: JSON.stringify(failureContext),
-            lastGitHubFailureAt: new Date().toISOString(),
-            ...(source === "queue_eviction"
-                ? {
-                    lastQueueSignalAt: new Date().toISOString(),
-                    lastQueueIncidentJson: JSON.stringify(buildQueueRepairContextFromEvent(event)),
-                }
-                : {
-                    lastQueueIncidentJson: null,
-                }),
+        deps.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            expectedVersion: preResolveVersion,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubFailureSource: source,
+                lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? event.headSha ?? null,
+                lastGitHubFailureSignature: failureContext.failureSignature ?? null,
+                lastGitHubFailureCheckName: failureContext.checkName ?? event.checkName ?? null,
+                lastGitHubFailureCheckUrl: failureContext.checkUrl ?? event.checkUrl ?? null,
+                lastGitHubFailureContextJson: JSON.stringify(failureContext),
+                lastGitHubFailureAt: new Date().toISOString(),
+                ...(source === "queue_eviction"
+                    ? {
+                        lastQueueSignalAt: new Date().toISOString(),
+                        lastQueueIncidentJson: JSON.stringify(buildQueueRepairContextFromEvent(event)),
+                    }
+                    : {
+                        lastQueueIncidentJson: null,
+                    }),
+            },
         });
         return;
     }
@@ -311,10 +373,13 @@ async function updateGitHubFailureProvenance(deps, issue, event, project, failur
         if (event.triggerEvent === "check_passed" && !canClearFailureProvenance(issue, event, project)) {
             return;
         }
-        deps.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...CLEARED_FAILURE_PROVENANCE,
+        deps.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...CLEARED_FAILURE_PROVENANCE,
+            },
         });
     }
 }

package/dist/github-webhook-terminal-handler.js

@@ -3,6 +3,7 @@ import { resolvePostMergeFactoryState } from "./post-merge-deploy.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { syncGitHubLinearSession } from "./github-linear-session-sync.js";
 import { wakeOrchestrationParentsForChildEvent } from "./orchestration-parent-wake.js";
+const WRITER = "github-webhook-terminal-handler";
 export async function handleGitHubTerminalPrEvent(params) {
     const { db, linearProvider, wakeDispatcher, logger, codex, issue, event, config } = params;
     const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
@@ -33,32 +34,35 @@ export async function handleGitHubTerminalPrEvent(params) {
             logger.warn({ issueKey: issue.issueKey, runId: run.id, error: error instanceof Error ? error.message : String(error) }, "Failed to steer active run after terminal PR event");
         }
     }
-    const commitTerminalUpdate = () => {
-        if (run) {
-            db.runs.finishRun(run.id, {
-                status: "released",
-                failureReason: event.triggerEvent === "pr_merged"
-                    ? "Pull request merged during active run"
-                    : "Pull request closed during active run",
-            });
-        }
+    const buildTerminalUpdate = (row) => {
         const terminalFactoryState = event.triggerEvent === "pr_merged"
             ? postMergeState
-            : resolveClosedPrFactoryState(issue);
-        db.issues.upsertIssue({
+            : resolveClosedPrFactoryState(row);
+        return {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             activeRunId: null,
             factoryState: terminalFactoryState,
             ...(terminalFactoryState === "deploying" ? { deployStartedAt: new Date().toISOString() } : {}),
-        });
+        };
     };
     const activeLease = db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
-    if (activeLease) {
-        db.issueSessions.withIssueSessionLease(issue.projectId, issue.linearIssueId, activeLease.leaseId, commitTerminalUpdate);
-    }
-    else {
-        db.transaction(commitTerminalUpdate);
+    const terminalCommit = db.issueSessions.commitIssueState({
+        writer: WRITER,
+        expectedVersion: issue.version,
+        ...(activeLease ? { lease: activeLease } : {}),
+        update: buildTerminalUpdate(issue),
+        // The terminal PR fact comes from GitHub; re-derive the closed-PR
+        // disposition from the fresh row instead of dropping the event.
+        onConflict: (current) => buildTerminalUpdate(current),
+    });
+    if (terminalCommit.outcome === "applied" && run) {
+        db.runs.finishRun(run.id, {
+            status: "released",
+            failureReason: event.triggerEvent === "pr_merged"
+                ? "Pull request merged during active run"
+                : "Pull request closed during active run",
+        });
     }
     db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
     const updatedIssue = db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
@@ -102,20 +106,26 @@ async function completeLinearIssueAfterMerge(params, issue) {
         }
         const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
         if (normalizedCurrent === targetState.trim().toLowerCase()) {
-            params.db.issues.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+            params.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                    ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+                },
             });
             return;
         }
         const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-        params.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-            ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        params.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+                ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+            },
         });
     }
     catch (error) {