patchrelay 0.12.4 → 0.12.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.12.4",
-  "commit": "dea4ce43848b",
-  "builtAt": "2026-03-24T18:27:01.637Z"
+  "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/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.4",
+  "version": "0.12.5",
   "license": "MIT",
   "type": "module",
   "repository": {