@lota-sdk/core 0.4.10 → 0.4.12

package/src/runtime/runtime-services.ts

@@ -8,16 +8,17 @@
  */
 
 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 type { AwaitableService, AwaitableValue } from '../effect/awaitable-effect'
-import { toAwaitableService } from '../effect/awaitable-effect'
 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'
@@ -51,6 +52,7 @@ import type {
   createThreadApprovalContinuationStream,
   createThreadNativeToolApprovalStream,
   createThreadTurnStream,
+  launchBackgroundThreadWork,
   runThreadTurnInBackground,
   ThreadTurnServiceTag,
   triggerPlanNodeTurn,
@@ -58,6 +60,7 @@ import type {
 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
@@ -65,11 +68,24 @@ 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']
-type HostSvc<T extends { readonly Service: object }> = AwaitableService<T['Service']>
 
-export type AwaitableThreadService = HostSvc<typeof ThreadServiceTag> &
+// 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 AwaitableDocumentChunkService = HostSvc<typeof DocumentChunkServiceTag> &
+export type PromisifiedDocumentChunkService = HostSvc<typeof DocumentChunkServiceTag> &
   Pick<Svc<typeof DocumentChunkServiceTag>, 'syncVersionedChunks'>
 
 export type ArchiveSdkThread = (
@@ -83,15 +99,17 @@ export type UnarchiveSdkThread = (
 ) => 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: AwaitableDocumentChunkService
+  documentChunkService: PromisifiedDocumentChunkService
   generatedDocumentStorageService: HostSvc<typeof GeneratedDocumentStorageServiceTag>
   memoryService: HostSvc<typeof MemoryServiceTag>
   rerankService: HostSvc<typeof RerankServiceTag>
@@ -113,49 +131,50 @@ export interface LotaRuntimeServices {
   planAgentQueryService: HostSvc<typeof PlanAgentQueryServiceTag>
   planCycleService: HostSvc<typeof PlanCycleServiceTag>
   threadMessageService: HostSvc<typeof ThreadMessageServiceTag>
-  threadService: AwaitableThreadService
+  threadService: PromisifiedThreadService
   threadTitleService: HostSvc<typeof ThreadTitleServiceTag>
   createThreadApprovalContinuationStream: typeof createThreadApprovalContinuationStream
   createThreadNativeToolApprovalStream: typeof createThreadNativeToolApprovalStream
   createThreadTurnStream: typeof createThreadTurnStream
   isApprovalContinuationRequest: typeof isApprovalContinuationRequestFn
+  launchBackgroundThreadWork: typeof launchBackgroundThreadWork
   runThreadTurnInBackground: typeof runThreadTurnInBackground
   triggerPlanNodeTurn: typeof triggerPlanNodeTurn
 }
 
 export interface LotaRuntimeLota {
   organizations: {
-    create: AwaitableValue<Svc<typeof OrganizationServiceTag>['createOrganization']>
-    upsert: AwaitableValue<Svc<typeof OrganizationServiceTag>['upsertOrganization']>
-    get: AwaitableValue<Svc<typeof OrganizationServiceTag>['getOrganization']>
-    list: AwaitableValue<Svc<typeof OrganizationServiceTag>['listOrganizations']>
-    update: AwaitableValue<Svc<typeof OrganizationServiceTag>['updateOrganization']>
-    delete: AwaitableValue<Svc<typeof OrganizationServiceTag>['deleteOrganization']>
+    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: AwaitableValue<Svc<typeof UserServiceTag>['upsertUser']>
-    get: AwaitableValue<Svc<typeof UserServiceTag>['getUser']>
-    list: AwaitableValue<Svc<typeof UserServiceTag>['listUsers']>
-    update: AwaitableValue<Svc<typeof UserServiceTag>['updateUser']>
-    delete: AwaitableValue<Svc<typeof UserServiceTag>['deleteUser']>
+    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: AwaitableValue<Svc<typeof OrganizationMemberServiceTag>['addMembership']>
-    listForOrganization: AwaitableValue<Svc<typeof OrganizationMemberServiceTag>['listMembershipsForOrganization']>
-    listForUser: AwaitableValue<Svc<typeof OrganizationMemberServiceTag>['listMembershipsForUser']>
-    remove: AwaitableValue<Svc<typeof OrganizationMemberServiceTag>['removeMembership']>
-    isMember: AwaitableValue<Svc<typeof OrganizationMemberServiceTag>['isMember']>
+    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: AwaitableValue<Svc<typeof ThreadServiceTag>['createThread']>
-    list: AwaitableValue<Svc<typeof ThreadServiceTag>['listThreads']>
-    get: AwaitableValue<Svc<typeof ThreadServiceTag>['getThread']>
-    update: AwaitableValue<Svc<typeof ThreadServiceTag>['updateTitle']>
-    archive: AwaitableValue<ArchiveSdkThread>
-    unarchive: AwaitableValue<UnarchiveSdkThread>
-    delete: AwaitableValue<Svc<typeof ThreadServiceTag>['deleteThread']>
-    stop: AwaitableValue<Svc<typeof ThreadServiceTag>['stopActiveRun']>
-    listMessages: AwaitableValue<Svc<typeof ThreadMessageServiceTag>['listMessageHistoryPage']>
+    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
@@ -163,18 +182,21 @@ export interface LotaRuntimeLota {
       userId: string
       userName: string
       messages: Parameters<typeof routeThreadChatMessages>[0]
-    }) => Promise<Awaited<ReturnType<typeof createThreadTurnStream>>>
+    }) => Promise<EffectSuccess<ReturnType<Svc<typeof ThreadTurnServiceTag>['createThreadTurnStream']>>>
     continueApproval: (params: {
       threadId: string
       organizationId: string
       userId: string
       userName: string
       messages: Parameters<typeof routeThreadChatMessages>[0]
-    }) => Promise<Awaited<ReturnType<typeof createThreadApprovalContinuationStream>>>
-    uploadAttachment: AwaitableValue<Svc<typeof AttachmentServiceTag>['uploadThreadAttachment']>
+    }) => 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
@@ -189,20 +211,66 @@ interface RuntimeServiceSurface {
   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.
  *
- * All Effect-returning service methods are wrapped with `toAwaitableService`,
- * which means callers can `await` them directly while they stay discoverable
- * as Effects for composition.
+ * 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
-  const runPromise = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => managedRuntime.runPromise(effect)
+  // 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>): AwaitableService<T> =>
-    toAwaitableService(resolveRaw(tag), { runPromise: (effect) => managedRuntime.runPromise(effect) })
+  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)
@@ -210,7 +278,7 @@ export function buildRuntimeServiceSurface(input: BuildRuntimeServiceSurfaceInpu
   const attachmentService = resolveOnce(AttachmentServiceTag)
   const autonomousJobService = resolveOnce(AutonomousJobServiceTag)
   const contextCompactionService = resolveOnce(ContextCompactionServiceTag)
-  const documentChunkService = resolveOnce(DocumentChunkServiceTag) as AwaitableDocumentChunkService
+  const documentChunkService = resolveOnce(DocumentChunkServiceTag) as PromisifiedDocumentChunkService
   const generatedDocumentStorageService = resolveOnce(GeneratedDocumentStorageServiceTag)
   const memoryService = resolveOnce(MemoryServiceTag)
   const rerankService = resolveOnce(RerankServiceTag)
@@ -231,21 +299,25 @@ export function buildRuntimeServiceSurface(input: BuildRuntimeServiceSurfaceInpu
   const planAgentQueryService = resolveOnce(PlanAgentQueryServiceTag)
   const planCycleService = resolveOnce(PlanCycleServiceTag)
   const threadMessageService = resolveOnce(ThreadMessageServiceTag)
-  const threadService = resolveOnce(ThreadServiceTag) as AwaitableThreadService
+  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 ──
-  // `toAwaitableService` (used above) erases Effect return types so callers
-  // can `await` directly. The `getMessage`/`sendMessage`/`continueApproval`
-  // wrappers below need the raw Effect-returning signatures so they can
-  // `yield*` service methods inside their `Effect.gen` blocks.
+  // `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,
@@ -276,13 +348,13 @@ export function buildRuntimeServiceSurface(input: BuildRuntimeServiceSurfaceInpu
     threadService,
     threadTitleService,
     createThreadApprovalContinuationStream: (...args) =>
-      runPromise(threadTurnService.createThreadApprovalContinuationStream(...args)),
-    createThreadNativeToolApprovalStream: (...args) =>
-      runPromise(threadTurnService.createThreadNativeToolApprovalStream(...args)),
-    createThreadTurnStream: (...args) => runPromise(threadTurnService.createThreadTurnStream(...args)),
+      threadTurnService.createThreadApprovalContinuationStream(...args),
+    createThreadNativeToolApprovalStream: (...args) => threadTurnService.createThreadNativeToolApprovalStream(...args),
+    createThreadTurnStream: (...args) => threadTurnService.createThreadTurnStream(...args),
     isApprovalContinuationRequest: isApprovalContinuationRequestFn,
-    runThreadTurnInBackground: (...args) => runPromise(threadTurnService.runThreadTurnInBackground(...args)),
-    triggerPlanNodeTurn: (...args) => runPromise(threadTurnService.triggerPlanNodeTurn(...args)),
+    launchBackgroundThreadWork: (...args) => threadTurnService.launchBackgroundThreadWork(...args),
+    runThreadTurnInBackground: (...args) => threadTurnService.runThreadTurnInBackground(...args),
+    triggerPlanNodeTurn: (...args) => threadTurnService.triggerPlanNodeTurn(...args),
   }
 
   const lota: LotaRuntimeLota = {

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,
+    },
   }
 }

