patchrelay 0.12.3 → 0.12.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.12.3",
-  "commit": "456e68578cd0",
-  "builtAt": "2026-03-24T17:07:10.750Z"
+  "version": "0.12.5",
+  "commit": "7de41a6b5840",
+  "builtAt": "2026-03-24T20:31:57.125Z"
 }

package/dist/db.js

@@ -260,7 +260,7 @@ export class PatchRelayDatabase {
     }
     listRunningRuns() {
         const rows = this.connection
-            .prepare("SELECT * FROM runs WHERE status = 'running'")
+            .prepare("SELECT * FROM runs WHERE status IN ('running', 'queued')")
             .all();
         return rows.map(mapRunRow);
     }

package/dist/factory-state.js

@@ -10,54 +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_queue", "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" || current === "changes_requested"
-                ? "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/dist/run-orchestrator.js

@@ -328,24 +328,49 @@ export class RunOrchestrator {
         }
     }
     async reconcileRun(run) {
-        if (!run.threadId) {
-            this.failRunAndClear(run, "Run has no thread ID during reconciliation");
-            return;
-        }
         const issue = this.db.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
             return;
-        // Read Codex state
+        // Zombie run: claimed in DB but Codex never started (no thread).
+        // This happens when the service crashes between claiming the run
+        // and starting the Codex turn. Re-enqueue instead of failing.
+        if (!run.threadId) {
+            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread) — clearing and re-enqueueing");
+            this.db.transaction(() => {
+                this.db.finishRun(run.id, { status: "failed", failureReason: "Zombie: never started (no thread after restart)" });
+                this.db.upsertIssue({
+                    projectId: run.projectId,
+                    linearIssueId: run.linearIssueId,
+                    activeRunId: null,
+                    pendingRunType: run.runType,
+                    pendingRunContextJson: null,
+                });
+            });
+            this.enqueueIssue(run.projectId, run.linearIssueId);
+            return;
+        }
+        // Read Codex state — thread may not exist after app-server restart.
         let thread;
         try {
             thread = await this.readThreadWithRetry(run.threadId);
         }
         catch {
-            this.failRunAndClear(run, "Codex thread not found during reconciliation");
+            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation — clearing and re-enqueueing");
+            this.db.transaction(() => {
+                this.db.finishRun(run.id, { status: "failed", failureReason: "Stale thread after restart" });
+                this.db.upsertIssue({
+                    projectId: run.projectId,
+                    linearIssueId: run.linearIssueId,
+                    activeRunId: null,
+                    pendingRunType: run.runType,
+                    pendingRunContextJson: null,
+                });
+            });
+            this.enqueueIssue(run.projectId, run.linearIssueId);
             return;
         }
-        // Check Linear state
-        const linear = await this.linearProvider.forProject(run.projectId);
+        // Check Linear state (non-fatal — token refresh may fail)
+        const linear = await this.linearProvider.forProject(run.projectId).catch(() => undefined);
         if (linear) {
             const linearIssue = await linear.getIssue(run.linearIssueId).catch(() => undefined);
             if (linearIssue) {
@@ -429,10 +454,10 @@ export class RunOrchestrator {
     async emitLinearActivity(issue, type, body, options) {
         if (!issue.agentSessionId)
             return;
-        const linear = await this.linearProvider.forProject(issue.projectId);
-        if (!linear)
-            return;
         try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear)
+                return;
             await linear.createAgentActivity({
                 agentSessionId: issue.agentSessionId,
                 content: { type, body },
@@ -446,10 +471,10 @@ export class RunOrchestrator {
     async updateLinearPlan(issue, plan) {
         if (!issue.agentSessionId)
             return;
-        const linear = await this.linearProvider.forProject(issue.projectId);
-        if (!linear?.updateAgentSession)
-            return;
         try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear?.updateAgentSession)
+                return;
             await linear.updateAgentSession({ agentSessionId: issue.agentSessionId, plan });
         }
         catch (error) {

package/dist/service.js

@@ -77,6 +77,20 @@ export class PatchRelayService {
         });
     }
     async start() {
+        // Verify Linear connectivity for all configured projects before starting.
+        // Fail fast on auth errors rather than crashing mid-run.
+        for (const project of this.config.projects) {
+            try {
+                const client = await this.linearProvider.forProject(project.id);
+                if (!client) {
+                    this.logger.warn({ projectId: project.id }, "No Linear installation linked — project will not receive agent session events");
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                throw new Error(`Linear auth failed for project ${project.id}: ${msg}. Re-run "patchrelay connect" to refresh the token.`, { cause: error });
+            }
+        }
         if (this.githubAppTokenManager) {
             await ensureGhWrapper(this.logger);
             await this.githubAppTokenManager.start();

package/package.json

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