patchrelay 0.10.6 → 0.11.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.10.6",
-  "commit": "39ced0e75b38",
-  "builtAt": "2026-03-22T22:02:35.390Z"
+  "version": "0.11.0",
+  "commit": "d4b6131b08e4",
+  "builtAt": "2026-03-23T23:29:46.267Z"
 }

package/dist/config.js

@@ -32,6 +32,7 @@ const projectSchema = z.object({
     github: z.object({
         webhook_secret: z.string().min(1).optional(),
         repo_full_name: z.string().min(1).optional(),
+        base_branch: z.string().min(1).optional(),
     }).optional(),
 });
 const configSchema = z.object({
@@ -393,6 +394,7 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                     github: {
                         ...(project.github.webhook_secret ? { webhookSecret: project.github.webhook_secret } : {}),
                         ...(project.github.repo_full_name ? { repoFullName: project.github.repo_full_name } : {}),
+                        ...(project.github.base_branch ? { baseBranch: project.github.base_branch } : {}),
                     },
                 } : {}),
             };

package/dist/db/migrations.js

@@ -129,4 +129,12 @@ export function runPatchRelayMigrations(connection) {
     connection.exec(schema);
     // Clean up stale dedupe-only webhook records (no payload, never processable)
     connection.prepare("UPDATE webhook_events SET processing_status = 'processed' WHERE processing_status = 'pending' AND payload_json IS NULL").run();
+    // Add pending_merge_prep column for merge queue stewardship
+    addColumnIfMissing(connection, "issues", "pending_merge_prep", "INTEGER NOT NULL DEFAULT 0");
+}
+function addColumnIfMissing(connection, table, column, definition) {
+    const cols = connection.prepare(`PRAGMA table_info(${table})`).all();
+    if (cols.some((c) => c.name === column))
+        return;
+    connection.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
 }

package/dist/db.js

@@ -149,6 +149,10 @@ export class PatchRelayDatabase {
                 sets.push("queue_repair_attempts = @queueRepairAttempts");
                 values.queueRepairAttempts = params.queueRepairAttempts;
             }
