patchrelay 0.38.0 → 0.38.1

package/dist/github-webhook-terminal-handler.js

@@ -0,0 +1,111 @@
+import { resolveClosedPrDisposition, resolveClosedPrFactoryState } from "./pr-state.js";
+import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+import { syncGitHubLinearSession } from "./github-linear-session-sync.js";
+export async function handleGitHubTerminalPrEvent(params) {
+    const { db, linearProvider, enqueueIssue, logger, codex, issue, event, config } = params;
+    const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
+    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("::"),
+    });
+    db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+    const run = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;
+    if (run?.threadId && run.turnId) {
+        try {
+            await 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) {
+            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) {
+            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);
+        db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            activeRunId: null,
+            factoryState: terminalFactoryState,
+        });
+    };
+    const activeLease = db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
+    if (activeLease) {
+        db.issueSessions.withIssueSessionLease(issue.projectId, issue.linearIssueId, activeLease.leaseId, commitTerminalUpdate);
+    }
+    else {
+        db.transaction(commitTerminalUpdate);
+    }
+    db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
+    const updatedIssue = db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+    if (event.triggerEvent === "pr_closed" && resolveClosedPrDisposition(issue) === "redelegate") {
+        db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "delegated",
+            dedupeKey: `github_pr_closed:implementation:${issue.linearIssueId}`,
+        });
+        if (db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
+    }
+    if (event.triggerEvent === "pr_merged") {
+        await completeLinearIssueAfterMerge(params, updatedIssue);
+    }
+    void syncGitHubLinearSession({
+        config,
+        linearProvider,
+        logger,
+        issue: updatedIssue,
+    });
+}
+async function completeLinearIssueAfterMerge(params, issue) {
+    const linear = await params.linearProvider.forProject(issue.projectId).catch(() => undefined);
+    if (!linear)
+        return;
+    try {
+        const liveIssue = await linear.getIssue(issue.linearIssueId);
+        const targetState = resolvePreferredCompletedLinearState(liveIssue);
+        if (!targetState) {
+            params.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()) {
+            params.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);
+        params.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);
+        params.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to move merged issue to a completed Linear state");
+    }
+}

package/dist/issue-overview-query.js

@@ -1,5 +1,6 @@
 import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { isIssueSessionReadyForExecution } from "./issue-session.js";
+import { getLegacyIssueOverview } from "./legacy-issue-overview.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 export function parseStageReport(reportJson, runStatus) {
@@ -25,7 +26,13 @@ export class IssueOverviewQuery {
     async getIssueOverview(issueKey) {
         const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
         if (!session) {
-            return await this.getLegacyIssueOverview(issueKey);
+            return await getLegacyIssueOverview({
+                db: this.db,
+                issueKey,
+                runStatusProvider: this.runStatusProvider,
+                buildRuns: (projectId, linearIssueId) => this.buildRuns(projectId, linearIssueId),
+                readLiveThread: (run) => this.readLiveThread(run),
+            });
         }
         return await this.getSessionIssueOverview(issueKey, session);
     }
@@ -66,62 +73,6 @@ export class IssueOverviewQuery {
             })(),
         }));
     }
-    async getLegacyIssueOverview(issueKey) {
-        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,
-                    },
-                }
-                : {}),
-        };
-    }
     async getSessionIssueOverview(issueKey, session) {
         const issueRecord = this.db.issues.getIssueByKey(issueKey);
         const blockedBy = this.db.issues.listIssueDependencies(session.projectId, session.linearIssueId);

package/dist/legacy-issue-overview.js

@@ -0,0 +1,58 @@
+import { deriveIssueStatusNote } from "./status-note.js";
+export async function getLegacyIssueOverview(params) {
+    const { db, issueKey, runStatusProvider, buildRuns, readLiveThread } = params;
+    const legacy = db.getIssueOverview(issueKey);
+    if (!legacy)
+        return undefined;
+    const issueRecord = db.issues.getIssueByKey(issueKey);
+    const activeStatus = await runStatusProvider.getActiveRunStatus(issueKey);
+    const activeRun = activeStatus?.run ?? legacy.activeRun;
+    const latestRun = db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
+    const latestEvent = db.issueSessions.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
+    const runs = buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
+    const runCount = runs.length;
+    const liveThread = await 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,
+                },
+            }
+            : {}),
+    };
+}

package/dist/reactive-pr-state.js

