patchrelay 0.37.1 → 0.38.1

package/dist/github-webhook-issue-resolution.js

@@ -0,0 +1,46 @@
+export function resolveGitHubWebhookIssue(db, project, event) {
+    if (event.prNumber !== undefined) {
+        const byPr = db.issues.getIssueByPrNumber(event.prNumber);
+        if (byPr && byPr.projectId === project.id) {
+            return { issue: byPr, linkedBy: "pr" };
+        }
+    }
+    const byBranch = db.issues.getIssueByBranch(event.branchName);
+    if (byBranch && byBranch.projectId === project.id) {
+        return { issue: byBranch, linkedBy: "branch" };
+    }
+    const byIssueKey = resolveGitHubWebhookIssueByKey(db, project, event);
+    if (byIssueKey) {
+        return { issue: byIssueKey, linkedBy: "issue_key" };
+    }
+    return undefined;
+}
+export function resolveGitHubWebhookIssueByKey(db, project, event) {
+    const candidates = new Set();
+    const sources = [event.prTitle, event.prBody, event.branchName];
+    for (const prefix of project.issueKeyPrefixes) {
+        const normalizedPrefix = prefix.trim();
+        if (!normalizedPrefix)
+            continue;
+        const pattern = new RegExp(`\\b${escapeRegExp(normalizedPrefix)}-\\d+\\b`, "gi");
+        for (const source of sources) {
+            if (!source)
+                continue;
+            for (const match of source.matchAll(pattern)) {
+                candidates.add(match[0].toUpperCase());
+            }
+        }
+    }
+    if (candidates.size !== 1) {
+        return undefined;
+    }
+    const [issueKey] = [...candidates];
+    if (!issueKey) {
+        return undefined;
+    }
+    const issue = db.issues.getIssueByKey(issueKey);
+    return issue?.projectId === project.id ? issue : undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/github-webhook-policy.js

@@ -0,0 +1,105 @@
+import { resolveFactoryStateFromGitHub } from "./factory-state.js";
+import { resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
+import { isIssueTerminal } from "./pr-state.js";
+const DEFAULT_GATE_CHECK_NAMES = ["verify", "tests"];
+/**
+ * GitHub sends both check_run and check_suite completion events.
+ * 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
+ * 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.
+ */
+export function isMetadataOnlyCheckEvent(event) {
+    return event.eventSource === "check_run"
+        && (event.triggerEvent === "check_passed" || event.triggerEvent === "check_failed");
+}
+export function getGateCheckNames(project) {
+    const configured = (project?.gateChecks ?? []).map((entry) => entry.trim()).filter(Boolean);
+    return configured.length > 0 ? configured : DEFAULT_GATE_CHECK_NAMES;
+}
+export function getPrimaryGateCheckName(project) {
+    return getGateCheckNames(project)[0] ?? "verify";
+}
+export function isGateCheckEvent(event, project) {
+    if (event.eventSource !== "check_run" || !event.checkName)
+        return false;
+    const normalized = event.checkName.trim().toLowerCase();
+    return getGateCheckNames(project).some((entry) => entry.trim().toLowerCase() === normalized);
+}
+export function deriveImmediatePrCheckStatus(issue, event, project) {
+    if (event.triggerEvent === "pr_synchronize") {
+        return "pending";
+    }
+    if (event.eventSource !== "check_run") {
+        return undefined;
+    }
+    if (!isGateCheckEvent(event, project)) {
+        return undefined;
+    }
+    if (isStaleGateEvent(issue, event)) {
+        return undefined;
+    }
+    return event.checkStatus;
+}
+export function isStaleGateEvent(issue, event) {
+    return Boolean(issue.lastGitHubCiSnapshotHeadSha
+        && event.headSha
+        && issue.lastGitHubCiSnapshotHeadSha !== event.headSha);
+}
+export function isQueueEvictionFailure(issue, event, project) {
+    const protocol = resolveMergeQueueProtocol(project);
+    return event.eventSource === "check_run"
+        && event.checkName === protocol.evictionCheckName;
+}
+export function isSettledBranchFailure(db, issue, event, project) {
+    if (event.triggerEvent !== "check_failed" || issue.prState !== "open")
+        return false;
+    if (!isGateCheckEvent(event, project))
+        return false;
+    const snapshot = db.issues.getLatestGitHubCiSnapshot(issue.projectId, issue.linearIssueId);
+    if (!snapshot || snapshot.headSha !== event.headSha)
+        return false;
+    return snapshot?.gateCheckStatus === "failure" && snapshot.headSha === event.headSha;
+}
+export function canClearFailureProvenance(issue, event, project) {
+    if (event.triggerEvent !== "check_passed")
+        return true;
+    if (isQueueEvictionFailure(issue, event, project)) {
+        return !issue.lastGitHubFailureHeadSha || issue.lastGitHubFailureHeadSha === event.headSha;
+    }
+    if (!isGateCheckEvent(event, project)) {
+        return true;
+    }
+    if (isStaleGateEvent(issue, event)) {
+        return false;
+    }
+    return !issue.lastGitHubFailureHeadSha || issue.lastGitHubFailureHeadSha === event.headSha;
+}
+export function resolveGitHubFactoryStateForEvent(issue, event, project) {
+    if (event.triggerEvent === "pr_closed") {
+        return undefined;
+    }
+    const effectiveCurrentState = (issue.factoryState === "awaiting_input" || issue.factoryState === "delegated")
+        && (event.prState === "open" || event.prNumber !== undefined)
+        ? "pr_open"
+        : issue.factoryState;
+    if (event.triggerEvent === "check_failed"
+        && isQueueEvictionFailure(issue, event, project)
+        && issue.prState === "open"
+        && issue.activeRunId === undefined
+        && !isIssueTerminal(issue)) {
+        return "repairing_queue";
+    }
+    const resolved = resolveFactoryStateFromGitHub(event.triggerEvent, effectiveCurrentState, {
+        prReviewState: issue.prReviewState,
+        activeRunId: issue.activeRunId,
+    });
+    if (resolved !== undefined) {
+        return resolved;
+    }
+    if (effectiveCurrentState !== issue.factoryState) {
+        return effectiveCurrentState;
+    }
+    return undefined;
+}

package/dist/github-webhook-reactive-run.js

@@ -0,0 +1,302 @@
+import { summarizeGitHubFailureContext } from "./github-failure-context.js";
+import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
+import { isIssueTerminal } from "./pr-state.js";
+import { buildGitHubQueueFailureContext, getRelevantGitHubCiSnapshot, resolveGitHubBranchFailureContext, resolveGitHubCheckClass, } from "./github-webhook-failure-context.js";
+import { isQueueEvictionFailure, isSettledBranchFailure } from "./github-webhook-policy.js";
+export async function maybeEnqueueGitHubReactiveRun(params) {
+    const { issue, event, project, logger, feed, enqueueIssue, db, fetchImpl, failureContextResolver } = params;
+    if (issue.activeRunId !== undefined)
+        return;
+    if (isIssueTerminal(issue))
+        return;
+    if (!issue.delegatedToPatchRelay) {
+        feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "ignored_undelegated",
+            summary: `Ignored ${event.triggerEvent} because the issue is undelegated`,
+        });
+        return;
+    }
+    if (event.triggerEvent === "check_failed" && issue.prState === "open") {
+        await handleCheckFailedEvent({
+            db,
+            logger,
+            feed,
+            enqueueIssue,
+            issue,
+            event,
+            project,
+            failureContextResolver,
+        });
+        return;
+    }
+    if (event.triggerEvent === "review_changes_requested") {
+        await handleRequestedChangesEvent({
+            db,
+            logger,
+            feed,
+            enqueueIssue,
+            issue,
+            event,
+            fetchImpl,
+        });
+    }
+}
+async function handleCheckFailedEvent(params) {
+    const { db, logger, feed, enqueueIssue, issue, event, project, failureContextResolver } = params;
+    if (isQueueEvictionFailure(issue, event, project)) {
+        const queueRepairContext = buildQueueRepairContextFromEvent(event);
+        const failureContext = buildGitHubQueueFailureContext(event, project, queueRepairContext);
+        if (hasDuplicatePendingReactiveRun(db, feed, issue, "queue_repair", failureContext)) {
+            return;
+        }
+        const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+        db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "merge_steward_incident",
+            eventJson: JSON.stringify({
+                ...queueRepairContext,
+                ...failureContext,
+            }),
+            dedupeKey: failureContext.failureSignature,
+        });
+        const queuedRunType = hadPendingWake
+            ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
+            : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
+        logger.info({ issueKey: issue.issueKey, checkName: event.checkName }, "Queue eviction detected, enqueued queue repair");
+        feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: "repairing_queue",
+            status: "queue_repair_queued",
+            summary: `${queuedRunType ?? "queue_repair"} queued after external failure from ${event.checkName}`,
+            detail: queueRepairContext.incidentSummary ?? queueRepairContext.incidentUrl ?? event.checkUrl,
+        });
+        return;
+    }
+    if (!isSettledBranchFailure(db, issue, event, project)) {
+        feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "ci_waiting_for_settlement",
+            summary: `Waiting for settled ${project?.gateChecks?.[0] ?? "verify"} result before starting CI repair`,
+        });
+        return;
+    }
+    const failureContext = await resolveGitHubBranchFailureContext({
+        db,
+        issue,
+        event,
+        project,
+        failureContextResolver,
+    });
+    if (hasDuplicatePendingReactiveRun(db, feed, issue, "ci_repair", failureContext)) {
+        return;
+    }
+    const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+    const snapshot = getRelevantGitHubCiSnapshot(db, issue, event);
+    db.issues.upsertIssue({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        lastGitHubFailureSource: "branch_ci",
+        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,
+    });
+    db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        eventType: "settled_red_ci",
+        eventJson: JSON.stringify({
+            ...failureContext,
+            checkClass: resolveGitHubCheckClass(failureContext.checkName ?? event.checkName, project),
+            ...(snapshot ? { ciSnapshot: snapshot } : {}),
+        }),
+        dedupeKey: failureContext.failureSignature,
+    });
+    const queuedRunType = hadPendingWake
+        ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
+        : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
+    logger.info({ issueKey: issue.issueKey, checkName: failureContext.checkName ?? event.checkName }, "Enqueued CI repair run");
+    feed?.publish({
+        level: "warn",
+        kind: "github",
+        issueKey: issue.issueKey,
+        projectId: issue.projectId,
+        stage: "repairing_ci",
+        status: "ci_repair_queued",
+        summary: `${queuedRunType ?? "ci_repair"} queued for ${failureContext.jobName ?? failureContext.checkName ?? "failed check"}`,
+        detail: summarizeGitHubFailureContext(failureContext),
+    });
+}
+async function handleRequestedChangesEvent(params) {
+    const { db, logger, feed, enqueueIssue, issue, event, fetchImpl } = params;
+    const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+    const reviewComments = await fetchReviewCommentsForEvent(event, fetchImpl).catch((error) => {
+        logger.warn({
+            issueKey: issue.issueKey,
+            prNumber: event.prNumber,
+            reviewId: event.reviewId,
+            error: error instanceof Error ? error.message : String(error),
+        }, "Failed to fetch inline review comments for requested-changes event");
+        return undefined;
+    });
+    db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        eventType: "review_changes_requested",
+        eventJson: JSON.stringify({
+            reviewBody: event.reviewBody,
+            reviewCommitId: event.reviewCommitId,
+            reviewId: event.reviewId,
+            reviewUrl: buildGitHubReviewUrl(event.repoFullName, event.prNumber, event.reviewId),
+            reviewerName: event.reviewerName,
+            ...(reviewComments && reviewComments.length > 0 ? { reviewComments } : {}),
+        }),
+        dedupeKey: [
+            "review_changes_requested",
+            issue.prHeadSha ?? event.headSha ?? "unknown-sha",
+            event.reviewerName ?? "unknown-reviewer",
+        ].join("::"),
+    });
+    const queuedRunType = hadPendingWake
+        ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
+        : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
+    logger.info({ issueKey: issue.issueKey, reviewerName: event.reviewerName }, "Enqueued review fix run");
+    feed?.publish({
+        level: "warn",
+        kind: "github",
+        issueKey: issue.issueKey,
+        projectId: issue.projectId,
+        stage: "changes_requested",
+        status: "review_fix_queued",
+        summary: `${queuedRunType ?? "review_fix"} queued after requested changes`,
+        detail: reviewComments && reviewComments.length > 0
+            ? `${reviewComments.length} inline review comment${reviewComments.length === 1 ? "" : "s"} captured`
+            : event.reviewBody?.slice(0, 200) ?? event.reviewerName,
+    });
+}
+function hasDuplicatePendingReactiveRun(db, feed, 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;
+    const pendingWake = db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+    if (pendingWake?.runType === runType && pendingWake.eventIds.length > 0) {
+        const existing = pendingWake.context;
+        if (existing?.failureSignature === signature
+            && (headSha === undefined || existing.failureHeadSha === headSha || existing.headSha === headSha)) {
+            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)) {
+        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;
+}
+function enqueuePendingSessionWake(db, enqueueIssue, projectId, issueId) {
+    const wake = db.issueSessions.peekIssueSessionWake(projectId, issueId);
+    if (!wake) {
+        return undefined;
+    }
+    enqueueIssue(projectId, issueId);
+    return wake.runType;
+}
+async function fetchReviewCommentsForEvent(event, fetchImpl) {
+    if (event.triggerEvent !== "review_changes_requested") {
+        return undefined;
+    }
+    if (!event.repoFullName || event.prNumber === undefined || event.reviewId === undefined) {
+        return undefined;
+    }
+    const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+    if (!token) {
+        return undefined;
+    }
+    const [owner, repo] = event.repoFullName.split("/", 2);
+    if (!owner || !repo) {
+        return undefined;
+    }
+    const response = await fetchImpl(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${event.prNumber}/reviews/${event.reviewId}/comments?per_page=100`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "User-Agent": "patchrelay",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub review comment fetch failed (${response.status})`);
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload)) {
+        return undefined;
+    }
+    const comments = [];
+    for (const entry of payload) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const body = typeof record.body === "string" ? record.body.trim() : "";
+        const id = typeof record.id === "number" ? record.id : undefined;
+        if (!body || id === undefined)
+            continue;
+        comments.push({
+            id,
+            body,
+            ...(typeof record.path === "string" ? { path: record.path } : {}),
+            ...(typeof record.line === "number" ? { line: record.line } : {}),
+            ...(typeof record.side === "string" ? { side: record.side } : {}),
+            ...(typeof record.start_line === "number" ? { startLine: record.start_line } : {}),
+            ...(typeof record.start_side === "string" ? { startSide: record.start_side } : {}),
+            ...(typeof record.commit_id === "string" ? { commitId: record.commit_id } : {}),
+            ...(typeof record.html_url === "string" ? { url: record.html_url } : {}),
+            ...(typeof record.diff_hunk === "string" ? { diffHunk: record.diff_hunk } : {}),
+            ...(typeof record.user?.login === "string"
+                ? { authorLogin: String(record.user.login) }
+                : {}),
+        });
+    }
+    return comments;
+}
+function buildGitHubReviewUrl(repoFullName, prNumber, reviewId) {
+    if (!repoFullName || prNumber === undefined || reviewId === undefined) {
+        return undefined;
+    }
+    return `https://github.com/${repoFullName}/pull/${prNumber}#pullrequestreview-${reviewId}`;
+}

