patchrelay 0.23.1 → 0.23.3

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.23.1",
-  "commit": "b04a5fd406df",
-  "builtAt": "2026-03-26T12:04:01.904Z"
+  "version": "0.23.3",
+  "commit": "1c8c52702f63",
+  "builtAt": "2026-03-26T13:46:43.445Z"
 }

package/dist/cli/watch/IssueRow.js

@@ -19,14 +19,14 @@ const STATE_SHORT = {
     preparing: "prep",
     implementing: "impl",
     pr_open: "pr open",
-    changes_requested: "changes",
+    changes_requested: "review fix",
     repairing_ci: "ci fix",
     awaiting_queue: "merging",
     repairing_queue: "merge fix",
     done: "done",
     failed: "failed",
     escalated: "escalated",
-    awaiting_input: "input",
+    awaiting_input: "paused",
 };
 const RUN_SHORT = {
     implementation: "impl",

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);
         }
@@ -611,11 +678,15 @@ export class RunOrchestrator {
     // ─── Internal helpers ─────────────────────────────────────────────
     escalate(issue, runType, reason) {
         this.logger.warn({ issueKey: issue.issueKey, runType, reason }, "Escalating to human");
+        if (issue.activeRunId) {
+            this.db.finishRun(issue.activeRunId, { status: "released" });
+        }
         this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             pendingRunType: null,
             pendingRunContextJson: null,
+            activeRunId: null,
             factoryState: "escalated",
         });
         this.feed?.publish({
@@ -752,10 +823,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/package.json

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