patchrelay 0.75.3 → 0.77.0

package/dist/service-startup-recovery.js

@@ -3,6 +3,7 @@ import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { isResumablePausedLocalWork } from "./paused-issue-state.js";
 import { buildRepairWakeDedupeKey, buildRequestedChangesWakeIdentity, reactiveWakeEventType } from "./reactive-wake-keys.js";
 import { upsertLinearIssueProjection } from "./linear-issue-projection.js";
+const WRITER = "service-startup-recovery";
 export class ServiceStartupRecovery {
     config;
     db;
@@ -30,13 +31,17 @@ export class ServiceStartupRecovery {
                 ? issue
                 : (() => {
                     const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
-                    return recoveredAgentSessionId
-                        ? this.db.issues.upsertIssue({
+                    if (!recoveredAgentSessionId)
+                        return issue;
+                    const commit = this.db.issueSessions.commitIssueState({
+                        writer: WRITER,
+                        update: {
                             projectId: issue.projectId,
                             linearIssueId: issue.linearIssueId,
                             agentSessionId: recoveredAgentSessionId,
-                        })
-                        : issue;
+                        },
+                    });
+                    return commit.outcome === "applied" ? commit.issue : issue;
                 })();
             if (!syncedIssue.agentSessionId) {
                 continue;
@@ -54,7 +59,7 @@ export class ServiceStartupRecovery {
     }
     async recoverDelegatedIssueStateFromLinear() {
         await this.discoverDelegatedIssuesFromLinear();
-        for (const issue of this.db.issues.listIssues()) {
+        for (let issue of this.db.issues.listIssues()) {
             if (issue.factoryState === "done" || issue.activeRunId !== undefined) {
                 continue;
             }
@@ -71,6 +76,9 @@ export class ServiceStartupRecovery {
                 continue;
             }
             upsertLinearIssueProjection(this.db, issue.projectId, liveIssue);
+            // The projection write bumped the issue version; continue with the
+            // fresh row so the recovery commit below doesn't self-conflict.
+            issue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
             const delegated = liveIssue.delegateId === installation.actorId;
             if (issue.delegatedToPatchRelay !== delegated) {
                 appendDelegationObservedEvent(this.db, {
@@ -116,24 +124,36 @@ export class ServiceStartupRecovery {
             const shouldRecoverReactivePrWork = delegated
                 && issue.prNumber !== undefined
                 && reactiveIntent !== undefined;
-            const updated = this.db.issues.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                delegatedToPatchRelay: delegated,
-                ...(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 } : {}),
-                ...(shouldRecoverPausedLocalWork
-                    ? { factoryState: "delegated" }
-                    : shouldRecoverReactivePrWork
-                        ? { factoryState: reactiveIntent.compatibilityFactoryState }
-                        : {}),
+            const commit = this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                expectedVersion: issue.version,
+                update: {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    delegatedToPatchRelay: delegated,
+                    ...(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 } : {}),
+                    ...(shouldRecoverPausedLocalWork
+                        ? { factoryState: "delegated" }
+                        : shouldRecoverReactivePrWork
+                            ? { factoryState: reactiveIntent.compatibilityFactoryState }
+                            : {}),
+                },
+                // The recovery decision was derived from the row read at loop start
+                // plus stale PR facts; a concurrent writer (webhook, another recovery
+                // pass) invalidates it. Skip — reconciliation re-derives shortly.
+                onConflict: () => undefined,
             });
+            if (commit.outcome !== "applied") {
+                continue;
+            }
+            const updated = commit.issue;
             if (!shouldRecoverPausedLocalWork && !shouldRecoverReactivePrWork) {
                 continue;
             }
@@ -215,20 +235,26 @@ export class ServiceStartupRecovery {
     upsertDiscoveredDelegatedIssue(project, liveIssue) {
         upsertLinearIssueProjection(this.db, project.id, liveIssue);
         const existing = this.db.issues.getIssue(project.id, liveIssue.id);
-        const updated = this.db.issues.upsertIssue({
-            projectId: project.id,
-            linearIssueId: liveIssue.id,
-            delegatedToPatchRelay: true,
-            factoryState: existing?.factoryState ?? "delegated",
-            ...(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 } : {}),
+        const commit = this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: project.id,
+                linearIssueId: liveIssue.id,
+                delegatedToPatchRelay: true,
+                factoryState: existing?.factoryState ?? "delegated",
+                ...(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 } : {}),
+            },
         });
+        if (commit.outcome !== "applied")
+            return;
+        const updated = commit.issue;
         const hasPendingWake = this.db.workflowWakes.peekIssueWake(project.id, liveIssue.id) !== undefined;
         const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(project.id, liveIssue.id);
         if (!hasPendingWake && unresolvedBlockers === 0) {

package/dist/telemetry.js

@@ -78,6 +78,15 @@ export class OperatorFeedTelemetrySink {
                     };
                 }
                 return undefined;
+            case "state.write_conflict":
+                return {
+                    level: "warn",
+                    kind: "workflow",
+                    ...(event.issueKey ? { issueKey: event.issueKey } : {}),
+                    ...(event.projectId ? { projectId: event.projectId } : {}),
+                    status: "state_write_conflict",
+                    summary: `Issue-state write conflict (${event.writer}): expected v${event.expectedVersion ?? "none"}, found v${event.actualVersion ?? "none"} — ${event.resolution.replaceAll("_", " ")}`,
+                };
             case "health.invariant":
                 return {
                     level: event.status === "observed" ? "warn" : "info",

package/dist/terminal-wake-reconciler.js

@@ -15,14 +15,31 @@ export class TerminalWakeReconciler {
                 && issue.pendingRunType === undefined) {
                 continue;
             }
-            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
-            this.db.issues.upsertIssue({
+            const pendingEvents = this.db.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { pendingOnly: true });
+            const clearUpdate = {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 pendingRunType: null,
                 pendingRunContextJson: null,
+            };
+            const commit = this.db.issueSessions.commitIssueState({
+                writer: "terminal-wake-reconciler",
+                expectedVersion: issue.version,
+                update: clearUpdate,
+                // Only clear if the issue is still terminal on the fresh row.
+                onConflict: (current) => (TERMINAL_STATES.has(current.factoryState) ? clearUpdate : undefined),
             });
-            this.logger.info({ issueKey: issue.issueKey, factoryState: issue.factoryState }, "Reconciliation: cleared stale terminal wake");
+            if (commit.outcome !== "applied")
+                continue;
+            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+            // Audit trail: record what was dropped so "why didn't this retry?"
+            // is answerable later.
+            this.logger.info({
+                issueKey: issue.issueKey,
+                factoryState: issue.factoryState,
+                droppedPendingRunType: issue.pendingRunType,
+                droppedEventTypes: pendingEvents.map((event) => event.eventType),
+            }, "Reconciliation: cleared stale terminal wake");
         }
     }
 }

package/dist/webhooks/agent-session-handler.js

@@ -3,6 +3,7 @@ import { buildAgentSessionExternalUrls } from "../agent-session-presentation.js"
 import { buildAlreadyRunningThought, buildAgentSessionAcknowledgementThought, buildBlockedDelegationActivity, buildDelegationThought, buildStopConfirmationActivity, } from "../linear-session-reporting.js";
 import { dirtyWorktreeEventPayload, inspectGitWorktreeStatus } from "../git-worktree-status.js";
 import { resolveProject, triggerEventAllowed } from "../project-resolution.js";
+const WRITER = "agent-session-handler";
 const PATCHRELAY_AGENT_ACTIVITY_TYPES = new Set([
     "action",
     "elicitation",
@@ -172,19 +173,28 @@ export class AgentSessionHandler {
             catch (error) {
                 this.logger.warn({ issueKey: params.trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop signal");
             }
-            this.db.runs.finishRun(params.activeRun.id, {
-                status: "released",
-                threadId: params.activeRun.threadId,
-                turnId: params.activeRun.turnId,
-                failureReason: dirtySummary ? `Stop signal received; ${dirtySummary}` : "Stop signal received",
-            });
         }
-        this.db.issueSessions.upsertIssueRespectingActiveLease(params.project.id, issueId, {
-            projectId: params.project.id,
-            linearIssueId: issueId,
-            activeRunId: null,
-            factoryState: "awaiting_input",
-            agentSessionId: sessionId,
+        // The stop signal is a user fact: the issue slot clear and the run
+        // release ride in one transaction, with the run gated on the issue commit.
+        this.db.transaction(() => {
+            const commit = this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    projectId: params.project.id,
+                    linearIssueId: issueId,
+                    activeRunId: null,
+                    factoryState: "awaiting_input",
+                    agentSessionId: sessionId,
+                },
+            });
+            if (commit.outcome === "applied" && params.activeRun?.threadId && params.activeRun.turnId) {
+                this.db.runs.finishRun(params.activeRun.id, {
+                    status: "released",
+                    threadId: params.activeRun.threadId,
+                    turnId: params.activeRun.turnId,
+                    failureReason: dirtySummary ? `Stop signal received; ${dirtySummary}` : "Stop signal received",
+                });
+            }
         });
         this.db.issueSessions.appendIssueSessionEvent({
             projectId: params.project.id,

package/dist/webhooks/dependency-readiness-handler.js

@@ -1,4 +1,5 @@
 import { emitTelemetry, noopTelemetry } from "../telemetry.js";
+const WRITER = "dependency-readiness-handler";
 export class DependencyReadinessHandler {
     db;
     wakeDispatcher;
@@ -41,11 +42,14 @@ export class DependencyReadinessHandler {
                 if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation"
                     && issue.activeRunId === undefined
                     && !this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
-                    this.db.issues.upsertIssue({
-                        projectId,
-                        linearIssueId: dependent.linearIssueId,
-                        pendingRunType: null,
-                        pendingRunContextJson: null,
+                    this.db.issueSessions.commitIssueState({
+                        writer: WRITER,
+                        update: {
+                            projectId,
+                            linearIssueId: dependent.linearIssueId,
+                            pendingRunType: null,
+                            pendingRunContextJson: null,
+                        },
                     });
                 }
                 continue;
@@ -72,11 +76,14 @@ export class DependencyReadinessHandler {
                 continue;
             }
             if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation") {
-                this.db.issues.upsertIssue({
-                    projectId,
-                    linearIssueId: dependent.linearIssueId,
-                    pendingRunType: null,
-                    pendingRunContextJson: null,
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    update: {
+                        projectId,
+                        linearIssueId: dependent.linearIssueId,
+                        pendingRunType: null,
+                        pendingRunContextJson: null,
+                    },
                 });
             }
             const dispatchedRunType = this.wakeDispatcher.recordEventAndDispatch(projectId, dependent.linearIssueId, {

package/dist/webhooks/desired-stage-recorder.js

@@ -7,6 +7,7 @@ import { resolveLinkedPrAdoption } from "./linked-pr-adoption.js";
 import { buildOperatorRetryEvent } from "../operator-retry-event.js";
 import { planIssueWebhookWorkflow } from "./issue-webhook-workflow-planner.js";
 import { dirtyWorktreeEventPayload, inspectGitWorktreeStatus } from "../git-worktree-status.js";
+const WRITER = "desired-stage-recorder";
 export class DesiredStageRecorder {
     db;
     linearProvider;
@@ -84,8 +85,14 @@ export class DesiredStageRecorder {
                 : workflowPlan.effectiveRunRelease.reason
             : undefined;
         const dirtyWorktreePayload = releaseWorktreeStatus ? dirtyWorktreeEventPayload(releaseWorktreeStatus) : undefined;
-        const commitIssueUpdate = () => {
-            const record = this.db.issues.upsertIssue({
+        const activeLease = this.db.issueSessions.getActiveIssueSessionLease(params.project.id, normalizedIssue.id);
+        // Webhook intake projection: the fields are facts carried by the webhook
+        // payload and the hydrated Linear issue, applied unconditionally (the
+        // active lease still gates the write, matching the previous semantics).
+        const issueCommit = this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            ...(activeLease ? { lease: activeLease } : {}),
+            update: {
                 projectId: params.project.id,
                 linearIssueId: normalizedIssue.id,
                 ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
@@ -103,20 +110,32 @@ export class DesiredStageRecorder {
                 ...linkedPrAdoption?.issueUpdates,
                 delegatedToPatchRelay: delegated,
                 ...workflowPlan.resolvedIssueUpdate,
-            });
+            },
+        });
+        let issue;
+        if (issueCommit.outcome === "applied") {
+            issue = issueCommit.issue;
             if (workflowPlan.effectiveRunRelease.release && activeRun && releaseReason) {
                 this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: releaseReason });
             }
-            return record;
-        };
-        const activeLease = this.db.issueSessions.getActiveIssueSessionLease(params.project.id, normalizedIssue.id);
-        const issue = activeLease
-            ? this.db.issueSessions.withIssueSessionLease(params.project.id, normalizedIssue.id, activeLease.leaseId, commitIssueUpdate) ?? (existingIssue ?? this.db.issues.upsertIssue({
-                projectId: params.project.id,
-                linearIssueId: normalizedIssue.id,
-                ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
-            }))
-            : this.db.transaction(commitIssueUpdate);
+        }
+        else if (existingIssue) {
+            issue = existingIssue;
+        }
+        else {
+            const fallbackCommit = this.db.issueSessions.commitIssueState({
+                writer: WRITER,
+                update: {
+                    projectId: params.project.id,
+                    linearIssueId: normalizedIssue.id,
+                    ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
+                },
+            });
+            if (fallbackCommit.outcome !== "applied") {
+                return { issue: undefined, wakeRunType: undefined, delegated };
+            }
+            issue = fallbackCommit.issue;
+        }
         const previousParentIssueId = existingIssue?.parentLinearIssueId;
         const currentParentIssueId = issue.parentLinearIssueId;
         const wasResolved = isResolvedLinearState(existingIssue?.currentLinearStateType, existingIssue?.currentLinearState);

package/dist/webhooks/issue-removal-handler.js

@@ -1,4 +1,5 @@
 import { TERMINAL_STATES } from "../factory-state.js";
+const WRITER = "issue-removal-handler";
 export class IssueRemovalHandler {
     db;
     feed;
@@ -13,27 +14,42 @@ export class IssueRemovalHandler {
         const activeLease = this.db.issueSessions.getActiveIssueSessionLease(params.projectId, params.issue.id);
         const commitRemoval = () => {
             if (removedIssue?.activeRunId) {
-                const run = this.db.runs.getRunById(removedIssue.activeRunId);
-                if (run) {
-                    this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue removed from Linear" });
-                }
-                return this.db.issues.upsertIssue({
+                const removedRunId = removedIssue.activeRunId;
+                const run = this.db.runs.getRunById(removedRunId);
+                const update = {
                     projectId: params.projectId,
                     linearIssueId: params.issue.id,
                     activeRunId: null,
                     pendingRunType: null,
                     factoryState: "failed",
+                };
+                const commit = this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    expectedVersion: removedIssue.version,
+                    ...(activeLease ? { lease: activeLease } : {}),
+                    update,
+                    onConflict: (current) => (current.activeRunId === removedRunId ? update : undefined),
                 });
+                if (run && commit.outcome === "applied") {
+                    this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue removed from Linear" });
+                }
+                return;
             }
             if (removedIssue && !TERMINAL_STATES.has(removedIssue.factoryState)) {
-                return this.db.issues.upsertIssue({
+                const update = {
                     projectId: params.projectId,
                     linearIssueId: params.issue.id,
                     pendingRunType: null,
                     factoryState: "failed",
+                };
+                this.db.issueSessions.commitIssueState({
+                    writer: WRITER,
+                    expectedVersion: removedIssue.version,
+                    ...(activeLease ? { lease: activeLease } : {}),
+                    update,
+                    onConflict: (current) => (TERMINAL_STATES.has(current.factoryState) ? undefined : update),
                 });
             }
-            return removedIssue;
         };
         if (removedIssue?.activeRunId) {
             const run = this.db.runs.getRunById(removedIssue.activeRunId);
@@ -41,12 +57,7 @@ export class IssueRemovalHandler {
                 await params.stopActiveRun(run, "STOP: The Linear issue was removed. Stop working immediately and exit.");
             }
         }
-        if (activeLease) {
-            this.db.issueSessions.withIssueSessionLease(params.projectId, params.issue.id, activeLease.leaseId, commitRemoval);
-        }
-        else {
-            commitRemoval();
-        }
+        commitRemoval();
         this.db.issueSessions.appendIssueSessionEvent({
             projectId: params.projectId,
             linearIssueId: params.issue.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.75.3",
+  "version": "0.77.0",
   "license": "MIT",
   "type": "module",
   "repository": {