@@ -0,0 +1,65 @@
+import { readRemotePrState } from "./remote-pr-state.js";
+export function isRequestedChangesRunType(runType) {
+    return runType === "review_fix" || runType === "branch_upkeep";
+}
+export 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;
+}
+export 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;
+}
+export function isDirtyMergeStateStatus(value) {
+    return value?.trim().toUpperCase() === "DIRTY";
+}
+export 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 async function readReactivePrSnapshot(config, projectId, prNumber) {
+    const project = config.projects.find((entry) => entry.id === projectId);
+    const repoFullName = project?.github?.repoFullName;
+    if (!repoFullName) {
+        return undefined;
+    }
+    const pr = await readRemotePrState(repoFullName, prNumber);
+    if (!pr) {
+        return undefined;
+    }
+    return {
+        projectId,
+        repoFullName,
+        baseBranch: project?.github?.baseBranch ?? "main",
+        pr,
+        prState: normalizeRemotePrState(pr.state),
+        reviewState: normalizeRemoteReviewDecision(pr.reviewDecision),
+        headSha: pr.headRefOid,
+        gateCheckName: project?.gateChecks?.find((entry) => entry.trim())?.trim() ?? "verify",
+    };
+}

package/dist/reactive-run-policy.js

@@ -1,47 +1,4 @@
-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,
-    };
-}
+import { buildReviewFixBranchUpkeepContext, isDirtyMergeStateStatus, isRequestedChangesRunType, readReactivePrSnapshot, } from "./reactive-pr-state.js";
 export class ReactiveRunPolicy {
     config;
     db;
@@ -60,15 +17,11 @@ export class ReactiveRunPolicy {
         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")
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot || snapshot.prState !== "open")
                 return undefined;
-            if (!pr.headRefOid || pr.headRefOid !== issue.lastGitHubFailureHeadSha)
+            if (!snapshot.headSha || snapshot.headSha !== issue.lastGitHubFailureHeadSha)
                 return undefined;
             return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
         }
@@ -91,18 +44,14 @@ export class ReactiveRunPolicy {
         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")
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot || snapshot.prState !== "open")
                 return undefined;
-            if (!pr.headRefOid) {
+            if (!snapshot.headSha) {
                 return `Requested-changes run finished for PR #${issue.prNumber} but GitHub did not report a current head SHA.`;
             }
-            if (pr.headRefOid === run.sourceHeadSha) {
+            if (snapshot.headSha === 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;
@@ -123,28 +72,20 @@ export class ReactiveRunPolicy {
         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) {
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot) {
                 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 headAdvanced = Boolean(snapshot.headSha && snapshot.headSha !== issue.lastGitHubFailureHeadSha);
             const reviewFixHeadAdvanced = isRequestedChangesRunType(run.runType)
-                && Boolean(pr.headRefOid && run.sourceHeadSha && pr.headRefOid !== run.sourceHeadSha);
+                && Boolean(snapshot.headSha && run.sourceHeadSha && snapshot.headSha !== 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 } : {}),
+                ...(snapshot.prState ? { prState: snapshot.prState } : {}),
+                ...(snapshot.headSha ? { prHeadSha: snapshot.headSha } : {}),
+                ...(snapshot.reviewState ? { prReviewState: snapshot.reviewState } : {}),
                 ...((headAdvanced || reviewFixHeadAdvanced)
                     ? {
                         prCheckStatus: "pending",
@@ -158,8 +99,8 @@ export class ReactiveRunPolicy {
                         lastQueueIncidentJson: null,
                         lastAttemptedFailureHeadSha: null,
                         lastAttemptedFailureSignature: null,
-                        lastGitHubCiSnapshotHeadSha: pr.headRefOid ?? null,
-                        lastGitHubCiSnapshotGateCheckName: gateCheckName,
+                        lastGitHubCiSnapshotHeadSha: snapshot.headSha ?? null,
+                        lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName,
                         lastGitHubCiSnapshotGateCheckStatus: "pending",
                         lastGitHubCiSnapshotJson: null,
                         lastGitHubCiSnapshotSettledAt: null,
@@ -183,31 +124,24 @@ export class ReactiveRunPolicy {
         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)
+            const snapshot = await readReactivePrSnapshot(this.config, issue.projectId, issue.prNumber);
+            if (!snapshot)
                 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 } : {}),
+                ...(snapshot.prState ? { prState: snapshot.prState } : {}),
+                ...(snapshot.headSha ? { prHeadSha: snapshot.headSha } : {}),
+                ...(snapshot.reviewState ? { prReviewState: snapshot.reviewState } : {}),
             }, "review-fix wake refresh");
-            if (nextPrState !== "open")
+            if (snapshot.prState !== "open")
                 return context;
-            if (nextReviewState && nextReviewState !== "changes_requested")
+            if (snapshot.reviewState && snapshot.reviewState !== "changes_requested")
                 return context;
-            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+            if (!isDirtyMergeStateStatus(snapshot.pr.mergeStateStatus))
                 return context;
-            return buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr, context);
+            return buildReviewFixBranchUpkeepContext(issue.prNumber, snapshot.baseBranch, snapshot.pr, context);
         }
         catch (error) {
             this.logger.debug({
@@ -228,34 +162,27 @@ export class ReactiveRunPolicy {
         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)
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot)
                 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 } : {}),
