patchrelay 0.12.2 → 0.12.4

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.12.2",
-  "commit": "a39d9226ae29",
-  "builtAt": "2026-03-24T13:32:47.905Z"
+  "version": "0.12.4",
+  "commit": "dea4ce43848b",
+  "builtAt": "2026-03-24T18:27:01.637Z"
 }

package/dist/factory-state.js

@@ -10,52 +10,98 @@ export const TERMINAL_STATES = new Set([
     "done",
     "escalated",
 ]);
-export const ALLOWED_TRANSITIONS = {
-    delegated: ["preparing", "failed"],
-    preparing: ["implementing", "failed"],
-    implementing: ["pr_open", "awaiting_input", "failed", "escalated"],
-    pr_open: ["awaiting_review", "awaiting_queue", "changes_requested", "repairing_ci", "failed"],
-    awaiting_review: ["changes_requested", "awaiting_queue", "repairing_ci"],
-    changes_requested: ["implementing", "awaiting_input", "escalated"],
-    repairing_ci: ["pr_open", "awaiting_review", "escalated", "failed"],
-    awaiting_queue: ["done", "repairing_queue", "repairing_ci", "changes_requested"],
-    repairing_queue: ["pr_open", "awaiting_review", "awaiting_queue", "escalated", "failed"],
-    awaiting_input: ["implementing", "delegated", "escalated"],
-    escalated: [],
-    done: [],
-    failed: ["delegated"],
-};
-export function resolveFactoryStateFromGitHub(triggerEvent, current) {
-    switch (triggerEvent) {
-        case "pr_opened":
-            return current === "implementing" ? "pr_open" : undefined;
-        case "pr_synchronize":
-            return undefined; // just resets repair counters, no state change
-        case "review_approved":
-            return current === "awaiting_review" || current === "pr_open" ? "awaiting_queue" : undefined;
-        case "review_changes_requested":
-            return current === "awaiting_review" || current === "pr_open" || current === "awaiting_queue"
-                ? "changes_requested"
-                : undefined;
-        case "review_commented":
-            return undefined; // informational only
-        case "check_passed":
-            if (current === "repairing_queue")
-                return "awaiting_queue";
-            return current === "repairing_ci" ? "pr_open" : undefined;
-        case "check_failed":
-            return current === "pr_open" || current === "awaiting_review" || current === "awaiting_queue"
-                ? "repairing_ci"
-                : undefined;
-        case "pr_merged":
-            return "done";
-        case "pr_closed":
-            return "failed";
-        case "merge_group_passed":
-            return undefined; // merge event will follow
-        case "merge_group_failed":
-            return current === "awaiting_queue" ? "repairing_queue" : undefined;
-        default:
-            return undefined;
+// ─── Semantic guards ─────────────────────────────────────────────
+//
+// Guards express INTENT rather than enumerating states. Adding a new
+// state automatically participates in transitions whose guard it
+// satisfies — no per-event maintenance required.
+const isOpen = (s) => !TERMINAL_STATES.has(s);
+const TRANSITION_RULES = [
+    // ── Terminal events ────────────────────────────────────────────
+    // pr_merged is unconditional — PR is merged, we're done.
+    { event: "pr_merged",
+        to: "done" },
+    // pr_closed during an active run is suppressed — Codex may reopen.
+    // Without a guard match, the event produces no transition (undefined).
+    { event: "pr_closed",
+        guard: (_, ctx) => ctx.activeRunId === undefined,
+        to: "failed" },
+    // ── PR lifecycle ───────────────────────────────────────────────
+    { event: "pr_opened",
+        guard: (s) => s === "implementing",
+        to: "pr_open" },
+    // ── Review events — apply when no Codex run is actively executing ──
+    // Uses activeRunId (runtime state) rather than the state name, because
+    // states like changes_requested are "run states" only while the run is
+    // active — once the run completes, reviews should be accepted.
+    { event: "review_approved",
+        guard: (s, ctx) => isOpen(s) && ctx.activeRunId === undefined,
+        to: "awaiting_queue" },
+    { event: "review_changes_requested",
+        guard: (s, ctx) => isOpen(s) && ctx.activeRunId === undefined,
+        to: "changes_requested" },
+    // review_commented: no rule → no transition (informational only)
+    // ── CI check events ────────────────────────────────────────────
+    // After queue repair, return to the merge queue.
+    { event: "check_passed",
+        guard: (s) => s === "repairing_queue",
+        to: "awaiting_queue" },
+    // After CI repair, return to merge queue if already approved,
+    // otherwise to pr_open for review.
+    { 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.
+    { event: "check_failed",
+        guard: (s, ctx) => isOpen(s) && ctx.activeRunId === undefined,
+        to: "repairing_ci" },
+    // ── Merge queue events ─────────────────────────────────────────
+    { event: "merge_group_failed",
+        guard: (s) => s === "awaiting_queue",
+        to: "repairing_queue" },
+    // merge_group_passed: no rule → no transition (merge event follows)
+    // pr_synchronize: no rule → no transition (resets counters only)
+];
+/**
+ * Resolve the next factory state from a GitHub webhook event.
+ *
+ * Returns `undefined` when no rule matches — the event is a no-op
+ * for the current state (e.g. check_passed while implementing).
+ */
+export function resolveFactoryStateFromGitHub(triggerEvent, current, ctx = {}) {
+    for (const rule of TRANSITION_RULES) {
+        if (rule.event !== triggerEvent)
+            continue;
+        if (rule.guard && !rule.guard(current, ctx))
+            continue;
+        return typeof rule.to === "function" ? rule.to(current, ctx) : rule.to;
     }
+    return undefined;
+}
+/**
+ * Derive the allowed transitions table from the rules for documentation
+ * and test validation. Not used at runtime.
+ */
+export function deriveAllowedTransitions(states, events) {
+    const result = {};
+    for (const state of states) {
+        result[state] = new Set();
+    }
+    // Sample with common review states to catch dynamic targets
+    const contexts = [
+        {},
+        { prReviewState: "approved" },
+        { prReviewState: "changes_requested" },
+    ];
+    for (const state of states) {
+        for (const event of events) {
+            for (const ctx of contexts) {
+                const target = resolveFactoryStateFromGitHub(event, state, ctx);
+                if (target !== undefined && target !== state) {
+                    result[state].add(target);
+                }
+            }
+        }
+    }
+    return result;
 }

package/dist/github-webhook-handler.js

@@ -15,25 +15,6 @@ function isMetadataOnlyCheckEvent(event) {
     return event.eventSource === "check_run"
         && (event.triggerEvent === "check_passed" || event.triggerEvent === "check_failed");
 }
-/**
- * Codex sometimes closes and immediately reopens a PR (e.g. to change the
- * base branch or fix the title). A pr_closed event during an active run
- * should not transition to "failed" — the reopened event will follow.
- * Without this guard, the state gets stuck at "failed" because
- * failed → pr_open is not an allowed transition.
- */
-function shouldSuppressCloseTransition(newState, event, issue) {
-    return newState === "failed" && event.triggerEvent === "pr_closed" && issue.activeRunId !== undefined;
-}
-/**
- * After a CI repair succeeds and CI passes, the resolver returns pr_open.
- * If the PR is already approved, fast-track to awaiting_queue so the merge
- * queue picks it up again. This avoids a dead state where the PR is approved
- * and CI-green but nobody advances the merge queue.
- */
-function shouldFastTrackToQueue(newState, issue) {
-    return newState === "pr_open" && issue.prReviewState === "approved";
-}
 export class GitHubWebhookHandler {
     config;
     db;
@@ -141,15 +122,12 @@ export class GitHubWebhookHandler {
             ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
         });
         if (!isMetadataOnlyCheckEvent(event)) {
-            // Re-read issue after PR metadata upsert so fast-track sees fresh prReviewState
+            // Re-read issue after PR metadata upsert so guards see fresh prReviewState
             const afterMetadata = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-            let newState = resolveFactoryStateFromGitHub(event.triggerEvent, afterMetadata.factoryState);
-            if (shouldSuppressCloseTransition(newState, event, afterMetadata)) {
-                newState = undefined;
-            }
-            if (shouldFastTrackToQueue(newState, afterMetadata)) {
-                newState = "awaiting_queue";
-            }
+            const newState = resolveFactoryStateFromGitHub(event.triggerEvent, afterMetadata.factoryState, {
+                prReviewState: afterMetadata.prReviewState,
+                activeRunId: afterMetadata.activeRunId,
+            });
             // Only transition and notify when the state actually changes.
             // Multiple check_suite events can arrive for the same outcome.
             if (newState && newState !== afterMetadata.factoryState) {

package/package.json

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