patchrelay 0.68.3 → 0.68.5

package/dist/reconcile-pr-state-updates.js

@@ -0,0 +1,40 @@
+function normalizedReviewDecision(value) {
+    return value?.trim().toUpperCase();
+}
+function reviewDecisionToPrReviewState(value) {
+    const normalized = normalizedReviewDecision(value);
+    if (normalized === "APPROVED")
+        return "approved";
+    if (normalized === "CHANGES_REQUESTED")
+        return "changes_requested";
+    if (normalized === "REVIEW_REQUIRED")
+        return "commented";
+    return undefined;
+}
+/**
+ * Pure projection from a fresh `gh pr view` snapshot into the issue-row
+ * fields that should be written back. Keeps the snapshot row in sync with
+ * GitHub truth and records a CI snapshot row (for the queue-health monitor
+ * and the operator feed) when both the head SHA and a gate check status
+ * are observable.
+ *
+ * Settled-at is null when the gate check is still pending so callers can
+ * tell a freshly-observed "in progress" from a recently-settled result.
+ */
+export function buildPrStateUpdates(pr, gateCheckStatus, primaryGateCheckName, now = () => new Date()) {
+    const prReviewState = reviewDecisionToPrReviewState(pr.reviewDecision);
+    return {
+        ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+        ...(pr.state === "OPEN" ? { prState: "open" } : {}),
+        ...(prReviewState ? { prReviewState } : {}),
+        ...(gateCheckStatus ? { prCheckStatus: gateCheckStatus } : {}),
+        ...(pr.headRefOid && gateCheckStatus
+            ? {
+                lastGitHubCiSnapshotHeadSha: pr.headRefOid,
+                lastGitHubCiSnapshotGateCheckName: primaryGateCheckName,
+                lastGitHubCiSnapshotGateCheckStatus: gateCheckStatus,
+                lastGitHubCiSnapshotSettledAt: gateCheckStatus === "pending" ? null : now().toISOString(),
+            }
+            : {}),
+    };
+}

package/dist/run-orchestrator.js

@@ -134,7 +134,7 @@ export class RunOrchestrator {
         this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed);
         this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.getHeldLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.leasePorts.releaseLease, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
-        this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, feed);
+        this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, feed);
         this.runWakePlanner = new RunWakePlanner(db);
         this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed);
         this.mainBranchHealthMonitor = new MainBranchHealthMonitor(db, config, linearProvider, this.wakeDispatcher, logger, feed);

package/dist/run-reconciler.js

@@ -6,6 +6,7 @@ import { getThreadTurns } from "./codex-thread-utils.js";
 import { resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
 import { resolveEffectiveActiveRun } from "./effective-active-run.js";
 import { isThreadMaterializingError } from "./codex-thread-errors.js";
+import { fetchPullRequestSnapshot } from "./reconcile-pr-fetch.js";
 const THREAD_MATERIALIZATION_GRACE_MS = 10 * 60_000;
 function isWithinThreadMaterializationGrace(run, nowMs = Date.now()) {
     const startedAtMs = Date.parse(run.startedAt);
@@ -24,8 +25,9 @@ export class RunReconciler {
     releaseLease;
     readThreadWithRetry;
     recoverOrEscalate;
+    resolveRepoFullName;
     feed;
-    constructor(db, logger, linearProvider, linearSync, interruptedRunRecovery, runFinalizer, withHeldLease, releaseLease, readThreadWithRetry, recoverOrEscalate, feed) {
+    constructor(db, logger, linearProvider, linearSync, interruptedRunRecovery, runFinalizer, withHeldLease, releaseLease, readThreadWithRetry, recoverOrEscalate, resolveRepoFullName = () => undefined, feed) {
         this.db = db;
         this.logger = logger;
         this.linearProvider = linearProvider;
@@ -36,6 +38,7 @@ export class RunReconciler {
         this.releaseLease = releaseLease;
         this.readThreadWithRetry = readThreadWithRetry;
         this.recoverOrEscalate = recoverOrEscalate;
+        this.resolveRepoFullName = resolveRepoFullName;
         this.feed = feed;
     }
     async reconcile(params) {
@@ -76,6 +79,9 @@ export class RunReconciler {
             this.releaseLease(run.projectId, run.linearIssueId);
             return;
         }
+        if (await this.releaseRunIfPullRequestMerged(run, effectiveIssue)) {
+            return;
+        }
         if (!run.threadId) {
             if (recoveryLease === "owned") {
                 this.logger.debug({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType }, "Skipping zombie reconciliation for locally-owned launch that has not created a thread yet");
@@ -171,6 +177,56 @@ export class RunReconciler {
             this.releaseLease(run.projectId, run.linearIssueId);
         }
     }
+    async releaseRunIfPullRequestMerged(run, issue) {
+        if (issue.prNumber === undefined)
+            return false;
+        if (issue.prState === "merged") {
+            this.releaseMergedRun(run, issue, "Cached PR state is merged");
+            return true;
+        }
+        const repoFullName = this.resolveRepoFullName(issue.projectId);
+        if (!repoFullName)
+            return false;
+        const snapshot = await fetchPullRequestSnapshot(repoFullName, issue.prNumber);
+        if (!snapshot.ok) {
+            this.logger.debug({ issueKey: issue.issueKey, prNumber: issue.prNumber, error: snapshot.error.message }, "Could not refresh active-run PR state during reconciliation");
+            return false;
+        }
+        if (snapshot.pr.state !== "MERGED")
+            return false;
+        this.releaseMergedRun(run, issue, "Pull request merged while the active Codex run was still marked running");
+        return true;
+    }
+    releaseMergedRun(run, issue, reason) {
+        this.withHeldLease(run.projectId, run.linearIssueId, () => {
+            this.db.issueSessions.clearPendingIssueSessionEvents(run.projectId, run.linearIssueId);
+            this.db.runs.finishRun(run.id, {
+                status: "released",
+                failureReason: reason,
+            });
+            this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: null,
+                factoryState: "done",
+                prState: "merged",
+                pendingRunType: null,
+                pendingRunContextJson: null,
+            });
+        });
+        this.feed?.publish({
+            level: "info",
+            kind: "stage",
+            issueKey: issue.issueKey,
+            projectId: run.projectId,
+            stage: "done",
+            status: "reconciled",
+            summary: `Released active ${run.runType} run after PR merge`,
+        });
+        const doneIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        void this.linearSync.syncSession(doneIssue, { activeRunType: run.runType });
+        this.releaseLease(run.projectId, run.linearIssueId);
+    }
     async confirmDelegationAuthorityBeforeRelease(run, issue) {
         const installation = this.db.linearInstallations.getLinearInstallationForProject(run.projectId);
         const linear = await this.linearProvider.forProject(run.projectId).catch(() => undefined);

package/package.json

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