patchrelay 0.59.1 → 0.60.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.59.1",
-  "commit": "1e520e0829e3",
-  "builtAt": "2026-05-02T23:50:20.540Z"
+  "version": "0.60.0",
+  "commit": "116496455e0c",
+  "builtAt": "2026-05-04T22:16:11.428Z"
 }

package/dist/cli/cluster-health.js

@@ -336,6 +336,10 @@ async function evaluateGitHubIssueHealth(snapshot, config, runCommand, reviewQui
     if (issue.delegatedToPatchRelay
         && gateCheckStatus === "failure"
         && issue.factoryState !== "repairing_ci"
+        // Plan §6.1 / §4.3: branch CI failures while In Deploy are
+        // metadata only — the lander's spec CI is the gate. Don't flag
+        // these as a missing-ci-repair condition.
+        && issue.factoryState !== "awaiting_queue"
         && issue.activeRunId === undefined
         && ageMs >= RECONCILIATION_GRACE_MS) {
         return {

package/dist/factory-state.js

@@ -58,9 +58,29 @@ const TRANSITION_RULES = [
     { event: "check_passed",
         guard: (s) => s === "repairing_ci",
         to: (_, ctx) => ctx.prReviewState === "approved" ? "awaiting_queue" : "pr_open" },
-    // CI failure when no run is active triggers repair.
+    // CI failure when no run is active. Plan §4.3: classification by
+    // failureSource determines whether we route to queue or branch repair.
+    // While In Deploy (`awaiting_queue`), branch CI failures are metadata
+    // only — the lander handles the spec; we don't initiate a ci_repair.
     { event: "check_failed",
-        guard: (s, ctx) => isOpen(s) && ctx.activeRunId === undefined,
+        guard: (s, ctx) => isOpen(s)
+            && ctx.activeRunId === undefined
+            && ctx.failureSource === "queue_eviction",
+        to: "repairing_queue" },
+    { event: "check_failed",
+        guard: (s, ctx) => isOpen(s)
+            && ctx.activeRunId === undefined
+            && ctx.failureSource === "branch_ci"
+            && s !== "awaiting_queue",
+        to: "repairing_ci" },
+    // Backward-compat fallback for callers that haven't classified the
+    // failure (older code paths or test fixtures). Behaves like today's
+    // single rule but still skips while In Deploy.
+    { event: "check_failed",
+        guard: (s, ctx) => isOpen(s)
+            && ctx.activeRunId === undefined
+            && ctx.failureSource === undefined
+            && s !== "awaiting_queue",
         to: "repairing_ci" },
     // pr_synchronize: no rule → no transition (resets counters only)
     // merge_group events: not used — merge queue is handled by external steward

package/dist/github-webhook-policy.js

@@ -1,6 +1,5 @@
 import { resolveFactoryStateFromGitHub } from "./factory-state.js";
 import { resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
-import { isIssueTerminal } from "./pr-state.js";
 const DEFAULT_GATE_CHECK_NAMES = ["verify", "tests"];
 /**
  * GitHub sends both check_run and check_suite completion events.
@@ -84,16 +83,16 @@ export function resolveGitHubFactoryStateForEvent(issue, event, project) {
         && (event.prState === "open" || event.prNumber !== undefined)
         ? "pr_open"
         : issue.factoryState;
-    if (event.triggerEvent === "check_failed"
-        && isQueueEvictionFailure(issue, event, project)
-        && issue.prState === "open"
-        && issue.activeRunId === undefined
-        && !isIssueTerminal(issue)) {
-        return "repairing_queue";
-    }
+    // Classify check_failed events so the rule table can route them.
+    // The duplicate short-circuit that lived here before is gone — the
+    // table now handles queue_eviction via failureSource (plan §4.3).
+    const failureSource = event.triggerEvent === "check_failed"
+        ? (isQueueEvictionFailure(issue, event, project) ? "queue_eviction" : "branch_ci")
+        : undefined;
     const resolved = resolveFactoryStateFromGitHub(event.triggerEvent, effectiveCurrentState, {
         prReviewState: issue.prReviewState,
         activeRunId: issue.activeRunId,
+        failureSource,
     });
     if (resolved !== undefined) {
         return resolved;

package/dist/github-webhook-reactive-run.js

@@ -49,6 +49,22 @@ export async function maybeEnqueueGitHubReactiveRun(params) {
 }
 async function handleCheckFailedEvent(params) {
     const { db, logger, feed, enqueueIssue, issue, event, project, failureContextResolver } = params;
+    // Plan §4.3: while In Deploy (`awaiting_queue`), branch CI is metadata
+    // only — the lander owns admission, and its spec CI on the integration
+    // tree is the gate. Queue eviction failures still flow through (they're
+    // how the lander signals a real integration regression).
+    if (issue.factoryState === "awaiting_queue" && !isQueueEvictionFailure(issue, event, project)) {
+        feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "branch_ci_metadata_in_deploy",
+            summary: `Ignored ${event.checkName ?? "branch CI"} failure while In Deploy; lander owns admission`,
+        });
+        return;
+    }
     if (isQueueEvictionFailure(issue, event, project)) {
         const queueRepairContext = buildQueueRepairContextFromEvent(event);
         const failureContext = buildGitHubQueueFailureContext(event, project, queueRepairContext);

package/package.json

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