@lota-sdk/core 0.4.8 → 0.4.10

package/src/queues/context-compaction.queue.ts

@@ -1,11 +1,15 @@
 import type { Job } from 'bullmq'
+import { Effect } from 'effect'
+import type { Context } from 'effect'
+import type IORedis from 'ioredis'
 
 import { ensureRecordId } from '../db/record-id'
-import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { contextCompactionService } from '../services/context-compaction.service'
-import { threadService } from '../services/thread.service'
-import { createQueueFactory } from './queue-factory'
+import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import { ContextCompactionServiceTag } from '../services/context-compaction.service'
+import { ThreadServiceTag } from '../services/thread/thread.service'
+import { createQueueFactoryWithDeps } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
 
 interface ContextCompactionJob {
   domain: 'thread'
@@ -13,26 +17,37 @@ interface ContextCompactionJob {
   contextSize?: number
 }
 
-async function processContextCompactionJob(job: Job<ContextCompactionJob>): Promise<void> {
-  await databaseService.connect()
+interface ContextCompactionQueueDeps {
+  databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
+  threadService: Context.Service.Shape<typeof ThreadServiceTag>
+  contextCompactionService: Context.Service.Shape<typeof ContextCompactionServiceTag>
+}
 
+function processContextCompactionJob(deps: ContextCompactionQueueDeps, job: Job<ContextCompactionJob>): Promise<void> {
+  const { threadService, contextCompactionService } = deps
   const { entityId, contextSize } = job.data
   const threadRef = ensureRecordId(entityId, TABLES.THREAD)
-  await threadService.setCompacting(threadRef, true)
-  try {
-    await contextCompactionService.compactThreadHistory({ threadId: threadRef, contextSize })
-  } finally {
-    await threadService.setCompacting(threadRef, false)
-  }
+  return Effect.runPromise(
+    Effect.ensuring(
+      Effect.asVoid(
+        Effect.gen(function* () {
+          yield* threadService.setCompacting(threadRef, true)
+          yield* contextCompactionService.compactThreadHistory({ threadId: threadRef, contextSize })
+        }),
+      ),
+      Effect.ignore(threadService.setCompacting(threadRef, false)),
+    ),
+  )
 }
 
-const contextCompaction = createQueueFactory<ContextCompactionJob>({
+const contextCompaction = createQueueFactoryWithDeps<ContextCompactionJob, ContextCompactionQueueDeps>({
   name: 'context-compaction',
   displayName: 'Context compaction',
   jobName: 'compact',
   concurrency: 2,
   lockDuration: 300_000,
   defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 3_000 } },
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processContextCompactionJob,
 })
 
@@ -40,8 +55,26 @@ export function enqueueContextCompaction(job: ContextCompactionJob) {
   return contextCompaction.enqueue(job, { deduplication: { id: `compact:${job.domain}:${job.entityId}` } })
 }
 
-export const startContextCompactionWorker = contextCompaction.startWorker
-
-if (import.meta.main) {
-  startContextCompactionWorker()
+export function startContextCompactionWorker(options: {
+  registerSignals?: boolean
+  connectionProvider: () => IORedis
+  deps: ContextCompactionQueueDeps
+}): ReturnType<typeof contextCompaction.startWorker> {
+  return contextCompaction.startWorker({
+    deps: options.deps,
+    registerSignals: options.registerSignals,
+    connectionProvider: options.connectionProvider,
+  })
 }
+
+runStandaloneQueueWorker((runtime) => {
+  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+  startContextCompactionWorker({
+    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
+    deps: {
+      databaseService: resolve(DatabaseServiceTag),
+      threadService: resolve(ThreadServiceTag),
+      contextCompactionService: resolve(ContextCompactionServiceTag),
+    },
+  })
+})

package/src/queues/delayed-node-promotion.queue.ts

@@ -1,8 +1,12 @@
 import type { Job } from 'bullmq'
+import { Effect } from 'effect'
+import type { Context } from 'effect'
+import type IORedis from 'ioredis'
 
-import { databaseService } from '../db/service'
-import { planExecutorService } from '../services/plan-executor.service'
-import { createQueueFactory } from './queue-factory'
+import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import { PlanExecutorServiceTag } from '../services/plan/plan-executor.service'
+import { createQueueFactoryWithDeps } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
 
 export interface DelayedNodePromotionJob {
   runId: string
@@ -12,30 +16,55 @@ export interface DelayedNodePromotionJob {
 
 export const DELAYED_NODE_PROMOTION_QUEUE = 'delayed-node-promotion'
 
-async function processDelayedNodePromotionJob(job: Job<DelayedNodePromotionJob>): Promise<void> {
-  await databaseService.connect()
-  await planExecutorService.promoteDelayedNode({
-    runId: job.data.runId,
-    nodeId: job.data.nodeId,
-    emittedBy: job.data.emittedBy,
-  })
+interface DelayedNodePromotionQueueDeps {
+  databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
+  planExecutorService: Context.Service.Shape<typeof PlanExecutorServiceTag>
+}
+
+function processDelayedNodePromotionJob(
+  deps: DelayedNodePromotionQueueDeps,
+  job: Job<DelayedNodePromotionJob>,
+): Promise<void> {
+  const { planExecutorService } = deps
+  return Promise.resolve(
+    planExecutorService.promoteDelayedNode({
+      runId: job.data.runId,
+      nodeId: job.data.nodeId,
+      emittedBy: job.data.emittedBy,
+    }),
+  ).then(() => undefined)
 }
 
-const delayedNodePromotion = createQueueFactory<DelayedNodePromotionJob>({
+const delayedNodePromotion = createQueueFactoryWithDeps<DelayedNodePromotionJob, DelayedNodePromotionQueueDeps>({
   name: DELAYED_NODE_PROMOTION_QUEUE,
   displayName: 'Delayed node promotion',
   jobName: 'promote-node',
   concurrency: 1,
   defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 5000 } },
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processDelayedNodePromotionJob,
 })
 
-export async function enqueueDelayedNodePromotion(job: DelayedNodePromotionJob, delayMs: number) {
-  await delayedNodePromotion.enqueue(job, { delay: delayMs, jobId: `promote:${job.runId}:${job.nodeId}` })
+export function enqueueDelayedNodePromotion(job: DelayedNodePromotionJob, delayMs: number) {
+  return delayedNodePromotion.enqueue(job, { delay: delayMs, jobId: `promote:${job.runId}:${job.nodeId}` })
 }
 
-export const startDelayedNodePromotionWorker = delayedNodePromotion.startWorker
-
-if (import.meta.main) {
-  startDelayedNodePromotionWorker()
+export function startDelayedNodePromotionWorker(options: {
+  registerSignals?: boolean
+  connectionProvider: () => IORedis
+  deps: DelayedNodePromotionQueueDeps
+}): ReturnType<typeof delayedNodePromotion.startWorker> {
+  return delayedNodePromotion.startWorker({
+    deps: options.deps,
+    registerSignals: options.registerSignals,
+    connectionProvider: options.connectionProvider,
+  })
 }
+
+runStandaloneQueueWorker((runtime) => {
+  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+  startDelayedNodePromotionWorker({
+    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
+    deps: { databaseService: resolve(DatabaseServiceTag), planExecutorService: resolve(PlanExecutorServiceTag) },
+  })
+})

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

@@ -1,16 +1,11 @@
-import { Queue, Worker } from 'bullmq'
-import type { QueueOptions } from 'bullmq'
+import { Effect } from 'effect'
 import type IORedis from 'ioredis'
 
 import type { chatLogger } from '../config/logger'
-import { queueJobService } from '../services/queue-job.service'
-import {
-  attachWorkerEvents,
-  createWorkerShutdown,
-  DEFAULT_JOB_RETENTION,
-  registerShutdownSignals,
-} from '../workers/worker-utils'
+import { sha256Hex } from '../utils/crypto'
+import { DEFAULT_JOB_RETENTION, getQueueJobService } from '../workers/worker-utils'
 import type { WorkerHandle } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
 
 export type DocumentSourceChannel = string
 
@@ -43,18 +38,16 @@ export function buildDocumentProcessorJobId(
     'orgId' | 'source' | 'sourceId' | 'sourceCanonicalKey' | 'sourceVersionKey' | 'title'
   >,
 ): string {
-  const digest = new Bun.CryptoHasher('sha256')
-    .update(
-      JSON.stringify({
-        orgId: job.orgId,
-        source: job.source,
-        sourceId: job.sourceId,
-        sourceCanonicalKey: job.sourceCanonicalKey,
-        sourceVersionKey: job.sourceVersionKey,
-        title: job.title,
-      }),
-    )
-    .digest('hex')
+  const digest = sha256Hex(
+    JSON.stringify({
+      orgId: job.orgId,
+      source: job.source,
+      sourceId: job.sourceId,
+      sourceCanonicalKey: job.sourceCanonicalKey,
+      sourceVersionKey: job.sourceVersionKey,
+      title: job.title,
+    }),
+  )
 
   return `doc__${digest}`
 }
@@ -67,68 +60,50 @@ export function createDocumentProcessorQueueRuntime<TJob extends DocumentProcess
   workerName?: string
   concurrency?: number
   lockDuration?: number
-}): {
-  enqueue: (job: TJob) => Promise<unknown>
-  startWorker: (options?: { registerSignals?: boolean }) => WorkerHandle
-} {
-  type QueueShape = Queue<TJob, unknown, string, TJob, unknown, string>
-
+}): { enqueue: (job: TJob) => Promise<void>; startWorker: (options?: { registerSignals?: boolean }) => WorkerHandle } {
   const queueName = params.queueName ?? DEFAULT_DOCUMENT_PROCESSOR_QUEUE
   const workerName = params.workerName ?? DEFAULT_WORKER_NAME
   const concurrency = params.concurrency ?? 10
   const lockDuration = params.lockDuration ?? 300_000
-  const jobName = 'process-document' as Parameters<QueueShape['add']>[0]
-  const toQueueData = (job: TJob): Parameters<QueueShape['add']>[1] => job
-  let queue: QueueShape | null = null
-  const getConnection = (): IORedis => params.getConnectionForBullMQ()
-
-  const getQueue = (): QueueShape => {
-    if (queue) {
-      return queue
-    }
-
-    queue = new Queue<TJob, unknown, string, TJob, unknown, string>(queueName, {
-      connection: getConnection() as QueueOptions['connection'],
-      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 1000 } },
-    })
-
-    return queue
-  }
+  const queueRuntime = createQueueFactory<TJob>({
+    name: queueName,
+    displayName: workerName,
+    jobName: 'process-document',
+    concurrency,
+    lockDuration,
+    logger: params.logger,
+    connectionProvider: params.getConnectionForBullMQ,
+    defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 1000 } },
+    processorPath: params.getWorkerPath(),
+  })
 
   return {
-    enqueue: async (job) => {
-      const queuedJob = await getQueue().add(jobName, toQueueData(job), { jobId: buildDocumentProcessorJobId(job) })
-      try {
-        await queueJobService.recordEnqueued({
-          queueName,
-          id: queuedJob.id,
-          name: queuedJob.name,
-          data: queuedJob.data,
-          opts: queuedJob.opts,
-          attemptsMade: queuedJob.attemptsMade,
-          timestamp: queuedJob.timestamp,
-        })
-      } catch (error) {
-        params.logger.error`Failed to persist queued job metadata (queue=${queueName}, job=${queuedJob.id}): ${error}`
-      }
-    },
-    startWorker: (options = {}) => {
-      const { registerSignals = import.meta.main } = options
-      const worker = new Worker(queueName, params.getWorkerPath(), {
-        connection: getConnection() as QueueOptions['connection'],
-        concurrency,
-        lockDuration,
-      })
-
-      attachWorkerEvents(worker, workerName, params.logger)
-
-      const shutdown = createWorkerShutdown(worker, workerName, params.logger)
-
-      if (registerSignals) {
-        registerShutdownSignals({ name: workerName, shutdown, logger: params.logger })
-      }
-
-      return { worker, shutdown }
+    enqueue: (job) => {
+      return Effect.runPromise(
+        Effect.gen(function* () {
+          const queuedJob = yield* Effect.tryPromise(() =>
+            queueRuntime.getQueue().add('process-document', job, { jobId: buildDocumentProcessorJobId(job) }),
+          )
+
+          yield* Effect.catch(
+            getQueueJobService().recordEnqueued({
+              queueName,
+              id: queuedJob.id,
+              name: queuedJob.name,
+              data: queuedJob.data,
+              opts: queuedJob.opts,
+              attemptsMade: queuedJob.attemptsMade,
+              timestamp: queuedJob.timestamp,
+            }),
+            (error) =>
+              Effect.sync(() => {
+                params.logger
+                  .error`Failed to persist queued job metadata (queue=${queueName}, job=${queuedJob.id}): ${error}`
+              }),
+          )
+        }),
+      )
     },
+    startWorker: (options = {}) => queueRuntime.startWorker(options),
   }
 }

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

@@ -1,7 +1,14 @@
+import { Effect } from 'effect'
+
 import { serverLogger } from '../config/logger'
-import { queueJobService } from '../services/queue-job.service'
-import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS, LOW_JOB_RETENTION } from '../workers/worker-utils'
+import {
+  getQueueJobService,
+  getWorkerPath,
+  LONG_JOB_LOCK_DURATION_MS,
+  LOW_JOB_RETENTION,
+} from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
 
 export interface MemoryConsolidationJob {
   scopeId?: string
@@ -20,40 +27,48 @@ const memoryConsolidation = createQueueFactory<MemoryConsolidationJob>({
   processorPath: getWorkerPath('memory-consolidation.worker.ts'),
 })
 
-export async function enqueueMemoryConsolidation(job: MemoryConsolidationJob = {}) {
-  await memoryConsolidation.enqueue(job, { jobId: job.scopeId ? `consolidate-turn:${job.scopeId}` : undefined })
+export function enqueueMemoryConsolidation(job: MemoryConsolidationJob = {}) {
+  return memoryConsolidation.enqueue(job, { jobId: job.scopeId ? `consolidate-turn:${job.scopeId}` : undefined })
 }
 
-export async function scheduleRecurringConsolidation() {
-  const queuedJob = await 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 } },
-      },
-    )
-
-  try {
-    await queueJobService.recordEnqueued({
-      queueName: 'memory-consolidation',
-      id: queuedJob.id,
-      name: queuedJob.name,
-      data: queuedJob.data,
-      opts: queuedJob.opts,
-      attemptsMade: queuedJob.attemptsMade,
-      timestamp: queuedJob.timestamp,
-    })
-  } catch (error) {
-    serverLogger.error`Failed to persist queued job metadata (queue=memory-consolidation, job=${queuedJob.id}): ${error}`
-  }
+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 } },
+            },
+          ),
+      )
+
+      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}`
+          }),
+      )
+    }),
+  )
 }
 
 export const startMemoryConsolidationWorker = memoryConsolidation.startWorker
 
-if (import.meta.main) {
+runStandaloneQueueWorker(() => {
   startMemoryConsolidationWorker()
-}
+})

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

@@ -1,5 +1,13 @@
+import { Effect, Schema } from 'effect'
+
 import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
+
+class OrganizationLearningQueueError extends Schema.TaggedErrorClass<OrganizationLearningQueueError>()(
+  '@lota-sdk/core/OrganizationLearningQueueError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
 export const ORGANIZATION_LEARNING_QUEUE = 'organization-learning'
 
@@ -67,12 +75,26 @@ export function enqueueSkillExtraction(job: Omit<SkillExtractionJob, 'kind'>) {
   )
 }
 
-export async function clearRegularChatMemoryDigestDeduplicationKey(orgId: string): Promise<void> {
-  await organizationLearningQueue.getQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId))
+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 const startOrganizationLearningWorker = organizationLearningQueue.startWorker
 
-if (import.meta.main) {
+runStandaloneQueueWorker(() => {
   startOrganizationLearningWorker()
-}
+})

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

@@ -1,11 +1,20 @@
 import type { Job } from 'bullmq'
+import { Effect, Schema } from 'effect'
+import type { Context } from 'effect'
+import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-import { databaseService } from '../db/service'
-import { planAgentHeartbeatService } from '../services/plan-agent-heartbeat.service'
+import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import { PlanAgentHeartbeatServiceTag } from '../services/plan/plan-agent-heartbeat.service'
 import type { WorkerHandle } from '../workers/worker-utils'
 import { DEFAULT_JOB_RETENTION, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
-import { createQueueFactory } from './queue-factory'
+import { createQueueFactoryWithDeps } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
+
+class PlanAgentHeartbeatQueueError extends Schema.TaggedErrorClass<PlanAgentHeartbeatQueueError>()(
+  '@lota-sdk/core/PlanAgentHeartbeatQueueError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
 export interface PlanAgentHeartbeatWakeJob {
   type: 'wake-node'
@@ -28,31 +37,54 @@ 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'
 
-async function enqueueDelayedPlanAgentHeartbeatSweep(delayMs = PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS): Promise<void> {
-  await planAgentHeartbeatQueue.enqueue({ type: 'sweep' }, { delay: delayMs, jobId: PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID })
+interface PlanAgentHeartbeatQueueDeps {
+  databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
+  planAgentHeartbeatService: Context.Service.Shape<typeof PlanAgentHeartbeatServiceTag>
 }
 
-async function processPlanAgentHeartbeatJob(job: Job<PlanAgentHeartbeatJob>): Promise<void> {
-  await databaseService.connect()
-
-  if (job.data.type === 'wake-node') {
-    await planAgentHeartbeatService.wakeNode(job.data)
-    return
-  }
+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 },
+  )
+}
 
-  await planAgentHeartbeatService.sweep({ organizationId: job.data.organizationId })
-  if (!job.data.organizationId) {
-    await enqueueDelayedPlanAgentHeartbeatSweep()
-  }
+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,
+            }),
+        })
+      }
+    }),
+  )
 }
 
-const planAgentHeartbeatQueue = createQueueFactory<PlanAgentHeartbeatJob>({
+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,
 })
 
@@ -68,7 +100,7 @@ function buildWakeJobId(params: {
   return `plan-agent-wake__${encode(params.runId)}__${encode(params.nodeId)}__${encode(params.agentId)}`
 }
 
-export async function enqueuePlanAgentHeartbeatWake(params: {
+export function enqueuePlanAgentHeartbeatWake(params: {
   organizationId: string
   threadId: string
   runId: string
@@ -76,11 +108,19 @@ export async function enqueuePlanAgentHeartbeatWake(params: {
   agentId: string
   reason: string
 }): Promise<void> {
-  await planAgentHeartbeatQueue.enqueue({ type: 'wake-node', ...params }, { jobId: buildWakeJobId(params) })
+  return planAgentHeartbeatQueue.enqueue({ type: 'wake-node', ...params }, { jobId: buildWakeJobId(params) })
 }
 
-export function startPlanAgentHeartbeatWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const handle = planAgentHeartbeatQueue.startWorker(options)
+export function startPlanAgentHeartbeatWorker(options: {
+  registerSignals?: boolean
+  connectionProvider: () => IORedis
+  deps: PlanAgentHeartbeatQueueDeps
+}): WorkerHandle {
+  const handle = planAgentHeartbeatQueue.startWorker({
+    deps: options.deps,
+    registerSignals: options.registerSignals,
+    connectionProvider: options.connectionProvider,
+  })
 
   enqueueDelayedPlanAgentHeartbeatSweep().catch((error: unknown) => {
     serverLogger.error`Plan agent heartbeat scheduler setup failed: ${error}`
@@ -89,6 +129,13 @@ export function startPlanAgentHeartbeatWorker(options: { registerSignals?: boole
   return handle
 }
 
-if (import.meta.main) {
-  startPlanAgentHeartbeatWorker()
-}
+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),
+    },
+  })
+})