patchrelay 0.23.3 → 0.23.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.23.3",
-  "commit": "1c8c52702f63",
-  "builtAt": "2026-03-26T13:46:43.445Z"
+  "version": "0.23.5",
+  "commit": "65abb29863f7",
+  "builtAt": "2026-03-26T16:08:25.878Z"
 }

package/dist/db/migrations.js

@@ -141,6 +141,9 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "description", "TEXT");
     addColumnIfMissing(connection, "issues", "priority", "INTEGER");
     addColumnIfMissing(connection, "issues", "estimate", "REAL");
+    // Zombie/stale recovery backoff
+    addColumnIfMissing(connection, "issues", "zombie_recovery_attempts", "INTEGER NOT NULL DEFAULT 0");
+    addColumnIfMissing(connection, "issues", "last_zombie_recovery_at", "TEXT");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/db.js

@@ -173,6 +173,14 @@ export class PatchRelayDatabase {
                 sets.push("pending_merge_prep = @pendingMergePrep");
                 values.pendingMergePrep = params.pendingMergePrep ? 1 : 0;
             }
+            if (params.zombieRecoveryAttempts !== undefined) {
+                sets.push("zombie_recovery_attempts = @zombieRecoveryAttempts");
+                values.zombieRecoveryAttempts = params.zombieRecoveryAttempts;
+            }
+            if (params.lastZombieRecoveryAt !== undefined) {
+                sets.push("last_zombie_recovery_at = @lastZombieRecoveryAt");
+                values.lastZombieRecoveryAt = params.lastZombieRecoveryAt;
+            }
             this.connection.prepare(`UPDATE issues SET ${sets.join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`).run(values);
         }
         else {
@@ -424,6 +432,8 @@ function mapIssueRow(row) {
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
         mergePrepAttempts: Number(row.merge_prep_attempts ?? 0),
         pendingMergePrep: Boolean(row.pending_merge_prep),
+        zombieRecoveryAttempts: Number(row.zombie_recovery_attempts ?? 0),
+        ...(row.last_zombie_recovery_at !== null && row.last_zombie_recovery_at !== undefined ? { lastZombieRecoveryAt: String(row.last_zombie_recovery_at) } : {}),
     };
 }
 function mapRunRow(row) {

package/dist/factory-state.js

@@ -20,8 +20,12 @@ export const TERMINAL_STATES = new Set([
 const isOpen = (s) => !TERMINAL_STATES.has(s);
 const TRANSITION_RULES = [
     // ── Terminal events ────────────────────────────────────────────
-    // pr_merged is unconditional — PR is merged, we're done.
+    // pr_merged transitions to done only when no agent run is active.
+    // If an active run exists, suppress the transition — the run's
+    // completion handler will detect the merged PR and advance to done.
+    // This prevents orphaning agent work (e.g. pending follow-up fixes).
     { event: "pr_merged",
+        guard: (_, ctx) => ctx.activeRunId === undefined,
         to: "done" },
     // pr_closed during an active run is suppressed — Codex may reopen.
     // Without a guard match, the event produces no transition (undefined).

package/dist/github-webhook-handler.js

@@ -1,4 +1,4 @@
-import { resolveFactoryStateFromGitHub } from "./factory-state.js";
+import { resolveFactoryStateFromGitHub, TERMINAL_STATES } from "./factory-state.js";
 import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
@@ -163,6 +163,12 @@ export class GitHubWebhookHandler {
                     this.mergeQueue.advanceQueue(issue.projectId);
                 }
             }
+            // Advance the merge queue even when the state transition was suppressed
+            // (e.g., pr_merged during an active run). The PR is factually merged —
+            // the next queued issue should not wait for the active run to finish.
+            if (!newState && event.triggerEvent === "pr_merged") {
+                this.mergeQueue.advanceQueue(issue.projectId);
+            }
         }
         // Re-read issue after all upserts so reactive run logic sees current state
         const freshIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
@@ -196,6 +202,10 @@ export class GitHubWebhookHandler {
         // Don't trigger if there's already an active run
         if (issue.activeRunId !== undefined)
             return;
+        // Don't trigger on terminal issues — late-arriving webhooks (e.g.
+        // merge_group_failed after pr_merged) must not resurrect done issues.
+        if (TERMINAL_STATES.has(issue.factoryState))
+            return;
         if (event.triggerEvent === "check_failed" && issue.prState === "open") {
             this.db.upsertIssue({
                 projectId: issue.projectId,

package/dist/merge-queue.js

@@ -3,7 +3,8 @@ import { execCommand } from "./utils.js";
 const DEFAULT_MERGE_PREP_BUDGET = 3;
 /**
  * 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.
+ * with the base branch via rebase and enables auto-merge so GitHub merges
+ * when CI passes. Uses rebase (not merge) to maintain linear history.
  *
  * Serialization: all calls are routed through the issue queue, and
  * prepareForMerge checks front-of-queue before acting. The issue processor
@@ -28,10 +29,10 @@ export class MergeQueue {
     /**
      * 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)
+     * 2. Rebase the branch onto latest base
+     * 3. Force-push (triggers CI; auto-merge fires when CI passes)
      *
-     * On conflict: abort merge, transition to repairing_queue, enqueue queue_repair.
+     * On conflict: abort rebase, transition to repairing_queue, enqueue queue_repair.
      * On transient failure: leave pendingMergePrep set so the next event retries.
      */
     async prepareForMerge(issue, project) {
@@ -88,20 +89,41 @@ export class MergeQueue {
             this.onLinearActivity?.(issue, buildMergePrepActivity("fetch_retry"), { ephemeral: true });
             return;
         }
-        // Merge base branch into the PR branch
-        const mergeResult = await execCommand(gitBin, ["-C", issue.worktreePath, "merge", `origin/${baseBranch}`, "--no-edit"], {
-            timeoutMs: 60_000,
+        // Check if rebase is needed: is HEAD already on top of origin/baseBranch?
+        const mergeBaseResult = await execCommand(gitBin, ["-C", issue.worktreePath, "merge-base", "--is-ancestor", `origin/${baseBranch}`, "HEAD"], {
+            timeoutMs: 10_000,
+        });
+        if (mergeBaseResult.exitCode === 0) {
+            this.logger.debug({ issueKey: issue.issueKey }, "Merge prep: branch already up to date");
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false, mergePrepAttempts: 0 });
+            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 — check gh auth and repo settings",
+                });
+                this.onLinearActivity?.(issue, buildMergePrepActivity("blocked"));
+            }
+            return;
+        }
+        // Rebase onto latest base branch (clean linear history, no merge commits)
+        const rebaseResult = await execCommand(gitBin, ["-C", issue.worktreePath, "rebase", `origin/${baseBranch}`], {
+            timeoutMs: 120_000,
         });
-        if (mergeResult.exitCode !== 0) {
+        if (rebaseResult.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");
+            await execCommand(gitBin, ["-C", issue.worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
+            this.logger.info({ issueKey: issue.issueKey }, "Merge prep: rebase 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" }),
+                pendingRunContextJson: JSON.stringify({ failureReason: "rebase_conflict" }),
                 pendingMergePrep: false,
             });
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
@@ -112,31 +134,13 @@ export class MergeQueue {
                 projectId: issue.projectId,
                 stage: "repairing_queue",
                 status: "conflict",
-                summary: `Merge conflict with ${baseBranch} — queue repair enqueued`,
+                summary: `Rebase conflict with ${baseBranch} — queue repair enqueued`,
             });
             this.onLinearActivity?.(issue, buildMergePrepActivity("conflict"));
             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, mergePrepAttempts: 0 });
-            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 — check gh auth and repo settings",
-                });
-                this.onLinearActivity?.(issue, buildMergePrepActivity("blocked"));
-            }
-            return;
-        }
-        // Push the merged branch
-        const pushResult = await execCommand(gitBin, ["-C", issue.worktreePath, "push"], {
+        // Push the rebased branch (force-with-lease to protect against concurrent changes)
+        const pushResult = await execCommand(gitBin, ["-C", issue.worktreePath, "push", "--force-with-lease"], {
             timeoutMs: 60_000,
         });
         if (pushResult.exitCode !== 0) {
@@ -145,7 +149,7 @@ export class MergeQueue {
             this.onLinearActivity?.(issue, buildMergePrepActivity("push_retry"), { ephemeral: true });
             return;
         }
-        this.logger.info({ issueKey: issue.issueKey, baseBranch }, "Merge prep: branch updated and pushed");
+        this.logger.info({ issueKey: issue.issueKey, baseBranch }, "Merge prep: rebased and pushed");
         this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false, mergePrepAttempts: 0 });
         this.feed?.publish({
             level: "info",
@@ -154,7 +158,7 @@ export class MergeQueue {
             projectId: issue.projectId,
             stage: "awaiting_queue",
             status: "prepared",
-            summary: `Branch updated to latest ${baseBranch} — CI will run`,
+            summary: `Branch rebased onto latest ${baseBranch} — CI will run`,
         });
         this.onLinearActivity?.(issue, buildMergePrepActivity("branch_update", baseBranch), { ephemeral: true });
     }

package/dist/run-orchestrator.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { ACTIVE_RUN_STATES } from "./factory-state.js";
+import { ACTIVE_RUN_STATES, TERMINAL_STATES } from "./factory-state.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
@@ -12,6 +12,8 @@ import { execCommand } from "./utils.js";
 const DEFAULT_CI_REPAIR_BUDGET = 3;
 const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
 const DEFAULT_REVIEW_FIX_BUDGET = 3;
+const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
+const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000; // 15s, 30s, 60s, 120s, 240s
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -191,7 +193,10 @@ export class RunOrchestrator {
             // Freshen the worktree: fetch + rebase onto latest base branch.
             // This prevents branch contamination when local main has drifted
             // and avoids scope-bundling review rejections from stale commits.
-            await this.freshenWorktree(worktreePath, project, issue);
+            // Skip for queue_repair — its entire purpose is to resolve rebase conflicts.
+            if (runType !== "queue_repair") {
+                await this.freshenWorktree(worktreePath, project, issue);
+            }
             // Run prepare-worktree hook
             const hookEnv = buildHookEnv(issue.issueKey ?? issue.linearIssueId, branchName, runType, worktreePath);
             const prepareResult = await runProjectHook(project.repoPath, "prepare-worktree", { cwd: worktreePath, env: hookEnv });
@@ -244,6 +249,15 @@ export class RunOrchestrator {
             throw error;
         }
         this.db.updateRunThread(run.id, { threadId, turnId });
+        // Reset zombie recovery counter — this run started successfully
+        if (issue.zombieRecoveryAttempts > 0) {
+            this.db.upsertIssue({
+                projectId: item.projectId,
+                linearIssueId: item.issueId,
+                zombieRecoveryAttempts: 0,
+                lastZombieRecoveryAt: null,
+            });
+        }
         this.logger.info({ issueKey: issue.issueKey, runType, threadId, turnId }, `Started ${runType} run`);
         // Emit Linear activity + plan
         const freshIssue = this.db.getIssue(item.projectId, item.issueId) ?? issue;
@@ -286,11 +300,14 @@ export class RunOrchestrator {
         // Rebase onto latest base
         const rebaseResult = await execCommand(gitBin, ["-C", worktreePath, "rebase", `origin/${baseBranch}`], { timeoutMs: 120_000 });
         if (rebaseResult.exitCode !== 0) {
-            // Abort the failed rebase and restore state
+            // Abort the failed rebase and restore state — then let the agent run
+            // proceed. The agent can resolve the conflict itself (the workflow
+            // prompt tells it to rebase and handle conflicts).
             await execCommand(gitBin, ["-C", worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
             if (didStash)
                 await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
-            throw new Error(`Pre-run rebase onto origin/${baseBranch} failed with conflicts — escalate or resolve manually`);
+            this.logger.warn({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebase conflict, agent will resolve");
+            return;
         }
         // Push the rebased branch (force-with-lease to protect against concurrent pushes)
         const pushResult = await execCommand(gitBin, ["-C", worktreePath, "push", "--force-with-lease"], { timeoutMs: 60_000 });
@@ -563,26 +580,91 @@ export class RunOrchestrator {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }
+    /**
+     * After a zombie/stale run is cleared, decide whether to re-enqueue
+     * or escalate. Checks: PR already merged → done; budget exhausted →
+     * escalate; backoff delay not elapsed → skip.
+     */
+    recoverOrEscalate(issue, runType, reason) {
+        // Re-read issue after the run was cleared (activeRunId is now null)
+        const fresh = this.db.getIssue(issue.projectId, issue.linearIssueId);
+        if (!fresh)
+            return;
+        // If PR already merged, transition to done — no retry needed
+        if (fresh.prState === "merged") {
+            this.db.upsertIssue({
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                factoryState: "done",
+                zombieRecoveryAttempts: 0,
+                lastZombieRecoveryAt: null,
+            });
+            this.logger.info({ issueKey: fresh.issueKey, reason }, "Recovery: PR already merged — transitioning to done");
+            return;
+        }
+        // Budget check
+        const attempts = fresh.zombieRecoveryAttempts + 1;
+        if (attempts > DEFAULT_ZOMBIE_RECOVERY_BUDGET) {
+            this.db.upsertIssue({
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                factoryState: "escalated",
+            });
+            this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: budget exhausted — escalating");
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: fresh.issueKey,
+                projectId: fresh.projectId,
+                stage: "escalated",
+                status: "budget_exhausted",
+                summary: `${reason} recovery failed after ${DEFAULT_ZOMBIE_RECOVERY_BUDGET} attempts`,
+            });
+            return;
+        }
+        // Exponential backoff — skip if delay hasn't elapsed
+        if (fresh.lastZombieRecoveryAt) {
+            const elapsed = Date.now() - new Date(fresh.lastZombieRecoveryAt).getTime();
+            const delay = ZOMBIE_RECOVERY_BASE_DELAY_MS * Math.pow(2, fresh.zombieRecoveryAttempts);
+            if (elapsed < delay) {
+                this.logger.debug({ issueKey: fresh.issueKey, attempts: fresh.zombieRecoveryAttempts, delay, elapsed }, "Recovery: backoff not elapsed, skipping");
+                return;
+            }
+        }
+        // Re-enqueue with backoff tracking
+        this.db.upsertIssue({
+            projectId: fresh.projectId,
+            linearIssueId: fresh.linearIssueId,
+            pendingRunType: runType,
+            pendingRunContextJson: null,
+            zombieRecoveryAttempts: attempts,
+            lastZombieRecoveryAt: new Date().toISOString(),
+        });
+        this.enqueueIssue(fresh.projectId, fresh.linearIssueId);
+        this.logger.info({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: re-enqueued with backoff");
+    }
     async reconcileRun(run) {
         const issue = this.db.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
             return;
+        // If the issue reached a terminal state while this run was active
+        // (e.g. pr_merged processed, DB manually edited), just release the run.
+        if (TERMINAL_STATES.has(issue.factoryState)) {
+            this.db.transaction(() => {
+                this.db.finishRun(run.id, { status: "released", failureReason: "Issue reached terminal state during active run" });
+                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
+            });
+            this.logger.info({ issueKey: issue.issueKey, runId: run.id, factoryState: issue.factoryState }, "Reconciliation: released run on terminal issue");
+            return;
+        }
         // 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.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
             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.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.enqueueIssue(run.projectId, run.linearIssueId);
+            this.recoverOrEscalate(issue, run.runType, "zombie");
             return;
         }
         // Read Codex state — thread may not exist after app-server restart.
@@ -591,18 +673,12 @@ export class RunOrchestrator {
             thread = await this.readThreadWithRetry(run.threadId);
         }
         catch {
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation — clearing and re-enqueueing");
+            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
             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.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.enqueueIssue(run.projectId, run.linearIssueId);
+            this.recoverOrEscalate(issue, run.runType, "stale_thread");
             return;
         }
         // Check Linear state (non-fatal — token refresh may fail)
@@ -622,6 +698,15 @@ export class RunOrchestrator {
                             factoryState: "done",
                         });
                     });
+                    this.feed?.publish({
+                        level: "info",
+                        kind: "stage",
+                        issueKey: issue.issueKey,
+                        projectId: run.projectId,
+                        stage: "done",
+                        status: "reconciled",
+                        summary: `Linear state ${stopState.stateName} \u2192 done`,
+                    });
                     return;
                 }
             }
@@ -670,6 +755,17 @@ export class RunOrchestrator {
                     ...(postRunState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
                 });
             });
