patchrelay 0.36.11 → 0.36.13

package/dist/issue-query-service.js

@@ -1,239 +1,27 @@
-import { parseGitHubFailureContext } from "./github-failure-context.js";
-import { isIssueSessionReadyForExecution } from "./issue-session.js";
 import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
-import { deriveIssueStatusNote } from "./status-note.js";
-import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
-function parseStageReport(reportJson, runStatus) {
-    if (!reportJson)
-        return undefined;
-    try {
-        const parsed = JSON.parse(reportJson);
-        return { ...parsed, status: runStatus };
-    }
-    catch {
-        return undefined;
-    }
-}
+import { IssueOverviewQuery, parseStageReport, } from "./issue-overview-query.js";
 export class IssueQueryService {
     db;
-    codex;
     runStatusProvider;
+    overviewQuery;
     constructor(db, codex, runStatusProvider) {
         this.db = db;
-        this.codex = codex;
         this.runStatusProvider = runStatusProvider;
-    }
-    async readLiveThread(run) {
-        if (!run?.threadId)
-            return undefined;
-        return await this.codex.readThread(run.threadId, true).catch(() => undefined);
-    }
-    buildRuns(projectId, linearIssueId) {
-        return this.db.runs.listRunsForIssue(projectId, linearIssueId).map((run) => ({
-            id: run.id,
-            runType: run.runType,
-            status: run.status,
-            startedAt: run.startedAt,
-            ...(run.endedAt ? { endedAt: run.endedAt } : {}),
-            ...(run.threadId ? { threadId: run.threadId } : {}),
-            ...(() => {
-                const report = parseStageReport(run.reportJson, run.status);
-                return report ? { report } : {};
-            })(),
-            ...(() => {
-                const events = this.db.runs.listThreadEvents(run.id).flatMap((event) => {
-                    try {
-                        const parsed = JSON.parse(event.eventJson);
-                        return [{
-                                id: event.id,
-                                method: event.method,
-                                createdAt: event.createdAt,
-                                ...(parsed && typeof parsed === "object" && !Array.isArray(parsed)
-                                    ? { parsedEvent: parsed }
-                                    : {}),
-                            }];
-                    }
-                    catch {
-                        return [{
-                                id: event.id,
-                                method: event.method,
-                                createdAt: event.createdAt,
-                            }];
-                    }
-                });
-                return events.length > 0 ? { events } : {};
-            })(),
-        }));
+        this.overviewQuery = new IssueOverviewQuery(db, codex, runStatusProvider);
     }
     async getIssueOverview(issueKey) {
-        const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
-        if (!session) {
-            const legacy = this.db.getIssueOverview(issueKey);
-            if (!legacy)
-                return undefined;
-            const issueRecord = this.db.issues.getIssueByKey(issueKey);
-            const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
-            const activeRun = activeStatus?.run ?? legacy.activeRun;
-            const latestRun = this.db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
-            const latestEvent = this.db.issueSessions.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
-            const runs = this.buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
-            const runCount = runs.length;
-            const liveThread = await this.readLiveThread(activeRun);
-            const statusNote = issueRecord
-                ? deriveIssueStatusNote({
-                    issue: issueRecord,
-                    latestRun,
-                    latestEvent,
-                    failureSummary: legacy.issue.latestFailureSummary,
-                    blockedByKeys: legacy.issue.blockedByKeys,
-                    waitingReason: legacy.issue.waitingReason,
-                })
-                : legacy.issue.statusNote;
-            return {
-                issue: {
-                    ...legacy.issue,
-                    ...(statusNote ? { statusNote } : {}),
-                },
-                ...(activeRun ? { activeRun } : {}),
-                ...(latestRun ? { latestRun } : {}),
-                ...(liveThread ? { liveThread } : {}),
-                ...(runs.length > 0 ? { runs } : {}),
-                ...(issueRecord
-                    ? {
-                        issueContext: {
-                            ...(issueRecord.description ? { description: issueRecord.description } : {}),
-                            ...(issueRecord.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
-                            ...(issueRecord.url ? { issueUrl: issueRecord.url } : {}),
-                            ...(issueRecord.worktreePath ? { worktreePath: issueRecord.worktreePath } : {}),
-                            ...(issueRecord.branchName ? { branchName: issueRecord.branchName } : {}),
-                            ...(issueRecord.prUrl ? { prUrl: issueRecord.prUrl } : {}),
-                            ...(issueRecord.priority != null ? { priority: issueRecord.priority } : {}),
-                            ...(issueRecord.estimate != null ? { estimate: issueRecord.estimate } : {}),
-                            ciRepairAttempts: issueRecord.ciRepairAttempts,
-                            queueRepairAttempts: issueRecord.queueRepairAttempts,
-                            reviewFixAttempts: issueRecord.reviewFixAttempts,
-                            ...(legacy.issue.latestFailureSource ? { latestFailureSource: legacy.issue.latestFailureSource } : {}),
-                            ...(legacy.issue.latestFailureHeadSha ? { latestFailureHeadSha: legacy.issue.latestFailureHeadSha } : {}),
-                            ...(legacy.issue.latestFailureCheckName ? { latestFailureCheckName: legacy.issue.latestFailureCheckName } : {}),
-                            ...(legacy.issue.latestFailureStepName ? { latestFailureStepName: legacy.issue.latestFailureStepName } : {}),
-                            ...(legacy.issue.latestFailureSummary ? { latestFailureSummary: legacy.issue.latestFailureSummary } : {}),
-                            runCount,
-                        },
-                    }
-                    : {}),
-            };
-        }
-        const issueRecord = this.db.issues.getIssueByKey(issueKey);
-        const blockedBy = this.db.issues.listIssueDependencies(session.projectId, session.linearIssueId);
-        const unresolvedBlockedBy = blockedBy.filter((entry) => (entry.blockerCurrentLinearStateType !== "completed"
-            && entry.blockerCurrentLinearState?.trim().toLowerCase() !== "done"));
-        const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
-        const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
-        const activeRun = activeStatus?.run
-            ?? (session.activeRunId !== undefined ? this.db.runs.getRunById(session.activeRunId) : undefined);
-        const latestRun = this.db.runs.getLatestRunForIssue(session.projectId, session.linearIssueId);
-        const latestEvent = this.db.issueSessions.listIssueSessionEvents(session.projectId, session.linearIssueId, { limit: 1 }).at(-1);
-        const runs = this.buildRuns(session.projectId, session.linearIssueId);
-        const runCount = runs.length;
-        const liveThread = await this.readLiveThread(activeRun);
-        const failureContext = parseGitHubFailureContext(issueRecord?.lastGitHubFailureContextJson);
-        const waitingReason = session.waitingReason ?? derivePatchRelayWaitingReason({
-            ...(activeRun ? { activeRunType: activeRun.runType } : {}),
-            blockedByKeys,
-            factoryState: issueRecord?.factoryState ?? "delegated",
-            pendingRunType: issueRecord?.pendingRunType,
-            prNumber: session.prNumber,
-            prHeadSha: issueRecord?.prHeadSha ?? session.prHeadSha,
-            prReviewState: issueRecord?.prReviewState,
-            prCheckStatus: issueRecord?.prCheckStatus,
-            lastBlockingReviewHeadSha: issueRecord?.lastBlockingReviewHeadSha,
-            latestFailureCheckName: issueRecord?.lastGitHubFailureCheckName,
-        });
-        const issue = {
-            id: issueRecord?.id ?? session.id,
-            projectId: session.projectId,
-            linearIssueId: session.linearIssueId,
-            ...(session.issueKey ? { issueKey: session.issueKey } : {}),
-            ...(issueRecord?.title ? { title: issueRecord.title } : {}),
-            ...(issueRecord?.url ? { issueUrl: issueRecord.url } : {}),
-            ...(issueRecord?.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
-            sessionState: session.sessionState,
-            factoryState: issueRecord?.factoryState ?? "delegated",
-            blockedByCount: unresolvedBlockedBy.length,
-            blockedByKeys,
-            readyForExecution: isIssueSessionReadyForExecution({
-                sessionState: session.sessionState,
-                factoryState: issueRecord?.factoryState ?? "delegated",
-                ...(activeRun ? { activeRunId: activeRun.id } : {}),
-                blockedByCount: unresolvedBlockedBy.length,
-                hasPendingWake: this.db.issueSessions.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
-                hasLegacyPendingRun: issueRecord?.pendingRunType !== undefined,
-                ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),
-                ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
-                ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
-                ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
-                ...(issueRecord?.lastGitHubFailureSource ? { latestFailureSource: issueRecord.lastGitHubFailureSource } : {}),
-            }),
-            ...(issueRecord?.lastGitHubFailureSource ? { latestFailureSource: issueRecord.lastGitHubFailureSource } : {}),
-            ...(issueRecord?.lastGitHubFailureHeadSha ? { latestFailureHeadSha: issueRecord.lastGitHubFailureHeadSha } : {}),
-            ...(issueRecord?.lastGitHubFailureCheckName ? { latestFailureCheckName: issueRecord.lastGitHubFailureCheckName } : {}),
-            ...(() => {
-                const statusNote = issueRecord
-                    ? deriveIssueStatusNote({
-                        issue: issueRecord,
-                        sessionSummary: session.summaryText,
-                        latestRun,
-                        latestEvent,
-                        failureSummary: failureContext?.summary,
-                        blockedByKeys,
-                        waitingReason,
-                    })
-                    : undefined;
-                return statusNote ? { statusNote } : {};
-            })(),
-            ...(waitingReason ? { waitingReason } : {}),
-            ...(activeRun ? { activeRunId: activeRun.id } : {}),
-            ...(issueRecord?.agentSessionId ? { activeAgentSessionId: issueRecord.agentSessionId } : {}),
-            updatedAt: session.updatedAt,
-        };
-        return {
-            issue,
-            session,
-            ...(activeRun ? { activeRun } : {}),
-            ...(latestRun ? { latestRun } : {}),
-            ...(liveThread ? { liveThread } : {}),
-            ...(runs.length > 0 ? { runs } : {}),
-            issueContext: {
-                ...(issueRecord?.description ? { description: issueRecord.description } : {}),
-                ...(issueRecord?.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
-                ...(issueRecord?.url ? { issueUrl: issueRecord.url } : {}),
-                ...(session.worktreePath ? { worktreePath: session.worktreePath } : {}),
-                ...(session.branchName ? { branchName: session.branchName } : {}),
-                ...(issueRecord?.prUrl ? { prUrl: issueRecord.prUrl } : {}),
-                ...(issueRecord?.priority != null ? { priority: issueRecord.priority } : {}),
-                ...(issueRecord?.estimate != null ? { estimate: issueRecord.estimate } : {}),
-                ciRepairAttempts: issueRecord?.ciRepairAttempts ?? session.ciRepairAttempts,
-                queueRepairAttempts: issueRecord?.queueRepairAttempts ?? session.queueRepairAttempts,
-                reviewFixAttempts: issueRecord?.reviewFixAttempts ?? session.reviewFixAttempts,
-                ...(issue.latestFailureSource ? { latestFailureSource: issue.latestFailureSource } : {}),
-                ...(issue.latestFailureHeadSha ? { latestFailureHeadSha: issue.latestFailureHeadSha } : {}),
-                ...(issue.latestFailureCheckName ? { latestFailureCheckName: issue.latestFailureCheckName } : {}),
-                ...(issue.latestFailureStepName ? { latestFailureStepName: issue.latestFailureStepName } : {}),
-                ...(issue.latestFailureSummary ? { latestFailureSummary: issue.latestFailureSummary } : {}),
-                runCount,
-            },
-        };
+        return await this.overviewQuery.getIssueOverview(issueKey);
     }
     async getActiveRunStatus(issueKey) {
         return await this.runStatusProvider.getActiveRunStatus(issueKey);
     }
     async getPublicAgentSessionStatus(issueKey) {
-        const overview = await this.getIssueOverview(issueKey);
+        const overview = await this.overviewQuery.getIssueOverview(issueKey);
         if (!overview)
             return undefined;
         const issueRecord = this.db.issues.getIssueByKey(issueKey);
         const latestRunReport = parseStageReport(overview.latestRun?.reportJson, overview.latestRun?.status ?? "unknown");
-        const runs = (overview.runs ?? this.buildRuns(overview.issue.projectId, overview.issue.linearIssueId)).map((run) => ({
+        const runs = (overview.runs ?? this.overviewQuery.buildRuns(overview.issue.projectId, overview.issue.linearIssueId)).map((run) => ({
             run: {
                 id: run.id,
                 runType: run.runType,

package/dist/linear-session-reporting.js

@@ -62,20 +62,51 @@ export function buildRunStartedActivity(runType) {
     }
 }
 export function buildRunCompletedActivity(params) {
-    const label = formatRunTypeLabel(params.runType);
-    const nextState = describeNextState(params.postRunState, params.prNumber);
+    const prLabel = params.prNumber ? `PR #${params.prNumber}` : "the pull request";
     const summary = trimSummary(params.completionSummary);
-    const lines = [`${label} completed.`];
-    if (nextState) {
-        lines.push("", nextState);
-    }
-    if (summary) {
-        lines.push("", summary);
+    const detail = summary ? ` ${summary}` : "";
+    switch (params.runType) {
+        case "implementation":
+            if (params.postRunState === "pr_open") {
+                return {
+                    type: "response",
+                    body: `${prLabel} opened:${detail || " Published and ready for review."}`,
+                };
+            }
+            return undefined;
+        case "review_fix":
+            return {
+                type: "response",
+                body: `Updated ${prLabel} to address review feedback.${detail}`,
+            };
+        case "ci_repair":
+            return {
+                type: "response",
+                body: `Updated ${prLabel} after CI repair.${detail}`,
+            };
+        case "queue_repair":
+            return {
+                type: "response",
+                body: `Updated ${prLabel} after merge-queue repair.${detail}`,
+            };
+        case "branch_upkeep":
+            return undefined;
+        default: {
+            const label = formatRunTypeLabel(params.runType);
+            const nextState = describeNextState(params.postRunState, params.prNumber);
+            const lines = [`${label} completed.`];
+            if (nextState) {
+                lines.push("", nextState);
+            }
+            if (summary) {
+                lines.push("", summary);
+            }
+            return {
+                type: "response",
+                body: lines.join("\n"),
+            };
+        }
     }
-    return {
-        type: "response",
-        body: lines.join("\n"),
-    };
 }
 export function buildRunFailureActivity(runType, reason) {
     const label = formatRunTypeLabel(runType);
@@ -92,33 +123,16 @@ export function buildStopConfirmationActivity() {
 }
 export function buildGitHubStateActivity(newState, event) {
     switch (newState) {
-        case "pr_open": {
-            const parts = [`PR #${event.prNumber ?? "?"} is open and ready for review.`];
-            if (event.prUrl) {
-                parts.push("", event.prUrl);
-            }
-            return { type: "response", body: parts.join("\n") };
-        }
+        case "pr_open":
+            return undefined;
         case "awaiting_queue":
-            return { type: "response", body: "Review approved. PatchRelay is moving the PR toward merge." };
+            return undefined;
         case "changes_requested":
-            return {
-                type: "action",
-                action: "Addressing",
-                parameter: event.reviewerName ? `review feedback from ${event.reviewerName}` : "review feedback",
-            };
+            return undefined;
         case "repairing_ci":
-            return {
-                type: "action",
-                action: "Repairing",
-                parameter: event.checkName ? `CI failure: ${event.checkName}` : "failing CI checks",
-            };
+            return undefined;
         case "repairing_queue":
-            return {
-                type: "action",
-                action: "Repairing",
-                parameter: "merge queue validation",
-            };
+            return undefined;
         case "done":
             return { type: "response", body: `PR merged.${event.prNumber ? ` PR #${event.prNumber}` : ""}` };
         case "failed":

package/dist/reactive-run-policy.js

@@ -0,0 +1,288 @@
+import { execCommand } from "./utils.js";
+function isRequestedChangesRunType(runType) {
+    return runType === "review_fix" || runType === "branch_upkeep";
+}
+function normalizeRemotePrState(value) {
+    const normalized = value?.trim().toUpperCase();
+    if (normalized === "OPEN")
+        return "open";
+    if (normalized === "CLOSED")
+        return "closed";
+    if (normalized === "MERGED")
+        return "merged";
+    return undefined;
+}
+function normalizeRemoteReviewDecision(value) {
+    const normalized = value?.trim().toUpperCase();
+    if (normalized === "APPROVED")
+        return "approved";
+    if (normalized === "CHANGES_REQUESTED")
+        return "changes_requested";
+    if (normalized === "REVIEW_REQUIRED")
+        return "commented";
+    return undefined;
+}
+function isDirtyMergeStateStatus(value) {
+    return value?.trim().toUpperCase() === "DIRTY";
+}
+function buildReviewFixBranchUpkeepContext(prNumber, baseBranch, pr, context) {
+    const promptContext = [
+        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${String(pr.mergeStateStatus)} against latest ${baseBranch}.`,
+        `This turn is branch upkeep on the existing PR branch: update onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push a newer head.`,
+        "Do not stop just because the requested code change is already present. Review can only move forward after a new pushed head.",
+    ].join(" ");
+    return {
+        ...(context ?? {}),
+        branchUpkeepRequired: true,
+        reviewFixMode: "branch_upkeep",
+        wakeReason: "branch_upkeep",
+        promptContext,
+        ...(pr.mergeStateStatus ? { mergeStateStatus: pr.mergeStateStatus } : {}),
+        ...(pr.headRefOid ? { failingHeadSha: pr.headRefOid } : {}),
+        baseBranch,
+    };
+}
+export class ReactiveRunPolicy {
+    config;
+    db;
+    logger;
+    withHeldLease;
+    constructor(config, db, logger, withHeldLease) {
+        this.config = config;
+        this.db = db;
+        this.logger = logger;
+        this.withHeldLease = withHeldLease;
+    }
+    async verifyReactiveRunAdvancedBranch(run, issue) {
+        if (run.runType !== "ci_repair" && run.runType !== "queue_repair") {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open" || !issue.lastGitHubFailureHeadSha) {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        if (!project?.github?.repoFullName) {
+            return undefined;
+        }
+        try {
+            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
+            if (!pr || pr.state?.toUpperCase() !== "OPEN")
+                return undefined;
+            if (!pr.headRefOid || pr.headRefOid !== issue.lastGitHubFailureHeadSha)
+                return undefined;
+            return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to verify PR head advancement after repair");
+            return undefined;
+        }
+    }
+    async verifyReviewFixAdvancedHead(run, issue) {
+        if (!isRequestedChangesRunType(run.runType)) {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open") {
+            return undefined;
+        }
+        if (!run.sourceHeadSha) {
+            return `Requested-changes run finished for PR #${issue.prNumber} without a recorded starting head SHA. PatchRelay cannot verify that a new head was published.`;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        if (!project?.github?.repoFullName) {
+            return undefined;
+        }
+        try {
+            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
+            if (!pr || pr.state?.toUpperCase() !== "OPEN")
+                return undefined;
+            if (!pr.headRefOid) {
+                return `Requested-changes run finished for PR #${issue.prNumber} but GitHub did not report a current head SHA.`;
+            }
+            if (pr.headRefOid === run.sourceHeadSha) {
+                return `Requested-changes run finished for PR #${issue.prNumber} without pushing a new head; PatchRelay must not hand the same SHA back to review.`;
+            }
+            return undefined;
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to verify PR head advancement after requested-changes work");
+            return undefined;
+        }
+    }
+    async refreshIssueAfterReactivePublish(run, issue) {
+        if (run.runType !== "ci_repair" && run.runType !== "queue_repair" && !isRequestedChangesRunType(run.runType)) {
+            return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        if (!issue.prNumber) {
+            return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        if (!repoFullName) {
+            return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr) {
+                return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            }
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            const gateCheckName = project?.gateChecks?.find((entry) => entry.trim())?.trim() ?? "verify";
+            const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== issue.lastGitHubFailureHeadSha);
+            const reviewFixHeadAdvanced = isRequestedChangesRunType(run.runType)
+                && Boolean(pr.headRefOid && run.sourceHeadSha && pr.headRefOid !== run.sourceHeadSha);
+            this.upsertIssueIfLeaseHeld(run.projectId, run.linearIssueId, {
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+                ...((headAdvanced || reviewFixHeadAdvanced)
+                    ? {
+                        prCheckStatus: "pending",
+                        lastGitHubFailureSource: null,
+                        lastGitHubFailureHeadSha: null,
+                        lastGitHubFailureSignature: null,
+                        lastGitHubFailureCheckName: null,
+                        lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureContextJson: null,
+                        lastGitHubFailureAt: null,
+                        lastQueueIncidentJson: null,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
+                        lastGitHubCiSnapshotHeadSha: pr.headRefOid ?? null,
+                        lastGitHubCiSnapshotGateCheckName: gateCheckName,
+                        lastGitHubCiSnapshotGateCheckStatus: "pending",
+                        lastGitHubCiSnapshotJson: null,
+                        lastGitHubCiSnapshotSettledAt: null,
+                    }
+                    : {}),
+            }, "reactive publish refresh");
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to refresh PR state after reactive publish");
+        }
+        return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+    }
+    async resolveRequestedChangesWakeContext(issue, runType, context) {
+        if (runType === "branch_upkeep" || context?.branchUpkeepRequired === true) {
+            return context;
+        }
+        if (!issue.prNumber || issue.prState !== "open" || issue.prReviewState !== "changes_requested") {
+            return context;
+        }
+        const project = this.config.projects.find((entry) => entry.id === issue.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        if (!repoFullName) {
+            return context;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr)
+                return context;
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+            }, "review-fix wake refresh");
+            if (nextPrState !== "open")
+                return context;
+            if (nextReviewState && nextReviewState !== "changes_requested")
+                return context;
+            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+                return context;
+            return buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr, context);
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to resolve requested-changes wake context");
+            return context;
+        }
+    }
+    async resolvePostRunFollowUp(run, issue) {
+        if (run.runType !== "review_fix") {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open") {
+            return undefined;
+        }
+        if (issue.prReviewState !== "changes_requested") {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        if (!repoFullName) {
+            return undefined;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr)
+                return undefined;
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+            }, "post-run follow-up refresh");
+            if (nextPrState !== "open")
+                return undefined;
+            if (nextReviewState && nextReviewState !== "changes_requested")
+                return undefined;
+            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+                return undefined;
+            return {
+                pendingRunType: "branch_upkeep",
+                factoryState: "changes_requested",
+                context: buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr),
+                summary: `PR #${issue.prNumber} is still dirty after review fix; queued branch upkeep`,
+            };
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to resolve post-run PR upkeep");
+            return undefined;
+        }
+    }
+    async loadRemotePrState(repoFullName, prNumber) {
+        const { stdout, exitCode } = await execCommand("gh", [
+            "pr", "view", String(prNumber),
+            "--repo", repoFullName,
+            "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
+        ], { timeoutMs: 10_000 });
+        if (exitCode !== 0)
+            return undefined;
+        return JSON.parse(stdout);
+    }
+    upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
+        const updated = this.withHeldLease(projectId, linearIssueId, (lease) => this.db.issueSessions.upsertIssueWithLease(lease, params));
+        if (updated === undefined) {
+            this.logger.warn({ projectId, linearIssueId, context }, "Skipping issue write after losing issue-session lease");
+        }
+        return updated;
+    }
+}