patchrelay 0.67.2 → 0.68.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.67.2",
-  "commit": "8d3d15a51ae1",
-  "builtAt": "2026-05-10T15:37:09.721Z"
+  "version": "0.68.1",
+  "commit": "1cc1884e5fe9",
+  "builtAt": "2026-05-15T07:24:40.081Z"
 }

package/dist/codex-app-server.js

@@ -206,6 +206,20 @@ export class CodexAppServerClient extends EventEmitter {
             status: String(response.turn.status),
         };
     }
+    async setThreadGoal(options) {
+        const params = {
+            threadId: options.threadId,
+            objective: options.objective,
+        };
+        if (options.status !== undefined) {
+            params.status = options.status;
+        }
+        if (options.tokenBudget !== undefined) {
+            params.tokenBudget = options.tokenBudget;
+        }
+        const response = (await this.sendRequest("thread/goal/set", params));
+        return this.mapThreadGoal(response.goal);
+    }
     async readThread(threadId, includeTurns = true) {
         const response = (await this.sendRequest("thread/read", {
             threadId,
@@ -230,6 +244,18 @@ export class CodexAppServerClient extends EventEmitter {
             ],
         });
     }
+    mapThreadGoal(goal) {
+        return {
+            threadId: String(goal.threadId),
+            objective: String(goal.objective ?? ""),
+            status: String(goal.status ?? "active"),
+            ...(goal.tokenBudget === null || goal.tokenBudget === undefined ? { tokenBudget: null } : { tokenBudget: Number(goal.tokenBudget) }),
+            tokensUsed: Number(goal.tokensUsed ?? 0),
+            timeUsedSeconds: Number(goal.timeUsedSeconds ?? 0),
+            createdAt: Number(goal.createdAt ?? 0),
+            updatedAt: Number(goal.updatedAt ?? 0),
+        };
+    }
     sendNotification(method, params) {
         this.writeMessage({
             jsonrpc: "2.0",

package/dist/db/issue-store.js

@@ -416,6 +416,25 @@ export class IssueStore {
             .all();
         return rows.map(mapIssueRow);
     }
+    // Safety net for orphaned wakes: any delegated, non-terminal issue
+    // with at least one unprocessed session event but no active run.
+    // The orchestrator's enqueueIssue is the only path that drains these
+    // events, and a prior enqueueIssue call can be silently lost (worker
+    // race, lease contention, in-memory queue cleared by service restart).
+    // The idle reconciler iterates this set and re-enqueues each one.
+    listIdleIssuesWithPendingWake() {
+        const rows = this.connection
+            .prepare(`SELECT DISTINCT i.* FROM issues i
+         INNER JOIN issue_session_events e
+           ON e.project_id = i.project_id
+          AND e.linear_issue_id = i.linear_issue_id
+         WHERE e.processed_at IS NULL
+           AND i.active_run_id IS NULL
+           AND i.delegated_to_patchrelay = 1
+           AND i.factory_state NOT IN ('done', 'escalated', 'failed', 'awaiting_input')`)
+            .all();
+        return rows.map(mapIssueRow);
+    }
     listBlockedDelegatedIssues() {
         const rows = this.connection
             .prepare(`SELECT DISTINCT i.* FROM issues i

package/dist/db.js

@@ -182,6 +182,14 @@ export class PatchRelayDatabase {
     listIdleNonTerminalIssues() {
         return this.issues.listIdleNonTerminalIssues();
     }
+    /**
+     * Idle delegated issues that still have unprocessed session events.
+     * The idle reconciler re-enqueues these to recover from a silently
+     * dropped enqueueIssue (lease race, in-memory queue cleared at restart).
+     */
+    listIdleIssuesWithPendingWake() {
+        return this.issues.listIdleIssuesWithPendingWake();
+    }
     /**
      * Issues in delegated state with dependencies but no pending/active run.
      * Candidates for unblocking when their blockers complete.

package/dist/github-pr-comment-handler.js

@@ -1,12 +1,12 @@
 export class GitHubPrCommentHandler {
     db;
-    enqueueIssue;
+    wakeDispatcher;
     logger;
     codex;
     feed;
-    constructor(db, enqueueIssue, logger, codex, feed) {
+    constructor(db, wakeDispatcher, logger, codex, feed) {
         this.db = db;
-        this.enqueueIssue = enqueueIssue;
+        this.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.codex = codex;
         this.feed = feed;
@@ -61,14 +61,9 @@ export class GitHubPrCommentHandler {
                 }
             }
         }
-        this.db.issueSessions.appendIssueSessionEvent({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
+        this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
             eventType: "followup_comment",
             eventJson: JSON.stringify({ body, author }),
         });
-        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
-            this.enqueueIssue(issue.projectId, issue.linearIssueId);
-        }
     }
 }

package/dist/github-webhook-handler.js

@@ -10,11 +10,11 @@ import { maybeEnqueueGitHubReactiveRun } from "./github-webhook-reactive-run.js"
 import { maybeRunSequenceBackstop } from "./github-webhook-sequence-backstop.js";
 import { maybeFanChildRebaseWakes } from "./github-webhook-stack-coordination.js";
 import { handleGitHubTerminalPrEvent } from "./github-webhook-terminal-handler.js";
+import { WakeDispatcher } from "./wake-dispatcher.js";
 export class GitHubWebhookHandler {
     config;
     db;
     linearProvider;
-    enqueueIssue;
     logger;
     codex;
     feed;
@@ -22,18 +22,23 @@ export class GitHubWebhookHandler {
     ciSnapshotResolver;
     fetchImpl;
     prCommentHandler;
-    constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed, failureContextResolver = createGitHubFailureContextResolver(), ciSnapshotResolver = createGitHubCiSnapshotResolver(), fetchImpl = fetch) {
+    wakeDispatcher;
+    constructor(config, db, linearProvider, wakeDispatcherOrEnqueueIssue, logger, codex, feed, failureContextResolver = createGitHubFailureContextResolver(), ciSnapshotResolver = createGitHubCiSnapshotResolver(), fetchImpl = fetch) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
-        this.enqueueIssue = enqueueIssue;
         this.logger = logger;
         this.codex = codex;
         this.feed = feed;
         this.failureContextResolver = failureContextResolver;
         this.ciSnapshotResolver = ciSnapshotResolver;
         this.fetchImpl = fetchImpl;
-        this.prCommentHandler = new GitHubPrCommentHandler(db, enqueueIssue, logger, codex, feed);
+        // GitHub webhook handlers never release leases either — see
+        // WebhookHandler for the same rationale.
+        this.wakeDispatcher = wakeDispatcherOrEnqueueIssue instanceof WakeDispatcher
+            ? wakeDispatcherOrEnqueueIssue
+            : new WakeDispatcher(db, wakeDispatcherOrEnqueueIssue, () => undefined, logger, feed);
+        this.prCommentHandler = new GitHubPrCommentHandler(db, this.wakeDispatcher, logger, codex, feed);
     }
     async acceptGitHubWebhook(params) {
         if (this.db.webhookEvents.isWebhookDuplicate(params.deliveryId)) {
@@ -125,7 +130,7 @@ export class GitHubWebhookHandler {
             db: this.db,
             logger: this.logger,
             feed: this.feed,
-            enqueueIssue: this.enqueueIssue,
+            wakeDispatcher: this.wakeDispatcher,
             issue: freshIssue,
             event,
             project,
@@ -152,7 +157,7 @@ export class GitHubWebhookHandler {
                 db: this.db,
                 logger: this.logger,
                 ...(this.feed ? { feed: this.feed } : {}),
-                enqueueIssue: this.enqueueIssue,
+                wakeDispatcher: this.wakeDispatcher,
                 event,
             });
         }
@@ -161,7 +166,7 @@ export class GitHubWebhookHandler {
                 config: this.config,
                 db: this.db,
                 linearProvider: this.linearProvider,
-                enqueueIssue: this.enqueueIssue,
+                wakeDispatcher: this.wakeDispatcher,
                 logger: this.logger,
                 codex: this.codex,
                 feed: this.feed,

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.js

@@ -105,17 +105,27 @@ function hasFailureProvenance(issue) {
 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 +171,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 +192,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 +247,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 +258,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 +281,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",