@lota-sdk/core 0.4.8 → 0.4.9

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,8 @@
+import { Effect } from 'effect'
+
 import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
 
 export const ORGANIZATION_LEARNING_QUEUE = 'organization-learning'
 
@@ -67,12 +70,18 @@ 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(() =>
+        organizationLearningQueue.getQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId)),
+      ),
+    ),
+  )
 }
 
 export const startOrganizationLearningWorker = organizationLearningQueue.startWorker
 
-if (import.meta.main) {
+runStandaloneQueueWorker(() => {
   startOrganizationLearningWorker()
-}
+})

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

@@ -1,11 +1,16 @@
 import type { Job } from 'bullmq'
+import { Effect } 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 { ConfigurationError } from '../effect/errors'
+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 { runStandaloneQueueWorker } from './standalone-worker'
 
 export interface PlanAgentHeartbeatWakeJob {
   type: 'wake-node'
@@ -28,22 +33,45 @@ 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()
+let _deps: PlanAgentHeartbeatQueueDeps | null = null
+function getDeps(): PlanAgentHeartbeatQueueDeps {
+  if (!_deps)
+    throw new ConfigurationError({
+      message: 'Plan agent heartbeat queue is not configured. Initialize the runtime before starting the worker.',
+      key: 'queue-deps',
+    })
+  return _deps
+}
 
-  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(job: Job<PlanAgentHeartbeatJob>): Promise<void> {
+  const { planAgentHeartbeatService } = getDeps()
+
+  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(() => enqueueDelayedPlanAgentHeartbeatSweep())
+      }
+    }),
+  )
 }
 
 const planAgentHeartbeatQueue = createQueueFactory<PlanAgentHeartbeatJob>({
@@ -53,6 +81,7 @@ const planAgentHeartbeatQueue = createQueueFactory<PlanAgentHeartbeatJob>({
   concurrency: 2,
   lockDuration: LONG_JOB_LOCK_DURATION_MS,
   defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 5_000 } },
+  prepare: () => getDeps().databaseService.connect(),
   processor: processPlanAgentHeartbeatJob,
 })
 
@@ -68,7 +97,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 +105,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 {
+  _deps = options.deps
+  const handle = planAgentHeartbeatQueue.startWorker({
+    registerSignals: options.registerSignals,
+    connectionProvider: options.connectionProvider,
+  })
 
   enqueueDelayedPlanAgentHeartbeatSweep().catch((error: unknown) => {
     serverLogger.error`Plan agent heartbeat scheduler setup failed: ${error}`
@@ -89,6 +126,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),
+    },
+  })
+})

package/src/queues/plan-scheduler.queue.ts

@@ -1,11 +1,19 @@
 import type { Job } from 'bullmq'
