patchrelay 0.30.1 → 0.31.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.30.1",
-  "commit": "dee1d8b522b1",
-  "builtAt": "2026-04-01T08:31:08.208Z"
+  "version": "0.31.0",
+  "commit": "5de73a74995a",
+  "builtAt": "2026-04-01T09:38:32.968Z"
 }

package/dist/cli/watch/IssueDetailView.js

@@ -44,5 +44,5 @@ export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, a
     const history = useMemo(() => buildStateHistory(rawRuns, rawFeedEvents, issue.factoryState, activeRunId), [rawRuns, rawFeedEvents, issue.factoryState, activeRunId]);
     const graph = useMemo(() => buildPatchRelayStateGraph(history, issue.factoryState), [history, issue.factoryState]);
     const queueObservations = useMemo(() => buildPatchRelayQueueObservations(issue, rawFeedEvents), [issue, rawFeedEvents]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.blockedByCount > 0 && _jsxs(Text, { color: "yellow", children: ["blocked by ", issue.blockedByKeys.join(", ")] }), issue.readyForExecution && !issue.activeRunType && issue.blockedByCount === 0 && _jsx(Text, { color: "blueBright", children: "ready" }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["#", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), detailTab === "timeline" && _jsx(Text, { dimColor: true, children: timelineMode }), follow && _jsx(Text, { color: "yellow", children: "follow" }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }), issue.title && _jsx(Text, { children: issue.title }), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "Plan" }), _jsx(Text, { children: progressBar(plan.filter((s) => s.status === "completed").length, plan.length, 16) }), _jsxs(Text, { dimColor: true, children: [plan.filter((s) => s.status === "completed").length, "/", plan.length] })] }), plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`)))] })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow, mode: timelineMode }) })] })) : (_jsxs(_Fragment, { children: [_jsx(FactoryStateGraph, { main: graph.main, prLoops: graph.prLoops, queueLoop: graph.queueLoop, exits: graph.exits }), _jsx(QueueObservationView, { observations: queueObservations }), _jsx(Box, { marginTop: 1, children: _jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.blockedByCount > 0 && _jsxs(Text, { color: "yellow", children: ["blocked by ", issue.blockedByKeys.join(", ")] }), issue.readyForExecution && !issue.activeRunType && issue.blockedByCount === 0 && _jsx(Text, { color: "blueBright", children: "ready" }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["#", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), detailTab === "timeline" && _jsx(Text, { dimColor: true, children: timelineMode }), follow && _jsx(Text, { color: "yellow", children: "follow" }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }), issue.title && _jsx(Text, { children: issue.title }), issueContext?.latestFailureSummary && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: issueContext.latestFailureSource === "queue_eviction" ? "yellow" : "red", children: ["Latest failure: ", issueContext.latestFailureSummary, issueContext.latestFailureHeadSha ? ` @ ${issueContext.latestFailureHeadSha.slice(0, 8)}` : ""] }) })), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "Plan" }), _jsx(Text, { children: progressBar(plan.filter((s) => s.status === "completed").length, plan.length, 16) }), _jsxs(Text, { dimColor: true, children: [plan.filter((s) => s.status === "completed").length, "/", plan.length] })] }), plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`)))] })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow, mode: timelineMode }) })] })) : (_jsxs(_Fragment, { children: [_jsx(FactoryStateGraph, { main: graph.main, prLoops: graph.prLoops, queueLoop: graph.queueLoop, exits: graph.exits }), _jsx(QueueObservationView, { observations: queueObservations }), _jsx(Box, { marginTop: 1, children: _jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode }) })] }));
 }

package/dist/cli/watch/use-detail-stream.js

@@ -54,6 +54,11 @@ async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
                 ciRepairAttempts: typeof i.ciRepairAttempts === "number" ? i.ciRepairAttempts : 0,
                 queueRepairAttempts: typeof i.queueRepairAttempts === "number" ? i.queueRepairAttempts : 0,
                 reviewFixAttempts: typeof i.reviewFixAttempts === "number" ? i.reviewFixAttempts : 0,
