@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -1,17 +1,29 @@
 import type { Job } from 'bullmq'
-import { Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-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 { 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 { createQueueFactory } from './queue-factory'
+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) },
+) {}
+
 export interface PlanAgentHeartbeatWakeJob {
   type: 'wake-node'
   organizationId: string
@@ -33,58 +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>
+  planAgentHeartbeatService: PlanAgentHeartbeatWorkerServiceShape
 }
 
-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
-}
-
-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(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>({
-  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: () => getDeps().databaseService.connect(),
-  processor: processPlanAgentHeartbeatJob,
-})
-
 function buildWakeJobId(params: {
   organizationId: string
   threadId: string
@@ -97,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 {
-  _deps = options.deps
-  const handle = planAgentHeartbeatQueue.startWorker({
-    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),
+      },
+    })
+  })()
 })

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

@@ -4,15 +4,15 @@ import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-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 { QueueJobServiceTag } from '../services/queue-job.service'
 import { nowEpochMillis } from '../utils/date-time'
-import type { WorkerHandle } from '../workers/worker-utils'
-import { createQueueFactory } from './queue-factory'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
 export interface PlanSchedulerFireJob {
@@ -29,7 +29,7 @@ export type PlanSchedulerJob = PlanSchedulerFireJob | PlanSchedulerDeadlineJob
 
 export const PLAN_SCHEDULER_QUEUE = 'plan-scheduler'
 
-interface PlanSchedulerQueueDeps {
+export interface PlanSchedulerWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
   planSchedulerService: Context.Service.Shape<typeof PlanSchedulerServiceTag>
   planDeadlineService: Context.Service.Shape<typeof PlanDeadlineServiceTag>
@@ -37,16 +37,6 @@ interface PlanSchedulerQueueDeps {
   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,
@@ -57,111 +47,125 @@ function toPlanSchedulerQueueError(stage: PlanSchedulerQueueError['stage'], caus
   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()
+function processPlanSchedulerJob(deps: PlanSchedulerWorkerDeps, job: Job<PlanSchedulerJob>): Promise<void> {
+  const { planSchedulerService, planDeadlineService, planExecutorService, planCycleService } = deps
+  const runWithResolvedContext = <A, E>(effect: Effect.Effect<A, E, unknown>): Promise<void> =>
+    // Service Effects carry their provided context through the managed runtime
+    // that resolved these service tags, so residual R collapses at runtime.
+    Effect.runPromise(Effect.asVoid(effect as Effect.Effect<A, E, never>))
 
   switch (job.data.type) {
     case 'fire-schedule':
-      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())),
-          }),
-        ),
+      return runWithResolvedContext(
+        planSchedulerService.fireScheduleById(job.data.scheduleId, {
+          promoteDelayedNode: (params) => runWithResolvedContext(planExecutorService.promoteDelayedNode(params)),
+          advanceCycle: (cycleId) => runWithResolvedContext(planCycleService.advanceCycle(cycleId)),
+          recoverDeadlineChecks: () => runWithResolvedContext(planDeadlineService.recoverDeadlineChecks()),
+        }),
       )
     case 'check-deadlines':
-      return Effect.runPromise(Effect.asVoid(planDeadlineService.checkDeadlines()))
+      return runWithResolvedContext(planDeadlineService.checkDeadlines())
   }
 }
 
