patchrelay 0.35.11 → 0.35.13

package/dist/run-orchestrator.js

@@ -1,18 +1,23 @@
+import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { ACTIVE_RUN_STATES, TERMINAL_STATES } from "./factory-state.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
 import { buildRunCompletedActivity, buildRunFailureActivity, buildRunStartedActivity, } from "./linear-session-reporting.js";
-import { requestMergeQueueAdmission, resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
 import { WorktreeManager } from "./worktree-manager.js";
-import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
+import { resolveAuthoritativeLinearStopState, resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { execCommand } from "./utils.js";
+import { getThreadTurns } from "./codex-thread-utils.js";
+import { deriveIssueSessionReactiveIntent } from "./issue-session.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
+const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
+const MAX_THREAD_GENERATION_BEFORE_COMPACTION = 4;
+const MAX_FOLLOW_UPS_BEFORE_COMPACTION = 4;
 import { QueueHealthMonitor } from "./queue-health-monitor.js";
 import { IdleIssueReconciler, resolveBranchOwnerForStateTransition } from "./idle-reconciliation.js";
 import { LinearSessionSync } from "./linear-session-sync.js";
@@ -38,22 +43,340 @@ function readWorkflowFile(repoPath, runType) {
         return undefined;
     return readFileSync(filePath, "utf8").trim();
 }
-function buildRunPrompt(issue, runType, repoPath, context) {
-    const lines = [
+function collectImplementationInstructionText(issue, context, promptText) {
+    const parts = [];
+    if (issue.title)
+        parts.push(issue.title);
+    if (issue.description)
+        parts.push(issue.description);
+    if (promptText)
+        parts.push(promptText);
+    const stringFields = ["promptContext", "promptBody", "operatorPrompt", "userComment"];
+    for (const field of stringFields) {
+        const value = context?.[field];
+        if (typeof value === "string" && value.trim()) {
+            parts.push(value);
+        }
+    }
+    if (Array.isArray(context?.followUps)) {
+        for (const entry of context.followUps) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const text = entry.text;
+            if (typeof text === "string" && text.trim()) {
+                parts.push(text);
+            }
+        }
+    }
+    return parts.join("\n").toLowerCase();
+}
+export function resolveImplementationDeliveryMode(issue, context, promptText) {
+    const instructionText = collectImplementationInstructionText(issue, context, promptText);
+    if (!instructionText)
+        return "publish_pr";
+    const hasExplicitNoPr = [
+        /\bdo not open (?:a |any )?pr\b/,
+        /\bdo not open (?:a |any )?pull request\b/,
+        /\bno pr is opened\b/,
+        /\bpatchrelay should not open a pr\b/,
+        /\bwithout opening a pr\b/,
+    ].some((pattern) => pattern.test(instructionText));
+    const forbidsRepoChanges = [
+        /\bdo not make repository changes\b/,
+        /\bdo not make repo changes\b/,
+        /\bno repository changes\b/,
+        /\bno repo changes\b/,
+        /\bdo not modify repo files\b/,
+    ].some((pattern) => pattern.test(instructionText));
+    const planningOnly = [
+        /\bplanning\/specification issue only\b/,
+        /\bplanning[- ]only\b/,
+        /\bspecification[- ]only\b/,
+        /\bplanning issue only\b/,
+    ].some((pattern) => pattern.test(instructionText));
+    if (hasExplicitNoPr || (planningOnly && forbidsRepoChanges)) {
+        return "linear_only";
+    }
+    return "publish_pr";
+}
+function appendPublicationContract(lines, runType, issue, context) {
+    const deliveryMode = runType === "implementation" && issue
+        ? resolveImplementationDeliveryMode(issue, context)
+        : "publish_pr";
+    if (runType === "implementation" && deliveryMode === "linear_only") {
+        lines.push("## Delivery Requirements", "");
+        lines.push("This issue is planning/specification only.", "Do not modify repo files or open a PR for this issue.", "Deliver the result through Linear artifacts such as follow-up issues, documents, and a concise summary.", "Leave the worktree clean before stopping.", "");
+        return;
+    }
+    lines.push("## Publication Requirements", "");
+    if (runType === "implementation") {
+        lines.push("Before finishing, publish the result instead of leaving it only in the worktree.", "If the worktree already contains relevant changes for this issue, verify them and publish them.", "If you changed files for this issue, commit them, push the issue branch, and open or update the PR before stopping.", "Do not stop with only local commits or uncommitted changes.", "");
+        return;
+    }
+    lines.push("Before finishing, publish the result to the existing PR branch.", "If you changed files for this repair, commit them and push the same branch before stopping.", "Do not open a new PR.", "Do not stop with only local commits or uncommitted changes.", "");
+}
+function buildPromptHeader(issue) {
+    return [
         `Issue: ${issue.issueKey ?? issue.linearIssueId}`,
         issue.title ? `Title: ${issue.title}` : undefined,
         issue.branchName ? `Branch: ${issue.branchName}` : undefined,
         issue.prNumber ? `PR: #${issue.prNumber}` : undefined,
         "",
     ].filter(Boolean);
+}
+function appendTaskObjective(lines, issue) {
+    const description = issue.description?.trim();
+    lines.push("## Task Objective", "");
+    lines.push(issue.title || `Complete ${issue.issueKey ?? issue.linearIssueId}.`);
+    if (description) {
+        lines.push("", description);
+    }
+    lines.push("");
+}
+function appendLinearContext(lines, context) {
     const promptContext = typeof context?.promptContext === "string" ? context.promptContext.trim() : "";
     const latestPrompt = typeof context?.promptBody === "string" ? context.promptBody.trim() : "";
+    const operatorPrompt = typeof context?.operatorPrompt === "string" ? context.operatorPrompt.trim() : "";
+    const userComment = typeof context?.userComment === "string" ? context.userComment.trim() : "";
     if (promptContext) {
         lines.push("## Linear Session Context", "", promptContext, "");
     }
     if (latestPrompt) {
         lines.push("## Latest Human Instruction", "", latestPrompt, "");
     }
+    if (operatorPrompt) {
+        lines.push("## Operator Prompt", "", operatorPrompt, "");
+    }
+    if (userComment) {
+        lines.push("## Human Follow-up Comment", "", userComment, "");
+    }
+}
+function readReviewFixComments(context) {
+    const raw = context?.reviewComments;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const comments = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const body = typeof record.body === "string" ? record.body.trim() : "";
+        if (!body)
+            continue;
+        comments.push({
+            body,
+            ...(typeof record.path === "string" ? { path: record.path } : {}),
+            ...(typeof record.line === "number" ? { line: record.line } : {}),
+            ...(typeof record.side === "string" ? { side: record.side } : {}),
+            ...(typeof record.startLine === "number" ? { startLine: record.startLine } : {}),
+            ...(typeof record.startSide === "string" ? { startSide: record.startSide } : {}),
+            ...(typeof record.url === "string" ? { url: record.url } : {}),
+            ...(typeof record.authorLogin === "string" ? { authorLogin: record.authorLogin } : {}),
+        });
+    }
+    return comments;
+}
+function appendStructuredReviewContext(lines, context) {
+    const reviewId = typeof context?.reviewId === "number" ? context.reviewId : undefined;
+    const reviewCommitId = typeof context?.reviewCommitId === "string" ? context.reviewCommitId : undefined;
+    const reviewUrl = typeof context?.reviewUrl === "string" ? context.reviewUrl : undefined;
+    const reviewComments = readReviewFixComments(context);
+    if (!reviewId && !reviewCommitId && !reviewUrl && reviewComments.length === 0) {
+        return;
+    }
+    lines.push("## Structured Review Context", "");
+    if (reviewId !== undefined) {
+        lines.push(`Review ID: ${reviewId}`);
+    }
+    if (reviewCommitId) {
+        lines.push(`Reviewed commit: ${reviewCommitId}`);
+    }
+    if (reviewUrl) {
+        lines.push(`Review URL: ${reviewUrl}`);
+    }
+    if (reviewComments.length === 0) {
+        lines.push("No inline review comments were captured for this review.", "");
+        return;
+    }
+    lines.push(`Inline review comments captured: ${reviewComments.length}`, "Resolve each comment below or verify it is already fixed on the current head before you stop.", "");
+    for (const comment of reviewComments) {
+        const location = comment.path
+            ? `${comment.path}${comment.line !== undefined ? `:${comment.line}` : ""}${comment.side ? ` (${comment.side})` : ""}`
+            : "general";
+        lines.push(`- ${location}`);
+        lines.push(comment.body);
+        if (comment.url) {
+            lines.push(`  URL: ${comment.url}`);
+        }
+    }
+    lines.push("");
+}
+function collectFollowUpInputs(context) {
+    const followUps = Array.isArray(context?.followUps) ? context.followUps : [];
+    const inputs = [];
+    for (const entry of followUps) {
+        const followUp = entry && typeof entry === "object" ? entry : undefined;
+        const type = typeof followUp?.type === "string" ? followUp.type : "followup";
+        const author = typeof followUp?.author === "string" ? followUp.author : undefined;
+        const text = typeof followUp?.text === "string" ? followUp.text.trim() : "";
+        if (!text)
+            continue;
+        inputs.push({ type, text, ...(author ? { author } : {}) });
+    }
+    return inputs;
+}
+function resolveFollowUpWhy(runType, context) {
+    const wakeReason = typeof context?.wakeReason === "string" ? context.wakeReason : undefined;
+    switch (wakeReason) {
+        case "direct_reply":
+            return "A human reply arrived for the outstanding question from the previous turn.";
+        case "followup_prompt":
+            return "A new Linear agent prompt arrived after the previous turn.";
+        case "followup_comment":
+            return "A human follow-up comment arrived after the previous turn.";
+        case "operator_prompt":
+            return "An operator supplied new guidance for this issue.";
+        case "review_changes_requested":
+            return "GitHub review requested changes on the current PR head.";
+        case "settled_red_ci":
+            return "Required CI settled red for the current PR head.";
+        case "merge_steward_incident":
+            return "Merge Steward reported an incident on the current PR head.";
+        case "delegated":
+            return runType === "implementation"
+                ? "This is the first implementation turn for the delegated issue."
+                : `This turn continues ${runType.replaceAll("_", " ")} work for the delegated issue.`;
+        default:
+            if (runType === "review_fix")
+                return "This turn continues requested-changes work on the existing PR.";
+            if (runType === "ci_repair")
+                return "This turn continues CI repair work on the existing PR.";
+            if (runType === "queue_repair")
+                return "This turn continues merge-queue repair work on the existing PR.";
+            return "This turn continues implementation on the existing issue session.";
+    }
+}
+function resolveFollowUpAction(runType, context) {
+    if (context?.directReplyMode === true) {
+        return "Apply the latest human answer, continue from the current branch/session context, and only ask another question if you are still blocked.";
+    }
+    if (runType === "review_fix" && context?.branchUpkeepRequired === true) {
+        const baseBranch = typeof context.baseBranch === "string" ? context.baseBranch : "main";
+        return `Update the existing PR branch onto latest ${baseBranch}, resolve conflicts if needed, rerun narrow verification, and push the same branch.`;
+    }
+    switch (runType) {
+        case "review_fix":
+            return "Address the review feedback on the current PR branch, verify the fix, and push the same branch.";
+        case "ci_repair":
+            return "Fix the failing CI root cause on the current PR branch, verify it locally, and push the same branch.";
+        case "queue_repair":
+            return "Repair the merge-queue incident on the current PR branch, verify the fix, and push the same branch.";
+        case "implementation":
+        default:
+            return "Continue from the latest branch state, incorporate the new input, and publish updates to the existing issue branch if you make changes.";
+    }
+}
+function hasAuthoritativeGitHubFacts(issue, runType, context) {
+    return issue.prNumber !== undefined
+        || issue.prHeadSha !== undefined
+        || runType !== "implementation"
+        || typeof context?.failureHeadSha === "string"
+        || typeof context?.failingHeadSha === "string"
+        || typeof context?.mergeStateStatus === "string"
+        || typeof context?.checkName === "string"
+        || typeof context?.reviewerName === "string";
+}
+function appendAuthoritativeGitHubFacts(lines, issue, runType, context) {
+    if (!hasAuthoritativeGitHubFacts(issue, runType, context)) {
+        return;
+    }
+    const prNumber = issue.prNumber !== undefined ? `#${issue.prNumber}` : undefined;
+    const headSha = typeof context?.failureHeadSha === "string"
+        ? context.failureHeadSha
+        : typeof context?.failingHeadSha === "string"
+            ? context.failingHeadSha
+            : issue.prHeadSha;
+    const mergeStateStatus = typeof context?.mergeStateStatus === "string" ? context.mergeStateStatus : undefined;
+    const baseBranch = typeof context?.baseBranch === "string" ? context.baseBranch : undefined;
+    const checkName = typeof context?.checkName === "string" ? context.checkName : undefined;
+    const jobName = typeof context?.jobName === "string" ? context.jobName : undefined;
+    const stepName = typeof context?.stepName === "string" ? context.stepName : undefined;
+    const reviewerName = typeof context?.reviewerName === "string" ? context.reviewerName : undefined;
+    const reviewBody = typeof context?.reviewBody === "string" ? context.reviewBody.trim() : "";
+    const summary = typeof context?.summary === "string" ? context.summary : undefined;
+    lines.push("## Authoritative GitHub Facts", "");
+    if (prNumber) {
+        lines.push(`- Current PR: ${prNumber}`);
+    }
+    if (headSha) {
+        lines.push(`- Current relevant head SHA: ${headSha}`);
+    }
+    if (issue.prReviewState) {
+        lines.push(`- Current review state: ${issue.prReviewState}`);
+    }
+    if (issue.prCheckStatus) {
+        lines.push(`- Current check status: ${issue.prCheckStatus}`);
+    }
+    if (mergeStateStatus) {
+        lines.push(`- Merge state against ${baseBranch ?? "base"}: ${mergeStateStatus}`);
+    }
+    if (checkName) {
+        lines.push(`- Relevant check: ${checkName}`);
+    }
+    if (jobName && jobName !== checkName) {
+        lines.push(`- Relevant job: ${jobName}`);
+    }
+    if (stepName) {
+        lines.push(`- Relevant step: ${stepName}`);
+    }
+    if (reviewerName) {
+        lines.push(`- Reviewer: ${reviewerName}`);
+    }
+    if (summary) {
+        lines.push(`- Summary: ${summary}`);
+    }
+    if (reviewBody) {
+        lines.push(`- Review body: ${reviewBody}`);
+    }
+    lines.push("");
+}
+function appendFactFreshness(lines, issue, runType, context) {
+    if (!hasAuthoritativeGitHubFacts(issue, runType, context)) {
+        return;
+    }
+    const hasFreshFacts = context?.githubFactsFresh === true || context?.branchUpkeepRequired === true;
+    lines.push("## Fact Freshness", "");
+    if (hasFreshFacts) {
+        lines.push("GitHub facts below were refreshed immediately before this turn was created.");
+    }
+    else {
+        lines.push("GitHub facts below came from the triggering event or last known reconciliation state and may now be stale.");
+        lines.push("Verify the current PR head, review state, and check state in GitHub before making branch-mutating decisions.");
+    }
+    lines.push("");
+}
+function appendFollowUpPromptPrelude(lines, issue, runType, context) {
+    lines.push("## Follow-up Turn", "");
+    lines.push(`Why this turn exists: ${resolveFollowUpWhy(runType, context)}`);
+    lines.push(`Required action now: ${resolveFollowUpAction(runType, context)}`);
+    lines.push("");
+    appendLinearContext(lines, context);
+    const followUps = collectFollowUpInputs(context);
+    if (followUps.length > 0) {
+        lines.push("## What Changed Since The Last Turn", "");
+        for (const followUp of followUps) {
+            lines.push(`- ${followUp.type}${followUp.author ? ` from ${followUp.author}` : ""}: ${followUp.text}`);
+        }
+        lines.push("");
+    }
+    appendFactFreshness(lines, issue, runType, context);
+    appendAuthoritativeGitHubFacts(lines, issue, runType, context);
+}
+export function buildInitialRunPrompt(issue, runType, repoPath, context) {
+    const lines = buildPromptHeader(issue);
+    appendTaskObjective(lines, issue);
+    appendLinearContext(lines, context);
     // Add run-type-specific context for reactive runs
     switch (runType) {
         case "ci_repair": {
@@ -68,24 +391,85 @@ function buildRunPrompt(issue, runType, repoPath, context) {
             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)}` : "", "", "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.", "");
+            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. Start with the structured review context below. Treat the inline review comments as the primary repair checklist for this turn.", "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 on the current head, note why. If not, fix it.", "4. If the structured review context looks incomplete, inspect the latest GitHub review threads directly before deciding you are done.", "5. Run verification, commit and push.", "6. 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.", "");
+            appendStructuredReviewContext(lines, context);
             break;
         case "queue_repair":
             appendQueueRepairContext(lines, context);
             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.", "");
             break;
     }
-    // Append the repo's workflow file
     const workflowBody = readWorkflowFile(repoPath, runType);
     if (workflowBody) {
         lines.push(workflowBody);
     }
     else if (runType === "implementation") {
-        // Fallback if no workflow file exists
-        lines.push("Implement the Linear issue. Read the issue via MCP for details.", "Run verification before finishing. Commit, push, and open a PR.");
+        lines.push("Implement the Linear issue. Read the issue via MCP for details.");
     }
+    appendPublicationContract(lines, runType, issue, context);
     return lines.join("\n");
 }
+export function buildFollowUpRunPrompt(issue, runType, repoPath, context) {
+    const lines = buildPromptHeader(issue);
+    appendFollowUpPromptPrelude(lines, issue, runType, context);
+    // Add run-type-specific context for reactive runs
+    switch (runType) {
+        case "ci_repair": {
+            const snapshot = context?.ciSnapshot && typeof context.ciSnapshot === "object"
+                ? context.ciSnapshot
+                : undefined;
+            lines.push("## CI Repair", "", "A full CI iteration has settled failed on your PR. Start from the specific failing check/job/step below on the latest remote PR branch tip, fix that concrete failure first, then push to the same PR branch.", snapshot?.gateCheckName ? `Gate check: ${String(snapshot.gateCheckName)}` : "", snapshot?.gateCheckStatus ? `Gate status: ${String(snapshot.gateCheckStatus)}` : "", snapshot?.settledAt ? `Settled at: ${String(snapshot.settledAt)}` : "", context?.failureHeadSha ? `Failing head SHA: ${String(context.failureHeadSha)}` : "", context?.checkName ? `Failed check: ${String(context.checkName)}` : "", context?.jobName && context?.jobName !== context?.checkName ? `Failed job: ${String(context.jobName)}` : "", context?.stepName ? `Failed step: ${String(context.stepName)}` : "", context?.summary ? `Failure summary: ${String(context.summary)}` : "", Array.isArray(snapshot?.failedChecks) && snapshot.failedChecks.length > 0
+                ? `Other failed checks in the settled snapshot (context only; ignore unless the logs show the same root cause):\n${snapshot.failedChecks.map((entry) => `- ${String(entry.name ?? "unknown")}${entry.summary ? `: ${String(entry.summary)}` : ""}`).join("\n")}`
+                : "", context?.checkUrl ? `Check URL: ${String(context.checkUrl)}` : "", Array.isArray(context?.annotations) && context.annotations.length > 0
+                ? `Annotations:\n${context.annotations.map((entry) => `- ${String(entry)}`).join("\n")}`
+                : "", "", "Fetch the latest remote branch state first. If the branch moved since this failure, restart from the new tip instead of pushing older work.", "Read the latest logs for the named failing check, fix that root cause, and only broaden scope when the logs show direct fallout from the same issue.", "Do not change workflows, dependency installation, or unrelated tests unless the failing logs clearly point there.", "Run focused verification for the named failure, then commit and push.", "Do not open a new PR. Keep working on the existing branch until CI goes green or the situation is clearly stuck.", "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)}` : "", "", "Steps:", "1. Start with the structured review context below. Treat the inline review comments as the primary repair checklist for this turn.", "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 on the current head, note why. If not, fix it.", "4. If the structured review context looks incomplete, inspect the latest GitHub review threads directly before deciding you are done.", "5. Run verification, commit and push.", "6. 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.", "");
+            appendStructuredReviewContext(lines, context);
+            break;
+        case "queue_repair":
+            appendQueueRepairContext(lines, context);
+            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.", "");
+            break;
+    }
+    const workflowBody = readWorkflowFile(repoPath, runType);
+    if (workflowBody) {
+        lines.push(workflowBody);
+    }
+    else if (runType === "implementation") {
+        lines.push("Implement the Linear issue. Read the issue via MCP for details.");
+    }
+    appendPublicationContract(lines, runType, issue, context);
+    return lines.join("\n");
+}
+function shouldBuildFollowUpPrompt(runType, context) {
+    if (context?.followUpMode)
+        return true;
+    if (runType !== "implementation")
+        return true;
+    const wakeReason = typeof context?.wakeReason === "string" ? context.wakeReason : undefined;
+    return Boolean(wakeReason && wakeReason !== "delegated");
+}
+export function buildRunPrompt(issue, runType, repoPath, context) {
+    if (shouldBuildFollowUpPrompt(runType, context)) {
+        return buildFollowUpRunPrompt(issue, runType, repoPath, context);
+    }
+    return buildInitialRunPrompt(issue, runType, repoPath, context);
+}
+function shouldCompactThread(issue, threadGeneration, context) {
+    const followUpCount = typeof context?.followUpCount === "number" ? context.followUpCount : 0;
+    return issue.threadId !== undefined
+        && (threadGeneration ?? 0) >= MAX_THREAD_GENERATION_BEFORE_COMPACTION
+        && followUpCount >= MAX_FOLLOW_UPS_BEFORE_COMPACTION;
+}
+export function shouldReuseIssueThread(params) {
+    return Boolean(params.existingThreadId) && !params.compactThread && params.resumeThread;
+}
+function isBranchUpkeepRequired(context) {
+    return context?.branchUpkeepRequired === true;
+}
 export class RunOrchestrator {
     config;
     db;
@@ -100,6 +484,8 @@ export class RunOrchestrator {
     idleReconciler;
     linearSync;
     activeThreadId;
+    workerId = `patchrelay:${process.pid}`;
+    activeSessionLeases = new Map();
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
         this.config = config;
@@ -112,28 +498,103 @@ export class RunOrchestrator {
         this.worktreeManager = new WorktreeManager(config);
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
         this.idleReconciler = new IdleIssueReconciler(db, config, {
-            requestMergeQueueAdmission: (issue, projectId) => this.requestMergeQueueAdmission(issue, projectId),
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
         }, logger, feed);
         this.queueHealthMonitor = new QueueHealthMonitor(db, config, {
             advanceIdleIssue: (issue, newState, options) => this.idleReconciler.advanceIdleIssue(issue, newState, options),
+            enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
         }, logger, feed);
     }
+    resolveRunWake(issue) {
+        const sessionWake = this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+        if (sessionWake) {
+            return {
+                runType: sessionWake.runType,
+                context: sessionWake.context,
+                wakeReason: sessionWake.wakeReason,
+                resumeThread: sessionWake.resumeThread,
+                eventIds: sessionWake.eventIds,
+            };
+        }
+        return undefined;
+    }
+    appendWakeEventWithLease(lease, issue, runType, context, dedupeScope) {
+        let eventType;
+        let dedupeKey;
+        if (runType === "queue_repair") {
+            eventType = "merge_steward_incident";
+            dedupeKey = `${dedupeScope ?? "wake"}:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`;
+        }
+        else if (runType === "ci_repair") {
+            eventType = "settled_red_ci";
+            dedupeKey = `${dedupeScope ?? "wake"}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`;
+        }
+        else if (runType === "review_fix") {
+            eventType = "review_changes_requested";
+            dedupeKey = `${dedupeScope ?? "wake"}:review_fix:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`;
+        }
+        else {
+            eventType = "delegated";
+            dedupeKey = `${dedupeScope ?? "wake"}:implementation:${issue.linearIssueId}`;
+        }
+        return Boolean(this.db.appendIssueSessionEventWithLease(lease, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType,
+            ...(context ? { eventJson: JSON.stringify(context) } : {}),
+            dedupeKey,
+        }));
+    }
+    materializeLegacyPendingWake(issue, lease) {
+        if (!issue.pendingRunType)
+            return issue;
+        const context = issue.pendingRunContextJson
+            ? JSON.parse(issue.pendingRunContextJson)
+            : undefined;
+        this.appendWakeEventWithLease(lease, issue, issue.pendingRunType, context, "legacy_pending");
+        const updated = this.db.upsertIssueWithLease(lease, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            pendingRunType: null,
+            pendingRunContextJson: null,
+        });
+        if (!updated)
+            return issue;
+        return this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+    }
     // ─── Run ────────────────────────────────────────────────────────
     async run(item) {
         const project = this.config.projects.find((p) => p.id === item.projectId);
         if (!project)
             return;
+        if (this.activeSessionLeases.has(this.issueSessionLeaseKey(item.projectId, item.issueId))) {
+            return;
+        }
         const issue = this.db.getIssue(item.projectId, item.issueId);
-        if (!issue?.pendingRunType || issue.activeRunId !== undefined)
+        if (!issue || issue.activeRunId !== undefined)
             return;
+        const issueSession = this.db.getIssueSession(item.projectId, item.issueId);
+        const leaseId = this.acquireIssueSessionLease(item.projectId, item.issueId);
+        if (!leaseId) {
+            this.logger.info({ issueKey: issue.issueKey, projectId: item.projectId }, "Skipped run because another worker holds the session lease");
+            return;
+        }
         if (issue.prState === "merged") {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingRunType: null, factoryState: "done" });
+            this.db.upsertIssueWithLease({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, leaseId }, { projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingRunType: null, factoryState: "done" });
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
             return;
         }
