patchrelay 0.30.0 → 0.31.0

package/dist/github-webhook-handler.js

@@ -1,4 +1,5 @@
 import { resolveFactoryStateFromGitHub, TERMINAL_STATES } from "./factory-state.js";
+import { createGitHubFailureContextResolver, summarizeGitHubFailureContext, } from "./github-failure-context.js";
 import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
@@ -28,7 +29,8 @@ export class GitHubWebhookHandler {
     logger;
     codex;
     feed;
-    constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed) {
+    failureContextResolver;
+    constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed, failureContextResolver = createGitHubFailureContextResolver()) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
@@ -36,6 +38,7 @@ export class GitHubWebhookHandler {
         this.logger = logger;
         this.codex = codex;
         this.feed = feed;
+        this.failureContextResolver = failureContextResolver;
     }
     async acceptGitHubWebhook(params) {
         // Deduplicate
@@ -114,6 +117,7 @@ export class GitHubWebhookHandler {
             this.logger.debug({ branchName: event.branchName, triggerEvent: event.triggerEvent }, "GitHub webhook: no matching issue for branch");
             return;
         }
+        const project = this.config.projects.find((p) => p.id === issue.projectId);
         // Update PR state on the issue
         this.db.upsertIssue({
             projectId: issue.projectId,
@@ -124,7 +128,7 @@ export class GitHubWebhookHandler {
             ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
             ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
         });
-        this.updateFailureProvenance(issue, event);
+        await this.updateFailureProvenance(issue, event, project);
         if (!isMetadataOnlyCheckEvent(event)) {
             // Re-read issue after PR metadata upsert so guards see fresh prReviewState
             const afterMetadata = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
@@ -168,10 +172,15 @@ export class GitHubWebhookHandler {
                 ciRepairAttempts: 0,
                 queueRepairAttempts: 0,
                 lastGitHubFailureSource: null,
+                lastGitHubFailureHeadSha: null,
+                lastGitHubFailureSignature: null,
                 lastGitHubFailureCheckName: null,
                 lastGitHubFailureCheckUrl: null,
+                lastGitHubFailureContextJson: null,
                 lastGitHubFailureAt: null,
                 lastQueueIncidentJson: null,
+                lastAttemptedFailureHeadSha: null,
+                lastAttemptedFailureSignature: null,
             });
         }
         this.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
@@ -188,16 +197,15 @@ export class GitHubWebhookHandler {
         // Queue eviction check runs bypass the metadata-only filter because
         // they're individual check_run events (not check_suite), but they
         // must drive state transitions.
-        const project = this.config.projects.find((p) => p.id === freshIssue.projectId);
         const protocol = resolveMergeQueueProtocol(project);
         if (event.eventSource === "check_run" && event.checkName === protocol.evictionCheckName) {
-            this.maybeEnqueueReactiveRun(freshIssue, event, project);
+            await this.maybeEnqueueReactiveRun(freshIssue, event, project);
         }
         else if (!isMetadataOnlyCheckEvent(event)) {
-            this.maybeEnqueueReactiveRun(freshIssue, event, project);
+            await this.maybeEnqueueReactiveRun(freshIssue, event, project);
         }
     }
-    maybeEnqueueReactiveRun(issue, event, project) {
+    async maybeEnqueueReactiveRun(issue, event, project) {
         // Don't trigger if there's already an active run
         if (issue.activeRunId !== undefined)
             return;
@@ -213,14 +221,24 @@ export class GitHubWebhookHandler {
             if (issue.factoryState === "awaiting_queue"
                 && event.checkName === queueCheckName) {
                 const queueRepairContext = buildQueueRepairContextFromEvent(event);
+                const failureContext = this.buildQueueFailureContext(issue, event, queueRepairContext);
+                if (this.hasDuplicatePendingReactiveRun(issue, "queue_repair", failureContext)) {
+                    return;
+                }
                 this.db.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     pendingRunType: "queue_repair",
-                    pendingRunContextJson: JSON.stringify(queueRepairContext),
+                    pendingRunContextJson: JSON.stringify({
+                        ...queueRepairContext,
+                        ...failureContext,
+                    }),
                     lastGitHubFailureSource: "queue_eviction",
+                    lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? null,
+                    lastGitHubFailureSignature: failureContext.failureSignature ?? null,
                     lastGitHubFailureCheckName: event.checkName ?? null,
                     lastGitHubFailureCheckUrl: event.checkUrl ?? null,
+                    lastGitHubFailureContextJson: JSON.stringify(failureContext),
                     lastGitHubFailureAt: new Date().toISOString(),
                     lastQueueSignalAt: new Date().toISOString(),
                     lastQueueIncidentJson: JSON.stringify(queueRepairContext),
@@ -239,23 +257,39 @@ export class GitHubWebhookHandler {
                 });
             }
             else {
+                const failureContext = await this.resolveBranchFailureContext(issue, event, project);
+                if (this.hasDuplicatePendingReactiveRun(issue, "ci_repair", failureContext)) {
+                    return;
+                }
                 this.db.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     pendingRunType: "ci_repair",
                     pendingRunContextJson: JSON.stringify({
-                        checkName: event.checkName,
-                        checkUrl: event.checkUrl,
-                        checkClass: resolveCheckClass(event.checkName, project),
+                        ...failureContext,
+                        checkClass: resolveCheckClass(failureContext.checkName ?? event.checkName, project),
                     }),
                     lastGitHubFailureSource: "branch_ci",
-                    lastGitHubFailureCheckName: event.checkName ?? null,
-                    lastGitHubFailureCheckUrl: event.checkUrl ?? null,
+                    lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? null,
+                    lastGitHubFailureSignature: failureContext.failureSignature ?? null,
+                    lastGitHubFailureCheckName: failureContext.checkName ?? event.checkName ?? null,
+                    lastGitHubFailureCheckUrl: failureContext.checkUrl ?? event.checkUrl ?? null,
+                    lastGitHubFailureContextJson: JSON.stringify(failureContext),
                     lastGitHubFailureAt: new Date().toISOString(),
                     lastQueueIncidentJson: null,
                 });
                 this.enqueueIssue(issue.projectId, issue.linearIssueId);
-                this.logger.info({ issueKey: issue.issueKey, checkName: event.checkName }, "Enqueued CI repair run");
+                this.logger.info({ issueKey: issue.issueKey, checkName: failureContext.checkName ?? event.checkName }, "Enqueued CI repair run");
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "repairing_ci",
+                    status: "ci_repair_queued",
+                    summary: `CI repair queued for ${failureContext.jobName ?? failureContext.checkName ?? "failed check"}`,
+                    detail: summarizeGitHubFailureContext(failureContext),
+                });
             }
         }
         if (event.triggerEvent === "review_changes_requested") {
@@ -272,23 +306,25 @@ export class GitHubWebhookHandler {
             this.logger.info({ issueKey: issue.issueKey, reviewerName: event.reviewerName }, "Enqueued review fix run");
         }
     }