package/dist/github-webhook-state-projector.js

@@ -0,0 +1,231 @@
+import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver } from "./github-failure-context.js";
+import { buildClosedPrCleanupFields } from "./pr-state.js";
+import { canClearFailureProvenance, deriveImmediatePrCheckStatus, getGateCheckNames, getPrimaryGateCheckName, isGateCheckEvent, isMetadataOnlyCheckEvent, isQueueEvictionFailure, isStaleGateEvent, isSettledBranchFailure, resolveGitHubFactoryStateForEvent, } from "./github-webhook-policy.js";
+import { buildGitHubQueueFailureContext, resolveGitHubBranchFailureContext, } from "./github-webhook-failure-context.js";
+import { emitGitHubLinearActivity, syncGitHubLinearSession } from "./github-linear-session-sync.js";
+import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
+export async function projectGitHubWebhookState(deps, issue, event, project, linkedBy) {
+    const failureContextResolver = deps.failureContextResolver ?? createGitHubFailureContextResolver();
+    const ciSnapshotResolver = deps.ciSnapshotResolver ?? createGitHubCiSnapshotResolver();
+    const immediateCheckStatus = deriveImmediatePrCheckStatus(issue, event, project);
+    deps.db.issues.upsertIssue({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        ...(event.prNumber !== undefined ? { prNumber: event.prNumber } : {}),
+        ...(event.prUrl !== undefined ? { prUrl: event.prUrl } : {}),
+        ...(event.prState !== undefined ? { prState: event.prState } : {}),
+        ...(event.headSha !== undefined ? { prHeadSha: event.headSha } : {}),
+        ...(event.prAuthorLogin !== undefined ? { prAuthorLogin: event.prAuthorLogin } : {}),
+        ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
+        ...(immediateCheckStatus !== undefined ? { prCheckStatus: immediateCheckStatus } : {}),
+        ...(linkedBy === "issue_key" ? { branchName: event.branchName } : {}),
+        ...(event.reviewState === "changes_requested"
+            ? { lastBlockingReviewHeadSha: event.reviewCommitId ?? event.headSha ?? null }
+            : event.reviewState === "approved"
+                ? { lastBlockingReviewHeadSha: null }
+                : {}),
+        ...(event.triggerEvent === "pr_closed"
+            ? buildClosedPrCleanupFields()
+            : {}),
+    });
+    await updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotResolver);
+    await updateGitHubFailureProvenance(deps, issue, event, project, failureContextResolver);
+    const queueEvictionCheck = isQueueEvictionFailure(issue, event, project);
+    if (!isMetadataOnlyCheckEvent(event) || queueEvictionCheck) {
+        const afterMetadata = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        const newState = resolveGitHubFactoryStateForEvent(afterMetadata, event, project);
+        if (newState && newState !== afterMetadata.factoryState) {
+            deps.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: newState,
+            });
+            deps.logger.info({ issueKey: issue.issueKey, from: afterMetadata.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
+            const transitionedIssue = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+            void emitGitHubLinearActivity({
+                linearProvider: deps.linearProvider,
+                logger: deps.logger,
+                feed: deps.feed,
+                issue: transitionedIssue,
+                newState,
+                event,
+            });
+            void syncGitHubLinearSession({
+                config: deps.config,
+                linearProvider: deps.linearProvider,
+                logger: deps.logger,
+                issue: transitionedIssue,
+            });
+        }
+    }
+    const freshIssue = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+    if (event.triggerEvent === "pr_synchronize" && !freshIssue.activeRunId) {
+        deps.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ciRepairAttempts: 0,
+            queueRepairAttempts: 0,
+            lastGitHubFailureSource: null,
+            lastGitHubFailureHeadSha: null,
+            lastGitHubFailureSignature: null,
+            lastGitHubFailureCheckName: null,
+            lastGitHubFailureCheckUrl: null,
+            lastGitHubFailureContextJson: null,
+            lastGitHubFailureAt: null,
+            lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
+            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: "pending",
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+            lastQueueIncidentJson: null,
+            lastAttemptedFailureHeadSha: null,
+            lastAttemptedFailureSignature: null,
+        });
+    }
+    deps.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
+    deps.feed?.publish({
+        level: event.triggerEvent.includes("failed") ? "warn" : "info",
+        kind: "github",
+        issueKey: freshIssue.issueKey,
+        projectId: freshIssue.projectId,
+        stage: freshIssue.factoryState,
+        status: event.triggerEvent,
+        summary: `GitHub: ${event.triggerEvent}${event.prNumber ? ` on PR #${event.prNumber}` : ""}`,
+        detail: event.checkName ?? event.reviewBody?.slice(0, 200) ?? undefined,
+    });
+    return freshIssue;
+}
+async function updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotResolver) {
+    if (event.triggerEvent === "pr_merged") {
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubCiSnapshotHeadSha: null,
+            lastGitHubCiSnapshotGateCheckName: null,
+            lastGitHubCiSnapshotGateCheckStatus: null,
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+        });
+        return;
+    }
+    if (event.triggerEvent === "pr_synchronize") {
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
+            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: "pending",
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+        });
+        return;
+    }
+    if (issue.prState !== "open")
+        return;
+    if (event.eventSource !== "check_run")
+        return;
+    if (isQueueEvictionFailure(issue, event, project))
+        return;
+    if (!isGateCheckEvent(event, project))
+        return;
+    if (isStaleGateEvent(issue, event))
+        return;
+    const snapshot = await ciSnapshotResolver.resolve({
+        repoFullName: project?.github?.repoFullName ?? event.repoFullName,
+        event,
+        gateCheckNames: getGateCheckNames(project),
+    });
+    if (!snapshot) {
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
+            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: "pending",
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+        });
+        deps.logger.warn({ issueKey: issue.issueKey, repoFullName: project?.github?.repoFullName ?? event.repoFullName, headSha: event.headSha }, "Could not resolve settled CI snapshot; waiting before CI repair");
+        deps.feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "ci_snapshot_unavailable",
+            summary: `Could not resolve settled ${getPrimaryGateCheckName(project)} snapshot; waiting before CI repair`,
+        });
+        return;
+    }
+    deps.db.issues.upsertIssue({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        prCheckStatus: snapshot.gateCheckStatus,
+        lastGitHubCiSnapshotHeadSha: snapshot.headSha,
+        lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName ?? getPrimaryGateCheckName(project),
+        lastGitHubCiSnapshotGateCheckStatus: snapshot.gateCheckStatus,
+        lastGitHubCiSnapshotJson: JSON.stringify(snapshot),
+        lastGitHubCiSnapshotSettledAt: snapshot.settledAt ?? null,
+    });
+}
+async function updateGitHubFailureProvenance(deps, issue, event, project, failureContextResolver) {
+    const isQueueEvictionCheck = isQueueEvictionFailure(issue, event, project);
+    if (event.triggerEvent === "check_failed" && issue.prState === "open") {
+        const source = isQueueEvictionCheck
+            ? "queue_eviction"
+            : "branch_ci";
+        if (source === "branch_ci" && !isSettledBranchFailure(deps.db, issue, event, project)) {
+            return;
+        }
+        const failureContext = source === "queue_eviction"
+            ? buildGitHubQueueFailureContext(event, project, buildQueueRepairContextFromEvent(event))
+            : await resolveGitHubBranchFailureContext({
+                db: deps.db,
+                issue,
+                event,
+                project,
+                failureContextResolver,
+            });
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubFailureSource: source,
+            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"
+                ? {
+                    lastQueueSignalAt: new Date().toISOString(),
+                    lastQueueIncidentJson: JSON.stringify(buildQueueRepairContextFromEvent(event)),
+                }
+                : {
+                    lastQueueIncidentJson: null,
+                }),
+        });
+        return;
+    }
+    if ((event.triggerEvent === "check_passed" && (!isMetadataOnlyCheckEvent(event) || isQueueEvictionFailure(issue, event, project) || isGateCheckEvent(event, project)))
+        || event.triggerEvent === "pr_synchronize"
+        || event.triggerEvent === "pr_merged") {
+        if (event.triggerEvent === "check_passed" && !canClearFailureProvenance(issue, event, project)) {
+            return;
+        }
+        deps.db.issues.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,
+        });
+    }
+}