patchrelay 0.82.0 → 0.83.0

package/dist/wake-dispatcher.js

@@ -32,6 +32,47 @@ export class WakeDispatcher {
         this.feed = feed;
         this.telemetry = telemetry;
     }
+    peekRunnableWorkflowTask(projectId, linearIssueId) {
+        return this.db.workflowTasks
+            .listOpenRunnableTasks(projectId)
+            .find((task) => task.subjectId === linearIssueId && task.runType !== undefined);
+    }
+    resolveDispatchableWake(projectId, linearIssueId, issue) {
+        const sessionWake = this.db.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
+        if (sessionWake) {
+            return {
+                runType: sessionWake.runType,
+                ...(sessionWake.wakeReason ? { wakeReason: sessionWake.wakeReason } : {}),
+                eventIds: sessionWake.eventIds,
+                source: "session_event",
+            };
+        }
+        const workflowTask = this.peekRunnableWorkflowTask(projectId, linearIssueId);
+        if (workflowTask?.runType) {
+            return {
+                runType: workflowTask.runType,
+                wakeReason: workflowTask.taskId,
+                eventIds: [],
+                source: "workflow_task",
+            };
+        }
+        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 +185,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 +212,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 +225,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 +245,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 +278,8 @@ 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);
+        const wake = issue ? this.resolveDispatchableWake(params.run.projectId, params.run.linearIssueId, issue) : undefined;
         if (!wake) {
             emitTelemetry(this.telemetry, {
                 type: "wake.suppressed",

package/dist/webhook-handler.js

@@ -15,6 +15,7 @@ import { WakeDispatcher } from "./wake-dispatcher.js";
 import { CodexFollowupIntentClassifier } from "./followup-intent.js";
 import { AgentInputService } from "./agent-input-service.js";
 import { noopTelemetry } from "./telemetry.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 export class WebhookHandler {
     config;
     db;
@@ -139,6 +140,33 @@ export class WebhookHandler {
                 stopActiveRun: (run, input) => this.stopActiveRun(run, input),
             });
             const trackedIssue = result.issue;
+            this.db.workflowObservations.appendObservation({
+                projectId: project.id,
+                subjectId: issue.id,
+                source: "linear",
+                type: hydrated.triggerEvent === "delegateChanged"
+                    ? result.delegated ? "linear.delegated" : "linear.undelegated"
+                    : `linear.${hydrated.triggerEvent}`,
+                payloadJson: JSON.stringify({
+                    triggerEvent: hydrated.triggerEvent,
+                    webhookId: hydrated.webhookId,
+                    delegated: result.delegated,
+                    issueId: issue.id,
+                    issueKey: issue.identifier,
+                    agentSessionId: hydrated.agentSession?.id,
+                    promptContext: hydrated.agentSession?.promptContext?.trim(),
+                    promptBody: hydrated.agentSession?.promptBody?.trim(),
+                    actorId: hydrated.actor?.id,
+                    actorName: hydrated.actor?.name,
+                }),
+                dedupeKey: hydrated.webhookId,
+            });
+            const observedIssue = this.db.getIssue(project.id, issue.id);
+            let openedRunnableWorkflowTask = false;
+            if (observedIssue) {
+                const workflowReconciliation = reconcileWorkflowTasksForIssue(this.db, observedIssue);
+                openedRunnableWorkflowTask = workflowReconciliation.result.opened.some((task) => task.gateAction === "start" && task.runType);
+            }
             const newlyReadyDependents = this.dependencyReadinessHandler.reconcile(project.id, issue.id);
             const syncTargets = new Set(shouldSyncLinearStateAfterWebhook(hydrated.triggerEvent)
                 ? [issue.id, ...newlyReadyDependents]
@@ -171,36 +199,53 @@ export class WebhookHandler {
             const wakeAlreadyQueuedByFollowUpHandler = normalized.triggerEvent === "commentCreated"
                 || normalized.triggerEvent === "commentUpdated"
                 || normalized.triggerEvent === "agentPrompted";
-            if (result.wakeRunType && !wakeAlreadyQueuedByFollowUpHandler) {
-                const queuedRunType = this.enqueuePendingSessionWake(project.id, issue.id);
-                this.feed?.publish({
-                    level: "info",
-                    kind: "stage",
-                    issueKey: issue.identifier,
-                    projectId: project.id,
-                    stage: queuedRunType ?? result.wakeRunType,
-                    status: "queued",
-                    summary: `Queued ${(queuedRunType ?? result.wakeRunType)} workflow`,
-                    detail: `Triggered by ${hydrated.triggerEvent}.`,
-                });
-            }
-            for (const dependentIssueId of newlyReadyDependents) {
-                // The dependency-readiness handler already dispatched via the
-                // wake dispatcher; here we just emit the operator-feed event so
-                // the dispatched run shows up in the timeline.
-                const dependent = this.db.getTrackedIssue(project.id, dependentIssueId);
-                const queuedRunType = this.peekPendingSessionWakeRunType(project.id, dependentIssueId);
-                this.feed?.publish({
-                    level: "info",
-                    kind: "stage",
-                    issueKey: dependent?.issueKey,
-                    projectId: project.id,
-                    stage: queuedRunType ?? "implementation",
-                    status: "queued",
-                    summary: `Queued ${(queuedRunType ?? "implementation")} after blockers resolved`,
-                    detail: `All blockers are now done for ${dependent?.issueKey ?? dependentIssueId}.`,
-                });
-            }
+            await this.wakeDispatcher.withTick(async () => {
+                if (result.wakeRunType && !wakeAlreadyQueuedByFollowUpHandler) {
+                    const queuedRunType = this.enqueuePendingSessionWake(project.id, issue.id);
+                    this.feed?.publish({
+                        level: "info",
+                        kind: "stage",
+                        issueKey: issue.identifier,
+                        projectId: project.id,
+                        stage: queuedRunType ?? result.wakeRunType,
+                        status: "queued",
+                        summary: `Queued ${(queuedRunType ?? result.wakeRunType)} workflow`,
+                        detail: `Triggered by ${hydrated.triggerEvent}.`,
+                    });
+                }
+                if (openedRunnableWorkflowTask && !wakeAlreadyQueuedByFollowUpHandler) {
+                    const workflowTaskRunType = this.enqueuePendingSessionWake(project.id, issue.id);
+                    if (workflowTaskRunType && !result.wakeRunType) {
+                        this.feed?.publish({
+                            level: "info",
+                            kind: "stage",
+                            issueKey: issue.identifier,
+                            projectId: project.id,
+                            stage: workflowTaskRunType,
+                            status: "queued",
+                            summary: `Queued ${workflowTaskRunType} workflow`,
+                            detail: `Derived after ${hydrated.triggerEvent}.`,
+                        });
+                    }
+                }
+                for (const dependentIssueId of newlyReadyDependents) {
+                    // The dependency-readiness handler already dispatched via the
+                    // wake dispatcher; here we just emit the operator-feed event so
+                    // the dispatched run shows up in the timeline.
+                    const dependent = this.db.getTrackedIssue(project.id, dependentIssueId);
+                    const queuedRunType = this.peekPendingSessionWakeRunType(project.id, dependentIssueId);
+                    this.feed?.publish({
+                        level: "info",
+                        kind: "stage",
+                        issueKey: dependent?.issueKey,
+                        projectId: project.id,
+                        stage: queuedRunType ?? "implementation",
+                        status: "queued",
+                        summary: `Queued ${(queuedRunType ?? "implementation")} after blockers resolved`,
+                        detail: `All blockers are now done for ${dependent?.issueKey ?? dependentIssueId}.`,
+                    });
+                }
+            });
             for (const issueId of syncTargets) {
                 const syncIssue = this.db.getIssue(project.id, issueId);
                 if (!syncIssue) {

package/dist/webhooks/dependency-readiness-handler.js

@@ -1,4 +1,5 @@
 import { emitTelemetry, noopTelemetry } from "../telemetry.js";
+import { reconcileWorkflowTasksForIssue } from "../workflow-task-reconciler.js";
 const WRITER = "dependency-readiness-handler";
 export class DependencyReadinessHandler {
     db;
@@ -57,6 +58,11 @@ export class DependencyReadinessHandler {
             if (!issue.delegatedToPatchRelay || issue.activeRunId !== undefined) {
                 continue;
             }
+            const workflowReconciliation = reconcileWorkflowTasksForIssue(this.db, issue);
+            const hasRunnableWorkflowTask = [
+                ...workflowReconciliation.result.opened,
+                ...workflowReconciliation.result.updated,
+            ].some((task) => task.gateAction === "start" && task.runType);
             const pendingWakeRunType = this.db.workflowWakes.peekIssueWake(projectId, dependent.linearIssueId)?.runType
                 ?? issue.pendingRunType;
             if (pendingWakeRunType) {
@@ -72,6 +78,19 @@ export class DependencyReadinessHandler {
                 newlyReady.push(dependent.linearIssueId);
                 continue;
             }
+            if (hasRunnableWorkflowTask) {
+                const dispatchedRunType = this.wakeDispatcher.dispatchIfWakePending(projectId, dependent.linearIssueId);
+                emitTelemetry(this.telemetry, {
+                    type: "dependency.dependent_unblocked",
+                    projectId,
+                    linearIssueId: dependent.linearIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    blockerLinearIssueId,
+                    ...(dispatchedRunType ? { dispatchedRunType } : {}),
+                });
+                newlyReady.push(dependent.linearIssueId);
+                continue;
+            }
             if (issue.factoryState !== "delegated" || this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
                 continue;
             }
@@ -86,19 +105,6 @@ export class DependencyReadinessHandler {
                     },
                 });
             }
-            const dispatchedRunType = this.wakeDispatcher.recordEventAndDispatch(projectId, dependent.linearIssueId, {
-                eventType: "delegated",
-                dedupeKey: `delegated:${dependent.linearIssueId}`,
-            });
-            emitTelemetry(this.telemetry, {
-                type: "dependency.dependent_unblocked",
-                projectId,
-                linearIssueId: dependent.linearIssueId,
-                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-                blockerLinearIssueId,
-                ...(dispatchedRunType ? { dispatchedRunType } : {}),
-            });
-            newlyReady.push(dependent.linearIssueId);
         }
         return newlyReady;
     }

package/dist/webhooks/desired-stage-recorder.js

@@ -141,6 +141,9 @@ export class DesiredStageRecorder {
         const wasResolved = isResolvedLinearState(existingIssue?.currentLinearStateType, existingIssue?.currentLinearState);
         const isResolved = isResolvedLinearState(issue.currentLinearStateType, issue.currentLinearState);
         if (workflowPlan.undelegation.factoryState) {
+            if (activeRun && releaseReason) {
+                this.db.runs.revokeRunLease(activeRun.id, { reason: releaseReason });
+            }
             if (activeRun?.threadId && activeRun.turnId) {
                 await params.stopActiveRun(activeRun, "STOP: The issue was un-delegated from PatchRelay. Stop working immediately and exit.");
             }
@@ -205,24 +208,6 @@ export class DesiredStageRecorder {
                 summary: "Waiting briefly for child issues to settle before orchestration starts",
             });
         }
-        else if (!workflowPlan.startupResume.factoryState
-            && !workflowPlan.startupResume.pendingRunType
-            && workflowPlan.desiredStage === "implementation"
-            && params.normalized.triggerEvent !== "commentCreated"
-            && params.normalized.triggerEvent !== "commentUpdated"
-            && params.normalized.triggerEvent !== "agentPrompted") {
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
-                projectId: params.project.id,
-                linearIssueId: normalizedIssue.id,
-                eventType: "delegated",
-                eventJson: JSON.stringify({
-                    promptContext: params.normalized.agentSession?.promptContext?.trim()
-                        ?? (issue.issueKey ? `Linear issue ${issue.issueKey} was delegated to PatchRelay.` : undefined),
-                    promptBody: params.normalized.agentSession?.promptBody?.trim(),
-                }),
-                dedupeKey: `delegated:${normalizedIssue.id}`,
-            });
-        }
         if (previousParentIssueId && previousParentIssueId !== currentParentIssueId) {
             wakeOrchestrationParentsForChildEvent({
                 db: this.db,