patchrelay 0.82.0 → 0.83.1

package/dist/run-wake-planner.js

@@ -1,8 +1,22 @@
 import { getCiRepairBudget, getQueueRepairBudget, getReviewFixBudget, } from "./run-budgets.js";
 import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
-import { parseRunContextOrWarn, serializeRunContext } from "./run-context.js";
+import { parseRunContextOrWarn, serializeRunContext, tryParseRunContextValue } from "./run-context.js";
 import { assertNever } from "./utils.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 const WRITER = "run-wake-planner";
+function parseObjectJson(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export class RunWakePlanner {
     db;
     logger;
@@ -11,17 +25,115 @@ export class RunWakePlanner {
         this.logger = logger;
     }
     resolveRunWake(issue) {
-        const sessionWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId);
-        if (!sessionWake)
+        const freshIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        if (this.db.issues.countUnresolvedBlockers(freshIssue.projectId, freshIssue.linearIssueId) > 0) {
+            return undefined;
+        }
+        const existingWorkflowTaskWake = this.resolveWorkflowTaskWake(freshIssue);
+        if (existingWorkflowTaskWake)
+            return existingWorkflowTaskWake;
+        this.reconcileWorkflowTasks(freshIssue);
+        const workflowTaskWake = this.resolveWorkflowTaskWake(freshIssue);
+        if (workflowTaskWake)
+            return workflowTaskWake;
+        const sessionWake = this.db.issueSessions.peekIssueSessionWake(freshIssue.projectId, freshIssue.linearIssueId);
+        if (sessionWake) {
+            if (this.workflowTasksSuppressSessionWake(freshIssue, sessionWake.wakeReason)) {
+                return undefined;
+            }
+            return {
+                runType: sessionWake.runType,
+                context: sessionWake.context,
+                wakeReason: sessionWake.wakeReason,
+                resumeThread: sessionWake.resumeThread,
+                eventIds: sessionWake.eventIds,
+            };
+        }
+        if (this.workflowTasksSuppressSessionWake(freshIssue, undefined)) {
+            return undefined;
+        }
+        const implicitWake = this.db.workflowWakes.peekIssueWake(freshIssue.projectId, freshIssue.linearIssueId);
+        if (!implicitWake)
+            return undefined;
+        return {
+            runType: implicitWake.runType,
+            context: implicitWake.context,
+            wakeReason: implicitWake.wakeReason,
+            resumeThread: implicitWake.resumeThread,
+            eventIds: implicitWake.eventIds,
+        };
+    }
+    resolveWorkflowTaskWake(issue) {
+        const task = this.db.workflowTasks
+            .listOpenRunnableTasks(issue.projectId)
+            .find((entry) => entry.subjectId === issue.linearIssueId);
+        if (!task?.runType)
             return undefined;
+        const runType = task.runType;
+        const rawRequirements = parseObjectJson(task.requirementsJson);
+        const context = tryParseRunContextValue({
+            ...rawRequirements,
+            ...(rawRequirements?.blockingHeadSha ? { requestedChangesHeadSha: rawRequirements.blockingHeadSha } : {}),
+            source: "workflow_task",
+        }) ?? { source: "workflow_task" };
         return {
-            runType: sessionWake.runType,
-            context: sessionWake.context,
-            wakeReason: sessionWake.wakeReason,
-            resumeThread: sessionWake.resumeThread,
-            eventIds: sessionWake.eventIds,
+            runType,
+            ...(Object.keys(context).length > 0 ? { context } : {}),
+            wakeReason: task.taskId,
+            resumeThread: runType !== "implementation",
+            eventIds: [],
         };
     }
+    reconcileWorkflowTasks(issue) {
+        try {
+            reconcileWorkflowTasksForIssue(this.db, issue);
+        }
+        catch (error) {
+            this.logger?.warn({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                error: error instanceof Error ? error.message : String(error),
+            }, "Workflow task reconciliation failed while planning run wake");
+        }
+    }
+    workflowTasksSuppressSessionWake(issue, wakeReason) {
+        const openTasks = this.db.workflowTasks.listOpenTasks(issue.projectId, issue.linearIssueId);
+        if (openTasks.length === 0)
+            return false;
+        if (openTasks.some((task) => task.taskType === "run" && task.gateAction === "start" && task.runType !== undefined)) {
+            return false;
+        }
+        if (!openTasks.some((task) => this.isBlockingWorkflowGate(task)))
+            return false;
+        if (!openTasks.every((task) => task.taskId === "wait:input")) {
+            return true;
+        }
+        return wakeReason !== "direct_reply"
+            && wakeReason !== "followup_prompt"
+            && wakeReason !== "followup_comment"
+            && wakeReason !== "human_instruction"
+            && wakeReason !== "operator_prompt"
+            && wakeReason !== "completion_check_continue";
+    }
+    isBlockingWorkflowGate(task) {
+        if (task.taskId === "wait:input")
+            return true;
+        if (task.taskId === "wait:children" || task.taskId === "wait:blockers" || task.taskId.startsWith("wait:active-run:")) {
+            return true;
+        }
+        if (task.taskId === "wait:authority") {
+            return this.workflowAuthorityObserved(task.projectId, task.subjectId);
+        }
+        return task.taskType === "verify" || task.taskType === "ask" || task.taskType === "escalate" || task.taskType === "publish";
+    }
+    workflowAuthorityObserved(projectId, linearIssueId) {
+        return this.db.workflowObservations
+            .listObservations(projectId, linearIssueId)
+            .some((observation) => (observation.type === "linear.delegated"
+            || observation.type === "linear.undelegated"
+            || observation.type === "operator.authority_changed"));
+    }
     appendWakeEventWithLease(lease, issue, runType, context, dedupeScope) {
         let eventType;
         let dedupeKey;

package/dist/service-runtime.js

@@ -1,5 +1,6 @@
 import { SerialWorkQueue } from "./service-queue.js";
 import { retrySqliteLockedQueueFailure } from "./queue-failure-policy.js";
+import { isSqliteSchemaReadError } from "./sqlite-errors.js";
 const ISSUE_KEY_DELIMITER = "::";
 const DEFAULT_RECONCILE_INTERVAL_MS = 5_000;
 const DEFAULT_RECONCILE_TIMEOUT_MS = 60_000;
@@ -135,7 +136,7 @@ export class ServiceRuntime {
         }
         this.reconcileInProgress = true;
         try {
-            await promiseWithTimeout(this.runReconciler.reconcileActiveRuns(), this.options.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS, "Background active-run reconciliation");
+            await this.reconcileActiveRunsWithSchemaRetry();
             // Pick up issues that became ready outside the webhook path
             // (e.g. CLI retry, manual DB edits) without requiring a restart.
             for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
@@ -143,7 +144,10 @@ export class ServiceRuntime {
             }
         }
         catch (error) {
-            this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "Background active-run reconciliation failed");
+            this.logger.warn({
+                error: error instanceof Error ? error.message : String(error),
+                storage: this.safeStorageDiagnostics(),
+            }, "Background active-run reconciliation failed");
         }
         finally {
             this.reconcileInProgress = false;
@@ -152,6 +156,30 @@ export class ServiceRuntime {
             }
         }
     }
