patchrelay 0.76.0 → 0.78.0

package/dist/interrupted-run-recovery.js

@@ -1,240 +0,0 @@
-import { ACTIVE_RUN_STATES } from "./factory-state.js";
-import { buildRunFailureActivity } from "./linear-session-reporting.js";
-import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
-import { isRequestedChangesRunType } from "./reactive-pr-state.js";
-const WRITER = "interrupted-run-recovery";
-// Roll back the attempt counter consumed by the interrupted run and clear the
-// attempted-failure provenance for repair runs, as a single issue update so
-// the whole repair commits (and conflict-recomputes) atomically.
-function buildInterruptedAttemptRepairUpdate(runType, issue) {
-    const counter = runType === "ci_repair" && issue.ciRepairAttempts > 0
-        ? { ciRepairAttempts: issue.ciRepairAttempts - 1 }
-        : runType === "queue_repair" && issue.queueRepairAttempts > 0
-            ? { queueRepairAttempts: issue.queueRepairAttempts - 1 }
-            : isRequestedChangesRunType(runType) && issue.reviewFixAttempts > 0
-                ? { reviewFixAttempts: issue.reviewFixAttempts - 1 }
-                : undefined;
-    const provenance = runType === "ci_repair" || runType === "queue_repair"
-        ? {
-            lastAttemptedFailureHeadSha: null,
-            lastAttemptedFailureSignature: null,
-            lastAttemptedFailureAt: null,
-        }
-        : undefined;
-    if (!counter && !provenance)
-        return undefined;
-    return {
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
-        ...counter,
-        ...provenance,
-    };
-}
-function resolveRetryRunType(runType, context) {
-    if (runType === "branch_upkeep") {
-        return "branch_upkeep";
-    }
-    return context?.reviewFixMode === "branch_upkeep" || context?.branchUpkeepRequired === true
-        ? "branch_upkeep"
-        : "review_fix";
-}
-function resolvePostRunState(issue) {
-    if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
-        if (issue.prState === "merged")
-            return "done";
-        if (issue.prReviewState === "approved")
-            return "awaiting_queue";
-        return "pr_open";
-    }
-    return undefined;
-}
-export function resolveRecoverablePostRunState(issue) {
-    if (!issue.prNumber) {
-        return resolvePostRunState(issue);
-    }
-    if (issue.prState === "merged")
-        return "done";
-    if (issue.prState === "open") {
-        const reactiveIntent = deriveIssueSessionReactiveIntent({
-            prNumber: issue.prNumber,
-            prState: issue.prState,
-            prReviewState: issue.prReviewState,
-            prCheckStatus: issue.prCheckStatus,
-            latestFailureSource: issue.lastGitHubFailureSource,
-        });
-        if (reactiveIntent)
-            return reactiveIntent.compatibilityFactoryState;
-        if (issue.prReviewState === "approved")
-            return "awaiting_queue";
-        return "pr_open";
-    }
-    return resolvePostRunState(issue);
-}
-export class InterruptedRunRecovery {
-    db;
-    logger;
-    linearSync;
-    withHeldLease;
-    releaseLease;
-    failRunAndClear;
-    restoreIdleWorktree;
-    completionPolicy;
-    enqueueIssue;
-    feed;
-    constructor(db, logger, linearSync, withHeldLease, releaseLease, failRunAndClear, restoreIdleWorktree, completionPolicy, enqueueIssue, feed) {
-        this.db = db;
-        this.logger = logger;
-        this.linearSync = linearSync;
-        this.withHeldLease = withHeldLease;
-        this.releaseLease = releaseLease;
-        this.failRunAndClear = failRunAndClear;
-        this.restoreIdleWorktree = restoreIdleWorktree;
-        this.completionPolicy = completionPolicy;
-        this.enqueueIssue = enqueueIssue;
-        this.feed = feed;
-    }
-    async handle(run, issue) {
-        this.logger.warn({ issueKey: issue.issueKey, runType: run.runType, threadId: run.threadId }, "Run has interrupted turn - marking as failed");
-        const repairedCounters = this.withHeldLease(issue.projectId, issue.linearIssueId, (lease) => {
-            // The decrement is read-modify-write against an issue row read before
-            // the awaits that led here; on conflict, recompute from the fresh row.
-            const update = buildInterruptedAttemptRepairUpdate(run.runType, issue);
-            if (update) {
-                this.db.issueSessions.commitIssueState({
-                    writer: WRITER,
-                    lease,
-                    expectedVersion: issue.version,
-                    update,
-                    onConflict: (current) => buildInterruptedAttemptRepairUpdate(run.runType, current),
-                });
-            }
-            return true;
-        });
-        if (!repairedCounters) {
-            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping interrupted-run recovery after losing issue-session lease");
-            this.releaseLease(run.projectId, run.linearIssueId);
-            return;
-        }
-        if (isRequestedChangesRunType(run.runType)) {
-            await this.handleInterruptedRequestedChangesRun(run, issue);
-            return;
-        }
-        if (run.runType === "implementation" && !issue.prNumber) {
-            await this.handleInterruptedImplementationRun(run, issue);
-            return;
-        }
-        const recoveredState = resolveRecoverablePostRunState(this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue);
-        this.failRunAndClear(run, "Codex turn was interrupted", recoveredState);
-        await this.restoreIdleWorktree(issue);
-        const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        if (recoveredState) {
-            this.feed?.publish({
-                level: "info",
-                kind: "stage",
-                issueKey: issue.issueKey,
-                projectId: run.projectId,
-                stage: recoveredState,
-                status: "reconciled",
-                summary: `Interrupted ${run.runType} recovered -> ${recoveredState}`,
-            });
-        }
-        else {
-            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, "The Codex turn was interrupted."));
-        }
-        void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
-        this.releaseLease(run.projectId, run.linearIssueId);
-    }
-    async handleInterruptedImplementationRun(run, issue) {
-        const interruptedMessage = "Implementation run was interrupted before PatchRelay could publish a PR";
-        this.failRunAndClear(run, "Codex turn was interrupted", "delegated");
-        await this.restoreIdleWorktree(issue);
-        const refreshedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(run.projectId, run.linearIssueId, {
-            projectId: run.projectId,
-            linearIssueId: run.linearIssueId,
-            eventType: "delegated",
-            dedupeKey: `interrupted_implementation:implementation:${run.linearIssueId}`,
-        });
-        if (!this.db.workflowWakes.peekIssueWake(run.projectId, run.linearIssueId)) {
-            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
-            this.feed?.publish({
-                level: "error",
-                kind: "workflow",
-                issueKey: issue.issueKey,
-                projectId: run.projectId,
-                stage: run.runType,
-                status: "escalated",
-                summary: interruptedMessage,
-            });
-            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, interruptedMessage));
-            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
-            this.releaseLease(run.projectId, run.linearIssueId);
-            return;
-        }
-        this.feed?.publish({
-            level: "warn",
-            kind: "workflow",
-            issueKey: issue.issueKey,
-            projectId: run.projectId,
-            stage: run.runType,
-            status: "retry_queued",
-            summary: "Implementation run was interrupted; PatchRelay will retry automatically",
-        });
-        const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
-        void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
-        this.enqueueIssue(run.projectId, run.linearIssueId);
-        this.releaseLease(run.projectId, run.linearIssueId);
-    }
-    async handleInterruptedRequestedChangesRun(run, issue) {
-        const freshIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        const refreshedIssue = await this.completionPolicy.refreshIssueAfterReactivePublish(run, freshIssue);
-        const retryContext = await this.completionPolicy.resolveRequestedChangesWakeContext(refreshedIssue, run.runType, run.runType === "branch_upkeep"
-            ? {
-                branchUpkeepRequired: true,
-                reviewFixMode: "branch_upkeep",
-                wakeReason: "branch_upkeep",
-            }
-            : undefined);
-        const retryRunType = resolveRetryRunType(run.runType, retryContext);
-        const recoveredState = resolveRecoverablePostRunState(refreshedIssue) ?? "failed";
-        const interruptedMessage = "Requested-changes run was interrupted before PatchRelay could verify that a new PR head was published";
-        this.failRunAndClear(run, interruptedMessage, recoveredState);
-        await this.restoreIdleWorktree(issue);
-        const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
-        if (recoveredState === "changes_requested") {
-            this.db.issueSessions.commitIssueState({
-                writer: WRITER,
-                update: {
-                    projectId: run.projectId,
-                    linearIssueId: run.linearIssueId,
-                    pendingRunType: retryRunType,
-                    pendingRunContextJson: retryContext ? JSON.stringify(retryContext) : null,
-                },
-            });
-            this.feed?.publish({
-                level: "warn",
-                kind: "workflow",
-                issueKey: issue.issueKey,
-                projectId: run.projectId,
-                stage: run.runType,
-                status: "retry_queued",
-                summary: "Requested-changes run was interrupted; PatchRelay will retry from fresh GitHub truth",
-            });
-            this.enqueueIssue(run.projectId, run.linearIssueId);
-        }
-        else {
-            this.feed?.publish({
-                level: "error",
-                kind: "workflow",
-                issueKey: issue.issueKey,
-                projectId: run.projectId,
-                stage: run.runType,
-                status: "escalated",
-                summary: interruptedMessage,
-            });
-        }
-        void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, interruptedMessage));
-        void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
-        this.releaseLease(run.projectId, run.linearIssueId);
-    }
-}

