patchrelay 0.35.2 → 0.35.4

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.2",
-  "commit": "19528baf10d3",
-  "builtAt": "2026-04-03T02:18:23.308Z"
+  "version": "0.35.4",
+  "commit": "327273902c17",
+  "builtAt": "2026-04-03T08:18:26.141Z"
 }

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

@@ -763,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/webhook-handler.js

@@ -98,6 +98,40 @@ export class WebhookHandler {
             const result = await this.recordDesiredStage(project, hydrated);
             const trackedIssue = result.issue;
             const newlyReadyDependents = this.reconcileDependentReadiness(project.id, issue.id);
+            // Handle issue removal: release active runs, mark as failed.
+            if (hydrated.triggerEvent === "issueRemoved" && trackedIssue) {
+                const removedIssue = this.db.getIssue(project.id, issue.id);
+                if (removedIssue?.activeRunId) {
+                    const run = this.db.getRun(removedIssue.activeRunId);
+                    if (run) {
+                        this.db.finishRun(run.id, { status: "released", failureReason: "Issue removed from Linear" });
+                    }
+                    this.db.upsertIssue({
+                        projectId: project.id,
+                        linearIssueId: issue.id,
+                        activeRunId: null,
+                        pendingRunType: null,
+                        factoryState: "failed",
+                    });
+                }
+                else if (removedIssue && !TERMINAL_STATES.has(removedIssue.factoryState)) {
+                    this.db.upsertIssue({
+                        projectId: project.id,
+                        linearIssueId: issue.id,
+                        pendingRunType: null,
+                        factoryState: "failed",
+                    });
+                }
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "stage",
+                    issueKey: issue.identifier,
+                    projectId: project.id,
+                    stage: "failed",
+                    status: "issue_removed",
+                    summary: "Issue removed from Linear",
+                });
+            }
             // Handle agent session events
             await this.handleAgentSession(hydrated, project, trackedIssue, result.desiredStage, result.delegated);
             // Handle comments during active run
@@ -167,7 +201,29 @@ 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);
+            }
+        }
+        // Un-delegation: transition to awaiting_input unless past point of no return.
+        // awaiting_queue means the PR is approved and in the merge queue — let it merge.
+        let undelegatedFactoryState;
+        if (normalized.triggerEvent === "delegateChanged" && !delegated && existingIssue) {
+            const pastNoReturn = existingIssue.factoryState === "awaiting_queue"
+                || TERMINAL_STATES.has(existingIssue.factoryState);
+            if (!pastNoReturn) {
+                undelegatedFactoryState = "awaiting_input";
+                clearPendingImplementation = Boolean(existingIssue.pendingRunType);
+            }
+        }
         // Resolve agent session
         const agentSessionId = normalized.agentSession?.id ??
             (!activeRun && (pendingRunType || (normalized.triggerEvent === "delegateChanged" && !delegated)) ? null : undefined);
@@ -189,7 +245,24 @@ export class WebhookHandler {
                 ? { pendingRunContextJson }
                 : {}),
             ...(agentSessionId !== undefined ? { agentSessionId } : {}),
+            ...(clearActiveRun ? { activeRunId: null } : {}),
+            ...(undelegatedFactoryState ? { factoryState: undelegatedFactoryState } : {}),
         });
+        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 });
+        }
+        if (undelegatedFactoryState) {
+            this.feed?.publish({
+                level: "warn",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: project.id,
+                stage: "awaiting_input",
+                status: "un_delegated",
+                summary: "Issue un-delegated from PatchRelay",
+            });
+        }
         return {
             issue: this.db.issueToTrackedIssue(issue),
             desiredStage: pendingRunType,

package/package.json

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