+    async reconcileActiveRunsWithSchemaRetry() {
+        try {
+            await this.reconcileActiveRunsOnce();
+        }
+        catch (error) {
+            if (!isSqliteSchemaReadError(error) || !this.options.assertStorageReady) {
+                throw error;
+            }
+            this.options.assertStorageReady();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            await this.reconcileActiveRunsOnce();
+        }
+    }
+    async reconcileActiveRunsOnce() {
+        await promiseWithTimeout(this.runReconciler.reconcileActiveRuns(), this.options.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS, "Background active-run reconciliation");
+    }
+    safeStorageDiagnostics() {
+        try {
+            return this.options.describeStorage?.();
+        }
+        catch {
+            return undefined;
+        }
+    }
     getMaxActiveIssueRuns() {
         const configured = this.options.maxActiveIssueRuns ?? DEFAULT_MAX_ACTIVE_ISSUE_RUNS;
         return Math.max(1, Math.floor(configured));

package/dist/service-startup-recovery.js

@@ -1,8 +1,8 @@
 import { appendDelegationObservedEvent } from "./delegation-audit.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { isResumablePausedLocalWork } from "./paused-issue-state.js";
-import { buildRepairWakeDedupeKey, buildRequestedChangesWakeIdentity, reactiveWakeEventType } from "./reactive-wake-keys.js";
 import { upsertLinearIssueProjection } from "./linear-issue-projection.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 const WRITER = "service-startup-recovery";
 export class ServiceStartupRecovery {
     config;
@@ -81,6 +81,14 @@ export class ServiceStartupRecovery {
             issue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
             const delegated = liveIssue.delegateId === installation.actorId;
             if (issue.delegatedToPatchRelay !== delegated) {
+                this.appendAuthorityObservation({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    delegated,
+                    actorId: installation.actorId,
+                    observedDelegateId: liveIssue.delegateId,
+                    reason: "startup_recovery_refreshed_linear_delegation",
+                });
                 appendDelegationObservedEvent(this.db, {
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
@@ -100,7 +108,8 @@ export class ServiceStartupRecovery {
             }
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
-            const hasPendingWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId) !== undefined;
+            const hasPendingWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId) !== undefined
+                || this.db.workflowTasks.listOpenRunnableTasks(issue.projectId).some((task) => task.subjectId === issue.linearIssueId);
             const shouldRecoverPausedLocalWork = delegated
                 && isResumablePausedLocalWork({
                     issue: {
@@ -158,18 +167,7 @@ export class ServiceStartupRecovery {
                 continue;
             }
             if (unresolvedBlockers === 0) {
-                if (shouldRecoverReactivePrWork && reactiveIntent) {
-                    this.appendReactiveWakeEvent(issue.projectId, issue.linearIssueId, issue, reactiveIntent.runType);
-                }
-                else {
-                    this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        eventType: "delegated",
-                        dedupeKey: `delegated:${issue.linearIssueId}`,
-                    });
-                }
-                if (this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId)) {
+                if (this.reconcileAndFindRunnableTask(updated.projectId, updated.linearIssueId)) {
                     this.enqueueIssue(issue.projectId, issue.linearIssueId);
                 }
                 this.logger.info({
@@ -255,61 +253,53 @@ export class ServiceStartupRecovery {
         if (commit.outcome !== "applied")
             return;
         const updated = commit.issue;
-        const hasPendingWake = this.db.workflowWakes.peekIssueWake(project.id, liveIssue.id) !== undefined;
+        this.appendAuthorityObservation({
+            projectId: project.id,
+            linearIssueId: liveIssue.id,
+            delegated: true,
+            observedDelegateId: liveIssue.delegateId,
+            reason: "startup_recovery_discovered_delegated_issue",
+        });
         const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(project.id, liveIssue.id);
-        if (!hasPendingWake && unresolvedBlockers === 0) {
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, liveIssue.id, {
-                projectId: project.id,
-                linearIssueId: liveIssue.id,
-                eventType: "delegated",
-                dedupeKey: `delegated:${liveIssue.id}`,
-            });
-        }
-        if (this.db.workflowWakes.peekIssueWake(project.id, liveIssue.id)) {
-            this.enqueueIssue(project.id, liveIssue.id);
-        }
         this.logger.info({
             issueKey: updated.issueKey,
             projectId: project.id,
             unresolvedBlockers,
         }, unresolvedBlockers === 0
-            ? "Discovered delegated Linear issue during startup recovery and queued implementation"
+            ? "Discovered delegated Linear issue during startup recovery"
             : "Discovered delegated blocked Linear issue during startup recovery");
     }
-    appendReactiveWakeEvent(projectId, linearIssueId, issue, runType) {
-        const eventType = reactiveWakeEventType(runType);
-        const dedupeKey = runType === "queue_repair" || runType === "ci_repair"
-            ? buildRepairWakeDedupeKey({
-                scope: "startup_recovery",
-                runType,
-                linearIssueId,
-                signature: issue.lastGitHubFailureSignature,
-                prHeadSha: issue.prHeadSha,
-                failureHeadSha: issue.lastGitHubFailureHeadSha,
-            })
-            : buildRequestedChangesWakeIdentity({
-                linearIssueId,
-                runType,
-                headSha: issue.prHeadSha,
-            }).dedupeKey;
-        const requestedChangesIdentity = eventType === "review_changes_requested"
-            ? buildRequestedChangesWakeIdentity({
-                linearIssueId,
-                runType: runType === "branch_upkeep" ? "branch_upkeep" : "review_fix",
-                headSha: issue.prHeadSha,
-            })
-            : undefined;
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, linearIssueId, {
-            projectId,
-            linearIssueId,
-            eventType,
-            ...(requestedChangesIdentity ? {
-                eventJson: JSON.stringify({
-                    requestedChangesCoalesceKey: requestedChangesIdentity.coalesceKey,
-                    ...(requestedChangesIdentity.headSha ? { requestedChangesHeadSha: requestedChangesIdentity.headSha } : {}),
-                }),
-            } : {}),
-            dedupeKey,
+    appendAuthorityObservation(params) {
+        this.db.workflowObservations.appendObservation({
+            projectId: params.projectId,
+            subjectId: params.linearIssueId,
+            source: "linear",
+            type: params.delegated ? "linear.delegated" : "linear.undelegated",
+            payloadJson: JSON.stringify({
+                source: "startup_recovery",
+                delegated: params.delegated,
+                issueId: params.linearIssueId,
+                actorId: params.actorId,
+                observedDelegateId: params.observedDelegateId,
+                reason: params.reason,
+            }),
+            dedupeKey: [
+                "startup_recovery",
+                "authority",
+                params.linearIssueId,
+                params.delegated ? "delegated" : "undelegated",
+                params.observedDelegateId ?? "",
+            ].join(":"),
         });
     }
+    reconcileAndFindRunnableTask(projectId, linearIssueId) {
+        const issue = this.db.issues.getIssue(projectId, linearIssueId);
+        if (!issue)
+            return false;
+        const reconciliation = reconcileWorkflowTasksForIssue(this.db, issue);
+        return [
+            ...reconciliation.result.opened,
+            ...reconciliation.result.updated,
+        ].some((task) => task.gateAction === "start" && task.runType);
+    }
 }

package/dist/service.js

@@ -77,6 +77,9 @@ export class PatchRelayService {
             processIssue: async (item) => {
                 await this.orchestrator.run(item);
             },
+        }, {
+            assertStorageReady: () => db.assertSchemaReady(),
+            describeStorage: () => db.describeSchema(),
         });
         enqueueIssue = (projectId, issueId) => runtime.enqueueIssue(projectId, issueId);
         this.oauthService = new LinearOAuthService(config, { linearInstallations: db.linearInstallations }, logger);

package/dist/sqlite-errors.js

@@ -0,0 +1,5 @@
+export function isSqliteSchemaReadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("no such table:")
+        || message.includes("no such column:");
+}

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

@@ -85,8 +85,12 @@ export class TrackedIssueListQuery {
             const blockedByKeys = parseStringArray(typeof row.blocked_by_keys_json === "string" ? row.blocked_by_keys_json : undefined);
             const blockedByCount = Number(row.blocked_by_count ?? 0);
             const hasPendingSessionEvents = Number(row.pending_session_event_count ?? 0) > 0;
+            const hasRunnableWorkflowTask = this.db.workflowTasks
+                .listOpenRunnableTasks(String(row.project_id))
+                .some((task) => task.subjectId === String(row.linear_issue_id));
             const hasPendingWake = hasPendingSessionEvents
-                || this.db.workflowWakes.peekIssueWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
+                || this.db.workflowWakes.peekIssueWake(String(row.project_id), String(row.linear_issue_id)) !== undefined
+                || hasRunnableWorkflowTask;
             const detachedActiveRun = hasDetachedActiveLatestRun({
                 activeRunId: row.active_run_type !== null ? 1 : undefined,
                 latestRun: row.latest_run_status !== null

package/dist/wake-dispatcher.js

@@ -1,4 +1,5 @@
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 // Single owner of "append a session event and tell the orchestrator
 // something might be runnable", and of "release a finished run so the
 // next wake fires." Until this existed, 8+ call sites each made their
@@ -32,6 +33,122 @@ export class WakeDispatcher {
         this.feed = feed;
         this.telemetry = telemetry;
     }
+    listOpenWorkflowTasks(projectId, linearIssueId) {
+        return this.db.workflowTasks.listOpenTasks(projectId, linearIssueId);
+    }
+    reconcileOpenWorkflowTasks(issue, options) {
+        try {
+            return reconcileWorkflowTasksForIssue(this.db, issue, options).result.open;
+        }
+        catch (error) {
+            this.logger.warn({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                error: error instanceof Error ? error.message : String(error),
+            }, "Workflow task reconciliation failed while resolving wake");
+            return this.listOpenWorkflowTasks(issue.projectId, issue.linearIssueId);
+        }
+    }
+    peekRunnableWorkflowTask(projectId, linearIssueId, openTasks) {
+        return (openTasks ?? this.db.workflowTasks.listOpenRunnableTasks(projectId))
+            .find((task) => (task.subjectId === linearIssueId
+            && task.taskType === "run"
+            && task.gateAction === "start"
+            && task.runType !== undefined));
+    }
+    workflowAuthorityObserved(projectId, linearIssueId) {
+        return this.db.workflowObservations
+            .listObservations(projectId, linearIssueId)
+            .some((observation) => (observation.type === "linear.delegated"
+            || observation.type === "linear.undelegated"
+            || observation.type === "operator.authority_changed"));
+    }
+    sessionWakeCanAnswerInputWait(openTasks, wakeReason) {
+        if (openTasks.length === 0 || !openTasks.every((task) => task.taskId === "wait:input")) {
+            return false;
+        }
+        return wakeReason === "direct_reply"
+            || wakeReason === "followup_prompt"
+            || wakeReason === "followup_comment"
+            || wakeReason === "human_instruction"
+            || wakeReason === "operator_prompt"
+            || wakeReason === "completion_check_continue";
+    }
+    workflowTasksSuppressSessionWake(openTasks, wakeReason) {
+        if (openTasks.length === 0)
+            return false;
+        if (this.peekRunnableWorkflowTask(openTasks[0].projectId, openTasks[0].subjectId, openTasks))
+            return false;
+        if (!openTasks.some((task) => this.isBlockingWorkflowGate(task)))
+            return false;
+        return !this.sessionWakeCanAnswerInputWait(openTasks, wakeReason);
+    }
+    isBlockingWorkflowGate(task) {
+        if (task.taskId === "wait:input")
+            return true;
+        if (task.taskId === "wait:children" || task.taskId === "wait:blockers" || task.taskId.startsWith("wait:active-run:")) {
+            return true;
+        }
+        if (task.taskId === "wait:authority") {
+            return this.workflowAuthorityObserved(task.projectId, task.subjectId);
+        }
+        return task.taskType === "verify" || task.taskType === "ask" || task.taskType === "escalate" || task.taskType === "publish";
+    }
+    resolveDispatchableWake(projectId, linearIssueId, issue, options) {
+        const existingWorkflowTasks = this.listOpenWorkflowTasks(projectId, linearIssueId);
+        const existingWorkflowTask = this.peekRunnableWorkflowTask(projectId, linearIssueId, existingWorkflowTasks);
+        if (existingWorkflowTask?.runType) {
+            return {
+                runType: existingWorkflowTask.runType,
+                wakeReason: existingWorkflowTask.taskId,
+                eventIds: [],
+                source: "workflow_task",
+            };
+        }
+        const freshIssue = this.db.issues.getIssue(projectId, linearIssueId) ?? issue;
+        const openWorkflowTasks = this.reconcileOpenWorkflowTasks(freshIssue, options);
+        const workflowTask = this.peekRunnableWorkflowTask(projectId, linearIssueId, openWorkflowTasks);
+        if (workflowTask?.runType) {
+            return {
+                runType: workflowTask.runType,
+                wakeReason: workflowTask.taskId,
+                eventIds: [],
+                source: "workflow_task",
+            };
+        }
+        const sessionWake = this.db.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
+        if (sessionWake) {
+            if (this.workflowTasksSuppressSessionWake(openWorkflowTasks, sessionWake.wakeReason)) {
+                return undefined;
+            }
+            return {
+                runType: sessionWake.runType,
+                ...(sessionWake.wakeReason ? { wakeReason: sessionWake.wakeReason } : {}),
+                eventIds: sessionWake.eventIds,
+                source: "session_event",
+            };
+        }
+        if (this.workflowTasksSuppressSessionWake(openWorkflowTasks, undefined)) {
+            return undefined;
+        }
+        if (issue.pendingRunType) {
+            return {
+                runType: issue.pendingRunType,
+                eventIds: [],
+                source: "legacy_pending_run_type",
+            };
+        }
+        const implicitWake = this.db.workflowWakes.peekIssueWake(projectId, linearIssueId);
+        if (!implicitWake)
+            return undefined;
+        return {
+            runType: implicitWake.runType,
+            ...(implicitWake.wakeReason ? { wakeReason: implicitWake.wakeReason } : {}),
+            eventIds: implicitWake.eventIds,
+            source: "implicit",
+        };
+    }
     // Scope the next enqueue calls inside `fn` to a single dedupe Set.
     // Nested ticks reuse the outermost Set so deeply nested helpers do
     // not silently lose dedupe.
@@ -144,12 +261,8 @@ export class WakeDispatcher {
             }
             return undefined;
         }
-        const wake = this.db.workflowWakes.peekIssueWake(projectId, linearIssueId);
-        // Fall back to the legacy pending_run_type column. The orchestrator
-        // materializes it into a real event at run time, but the poke still
-        // needs to happen now so the orchestrator gets called at all.
-        const runType = wake?.runType ?? issue.pendingRunType;
-        if (!runType) {
+        const dispatchable = this.resolveDispatchableWake(projectId, linearIssueId, issue);
+        if (!dispatchable) {
             emitTelemetry(this.telemetry, {
                 type: "wake.suppressed",
                 projectId,
@@ -175,10 +288,10 @@ export class WakeDispatcher {
             projectId,
             linearIssueId,
             ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-            runType,
-            ...(wake?.wakeReason ? { wakeReason: wake.wakeReason } : {}),
-            ...(wake?.eventIds ? { eventIds: wake.eventIds } : {}),
-            source: wake ? (wake.eventIds.length > 0 ? "session_event" : "implicit") : "legacy_pending_run_type",
+            runType: dispatchable.runType,
+            ...(dispatchable.wakeReason ? { wakeReason: dispatchable.wakeReason } : {}),
+            eventIds: dispatchable.eventIds,
+            source: dispatchable.source,
         });
         const tick = options?.enqueuedThisTick ?? this.currentTick;
         const key = `${projectId}:${linearIssueId}`;
@@ -188,18 +301,18 @@ export class WakeDispatcher {
                 projectId,
                 linearIssueId,
                 ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-                runType,
-                ...(wake?.wakeReason ? { wakeReason: wake.wakeReason } : {}),
-                ...(wake?.eventIds ? { eventIds: wake.eventIds } : {}),
+                runType: dispatchable.runType,
+                ...(dispatchable.wakeReason ? { wakeReason: dispatchable.wakeReason } : {}),
+                eventIds: dispatchable.eventIds,
             });
             emitTelemetry(this.telemetry, {
                 type: "queue.deduped",
                 projectId,
                 linearIssueId,
                 ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-                runType,
+                runType: dispatchable.runType,
             });
-            return runType;
+            return dispatchable.runType;
         }
         tick?.add(key);
         this.enqueueIssue(projectId, linearIssueId);
@@ -208,18 +321,18 @@ export class WakeDispatcher {
             projectId,
             linearIssueId,
             ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-            runType,
-            ...(wake?.wakeReason ? { wakeReason: wake.wakeReason } : {}),
-            ...(wake?.eventIds ? { eventIds: wake.eventIds } : {}),
+            runType: dispatchable.runType,
+            ...(dispatchable.wakeReason ? { wakeReason: dispatchable.wakeReason } : {}),
+            eventIds: dispatchable.eventIds,
         });
         emitTelemetry(this.telemetry, {
             type: "queue.enqueued",
             projectId,
             linearIssueId,
             ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-            runType,
+            runType: dispatchable.runType,
         });
-        return runType;
+        return dispatchable.runType;
     }
     // Release the lease for a finished run, then drain any wake that
     // landed during the run. The single owner of "run is over, what's
@@ -241,7 +354,18 @@ export class WakeDispatcher {
             runId: params.run.id,
             runType: params.run.runType,
         });
-        const wake = this.db.workflowWakes.peekIssueWake(params.run.projectId, params.run.linearIssueId);
+        const issue = this.db.issues.getIssue(params.run.projectId, params.run.linearIssueId);
+        if (issue?.factoryState === "done" || issue?.factoryState === "failed" || issue?.factoryState === "escalated" || issue?.prState === "merged") {
+            emitTelemetry(this.telemetry, {
+                type: "wake.suppressed",
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                ...(params.issueKey ? { issueKey: params.issueKey } : {}),
+                reason: "terminal_event",
+            });
+            return undefined;
+        }
+        const wake = issue ? this.resolveDispatchableWake(params.run.projectId, params.run.linearIssueId, issue, { ignoreDetachedActiveRuns: true }) : undefined;
         if (!wake) {
             emitTelemetry(this.telemetry, {
                 type: "wake.suppressed",