patchrelay 0.12.5 → 0.12.7

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.12.5",
-  "commit": "7de41a6b5840",
-  "builtAt": "2026-03-24T20:31:57.125Z"
+  "version": "0.12.7",
+  "commit": "b46978c9149d",
+  "builtAt": "2026-03-24T22:34:10.024Z"
 }

package/dist/db.js

@@ -217,6 +217,16 @@ export class PatchRelayDatabase {
             linearIssueId: String(row.linear_issue_id),
         }));
     }
+    /**
+     * Issues idle in pr_open with no active run — candidates for state
+     * advancement based on stored PR metadata (missed GitHub webhooks).
+     */
+    listIdlePrOpenIssues() {
+        const rows = this.connection
+            .prepare("SELECT * FROM issues WHERE factory_state = 'pr_open' AND active_run_id IS NULL AND pending_run_type IS NULL AND pr_number IS NOT NULL")
+            .all();
+        return rows.map(mapIssueRow);
+    }
     listIssuesByState(projectId, state) {
         const rows = this.connection
             .prepare("SELECT * FROM issues WHERE project_id = ? AND factory_state = ? ORDER BY pr_number ASC")

package/dist/github-webhook-handler.js

@@ -226,32 +226,32 @@ export class GitHubWebhookHandler {
     async emitLinearActivity(issue, newState, event) {
         if (!issue.agentSessionId)
             return;
-        const linear = await this.linearProvider.forProject(issue.projectId);
-        if (!linear?.createAgentActivity)
-            return;
-        const messages = {
-            pr_open: `PR #${event.prNumber ?? ""} opened.${event.prUrl ? ` ${event.prUrl}` : ""}`,
-            awaiting_queue: "PR approved. Preparing merge.",
-            changes_requested: `Review requested changes.${event.reviewerName ? ` Reviewer: ${event.reviewerName}` : ""}`,
-            repairing_ci: `CI check failed${event.checkName ? `: ${event.checkName}` : ""}. Starting repair.`,
-            repairing_queue: "Merge conflict with base branch. Starting repair.",
-            done: `PR merged and deployed.${event.prNumber ? ` PR #${event.prNumber}` : ""}`,
-            failed: "PR was closed without merging.",
-        };
-        const body = messages[newState];
-        if (!body)
-            return;
-        const type = newState === "failed" || newState === "repairing_ci" || newState === "repairing_queue"
-            ? "error"
-            : "response";
         try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear?.createAgentActivity)
+                return;
+            const messages = {
+                pr_open: `PR #${event.prNumber ?? ""} opened.${event.prUrl ? ` ${event.prUrl}` : ""}`,
+                awaiting_queue: "PR approved. Preparing merge.",
+                changes_requested: `Review requested changes.${event.reviewerName ? ` Reviewer: ${event.reviewerName}` : ""}`,
+                repairing_ci: `CI check failed${event.checkName ? `: ${event.checkName}` : ""}. Starting repair.`,
+                repairing_queue: "Merge conflict with base branch. Starting repair.",
+                done: `PR merged and deployed.${event.prNumber ? ` PR #${event.prNumber}` : ""}`,
+                failed: "PR was closed without merging.",
+            };
+            const body = messages[newState];
+            if (!body)
+                return;
+            const type = newState === "failed" || newState === "repairing_ci" || newState === "repairing_queue"
+                ? "error"
+                : "response";
             await linear.createAgentActivity({
                 agentSessionId: issue.agentSessionId,
                 content: { type, body },
             });
         }
         catch {
-            // Non-blocking — don't fail the webhook for a Linear activity error
+            // Non-blocking — don't crash the webhook handler for a Linear activity error
         }
     }
 }

