patchrelay 0.50.2 → 0.50.4

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.50.2",
-  "commit": "59ab92391401",
-  "builtAt": "2026-04-20T18:42:11.703Z"
+  "version": "0.50.4",
+  "commit": "0063b47a1df7",
+  "builtAt": "2026-04-21T12:01:24.460Z"
 }

package/dist/implementation-outcome-policy.js

@@ -16,53 +16,74 @@ export class ImplementationOutcomePolicy {
         }
         const project = this.config.projects.find((entry) => entry.id === run.projectId);
         const baseBranch = project?.github?.baseBranch ?? "main";
-        if (issue.prNumber && issue.prState && issue.prState !== "closed") {
+        const publishedPrState = await this.detectPublishedPrState(issue, project?.github?.repoFullName);
+        if (publishedPrState === "open") {
             return undefined;
         }
-        if (project?.github?.repoFullName && issue.branchName) {
-            try {
-                const { stdout, exitCode } = await execCommand("gh", [
-                    "pr",
-                    "list",
-                    "--repo",
-                    project.github.repoFullName,
-                    "--head",
-                    issue.branchName,
-                    "--state",
-                    "all",
-                    "--json",
-                    "number,url,state,author,headRefOid",
-                ], { timeoutMs: 10_000 });
-                if (exitCode === 0) {
-                    const matches = JSON.parse(stdout);
-                    const pr = matches[0];
-                    if (pr?.number) {
-                        this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
-                            projectId: issue.projectId,
-                            linearIssueId: issue.linearIssueId,
-                            prNumber: pr.number,
-                            ...(pr.url ? { prUrl: pr.url } : {}),
-                            ...(pr.state ? { prState: pr.state.toLowerCase() } : {}),
-                            ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                            ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
-                        }, "published PR verification refresh");
-                        if (pr.state?.toLowerCase() !== "closed") {
-                            return undefined;
-                        }
-                    }
-                }
+        const details = await this.describeLocalImplementationOutcome(issue, baseBranch);
+        return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
+    }
+    async detectRecoverableFailedImplementationOutcome(run, issue) {
+        if (run.runType !== "implementation") {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const publishedPrState = await this.detectPublishedPrState(issue, project?.github?.repoFullName);
+        if (publishedPrState === "open" || publishedPrState === "unknown") {
+            return undefined;
+        }
+        const baseBranch = project?.github?.baseBranch ?? "main";
+        return await this.describeLocalImplementationOutcome(issue, baseBranch);
+    }
+    async detectPublishedPrState(issue, repoFullName) {
+        if (issue.prNumber && issue.prState && issue.prState !== "closed") {
+            return "open";
+        }
+        if (!repoFullName || !issue.branchName) {
+            return "unknown";
+        }
+        try {
+            const { stdout, exitCode } = await execCommand("gh", [
+                "pr",
+                "list",
+                "--repo",
+                repoFullName,
+                "--head",
+                issue.branchName,
+                "--state",
+                "all",
+                "--json",
+                "number,url,state,author,headRefOid",
+            ], { timeoutMs: 10_000 });
+            if (exitCode !== 0) {
+                return "unknown";
             }
-            catch (error) {
-                this.logger.debug({
-                    issueKey: issue.issueKey,
-                    branchName: issue.branchName,
-                    repoFullName: project.github.repoFullName,
-                    error: error instanceof Error ? error.message : String(error),
-                }, "Failed to verify published PR state after implementation");
+            const matches = JSON.parse(stdout);
+            const pr = matches[0];
+            if (!pr?.number) {
+                return "none";
             }
+            const state = pr.state?.toLowerCase();
+            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                prNumber: pr.number,
+                ...(pr.url ? { prUrl: pr.url } : {}),
+                ...(state ? { prState: state } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
+            }, "published PR verification refresh");
+            return state === "closed" ? "closed" : "open";
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                branchName: issue.branchName,
+                repoFullName,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to verify published PR state after implementation");
+            return "unknown";
         }
-        const details = await this.describeLocalImplementationOutcome(issue, baseBranch);
-        return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
     }
     upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
         const updated = this.withHeldLease(projectId, linearIssueId, (lease) => this.db.issueSessions.upsertIssueWithLease(lease, params));

package/dist/no-pr-completion-check.js

@@ -8,10 +8,12 @@ function shouldContinueForUnpublishedLocalChanges(message) {
         || (normalized.includes("local commit") && normalized.includes("ahead of origin/"));
 }
 export async function handleNoPrCompletionCheck(params) {
-    const completedRunUpdate = buildCompletedRunUpdate({
+    const runUpdate = buildRunUpdate({
+        status: params.runStatus,
         threadId: params.threadId,
         ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
         report: params.report,
+        ...(params.failureReason ? { failureReason: params.failureReason } : {}),
     });
     params.publishTurnEvent({
         level: "info",
@@ -53,7 +55,7 @@ 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, completedRunUpdate);
+            params.db.runs.finishRun(params.run.id, runUpdate);
             params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
             params.db.issues.upsertIssue({
                 projectId: params.run.projectId,
@@ -93,7 +95,7 @@ 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, completedRunUpdate);
+            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({
@@ -125,7 +127,7 @@ 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, completedRunUpdate);
+                params.db.runs.finishRun(params.run.id, runUpdate);
                 params.db.runs.saveCompletionCheck(params.run.id, {
                     ...completionCheck,
                     outcome: "continue",
@@ -172,7 +174,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, completedRunUpdate);
+            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({
@@ -226,7 +228,7 @@ 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, {
-            ...completedRunUpdate,
+            ...runUpdate,
             status: "failed",
             failureReason,
         });
@@ -256,12 +258,13 @@ export async function handleNoPrCompletionCheck(params) {
         detail: completionCheck.summary,
     });
 }
-function buildCompletedRunUpdate(params) {
+function buildRunUpdate(params) {
     return {
-        status: "completed",
+        status: params.status,
         threadId: params.threadId,
         ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
         summaryJson: JSON.stringify({ latestAssistantMessage: params.report.assistantMessages.at(-1) ?? null }),
         reportJson: JSON.stringify(params.report),
+        ...(params.failureReason ? { failureReason: params.failureReason } : {}),
     };
 }

package/dist/prompting/patchrelay.js

@@ -157,7 +157,10 @@ function buildOrchestrationConstraints(context) {
         "## Constraints",
         "",
         "This issue is orchestration work. Coordinate convergence instead of duplicating child implementation.",
+        "Inspect the current child set before acting. Reuse existing child issues when they already cover the needed slices instead of creating duplicates.",
+        "Babysit child progress and solve parent-owned integration or convergence issues when the delivered pieces do not yet fit together cleanly.",
         "Do not open an overlapping umbrella PR unless this parent owns unique direct work.",
+        "Create new child issues only for genuinely missing required work needed to satisfy the parent goal.",
         "Leave later-wave child issues queued unless they are immediately actionable.",
         "",
         "### Child Issue Summaries",
@@ -435,6 +438,8 @@ function buildOrchestrationWorkflowGuidance() {
         "## Workflow",
         "",
         "Use the wake reason and child issue summaries to decide the next orchestration step.",
+        "Prefer supervising, auditing, and unblocking existing child work over creating more issues.",
+        "If the parent goal now depends on an integration fix between delivered child slices, own that convergence work here without restating already-owned child implementation.",
         "Keep outputs concise and observable in Linear.",
     ].join("\n");
 }

package/dist/run-completion-policy.js

@@ -39,4 +39,7 @@ export class RunCompletionPolicy {
     async verifyPublishedRunOutcome(run, issue) {
         return await this.implementationOutcomes.verifyPublishedRunOutcome(run, issue);
     }
+    async detectRecoverableFailedImplementationOutcome(run, issue) {
+        return await this.implementationOutcomes.detectRecoverableFailedImplementationOutcome(run, issue);
+    }
 }

package/dist/run-finalizer.js

@@ -126,6 +126,7 @@ export class RunFinalizer {
                 run,
                 issue: freshIssue,
                 report,
+                runStatus: "completed",
                 threadId,
                 ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
                 publishedOutcomeError,
@@ -220,4 +221,34 @@ export class RunFinalizer {
         this.linearSync.clearProgress(run.id);
         this.releaseLease(run.projectId, run.linearIssueId);
     }
+    async recoverFailedImplementationRun(params) {
+        const freshIssue = this.db.issues.getIssue(params.run.projectId, params.run.linearIssueId) ?? params.issue;
+        const publishedOutcomeError = await this.completionPolicy.detectRecoverableFailedImplementationOutcome(params.run, freshIssue);
+        if (!publishedOutcomeError) {
+            return false;
+        }
+        const trackedIssue = this.db.issueToTrackedIssue(freshIssue);
+        const report = buildStageReport({ ...params.run, status: "failed" }, trackedIssue, params.thread, countEventMethods(this.db.runs.listThreadEvents(params.run.id)));
+        await handleNoPrCompletionCheck({
+            db: this.db,
+            logger: this.logger,
+            withHeldLease: this.withHeldLease,
+            completionCheck: this.completionCheck,
+            run: params.run,
+            issue: freshIssue,
+            report,
+            runStatus: "failed",
+            threadId: params.threadId,
+            ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
+            failureReason: params.failureReason,
+            publishedOutcomeError,
+            failRunAndClear: this.failRunAndClear,
+            emitActivity: (issueRecord, activity, options) => this.linearSync.emitActivity(issueRecord, activity, options),
+            publishTurnEvent: (event) => this.publishTurnEvent(event),
+            syncFailureOutcome: (event) => this.syncFailureOutcome(event),
+            syncCompletionCheckOutcome: (event) => this.syncCompletionCheckOutcome(event),
+            clearProgressAndRelease: (releaseRun) => this.clearProgressAndRelease(releaseRun),
+        });
+        return true;
+    }
 }

package/dist/run-notification-handler.js

@@ -75,13 +75,26 @@ export class RunNotificationHandler {
         const completedTurnId = extractTurnId(notification.params);
         const status = resolveRunCompletionStatus(notification.params);
         if (status === "failed") {
+            const failureReason = "Codex reported the turn completed in a failed state";
+            const recovered = await this.runFinalizer.recoverFailedImplementationRun({
+                run,
+                issue,
+                thread,
+                threadId,
+                ...(completedTurnId ? { completedTurnId } : {}),
+                failureReason,
+            });
+            if (recovered) {
+                this.activeThreadId = undefined;
+                return;
+            }
             const nextState = isRequestedChangesRunType(run.runType) ? "escalated" : "failed";
             const updated = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (lease) => {
                 this.db.issueSessions.finishRunWithLease(lease, run.id, {
                     status: "failed",
                     threadId,
                     ...(completedTurnId ? { turnId: completedTurnId } : {}),
-                    failureReason: "Codex reported the turn completed in a failed state",
+                    failureReason,
                 });
                 this.db.issueSessions.upsertIssueWithLease(lease, {
                     projectId: run.projectId,

package/package.json

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