patchrelay 0.75.2 → 0.76.0

package/dist/idle-reconciliation.js

@@ -16,6 +16,7 @@ import { LinearIssueProjectionService } from "./linear-issue-projection.js";
 import { TerminalWakeReconciler } from "./terminal-wake-reconciler.js";
 const BLOCKED_DEPENDENCY_REFRESH_SUCCESS_BACKOFF_MS = 60_000;
 const BLOCKED_DEPENDENCY_REFRESH_FAILURE_BACKOFF_MS = 5 * 60_000;
+const WRITER = "idle-reconciliation";
 export class IdleIssueReconciler {
     db;
     config;
@@ -174,12 +175,16 @@ export class IdleIssueReconciler {
             return;
         const project = this.config.projects.find((candidate) => candidate.id === issue.projectId);
         if (isDeployTrackingEnabled(project)) {
-            this.advanceIdleIssue(issue, "deploying", { clearFailureProvenance: true });
-            this.db.issues.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                deployStartedAt: new Date().toISOString(),
-            });
+            if (this.advanceIdleIssue(issue, "deploying", { clearFailureProvenance: true }) !== "skipped") {
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    update: {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        deployStartedAt: new Date().toISOString(),
+                    },
+                });
+            }
         }
         else {
             this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
@@ -242,33 +247,49 @@ export class IdleIssueReconciler {
         }
     }
     finishDeploy(issue, state) {
-        this.advanceIdleIssue(issue, state, state === "done" ? { clearFailureProvenance: true } : undefined);
-        this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            deployStartedAt: null,
+        if (this.advanceIdleIssue(issue, state, state === "done" ? { clearFailureProvenance: true } : undefined) === "skipped") {
+            return;
+        }
+        this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                deployStartedAt: null,
+            },
         });
     }
     advanceIdleIssue(issue, newState, options) {
         if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
-            return;
+            return "noop";
         }
-        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
-        this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            factoryState: newState,
-            ...((options?.pendingRunType || newState === "awaiting_queue" || newState === "delegated" || newState === "done")
-                ? {
-                    pendingRunType: null,
-                    pendingRunContextJson: null,
-                }
-                : {}),
-            ...(options?.clearFailureProvenance
-                ? { ...CLEARED_FAILURE_PROVENANCE }
-                : {}),
+        const commit = this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            expectedVersion: issue.version,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: newState,
+                ...((options?.pendingRunType || newState === "awaiting_queue" || newState === "delegated" || newState === "done")
+                    ? {
+                        pendingRunType: null,
+                        pendingRunContextJson: null,
+                    }
+                    : {}),
+                ...(options?.clearFailureProvenance
+                    ? { ...CLEARED_FAILURE_PROVENANCE }
+                    : {}),
+            },
+            // A writer that landed mid-tick (almost always a webhook) is newer
+            // truth than this pass's read; skip and let the next tick re-derive.
+            onConflict: () => undefined,
         });
-        const updatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        if (commit.outcome !== "applied") {
+            this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, outcome: commit.outcome }, "Reconciliation: skipped advancing idle issue after a concurrent write");
+            return "skipped";
+        }
+        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
+        const updatedIssue = commit.issue;
         if (this.syncIssue) {
             void Promise.resolve(this.syncIssue(updatedIssue)).catch((error) => {
                 this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to sync Linear workflow state after idle reconciliation");
@@ -289,6 +310,7 @@ export class IdleIssueReconciler {
         // The dispatcher's recordEventAndDispatch in recordWakeEvent already
         // handles the enqueue when no run is in flight, so no extra poke
         // is needed here.
+        return "applied";
     }
     recordWakeEvent(issue, runType, context, dedupeScope = "idle_reconciliation") {
         const eventType = reactiveWakeEventType(runType);
@@ -395,19 +417,27 @@ export class IdleIssueReconciler {
             ?? (inferred === "queue_eviction" && failureHeadSha && checkName
                 ? ["queue_eviction", failureHeadSha, checkName].join("::")
                 : null);
-        this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            lastGitHubFailureSource: inferred,
-            ...(failureHeadSha ? { lastGitHubFailureHeadSha: failureHeadSha } : {}),
-            ...(checkName ? { lastGitHubFailureCheckName: checkName } : {}),
-            ...(failureSignature ? { lastGitHubFailureSignature: failureSignature } : {}),
+        // Inference from a stale read must never overwrite provenance a
+        // concurrent webhook just recorded — skip on conflict and continue
+        // with the fresh row.
+        const commit = this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            expectedVersion: issue.version,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubFailureSource: inferred,
+                ...(failureHeadSha ? { lastGitHubFailureHeadSha: failureHeadSha } : {}),
+                ...(checkName ? { lastGitHubFailureCheckName: checkName } : {}),
+                ...(failureSignature ? { lastGitHubFailureSignature: failureSignature } : {}),
+            },
+            onConflict: () => undefined,
         });
-        const refreshed = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
-        if (!refreshed)
-            return issue;
+        if (commit.outcome !== "applied") {
+            return (commit.outcome === "conflict_skipped" ? commit.issue : undefined) ?? issue;
+        }
         this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, inferred, factoryState: issue.factoryState }, "Recovered missing failure provenance from GitHub state");
