patchrelay 0.75.2 → 0.75.3

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.75.3",
+  "commit": "0186011684f3",
+  "builtAt": "2026-06-09T00:09:44.822Z"
 }

package/dist/db/issue-store.js

@@ -92,6 +92,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

package/dist/run-orchestrator.js

@@ -26,6 +26,10 @@ import { CodexThreadMaterializingError, isThreadMaterializingError } from "./cod
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 import { LinearIssueProjectionService } from "./linear-issue-projection.js";
 import { RunAdmissionController } from "./run-admission-controller.js";
+// A terminal run must hold the active slot for at least this long before
+// the orchestrator force-clears it, so we never race the normal
+// notification-driven finalize that runs within seconds of completion.
+const DANGLING_ACTIVE_RUN_MIN_AGE_MS = 2 * 60_000;
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
 }
@@ -559,6 +563,10 @@ export class RunOrchestrator {
         for (const run of this.db.runs.listRunningRuns()) {
             await this.reconcileRun(run);
         }
+        // Free any issue whose active slot is pinned to an already-terminal
+        // run (post-run finalize interrupted by restart). Must run before the
+        // idle reconciler so the freed issue is routed in this same pass.
+        this.finalizeDanglingActiveRuns();
         // Preemptively detect stuck merge-queue PRs (conflicts visible on
         // GitHub) and dispatch queue_repair before the Steward evicts.
         await this.queueHealthMonitor.reconcile();
@@ -584,6 +592,67 @@ export class RunOrchestrator {
             isRequestedChangesRunType,
         });
     }
+    // Clear a dangling active slot: an issue still pointing at an
+    // already-terminal run via `activeRunId`. The post-run finalize was
+    // interrupted (almost always a restart between marking the run
+    // terminal and clearing the slot), so the run can never drive the
+    // session forward, yet every idle/recovery pass skips the issue
+    // because `activeRunId` is set. We re-read under the issue-session
+    // lease and null the slot; the idle reconciler then routes the issue
+    // from GitHub truth (e.g. a missed changes_requested → review_fix).
+    finalizeDanglingActiveRuns() {
+        for (const issue of this.db.issues.listIssuesWithTerminalActiveRun()) {
+            if (issue.activeRunId === undefined)
+                continue;
+            const run = this.db.runs.getRunById(issue.activeRunId);
+            // The query already filters to terminal runs; this guards against a
+            // race where the run advanced back to active between query and read.
+            if (!run || run.status === "running" || run.status === "queued")
+                continue;
+            // Hold off until the run has been terminal long enough that the
+            // normal notification-driven finalize has demonstrably not run —
+            // avoids racing a live completion that is milliseconds from clearing
+            // the slot itself.
+            const endedAtMs = run.endedAt ? Date.parse(run.endedAt) : Number.NaN;
+            if (Number.isFinite(endedAtMs) && Date.now() - endedAtMs < DANGLING_ACTIVE_RUN_MIN_AGE_MS)
+                continue;
+            const lease = this.claimLeaseForReconciliation(run.projectId, run.linearIssueId);
+            // "skip" → a live lease owns the session (a real run is in flight);
+            // leave it alone. "owned" → an outer local scope holds it, so we
+            // must not release it here.
+            if (lease === "skip")
+                continue;
+            try {
+                const cleared = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (held) => {
+                    const fresh = this.db.issues.getIssue(run.projectId, run.linearIssueId);
+                    if (!fresh || fresh.activeRunId !== run.id)
+                        return false;
+                    this.db.issueSessions.upsertIssueWithLease(held, {
+                        projectId: run.projectId,
+                        linearIssueId: run.linearIssueId,
+                        activeRunId: null,
+                    });
+                    return true;
+                });
+                if (cleared) {
+                    this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, runStatus: run.status }, "Cleared dangling active-run slot left by a terminal run; idle reconcile will resume the issue");
+                    this.feed?.publish({
+                        level: "warn",
+                        kind: "workflow",
+                        issueKey: issue.issueKey,
+                        projectId: run.projectId,
+                        stage: run.runType,
+                        status: "recovered",
+                        summary: `Cleared stuck active slot: run #${run.id} was ${run.status} but still held the issue`,
+                    });
+                }
+            }
+            finally {
+                if (lease !== "owned")
+                    this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+            }
+        }
+    }
     async reconcileRun(run) {
         const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
         if (!issue)

package/package.json

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