+import { Schema, Effect } from 'effect'
+import type { Context } from 'effect'
+import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-import { databaseService } from '../db/service'
-import { planDeadlineService } from '../services/plan-deadline.service'
-import { planSchedulerService } from '../services/plan-scheduler.service'
+import { ConfigurationError } from '../effect/errors'
+import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import { PlanCycleServiceTag } from '../services/plan/plan-cycle.service'
+import { PlanDeadlineServiceTag } from '../services/plan/plan-deadline.service'
+import { PlanExecutorServiceTag } from '../services/plan/plan-executor.service'
+import { PlanSchedulerServiceTag } from '../services/plan/plan-scheduler.service'
+import { nowEpochMillis } from '../utils/date-time'
 import type { WorkerHandle } from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
 
 export interface PlanSchedulerFireJob {
   type: 'fire-schedule'
@@ -21,16 +29,50 @@ export type PlanSchedulerJob = PlanSchedulerFireJob | PlanSchedulerDeadlineJob
 
 export const PLAN_SCHEDULER_QUEUE = 'plan-scheduler'
 
-async function processPlanSchedulerJob(job: Job<PlanSchedulerJob>): Promise<void> {
-  await databaseService.connect()
+interface PlanSchedulerQueueDeps {
+  databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
+  planSchedulerService: Context.Service.Shape<typeof PlanSchedulerServiceTag>
+  planDeadlineService: Context.Service.Shape<typeof PlanDeadlineServiceTag>
+  planExecutorService: Context.Service.Shape<typeof PlanExecutorServiceTag>
+  planCycleService: Context.Service.Shape<typeof PlanCycleServiceTag>
+}
+
+let _deps: PlanSchedulerQueueDeps | null = null
+function getDeps(): PlanSchedulerQueueDeps {
+  if (!_deps)
+    throw new ConfigurationError({
+      message: 'Plan scheduler queue is not configured. Initialize the runtime before starting the worker.',
+      key: 'queue-deps',
+    })
+  return _deps
+}
+
+class PlanSchedulerQueueError extends Schema.TaggedErrorClass<PlanSchedulerQueueError>()('PlanSchedulerQueueError', {
+  stage: Schema.Literals(['remove-schedule-fire-job', 'recover-active-schedules', 'recover-deadline-checks']),
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function toPlanSchedulerQueueError(stage: PlanSchedulerQueueError['stage'], cause: unknown): PlanSchedulerQueueError {
+  return new PlanSchedulerQueueError({ stage, message: cause instanceof Error ? cause.message : String(cause), cause })
+}
+
+function processPlanSchedulerJob(job: Job<PlanSchedulerJob>): Promise<void> {
+  const { planSchedulerService, planDeadlineService, planExecutorService, planCycleService } = getDeps()
 
   switch (job.data.type) {
     case 'fire-schedule':
-      await planSchedulerService.fireScheduleById(job.data.scheduleId)
-      break
+      return Effect.runPromise(
+        Effect.asVoid(
+          planSchedulerService.fireScheduleById(job.data.scheduleId, {
+            promoteDelayedNode: (params) => planExecutorService.promoteDelayedNode(params),
+            advanceCycle: (cycleId) => planCycleService.advanceCycle(cycleId),
+            recoverDeadlineChecks: () => Effect.runPromise(Effect.asVoid(planDeadlineService.recoverDeadlineChecks())),
+          }),
+        ),
+      )
     case 'check-deadlines':
-      await planDeadlineService.checkDeadlines()
-      break
+      return Effect.runPromise(Effect.asVoid(planDeadlineService.checkDeadlines()))
   }
 }
 
@@ -40,31 +82,33 @@ const planScheduler = createQueueFactory<PlanSchedulerJob>({
   jobName: 'plan-scheduler-job',
   concurrency: 1,
   defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 5000 } },
+  prepare: () => getDeps().databaseService.connect(),
   processor: processPlanSchedulerJob,
 })
 
 /** Enqueue a delayed job that fires a specific schedule at its nextFireAt time. */
-export async function enqueueScheduleFire(scheduleId: string, delayMs: number): Promise<void> {
-  await planScheduler.enqueue(
+export function enqueueScheduleFire(scheduleId: string, delayMs: number): Promise<void> {
+  return planScheduler.enqueue(
     { type: 'fire-schedule', scheduleId },
     { delay: Math.max(0, delayMs), jobId: `schedule:${scheduleId}`, removeOnComplete: true, removeOnFail: 50 },
   )
 }
 
 /** Remove a pending fire job for a schedule (on cancel/pause/complete). */
-export async function removeScheduleFireJob(scheduleId: string): Promise<void> {
-  try {
-    await planScheduler.getQueue().remove(`schedule:${scheduleId}`)
-  } catch {
-    // Job may not exist (already fired or never enqueued) — safe to ignore
-  }
+export function removeScheduleFireJob(scheduleId: string): Promise<void> {
+  return Effect.runPromise(
+    Effect.tryPromise({
+      try: () => planScheduler.getQueue().remove(`schedule:${scheduleId}`),
+      catch: (cause) => toPlanSchedulerQueueError('remove-schedule-fire-job', cause),
+    }).pipe(Effect.asVoid),
+  )
 }
 
 const DEADLINE_CHECK_JOB_PREFIX = 'deadline-check'
 
-export async function enqueueDeadlineCheck(scheduledFor: Date): Promise<void> {
-  const delay = Math.max(0, scheduledFor.getTime() - Date.now())
-  await planScheduler.enqueue(
+export function enqueueDeadlineCheck(scheduledFor: Date): Promise<void> {
+  const delay = Math.max(0, scheduledFor.getTime() - nowEpochMillis())
+  return planScheduler.enqueue(
     { type: 'check-deadlines', scheduledFor: scheduledFor.toISOString() },
     {
       delay,
@@ -75,23 +119,55 @@ export async function enqueueDeadlineCheck(scheduledFor: Date): Promise<void> {
   )
 }
 
-export function startPlanSchedulerWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const handle = planScheduler.startWorker(options)
+export function startPlanSchedulerWorker(options: {
+  registerSignals?: boolean
+  connectionProvider: () => IORedis
+  deps: PlanSchedulerQueueDeps
+}): WorkerHandle {
+  _deps = options.deps
+  const handle = planScheduler.startWorker({
+    registerSignals: options.registerSignals,
+    connectionProvider: options.connectionProvider,
+  })
 
   // Recover active schedules on startup
-  planSchedulerService.recoverActiveSchedules().catch((err: unknown) => {
-    serverLogger.error`Plan scheduler startup recovery failed: ${err}`
-  })
+  void Effect.runFork(
+    options.deps.planSchedulerService.recoverActiveSchedules().pipe(
+      Effect.mapError((cause) => toPlanSchedulerQueueError('recover-active-schedules', cause)),
+      Effect.catchTag('PlanSchedulerQueueError', (error) =>
+        Effect.sync(() => {
+          serverLogger.error`Plan scheduler startup recovery failed: ${error.message}`
+        }),
+      ),
+    ),
+  )
 
   // Seed deadline checks from current runtime state. Subsequent checks are
   // re-seeded by the queue job after each sweep and by schedule fire events.
-  planDeadlineService.recoverDeadlineChecks().catch((err: unknown) => {
-    serverLogger.error`Plan deadline recovery failed: ${err}`
-  })
+  void Effect.runFork(
+    options.deps.planDeadlineService.recoverDeadlineChecks().pipe(
+      Effect.mapError((cause) => toPlanSchedulerQueueError('recover-deadline-checks', cause)),
+      Effect.catchTag('PlanSchedulerQueueError', (error) =>
+        Effect.sync(() => {
+          serverLogger.error`Plan deadline recovery failed: ${error.message}`
+        }),
+      ),
+    ),
+  )
 
   return handle
 }
 
-if (import.meta.main) {
-  startPlanSchedulerWorker()
-}
+runStandaloneQueueWorker((runtime) => {
+  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+  startPlanSchedulerWorker({
+    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
+    deps: {
+      databaseService: resolve(DatabaseServiceTag),
+      planSchedulerService: resolve(PlanSchedulerServiceTag),
+      planDeadlineService: resolve(PlanDeadlineServiceTag),
+      planExecutorService: resolve(PlanExecutorServiceTag),
+      planCycleService: resolve(PlanCycleServiceTag),
+    },
+  })
+})