package/dist/run-recovery-service.js

@@ -1,239 +0,0 @@
-import { buildRunFailureActivity } from "./linear-session-reporting.js";
-import { getRemainingZombieRecoveryDelayMs } from "./zombie-recovery.js";
-const WRITER = "run-recovery-service";
-const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
-export class RunRecoveryService {
-    db;
-    logger;
-    linearSync;
-    withHeldLease;
-    getHeldLease;
-    appendWakeEventWithLease;
-    releaseLease;
-    enqueueIssue;
-    feed;
-    constructor(db, logger, linearSync, withHeldLease, getHeldLease, appendWakeEventWithLease, releaseLease, enqueueIssue, feed) {
-        this.db = db;
-        this.logger = logger;
-        this.linearSync = linearSync;
-        this.withHeldLease = withHeldLease;
-        this.getHeldLease = getHeldLease;
-        this.appendWakeEventWithLease = appendWakeEventWithLease;
-        this.releaseLease = releaseLease;
-        this.enqueueIssue = enqueueIssue;
-        this.feed = feed;
-    }
-    recoverOrEscalate(params) {
-        const { issue, runType, reason } = params;
-        const fresh = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
-        if (!fresh)
-            return;
-        if (params.isRequestedChangesRunType(runType)) {
-            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
-                this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
-                this.db.issueSessions.commitIssueState({
-                    writer: WRITER,
-                    lease,
-                    update: {
-                        projectId: fresh.projectId,
-                        linearIssueId: fresh.linearIssueId,
-                        pendingRunType: null,
-                        pendingRunContextJson: null,
-                        factoryState: "escalated",
-                    },
-                });
-                return true;
-            });
-            if (!updated) {
-                this.logger.warn({ issueKey: fresh.issueKey, reason }, "Skipping review-fix recovery escalation after losing issue-session lease");
-                this.releaseLease(fresh.projectId, fresh.linearIssueId);
-                return;
-            }
-            this.logger.warn({ issueKey: fresh.issueKey, reason }, "Requested-changes run failed before a new head was published - escalating");
-            this.feed?.publish({
-                level: "error",
-                kind: "workflow",
-                issueKey: fresh.issueKey,
-                projectId: fresh.projectId,
-                stage: runType,
-                status: "escalated",
-                summary: `Requested-changes run failed before publishing a new head (${reason})`,
-            });
-            this.releaseLease(fresh.projectId, fresh.linearIssueId);
-            return;
-        }
-        if (fresh.prState === "merged") {
-            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
-                this.db.issueSessions.commitIssueState({
-                    writer: WRITER,
-                    lease,
-                    update: {
-                        projectId: fresh.projectId,
-                        linearIssueId: fresh.linearIssueId,
-                        factoryState: "done",
-                        zombieRecoveryAttempts: 0,
-                        lastZombieRecoveryAt: null,
-                    },
-                });
-                return true;
-            });
-            if (!updated) {
-                this.logger.warn({ issueKey: fresh.issueKey, reason }, "Skipping merged recovery completion after losing issue-session lease");
-                this.releaseLease(fresh.projectId, fresh.linearIssueId);
-                return;
-            }
-            this.logger.info({ issueKey: fresh.issueKey, reason }, "Recovery: PR already merged - transitioning to done");
-            this.releaseLease(fresh.projectId, fresh.linearIssueId);
-            return;
-        }
-        const attempts = fresh.zombieRecoveryAttempts + 1;
-        if (attempts > DEFAULT_ZOMBIE_RECOVERY_BUDGET) {
-            const updated = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
-                this.db.issueSessions.commitIssueState({
-                    writer: WRITER,
-                    lease,
-                    update: {
-                        projectId: fresh.projectId,
-                        linearIssueId: fresh.linearIssueId,
-                        factoryState: "escalated",
-                    },
-                });
-                return true;
-            });
-            if (!updated) {
-                this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Skipping recovery escalation after losing issue-session lease");
-                this.releaseLease(fresh.projectId, fresh.linearIssueId);
-                return;
-            }
-            this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: budget exhausted - escalating");
-            this.feed?.publish({
-                level: "error",
-                kind: "workflow",
-                issueKey: fresh.issueKey,
-                projectId: fresh.projectId,
-                stage: "escalated",
-                status: "budget_exhausted",
-                summary: `${reason} recovery failed after ${DEFAULT_ZOMBIE_RECOVERY_BUDGET} attempts`,
-            });
-            this.releaseLease(fresh.projectId, fresh.linearIssueId);
-            return;
-        }
-        if (fresh.lastZombieRecoveryAt) {
-            const remainingDelayMs = getRemainingZombieRecoveryDelayMs(fresh.lastZombieRecoveryAt, fresh.zombieRecoveryAttempts);
-            if (remainingDelayMs > 0) {
-                this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
-                    this.appendWakeEventWithLease(lease, fresh, runType, undefined, `recovery:${attempts}`);
-                });
-                this.logger.debug({ issueKey: fresh.issueKey, attempts: fresh.zombieRecoveryAttempts, remainingDelayMs }, "Recovery: backoff not elapsed, deferring retry");
-                return;
-            }
-        }
-        const requeued = this.withHeldLease(fresh.projectId, fresh.linearIssueId, (lease) => {
-            // `attempts` is read-modify-write against the fresh row read above; on
-            // conflict recompute the counter from the current row.
-            const buildRequeueUpdate = (record) => ({
-                projectId: fresh.projectId,
-                linearIssueId: fresh.linearIssueId,
-                pendingRunType: null,
-                pendingRunContextJson: null,
-                zombieRecoveryAttempts: record.zombieRecoveryAttempts + 1,
-                lastZombieRecoveryAt: new Date().toISOString(),
-            });
-            this.db.issueSessions.commitIssueState({
-                writer: WRITER,
-                lease,
-                expectedVersion: fresh.version,
-                update: buildRequeueUpdate(fresh),
-                onConflict: (current) => buildRequeueUpdate(current),
-            });
-            return this.appendWakeEventWithLease(lease, fresh, runType, undefined, `recovery:${attempts}`);
-        });
-        if (!requeued) {
-            this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Skipping recovery re-enqueue after losing issue-session lease");
-            this.releaseLease(fresh.projectId, fresh.linearIssueId);
-            return;
-        }
-        this.enqueueIssue(fresh.projectId, fresh.linearIssueId);
-        this.logger.info({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: re-enqueued with backoff");
-    }
-    escalate(params) {
-        const { issue, runType, reason } = params;
-        this.logger.warn({ issueKey: issue.issueKey, runType, reason }, "Escalating to human");
-        const escalated = this.withHeldLease(issue.projectId, issue.linearIssueId, (lease) => {
-            // Escalation is an operator-facing decision: the issue write and the
-            // run release ride in the held-lease transaction, with the run gated
-            // on the issue commit.
-            const commit = this.db.issueSessions.commitIssueState({
-                writer: WRITER,
-                lease,
-                update: {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    pendingRunType: null,
-                    pendingRunContextJson: null,
-                    activeRunId: null,
-                    factoryState: "escalated",
-                },
-            });
-            if (commit.outcome !== "applied")
-                return false;
-            if (issue.activeRunId) {
-                this.db.runs.finishRun(issue.activeRunId, { status: "released" });
-            }
-            this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
-            return true;
-        });
-        if (!escalated) {
-            this.logger.warn({ issueKey: issue.issueKey, runType }, "Skipping escalation write after losing issue-session lease");
-            this.releaseLease(issue.projectId, issue.linearIssueId);
-            return;
-        }
-        this.feed?.publish({
-            level: "error",
-            kind: "workflow",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: runType,
-            status: "escalated",
-            summary: `Escalated: ${reason}`,
-        });
-        const escalatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-        void this.linearSync.emitActivity(escalatedIssue, {
-            type: "error",
-            body: `PatchRelay needs human help to continue.\n\n${reason}`,
-        });
-        void this.linearSync.syncSession(escalatedIssue);
-        this.releaseLease(issue.projectId, issue.linearIssueId);
-    }
-    failRunAndClear(params) {
-        const { run, message, nextState } = params;
-        const updated = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
-            const commit = this.db.issueSessions.commitIssueState({
-                writer: WRITER,
-                update: {
-                    projectId: run.projectId,
-                    linearIssueId: run.linearIssueId,
-                    activeRunId: null,
-                    factoryState: nextState,
-                },
-            });
-            if (commit.outcome !== "applied") {
-                return false;
-            }
-            this.db.runs.finishRun(run.id, { status: "failed", failureReason: message });
-            if (nextState === "failed" || nextState === "escalated" || nextState === "awaiting_input" || nextState === "done") {
-                this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
-            }
-            return true;
-        });
-        if (!updated) {
-            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping failure cleanup after losing issue-session lease");
-        }
-        this.releaseLease(run.projectId, run.linearIssueId);
-    }
-    emitInterruptedFailure(runType, issue, message) {
-        const latest = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-        void this.linearSync.emitActivity(latest, buildRunFailureActivity(runType, message));
-        void this.linearSync.syncSession(latest, { activeRunType: runType });
-    }
-}

package/dist/zombie-recovery.js

@@ -1,13 +0,0 @@
-const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000;
-export function getZombieRecoveryDelayMs(recoveryAttempts) {
-    return ZOMBIE_RECOVERY_BASE_DELAY_MS * Math.pow(2, recoveryAttempts);
-}
-export function getRemainingZombieRecoveryDelayMs(lastRecoveryAt, recoveryAttempts, now = Date.now()) {
-    if (!lastRecoveryAt)
-        return 0;
-    const recoveredAtMs = Date.parse(lastRecoveryAt);
-    if (!Number.isFinite(recoveredAtMs))
-        return 0;
-    const delay = getZombieRecoveryDelayMs(recoveryAttempts);
-    return Math.max(0, recoveredAtMs + delay - now);
-}