@lota-sdk/core 0.4.9 → 0.4.11

package/src/runtime/runtime-services.ts

@@ -0,0 +1,455 @@
+/**
+ * Eagerly resolves the full SDK service surface against a live ManagedRuntime.
+ *
+ * The previous implementation used per-property `get` Proxies that re-resolved
+ * each tag on every access. This module resolves every tag exactly once when
+ * the runtime starts and returns a plain object whose shape matches the
+ * `LotaRuntime['services']` + `LotaRuntime['lota']` contracts byte-for-byte.
+ */
+
+import type { ChatMessage } from '@lota-sdk/shared'
+import type Firecrawl from '@mendable/firecrawl-js'
+import type { Context, ManagedRuntime } from 'effect'
+import { Effect } from 'effect'
+
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { ensureRecordId } from '../db/record-id'
+import type { SurrealDBService } from '../db/service'
+import { TABLES } from '../db/tables'
+import { BadRequestError, NotFoundError } from '../effect/errors'
+import { effectTryPromise } from '../effect/helpers'
+import { AgentConfigServiceTag } from '../effect/services'
+import type { RedisConnectionManager } from '../redis/connection'
+import type { SharedThreadStreamSubscriberTag } from '../redis/stream-context'
+import { AgentActivityServiceTag } from '../services/agent-activity.service'
+import { ArtifactServiceTag } from '../services/artifact.service'
+import { AttachmentServiceTag } from '../services/attachment.service'
+import { AutonomousJobServiceTag } from '../services/autonomous-job.service'
+import { ContextCompactionServiceTag } from '../services/context-compaction.service'
+import { DocumentChunkServiceTag } from '../services/document-chunk.service'
+import { ExecutionPlanServiceTag } from '../services/execution-plan/execution-plan.service'
+import { MemoryServiceTag } from '../services/memory/memory.service'
+import { RerankServiceTag } from '../services/memory/rerank.service'
+import { MutatingApprovalServiceTag } from '../services/mutating-approval.service'
+import { OrganizationMemberServiceTag } from '../services/organization-member.service'
+import { OrganizationServiceTag } from '../services/organization.service'
+import { PlanAgentHeartbeatServiceTag } from '../services/plan/plan-agent-heartbeat.service'
+import { PlanAgentQueryServiceTag } from '../services/plan/plan-agent-query.service'
+import { PlanCoordinationServiceTag } from '../services/plan/plan-coordination.service'
+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 { PlanRunServiceTag } from '../services/plan/plan-run.service'
+import { PlanSchedulerServiceTag } from '../services/plan/plan-scheduler.service'
+import { PlanTemplateServiceTag } from '../services/plan/plan-template.service'
+import { RecentActivityTitleServiceTag } from '../services/recent-activity-title.service'
+import { RecentActivityServiceTag } from '../services/recent-activity.service'
+import type { makeSocialChatHistoryService } from '../services/social-chat-history.service'
+import { ThreadMessageServiceTag } from '../services/thread/thread-message.service'
+import { ThreadTitleServiceTag } from '../services/thread/thread-title.service'
+import { isApprovalContinuationRequest as isApprovalContinuationRequestFn } from '../services/thread/thread-turn'
+import type {
+  createThreadApprovalContinuationStream,
+  createThreadNativeToolApprovalStream,
+  createThreadTurnStream,
+  runThreadTurnInBackground,
+  ThreadTurnServiceTag,
+  triggerPlanNodeTurn,
+} from '../services/thread/thread-turn'
+import { ThreadServiceTag } from '../services/thread/thread.service'
+import { UserServiceTag } from '../services/user.service'
+import { GeneratedDocumentStorageServiceTag } from '../storage/generated-document-storage.service'
+import { FirecrawlTag } from '../tools/firecrawl-client'
+import { routeThreadChatMessages } from './chat-request-routing'
+
+// eslint-disable-next-line typescript-eslint/no-explicit-any -- ManagedRuntime is contravariant in R; `any` is the only valid wildcard
+type SdkManagedRuntime = ManagedRuntime.ManagedRuntime<any, any>
+
+// ── Type helpers (shared with create-runtime.ts's public interface) ──
+type Svc<T extends { readonly Service: unknown }> = T['Service']
+
+// Map an Effect-returning function signature to a Promise-returning signature.
+// Non-Effect-returning methods and non-function properties pass through unchanged.
+type PromisifiedValue<T> = T extends (...args: infer TArgs) => Effect.Effect<infer A, infer _E, infer _R>
+  ? (...args: TArgs) => Promise<A>
+  : T extends (...args: infer TArgs) => infer TResult
+    ? (...args: TArgs) => TResult
+    : T
+
+type PromisifiedService<T> = {
+  [K in keyof T]: PromisifiedValue<T[K]>
+}
+
+type HostSvc<T extends { readonly Service: object }> = PromisifiedService<T['Service']>
+
+export type PromisifiedThreadService = HostSvc<typeof ThreadServiceTag> &
+  Pick<Svc<typeof ThreadServiceTag>, 'withActiveRunLease'>
+export type PromisifiedDocumentChunkService = HostSvc<typeof DocumentChunkServiceTag> &
+  Pick<Svc<typeof DocumentChunkServiceTag>, 'syncVersionedChunks'>
+
+export type ArchiveSdkThread = (
+  threadId: Parameters<Svc<typeof ThreadServiceTag>['updateStatus']>[0],
+  status?: 'archived',
+) => ReturnType<Svc<typeof ThreadServiceTag>['updateStatus']>
+
+export type UnarchiveSdkThread = (
+  threadId: Parameters<Svc<typeof ThreadServiceTag>['updateStatus']>[0],
+  status?: 'active',
+) => ReturnType<Svc<typeof ThreadServiceTag>['updateStatus']>
+
+export interface LotaRuntimeServices {
+  agentConfig: ResolvedAgentConfig
+  database: SurrealDBService
+  redis: RedisConnectionManager
+  closeRedisConnection: () => Promise<void>
+  firecrawl: Firecrawl
+  agentActivityService: HostSvc<typeof AgentActivityServiceTag>
+  artifactService: HostSvc<typeof ArtifactServiceTag>
+  attachmentService: HostSvc<typeof AttachmentServiceTag>
+  autonomousJobService: HostSvc<typeof AutonomousJobServiceTag>
+  contextCompactionService: HostSvc<typeof ContextCompactionServiceTag>
+  documentChunkService: PromisifiedDocumentChunkService
+  generatedDocumentStorageService: HostSvc<typeof GeneratedDocumentStorageServiceTag>
+  memoryService: HostSvc<typeof MemoryServiceTag>
+  rerankService: HostSvc<typeof RerankServiceTag>
+  verifyMutatingApproval: HostSvc<typeof MutatingApprovalServiceTag>
+  organizationService: HostSvc<typeof OrganizationServiceTag>
+  organizationMemberService: HostSvc<typeof OrganizationMemberServiceTag>
+  userService: HostSvc<typeof UserServiceTag>
+  recentActivityService: HostSvc<typeof RecentActivityServiceTag>
+  recentActivityTitleService: HostSvc<typeof RecentActivityTitleServiceTag>
+  socialChatHistoryService: ReturnType<typeof makeSocialChatHistoryService>
+  executionPlanService: HostSvc<typeof ExecutionPlanServiceTag>
+  planDeadlineService: HostSvc<typeof PlanDeadlineServiceTag>
+  planExecutorService: HostSvc<typeof PlanExecutorServiceTag>
+  planRunService: HostSvc<typeof PlanRunServiceTag>
+  planTemplateService: HostSvc<typeof PlanTemplateServiceTag>
+  planCoordinationService: HostSvc<typeof PlanCoordinationServiceTag>
+  planSchedulerService: HostSvc<typeof PlanSchedulerServiceTag>
+  planAgentHeartbeatService: HostSvc<typeof PlanAgentHeartbeatServiceTag>
+  planAgentQueryService: HostSvc<typeof PlanAgentQueryServiceTag>
+  planCycleService: HostSvc<typeof PlanCycleServiceTag>
+  threadMessageService: HostSvc<typeof ThreadMessageServiceTag>
+  threadService: PromisifiedThreadService
+  threadTitleService: HostSvc<typeof ThreadTitleServiceTag>
+  createThreadApprovalContinuationStream: typeof createThreadApprovalContinuationStream
+  createThreadNativeToolApprovalStream: typeof createThreadNativeToolApprovalStream
+  createThreadTurnStream: typeof createThreadTurnStream
+  isApprovalContinuationRequest: typeof isApprovalContinuationRequestFn
+  runThreadTurnInBackground: typeof runThreadTurnInBackground
+  triggerPlanNodeTurn: typeof triggerPlanNodeTurn
+}
+
+export interface LotaRuntimeLota {
+  organizations: {
+    create: PromisifiedValue<Svc<typeof OrganizationServiceTag>['createOrganization']>
+    upsert: PromisifiedValue<Svc<typeof OrganizationServiceTag>['upsertOrganization']>
+    get: PromisifiedValue<Svc<typeof OrganizationServiceTag>['getOrganization']>
+    list: PromisifiedValue<Svc<typeof OrganizationServiceTag>['listOrganizations']>
+    update: PromisifiedValue<Svc<typeof OrganizationServiceTag>['updateOrganization']>
+    delete: PromisifiedValue<Svc<typeof OrganizationServiceTag>['deleteOrganization']>
+  }
+  users: {
+    upsert: PromisifiedValue<Svc<typeof UserServiceTag>['upsertUser']>
+    get: PromisifiedValue<Svc<typeof UserServiceTag>['getUser']>
+    list: PromisifiedValue<Svc<typeof UserServiceTag>['listUsers']>
+    update: PromisifiedValue<Svc<typeof UserServiceTag>['updateUser']>
+    delete: PromisifiedValue<Svc<typeof UserServiceTag>['deleteUser']>
+  }
+  memberships: {
+    add: PromisifiedValue<Svc<typeof OrganizationMemberServiceTag>['addMembership']>
+    listForOrganization: PromisifiedValue<Svc<typeof OrganizationMemberServiceTag>['listMembershipsForOrganization']>
+    listForUser: PromisifiedValue<Svc<typeof OrganizationMemberServiceTag>['listMembershipsForUser']>
+    remove: PromisifiedValue<Svc<typeof OrganizationMemberServiceTag>['removeMembership']>
+    isMember: PromisifiedValue<Svc<typeof OrganizationMemberServiceTag>['isMember']>
+  }
+  threads: {
+    create: PromisifiedValue<Svc<typeof ThreadServiceTag>['createThread']>
+    list: PromisifiedValue<Svc<typeof ThreadServiceTag>['listThreads']>
+    get: PromisifiedValue<Svc<typeof ThreadServiceTag>['getThread']>
+    update: PromisifiedValue<Svc<typeof ThreadServiceTag>['updateTitle']>
+    archive: PromisifiedValue<ArchiveSdkThread>
+    unarchive: PromisifiedValue<UnarchiveSdkThread>
+    delete: PromisifiedValue<Svc<typeof ThreadServiceTag>['deleteThread']>
+    stop: PromisifiedValue<Svc<typeof ThreadServiceTag>['stopActiveRun']>
+    listMessages: PromisifiedValue<Svc<typeof ThreadMessageServiceTag>['listMessageHistoryPage']>
+    getMessage: (params: { threadId: string; messageId: string }) => Promise<ChatMessage>
+    sendMessage: (params: {
+      threadId: string
+      organizationId: string
+      userId: string
+      userName: string
+      messages: Parameters<typeof routeThreadChatMessages>[0]
+    }) => Promise<EffectSuccess<ReturnType<Svc<typeof ThreadTurnServiceTag>['createThreadTurnStream']>>>
+    continueApproval: (params: {
+      threadId: string
+      organizationId: string
+      userId: string
+      userName: string
+      messages: Parameters<typeof routeThreadChatMessages>[0]
+    }) => Promise<EffectSuccess<ReturnType<Svc<typeof ThreadTurnServiceTag>['createThreadApprovalContinuationStream']>>>
+    uploadAttachment: PromisifiedValue<Svc<typeof AttachmentServiceTag>['uploadThreadAttachment']>
+  }
+}
+
+// Helper: extract the success type from an Effect return type.
+type EffectSuccess<T> = T extends Effect.Effect<infer A, infer _E, infer _R> ? A : never
+
+interface BuildRuntimeServiceSurfaceInput {
+  managedRuntime: SdkManagedRuntime
+  db: SurrealDBService
+  redisManager: RedisConnectionManager
+  sharedSubscriber: Svc<typeof SharedThreadStreamSubscriberTag>
+  threadTurnService: Svc<typeof ThreadTurnServiceTag>
+  socialChatHistoryService: ReturnType<typeof makeSocialChatHistoryService>
+}
+
+interface RuntimeServiceSurface {
+  services: LotaRuntimeServices
+  lota: LotaRuntimeLota
+}
+
+/**
+ * Build a Promise-method shell around a service whose methods return Effects.
+ *
+ * Non-function properties and non-Effect-returning methods pass through
+ * unchanged. Each Effect-returning method is wrapped so callers receive a
+ * Promise resolved by the supplied `managedRuntime`, keeping the host-facing
+ * API stable while the SDK internals stay pure Effect.
+ */
+function promisifyServiceMethods<T extends object>(
+  managedRuntime: SdkManagedRuntime,
+  rawService: T,
+): PromisifiedService<T> {
+  const out: Record<string, unknown> = {}
+  // Walk own + prototype chain so class-based Context.Service implementations
+  // whose methods live on the prototype get wrapped too. Object.entries alone
+  // only sees own enumerable string keys — silent miss for class methods.
+  let proto: object | null = rawService
+  while (proto && proto !== Object.prototype) {
+    for (const key of Object.getOwnPropertyNames(proto)) {
+      if (key === 'constructor' || key in out) continue
+      const descriptor = Object.getOwnPropertyDescriptor(proto, key)
+      if (!descriptor || typeof descriptor.value !== 'function') continue
+      const method = descriptor.value as (...args: unknown[]) => unknown
+      out[key] = (...args: unknown[]) => {
+        const result = method.apply(rawService, args)
+        return Effect.isEffect(result)
+          ? managedRuntime.runPromise(result as Effect.Effect<unknown, unknown, never>)
+          : result
+      }
+    }
+    proto = Object.getPrototypeOf(proto)
+  }
+  // Copy non-function own properties not already set.
+  for (const [key, value] of Object.entries(rawService)) {
+    if (!(key in out)) out[key] = value
+  }
+  return out as PromisifiedService<T>
+}
+
+/**
+ * Eagerly resolve the full service surface exactly once.
+ *
+ * Effect-returning service methods are wrapped into plain Promise-returning
+ * functions by `promisifyServiceMethods`, which means callers can `await`
+ * them directly. The SDK retains the raw Effect-aware services internally
+ * for composition within `Effect.gen` blocks.
+ */
+export function buildRuntimeServiceSurface(input: BuildRuntimeServiceSurfaceInput): RuntimeServiceSurface {
+  const { managedRuntime, db, redisManager, threadTurnService, socialChatHistoryService } = input
+  // The ManagedRuntime carries every service tag the SDK composes in
+  // `buildDomainServiceLayer`, so we can safely run any SDK effect through it.
+  // The explicit `any` for R lets this helper accept effects with residual
+  // service requirements (e.g. `ThreadTurnServiceTag | LotaQueuesServiceTag`)
+  // without forcing each call site to provide them.
+  const runPromise = <A, E, R>(effect: Effect.Effect<A, E, R>): Promise<A> =>
+    managedRuntime.runPromise(effect as unknown as Effect.Effect<A, E, never>)
+
+  const resolveRaw = <I, T>(tag: Context.Key<I, T>): T => managedRuntime.runSync(Effect.service(tag))
+  const resolveOnce = <I, T extends object>(tag: Context.Key<I, T>): PromisifiedService<T> =>
+    promisifyServiceMethods(managedRuntime, resolveRaw(tag))
+
+  // ── Resolve every tag eagerly. Each binding is a plain value from here. ──
+  const agentActivityService = resolveOnce(AgentActivityServiceTag)
+  const artifactService = resolveOnce(ArtifactServiceTag)
+  const attachmentService = resolveOnce(AttachmentServiceTag)
+  const autonomousJobService = resolveOnce(AutonomousJobServiceTag)
+  const contextCompactionService = resolveOnce(ContextCompactionServiceTag)
+  const documentChunkService = resolveOnce(DocumentChunkServiceTag) as PromisifiedDocumentChunkService
+  const generatedDocumentStorageService = resolveOnce(GeneratedDocumentStorageServiceTag)
+  const memoryService = resolveOnce(MemoryServiceTag)
+  const rerankService = resolveOnce(RerankServiceTag)
+  const verifyMutatingApproval = resolveOnce(MutatingApprovalServiceTag)
+  const organizationService = resolveOnce(OrganizationServiceTag)
+  const organizationMemberService = resolveOnce(OrganizationMemberServiceTag)
+  const userService = resolveOnce(UserServiceTag)
+  const recentActivityService = resolveOnce(RecentActivityServiceTag)
+  const recentActivityTitleService = resolveOnce(RecentActivityTitleServiceTag)
+  const executionPlanService = resolveOnce(ExecutionPlanServiceTag)
+  const planDeadlineService = resolveOnce(PlanDeadlineServiceTag)
+  const planExecutorService = resolveOnce(PlanExecutorServiceTag)
+  const planRunService = resolveOnce(PlanRunServiceTag)
+  const planTemplateService = resolveOnce(PlanTemplateServiceTag)
+  const planCoordinationService = resolveOnce(PlanCoordinationServiceTag)
+  const planSchedulerService = resolveOnce(PlanSchedulerServiceTag)
+  const planAgentHeartbeatService = resolveOnce(PlanAgentHeartbeatServiceTag)
+  const planAgentQueryService = resolveOnce(PlanAgentQueryServiceTag)
+  const planCycleService = resolveOnce(PlanCycleServiceTag)
+  const threadMessageService = resolveOnce(ThreadMessageServiceTag)
+  const threadService = resolveOnce(ThreadServiceTag) as PromisifiedThreadService
+  const threadTitleService = resolveOnce(ThreadTitleServiceTag)
+  const firecrawl = resolveRaw(FirecrawlTag)
+  const agentConfig = resolveRaw(AgentConfigServiceTag)
+
+  // ── Resolve the raw service instances once for inline Effect composition ──
+  // `promisifyServiceMethods` (used above) converts Effect-returning methods
+  // into Promise-returning shims. The `getMessage`/`sendMessage`/
+  // `continueApproval` wrappers below need the raw Effect-returning
+  // signatures so they can `yield*` service methods inside `Effect.gen`.
+  const threadMessageServiceRaw = resolveRaw(ThreadMessageServiceTag)
+  const threadServiceRaw = resolveRaw(ThreadServiceTag)
+
+  const services: LotaRuntimeServices = {
+    agentConfig,
+    database: db,
+    redis: redisManager,
+    closeRedisConnection: () => runPromise(effectTryPromise(() => redisManager.closeConnection())),
+    firecrawl,
+    agentActivityService,
+    artifactService,
+    attachmentService,
+    autonomousJobService,
+    contextCompactionService,
+    documentChunkService,
+    generatedDocumentStorageService,
+    memoryService,
+    rerankService,
+    verifyMutatingApproval,
+    organizationService,
+    organizationMemberService,
+    userService,
+    recentActivityService,
+    recentActivityTitleService,
+    socialChatHistoryService,
+    executionPlanService,
+    planDeadlineService,
+    planExecutorService,
+    planRunService,
+    planTemplateService,
+    planCoordinationService,
+    planSchedulerService,
+    planAgentHeartbeatService,
+    planAgentQueryService,
+    planCycleService,
+    threadMessageService,
+    threadService,
+    threadTitleService,
+    createThreadApprovalContinuationStream: (...args) =>
+      threadTurnService.createThreadApprovalContinuationStream(...args),
+    createThreadNativeToolApprovalStream: (...args) => threadTurnService.createThreadNativeToolApprovalStream(...args),
+    createThreadTurnStream: (...args) => threadTurnService.createThreadTurnStream(...args),
+    isApprovalContinuationRequest: isApprovalContinuationRequestFn,
+    runThreadTurnInBackground: (...args) => threadTurnService.runThreadTurnInBackground(...args),
+    triggerPlanNodeTurn: (...args) => threadTurnService.triggerPlanNodeTurn(...args),
+  }
+
+  const lota: LotaRuntimeLota = {
+    organizations: {
+      create: (...args) => organizationService.createOrganization(...args),
+      upsert: (...args) => organizationService.upsertOrganization(...args),
+      get: (...args) => organizationService.getOrganization(...args),
+      list: (...args) => organizationService.listOrganizations(...args),
+      update: (...args) => organizationService.updateOrganization(...args),
+      delete: (...args) => organizationService.deleteOrganization(...args),
+    },
+    users: {
+      upsert: (...args) => userService.upsertUser(...args),
+      get: (...args) => userService.getUser(...args),
+      list: (...args) => userService.listUsers(...args),
+      update: (...args) => userService.updateUser(...args),
+      delete: (...args) => userService.deleteUser(...args),
+    },
+    memberships: {
+      add: (...args) => organizationMemberService.addMembership(...args),
+      listForOrganization: (...args) => organizationMemberService.listMembershipsForOrganization(...args),
+      listForUser: (...args) => organizationMemberService.listMembershipsForUser(...args),
+      remove: (...args) => organizationMemberService.removeMembership(...args),
+      isMember: (...args) => organizationMemberService.isMember(...args),
+    },
+    threads: {
+      create: (...args) => threadService.createThread(...args),
+      list: (...args) => threadService.listThreads(...args),
+      get: (...args) => threadService.getThread(...args),
+      update: (...args) => threadService.updateTitle(...args),
+      archive: (threadId, status = 'archived') => threadService.updateStatus(threadId, status),
+      unarchive: (threadId, status = 'active') => threadService.updateStatus(threadId, status),
+      delete: (...args) => threadService.deleteThread(...args),
+      stop: (...args) => threadService.stopActiveRun(...args),
+      listMessages: (...args) => threadMessageService.listMessageHistoryPage(...args),
+      getMessage: ({ threadId, messageId }) =>
+        runPromise(
+          Effect.gen(function* () {
+            const messages = yield* threadMessageServiceRaw.listMessages(ensureRecordId(threadId, TABLES.THREAD))
+            const message = messages.find((candidate: ChatMessage) => candidate.id === messageId)
+            if (!message) {
+              return yield* new NotFoundError({
+                resource: 'Thread message',
+                id: messageId,
+                message: `Thread message not found: ${messageId}`,
+              })
+            }
+            return message
+          }),
+        ),
+      sendMessage: ({ threadId, organizationId, userId, userName, messages }) =>
+        runPromise(
+          Effect.gen(function* () {
+            const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+            const thread = yield* threadServiceRaw.getThread(threadRef)
+            const routed = routeThreadChatMessages(messages)
+            if (routed.kind !== 'turn') {
+              return yield* new BadRequestError({
+                message: routed.kind === 'invalid' ? routed.message : 'Expected a user turn payload.',
+              })
+            }
+
+            return yield* threadTurnService.createThreadTurnStream({
+              thread,
+              threadRef,
+              orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
+              userRef: ensureRecordId(userId, TABLES.USER),
+              userName,
+              inputMessage: routed.inputMessage,
+            })
+          }),
+        ),
+      continueApproval: ({ threadId, organizationId, userId, userName, messages }) =>
+        runPromise(
+          Effect.gen(function* () {
+            const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+            const thread = yield* threadServiceRaw.getThread(threadRef)
+            const routed = routeThreadChatMessages(messages)
+            if (routed.kind !== 'approval-continuation') {
+              return yield* new BadRequestError({
+                message:
+                  routed.kind === 'invalid' ? routed.message : 'Expected approval continuation messages payload.',
+              })
+            }
+
+            return yield* threadTurnService.createThreadApprovalContinuationStream({
+              thread,
+              threadRef,
+              orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
+              userRef: ensureRecordId(userId, TABLES.USER),
+              userName,
+              approvalMessages: routed.approvalMessages,
+            })
+          }),
+        ),
+      uploadAttachment: (...args) => attachmentService.uploadThreadAttachment(...args),
+    },
+  }
+
+  return { services, lota }
+}

