patchrelay 0.82.0 → 0.83.0

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) {

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/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