patchrelay 0.36.11 → 0.36.13

package/dist/run-completion-policy.js

@@ -1,9 +1,7 @@
 import { ACTIVE_RUN_STATES } from "./factory-state.js";
-import { execCommand } from "./utils.js";
 import { resolveImplementationDeliveryMode, } from "./prompting/patchrelay.js";
-function isRequestedChangesRunType(runType) {
-    return runType === "review_fix" || runType === "branch_upkeep";
-}
+import { ImplementationOutcomePolicy } from "./implementation-outcome-policy.js";
+import { ReactiveRunPolicy } from "./reactive-run-policy.js";
 function resolvePostRunState(issue) {
     if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
         if (issue.prState === "merged")
@@ -20,393 +18,29 @@ export function resolveCompletedRunState(issue, run) {
     }
     return resolvePostRunState(issue);
 }
-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 RunCompletionPolicy {
-    config;
-    db;
-    logger;
-    withHeldLease;
+    reactive;
+    implementationOutcomes;
     constructor(config, db, logger, withHeldLease) {
-        this.config = config;
-        this.db = db;
-        this.logger = logger;
-        this.withHeldLease = withHeldLease;
+        this.reactive = new ReactiveRunPolicy(config, db, logger, withHeldLease);
+        this.implementationOutcomes = new ImplementationOutcomePolicy(config, db, logger, 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;
-        }
+        return await this.reactive.verifyReactiveRunAdvancedBranch(run, issue);
     }
     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;
-        }
+        return await this.reactive.verifyReviewFixAdvancedHead(run, issue);
     }
     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;
+        return await this.reactive.refreshIssueAfterReactivePublish(run, 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;
-        }
+        return await this.reactive.resolveRequestedChangesWakeContext(issue, runType, 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;
-        }
+        return await this.reactive.resolvePostRunFollowUp(run, issue);
     }
     async verifyPublishedRunOutcome(run, issue) {
-        if (run.runType !== "implementation") {
-            return undefined;
-        }
-        const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        const baseBranch = project?.github?.baseBranch ?? "main";
-        const deliveryMode = resolveImplementationDeliveryMode(issue, undefined, run.promptText);
-        if (deliveryMode === "linear_only") {
-            if (issue.prNumber !== undefined) {
-                return `Planning-only implementation should not open a PR, but PR #${issue.prNumber} was observed`;
-            }
-            return this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
-        }
-        if (issue.prNumber && issue.prState && issue.prState !== "closed") {
-            return undefined;
-        }
-        if (project?.github?.repoFullName && issue.branchName) {
-            try {
-                const { stdout, exitCode } = await execCommand("gh", [
-                    "pr",
-                    "list",
-                    "--repo",
-                    project.github.repoFullName,
-                    "--head",
-                    issue.branchName,
-                    "--state",
-                    "all",
-                    "--json",
-                    "number,url,state,author,headRefOid",
-                ], { timeoutMs: 10_000 });
-                if (exitCode === 0) {
-                    const matches = JSON.parse(stdout);
-                    const pr = matches[0];
-                    if (pr?.number) {
-                        this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
-                            projectId: issue.projectId,
-                            linearIssueId: issue.linearIssueId,
-                            prNumber: pr.number,
-                            ...(pr.url ? { prUrl: pr.url } : {}),
-                            ...(pr.state ? { prState: pr.state.toLowerCase() } : {}),
-                            ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                            ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
-                        }, "published PR verification refresh");
-                        return undefined;
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.debug({
-                    issueKey: issue.issueKey,
-                    branchName: issue.branchName,
-                    repoFullName: project.github.repoFullName,
-                    error: error instanceof Error ? error.message : String(error),
-                }, "Failed to verify published PR state after implementation");
-            }
-        }
-        const details = await this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
-        return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
-    }
-    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;
-    }
-    async describeLocalImplementationOutcome(issue, baseBranch, deliveryMode = "publish_pr") {
-        if (!issue.worktreePath) {
-            return undefined;
-        }
-        try {
-            const status = await execCommand(this.config.runner.gitBin, [
-                "-C",
-                issue.worktreePath,
-                "status",
-                "--short",
-            ], { timeoutMs: 10_000 });
-            const dirtyEntries = status.exitCode === 0
-                ? status.stdout.split("\n").map((line) => line.trim()).filter(Boolean)
-                : [];
-            if (dirtyEntries.length > 0) {
-                if (deliveryMode === "linear_only") {
-                    return `Planning-only implementation should not modify the repo; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
-                }
-                return `Implementation completed without opening a PR; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
-            }
-        }
-        catch {
-            // Best effort only.
-        }
-        try {
-            const ahead = await execCommand(this.config.runner.gitBin, [
-                "-C",
-                issue.worktreePath,
-                "rev-list",
-                "--count",
-                `origin/${baseBranch}..HEAD`,
-            ], { timeoutMs: 10_000 });
-            if (ahead.exitCode === 0) {
-                const count = Number(ahead.stdout.trim());
-                if (Number.isFinite(count) && count > 0) {
-                    if (deliveryMode === "linear_only") {
-                        return `Planning-only implementation should not create repo commits; worktree is ${count} local commit(s) ahead of origin/${baseBranch}`;
-                    }
-                    return `Implementation completed with ${count} local commit(s) ahead of origin/${baseBranch} but no PR was observed`;
-                }
-            }
-        }
-        catch {
-            // Best effort only.
-        }
-        return undefined;
+        return await this.implementationOutcomes.verifyPublishedRunOutcome(run, issue);
     }
 }