package/src/runtime/social-chat/social-chat-agent-runner.ts

@@ -2,7 +2,7 @@ import { stepCountIs } from 'ai'
 import type { ToolSet } from 'ai'
 import { Schema, Effect } from 'effect'
 
-import { getAgentRuntimeConfig, getResolvedAgentFactoryConfig } from '../../config/agent-defaults'
+import type { ResolvedAgentFactoryConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 
 interface ExecutableToolDefinition {
@@ -69,6 +69,7 @@ export function withLoggedSocialToolSet(
 }
 
 function runSocialAgentTurnEffect(params: {
+  agentFactoryConfig: ResolvedAgentFactoryConfig
   agentId: string
   mode: 'fixedThreadMode' | 'threadMode'
   threadType: 'group'
@@ -85,7 +86,8 @@ function runSocialAgentTurnEffect(params: {
   abortSignal: AbortSignal
 }): Effect.Effect<{ text: string; displayName: string }, SocialChatAgentRunnerError> {
   return Effect.gen(function* () {
-    const runtimeConfig = getAgentRuntimeConfig({
+    const { agentFactoryConfig } = params
+    const runtimeConfig = agentFactoryConfig.getAgentRuntimeConfig({
       agentId: params.agentId,
       threadType: params.threadType,
       mode: params.mode,
@@ -103,7 +105,7 @@ function runSocialAgentTurnEffect(params: {
       additionalInstructionSections: params.additionalInstructionSections,
     })
 
-    const agentFactoryEntry = getResolvedAgentFactoryConfig().createAgent[runtimeConfig.id]
+    const agentFactoryEntry = agentFactoryConfig.createAgent[runtimeConfig.id]
     if (typeof agentFactoryEntry !== 'function') {
       return yield* new SocialChatAgentRunnerError({
         message: `Social chat agent factory is not configured for ${runtimeConfig.id}`,
@@ -140,6 +142,7 @@ function runSocialAgentTurnEffect(params: {
 }
 
 export function runSocialAgentTurn(params: {
+  agentFactoryConfig: ResolvedAgentFactoryConfig
   agentId: string
   mode: 'fixedThreadMode' | 'threadMode'
   threadType: 'group'

package/src/runtime/social-chat/social-chat-history.ts

@@ -2,6 +2,7 @@ import { stripSlackToolExecutionNoticeMarkdown } from '@lota-sdk/shared'
 import type { Message, Thread } from 'chat'
 import { Schema, Effect } from 'effect'
 
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { iterateEffect } from '../../effect/helpers'
 import type {
   SocialChatHistoryMessage,
@@ -25,9 +26,10 @@ export function readSlackAuthorName(message: Message): string | undefined {
 }
 
 export function buildSocialChatThreadTranscript(
+  agentConfig: ResolvedAgentConfig,
   messages: ReadonlyArray<Pick<SocialChatHistoryMessage, 'role' | 'parts' | 'metadata'>>,
 ): string {
-  const historyMessages = toHistoryMessages([...messages])
+  const historyMessages = toHistoryMessages(agentConfig, [...messages])
   if (historyMessages.length === 0) return 'No prior thread history.'
 
   return historyMessages