patchrelay 0.68.4 → 0.68.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.68.4",
-  "commit": "7680b548a651",
-  "builtAt": "2026-05-15T11:58:17.825Z"
+  "version": "0.68.5",
+  "commit": "cafd8f502dee",
+  "builtAt": "2026-05-16T20:40:41.007Z"
 }

package/dist/codex-app-server.js

@@ -286,12 +286,22 @@ export class CodexAppServerClient extends EventEmitter {
                 },
             });
         });
-        this.writeMessage({
-            jsonrpc: "2.0",
-            id,
-            method,
-            params,
-        });
+        try {
+            this.writeMessage({
+                jsonrpc: "2.0",
+                id,
+                method,
+                params,
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            const pending = this.pending.get(id);
+            if (pending) {
+                this.pending.delete(id);
+                pending.reject(err);
+            }
+        }
         return promise.catch((error) => {
             const err = error instanceof Error ? error : new Error(String(error));
             this.logger.error({
@@ -390,10 +400,37 @@ export class CodexAppServerClient extends EventEmitter {
         }
     }
     writeMessage(message) {
-        if (!this.child?.stdin) {
-            throw new Error("Codex app-server stdin is unavailable");
+        const child = this.child;
+        const stdin = child?.stdin;
+        if (!stdin || stdin.destroyed || stdin.writableEnded || !stdin.writable) {
+            const error = new Error("Codex app-server stdin is closed");
+            this.handleTransportFailure(error);
+            throw error;
         }
-        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+        try {
+            stdin.write(`${JSON.stringify(message)}\n`, (error) => {
+                if (error) {
+                    this.handleTransportFailure(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.handleTransportFailure(err);
+            throw err;
+        }
+    }
+    handleTransportFailure(error) {
+        const child = this.child;
+        this.started = false;
+        this.child = undefined;
+        this.stdoutBuffer = "";
+        this.logger.error({
+            error: sanitizeDiagnosticText(error.message),
+            pendingRequestCount: this.pending.size,
+        }, "Codex app-server transport failed");
+        this.rejectAllPending(error);
+        child?.kill("SIGTERM");
     }
     drainMessages() {
         while (true) {

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.4",
+  "version": "0.68.5",
   "license": "MIT",
   "type": "module",
   "repository": {