patchrelay 0.38.0 → 0.38.1

package/dist/github-webhook-handler.js

@@ -1,28 +1,12 @@
-import { resolveFactoryStateFromGitHub } 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";
-import { buildGitHubStateActivity } from "./linear-session-reporting.js";
-import { resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
-import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
-import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
-import { buildClosedPrCleanupFields, isIssueTerminal, resolveClosedPrFactoryState, resolveClosedPrDisposition, } from "./pr-state.js";
 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 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"
-        && (event.triggerEvent === "check_passed" || event.triggerEvent === "check_failed");
-}
-const DEFAULT_GATE_CHECK_NAMES = ["verify", "tests"];
+import { GitHubPrCommentHandler } from "./github-pr-comment-handler.js";
+import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver, } from "./github-failure-context.js";
+import { resolveGitHubWebhookIssue } from "./github-webhook-issue-resolution.js";
+import { projectGitHubWebhookState } from "./github-webhook-state-projector.js";
+import { maybeEnqueueGitHubReactiveRun } from "./github-webhook-reactive-run.js";
+import { handleGitHubTerminalPrEvent } from "./github-webhook-terminal-handler.js";
 export class GitHubWebhookHandler {
     config;
     db;
@@ -34,6 +18,7 @@ export class GitHubWebhookHandler {
     failureContextResolver;
     ciSnapshotResolver;
     fetchImpl;
+    prCommentHandler;
     constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed, failureContextResolver = createGitHubFailureContextResolver(), ciSnapshotResolver = createGitHubCiSnapshotResolver(), fetchImpl = fetch) {
         this.config = config;
         this.db = db;
@@ -45,20 +30,17 @@ export class GitHubWebhookHandler {
         this.failureContextResolver = failureContextResolver;
         this.ciSnapshotResolver = ciSnapshotResolver;
         this.fetchImpl = fetchImpl;
+        this.prCommentHandler = new GitHubPrCommentHandler(db, enqueueIssue, logger, codex, feed);
     }
     async acceptGitHubWebhook(params) {
-        // Deduplicate
         if (this.db.webhookEvents.isWebhookDuplicate(params.deliveryId)) {
             return { status: 200, body: { ok: true, duplicate: true } };
         }
-        // Store the event
         const stored = this.db.webhookEvents.insertWebhookEvent(params.deliveryId, new Date().toISOString());
-        // Parse payload
         const payload = safeJsonParse(params.rawBody.toString("utf8"));
         if (!payload) {
             return { status: 400, body: { ok: false, reason: "invalid_json" } };
         }
-        // Find matching project by repo
         const repoFullName = typeof payload === "object" && payload !== null && "repository" in payload
             ? payload.repository
             : undefined;
@@ -68,12 +50,9 @@ export class GitHubWebhookHandler {
         const project = repoName
             ? this.config.projects.find((p) => p.github?.repoFullName === repoName)
             : undefined;
-        // Verify signature using global GitHub App webhook secret
         const webhookSecret = resolveSecret("github-app-webhook-secret", "GITHUB_APP_WEBHOOK_SECRET");
-        if (webhookSecret) {
-            if (!verifyGitHubWebhookSignature(params.rawBody, webhookSecret, params.signature)) {
-                return { status: 401, body: { ok: false, reason: "invalid_signature" } };
-            }
+        if (webhookSecret && !verifyGitHubWebhookSignature(params.rawBody, webhookSecret, params.signature)) {
+            return { status: 401, body: { ok: false, reason: "invalid_signature" } };
         }
         if (stored.duplicate) {
             return { status: 200, body: { ok: true, duplicate: true } };
@@ -93,20 +72,11 @@ export class GitHubWebhookHandler {
         const payload = safeJsonParse(params.rawBody);
         if (!payload || typeof payload !== "object")
             return;
-        // Push to a base branch advances the merge queue for affected projects.
-        // This catches external merges (human PRs, direct pushes) that PatchRelay
-        // does not track as issues but that make queued branches stale.
         if (params.eventType === "push") {
-            const pushPayload = payload;
-            const ref = pushPayload.ref;
-            const repoFullName = pushPayload.repository?.full_name;
-            if (ref && repoFullName) {
-                // Push to base branch — external merge queue handles advancement.
-            }
             return;
         }
         if (params.eventType === "issue_comment") {
-            await this.handlePrComment(payload);
+            await this.prCommentHandler.handleCreatedComment(payload);
             return;
         }
         const event = normalizeGitHubWebhook({
@@ -122,949 +92,44 @@ export class GitHubWebhookHandler {
             this.logger.debug({ repoFullName: event.repoFullName, triggerEvent: event.triggerEvent }, "GitHub webhook: no configured project for repository");
             return;
         }
-        const resolved = this.resolveIssueForEvent(project, event);
+        const resolved = resolveGitHubWebhookIssue(this.db, project, event);
         const issue = resolved?.issue;
         if (!issue) {
             this.logger.debug({ repoFullName: event.repoFullName, branchName: event.branchName, prNumber: event.prNumber, triggerEvent: event.triggerEvent }, "GitHub webhook: no matching tracked issue");
             return;
         }
-        const immediateCheckStatus = this.deriveImmediatePrCheckStatus(issue, event, project);
-        // Update PR state on the issue
-        this.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 } : {}),
-            ...(resolved.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 this.updateCiSnapshot(issue, event, project);
-        await this.updateFailureProvenance(issue, event, project);
-        const queueEvictionCheck = this.isQueueEvictionFailure(issue, event, project);
-        if (!isMetadataOnlyCheckEvent(event) || queueEvictionCheck) {
-            // Re-read issue after PR metadata upsert so guards see fresh prReviewState
-            const afterMetadata = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-            const newState = this.resolveFactoryStateForEvent(afterMetadata, event, project);
-            // Only transition and notify when the state actually changes.
-            // Multiple check_suite events can arrive for the same outcome.
-            if (newState && newState !== afterMetadata.factoryState) {
-                this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    factoryState: newState,
-                });
-                this.logger.info({ issueKey: issue.issueKey, from: afterMetadata.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
-                const transitionedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-                void this.emitLinearActivity(transitionedIssue, newState, event);
-                void this.syncLinearSession(transitionedIssue);
-            }
-        }
-        // Re-read issue after all upserts so reactive run logic sees current state
-        const freshIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-        // Reset repair counters on new push — but only when no repair run is active,
-        // since Codex pushes during repair and resetting mid-run would bypass budgets.
-        if (event.triggerEvent === "pr_synchronize" && !freshIssue.activeRunId) {
-            this.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: 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");
-        this.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,
-        });
-        // 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.
-        if (queueEvictionCheck || this.isGateCheckEvent(event, project)) {
-            await this.maybeEnqueueReactiveRun(freshIssue, event, project);
-        }
-        else if (!isMetadataOnlyCheckEvent(event)) {
-            await this.maybeEnqueueReactiveRun(freshIssue, event, project);
-        }
-        if (event.triggerEvent === "pr_merged" || event.triggerEvent === "pr_closed") {
-            await this.handleTerminalPrEvent(freshIssue, event);
-        }
-    }
-    resolveIssueForEvent(project, event) {
-        if (event.prNumber !== undefined) {
-            const byPr = this.db.issues.getIssueByPrNumber(event.prNumber);
-            if (byPr && byPr.projectId === project.id) {
-                return { issue: byPr, linkedBy: "pr" };
-            }
-        }
-        const byBranch = this.db.issues.getIssueByBranch(event.branchName);
-        if (byBranch && byBranch.projectId === project.id) {
-            return { issue: byBranch, linkedBy: "branch" };
-        }
-        const byIssueKey = this.resolveIssueByExplicitIssueKey(project, event);
-        if (byIssueKey) {
-            return { issue: byIssueKey, linkedBy: "issue_key" };
-        }
-        return undefined;
-    }
-    resolveIssueByExplicitIssueKey(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 = this.db.issues.getIssueByKey(issueKey);
-        return issue?.projectId === project.id ? issue : undefined;
-    }
-    resolveFactoryStateForEvent(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"
-            && this.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;
-    }
-    async updateCiSnapshot(issue, event, project) {
-        if (event.triggerEvent === "pr_merged") {
-            this.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") {
-            this.db.issues.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,
+        const freshIssue = await projectGitHubWebhookState({
+            config: this.config,
+            db: this.db,
+            linearProvider: this.linearProvider,
+            logger: this.logger,
+            feed: this.feed,
+            failureContextResolver: this.failureContextResolver,
+            ciSnapshotResolver: this.ciSnapshotResolver,
+        }, issue, event, project, resolved.linkedBy);
+        await maybeEnqueueGitHubReactiveRun({
+            db: this.db,
+            logger: this.logger,
+            feed: this.feed,
+            enqueueIssue: this.enqueueIssue,
+            issue: freshIssue,
             event,
-            gateCheckNames: this.getGateCheckNames(project),
-        });
-        if (!snapshot) {
-            this.db.issues.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.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            prCheckStatus: snapshot.gateCheckStatus,
-            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;
-        // Don't trigger on terminal issues — late-arriving webhooks (e.g.
-        // merge_group_failed after pr_merged) must not resurrect done issues.
-        if (isIssueTerminal(issue))
-            return;
-        if (!issue.delegatedToPatchRelay) {
-            this.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") {
-            // External merge queue eviction: react only to the configured check
-            // name, not to any CI failure. Regular CI failures still get ci_repair.
-            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;
-                }
-                const hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
-                this.db.issues.upsertIssue({
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    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),
-                });
-                this.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
-                    ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
-                    : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
-                this.logger.info({ issueKey: issue.issueKey, checkName: event.checkName }, "Queue eviction detected, enqueued queue repair");
-                this.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,
-                });
-            }
-            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 hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
-                const snapshot = this.getRelevantCiSnapshot(issue, event);
-                this.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,
-                });
-                this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    eventType: "settled_red_ci",
-                    eventJson: JSON.stringify({
-                        ...failureContext,
-                        checkClass: resolveCheckClass(failureContext.checkName ?? event.checkName, project),
-                        ...(snapshot ? { ciSnapshot: snapshot } : {}),
-                    }),
-                    dedupeKey: failureContext.failureSignature,
-                });
-                const queuedRunType = hadPendingWake
-                    ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
-                    : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
-                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: `${queuedRunType ?? "ci_repair"} queued for ${failureContext.jobName ?? failureContext.checkName ?? "failed check"}`,
-                    detail: summarizeGitHubFailureContext(failureContext),
-                });
-            }
-        }
-        if (event.triggerEvent === "review_changes_requested") {
-            const hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
-            const reviewComments = await this.fetchReviewCommentsForEvent(event).catch((error) => {
-                this.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;
-            });
-            this.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
-                ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
-                : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
-            this.logger.info({ issueKey: issue.issueKey, reviewerName: event.reviewerName }, "Enqueued review fix run");
-            this.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,
-            });
-        }
-    }
-    async handleTerminalPrEvent(issue, event) {
-        const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
-        this.db.issueSessions.appendIssueSessionEvent({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            eventType,
-            dedupeKey: [eventType, issue.prNumber ?? event.prNumber ?? "unknown-pr", issue.prHeadSha ?? event.headSha ?? "unknown-sha"].join("::"),
-        });
-        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        const run = issue.activeRunId ? this.db.runs.getRunById(issue.activeRunId) : undefined;
-        if (run?.threadId && run.turnId) {
-            try {
-                await this.codex.steerTurn({
-                    threadId: run.threadId,
-                    turnId: run.turnId,
-                    input: event.triggerEvent === "pr_merged"
-                        ? "STOP: The pull request has already merged. Stop working immediately and exit without making further changes."
-                        : "STOP: The pull request was closed. Stop working immediately and exit without making further changes.",
-                });
-            }
-            catch (error) {
-                this.logger.warn({ issueKey: issue.issueKey, runId: run.id, error: error instanceof Error ? error.message : String(error) }, "Failed to steer active run after terminal PR event");
-            }
-        }
-        const commitTerminalUpdate = () => {
-            if (run) {
-                this.db.runs.finishRun(run.id, {
-                    status: "released",
-                    failureReason: event.triggerEvent === "pr_merged"
-                        ? "Pull request merged during active run"
-                        : "Pull request closed during active run",
-                });
-            }
-            const terminalFactoryState = event.triggerEvent === "pr_merged"
-                ? "done"
-                : resolveClosedPrFactoryState(issue);
-            this.db.issues.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                activeRunId: null,
-                factoryState: terminalFactoryState,
-            });
-        };
-        const activeLease = this.db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
-        if (activeLease) {
-            this.db.issueSessions.withIssueSessionLease(issue.projectId, issue.linearIssueId, activeLease.leaseId, commitTerminalUpdate);
-        }
-        else {
-            this.db.transaction(commitTerminalUpdate);
-        }
-        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        const updatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-        if (event.triggerEvent === "pr_closed" && resolveClosedPrDisposition(issue) === "redelegate") {
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "delegated",
-                dedupeKey: `github_pr_closed:implementation:${issue.linearIssueId}`,
-            });
-            if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
-                this.enqueueIssue(issue.projectId, issue.linearIssueId);
-            }
-        }
-        if (event.triggerEvent === "pr_merged") {
-            await this.completeLinearIssueAfterMerge(updatedIssue);
-        }
-        void this.syncLinearSession(updatedIssue);
-    }
-    async completeLinearIssueAfterMerge(issue) {
-        const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
-        if (!linear)
-            return;
-        try {
-            const liveIssue = await linear.getIssue(issue.linearIssueId);
-            const targetState = resolvePreferredCompletedLinearState(liveIssue);
-            if (!targetState) {
-                this.logger.warn({ issueKey: issue.issueKey }, "Could not find a completed Linear workflow state after merge");
-                return;
-            }
-            const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
-            if (normalizedCurrent === targetState.trim().toLowerCase()) {
-                this.db.issues.upsertIssue({
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-                    ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-                });
-                return;
-            }
-            const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-            this.db.issues.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-                ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
-            });
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to move merged issue to a completed Linear state");
-        }
-    }
-    async updateFailureProvenance(issue, event, project) {
-        const isQueueEvictionCheck = this.isQueueEvictionFailure(issue, event, project);
-        if (event.triggerEvent === "check_failed" && issue.prState === "open") {
-            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.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) || 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.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,
-            });
-        }
-    }
-    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;
-        const pendingWake = this.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)) {
-                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 : DEFAULT_GATE_CHECK_NAMES;
-    }
-    getPrimaryGateCheckName(project) {
-        return this.getGateCheckNames(project)[0] ?? "verify";
-    }
-    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);
-    }
-    deriveImmediatePrCheckStatus(issue, event, project) {
-        if (event.triggerEvent === "pr_synchronize") {
-            return "pending";
-        }
-        if (event.eventSource !== "check_run") {
-            return undefined;
-        }
-        if (!this.isGateCheckEvent(event, project)) {
-            return undefined;
-        }
-        if (this.isStaleGateEvent(issue, event)) {
-            return undefined;
-        }
-        return event.checkStatus;
-    }
-    isStaleGateEvent(issue, event) {
-        return Boolean(issue.lastGitHubCiSnapshotHeadSha
-            && event.headSha
-            && issue.lastGitHubCiSnapshotHeadSha !== event.headSha);
-    }
-    isQueueEvictionFailure(issue, event, project) {
-        const protocol = resolveMergeQueueProtocol(project);
-        return 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.issues.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)
-            return;
-        try {
-            const linear = await this.linearProvider.forProject(issue.projectId);
-            if (!linear?.createAgentActivity)
-                return;
-            const content = buildGitHubStateActivity(issue.factoryState, event);
-            if (!content)
-                return;
-            const allowEphemeral = content.type === "thought" || content.type === "action";
-            await linear.createAgentActivity({
-                agentSessionId: issue.agentSessionId,
-                content,
-                ...(allowEphemeral ? { ephemeral: false } : {}),
-            });
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, newState, error: msg }, "Failed to emit Linear activity from GitHub webhook");
-            this.feed?.publish({
-                level: "warn",
-                kind: "linear",
-                issueKey: issue.issueKey,
-                projectId: issue.projectId,
-                status: "linear_error",
-                summary: `Linear activity failed: ${msg}`,
-            });
-        }
-    }
-    async syncLinearSession(issue) {
-        if (!issue.agentSessionId)
-            return;
-        try {
-            const linear = await this.linearProvider.forProject(issue.projectId);
-            if (!linear?.updateAgentSession)
-                return;
-            const externalUrls = buildAgentSessionExternalUrls(this.config, {
-                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-                ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
-            });
-            await linear.updateAgentSession({
-                agentSessionId: issue.agentSessionId,
-                plan: buildAgentSessionPlanForIssue(issue),
-                ...(externalUrls ? { externalUrls } : {}),
-            });
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear session from GitHub webhook");
-        }
-    }
-    async fetchReviewCommentsForEvent(event) {
-        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) {
-            this.logger.debug({ prNumber: event.prNumber, reviewId: event.reviewId }, "Skipping inline review comment fetch because no GitHub API token is available");
-            return undefined;
-        }
-        const [owner, repo] = event.repoFullName.split("/", 2);
-        if (!owner || !repo) {
-            return undefined;
-        }
-        const response = await this.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",
-            },
+            project,
+            failureContextResolver: this.failureContextResolver,
+            fetchImpl: this.fetchImpl,
         });
