@lota-sdk/core 0.4.10 → 0.4.11

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

@@ -10,6 +10,7 @@ import type {
 import { PlanDraftSchema, PlanRunSchema, PlanSpecSchema } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer, Match } from 'effect'
 import { RecordId } from 'surrealdb'
+import type { z } from 'zod'
 
 import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
@@ -84,6 +85,17 @@ const effectTryPromise = makeEffectTryPromiseWithMessage(
   (message, cause) => new ExecutionPlanServiceError({ message, cause }),
 )
 
+function parseRowEffect<TSchema extends z.ZodTypeAny>(
+  schema: TSchema,
+  value: unknown,
+  label: string,
+): Effect.Effect<z.infer<TSchema>, ExecutionPlanServiceError> {
+  return Effect.try({
+    try: () => schema.parse(value) as z.infer<TSchema>,
+    catch: (cause) => new ExecutionPlanServiceError({ message: `Failed to parse ${label}.`, cause }),
+  })
+}
+
 function toSerializablePlanEffect(
   deps: ExecutionPlanDeps,
   run: PlanRunRecord,
@@ -285,7 +297,8 @@ function createPlanEffect(
     const databaseService = deps.db
     const requireApproval =
       params.requireApproval ?? hasCrossThreadSourceContext(params.sourceThreadId, params.threadId)
-    const preparedDraft = deps.planBuilder.prepareDraft(PlanDraftSchema.parse(params.input))
+    const parsedDraft = yield* parseRowEffect(PlanDraftSchema, params.input, 'plan draft input')
+    const preparedDraft = deps.planBuilder.prepareDraft(parsedDraft)
     const validation = deps.planValidator.validateDraft(preparedDraft)
     if (validation.blocking.length > 0) {
       return yield* new BadRequestError({
@@ -319,7 +332,7 @@ function createPlanEffect(
                 .output('after'),
             'Failed to create execution plan spec.',
           )
-          const spec = PlanSpecSchema.parse(createdSpec)
+          const spec = yield* parseRowEffect(PlanSpecSchema, createdSpec, 'created plan spec')
 
           yield* effectTryPromise(
             () =>
@@ -391,7 +404,8 @@ function replacePlanEffect(
 
     const activeSpec = yield* deps.planRun.getPlanSpecById(activeRun.planSpecId)
     const { runId: _runId, reason: _reason, requireApproval: requestedRequireApproval, ...draftInput } = params.input
-    const preparedDraft = deps.planBuilder.prepareDraft(PlanDraftSchema.parse(draftInput))
+    const parsedDraft = yield* parseRowEffect(PlanDraftSchema, draftInput, 'plan draft replacement input')
+    const preparedDraft = deps.planBuilder.prepareDraft(parsedDraft)
     const validation = deps.planValidator.validateDraft(preparedDraft)
     if (validation.blocking.length > 0) {
       return yield* new BadRequestError({
@@ -419,7 +433,7 @@ function replacePlanEffect(
                 .output('after'),
             'Failed to update superseded execution plan spec.',
           )
-          const supersededSpec = PlanSpecSchema.parse(updatedSpec)
+          const supersededSpec = yield* parseRowEffect(PlanSpecSchema, updatedSpec, 'superseded plan spec')
 
           const updatedRun = yield* effectTryPromise(
             () =>
@@ -437,7 +451,7 @@ function replacePlanEffect(
                 .output('after'),
             'Failed to abort previous execution run.',
           )
-          const abortedRun = PlanRunSchema.parse(updatedRun)
+          const abortedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'aborted plan run')
 
           const createdSpec = yield* effectTryPromise(
             () =>
@@ -456,7 +470,7 @@ function replacePlanEffect(
                 .output('after'),
             'Failed to create replacement execution plan spec.',
           )
-          const spec = PlanSpecSchema.parse(createdSpec)
+          const spec = yield* parseRowEffect(PlanSpecSchema, createdSpec, 'replacement plan spec')
 
           yield* effectTryPromise(
             () =>
@@ -523,18 +537,19 @@ function submitPlanTurnResultEffect(
   },
 ) {
   return Effect.gen(function* () {
-    const result = yield* Effect.tryPromise({
-      try: () =>
-        deps.planExecutor.submitNodeResult({
-          threadId: params.threadId,
-          runId: params.runId,
-          nodeId: params.nodeId,
-          emittedBy: params.emittedBy,
-          result: params.input,
-        }),
-      catch: (cause) =>
-        new ExecutionPlanServiceError({ message: 'Failed to submit execution plan node result.', cause }),
-    })
+    const result = yield* deps.planExecutor
+      .submitNodeResult({
+        threadId: params.threadId,
+        runId: params.runId,
+        nodeId: params.nodeId,
+        emittedBy: params.emittedBy,
+        result: params.input,
+      })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit execution plan node result.', cause }),
+        ),
+      )
 
     const plan = yield* finalizePlanSnapshotEffect(deps, { runId: params.runId, emittedBy: params.emittedBy })
     return buildExecutionPlanToolResult({
@@ -550,15 +565,13 @@ function resumeRunEffect(
   params: { threadId: RecordIdInput; emittedBy: string; input: { runId: string } },
 ) {
   return Effect.gen(function* () {
-    const result = yield* Effect.tryPromise({
-      try: () =>
-        deps.planExecutor.resumeRun({
-          threadId: params.threadId,
-          runId: params.input.runId,
-          emittedBy: params.emittedBy,
-        }),
-      catch: (cause) => new ExecutionPlanServiceError({ message: 'Failed to resume execution run.', cause }),
-    })
+    const result = yield* deps.planExecutor
+      .resumeRun({ threadId: params.threadId, runId: params.input.runId, emittedBy: params.emittedBy })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ExecutionPlanServiceError({ message: 'Failed to resume execution run.', cause }),
+        ),
+      )
 
     const plan = yield* finalizePlanSnapshotEffect(deps, { runId: params.input.runId, emittedBy: params.emittedBy })
     return buildExecutionPlanToolResult({
@@ -609,7 +622,7 @@ function approvePlanEffect(
                 .output('after'),
             'Failed to activate execution run.',
           )
-          const activatedRun = PlanRunSchema.parse(updatedRun)
+          const activatedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'activated plan run')
 
           const synced = yield* effectTryPromise(
             () =>
@@ -729,7 +742,7 @@ function rejectPlanEffect(
                 .output('after'),
             'Failed to abort execution run.',
           )
-          const rejectedRun = PlanRunSchema.parse(updatedRun)
+          const rejectedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'rejected plan run')
 
           yield* emitEvent({
             tx,
@@ -778,17 +791,19 @@ function respondToApprovalEffect(
     const run = yield* deps.planRun.getActiveRunRecord(params.threadId)
     if (!run) return null
 
-    const plan = yield* Effect.tryPromise({
-      try: () =>
-        deps.planExecutor.submitHumanNodeResponse({
-          threadId: params.threadId,
-          approvalId: params.input.approvalId,
-          respondedBy: params.emittedBy,
-          response: params.input.response,
-          approvalMessageId: params.input.approvalMessageId,
-        }),
-      catch: (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit human approval response.', cause }),
-    })
+    const plan = yield* deps.planExecutor
+      .submitHumanNodeResponse({
+        threadId: params.threadId,
+        approvalId: params.input.approvalId,
+        respondedBy: params.emittedBy,
+        response: params.input.response,
+        approvalMessageId: params.input.approvalMessageId,
+      })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit human approval response.', cause }),
+        ),
+      )
     if (!plan) return null
 
     return yield* finalizePlanSnapshotEffect(deps, { runId: run.id, emittedBy: params.emittedBy })
@@ -825,16 +840,18 @@ function applyHumanInputFromUserMessageEffect(
     )
     if (!response) return null
 
-    const plan = yield* Effect.tryPromise({
-      try: () =>
-        deps.planExecutor.submitHumanNodeResponse({
-          threadId: params.threadId,
-          respondedBy: params.respondedBy,
-          response,
-          approvalMessageId: params.message.id,
-        }),
-      catch: (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit human node response.', cause }),
-    })
+    const plan = yield* deps.planExecutor
+      .submitHumanNodeResponse({
+        threadId: params.threadId,
+        respondedBy: params.respondedBy,
+        response,
+        approvalMessageId: params.message.id,
+      })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit human node response.', cause }),
+        ),
+      )
     if (!plan) return null
 
     return yield* finalizePlanSnapshotEffect(deps, { runId: run.id, emittedBy: params.respondedBy })

package/src/services/global-orchestrator.service.ts

@@ -9,7 +9,10 @@ import type {
 } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 
-import { runPromise } from '../effect/runtime'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { AgentConfigServiceTag } from '../effect/services'
+import type { PlanAgentHeartbeatQueueRuntime } from '../queues/plan-agent-heartbeat.queue'
+import { LotaQueuesServiceTag } from '../queues/queues.service'
 import { routeGraphFullEffect } from './graph-full-routing'
 import type { OwnershipDispatcherService } from './ownership-dispatcher.service'
 import { OwnershipDispatcherServiceTag } from './ownership-dispatcher.service'
@@ -55,9 +58,11 @@ function decideRerouteAction(params: {
 }
 
 interface GlobalOrchestratorDeps {
+  agentConfig: ResolvedAgentConfig
   ownershipDispatcherService: Pick<OwnershipDispatcherService, 'dispatchReadyNode'>
   planExecutorService: ReturnType<typeof makePlanExecutorService>
   planRunService: ReturnType<typeof makePlanRunService>
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime
 }
 
 type DispatchReadyNodeParams = {
@@ -78,9 +83,11 @@ export function makeGlobalOrchestratorService(deps: GlobalOrchestratorDeps) {
     decideRerouteAction,
     routeGraphFull: (params: { threadId: string; runId: string }) =>
       routeGraphFullEffect(params, {
+        agentConfig: deps.agentConfig,
         dispatchReadyNode,
         planExecutorService: deps.planExecutorService,
         planRunService: deps.planRunService,
+        planAgentHeartbeatQueue: deps.planAgentHeartbeatQueue,
       }),
   }
 }
@@ -93,21 +100,25 @@ export class GlobalOrchestratorServiceTag extends Context.Service<
 export const GlobalOrchestratorServiceLive = Layer.effect(
   GlobalOrchestratorServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const ownershipDispatcherService = yield* OwnershipDispatcherServiceTag
     const planExecutorService = yield* PlanExecutorServiceTag
     const planRunService = yield* PlanRunServiceTag
-    return makeGlobalOrchestratorService({ ownershipDispatcherService, planExecutorService, planRunService })
+    const queues = yield* LotaQueuesServiceTag
+    return makeGlobalOrchestratorService({
+      agentConfig,
+      ownershipDispatcherService,
+      planExecutorService,
+      planRunService,
+      planAgentHeartbeatQueue: queues.planAgentHeartbeat,
+    })
   }),
 )
 
-const routeGraphFullWithRuntime = Effect.fn('GlobalOrchestrator.routeGraphFullWithRuntime')(function* (params: {
+export const routeGraphFull = Effect.fn('GlobalOrchestrator.routeGraphFull')(function* (params: {
   threadId: string
   runId: string
 }) {
   const globalOrchestratorService = yield* GlobalOrchestratorServiceTag
   return yield* globalOrchestratorService.routeGraphFull(params)
 })
-
-export function routeGraphFull(params: { threadId: string; runId: string }): Promise<void> {
-  return runPromise(routeGraphFullWithRuntime(params))
-}

package/src/services/graph-full-routing.ts

@@ -9,11 +9,13 @@ import type {
 } from '@lota-sdk/shared'
 import { Effect } from 'effect'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { BadRequestError, ServiceError } from '../effect/errors'
 import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import type { PlanAgentHeartbeatQueueRuntime } from '../queues/plan-agent-heartbeat.queue'
 import { shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
 import type { makePlanExecutorService } from './plan/plan-executor.service'
 import type { makePlanRunService } from './plan/plan-run.service'
@@ -34,6 +36,7 @@ function formatDispatchError(error: unknown): string {
 const STABLE_RUN_STATUSES = new Set(['pending-approval', 'awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
 
 interface GraphFullRoutingDeps<E = never> {
+  agentConfig: ResolvedAgentConfig
   dispatchReadyNode(params: {
     run: PlanRunRecord
     nodeSpecRecord: PlanNodeSpecRecord
@@ -43,6 +46,7 @@ interface GraphFullRoutingDeps<E = never> {
   }): Effect.Effect<PlanNodeResultSubmission, E, never>
   planExecutorService: ReturnType<typeof makePlanExecutorService>
   planRunService: ReturnType<typeof makePlanRunService>
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime
 }
 
 export function routeGraphFullEffect<E>(params: { threadId: string; runId: string }, deps: GraphFullRoutingDeps<E>) {
@@ -68,11 +72,11 @@ export function routeGraphFullEffect<E>(params: { threadId: string; runId: strin
 
       const silentNodes = readyNodes.filter((nr: PlanNodeRunRecord) => {
         const ns = nodeSpecs.find((s: PlanNodeSpecRecord) => s.nodeId === nr.nodeId)
-        return ns && !shouldPlanNodeUseVisibleTurn(spec, ns)
+        return ns && !shouldPlanNodeUseVisibleTurn(deps.agentConfig, spec, ns)
       })
       const visibleNodes = readyNodes.filter((nr: PlanNodeRunRecord) => {
         const ns = nodeSpecs.find((s: PlanNodeSpecRecord) => s.nodeId === nr.nodeId)
-        return ns && shouldPlanNodeUseVisibleTurn(spec, ns)
+        return ns && shouldPlanNodeUseVisibleTurn(deps.agentConfig, spec, ns)
       })
 
       yield* Effect.forEach(
@@ -86,10 +90,7 @@ export function routeGraphFullEffect<E>(params: { threadId: string; runId: strin
       )
 
       if (visibleNodes.length > 0) {
-        const { enqueuePlanAgentHeartbeatWake } = yield* tryGraphFullPromise(
-          () => import('../queues/plan-agent-heartbeat.queue'),
-          'Failed to load plan agent heartbeat queue module.',
-        )
+        const enqueuePlanAgentHeartbeatWake = deps.planAgentHeartbeatQueue.enqueuePlanAgentHeartbeatWake
         const updatedRunForWake = yield* deps.planRunService.getRunById(params.runId)
         yield* Effect.forEach(
           visibleNodes,

package/src/services/memory/memory-conversation.ts

@@ -1,4 +1,5 @@
-import { getAgentRoster } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
+import { isAgentName } from '../../config/agent-defaults'
 import type { ExtractedFact, Message } from '../../db/memory-types'
 import { sanitizeAgentOutputForMemory } from '../../runtime/llm-content'
 import { compactWhitespace, truncateText } from '../../utils/string'
@@ -9,8 +10,8 @@ const MAX_CONVERSATION_MEMORY_BLOCK_CHARS = 2_000
 const MAX_CONVERSATION_ATTACHMENT_CONTEXT_CHARS = 6_000
 const LOW_VALUE_MEMORY_IMPORTANCE_THRESHOLD = 0.45
 
-export const isRoutableAgentName = (value?: string): value is string =>
-  Boolean(value && getAgentRoster().includes(value))
+export const isRoutableAgentName = (agentConfig: ResolvedAgentConfig, value?: string): value is string =>
+  isAgentName(agentConfig, value)
 
 function normalizeConversationText(value: string, maxChars: number): string {
   const normalized = compactWhitespace(value)
@@ -18,7 +19,11 @@ function normalizeConversationText(value: string, maxChars: number): string {
   return truncateText(normalized, maxChars)
 }
 
-export function resolveAgentScopeNames(agentName?: string, agentNames: string[] = []): string[] {
+export function resolveAgentScopeNames(
+  agentConfig: ResolvedAgentConfig,
+  agentName?: string,
+  agentNames: string[] = [],
+): string[] {
   const unique = new Set<string>()
   if (typeof agentName === 'string' && agentName.trim()) {
     unique.add(agentName.trim())
@@ -29,7 +34,7 @@ export function resolveAgentScopeNames(agentName?: string, agentNames: string[]
     if (!normalized) continue
     unique.add(normalized)
   }
-  return [...unique].filter((name) => isRoutableAgentName(name))
+  return [...unique].filter((name) => isRoutableAgentName(agentConfig, name))
 }
 
 export function buildConversationMessages(params: {

package/src/services/memory/memory.service.ts

@@ -1,5 +1,6 @@
 import { Context, Schema, Effect, Layer } from 'effect'
 
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { Memory } from '../../db/memory'
 import { isUniqueIndexConflict } from '../../db/memory-store.helpers'
@@ -12,7 +13,7 @@ import type {
   MemoryType,
   RelationType,
 } from '../../db/memory-types'
-import { DatabaseServiceTag, RuntimeConfigServiceTag } from '../../effect/services'
+import { AgentConfigServiceTag, DatabaseServiceTag, RuntimeConfigServiceTag } from '../../effect/services'
 import { withOrgMemoryLockEffect } from '../../redis/org-memory-lock'
 import type { HelperModelRuntime } from '../../runtime/helper-model'
 import { HelperModelTag } from '../../runtime/helper-model'
@@ -177,10 +178,11 @@ interface MemoryServiceDeps {
   rerankService: ReturnType<typeof makeRerankService>
   helperModelRuntime: HelperModelRuntime
   orgMemoryCache: OrgMemoryCache
+  agentConfig: ResolvedAgentConfig
 }
 
 export function createMemoryService(deps: MemoryServiceDeps) {
-  const { runtimeConfig, helperModelRuntime, orgMemoryCache } = deps
+  const { runtimeConfig, helperModelRuntime, orgMemoryCache, agentConfig } = deps
   const resolveRerankService = () => deps.rerankService
   const service = {
     searchOrganizationMemories: Effect.fn('MemoryService.searchOrganizationMemories')(function* (
@@ -251,7 +253,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       agentName: string,
       query: string,
     ) {
-      if (!isRoutableAgentName(agentName)) {
+      if (!isRoutableAgentName(agentConfig, agentName)) {
         aiLogger.debug`Agent memory search skipped - invalid agentName: ${agentName}`
         return 'No stored memories.'
       }
@@ -329,7 +331,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         },
       ]
 
-      if (isRoutableAgentName(agentName)) {
+      if (isRoutableAgentName(agentConfig, agentName)) {
         const agentScoped = yield* agentScopeId(orgId, agentName)
         retrievalTasks.push({
           scopeTag: `agent:${agentName}`,
@@ -449,7 +451,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       metadata?: Record<string, unknown>
       importance?: number
     }) {
-      if (!isRoutableAgentName(agentName)) {
+      if (!isRoutableAgentName(agentConfig, agentName)) {
         return Effect.fail(new InvalidAgentNameError({ agentName }))
       }
 
@@ -536,7 +538,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         },
       ]
 
-      for (const scopedAgentName of resolveAgentScopeNames(undefined, params.agentNames ?? [])) {
+      for (const scopedAgentName of resolveAgentScopeNames(agentConfig, undefined, params.agentNames ?? [])) {
         const agentScopedValue = yield* agentScopeId(params.orgId, scopedAgentName)
         scopes.push({
           scopeId: agentScopedValue,
@@ -619,7 +621,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         },
       ]
 
-      for (const scopedAgentName of resolveAgentScopeNames(agentName, agentNames)) {
+      for (const scopedAgentName of resolveAgentScopeNames(agentConfig, agentName, agentNames)) {
         const agentId = yield* agentScopeId(orgId, scopedAgentName)
         scopes.push({
           scopeId: agentId,
@@ -668,7 +670,8 @@ export const MemoryServiceLive = Layer.effect(
     const rerankService = yield* RerankServiceTag
     const helperModelRuntime = yield* HelperModelTag
     const background = yield* BackgroundWorkService
+    const agentConfig = yield* AgentConfigServiceTag
     const orgMemoryCache = yield* makeOrgMemoryCache({ db, runtimeConfig, helperModelRuntime, background })
-    return createMemoryService({ runtimeConfig, rerankService, helperModelRuntime, orgMemoryCache })
+    return createMemoryService({ runtimeConfig, rerankService, helperModelRuntime, orgMemoryCache, agentConfig })
   }),
 )

package/src/services/ownership-dispatcher.service.ts

@@ -25,6 +25,8 @@ import { TABLES } from '../db/tables'
 import { BadRequestError, ConfigurationError, DatabaseError, ServiceError } from '../effect/errors'
 import { isPromiseLike, makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { AgentConfigServiceTag, DatabaseServiceTag, RuntimeAdaptersServiceTag } from '../effect/services'
+import type { PlanAgentHeartbeatQueueRuntime } from '../queues/plan-agent-heartbeat.queue'
+import { LotaQueuesServiceTag } from '../queues/queues.service'
 import { resolvePlanNodeExecutionVisibility, shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
 import type { LotaRuntimeAdapters } from '../runtime/runtime-extensions'
 import type { makeAgentExecutorService } from './agent-executor.service'
@@ -60,6 +62,7 @@ interface OwnershipDispatcherDeps {
   skillResolver: NoContextService<Pick<SkillResolverService, 'resolve'>>
   systemExecutor: NoContextService<Pick<ReturnType<typeof makeSystemExecutorService>, 'executeNode' | 'validateOwner'>>
   user: NoContextService<Pick<ReturnType<typeof makeUserService>, 'getUser'>>
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime
 }
 
 type NoContextService<TService> = {
@@ -387,9 +390,11 @@ const dispatchRunToStableBoundaryEffect = (
         yield* routeGraphFullEffect(
           { threadId: recordIdToString(run.threadId, TABLES.THREAD), runId: recordIdToString(run.id, TABLES.PLAN_RUN) },
           {
+            agentConfig: deps.agentConfig,
             dispatchReadyNode: dispatchReadyNodeForGraphFull,
             planExecutorService: deps.planExecutor,
             planRunService: deps.planRun,
+            planAgentHeartbeatQueue: deps.planAgentHeartbeatQueue,
           },
         ).pipe(
           Effect.mapError(
@@ -427,7 +432,7 @@ const dispatchRunToStableBoundaryEffect = (
       if (nodeRun.status !== 'running') {
         return yield* serializeRunEffect(deps, run.id)
       }
-      if (shouldPlanNodeUseVisibleTurn(spec, nodeSpecRecord)) {
+      if (shouldPlanNodeUseVisibleTurn(deps.agentConfig, spec, nodeSpecRecord)) {
         return yield* serializeRunEffect(deps, run.id)
       }
 
@@ -503,7 +508,7 @@ const dispatchReadyNodeEffect = (
   },
 ) =>
   Effect.gen(function* () {
-    if (shouldPlanNodeUseVisibleTurn(params.spec, params.nodeSpecRecord)) {
+    if (shouldPlanNodeUseVisibleTurn(deps.agentConfig, params.spec, params.nodeSpecRecord)) {
       return yield* new BadRequestError({
         message: `Node "${params.nodeSpecRecord.nodeId}" requires a visible plan turn and cannot be silently dispatched.`,
       })
@@ -531,8 +536,12 @@ const dispatchReadyNodeEffect = (
     })
   })
 
-function resolveExecutionVisibility(params: { spec: PlanSpecRecord; nodeSpecRecord: PlanNodeSpecRecord }) {
-  return resolvePlanNodeExecutionVisibility(params.spec, params.nodeSpecRecord)
+function resolveExecutionVisibility(params: {
+  agentConfig: ResolvedAgentConfig
+  spec: PlanSpecRecord
+  nodeSpecRecord: PlanNodeSpecRecord
+}) {
+  return resolvePlanNodeExecutionVisibility(params.agentConfig, params.spec, params.nodeSpecRecord)
 }
 
 export function makeOwnershipDispatcherService(deps: OwnershipDispatcherDeps) {
@@ -553,7 +562,7 @@ export function makeOwnershipDispatcherService(deps: OwnershipDispatcherDeps) {
       return dispatchReadyNodeEffect(deps, params)
     },
     resolveExecutionVisibility(params: { spec: PlanSpecRecord; nodeSpecRecord: PlanNodeSpecRecord }) {
-      return resolveExecutionVisibility(params)
+      return resolveExecutionVisibility({ ...params, agentConfig: deps.agentConfig })
     },
     dispatchNode(params: {
       nodeSpec: PlanNodeSpec
@@ -593,6 +602,7 @@ export const OwnershipDispatcherServiceLive = Layer.effect(
     const skillResolver = yield* SkillResolverServiceTag
     const systemExecutor = yield* SystemExecutorServiceTag
     const user = yield* UserServiceTag
+    const queues = yield* LotaQueuesServiceTag
     const executeAgentNode = agentExecutor.executeNode as OwnershipDispatcherDeps['agentExecutor']['executeNode']
     return makeOwnershipDispatcherService({
       db,
@@ -614,6 +624,7 @@ export const OwnershipDispatcherServiceLive = Layer.effect(
         executeNode: (params) => provideCurrentContext(systemExecutor.executeNode(params)),
       },
       user: { getUser: (userId) => provideCurrentContext(user.getUser(userId)) },
+      planAgentHeartbeatQueue: queues.planAgentHeartbeat,
     })
   }),
 )

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

@@ -1,10 +1,13 @@
 import { Context, Schema, Effect, Layer } from 'effect'
 
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { serverLogger } from '../../config/logger'
 import { ensureRecordId } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
 import { effectTryPromise } from '../../effect/helpers'
-import { RedisServiceTag } from '../../effect/services'
+import { AgentConfigServiceTag, RedisServiceTag } 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 { withLeaseLock } from '../../redis/redis-lease-lock'
 import { resolvePlanNodeExecutionVisibility } from '../../runtime/execution-plan-visibility'
@@ -39,30 +42,40 @@ class PlanAgentHeartbeatError extends Schema.TaggedErrorClass<PlanAgentHeartbeat
   cause: Schema.Defect,
 }) {}
 
-function tryHeartbeatPromise<A>(
+function tryHeartbeatPromise<A, R = never>(
   operation: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, PlanAgentHeartbeatError> {
+  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown, R>,
+): Effect.Effect<A, PlanAgentHeartbeatError, R> {
   return effectTryPromise(thunk, (cause) => new PlanAgentHeartbeatError({ operation, cause }))
 }
 
-function heartbeatServiceEffect<A, E>(
+function heartbeatServiceEffect<A, E, R = never>(
   operation: string,
-  effect: Effect.Effect<A, E>,
-): Effect.Effect<A, PlanAgentHeartbeatError> {
+  effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, PlanAgentHeartbeatError, R> {
   return effect.pipe(Effect.mapError((cause) => new PlanAgentHeartbeatError({ operation, cause })))
 }
 
 interface PlanAgentHeartbeatDeps {
+  agentConfig: ResolvedAgentConfig
   redis: RedisConnectionManager
   planAgentQueryService: ReturnType<typeof makePlanAgentQueryService>
   planExecutorService: ReturnType<typeof makePlanExecutorService>
   planRunService: ReturnType<typeof makePlanRunService>
   threadService: ReturnType<typeof makeThreadService>
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime
 }
 
 export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
-  const { planExecutorService, planRunService, redis, planAgentQueryService, threadService } = deps
+  const {
+    agentConfig,
+    planExecutorService,
+    planRunService,
+    redis,
+    planAgentQueryService,
+    threadService,
+    planAgentHeartbeatQueue,
+  } = deps
 
   const wakeNodeEffect = (params: {
     organizationId: string
@@ -71,7 +84,7 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
     nodeId: string
     agentId: string
     reason: string
-  }): Effect.Effect<boolean, PlanAgentHeartbeatError> =>
+  }): Effect.Effect<boolean, PlanAgentHeartbeatError, unknown> =>
     Effect.gen(function* () {
       const threadRef = ensureRecordId(params.threadId, TABLES.THREAD)
       yield* heartbeatServiceEffect(
@@ -125,7 +138,7 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
               return false
             }
 
-            const visibility = resolvePlanNodeExecutionVisibility(spec, nodeSpec)
+            const visibility = resolvePlanNodeExecutionVisibility(agentConfig, spec, nodeSpec)
             if (visibility !== 'visible') {
               return false
             }
@@ -153,12 +166,9 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
       ).pipe(Effect.mapError((cause) => new PlanAgentHeartbeatError({ operation: 'wake-node-lock', cause })))
     })
 
-  const sweepEffect = (params?: { organizationId?: string }): Effect.Effect<void, PlanAgentHeartbeatError> =>
+  const sweepEffect = (params?: { organizationId?: string }): Effect.Effect<void, PlanAgentHeartbeatError, unknown> =>
     Effect.gen(function* () {
-      const { enqueuePlanAgentHeartbeatWake } = yield* tryHeartbeatPromise(
-        'import-heartbeat-queue',
-        () => import('../../queues/plan-agent-heartbeat.queue'),
-      )
+      const enqueuePlanAgentHeartbeatWake = planAgentHeartbeatQueue.enqueuePlanAgentHeartbeatWake
       const [actionable, recentlyUnblocked, approachingDeadlines] = yield* Effect.all([
         heartbeatServiceEffect(
           'get-actionable-nodes-for-agent',
@@ -218,17 +228,21 @@ export class PlanAgentHeartbeatServiceTag extends Context.Service<
 export const PlanAgentHeartbeatServiceLive = Layer.effect(
   PlanAgentHeartbeatServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const redis = yield* RedisServiceTag
     const planAgentQueryService = yield* PlanAgentQueryServiceTag
     const planRunService = yield* PlanRunServiceTag
     const planExecutor = yield* PlanExecutorServiceTag
     const threadSvc = yield* ThreadServiceTag
+    const queues = yield* LotaQueuesServiceTag
     return makePlanAgentHeartbeatService({
+      agentConfig,
       redis,
       planAgentQueryService,
       planExecutorService: planExecutor,
       planRunService,
       threadService: threadSvc,
+      planAgentHeartbeatQueue: queues.planAgentHeartbeat,
     })
   }),
 )