@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -4,6 +4,7 @@ import type {
   PlanArtifactRecord,
   PlanArtifactSubmission,
   PlanFailureClass,
+  PlanNodeResultSubmission,
   PlanNodeRunRecord,
   PlanNodeSpec,
   PlanNodeSpecRecord,
@@ -14,16 +15,18 @@ import type {
   PlanDraft,
   UpstreamHandoff,
 } from '@lota-sdk/shared'
-import { Cause, Context, Effect, Layer, Match } from 'effect'
+import { Cause, Context, Effect, Exit, Layer, Match } from 'effect'
 
 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 { BadRequestError, ConfigurationError, DatabaseError } from '../effect/errors'
-import { isPromiseLike } from '../effect/helpers'
+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'
@@ -51,14 +54,21 @@ interface OwnershipDispatcherDeps {
   db: SurrealDBService
   agentConfig: ResolvedAgentConfig
   runtimeAdapters: LotaRuntimeAdapters
-  agentExecutor: ReturnType<typeof makeAgentExecutorService>
-  monitoringWindow: ReturnType<typeof makeMonitoringWindowService>
+  agentExecutor: NoContextService<Pick<ReturnType<typeof makeAgentExecutorService>, 'executeNode'>>
+  monitoringWindow: NoContextService<Pick<ReturnType<typeof makeMonitoringWindowService>, 'startMonitoringWindow'>>
   planExecutor: ReturnType<typeof makePlanExecutorService>
   planRun: ReturnType<typeof makePlanRunService>
-  pluginExecutor: ReturnType<typeof makePluginExecutorService>
-  skillResolver: SkillResolverService
-  systemExecutor: ReturnType<typeof makeSystemExecutorService>
-  user: ReturnType<typeof makeUserService>
+  pluginExecutor: NoContextService<Pick<ReturnType<typeof makePluginExecutorService>, 'executeNode' | 'validateOwner'>>
+  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> = {
+  [K in keyof TService]: TService[K] extends (...args: infer TArgs) => Effect.Effect<infer A, infer E, unknown>
+    ? (...args: TArgs) => Effect.Effect<A, E, never>
+    : TService[K]
 }
 
 const STABLE_RUN_STATUSES = new Set(['pending-approval', 'awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
@@ -132,6 +142,8 @@ function toDispatchDatabaseError(message: string, cause: unknown) {
   return new DatabaseError({ message, cause })
 }
 
+const tryDispatchPromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
+
 const matchDraftExecutor = (deps: OwnershipDispatcherDeps, node: { id: string; label: string }) =>
   Match.type<PlanNodeOwner>().pipe(
     Match.discriminator('executorType')('agent', (owner): PlanValidationIssueInput[] =>
@@ -169,8 +181,9 @@ const shouldAutoDispatchEffect = (deps: OwnershipDispatcherDeps, run: PlanRunRec
       return true
     }
 
-    const workspace = yield* Effect.tryPromise(() =>
-      workspaceProvider.getWorkspace(ensureRecordId(run.organizationId, TABLES.ORGANIZATION)),
+    const workspace = yield* tryDispatchPromise(
+      () => workspaceProvider.getWorkspace(ensureRecordId(run.organizationId, TABLES.ORGANIZATION)),
+      'Failed to load workspace for dispatch eligibility.',
     )
     if (!workspaceProvider.getLifecycleState) {
       return true
@@ -179,7 +192,7 @@ const shouldAutoDispatchEffect = (deps: OwnershipDispatcherDeps, run: PlanRunRec
     const lifecycleState = yield* Effect.gen(function* () {
       const result = workspaceProvider.getLifecycleState?.call(workspaceProvider, workspace)
       if (isPromiseLike(result)) {
-        return yield* Effect.tryPromise(() => result)
+        return yield* tryDispatchPromise(() => result, 'Failed to read workspace lifecycle state.')
       }
 
       return result
@@ -210,7 +223,9 @@ const buildDispatchContextEffect = (
     ])
     const userId = thread?.userId ? recordIdToString(thread.userId, TABLES.USER) : undefined
     const userResult = userId ? yield* Effect.exit(deps.user.getUser(userId)) : undefined
-    const userName = userResult?._tag === 'Success' ? userResult.value.name : undefined
+    const userName = userResult
+      ? Exit.match(userResult, { onSuccess: (user) => user.name, onFailure: () => undefined })
+      : undefined
     const nodeSpecsById = new Map(nodeSpecs.map((candidate) => [candidate.nodeId, candidate]))
     const upstreamHandoffs: UpstreamHandoff[] = nodeRuns
       .filter(
@@ -274,71 +289,81 @@ const dispatchNodeEffect = (
       }
     }
 
-    switch (params.nodeSpec.owner.executorType) {
-      case 'agent':
-        return yield* deps.agentExecutor.executeNode({
+    return yield* Match.value(params.nodeSpec.owner.executorType).pipe(
+      Match.when('agent', () =>
+        deps.agentExecutor.executeNode({
           nodeSpec: params.nodeSpec,
           resolvedInput: params.resolvedInput,
           inputArtifacts: params.inputArtifacts,
           context: params.context,
           executionMode: effectiveExecutionMode,
           schemaRegistry: params.schemaRegistry,
-        })
-      case 'plugin':
-        return yield* deps.pluginExecutor.executeNode({
+        }),
+      ),
+      Match.when('plugin', () =>
+        deps.pluginExecutor.executeNode({
           nodeSpec: params.nodeSpec,
           resolvedInput: params.resolvedInput,
           context: params.context,
-        })
-      case 'system':
-        return yield* deps.systemExecutor.executeNode({
+        }),
+      ),
+      Match.when('system', () =>
+        deps.systemExecutor.executeNode({
           nodeSpec: params.nodeSpec,
           resolvedInput: params.resolvedInput,
           context: params.context,
-        })
-      case 'skill': {
-        const resolved = yield* deps.skillResolver.resolve({
-          skillRef: params.nodeSpec.owner.ref,
-          organizationId: params.context.organizationId,
-        })
-        if (!resolved) {
-          return yield* new ConfigurationError({
-            message: `Skill "${params.nodeSpec.owner.ref}" could not be resolved. This is a configuration error.`,
+        }),
+      ),
+      Match.when('skill', () =>
+        Effect.gen(function* () {
+          const resolved = yield* deps.skillResolver.resolve({
+            skillRef: params.nodeSpec.owner.ref,
+            organizationId: params.context.organizationId,
           })
-        }
-
-        if (resolved.executorType === 'agent') {
-          const skillNodeSpec = { ...params.nodeSpec, owner: { executorType: 'agent' as const, ref: resolved.ref } }
-          return yield* deps.agentExecutor.executeNode({
-            nodeSpec: skillNodeSpec,
+          if (!resolved) {
+            return yield* new ConfigurationError({
+              message: `Skill "${params.nodeSpec.owner.ref}" could not be resolved. This is a configuration error.`,
+            })
+          }
+
+          if (resolved.executorType === 'agent') {
+            const skillNodeSpec = { ...params.nodeSpec, owner: { executorType: 'agent' as const, ref: resolved.ref } }
+            return yield* deps.agentExecutor.executeNode({
+              nodeSpec: skillNodeSpec,
+              resolvedInput: params.resolvedInput,
+              inputArtifacts: params.inputArtifacts,
+              context: params.context,
+              executionMode: effectiveExecutionMode,
+              schemaRegistry: params.schemaRegistry,
+            })
+          }
+
+          return yield* deps.pluginExecutor.executeNode({
+            nodeSpec: {
+              ...params.nodeSpec,
+              owner: {
+                executorType: 'plugin' as const,
+                ref: resolved.ref,
+                operation: resolved.operation ?? params.nodeSpec.owner.ref,
+              },
+            },
             resolvedInput: params.resolvedInput,
-            inputArtifacts: params.inputArtifacts,
             context: params.context,
-            executionMode: effectiveExecutionMode,
-            schemaRegistry: params.schemaRegistry,
           })
-        }
-
-        return yield* deps.pluginExecutor.executeNode({
-          nodeSpec: {
-            ...params.nodeSpec,
-            owner: {
-              executorType: 'plugin' as const,
-              ref: resolved.ref,
-              operation: resolved.operation ?? params.nodeSpec.owner.ref,
-            },
-          },
-          resolvedInput: params.resolvedInput,
-          context: params.context,
-        })
-      }
-      case 'user':
-        return yield* new BadRequestError({
-          message: `User-owned node "${params.nodeSpec.id}" cannot be auto-dispatched.`,
-        })
-    }
+        }),
+      ),
+      Match.when(
+        'user',
+        () => new BadRequestError({ message: `User-owned node "${params.nodeSpec.id}" cannot be auto-dispatched.` }),
+      ),
+      Match.exhaustive,
+    )
   })
 
+type GraphFullDispatchReadyNode = (
+  params: Parameters<typeof dispatchReadyNodeEffect>[1],
+) => Effect.Effect<PlanNodeResultSubmission, Effect.Error<ReturnType<typeof dispatchReadyNodeEffect>>, never>
+
 const dispatchRunToStableBoundaryEffect = (
   deps: OwnershipDispatcherDeps,
   params: { runId: RecordIdInput; emittedBy: string },
@@ -359,20 +384,24 @@ const dispatchRunToStableBoundaryEffect = (
       const spec = yield* deps.planRun.getPlanSpecById(run.planSpecId)
 
       if (spec.executionMode === 'graph-full') {
+        const dispatchReadyNodeForGraphFull: GraphFullDispatchReadyNode = (dispatchParams) =>
+          dispatchReadyNodeEffect(deps, dispatchParams)
+
         yield* routeGraphFullEffect(
           { threadId: recordIdToString(run.threadId, TABLES.THREAD), runId: recordIdToString(run.id, TABLES.PLAN_RUN) },
           {
-            dispatchReadyNode: (dispatchParams) => dispatchReadyNodeEffect(deps, dispatchParams),
+            agentConfig: deps.agentConfig,
+            dispatchReadyNode: dispatchReadyNodeForGraphFull,
             planExecutorService: deps.planExecutor,
             planRunService: deps.planRun,
+            planAgentHeartbeatQueue: deps.planAgentHeartbeatQueue,
           },
         ).pipe(
-          Effect.catch(() =>
-            Effect.fail(
+          Effect.mapError(
+            () =>
               new ConfigurationError({
                 message: `Failed to route graph-full execution for run ${recordIdToString(run.id, TABLES.PLAN_RUN)}.`,
               }),
-            ),
           ),
         )
         return yield* serializeRunEffect(deps, run.id)
@@ -403,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)
       }
 
@@ -428,29 +457,33 @@ const dispatchRunToStableBoundaryEffect = (
             schemaRegistry: spec.schemaRegistry,
           })
 
-          yield* Effect.tryPromise(() =>
-            deps.planExecutor.submitNodeResult({
-              threadId: run.threadId,
-              runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-              nodeId: planNode.id,
-              emittedBy: planNode.owner.ref,
-              result,
-            }),
+          yield* tryDispatchPromise(
+            () =>
+              deps.planExecutor.submitNodeResult({
+                threadId: run.threadId,
+                runId: recordIdToString(run.id, TABLES.PLAN_RUN),
+                nodeId: planNode.id,
+                emittedBy: planNode.owner.ref,
+                result,
+              }),
+            'Failed to submit plan node result.',
           )
         }),
       )
 
-      if (dispatchExit._tag === 'Failure') {
+      if (Exit.isFailure(dispatchExit)) {
         const failure = Cause.squash(dispatchExit.cause)
-        yield* Effect.tryPromise(() =>
-          deps.planExecutor.blockNodeOnDispatchFailure({
-            threadId: run.threadId,
-            runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-            nodeId: planNode.id,
-            emittedBy: planNode.owner.ref,
-            message: formatDispatchError(failure),
-            failureClass: classifyDispatchFailure({ ownerType: planNode.owner.executorType, error: failure }),
-          }),
+        yield* tryDispatchPromise(
+          () =>
+            deps.planExecutor.blockNodeOnDispatchFailure({
+              threadId: run.threadId,
+              runId: recordIdToString(run.id, TABLES.PLAN_RUN),
+              nodeId: planNode.id,
+              emittedBy: planNode.owner.ref,
+              message: formatDispatchError(failure),
+              failureClass: classifyDispatchFailure({ ownerType: planNode.owner.executorType, error: failure }),
+            }),
+          'Failed to block plan node on dispatch failure.',
         )
         return yield* serializeRunEffect(deps, run.id)
       }
@@ -475,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.`,
       })
@@ -503,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) {
@@ -525,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
@@ -541,14 +578,19 @@ export function makeOwnershipDispatcherService(deps: OwnershipDispatcherDeps) {
   } as const
 }
 
+export interface OwnershipDispatcherService extends ReturnType<typeof makeOwnershipDispatcherService> {}
+
 export class OwnershipDispatcherServiceTag extends Context.Service<
   OwnershipDispatcherServiceTag,
-  ReturnType<typeof makeOwnershipDispatcherService>
->()('OwnershipDispatcherService') {}
+  OwnershipDispatcherService
+>()('@lota-sdk/core/OwnershipDispatcherService') {}
 
 export const OwnershipDispatcherServiceLive = Layer.effect(
   OwnershipDispatcherServiceTag,
   Effect.gen(function* () {
+    const currentContext = yield* Effect.context()
+    const provideCurrentContext = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, never> =>
+      effect.pipe(Effect.provide(currentContext)) as Effect.Effect<A, E, never>
     const db = yield* DatabaseServiceTag
     const agentConfig = yield* AgentConfigServiceTag
     const runtimeAdapters = yield* RuntimeAdaptersServiceTag
@@ -560,18 +602,29 @@ 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,
       agentConfig,
       runtimeAdapters,
-      agentExecutor,
-      monitoringWindow,
+      agentExecutor: { executeNode: executeAgentNode },
+      monitoringWindow: {
+        startMonitoringWindow: (params) => provideCurrentContext(monitoringWindow.startMonitoringWindow(params)),
+      },
       planExecutor,
       planRun,
-      pluginExecutor,
-      skillResolver,
-      systemExecutor,
-      user,
+      pluginExecutor: {
+        validateOwner: (owner, nodeId) => pluginExecutor.validateOwner(owner, nodeId),
+        executeNode: (params) => provideCurrentContext(pluginExecutor.executeNode(params)),
+      },
+      skillResolver: { resolve: (params) => provideCurrentContext(skillResolver.resolve(params)) },
+      systemExecutor: {
+        validateOwner: (owner, nodeId) => systemExecutor.validateOwner(owner, nodeId),
+        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',
@@ -213,22 +223,26 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
 export class PlanAgentHeartbeatServiceTag extends Context.Service<
   PlanAgentHeartbeatServiceTag,
   ReturnType<typeof makePlanAgentHeartbeatService>
->()('PlanAgentHeartbeatService') {}
+>()('@lota-sdk/core/PlanAgentHeartbeatService') {}
 
 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,
     })
   }),
 )

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
           }
@@ -310,13 +313,14 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
 export class PlanAgentQueryServiceTag extends Context.Service<
   PlanAgentQueryServiceTag,
   ReturnType<typeof makePlanAgentQueryService>
->()('PlanAgentQueryService') {}
+>()('@lota-sdk/core/PlanAgentQueryService') {}
 
 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 })
   }),
 )