patchrelay 0.23.3 → 0.23.4

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.4",
+  "commit": "650e9c85fdcf",
+  "builtAt": "2026-03-26T13:49:43.718Z"
 }

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

@@ -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;

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

@@ -622,6 +622,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 +679,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/package.json

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