package/src/runtime/runtime-worker-registry.ts

@@ -1,27 +1,54 @@
-import { startAutonomousJobWorker } from '../queues/autonomous-job.queue'
-import { startContextCompactionWorker } from '../queues/context-compaction.queue'
-import { startDelayedNodePromotionWorker } from '../queues/delayed-node-promotion.queue'
-import { scheduleRecurringConsolidation, startMemoryConsolidationWorker } from '../queues/memory-consolidation.queue'
-import { startOrganizationLearningWorker } from '../queues/organization-learning.queue'
-import { startPlanAgentHeartbeatWorker } from '../queues/plan-agent-heartbeat.queue'
-import { startPlanSchedulerWorker } from '../queues/plan-scheduler.queue'
-import { startPostChatMemoryWorker } from '../queues/post-chat-memory.queue'
-import { startTitleGenerationWorker } from '../queues/title-generation.queue'
+import type { Context } from 'effect'
+
+import type { DatabaseServiceTag } from '../effect/services'
+import type { LotaQueuesRuntime } from '../queues/queues.service'
+import type { RedisConnectionManager } from '../redis/connection'
+import type { AutonomousJobServiceTag } from '../services/autonomous-job.service'
+import type { ContextCompactionServiceTag } from '../services/context-compaction.service'
+import type { MemoryServiceTag } from '../services/memory/memory.service'
+import type { PlanAgentHeartbeatServiceTag } from '../services/plan/plan-agent-heartbeat.service'
+import type { PlanCycleServiceTag } from '../services/plan/plan-cycle.service'
+import type { PlanDeadlineServiceTag } from '../services/plan/plan-deadline.service'
+import type { PlanExecutorServiceTag } from '../services/plan/plan-executor.service'
+import type { PlanSchedulerServiceTag } from '../services/plan/plan-scheduler.service'
+import type { RecentActivityTitleServiceTag } from '../services/recent-activity-title.service'
+import type { ThreadTitleServiceTag } from '../services/thread/thread-title.service'
+import type { ThreadServiceTag } from '../services/thread/thread.service'
+
+type StartWorkerResult = ReturnType<LotaQueuesRuntime['autonomousJob']['startWorker']>
+
+export interface LotaRuntimeWorkerServices {
+  databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
+  threadService: Context.Service.Shape<typeof ThreadServiceTag>
+  contextCompactionService: Context.Service.Shape<typeof ContextCompactionServiceTag>
+  autonomousJobService: Context.Service.Shape<typeof AutonomousJobServiceTag>
+  memoryService: Context.Service.Shape<typeof MemoryServiceTag>
+  planAgentHeartbeatService: Context.Service.Shape<typeof PlanAgentHeartbeatServiceTag>
+  planSchedulerService: Context.Service.Shape<typeof PlanSchedulerServiceTag>
+  planDeadlineService: Context.Service.Shape<typeof PlanDeadlineServiceTag>
+  planExecutorService: Context.Service.Shape<typeof PlanExecutorServiceTag>
+  planCycleService: Context.Service.Shape<typeof PlanCycleServiceTag>
+  threadTitleService: Context.Service.Shape<typeof ThreadTitleServiceTag>
+  recentActivityTitleService: Context.Service.Shape<typeof RecentActivityTitleServiceTag>
+  redisManager: RedisConnectionManager
+}
+
+type WorkerStarter = (options?: { registerSignals?: boolean }) => StartWorkerResult
 
 export interface LotaRuntimeWorkerStartRegistry {
-  autonomousJob: typeof startAutonomousJobWorker
-  contextCompaction: typeof startContextCompactionWorker
-  delayedNodePromotion: typeof startDelayedNodePromotionWorker
-  memoryConsolidation: typeof startMemoryConsolidationWorker
-  organizationLearning: typeof startOrganizationLearningWorker
-  planAgentHeartbeat: typeof startPlanAgentHeartbeatWorker
-  planScheduler: typeof startPlanSchedulerWorker
-  postChatMemory: typeof startPostChatMemoryWorker
-  titleGeneration: typeof startTitleGenerationWorker
+  autonomousJob: WorkerStarter
+  contextCompaction: WorkerStarter
+  delayedNodePromotion: WorkerStarter
+  memoryConsolidation: WorkerStarter
+  organizationLearning: WorkerStarter
+  planAgentHeartbeat: WorkerStarter
+  planScheduler: WorkerStarter
+  postChatMemory: WorkerStarter
+  titleGeneration: WorkerStarter
 }
 
 export interface LotaRuntimeWorkerScheduleRegistry {
-  recurringConsolidation: typeof scheduleRecurringConsolidation
+  recurringConsolidation: LotaQueuesRuntime['memoryConsolidation']['scheduleRecurringConsolidation']
 }
 
 export interface LotaRuntimeWorkers {
@@ -34,20 +61,76 @@ export interface LotaRuntimeWorkerExtensions {
   schedule?: Record<string, unknown>
 }
 
-export function buildRuntimeWorkerRegistry(extraWorkers?: LotaRuntimeWorkerExtensions): LotaRuntimeWorkers {
+export function buildRuntimeWorkerRegistry(
+  queues: LotaQueuesRuntime,
+  services: LotaRuntimeWorkerServices,
+  extraWorkers?: LotaRuntimeWorkerExtensions,
+): LotaRuntimeWorkers {
   return {
     start: {
-      autonomousJob: startAutonomousJobWorker,
-      contextCompaction: startContextCompactionWorker,
-      delayedNodePromotion: startDelayedNodePromotionWorker,
-      memoryConsolidation: startMemoryConsolidationWorker,
-      organizationLearning: startOrganizationLearningWorker,
-      planAgentHeartbeat: startPlanAgentHeartbeatWorker,
-      planScheduler: startPlanSchedulerWorker,
-      postChatMemory: startPostChatMemoryWorker,
-      titleGeneration: startTitleGenerationWorker,
+      autonomousJob: (options = {}) =>
+        queues.autonomousJob.startWorker({
+          registerSignals: options.registerSignals,
+          deps: { databaseService: services.databaseService, autonomousJobService: services.autonomousJobService },
+        }),
+      contextCompaction: (options = {}) =>
+        queues.contextCompaction.startWorker({
+          registerSignals: options.registerSignals,
+          deps: {
+            databaseService: services.databaseService,
+            threadService: services.threadService,
+            contextCompactionService: services.contextCompactionService,
+          },
+        }),
+      delayedNodePromotion: (options = {}) =>
+        queues.delayedNodePromotion.startWorker({
+          registerSignals: options.registerSignals,
+          deps: { databaseService: services.databaseService, planExecutorService: services.planExecutorService },
+        }),
+      memoryConsolidation: (options = {}) => queues.memoryConsolidation.startWorker(options),
+      organizationLearning: (options = {}) => queues.organizationLearning.startWorker(options),
+      planAgentHeartbeat: (options = {}) =>
+        queues.planAgentHeartbeat.startWorker({
+          registerSignals: options.registerSignals,
+          deps: {
+            databaseService: services.databaseService,
+            planAgentHeartbeatService: services.planAgentHeartbeatService,
+          },
+        }),
+      planScheduler: (options = {}) =>
+        queues.planScheduler.startWorker({
+          registerSignals: options.registerSignals,
+          deps: {
+            databaseService: services.databaseService,
+            planSchedulerService: services.planSchedulerService,
+            planDeadlineService: services.planDeadlineService,
+            planExecutorService: services.planExecutorService,
+            planCycleService: services.planCycleService,
+          },
+        }),
+      postChatMemory: (options = {}) =>
+        queues.postChatMemory.startWorker({
+          registerSignals: options.registerSignals,
+          deps: {
+            databaseService: services.databaseService,
+            memoryService: services.memoryService,
+            redisManager: services.redisManager,
+          },
+        }),
+      titleGeneration: (options = {}) =>
+        queues.titleGeneration.startWorker({
+          registerSignals: options.registerSignals,
+          deps: {
+            databaseService: services.databaseService,
+            threadTitleService: services.threadTitleService,
+            recentActivityTitleService: services.recentActivityTitleService,
+          },
+        }),
       ...extraWorkers?.start,
     },
-    schedule: { recurringConsolidation: scheduleRecurringConsolidation, ...extraWorkers?.schedule },
+    schedule: {
+      recurringConsolidation: () => queues.memoryConsolidation.scheduleRecurringConsolidation(),
+      ...extraWorkers?.schedule,
+    },
   }
 }