@lota-sdk/core 0.4.10 → 0.4.12

package/src/effect/index.ts

@@ -1,7 +1,5 @@
-export * from './awaitable-effect'
 export * from './helpers'
 export * from './layers'
-export * from './runtime'
 export * from './services'
 export * from './zod'
 export {

package/src/effect/layers.ts

@@ -7,7 +7,7 @@ import { Otlp } from 'effect/unstable/observability'
 import type { CoreThreadProfile } from '../config/agent-defaults'
 import { resolveAgentConfig, resolveAgentFactoryConfig } from '../config/agent-defaults'
 import type { AgentFactory, AgentRuntimeConfigProvider, AgentToolBuilder } from '../config/agent-types'
-import { configureLotaLogger, getLotaLoggers, toEffectLogLevel } from '../config/logger'
+import { getLotaLoggers, toEffectLogLevel } from '../config/logger'
 import type { LotaLogLevel } from '../config/logger'
 import { resolveThreadConfig } from '../config/thread-defaults'
 import type { LotaThreadConfig } from '../config/thread-defaults'
@@ -67,19 +67,12 @@ export function RedisLive(config: CreateRedisConnectionManagerOptions) {
 }
 
 export function AppLoggerLive(level: LotaLogLevel = 'info') {
-  // Sequence `configureLotaLogger(level)` before `getLotaLoggers()` inside a
-  // single Effect.sync so the log-level mutation is observed when the loggers
-  // are assembled. `Layer.mergeAll` builds in parallel, so splitting these
-  // across two sub-layers is an ordering hazard.
-  const AppLoggersLayer = Layer.effect(
-    AppLoggerTag,
-    Effect.sync(() => {
-      configureLotaLogger(level)
-      return getLotaLoggers()
-    }),
-  )
+  // The logger level used by `serverLogger`/`chatLogger`/`aiLogger` is read
+  // once from `LOG_LEVEL` at module load. This layer wires the Effect-side
+  // console logger and minimum level plus the `AppLoggerTag` for callers
+  // that want the logger set from context.
   return Layer.mergeAll(
-    AppLoggersLayer,
+    Layer.succeed(AppLoggerTag, getLotaLoggers()),
     Logger.layer([Logger.consolePretty()]),
     Layer.succeed(References.MinimumLogLevel, toEffectLogLevel(level)),
   )

package/src/embeddings/provider.ts

@@ -2,7 +2,6 @@ import { embed, embedMany } from 'ai'
 import { Schema, Effect } from 'effect'
 
 import { ConfigurationError } from '../effect/errors'
-import { runPromiseWithOptionalLotaRuntime } from '../effect/runtime'
 import { getDirectOpenRouterProvider, normalizeDirectOpenRouterModelId } from '../openrouter/direct-provider'
 
 const SUPPORTED_EMBEDDING_PREFIXES = ['openai/', 'openrouter/'] as const
@@ -92,10 +91,6 @@ export class ProviderEmbeddings {
     return redisCache.get(this.getModelId(), text)
   }
 
-  private runEffect<A>(effect: Effect.Effect<A, EmbeddingProviderError>): Promise<A> {
-    return runPromiseWithOptionalLotaRuntime(effect)
-  }
-
   embedQuery(text: string): Promise<number[]> {
     const input = text.trim()
     if (!input) return Promise.resolve([])
@@ -104,7 +99,7 @@ export class ProviderEmbeddings {
     const pending = this.inflightEmbeddings.get(dedupKey)
     if (pending) return pending
 
-    const promise = this.runEffect(this.executeEmbedQueryEffect(input))
+    const promise = Effect.runPromise(this.executeEmbedQueryEffect(input))
     this.inflightEmbeddings.set(dedupKey, promise)
     void promise.finally(() => this.inflightEmbeddings.delete(dedupKey))
 
@@ -149,7 +144,7 @@ export class ProviderEmbeddings {
     }
 
     const uniqueTexts = [...new Set(nonEmptyEntries.map((entry) => entry.value))]
-    return this.runEffect(this.embedDocumentsEffect(normalized, uniqueTexts))
+    return Effect.runPromise(this.embedDocumentsEffect(normalized, uniqueTexts))
   }
 
   private embedDocumentsEffect(

package/src/index.ts

@@ -17,7 +17,9 @@ export { Effect } from 'effect'
 export {
   ActiveThreadRunConflictError,
   AgentConfigLive,
+  AgentConfigServiceTag,
   AgentFactoryLive,
+  AgentFactoryServiceTag,
   AiGenerationError,
   AppLoggerLive,
   AppLoggerTag,
@@ -26,12 +28,14 @@ export {
   ConflictError,
   DatabaseError,
   DatabaseLive,
+  DatabaseServiceTag,
   DatabaseServiceTag as EffectDatabaseService,
   ForbiddenError,
   LockAcquisitionError,
   LockLostError,
   RedisError,
   RedisLive,
+  RedisServiceTag,
   RedisServiceTag as EffectRedisService,
   RuntimeAdaptersServiceTag,
   RuntimeConfigLive,
@@ -46,13 +50,8 @@ export {
   ToolProvidersServiceTag,
   TurnHooksServiceTag,
   ValidationError,
-  clearLotaSdkRuntime,
-  getLotaSdkRuntime,
   isEffectError,
-  setLotaSdkRuntime,
   summarizeZodIssues,
-  toAwaitableEffect,
-  toAwaitableService,
   toValidationError,
   toValidationIssues,
   zodParse,

package/src/queues/autonomous-job.queue.ts

@@ -6,13 +6,25 @@ import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
-import { AutonomousJobServiceTag } from '../services/autonomous-job.service'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { buildAutonomousAtJobId } from '../utils/autonomous-job-ids'
-import type { WorkerHandle } from '../workers/worker-utils'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 import { DEFAULT_JOB_RETENTION } from '../workers/worker-utils'
 import { createQueueFactoryWithDeps, recordEnqueuedJobMetadata } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
+// Minimal service shape used by the queue's worker processor. We declare it
+// structurally to avoid importing `AutonomousJobServiceTag` — that would form a
+// dependency cycle since `AutonomousJobServiceLive` now depends on
+// `LotaQueuesServiceTag` (defined in `queues.service.ts` which imports this
+// module).
+interface AutonomousJobWorkerServiceShape {
+  executeQueuedRun(
+    job: Job<AutonomousJobQueuePayload>,
+  ): Effect.Effect<{ status: string; summary?: string }, unknown, unknown>
+  recoverActiveJobs(): Effect.Effect<unknown, unknown, unknown>
+}
+
 class AutonomousJobQueueError extends Schema.TaggedErrorClass<AutonomousJobQueueError>()(
   '@lota-sdk/core/AutonomousJobQueueError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
@@ -26,9 +38,9 @@ export interface AutonomousJobQueuePayload {
 
 export const AUTONOMOUS_JOB_QUEUE = 'autonomous-job'
 
-interface AutonomousJobQueueDeps {
+export interface AutonomousJobWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
-  autonomousJobService: Context.Service.Shape<typeof AutonomousJobServiceTag>
+  autonomousJobService: AutonomousJobWorkerServiceShape
 }
 
 const DEFAULT_AUTONOMOUS_JOB_OPTIONS = {
@@ -38,141 +50,175 @@ const DEFAULT_AUTONOMOUS_JOB_OPTIONS = {
 } as const
 
 function processAutonomousJob(
-  deps: AutonomousJobQueueDeps,
+  deps: AutonomousJobWorkerDeps,
   job: Job<AutonomousJobQueuePayload>,
 ): Promise<{ status: string; summary?: string }> {
-  return Effect.runPromise(deps.autonomousJobService.executeQueuedRun(job))
+  // `executeQueuedRun` is typed with a wide residual context to account for
+  // the dynamic thread-turn import inside the service; the actual Effect
+  // resolves every tag via the managed runtime that produced this service.
+  return Effect.runPromise(
+    deps.autonomousJobService.executeQueuedRun(job) as Effect.Effect<
+      { status: string; summary?: string },
+      never,
+      never
+    >,
+  )
 }
 
-const autonomousJobQueue = createQueueFactoryWithDeps<AutonomousJobQueuePayload, AutonomousJobQueueDeps>({
-  name: AUTONOMOUS_JOB_QUEUE,
-  displayName: 'Autonomous job',
-  jobName: 'run-autonomous-job',
-  concurrency: 2,
-  defaultJobOptions: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
-  prepare: ({ databaseService }) => databaseService.connect(),
-  processor: processAutonomousJob,
-})
-
 function buildAutonomousSchedulerId(autonomousJobId: string): string {
   return `autonomous:${autonomousJobId}`
 }
 
-export function enqueueAutonomousJobRun(params: {
-  payload: AutonomousJobQueuePayload
-  delayMs?: number
-  jobId?: string
-}): Promise<{ bullmqJobId: string; queueJobId?: string }> {
-  return Effect.runPromise(
-    Effect.gen(function* () {
-      const queuedJob = yield* Effect.tryPromise({
-        try: () =>
-          autonomousJobQueue
-            .getQueue()
-            .add('run-autonomous-job', params.payload, {
-              ...(typeof params.delayMs === 'number' ? { delay: Math.max(0, params.delayMs) } : {}),
-              ...(params.jobId ? { jobId: params.jobId } : {}),
-            }),
-        catch: (cause) => new AutonomousJobQueueError({ message: 'Failed to enqueue autonomous job run.', cause }),
-      })
+interface MakeAutonomousJobQueueRuntimeParams {
+  connectionProvider: () => IORedis
+  queueJobService: QueueJobService
+}
 
-      const bullmqJobId = String(queuedJob.id)
-      const queueJobId = yield* recordEnqueuedJobMetadata({ queueName: AUTONOMOUS_JOB_QUEUE, job: queuedJob })
-      return { bullmqJobId, queueJobId }
-    }),
-  )
+export interface AutonomousJobQueueRuntime {
+  enqueueAutonomousJobRun(params: {
+    payload: AutonomousJobQueuePayload
+    delayMs?: number
+    jobId?: string
+  }): Promise<{ bullmqJobId: string; queueJobId?: string }>
+  upsertAutonomousJobScheduler(params: {
+    autonomousJobId: string
+    schedule: Extract<AutonomousJobSchedule, { kind: 'cron' | 'every' }>
+  }): Promise<void>
+  removeAutonomousJobScheduler(autonomousJobId: string): Promise<void>
+  removeAutonomousAtJob(autonomousJobId: string): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: AutonomousJobWorkerDeps }): WorkerHandle
 }
 
-export function upsertAutonomousJobScheduler(params: {
-  autonomousJobId: string
-  schedule: Extract<AutonomousJobSchedule, { kind: 'cron' | 'every' }>
-}): Promise<void> {
-  const repeatOpts =
-    params.schedule.kind === 'cron' ? { pattern: params.schedule.cron } : { every: params.schedule.intervalMs }
-  return Effect.runPromise(
-    Effect.gen(function* () {
-      const queuedJob = yield* Effect.tryPromise({
-        try: () =>
-          autonomousJobQueue
-            .getQueue()
-            .upsertJobScheduler(buildAutonomousSchedulerId(params.autonomousJobId), repeatOpts, {
-              name: 'run-autonomous-job',
-              data: { autonomousJobId: params.autonomousJobId, trigger: 'scheduled' },
-              opts: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
-            }),
-        catch: (cause) =>
-          new AutonomousJobQueueError({
-            message: `Failed to upsert autonomous job scheduler for ${params.autonomousJobId}.`,
-            cause,
-          }),
-      })
+export function makeAutonomousJobQueueRuntime(params: MakeAutonomousJobQueueRuntimeParams): AutonomousJobQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+  const queue = createQueueFactoryWithDeps<AutonomousJobQueuePayload, AutonomousJobWorkerDeps>({
+    name: AUTONOMOUS_JOB_QUEUE,
+    displayName: 'Autonomous job',
+    jobName: 'run-autonomous-job',
+    concurrency: 2,
+    defaultJobOptions: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processAutonomousJob,
+  })
 
-      yield* recordEnqueuedJobMetadata({ queueName: AUTONOMOUS_JOB_QUEUE, job: queuedJob })
-    }),
-  )
-}
+  const enqueueAutonomousJobRun: AutonomousJobQueueRuntime['enqueueAutonomousJobRun'] = (request) =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        const queuedJob = yield* Effect.tryPromise({
+          try: () =>
+            queue
+              .getQueue()
+              .add('run-autonomous-job', request.payload, {
+                ...(typeof request.delayMs === 'number' ? { delay: Math.max(0, request.delayMs) } : {}),
+                ...(request.jobId ? { jobId: request.jobId } : {}),
+              }),
+          catch: (cause) => new AutonomousJobQueueError({ message: 'Failed to enqueue autonomous job run.', cause }),
+        })
+
+        const bullmqJobId = String(queuedJob.id)
+        const queueJobId = yield* recordEnqueuedJobMetadata({
+          queueName: AUTONOMOUS_JOB_QUEUE,
+          job: queuedJob,
+          queueJobService,
+        })
+        return { bullmqJobId, queueJobId }
+      }),
+    )
+
+  const upsertAutonomousJobScheduler: AutonomousJobQueueRuntime['upsertAutonomousJobScheduler'] = (request) => {
+    const repeatOpts =
+      request.schedule.kind === 'cron' ? { pattern: request.schedule.cron } : { every: request.schedule.intervalMs }
+    return Effect.runPromise(
+      Effect.gen(function* () {
+        const queuedJob = yield* Effect.tryPromise({
+          try: () =>
+            queue
+              .getQueue()
+              .upsertJobScheduler(buildAutonomousSchedulerId(request.autonomousJobId), repeatOpts, {
+                name: 'run-autonomous-job',
+                data: { autonomousJobId: request.autonomousJobId, trigger: 'scheduled' },
+                opts: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
+              }),
+          catch: (cause) =>
+            new AutonomousJobQueueError({
+              message: `Failed to upsert autonomous job scheduler for ${request.autonomousJobId}.`,
+              cause,
+            }),
+        })
 
-export function removeAutonomousJobScheduler(autonomousJobId: string): Promise<void> {
-  return Effect.runPromise(
-    Effect.asVoid(
-      Effect.tryPromise({
-        try: () => autonomousJobQueue.getQueue().removeJobScheduler(buildAutonomousSchedulerId(autonomousJobId)),
-        catch: (cause) =>
-          new AutonomousJobQueueError({
-            message: `Failed to remove autonomous job scheduler for ${autonomousJobId}.`,
-            cause,
-          }),
+        yield* recordEnqueuedJobMetadata({ queueName: AUTONOMOUS_JOB_QUEUE, job: queuedJob, queueJobService })
       }),
-    ),
-  )
-}
+    )
+  }
 
-export function removeAutonomousAtJob(autonomousJobId: string): Promise<void> {
-  return Effect.runPromise(
-    Effect.catch(
+  const removeAutonomousJobScheduler: AutonomousJobQueueRuntime['removeAutonomousJobScheduler'] = (autonomousJobId) =>
+    Effect.runPromise(
       Effect.asVoid(
         Effect.tryPromise({
-          try: () => autonomousJobQueue.getQueue().remove(buildAutonomousAtJobId(autonomousJobId)),
+          try: () => queue.getQueue().removeJobScheduler(buildAutonomousSchedulerId(autonomousJobId)),
           catch: (cause) =>
             new AutonomousJobQueueError({
-              message: `Failed to remove autonomous-at job for ${autonomousJobId}.`,
+              message: `Failed to remove autonomous job scheduler for ${autonomousJobId}.`,
               cause,
             }),
         }),
       ),
-      () => Effect.void,
-    ),
-  )
-}
-
-interface AutonomousJobWorkerOptions {
-  registerSignals?: boolean
-  connectionProvider: () => IORedis
-  deps: AutonomousJobQueueDeps
-}
-
-export function startAutonomousJobWorker(options: AutonomousJobWorkerOptions): WorkerHandle {
-  const handle = autonomousJobQueue.startWorker({
-    deps: options.deps,
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
-  })
+    )
+
+  const removeAutonomousAtJob: AutonomousJobQueueRuntime['removeAutonomousAtJob'] = (autonomousJobId) =>
+    Effect.runPromise(
+      Effect.catch(
+        Effect.asVoid(
+          Effect.tryPromise({
+            try: () => queue.getQueue().remove(buildAutonomousAtJobId(autonomousJobId)),
+            catch: (cause) =>
+              new AutonomousJobQueueError({
+                message: `Failed to remove autonomous-at job for ${autonomousJobId}.`,
+                cause,
+              }),
+          }),
+        ),
+        () => Effect.void,
+      ),
+    )
 
-  void Effect.runPromise(
-    Effect.catch(options.deps.autonomousJobService.recoverActiveJobs(), (error) =>
-      Effect.sync(() => {
-        serverLogger.error`Autonomous job startup recovery failed: ${error}`
-      }),
-    ),
-  )
+  const startWorker: AutonomousJobQueueRuntime['startWorker'] = (options) => {
+    const { deps } = options
+    const handle = queue.startWorker({ deps, registerSignals: options.registerSignals, connectionProvider })
 
-  return handle
+    void Effect.runPromise(
+      Effect.catch(deps.autonomousJobService.recoverActiveJobs(), (error) =>
+        Effect.sync(() => {
+          serverLogger.error`Autonomous job startup recovery failed: ${error}`
+        }),
+      ) as Effect.Effect<unknown, never, never>,
+    )
+
+    return handle
+  }
+
+  return {
+    enqueueAutonomousJobRun,
+    upsertAutonomousJobScheduler,
+    removeAutonomousJobScheduler,
+    removeAutonomousAtJob,
+    startWorker,
+  }
 }
 
 runStandaloneQueueWorker((runtime) => {
-  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
-  startAutonomousJobWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
-    deps: { databaseService: resolve(DatabaseServiceTag), autonomousJobService: resolve(AutonomousJobServiceTag) },
-  })
+  void (async () => {
+    const { AutonomousJobServiceTag } = await import('../services/autonomous-job.service')
+    const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+    const redis = resolve(RedisServiceTag)
+    const autonomousJobQueueRuntime = makeAutonomousJobQueueRuntime({
+      connectionProvider: () => redis.getConnectionForBullMQ(),
+      queueJobService: resolve(QueueJobServiceTag),
+    })
+    autonomousJobQueueRuntime.startWorker({
+      deps: { databaseService: resolve(DatabaseServiceTag), autonomousJobService: resolve(AutonomousJobServiceTag) },
+    })
+  })()
 })

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

@@ -7,7 +7,9 @@ import { ensureRecordId } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
 import { ContextCompactionServiceTag } from '../services/context-compaction.service'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { ThreadServiceTag } from '../services/thread/thread.service'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
@@ -17,13 +19,13 @@ interface ContextCompactionJob {
   contextSize?: number
 }
 
-interface ContextCompactionQueueDeps {
+export interface ContextCompactionWorkerDeps {
   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> {
+function processContextCompactionJob(deps: ContextCompactionWorkerDeps, job: Job<ContextCompactionJob>): Promise<void> {
   const { threadService, contextCompactionService } = deps
   const { entityId, contextSize } = job.data
   const threadRef = ensureRecordId(entityId, TABLES.THREAD)
@@ -40,37 +42,49 @@ function processContextCompactionJob(deps: ContextCompactionQueueDeps, job: Job<
   )
 }
 
-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,
-})
-
-export function enqueueContextCompaction(job: ContextCompactionJob) {
-  return contextCompaction.enqueue(job, { deduplication: { id: `compact:${job.domain}:${job.entityId}` } })
+export interface ContextCompactionQueueRuntime {
+  enqueueContextCompaction(job: ContextCompactionJob): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: ContextCompactionWorkerDeps }): WorkerHandle
 }
 
-export function startContextCompactionWorker(options: {
-  registerSignals?: boolean
+interface MakeContextCompactionQueueRuntimeParams {
   connectionProvider: () => IORedis
-  deps: ContextCompactionQueueDeps
-}): ReturnType<typeof contextCompaction.startWorker> {
-  return contextCompaction.startWorker({
-    deps: options.deps,
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
+  queueJobService: QueueJobService
+}
+
+export function makeContextCompactionQueueRuntime(
+  params: MakeContextCompactionQueueRuntimeParams,
+): ContextCompactionQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+  const queue = createQueueFactoryWithDeps<ContextCompactionJob, ContextCompactionWorkerDeps>({
+    name: 'context-compaction',
+    displayName: 'Context compaction',
+    jobName: 'compact',
+    concurrency: 2,
+    lockDuration: 300_000,
+    defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 3_000 } },
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processContextCompactionJob,
   })
+
+  return {
+    enqueueContextCompaction: (job) =>
+      queue.enqueue(job, { deduplication: { id: `compact:${job.domain}:${job.entityId}` } }),
+    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))
-  startContextCompactionWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
+  const redis = resolve(RedisServiceTag)
+  const contextCompactionQueue = makeContextCompactionQueueRuntime({
+    connectionProvider: () => redis.getConnectionForBullMQ(),
+    queueJobService: resolve(QueueJobServiceTag),
+  })
+  contextCompactionQueue.startWorker({
     deps: {
       databaseService: resolve(DatabaseServiceTag),
       threadService: resolve(ThreadServiceTag),

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

@@ -4,10 +4,22 @@ import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
-import { PlanExecutorServiceTag } from '../services/plan/plan-executor.service'
+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'
 
+// Minimal service shape used by the worker processor. Declared structurally to
+// avoid importing the service tag — which would form a dependency cycle since
+// PlanExecutorServiceLive depends on LotaQueuesServiceTag.
+interface DelayedNodePromotionPlanExecutorShape {
+  promoteDelayedNode(params: {
+    runId: string
+    nodeId: string
+    emittedBy: string
+  }): Effect.Effect<unknown, unknown, unknown>
+}
+
 export interface DelayedNodePromotionJob {
   runId: string
   nodeId: string
@@ -16,13 +28,13 @@ export interface DelayedNodePromotionJob {
 
 export const DELAYED_NODE_PROMOTION_QUEUE = 'delayed-node-promotion'
 
-interface DelayedNodePromotionQueueDeps {
+export interface DelayedNodePromotionWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
-  planExecutorService: Context.Service.Shape<typeof PlanExecutorServiceTag>
+  planExecutorService: DelayedNodePromotionPlanExecutorShape
 }
 
 function processDelayedNodePromotionJob(
-  deps: DelayedNodePromotionQueueDeps,
+  deps: DelayedNodePromotionWorkerDeps,
   job: Job<DelayedNodePromotionJob>,
 ): Promise<void> {
   const { planExecutorService } = deps
@@ -35,36 +47,51 @@ function processDelayedNodePromotionJob(
   ).then(() => undefined)
 }
 
-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 function enqueueDelayedNodePromotion(job: DelayedNodePromotionJob, delayMs: number) {
-  return delayedNodePromotion.enqueue(job, { delay: delayMs, jobId: `promote:${job.runId}:${job.nodeId}` })
+export interface DelayedNodePromotionQueueRuntime {
+  enqueueDelayedNodePromotion(job: DelayedNodePromotionJob, delayMs: number): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: DelayedNodePromotionWorkerDeps }): WorkerHandle
 }
 
-export function startDelayedNodePromotionWorker(options: {
-  registerSignals?: boolean
+interface MakeDelayedNodePromotionQueueRuntimeParams {
   connectionProvider: () => IORedis
-  deps: DelayedNodePromotionQueueDeps
-}): ReturnType<typeof delayedNodePromotion.startWorker> {
-  return delayedNodePromotion.startWorker({
-    deps: options.deps,
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
+  queueJobService: QueueJobService
+}
+
+export function makeDelayedNodePromotionQueueRuntime(
+  params: MakeDelayedNodePromotionQueueRuntimeParams,
+): DelayedNodePromotionQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+  const queue = createQueueFactoryWithDeps<DelayedNodePromotionJob, DelayedNodePromotionWorkerDeps>({
+    name: DELAYED_NODE_PROMOTION_QUEUE,
+    displayName: 'Delayed node promotion',
+    jobName: 'promote-node',
+    concurrency: 1,
+    defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 5000 } },
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processDelayedNodePromotionJob,
   })
+
+  return {
+    enqueueDelayedNodePromotion: (job, delayMs) =>
+      queue.enqueue(job, { delay: delayMs, jobId: `promote:${job.runId}:${job.nodeId}` }),
+    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))
-  startDelayedNodePromotionWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
-    deps: { databaseService: resolve(DatabaseServiceTag), planExecutorService: resolve(PlanExecutorServiceTag) },
-  })
+  void (async () => {
+    const { PlanExecutorServiceTag } = await import('../services/plan/plan-executor.service')
+    const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+    const redis = resolve(RedisServiceTag)
+    const delayedNodePromotionQueue = makeDelayedNodePromotionQueueRuntime({
+      connectionProvider: () => redis.getConnectionForBullMQ(),
+      queueJobService: resolve(QueueJobServiceTag),
+    })
+    delayedNodePromotionQueue.startWorker({
+      deps: { databaseService: resolve(DatabaseServiceTag), planExecutorService: resolve(PlanExecutorServiceTag) },
+    })
+  })()
 })