-        const runType = issue.pendingRunType;
-        const contextJson = issue.pendingRunContextJson;
-        const context = contextJson ? JSON.parse(contextJson) : undefined;
+        const wakeIssue = this.materializeLegacyPendingWake(issue, { projectId: item.projectId, linearIssueId: item.issueId, leaseId });
+        const wake = this.resolveRunWake(wakeIssue);
+        if (!wake) {
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
+            return;
+        }
+        const { runType, context, resumeThread } = wake;
+        const effectiveContext = runType === "review_fix"
+            ? await this.resolveReviewFixWakeContext(issue, context, project)
+            : context;
+        const isReviewFixBranchUpkeep = runType === "review_fix" && isBranchUpkeepRequired(effectiveContext);
         // Check repair budgets
         if (runType === "ci_repair" && issue.ciRepairAttempts >= DEFAULT_CI_REPAIR_BUDGET) {
             this.escalate(issue, runType, `CI repair budget exhausted (${DEFAULT_CI_REPAIR_BUDGET} attempts)`);
@@ -143,22 +604,34 @@ export class RunOrchestrator {
             this.escalate(issue, runType, `Queue repair budget exhausted (${DEFAULT_QUEUE_REPAIR_BUDGET} attempts)`);
             return;
         }
-        if (runType === "review_fix" && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+        if (runType === "review_fix" && !isReviewFixBranchUpkeep && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
             this.escalate(issue, runType, `Review fix budget exhausted (${DEFAULT_REVIEW_FIX_BUDGET} attempts)`);
             return;
         }
         // Increment repair counters
         if (runType === "ci_repair") {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, ciRepairAttempts: issue.ciRepairAttempts + 1 });
+            const updated = this.db.upsertIssueWithLease({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, leaseId }, { projectId: issue.projectId, linearIssueId: issue.linearIssueId, ciRepairAttempts: issue.ciRepairAttempts + 1 });
+            if (!updated) {
+                this.releaseIssueSessionLease(item.projectId, item.issueId);
+                return;
+            }
         }
         if (runType === "queue_repair") {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, queueRepairAttempts: issue.queueRepairAttempts + 1 });