package/dist/run-orchestrator.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { ACTIVE_RUN_STATES } from "./factory-state.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildRunningSessionPlan, buildCompletedSessionPlan, buildFailedSessionPlan, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
@@ -275,6 +276,22 @@ export class RunOrchestrator {
         // Complete the run
         const trackedIssue = this.db.issueToTrackedIssue(issue);
         const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
+        // Determine post-run state. When a re-run finds the PR already exists
+        // and makes no changes, no pr_opened webhook arrives — the state would
+        // stay in the active-run state forever. Advance based on PR metadata.
+        const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        let postRunState;
+        if (ACTIVE_RUN_STATES.has(freshIssue.factoryState) && freshIssue.prNumber) {
+            if (freshIssue.prReviewState === "approved") {
+                postRunState = "awaiting_queue";
+            }
+            else if (freshIssue.prState === "merged") {
+                postRunState = "done";
+            }
+            else {
+                postRunState = "pr_open";
+            }
+        }
         this.db.transaction(() => {
             this.db.finishRun(run.id, {
                 status: "completed",
@@ -287,8 +304,14 @@ export class RunOrchestrator {
                 projectId: run.projectId,
                 linearIssueId: run.linearIssueId,
                 activeRunId: null,
+                ...(postRunState ? { factoryState: postRunState } : {}),
+                ...(postRunState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
             });
         });
+        // If we advanced to awaiting_queue, enqueue for merge prep
+        if (postRunState === "awaiting_queue") {
+            this.enqueueIssue(run.projectId, run.linearIssueId);
+        }
         this.feed?.publish({
             level: "info",
             kind: "turn",
@@ -326,6 +349,57 @@ export class RunOrchestrator {
         for (const run of this.db.listRunningRuns()) {
             await this.reconcileRun(run);
         }
+        // Advance issues stuck in pr_open whose stored PR metadata already
+        // shows they should transition (e.g. approved PR, missed webhook).
+        await this.reconcileIdlePrOpenIssues();
+    }
+    async reconcileIdlePrOpenIssues() {
+        for (const issue of this.db.listIdlePrOpenIssues()) {
+            if (issue.prState === "merged") {
+                this.advanceIdleIssue(issue, "done");
+                continue;
+            }
+            if (issue.prReviewState === "approved") {
+                this.advanceIdleIssue(issue, "awaiting_queue");
+                continue;
+            }
+            // Stored metadata may be stale (missed webhooks during downtime).
+            // Query GitHub for the actual PR review state.
+            const project = this.config.projects.find((p) => p.id === issue.projectId);
+            if (!project?.github?.repoFullName || !issue.prNumber)
+                continue;
+            try {
+                const { stdout } = await execCommand("gh", [
+                    "pr", "view", String(issue.prNumber),
+                    "--repo", project.github.repoFullName,
+                    "--json", "state,reviewDecision",
+                ], { timeoutMs: 10_000 });
+                const pr = JSON.parse(stdout);
+                if (pr.state === "MERGED") {
+                    this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+                    this.advanceIdleIssue(issue, "done");
+                }
+                else if (pr.reviewDecision === "APPROVED") {
+                    this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
+                    this.advanceIdleIssue(issue, "awaiting_queue");
+                }
+            }
+            catch (error) {
+                this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+            }
+        }
+    }
+    advanceIdleIssue(issue, newState) {
+        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState }, "Reconciliation: advancing idle issue from stored PR metadata");
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: newState,
+            ...(newState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
+        });
+        if (newState === "awaiting_queue") {
+            this.enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
     }
     async reconcileRun(run) {
         const issue = this.db.getIssue(run.projectId, run.linearIssueId);

package/dist/service-runtime.js

@@ -14,6 +14,7 @@ export class ServiceRuntime {
     webhookQueue;
     issueQueue;
     ready = false;
+    linearConnected = false;
     startupError;
     reconcileTimer;
     reconcileInProgress = false;
@@ -54,10 +55,14 @@ export class ServiceRuntime {
     enqueueIssue(projectId, issueId) {
         this.issueQueue.enqueue({ projectId, issueId });
     }
+    setLinearConnected(connected) {
+        this.linearConnected = connected;
+    }
     getReadiness() {
         return {
-            ready: this.ready && this.codex.isStarted(),
+            ready: this.ready && this.codex.isStarted() && this.linearConnected,
             codexStarted: this.codex.isStarted(),
+            linearConnected: this.linearConnected,
             ...(this.startupError ? { startupError: this.startupError } : {}),
         };
     }
@@ -85,6 +90,11 @@ export class ServiceRuntime {
         this.reconcileInProgress = true;
         try {
             await promiseWithTimeout(this.runReconciler.reconcileActiveRuns(), this.options.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS, "Background active-run reconciliation");
+            // Pick up issues that became ready outside the webhook path
+            // (e.g. CLI retry, manual DB edits) without requiring a restart.
+            for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
         }
         catch (error) {
             this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "Background active-run reconciliation failed");

package/dist/service.js

@@ -73,24 +73,37 @@ export class PatchRelayService {
             this.githubAppTokenManager = createGitHubAppTokenManager(ghAppCredentials, logger);
         }
         this.codex.on("notification", (notification) => {
-            void this.orchestrator.handleCodexNotification(notification);
+            this.orchestrator.handleCodexNotification(notification).catch((error) => {
+                const msg = error instanceof Error ? error.message : String(error);
+                logger.error({ method: notification.method, error: msg }, "Unhandled error in Codex notification handler");
+            });
         });
     }
     async start() {
         // Verify Linear connectivity for all configured projects before starting.
-        // Fail fast on auth errors rather than crashing mid-run.
+        // Auth errors do not prevent startup (the OAuth callback must be reachable
+        // for `patchrelay connect`), but the service reports NOT READY until at
+        // least one project has a working Linear token.
+        let anyLinearConnected = false;
         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");
+                if (client) {
+                    anyLinearConnected = true;
+                }
+                else {
+                    this.logger.warn({ projectId: project.id }, "No Linear installation linked — run 'patchrelay connect' to authorize");
                 }
             }
             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 });
+                this.logger.error({ projectId: project.id, error: msg }, "Linear auth failed — run 'patchrelay connect' to refresh the token. Runs for this project will fail until re-authorized.");
             }
         }
+        this.runtime.setLinearConnected(anyLinearConnected);
+        if (!anyLinearConnected && this.config.projects.length > 0) {
+            this.logger.error("No projects have working Linear auth — service is NOT READY. Run 'patchrelay connect' to authorize.");
+        }
         if (this.githubAppTokenManager) {
             await ensureGhWrapper(this.logger);
             await this.githubAppTokenManager.start();
@@ -110,7 +123,11 @@ export class PatchRelayService {
         return await this.oauthService.createStart(params);
     }
     async completeLinearOAuth(params) {
-        return await this.oauthService.complete(params);
+        const result = await this.oauthService.complete(params);
+        // A successful OAuth completion means at least one project now has
+        // working Linear auth — update readiness.
+        this.runtime.setLinearConnected(true);
+        return result;
     }
     getLinearOAuthStateStatus(state) {
         return this.oauthService.getStateStatus(state);

package/package.json

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