+                latestFailureSource: typeof i.latestFailureSource === "string" ? i.latestFailureSource : undefined,
+                latestFailureHeadSha: typeof i.latestFailureHeadSha === "string" ? i.latestFailureHeadSha : undefined,
+                latestFailureCheckName: typeof i.latestFailureCheckName === "string" ? i.latestFailureCheckName : undefined,
+                latestFailureStepName: typeof i.latestFailureStepName === "string" ? i.latestFailureStepName : undefined,
+                latestFailureSummary: typeof i.latestFailureSummary === "string" ? i.latestFailureSummary : undefined,
                 runCount: runs.length,
             };
         }

package/dist/cli/watch/watch-state.js

@@ -171,6 +171,20 @@ function applyFeedEvent(state, event, receivedAt) {
         if (event.status === "check_passed" || event.status === "check_failed") {
             issue.prCheckStatus = event.status === "check_passed" ? "passed" : "failed";
         }
+        if (event.status === "ci_repair_queued") {
+            issue.factoryState = "repairing_ci";
+            issue.statusNote = event.detail ?? event.summary;
+        }
+        if (event.status === "queue_repair_queued") {
+            issue.factoryState = "repairing_queue";
+            issue.statusNote = event.detail ?? event.summary;
+        }
+        if (event.status === "repair_deduped" || event.status === "branch_not_advanced") {
+            issue.statusNote = event.summary;
+        }
+    }
+    if ((event.kind === "turn" || event.kind === "github") && event.status === "branch_not_advanced") {
+        issue.statusNote = event.summary;
     }
     issue.updatedAt = event.at;
     updated[index] = issue;

package/dist/db/migrations.js

