patchrelay 0.35.4 → 0.35.6

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.4",
-  "commit": "327273902c17",
-  "builtAt": "2026-04-03T08:18:26.141Z"
+  "version": "0.35.6",
+  "commit": "724dfad4eb3b",
+  "builtAt": "2026-04-03T11:34:35.008Z"
 }

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,30 @@ 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";
+                    const probeSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha;
+                    if (inferProject?.github?.repoFullName && issue.prNumber && probeSha) {
+                        try {
+                            const { stdout } = await execCommand("gh", [
+                                "api",
+                                `repos/${inferProject.github.repoFullName}/commits/${probeSha}/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;
                 }
@@ -805,6 +824,9 @@ export class RunOrchestrator {
             return;
         }
         this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
+        // Reset queueLabelApplied when entering or leaving awaiting_queue so
+        // the retry loop re-applies the label on each queue cycle.
+        const resetQueueLabel = newState === "awaiting_queue" || issue.factoryState === "awaiting_queue";
         this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
@@ -815,6 +837,7 @@ export class RunOrchestrator {
                     pendingRunContextJson: options.pendingRunContext ? JSON.stringify(options.pendingRunContext) : null,
                 }
                 : {}),
+            ...(resetQueueLabel ? { queueLabelApplied: false } : {}),
             ...(options?.clearFailureProvenance
                 ? {
                     lastGitHubFailureSource: null,
@@ -1117,15 +1140,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/package.json

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