patchrelay 0.68.4 → 0.68.6

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.6",
+  "commit": "b47d248df282",
+  "builtAt": "2026-05-19T20:34:54.989Z"
 }

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/db/issue-store.js

@@ -1,5 +1,13 @@
 import { buildInsertBindings, buildUpdateAssignments } from "./issue-upsert-columns.js";
 import { isoNow } from "./shared.js";
+const CANCELED_OR_DUPLICATE_CHILD_PREDICATE = `
+  LOWER(TRIM(COALESCE(child.current_linear_state_type, ''))) NOT IN ('canceled', 'cancelled')
+  AND LOWER(TRIM(COALESCE(child.current_linear_state, ''))) NOT IN ('duplicate', 'canceled', 'cancelled')
+`;
+const OPEN_CHILD_PREDICATE = `
+  LOWER(TRIM(COALESCE(child.current_linear_state_type, ''))) NOT IN ('completed', 'canceled', 'cancelled')
+  AND LOWER(TRIM(COALESCE(child.current_linear_state, ''))) NOT IN ('done', 'completed', 'duplicate', 'canceled', 'cancelled')
+`;
 export class IssueStore {
     connection;
     syncIssueSessionFromIssue;
@@ -292,6 +300,19 @@ export class IssueStore {
     `).all(projectId, parentLinearIssueId);
         return rows.map(mapIssueRow);
     }
+    listCanonicalChildIssues(projectId, parentLinearIssueId) {
+        const rows = this.connection.prepare(`
+      SELECT child.*
+      FROM issue_children edges
+      JOIN issues child
+        ON child.project_id = edges.project_id
+       AND child.linear_issue_id = edges.child_linear_issue_id
+      WHERE edges.project_id = ? AND edges.parent_linear_issue_id = ?
+        AND ${CANCELED_OR_DUPLICATE_CHILD_PREDICATE}
+      ORDER BY COALESCE(child.issue_key, child.linear_issue_id) ASC
+    `).all(projectId, parentLinearIssueId);
+        return rows.map(mapIssueRow);
+    }
     countOpenChildIssues(projectId, parentLinearIssueId) {
         const row = this.connection.prepare(`
       SELECT COUNT(*) AS count
@@ -302,10 +323,7 @@ export class IssueStore {
       WHERE edges.project_id = ? AND edges.parent_linear_issue_id = ?
         AND (
           child.linear_issue_id IS NULL
-          OR (
-            COALESCE(child.current_linear_state_type, '') NOT IN ('completed', 'canceled')
-            AND LOWER(TRIM(COALESCE(child.current_linear_state, ''))) NOT IN ('done', 'duplicate', 'canceled')
-          )
+          OR (${OPEN_CHILD_PREDICATE})
         )
     `).get(projectId, parentLinearIssueId);
         return Number(row?.count ?? 0);

package/dist/db.js

@@ -163,6 +163,9 @@ export class PatchRelayDatabase {
     listChildIssues(projectId, parentLinearIssueId) {
         return this.issues.listChildIssues(projectId, parentLinearIssueId);
     }
+    listCanonicalChildIssues(projectId, parentLinearIssueId) {
+        return this.issues.listCanonicalChildIssues(projectId, parentLinearIssueId);
+    }
     countOpenChildIssues(projectId, parentLinearIssueId) {
         return this.issues.countOpenChildIssues(projectId, parentLinearIssueId);
     }

package/dist/issue-class.js

@@ -1,3 +1,26 @@
+function hasExplicitNoCodePlanningSplitIntent(issue) {
+    const text = [issue.title, issue.description].filter(Boolean).join("\n").toLowerCase();
+    if (!text.trim())
+        return false;
+    const noCodePlanning = [
+        /\bno code\b/,
+        /\bcode (?:is )?not (?:needed|required|part of this)\b/,
+        /\bplanning only\b/,
+        /\banalysis only\b/,
+        /код[^\n.]{0,80}не делаем/,
+        /без (?:изменени[яй]|правок) код[а]?/,
+        /только анализ/,
+        /только планирован/,
+    ].some((pattern) => pattern.test(text));
+    if (!noCodePlanning)
+        return false;
+    return [
+        /\b(?:create|open|file|add|split|decompose|break down)[^\n.]{0,100}\b(?:child issues|follow-?up issues|issues|tickets|tasks)\b/,
+        /\b(?:child issues|follow-?up issues|issues|tickets|tasks)[^\n.]{0,100}\b(?:create|open|file|add|split|decompose|break down)\b/,
+        /(?:поставь|создай|заведи|добавь|разбей)[^\n.]{0,100}(?:задач|тикет|issue)/,
+        /(?:задач|тикет|issue)[^\n.]{0,100}(?:поставь|создай|заведи|добавь|разбей)/,
+    ].some((pattern) => pattern.test(text));
+}
 export function classifyIssue(params) {
     if (params.issue.parentLinearIssueId) {
         return { issueClass: "implementation", issueClassSource: "hierarchy" };
@@ -14,5 +37,8 @@ export function classifyIssue(params) {
     if (params.issue.issueClassSource === "triage" && params.issue.issueClass) {
         return { issueClass: params.issue.issueClass, issueClassSource: "triage" };
     }
+    if (hasExplicitNoCodePlanningSplitIntent(params.issue)) {
+        return { issueClass: "orchestration", issueClassSource: "heuristic" };
+    }
     return { issueClass: "implementation", issueClassSource: "heuristic" };
 }

package/dist/orchestration-parent-wake.js

@@ -6,7 +6,7 @@ export function computeOrchestrationSettleUntil(now = Date.now()) {
 function resolveOrchestrationIssueClass(db, issue) {
     return classifyIssue({
         issue,
-        childIssueCount: db.issues.listChildIssues(issue.projectId, issue.linearIssueId).length,
+        childIssueCount: db.issues.listCanonicalChildIssues(issue.projectId, issue.linearIssueId).length,
     }).issueClass;
 }
 function unique(values) {

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);
@@ -186,7 +186,7 @@ export class RunOrchestrator {
             ...(entry.blockerCurrentLinearStateType ? { stateType: entry.blockerCurrentLinearStateType } : {}),
         }));
         const childIssues = this.db.issues
-            .listChildIssues(issue.projectId, issue.linearIssueId)
+            .listCanonicalChildIssues(issue.projectId, issue.linearIssueId)
             .map((entry) => ({
             linearIssueId: entry.linearIssueId,
             ...(entry.issueKey ? { issueKey: entry.issueKey } : {}),
@@ -205,7 +205,7 @@ export class RunOrchestrator {
         };
     }
     async classifyTrackedIssue(issue) {
-        const childIssues = this.db.issues.listChildIssues(issue.projectId, issue.linearIssueId);
+        const childIssues = this.db.issues.listCanonicalChildIssues(issue.projectId, issue.linearIssueId);
         const classification = classifyIssue({ issue, childIssueCount: childIssues.length });
         const triageHash = buildIssueTriageHash({ issue, childIssues });
         const triageCacheFresh = issue.issueClassSource === "triage" && issue.issueTriageHash === triageHash;

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/dist/webhooks/comment-wake-handler.js

@@ -30,7 +30,7 @@ export class CommentWakeHandler {
             return;
         const issueClass = classifyIssue({
             issue,
-            childIssueCount: this.db.issues.listChildIssues(project.id, normalized.issue.id).length,
+            childIssueCount: this.db.issues.listCanonicalChildIssues(project.id, normalized.issue.id).length,
         }).issueClass;
         const trimmedBody = normalized.comment.body.trim();
         const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);

package/dist/webhooks/desired-stage-recorder.js

@@ -75,7 +75,7 @@ export class DesiredStageRecorder {
                 terminal,
                 currentState: existingIssue?.factoryState,
             });
-        const childIssueCount = this.db.issues.listChildIssues(params.project.id, normalizedIssue.id).length;
+        const childIssueCount = this.db.issues.listCanonicalChildIssues(params.project.id, normalizedIssue.id).length;
         const classification = classifyIssue({
             issue: {
                 issueClass: existingIssue?.issueClass,

package/package.json

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