patchrelay 0.75.2 → 0.76.0

package/dist/merged-linear-completion-reconciler.js

@@ -3,6 +3,7 @@ import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
 import { replaceIssueDependenciesFromLinearIssue } from "./linear-issue-projection.js";
+const WRITER = "merged-linear-completion-reconciler";
 const COMPLETION_RECONCILE_WINDOW_MS = 60 * 60 * 1000;
 const COMPLETION_RECONCILE_SUCCESS_BACKOFF_MS = 60 * 60 * 1000;
 const COMPLETION_RECONCILE_FAILURE_BACKOFF_MS = 5 * 60 * 1000;
@@ -88,23 +89,41 @@ export class MergedLinearCompletionReconciler {
             return;
         }
         const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-        this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-            ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+                ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+            },
         });
     }
     reopenStaleLocalDoneIssue(issue, liveIssue) {
+        const buildReopenUpdate = (record) => {
+            const restored = resolveOpenWorkflowState(record);
+            return {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+                ...(restored ? { factoryState: restored.factoryState } : {}),
+                ...(restored ? { pendingRunType: restored.pendingRunType } : {}),
+            };
+        };
         const restored = resolveOpenWorkflowState(issue);
-        this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-            ...(restored ? { factoryState: restored.factoryState } : {}),
-            ...(restored ? { pendingRunType: restored.pendingRunType } : {}),
+        const commit = this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            expectedVersion: issue.version,
+            update: buildReopenUpdate(issue),
+            // Reopening a local done state must be re-derived against the fresh
+            // row when something else wrote in between — and only if it is
+            // still done.
+            onConflict: (current) => (current.factoryState === "done" ? buildReopenUpdate(current) : undefined),
         });
