patchrelay 0.35.1 → 0.35.3

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.1",
-  "commit": "f9a5d8a6d7ff",
-  "builtAt": "2026-04-02T23:43:16.960Z"
+  "version": "0.35.3",
+  "commit": "6107a755ba05",
+  "builtAt": "2026-04-03T02:41:14.980Z"
 }

package/dist/db.js

@@ -484,6 +484,20 @@ export class PatchRelayDatabase {
             .all();
         return rows.map(mapIssueRow);
     }
+    /**
+     * Issues in delegated state with dependencies but no pending/active run.
+     * Candidates for unblocking when their blockers complete.
+     */
+    listBlockedDelegatedIssues() {
+        const rows = this.connection
+            .prepare(`SELECT DISTINCT i.* FROM issues i
+         JOIN issue_dependencies d ON d.project_id = i.project_id AND d.linear_issue_id = i.linear_issue_id
+         WHERE i.factory_state = 'delegated'
+         AND i.active_run_id IS NULL
+         AND i.pending_run_type IS NULL`)
+            .all();
+        return rows.map(mapIssueRow);
+    }
     /**
      * Issues waiting in the merge queue with no active or pending run.
      * Used by the queue health monitor to probe GitHub for stuck PRs.

package/dist/run-orchestrator.js

@@ -126,6 +126,10 @@ export class RunOrchestrator {
         const issue = this.db.getIssue(item.projectId, item.issueId);
         if (!issue?.pendingRunType || issue.activeRunId !== undefined)
             return;
+        if (issue.prState === "merged") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingRunType: null, factoryState: "done" });
+            return;
+        }
         const runType = issue.pendingRunType;
         const contextJson = issue.pendingRunContextJson;
         const context = contextJson ? JSON.parse(contextJson) : undefined;
@@ -759,6 +763,18 @@ export class RunOrchestrator {
                 await this.reconcileFromGitHub(issue);
             }
         }
+        // Unblock delegated issues whose blockers have been resolved.
+        for (const issue of this.db.listBlockedDelegatedIssues()) {
+            const unresolved = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+            if (unresolved === 0) {
+                this.db.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    pendingRunType: "implementation",
+                });
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
+        }
     }
     async reconcileFromGitHub(issue) {
         const project = this.config.projects.find((p) => p.id === issue.projectId);

package/dist/service.js

@@ -487,6 +487,10 @@ export class PatchRelayService {
             return undefined;
         if (issue.activeRunId)
             return { error: "Issue already has an active run" };
+        if (issue.prState === "merged") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, factoryState: "done" });
+            return { issueKey, runType: "none" };
+        }
         // Infer run type from current state instead of always resetting to implementation
         let runType = "implementation";
         let factoryState = "delegated";

package/dist/webhook-handler.js

@@ -167,7 +167,18 @@ export class WebhookHandler {
         if (delegated && triggerAllowed && unresolvedBlockers === 0 && !activeRun && !existingIssue?.pendingRunType && !terminalForAutomation) {
             pendingRunType = "implementation";
         }
-        const clearPendingImplementation = unresolvedBlockers > 0 && existingIssue?.pendingRunType === "implementation" && !activeRun;
+        let clearPendingImplementation = unresolvedBlockers > 0 && existingIssue?.pendingRunType === "implementation" && !activeRun;
+        // Release active run when issue reaches a terminal state or is un-delegated.
+        let clearActiveRun = false;
+        if (activeRun && existingIssue) {
+            if (terminalForAutomation) {
+                clearActiveRun = true;
+            }
+            if (normalized.triggerEvent === "delegateChanged" && !delegated) {
+                clearActiveRun = true;
+                clearPendingImplementation = Boolean(existingIssue.pendingRunType);
+            }
+        }
         // Resolve agent session
         const agentSessionId = normalized.agentSession?.id ??
             (!activeRun && (pendingRunType || (normalized.triggerEvent === "delegateChanged" && !delegated)) ? null : undefined);
@@ -189,7 +200,12 @@ export class WebhookHandler {
                 ? { pendingRunContextJson }
                 : {}),
             ...(agentSessionId !== undefined ? { agentSessionId } : {}),
+            ...(clearActiveRun ? { activeRunId: null } : {}),
         });
+        if (clearActiveRun && activeRun) {
+            const reason = terminalForAutomation ? "Issue reached terminal state during active run" : "Un-delegated from PatchRelay";
+            this.db.finishRun(activeRun.id, { status: "released", failureReason: reason });
+        }
         return {
             issue: this.db.issueToTrackedIssue(issue),
             desiredStage: pendingRunType,

package/package.json

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