@lota-sdk/core 0.4.10 → 0.4.12

package/src/services/plan/plan-agent-query.service.ts

@@ -3,12 +3,13 @@ import { PlanRunSchema } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
 import { BoundQuery } from 'surrealdb'
 
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { effectTryPromise } from '../../effect/helpers'
-import { DatabaseServiceTag } from '../../effect/services'
+import { AgentConfigServiceTag, DatabaseServiceTag } from '../../effect/services'
 import { resolvePlanNodeExecutionVisibility } from '../../runtime/execution-plan-visibility'
 import { nowDate, unsafeDateFrom } from '../../utils/date-time'
 import { evaluateDeadline } from './plan-deadline.service'
@@ -53,6 +54,7 @@ export interface RecentlyUnblockedNode {
 }
 
 function isVisibleAgentNode(params: {
+  agentConfig: ResolvedAgentConfig
   nodeSpec: PlanNodeSpecRecord
   spec: PlanSpecRecord
 }): { agentId: string; visibility: PlanExecutionVisibility } | null {
@@ -60,7 +62,7 @@ function isVisibleAgentNode(params: {
     return null
   }
 
-  const visibility = resolvePlanNodeExecutionVisibility(params.spec, params.nodeSpec)
+  const visibility = resolvePlanNodeExecutionVisibility(params.agentConfig, params.spec, params.nodeSpec)
   const isVisible = visibility === 'visible'
   if (!isVisible) {
     return null
@@ -93,12 +95,13 @@ function queryServiceEffect<A, E>(
 }
 
 interface PlanAgentQueryDeps {
+  agentConfig: ResolvedAgentConfig
   db: SurrealDBService
   planRunService: ReturnType<typeof makePlanRunService>
 }
 
 export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
-  const { db, planRunService } = deps
+  const { agentConfig, db, planRunService } = deps
 
   function listActiveRunsEffect(organizationId?: RecordIdInput): Effect.Effect<PlanRunRecord[], PlanAgentQueryError> {
     const bindings = {
@@ -138,7 +141,7 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
             if (!ACTIONABLE_NODE_STATUSES.has(nodeRun.status)) continue
             const nodeSpec = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
             if (!nodeSpec) continue
-            const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
+            const visibleTarget = isVisibleAgentNode({ agentConfig, nodeSpec, spec })
             if (!visibleTarget) continue
             if (params.agentId && params.agentId !== visibleTarget.agentId) continue
             actionable.push({
@@ -167,7 +170,7 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
           continue
         }
 
-        const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
+        const visibleTarget = isVisibleAgentNode({ agentConfig, nodeSpec, spec })
         if (!visibleTarget) {
           continue
         }
@@ -226,7 +229,7 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
             continue
           }
 
-          const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
+          const visibleTarget = isVisibleAgentNode({ agentConfig, nodeSpec, spec })
           matches.push({
             organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
             threadId: recordIdToString(run.threadId, TABLES.THREAD),
@@ -276,7 +279,7 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
             continue
           }
 
-          const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
+          const visibleTarget = isVisibleAgentNode({ agentConfig, nodeSpec, spec })
           if (!visibleTarget) {
             continue
           }
@@ -315,8 +318,9 @@ export class PlanAgentQueryServiceTag extends Context.Service<
 export const PlanAgentQueryServiceLive = Layer.effect(
   PlanAgentQueryServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const db = yield* DatabaseServiceTag
     const planRunService = yield* PlanRunServiceTag
-    return makePlanAgentQueryService({ db, planRunService })
+    return makePlanAgentQueryService({ agentConfig, db, planRunService })
   }),
 )

package/src/services/plan/plan-completion-side-effects.ts

@@ -7,7 +7,6 @@ import { ensureRecordId } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
-import { runPromise } from '../../effect/runtime'
 import { nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
 import type { makeFeedbackLoopService } from '../feedback-loop.service'
 import type { makeInstitutionalMemoryService } from '../institutional-memory.service'
@@ -53,117 +52,110 @@ export function makePlanCompletionSideEffects({
   planRunService,
   qualityMetricsService,
 }: PlanCompletionSideEffectsDeps) {
-  function runPlanNodeCompletionSideEffects(params: {
-    runId: string
-    organizationId: string
-    nodeId: string
-    nodeLabel: string
-    nodeOwnerRef: string
-    nodeOwnerType: PlanNodeOwner['executorType']
-    nodeType: PlanNodeType
-    nodeStartedAt?: string | Date | null
-    nodeAttemptCount: number
-    artifactCount: number
-    validationIssues: PlanValidationIssueInput[]
-  }): Promise<void> {
-    return runPromise(
-      Effect.gen(function* () {
-        const executionTimeMs = params.nodeStartedAt
-          ? nowEpochMillis() - unsafeDateFrom(params.nodeStartedAt).getTime()
-          : 0
-        if (executionTimeMs > 0) {
-          yield* Metric.update(
-            Metric.withAttributes(planNodeExecutionDuration, { nodeType: params.nodeType }),
-            executionTimeMs,
-          )
-        }
-        yield* qualityMetricsService.recordNodeMetrics({
-          organizationId: params.organizationId,
-          runId: params.runId,
-          nodeId: params.nodeId,
-          metrics: {
-            executionTimeMs: Math.max(0, executionTimeMs),
-            attemptCount: params.nodeAttemptCount,
-            artifactCount: params.artifactCount,
-            validationIssueCount: params.validationIssues.length,
-            ownerRef: params.nodeOwnerRef,
-            ownerType: params.nodeOwnerType,
-            nodeType: params.nodeType,
-          },
-        })
-      }),
-    )
-  }
+  const runPlanNodeCompletionSideEffects = Effect.fn('PlanCompletionSideEffects.runPlanNodeCompletionSideEffects')(
+    function* (params: {
+      runId: string
+      organizationId: string
+      nodeId: string
+      nodeLabel: string
+      nodeOwnerRef: string
+      nodeOwnerType: PlanNodeOwner['executorType']
+      nodeType: PlanNodeType
+      nodeStartedAt?: string | Date | null
+      nodeAttemptCount: number
+      artifactCount: number
+      validationIssues: PlanValidationIssueInput[]
+    }) {
+      const executionTimeMs = params.nodeStartedAt
+        ? nowEpochMillis() - unsafeDateFrom(params.nodeStartedAt).getTime()
+        : 0
+      if (executionTimeMs > 0) {
+        yield* Metric.update(
+          Metric.withAttributes(planNodeExecutionDuration, { nodeType: params.nodeType }),
+          executionTimeMs,
+        )
+      }
+      yield* qualityMetricsService.recordNodeMetrics({
+        organizationId: params.organizationId,
+        runId: params.runId,
+        nodeId: params.nodeId,
+        metrics: {
+          executionTimeMs: Math.max(0, executionTimeMs),
+          attemptCount: params.nodeAttemptCount,
+          artifactCount: params.artifactCount,
+          validationIssueCount: params.validationIssues.length,
+          ownerRef: params.nodeOwnerRef,
+          ownerType: params.nodeOwnerType,
+          nodeType: params.nodeType,
+        },
+      })
+    },
+  )
 
-  function runPlanCompletionSideEffects(params: { runId: string; organizationId: string }): Promise<void> {
-    return runPromise(
-      Effect.gen(function* () {
-        yield* qualityMetricsService.recordCycleMetrics({ organizationId: params.organizationId, runId: params.runId })
+  const runPlanCompletionSideEffects = Effect.fn('PlanCompletionSideEffects.runPlanCompletionSideEffects')(
+    function* (params: { runId: string; organizationId: string }) {
+      yield* qualityMetricsService.recordCycleMetrics({ organizationId: params.organizationId, runId: params.runId })
 
-        const recommendations = yield* feedbackLoopService
-          .analyzeOutcomes({ runId: params.runId, organizationId: params.organizationId })
+      const recommendations = yield* feedbackLoopService
+        .analyzeOutcomes({ runId: params.runId, organizationId: params.organizationId })
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new PlanCompletionSideEffectsError({ message: 'Failed to analyze plan feedback outcomes.', cause }),
+          ),
+        )
+      if (recommendations.length > 0) {
+        const run = yield* planRunService.getRunById(params.runId)
+        const specRecord = yield* planRunService.getPlanSpecById(run.planSpecId)
+        const event = yield* tryPlanCompletionPromise('Failed to create feedback analyzed plan event.', () =>
+          databaseService.create(
+            TABLES.PLAN_EVENT,
+            {
+              planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
+              runId: ensureRecordId(run.id, TABLES.PLAN_RUN),
+              eventType: 'feedback-analyzed',
+              message: `Feedback analysis produced ${recommendations.length} recommendation(s).`,
+              detail: { recommendations },
+              emittedBy: 'system',
+            },
+            PlanEventSchema,
+          ),
+        )
+        yield* planEventDeliveryService
+          .dispatchEvent(event)
           .pipe(
             Effect.mapError(
-              (cause) =>
-                new PlanCompletionSideEffectsError({ message: 'Failed to analyze plan feedback outcomes.', cause }),
-            ),
-          )
-        if (recommendations.length > 0) {
-          const run = yield* planRunService.getRunById(params.runId)
-          const specRecord = yield* planRunService.getPlanSpecById(run.planSpecId)
-          const event = yield* tryPlanCompletionPromise('Failed to create feedback analyzed plan event.', () =>
-            databaseService.create(
-              TABLES.PLAN_EVENT,
-              {
-                planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
-                runId: ensureRecordId(run.id, TABLES.PLAN_RUN),
-                eventType: 'feedback-analyzed',
-                message: `Feedback analysis produced ${recommendations.length} recommendation(s).`,
-                detail: { recommendations },
-                emittedBy: 'system',
-              },
-              PlanEventSchema,
-            ),
-          )
-          yield* planEventDeliveryService
-            .dispatchEventEffect(event)
-            .pipe(
-              Effect.mapError(
-                (error) =>
-                  new PlanCompletionSideEffectsError({
-                    message: 'Failed to dispatch feedback analyzed plan event.',
-                    cause: error,
-                  }),
-              ),
-            )
-        }
-
-        yield* institutionalMemoryService
-          .extractPatterns({ organizationId: params.organizationId, runId: params.runId })
-          .pipe(
-            Effect.mapError(
-              (cause) =>
+              (error) =>
                 new PlanCompletionSideEffectsError({
-                  message: 'Failed to extract institutional memory patterns.',
-                  cause,
+                  message: 'Failed to dispatch feedback analyzed plan event.',
+                  cause: error,
                 }),
             ),
           )
-      }),
-    )
-  }
+      }
+
+      yield* institutionalMemoryService
+        .extractPatterns({ organizationId: params.organizationId, runId: params.runId })
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new PlanCompletionSideEffectsError({
+                message: 'Failed to extract institutional memory patterns.',
+                cause,
+              }),
+          ),
+        )
+    },
+  )
 
-  function runPlanCompletionSideEffectsSafely(params: { runId: string; organizationId: string }): Promise<void> {
-    return runPromise(
-      Effect.catch(
-        tryPlanCompletionPromise('Plan completion side effects failed.', () => runPlanCompletionSideEffects(params)),
-        (error: unknown) =>
-          Effect.sync(() => {
-            aiLogger.warn`Plan completion side effects failed for run ${params.runId}: ${error instanceof Error ? error.message : String(error)}`
-          }),
+  const runPlanCompletionSideEffectsSafely = (params: { runId: string; organizationId: string }) =>
+    runPlanCompletionSideEffects(params).pipe(
+      Effect.catch((error) =>
+        Effect.sync(() => {
+          aiLogger.warn`Plan completion side effects failed for run ${params.runId}: ${error instanceof Error ? error.message : String(error)}`
+        }),
       ),
     )
-  }
 
   return { runPlanNodeCompletionSideEffects, runPlanCompletionSideEffectsSafely }
 }

package/src/services/plan/plan-cycle.service.ts

@@ -3,7 +3,6 @@ import type {
   CarryForwardPolicy,
   CycleSchedule,
   PlanArtifactRecord,
-  PlanCycleRecord,
   PlanDraft,
   PlanRunStatus,
   PlanScheduleSpec,
@@ -15,7 +14,6 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { runPromise } from '../../effect/runtime'
 import { DatabaseServiceTag } from '../../effect/services'
 import { nowDate, nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
 import type { makePlanSchedulerService } from './plan-scheduler.service'
@@ -336,24 +334,8 @@ export function makePlanCycleService(deps: PlanCycleDeps) {
 
   return {
     cycleScheduleToSpec,
-    createCycle(params: {
-      organizationId: RecordIdInput
-      threadId: RecordIdInput
-      templateId: RecordIdInput
-      name: string
-      schedule: CycleSchedule
-      carryForwardPolicy?: CarryForwardPolicy
-      leadAgentId: string
-    }): Promise<PlanCycleRecord> {
-      return runPromise(createCycleEffect(params))
-    },
-    createCycleEffect,
-
-    advanceCycle(cycleId: RecordIdInput): Promise<void> {
-      return runPromise(advanceCycleEffect(cycleId))
-    },
-    advanceCycleEffect,
-
+    createCycle: createCycleEffect,
+    advanceCycle: advanceCycleEffect,
     buildCarryForwardDraft(params: {
       template: PlanTemplateRecord
       previousRunArtifacts: PlanArtifactRecord[]
@@ -361,31 +343,11 @@ export function makePlanCycleService(deps: PlanCycleDeps) {
     }): PlanDraft {
       return buildCarryForwardDraft(params)
     },
-
-    cancelCycle(cycleId: RecordIdInput): Promise<void> {
-      return runPromise(cancelCycleEffect(cycleId))
-    },
-    cancelCycleEffect,
-
-    pauseCycle(cycleId: RecordIdInput): Promise<void> {
-      return runPromise(pauseCycleEffect(cycleId))
-    },
-    pauseCycleEffect,
-
-    resumeCycle(cycleId: RecordIdInput): Promise<void> {
-      return runPromise(resumeCycleEffect(cycleId))
-    },
-    resumeCycleEffect,
-
-    listCycles(threadId: RecordIdInput): Promise<PlanCycleRecord[]> {
-      return runPromise(listCyclesEffect(threadId))
-    },
-    listCyclesEffect,
-
-    getCycle(cycleId: RecordIdInput): Promise<PlanCycleRecord | null> {
-      return runPromise(getCycleEffect(cycleId))
-    },
-    getCycleEffect,
+    cancelCycle: cancelCycleEffect,
+    pauseCycle: pauseCycleEffect,
+    resumeCycle: resumeCycleEffect,
+    listCycles: listCyclesEffect,
+    getCycle: getCycleEffect,
   }
 }
 

package/src/services/plan/plan-deadline.service.ts

@@ -17,6 +17,8 @@ import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { DatabaseServiceTag } from '../../effect/services'
+import type { PlanSchedulerQueueRuntime } from '../../queues/plan-scheduler.queue'
+import { LotaQueuesServiceTag } from '../../queues/queues.service'
 import { nowDate, unsafeDateFrom } from '../../utils/date-time'
 import type { makePlanEventDeliveryService } from './plan-event-delivery.service'
 import { PlanEventDeliveryServiceTag } from './plan-event-delivery.service'
@@ -86,6 +88,7 @@ interface PlanDeadlineDeps {
   planExecutorService: ReturnType<typeof makePlanExecutorService>
   planEventDeliveryService: ReturnType<typeof makePlanEventDeliveryService>
   planRunService: ReturnType<typeof makePlanRunService>
+  planSchedulerQueue: PlanSchedulerQueueRuntime
 }
 
 class PlanDeadlineError extends Schema.TaggedErrorClass<PlanDeadlineError>()('PlanDeadlineError', {
@@ -94,12 +97,12 @@ class PlanDeadlineError extends Schema.TaggedErrorClass<PlanDeadlineError>()('Pl
 }) {}
 
 export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
-  const { db, planEventDeliveryService, planExecutorService, planRunService } = deps
+  const { db, planEventDeliveryService, planExecutorService, planRunService, planSchedulerQueue } = deps
   const effectTryPromise = makeEffectTryPromiseWithMessage(
     (message, cause) => new PlanDeadlineError({ message, cause }),
   )
-  const loadPlanSchedulerQueue = () =>
-    effectTryPromise(() => import('../../queues/plan-scheduler.queue'), 'Failed to load plan scheduler queue module.')
+  const loadPlanSchedulerQueue = (): Effect.Effect<PlanSchedulerQueueRuntime, PlanDeadlineError> =>
+    Effect.succeed(planSchedulerQueue)
 
   function loadNodeSpec(nodeRun: PlanNodeRunRecord): Effect.Effect<PlanNodeSpecRecord | null, PlanDeadlineError> {
     return db
@@ -219,7 +222,7 @@ export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
       'Failed to create deadline event.',
     )
     yield* planEventDeliveryService
-      .dispatchEventEffect(PlanEventSchema.parse(event))
+      .dispatchEvent(PlanEventSchema.parse(event))
       .pipe(
         Effect.mapError(
           (error) => new PlanDeadlineError({ message: 'Failed to dispatch deadline event.', cause: error }),
@@ -253,18 +256,19 @@ export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
         ),
     ])
     const blockNode = (message: string): Effect.Effect<void, PlanDeadlineError> =>
-      effectTryPromise(
-        () =>
-          planExecutorService.blockNodeOnDispatchFailure({
-            threadId: params.threadId,
-            runId: runIdStr,
-            nodeId: params.nodeId,
-            emittedBy: params.emittedBy,
-            message,
-            failureClass: 'timeout_exceeded',
-          }),
-        `Failed to ${message.toLowerCase()}.`,
-      )
+      planExecutorService
+        .blockNodeOnDispatchFailure({
+          threadId: params.threadId,
+          runId: runIdStr,
+          nodeId: params.nodeId,
+          emittedBy: params.emittedBy,
+          message,
+          failureClass: 'timeout_exceeded',
+        })
+        .pipe(
+          Effect.asVoid,
+          Effect.mapError((cause) => new PlanDeadlineError({ message: `Failed to ${message.toLowerCase()}.`, cause })),
+        )
 
     switch (params.action) {
       case 'notify':
@@ -528,6 +532,13 @@ export const PlanDeadlineServiceLive = Layer.effect(
     const planExecutorService = yield* PlanExecutorServiceTag
     const planEventDeliveryService = yield* PlanEventDeliveryServiceTag
     const planRunService = yield* PlanRunServiceTag
-    return makePlanDeadlineService({ db, planExecutorService, planEventDeliveryService, planRunService })
+    const queues = yield* LotaQueuesServiceTag
+    return makePlanDeadlineService({
+      db,
+      planExecutorService,
+      planEventDeliveryService,
+      planRunService,
+      planSchedulerQueue: queues.planScheduler,
+    })
   }),
 )

package/src/services/plan/plan-event-delivery.service.ts

@@ -1,15 +1,21 @@
 import type { PlanEventRecord } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
 
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { runPromise } from '../../effect/runtime'
-import { DatabaseServiceTag, RedisServiceTag } from '../../effect/services'
+import {
+  AgentConfigServiceTag,
+  DatabaseServiceTag,
+  RedisServiceTag,
+  RuntimeAdaptersServiceTag,
+} from '../../effect/services'
+import type { PlanAgentHeartbeatQueueRuntime } from '../../queues/plan-agent-heartbeat.queue'
+import { LotaQueuesServiceTag } from '../../queues/queues.service'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { resolvePlanNodeExecutionVisibility } from '../../runtime/execution-plan-visibility'
-import { getRuntimeAdapters } from '../../runtime/runtime-extensions'
-import type { LotaRuntimePlanEventEnvelope } from '../../runtime/runtime-extensions'
+import type { LotaRuntimeAdapters, LotaRuntimePlanEventEnvelope } from '../../runtime/runtime-extensions'
 import { getErrorMessage } from '../../utils/errors'
 import { ThreadSchema } from '../thread/thread.types'
 import type { makeUserService } from '../user.service'
@@ -28,19 +34,22 @@ function buildDeliveredKey(eventId: string): string {
   return `plan-event:delivered:${eventId}`
 }
 
-function dispatchAdapterEvent(envelope: LotaRuntimePlanEventEnvelope) {
-  const adapter = getRuntimeAdapters().planEventAdapter
-  if (!adapter) {
-    return Effect.void
-  }
+function dispatchAdapterEvent(runtimeAdapters: LotaRuntimeAdapters, envelope: LotaRuntimePlanEventEnvelope) {
+  return Effect.gen(function* () {
+    const adapter = runtimeAdapters.planEventAdapter
+    if (!adapter) {
+      return
+    }
 
-  return Effect.tryPromise({
-    try: () => adapter.onPlanEvent(envelope),
-    catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    yield* Effect.tryPromise({
+      try: () => adapter.onPlanEvent(envelope),
+      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    })
   })
 }
 
 function resolveWakeTarget(
+  agentConfig: ResolvedAgentConfig,
   envelope: LotaRuntimePlanEventEnvelope,
   nodeSpecsById: Map<string, NonNullable<LotaRuntimePlanEventEnvelope['nodeSpec']>>,
 ): { nodeId: string; agentId: string; reason: string } | null {
@@ -55,7 +64,7 @@ function resolveWakeTarget(
     return null
   }
 
-  const isVisible = resolvePlanNodeExecutionVisibility(envelope.spec, effectiveNodeSpec) === 'visible'
+  const isVisible = resolvePlanNodeExecutionVisibility(agentConfig, envelope.spec, effectiveNodeSpec) === 'visible'
   if (!isVisible) {
     return null
   }
@@ -76,22 +85,20 @@ function resolveWakeTarget(
 }
 
 function enqueueWakeIfNeeded(
+  agentConfig: ResolvedAgentConfig,
   envelope: LotaRuntimePlanEventEnvelope,
   nodeSpecsById: Map<string, NonNullable<LotaRuntimePlanEventEnvelope['nodeSpec']>>,
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime,
 ) {
   return Effect.gen(function* () {
-    const wakeTarget = resolveWakeTarget(envelope, nodeSpecsById)
+    const wakeTarget = resolveWakeTarget(agentConfig, envelope, nodeSpecsById)
     if (!wakeTarget) {
       return
     }
 
-    const { enqueuePlanAgentHeartbeatWake } = yield* Effect.tryPromise({
-      try: () => import('../../queues/plan-agent-heartbeat.queue'),
-      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
-    })
     yield* Effect.tryPromise({
       try: () =>
-        enqueuePlanAgentHeartbeatWake({
+        planAgentHeartbeatQueue.enqueuePlanAgentHeartbeatWake({
           organizationId: envelope.organizationId,
           threadId: envelope.threadId,
           runId: envelope.runId,
@@ -105,14 +112,17 @@ function enqueueWakeIfNeeded(
 }
 
 interface PlanEventDeliveryDeps {
+  agentConfig: ResolvedAgentConfig
   db: SurrealDBService
   redis: RedisConnectionManager
   planRunService: ReturnType<typeof makePlanRunService>
   userService: ReturnType<typeof makeUserService>
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime
+  runtimeAdapters: LotaRuntimeAdapters
 }
 
 export function makePlanEventDeliveryService(deps: PlanEventDeliveryDeps) {
-  const { db, redis, planRunService, userService } = deps
+  const { agentConfig, db, redis, planRunService, userService, planAgentHeartbeatQueue, runtimeAdapters } = deps
 
   function deliverEvent(event: PlanEventRecord) {
     return Effect.gen(function* () {
@@ -182,8 +192,8 @@ export function makePlanEventDeliveryService(deps: PlanEventDeliveryDeps) {
         ...(userName ? { userName } : {}),
       }
 
-      yield* dispatchAdapterEvent(envelope)
-      yield* enqueueWakeIfNeeded(envelope, nodeSpecsById)
+      yield* dispatchAdapterEvent(runtimeAdapters, envelope)
+      yield* enqueueWakeIfNeeded(agentConfig, envelope, nodeSpecsById, planAgentHeartbeatQueue)
     })
   }
 
@@ -229,23 +239,9 @@ export function makePlanEventDeliveryService(deps: PlanEventDeliveryDeps) {
   })
 
   return {
-    dispatchEvents(events: PlanEventRecord[]): Promise<void> {
-      return runPromise(dispatchEventsEffect(events))
-    },
-
-    dispatchEventsEffect,
-
-    dispatchEvent(event: PlanEventRecord): Promise<void> {
-      return runPromise(dispatchEventEffect(event))
-    },
-
-    dispatchEventEffect,
-
-    dispatchUndeliveredEvents(runId: string, options?: { limit?: number }): Promise<void> {
-      return runPromise(dispatchUndeliveredEventsEffect(runId, options))
-    },
-
-    dispatchUndeliveredEventsEffect,
+    dispatchEvents: dispatchEventsEffect,
+    dispatchEvent: dispatchEventEffect,
+    dispatchUndeliveredEvents: dispatchUndeliveredEventsEffect,
   }
 }
 
@@ -257,10 +253,21 @@ export class PlanEventDeliveryServiceTag extends Context.Service<
 export const PlanEventDeliveryServiceLive = Layer.effect(
   PlanEventDeliveryServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const db = yield* DatabaseServiceTag
     const redis = yield* RedisServiceTag
     const planRunService = yield* PlanRunServiceTag
     const userService = yield* UserServiceTag
-    return makePlanEventDeliveryService({ db, redis, planRunService, userService })
+    const queues = yield* LotaQueuesServiceTag
+    const runtimeAdapters = yield* RuntimeAdaptersServiceTag
+    return makePlanEventDeliveryService({
+      agentConfig,
+      db,
+      redis,
+      planRunService,
+      userService,
+      planAgentHeartbeatQueue: queues.planAgentHeartbeat,
+      runtimeAdapters,
+    })
   }),
 )

package/src/services/plan/plan-executor-context.ts

@@ -1,6 +1,7 @@
 import type { Context } from 'effect'
 
 import type { SurrealDBService } from '../../db/service'
+import type { DelayedNodePromotionQueueRuntime } from '../../queues/delayed-node-promotion.queue'
 import type { makeGeneratedDocumentStorageService } from '../../storage/generated-document-storage.service'
 import type { makeArtifactService } from '../artifact.service'
 import type { FeedbackLoopServiceTag } from '../feedback-loop.service'
@@ -32,4 +33,5 @@ export interface PlanExecutorContext {
   planValidatorService: ReturnType<typeof makePlanValidatorService>
   qualityMetricsService: Context.Service.Shape<typeof QualityMetricsServiceTag>
   planCompletionSideEffects: ReturnType<typeof makePlanCompletionSideEffects>
+  delayedNodePromotionQueue: DelayedNodePromotionQueueRuntime
 }