+        if (commit.outcome !== "applied") {
+            return;
+        }
         this.logger.info({
             issueKey: issue.issueKey,
             previousFactoryState: issue.factoryState,
@@ -116,11 +135,14 @@ export class MergedLinearCompletionReconciler {
         if (issue.currentLinearState === liveIssue.stateName && issue.currentLinearStateType === liveIssue.stateType) {
             return;
         }
-        this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+        this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+            },
         });
     }
     isRecentCompletionCandidate(issue, now) {

package/dist/no-pr-completion-check.js

@@ -1,6 +1,18 @@
 import { CLEARED_FAILURE_PROVENANCE } from "./failure-provenance.js";
 import { buildCompletionCheckActivity } from "./linear-session-reporting.js";
 import { wakeOrchestrationParentsForChildEvent } from "./orchestration-parent-wake.js";
+const WRITER = "no-pr-completion-check";
+// Post-completion-check decision writes all clear the run slot; on a version
+// conflict, apply only if the slot still belongs to this run on the fresh row.
+function commitRunSlotUpdate(db, run, issue, update) {
+    const commit = db.issueSessions.commitIssueState({
+        writer: WRITER,
+        expectedVersion: issue.version,
+        update,
+        onConflict: (current) => (current.activeRunId === run.id ? update : undefined),
+    });
+    return commit.outcome === "applied";
+}
 function shouldContinueForUnpublishedLocalChanges(message) {
     const normalized = message.trim().toLowerCase();
     if (!normalized)
@@ -56,16 +68,18 @@ export async function handleNoPrCompletionCheck(params) {
     }
     if (completionCheck.outcome === "continue") {
         const continued = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
-            params.db.runs.finishRun(params.run.id, runUpdate);
-            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
-            params.db.issues.upsertIssue({
+            if (!commitRunSlotUpdate(params.db, params.run, params.issue, {
                 projectId: params.run.projectId,
                 linearIssueId: params.run.linearIssueId,
                 activeRunId: null,
                 factoryState: "delegated",
                 pendingRunType: null,
                 pendingRunContextJson: null,
-            });
+            })) {
+                return false;
+            }
+            params.db.runs.finishRun(params.run.id, runUpdate);
+            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
             return Boolean(params.db.issueSessions.appendIssueSessionEventWithLease(lease, {
                 projectId: params.run.projectId,
                 linearIssueId: params.run.linearIssueId,
@@ -95,17 +109,19 @@ export async function handleNoPrCompletionCheck(params) {
     }
     if (completionCheck.outcome === "needs_input") {
         const completed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
-            params.db.runs.finishRun(params.run.id, runUpdate);
-            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
-            params.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
-            params.db.issues.upsertIssue({
+            if (!commitRunSlotUpdate(params.db, params.run, params.issue, {
                 projectId: params.run.projectId,
                 linearIssueId: params.run.linearIssueId,
                 activeRunId: null,
                 factoryState: "awaiting_input",
                 pendingRunType: null,
                 pendingRunContextJson: null,
-            });
+            })) {
+                return false;
+            }
+            params.db.runs.finishRun(params.run.id, runUpdate);
+            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
+            params.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
             return true;
         });
         if (!completed) {
@@ -127,20 +143,22 @@ export async function handleNoPrCompletionCheck(params) {
     if (completionCheck.outcome === "done") {
         if (shouldContinueForUnpublishedLocalChanges(params.publishedOutcomeError)) {
             const continued = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
-                params.db.runs.finishRun(params.run.id, runUpdate);
-                params.db.runs.saveCompletionCheck(params.run.id, {
-                    ...completionCheck,
-                    outcome: "continue",
-                    summary: "PatchRelay changed files locally but has not published them yet; continuing automatically to finish publication.",
-                    why: params.publishedOutcomeError,
-                });
-                params.db.issues.upsertIssue({
+                if (!commitRunSlotUpdate(params.db, params.run, params.issue, {
                     projectId: params.run.projectId,
                     linearIssueId: params.run.linearIssueId,
                     activeRunId: null,
                     factoryState: "delegated",
                     pendingRunType: null,
                     pendingRunContextJson: null,
+                })) {
+                    return false;
+                }
+                params.db.runs.finishRun(params.run.id, runUpdate);
+                params.db.runs.saveCompletionCheck(params.run.id, {
+                    ...completionCheck,
+                    outcome: "continue",
+                    summary: "PatchRelay changed files locally but has not published them yet; continuing automatically to finish publication.",
+                    why: params.publishedOutcomeError,
                 });
                 return Boolean(params.db.issueSessions.appendIssueSessionEventWithLease(lease, {
                     projectId: params.run.projectId,
@@ -173,10 +191,7 @@ export async function handleNoPrCompletionCheck(params) {
             ? params.db.issues.countOpenChildIssues(params.run.projectId, params.run.linearIssueId)
             : 0;
         const completed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
-            params.db.runs.finishRun(params.run.id, runUpdate);
-            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
-            params.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
-            params.db.issues.upsertIssue({
+            if (!commitRunSlotUpdate(params.db, params.run, params.issue, {
                 projectId: params.run.projectId,
                 linearIssueId: params.run.linearIssueId,
                 activeRunId: null,
@@ -185,7 +200,12 @@ export async function handleNoPrCompletionCheck(params) {
                 pendingRunContextJson: null,
                 orchestrationSettleUntil: null,
                 ...CLEARED_FAILURE_PROVENANCE,
-            });
+            })) {
+                return false;
+            }
+            params.db.runs.finishRun(params.run.id, runUpdate);
+            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
+            params.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
             return true;
         });
         if (!completed) {
@@ -217,20 +237,22 @@ export async function handleNoPrCompletionCheck(params) {
     }
     const failureReason = `No PR observed and the completion check failed this run: ${completionCheck.summary}`;
     const failed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, () => {
-        params.db.runs.finishRun(params.run.id, {
-            ...runUpdate,
-            status: "failed",
-            failureReason,
-        });
-        params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
-        params.db.issues.upsertIssue({
+        if (!commitRunSlotUpdate(params.db, params.run, params.issue, {
             projectId: params.run.projectId,
             linearIssueId: params.run.linearIssueId,
             activeRunId: null,
             factoryState: "failed",
             pendingRunType: null,
             pendingRunContextJson: null,
+        })) {
+            return false;
+        }
+        params.db.runs.finishRun(params.run.id, {
+            ...runUpdate,
+            status: "failed",
+            failureReason,
         });
+        params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
         return true;
     });
     if (!failed) {

package/dist/orchestration-parent-wake.js

@@ -1,4 +1,5 @@
 import { classifyIssue } from "./issue-class.js";
+const WRITER = "orchestration-parent-wake";
 export const ORCHESTRATION_SETTLE_WINDOW_MS = 10_000;
 export function computeOrchestrationSettleUntil(now = Date.now()) {
     return new Date(now + ORCHESTRATION_SETTLE_WINDOW_MS).toISOString();
@@ -24,18 +25,24 @@ function resolveParentIssueIds(db, child) {
 }
 export function startOrchestrationSettleWindow(db, issue, now = Date.now()) {
     const settleUntil = computeOrchestrationSettleUntil(now);
-    db.issues.upsertIssue({
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
-        orchestrationSettleUntil: settleUntil,
+    db.issueSessions.commitIssueState({
+        writer: WRITER,
+        update: {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            orchestrationSettleUntil: settleUntil,
+        },
     });
     return settleUntil;
 }
 export function queueSettledOrchestrationIssue(params) {
-    params.db.issues.upsertIssue({
-        projectId: params.issue.projectId,
-        linearIssueId: params.issue.linearIssueId,
-        orchestrationSettleUntil: null,
+    params.db.issueSessions.commitIssueState({
+        writer: WRITER,
+        update: {
+            projectId: params.issue.projectId,
+            linearIssueId: params.issue.linearIssueId,
+            orchestrationSettleUntil: null,
+        },
     });
     const dispatched = params.wakeDispatcher.recordEventAndDispatch(params.issue.projectId, params.issue.linearIssueId, {
         eventType: "delegated",

package/dist/queue-health-monitor.js

@@ -1,6 +1,7 @@
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { buildRepairWakeDedupeKey } from "./reactive-wake-keys.js";
 import { execCommand } from "./utils.js";
+const WRITER = "queue-health-monitor";
 const QUEUE_HEALTH_GRACE_MS = 120_000;
 const QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS = 300_000;
 // Plan §6.2: an approved PR with red branch CI for >= this long is
@@ -113,8 +114,12 @@ export class QueueHealthMonitor {
         }
         this.probeFailureFeedTimes.delete(`${issue.projectId}::${issue.linearIssueId}`);
         if (pr.state === "MERGED") {
-            this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
-            this.advancer.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+            const mergedCommit = this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: { projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" },
+            });
+            const merged = mergedCommit.outcome === "applied" ? mergedCommit.issue : issue;
+            this.advancer.advanceIdleIssue(merged, "done", { clearFailureProvenance: true });
             return;
         }
         if (pr.state !== "OPEN")
@@ -159,12 +164,16 @@ export class QueueHealthMonitor {
             if (isDuplicateProbe(issue, pendingRunContext)) {
                 return;
             }
-            this.db.issues.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                lastAttemptedFailureHeadSha: headRefOid,
-                lastAttemptedFailureSignature: signature,
+            const probedCommit = this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    lastAttemptedFailureHeadSha: headRefOid,
+                    lastAttemptedFailureSignature: signature,
+                },
             });
+            const probed = probedCommit.outcome === "applied" ? probedCommit.issue : issue;
             this.advancer.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
                 eventType: "merge_steward_incident",
                 eventJson: JSON.stringify(pendingRunContext),
@@ -175,7 +184,7 @@ export class QueueHealthMonitor {
                     signature,
                 }),
             });
-            this.advancer.advanceIdleIssue(issue, "repairing_queue");
+            this.advancer.advanceIdleIssue(probed, "repairing_queue");
             this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");
             this.feed?.publish({
                 level: "warn",

package/dist/reactive-run-policy.js

@@ -2,6 +2,7 @@ import { CLEARED_FAILURE_PROVENANCE } from "./failure-provenance.js";
 import { buildReviewFixBranchUpkeepContext, isDirtyMergeStateStatus, isRequestedChangesRunType, readReactivePrSnapshot, } from "./reactive-pr-state.js";
 import { readReactivePublishDelta } from "./reactive-publish-delta.js";
 import { readLatestRequestedChangesReviewContext } from "./remote-pr-review.js";
+const WRITER = "reactive-run-policy";
 const REACTIVE_SCOPE_RISK_PREFIXES = [
     ".github/workflows/",
     "scripts/bootstrap-worktree.",
@@ -273,7 +274,10 @@ export class ReactiveRunPolicy {
         }
     }
     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/run-finalizer.js

@@ -6,6 +6,7 @@ import { resolveCompletedRunState } from "./run-completion-policy.js";
 import { computeChangeIdentityFromWorktree } from "./change-identity.js";
 import { inspectGitWorktreeStatus, isRepairRunType } from "./git-worktree-status.js";
 import { buildRunOutcomeSummary } from "./run-outcome-summary.js";
+const WRITER = "run-finalizer";
 function parseEventJson(eventJson) {
     if (!eventJson)
         return undefined;
@@ -150,12 +151,16 @@ export class RunFinalizer {
         });
         if (!identity.patchId && !identity.integrationTreeId)
             return;
-        this.db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(identity.patchId ? { lastPublishedPatchId: identity.patchId } : {}),
-            ...(identity.integrationTreeId ? { lastPublishedIntegrationTreeId: identity.integrationTreeId } : {}),
-            lastPublishedHeadSha: issue.prHeadSha,
+        this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            expectedVersion: issue.version,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(identity.patchId ? { lastPublishedPatchId: identity.patchId } : {}),
+                ...(identity.integrationTreeId ? { lastPublishedIntegrationTreeId: identity.integrationTreeId } : {}),
+                lastPublishedHeadSha: issue.prHeadSha,
+            },
         });
         this.logger.info({
             issueKey: issue.issueKey,
@@ -194,12 +199,15 @@ export class RunFinalizer {
                 ...(completedTurnId ? { turnId: completedTurnId } : {}),
                 failureReason: run.failureReason ?? "approved on the same head; further publication suppressed",
             });
-            this.db.issues.upsertIssue({
-                projectId: run.projectId,
-                linearIssueId: run.linearIssueId,
-                activeRunId: null,
-                pendingRunType: null,
-                pendingRunContextJson: null,
+            this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    projectId: run.projectId,
+                    linearIssueId: run.linearIssueId,
+                    activeRunId: null,
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                },
             });
         });
         this.clearProgressAndRelease(run);
@@ -274,23 +282,33 @@ export class RunFinalizer {
                 report: params.report,
                 outcomeSummary,
             }));
-            this.db.issueSessions.upsertIssueWithLease(lease, {
+            // The attempt decrements are read-modify-write against the issue row;
+            // on conflict, recompute them from the fresh row instead of writing
+            // counters derived from a stale read.
+            const buildContinueUpdate = (record) => ({
                 projectId: params.run.projectId,
                 linearIssueId: params.run.linearIssueId,
                 activeRunId: null,
                 factoryState: "delegated",
                 pendingRunType: null,
                 pendingRunContextJson: null,
-                ...(params.run.runType === "ci_repair" && params.issue.ciRepairAttempts > 0
-                    ? { ciRepairAttempts: params.issue.ciRepairAttempts - 1 }
+                ...(params.run.runType === "ci_repair" && record.ciRepairAttempts > 0
+                    ? { ciRepairAttempts: record.ciRepairAttempts - 1 }
                     : {}),
-                ...(params.run.runType === "queue_repair" && params.issue.queueRepairAttempts > 0
-                    ? { queueRepairAttempts: params.issue.queueRepairAttempts - 1 }
+                ...(params.run.runType === "queue_repair" && record.queueRepairAttempts > 0
+                    ? { queueRepairAttempts: record.queueRepairAttempts - 1 }
                     : {}),
-                ...((params.run.runType === "review_fix" || params.run.runType === "branch_upkeep") && params.issue.reviewFixAttempts > 0
-                    ? { reviewFixAttempts: params.issue.reviewFixAttempts - 1 }
+                ...((params.run.runType === "review_fix" || params.run.runType === "branch_upkeep") && record.reviewFixAttempts > 0
+                    ? { reviewFixAttempts: record.reviewFixAttempts - 1 }
                     : {}),
             });
+            this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                lease,
+                expectedVersion: params.issue.version,
+                update: buildContinueUpdate(params.issue),
+                onConflict: (current) => buildContinueUpdate(current),
+            });
             return Boolean(this.db.issueSessions.appendIssueSessionEventWithLease(lease, {
                 projectId: params.run.projectId,
                 linearIssueId: params.run.linearIssueId,
@@ -435,23 +453,37 @@ export class RunFinalizer {
             postRunState,
             latestAssistantSummary: report.assistantMessages.at(-1),
         });
-        const completed = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
-            this.db.runs.finishRun(run.id, this.buildCompletedRunUpdate({
-                threadId,
-                ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
-                report,
-                outcomeSummary,
-            }));
-            this.db.issues.upsertIssue({
+        // `refreshedIssue` was read before several async policy checks; a
+        // version conflict here means a webhook landed mid-finalize. Re-resolve
+        // the post-run state from the fresh row so we never regress it (e.g.
+        // the PR merged while we were verifying the publish).
+        const buildCompletionUpdate = (record) => {
+            const state = postRunFollowUp?.factoryState ?? resolveCompletedRunState(record, run);
+            return {
                 projectId: run.projectId,
                 linearIssueId: run.linearIssueId,
                 activeRunId: null,
-                ...(postRunState ? { factoryState: postRunState } : {}),
+                ...(state ? { factoryState: state } : {}),
                 pendingRunType: null,
                 pendingRunContextJson: null,
-                ...(postRunFollowUp ? {} : (postRunState === "awaiting_queue" || postRunState === "done"
+                ...(postRunFollowUp ? {} : (state === "awaiting_queue" || state === "done"
                     ? { ...CLEARED_FAILURE_PROVENANCE }
                     : {})),
+            };
+        };
+        const completed = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+            this.db.runs.finishRun(run.id, this.buildCompletedRunUpdate({
+                threadId,
+                ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
+                report,
+                outcomeSummary,
+            }));
+            this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                lease,
+                expectedVersion: refreshedIssue.version,
+                update: buildCompletionUpdate(refreshedIssue),
+                onConflict: (current) => buildCompletionUpdate(current),
             });
             if (postRunFollowUp) {
                 return this.appendWakeEventWithLease(lease, issue, postRunFollowUp.pendingRunType, postRunFollowUp.context, "post_run");

package/dist/run-launcher.js

@@ -4,6 +4,7 @@ import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { loadPatchRelayRepoPrompting } from "./patchrelay-customization.js";
 import { buildRunPrompt as buildPatchRelayRunPrompt, findDisallowedPatchRelayPromptSectionIds, findUnknownPatchRelayPromptSectionIds, mergePromptCustomizationLayers, resolvePromptLayers, } from "./prompting/patchrelay.js";
 import { sanitizeDiagnosticText } from "./utils.js";
+const WRITER = "run-launcher";
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -128,7 +129,7 @@ export class RunLauncher {
                     ? params.effectiveContext.failureHeadSha
                     : typeof params.effectiveContext?.headSha === "string" ? params.effectiveContext.headSha : undefined;
                 const failureSignature = typeof params.effectiveContext?.failureSignature === "string" ? params.effectiveContext.failureSignature : undefined;
-                this.db.issues.upsertIssue({
+                const claimUpdate = {
                     projectId: params.item.projectId,
                     linearIssueId: params.item.issueId,
                     pendingRunType: null,
@@ -148,7 +149,18 @@ export class RunLauncher {
                             lastAttemptedFailureAt: new Date().toISOString(),
                         }
                         : {}),
+                };
+                const claimCommit = this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    // `wakeIssue` is the freshest row this claim transaction has seen
+                    // (materializeLegacyPendingWake may have bumped the version).
+                    expectedVersion: wakeIssue.version,
+                    update: claimUpdate,
+                    // Never steal a slot another writer claimed concurrently.
+                    onConflict: (current) => (current.activeRunId == null ? claimUpdate : undefined),
                 });
+                if (claimCommit.outcome !== "applied")
+                    return undefined;
                 this.db.issueSessions.consumeIssueSessionEvents(params.item.projectId, params.item.issueId, freshWake.eventIds, created.id);
                 this.db.issueSessions.setIssueSessionLastWakeReason(params.item.projectId, params.item.issueId, freshWake.wakeReason ?? null);
                 return created;
@@ -201,7 +213,11 @@ export class RunLauncher {
                 const thread = await this.codex.startThread({ cwd: params.worktreePath });
                 threadId = thread.id;
                 createdThreadForRun = true;
-                this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId });
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    lease: { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId },
+                    update: { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId },
+                });
             }
             this.db.runs.updateLaunchPhase(params.run.id, "thread_started");
             try {
@@ -216,7 +232,11 @@ export class RunLauncher {
                     const thread = await this.codex.startThread({ cwd: params.worktreePath });
                     threadId = thread.id;
                     createdThreadForRun = true;
-                    this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId });
+                    this.db.issueSessions.commitIssueState({
+                        writer: WRITER,
+                        lease: { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId },
+                        update: { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId },
+                    });
                     const turn = await this.codex.startTurn({ threadId, cwd: params.worktreePath, input: params.prompt });
                     turnId = turn.turnId;
                     this.db.runs.updateLaunchPhase(params.run.id, "turn_started");
@@ -236,15 +256,25 @@ export class RunLauncher {
             const lostLease = error instanceof Error && error.name === "IssueSessionLeaseLostError";
             if (!lostLease) {
                 const nextState = resolveFailureFactoryState(params.runType);
-                this.db.issueSessions.finishRunWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, params.run.id, {
-                    status: "failed",
-                    failureReason: message,
-                });
-                this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, {
-                    projectId: params.project.id,
-                    linearIssueId: params.issue.linearIssueId,
-                    activeRunId: null,
-                    factoryState: nextState,
+                // Issue clear + run-terminal write ride in one transaction; the run
+                // finish is gated on the issue commit so a lost lease skips both.
+                this.db.transaction(() => {
+                    const commit = this.db.issueSessions.commitIssueState({
+                        writer: WRITER,
+                        lease: { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId },
+                        update: {
+                            projectId: params.project.id,
+                            linearIssueId: params.issue.linearIssueId,
+                            activeRunId: null,
+                            factoryState: nextState,
+                        },
+                    });
+                    if (commit.outcome !== "applied")
+                        return;
+                    this.db.runs.finishRun(params.run.id, {
+                        status: "failed",
+                        failureReason: message,
+                    });
                 });
             }
             this.logger.error({ issueKey: params.issue.issueKey, runType: params.runType, error: message }, `Failed to launch ${params.runType} run`);

package/dist/run-notification-handler.js

@@ -2,6 +2,7 @@ import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { extractTurnId, resolveRunCompletionStatus } from "./run-reporting.js";
 import { resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
 import { resolveFailureFactoryState } from "./reactive-pr-state.js";
+const WRITER = "run-notification-handler";
 const DEFAULT_PUBLISH_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
 export class RunNotificationHandler {
     config;
@@ -90,19 +91,30 @@ export class RunNotificationHandler {
                 return;
             }
             const nextState = resolveFailureFactoryState(run.runType);
+            const failureUpdate = {
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: null,
+                factoryState: nextState,
+            };
             const updated = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (lease) => {
-                this.db.issueSessions.finishRunWithLease(lease, run.id, {
+                const commit = this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    lease,
+                    // The issue row was read before awaiting the failed-run recovery;
+                    // only clear the slot if it still belongs to this run.
+                    expectedVersion: issue.version,
+                    update: failureUpdate,
+                    onConflict: (current) => (current.activeRunId === run.id ? failureUpdate : undefined),
+                });
+                if (commit.outcome !== "applied")
+                    return false;
+                this.db.runs.finishRun(run.id, {
                     status: "failed",
                     threadId,
                     ...(completedTurnId ? { turnId: completedTurnId } : {}),
                     failureReason,
                 });
-                this.db.issueSessions.upsertIssueWithLease(lease, {
-                    projectId: run.projectId,
-                    linearIssueId: run.linearIssueId,
-                    activeRunId: null,
-                    factoryState: nextState,
-                });
                 return true;
             });
             if (!updated) {