patchrelay 0.81.0 → 0.83.0

package/dist/github-webhook-handler.js

@@ -6,11 +6,12 @@ import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver, } f
 import { resolveGitHubWebhookIssue } from "./github-webhook-issue-resolution.js";
 import { maybeCloseLatePublishedImplementationPr } from "./github-webhook-late-publication-guard.js";
 import { projectGitHubWebhookState } from "./github-webhook-state-projector.js";
-import { maybeEnqueueGitHubReactiveRun } from "./github-webhook-reactive-run.js";
+import { resolveGitHubRequestedChangesContext } from "./github-review-context.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";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 export class GitHubWebhookHandler {
     config;
     db;
@@ -126,16 +127,68 @@ export class GitHubWebhookHandler {
             failureContextResolver: this.failureContextResolver,
             ciSnapshotResolver: this.ciSnapshotResolver,
         }, issue, event, project, resolved.linkedBy);
-        await maybeEnqueueGitHubReactiveRun({
-            db: this.db,
-            logger: this.logger,
-            feed: this.feed,
-            wakeDispatcher: this.wakeDispatcher,
-            issue: freshIssue,
-            event,
-            project,
-            failureContextResolver: this.failureContextResolver,
-            fetchImpl: this.fetchImpl,
+        const requestedChangesContext = event.triggerEvent === "review_changes_requested"
+            ? await resolveGitHubRequestedChangesContext({
+                linearIssueId: freshIssue.linearIssueId,
+                event,
+                fetchImpl: this.fetchImpl,
+            }).catch((error) => {
+                this.logger.warn({
+                    issueKey: freshIssue.issueKey,
+                    prNumber: event.prNumber,
+                    reviewId: event.reviewId,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Failed to fetch inline review comments for requested-changes observation");
+                return resolveGitHubRequestedChangesContext({
+                    linearIssueId: freshIssue.linearIssueId,
+                    event,
+                    fetchImpl: this.fetchImpl,
+                    includeInlineComments: false,
+                });
+            })
+            : undefined;
+        this.db.workflowObservations.appendObservation({
+            projectId: freshIssue.projectId,
+            subjectId: freshIssue.linearIssueId,
+            source: "github",
+            type: `github.${event.triggerEvent}`,
+            payloadJson: JSON.stringify({
+                triggerEvent: event.triggerEvent,
+                repoFullName: event.repoFullName,
+                branchName: event.branchName,
+                headSha: event.headSha,
+                prNumber: event.prNumber,
+                prState: event.prState,
+                reviewState: event.reviewState,
+                reviewId: event.reviewId,
+                reviewCommitId: event.reviewCommitId,
+                reviewerName: event.reviewerName,
+                requestedChangesContext: requestedChangesContext?.context,
+                checkStatus: event.checkStatus,
+                checkName: event.checkName,
+                checkUrl: event.checkUrl,
+            }),
+            dedupeKey: requestedChangesContext?.dedupeKey ?? [
+                event.triggerEvent,
+                event.repoFullName,
+                event.prNumber ?? event.branchName,
+                event.headSha,
+                event.reviewId ?? event.checkName ?? "",
+                event.reviewState ?? event.checkStatus ?? event.prState ?? "",
+            ].join(":"),
+        });
+        const workflowReconciliation = reconcileWorkflowTasksForIssue(this.db, freshIssue);
+        const changedRunnableWorkflowTask = [
+            ...workflowReconciliation.result.opened,
+            ...workflowReconciliation.result.updated,
+        ].some((task) => task.gateAction === "start" && task.runType);
+        const shouldDispatchWorkflowTask = event.triggerEvent === "review_changes_requested"
+            || event.triggerEvent === "check_failed"
+            || event.triggerEvent === "pr_closed";
+        await this.wakeDispatcher.withTick(async () => {
+            if (shouldDispatchWorkflowTask && changedRunnableWorkflowTask) {
+                this.wakeDispatcher.dispatchIfWakePending(freshIssue.projectId, freshIssue.linearIssueId);
+            }
         });
         if (event.triggerEvent === "pr_opened") {
             await maybeRunSequenceBackstop({

package/dist/idle-reconciliation.js

@@ -13,6 +13,7 @@ import { queueSettledOrchestrationIssue } from "./orchestration-parent-wake.js";
 import { fetchPullRequestSnapshot } from "./reconcile-pr-fetch.js";
 import { buildPrStateUpdates } from "./reconcile-pr-state-updates.js";
 import { buildRepairWakeDedupeKey, buildRequestedChangesWakeIdentity, reactiveWakeEventType } from "./reactive-wake-keys.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 import { execCommand } from "./utils.js";
 import { LinearIssueProjectionService } from "./linear-issue-projection.js";
 import { TerminalWakeReconciler } from "./terminal-wake-reconciler.js";
@@ -561,6 +562,29 @@ export class IdleIssueReconciler {
                 headAdvanced,
                 ...(prState === "closed" ? { closedPrDisposition: resolveClosedPrDisposition(issue) } : {}),
             };
+            this.db.workflowObservations.appendObservation({
+                projectId: issue.projectId,
+                subjectId: issue.linearIssueId,
+                source: "github",
+                type: "github.pr_reconciled",
+                payloadJson: JSON.stringify({
+                    ...observed,
+                    repoFullName: project.github.repoFullName,
+                    mergeable: pr.mergeable,
+                    mergeStateStatus: pr.mergeStateStatus,
+                }),
+                dedupeKey: [
+                    "pr_reconciled",
+                    project.github.repoFullName,
+                    prNumber,
+                    prState,
+                    pr.headRefOid ?? "",
+                    pr.reviewDecision ?? "",
+                    gateCheckStatus ?? "",
+                    pr.mergeable ?? "",
+                    pr.mergeStateStatus ?? "",
+                ].join(":"),
+            });
             const currentFacts = (record) => ({
                 factoryState: record.factoryState,
                 prReviewState: record.prReviewState,
@@ -720,18 +744,21 @@ export class IdleIssueReconciler {
                 return;
             }
             if (issue.delegatedToPatchRelay
-                && reactiveIntent?.runType === "review_fix"
-                && this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId) === undefined) {
+                && reactiveIntent?.runType === "review_fix") {
                 this.logger.info({
                     issueKey: issue.issueKey,
                     prNumber: issue.prNumber,
                     from: issue.factoryState,
                     runType: reactiveIntent.runType,
                 }, "Reconciliation: re-queued requested-changes follow-up from GitHub truth");
-                this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
-                    pendingRunType: reactiveIntent.runType,
-                    ...(mayClearFailureProvenance(issue, provenanceEvidence) ? { clearFailureProvenance: true } : {}),
-                });
+                this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, mayClearFailureProvenance(issue, provenanceEvidence)
+                    ? { clearFailureProvenance: true }
+                    : undefined);
+                const currentIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId);
+                if (currentIssue) {
+                    reconcileWorkflowTasksForIssue(this.db, currentIssue);
+                    this.wakeDispatcher.dispatchIfWakePending(currentIssue.projectId, currentIssue.linearIssueId);
+                }
                 this.feed?.publish({
                     level: "warn",
                     kind: "github",

package/dist/issue-overview-query.js

@@ -127,7 +127,8 @@ export class IssueOverviewQuery {
                 delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
                 ...(activeRun ? { activeRunId: activeRun.id } : {}),
                 blockedByCount: unresolvedBlockedBy.length,
-                hasPendingWake: this.db.workflowWakes.peekIssueWake(session.projectId, session.linearIssueId) !== undefined,
+                hasPendingWake: this.db.workflowWakes.peekIssueWake(session.projectId, session.linearIssueId) !== undefined
+                    || this.db.workflowTasks.listOpenRunnableTasks(session.projectId).some((task) => task.subjectId === session.linearIssueId),
                 hasLegacyPendingRun: issueRecord?.pendingRunType !== undefined,
                 orchestrationSettleUntil: issueRecord?.orchestrationSettleUntil,
                 ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),

package/dist/linear-issue-projection.js

@@ -46,6 +46,43 @@ export async function refreshIssueFromLinear(params) {
     }
 }
 export function upsertLinearIssueProjection(db, projectId, liveIssue) {
+    db.workflowObservations.appendObservation({
+        projectId,
+        subjectId: liveIssue.id,
+        source: "linear",
+        type: "linear.issue_reconciled",
+        payloadJson: JSON.stringify({
+            issueId: liveIssue.id,
+            issueKey: liveIssue.identifier,
+            title: liveIssue.title,
+            stateName: liveIssue.stateName,
+            stateType: liveIssue.stateType,
+            delegateId: liveIssue.delegateId,
+            parentId: liveIssue.parentId,
+            blockedBy: liveIssue.blockedBy.map((blocker) => ({
+                id: blocker.id,
+                identifier: blocker.identifier,
+                title: blocker.title,
+                stateName: blocker.stateName,
+                stateType: blocker.stateType,
+            })),
+        }),
+        dedupeKey: [
+            "issue_reconciled",
+            liveIssue.id,
+            liveIssue.identifier ?? "",
+            liveIssue.stateName ?? "",
+            liveIssue.stateType ?? "",
+            liveIssue.delegateId ?? "",
+            liveIssue.parentId ?? "",
+            ...liveIssue.blockedBy.map((blocker) => [
+                blocker.id,
+                blocker.identifier ?? "",
+                blocker.stateName ?? "",
+                blocker.stateType ?? "",
+            ].join("/")),
+        ].join(":"),
+    });
     replaceIssueDependenciesFromLinearIssue(db, projectId, liveIssue);
     db.issues.replaceIssueParentLink({
         projectId,

package/dist/run-context.js

@@ -33,8 +33,8 @@ const followUpEntryShape = {
     author: z.string().optional(),
 };
 /** Inline review comment captured from GitHub. Produced by
- * github-webhook-reactive-run.ts fetchReviewCommentsForEvent and
- * reactive-run-policy.ts hydrateRequestedChangesContext (remote-pr-review.ts);
+ * github-review-context.ts and reactive-run-policy.ts
+ * hydrateRequestedChangesContext (remote-pr-review.ts);
  * consumed by prompting/patchrelay.ts readReviewFixComments and
  * run-orchestrator.ts (review round activity comment count). */
 const reviewCommentShape = {
@@ -74,8 +74,8 @@ const ciSnapshotCheckShape = {
     summary: z.string().optional(),
 };
 /** Settled CI snapshot. Produced by github-failure-context.ts
- * buildCiSnapshotFromChecks (attached to settled_red_ci payloads by
- * github-webhook-reactive-run.ts and to implicit ci_repair wakes by
+ * buildCiSnapshotFromChecks (attached to workflow task payloads by
+ * workflow-runtime.ts and to implicit ci_repair wakes by
  * workflow-wake-resolver.ts); consumed by prompting/patchrelay.ts
  * buildCiRepairContext. */
 const ciSnapshotShape = {
@@ -196,7 +196,7 @@ const runContextShape = {
     // ── Requested-changes / review fix ────────────────────────────────
     /** Coalescing identity for review_changes_requested wakes. Produced by
      * buildRequestedChangesWakeIdentity callers (run-wake-planner.ts,
-     * github-webhook-reactive-run.ts, operator-retry-event.ts,
+     * github-review-context.ts, operator-retry-event.ts,
      * idle-reconciliation.ts); consumed by reactive-wake-keys.ts
      * readRequestedChangesCoalesceKey for event coalescing. */
     requestedChangesCoalesceKey: z.string().optional(),
@@ -211,7 +211,7 @@ const runContextShape = {
      * review_changes_requested payloads from operator-retry-event.ts and
      * deriveSessionWakePlan branch selection). */
     branchUpkeepRequired: z.boolean().optional(),
-    /** GitHub review id. Produced by github-webhook-reactive-run.ts and
+    /** GitHub review id. Produced by github-review-context.ts and
      * reactive-run-policy.ts hydrateRequestedChangesContext; consumed by
      * prompting/patchrelay.ts buildStructuredReviewContext. */
     reviewId: z.number().optional(),

package/dist/run-finalizer.js

@@ -9,7 +9,21 @@ import { computeChangeIdentityFromWorktree } from "./change-identity.js";
 import { inspectGitWorktreeStatus, isRepairRunType } from "./git-worktree-status.js";
 import { buildRunOutcomeSummary } from "./run-outcome-summary.js";
 import { settleRun } from "./run-settlement.js";
+import { evaluateTaskCompletion, projectWorkflowSnapshot } from "./workflow-runtime.js";
 const WRITER = "run-finalizer";
+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;
+    }
+}
 function buildRunSummaryJson(report, outcomeSummary) {
     return JSON.stringify({
         latestAssistantMessage: report.assistantMessages.at(-1) ?? null,
@@ -201,20 +215,16 @@ export class RunFinalizer {
             ...(options?.publishDeferredFollowUp ? { publishDeferredFollowUp: true } : {}),
         });
     }
-    // Plan §4.4: finalize a run that was superseded mid-flight. The
-    // status row was already moved to `superseded` by the trigger
-    // observer; this just makes sure the issue's activeRunId is
-    // cleared, the lease is released, and the operator sees a
-    // clean recap event. No publication, no follow-up enqueue —
-    // the approval that triggered supersedure already advanced the
-    // factoryState.
-    releaseSupersededRun(run, threadId, completedTurnId) {
+    // Finalize a run whose authority/premise was revoked mid-flight.
+    // No publication, no follow-up enqueue: the current external truth
+    // already superseded the run's right to act.
+    releaseSuppressedRun(run, threadId, completedTurnId, reason) {
         this.withHeldLease(run.projectId, run.linearIssueId, () => {
             this.db.runs.finishRun(run.id, {
                 status: "superseded",
                 threadId,
                 ...(completedTurnId ? { turnId: completedTurnId } : {}),
-                failureReason: run.failureReason ?? "approved on the same head; further publication suppressed",
+                failureReason: run.failureReason ?? reason,
             });
             this.db.issueSessions.commitIssueState({
                 writer: WRITER,
@@ -231,10 +241,28 @@ export class RunFinalizer {
         this.feed?.publish({
             level: "info",
             kind: "agent",
-            summary: `Run #${run.id} superseded — publication suppressed (approved on the same head)`,
+            summary: `Run #${run.id} superseded — publication suppressed (${reason})`,
             ...(run.projectId ? { projectId: run.projectId } : {}),
         });
     }
+    resolveSuppressedRunReason(run, issue) {
+        if (run.shouldNotPublish || run.status === "superseded") {
+            return run.leaseRevokeReason ?? run.failureReason ?? "publication suppressed";
+        }
+        const workflowSnapshot = projectWorkflowSnapshot({
+            issue,
+            observations: this.db.workflowObservations.listObservations(issue.projectId, issue.linearIssueId),
+            blockerCount: this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId),
+            childCount: this.db.issues.listCanonicalChildIssues(issue.projectId, issue.linearIssueId).length,
+        });
+        if (!workflowSnapshot.authority.delegated) {
+            return "authority revoked before run completion";
+        }
+        if (run.authorityEpoch > 0 && workflowSnapshot.authority.epoch > run.authorityEpoch) {
+            return `authority epoch changed from ${run.authorityEpoch} to ${workflowSnapshot.authority.epoch}`;
+        }
+        return undefined;
+    }
     publishTurnEvent(params) {
         this.feed?.publish({
             level: params.level,
@@ -287,6 +315,49 @@ export class RunFinalizer {
             return undefined;
         return status;
     }
+    resolveWorkflowCompletionTask(run) {
+        if (!isRepairRunType(run.runType))
+            return undefined;
+        const record = this.db.workflowTasks.getTask(run.projectId, run.linearIssueId, `run:${run.runType}`);
+        if (!record?.runType)
+            return undefined;
+        const requirements = parseObjectJson(record.requirementsJson);
+        return {
+            id: record.taskId,
+            type: record.taskType,
+            runType: record.runType,
+            reason: record.reason,
+            ...(requirements ? { requirements } : {}),
+        };
+    }
+    evaluateWorkflowCompletionGate(run, issue) {
+        const task = this.resolveWorkflowCompletionTask(run);
+        if (!task)
+            return undefined;
+        const snapshot = projectWorkflowSnapshot({
+            issue,
+            observations: this.db.workflowObservations.listObservations(issue.projectId, issue.linearIssueId),
+            blockerCount: this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId),
+            childCount: this.db.issues.listCanonicalChildIssues(issue.projectId, issue.linearIssueId).length,
+        });
+        const decision = evaluateTaskCompletion(snapshot, task);
+        if (decision.action === "start")
+            return undefined;
+        if (decision.action === "ask") {
+            return {
+                message: decision.question,
+                nextState: "awaiting_input",
+                status: decision.reason,
+                level: "warn",
+            };
+        }
+        return {
+            message: decision.reason,
+            nextState: "escalated",
+            status: decision.reason,
+            level: decision.action === "wait" ? "warn" : "error",
+        };
+    }
     continueDirtyRepairWorktree(params) {
         const message = params.status.summary
             ? `Repair run finished with a dirty worktree; ${params.status.summary}`
@@ -363,22 +434,18 @@ export class RunFinalizer {
     }
     async finalizeCompletedRun(params) {
         const { run, issue, thread, threadId } = params;
-        // Plan §4.4: a run flagged shouldNotPublish was deliberately
-        // superseded mid-flight (the PR was approved on the same head
-        // while a review_fix run was still producing output). The Codex
-        // turn may have completed; the finalizer must NOT run any of
-        // the publication-verification policies — they all assume the
-        // run was supposed to publish, and would either fail it
-        // spuriously (`verifyReviewFixAdvancedHead`) or open new
-        // follow-up work. Just record the supersedure outcome and
-        // release the lease.
-        if (run.shouldNotPublish || run.status === "superseded") {
-            this.releaseSupersededRun(run, threadId, params.completedTurnId);
+        const freshIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        // A run flagged shouldNotPublish, or whose authority epoch no
+        // longer matches current truth, must not enter publication or
+        // completion-verification paths. Those policies assume the run is
+        // still allowed to publish and may open follow-up work.
+        const suppressedReason = this.resolveSuppressedRunReason(run, freshIssue);
+        if (suppressedReason) {
+            this.releaseSuppressedRun(run, threadId, params.completedTurnId, suppressedReason);
             return;
         }
         const trackedIssue = this.db.issueToTrackedIssue(issue);
         const report = buildStageReport({ ...run, status: "completed" }, trackedIssue, thread, countEventMethods(this.db.runs.listThreadEvents(run.id)));
-        const freshIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
         const dirtyRepairWorktree = this.inspectDirtyRepairWorktree(run, freshIssue);
         if (dirtyRepairWorktree) {
             this.continueDirtyRepairWorktree({
@@ -391,6 +458,19 @@ export class RunFinalizer {
             });
             return;
         }
+        const workflowCompletionGate = this.evaluateWorkflowCompletionGate(run, freshIssue);
+        if (workflowCompletionGate) {
+            this.failRunAndClear(run, workflowCompletionGate.message, workflowCompletionGate.nextState);
+            this.syncFailureOutcome({
+                run,
+                fallbackIssue: freshIssue,
+                message: workflowCompletionGate.message,
+                level: workflowCompletionGate.level,
+                status: workflowCompletionGate.status,
+                summary: workflowCompletionGate.message,
+            });
+            return;
+        }
         const verifiedRepairError = await this.completionPolicy.verifyReactiveRunAdvancedBranch(run, freshIssue);
         if (verifiedRepairError) {
             // The run failed verification — it did not do its work, so resolve

package/dist/run-launcher.js

@@ -123,6 +123,7 @@ export class RunLauncher {
                     linearIssueId: params.item.issueId,
                     runType: params.runType,
                     ...(params.sourceHeadSha ? { sourceHeadSha: params.sourceHeadSha } : {}),
+                    ...(params.authorityEpoch !== undefined ? { authorityEpoch: params.authorityEpoch } : {}),
                     promptText: params.prompt,
                 });
                 const failureHeadSha = params.effectiveContext?.failureHeadSha ?? params.effectiveContext?.headSha;

package/dist/run-orchestrator.js

@@ -26,6 +26,7 @@ import { CodexThreadMaterializingError, isThreadMaterializingError } from "./cod
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 import { LinearIssueProjectionService } from "./linear-issue-projection.js";
 import { RunAdmissionController } from "./run-admission-controller.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 const WRITER = "run-orchestrator";
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
@@ -434,6 +435,7 @@ export class RunOrchestrator {
         const sourceHeadSha = effectiveContext?.failureHeadSha
             ?? effectiveContext?.headSha
             ?? issue.prHeadSha;
+        const workflowSnapshot = reconcileWorkflowTasksForIssue(this.db, issue).snapshot;
         const budgetExceeded = this.runWakePlanner.budgetExceeded(issue, project, runType, isRequestedChangesRunType);
         if (budgetExceeded) {
             this.emitRunSkipped(item, "budget_exceeded", issue, { runType });
@@ -458,6 +460,7 @@ export class RunOrchestrator {
             runType,
             prompt,
             ...(sourceHeadSha ? { sourceHeadSha } : {}),
+            authorityEpoch: workflowSnapshot.authority.epoch,
             ...(effectiveContext ? { effectiveContext } : {}),
             materializeLegacyPendingWake: (targetIssue, lease) => this.materializeLegacyPendingWake(targetIssue, lease),
             resolveRunWake: (targetIssue) => this.resolveRunWake(targetIssue),
@@ -469,6 +472,10 @@ export class RunOrchestrator {
             this.releaseIssueSessionLease(item.projectId, item.issueId);
             return;
         }
+        const claimedIssue = this.db.issues.getIssue(item.projectId, item.issueId);
+        if (claimedIssue) {
+            reconcileWorkflowTasksForIssue(this.db, claimedIssue);
+        }
         this.feed?.publish({
             level: "info",
             kind: "stage",

package/dist/run-wake-planner.js

@@ -1,8 +1,21 @@
 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";
 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,15 +24,52 @@ export class RunWakePlanner {
         this.logger = logger;
     }
     resolveRunWake(issue) {
-        const sessionWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId);
-        if (!sessionWake)
+        if (this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId) > 0) {
+            return undefined;
+        }
+        const sessionWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+        if (sessionWake) {
+            return {
+                runType: sessionWake.runType,
+                context: sessionWake.context,
+                wakeReason: sessionWake.wakeReason,
+                resumeThread: sessionWake.resumeThread,
+                eventIds: sessionWake.eventIds,
+            };
+        }
+        const workflowTaskWake = this.resolveWorkflowTaskWake(issue);
+        if (workflowTaskWake)
+            return workflowTaskWake;
+        const implicitWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.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: [],
         };
     }
     appendWakeEventWithLease(lease, issue, runType, context, dedupeScope) {