patchrelay 0.68.0 → 0.68.2

package/dist/github-webhook-reactive-run.js

@@ -4,7 +4,7 @@ import { isIssueTerminal } from "./pr-state.js";
 import { buildGitHubQueueFailureContext, getRelevantGitHubCiSnapshot, resolveGitHubBranchFailureContext, resolveGitHubCheckClass, } from "./github-webhook-failure-context.js";
 import { isQueueEvictionFailure, isSettledBranchFailure } from "./github-webhook-policy.js";
 export async function maybeEnqueueGitHubReactiveRun(params) {
-    const { issue, event, project, logger, feed, enqueueIssue, db, fetchImpl, failureContextResolver } = params;
+    const { issue, event, project, logger, feed, wakeDispatcher, db, fetchImpl, failureContextResolver } = params;
     if (isIssueTerminal(issue))
         return;
     if (!issue.delegatedToPatchRelay) {
@@ -27,7 +27,7 @@ export async function maybeEnqueueGitHubReactiveRun(params) {
             db,
             logger,
             feed,
-            enqueueIssue,
+            wakeDispatcher,
             issue,
             event,
             project,
@@ -40,7 +40,7 @@ export async function maybeEnqueueGitHubReactiveRun(params) {
             db,
             logger,
             feed,
-            enqueueIssue,
+            wakeDispatcher,
             issue,
             event,
             fetchImpl,
@@ -48,7 +48,7 @@ export async function maybeEnqueueGitHubReactiveRun(params) {
     }
 }
 async function handleCheckFailedEvent(params) {
-    const { db, logger, feed, enqueueIssue, issue, event, project, failureContextResolver } = params;
+    const { db, logger, feed, wakeDispatcher, issue, event, project, failureContextResolver } = params;
     // Plan §4.3: while In Deploy (`awaiting_queue`), branch CI is metadata
     // only — the lander owns admission, and its spec CI on the integration
     // tree is the gate. Queue eviction failures still flow through (they're
@@ -71,20 +71,14 @@ async function handleCheckFailedEvent(params) {
         if (hasDuplicatePendingReactiveRun(db, feed, issue, "queue_repair", failureContext)) {
             return;
         }
-        const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
-        db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
+        const queuedRunType = wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
             eventType: "merge_steward_incident",
             eventJson: JSON.stringify({
                 ...queueRepairContext,
                 ...failureContext,
             }),
-            dedupeKey: failureContext.failureSignature,
+            ...(failureContext.failureSignature ? { dedupeKey: failureContext.failureSignature } : {}),
         });
-        const queuedRunType = hadPendingWake
-            ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
-            : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
         logger.info({ issueKey: issue.issueKey, checkName: event.checkName }, "Queue eviction detected, enqueued queue repair");
         feed?.publish({
             level: "warn",
@@ -120,7 +114,6 @@ async function handleCheckFailedEvent(params) {
     if (hasDuplicatePendingReactiveRun(db, feed, issue, "ci_repair", failureContext)) {
         return;
     }
-    const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
     const snapshot = getRelevantGitHubCiSnapshot(db, issue, event);
     db.issues.upsertIssue({
         projectId: issue.projectId,
@@ -134,20 +127,15 @@ async function handleCheckFailedEvent(params) {
         lastGitHubFailureAt: new Date().toISOString(),
         lastQueueIncidentJson: null,
     });
-    db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
+    const queuedRunType = wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
         eventType: "settled_red_ci",
         eventJson: JSON.stringify({
             ...failureContext,
             checkClass: resolveGitHubCheckClass(failureContext.checkName ?? event.checkName, project),
             ...(snapshot ? { ciSnapshot: snapshot } : {}),
         }),
-        dedupeKey: failureContext.failureSignature,
+        ...(failureContext.failureSignature ? { dedupeKey: failureContext.failureSignature } : {}),
     });
-    const queuedRunType = hadPendingWake
-        ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
-        : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
     logger.info({ issueKey: issue.issueKey, checkName: failureContext.checkName ?? event.checkName }, "Enqueued CI repair run");
     feed?.publish({
         level: "warn",
@@ -161,8 +149,7 @@ async function handleCheckFailedEvent(params) {
     });
 }
 async function handleRequestedChangesEvent(params) {
-    const { db, logger, feed, enqueueIssue, issue, event, fetchImpl } = params;
-    const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+    const { logger, feed, wakeDispatcher, issue, event, fetchImpl } = params;
     const reviewComments = await fetchReviewCommentsForEvent(event, fetchImpl).catch((error) => {
         logger.warn({
             issueKey: issue.issueKey,
@@ -172,9 +159,7 @@ async function handleRequestedChangesEvent(params) {
         }, "Failed to fetch inline review comments for requested-changes event");
         return undefined;
     });
-    db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
+    const queuedRunType = wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
         eventType: "review_changes_requested",
         eventJson: JSON.stringify({
             reviewBody: event.reviewBody,
@@ -190,11 +175,6 @@ async function handleRequestedChangesEvent(params) {
             event.reviewerName ?? "unknown-reviewer",
         ].join("::"),
     });
-    const queuedRunType = hadPendingWake
-        ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
-        : issue.activeRunId === undefined
-            ? enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId)
-            : db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType;
     logger.info({
         issueKey: issue.issueKey,
         reviewerName: event.reviewerName,
@@ -254,14 +234,6 @@ function hasDuplicatePendingReactiveRun(db, feed, issue, runType, failureContext
     }
     return false;
 }
-function enqueuePendingSessionWake(db, enqueueIssue, projectId, issueId) {
-    const wake = db.issueSessions.peekIssueSessionWake(projectId, issueId);
-    if (!wake) {
-        return undefined;
-    }
-    enqueueIssue(projectId, issueId);
-    return wake.runType;
-}
 async function fetchReviewCommentsForEvent(event, fetchImpl) {
     if (event.triggerEvent !== "review_changes_requested") {
         return undefined;

package/dist/github-webhook-stack-coordination.js

@@ -4,7 +4,7 @@
 // matching child and enqueues a `branch_upkeep` run to rebase the
 // child onto the new parent head.
 export function maybeFanChildRebaseWakes(params) {
-    const { db, logger, feed, enqueueIssue, event } = params;
+    const { db, logger, feed, wakeDispatcher, event } = params;
     if (event.triggerEvent !== "pr_synchronize")
         return;
     if (!event.branchName)
@@ -24,7 +24,10 @@ export function maybeFanChildRebaseWakes(params) {
             linearIssueId: child.linearIssueId,
             pendingRunType: "branch_upkeep",
         });
-        enqueueIssue(child.projectId, child.linearIssueId);
+        // The pending_run_type field above isn't an event, so we still need
+        // an explicit dispatch call. dispatchIfWakePending will pick up the
+        // wake derived from the legacy pendingRunType column.
+        wakeDispatcher.dispatchIfWakePending(child.projectId, child.linearIssueId);
         logger.info({
             parentBranch: event.branchName,
             parentHeadSha: event.headSha,

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

@@ -3,7 +3,7 @@ import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { syncGitHubLinearSession } from "./github-linear-session-sync.js";
 import { wakeOrchestrationParentsForChildEvent } from "./orchestration-parent-wake.js";
 export async function handleGitHubTerminalPrEvent(params) {
-    const { db, linearProvider, enqueueIssue, logger, codex, issue, event, config } = params;
+    const { db, linearProvider, wakeDispatcher, logger, codex, issue, event, config } = params;
     const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
     db.issueSessions.appendIssueSessionEvent({
         projectId: issue.projectId,
@@ -56,22 +56,17 @@ export async function handleGitHubTerminalPrEvent(params) {
     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,
+        wakeDispatcher.recordEventAndDispatch(issue.projectId, 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") {
         wakeOrchestrationParentsForChildEvent({
             db,
             child: updatedIssue,
             eventType: "child_delivered",
-            enqueueIssue,
+            wakeDispatcher,
         });
         await completeLinearIssueAfterMerge(params, updatedIssue);
     }

package/dist/idle-reconciliation-helpers.js

@@ -0,0 +1,100 @@
+import { parseGitHubFailureContext } from "./github-failure-context.js";
+import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
+export function isFailingCheckStatus(status) {
+    return status === "failed" || status === "failure";
+}
+export function isReviewDecisionApproved(value) {
+    return value?.trim().toUpperCase() === "APPROVED";
+}
+export function isReviewDecisionChangesRequested(value) {
+    return value?.trim().toUpperCase() === "CHANGES_REQUESTED";
+}
+export function isReviewDecisionReviewRequired(value) {
+    return value?.trim().toUpperCase() === "REVIEW_REQUIRED";
+}
+export function buildBranchUpkeepContext(prNumber, baseBranch, mergeStateStatus, headSha) {
+    const promptContext = [
+        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${mergeStateStatus ?? "DIRTY"} 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 {
+        branchUpkeepRequired: true,
+        reviewFixMode: "branch_upkeep",
+        wakeReason: "branch_upkeep",
+        promptContext,
+        ...(mergeStateStatus ? { mergeStateStatus } : {}),
+        ...(headSha ? { failingHeadSha: headSha } : {}),
+        baseBranch,
+    };
+}
+export function hasCompletedReviewQuillVerdict(entries) {
+    return (entries ?? []).some((entry) => entry.__typename === "CheckRun"
+        && entry.name === "review-quill/verdict"
+        && entry.status === "COMPLETED");
+}
+export function getGateCheckNames(project) {
+    const configured = project?.gateChecks?.map((entry) => entry.trim()).filter(Boolean) ?? [];
+    return configured.length > 0 ? configured : ["verify"];
+}
+/**
+ * A repair attempt is "duplicate" when we have already tried to repair the
+ * exact same failure (same signature, same head SHA) AND no newer failure
+ * has been observed since that attempt was recorded. For queue evictions
+ * the PR head doesn't advance between attempts, so we additionally compare
+ * the timestamps: a fresh incident after `main` advances looks identical
+ * to a stale one without the timestamp check.
+ */
+export function isDuplicateRepairAttempt(issue, context) {
+    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+    const headSha = typeof context?.failureHeadSha === "string"
+        ? context.failureHeadSha
+        : typeof context?.headSha === "string" ? context.headSha : undefined;
+    if (!signature)
+        return false;
+    if (issue.lastAttemptedFailureSignature !== signature)
+        return false;
+    if (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha)
+        return false;
+    if (issue.lastAttemptedFailureAt && issue.lastGitHubFailureAt
+        && issue.lastGitHubFailureAt > issue.lastAttemptedFailureAt) {
+        return false;
+    }
+    return true;
+}
+export function buildFailureContext(issue) {
+    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
+    const queueRepairContext = issue.lastQueueIncidentJson
+        ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
+        : undefined;
+    if (!queueRepairContext
+        && !issue.lastGitHubFailureSource
+        && !issue.lastGitHubFailureHeadSha
+        && !issue.lastGitHubFailureSignature
+        && !issue.lastGitHubFailureCheckName
+        && !issue.lastGitHubFailureCheckUrl
+        && !storedFailureContext) {
+        return undefined;
+    }
+    return {
+        ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
+        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
+        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
+        ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
+        ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
+        ...(storedFailureContext ? storedFailureContext : {}),
+        ...(queueRepairContext ? queueRepairContext : {}),
+    };
+}
+export function hasFailureProvenance(issue) {
+    return Boolean(issue.lastGitHubFailureSource
+        || issue.lastGitHubFailureHeadSha
+        || issue.lastGitHubFailureSignature
+        || issue.lastGitHubFailureCheckName
+        || issue.lastGitHubFailureCheckUrl
+        || issue.lastGitHubFailureContextJson
+        || issue.lastGitHubFailureAt
+        || issue.lastQueueIncidentJson
+        || issue.lastAttemptedFailureHeadSha
+        || issue.lastAttemptedFailureSignature);
+}

package/dist/idle-reconciliation.js

@@ -1,121 +1,36 @@
+import { buildBranchUpkeepContext, buildFailureContext, getGateCheckNames, hasCompletedReviewQuillVerdict, hasFailureProvenance, isDuplicateRepairAttempt, isFailingCheckStatus, isReviewDecisionApproved, isReviewDecisionChangesRequested, isReviewDecisionReviewRequired, } from "./idle-reconciliation-helpers.js";
 import { isMainRepairIssue } from "./main-repair.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
-import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
-import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { buildClosedPrCleanupFields, resolveClosedPrDisposition } from "./pr-state.js";
 import { getReviewFixBudget } from "./run-budgets.js";
 import { queueSettledOrchestrationIssue } from "./orchestration-parent-wake.js";
 import { execCommand } from "./utils.js";
-function isFailingCheckStatus(status) {
-    return status === "failed" || status === "failure";
-}
-function isReviewDecisionApproved(value) {
-    return value?.trim().toUpperCase() === "APPROVED";
-}
-function isReviewDecisionChangesRequested(value) {
-    return value?.trim().toUpperCase() === "CHANGES_REQUESTED";
-}
-function isReviewDecisionReviewRequired(value) {
-    return value?.trim().toUpperCase() === "REVIEW_REQUIRED";
-}
-function buildBranchUpkeepContext(prNumber, baseBranch, mergeStateStatus, headSha) {
-    const promptContext = [
-        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${mergeStateStatus ?? "DIRTY"} 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 {
-        branchUpkeepRequired: true,
-        reviewFixMode: "branch_upkeep",
-        wakeReason: "branch_upkeep",
-        promptContext,
-        ...(mergeStateStatus ? { mergeStateStatus } : {}),
-        ...(headSha ? { failingHeadSha: headSha } : {}),
-        baseBranch,
-    };
-}
-function hasCompletedReviewQuillVerdict(entries) {
-    return (entries ?? []).some((entry) => entry.__typename === "CheckRun"
-        && entry.name === "review-quill/verdict"
-        && entry.status === "COMPLETED");
-}
-function getGateCheckNames(project) {
-    const configured = project?.gateChecks?.map((entry) => entry.trim()).filter(Boolean) ?? [];
-    return configured.length > 0 ? configured : ["verify"];
-}
-function isDuplicateRepairAttempt(issue, context) {
-    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
-    const headSha = typeof context?.failureHeadSha === "string"
-        ? context.failureHeadSha
-        : typeof context?.headSha === "string" ? context.headSha : undefined;
-    if (!signature)
-        return false;
-    if (issue.lastAttemptedFailureSignature !== signature)
-        return false;
-    if (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha)
-        return false;
-    // A signature+headSha match alone isn't enough: for queue evictions the PR head
-    // doesn't advance (we haven't pushed) and the steward's check name is constant,
-    // so a fresh incident after main advances looks identical. Treat the attempt as
-    // stale if a newer failure has been observed since it was recorded.
-    if (issue.lastAttemptedFailureAt && issue.lastGitHubFailureAt
-        && issue.lastGitHubFailureAt > issue.lastAttemptedFailureAt) {
-        return false;
-    }
-    return true;
-}
-function buildFailureContext(issue) {
-    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
-    const queueRepairContext = issue.lastQueueIncidentJson
-        ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
-        : undefined;
-    if (!queueRepairContext
-        && !issue.lastGitHubFailureSource
-        && !issue.lastGitHubFailureHeadSha
-        && !issue.lastGitHubFailureSignature
-        && !issue.lastGitHubFailureCheckName
-        && !issue.lastGitHubFailureCheckUrl
-        && !storedFailureContext) {
-        return undefined;
-    }
-    return {
-        ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
-        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
-        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
-        ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
-        ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
-        ...(storedFailureContext ? storedFailureContext : {}),
-        ...(queueRepairContext ? queueRepairContext : {}),
-    };
-}
-function hasFailureProvenance(issue) {
-    return Boolean(issue.lastGitHubFailureSource
-        || issue.lastGitHubFailureHeadSha
-        || issue.lastGitHubFailureSignature
-        || issue.lastGitHubFailureCheckName
-        || issue.lastGitHubFailureCheckUrl
-        || issue.lastGitHubFailureContextJson
-        || issue.lastGitHubFailureAt
-        || issue.lastQueueIncidentJson
-        || issue.lastAttemptedFailureHeadSha
-        || issue.lastAttemptedFailureSignature);
-}
 export class IdleIssueReconciler {
     db;
     config;
-    deps;
+    wakeDispatcher;
     logger;
     feed;
-    constructor(db, config, deps, logger, feed) {
+    constructor(db, config, wakeDispatcher, logger, feed) {
         this.db = db;
         this.config = config;
-        this.deps = deps;
+        this.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.feed = feed;
     }
     async reconcile() {
+        // Wrap the entire reconcile pass in a dispatcher tick. Every
+        // dispatchIfWakePending / recordEventAndDispatch call inside the
+        // callback automatically shares one dedupe Set, so a single pass
+        // produces at most one enqueue per issue even when several sub-
+        // passes detect the same wake. SerialWorkQueue would dedupe anyway,
+        // but keeping the call log clean makes orchestrator behaviour
+        // easier to inspect from tests and the operator feed.
+        return this.wakeDispatcher.withTick(() => this.reconcileBody());
+    }
+    async reconcileBody() {
         for (const issue of this.db.issues.listIdleNonTerminalIssues()) {
             if (issue.prState === "merged") {
                 this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
@@ -161,15 +76,10 @@ export class IdleIssueReconciler {
                 continue;
             const unresolved = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
-                this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
+                this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
                     eventType: "delegated",
                     dedupeKey: `delegated:${issue.linearIssueId}`,
                 });
-                if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
-                    this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
-                }
             }
         }
         const now = Date.now();
@@ -187,9 +97,19 @@ export class IdleIssueReconciler {
             queueSettledOrchestrationIssue({
                 db: this.db,
                 issue,
-                enqueueIssue: this.deps.enqueueIssue,
+                wakeDispatcher: this.wakeDispatcher,
             });
         }
+        // Safety net: re-enqueue any idle delegated issue that still has
+        // unprocessed session events. Until this pass existed, a single
+        // dropped enqueueIssue (lease race, in-memory queue lost across
+        // restart) left review_fix / ci_repair / queue_repair wakes stuck
+        // for hours until an external event re-poked the issue. The
+        // surrounding withTick scope ensures the call log shows at most one
+        // enqueue per issue per pass even when earlier passes also queued.
+        for (const issue of this.db.issues.listIdleIssuesWithPendingWake()) {
+            this.wakeDispatcher.dispatchIfWakePending(issue.projectId, issue.linearIssueId);
+        }
     }
     shouldProbeTerminalIssueFromGitHub(issue) {
         if (issue.prNumber === undefined)
@@ -232,7 +152,7 @@ export class IdleIssueReconciler {
                 : {}),
         });
         if (options?.pendingRunType) {
-            this.appendWakeEvent(issue, options.pendingRunType, options.pendingRunContext, "idle_reconciliation");
+            this.recordWakeEvent(issue, options.pendingRunType, options.pendingRunContext, "idle_reconciliation");
         }
         this.feed?.publish({
             level: "info",
@@ -243,11 +163,11 @@ export class IdleIssueReconciler {
             status: "reconciled",
             summary: `Reconciliation: ${issue.factoryState} \u2192 ${newState}`,
         });
-        if (options?.pendingRunType && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
-            this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
-        }
+        // The dispatcher's recordEventAndDispatch in recordWakeEvent already
+        // handles the enqueue when no run is in flight, so no extra poke
+        // is needed here.
     }
-    appendWakeEvent(issue, runType, context, dedupeScope = "idle_reconciliation") {
+    recordWakeEvent(issue, runType, context, dedupeScope = "idle_reconciliation") {
         let eventType;
         let dedupeKey;
         if (runType === "queue_repair") {
@@ -266,9 +186,7 @@ export class IdleIssueReconciler {
             eventType = "delegated";
             dedupeKey = `${dedupeScope}:implementation:${issue.linearIssueId}`;
         }
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
+        this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
             eventType,
             ...(context ? { eventJson: JSON.stringify(context) } : {}),
             dedupeKey,

package/dist/main-branch-health-monitor.js

@@ -14,14 +14,14 @@ export class MainBranchHealthMonitor {
     db;
     config;
     linearProvider;
-    enqueueIssue;
+    wakeDispatcher;
     logger;
     feed;
-    constructor(db, config, linearProvider, enqueueIssue, logger, feed) {
+    constructor(db, config, linearProvider, wakeDispatcher, logger, feed) {
         this.db = db;
         this.config = config;
         this.linearProvider = linearProvider;
-        this.enqueueIssue = enqueueIssue;
+        this.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.feed = feed;
     }
@@ -82,9 +82,7 @@ export class MainBranchHealthMonitor {
             branchName,
             factoryState: "delegated",
         });
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, issue.linearIssueId, {
-            projectId,
-            linearIssueId: issue.linearIssueId,
+        this.wakeDispatcher.recordEventAndDispatch(projectId, issue.linearIssueId, {
             eventType: "delegated",
             eventJson: JSON.stringify({
                 runType: "main_repair",
@@ -96,9 +94,6 @@ export class MainBranchHealthMonitor {
             }),
             dedupeKey: `main_repair:${projectId}:${summary.baseSha}:${summary.failingChecks.map((check) => check.name).join("|")}`,
         });
-        if (this.db.issueSessions.peekIssueSessionWake(projectId, issue.linearIssueId)) {
-            this.enqueueIssue(projectId, issue.linearIssueId);
-        }
         this.feed?.publish({
             level: "warn",
             kind: "github",
@@ -153,9 +148,7 @@ export class MainBranchHealthMonitor {
             pendingRunContextJson: null,
             activeRunId: null,
         });
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
+        this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
             eventType: "delegated",
             eventJson: JSON.stringify({
                 runType: "main_repair",
@@ -167,9 +160,6 @@ export class MainBranchHealthMonitor {
             }),
             dedupeKey: `main_repair:${issue.projectId}:${summary.baseSha}:${summary.failingChecks.map((check) => check.name).join("|")}`,
         });
-        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
-            this.enqueueIssue(issue.projectId, issue.linearIssueId);
-        }
     }
     async resolveRecoveredMainRepair(issue) {
         if (issue.activeRunId !== undefined)

package/dist/no-pr-completion-check.js

@@ -89,7 +89,6 @@ export async function handleNoPrCompletionCheck(params) {
             summary: "No PR found; continuing automatically",
             detail: completionCheck.summary,
             activity: buildCompletionCheckActivity("continue"),
-            enqueue: true,
         });
         return;
     }
@@ -166,7 +165,6 @@ export async function handleNoPrCompletionCheck(params) {
                 summary: "No PR found; continuing automatically to finish publication",
                 detail: params.publishedOutcomeError,
                 activity: buildCompletionCheckActivity("continue"),
-                enqueue: true,
             });
             return;
         }
@@ -211,7 +209,6 @@ export async function handleNoPrCompletionCheck(params) {
                 summary: "No repair PR found; continuing automatically",
                 detail: "Main repair cannot close until PatchRelay publishes a repair PR or main recovers externally.",
                 activity: buildCompletionCheckActivity("continue"),
-                enqueue: true,
             });
             return;
         }
@@ -267,6 +264,7 @@ export async function handleNoPrCompletionCheck(params) {
             db: params.db,
             child: doneIssue,
             eventType: "child_delivered",
+            wakeDispatcher: params.wakeDispatcher,
         });
         return;
     }

package/dist/orchestration-parent-wake.js

@@ -37,9 +37,7 @@ export function queueSettledOrchestrationIssue(params) {
         linearIssueId: params.issue.linearIssueId,
         orchestrationSettleUntil: null,
     });
-    params.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.issue.projectId, params.issue.linearIssueId, {
-        projectId: params.issue.projectId,
-        linearIssueId: params.issue.linearIssueId,
+    const dispatched = params.wakeDispatcher.recordEventAndDispatch(params.issue.projectId, params.issue.linearIssueId, {
         eventType: "delegated",
         eventJson: JSON.stringify({
             ...(params.promptContext
@@ -48,11 +46,7 @@ export function queueSettledOrchestrationIssue(params) {
         }),
         dedupeKey: `delegated:orchestration_settle:${params.issue.linearIssueId}`,
     });
-    if (params.db.issueSessions.peekIssueSessionWake(params.issue.projectId, params.issue.linearIssueId)) {
-        params.enqueueIssue?.(params.issue.projectId, params.issue.linearIssueId);
-        return true;
-    }
-    return false;
+    return dispatched !== undefined;
 }
 export function wakeOrchestrationParentsForChildEvent(params) {
     const parentIds = [];
@@ -71,9 +65,7 @@ export function wakeOrchestrationParentsForChildEvent(params) {
             parentIds.push(parent.linearIssueId);
             continue;
         }
-        params.db.issueSessions.appendIssueSessionEventRespectingActiveLease(parent.projectId, parent.linearIssueId, {
-            projectId: parent.projectId,
-            linearIssueId: parent.linearIssueId,
+        params.wakeDispatcher.recordEventAndDispatch(parent.projectId, parent.linearIssueId, {
             eventType: params.eventType,
             eventJson: JSON.stringify({
                 childIssueId: params.child.linearIssueId,
@@ -87,9 +79,6 @@ export function wakeOrchestrationParentsForChildEvent(params) {
             }),
             dedupeKey: `${params.eventType}:${parent.linearIssueId}:${params.child.linearIssueId}:${params.child.factoryState}:${params.changeKind ?? params.child.prState ?? "no-pr"}`,
         });
-        if (params.db.issueSessions.peekIssueSessionWake(parent.projectId, parent.linearIssueId)) {
-            params.enqueueIssue?.(parent.projectId, parent.linearIssueId);
-        }
         parentIds.push(parent.linearIssueId);
     }
     return unique(parentIds);

package/dist/queue-health-monitor.js

@@ -149,17 +149,12 @@ export class QueueHealthMonitor {
                 lastAttemptedFailureHeadSha: headRefOid,
                 lastAttemptedFailureSignature: signature,
             });
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
+            this.advancer.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
                 eventType: "merge_steward_incident",
                 eventJson: JSON.stringify(pendingRunContext),
                 dedupeKey: `queue_health:queue_repair:${issue.linearIssueId}:${signature}`,
             });
             this.advancer.advanceIdleIssue(issue, "repairing_queue");
-            if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
-                this.advancer.enqueueIssue(issue.projectId, issue.linearIssueId);
-            }
             this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");
             this.feed?.publish({
                 level: "warn",