-        return refreshed;
+        return commit.issue;
     }
     async reclassifyStaleBranchFailure(issue) {
         const downstreamOwned = issue.factoryState === "awaiting_queue" || issue.prReviewState === "approved";
@@ -423,19 +453,24 @@ export class IdleIssueReconciler {
         const checkName = issue.lastGitHubFailureCheckName ?? protocol.evictionCheckName;
         const failureSignature = issue.lastGitHubFailureSignature
             ?? (failureHeadSha && checkName ? ["queue_eviction", failureHeadSha, checkName].join("::") : null);
-        this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            lastGitHubFailureSource: "queue_eviction",
-            ...(failureHeadSha ? { lastGitHubFailureHeadSha: failureHeadSha } : {}),
-            ...(checkName ? { lastGitHubFailureCheckName: checkName } : {}),
-            ...(failureSignature ? { lastGitHubFailureSignature: failureSignature } : {}),
+        const commit = this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            expectedVersion: issue.version,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubFailureSource: "queue_eviction",
+                ...(failureHeadSha ? { lastGitHubFailureHeadSha: failureHeadSha } : {}),
+                ...(checkName ? { lastGitHubFailureCheckName: checkName } : {}),
+                ...(failureSignature ? { lastGitHubFailureSignature: failureSignature } : {}),
+            },
+            onConflict: () => undefined,
         });
-        const refreshed = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
-        if (!refreshed)
-            return issue;
+        if (commit.outcome !== "applied") {
+            return (commit.outcome === "conflict_skipped" ? commit.issue : undefined) ?? issue;
+        }
         this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reclassified stale branch failure as queue repair from GitHub state");