-    updateFailureProvenance(issue, event) {
-        const project = this.config.projects.find((p) => p.id === issue.projectId);
+    async updateFailureProvenance(issue, event, project) {
         const protocol = resolveMergeQueueProtocol(project);
         const isQueueEvictionCheck = event.eventSource === "check_run" && event.checkName === protocol.evictionCheckName;
         if (event.triggerEvent === "check_failed" && issue.prState === "open") {
-            if (isMetadataOnlyCheckEvent(event) && !isQueueEvictionCheck) {
-                return;
-            }
             const source = issue.factoryState === "awaiting_queue" && isQueueEvictionCheck
                 ? "queue_eviction"
                 : "branch_ci";
+            const failureContext = source === "queue_eviction"
+                ? this.buildQueueFailureContext(issue, event)
+                : await this.resolveBranchFailureContext(issue, event, project);
             this.db.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastGitHubFailureSource: source,
-                lastGitHubFailureCheckName: event.checkName ?? null,
-                lastGitHubFailureCheckUrl: event.checkUrl ?? null,
+                lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? event.headSha ?? null,
+                lastGitHubFailureSignature: failureContext.failureSignature ?? null,
+                lastGitHubFailureCheckName: failureContext.checkName ?? event.checkName ?? null,
+                lastGitHubFailureCheckUrl: failureContext.checkUrl ?? event.checkUrl ?? null,
+                lastGitHubFailureContextJson: JSON.stringify(failureContext),
                 lastGitHubFailureAt: new Date().toISOString(),
                 ...(source === "queue_eviction"
                     ? {
@@ -308,12 +344,94 @@ export class GitHubWebhookHandler {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastGitHubFailureSource: null,
+                lastGitHubFailureHeadSha: null,
+                lastGitHubFailureSignature: null,
                 lastGitHubFailureCheckName: null,
                 lastGitHubFailureCheckUrl: null,
+                lastGitHubFailureContextJson: null,
                 lastGitHubFailureAt: null,
                 lastQueueIncidentJson: null,
+                lastAttemptedFailureHeadSha: null,
+                lastAttemptedFailureSignature: null,
+            });
+        }
+    }
+    async resolveBranchFailureContext(issue, event, project) {
+        const repoFullName = project?.github?.repoFullName ?? event.repoFullName;
+        const context = await this.failureContextResolver.resolve({
+            source: "branch_ci",
+            repoFullName,
+            event,
+        });
+        return {
+            ...(context ? context : {}),
+            ...(context?.headSha || event.headSha ? { failureHeadSha: context?.headSha ?? event.headSha } : {}),
+            ...(context?.failureSignature ? { failureSignature: context.failureSignature } : {}),
+        };
+    }
+    buildQueueFailureContext(issue, event, queueRepairContext) {
+        const repoFullName = event.repoFullName || this.config.projects.find((p) => p.id === issue.projectId)?.github?.repoFullName || "";
+        const incident = queueRepairContext && typeof queueRepairContext === "object"
+            ? queueRepairContext
+            : undefined;
+        const summary = typeof incident?.incidentSummary === "string"
+            ? incident.incidentSummary
+            : event.checkOutputSummary ?? event.checkOutputTitle;
+        const failureHeadSha = event.headSha;
+        const failureSignature = [
+            "queue_eviction",
+            failureHeadSha ?? "unknown-sha",
+            event.checkName ?? "merge-steward/queue",
+        ].join("::");
+        return {
+            source: "queue_eviction",
+            repoFullName,
+            capturedAt: new Date().toISOString(),
+            ...(failureHeadSha ? { headSha: failureHeadSha, failureHeadSha } : {}),
+            ...(event.checkName ? { checkName: event.checkName } : {}),
+            ...(event.checkUrl ? { checkUrl: event.checkUrl } : {}),
+            ...(event.checkDetailsUrl ? { checkDetailsUrl: event.checkDetailsUrl } : {}),
+            ...(summary ? { summary } : {}),
+            failureSignature,
+        };
+    }
+    hasDuplicatePendingReactiveRun(issue, runType, failureContext) {
+        const signature = typeof failureContext.failureSignature === "string" ? failureContext.failureSignature : undefined;
+        const headSha = typeof failureContext.failureHeadSha === "string"
+            ? failureContext.failureHeadSha
+            : typeof failureContext.headSha === "string" ? failureContext.headSha : undefined;
+        if (!signature)
+            return false;
+        if (issue.pendingRunType === runType && issue.pendingRunContextJson) {
+            const existing = safeJsonParse(issue.pendingRunContextJson);
+            if (existing?.failureSignature === signature
+                && (headSha === undefined || existing.failureHeadSha === headSha || existing.headSha === headSha)) {
+                this.feed?.publish({
+                    level: "info",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: issue.factoryState,
+                    status: "repair_deduped",
+                    summary: `Skipped duplicate ${runType} for ${signature}`,
+                });
+                return true;
+            }
+        }
+        if (issue.lastAttemptedFailureSignature === signature
+            && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha)) {
+            this.feed?.publish({
+                level: "info",
+                kind: "github",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: issue.factoryState,
+                status: "repair_deduped",
+                summary: `Already attempted ${runType} for this failing PR head`,
             });
+            return true;
         }
+        return false;
     }
     async emitLinearActivity(issue, newState, event) {
         if (!issue.agentSessionId)
@@ -421,9 +539,9 @@ export class GitHubWebhookHandler {
 function resolveCheckClass(checkName, project) {
     if (!checkName || !project)
         return "code";
-    if (project.reviewChecks.some((name) => checkName.includes(name)))
+    if ((project.reviewChecks ?? []).some((name) => checkName.includes(name)))
         return "review";
-    if (project.gateChecks.some((name) => checkName.includes(name)))
+    if ((project.gateChecks ?? []).some((name) => checkName.includes(name)))
         return "gate";
     return "code";
 }

package/dist/issue-query-service.js

@@ -1,3 +1,4 @@
+import { parseGitHubFailureContext, summarizeGitHubFailureContext } from "./github-failure-context.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
@@ -149,6 +150,7 @@ export class IssueQueryService {
     buildQueueProtocol(projectId, issue) {
         const project = this.config.projects.find((entry) => entry.id === projectId);
         const protocol = resolveMergeQueueProtocol(project);
+        const failureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
         const queueIncident = issue.lastQueueIncidentJson
             ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
             : undefined;
@@ -159,8 +161,12 @@ export class IssueQueryService {
             evictionCheckName: protocol.evictionCheckName,
             prNumber: issue.prNumber ?? null,
             lastFailureSource: issue.lastGitHubFailureSource ?? null,
+            lastFailureHeadSha: issue.lastGitHubFailureHeadSha ?? failureContext?.headSha ?? null,
+            lastFailureSignature: issue.lastGitHubFailureSignature ?? failureContext?.failureSignature ?? null,
             lastFailureCheckName: issue.lastGitHubFailureCheckName ?? null,
             lastFailureCheckUrl: issue.lastGitHubFailureCheckUrl ?? null,
+            lastFailureStepName: failureContext?.stepName ?? null,
+            lastFailureSummary: summarizeGitHubFailureContext(failureContext) ?? null,
             lastFailureAt: issue.lastGitHubFailureAt ?? null,
             lastQueueSignalAt: issue.lastQueueSignalAt ?? null,
             lastIncidentId: queueIncident?.incidentId ?? null,

package/dist/linear-client.js

@@ -15,6 +15,7 @@ const LINEAR_ISSUE_SELECTION = `
   state {
     id
     name
+    type
   }
   labels {
     nodes {
@@ -317,6 +318,7 @@ export class LinearGraphqlClient {
             ...(issue.estimate != null ? { estimate: issue.estimate } : {}),
             ...(issue.state?.id ? { stateId: issue.state.id } : {}),
             ...(issue.state?.name ? { stateName: issue.state.name } : {}),
+            ...(issue.state?.type ? { stateType: issue.state.type } : {}),
             ...(issue.team?.id ? { teamId: issue.team.id } : {}),
             ...(issue.team?.key ? { teamKey: issue.team.key } : {}),
             ...(issue.delegate?.id ? { delegateId: issue.delegate.id } : {}),

package/dist/run-orchestrator.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { ACTIVE_RUN_STATES, TERMINAL_STATES } from "./factory-state.js";
+import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
@@ -57,7 +58,9 @@ function buildRunPrompt(issue, runType, repoPath, context) {
     // Add run-type-specific context for reactive runs
     switch (runType) {
         case "ci_repair":
-            lines.push("## CI Repair", "", "A CI check has failed on your PR. Fix the failure and push.", context?.checkName ? `Failed check: ${String(context.checkName)}` : "", context?.checkUrl ? `Check URL: ${String(context.checkUrl)}` : "", "", "Read the CI failure logs, fix the code issue, run verification, commit and push.", "Do not change test expectations unless the test is genuinely wrong.", "");
+            lines.push("## CI Repair", "", "A CI check has failed on your PR. Fix the failure and push.", 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)}` : "", 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")}`
+                : "", "", "Read the CI failure logs, fix the code issue, run verification, commit and push.", "Do not change test expectations unless the test is genuinely wrong.", "");
             break;
         case "review_fix":
             lines.push("## Review Changes Requested", "", "A reviewer has requested changes on your PR. Address the feedback and push.", context?.reviewerName ? `Reviewer: ${String(context.reviewerName)}` : "", context?.reviewBody ? `\n## Review comment\n\n${String(context.reviewBody)}` : "", "", "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.", "");
@@ -155,6 +158,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;
             this.db.upsertIssue({
                 projectId: item.projectId,
                 linearIssueId: item.issueId,
@@ -168,6 +175,12 @@ export class RunOrchestrator {
                         : runType === "review_fix" ? "changes_requested"
                             : runType === "queue_repair" ? "repairing_queue"
                                 : "implementing",
+                ...((runType === "ci_repair" || runType === "queue_repair") && failureSignature
+                    ? {
+                        lastAttemptedFailureSignature: failureSignature,
+                        lastAttemptedFailureHeadSha: failureHeadSha ?? null,
+                    }
+                    : {}),
             });
             return created;
         });
@@ -402,6 +415,26 @@ export class RunOrchestrator {
         const report = buildStageReport(run, 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);
+        if (verifiedRepairError) {
+            const holdState = resolveRecoverablePostRunState(freshIssue) ?? "failed";
+            this.failRunAndClear(run, verifiedRepairError, holdState);
+            const heldIssue = 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: "branch_not_advanced",
+                summary: verifiedRepairError,
+            });
+            void this.emitLinearActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
+            void this.syncLinearSession(heldIssue, { activeRunType: run.runType });
+            this.progressThrottle.delete(run.id);
+            this.activeThreadId = undefined;
+            return;
+        }
         const postRunState = resolvePostRunState(freshIssue);
         this.db.transaction(() => {
             this.db.finishRun(run.id, {
@@ -419,10 +452,15 @@ export class RunOrchestrator {
                 ...(postRunState === "awaiting_queue" || postRunState === "done"
                     ? {
                         lastGitHubFailureSource: null,
+                        lastGitHubFailureHeadSha: null,
+                        lastGitHubFailureSignature: null,
                         lastGitHubFailureCheckName: null,
                         lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureContextJson: null,
                         lastGitHubFailureAt: null,
                         lastQueueIncidentJson: null,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
                     }
                     : {}),
             });
@@ -534,8 +572,11 @@ export class RunOrchestrator {
             // Checks failed + idle — route based on durable GitHub failure provenance.
             if (issue.prCheckStatus === "failed") {
                 if (issue.lastGitHubFailureSource === "queue_eviction") {
-                    if (issue.factoryState !== "repairing_queue") {
-                        const pendingRunContext = buildFailureContext(issue);
+                    const pendingRunContext = buildFailureContext(issue);
+                    if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                        this.advanceIdleIssue(issue, "repairing_queue");
+                    }
+                    else {
                         this.advanceIdleIssue(issue, "repairing_queue", {
                             pendingRunType: "queue_repair",
                             ...(pendingRunContext ? { pendingRunContext } : {}),
@@ -544,8 +585,11 @@ export class RunOrchestrator {
                     continue;
                 }
                 if (issue.lastGitHubFailureSource === "branch_ci") {
-                    if (issue.factoryState !== "repairing_ci") {
-                        const pendingRunContext = buildFailureContext(issue);
+                    const pendingRunContext = buildFailureContext(issue);
+                    if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                        this.advanceIdleIssue(issue, "repairing_ci");
+                    }
+                    else {
                         this.advanceIdleIssue(issue, "repairing_ci", {
                             pendingRunType: "ci_repair",
                             ...(pendingRunContext ? { pendingRunContext } : {}),
@@ -566,8 +610,11 @@ export class RunOrchestrator {
                     });
                     continue;
                 }
-                if (issue.factoryState !== "repairing_ci") {
-                    const pendingRunContext = buildFailureContext(issue);
+                const pendingRunContext = buildFailureContext(issue);
+                if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                    this.advanceIdleIssue(issue, "repairing_ci");
+                }
+                else {
                     this.advanceIdleIssue(issue, "repairing_ci", {
                         pendingRunType: "ci_repair",
                         ...(pendingRunContext ? { pendingRunContext } : {}),
@@ -606,6 +653,9 @@ export class RunOrchestrator {
         }
     }
     advanceIdleIssue(issue, newState, options) {
+        if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
+            return;
+        }
         this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
         this.db.upsertIssue({
             projectId: issue.projectId,
@@ -620,10 +670,15 @@ export class RunOrchestrator {
             ...(options?.clearFailureProvenance
                 ? {
                     lastGitHubFailureSource: null,
+                    lastGitHubFailureHeadSha: null,
+                    lastGitHubFailureSignature: null,
                     lastGitHubFailureCheckName: null,
                     lastGitHubFailureCheckUrl: null,
+                    lastGitHubFailureContextJson: null,
                     lastGitHubFailureAt: null,
                     lastQueueIncidentJson: null,
+                    lastAttemptedFailureHeadSha: null,
+                    lastAttemptedFailureSignature: null,
                 }
                 : {}),
         });
@@ -790,7 +845,7 @@ export class RunOrchestrator {
             else if (run.runType === "review_fix" && issue.reviewFixAttempts > 0) {
                 this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, reviewFixAttempts: issue.reviewFixAttempts - 1 });
             }
-            const recoveredState = resolvePostRunState(this.db.getIssue(run.projectId, run.linearIssueId) ?? issue);
+            const recoveredState = resolveRecoverablePostRunState(this.db.getIssue(run.projectId, run.linearIssueId) ?? issue);
             this.failRunAndClear(run, "Codex turn was interrupted", recoveredState);
             const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
             if (recoveredState) {
@@ -815,6 +870,21 @@ export class RunOrchestrator {
             const trackedIssue = this.db.issueToTrackedIssue(issue);
             const report = buildStageReport(run, 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) {
+                const holdState = resolveRecoverablePostRunState(freshIssue) ?? "failed";
+                this.failRunAndClear(run, verifiedRepairError, holdState);
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "turn",
+                    issueKey: issue.issueKey,
+                    projectId: run.projectId,
+                    stage: run.runType,
+                    status: "branch_not_advanced",
+                    summary: verifiedRepairError,
+                });
+                return;
+            }
             const postRunState = resolvePostRunState(freshIssue);
             this.db.transaction(() => {
                 this.db.finishRun(run.id, {
@@ -832,10 +902,15 @@ export class RunOrchestrator {
                     ...(postRunState === "awaiting_queue" || postRunState === "done"
                         ? {
                             lastGitHubFailureSource: null,
+                            lastGitHubFailureHeadSha: null,
+                            lastGitHubFailureSignature: null,
                             lastGitHubFailureCheckName: null,
                             lastGitHubFailureCheckUrl: null,
+                            lastGitHubFailureContextJson: null,
                             lastGitHubFailureAt: null,
                             lastQueueIncidentJson: null,
+                            lastAttemptedFailureHeadSha: null,
+                            lastAttemptedFailureSignature: null,
                         }
                         : {}),
                 });
@@ -908,6 +983,41 @@ export class RunOrchestrator {
             });
         });
     }
+    async verifyReactiveRunAdvancedBranch(run, issue) {
+        if (run.runType !== "ci_repair" && run.runType !== "queue_repair") {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open" || !issue.lastGitHubFailureHeadSha) {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        if (!project?.github?.repoFullName) {
+            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")
+                return undefined;
+            if (!pr.headRefOid || pr.headRefOid !== issue.lastGitHubFailureHeadSha)
+                return undefined;
+            return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to verify PR head advancement after repair");
+            return undefined;
+        }
+    }
     async emitLinearActivity(issue, content, options) {
         if (!issue.agentSessionId)
             return;
@@ -1025,23 +1135,59 @@ function resolvePostRunState(issue) {
     }
     return undefined;
 }
+function resolveRecoverablePostRunState(issue) {
+    if (!issue.prNumber) {
+        return resolvePostRunState(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";
+        if (issue.prReviewState === "approved")
+            return "awaiting_queue";
+        return "pr_open";
+    }
+    return resolvePostRunState(issue);
+}
 function buildFailureContext(issue) {
+    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
     const queueRepairContext = issue.lastQueueIncidentJson
         ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
         : undefined;
     if (!queueRepairContext
         && !issue.lastGitHubFailureSource
+        && !issue.lastGitHubFailureHeadSha
+        && !issue.lastGitHubFailureSignature
         && !issue.lastGitHubFailureCheckName
-        && !issue.lastGitHubFailureCheckUrl) {
+        && !issue.lastGitHubFailureCheckUrl
+        && !storedFailureContext) {
         return undefined;
     }
     return {
         ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
+        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
+        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
         ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
         ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
+        ...(storedFailureContext ? storedFailureContext : {}),
         ...(queueRepairContext ? queueRepairContext : {}),
     };
 }
+function isDuplicateRepairAttempt(issue, context) {
+    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+    const headSha = typeof context?.failureHeadSha === "string"
+        ? context.failureHeadSha
+        : typeof context?.headSha === "string" ? context.headSha : undefined;
+    if (!signature)
+        return false;
+    return issue.lastAttemptedFailureSignature === signature
+        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
+}
 function appendQueueRepairContext(lines, context) {
     const incidentTitle = typeof context?.incidentTitle === "string" ? context.incidentTitle.trim() : "";
     const incidentSummary = typeof context?.incidentSummary === "string" ? context.incidentSummary.trim() : "";