patchrelay 0.75.2 → 0.76.0

package/dist/agent-input-service.js

@@ -2,6 +2,7 @@ import { buildFollowupStatusActivity, buildNonActionableFollowupActivity, buildP
 import { deriveIssueStatusNote } from "./status-note.js";
 import { extractLatestAssistantSummary } from "./issue-session-events.js";
 import { dirtyWorktreeEventPayload, inspectGitWorktreeStatus } from "./git-worktree-status.js";
+const WRITER = "agent-input-service";
 export class AgentInputService {
     db;
     codex;
@@ -195,21 +196,25 @@ export class AgentInputService {
     prepareReplacementWork(project, issue) {
         const issueRef = (issue.issueKey ?? issue.linearIssueId).replace(/[^a-zA-Z0-9._-]+/g, "-");
         const suffix = Date.now().toString(36);
-        return this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            factoryState: "delegated",
-            branchName: `${project.branchPrefix}/${issueRef}-replacement-${suffix}`,
-            prNumber: null,
-            prUrl: null,
-            prState: null,
-            prIsDraft: null,
-            prHeadSha: null,
-            prAuthorLogin: null,
-            prReviewState: null,
-            prCheckStatus: null,
-            lastBlockingReviewHeadSha: null,
-        }) ?? issue;
+        const commit = this.db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: "delegated",
+                branchName: `${project.branchPrefix}/${issueRef}-replacement-${suffix}`,
+                prNumber: null,
+                prUrl: null,
+                prState: null,
+                prIsDraft: null,
+                prHeadSha: null,
+                prAuthorLogin: null,
+                prReviewState: null,
+                prCheckStatus: null,
+                lastBlockingReviewHeadSha: null,
+            },
+        });
+        return commit.outcome === "applied" ? commit.issue : issue;
     }
     async stopActiveRun(issue, run, body, source) {
         const worktreeStatus = issue.worktreePath ? inspectGitWorktreeStatus(issue.worktreePath) : undefined;
@@ -226,18 +231,27 @@ export class AgentInputService {
             catch (error) {
                 this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop request");
             }
-            this.db.runs.finishRun(run.id, {
-                status: "released",
-                threadId: run.threadId,
-                turnId: run.turnId,
-                failureReason: dirtySummary ? `Operator stopped run; ${dirtySummary}` : "Operator stopped run",
-            });
         }
-        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            activeRunId: null,
-            factoryState: "awaiting_input",
+        // The stop is an operator 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: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    activeRunId: null,
+                    factoryState: "awaiting_input",
+                },
+            });
+            if (commit.outcome === "applied" && run.threadId && run.turnId) {
+                this.db.runs.finishRun(run.id, {
+                    status: "released",
+                    threadId: run.threadId,
+                    turnId: run.turnId,
+                    failureReason: dirtySummary ? `Operator stopped run; ${dirtySummary}` : "Operator stopped run",
+                });
+            }
         });
         this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
             eventType: "stop_requested",

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.75.2",
-  "commit": "ba00b4a18609",
-  "builtAt": "2026-06-05T23:03:05.291Z"
+  "version": "0.76.0",
+  "commit": "b6c068ca2195",
+  "builtAt": "2026-06-10T03:29:06.189Z"
 }

package/dist/cli/data.js

@@ -276,7 +276,9 @@ export class CliDataAccess extends CliOperatorApiClient {
                     : `Operator closed issue as ${terminalState}`,
             });
         }
-        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        // Operator CLI manual close — interactive, single-writer by construction
+        // (see the issue-write-door guard allowlist), so a raw upsert is fine.
+        this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             delegatedToPatchRelay: false,

package/dist/db/issue-session-store.js

@@ -20,6 +20,7 @@ export class IssueSessionStore {
         this.telemetry = telemetry;
     }
     getIssueSession(projectId, linearIssueId) {
+        this.issueSessionProjection.assertNotMidBatch?.("getIssueSession");
         const row = this.connection
             .prepare("SELECT * FROM issue_sessions WHERE project_id = ? AND linear_issue_id = ?")
             .get(projectId, linearIssueId);
@@ -261,15 +262,49 @@ export class IssueSessionStore {
             return fn();
         })();
     }