-        return refreshed;
+        return commit.issue;
     }
     async inferFailureSourceFromGitHub(issue) {
         const project = this.config.projects.find((candidate) => candidate.id === issue.projectId);
@@ -486,7 +521,8 @@ export class IdleIssueReconciler {
         const project = this.config.projects.find((p) => p.id === issue.projectId);
         if (!project?.github?.repoFullName || !issue.prNumber)
             return;
-        const snapshot = await fetchPullRequestSnapshot(project.github.repoFullName, issue.prNumber);
+        const prNumber = issue.prNumber;
+        const snapshot = await fetchPullRequestSnapshot(project.github.repoFullName, prNumber);
         if (!snapshot.ok) {
             this.logger.debug({ issueKey: issue.issueKey, error: snapshot.error.message }, "Failed to query GitHub PR state during reconciliation");
             if (issue.prReviewState === "approved") {
@@ -501,25 +537,42 @@ export class IdleIssueReconciler {
             const previousHeadSha = issue.prHeadSha;
             const gateCheckNames = getGateCheckNames(project);
             const gateCheckStatus = deriveGateCheckStatusFromRollup(pr.statusCheckRollup, gateCheckNames);
-            this.db.issues.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                ...buildPrStateUpdates(pr, gateCheckStatus, gateCheckNames[0] ?? "verify"),
+            const factsCommit = this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    ...buildPrStateUpdates(pr, gateCheckStatus, gateCheckNames[0] ?? "verify"),
+                },
             });
+            // Continue the pass with the refreshed row so later version-checked
+            // writes don't see our own facts write as a conflict.
+            if (factsCommit.outcome === "applied") {
+                issue = factsCommit.issue;
+            }
             if (pr.state === "MERGED") {
-                this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    update: { projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" },
+                });
                 const merged = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? { ...issue, prState: "merged" };
                 await this.handleMergedIssue(merged);
                 return;
             }
             if (pr.state === "CLOSED") {
                 const closedPrDisposition = resolveClosedPrDisposition(issue);
-                this.db.issues.upsertIssue({
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    prState: "closed",
-                    ...buildClosedPrCleanupFields(),
+                const closedCommit = this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    update: {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        prState: "closed",
+                        ...buildClosedPrCleanupFields(),
+                    },
                 });
+                if (closedCommit.outcome === "applied") {
+                    issue = closedCommit.issue;
+                }
                 if (closedPrDisposition === "done") {
                     this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed for an already completed issue; preserving done state");
                     this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
@@ -604,7 +657,7 @@ export class IdleIssueReconciler {
                     return;
                 }
                 const pendingRunContext = reactiveIntent.runType === "branch_upkeep"
-                    ? buildBranchUpkeepContext(issue.prNumber, project.github?.baseBranch ?? "main", pr.mergeStateStatus, pr.headRefOid)
+                    ? buildBranchUpkeepContext(prNumber, project.github?.baseBranch ?? "main", pr.mergeStateStatus, pr.headRefOid)
                     : undefined;
                 this.logger.info({
                     issueKey: issue.issueKey,
@@ -648,7 +701,7 @@ export class IdleIssueReconciler {
                 this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable, mergeStateStatus: pr.mergeStateStatus }, "Reconciliation: PR still needs branch upkeep after requested changes");
                 this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
                     pendingRunType: reactiveIntent.runType,
-                    pendingRunContext: buildBranchUpkeepContext(issue.prNumber, project.github?.baseBranch ?? "main", pr.mergeStateStatus, pr.headRefOid),
+                    pendingRunContext: buildBranchUpkeepContext(prNumber, project.github?.baseBranch ?? "main", pr.mergeStateStatus, pr.headRefOid),
                 });
                 this.feed?.publish({
                     level: "warn",
@@ -683,10 +736,13 @@ export class IdleIssueReconciler {
                 return;
             }
             if (isReviewDecisionApproved(pr.reviewDecision)) {
-                this.db.issues.upsertIssue({
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    prReviewState: "approved",
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    update: {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        prReviewState: "approved",
+                    },
                 });
                 if (issue.factoryState !== "awaiting_queue" || hasFailureProvenance(issue)) {
                     const options = hasFailureProvenance(issue) ? { clearFailureProvenance: true } : undefined;

package/dist/implementation-outcome-policy.js

@@ -1,4 +1,5 @@
 import { execCommand } from "./utils.js";
+const WRITER = "implementation-outcome-policy";
 export class ImplementationOutcomePolicy {
     config;
     db;
@@ -92,7 +93,10 @@ export class ImplementationOutcomePolicy {
         }
     }
     upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
-        const updated = this.withHeldLease(projectId, linearIssueId, (lease) => this.db.issueSessions.upsertIssueWithLease(lease, params));
+        const updated = this.withHeldLease(projectId, linearIssueId, (lease) => {
+            const commit = this.db.issueSessions.commitIssueState({ writer: WRITER, lease, update: params });
+            return commit.outcome === "applied" ? commit.issue : undefined;
+        });
         if (updated === undefined) {
             this.logger.warn({ projectId, linearIssueId, context }, "Skipping issue write after losing issue-session lease");
         }

package/dist/interrupted-run-recovery.js

@@ -2,6 +2,34 @@ import { ACTIVE_RUN_STATES } from "./factory-state.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { isRequestedChangesRunType } from "./reactive-pr-state.js";
+const WRITER = "interrupted-run-recovery";
+// Roll back the attempt counter consumed by the interrupted run and clear the
+// attempted-failure provenance for repair runs, as a single issue update so
+// the whole repair commits (and conflict-recomputes) atomically.
+function buildInterruptedAttemptRepairUpdate(runType, issue) {
+    const counter = runType === "ci_repair" && issue.ciRepairAttempts > 0
+        ? { ciRepairAttempts: issue.ciRepairAttempts - 1 }
+        : runType === "queue_repair" && issue.queueRepairAttempts > 0
+            ? { queueRepairAttempts: issue.queueRepairAttempts - 1 }
+            : isRequestedChangesRunType(runType) && issue.reviewFixAttempts > 0
+                ? { reviewFixAttempts: issue.reviewFixAttempts - 1 }
+                : undefined;
+    const provenance = runType === "ci_repair" || runType === "queue_repair"
+        ? {
+            lastAttemptedFailureHeadSha: null,
+            lastAttemptedFailureSignature: null,
+            lastAttemptedFailureAt: null,
+        }
+        : undefined;
+    if (!counter && !provenance)
+        return undefined;
+    return {
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        ...counter,
+        ...provenance,
+    };
+}
 function resolveRetryRunType(runType, context) {
     if (runType === "branch_upkeep") {
         return "branch_upkeep";
@@ -68,34 +96,16 @@ export class InterruptedRunRecovery {
     async handle(run, issue) {
         this.logger.warn({ issueKey: issue.issueKey, runType: run.runType, threadId: run.threadId }, "Run has interrupted turn - marking as failed");
         const repairedCounters = this.withHeldLease(issue.projectId, issue.linearIssueId, (lease) => {
-            if (run.runType === "ci_repair" && issue.ciRepairAttempts > 0) {
-                this.db.issueSessions.upsertIssueWithLease(lease, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    ciRepairAttempts: issue.ciRepairAttempts - 1,
-                });
-            }
-            else if (run.runType === "queue_repair" && issue.queueRepairAttempts > 0) {
-                this.db.issueSessions.upsertIssueWithLease(lease, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    queueRepairAttempts: issue.queueRepairAttempts - 1,
-                });
-            }
-            else if (isRequestedChangesRunType(run.runType) && issue.reviewFixAttempts > 0) {
-                this.db.issueSessions.upsertIssueWithLease(lease, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    reviewFixAttempts: issue.reviewFixAttempts - 1,
-                });
-            }
-            if (run.runType === "ci_repair" || run.runType === "queue_repair") {
-                this.db.issueSessions.upsertIssueWithLease(lease, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    lastAttemptedFailureHeadSha: null,
-                    lastAttemptedFailureSignature: null,
-                    lastAttemptedFailureAt: null,
+            // The decrement is read-modify-write against an issue row read before
+            // the awaits that led here; on conflict, recompute from the fresh row.
+            const update = buildInterruptedAttemptRepairUpdate(run.runType, issue);
+            if (update) {
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    lease,
+                    expectedVersion: issue.version,
+                    update,
+                    onConflict: (current) => buildInterruptedAttemptRepairUpdate(run.runType, current),
                 });
             }
             return true;
@@ -192,11 +202,14 @@ export class InterruptedRunRecovery {
         await this.restoreIdleWorktree(issue);
         const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
         if (recoveredState === "changes_requested") {
-            this.db.issues.upsertIssue({
-                projectId: run.projectId,
-                linearIssueId: run.linearIssueId,
-                pendingRunType: retryRunType,
-                pendingRunContextJson: retryContext ? JSON.stringify(retryContext) : null,
+            this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    projectId: run.projectId,
+                    linearIssueId: run.linearIssueId,
+                    pendingRunType: retryRunType,
+                    pendingRunContextJson: retryContext ? JSON.stringify(retryContext) : null,
+                },
             });
             this.feed?.publish({
                 level: "warn",

package/dist/issue-session-projection-invalidator.js

@@ -3,6 +3,9 @@ export class ImmediateIssueSessionProjectionInvalidator {
     deps;
     batchDepth = 0;
     pendingProjections = new Map();
+    // Captured once: the guard must stay a single integer compare on the hot
+    // read path and be OFF in production.
+    strictMidBatchReads = process.env.NODE_ENV !== "production";
     constructor(deps) {
         this.deps = deps;
     }
@@ -18,6 +21,12 @@ export class ImmediateIssueSessionProjectionInvalidator {
             }
         }
     }
+    assertNotMidBatch(context) {
+        if (this.batchDepth > 0 && this.strictMidBatchReads) {
+            throw new Error(`Issue-session projection read mid-batch (${context}): the projection is stale until the `
+                + "batch flushes. Read it before batchIssueSessionProjections() or after it returns.");
+        }
+    }
     issueChanged(issue, options) {
         const dependents = this.deps.listDependents(issue.projectId, issue.linearIssueId);
         this.emitInvalidated("issue_changed", issue.projectId, issue.linearIssueId, issue.issueKey, 1 + dependents.length);

package/dist/linear-agent-session-client.js

@@ -1,6 +1,7 @@
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { computeLinearActivityKey } from "./linear-activity-key.js";
+const WRITER = "linear-agent-session-client";
 export class LinearAgentSessionClient {
     config;
     db;
@@ -22,11 +23,15 @@ export class LinearAgentSessionClient {
         if (!recoveredAgentSessionId)
             return issue;
         this.logger.info({ issueKey: issue.issueKey, agentSessionId: recoveredAgentSessionId }, "Recovered missing Linear agent session id from webhook history");
-        return this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            agentSessionId: recoveredAgentSessionId,
+        const commit = this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                agentSessionId: recoveredAgentSessionId,
+            },
         });
+        return commit.outcome === "applied" ? commit.issue : issue;
     }
     async emitActivity(issue, content, options) {
         const syncedIssue = this.ensureAgentSessionIssue(issue);
@@ -48,10 +53,13 @@ export class LinearAgentSessionClient {
                 ...(ephemeral ? { ephemeral: true } : {}),
             });
             if (activityKey) {
-                this.db.issues.upsertIssue({
-                    projectId: syncedIssue.projectId,
-                    linearIssueId: syncedIssue.linearIssueId,
-                    lastLinearActivityKey: activityKey,
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    update: {
+                        projectId: syncedIssue.projectId,
+                        linearIssueId: syncedIssue.linearIssueId,
+                        lastLinearActivityKey: activityKey,
+                    },
                 });
             }
         }

package/dist/linear-issue-projection.js

@@ -1,3 +1,4 @@
+const WRITER = "linear-issue-projection";
 export class LinearIssueProjectionService {
     db;
     linearProvider;
@@ -51,17 +52,20 @@ export function upsertLinearIssueProjection(db, projectId, liveIssue) {
         childLinearIssueId: liveIssue.id,
         parentLinearIssueId: liveIssue.parentId ?? null,
     });
-    db.issues.upsertIssue({
-        projectId,
-        linearIssueId: liveIssue.id,
-        ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
-        ...(liveIssue.title ? { title: liveIssue.title } : {}),
-        ...(liveIssue.description ? { description: liveIssue.description } : {}),
-        ...(liveIssue.url ? { url: liveIssue.url } : {}),
-        ...(liveIssue.priority != null ? { priority: liveIssue.priority } : {}),
-        ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
-        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+    db.issueSessions.commitIssueState({
+        writer: WRITER,
+        update: {
+            projectId,
+            linearIssueId: liveIssue.id,
+            ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
+            ...(liveIssue.title ? { title: liveIssue.title } : {}),
+            ...(liveIssue.description ? { description: liveIssue.description } : {}),
+            ...(liveIssue.url ? { url: liveIssue.url } : {}),
+            ...(liveIssue.priority != null ? { priority: liveIssue.priority } : {}),
+            ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
+            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+        },
     });
 }
 export function replaceIssueDependenciesFromLinearIssue(db, projectId, liveIssue) {

package/dist/linear-status-comment-sync.js

@@ -3,6 +3,7 @@ import { isClosedPrState } from "./pr-state.js";
 import { derivePrDisplayContext } from "./pr-display-context.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+const WRITER = "linear-status-comment-sync";
 export async function syncVisibleStatusComment(params) {
     const { db, issue, linear, logger, trackedIssue, options } = params;
     try {
@@ -13,10 +14,13 @@ export async function syncVisibleStatusComment(params) {
             body,
         });
         if (result.id !== issue.statusCommentId) {
-            db.issues.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                statusCommentId: result.id,
+            db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    statusCommentId: result.id,
+                },
             });
         }
     }

package/dist/linear-workflow-state-sync.js

@@ -2,6 +2,7 @@ import { resolvePreferredQueuedLinearState, resolvePreferredCompletedLinearState
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
+const WRITER = "linear-workflow-state-sync";
 export async function syncActiveWorkflowState(params) {
     const { db, issue, linear, trackedIssue, options, project } = params;
     const liveIssue = await linear.getIssue(issue.linearIssueId).catch(() => undefined);
@@ -103,11 +104,14 @@ async function syncCompletedLinearState(params) {
     refreshCachedLinearState(db, issue, updated.stateName, updated.stateType);
 }
 function refreshCachedLinearState(db, issue, stateName, stateType) {
-    db.issues.upsertIssue({
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
-        ...(stateName ? { currentLinearState: stateName } : {}),
-        ...(stateType ? { currentLinearStateType: stateType } : {}),
+    db.issueSessions.commitIssueState({
+        writer: WRITER,
+        update: {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(stateName ? { currentLinearState: stateName } : {}),
+            ...(stateType ? { currentLinearStateType: stateType } : {}),
+        },
     });
 }
 function shouldAutoAdvanceLinearState(issue) {