@@ -198,11 +198,16 @@ export function runPatchRelayMigrations(connection) {
     // Preserve GitHub failure provenance so reconciliation can distinguish
     // branch CI failures from merge-queue evictions after webhook delivery.
     addColumnIfMissing(connection, "issues", "last_github_failure_source", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_github_failure_head_sha", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_github_failure_signature", "TEXT");
     addColumnIfMissing(connection, "issues", "last_github_failure_check_name", "TEXT");
     addColumnIfMissing(connection, "issues", "last_github_failure_check_url", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_github_failure_context_json", "TEXT");
     addColumnIfMissing(connection, "issues", "last_github_failure_at", "TEXT");
     addColumnIfMissing(connection, "issues", "last_queue_signal_at", "TEXT");
     addColumnIfMissing(connection, "issues", "last_queue_incident_json", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_attempted_failure_head_sha", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_attempted_failure_signature", "TEXT");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/db.js

@@ -1,3 +1,4 @@
+import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { LinearInstallationStore } from "./db/linear-installation-store.js";
 import { OperatorFeedStore } from "./db/operator-feed-store.js";
 import { RepositoryLinkStore } from "./db/repository-link-store.js";
@@ -164,6 +165,14 @@ export class PatchRelayDatabase {
                 sets.push("last_github_failure_source = @lastGitHubFailureSource");
                 values.lastGitHubFailureSource = params.lastGitHubFailureSource;
             }
+            if (params.lastGitHubFailureHeadSha !== undefined) {
+                sets.push("last_github_failure_head_sha = @lastGitHubFailureHeadSha");
+                values.lastGitHubFailureHeadSha = params.lastGitHubFailureHeadSha;
+            }
+            if (params.lastGitHubFailureSignature !== undefined) {
+                sets.push("last_github_failure_signature = @lastGitHubFailureSignature");
+                values.lastGitHubFailureSignature = params.lastGitHubFailureSignature;
+            }
             if (params.lastGitHubFailureCheckName !== undefined) {
                 sets.push("last_github_failure_check_name = @lastGitHubFailureCheckName");
                 values.lastGitHubFailureCheckName = params.lastGitHubFailureCheckName;
@@ -172,6 +181,10 @@ export class PatchRelayDatabase {
                 sets.push("last_github_failure_check_url = @lastGitHubFailureCheckUrl");
                 values.lastGitHubFailureCheckUrl = params.lastGitHubFailureCheckUrl;
             }
+            if (params.lastGitHubFailureContextJson !== undefined) {
+                sets.push("last_github_failure_context_json = @lastGitHubFailureContextJson");
+                values.lastGitHubFailureContextJson = params.lastGitHubFailureContextJson;
+            }
             if (params.lastGitHubFailureAt !== undefined) {
                 sets.push("last_github_failure_at = @lastGitHubFailureAt");
                 values.lastGitHubFailureAt = params.lastGitHubFailureAt;
@@ -184,6 +197,14 @@ export class PatchRelayDatabase {
                 sets.push("last_queue_incident_json = @lastQueueIncidentJson");
                 values.lastQueueIncidentJson = params.lastQueueIncidentJson;
             }
+            if (params.lastAttemptedFailureHeadSha !== undefined) {
+                sets.push("last_attempted_failure_head_sha = @lastAttemptedFailureHeadSha");
+                values.lastAttemptedFailureHeadSha = params.lastAttemptedFailureHeadSha;
+            }
+            if (params.lastAttemptedFailureSignature !== undefined) {
+                sets.push("last_attempted_failure_signature = @lastAttemptedFailureSignature");
+                values.lastAttemptedFailureSignature = params.lastAttemptedFailureSignature;
+            }
             if (params.ciRepairAttempts !== undefined) {
                 sets.push("ci_repair_attempts = @ciRepairAttempts");
                 values.ciRepairAttempts = params.ciRepairAttempts;
@@ -215,7 +236,8 @@ export class PatchRelayDatabase {
           branch_name, worktree_path, thread_id, active_run_id,
           agent_session_id,
           pr_number, pr_url, pr_state, pr_review_state, pr_check_status,
-          last_github_failure_source, last_github_failure_check_name, last_github_failure_check_url, last_github_failure_at, last_queue_signal_at, last_queue_incident_json,
+          last_github_failure_source, last_github_failure_head_sha, last_github_failure_signature, last_github_failure_check_name, last_github_failure_check_url, last_github_failure_context_json, last_github_failure_at, last_queue_signal_at, last_queue_incident_json,
+          last_attempted_failure_head_sha, last_attempted_failure_signature,
           updated_at
         ) VALUES (
           @projectId, @linearIssueId, @issueKey, @title, @description, @url,
@@ -224,7 +246,8 @@ export class PatchRelayDatabase {
           @branchName, @worktreePath, @threadId, @activeRunId,
           @agentSessionId,
           @prNumber, @prUrl, @prState, @prReviewState, @prCheckStatus,
-          @lastGitHubFailureSource, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureAt, @lastQueueSignalAt, @lastQueueIncidentJson,
+          @lastGitHubFailureSource, @lastGitHubFailureHeadSha, @lastGitHubFailureSignature, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureContextJson, @lastGitHubFailureAt, @lastQueueSignalAt, @lastQueueIncidentJson,
+          @lastAttemptedFailureHeadSha, @lastAttemptedFailureSignature,
           @now
         )
       `).run({
@@ -252,11 +275,16 @@ export class PatchRelayDatabase {
                 prReviewState: params.prReviewState ?? null,
                 prCheckStatus: params.prCheckStatus ?? null,
                 lastGitHubFailureSource: params.lastGitHubFailureSource ?? null,
+                lastGitHubFailureHeadSha: params.lastGitHubFailureHeadSha ?? null,
+                lastGitHubFailureSignature: params.lastGitHubFailureSignature ?? null,
                 lastGitHubFailureCheckName: params.lastGitHubFailureCheckName ?? null,
                 lastGitHubFailureCheckUrl: params.lastGitHubFailureCheckUrl ?? null,
+                lastGitHubFailureContextJson: params.lastGitHubFailureContextJson ?? null,
                 lastGitHubFailureAt: params.lastGitHubFailureAt ?? null,
                 lastQueueSignalAt: params.lastQueueSignalAt ?? null,
                 lastQueueIncidentJson: params.lastQueueIncidentJson ?? null,
+                lastAttemptedFailureHeadSha: params.lastAttemptedFailureHeadSha ?? null,
+                lastAttemptedFailureSignature: params.lastAttemptedFailureSignature ?? null,
                 now,
             });
         }
@@ -508,6 +536,7 @@ export class PatchRelayDatabase {
     issueToTrackedIssue(issue) {
         const blockedBy = this.listIssueDependencies(issue.projectId, issue.linearIssueId);
         const unresolvedBlockedBy = blockedBy.filter((entry) => !isResolvedLinearState(entry.blockerCurrentLinearStateType, entry.blockerCurrentLinearState));
+        const failureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
         return {
             id: issue.id,
             projectId: issue.projectId,
@@ -521,6 +550,11 @@ export class PatchRelayDatabase {
             blockedByKeys: unresolvedBlockedBy
                 .map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId),
             readyForExecution: issue.pendingRunType !== undefined && issue.activeRunId === undefined && unresolvedBlockedBy.length === 0,
+            ...(issue.lastGitHubFailureSource ? { latestFailureSource: issue.lastGitHubFailureSource } : {}),
+            ...(issue.lastGitHubFailureHeadSha ? { latestFailureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
+            ...(issue.lastGitHubFailureCheckName ? { latestFailureCheckName: issue.lastGitHubFailureCheckName } : {}),
+            ...(failureContext?.stepName ? { latestFailureStepName: failureContext.stepName } : {}),
+            ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
             ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
             ...(issue.agentSessionId ? { activeAgentSessionId: issue.agentSessionId } : {}),
             updatedAt: issue.updatedAt,
@@ -580,12 +614,21 @@ function mapIssueRow(row) {
         ...(row.last_github_failure_source !== null && row.last_github_failure_source !== undefined
             ? { lastGitHubFailureSource: String(row.last_github_failure_source) }
             : {}),
+        ...(row.last_github_failure_head_sha !== null && row.last_github_failure_head_sha !== undefined
+            ? { lastGitHubFailureHeadSha: String(row.last_github_failure_head_sha) }
+            : {}),
+        ...(row.last_github_failure_signature !== null && row.last_github_failure_signature !== undefined
+            ? { lastGitHubFailureSignature: String(row.last_github_failure_signature) }
+            : {}),
         ...(row.last_github_failure_check_name !== null && row.last_github_failure_check_name !== undefined
             ? { lastGitHubFailureCheckName: String(row.last_github_failure_check_name) }
             : {}),
         ...(row.last_github_failure_check_url !== null && row.last_github_failure_check_url !== undefined
             ? { lastGitHubFailureCheckUrl: String(row.last_github_failure_check_url) }
             : {}),
+        ...(row.last_github_failure_context_json !== null && row.last_github_failure_context_json !== undefined
+            ? { lastGitHubFailureContextJson: String(row.last_github_failure_context_json) }
+            : {}),
         ...(row.last_github_failure_at !== null && row.last_github_failure_at !== undefined
             ? { lastGitHubFailureAt: String(row.last_github_failure_at) }
             : {}),
@@ -595,6 +638,12 @@ function mapIssueRow(row) {
         ...(row.last_queue_incident_json !== null && row.last_queue_incident_json !== undefined
             ? { lastQueueIncidentJson: String(row.last_queue_incident_json) }
             : {}),
+        ...(row.last_attempted_failure_head_sha !== null && row.last_attempted_failure_head_sha !== undefined
+            ? { lastAttemptedFailureHeadSha: String(row.last_attempted_failure_head_sha) }
+            : {}),
+        ...(row.last_attempted_failure_signature !== null && row.last_attempted_failure_signature !== undefined
+            ? { lastAttemptedFailureSignature: String(row.last_attempted_failure_signature) }
+            : {}),
         ciRepairAttempts: Number(row.ci_repair_attempts ?? 0),
         queueRepairAttempts: Number(row.queue_repair_attempts ?? 0),
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),

package/dist/github-failure-context.js

@@ -0,0 +1,205 @@
+import { execCommand, safeJsonParse, sanitizeDiagnosticText } from "./utils.js";
+const FAILED_CONCLUSIONS = new Set([
+    "failure",
+    "timed_out",
+    "cancelled",
+    "startup_failure",
+    "action_required",
+    "stale",
+]);
+export function createGitHubFailureContextResolver() {
+    return {
+        resolve: async ({ source, repoFullName, event }) => {
+            if (!repoFullName)
+                return undefined;
+            if (source === "queue_eviction") {
+                const queueContext = buildFallbackFailureContext(source, repoFullName, event);
+                return {
+                    ...queueContext,
+                    failureSignature: buildFailureSignature({
+                        source,
+                        headSha: queueContext.headSha,
+                        checkName: queueContext.checkName,
+                    }),
+                };
+            }
+            const fallback = buildFallbackFailureContext(source, repoFullName, event);
+            try {
+                const failedCheck = await resolveFailedCheckRun(repoFullName, event);
+                const workflowRunId = parseWorkflowRunId(failedCheck?.detailsUrl ?? failedCheck?.htmlUrl ?? event.checkDetailsUrl ?? event.checkUrl);
+                const workflowJob = workflowRunId
+                    ? await resolveWorkflowJob(repoFullName, workflowRunId, failedCheck?.name ?? event.checkName)
+                    : undefined;
+                const annotations = failedCheck?.id
+                    ? await resolveAnnotations(repoFullName, failedCheck.id)
+                    : undefined;
+                const summary = firstNonEmpty(annotations?.[0], failedCheck?.outputTitle, failedCheck?.outputSummary, event.checkOutputTitle, event.checkOutputSummary, workflowJob?.stepName ? `Failed step: ${workflowJob.stepName}` : undefined);
+                const checkName = firstNonEmpty(failedCheck?.name, event.checkName);
+                const checkUrl = firstNonEmpty(failedCheck?.htmlUrl, event.checkUrl);
+                const checkDetailsUrl = firstNonEmpty(failedCheck?.detailsUrl, event.checkDetailsUrl);
+                const jobName = firstNonEmpty(workflowJob?.name, failedCheck?.name, event.checkName);
+                const stepName = workflowJob?.stepName;
+                return {
+                    source,
+                    repoFullName,
+                    capturedAt: new Date().toISOString(),
+                    ...(event.headSha ? { headSha: event.headSha } : {}),
+                    ...(checkName ? { checkName } : {}),
+                    ...(checkUrl ? { checkUrl } : {}),
+                    ...(checkDetailsUrl ? { checkDetailsUrl } : {}),
+                    ...(workflowRunId !== undefined ? { workflowRunId } : {}),
+                    ...(jobName ? { jobName } : {}),
+                    ...(stepName ? { stepName } : {}),
+                    ...(summary ? { summary } : {}),
+                    ...(annotations && annotations.length > 0 ? { annotations } : {}),
+                    failureSignature: buildFailureSignature({
+                        source,
+                        headSha: event.headSha,
+                        checkName,
+                        jobName,
+                        stepName,
+                    }),
+                };
+            }
+            catch {
+                return {
+                    ...fallback,
+                    failureSignature: buildFailureSignature({
+                        source,
+                        headSha: fallback.headSha,
+                        checkName: fallback.checkName,
+                        stepName: fallback.stepName,
+                    }),
+                };
+            }
+        },
+    };
+}
+export function parseGitHubFailureContext(value) {
+    if (!value)
+        return undefined;
+    return safeJsonParse(value);
+}
+export function summarizeGitHubFailureContext(context) {
+    if (!context)
+        return undefined;
+    if (context.source === "queue_eviction") {
+        return firstNonEmpty(context.summary, context.checkName, "Queue eviction");
+    }
+    const lead = firstNonEmpty(context.jobName, context.checkName);
+    const step = context.stepName ? `${lead ?? "CI"} -> ${context.stepName}` : lead;
+    return firstNonEmpty(step && context.summary ? `${step}: ${context.summary}` : undefined, step, context.summary);
+}
+function buildFallbackFailureContext(source, repoFullName, event) {
+    const summary = firstNonEmpty(event.checkOutputTitle, event.checkOutputSummary, event.checkOutputText ? sanitizeDiagnosticText(event.checkOutputText, 240) : undefined);
+    return {
+        source,
+        repoFullName,
+        capturedAt: new Date().toISOString(),
+        ...(event.headSha ? { headSha: event.headSha } : {}),
+        ...(event.checkName ? { checkName: event.checkName } : {}),
+        ...(event.checkUrl ? { checkUrl: event.checkUrl } : {}),
+        ...(event.checkDetailsUrl ? { checkDetailsUrl: event.checkDetailsUrl } : {}),
+        ...(event.checkName ? { jobName: event.checkName } : {}),
+        ...(summary ? { summary } : {}),
+    };
+}
+async function resolveFailedCheckRun(repoFullName, event) {
+    if (!event.headSha)
+        return undefined;
+    const response = await execCommand("gh", [
+        "api",
+        `repos/${repoFullName}/commits/${event.headSha}/check-runs`,
+        "--method", "GET",
+    ], { timeoutMs: 15_000 });
+    if (response.exitCode !== 0) {
+        throw new Error(response.stderr || "gh api check-runs failed");
+    }
+    const payload = safeJsonParse(response.stdout);
+    const checks = (payload?.check_runs ?? [])
+        .map(mapCheckRunSummary)
+        .filter((entry) => entry.conclusion && FAILED_CONCLUSIONS.has(entry.conclusion.toLowerCase()));
+    return checks.find((entry) => entry.name === event.checkName)
+        ?? checks.find((entry) => entry.name && event.checkName && entry.name.includes(event.checkName))
+        ?? checks[0];
+}
+async function resolveWorkflowJob(repoFullName, workflowRunId, preferredName) {
+    const response = await execCommand("gh", [
+        "api",
+        `repos/${repoFullName}/actions/runs/${workflowRunId}/jobs`,
+        "--method", "GET",
+    ], { timeoutMs: 15_000 });
+    if (response.exitCode !== 0) {
+        throw new Error(response.stderr || "gh api workflow jobs failed");
+    }
+    const payload = safeJsonParse(response.stdout);
+    const jobs = (payload?.jobs ?? []).map(mapWorkflowJobSummary);
+    return jobs.find((entry) => entry.name === preferredName)
+        ?? jobs.find((entry) => entry.name && preferredName && entry.name.includes(preferredName))
+        ?? jobs.find((entry) => entry.conclusion && FAILED_CONCLUSIONS.has(entry.conclusion.toLowerCase()))
+        ?? jobs[0];
+}
+async function resolveAnnotations(repoFullName, checkRunId) {
+    const response = await execCommand("gh", [
+        "api",
+        `repos/${repoFullName}/check-runs/${checkRunId}/annotations`,
+        "--method", "GET",
+        "-F", "per_page=20",
+    ], { timeoutMs: 15_000 });
+    if (response.exitCode !== 0) {
+        throw new Error(response.stderr || "gh api annotations failed");
+    }
+    const payload = safeJsonParse(response.stdout) ?? [];
+    return payload
+        .map((entry) => {
+        const title = typeof entry.title === "string" ? entry.title.trim() : "";
+        const message = typeof entry.message === "string" ? entry.message.trim() : "";
+        const path = typeof entry.path === "string" ? entry.path.trim() : "";
+        const rendered = [title, message, path ? `(${path})` : ""].filter(Boolean).join(": ");
+        return rendered ? sanitizeDiagnosticText(rendered, 240) : undefined;
+    })
+        .filter((entry) => Boolean(entry));
+}
+function mapCheckRunSummary(row) {
+    const output = row.output && typeof row.output === "object" ? row.output : undefined;
+    return {
+        ...(typeof row.id === "number" ? { id: row.id } : {}),
+        ...(typeof row.name === "string" ? { name: row.name } : {}),
+        ...(typeof row.html_url === "string" ? { htmlUrl: row.html_url } : {}),
+        ...(typeof row.details_url === "string" ? { detailsUrl: row.details_url } : {}),
+        ...(typeof row.conclusion === "string" ? { conclusion: row.conclusion } : {}),
+        ...(typeof output?.title === "string" ? { outputTitle: output.title } : {}),
+        ...(typeof output?.summary === "string" ? { outputSummary: sanitizeDiagnosticText(output.summary, 240) } : {}),
+        ...(typeof output?.text === "string" ? { outputText: sanitizeDiagnosticText(output.text, 240) } : {}),
+    };
+}
+function mapWorkflowJobSummary(row) {
+    const steps = Array.isArray(row.steps) ? row.steps.filter((entry) => Boolean(entry) && typeof entry === "object") : [];
+    const failedStep = steps.find((entry) => {
+        const conclusion = typeof entry.conclusion === "string" ? entry.conclusion.toLowerCase() : "";
+        return FAILED_CONCLUSIONS.has(conclusion);
+    });
+    const informativeStep = failedStep ?? steps.findLast((entry) => typeof entry.name === "string");
+    return {
+        ...(typeof row.name === "string" ? { name: row.name } : {}),
+        ...(typeof row.conclusion === "string" ? { conclusion: row.conclusion } : {}),
+        ...(typeof informativeStep?.name === "string" ? { stepName: informativeStep.name } : {}),
+    };
+}
+function parseWorkflowRunId(url) {
+    if (!url)
+        return undefined;
+    const match = url.match(/\/actions\/runs\/(\d+)/);
+    return match ? Number(match[1]) : undefined;
+}
+function buildFailureSignature(parts) {
+    return [
+        parts.source,
+        parts.headSha ?? "unknown-sha",
+        parts.jobName ?? parts.checkName ?? "unknown-check",
+        parts.stepName ?? "unknown-step",
+    ].join("::");
+}
+function firstNonEmpty(...values) {
+    return values.find((value) => typeof value === "string" && value.trim().length > 0)?.trim();
+}

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/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() : "";

package/dist/service.js

@@ -1,4 +1,5 @@
 import { resolveGitHubAppCredentials, createGitHubAppTokenManager, ensureGhWrapper, } from "./github-app-token.js";
+import { parseGitHubFailureContext, summarizeGitHubFailureContext } from "./github-failure-context.js";
 import { GitHubWebhookHandler } from "./github-webhook-handler.js";
 import { IssueQueryService } from "./issue-query-service.js";
 import { DatabaseBackedLinearClientProvider } from "./linear-client.js";
@@ -216,6 +217,10 @@ export class PatchRelayService {
           i.current_linear_state, i.factory_state, i.updated_at,
           i.pending_run_type,
           i.pr_number, i.pr_review_state, i.pr_check_status,
+          i.last_github_failure_source,
+          i.last_github_failure_head_sha,
+          i.last_github_failure_check_name,
+          i.last_github_failure_context_json,
           active_run.run_type AS active_run_type,
           latest_run.run_type AS latest_run_type,
           latest_run.status AS latest_run_status,
@@ -257,13 +262,22 @@ export class PatchRelayService {
         ORDER BY i.updated_at DESC, i.issue_key ASC`)
             .all();
         return rows.map((row) => {
+            const failureContext = parseGitHubFailureContext(typeof row.last_github_failure_context_json === "string" ? row.last_github_failure_context_json : undefined);
             const statusNote = extractStatusNote(typeof row.latest_run_summary_json === "string" ? row.latest_run_summary_json : undefined, typeof row.latest_run_report_json === "string" ? row.latest_run_report_json : undefined);
             const blockedByKeys = parseStringArray(typeof row.blocked_by_keys_json === "string" ? row.blocked_by_keys_json : undefined);
             const blockedByCount = Number(row.blocked_by_count ?? 0);
             const readyForExecution = row.pending_run_type !== null && row.pending_run_type !== undefined && row.active_run_type === null && blockedByCount === 0;
+            const failureSummary = summarizeGitHubFailureContext(failureContext);
+            const derivedStatusNote = blockedByCount > 0
+                ? `Blocked by ${blockedByKeys.join(", ")}`
+                : failureSummary && (row.factory_state === "repairing_ci"
+                    || row.factory_state === "repairing_queue"
+                    || row.factory_state === "failed")
+                    ? failureSummary
+                    : statusNote;
             const statusNoteWithBlockers = blockedByCount > 0
                 ? `Blocked by ${blockedByKeys.join(", ")}`
-                : statusNote;
+                : derivedStatusNote;
             return {
                 ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
                 ...(row.title !== null ? { title: String(row.title) } : {}),
@@ -281,6 +295,11 @@ export class PatchRelayService {
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
                 ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
                 ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
+                ...(row.last_github_failure_source !== null ? { latestFailureSource: String(row.last_github_failure_source) } : {}),
+                ...(row.last_github_failure_head_sha !== null ? { latestFailureHeadSha: String(row.last_github_failure_head_sha) } : {}),
+                ...(row.last_github_failure_check_name !== null ? { latestFailureCheckName: String(row.last_github_failure_check_name) } : {}),
+                ...(failureContext?.stepName ? { latestFailureStepName: failureContext.stepName } : {}),
+                ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
                 updatedAt: String(row.updated_at),
             };
         });

package/package.json

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