patchrelay 0.30.1 → 0.32.0

package/dist/github-webhook-handler.js

@@ -1,4 +1,5 @@
 import { resolveFactoryStateFromGitHub, TERMINAL_STATES } from "./factory-state.js";
+import { createGitHubCiSnapshotResolver, 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";
@@ -9,12 +10,11 @@ import { resolveSecret } from "./resolve-secret.js";
 import { safeJsonParse } from "./utils.js";
 /**
  * GitHub sends both check_run and check_suite completion events.
- * A single CI run generates 10+ individual check_run events as each job finishes,
- * but only 1 check_suite event when the entire suite completes. Reacting to
- * individual check_run events causes the factory state to flicker rapidly
- * between pr_open and repairing_ci. We only drive state transitions and reactive
- * runs from check_suite events. Individual check_run events still update PR
- * metadata (prCheckStatus) for observability.
+ * A single CI run generates many individual check_run events as each job finishes,
+ * but PatchRelay should only start ci_repair once the configured gate check
+ * (for example `Tests`) has gone terminal for the current PR head SHA. We still
+ * treat most check_run events as metadata-only and only react to queue eviction
+ * checks or the settled gate check.
  */
 function isMetadataOnlyCheckEvent(event) {
     return event.eventSource === "check_run"
@@ -28,7 +28,9 @@ export class GitHubWebhookHandler {
     logger;
     codex;
     feed;
-    constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed) {
+    failureContextResolver;
+    ciSnapshotResolver;
+    constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed, failureContextResolver = createGitHubFailureContextResolver(), ciSnapshotResolver = createGitHubCiSnapshotResolver()) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
@@ -36,6 +38,8 @@ export class GitHubWebhookHandler {
         this.logger = logger;
         this.codex = codex;
         this.feed = feed;
+        this.failureContextResolver = failureContextResolver;
+        this.ciSnapshotResolver = ciSnapshotResolver;
     }
     async acceptGitHubWebhook(params) {
         // Deduplicate
@@ -114,6 +118,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 +129,8 @@ export class GitHubWebhookHandler {
             ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
             ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
         });
-        this.updateFailureProvenance(issue, event);
+        await this.updateCiSnapshot(issue, event, project);
+        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 +174,20 @@ export class GitHubWebhookHandler {
                 ciRepairAttempts: 0,
                 queueRepairAttempts: 0,
                 lastGitHubFailureSource: null,
+                lastGitHubFailureHeadSha: null,
+                lastGitHubFailureSignature: null,
                 lastGitHubFailureCheckName: null,
                 lastGitHubFailureCheckUrl: null,
+                lastGitHubFailureContextJson: null,
                 lastGitHubFailureAt: null,
+                lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
+                lastGitHubCiSnapshotGateCheckName: this.getPrimaryGateCheckName(project),
+                lastGitHubCiSnapshotGateCheckStatus: "pending",
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: 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 +204,86 @@ 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);
+        if (this.isQueueEvictionFailure(freshIssue, event, project) || this.isGateCheckEvent(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 updateCiSnapshot(issue, event, project) {
+        if (event.triggerEvent === "pr_merged") {
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubCiSnapshotHeadSha: null,
+                lastGitHubCiSnapshotGateCheckName: null,
+                lastGitHubCiSnapshotGateCheckStatus: null,
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: null,
+            });
+            return;
+        }
+        if (event.triggerEvent === "pr_synchronize") {
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
+                lastGitHubCiSnapshotGateCheckName: this.getPrimaryGateCheckName(project),
+                lastGitHubCiSnapshotGateCheckStatus: "pending",
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: null,
+            });
+            return;
+        }
+        if (issue.prState !== "open")
+            return;
+        if (event.eventSource !== "check_run")
+            return;
+        if (this.isQueueEvictionFailure(issue, event, project))
+            return;
+        if (!this.isGateCheckEvent(event, project))
+            return;
+        if (this.isStaleGateEvent(issue, event))
+            return;
+        const snapshot = await this.ciSnapshotResolver.resolve({
+            repoFullName: project?.github?.repoFullName ?? event.repoFullName,
+            event,
+            gateCheckNames: this.getGateCheckNames(project),
+        });
+        if (!snapshot) {
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
+                lastGitHubCiSnapshotGateCheckName: this.getPrimaryGateCheckName(project),
+                lastGitHubCiSnapshotGateCheckStatus: "pending",
+                lastGitHubCiSnapshotJson: null,
+                lastGitHubCiSnapshotSettledAt: null,
+            });
+            this.logger.warn({ issueKey: issue.issueKey, repoFullName: project?.github?.repoFullName ?? event.repoFullName, headSha: event.headSha }, "Could not resolve settled CI snapshot; waiting before CI repair");
+            this.feed?.publish({
+                level: "warn",
+                kind: "github",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: issue.factoryState,
+                status: "ci_snapshot_unavailable",
+                summary: `Could not resolve settled ${this.getPrimaryGateCheckName(project)} snapshot; waiting before CI repair`,
+            });
+            return;
+        }
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubCiSnapshotHeadSha: snapshot.headSha,
+            lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName ?? this.getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: snapshot.gateCheckStatus,
+            lastGitHubCiSnapshotJson: JSON.stringify(snapshot),
+            lastGitHubCiSnapshotSettledAt: snapshot.settledAt ?? null,
+        });
+    }
+    async maybeEnqueueReactiveRun(issue, event, project) {
         // Don't trigger if there's already an active run
         if (issue.activeRunId !== undefined)
             return;
@@ -208,19 +294,26 @@ export class GitHubWebhookHandler {
         if (event.triggerEvent === "check_failed" && issue.prState === "open") {
             // External merge queue eviction: react only to the configured check
             // name, not to any CI failure. Regular CI failures still get ci_repair.
-            const protocol = resolveMergeQueueProtocol(project);
-            const queueCheckName = protocol.evictionCheckName;
-            if (issue.factoryState === "awaiting_queue"
-                && event.checkName === queueCheckName) {
+            if (this.isQueueEvictionFailure(issue, event, project)) {
                 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 +332,53 @@ export class GitHubWebhookHandler {
                 });
             }
             else {
+                if (!this.isSettledBranchFailure(issue, event, project)) {
+                    this.feed?.publish({
+                        level: "info",
+                        kind: "github",
+                        issueKey: issue.issueKey,
+                        projectId: issue.projectId,
+                        stage: issue.factoryState,
+                        status: "ci_waiting_for_settlement",
+                        summary: `Waiting for settled ${this.getPrimaryGateCheckName(project)} result before starting CI repair`,
+                    });
+                    return;
+                }
+                const failureContext = await this.resolveBranchFailureContext(issue, event, project);
+                if (this.hasDuplicatePendingReactiveRun(issue, "ci_repair", failureContext)) {
+                    return;
+                }
+                const snapshot = this.getRelevantCiSnapshot(issue, event);
                 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),
+                        ...(snapshot ? { ciSnapshot: snapshot } : {}),
                     }),
                     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 +395,27 @@ 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);