+            if (postRunState) {
+                this.feed?.publish({
+                    level: "info",
+                    kind: "turn",
+                    issueKey: issue.issueKey,
+                    projectId: run.projectId,
+                    stage: run.runType,
+                    status: "completed",
+                    summary: `Reconciliation: ${run.runType} completed \u2192 ${postRunState}`,
+                });
+            }
             if (postRunState === "awaiting_queue") {
                 this.enqueueIssue(run.projectId, run.linearIssueId);
             }

package/dist/service.js

@@ -342,6 +342,15 @@ export class PatchRelayService {
             pendingRunType: runType,
             factoryState: factoryState,
         });
+        this.feed.publish({
+            level: "info",
+            kind: "stage",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: factoryState,
+            status: "retry",
+            summary: `Retry queued: ${runType}`,
+        });
         this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
         return { issueKey, runType };
     }

package/dist/worktree-manager.js

@@ -12,7 +12,13 @@ export class WorktreeManager {
             return;
         }
         await ensureDir(path.dirname(worktreePath));
-        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "worktree", "add", "--force", "-B", branchName, worktreePath, "HEAD"], {
+        // Fetch latest main so the branch forks from a clean, up-to-date base.
+        // This prevents branch contamination when local HEAD has drifted.
+        // freshenWorktree in run-orchestrator acts as a secondary safety net.
+        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "fetch", "origin", "main"], {
+            timeoutMs: 60_000,
+        });
+        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "worktree", "add", "--force", "-B", branchName, worktreePath, "origin/main"], {
             timeoutMs: 120_000,
         });
     }

package/package.json

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