+                ...(snapshot.prState ? { prState: snapshot.prState } : {}),
+                ...(snapshot.headSha ? { prHeadSha: snapshot.headSha } : {}),
+                ...(snapshot.reviewState ? { prReviewState: snapshot.reviewState } : {}),
             }, "post-run follow-up refresh");
-            if (nextPrState !== "open")
+            if (snapshot.prState !== "open")
                 return undefined;
-            if (nextReviewState && nextReviewState !== "changes_requested")
+            if (snapshot.reviewState && snapshot.reviewState !== "changes_requested")
                 return undefined;
-            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+            if (!isDirtyMergeStateStatus(snapshot.pr.mergeStateStatus))
                 return undefined;
             return {
                 pendingRunType: "branch_upkeep",
                 factoryState: "changes_requested",
-                context: buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr),
+                context: buildReviewFixBranchUpkeepContext(issue.prNumber, snapshot.baseBranch, snapshot.pr),
                 summary: `PR #${issue.prNumber} is still dirty after review fix; queued branch upkeep`,
             };
         }
@@ -268,16 +195,6 @@ export class ReactiveRunPolicy {
             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) {

package/dist/remote-pr-state.js

@@ -0,0 +1,11 @@
+import { execCommand } from "./utils.js";
+export async function readRemotePrState(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);
+}

package/dist/run-orchestrator.js

@@ -54,6 +54,20 @@ export class RunOrchestrator {
     runNotificationHandler;
     runReconciler;
     mergedLinearCompletionReconciler;
+    threadPorts = {
+        readThreadWithRetry: (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries),
+    };
+    leasePorts = {
+        withHeldLease: (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn),
+        releaseLease: (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId),
+        heartbeatLease: (projectId, linearIssueId) => this.heartbeatIssueSessionLease(projectId, linearIssueId),
+        getHeldLease: (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId),
+    };
+    recoveryPorts = {
+        failRunAndClear: (run, message, nextState) => this.failRunAndClear(run, message, nextState),
+        restoreIdleWorktree: (issue) => this.restoreIdleWorktree(issue),
+        recoverOrEscalate: (issue, runType, reason) => this.recoverOrEscalate(issue, runType, reason),
+    };
     activeSessionLeases;
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
@@ -66,16 +80,16 @@ export class RunOrchestrator {
         this.feed = feed;
         this.worktreeManager = new WorktreeManager(config);
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
-        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries));
+        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, this.threadPorts.readThreadWithRetry);
         this.activeSessionLeases = this.leaseService.activeSessionLeases;
-        this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn));
+        this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, this.leasePorts.withHeldLease);
         this.completionCheck = new CompletionCheckService(codex, logger);
-        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (run, message, nextState) => this.failRunAndClear(run, message, nextState), this.runCompletionPolicy, this.completionCheck, feed);
+        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.recoveryPorts.failRunAndClear, this.runCompletionPolicy, this.completionCheck, feed);
         this.runLauncher = new RunLauncher(config, db, codex, logger, this.worktreeManager);
-        this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries), (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.heartbeatIssueSessionLease(projectId, linearIssueId), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), feed);
-        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
-        this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (run, message, nextState) => this.failRunAndClear(run, message, nextState), (issue) => this.restoreIdleWorktree(issue), this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
-        this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries), (issue, runType, reason) => this.recoverOrEscalate(issue, runType, reason), feed);
+        this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed);
+        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.getHeldLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.leasePorts.releaseLease, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
+        this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
+        this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, feed);
         this.runWakePlanner = new RunWakePlanner(db);
         this.idleReconciler = new IdleIssueReconciler(db, config, {
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),

package/package.json

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