-        const protocol = resolveMergeQueueProtocol(project);
-        const isQueueEvictionCheck = event.eventSource === "check_run" && event.checkName === protocol.evictionCheckName;
+    async updateFailureProvenance(issue, event, project) {
+        const isQueueEvictionCheck = this.isQueueEvictionFailure(issue, event, project);
         if (event.triggerEvent === "check_failed" && issue.prState === "open") {
-            if (isMetadataOnlyCheckEvent(event) && !isQueueEvictionCheck) {
-                return;
-            }
-            const source = issue.factoryState === "awaiting_queue" && isQueueEvictionCheck
+            const source = isQueueEvictionCheck
                 ? "queue_eviction"
                 : "branch_ci";
+            if (source === "branch_ci" && !this.isSettledBranchFailure(issue, event, project)) {
+                return;
+            }
+            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"
                     ? {
@@ -301,19 +428,172 @@ export class GitHubWebhookHandler {
             });
             return;
         }
-        if ((event.triggerEvent === "check_passed" && (!isMetadataOnlyCheckEvent(event) || isQueueEvictionCheck))
+        if ((event.triggerEvent === "check_passed" && (!isMetadataOnlyCheckEvent(event) || isQueueEvictionCheck || this.isGateCheckEvent(event, project)))
             || event.triggerEvent === "pr_synchronize"
             || event.triggerEvent === "pr_merged") {
+            if (event.triggerEvent === "check_passed" && !this.canClearFailureProvenance(issue, event, project)) {
+                return;
+            }
             this.db.upsertIssue({
                 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 snapshot = this.getRelevantCiSnapshot(issue, event);
+        const primaryFailedCheck = snapshot ? this.pickPrimaryFailedCheck(snapshot) : undefined;
+        const context = await this.failureContextResolver.resolve({
+            source: "branch_ci",
+            repoFullName,
+            event: primaryFailedCheck
+                ? {
+                    ...event,
+                    checkName: primaryFailedCheck.name,
+                    checkUrl: primaryFailedCheck.detailsUrl ?? event.checkUrl,
+                    checkDetailsUrl: primaryFailedCheck.detailsUrl ?? event.checkDetailsUrl,
+                }
+                : 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;
+    }
+    getGateCheckNames(project) {
+        const configured = (project?.gateChecks ?? []).map((entry) => entry.trim()).filter(Boolean);
+        return configured.length > 0 ? configured : ["Tests"];
+    }
+    getPrimaryGateCheckName(project) {
+        return this.getGateCheckNames(project)[0] ?? "Tests";
+    }
+    isGateCheckEvent(event, project) {
+        if (event.eventSource !== "check_run" || !event.checkName)
+            return false;
+        const normalized = event.checkName.trim().toLowerCase();
+        return this.getGateCheckNames(project).some((entry) => entry.trim().toLowerCase() === normalized);
+    }
+    isStaleGateEvent(issue, event) {
+        return Boolean(issue.lastGitHubCiSnapshotHeadSha
+            && event.headSha
+            && issue.lastGitHubCiSnapshotHeadSha !== event.headSha);
+    }
+    isQueueEvictionFailure(issue, event, project) {
+        const protocol = resolveMergeQueueProtocol(project);
+        return issue.factoryState === "awaiting_queue"
+            && event.eventSource === "check_run"
+            && event.checkName === protocol.evictionCheckName;
+    }
+    isSettledBranchFailure(issue, event, project) {
+        if (event.triggerEvent !== "check_failed" || issue.prState !== "open")
+            return false;
+        if (!this.isGateCheckEvent(event, project))
+            return false;
+        const snapshot = this.getRelevantCiSnapshot(issue, event);
+        return snapshot?.gateCheckStatus === "failure" && snapshot.headSha === event.headSha;
+    }
+    canClearFailureProvenance(issue, event, project) {
+        if (event.triggerEvent !== "check_passed")
+            return true;
+        if (this.isQueueEvictionFailure(issue, event, project)) {
+            return !issue.lastGitHubFailureHeadSha || issue.lastGitHubFailureHeadSha === event.headSha;
+        }
+        if (!this.isGateCheckEvent(event, project)) {
+            return true;
+        }
+        if (this.isStaleGateEvent(issue, event)) {
+            return false;
+        }
+        return !issue.lastGitHubFailureHeadSha || issue.lastGitHubFailureHeadSha === event.headSha;
+    }
+    getRelevantCiSnapshot(issue, event) {
+        const snapshot = this.db.getLatestGitHubCiSnapshot(issue.projectId, issue.linearIssueId);
+        if (!snapshot)
+            return undefined;
+        if (snapshot.headSha !== event.headSha)
+            return undefined;
+        return snapshot;
+    }
+    pickPrimaryFailedCheck(snapshot) {
+        const gateName = snapshot.gateCheckName?.trim().toLowerCase();
+        return snapshot.failedChecks.find((entry) => entry.name.trim().toLowerCase() !== gateName)
+            ?? snapshot.failedChecks[0];
     }
     async emitLinearActivity(issue, newState, event) {
         if (!issue.agentSessionId)
@@ -421,9 +701,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,