-const planScheduler = createQueueFactory<PlanSchedulerJob>({
-  name: PLAN_SCHEDULER_QUEUE,
-  displayName: 'Plan scheduler',
-  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 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 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 function enqueueDeadlineCheck(scheduledFor: Date): Promise<void> {
-  const delay = Math.max(0, scheduledFor.getTime() - nowEpochMillis())
-  return planScheduler.enqueue(
-    { type: 'check-deadlines', scheduledFor: scheduledFor.toISOString() },
-    {
-      delay,
-      jobId: `${DEADLINE_CHECK_JOB_PREFIX}:${scheduledFor.getTime()}`,
-      removeOnComplete: true,
-      removeOnFail: 50,
-    },
-  )
+export interface PlanSchedulerQueueRuntime {
+  enqueueScheduleFire(scheduleId: string, delayMs: number): Promise<void>
+  removeScheduleFireJob(scheduleId: string): Promise<void>
+  enqueueDeadlineCheck(scheduledFor: Date): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: PlanSchedulerWorkerDeps }): WorkerHandle
 }
 
-export function startPlanSchedulerWorker(options: {
-  registerSignals?: boolean
+interface MakePlanSchedulerQueueRuntimeParams {
   connectionProvider: () => IORedis
-  deps: PlanSchedulerQueueDeps
-}): WorkerHandle {
-  _deps = options.deps
-  const handle = planScheduler.startWorker({
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
+  queueJobService: QueueJobService
+}
+
+export function makePlanSchedulerQueueRuntime(params: MakePlanSchedulerQueueRuntimeParams): PlanSchedulerQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+
+  const queue = createQueueFactoryWithDeps<PlanSchedulerJob, PlanSchedulerWorkerDeps>({
+    name: PLAN_SCHEDULER_QUEUE,
+    displayName: 'Plan scheduler',
+    jobName: 'plan-scheduler-job',
+    concurrency: 1,
+    defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 5000 } },
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processPlanSchedulerJob,
   })
 
-  // Recover active schedules on startup
-  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}`
-        }),
+  const enqueueScheduleFire: PlanSchedulerQueueRuntime['enqueueScheduleFire'] = (scheduleId, delayMs) =>
+    queue.enqueue(
+      { type: 'fire-schedule', scheduleId },
+      { delay: Math.max(0, delayMs), jobId: `schedule:${scheduleId}`, removeOnComplete: true, removeOnFail: 50 },
+    )
+
+  const removeScheduleFireJob: PlanSchedulerQueueRuntime['removeScheduleFireJob'] = (scheduleId) =>
+    Effect.runPromise(
+      Effect.tryPromise({
+        try: () => queue.getQueue().remove(`schedule:${scheduleId}`),
+        catch: (cause) => toPlanSchedulerQueueError('remove-schedule-fire-job', cause),
+      }).pipe(Effect.asVoid),
+    )
+
+  const enqueueDeadlineCheck: PlanSchedulerQueueRuntime['enqueueDeadlineCheck'] = (scheduledFor) => {
+    const delay = Math.max(0, scheduledFor.getTime() - nowEpochMillis())
+    return queue.enqueue(
+      { type: 'check-deadlines', scheduledFor: scheduledFor.toISOString() },
+      {
+        delay,
+        jobId: `${DEADLINE_CHECK_JOB_PREFIX}:${scheduledFor.getTime()}`,
+        removeOnComplete: true,
+        removeOnFail: 50,
+      },
+    )
+  }
+
+  const startWorker: PlanSchedulerQueueRuntime['startWorker'] = (options) => {
+    const { deps } = options
+    const handle = queue.startWorker({ deps, registerSignals: options.registerSignals, connectionProvider })
+
+    // Recover active schedules on startup
+    void Effect.runFork(
+      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.
-  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}`
-        }),
+    )
+
+    // Seed deadline checks from current runtime state.
+    void Effect.runFork(
+      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
+    return handle
+  }
+
+  return { enqueueScheduleFire, removeScheduleFireJob, enqueueDeadlineCheck, startWorker }
 }
 
 runStandaloneQueueWorker((runtime) => {
   const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
-  startPlanSchedulerWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
+  const redis = resolve(RedisServiceTag)
+  const planSchedulerQueue = makePlanSchedulerQueueRuntime({
+    connectionProvider: () => redis.getConnectionForBullMQ(),
+    queueJobService: resolve(QueueJobServiceTag),
+  })
+  planSchedulerQueue.startWorker({
     deps: {
       databaseService: resolve(DatabaseServiceTag),
       planSchedulerService: resolve(PlanSchedulerServiceTag),

package/src/queues/post-chat-memory.queue.ts

@@ -3,11 +3,12 @@ import { Effect } from 'effect'
 import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
-import type { MaybeAwaitableService } from '../effect/awaitable-effect'
-import { ConfigurationError } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import type { RedisConnectionManager } from '../redis/connection'
 import { MemoryServiceTag } from '../services/memory/memory.service'
-import { createQueueFactory } from './queue-factory'
+import { QueueJobServiceTag } from '../services/queue-job.service'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
 interface PostChatMemoryMessage {
@@ -16,7 +17,7 @@ interface PostChatMemoryMessage {
   agentName?: string
 }
 
-interface PostChatMemoryExtractionJob {
+export interface PostChatMemoryExtractionJob {
   orgId: string
   threadId: string
   sourceId: string
@@ -30,24 +31,17 @@ interface PostChatMemoryExtractionJob {
   attachmentContext?: string
 }
 
-interface PostChatMemoryQueueDeps {
+export interface PostChatMemoryWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
-  memoryService: MaybeAwaitableService<Context.Service.Shape<typeof MemoryServiceTag>>
+  memoryService: Context.Service.Shape<typeof MemoryServiceTag>
+  redisManager: RedisConnectionManager
 }
 
-let _deps: PostChatMemoryQueueDeps | null = null
-function getDeps(): PostChatMemoryQueueDeps {
-  if (!_deps)
-    throw new ConfigurationError({
-      message: 'Post-chat memory queue is not configured. Initialize the runtime before starting the worker.',
-      key: 'queue-deps',
-    })
-  return _deps
-}
-
-function processPostChatMemoryJob(job: Job<PostChatMemoryExtractionJob>): Promise<void> {
-  const { memoryService } = getDeps()
-
+function processPostChatMemoryJob(
+  deps: PostChatMemoryWorkerDeps,
+  job: Job<PostChatMemoryExtractionJob>,
+): Promise<void> {
+  const { memoryService, redisManager } = deps
   const data = job.data
   const userMessage = data.userMessage.trim()
   const agentMessages = data.agentMessages
@@ -89,43 +83,59 @@ function processPostChatMemoryJob(job: Job<PostChatMemoryExtractionJob>): Promis
         attachmentContext: data.attachmentContext,
         agentNames: uniqueAgentNames,
       }),
-    ),
+    ).pipe(Effect.provideService(RedisServiceTag, redisManager)),
   )
 }
 
-const postChatMemory = createQueueFactory<PostChatMemoryExtractionJob>({
-  name: 'post-chat-memory',
-  displayName: 'Post-chat memory',
-  jobName: 'extract-memory',
-  concurrency: 10,
-  lockDuration: 900_000,
-  maxStalledCount: 10,
-  stalledInterval: 120_000,
-  defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
-  prepare: () => getDeps().databaseService.connect(),
-  processor: processPostChatMemoryJob,
-})
-
-export function enqueuePostChatMemory(job: PostChatMemoryExtractionJob, options?: { dedupeKey?: string }) {
-  return postChatMemory.enqueue(job, options?.dedupeKey ? { jobId: options.dedupeKey } : undefined)
+export interface PostChatMemoryQueueRuntime {
+  enqueuePostChatMemory(job: PostChatMemoryExtractionJob, options?: { dedupeKey?: string }): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: PostChatMemoryWorkerDeps }): WorkerHandle
 }
 
-export function startPostChatMemoryWorker(options: {
-  registerSignals?: boolean
+interface MakePostChatMemoryQueueRuntimeParams {
   connectionProvider: () => IORedis
-  deps: PostChatMemoryQueueDeps
-}) {
-  _deps = options.deps
-  return postChatMemory.startWorker({
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
+  queueJobService: QueueJobService
+}
+
+export function makePostChatMemoryQueueRuntime(
+  params: MakePostChatMemoryQueueRuntimeParams,
+): PostChatMemoryQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+  const queue = createQueueFactoryWithDeps<PostChatMemoryExtractionJob, PostChatMemoryWorkerDeps>({
+    name: 'post-chat-memory',
+    displayName: 'Post-chat memory',
+    jobName: 'extract-memory',
+    concurrency: 10,
+    lockDuration: 900_000,
+    maxStalledCount: 10,
+    stalledInterval: 120_000,
+    defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processPostChatMemoryJob,
   })
+
+  return {
+    enqueuePostChatMemory: (job, options) =>
+      queue.enqueue(job, options?.dedupeKey ? { jobId: options.dedupeKey } : undefined),
+    startWorker: (options) =>
+      queue.startWorker({ deps: options.deps, registerSignals: options.registerSignals, connectionProvider }),
+  }
 }
 
 runStandaloneQueueWorker((runtime) => {
   const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
-  startPostChatMemoryWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
-    deps: { databaseService: resolve(DatabaseServiceTag), memoryService: resolve(MemoryServiceTag) },
+  const redis = resolve(RedisServiceTag)
+  const postChatMemoryQueue = makePostChatMemoryQueueRuntime({
+    connectionProvider: () => redis.getConnectionForBullMQ(),
+    queueJobService: resolve(QueueJobServiceTag),
+  })
+  postChatMemoryQueue.startWorker({
+    deps: {
+      databaseService: resolve(DatabaseServiceTag),
+      memoryService: resolve(MemoryServiceTag),
+      redisManager: redis,
+    },
   })
 })