patchrelay 0.81.0 → 0.83.0

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

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,