+            if (params.pendingMergePrep !== undefined) {
+                sets.push("pending_merge_prep = @pendingMergePrep");
+                values.pendingMergePrep = params.pendingMergePrep ? 1 : 0;
+            }
             this.connection.prepare(`UPDATE issues SET ${sets.join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`).run(values);
         }
         else {
@@ -206,13 +210,19 @@ export class PatchRelayDatabase {
     }
     listIssuesReadyForExecution() {
         const rows = this.connection
-            .prepare("SELECT project_id, linear_issue_id FROM issues WHERE pending_run_type IS NOT NULL AND active_run_id IS NULL")
+            .prepare("SELECT project_id, linear_issue_id FROM issues WHERE (pending_run_type IS NOT NULL OR pending_merge_prep = 1) AND active_run_id IS NULL")
             .all();
         return rows.map((row) => ({
             projectId: String(row.project_id),
             linearIssueId: String(row.linear_issue_id),
         }));
     }
+    listIssuesByState(projectId, state) {
+        const rows = this.connection
+            .prepare("SELECT * FROM issues WHERE project_id = ? AND factory_state = ? ORDER BY pr_number ASC")
+            .all(projectId, state);
+        return rows.map(mapIssueRow);
+    }
     // ─── Runs ─────────────────────────────────────────────────────────
     createRun(params) {
         const now = isoNow();
@@ -365,6 +375,7 @@ function mapIssueRow(row) {
         ...(row.pr_check_status !== null && row.pr_check_status !== undefined ? { prCheckStatus: String(row.pr_check_status) } : {}),
         ciRepairAttempts: Number(row.ci_repair_attempts ?? 0),
         queueRepairAttempts: Number(row.queue_repair_attempts ?? 0),
+        pendingMergePrep: Boolean(row.pending_merge_prep),
     };
 }
 function mapRunRow(row) {

package/dist/factory-state.js

@@ -19,7 +19,7 @@ export const ALLOWED_TRANSITIONS = {
     changes_requested: ["implementing", "awaiting_input", "escalated"],
     repairing_ci: ["pr_open", "awaiting_review", "escalated", "failed"],
     awaiting_queue: ["done", "repairing_queue", "repairing_ci"],
-    repairing_queue: ["pr_open", "awaiting_review", "escalated", "failed"],
+    repairing_queue: ["pr_open", "awaiting_review", "awaiting_queue", "escalated", "failed"],
     awaiting_input: ["implementing", "delegated", "escalated"],
     escalated: [],
     done: [],
@@ -38,9 +38,13 @@ export function resolveFactoryStateFromGitHub(triggerEvent, current) {
         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" ? "repairing_ci" : undefined;
+            return current === "pr_open" || current === "awaiting_review" || current === "awaiting_queue"
+                ? "repairing_ci"
+                : undefined;
         case "pr_merged":
             return "done";
         case "pr_closed":

package/dist/github-webhook-handler.js

@@ -1,18 +1,52 @@
 import { resolveFactoryStateFromGitHub } from "./factory-state.js";
 import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
 import { safeJsonParse } from "./utils.js";
+/**
+ * GitHub sends both check_run and check_suite completion events.
+ * A single CI run generates 10+ individual check_run events as each job finishes,
+ * but only 1 check_suite event when the entire suite completes. Reacting to
+ * individual check_run events causes the factory state to flicker rapidly
+ * between pr_open and repairing_ci. We only drive state transitions and reactive
+ * runs from check_suite events. Individual check_run events still update PR
+ * metadata (prCheckStatus) for observability.
+ */
+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;
     linearProvider;
     enqueueIssue;
+    mergeQueue;
     logger;
     feed;
-    constructor(config, db, linearProvider, enqueueIssue, logger, feed) {
+    constructor(config, db, linearProvider, enqueueIssue, mergeQueue, logger, feed) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
         this.enqueueIssue = enqueueIssue;
+        this.mergeQueue = mergeQueue;
         this.logger = logger;
         this.feed = feed;
     }
@@ -63,6 +97,24 @@ export class GitHubWebhookHandler {
         const payload = safeJsonParse(params.rawBody);
         if (!payload || typeof payload !== "object")
             return;
+        // Push to a base branch advances the merge queue for affected projects.
+        // This catches external merges (human PRs, direct pushes) that PatchRelay
+        // does not track as issues but that make queued branches stale.
+        if (params.eventType === "push") {
+            const pushPayload = payload;
+            const ref = pushPayload.ref;
+            const repoFullName = pushPayload.repository?.full_name;
+            if (ref && repoFullName) {
+                const branchName = ref.replace("refs/heads/", "");
+                for (const project of this.config.projects) {
+                    const baseBranch = project.github?.baseBranch ?? "main";
+                    if (project.github?.repoFullName === repoFullName && branchName === baseBranch) {
+                        this.mergeQueue.advanceQueue(project.id);
+                    }
+                }
+            }
+            return;
+        }
         const event = normalizeGitHubWebhook({
             eventType: params.eventType,
             payload: payload,
@@ -87,28 +139,40 @@ export class GitHubWebhookHandler {
             ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
             ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
         });
-        // Individual check_run events only update PR metadata, not factory state.
-        // State transitions and reactive runs are driven by check_suite completion
-        // to avoid flickering when multiple checks run in parallel.
-        const isIndividualCheckRun = event.eventSource === "check_run"
-            && (event.triggerEvent === "check_passed" || event.triggerEvent === "check_failed");
-        // Drive factory state transitions from GitHub events
-        if (!isIndividualCheckRun) {
-            let newState = resolveFactoryStateFromGitHub(event.triggerEvent, issue.factoryState);
-            // Don't transition to failed on pr_closed when a run is active —
-            // Codex sometimes closes and reopens PRs during its workflow.
-            if (newState === "failed" && event.triggerEvent === "pr_closed" && issue.activeRunId !== undefined) {
+        if (!isMetadataOnlyCheckEvent(event)) {
+            // Re-read issue after PR metadata upsert so fast-track sees 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 (newState) {
+            if (shouldFastTrackToQueue(newState, afterMetadata)) {
+                newState = "awaiting_queue";
+            }
+            // Only transition and notify when the state actually changes.
+            // Multiple check_suite events can arrive for the same outcome.
+            if (newState && newState !== afterMetadata.factoryState) {
                 this.db.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     factoryState: newState,
                 });
-                this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
+                this.logger.info({ issueKey: issue.issueKey, from: afterMetadata.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
                 // Emit Linear activity for significant state changes
                 void this.emitLinearActivity(issue, newState, event);
+                // Schedule merge prep when entering awaiting_queue
+                if (newState === "awaiting_queue") {
+                    this.db.upsertIssue({
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        pendingMergePrep: true,
+                    });
+                    this.enqueueIssue(issue.projectId, issue.linearIssueId);
+                }
+                // Advance the merge queue when a PR merges
+                if (newState === "done" && event.triggerEvent === "pr_merged") {
+                    this.mergeQueue.advanceQueue(issue.projectId);
+                }
             }
         }
         // Reset repair counters on new push
@@ -133,8 +197,7 @@ export class GitHubWebhookHandler {
             summary: `GitHub: ${event.triggerEvent}${event.prNumber ? ` on PR #${event.prNumber}` : ""}`,
             detail: event.checkName ?? event.reviewBody?.slice(0, 200) ?? undefined,
         });
-        // Trigger reactive runs if applicable (skip individual check_run events)
-        if (!isIndividualCheckRun) {
+        if (!isMetadataOnlyCheckEvent(event)) {
             this.maybeEnqueueReactiveRun(freshIssue, event);
         }
     }
@@ -189,10 +252,10 @@ export class GitHubWebhookHandler {
             return;
         const messages = {
             pr_open: `PR #${event.prNumber ?? ""} opened.${event.prUrl ? ` ${event.prUrl}` : ""}`,
-            awaiting_queue: "PR approved. Awaiting merge queue.",
+            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 queue failed. 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.",
         };

package/dist/merge-queue.js

@@ -0,0 +1,156 @@
+import { execCommand } from "./utils.js";
+/**
+ * Merge queue steward — keeps PatchRelay-managed PR branches up to date
+ * with the base branch and enables auto-merge so GitHub merges when CI passes.
+ *
+ * Serialization: all calls are routed through the issue queue, and
+ * prepareForMerge checks front-of-queue before acting. The issue processor
+ * in service.ts checks pendingRunType before pendingMergePrep, so repair
+ * runs always take priority over merge prep.
+ */
+export class MergeQueue {
+    config;
+    db;
+    enqueueIssue;
+    logger;
+    feed;
+    constructor(config, db, enqueueIssue, logger, feed) {
+        this.config = config;
+        this.db = db;
+        this.enqueueIssue = enqueueIssue;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    /**
+     * Prepare the front-of-queue issue for merge:
+     * 1. Enable auto-merge
+     * 2. Update the branch to latest base (git merge)
+     * 3. Push (triggers CI; auto-merge fires when CI passes)
+     *
+     * On conflict: abort merge, transition to repairing_queue, enqueue queue_repair.
+     * On transient failure: leave pendingMergePrep set so the next event retries.
+     */
+    async prepareForMerge(issue, project) {
+        // Only prepare the front-of-queue issue for this project
+        const queue = this.db.listIssuesByState(project.id, "awaiting_queue");
+        const front = queue.find((i) => i.activeRunId === undefined && i.pendingRunType === undefined);
+        if (!front || front.id !== issue.id) {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
+            return;
+        }
+        if (!issue.worktreePath || !issue.prNumber) {
+            this.logger.warn({ issueKey: issue.issueKey }, "Merge prep skipped: missing worktree or PR number");
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
+            return;
+        }
+        const repoFullName = project.github?.repoFullName;
+        const baseBranch = project.github?.baseBranch ?? "main";
+        const gitBin = this.config.runner.gitBin;
+        // Enable auto-merge (idempotent)
+        const autoMergeOk = repoFullName ? await this.enableAutoMerge(issue, repoFullName) : false;
+        // Fetch latest base branch
+        const fetchResult = await execCommand(gitBin, ["-C", issue.worktreePath, "fetch", "origin", baseBranch], {
+            timeoutMs: 60_000,
+        });
+        if (fetchResult.exitCode !== 0) {
+            // Transient failure — leave pendingMergePrep set so the next event retries.
+            this.logger.warn({ issueKey: issue.issueKey, stderr: fetchResult.stderr?.slice(0, 300) }, "Merge prep: fetch failed, will retry on next event");
+            return;
+        }
+        // Merge base branch into the PR branch
+        const mergeResult = await execCommand(gitBin, ["-C", issue.worktreePath, "merge", `origin/${baseBranch}`, "--no-edit"], {
+            timeoutMs: 60_000,
+        });
+        if (mergeResult.exitCode !== 0) {
+            // Conflict — abort and trigger queue_repair
+            await execCommand(gitBin, ["-C", issue.worktreePath, "merge", "--abort"], { timeoutMs: 10_000 });
+            this.logger.info({ issueKey: issue.issueKey }, "Merge prep: conflict detected, triggering queue repair");
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: "repairing_queue",
+                pendingRunType: "queue_repair",
+                pendingRunContextJson: JSON.stringify({ failureReason: "merge_conflict" }),
+                pendingMergePrep: false,
+            });
+            this.enqueueIssue(issue.projectId, issue.linearIssueId);
+            this.feed?.publish({
+                level: "warn",
+                kind: "workflow",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: "repairing_queue",
+                status: "conflict",
+                summary: `Merge conflict with ${baseBranch} — queue repair enqueued`,
+            });
+            return;
+        }
+        // Check if merge was a no-op (already up to date)
+        if (mergeResult.stdout?.includes("Already up to date")) {
+            this.logger.debug({ issueKey: issue.issueKey }, "Merge prep: branch already up to date");
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
+            if (!autoMergeOk) {
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "workflow",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "awaiting_queue",
+                    status: "blocked",
+                    summary: "Branch up to date but auto-merge not enabled — set GITHUB_TOKEN to unblock",
+                });
+            }
+            return;
+        }
+        // Push the merged branch
+        const pushResult = await execCommand(gitBin, ["-C", issue.worktreePath, "push"], {
+            timeoutMs: 60_000,
+        });
+        if (pushResult.exitCode !== 0) {
+            // Push failed — leave pendingMergePrep set so the next event retries.
+            this.logger.warn({ issueKey: issue.issueKey, stderr: pushResult.stderr?.slice(0, 300) }, "Merge prep: push failed, will retry on next event");
+            return;
+        }
+        this.logger.info({ issueKey: issue.issueKey, baseBranch }, "Merge prep: branch updated and pushed");
+        this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
+        this.feed?.publish({
+            level: "info",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: "awaiting_queue",
+            status: "prepared",
+            summary: `Branch updated to latest ${baseBranch} — CI will run`,
+        });
+    }
+    /**
+     * Advance the queue: find the next awaiting_queue issue and prepare it.
+     * Called when a PR merges (pr_merged event).
+     */
+    advanceQueue(projectId) {
+        const queue = this.db.listIssuesByState(projectId, "awaiting_queue");
+        const next = queue.find((i) => i.activeRunId === undefined && i.pendingRunType === undefined && !i.pendingMergePrep);
+        if (!next)
+            return;
+        this.logger.info({ issueKey: next.issueKey, projectId }, "Advancing merge queue");
+        this.db.upsertIssue({ projectId: next.projectId, linearIssueId: next.linearIssueId, pendingMergePrep: true });
+        this.enqueueIssue(next.projectId, next.linearIssueId);
+    }
+    /** Returns true if auto-merge was successfully enabled (or already enabled). */
+    async enableAutoMerge(issue, repoFullName) {
+        const token = process.env.GITHUB_TOKEN;
+        if (!token) {
+            this.logger.warn({ issueKey: issue.issueKey }, "Merge prep: GITHUB_TOKEN not set — auto-merge cannot be enabled");
+            return false;
+        }
+        const result = await execCommand("gh", ["pr", "merge", String(issue.prNumber), "--repo", repoFullName, "--auto", "--squash"], {
+            timeoutMs: 30_000,
+            env: { ...process.env, GH_TOKEN: token },
+        });
+        if (result.exitCode !== 0) {
+            this.logger.warn({ issueKey: issue.issueKey, stderr: result.stderr?.slice(0, 200) }, "Merge prep: auto-merge enablement failed");
+            return false;
+        }
+        return true;
+    }
+}

package/dist/run-orchestrator.js

@@ -30,7 +30,7 @@ function buildRunPrompt(issue, runType, repoPath, context) {
     const lines = [
         `Issue: ${issue.issueKey ?? issue.linearIssueId}`,
         issue.title ? `Title: ${issue.title}` : undefined,
-        `Branch: ${issue.branchName}`,
+        issue.branchName ? `Branch: ${issue.branchName}` : undefined,
         issue.prNumber ? `PR: #${issue.prNumber}` : undefined,
         "",
     ].filter(Boolean);
@@ -161,8 +161,9 @@ export class RunOrchestrator {
             if (prepareResult.ran && prepareResult.exitCode !== 0) {
                 throw new Error(`prepare-worktree hook failed (exit ${prepareResult.exitCode}): ${prepareResult.stderr?.slice(0, 500) ?? ""}`);
             }
-            // Start or reuse Codex thread
-            if (issue.threadId && runType !== "implementation") {
+            // Reuse the existing thread only for review_fix (reviewer context matters).
+            // Implementation, ci_repair, and queue_repair get fresh threads.
+            if (issue.threadId && runType === "review_fix") {
                 threadId = issue.threadId;
             }
             else {

package/dist/service.js

@@ -1,6 +1,7 @@
 import { GitHubWebhookHandler } from "./github-webhook-handler.js";
 import { IssueQueryService } from "./issue-query-service.js";
 import { LinearOAuthService } from "./linear-oauth-service.js";
+import { MergeQueue } from "./merge-queue.js";
 import { RunOrchestrator } from "./run-orchestrator.js";
 import { OperatorEventFeed } from "./operator-feed.js";
 import { buildSessionStatusUrl, createSessionStatusToken, deriveSessionStatusSigningSecret, verifySessionStatusToken, } from "./public-agent-session-status.js";
@@ -14,6 +15,7 @@ export class PatchRelayService {
     logger;
     linearProvider;
     orchestrator;
+    mergeQueue;
     webhookHandler;
     githubWebhookHandler;
     oauthService;
@@ -31,9 +33,33 @@ export class PatchRelayService {
             throw new Error("Service runtime enqueueIssue is not initialized");
         };
         this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
+        this.mergeQueue = new MergeQueue(config, db, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
         this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
-        this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
-        const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, { processIssue: (item) => this.orchestrator.run(item) });
+        this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), this.mergeQueue, logger, this.feed);
+        const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, {
+            processIssue: async (item) => {
+                const issue = db.getIssue(item.projectId, item.issueId);
+                // Repairs take priority over merge prep — a check_failed or
+                // review_changes_requested that arrived while merge prep was
+                // queued must not be swallowed.
+                if (issue?.pendingRunType) {
+                    await this.orchestrator.run(item);
+                    return;
+                }
+                if (issue?.pendingMergePrep) {
+                    const project = config.projects.find((p) => p.id === item.projectId);
+                    if (project)
+                        await this.mergeQueue.prepareForMerge(issue, project);
+                    // Re-check: a repair run may have been enqueued during prep
+                    const after = db.getIssue(item.projectId, item.issueId);
+                    if (after?.pendingRunType) {
+                        runtime.enqueueIssue(item.projectId, item.issueId);
+                    }
+                    return;
+                }
+                await this.orchestrator.run(item);
+            },
+        });
         enqueueIssue = (projectId, issueId) => runtime.enqueueIssue(projectId, issueId);
         this.oauthService = new LinearOAuthService(config, { linearInstallations: db.linearInstallations }, logger);
         this.queryService = new IssueQueryService(db, codex, this.orchestrator);

package/package.json

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