-    upsertIssueWithLease(lease, params) {
-        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => this.issues.upsertIssue(params));
-    }
-    upsertIssueRespectingActiveLease(projectId, linearIssueId, params) {
-        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
-        if (!lease) {
-            return this.issues.upsertIssue(params);
-        }
-        return this.upsertIssueWithLease(lease, params);
+    /**
+     * The single door for issue-state writes (core simplification plan, phase
+     * A): one transaction wrapping lease validity, an optimistic version check
+     * against the row the update was derived from, and the write itself. A
+     * version mismatch means another writer landed between the caller's read
+     * and this commit — emitted as `state.write_conflict` telemetry and either
+     * recomputed via `onConflict`, skipped, or applied anyway (see params).
+     */
+    commitIssueState(params) {
+        return this.connection.transaction(() => {
+            const { projectId, linearIssueId } = params.update;
+            if (params.lease && !this.hasActiveIssueSessionLease(projectId, linearIssueId, params.lease.leaseId)) {
+                return { outcome: "lease_denied" };
+            }
+            const current = this.issues.getIssue(projectId, linearIssueId);
+            const actualVersion = current?.version ?? null;
+            if (params.expectedVersion === undefined || actualVersion === params.expectedVersion) {
+                return { outcome: "applied", issue: this.issues.upsertIssue(params.update), conflicted: false };
+            }
+            const emitConflict = (resolution) => {
+                emitTelemetry(this.telemetry, {
+                    type: "state.write_conflict",
+                    projectId,
+                    linearIssueId,
+                    ...(current?.issueKey ? { issueKey: current.issueKey } : {}),
+                    writer: params.writer,
+                    expectedVersion: params.expectedVersion ?? null,
+                    actualVersion,
+                    resolution,
+                });
+            };
+            if (params.onConflict && current) {
+                const recomputed = params.onConflict(current);
+                if (!recomputed) {
+                    emitConflict("skipped");
+                    return { outcome: "conflict_skipped", issue: current };
+                }
+                emitConflict("recomputed");
+                return { outcome: "applied", issue: this.issues.upsertIssue(recomputed), conflicted: true };
+            }
+            emitConflict("applied_anyway");
+            return { outcome: "applied", issue: this.issues.upsertIssue(params.update), conflicted: true };
+        })();
     }
     finishRunWithLease(lease, runId, params) {
         return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {

package/dist/db/issue-store.js

@@ -1,3 +1,4 @@
+import { FACTORY_STATES, isFactoryState } from "../factory-state.js";
 import { buildInsertBindings, buildUpdateAssignments } from "./issue-upsert-columns.js";
 import { isoNow } from "./shared.js";
 const CANCELED_OR_DUPLICATE_CHILD_PREDICATE = `
@@ -20,7 +21,7 @@ export class IssueStore {
         const existing = this.getIssue(params.projectId, params.linearIssueId);
         if (existing) {
             const { assignments, values } = buildUpdateAssignments(params);
-            const sql = `UPDATE issues SET ${["updated_at = @now", ...assignments].join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`;
+            const sql = `UPDATE issues SET ${["updated_at = @now", "version = version + 1", ...assignments].join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`;
             this.connection.prepare(sql).run({
                 ...values,
                 now,
@@ -92,6 +93,26 @@ export class IssueStore {
             .all();
         return rows.map(mapIssueRow);
     }
+    // Recovery net for a dangling active slot: an issue whose
+    // `active_run_id` still points at a run that has already reached a
+    // terminal status. This happens when the post-run finalize never ran
+    // to completion — almost always a service restart landing between
+    // `finishRun` (which marks the run terminal) and the issue write that
+    // clears `active_run_id` and arms the next wake. The Codex
+    // `turn/completed` notification that would finalize it never re-fires
+    // after restart, and every idle/recovery pass gates on
+    // `active_run_id IS NULL`, so the issue is invisible to all of them
+    // and freezes indefinitely. The orchestrator clears the slot so the
+    // idle reconciler can route the issue forward (review_fix, etc.).
+    listIssuesWithTerminalActiveRun() {
+        const rows = this.connection
+            .prepare(`SELECT i.* FROM issues i
+         JOIN runs r ON r.id = i.active_run_id
+         WHERE i.active_run_id IS NOT NULL
+         AND r.status IN ('completed', 'failed', 'released', 'superseded')`)
+            .all();
+        return rows.map(mapIssueRow);
+    }
     // Safety net for orphaned wakes: any delegated, non-terminal issue
     // with at least one unprocessed session event but no active run.
     // The orchestrator's enqueueIssue is the only path that drains these
@@ -399,6 +420,13 @@ export class IssueStore {
     }
 }
 export function mapIssueRow(row) {
+    const factoryState = String(row.factory_state ?? "delegated");
+    if (!isFactoryState(factoryState)) {
+        throw new Error(`Invalid factory_state '${factoryState}' on issue row `
+            + `${String(row.project_id)}/${String(row.linear_issue_id)}`
+            + `${row.issue_key != null ? ` (${String(row.issue_key)})` : ""}; `
+            + "expected one of: " + [...FACTORY_STATES].join(", "));
+    }
     return {
         id: Number(row.id),
         projectId: String(row.project_id),
@@ -428,7 +456,7 @@ export function mapIssueRow(row) {
         ...(row.current_linear_state_type !== null && row.current_linear_state_type !== undefined
             ? { currentLinearStateType: String(row.current_linear_state_type) }
             : {}),
-        factoryState: String(row.factory_state ?? "delegated"),
+        factoryState,
         ...(row.pending_run_type !== null && row.pending_run_type !== undefined ? { pendingRunType: String(row.pending_run_type) } : {}),
         ...(row.pending_run_context_json !== null && row.pending_run_context_json !== undefined ? { pendingRunContextJson: String(row.pending_run_context_json) } : {}),
         ...(row.branch_name !== null ? { branchName: String(row.branch_name) } : {}),
@@ -526,5 +554,6 @@ export function mapIssueRow(row) {
         ...(row.deploy_started_at !== null && row.deploy_started_at !== undefined
             ? { deployStartedAt: String(row.deploy_started_at) }
             : {}),
+        version: Number(row.version ?? 0),
     };
 }

package/dist/db/migrations.js

@@ -366,6 +366,9 @@ export function runPatchRelayMigrations(connection) {
     // `deploying` state, so the deploy watcher only considers deploy runs
     // created at/after the merge (and can time out a never-arriving deploy).
     addColumnIfMissing(connection, "issues", "deploy_started_at", "TEXT");
+    // Optimistic-concurrency counter for issue-state writes (core
+    // simplification plan, phase A). Bumped on every UPDATE by upsertIssue.
+    addColumnIfMissing(connection, "issues", "version", "INTEGER NOT NULL DEFAULT 0");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/factory-state.js

@@ -1,3 +1,26 @@
+/**
+ * Canonical value set for {@link FactoryState}. Used for read-side validation
+ * (row mappers throw on unknown values instead of lying via cast) — keep in
+ * sync with the union above; `satisfies` rejects values outside the union.
+ */
+const FACTORY_STATE_VALUES = [
+    "delegated",
+    "implementing",
+    "pr_open",
+    "changes_requested",
+    "repairing_ci",
+    "awaiting_queue",
+    "repairing_queue",
+    "deploying",
+    "awaiting_input",
+    "escalated",
+    "done",
+    "failed",
+];
+export const FACTORY_STATES = new Set(FACTORY_STATE_VALUES);
+export function isFactoryState(value) {
+    return FACTORY_STATES.has(value);
+}
 /** Which factory states involve an active Codex run. */
 export const ACTIVE_RUN_STATES = new Set([
     "implementing",

package/dist/github-webhook-reactive-run.js

@@ -4,6 +4,7 @@ import { isIssueTerminal } from "./pr-state.js";
 import { buildGitHubQueueFailureContext, getRelevantGitHubCiSnapshot, resolveGitHubBranchFailureContext, resolveGitHubCheckClass, } from "./github-webhook-failure-context.js";
 import { isQueueEvictionFailure, isSettledBranchFailure } from "./github-webhook-policy.js";
 import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
+const WRITER = "github-webhook-reactive-run";
 export async function maybeEnqueueGitHubReactiveRun(params) {
     const { issue, event, project, logger, feed, wakeDispatcher, db, fetchImpl, failureContextResolver } = params;
     if (isIssueTerminal(issue))
@@ -116,17 +117,20 @@ async function handleCheckFailedEvent(params) {
         return;
     }
     const snapshot = getRelevantGitHubCiSnapshot(db, issue, event);
-    db.issues.upsertIssue({
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
-        lastGitHubFailureSource: "branch_ci",
-        lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? 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(),
-        lastQueueIncidentJson: null,
+    db.issueSessions.commitIssueState({
+        writer: WRITER,
+        update: {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubFailureSource: "branch_ci",
+            lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? 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(),
+            lastQueueIncidentJson: null,
+        },
     });
     const queuedRunType = wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
         eventType: "settled_red_ci",

package/dist/github-webhook-stack-coordination.js

@@ -1,3 +1,4 @@
+const WRITER = "github-webhook-stack-coordination";
 // Plan §8.3-8.4: when a parent PR's head moves (review-fix push,
 // eviction repair, base-branch update), child PRs stacked on it
 // become stale. Patchrelay treats this as a wake event for each
@@ -19,10 +20,13 @@ export function maybeFanChildRebaseWakes(params) {
             logger.debug({ parentBranch: event.branchName, childIssue: child.issueKey, childRunId: child.activeRunId }, "Skipping child-rebase wake — child has an active run");
             continue;
         }
-        db.issues.upsertIssue({
-            projectId: child.projectId,
-            linearIssueId: child.linearIssueId,
-            pendingRunType: "branch_upkeep",
+        db.issueSessions.commitIssueState({
+            writer: WRITER,
+            update: {
+                projectId: child.projectId,
+                linearIssueId: child.linearIssueId,
+                pendingRunType: "branch_upkeep",
+            },
         });
         // The pending_run_type field above isn't an event, so we still need
         // an explicit dispatch call. dispatchIfWakePending will pick up the