package/dist/run-finalizer.js

@@ -159,12 +159,15 @@ export class RunFinalizer {
         });
         const updatedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
         const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
-        void this.linearSync.emitActivity(updatedIssue, buildRunCompletedActivity({
+        const linearActivity = buildRunCompletedActivity({
             runType: run.runType,
             completionSummary,
             postRunState: updatedIssue.factoryState,
             ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
-        }));
+        });
+        if (linearActivity) {
+            void this.linearSync.emitActivity(updatedIssue, linearActivity);
+        }
         void this.linearSync.syncSession(updatedIssue);
         this.linearSync.clearProgress(run.id);
         this.releaseLease(run.projectId, run.linearIssueId);

package/dist/run-notification-handler.js

@@ -0,0 +1,123 @@
+import { buildRunFailureActivity } from "./linear-session-reporting.js";
+import { extractTurnId, resolveRunCompletionStatus } from "./run-reporting.js";
+import { resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
+function isRequestedChangesRunType(runType) {
+    return runType === "review_fix" || runType === "branch_upkeep";
+}
+export class RunNotificationHandler {
+    config;
+    db;
+    logger;
+    linearSync;
+    runFinalizer;
+    readThreadWithRetry;
+    withHeldIssueSessionLease;
+    heartbeatIssueSessionLease;
+    releaseIssueSessionLease;
+    feed;
+    activeThreadId;
+    constructor(config, db, logger, linearSync, runFinalizer, readThreadWithRetry, withHeldIssueSessionLease, heartbeatIssueSessionLease, releaseIssueSessionLease, feed) {
+        this.config = config;
+        this.db = db;
+        this.logger = logger;
+        this.linearSync = linearSync;
+        this.runFinalizer = runFinalizer;
+        this.readThreadWithRetry = readThreadWithRetry;
+        this.withHeldIssueSessionLease = withHeldIssueSessionLease;
+        this.heartbeatIssueSessionLease = heartbeatIssueSessionLease;
+        this.releaseIssueSessionLease = releaseIssueSessionLease;
+        this.feed = feed;
+    }
+    async handle(notification) {
+        let threadId = typeof notification.params.threadId === "string" ? notification.params.threadId : undefined;
+        if (!threadId) {
+            threadId = this.activeThreadId;
+        }
+        if (!threadId)
+            return;
+        if (notification.method === "turn/started") {
+            this.activeThreadId = threadId;
+        }
+        const run = this.db.runs.getRunByThreadId(threadId);
+        if (!run)
+            return;
+        if (!this.heartbeatIssueSessionLease(run.projectId, run.linearIssueId)) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Ignoring Codex notification after losing issue-session lease");
+            return;
+        }
+        const turnId = typeof notification.params.turnId === "string" ? notification.params.turnId : undefined;
+        if (this.config.runner.codex.persistExtendedHistory) {
+            this.db.runs.saveThreadEvent({
+                runId: run.id,
+                threadId,
+                ...(turnId ? { turnId } : {}),
+                method: notification.method,
+                eventJson: JSON.stringify(notification.params),
+            });
+        }
+        this.linearSync.maybeEmitProgress(notification, run);
+        if (notification.method === "turn/plan/updated") {
+            const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
+            if (issue) {
+                void this.linearSync.syncCodexPlan(issue, notification.params);
+            }
+        }
+        if (notification.method !== "turn/completed")
+            return;
+        const thread = await this.readThreadWithRetry(threadId);
+        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
+        if (!issue)
+            return;
+        const completedTurnId = extractTurnId(notification.params);
+        const status = resolveRunCompletionStatus(notification.params);
+        if (status === "failed") {
+            const nextState = isRequestedChangesRunType(run.runType) ? "escalated" : "failed";
+            const updated = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (lease) => {
+                this.db.issueSessions.finishRunWithLease(lease, run.id, {
+                    status: "failed",
+                    threadId,
+                    ...(completedTurnId ? { turnId: completedTurnId } : {}),
+                    failureReason: "Codex reported the turn completed in a failed state",
+                });
+                this.db.issueSessions.upsertIssueWithLease(lease, {
+                    projectId: run.projectId,
+                    linearIssueId: run.linearIssueId,
+                    activeRunId: null,
+                    factoryState: nextState,
+                });
+                return true;
+            });
+            if (!updated) {
+                this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping failed-turn cleanup after losing issue-session lease");
+                this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+                return;
+            }
+            this.feed?.publish({
+                level: "error",
+                kind: "turn",
+                issueKey: issue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "failed",
+                summary: `Turn failed for ${run.runType}`,
+            });
+            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            this.activeThreadId = undefined;
+            this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        await this.runFinalizer.finalizeCompletedRun({
+            source: "notification",
+            run,
+            issue,
+            thread,
+            threadId,
+            ...(completedTurnId ? { completedTurnId } : {}),
+            resolveRecoverableRunState: resolveRecoverablePostRunState,
+        });
+        this.activeThreadId = undefined;
+    }
+}