patchrelay 0.75.3 → 0.77.0

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-budgets.js

@@ -1,12 +1,46 @@
-export const DEFAULT_CI_REPAIR_BUDGET = 10;
-export const DEFAULT_QUEUE_REPAIR_BUDGET = 10;
-export const DEFAULT_REVIEW_FIX_BUDGET = 10;
+export const DEFAULT_RUN_BUDGETS = {
+    ciRepair: 10,
+    queueRepair: 10,
+    reviewFix: 10,
+    zombieRecovery: 5,
+};
+export function resolveRunBudgets(project) {
+    return {
+        ciRepair: project?.repairBudgets?.ciRepair ?? DEFAULT_RUN_BUDGETS.ciRepair,
+        queueRepair: project?.repairBudgets?.queueRepair ?? DEFAULT_RUN_BUDGETS.queueRepair,
+        reviewFix: project?.repairBudgets?.reviewFix ?? DEFAULT_RUN_BUDGETS.reviewFix,
+        // No per-project override exists for zombie recovery yet; add one to
+        // ProjectConfig.repairBudgets if a project ever needs it.
+        zombieRecovery: DEFAULT_RUN_BUDGETS.zombieRecovery,
+    };
+}
 export function getCiRepairBudget(project) {
-    return project?.repairBudgets?.ciRepair ?? DEFAULT_CI_REPAIR_BUDGET;
+    return resolveRunBudgets(project).ciRepair;
 }
 export function getQueueRepairBudget(project) {
-    return project?.repairBudgets?.queueRepair ?? DEFAULT_QUEUE_REPAIR_BUDGET;
+    return resolveRunBudgets(project).queueRepair;
 }
 export function getReviewFixBudget(project) {
-    return project?.repairBudgets?.reviewFix ?? DEFAULT_REVIEW_FIX_BUDGET;
+    return resolveRunBudgets(project).reviewFix;
+}
+export function getZombieRecoveryBudget(project) {
+    return resolveRunBudgets(project).zombieRecovery;
+}
+// ─── Zombie-recovery backoff schedule (formerly zombie-recovery.ts) ──
+//
+// Exponential backoff between retries of a run that died without doing
+// its work. Owned here with the budgets so the whole retry discipline
+// (how many attempts, how far apart) reads in one place.
+const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000;
+export function getZombieRecoveryDelayMs(recoveryAttempts) {
+    return ZOMBIE_RECOVERY_BASE_DELAY_MS * Math.pow(2, recoveryAttempts);
+}
+export function getRemainingZombieRecoveryDelayMs(lastRecoveryAt, recoveryAttempts, now = Date.now()) {
+    if (!lastRecoveryAt)
+        return 0;
+    const recoveredAtMs = Date.parse(lastRecoveryAt);
+    if (!Number.isFinite(recoveredAtMs))
+        return 0;
+    const delay = getZombieRecoveryDelayMs(recoveryAttempts);
+    return Math.max(0, recoveredAtMs + delay - now);
 }

package/dist/run-completion-policy.js

@@ -1,18 +1,59 @@
 import { ACTIVE_RUN_STATES } from "./factory-state.js";
 import { ImplementationOutcomePolicy } from "./implementation-outcome-policy.js";
 import { ReactiveRunPolicy } from "./reactive-run-policy.js";
-function resolvePostRunState(issue) {
-    if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
+// Plan §B3: the one post-run factory-state resolver. Unifies the former
+// `resolveCompletedRunState` (run-completion-policy) and
+// `resolveRecoverablePostRunState` (interrupted-run-recovery).
+//
+// Shared rule (both old functions agreed):
+//   - no PR on the issue → undefined (nothing to resolve from PR truth);
+//   - approved open/closed PR → awaiting_queue; otherwise pr_open;
+//   - merged PR (while the issue is in an active-run state) → done.
+//
+// The two old functions genuinely disagreed in two places, and the
+// disagreement is semantic, so it survives as the `outcome` option rather
+// than being averaged away:
+//   - outcome "completed" (the run did its work, default): gate every write
+//     on ACTIVE_RUN_STATES so a state advanced concurrently by webhooks
+//     (e.g. deploying, awaiting_queue) is never clobbered, and never
+//     re-derive a reactive repair state — the stale GitHub verdict
+//     (changes_requested / red CI) refers to the head the run just
+//     replaced, and routing it again would loop the fix forever.
+//   - outcome "recovered" (the run died without doing its work): GitHub
+//     truth is authoritative regardless of the local factory state —
+//     merged → done unconditionally, and an open PR re-derives the
+//     reactive intent (repairing_ci / repairing_queue / changes_requested)
+//     so the original problem is routed again.
+export function resolvePostRunFactoryState(issue, _run, options) {
+    if (!issue.prNumber)
+        return undefined;
+    if (options?.outcome === "recovered") {
         if (issue.prState === "merged")
             return "done";
-        if (issue.prReviewState === "approved")
-            return "awaiting_queue";
-        return "pr_open";
+        if (issue.prState === "open") {
+            const reactiveIntent = deriveIssueSessionReactiveIntent({
+                prNumber: issue.prNumber,
+                prState: issue.prState,
+                prReviewState: issue.prReviewState,
+                prCheckStatus: issue.prCheckStatus,
+                latestFailureSource: issue.lastGitHubFailureSource,
+            });
+            if (reactiveIntent)
+                return reactiveIntent.compatibilityFactoryState;
+            if (issue.prReviewState === "approved")
+                return "awaiting_queue";
+            return "pr_open";
+        }
+        // Closed (or unknown) PR: fall through to the factory-state-gated rule.
     }
-    return undefined;
-}
-export function resolveCompletedRunState(issue, _run) {
-    return resolvePostRunState(issue);
+    if (!ACTIVE_RUN_STATES.has(issue.factoryState))
+        return undefined;
+    if (issue.prState === "merged")
+        return "done";
+    if (issue.prReviewState === "approved")
+        return "awaiting_queue";
+    return "pr_open";
 }
 export class RunCompletionPolicy {
     reactive;