patchrelay 0.23.2 → 0.23.4

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.23.2",
-  "commit": "c701bbd6fa48",
-  "builtAt": "2026-03-26T12:54:15.295Z"
+  "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

@@ -56,7 +56,7 @@ function buildRunPrompt(issue, runType, repoPath, context) {
             lines.push("## CI Repair", "", "A CI check has failed on your PR. Fix the failure and push.", context?.checkName ? `Failed check: ${String(context.checkName)}` : "", context?.checkUrl ? `Check URL: ${String(context.checkUrl)}` : "", "", "Read the CI failure logs, fix the code issue, run verification, commit and push.", "Do not change test expectations unless the test is genuinely wrong.", "");
             break;
         case "review_fix":
-            lines.push("## Review Changes Requested", "", "A reviewer has requested changes on your PR. Address the feedback and push.", context?.reviewerName ? `Reviewer: ${String(context.reviewerName)}` : "", context?.reviewBody ? `\n## Review comment\n\n${String(context.reviewBody)}` : "", "", "Read the review feedback and PR comments (`gh pr view --comments`), address each point, run verification, commit and push.", "");
+            lines.push("## Review Changes Requested", "", "A reviewer has requested changes on your PR. Address the feedback and push.", context?.reviewerName ? `Reviewer: ${String(context.reviewerName)}` : "", context?.reviewBody ? `\n## Review comment\n\n${String(context.reviewBody)}` : "", "", "Steps:", "1. Read the review feedback and PR comments (`gh pr view --comments`).", "2. Check the current diff (`git diff origin/main`) — a prior rebase may have already resolved some concerns (e.g., scope-bundling from stale commits).", "3. For each review point: if already resolved, note why. If not, fix it.", "4. Run verification, commit and push.", "5. If you believe all concerns are resolved, request a re-review: `gh pr edit <PR#> --add-reviewer <reviewer>`.", "   Do NOT just post a comment saying \"resolved\" — the reviewer must re-review to dismiss the CHANGES_REQUESTED state.", "");
             break;
         case "queue_repair":
             lines.push("## Merge Queue Failure", "", "The merge queue rejected this PR. Rebase onto latest main and fix conflicts.", context?.failureReason ? `Failure reason: ${String(context.failureReason)}` : "", "", "Fetch and rebase onto latest main, resolve conflicts, run verification, push.", "If the conflict is a semantic contradiction, explain and stop.", "");
@@ -188,6 +188,10 @@ export class RunOrchestrator {
                 await execCommand(gitBin, ["-C", worktreePath, "config", "user.name", this.botIdentity.name], { timeoutMs: 5_000 });
                 await execCommand(gitBin, ["-C", worktreePath, "config", "user.email", this.botIdentity.email], { timeoutMs: 5_000 });
             }
+            // 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);
             // 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 });
@@ -246,6 +250,60 @@ export class RunOrchestrator {
         void this.emitLinearActivity(freshIssue, buildRunStartedActivity(runType));
         void this.syncLinearSession(freshIssue, { activeRunType: runType });
     }
+    // ─── Pre-run branch freshening ────────────────────────────────────
+    /**
+     * Fetch origin and rebase the worktree onto the latest base branch.
+     *
+     * Risks mitigated:
+     * - Dirty worktree from interrupted run → stash before, pop after
+     * - Conflicts → abort rebase, throw so the run fails with a clear reason
+     * - Already up-to-date → no-op, no force-push needed
+     * - Force-push invalidates reviews → only push if rebase actually moved commits
+     */
+    async freshenWorktree(worktreePath, project, issue) {
+        const gitBin = this.config.runner.gitBin;
+        const baseBranch = project.github?.baseBranch ?? "main";
+        // Stash any uncommitted changes from a previous interrupted run
+        const stashResult = await execCommand(gitBin, ["-C", worktreePath, "stash"], { timeoutMs: 30_000 });
+        const didStash = stashResult.exitCode === 0 && !stashResult.stdout?.includes("No local changes");
+        // Fetch latest base
+        const fetchResult = await execCommand(gitBin, ["-C", worktreePath, "fetch", "origin", baseBranch], { timeoutMs: 60_000 });
+        if (fetchResult.exitCode !== 0) {
+            this.logger.warn({ issueKey: issue.issueKey, stderr: fetchResult.stderr?.slice(0, 300) }, "Pre-run fetch failed, proceeding with current base");
+            if (didStash)
+                await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+            return;
+        }
+        // Check if rebase is needed: is HEAD already on top of origin/baseBranch?
+        const mergeBaseResult = await execCommand(gitBin, ["-C", worktreePath, "merge-base", "--is-ancestor", `origin/${baseBranch}`, "HEAD"], { timeoutMs: 10_000 });
+        if (mergeBaseResult.exitCode === 0) {
+            // Already up-to-date — no rebase needed
+            this.logger.debug({ issueKey: issue.issueKey }, "Pre-run freshen: branch already up to date");
+            if (didStash)
+                await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+            return;
+        }
+        // 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
+            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`);
+        }
+        // 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 });
+        if (pushResult.exitCode !== 0) {
+            this.logger.warn({ issueKey: issue.issueKey, stderr: pushResult.stderr?.slice(0, 300) }, "Pre-run rebase push failed, proceeding anyway");
+        }
+        else {
+            this.logger.info({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebased and pushed onto latest base");
+        }
+        // Restore stashed changes
+        if (didStash)
+            await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+    }
     // ─── Notification handler ─────────────────────────────────────────
     async handleCodexNotification(notification) {
         // threadId is present on turn-level notifications but NOT on item-level ones.
@@ -492,6 +550,15 @@ export class RunOrchestrator {
             ...(newState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
             ...(pendingRunType ? { pendingRunType: pendingRunType } : {}),
         });
+        this.feed?.publish({
+            level: "info",
+            kind: "stage",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: newState,
+            status: "reconciled",
+            summary: `Reconciliation: ${issue.factoryState} \u2192 ${newState}`,
+        });
         if (newState === "awaiting_queue" || pendingRunType) {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
@@ -555,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;
                 }
             }
@@ -603,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);
             }
@@ -756,10 +843,12 @@ export class RunOrchestrator {
  */
 function resolvePostRunState(issue) {
     if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
-        if (issue.prReviewState === "approved")
-            return "awaiting_queue";
+        // Check merged first — a merged PR is both approved and merged,
+        // and "done" must take priority over "awaiting_queue".
         if (issue.prState === "merged")
             return "done";
+        if (issue.prReviewState === "approved")
+            return "awaiting_queue";
         return "pr_open";
     }
     return undefined;

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.2",
+  "version": "0.23.4",
   "license": "MIT",
   "type": "module",
   "repository": {