patchrelay 0.35.3 → 0.35.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.3",
-  "commit": "6107a755ba05",
-  "builtAt": "2026-04-03T02:41:14.980Z"
+  "version": "0.35.5",
+  "commit": "9abdef5af6a1",
+  "builtAt": "2026-04-03T11:16:59.270Z"
 }

package/dist/db/migrations.js

@@ -218,6 +218,8 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "last_queue_incident_json", "TEXT");
     addColumnIfMissing(connection, "issues", "last_attempted_failure_head_sha", "TEXT");
     addColumnIfMissing(connection, "issues", "last_attempted_failure_signature", "TEXT");
+    // Track whether the merge queue label was successfully applied.
+    addColumnIfMissing(connection, "issues", "queue_label_applied", "INTEGER NOT NULL DEFAULT 0");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/db.js

@@ -245,6 +245,10 @@ export class PatchRelayDatabase {
                 sets.push("last_zombie_recovery_at = @lastZombieRecoveryAt");
                 values.lastZombieRecoveryAt = params.lastZombieRecoveryAt;
             }
+            if (params.queueLabelApplied !== undefined) {
+                sets.push("queue_label_applied = @queueLabelApplied");
+                values.queueLabelApplied = params.queueLabelApplied ? 1 : 0;
+            }
             this.connection.prepare(`UPDATE issues SET ${sets.join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`).run(values);
         }
         else {
@@ -743,6 +747,7 @@ function mapIssueRow(row) {
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
         zombieRecoveryAttempts: Number(row.zombie_recovery_attempts ?? 0),
         ...(row.last_zombie_recovery_at !== null && row.last_zombie_recovery_at !== undefined ? { lastZombieRecoveryAt: String(row.last_zombie_recovery_at) } : {}),
+        queueLabelApplied: Boolean(row.queue_label_applied),
     };
 }
 function mapRunRow(row) {

package/dist/merge-queue-protocol.js

@@ -12,7 +12,7 @@ export function resolveMergeQueueProtocol(project) {
 export async function requestMergeQueueAdmission(params) {
     const { issue, protocol, logger, feed } = params;
     if (!protocol.repoFullName || !issue.prNumber)
-        return;
+        return false;
     feed?.publish({
         level: "info",
         kind: "github",
@@ -42,6 +42,7 @@ export async function requestMergeQueueAdmission(params) {
             status: "queue_label_applied",
             summary: `Queue label "${protocol.admissionLabel}" applied to PR #${issue.prNumber}`,
         });
+        return true;
     }
     catch (error) {
         logger.warn({ issueKey: issue.issueKey, err: error }, "Failed to add merge queue label");
@@ -55,5 +56,6 @@ export async function requestMergeQueueAdmission(params) {
             summary: `Queue hand-off failed while adding label "${protocol.admissionLabel}" to PR #${issue.prNumber}`,
             detail: error instanceof Error ? error.message : String(error),
         });
+        return false;
     }
 }

package/dist/run-orchestrator.js

@@ -703,6 +703,10 @@ export class RunOrchestrator {
                 if (issue.factoryState !== "awaiting_queue" || issue.branchOwner !== "merge_steward") {
                     this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
                 }
+                else if (!issue.queueLabelApplied) {
+                    // Retry failed label application
+                    await this.requestMergeQueueAdmission(issue, issue.projectId);
+                }
                 continue;
             }
             // Checks failed + idle — route based on durable GitHub failure provenance.
@@ -734,15 +738,29 @@ export class RunOrchestrator {
                     continue;
                 }
                 if (issue.factoryState === "awaiting_queue") {
-                    this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation skipped failed awaiting_queue issue with unknown failure provenance");
-                    this.feed?.publish({
-                        level: "warn",
-                        kind: "github",
-                        issueKey: issue.issueKey,
-                        projectId: issue.projectId,
-                        stage: issue.factoryState,
-                        status: "failure_source_unknown",
-                        summary: "Reconciliation saw failed checks but could not determine whether the failure came from CI or the merge queue",
+                    // Infer provenance: check if steward eviction check run exists on the PR
+                    const inferProject = this.config.projects.find((p) => p.id === issue.projectId);
+                    const inferProtocol = resolveMergeQueueProtocol(inferProject);
+                    let inferred = "branch_ci";
+                    if (inferProject?.github?.repoFullName && issue.prNumber && issue.lastGitHubFailureHeadSha) {
+                        try {
+                            const { stdout } = await execCommand("gh", [
+                                "api",
+                                `repos/${inferProject.github.repoFullName}/commits/${issue.lastGitHubFailureHeadSha}/check-runs`,
+                                "--jq", `.check_runs[] | select(.name == "${inferProtocol.evictionCheckName}" and .conclusion == "failure") | .name`,
+                            ], { timeoutMs: 10_000 });
+                            if (stdout.trim().length > 0)
+                                inferred = "queue_eviction";
+                        }
+                        catch { /* best effort */ }
+                    }
+                    const inferRunType = inferred === "queue_eviction" ? "queue_repair" : "ci_repair";
+                    const inferState = inferred === "queue_eviction" ? "repairing_queue" : "repairing_ci";
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, inferred }, "Inferred failure provenance for awaiting_queue issue");
+                    const pendingRunContext = buildFailureContext(issue);
+                    this.advanceIdleIssue(issue, inferState, {
+                        pendingRunType: inferRunType,
+                        ...(pendingRunContext ? { pendingRunContext } : {}),
                     });
                     continue;
                 }
@@ -1117,15 +1135,18 @@ export class RunOrchestrator {
         void this.syncLinearSession(escalatedIssue);
     }
     /** Add the merge queue admission label for external-queue projects (best-effort). */
-    requestMergeQueueAdmission(issue, projectId) {
+    async requestMergeQueueAdmission(issue, projectId) {
         const project = this.config.projects.find((p) => p.id === projectId);
         const protocol = resolveMergeQueueProtocol(project);
-        void requestMergeQueueAdmission({
+        const applied = await requestMergeQueueAdmission({
             issue,
             protocol,
             logger: this.logger,
             feed: this.feed,
         });
+        if (applied) {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, queueLabelApplied: true });
+        }
     }
     failRunAndClear(run, message, nextState = "failed") {
         this.db.transaction(() => {

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
@@ -179,6 +213,17 @@ export class WebhookHandler {
                 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);
@@ -201,11 +246,23 @@ export class WebhookHandler {
                 : {}),
             ...(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.3",
+  "version": "0.35.5",
   "license": "MIT",
   "type": "module",
   "repository": {