-        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) }
-                    : {}),
+        if (event.triggerEvent === "pr_merged" || event.triggerEvent === "pr_closed") {
+            await handleGitHubTerminalPrEvent({
+                config: this.config,
+                db: this.db,
+                linearProvider: this.linearProvider,
+                enqueueIssue: this.enqueueIssue,
+                logger: this.logger,
+                codex: this.codex,
+                feed: this.feed,
+                issue: freshIssue,
+                event,
             });
         }
-        return comments;
-    }
-    async handlePrComment(payload) {
-        if (payload.action !== "created")
-            return;
-        const issuePayload = payload.issue;
-        const comment = payload.comment;
-        if (!issuePayload || !comment)
-            return;
-        if (!issuePayload.pull_request)
-            return; // only PR comments
-        const body = typeof comment.body === "string" ? comment.body : "";
-        if (!body.trim())
-            return;
-        const user = comment.user;
-        const author = typeof user?.login === "string" ? user.login : "unknown";
-        if (typeof user?.type === "string" && user.type === "Bot")
-            return;
-        const prNumber = typeof issuePayload.number === "number" ? issuePayload.number : undefined;
-        if (!prNumber)
-            return;
-        const issue = this.db.issues.getIssueByPrNumber(prNumber);
-        if (!issue)
-            return;
-        this.feed?.publish({
-            level: "info",
-            kind: "comment",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: issue.factoryState,
-            status: "pr_comment",
-            summary: `GitHub PR comment from ${author}`,
-            detail: body.slice(0, 200),
-        });
-        if (issue.activeRunId) {
-            const run = this.db.runs.getRunById(issue.activeRunId);
-            if (run?.threadId && run.turnId) {
-                try {
-                    await this.codex.steerTurn({
-                        threadId: run.threadId,
-                        turnId: run.turnId,
-                        input: `GitHub PR comment from ${author}:\n\n${body}`,
-                    });
-                    this.logger.info({ issueKey: issue.issueKey, author }, "Forwarded GitHub PR comment to active run");
-                    return;
-                }
-                catch (error) {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to forward GitHub PR comment");
-                }
-            }
-        }
-        this.db.issueSessions.appendIssueSessionEvent({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            eventType: "followup_comment",
-            eventJson: JSON.stringify({ body, author }),
-        });
-        this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
-    }
-    async readGitHubErrorResponse(response) {
-        try {
-            const payload = await response.json();
-            if (typeof payload?.message === "string" && payload.message.trim()) {
-                return payload.message.trim();
-            }
-            if (payload?.errors !== undefined) {
-                return JSON.stringify(payload.errors);
-            }
-        }
-        catch {
-            // Fall through to status text.
-        }
-        return response.statusText || `GitHub API responded with ${response.status}`;
-    }
-    peekPendingSessionWakeRunType(projectId, issueId) {
-        return this.db.issueSessions.peekIssueSessionWake(projectId, issueId)?.runType;
-    }
-    enqueuePendingSessionWake(projectId, issueId) {
-        const wake = this.db.issueSessions.peekIssueSessionWake(projectId, issueId);
-        if (!wake) {
-            return undefined;
-        }
-        this.enqueueIssue(projectId, issueId);
-        return wake.runType;
     }
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function buildGitHubReviewUrl(repoFullName, prNumber, reviewId) {
-    if (!repoFullName || prNumber === undefined || reviewId === undefined) {
-        return undefined;
-    }
-    return `https://github.com/${repoFullName}/pull/${prNumber}#pullrequestreview-${reviewId}`;
-}
-function resolveCheckClass(checkName, project) {
-    if (!checkName || !project)
-        return "code";
-    if ((project.reviewChecks ?? []).some((name) => checkName.includes(name)))
-        return "review";
-    if ((project.gateChecks ?? []).some((name) => checkName.includes(name)))
-        return "gate";
-    return "code";
-}