@lota-sdk/core 0.4.10 → 0.4.12

package/src/queues/document-processor.queue.ts

@@ -3,8 +3,8 @@ import type IORedis from 'ioredis'
 
 import type { chatLogger } from '../config/logger'
 import { sha256Hex } from '../utils/crypto'
-import { DEFAULT_JOB_RETENTION, getQueueJobService } from '../workers/worker-utils'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { DEFAULT_JOB_RETENTION } from '../workers/worker-utils'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
 
 export type DocumentSourceChannel = string
@@ -56,6 +56,7 @@ export function createDocumentProcessorQueueRuntime<TJob extends DocumentProcess
   getConnectionForBullMQ: () => IORedis
   getWorkerPath: () => string
   logger: typeof chatLogger
+  queueJobService: QueueJobService
   queueName?: string
   workerName?: string
   concurrency?: number
@@ -75,6 +76,7 @@ export function createDocumentProcessorQueueRuntime<TJob extends DocumentProcess
     connectionProvider: params.getConnectionForBullMQ,
     defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 1000 } },
     processorPath: params.getWorkerPath(),
+    queueJobService: params.queueJobService,
   })
 
   return {
@@ -86,7 +88,7 @@ export function createDocumentProcessorQueueRuntime<TJob extends DocumentProcess
           )
 
           yield* Effect.catch(
-            getQueueJobService().recordEnqueued({
+            params.queueJobService.recordEnqueued({
               queueName,
               id: queuedJob.id,
               name: queuedJob.name,

package/src/queues/index.ts

@@ -8,4 +8,5 @@ export * from './organization-learning.queue'
 export * from './plan-agent-heartbeat.queue'
 export * from './plan-scheduler.queue'
 export * from './post-chat-memory.queue'
+export * from './queues.service'
 export * from './title-generation.queue'

package/src/queues/memory-consolidation.queue.ts

@@ -1,12 +1,12 @@
 import { Effect } from 'effect'
+import type { Context } from 'effect'
+import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-import {
-  getQueueJobService,
-  getWorkerPath,
-  LONG_JOB_LOCK_DURATION_MS,
-  LOW_JOB_RETENTION,
-} from '../workers/worker-utils'
+import { RedisServiceTag } from '../effect/services'
+import { QueueJobServiceTag } from '../services/queue-job.service'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
+import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS, LOW_JOB_RETENTION } from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
@@ -17,58 +17,84 @@ export interface MemoryConsolidationJob {
 const MEMORY_CONSOLIDATION_INTERVAL_MS = 24 * 60 * 60 * 1000
 const MEMORY_CONSOLIDATION_SCHEDULER_ID = 'memory-consolidation-recurring'
 
-const memoryConsolidation = createQueueFactory<MemoryConsolidationJob>({
-  name: 'memory-consolidation',
-  displayName: 'Memory consolidation',
-  jobName: 'consolidate-turn',
-  concurrency: 1,
-  lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  defaultJobOptions: { ...LOW_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
-  processorPath: getWorkerPath('memory-consolidation.worker.ts'),
-})
+export interface MemoryConsolidationQueueRuntime {
+  enqueueMemoryConsolidation(job?: MemoryConsolidationJob): Promise<void>
+  scheduleRecurringConsolidation(): Promise<void>
+  startWorker(options?: { registerSignals?: boolean }): WorkerHandle
+}
 
-export function enqueueMemoryConsolidation(job: MemoryConsolidationJob = {}) {
-  return memoryConsolidation.enqueue(job, { jobId: job.scopeId ? `consolidate-turn:${job.scopeId}` : undefined })
+interface MakeMemoryConsolidationQueueRuntimeParams {
+  connectionProvider: () => IORedis
+  queueJobService: QueueJobService
 }
 
-export function scheduleRecurringConsolidation() {
-  return Effect.runPromise(
-    Effect.gen(function* () {
-      const queuedJob = yield* Effect.tryPromise(() =>
-        memoryConsolidation
-          .getQueue()
-          .upsertJobScheduler(
-            MEMORY_CONSOLIDATION_SCHEDULER_ID,
-            { every: MEMORY_CONSOLIDATION_INTERVAL_MS },
-            {
-              name: 'consolidate',
-              data: {},
-              opts: { ...LOW_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
-            },
-          ),
-      )
+export function makeMemoryConsolidationQueueRuntime(
+  params: MakeMemoryConsolidationQueueRuntimeParams,
+): MemoryConsolidationQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+  const queue = createQueueFactory<MemoryConsolidationJob>({
+    name: 'memory-consolidation',
+    displayName: 'Memory consolidation',
+    jobName: 'consolidate-turn',
+    concurrency: 1,
+    lockDuration: LONG_JOB_LOCK_DURATION_MS,
+    defaultJobOptions: { ...LOW_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
+    processorPath: getWorkerPath('memory-consolidation.worker.ts'),
+    connectionProvider,
+    queueJobService,
+  })
+
+  const enqueueMemoryConsolidation: MemoryConsolidationQueueRuntime['enqueueMemoryConsolidation'] = (job = {}) =>
+    queue.enqueue(job, { jobId: job.scopeId ? `consolidate-turn:${job.scopeId}` : undefined })
 
-      yield* Effect.catch(
-        getQueueJobService().recordEnqueued({
-          queueName: 'memory-consolidation',
-          id: queuedJob.id,
-          name: queuedJob.name,
-          data: queuedJob.data,
-          opts: queuedJob.opts,
-          attemptsMade: queuedJob.attemptsMade,
-          timestamp: queuedJob.timestamp,
-        }),
-        (error) =>
-          Effect.sync(() => {
-            serverLogger.error`Failed to persist queued job metadata (queue=memory-consolidation, job=${queuedJob.id}): ${error}`
+  const scheduleRecurringConsolidation: MemoryConsolidationQueueRuntime['scheduleRecurringConsolidation'] = () =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        const queuedJob = yield* Effect.tryPromise(() =>
+          queue
+            .getQueue()
+            .upsertJobScheduler(
+              MEMORY_CONSOLIDATION_SCHEDULER_ID,
+              { every: MEMORY_CONSOLIDATION_INTERVAL_MS },
+              {
+                name: 'consolidate',
+                data: {},
+                opts: { ...LOW_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
+              },
+            ),
+        )
+
+        yield* Effect.catch(
+          queueJobService.recordEnqueued({
+            queueName: 'memory-consolidation',
+            id: queuedJob.id,
+            name: queuedJob.name,
+            data: queuedJob.data,
+            opts: queuedJob.opts,
+            attemptsMade: queuedJob.attemptsMade,
+            timestamp: queuedJob.timestamp,
           }),
-      )
-    }),
-  )
-}
+          (error) =>
+            Effect.sync(() => {
+              serverLogger.error`Failed to persist queued job metadata (queue=memory-consolidation, job=${queuedJob.id}): ${error}`
+            }),
+        )
+      }),
+    )
 
-export const startMemoryConsolidationWorker = memoryConsolidation.startWorker
+  return {
+    enqueueMemoryConsolidation,
+    scheduleRecurringConsolidation,
+    startWorker: (options = {}) => queue.startWorker({ registerSignals: options.registerSignals, connectionProvider }),
+  }
+}
 
-runStandaloneQueueWorker(() => {
-  startMemoryConsolidationWorker()
+runStandaloneQueueWorker((runtime) => {
+  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+  const redis = resolve(RedisServiceTag)
+  const memoryConsolidationQueue = makeMemoryConsolidationQueueRuntime({
+    connectionProvider: () => redis.getConnectionForBullMQ(),
+    queueJobService: resolve(QueueJobServiceTag),
+  })
+  memoryConsolidationQueue.startWorker()
 })

package/src/queues/organization-learning.queue.ts

@@ -1,5 +1,10 @@
 import { Effect, Schema } from 'effect'
+import type { Context } from 'effect'
+import type IORedis from 'ioredis'
 
+import { RedisServiceTag } from '../effect/services'
+import { QueueJobServiceTag } from '../services/queue-job.service'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
@@ -51,50 +56,69 @@ export function buildSkillExtractionJobOptions(orgId: string) {
   return { delay: ORGANIZATION_LEARNING_DELAY_MS, deduplication: { id: buildSkillExtractionDeduplicationId(orgId) } }
 }
 
-const organizationLearningQueue = createQueueFactory<OrganizationLearningJob>({
-  name: ORGANIZATION_LEARNING_QUEUE,
-  displayName: 'Organization learning',
-  jobName: 'organization-learning',
-  concurrency: 4,
-  lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5_000 } },
-  processorPath: getWorkerPath('organization-learning.worker.ts'),
-})
-
-export function enqueueRegularChatMemoryDigest(job: Omit<RegularChatMemoryDigestJob, 'kind'>) {
-  return organizationLearningQueue.enqueue(
-    { kind: 'regular-chat-memory-digest', ...job },
-    buildRegularChatMemoryDigestJobOptions(job.orgId),
-  )
+export interface OrganizationLearningQueueRuntime {
+  enqueueRegularChatMemoryDigest(job: Omit<RegularChatMemoryDigestJob, 'kind'>): Promise<void>
+  enqueueSkillExtraction(job: Omit<SkillExtractionJob, 'kind'>): Promise<void>
+  clearRegularChatMemoryDigestDeduplicationKey(orgId: string): Promise<void>
+  startWorker(options?: { registerSignals?: boolean }): WorkerHandle
 }
 
-export function enqueueSkillExtraction(job: Omit<SkillExtractionJob, 'kind'>) {
-  return organizationLearningQueue.enqueue(
-    { kind: 'skill-extraction', ...job },
-    buildSkillExtractionJobOptions(job.orgId),
-  )
+interface MakeOrganizationLearningQueueRuntimeParams {
+  connectionProvider: () => IORedis
+  queueJobService: QueueJobService
 }
 
-export function clearRegularChatMemoryDigestDeduplicationKey(orgId: string): Promise<void> {
-  return Effect.runPromise(
-    Effect.asVoid(
-      Effect.tryPromise({
-        try: () =>
-          organizationLearningQueue
-            .getQueue()
-            .removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId)),
-        catch: (cause) =>
-          new OrganizationLearningQueueError({
-            message: `Failed to clear regular-chat memory digest deduplication key for ${orgId}.`,
-            cause,
+export function makeOrganizationLearningQueueRuntime(
+  params: MakeOrganizationLearningQueueRuntimeParams,
+): OrganizationLearningQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+  const queue = createQueueFactory<OrganizationLearningJob>({
+    name: ORGANIZATION_LEARNING_QUEUE,
+    displayName: 'Organization learning',
+    jobName: 'organization-learning',
+    concurrency: 4,
+    lockDuration: LONG_JOB_LOCK_DURATION_MS,
+    defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5_000 } },
+    processorPath: getWorkerPath('organization-learning.worker.ts'),
+    connectionProvider,
+    queueJobService,
+  })
+
+  const enqueueRegularChatMemoryDigest: OrganizationLearningQueueRuntime['enqueueRegularChatMemoryDigest'] = (job) =>
+    queue.enqueue({ kind: 'regular-chat-memory-digest', ...job }, buildRegularChatMemoryDigestJobOptions(job.orgId))
+
+  const enqueueSkillExtraction: OrganizationLearningQueueRuntime['enqueueSkillExtraction'] = (job) =>
+    queue.enqueue({ kind: 'skill-extraction', ...job }, buildSkillExtractionJobOptions(job.orgId))
+
+  const clearRegularChatMemoryDigestDeduplicationKey: OrganizationLearningQueueRuntime['clearRegularChatMemoryDigestDeduplicationKey'] =
+    (orgId) =>
+      Effect.runPromise(
+        Effect.asVoid(
+          Effect.tryPromise({
+            try: () => queue.getQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId)),
+            catch: (cause) =>
+              new OrganizationLearningQueueError({
+                message: `Failed to clear regular-chat memory digest deduplication key for ${orgId}.`,
+                cause,
+              }),
           }),
-      }),
-    ),
-  )
-}
+        ),
+      )
 
-export const startOrganizationLearningWorker = organizationLearningQueue.startWorker
+  return {
+    enqueueRegularChatMemoryDigest,
+    enqueueSkillExtraction,
+    clearRegularChatMemoryDigestDeduplicationKey,
+    startWorker: (options = {}) => queue.startWorker({ registerSignals: options.registerSignals, connectionProvider }),
+  }
+}
 
-runStandaloneQueueWorker(() => {
-  startOrganizationLearningWorker()
+runStandaloneQueueWorker((runtime) => {
+  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+  const redis = resolve(RedisServiceTag)
+  const organizationLearningQueue = makeOrganizationLearningQueueRuntime({
+    connectionProvider: () => redis.getConnectionForBullMQ(),
+    queueJobService: resolve(QueueJobServiceTag),
+  })
+  organizationLearningQueue.startWorker()
 })

package/src/queues/plan-agent-heartbeat.queue.ts

@@ -5,12 +5,20 @@ import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
-import { PlanAgentHeartbeatServiceTag } from '../services/plan/plan-agent-heartbeat.service'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { QueueJobServiceTag } from '../services/queue-job.service'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 import { DEFAULT_JOB_RETENTION, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
 import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
+// Minimal service shape used by the worker processor. Declared structurally to
+// avoid importing the service tag — which would form a dependency cycle since
+// PlanAgentHeartbeatServiceLive depends on LotaQueuesServiceTag.
+interface PlanAgentHeartbeatWorkerServiceShape {
+  wakeNode(params: PlanAgentHeartbeatWakeJob): Effect.Effect<unknown, unknown, unknown>
+  sweep(params: { organizationId?: string }): Effect.Effect<void, unknown, unknown>
+}
+
 class PlanAgentHeartbeatQueueError extends Schema.TaggedErrorClass<PlanAgentHeartbeatQueueError>()(
   '@lota-sdk/core/PlanAgentHeartbeatQueueError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
@@ -37,57 +45,11 @@ export const PLAN_AGENT_HEARTBEAT_QUEUE = 'plan-agent-heartbeat'
 const PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS = 30_000
 const PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID = 'plan-agent-heartbeat-sweep'
 
-interface PlanAgentHeartbeatQueueDeps {
+export interface PlanAgentHeartbeatWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
-  planAgentHeartbeatService: Context.Service.Shape<typeof PlanAgentHeartbeatServiceTag>
-}
-
-function enqueueDelayedPlanAgentHeartbeatSweep(delayMs = PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS): Promise<void> {
-  return planAgentHeartbeatQueue.enqueue(
-    { type: 'sweep' },
-    { delay: delayMs, jobId: PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID },
-  )
-}
-
-function processPlanAgentHeartbeatJob(
-  deps: PlanAgentHeartbeatQueueDeps,
-  job: Job<PlanAgentHeartbeatJob>,
-): Promise<void> {
-  const { planAgentHeartbeatService } = deps
-  return Effect.runPromise(
-    Effect.gen(function* () {
-      if (job.data.type === 'wake-node') {
-        const wakeJob = job.data
-        yield* planAgentHeartbeatService.wakeNode(wakeJob)
-        return
-      }
-
-      yield* planAgentHeartbeatService.sweep({ organizationId: job.data.organizationId })
-      if (!job.data.organizationId) {
-        yield* Effect.tryPromise({
-          try: () => enqueueDelayedPlanAgentHeartbeatSweep(),
-          catch: (cause) =>
-            new PlanAgentHeartbeatQueueError({
-              message: 'Failed to enqueue delayed plan-agent heartbeat sweep.',
-              cause,
-            }),
-        })
-      }
-    }),
-  )
+  planAgentHeartbeatService: PlanAgentHeartbeatWorkerServiceShape
 }
 
-const planAgentHeartbeatQueue = createQueueFactoryWithDeps<PlanAgentHeartbeatJob, PlanAgentHeartbeatQueueDeps>({
-  name: PLAN_AGENT_HEARTBEAT_QUEUE,
-  displayName: 'Plan agent heartbeat',
-  jobName: 'plan-agent-heartbeat-job',
-  concurrency: 2,
-  lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 5_000 } },
-  prepare: ({ databaseService }) => databaseService.connect(),
-  processor: processPlanAgentHeartbeatJob,
-})
-
 function buildWakeJobId(params: {
   organizationId: string
   threadId: string
@@ -100,42 +62,105 @@ function buildWakeJobId(params: {
   return `plan-agent-wake__${encode(params.runId)}__${encode(params.nodeId)}__${encode(params.agentId)}`
 }
 
-export function enqueuePlanAgentHeartbeatWake(params: {
-  organizationId: string
-  threadId: string
-  runId: string
-  nodeId: string
-  agentId: string
-  reason: string
-}): Promise<void> {
-  return planAgentHeartbeatQueue.enqueue({ type: 'wake-node', ...params }, { jobId: buildWakeJobId(params) })
+export interface PlanAgentHeartbeatQueueRuntime {
+  enqueuePlanAgentHeartbeatWake(params: {
+    organizationId: string
+    threadId: string
+    runId: string
+    nodeId: string
+    agentId: string
+    reason: string
+  }): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: PlanAgentHeartbeatWorkerDeps }): WorkerHandle
 }
 
-export function startPlanAgentHeartbeatWorker(options: {
-  registerSignals?: boolean
+interface MakePlanAgentHeartbeatQueueRuntimeParams {
   connectionProvider: () => IORedis
-  deps: PlanAgentHeartbeatQueueDeps
-}): WorkerHandle {
-  const handle = planAgentHeartbeatQueue.startWorker({
-    deps: options.deps,
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
-  })
+  queueJobService: QueueJobService
+}
 
-  enqueueDelayedPlanAgentHeartbeatSweep().catch((error: unknown) => {
-    serverLogger.error`Plan agent heartbeat scheduler setup failed: ${error}`
+export function makePlanAgentHeartbeatQueueRuntime(
+  params: MakePlanAgentHeartbeatQueueRuntimeParams,
+): PlanAgentHeartbeatQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+
+  const enqueueDelayedSweep = (delayMs = PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS): Promise<void> =>
+    queue.enqueue({ type: 'sweep' }, { delay: delayMs, jobId: PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID })
+
+  const processPlanAgentHeartbeatJob = (
+    deps: PlanAgentHeartbeatWorkerDeps,
+    job: Job<PlanAgentHeartbeatJob>,
+  ): Promise<void> => {
+    const { planAgentHeartbeatService: service } = deps
+    return Effect.runPromise(
+      Effect.gen(function* () {
+        if (job.data.type === 'wake-node') {
+          const wakeJob = job.data
+          yield* service.wakeNode(wakeJob)
+          return
+        }
+
+        yield* service.sweep({ organizationId: job.data.organizationId })
+        if (!job.data.organizationId) {
+          yield* Effect.tryPromise({
+            try: () => enqueueDelayedSweep(),
+            catch: (cause) =>
+              new PlanAgentHeartbeatQueueError({
+                message: 'Failed to enqueue delayed plan-agent heartbeat sweep.',
+                cause,
+              }),
+          })
+        }
+      }) as Effect.Effect<void, never, never>,
+    )
+  }
+
+  const queue = createQueueFactoryWithDeps<PlanAgentHeartbeatJob, PlanAgentHeartbeatWorkerDeps>({
+    name: PLAN_AGENT_HEARTBEAT_QUEUE,
+    displayName: 'Plan agent heartbeat',
+    jobName: 'plan-agent-heartbeat-job',
+    concurrency: 2,
+    lockDuration: LONG_JOB_LOCK_DURATION_MS,
+    defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 5_000 } },
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processPlanAgentHeartbeatJob,
   })
 
-  return handle
+  return {
+    enqueuePlanAgentHeartbeatWake: (wakeParams) =>
+      queue.enqueue({ type: 'wake-node', ...wakeParams }, { jobId: buildWakeJobId(wakeParams) }),
+    startWorker: (options) => {
+      const handle = queue.startWorker({
+        deps: options.deps,
+        registerSignals: options.registerSignals,
+        connectionProvider,
+      })
+
+      enqueueDelayedSweep().catch((error: unknown) => {
+        serverLogger.error`Plan agent heartbeat scheduler setup failed: ${error}`
+      })
+
+      return handle
+    },
+  }
 }
 
 runStandaloneQueueWorker((runtime) => {
-  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
-  startPlanAgentHeartbeatWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
-    deps: {
-      databaseService: resolve(DatabaseServiceTag),
-      planAgentHeartbeatService: resolve(PlanAgentHeartbeatServiceTag),
-    },
-  })
+  void (async () => {
+    const { PlanAgentHeartbeatServiceTag } = await import('../services/plan/plan-agent-heartbeat.service')
+    const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+    const redis = resolve(RedisServiceTag)
+    const planAgentHeartbeatQueue = makePlanAgentHeartbeatQueueRuntime({
+      connectionProvider: () => redis.getConnectionForBullMQ(),
+      queueJobService: resolve(QueueJobServiceTag),
+    })
+    planAgentHeartbeatQueue.startWorker({
+      deps: {
+        databaseService: resolve(DatabaseServiceTag),
+        planAgentHeartbeatService: resolve(PlanAgentHeartbeatServiceTag),
+      },
+    })
+  })()
 })