+            const updated = this.db.upsertIssueWithLease({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, leaseId }, { projectId: issue.projectId, linearIssueId: issue.linearIssueId, queueRepairAttempts: issue.queueRepairAttempts + 1 });
+            if (!updated) {
+                this.releaseIssueSessionLease(item.projectId, item.issueId);
+                return;
+            }
         }
-        if (runType === "review_fix") {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, reviewFixAttempts: issue.reviewFixAttempts + 1 });
+        if (runType === "review_fix" && !isReviewFixBranchUpkeep) {
+            const updated = this.db.upsertIssueWithLease({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, leaseId }, { projectId: issue.projectId, linearIssueId: issue.linearIssueId, reviewFixAttempts: issue.reviewFixAttempts + 1 });
+            if (!updated) {
+                this.releaseIssueSessionLease(item.projectId, item.issueId);
+                return;
+            }
         }
         // Build prompt
-        const prompt = buildRunPrompt(issue, runType, project.repoPath, context);
+        const prompt = buildRunPrompt(issue, runType, project.repoPath, effectiveContext);
         // Resolve workspace
         const issueRef = sanitizePathSegment(issue.issueKey ?? issue.linearIssueId);
         const slug = issue.title ? slugify(issue.title) : "";
@@ -166,9 +639,13 @@ export class RunOrchestrator {
         const branchName = issue.branchName ?? `${project.branchPrefix}/${branchSuffix}`;
         const worktreePath = issue.worktreePath ?? `${project.worktreeRoot}/${issueRef}`;
         // Claim the run atomically
-        const run = this.db.transaction(() => {
+        const run = this.db.withIssueSessionLease(item.projectId, item.issueId, leaseId, () => {
             const fresh = this.db.getIssue(item.projectId, item.issueId);
-            if (!fresh?.pendingRunType || fresh.activeRunId !== undefined)
+            if (!fresh || fresh.activeRunId !== undefined)
+                return undefined;
+            const wakeIssue = this.materializeLegacyPendingWake(fresh, { projectId: item.projectId, linearIssueId: item.issueId, leaseId });
+            const freshWake = this.resolveRunWake(wakeIssue);
+            if (!freshWake || freshWake.runType !== runType)
                 return undefined;
             const created = this.db.createRun({
                 issueId: fresh.id,
@@ -177,10 +654,10 @@ export class RunOrchestrator {
                 runType,
                 promptText: prompt,
             });
-            const failureHeadSha = typeof context?.failureHeadSha === "string"
-                ? context.failureHeadSha
-                : typeof context?.headSha === "string" ? context.headSha : undefined;
-            const failureSignature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+            const failureHeadSha = typeof effectiveContext?.failureHeadSha === "string"
+                ? effectiveContext.failureHeadSha
+                : typeof effectiveContext?.headSha === "string" ? effectiveContext.headSha : undefined;
+            const failureSignature = typeof effectiveContext?.failureSignature === "string" ? effectiveContext.failureSignature : undefined;
             this.db.upsertIssue({
                 projectId: item.projectId,
                 linearIssueId: item.issueId,
@@ -201,11 +678,15 @@ export class RunOrchestrator {
                     }
                     : {}),
             });
-            this.db.setBranchOwner(item.projectId, item.issueId, "patchrelay");
+            this.db.consumeIssueSessionEvents(item.projectId, item.issueId, freshWake.eventIds, created.id);
+            this.db.setIssueSessionLastWakeReason(item.projectId, item.issueId, freshWake.wakeReason ?? null);
+            this.db.setBranchOwnerWithLease({ projectId: item.projectId, linearIssueId: item.issueId, leaseId }, "patchrelay");
             return created;
         });
-        if (!run)
+        if (!run) {
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
             return;
+        }
         this.feed?.publish({
             level: "info",
             kind: "stage",
@@ -217,6 +698,7 @@ export class RunOrchestrator {
         });
         let threadId;
         let turnId;
+        let parentThreadId;
         try {
             // Ensure worktree
             await this.worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, worktreePath, branchName, { allowExistingOutsideRoot: issue.branchName !== undefined });
@@ -232,6 +714,7 @@ export class RunOrchestrator {
                 const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=$(cat ${this.botIdentity.tokenFile})"; }; f`;
                 await execCommand(gitBin, ["-C", worktreePath, "config", "credential.helper", credentialHelper], { timeoutMs: 5_000 });
             }
+            await this.resetWorktreeToTrackedBranch(worktreePath, branchName, issue);
             // 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.
@@ -245,15 +728,24 @@ export class RunOrchestrator {
             if (prepareResult.ran && prepareResult.exitCode !== 0) {
                 throw new Error(`prepare-worktree hook failed (exit ${prepareResult.exitCode}): ${prepareResult.stderr?.slice(0, 500) ?? ""}`);
             }
-            // 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") {
+            this.assertLaunchLease(run, "before starting the Codex turn");
+            // Reuse the existing thread only for additive follow-ups that explicitly
+            // request continuity. Fresh review-fix runs now start a new thread so the
+            // model is not anchored to the implementation conversation that produced
+            // the rejected patch. If the thread has accumulated many resumptions and
+            // batched follow-ups, compact by starting a fresh main thread while
+            // keeping a parent link.
+            const compactThread = shouldCompactThread(issue, issueSession?.threadGeneration, effectiveContext);
+            if (compactThread && issue.threadId) {
+                parentThreadId = issue.threadId;
+            }
+            if (shouldReuseIssueThread({ existingThreadId: issue.threadId, compactThread, resumeThread })) {
                 threadId = issue.threadId;
             }
             else {
                 const thread = await this.codex.startThread({ cwd: worktreePath });
                 threadId = thread.id;
-                this.db.upsertIssue({ projectId: item.projectId, linearIssueId: item.issueId, threadId });
+                this.db.upsertIssueWithLease({ projectId: item.projectId, linearIssueId: item.issueId, leaseId }, { projectId: item.projectId, linearIssueId: item.issueId, threadId });
             }
             try {
                 const turn = await this.codex.startTurn({ threadId, cwd: worktreePath, input: prompt });
@@ -266,7 +758,7 @@ export class RunOrchestrator {
                     this.logger.info({ issueKey: issue.issueKey, staleThreadId: threadId }, "Thread is stale, retrying with fresh thread");
                     const thread = await this.codex.startThread({ cwd: worktreePath });
                     threadId = thread.id;
-                    this.db.upsertIssue({ projectId: item.projectId, linearIssueId: item.issueId, threadId });
+                    this.db.upsertIssueWithLease({ projectId: item.projectId, linearIssueId: item.issueId, leaseId }, { projectId: item.projectId, linearIssueId: item.issueId, threadId });
                     const turn = await this.codex.startTurn({ threadId, cwd: worktreePath, input: prompt });
                     turnId = turn.turnId;
                 }
@@ -274,26 +766,39 @@ export class RunOrchestrator {
                     throw turnError;
                 }
             }
+            this.assertLaunchLease(run, "after starting the Codex turn");
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            this.db.finishRun(run.id, { status: "failed", failureReason: message });
-            this.db.upsertIssue({
-                projectId: item.projectId,
-                linearIssueId: item.issueId,
-                activeRunId: null,
-                factoryState: "failed",
-            });
+            const lostLease = error instanceof Error && error.name === "IssueSessionLeaseLostError";
+            if (!lostLease) {
+                this.db.finishRunWithLease({ projectId: item.projectId, linearIssueId: item.issueId, leaseId }, run.id, {
+                    status: "failed",
+                    failureReason: message,
+                });
+                this.db.upsertIssueWithLease({ projectId: item.projectId, linearIssueId: item.issueId, leaseId }, {
+                    projectId: item.projectId,
+                    linearIssueId: item.issueId,
+                    activeRunId: null,
+                    factoryState: "failed",
+                });
+            }
             this.logger.error({ issueKey: issue.issueKey, runType, error: message }, `Failed to launch ${runType} run`);
             const failedIssue = this.db.getIssue(item.projectId, item.issueId) ?? issue;
             void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(runType, `Failed to start ${lowerCaseFirst(message)}`));
             void this.linearSync.syncSession(failedIssue, { activeRunType: runType });
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
             throw error;
         }
-        this.db.updateRunThread(run.id, { threadId, turnId });
+        this.assertLaunchLease(run, "before recording the active thread");
+        if (!this.db.updateRunThreadWithLease({ projectId: run.projectId, linearIssueId: run.linearIssueId, leaseId }, run.id, { threadId, turnId, ...(parentThreadId ? { parentThreadId } : {}) })) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping run thread update after losing issue-session lease");
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+            return;
+        }
         // Reset zombie recovery counter — this run started successfully
         if (issue.zombieRecoveryAttempts > 0) {
-            this.db.upsertIssue({
+            this.db.upsertIssueWithLease({ projectId: item.projectId, linearIssueId: item.issueId, leaseId }, {
                 projectId: item.projectId,
                 linearIssueId: item.issueId,
                 zombieRecoveryAttempts: 0,
@@ -357,6 +862,44 @@ export class RunOrchestrator {
         if (didStash)
             await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
     }
+    async resetWorktreeToTrackedBranch(worktreePath, branchName, issue) {
+        const gitBin = this.config.runner.gitBin;
+        const branchFetch = await execCommand(gitBin, ["-C", worktreePath, "fetch", "origin", branchName], { timeoutMs: 60_000 });
+        const hasRemoteBranch = branchFetch.exitCode === 0;
+        await execCommand(gitBin, ["-C", worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "merge", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "cherry-pick", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "am", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "reset", "--hard", "HEAD"], { timeoutMs: 30_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "clean", "-fd"], { timeoutMs: 30_000 });
+        const checkoutTarget = hasRemoteBranch ? `origin/${branchName}` : branchName;
+        const checkoutResult = await execCommand(gitBin, ["-C", worktreePath, "checkout", "-B", branchName, checkoutTarget], { timeoutMs: 30_000 });
+        if (checkoutResult.exitCode !== 0) {
+            throw new Error(`Failed to restore ${branchName} worktree state: ${checkoutResult.stderr?.slice(0, 300) ?? "git checkout failed"}`);
+        }
+        const resetTarget = hasRemoteBranch ? `origin/${branchName}` : "HEAD";
+        const resetResult = await execCommand(gitBin, ["-C", worktreePath, "reset", "--hard", resetTarget], { timeoutMs: 30_000 });
+        if (resetResult.exitCode !== 0) {
+            throw new Error(`Failed to reset ${branchName} worktree state: ${resetResult.stderr?.slice(0, 300) ?? "git reset failed"}`);
+        }
+        await execCommand(gitBin, ["-C", worktreePath, "clean", "-fd"], { timeoutMs: 30_000 });
+        this.logger.debug({ issueKey: issue.issueKey, branchName, hasRemoteBranch }, "Reset issue worktree to tracked branch state");
+    }
+    async restoreIdleWorktree(issue) {
+        if (!issue.worktreePath || !issue.branchName)
+            return;
+        try {
+            await this.resetWorktreeToTrackedBranch(issue.worktreePath, issue.branchName, issue);
+        }
+        catch (error) {
+            this.logger.warn({
+                issueKey: issue.issueKey,
+                branchName: issue.branchName,
+                worktreePath: issue.worktreePath,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to restore idle worktree after interrupted run");
+        }
+    }
     // ─── Notification handler ─────────────────────────────────────────
     async handleCodexNotification(notification) {
         // threadId is present on turn-level notifications but NOT on item-level ones.
@@ -374,6 +917,10 @@ export class RunOrchestrator {
         const run = this.db.getRunByThreadId(threadId);
         if (!run)
             return;
+        if (!this.heartbeatIssueSessionLease(run.projectId, run.linearIssueId)) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Ignoring Codex notification after losing issue-session lease");
+            return;
+        }
         const turnId = typeof notification.params.turnId === "string" ? notification.params.turnId : undefined;
         if (this.config.runner.codex.persistExtendedHistory) {
             this.db.saveThreadEvent({
@@ -402,18 +949,26 @@ export class RunOrchestrator {
         const completedTurnId = extractTurnId(notification.params);
         const status = resolveRunCompletionStatus(notification.params);
         if (status === "failed") {
-            this.db.finishRun(run.id, {
-                status: "failed",
-                threadId,
-                ...(completedTurnId ? { turnId: completedTurnId } : {}),
-                failureReason: "Codex reported the turn completed in a failed state",
-            });
-            this.db.upsertIssue({
-                projectId: run.projectId,
-                linearIssueId: run.linearIssueId,
-                activeRunId: null,
-                factoryState: "failed",
+            const updated = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (lease) => {
+                this.db.finishRunWithLease(lease, run.id, {
+                    status: "failed",
+                    threadId,
+                    ...(completedTurnId ? { turnId: completedTurnId } : {}),
+                    failureReason: "Codex reported the turn completed in a failed state",
+                });
+                this.db.upsertIssueWithLease(lease, {
+                    projectId: run.projectId,
+                    linearIssueId: run.linearIssueId,
+                    activeRunId: null,
+                    factoryState: "failed",
+                });
+                return true;
             });
+            if (!updated) {
+                this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping failed-turn cleanup after losing issue-session lease");
+                this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+                return;
+            }
             this.feed?.publish({
                 level: "error",
                 kind: "turn",
@@ -428,11 +983,12 @@ export class RunOrchestrator {
             void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
             this.linearSync.clearProgress(run.id);
             this.activeThreadId = undefined;
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
             return;
         }
         // Complete the run
         const trackedIssue = this.db.issueToTrackedIssue(issue);
-        const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
+        const report = buildStageReport({ ...run, status: "completed" }, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
         // Determine post-run state based on current PR metadata.
         const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
         const verifiedRepairError = await this.verifyReactiveRunAdvancedBranch(run, freshIssue);
@@ -453,10 +1009,32 @@ export class RunOrchestrator {
             void this.linearSync.syncSession(heldIssue, { activeRunType: run.runType });
             this.linearSync.clearProgress(run.id);
             this.activeThreadId = undefined;
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
             return;
         }
-        const postRunState = resolvePostRunState(freshIssue);
-        this.db.transaction(() => {
+        const publishedOutcomeError = await this.verifyPublishedRunOutcome(run, freshIssue);
+        if (publishedOutcomeError) {
+            this.failRunAndClear(run, publishedOutcomeError, "failed");
+            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "warn",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "publish_incomplete",
+                summary: publishedOutcomeError,
+            });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, publishedOutcomeError));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            this.activeThreadId = undefined;
+            return;
+        }
+        const refreshedIssue = await this.refreshIssueAfterReactivePublish(run, freshIssue);
+        const postRunFollowUp = await this.resolvePostRunFollowUp(run, refreshedIssue);
+        const postRunState = postRunFollowUp?.factoryState ?? resolveCompletedRunState(refreshedIssue, run);
+        const completed = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (lease) => {
             this.db.finishRun(run.id, {
                 status: "completed",
                 threadId,
@@ -468,9 +1046,10 @@ export class RunOrchestrator {
                 projectId: run.projectId,
                 linearIssueId: run.linearIssueId,
                 activeRunId: null,
-                ...(postRunState === "awaiting_queue" ? { queueLabelApplied: false } : {}),
                 ...(postRunState ? { factoryState: postRunState } : {}),
-                ...(postRunState === "awaiting_queue" || postRunState === "done"
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                ...(postRunFollowUp ? {} : (postRunState === "awaiting_queue" || postRunState === "done"
                     ? {
                         lastGitHubFailureSource: null,
                         lastGitHubFailureHeadSha: null,
@@ -483,15 +1062,31 @@ export class RunOrchestrator {
                         lastAttemptedFailureHeadSha: null,
                         lastAttemptedFailureSignature: null,
                     }
-                    : {}),
+                    : {})),
             });
-            if (postRunState === "awaiting_queue") {
-                this.db.setBranchOwner(run.projectId, run.linearIssueId, "merge_steward");
+            if (postRunFollowUp) {
+                return this.appendWakeEventWithLease(lease, issue, postRunFollowUp.pendingRunType, postRunFollowUp.context, "post_run");
             }
+            return true;
         });
-        // If we advanced to awaiting_queue, enqueue for merge prep
-        if (postRunState === "awaiting_queue") {
-            this.requestMergeQueueAdmission(issue, run.projectId);
+        if (!completed) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping completion writes after losing issue-session lease");
+            this.linearSync.clearProgress(run.id);
+            this.activeThreadId = undefined;
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        if (postRunFollowUp) {
+            this.feed?.publish({
+                level: "info",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: run.projectId,
+                stage: postRunFollowUp.factoryState,
+                status: "follow_up_queued",
+                summary: postRunFollowUp.summary,
+            });
+            this.enqueueIssue(run.projectId, run.linearIssueId);
         }
         this.feed?.publish({
             level: "info",
@@ -504,7 +1099,7 @@ export class RunOrchestrator {
             detail: summarizeCurrentThread(thread).latestAgentMessage,
         });
         // Emit Linear completion activity + plan
-        const updatedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        const updatedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
         const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
         void this.linearSync.emitActivity(updatedIssue, buildRunCompletedActivity({
             runType: run.runType,
@@ -515,6 +1110,7 @@ export class RunOrchestrator {
         void this.linearSync.syncSession(updatedIssue);
         this.linearSync.clearProgress(run.id);
         this.activeThreadId = undefined;
+        this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
     }
     // ─── Active status for query ──────────────────────────────────────
     async getActiveRunStatus(issueKey) {
@@ -543,6 +1139,44 @@ export class RunOrchestrator {
         // Advance issues stuck in pr_open whose stored PR metadata already
         // shows they should transition (e.g. approved PR, missed webhook).
         await this.idleReconciler.reconcile();
+        await this.reconcileMergedLinearCompletion();
+    }
+    async reconcileMergedLinearCompletion() {
+        for (const issue of this.db.listIssues()) {
+            if (issue.prState !== "merged")
+                continue;
+            if (issue.currentLinearStateType?.trim().toLowerCase() === "completed")
+                continue;
+            const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
+            if (!linear)
+                continue;
+            try {
+                const liveIssue = await linear.getIssue(issue.linearIssueId);
+                const targetState = resolvePreferredCompletedLinearState(liveIssue);
+                if (!targetState)
+                    continue;
+                const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+                if (normalizedCurrent === targetState.trim().toLowerCase()) {
+                    this.db.upsertIssue({
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+                    });
+                    continue;
+                }
+                const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+                this.db.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+                    ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+                });
+            }
+            catch (error) {
+                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged issue to a completed Linear state");
+            }
+        }
     }
     // advanceIdleIssue is now on IdleIssueReconciler — delegate for internal callers
     advanceIdleIssue(issue, newState, options) {
@@ -560,24 +1194,41 @@ export class RunOrchestrator {
             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,
+            const updated = this.withHeldIssueSessionLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                this.db.upsertIssueWithLease(lease, {
+                    projectId: fresh.projectId,
+                    linearIssueId: fresh.linearIssueId,
+                    factoryState: "done",
+                    zombieRecoveryAttempts: 0,
+                    lastZombieRecoveryAt: null,
+                });
+                return true;
             });
+            if (!updated) {
+                this.logger.warn({ issueKey: fresh.issueKey, reason }, "Skipping merged recovery completion after losing issue-session lease");
+                this.releaseIssueSessionLease(fresh.projectId, fresh.linearIssueId);
+                return;
+            }
             this.logger.info({ issueKey: fresh.issueKey, reason }, "Recovery: PR already merged — transitioning to done");
+            this.releaseIssueSessionLease(fresh.projectId, fresh.linearIssueId);
             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",
+            const updated = this.withHeldIssueSessionLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+                this.db.upsertIssueWithLease(lease, {
+                    projectId: fresh.projectId,
+                    linearIssueId: fresh.linearIssueId,
+                    factoryState: "escalated",
+                });
+                return true;
             });
+            if (!updated) {
+                this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Skipping recovery escalation after losing issue-session lease");
+                this.releaseIssueSessionLease(fresh.projectId, fresh.linearIssueId);
+                return;
+            }
             this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: budget exhausted — escalating");
             this.feed?.publish({
                 level: "error",
@@ -588,6 +1239,7 @@ export class RunOrchestrator {
                 status: "budget_exhausted",
                 summary: `${reason} recovery failed after ${DEFAULT_ZOMBIE_RECOVERY_BUDGET} attempts`,
             });
+            this.releaseIssueSessionLease(fresh.projectId, fresh.linearIssueId);
             return;
         }
         // Exponential backoff — skip if delay hasn't elapsed
@@ -600,14 +1252,22 @@ export class RunOrchestrator {
             }
         }
         // Re-enqueue with backoff tracking
-        this.db.upsertIssue({
-            projectId: fresh.projectId,
-            linearIssueId: fresh.linearIssueId,
-            pendingRunType: runType,
-            pendingRunContextJson: null,
-            zombieRecoveryAttempts: attempts,
-            lastZombieRecoveryAt: new Date().toISOString(),
+        const requeued = this.withHeldIssueSessionLease(fresh.projectId, fresh.linearIssueId, (lease) => {
+            this.db.upsertIssueWithLease(lease, {
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                zombieRecoveryAttempts: attempts,
+                lastZombieRecoveryAt: new Date().toISOString(),
+            });
+            return this.appendWakeEventWithLease(lease, fresh, runType, undefined, `recovery:${attempts}`);
         });
+        if (!requeued) {
+            this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Skipping recovery re-enqueue after losing issue-session lease");
+            this.releaseIssueSessionLease(fresh.projectId, fresh.linearIssueId);
+            return;
+        }
         this.enqueueIssue(fresh.projectId, fresh.linearIssueId);
         this.logger.info({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: re-enqueued with backoff");
     }
@@ -615,24 +1275,38 @@ export class RunOrchestrator {
         const issue = this.db.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
             return;
+        let recoveryLease = this.claimLeaseForReconciliation(run.projectId, run.linearIssueId);
+        if (recoveryLease === "skip" && await this.reclaimForeignRecoveryLeaseIfSafe(run, issue)) {
+            recoveryLease = true;
+        }
+        if (recoveryLease === "skip")
+            return;
+        const acquiredRecoveryLease = recoveryLease === true;
         // 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.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
                 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");
+            const releasedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            void this.linearSync.syncSession(releasedIssue, { activeRunType: run.runType });
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
             return;
         }
         // Zombie run: claimed in DB but Codex never started (no thread).
         if (!run.threadId) {
             this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
-            this.db.transaction(() => {
+            this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
                 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 });
             });
             this.recoverOrEscalate(issue, run.runType, "zombie");
+            const recoveredIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, "The Codex turn never started before PatchRelay restarted."));
+            void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
             return;
         }
         // Read Codex state — thread may not exist after app-server restart.
@@ -642,11 +1316,15 @@ export class RunOrchestrator {
         }
         catch {
             this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
-            this.db.transaction(() => {
+            this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
                 this.db.finishRun(run.id, { status: "failed", failureReason: "Stale thread after restart" });
                 this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
             this.recoverOrEscalate(issue, run.runType, "stale_thread");
+            const recoveredIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, "PatchRelay lost the active Codex thread after restart and needs to recover."));
+            void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
             return;
         }
         // Check Linear state (non-fatal — token refresh may fail)
@@ -656,7 +1334,7 @@ export class RunOrchestrator {
             if (linearIssue) {
                 const stopState = resolveAuthoritativeLinearStopState(linearIssue);
                 if (stopState?.isFinal) {
-                    this.db.transaction(() => {
+                    this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
                         this.db.finishRun(run.id, { status: "released" });
                         this.db.upsertIssue({
                             projectId: run.projectId,
@@ -675,28 +1353,60 @@ export class RunOrchestrator {
                         status: "reconciled",
                         summary: `Linear state ${stopState.stateName} \u2192 done`,
                     });
+                    const doneIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+                    void this.linearSync.syncSession(doneIssue, { activeRunType: run.runType });
+                    this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
                     return;
                 }
             }
         }
-        const latestTurn = thread.turns.at(-1);
+        const latestTurn = getThreadTurns(thread).at(-1);
         // Handle interrupted turn — fail the run rather than retrying indefinitely.
         // The agent may have partially completed work (commits, PR) before interruption.
         // Reactive loops (CI repair, review fix) will handle follow-up if needed.
         if (latestTurn?.status === "interrupted") {
             this.logger.warn({ issueKey: issue.issueKey, runType: run.runType, threadId: run.threadId }, "Run has interrupted turn — marking as failed");
             // Interrupted runs are not real failures — undo the budget increment.
-            if (run.runType === "ci_repair" && issue.ciRepairAttempts > 0) {
-                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, ciRepairAttempts: issue.ciRepairAttempts - 1 });
-            }
-            else if (run.runType === "queue_repair" && issue.queueRepairAttempts > 0) {
-                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, queueRepairAttempts: issue.queueRepairAttempts - 1 });
-            }
-            else if (run.runType === "review_fix" && issue.reviewFixAttempts > 0) {
-                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, reviewFixAttempts: issue.reviewFixAttempts - 1 });
+            const repairedCounters = this.withHeldIssueSessionLease(issue.projectId, issue.linearIssueId, (lease) => {
+                if (run.runType === "ci_repair" && issue.ciRepairAttempts > 0) {
+                    this.db.upsertIssueWithLease(lease, {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        ciRepairAttempts: issue.ciRepairAttempts - 1,
+                    });
+                }
+                else if (run.runType === "queue_repair" && issue.queueRepairAttempts > 0) {
+                    this.db.upsertIssueWithLease(lease, {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        queueRepairAttempts: issue.queueRepairAttempts - 1,
+                    });
+                }
+                else if (run.runType === "review_fix" && issue.reviewFixAttempts > 0) {
+                    this.db.upsertIssueWithLease(lease, {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        reviewFixAttempts: issue.reviewFixAttempts - 1,
+                    });
+                }
+                if (run.runType === "ci_repair" || run.runType === "queue_repair") {
+                    this.db.upsertIssueWithLease(lease, {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
+                    });
+                }
+                return true;
+            });
+            if (!repairedCounters) {
+                this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping interrupted-run recovery after losing issue-session lease");
+                this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+                return;
             }
             const recoveredState = resolveRecoverablePostRunState(this.db.getIssue(run.projectId, run.linearIssueId) ?? issue);
             this.failRunAndClear(run, "Codex turn was interrupted", recoveredState);
+            await this.restoreIdleWorktree(issue);
             const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
             if (recoveredState) {
                 this.feed?.publish({
@@ -713,12 +1423,13 @@ export class RunOrchestrator {
                 void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, "The Codex turn was interrupted."));
             }
             void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
             return;
         }
         // Handle completed turn discovered during reconciliation
         if (latestTurn?.status === "completed") {
             const trackedIssue = this.db.issueToTrackedIssue(issue);
-            const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
+            const report = buildStageReport({ ...run, status: "completed" }, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
             const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
             const verifiedRepairError = await this.verifyReactiveRunAdvancedBranch(run, freshIssue);
             if (verifiedRepairError) {
@@ -733,10 +1444,34 @@ export class RunOrchestrator {
                     status: "branch_not_advanced",
                     summary: verifiedRepairError,
                 });
+                const heldIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+                void this.linearSync.emitActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
+                void this.linearSync.syncSession(heldIssue, { activeRunType: run.runType });
+                this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+                return;
+            }
+            const publishedOutcomeError = await this.verifyPublishedRunOutcome(run, freshIssue);
+            if (publishedOutcomeError) {
+                this.failRunAndClear(run, publishedOutcomeError, "failed");
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "turn",
+                    issueKey: issue.issueKey,
+                    projectId: run.projectId,
+                    stage: run.runType,
+                    status: "publish_incomplete",
+                    summary: publishedOutcomeError,
+                });
+                const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+                void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, publishedOutcomeError));
+                void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+                this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
                 return;
             }
-            const postRunState = resolvePostRunState(freshIssue);
-            this.db.transaction(() => {
+            const refreshedIssue = await this.refreshIssueAfterReactivePublish(run, freshIssue);
+            const postRunFollowUp = await this.resolvePostRunFollowUp(run, refreshedIssue);
+            const postRunState = postRunFollowUp?.factoryState ?? resolveCompletedRunState(refreshedIssue, run);
+            const reconciled = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (lease) => {
                 this.db.finishRun(run.id, {
                     status: "completed",
                     ...(run.threadId ? { threadId: run.threadId } : {}),
@@ -748,9 +1483,10 @@ export class RunOrchestrator {
                     projectId: run.projectId,
                     linearIssueId: run.linearIssueId,
                     activeRunId: null,
-                    ...(postRunState === "awaiting_queue" ? { queueLabelApplied: false } : {}),
                     ...(postRunState ? { factoryState: postRunState } : {}),
-                    ...(postRunState === "awaiting_queue" || postRunState === "done"
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                    ...(postRunFollowUp ? {} : (postRunState === "awaiting_queue" || postRunState === "done"
                         ? {
                             lastGitHubFailureSource: null,
                             lastGitHubFailureHeadSha: null,
@@ -763,12 +1499,30 @@ export class RunOrchestrator {
                             lastAttemptedFailureHeadSha: null,
                             lastAttemptedFailureSignature: null,
                         }
-                        : {}),
+                        : {})),
                 });
-                if (postRunState === "awaiting_queue") {
-                    this.db.setBranchOwner(run.projectId, run.linearIssueId, "merge_steward");
+                if (postRunFollowUp) {
+                    return this.appendWakeEventWithLease(lease, issue, postRunFollowUp.pendingRunType, postRunFollowUp.context, "post_run");
                 }
+                return true;
             });
+            if (!reconciled) {
+                this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping reconciled completion writes after losing issue-session lease");
+                this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+                return;
+            }
+            if (postRunFollowUp) {
+                this.feed?.publish({
+                    level: "info",
+                    kind: "stage",
+                    issueKey: issue.issueKey,
+                    projectId: run.projectId,
+                    stage: postRunFollowUp.factoryState,
+                    status: "follow_up_queued",
+                    summary: postRunFollowUp.summary,
+                });
+                this.enqueueIssue(run.projectId, run.linearIssueId);
+            }
             if (postRunState) {
                 this.feed?.publish({
                     level: "info",
@@ -780,25 +1534,43 @@ export class RunOrchestrator {
                     summary: `Reconciliation: ${run.runType} completed \u2192 ${postRunState}`,
                 });
             }
-            if (postRunState === "awaiting_queue") {
-                this.requestMergeQueueAdmission(issue, run.projectId);
-            }
+            const updatedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+            const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
+            void this.linearSync.emitActivity(updatedIssue, buildRunCompletedActivity({
+                runType: run.runType,
+                completionSummary,
+                postRunState: updatedIssue.factoryState,
+                ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
+            }));
+            void this.linearSync.syncSession(updatedIssue);
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+            return;
         }
+        if (acquiredRecoveryLease)
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
     }
     // ─── 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",
+        const escalated = this.withHeldIssueSessionLease(issue.projectId, issue.linearIssueId, (lease) => {
+            if (issue.activeRunId) {
+                this.db.finishRunWithLease(lease, issue.activeRunId, { status: "released" });
+            }
+            this.db.upsertIssueWithLease(lease, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                activeRunId: null,
+                factoryState: "escalated",
+            });
+            return true;
         });
+        if (!escalated) {
+            this.logger.warn({ issueKey: issue.issueKey, runType }, "Skipping escalation write after losing issue-session lease");
+            this.releaseIssueSessionLease(issue.projectId, issue.linearIssueId);
+            return;
+        }
         this.feed?.publish({
             level: "error",
             kind: "workflow",
@@ -814,23 +1586,10 @@ export class RunOrchestrator {
             body: `PatchRelay needs human help to continue.\n\n${reason}`,
         });
         void this.linearSync.syncSession(escalatedIssue);
-    }
-    /** Add the merge queue admission label for external-queue projects (best-effort). */
-    async requestMergeQueueAdmission(issue, projectId) {
-        const project = this.config.projects.find((p) => p.id === projectId);
-        const protocol = resolveMergeQueueProtocol(project);
-        const applied = await requestMergeQueueAdmission({
-            issue,
-            protocol,
-            logger: this.logger,
-            feed: this.feed,
-        });
-        if (applied) {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, queueLabelApplied: true });
-        }
+        this.releaseIssueSessionLease(issue.projectId, issue.linearIssueId);
     }
     failRunAndClear(run, message, nextState = "failed") {
-        this.db.transaction(() => {
+        const updated = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, () => {
             this.db.finishRun(run.id, { status: "failed", failureReason: message });
             this.db.upsertIssue({
                 projectId: run.projectId,
@@ -840,9 +1599,17 @@ export class RunOrchestrator {
             });
             const branchOwner = this.resolveBranchOwnerForStateTransition(nextState);
             if (branchOwner) {
-                this.db.setBranchOwner(run.projectId, run.linearIssueId, branchOwner);
+                const lease = this.getHeldIssueSessionLease(run.projectId, run.linearIssueId);
+                if (lease) {
+                    this.db.setBranchOwnerWithLease(lease, branchOwner);
+                }
             }
+            return true;
         });
+        if (!updated) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping failure cleanup after losing issue-session lease");
+        }
+        this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
     }
     resolveBranchOwnerForStateTransition(newState, pendingRunType) {
         return resolveBranchOwnerForStateTransition(newState, pendingRunType);
@@ -859,15 +1626,8 @@ export class RunOrchestrator {
             return undefined;
         }
         try {
-            const { stdout, exitCode } = await execCommand("gh", [
-                "pr", "view", String(issue.prNumber),
-                "--repo", project.github.repoFullName,
-                "--json", "headRefOid,state",
-            ], { timeoutMs: 10_000 });
-            if (exitCode !== 0)
-                return undefined;
-            const pr = JSON.parse(stdout);
-            if (pr.state?.toUpperCase() !== "OPEN")
+            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
+            if (!pr || pr.state?.toUpperCase() !== "OPEN")
                 return undefined;
             if (!pr.headRefOid || pr.headRefOid !== issue.lastGitHubFailureHeadSha)
                 return undefined;
@@ -882,6 +1642,271 @@ export class RunOrchestrator {
             return undefined;
         }
     }
+    async refreshIssueAfterReactivePublish(run, issue) {
+        if (run.runType !== "ci_repair" && run.runType !== "queue_repair") {
+            return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        if (!issue.prNumber) {
+            return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        if (!repoFullName) {
+            return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr) {
+                return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            }
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            const gateCheckName = project?.gateChecks?.find((entry) => entry.trim())?.trim() ?? "verify";
+            const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== issue.lastGitHubFailureHeadSha);
+            this.upsertIssueIfLeaseHeld(run.projectId, run.linearIssueId, {
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+                ...(headAdvanced
+                    ? {
+                        prCheckStatus: "pending",
+                        lastGitHubFailureSource: null,
+                        lastGitHubFailureHeadSha: null,
+                        lastGitHubFailureSignature: null,
+                        lastGitHubFailureCheckName: null,
+                        lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureContextJson: null,
+                        lastGitHubFailureAt: null,
+                        lastQueueIncidentJson: null,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
+                        lastGitHubCiSnapshotHeadSha: pr.headRefOid ?? null,
+                        lastGitHubCiSnapshotGateCheckName: gateCheckName,
+                        lastGitHubCiSnapshotGateCheckStatus: "pending",
+                        lastGitHubCiSnapshotJson: null,
+                        lastGitHubCiSnapshotSettledAt: null,
+                    }
+                    : {}),
+            }, "reactive publish refresh");
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to refresh PR state after reactive publish");
+        }
+        return this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+    }
+    async loadRemotePrState(repoFullName, prNumber) {
+        const { stdout, exitCode } = await execCommand("gh", [
+            "pr", "view", String(prNumber),
+            "--repo", repoFullName,
+            "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
+        ], { timeoutMs: 10_000 });
+        if (exitCode !== 0)
+            return undefined;
+        return JSON.parse(stdout);
+    }
+    async resolveReviewFixWakeContext(issue, context, project) {
+        if (isBranchUpkeepRequired(context)) {
+            return context;
+        }
+        if (!issue.prNumber || issue.prState !== "open" || issue.prReviewState !== "changes_requested") {
+            return context;
+        }
+        const repoFullName = project.github?.repoFullName;
+        if (!repoFullName) {
+            return context;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr)
+                return context;
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+            }, "review-fix wake refresh");
+            if (nextPrState !== "open")
+                return context;
+            if (nextReviewState && nextReviewState !== "changes_requested")
+                return context;
+            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+                return context;
+            return buildReviewFixBranchUpkeepContext(issue.prNumber, project.github?.baseBranch ?? "main", pr, context);
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to resolve review-fix wake context");
+            return context;
+        }
+    }
+    async resolvePostRunFollowUp(run, issue, projectOverride) {
+        if (run.runType !== "review_fix") {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open") {
+            return undefined;
+        }
+        if (issue.prReviewState !== "changes_requested") {
+            return undefined;
+        }
+        const project = projectOverride ?? this.config.projects.find((entry) => entry.id === run.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        if (!repoFullName) {
+            return undefined;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr)
+                return undefined;
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+            }, "post-run follow-up refresh");
+            if (nextPrState !== "open")
+                return undefined;
+            if (nextReviewState && nextReviewState !== "changes_requested")
+                return undefined;
+            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+                return undefined;
+            return {
+                pendingRunType: "review_fix",
+                factoryState: "changes_requested",
+                context: buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr),
+                summary: `PR #${issue.prNumber} is still dirty after review fix; queued branch upkeep`,
+            };
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to resolve post-run PR upkeep");
+            return undefined;
+        }
+    }
+    async verifyPublishedRunOutcome(run, issue, projectOverride) {
+        if (run.runType !== "implementation") {
+            return undefined;
+        }
+        const project = projectOverride ?? this.config.projects.find((entry) => entry.id === run.projectId);
+        const baseBranch = project?.github?.baseBranch ?? "main";
+        const deliveryMode = resolveImplementationDeliveryMode(issue, undefined, run.promptText);
+        if (deliveryMode === "linear_only") {
+            if (issue.prNumber !== undefined) {
+                return `Planning-only implementation should not open a PR, but PR #${issue.prNumber} was observed`;
+            }
+            return this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
+        }
+        if (issue.prNumber && issue.prState && issue.prState !== "closed") {
+            return undefined;
+        }
+        if (project?.github?.repoFullName && issue.branchName) {
+            try {
+                const { stdout, exitCode } = await execCommand("gh", [
+                    "pr",
+                    "list",
+                    "--repo",
+                    project.github.repoFullName,
+                    "--head",
+                    issue.branchName,
+                    "--state",
+                    "all",
+                    "--json",
+                    "number,url,state,author,headRefOid",
+                ], { timeoutMs: 10_000 });
+                if (exitCode === 0) {
+                    const matches = JSON.parse(stdout);
+                    const pr = matches[0];
+                    if (pr?.number) {
+                        this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                            projectId: issue.projectId,
+                            linearIssueId: issue.linearIssueId,
+                            prNumber: pr.number,
+                            ...(pr.url ? { prUrl: pr.url } : {}),
+                            ...(pr.state ? { prState: pr.state.toLowerCase() } : {}),
+                            ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                            ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
+                        }, "published PR verification refresh");
+                        return undefined;
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.debug({
+                    issueKey: issue.issueKey,
+                    branchName: issue.branchName,
+                    repoFullName: project.github.repoFullName,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Failed to verify published PR state after implementation");
+            }
+        }
+        const details = await this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
+        return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
+    }
+    async describeLocalImplementationOutcome(issue, baseBranch, deliveryMode = "publish_pr") {
+        if (!issue.worktreePath) {
+            return undefined;
+        }
+        try {
+            const status = await execCommand(this.config.runner.gitBin, [
+                "-C",
+                issue.worktreePath,
+                "status",
+                "--short",
+            ], { timeoutMs: 10_000 });
+            const dirtyEntries = status.exitCode === 0
+                ? status.stdout.split("\n").map((line) => line.trim()).filter(Boolean)
+                : [];
+            if (dirtyEntries.length > 0) {
+                if (deliveryMode === "linear_only") {
+                    return `Planning-only implementation should not modify the repo; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
+                }
+                return `Implementation completed without opening a PR; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
+            }
+        }
+        catch {
+            // Best effort only.
+        }
+        try {
+            const ahead = await execCommand(this.config.runner.gitBin, [
+                "-C",
+                issue.worktreePath,
+                "rev-list",
+                "--count",
+                `origin/${baseBranch}..HEAD`,
+            ], { timeoutMs: 10_000 });
+            if (ahead.exitCode === 0) {
+                const count = Number(ahead.stdout.trim());
+                if (Number.isFinite(count) && count > 0) {
+                    if (deliveryMode === "linear_only") {
+                        return `Planning-only implementation should not create repo commits; worktree is ${count} local commit(s) ahead of origin/${baseBranch}`;
+                    }
+                    return `Implementation completed with ${count} local commit(s) ahead of origin/${baseBranch} but no PR was observed`;
+                }
+            }
+        }
+        catch {
+            // Best effort only.
+        }
+        return undefined;
+    }
     async readThreadWithRetry(threadId, maxRetries = 3) {
         for (let attempt = 0; attempt < maxRetries; attempt++) {
             try {
@@ -895,6 +1920,151 @@ export class RunOrchestrator {
         }
         throw new Error(`Failed to read thread ${threadId}`);
     }
+    issueSessionLeaseKey(projectId, linearIssueId) {
+        return `${projectId}:${linearIssueId}`;
+    }
+    getHeldIssueSessionLease(projectId, linearIssueId) {
+        const leaseId = this.activeSessionLeases.get(this.issueSessionLeaseKey(projectId, linearIssueId));
+        if (!leaseId)
+            return undefined;
+        return { projectId, linearIssueId, leaseId };
+    }
+    withHeldIssueSessionLease(projectId, linearIssueId, fn) {
+        const lease = this.getHeldIssueSessionLease(projectId, linearIssueId);
+        if (!lease)
+            return undefined;
+        return this.db.withIssueSessionLease(projectId, linearIssueId, lease.leaseId, () => fn(lease));
+    }
+    upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
+        const lease = this.getHeldIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            this.logger.warn({ projectId, linearIssueId, context }, "Skipping issue write without a held issue-session lease");
+            return undefined;
+        }
+        const updated = this.db.upsertIssueWithLease(lease, params);
+        if (!updated) {
+            this.logger.warn({ projectId, linearIssueId, context }, "Skipping issue write after losing issue-session lease");
+        }
+        return updated;
+    }
+    assertLaunchLease(run, phase) {
+        if (this.heartbeatIssueSessionLease(run.projectId, run.linearIssueId)) {
+            return;
+        }
+        const error = new Error(`Lost issue-session lease ${phase}`);
+        error.name = "IssueSessionLeaseLostError";
+        this.logger.warn({ runId: run.id, issueId: run.linearIssueId, phase }, "Aborting run launch after losing issue-session lease");
+        throw error;
+    }
+    acquireIssueSessionLease(projectId, linearIssueId) {
+        const leaseId = randomUUID();
+        const leasedUntil = new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString();
+        const acquired = this.db.acquireIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            workerId: this.workerId,
+            leasedUntil,
+        });
+        if (!acquired)
+            return undefined;
+        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
+        return leaseId;
+    }
+    forceAcquireIssueSessionLease(projectId, linearIssueId) {
+        const leaseId = randomUUID();
+        const leasedUntil = new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString();
+        const acquired = this.db.forceAcquireIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            workerId: this.workerId,
+            leasedUntil,
+        });
+        if (!acquired)
+            return undefined;
+        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
+        return leaseId;
+    }
+    claimLeaseForReconciliation(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        if (this.activeSessionLeases.has(key)) {
+            return "owned";
+        }
+        const session = this.db.getIssueSession(projectId, linearIssueId);
+        if (!session)
+            return "skip";
+        const leasedUntilMs = session.leasedUntil ? Date.parse(session.leasedUntil) : undefined;
+        if (leasedUntilMs !== undefined && Number.isFinite(leasedUntilMs) && leasedUntilMs > Date.now()) {
+            return "skip";
+        }
+        return this.acquireIssueSessionLease(projectId, linearIssueId) ? true : "skip";
+    }
+    async reclaimForeignRecoveryLeaseIfSafe(run, issue) {
+        const key = this.issueSessionLeaseKey(run.projectId, run.linearIssueId);
+        if (this.activeSessionLeases.has(key)) {
+            return false;
+        }
+        const session = this.db.getIssueSession(run.projectId, run.linearIssueId);
+        if (!session?.leaseId || !session.workerId || session.workerId === this.workerId) {
+            return false;
+        }
+        if (issue.activeRunId !== run.id) {
+            return false;
+        }
+        let safeToReclaim = !run.threadId;
+        if (!safeToReclaim && run.threadId) {
+            try {
+                const thread = await this.readThreadWithRetry(run.threadId, 1);
+                const latestTurn = getThreadTurns(thread).at(-1);
+                safeToReclaim = thread.status === "notLoaded"
+                    || latestTurn?.status === "interrupted"
+                    || latestTurn?.status === "completed";
+            }
+            catch {
+                safeToReclaim = true;
+            }
+        }
+        if (!safeToReclaim) {
+            return false;
+        }
+        const leaseId = this.forceAcquireIssueSessionLease(run.projectId, run.linearIssueId);
+        if (!leaseId) {
+            return false;
+        }
+        this.logger.info({
+            issueKey: issue.issueKey,
+            runId: run.id,
+            previousWorkerId: session.workerId,
+            previousLeaseId: session.leaseId,
+            reclaimedLeaseId: leaseId,
+        }, "Reclaimed foreign issue-session lease for active-run recovery");
+        return true;
+    }
+    heartbeatIssueSessionLease(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        const leaseId = this.activeSessionLeases.get(key) ?? this.db.getIssueSession(projectId, linearIssueId)?.leaseId;
+        if (!leaseId)
+            return false;
+        const renewed = this.db.renewIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            leasedUntil: new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString(),
+        });
+        if (renewed) {
+            this.activeSessionLeases.set(key, leaseId);
+            return true;
+        }
+        this.activeSessionLeases.delete(key);
+        return false;
+    }
+    releaseIssueSessionLease(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        const leaseId = this.activeSessionLeases.get(key);
+        this.db.releaseIssueSessionLease(projectId, linearIssueId, leaseId);
+        this.activeSessionLeases.delete(key);
+    }
 }
 /**
  * Determine post-run factory state from current PR metadata.
@@ -912,6 +2082,12 @@ function resolvePostRunState(issue) {
     }
     return undefined;
 }
+function resolveCompletedRunState(issue, run) {
+    if (run.runType === "implementation" && resolveImplementationDeliveryMode(issue, undefined, run.promptText) === "linear_only") {
+        return "done";
+    }
+    return resolvePostRunState(issue);
+}
 function resolveRecoverablePostRunState(issue) {
     if (!issue.prNumber) {
         return resolvePostRunState(issue);
@@ -919,18 +2095,59 @@ function resolveRecoverablePostRunState(issue) {
     if (issue.prState === "merged")
         return "done";
     if (issue.prState === "open") {
-        if (issue.lastGitHubFailureSource === "queue_eviction")
-            return "repairing_queue";
-        if (issue.prCheckStatus === "failed" || issue.lastGitHubFailureSource === "branch_ci")
-            return "repairing_ci";
-        if (issue.prReviewState === "changes_requested")
-            return "changes_requested";
+        const reactiveIntent = deriveIssueSessionReactiveIntent({
+            prNumber: issue.prNumber,
+            prState: issue.prState,
+            prReviewState: issue.prReviewState,
+            prCheckStatus: issue.prCheckStatus,
+            latestFailureSource: issue.lastGitHubFailureSource,
+        });
+        if (reactiveIntent)
+            return reactiveIntent.compatibilityFactoryState;
         if (issue.prReviewState === "approved")
             return "awaiting_queue";
         return "pr_open";
     }
     return resolvePostRunState(issue);
 }
+function normalizeRemotePrState(value) {
+    const normalized = value?.trim().toUpperCase();
+    if (normalized === "OPEN")
+        return "open";
+    if (normalized === "CLOSED")
+        return "closed";
+    if (normalized === "MERGED")
+        return "merged";
+    return undefined;
+}
+function normalizeRemoteReviewDecision(value) {
+    const normalized = value?.trim().toUpperCase();
+    if (normalized === "APPROVED")
+        return "approved";
+    if (normalized === "CHANGES_REQUESTED")
+        return "changes_requested";
+    if (normalized === "REVIEW_REQUIRED")
+        return "commented";
+    return undefined;
+}
+function isDirtyMergeStateStatus(value) {
+    return value?.trim().toUpperCase() === "DIRTY";
+}
+function buildReviewFixBranchUpkeepContext(prNumber, baseBranch, pr, context) {
+    const promptContext = [
+        `The requested review change is already addressed, but GitHub still reports PR #${prNumber} as ${String(pr.mergeStateStatus)} against latest ${baseBranch}.`,
+        `Before stopping, update the existing PR branch onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push again.`,
+        "Do not stop just because the requested code change is already present.",
+    ].join(" ");
+    return {
+        ...(context ?? {}),
+        branchUpkeepRequired: true,
+        promptContext,
+        ...(pr.mergeStateStatus ? { mergeStateStatus: pr.mergeStateStatus } : {}),
+        ...(pr.headRefOid ? { failingHeadSha: pr.headRefOid } : {}),
+        baseBranch,
+    };
+}
 function appendQueueRepairContext(lines, context) {
     const incidentTitle = typeof context?.incidentTitle === "string" ? context.incidentTitle.trim() : "";
     const incidentSummary = typeof context?.incidentSummary === "string" ? context.incidentSummary.trim() : "";