patchrelay 0.79.0 → 0.80.1

package/dist/awaiting-input-reason.js

@@ -1,9 +1,8 @@
+import { deriveIssueExecutionState } from "./issue-execution-state.js";
 export function resolveAwaitingInputReason(params) {
-    if (params.issue.factoryState !== "awaiting_input") {
-        return undefined;
-    }
-    if (params.latestRun?.completionCheckOutcome === "needs_input") {
-        return "completion_check_question";
-    }
-    return "paused_local_work";
+    const state = deriveIssueExecutionState({
+        factoryState: params.issue.factoryState,
+        latestRunCompletionCheckOutcome: params.latestRun?.completionCheckOutcome,
+    });
+    return state.kind === "waiting_input" ? state.reason : undefined;
 }

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.79.0",
-  "commit": "497f534ca6a5",
-  "builtAt": "2026-06-10T21:17:11.105Z"
+  "version": "0.80.1",
+  "commit": "d2c60661d5fa",
+  "builtAt": "2026-06-10T22:15:08.651Z"
 }

package/dist/idle-reconciliation.js

@@ -775,7 +775,7 @@ export class IdleIssueReconciler {
                 return;
             }
             if (isReviewDecisionApproved(pr.reviewDecision)) {
-                this.db.issueSessions.commitIssueState({
+                const reviewCommit = this.db.issueSessions.commitIssueState({
                     writer: WRITER,
                     update: {
                         projectId: issue.projectId,
@@ -783,6 +783,14 @@ export class IdleIssueReconciler {
                         prReviewState: "approved",
                     },
                 });
+                // Continue with the refreshed row so the version-checked advance
+                // below doesn't see our own review-state write as a conflict (same
+                // pattern as the facts commit above). Without this the advance was
+                // conflict-skipped on EVERY pass while the poll succeeded, so a lost
+                // review_approved webhook never converged to awaiting_queue.
+                if (reviewCommit.outcome === "applied") {
+                    issue = reviewCommit.issue;
+                }
                 const approvedState = deriveFactoryStateFromPrFacts(observed, currentFacts(issue));
                 if (approvedState === "awaiting_queue") {
                     // Provenance survives unless the polled evidence is newer than the

package/dist/issue-execution-state.js

@@ -0,0 +1,139 @@
+import { hasOpenPr } from "./pr-state.js";
+/** Run statuses that may legally occupy an issue's active-run slot. */
+const ACTIVE_RUN_STATUSES = new Set(["queued", "running"]);
+export function deriveIssueExecutionState(params) {
+    const factoryState = params.factoryState;
+    // Undelegation pauses automation for any non-finished issue and outranks
+    // every other answer (including an active run, which keeps executing but
+    // is reported as paused-with-downstream-continuation where relevant).
+    if (params.delegatedToPatchRelay === false
+        && factoryState !== "done"
+        && factoryState !== "failed"
+        && factoryState !== "escalated") {
+        const downstreamMayContinue = factoryState === "awaiting_queue"
+            || (hasOpenPr(params.prNumber, params.prState) && params.prReviewState === "approved");
+        return { kind: "undelegated", downstreamMayContinue };
+    }
+    // Active run facts win next — the issue is moving (or claims to be).
+    if (params.activeRunType || params.activeRunId !== undefined) {
+        const run = {
+            ...(params.activeRunId !== undefined ? { activeRunId: params.activeRunId } : {}),
+            ...(params.activeRunType ? { runType: params.activeRunType } : {}),
+            phase: resolveRunPhase(params),
+        };
+        // `done` + active run is a legitimate finalizing window (the post-run
+        // finalizer advances factoryState before clearing the slot), and
+        // `awaiting_input` + active run is a resumed reply turn. `failed` /
+        // `escalated` should never hold a slot: settleRun clears it before the
+        // terminal transition lands.
+        if (factoryState === "failed" || factoryState === "escalated") {
+            return {
+                kind: "inconsistent",
+                description: `terminal factoryState "${factoryState}" still holds an active run slot`,
+                run,
+            };
+        }
+        if (params.activeRunStatus !== undefined && !ACTIVE_RUN_STATUSES.has(params.activeRunStatus)) {
+            return {
+                kind: "inconsistent",
+                description: `active run slot points at a ${params.activeRunStatus} run`,
+                run,
+            };
+        }
+        return { kind: "running", run };
+    }
+    if (params.orchestrationSettleUntil) {
+        const settleAt = Date.parse(params.orchestrationSettleUntil);
+        if (Number.isFinite(settleAt) && settleAt > (params.now ?? Date.now())) {
+            return { kind: "settling", settleUntil: params.orchestrationSettleUntil };
+        }
+    }
+    const blockedByKeys = (params.blockedByKeys ?? []).filter((value) => value.trim().length > 0);
+    if (blockedByKeys.length > 0) {
+        return { kind: "blocked", blockedByKeys };
+    }
+    switch (factoryState) {
+        case "awaiting_input":
+            return {
+                kind: "waiting_input",
+                reason: params.latestRunCompletionCheckOutcome === "needs_input"
+                    ? "completion_check_question"
+                    : "paused_local_work",
+            };
+        case "changes_requested":
+            return { kind: "awaiting_followup", followup: "review_fix" };
+        case "repairing_ci":
+            return { kind: "awaiting_followup", followup: "ci_repair", checkName: params.latestFailureCheckName };
+        case "repairing_queue":
+            return { kind: "awaiting_followup", followup: "queue_repair" };
+        case "awaiting_queue":
+            return { kind: "idle_awaiting_external", waitingOn: "merge_queue" };
+        case "done":
+            return { kind: "terminal", outcome: "done" };
+        case "failed":
+            return { kind: "terminal", outcome: "failed" };
+        case "escalated":
+            return { kind: "terminal", outcome: "escalated" };
+        default:
+            break;
+    }
+    // delegated / implementing / pr_open / deploying: the wait, if any, is
+    // derived from live PR truth.
+    if (params.prCheckStatus === "failed" || params.prCheckStatus === "failure") {
+        return { kind: "idle_awaiting_external", waitingOn: "ci_failure", checkName: params.latestFailureCheckName };
+    }
+    if (params.prReviewState === "changes_requested") {
+        if (params.prCheckStatus === "passed" || params.prCheckStatus === "success") {
+            if (params.prHeadSha
+                && params.lastBlockingReviewHeadSha
+                && params.prHeadSha !== params.lastBlockingReviewHeadSha) {
+                return { kind: "idle_awaiting_external", waitingOn: "review_of_new_head" };
+            }
+            return { kind: "idle_awaiting_external", waitingOn: "blocking_review_same_head" };
+        }
+        return { kind: "idle_awaiting_external", waitingOn: "review_feedback" };
+    }
+    if (params.prReviewState === "approved") {
+        return { kind: "idle_awaiting_external", waitingOn: "downstream_automation" };
+    }
+    if (hasOpenPr(params.prNumber, params.prState)) {
+        return { kind: "idle_awaiting_external", waitingOn: "external_review" };
+    }
+    if (params.pendingRunType) {
+        return { kind: "ready", pendingRunType: params.pendingRunType };
+    }
+    return { kind: "idle" };
+}
+function resolveRunPhase(params) {
+    if (hasOpenPr(params.prNumber, params.prState) && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
+        return "finalizing_published_pr";
+    }
+    if (params.factoryState === "done") {
+        return "finalizing_merged_change";
+    }
+    return "working";
+}
+/** Build the deriver input from full records (issue row + resolved runs). */
+export function issueExecutionStateInputFromRecords(issue, extras) {
+    return {
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
+        factoryState: issue.factoryState,
+        activeRunId: issue.activeRunId,
+        activeRunType: extras?.activeRun?.runType,
+        activeRunStatus: extras?.activeRun?.status,
+        latestRunCompletionCheckOutcome: extras?.latestRun?.completionCheckOutcome,
+        pendingRunType: issue.pendingRunType,
+        blockedByKeys: extras?.blockedByKeys,
+        orchestrationSettleUntil: issue.orchestrationSettleUntil,
+        prNumber: issue.prNumber,
+        prState: issue.prState,
+        prHeadSha: issue.prHeadSha,
+        prReviewState: issue.prReviewState,
+        prCheckStatus: issue.prCheckStatus,
+        lastBlockingReviewHeadSha: issue.lastBlockingReviewHeadSha,
+        latestFailureCheckName: issue.lastGitHubFailureCheckName,
+    };
+}
+export function deriveIssueExecutionStateFromRecords(issue, extras) {
+    return deriveIssueExecutionState(issueExecutionStateInputFromRecords(issue, extras));
+}

package/dist/issue-session-lease-service.js

@@ -1,34 +1,51 @@
 import { randomUUID } from "node:crypto";
-import { getThreadTurns } from "./codex-thread-utils.js";
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
-const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
+export const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
+/**
+ * Expected heartbeat cadence for a live lease holder. Heartbeats are
+ * notification-driven (every Codex notification renews the lease) rather
+ * than timer-driven, so this is the staleness budget granted to a live
+ * holder, not a timer the service runs. A foreign holder whose inferred
+ * last heartbeat (`leasedUntil - ISSUE_SESSION_LEASE_MS`) is older than
+ * 2x this budget is presumed dead (crashed process) and its lease may be
+ * reclaimed for recovery without waiting for full TTL expiry.
+ */
+export const ISSUE_SESSION_HEARTBEAT_INTERVAL_MS = 60_000;
+const FOREIGN_LEASE_RECLAIM_STALENESS_MS = 2 * ISSUE_SESSION_HEARTBEAT_INTERVAL_MS;
+/**
+ * Issue-session lease coordination over the `issue_sessions` lease columns.
+ * The DB row (`lease_id`, `worker_id`, `leased_until`) is the only truth —
+ * there is no in-memory mirror, so a restarted process loses no lease state
+ * (D4, core simplification plan). "Held by us" means the row carries this
+ * service's `workerId` with an unexpired `leased_until`.
+ */
 export class IssueSessionLeaseService {
     db;
     logger;
     workerId;
-    readThreadWithRetry;
     telemetry;
-    activeSessionLeases = new Map();
-    constructor(db, logger, workerId, readThreadWithRetry, telemetry = noopTelemetry) {
+    constructor(db, logger, workerId, telemetry = noopTelemetry) {
         this.db = db;
         this.logger = logger;
         this.workerId = workerId;
-        this.readThreadWithRetry = readThreadWithRetry;
         this.telemetry = telemetry;
     }
     hasLocalLease(projectId, linearIssueId) {
-        return this.getValidatedLocalLeaseId(projectId, linearIssueId) !== undefined;
+        return this.getHeldLease(projectId, linearIssueId) !== undefined;
     }
     getHeldLease(projectId, linearIssueId) {
-        const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
-        if (!leaseId)
+        const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
+        if (!session?.leaseId || session.workerId !== this.workerId || !isLeaseActive(session)) {
             return undefined;
-        return { projectId, linearIssueId, leaseId };
+        }
+        return { projectId, linearIssueId, leaseId: session.leaseId };
     }
     withHeldLease(projectId, linearIssueId, fn) {
         const lease = this.getHeldLease(projectId, linearIssueId);
         if (!lease)
             return undefined;
+        // Re-validated inside the store's transaction so the check and the
+        // guarded writes are atomic.
         return this.db.issueSessions.withIssueSessionLease(projectId, linearIssueId, lease.leaseId, () => fn(lease));
     }
     acquire(projectId, linearIssueId) {
@@ -46,7 +63,6 @@ export class IssueSessionLeaseService {
             this.emitStaleLeaseInvariantIfRunnable(projectId, linearIssueId);
             return undefined;
         }
-        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
         this.emitLease("lease.acquired", projectId, linearIssueId, leaseId);
         return leaseId;
     }
@@ -64,20 +80,17 @@ export class IssueSessionLeaseService {
             this.emitLease("lease.acquire_failed", projectId, linearIssueId);
             return undefined;
         }
-        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
         this.emitLease("lease.acquired", projectId, linearIssueId, leaseId);
         return leaseId;
     }
     claimForReconciliation(projectId, linearIssueId) {
-        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        if (this.activeSessionLeases.has(key)) {
-            return "owned";
-        }
         const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
         if (!session)
             return "skip";
-        const leasedUntilMs = session.leasedUntil ? Date.parse(session.leasedUntil) : undefined;
-        if (leasedUntilMs !== undefined && Number.isFinite(leasedUntilMs) && leasedUntilMs > Date.now()) {
+        if (isLeaseActive(session)) {
+            if (session.workerId === this.workerId) {
+                return "owned";
+            }
             this.emitStaleLeaseInvariantIfRunnable(projectId, linearIssueId);
             return "skip";
         }
@@ -86,11 +99,16 @@ export class IssueSessionLeaseService {
         }
         return this.acquire(projectId, linearIssueId) ? true : "skip";
     }
-    async reclaimForeignRecoveryLeaseIfSafe(run, issue) {
-        const key = this.issueSessionLeaseKey(run.projectId, run.linearIssueId);
-        if (this.activeSessionLeases.has(key)) {
-            return false;
-        }
+    /**
+     * Post-crash recovery shortcut: take over a foreign (other-worker) lease on
+     * an issue whose active run needs recovery, without waiting for full TTL
+     * expiry. Safe purely on heartbeat staleness — post-phase-B invariants make
+     * the recovery path idempotent (settleRun is idempotent, slot-clearing has
+     * exactly one owner, recovery is detect → RunFailurePolicy → settleRun) —
+     * so no Codex thread probing is needed. A holder that has not heartbeat
+     * for 2x the heartbeat budget is presumed dead.
+     */
+    reclaimForeignRecoveryLeaseIfSafe(run, issue) {
         const session = this.db.issueSessions.getIssueSession(run.projectId, run.linearIssueId);
         if (!session?.leaseId || !session.workerId || session.workerId === this.workerId) {
             return false;
@@ -98,20 +116,12 @@ export class IssueSessionLeaseService {
         if (issue.activeRunId !== run.id) {
             return false;
         }
-        let safeToReclaim = !run.threadId;
-        if (!safeToReclaim && run.threadId) {
-            try {
-                const thread = await this.readThreadWithRetry(run.threadId, 1);
-                const latestTurn = getThreadTurns(thread).at(-1);
-                safeToReclaim = thread.status === "notLoaded"
-                    || latestTurn?.status === "interrupted"
-                    || latestTurn?.status === "completed";
-            }
-            catch {
-                safeToReclaim = true;
-            }
-        }
-        if (!safeToReclaim) {
+        const leasedUntilMs = session.leasedUntil ? Date.parse(session.leasedUntil) : Number.NaN;
+        // A lease row without a parseable leasedUntil cannot prove a live holder.
+        const heartbeatAgeMs = Number.isFinite(leasedUntilMs)
+            ? Date.now() - (leasedUntilMs - ISSUE_SESSION_LEASE_MS)
+            : Number.POSITIVE_INFINITY;
+        if (heartbeatAgeMs < FOREIGN_LEASE_RECLAIM_STALENESS_MS) {
             return false;
         }
         const leaseId = this.forceAcquire(run.projectId, run.linearIssueId);
@@ -123,6 +133,7 @@ export class IssueSessionLeaseService {
             runId: run.id,
             previousWorkerId: session.workerId,
             previousLeaseId: session.leaseId,
+            heartbeatAgeMs: Math.round(heartbeatAgeMs),
             reclaimedLeaseId: leaseId,
         }, "Reclaimed foreign issue-session lease for active-run recovery");
         emitTelemetry(this.telemetry, {
@@ -138,43 +149,29 @@ export class IssueSessionLeaseService {
         return true;
     }
     heartbeat(projectId, linearIssueId) {
-        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        const leaseId = this.activeSessionLeases.get(key) ?? this.db.issueSessions.getIssueSession(projectId, linearIssueId)?.leaseId;
-        if (!leaseId)
+        const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
+        // Only this worker's lease may be renewed: extending a foreign holder's
+        // lease would let a launch proceed against a lease we do not hold.
+        if (!session?.leaseId || session.workerId !== this.workerId) {
             return false;
-        const renewed = this.db.issueSessions.renewIssueSessionLease({
+        }
+        return this.db.issueSessions.renewIssueSessionLease({
             projectId,
             linearIssueId,
-            leaseId,
+            leaseId: session.leaseId,
             leasedUntil: new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString(),
         });
-        if (renewed) {
-            this.activeSessionLeases.set(key, leaseId);
-            return true;
-        }
-        this.activeSessionLeases.delete(key);
-        return false;
     }
     release(projectId, linearIssueId) {
-        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
-        this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, leaseId);
-        this.activeSessionLeases.delete(key);
-        this.emitLease("lease.released", projectId, linearIssueId, leaseId);
-    }
-    getValidatedLocalLeaseId(projectId, linearIssueId) {
-        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        const leaseId = this.activeSessionLeases.get(key);
-        if (!leaseId)
-            return undefined;
-        if (this.db.issueSessions.hasActiveIssueSessionLease(projectId, linearIssueId, leaseId)) {
-            return leaseId;
+        const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
+        const ownLeaseId = session?.workerId === this.workerId ? session.leaseId : undefined;
+        if (!ownLeaseId && session?.leaseId && isLeaseActive(session)) {
+            // An active foreign lease is not ours to clear; expired leftovers are
+            // swept by releaseExpiredIssueSessionLeases.
+            return;
         }
-        this.activeSessionLeases.delete(key);
-        return undefined;
-    }
-    issueSessionLeaseKey(projectId, linearIssueId) {
-        return `${projectId}:${linearIssueId}`;
+        this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, ownLeaseId);
+        this.emitLease("lease.released", projectId, linearIssueId, ownLeaseId);
     }
     emitLease(type, projectId, linearIssueId, leaseId) {
         const issue = this.db.issues.getIssue(projectId, linearIssueId);
@@ -206,3 +203,9 @@ export class IssueSessionLeaseService {
         });
     }
 }
+function isLeaseActive(session, now = Date.now()) {
+    if (!session.leaseId || !session.leasedUntil)
+        return false;
+    const leasedUntilMs = Date.parse(session.leasedUntil);
+    return Number.isFinite(leasedUntilMs) && leasedUntilMs > now;
+}

package/dist/issue-session.js

@@ -1,4 +1,3 @@
-import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 export function deriveIssueSessionState(params) {
     if (params.factoryState === "done")
         return "done";
@@ -10,9 +9,6 @@ export function deriveIssueSessionState(params) {
         return "running";
     return "idle";
 }
-export function deriveIssueSessionWaitingReason(params) {
-    return derivePatchRelayWaitingReason(params);
-}
 export function deriveIssueSessionWakeReason(params) {
     if (params.delegatedToPatchRelay === false)
         return undefined;

package/dist/paused-issue-state.js

@@ -1,9 +1,10 @@
 import { resolveAwaitingInputReason } from "./awaiting-input-reason.js";
+import { deriveIssueExecutionState } from "./issue-execution-state.js";
 export function isUndelegatedPausedIssue(issue) {
-    return issue.delegatedToPatchRelay === false
-        && issue.factoryState !== "done"
-        && issue.factoryState !== "failed"
-        && issue.factoryState !== "escalated";
+    return deriveIssueExecutionState({
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
+        factoryState: issue.factoryState,
+    }).kind === "undelegated";
 }
 export function isUndelegatedPausedNoPrWork(issue) {
     return isUndelegatedPausedIssue(issue)

package/dist/run-orchestrator.js

@@ -82,7 +82,6 @@ export class RunOrchestrator {
         failRunAndClear: (run, message, nextState) => this.failRunAndClear(run, message, nextState),
         restoreIdleWorktree: (issue) => this.restoreIdleWorktree(issue),
     };
-    activeSessionLeases;
     botIdentity;
     wakeDispatcher;
     logger;
@@ -124,8 +123,7 @@ export class RunOrchestrator {
         this.worktreeManager = new WorktreeManager(config);
         this.codexRuntimeConfig = config.runner.codex;
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
-        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, this.threadPorts.readThreadWithRetry, telemetry);
-        this.activeSessionLeases = this.leaseService.activeSessionLeases;
+        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, telemetry);
         this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, this.leasePorts.withHeldLease);
         this.completionCheck = new CompletionCheckService(codex, logger);
         this.issueTriage = new IssueTriageService(codex, logger);
@@ -648,7 +646,7 @@ export class RunOrchestrator {
         if (!issue)
             return;
         let recoveryLease = this.claimLeaseForReconciliation(run.projectId, run.linearIssueId);
-        if (recoveryLease === "skip" && await this.reclaimForeignRecoveryLeaseIfSafe(run, issue)) {
+        if (recoveryLease === "skip" && this.reclaimForeignRecoveryLeaseIfSafe(run, issue)) {
             recoveryLease = true;
         }
         if (recoveryLease === "skip")
@@ -725,8 +723,8 @@ export class RunOrchestrator {
     claimLeaseForReconciliation(projectId, linearIssueId) {
         return this.leaseService.claimForReconciliation(projectId, linearIssueId);
     }
-    async reclaimForeignRecoveryLeaseIfSafe(run, issue) {
-        return await this.leaseService.reclaimForeignRecoveryLeaseIfSafe(run, issue);
+    reclaimForeignRecoveryLeaseIfSafe(run, issue) {
+        return this.leaseService.reclaimForeignRecoveryLeaseIfSafe(run, issue);
     }
     heartbeatIssueSessionLease(projectId, linearIssueId) {
         return this.leaseService.heartbeat(projectId, linearIssueId);

package/dist/tracked-issue-list-query.js

@@ -137,7 +137,11 @@ export class TrackedIssueListQuery {
                 ...(row.last_blocking_review_head_sha !== null ? { lastBlockingReviewHeadSha: String(row.last_blocking_review_head_sha) } : {}),
                 ...(row.last_github_failure_check_name !== null ? { latestFailureCheckName: String(row.last_github_failure_check_name) } : {}),
             });
-            const waitingReason = detachedActiveRun ? derivedWaitingReason : sessionWaitingReason ?? derivedWaitingReason;
+            // The derivation (issue-execution-state.ts via waiting-reason.ts) is the
+            // single source; the stored session projection is only a fallback for
+            // rows whose live facts derive no reason. A detached active run means
+            // the projection is stale, so it is not consulted at all.
+            const waitingReason = derivedWaitingReason ?? (detachedActiveRun ? undefined : sessionWaitingReason);
             const latestRun = row.latest_run_type !== null && row.latest_run_status !== null
                 ? {
                     id: 0,

package/dist/waiting-reason.js

@@ -1,4 +1,4 @@
-import { hasOpenPr } from "./pr-state.js";
+import { deriveIssueExecutionState, } from "./issue-execution-state.js";
 export const PATCHRELAY_WAITING_REASONS = {
     activeWork: "PatchRelay is actively working",
     automationPaused: "PatchRelay automation is paused because the issue is undelegated",
@@ -16,82 +16,82 @@ export const PATCHRELAY_WAITING_REASONS = {
     waitingForOperatorIntervention: "Waiting on operator intervention",
     waitingForExternalReview: "Waiting on external review",
 };
+/**
+ * `waitingReason` is a pure function of {@link IssueExecutionState} — the
+ * union (issue-execution-state.ts) is the single derivation of "why is this
+ * issue not moving"; this module only renders it for operators.
+ */
 export function derivePatchRelayWaitingReason(params) {
-    if (params.delegatedToPatchRelay === false && params.factoryState !== "done" && params.factoryState !== "failed" && params.factoryState !== "escalated") {
-        return params.factoryState === "awaiting_queue" || (hasLiveOpenPr(params.prNumber, params.prState) && params.prReviewState === "approved")
-            ? PATCHRELAY_WAITING_REASONS.automationPausedDownstream
-            : PATCHRELAY_WAITING_REASONS.automationPaused;
-    }
-    if (params.activeRunType) {
-        if (hasOpenPr(params.prNumber, params.prState) && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
-            return PATCHRELAY_WAITING_REASONS.finalizingPublishedPr;
-        }
-        if (params.factoryState === "done") {
-            return PATCHRELAY_WAITING_REASONS.finalizingMergedChange;
-        }
-        return `PatchRelay is running ${humanize(params.activeRunType)}`;
-    }
-    if (params.activeRunId !== undefined) {
-        return PATCHRELAY_WAITING_REASONS.activeWork;
-    }
-    if (params.orchestrationSettleUntil) {
-        const settleAt = Date.parse(params.orchestrationSettleUntil);
-        if (Number.isFinite(settleAt) && settleAt > Date.now()) {
+    return waitingReasonForExecutionState(deriveIssueExecutionState(params));
+}
+export function waitingReasonForExecutionState(state) {
+    switch (state.kind) {
+        case "undelegated":
+            return state.downstreamMayContinue
+                ? PATCHRELAY_WAITING_REASONS.automationPausedDownstream
+                : PATCHRELAY_WAITING_REASONS.automationPaused;
+        case "running":
+        // An inconsistent row still describes what is observably happening (a run
+        // occupies the slot); reconcilers act on the union kind, not this string.
+        case "inconsistent":
+            return describeRun(state.run);
+        case "settling":
             return PATCHRELAY_WAITING_REASONS.waitingForChildSettle;
-        }
-    }
-    const blockedByKeys = (params.blockedByKeys ?? []).filter((value) => value.trim().length > 0);
-    if (blockedByKeys.length > 0) {
-        return `Blocked by ${blockedByKeys.join(", ")}`;
-    }
-    const checkName = params.latestFailureCheckName ?? "CI";
-    switch (params.factoryState) {
-        case "awaiting_input":
+        case "blocked":
+            return `Blocked by ${state.blockedByKeys.join(", ")}`;
+        case "waiting_input":
             return PATCHRELAY_WAITING_REASONS.waitingForOperatorInput;
-        case "changes_requested":
-            return PATCHRELAY_WAITING_REASONS.waitingForReviewFeedback;
-        case "repairing_ci":
-            return `Waiting to repair ${checkName}`;
-        case "repairing_queue":
-            return PATCHRELAY_WAITING_REASONS.waitingForMergeStewardRepair;
-        case "awaiting_queue":
-            return PATCHRELAY_WAITING_REASONS.waitingForDownstreamAutomation;
-        case "done":
-            return PATCHRELAY_WAITING_REASONS.workComplete;
-        case "failed":
-        case "escalated":
-            return PATCHRELAY_WAITING_REASONS.waitingForOperatorIntervention;
-        default:
+        case "awaiting_followup":
+            switch (state.followup) {
+                case "review_fix":
+                    return PATCHRELAY_WAITING_REASONS.waitingForReviewFeedback;
+                case "ci_repair":
+                    return `Waiting to repair ${state.checkName ?? "CI"}`;
+                case "queue_repair":
+                    return PATCHRELAY_WAITING_REASONS.waitingForMergeStewardRepair;
+            }
             break;
-    }
-    if (params.prCheckStatus === "failed" || params.prCheckStatus === "failure") {
-        return `${checkName} failed`;
-    }
-    if (params.prReviewState === "changes_requested") {
-        if (params.prCheckStatus === "passed" || params.prCheckStatus === "success") {
-            if (params.prHeadSha
-                && params.lastBlockingReviewHeadSha
-                && params.prHeadSha !== params.lastBlockingReviewHeadSha) {
-                return PATCHRELAY_WAITING_REASONS.waitingForReviewOnNewHead;
+        case "terminal":
+            return state.outcome === "done"
+                ? PATCHRELAY_WAITING_REASONS.workComplete
+                : PATCHRELAY_WAITING_REASONS.waitingForOperatorIntervention;
+        case "idle_awaiting_external":
+            switch (state.waitingOn) {
+                case "merge_queue":
+                case "downstream_automation":
+                    return PATCHRELAY_WAITING_REASONS.waitingForDownstreamAutomation;
+                case "ci_failure":
+                    return `${state.checkName ?? "CI"} failed`;
+                case "review_of_new_head":
+                    return PATCHRELAY_WAITING_REASONS.waitingForReviewOnNewHead;
+                case "blocking_review_same_head":
+                    return PATCHRELAY_WAITING_REASONS.sameHeadStillBlocked;
+                case "review_feedback":
+                    return PATCHRELAY_WAITING_REASONS.waitingForReviewFeedback;
+                case "external_review":
+                    return PATCHRELAY_WAITING_REASONS.waitingForExternalReview;
             }
-            return PATCHRELAY_WAITING_REASONS.sameHeadStillBlocked;
-        }
-        return PATCHRELAY_WAITING_REASONS.waitingForReviewFeedback;
-    }
-    if (params.prReviewState === "approved") {
-        return PATCHRELAY_WAITING_REASONS.waitingForDownstreamAutomation;
+            break;
+        case "ready":
+            return `Ready to run ${humanize(state.pendingRunType)}`;
+        case "idle":
+            return undefined;
     }
-    if (hasOpenPr(params.prNumber, params.prState)) {
-        return PATCHRELAY_WAITING_REASONS.waitingForExternalReview;
+    return undefined;
+}
+function describeRun(run) {
+    if (!run.runType) {
+        return PATCHRELAY_WAITING_REASONS.activeWork;
     }
-    if (params.pendingRunType) {
-        return `Ready to run ${humanize(params.pendingRunType)}`;
+    switch (run.phase) {
+        case "finalizing_published_pr":
+            return PATCHRELAY_WAITING_REASONS.finalizingPublishedPr;
+        case "finalizing_merged_change":
+            return PATCHRELAY_WAITING_REASONS.finalizingMergedChange;
+        case "working":
+            return `PatchRelay is running ${humanize(run.runType)}`;
     }
-    return undefined;
 }
 function humanize(value) {
     return value.replaceAll("_", " ");
 }
-function hasLiveOpenPr(prNumber, prState) {
-    return prNumber !== undefined && (prState === undefined || prState === "open");
-}

package/package.json

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