@lota-sdk/core 0.4.8 → 0.4.10

package/src/create-runtime.ts

@@ -1,219 +1,56 @@
-import type { ChatMessage } from '@lota-sdk/shared'
+import { Effect, ManagedRuntime } from 'effect'
+import type { Subscriber } from 'resumable-stream/ioredis'
 
-import { configureEmbeddingCache } from './ai/embedding-cache'
-import { configureAgentFactory, configureAgents } from './config/agent-defaults'
-import { configureLotaLogger } from './config/logger'
-import { configureThreads } from './config/thread-defaults'
-import { ensureRecordId } from './db/record-id'
 import { computeSchemaFingerprint } from './db/schema-fingerprint'
-import { LOTA_SDK_DATABASE_NAME } from './db/sdk-database'
-import type { SurrealDBService } from './db/service'
-import { SurrealDBService as SurrealDBServiceClass, setDatabaseService } from './db/service'
-import { publishDatabaseBootstrap } from './db/startup'
-import { TABLES } from './db/tables'
+import { publishDatabaseBootstrapEffect } from './db/startup'
+import {
+  buildInfrastructureLayer,
+  clearLotaSdkRuntime,
+  DatabaseServiceTag as EffectDatabaseService,
+  RedisServiceTag as EffectRedisService,
+  setLotaSdkRuntime,
+} from './effect'
+import { ConfigurationError, ServiceError } from './effect/errors'
+import { effectTryPromise } from './effect/helpers'
 import type { RedisConnectionManager } from './redis/connection'
-import { createRedisConnectionManager } from './redis/connection'
-import { setRedisConnectionManager } from './redis/index'
-import { closeSharedSubscriber } from './redis/stream-context'
-import type { isApprovalContinuationRequest } from './runtime/approval-continuation'
-import { routeThreadChatMessages } from './runtime/chat-request-routing'
-import { configureGraphDesigner } from './runtime/graph-designer'
+import { SharedThreadStreamSubscriberTag } from './redis/stream-context'
+import { buildDomainServiceLayer } from './runtime/domain-layer'
 import type { LotaPlugin, SystemNodeExecutor } from './runtime/plugin-types'
-import { configureRuntimeConfig, LOTA_RUNTIME_ENV_KEYS, parseLotaRuntimeConfig } from './runtime/runtime-config'
+import { clearRuntimeModuleAccessors, configureRuntimeModuleAccessors } from './runtime/runtime-accessors'
+import { LOTA_RUNTIME_ENV_KEYS, loadLotaRuntimeConfigFromEnv, parseLotaRuntimeConfig } from './runtime/runtime-config'
 import type { LotaRuntimeConfig, ResolvedLotaRuntimeConfig } from './runtime/runtime-config'
-import { configureRuntimeExtensions } from './runtime/runtime-extensions'
+import {
+  createPluginDatabaseConnector,
+  createPluginDatabaseDisconnector,
+  createRuntimeDisconnect,
+} from './runtime/runtime-lifecycle'
+import { buildRuntimeServiceSurface } from './runtime/runtime-services'
+import type { LotaRuntimeLota, LotaRuntimeServices } from './runtime/runtime-services'
+import { acquireRuntimeTokenEffect, isRuntimeTokenActive, releaseRuntimeToken } from './runtime/runtime-token'
 import type { LotaRuntimeWorkers } from './runtime/runtime-worker-registry'
 import { buildRuntimeWorkerRegistry } from './runtime/runtime-worker-registry'
-import type { LotaRuntimeSocialChat } from './runtime/social-chat'
-import { createSocialChatRuntime } from './runtime/social-chat'
-import type { agentActivityService } from './services/agent-activity.service'
-import { agentActivityService as agentActivityServiceSingleton } from './services/agent-activity.service'
-import type { artifactService } from './services/artifact.service'
-import { artifactService as artifactServiceSingleton } from './services/artifact.service'
-import type { attachmentService } from './services/attachment.service'
-import { attachmentService as attachmentServiceSingleton } from './services/attachment.service'
-import type { autonomousJobService } from './services/autonomous-job.service'
-import { autonomousJobService as autonomousJobServiceSingleton } from './services/autonomous-job.service'
-import type { documentChunkService } from './services/document-chunk.service'
-import { documentChunkService as documentChunkServiceSingleton } from './services/document-chunk.service'
-import type { executionPlanService } from './services/execution-plan.service'
-import { executionPlanService as executionPlanServiceSingleton } from './services/execution-plan.service'
-import type { memoryService } from './services/memory.service'
-import { memoryService as memoryServiceSingleton } from './services/memory.service'
-import type { verifyMutatingApproval } from './services/mutating-approval.service'
-import { verifyMutatingApproval as verifyMutatingApprovalSingleton } from './services/mutating-approval.service'
-import { configureNotificationService } from './services/notification.service'
-import type { organizationMemberService } from './services/organization-member.service'
-import { organizationMemberService as organizationMemberServiceSingleton } from './services/organization-member.service'
-import type { organizationService } from './services/organization.service'
-import { organizationService as organizationServiceSingleton } from './services/organization.service'
-import type { planAgentHeartbeatService } from './services/plan-agent-heartbeat.service'
-import { planAgentHeartbeatService as planAgentHeartbeatServiceSingleton } from './services/plan-agent-heartbeat.service'
-import type { planAgentQueryService } from './services/plan-agent-query.service'
-import { planAgentQueryService as planAgentQueryServiceSingleton } from './services/plan-agent-query.service'
-import type { planCoordinationService } from './services/plan-coordination.service'
-import { planCoordinationService as planCoordinationServiceSingleton } from './services/plan-coordination.service'
-import type { planCycleService } from './services/plan-cycle.service'
-import { planCycleService as planCycleServiceSingleton } from './services/plan-cycle.service'
-import type { planSchedulerService } from './services/plan-scheduler.service'
-import { planSchedulerService as planSchedulerServiceSingleton } from './services/plan-scheduler.service'
-import type { planTemplateService } from './services/plan-template.service'
-import { planTemplateService as planTemplateServiceSingleton } from './services/plan-template.service'
-import type { recentActivityTitleService } from './services/recent-activity-title.service'
-import { recentActivityTitleService as recentActivityTitleServiceSingleton } from './services/recent-activity-title.service'
-import type { recentActivityService } from './services/recent-activity.service'
-import { recentActivityService as recentActivityServiceSingleton } from './services/recent-activity.service'
-import type { rerankService } from './services/rerank.service'
-import { rerankService as rerankServiceSingleton } from './services/rerank.service'
-import {
-  configureSocialChatHistory,
-  socialChatHistoryService as socialChatHistoryServiceSingleton,
-} from './services/social-chat-history.service'
+import type { LotaRuntimeSocialChat } from './runtime/social-chat/social-chat'
+import { createSocialChatRuntime } from './runtime/social-chat/social-chat'
+import { LearnedSkillServiceTag } from './services/learned-skill.service'
+import { MemoryServiceTag } from './services/memory/memory.service'
+import { SocialChatHistoryServiceTag } from './services/social-chat-history.service'
 import { getBuiltInSystemExecutors } from './services/system-executor.service'
-import type { threadMessageService } from './services/thread-message.service'
-import { threadMessageService as threadMessageServiceSingleton } from './services/thread-message.service'
-import type { threadTitleService } from './services/thread-title.service'
-import { threadTitleService as threadTitleServiceSingleton } from './services/thread-title.service'
-import type {
-  createThreadApprovalContinuationStream,
-  createThreadNativeToolApprovalStream,
-  createThreadTurnStream,
-  runThreadTurnInBackground,
-  triggerPlanNodeTurn,
-} from './services/thread-turn'
-import {
-  createThreadApprovalContinuationStream as createThreadApprovalContinuationStreamSingleton,
-  createThreadNativeToolApprovalStream as createThreadNativeToolApprovalStreamSingleton,
-  createThreadTurnStream as createThreadTurnStreamSingleton,
-  isApprovalContinuationRequest as isApprovalContinuationRequestSingleton,
-  runThreadTurnInBackground as runThreadTurnInBackgroundSingleton,
-  triggerPlanNodeTurn as triggerPlanNodeTurnSingleton,
-} from './services/thread-turn'
-import type { threadService } from './services/thread.service'
-import { threadService as threadServiceSingleton } from './services/thread.service'
-import type { userService } from './services/user.service'
-import { userService as userServiceSingleton } from './services/user.service'
-import type { generatedDocumentStorageService } from './storage/generated-document-storage.service'
-import { generatedDocumentStorageService as generatedDocumentStorageServiceSingleton } from './storage/generated-document-storage.service'
-
-type ArchiveSdkThread = (
-  threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
-  status?: 'archived',
-) => ReturnType<typeof threadServiceSingleton.updateStatus>
-
-type UnarchiveSdkThread = (
-  threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
-  status?: 'active',
-) => ReturnType<typeof threadServiceSingleton.updateStatus>
-
-let activeRuntimeToken: symbol | null = null
-
-function claimRuntimeToken(): symbol {
-  if (activeRuntimeToken) {
-    throw new Error('createLotaRuntime() is process-scoped. Disconnect the active runtime before creating another one.')
-  }
+import { ThreadTurnServiceTag } from './services/thread/thread-turn'
 
-  const token = Symbol('lota-runtime')
-  activeRuntimeToken = token
-  return token
-}
-
-function releaseRuntimeToken(token: symbol) {
-  if (activeRuntimeToken === token) {
-    activeRuntimeToken = null
-  }
-}
+// Re-exported for consumers that reason about the runtime slot without
+// instantiating one (e.g., diagnostic harnesses).
+export { isRuntimeTokenActive }
 
 export interface LotaRuntime {
-  services: {
-    database: SurrealDBService
-    redis: RedisConnectionManager
-    closeRedisConnection: () => Promise<void>
-    agentActivityService: typeof agentActivityService
-    artifactService: typeof artifactService
-    attachmentService: typeof attachmentService
-    autonomousJobService: typeof autonomousJobService
-    documentChunkService: typeof documentChunkService
-    generatedDocumentStorageService: typeof generatedDocumentStorageService
-    memoryService: typeof memoryService
-    rerankService: typeof rerankService
-    verifyMutatingApproval: typeof verifyMutatingApproval
-    organizationService: typeof organizationService
-    organizationMemberService: typeof organizationMemberService
-    userService: typeof userService
-    recentActivityService: typeof recentActivityService
-    recentActivityTitleService: typeof recentActivityTitleService
-    socialChatHistoryService: typeof socialChatHistoryServiceSingleton
-    executionPlanService: typeof executionPlanService
-    planTemplateService: typeof planTemplateService
-    planCoordinationService: typeof planCoordinationService
-    planSchedulerService: typeof planSchedulerService
-    planAgentHeartbeatService: typeof planAgentHeartbeatService
-    planAgentQueryService: typeof planAgentQueryService
-    planCycleService: typeof planCycleService
-    threadMessageService: typeof threadMessageService
-    threadService: typeof threadService
-    threadTitleService: typeof threadTitleService
-    createThreadApprovalContinuationStream: typeof createThreadApprovalContinuationStream
-    createThreadNativeToolApprovalStream: typeof createThreadNativeToolApprovalStream
-    createThreadTurnStream: typeof createThreadTurnStream
-    isApprovalContinuationRequest: typeof isApprovalContinuationRequest
-    runThreadTurnInBackground: typeof runThreadTurnInBackground
-    triggerPlanNodeTurn: typeof triggerPlanNodeTurn
-  }
-  lota: {
-    organizations: {
-      create: typeof organizationServiceSingleton.createOrganization
-      upsert: typeof organizationServiceSingleton.upsertOrganization
-      get: typeof organizationServiceSingleton.getOrganization
-      list: typeof organizationServiceSingleton.listOrganizations
-      update: typeof organizationServiceSingleton.updateOrganization
-      delete: typeof organizationServiceSingleton.deleteOrganization
-    }
-    users: {
-      upsert: typeof userServiceSingleton.upsertUser
-      get: typeof userServiceSingleton.getUser
-      list: typeof userServiceSingleton.listUsers
-      update: typeof userServiceSingleton.updateUser
-      delete: typeof userServiceSingleton.deleteUser
-    }
-    memberships: {
-      add: typeof organizationMemberServiceSingleton.addMembership
-      listForOrganization: typeof organizationMemberServiceSingleton.listMembershipsForOrganization
-      listForUser: typeof organizationMemberServiceSingleton.listMembershipsForUser
-      remove: typeof organizationMemberServiceSingleton.removeMembership
-      isMember: typeof organizationMemberServiceSingleton.isMember
-    }
-    threads: {
-      create: typeof threadServiceSingleton.createThread
-      list: typeof threadServiceSingleton.listThreads
-      get: typeof threadServiceSingleton.getThread
-      update: typeof threadServiceSingleton.updateTitle
-      archive: ArchiveSdkThread
-      unarchive: UnarchiveSdkThread
-      delete: typeof threadServiceSingleton.deleteThread
-      stop: typeof threadServiceSingleton.stopActiveRun
-      listMessages: typeof threadMessageServiceSingleton.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<Awaited<ReturnType<typeof createThreadTurnStream>>>
-      continueApproval: (params: {
-        threadId: string
-        organizationId: string
-        userId: string
-        userName: string
-        messages: Parameters<typeof routeThreadChatMessages>[0]
-      }) => Promise<Awaited<ReturnType<typeof createThreadApprovalContinuationStream>>>
-      uploadAttachment: typeof attachmentServiceSingleton.uploadThreadAttachment
-    }
-  }
+  /** Run an Effect as a Promise through the SDK runtime (carries OTLP context). */
+  runPromise: <A, E>(effect: Effect.Effect<A, E>, options?: { readonly signal?: AbortSignal }) => Promise<A>
+  /** Run an Effect synchronously through the SDK runtime. */
+  runSync: <A, E>(effect: Effect.Effect<A, E>) => A
+  services: LotaRuntimeServices
+  lota: LotaRuntimeLota
   redis: {
     manager: RedisConnectionManager
+    subscriber: Subscriber
     getConnection: () => ReturnType<RedisConnectionManager['getConnection']>
     getConnectionForBullMQ: () => ReturnType<RedisConnectionManager['getConnectionForBullMQ']>
     closeConnection: () => Promise<void>
@@ -230,253 +67,181 @@ export interface LotaRuntime {
   disconnect(): Promise<void>
 }
 
-export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
-  const runtimeToken = claimRuntimeToken()
+export function createLotaRuntimeFromEnv(
+  config: Parameters<typeof loadLotaRuntimeConfigFromEnv>[0],
+  options?: Parameters<typeof loadLotaRuntimeConfigFromEnv>[1],
+): Promise<LotaRuntime> {
+  return Effect.runPromise(loadLotaRuntimeConfigFromEnv(config, options)).then((resolvedConfig) =>
+    createLotaRuntime(resolvedConfig),
+  )
+}
 
-  try {
-    const resolvedConfig = parseLotaRuntimeConfig(config)
-    const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
-    const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
-    configureRuntimeConfig(runtimeConfig)
+export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
+  let runtimeToken: symbol | null = null
+  let effectRuntime: { dispose(): Promise<void> } | null = null
 
-    await configureLotaLogger(runtimeConfig.logging.level)
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      // Fail fast if another runtime is already active in this process.
+      runtimeToken = yield* acquireRuntimeTokenEffect()
 
-    const db = new SurrealDBServiceClass({
-      url: runtimeConfig.database.url,
-      namespace: runtimeConfig.database.namespace,
-      database: LOTA_SDK_DATABASE_NAME,
-      username: runtimeConfig.database.username,
-      password: runtimeConfig.database.password,
-    })
-    setDatabaseService(db)
+      const resolvedConfig = parseLotaRuntimeConfig(config)
+      const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
+      const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
 
-    const redisManager = createRedisConnectionManager({ url: runtimeConfig.redis.url })
-    setRedisConnectionManager(redisManager)
-    configureEmbeddingCache(redisManager.getConnection(), runtimeConfig.memory.embeddingCacheTtlSeconds)
-    configureSocialChatHistory({ keyPrefix: runtimeConfig.socialChat?.historyRedisKeyPrefix })
+      const socialChatAgentId = runtimeConfig.socialChat?.agentId?.trim() || 'socialChat'
+      const socialChatAgentDisplayName = runtimeConfig.socialChat?.agentDisplayName?.trim() || 'Lota'
+      if (runtimeConfig.socialChat && !runtimeConfig.agents.roster.includes(socialChatAgentId)) {
+        return yield* new ConfigurationError({
+          message: `socialChat.agentId must be present in agents.roster: ${socialChatAgentId}`,
+          key: 'socialChat.agentId',
+        })
+      }
+      const resolvedAgentDisplayNames = runtimeConfig.socialChat
+        ? { ...runtimeConfig.agents.displayNames, [socialChatAgentId]: socialChatAgentDisplayName }
+        : runtimeConfig.agents.displayNames
 
-    const socialChatAgentId = runtimeConfig.socialChat?.agentId?.trim() || 'socialChat'
-    const socialChatAgentDisplayName = runtimeConfig.socialChat?.agentDisplayName?.trim() || 'Lota'
-    if (runtimeConfig.socialChat && !runtimeConfig.agents.roster.includes(socialChatAgentId)) {
-      throw new Error(`socialChat.agentId must be present in agents.roster: ${socialChatAgentId}`)
-    }
-    const agentDisplayNames = runtimeConfig.socialChat
-      ? { ...runtimeConfig.agents.displayNames, [socialChatAgentId]: socialChatAgentDisplayName }
-      : runtimeConfig.agents.displayNames
+      // ── Infrastructure + domain layer composition ─────────────────────
+      const infrastructureLayer = buildInfrastructureLayer(runtimeConfig, { resolvedAgentDisplayNames })
+      const fullLayer = buildDomainServiceLayer(infrastructureLayer)
 
-    configureAgents({
-      roster: runtimeConfig.agents.roster,
-      leadAgentId: runtimeConfig.agents.leadAgentId,
-      displayNames: agentDisplayNames,
-      shortDisplayNames: runtimeConfig.agents.shortDisplayNames,
-      descriptions: runtimeConfig.agents.descriptions,
-      routerModelId: runtimeConfig.agents.routerModelId,
-      teamConsultParticipants: runtimeConfig.agents.teamConsultParticipants,
-      getCoreThreadProfile: runtimeConfig.agents.getCoreThreadProfile,
-    })
-    configureAgentFactory({
-      createAgent: runtimeConfig.agents.createAgent,
-      buildAgentTools: runtimeConfig.agents.buildAgentTools,
-      getAgentRuntimeConfig: runtimeConfig.agents.getAgentRuntimeConfig,
-      pluginRuntime: runtimeConfig.pluginRuntime,
-    })
-    configureThreads({ agentRoster: runtimeConfig.agents.roster, config: runtimeConfig.threads })
-    configureNotificationService(runtimeConfig.notificationService ?? null)
-    configureRuntimeExtensions({
-      adapters: runtimeConfig.runtimeAdapters,
-      turnHooks: runtimeConfig.turnHooks,
-      toolProviders: (runtimeConfig.toolProviders ?? {}) as never,
-      extraWorkers: runtimeConfig.extraWorkers,
-    })
+      const managedRuntime = ManagedRuntime.make(fullLayer)
+      effectRuntime = managedRuntime
 
-    const pluginRuntime = runtimeConfig.pluginRuntime ?? {}
-    if (runtimeConfig.graphDesigner) {
-      configureGraphDesigner(runtimeConfig.graphDesigner)
-    }
+      // Eagerly resolve the services the outer entrypoint needs directly.
+      const resolvedServices = yield* Effect.tryPromise({
+        try: () =>
+          managedRuntime.runPromise(
+            Effect.gen(function* () {
+              return {
+                db: yield* EffectDatabaseService,
+                redisManager: yield* EffectRedisService,
+                sharedSubscriber: yield* SharedThreadStreamSubscriberTag,
+                threadTurnService: yield* ThreadTurnServiceTag,
+                socialChatHistoryService: yield* SocialChatHistoryServiceTag,
+                learnedSkillService: yield* LearnedSkillServiceTag,
+                memoryService: yield* MemoryServiceTag,
+              }
+            }),
+          ),
+        catch: (error) =>
+          new ServiceError({
+            message: `Failed to initialize Effect runtime services: ${error instanceof Error ? error.message : String(error)}`,
+            cause: error,
+          }),
+      })
+      const {
+        db,
+        redisManager,
+        sharedSubscriber,
+        threadTurnService,
+        socialChatHistoryService,
+        learnedSkillService,
+        memoryService,
+      } = resolvedServices
 
-    const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
-    const hostContributionSchemaFiles = pluginContributions.flatMap((plugin) => plugin.schemaFiles)
-    const schemaFiles = [
-      ...getBuiltInSchemaFiles(),
-      ...(runtimeConfig.extraSchemaFiles ?? []),
-      ...hostContributionSchemaFiles,
-    ]
-    const contributionEnvKeys = [...LOTA_RUNTIME_ENV_KEYS, ...pluginContributions.flatMap((plugin) => plugin.envKeys)]
-    const connectPluginDatabases = createPluginDatabaseConnector(pluginRuntime)
-    const workers = buildRuntimeWorkerRegistry(runtimeConfig.extraWorkers)
-    const socialChat = createSocialChatRuntime({
-      redisClient: redisManager.getConnection(),
-      socialChat: runtimeConfig.socialChat,
-    })
+      setLotaSdkRuntime(managedRuntime)
+      configureRuntimeModuleAccessors({ managedRuntime, runtimeConfig, redisManager })
 
-    const lota = {
-      organizations: {
-        create: organizationServiceSingleton.createOrganization.bind(organizationServiceSingleton),
-        upsert: organizationServiceSingleton.upsertOrganization.bind(organizationServiceSingleton),
-        get: organizationServiceSingleton.getOrganization.bind(organizationServiceSingleton),
-        list: organizationServiceSingleton.listOrganizations.bind(organizationServiceSingleton),
-        update: organizationServiceSingleton.updateOrganization.bind(organizationServiceSingleton),
-        delete: organizationServiceSingleton.deleteOrganization.bind(organizationServiceSingleton),
-      },
-      users: {
-        upsert: userServiceSingleton.upsertUser.bind(userServiceSingleton),
-        get: userServiceSingleton.getUser.bind(userServiceSingleton),
-        list: userServiceSingleton.listUsers.bind(userServiceSingleton),
-        update: userServiceSingleton.updateUser.bind(userServiceSingleton),
-        delete: userServiceSingleton.deleteUser.bind(userServiceSingleton),
-      },
-      memberships: {
-        add: organizationMemberServiceSingleton.addMembership.bind(organizationMemberServiceSingleton),
-        listForOrganization: organizationMemberServiceSingleton.listMembershipsForOrganization.bind(
-          organizationMemberServiceSingleton,
-        ),
-        listForUser: organizationMemberServiceSingleton.listMembershipsForUser.bind(organizationMemberServiceSingleton),
-        remove: organizationMemberServiceSingleton.removeMembership.bind(organizationMemberServiceSingleton),
-        isMember: organizationMemberServiceSingleton.isMember.bind(organizationMemberServiceSingleton),
-      },
-      threads: {
-        create: threadServiceSingleton.createThread.bind(threadServiceSingleton),
-        list: threadServiceSingleton.listThreads.bind(threadServiceSingleton),
-        get: threadServiceSingleton.getThread.bind(threadServiceSingleton),
-        update: threadServiceSingleton.updateTitle.bind(threadServiceSingleton),
-        archive: async (threadId, status = 'archived') => await threadServiceSingleton.updateStatus(threadId, status),
-        unarchive: async (threadId, status = 'active') => await threadServiceSingleton.updateStatus(threadId, status),
-        delete: threadServiceSingleton.deleteThread.bind(threadServiceSingleton),
-        stop: threadServiceSingleton.stopActiveRun.bind(threadServiceSingleton),
-        listMessages: threadMessageServiceSingleton.listMessageHistoryPage.bind(threadMessageServiceSingleton),
-        getMessage: async ({ threadId, messageId }) => {
-          const messages = await threadMessageServiceSingleton.listMessages(ensureRecordId(threadId, TABLES.THREAD))
-          const message = messages.find((candidate) => candidate.id === messageId)
-          if (!message) {
-            throw new Error(`Thread message not found: ${messageId}`)
-          }
-          return message
-        },
-        sendMessage: async ({ threadId, organizationId, userId, userName, messages }) => {
-          const threadRef = ensureRecordId(threadId, TABLES.THREAD)
-          const thread = await threadServiceSingleton.getThread(threadRef)
-          const routed = routeThreadChatMessages(messages)
-          if (routed.kind !== 'turn') {
-            throw new Error(routed.kind === 'invalid' ? routed.message : 'Expected a user turn payload.')
-          }
+      // ── Schema + plugin + worker + social-chat composition ────────────
+      const pluginRuntime = runtimeConfig.pluginRuntime ?? {}
+      const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
+      const hostContributionSchemaFiles = pluginContributions.flatMap((plugin) => plugin.schemaFiles)
+      const schemaFiles = [
+        ...getBuiltInSchemaFiles(),
+        ...(runtimeConfig.extraSchemaFiles ?? []),
+        ...hostContributionSchemaFiles,
+      ]
+      const contributionEnvKeys = [...LOTA_RUNTIME_ENV_KEYS, ...pluginContributions.flatMap((plugin) => plugin.envKeys)]
+      const connectedPluginDatabases = new Set<string>()
+      const connectPluginDatabases = createPluginDatabaseConnector(
+        managedRuntime,
+        pluginRuntime,
+        connectedPluginDatabases,
+      )
+      const disconnectPluginDatabases = createPluginDatabaseDisconnector(
+        managedRuntime,
+        pluginRuntime,
+        connectedPluginDatabases,
+      )
+      const workers = buildRuntimeWorkerRegistry(runtimeConfig.extraWorkers)
+      const socialChat = createSocialChatRuntime({
+        redisClient: redisManager.getConnection() as unknown as Parameters<
+          typeof createSocialChatRuntime
+        >[0]['redisClient'],
+        socialChat: runtimeConfig.socialChat,
+        services: { learnedSkillService, memoryService, socialChatHistoryService },
+      })
+      const currentContext = yield* Effect.context()
+      const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
 
-          return createThreadTurnStreamSingleton({
-            thread,
-            threadRef,
-            orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
-            userRef: ensureRecordId(userId, TABLES.USER),
-            userName,
-            inputMessage: routed.inputMessage,
-          })
-        },
-        continueApproval: async ({ threadId, organizationId, userId, userName, messages }) => {
-          const threadRef = ensureRecordId(threadId, TABLES.THREAD)
-          const thread = await threadServiceSingleton.getThread(threadRef)
-          const routed = routeThreadChatMessages(messages)
-          if (routed.kind !== 'approval-continuation') {
-            throw new Error(
-              routed.kind === 'invalid' ? routed.message : 'Expected approval continuation messages payload.',
-            )
-          }
+      // ── Service surface (eager, plain-property) ───────────────────────
+      const { services, lota } = buildRuntimeServiceSurface({
+        managedRuntime,
+        db,
+        redisManager,
+        sharedSubscriber,
+        threadTurnService,
+        socialChatHistoryService,
+      })
 
-          return createThreadApprovalContinuationStreamSingleton({
-            thread,
-            threadRef,
-            orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
-            userRef: ensureRecordId(userId, TABLES.USER),
-            userName,
-            approvalMessages: routed.approvalMessages,
-          })
+      const disconnect = createRuntimeDisconnect({
+        managedRuntime,
+        runPromiseWithCurrentContext,
+        socialChatShutdown: () => socialChat.shutdown(),
+        disconnectPluginDatabases,
+        onFinalize: () => {
+          clearRuntimeModuleAccessors()
+          clearLotaSdkRuntime()
+          if (runtimeToken) releaseRuntimeToken(runtimeToken)
         },
-        uploadAttachment: attachmentServiceSingleton.uploadThreadAttachment.bind(attachmentServiceSingleton),
-      },
-    } satisfies LotaRuntime['lota']
-
-    let disconnected = false
-
-    return {
-      services: {
-        database: db,
-        redis: redisManager,
-        closeRedisConnection: async () => await redisManager.closeConnection(),
-        agentActivityService: agentActivityServiceSingleton,
-        artifactService: artifactServiceSingleton,
-        attachmentService: attachmentServiceSingleton,
-        autonomousJobService: autonomousJobServiceSingleton,
-        documentChunkService: documentChunkServiceSingleton,
-        generatedDocumentStorageService: generatedDocumentStorageServiceSingleton,
-        memoryService: memoryServiceSingleton,
-        rerankService: rerankServiceSingleton,
-        verifyMutatingApproval: verifyMutatingApprovalSingleton,
-        organizationService: organizationServiceSingleton,
-        organizationMemberService: organizationMemberServiceSingleton,
-        userService: userServiceSingleton,
-        recentActivityService: recentActivityServiceSingleton,
-        recentActivityTitleService: recentActivityTitleServiceSingleton,
-        socialChatHistoryService: socialChatHistoryServiceSingleton,
-        executionPlanService: executionPlanServiceSingleton,
-        planTemplateService: planTemplateServiceSingleton,
-        planCoordinationService: planCoordinationServiceSingleton,
-        planSchedulerService: planSchedulerServiceSingleton,
-        planAgentHeartbeatService: planAgentHeartbeatServiceSingleton,
-        planAgentQueryService: planAgentQueryServiceSingleton,
-        planCycleService: planCycleServiceSingleton,
-        threadMessageService: threadMessageServiceSingleton,
-        threadService: threadServiceSingleton,
-        threadTitleService: threadTitleServiceSingleton,
-        createThreadApprovalContinuationStream: createThreadApprovalContinuationStreamSingleton,
-        createThreadNativeToolApprovalStream: createThreadNativeToolApprovalStreamSingleton,
-        createThreadTurnStream: createThreadTurnStreamSingleton,
-        isApprovalContinuationRequest: isApprovalContinuationRequestSingleton,
-        runThreadTurnInBackground: runThreadTurnInBackgroundSingleton,
-        triggerPlanNodeTurn: triggerPlanNodeTurnSingleton,
-      },
-      lota,
-      redis: {
-        manager: redisManager,
-        getConnection: () => redisManager.getConnection(),
-        getConnectionForBullMQ: () => redisManager.getConnectionForBullMQ(),
-        closeConnection: async () => await redisManager.closeConnection(),
-      },
-      workers,
-      socialChat,
-      schemaFiles,
-      contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
-      config: runtimeConfig,
-      plugins: pluginRuntime,
-      systemExecutors,
-      async connectPluginDatabases() {
-        await connectPluginDatabases()
-      },
-      async connect() {
-        await db.connect()
-        const bunFiles = schemaFiles.map((schemaFile) =>
-          schemaFile instanceof URL ? Bun.file(schemaFile.pathname) : Bun.file(schemaFile),
-        )
-        await db.applySchema(bunFiles)
-        const schemaFingerprint = await computeSchemaFingerprint(schemaFiles)
-        await publishDatabaseBootstrap({ databaseService: db, schemaFingerprint })
-      },
-      async disconnect() {
-        if (disconnected) {
-          return
-        }
-        disconnected = true
+      })
 
-        try {
-          await socialChat.shutdown()
-          await closeSharedSubscriber()
-          await db.disconnect()
-          await redisManager.closeConnection()
-        } finally {
-          releaseRuntimeToken(runtimeToken)
-        }
-      },
+      const lotaRuntime: LotaRuntime = {
+        runPromise: (effect, options) => managedRuntime.runPromise(effect, options),
+        runSync: (effect) => managedRuntime.runSync(effect),
+        services,
+        lota,
+        redis: {
+          manager: redisManager,
+          subscriber: sharedSubscriber.subscriber,
+          getConnection: () => redisManager.getConnection(),
+          getConnectionForBullMQ: () => redisManager.getConnectionForBullMQ(),
+          closeConnection: () => managedRuntime.runPromise(effectTryPromise(() => redisManager.closeConnection())),
+        },
+        workers,
+        socialChat,
+        schemaFiles,
+        contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
+        config: runtimeConfig,
+        plugins: pluginRuntime,
+        systemExecutors,
+        connectPluginDatabases,
+        connect: () =>
+          managedRuntime.runPromise(
+            Effect.gen(function* () {
+              yield* db.connect()
+              const bunFiles = schemaFiles.map((schemaFile) =>
+                schemaFile instanceof URL ? Bun.file(schemaFile.pathname) : Bun.file(schemaFile),
+              )
+              yield* db.applySchema(bunFiles)
+              const schemaFingerprint = yield* effectTryPromise(() => computeSchemaFingerprint(schemaFiles))
+              yield* publishDatabaseBootstrapEffect({ databaseService: db, schemaFingerprint })
+            }),
+          ),
+        disconnect,
+      }
+      return lotaRuntime
+    }),
+  ).catch((error) => {
+    if (effectRuntime) {
+      clearRuntimeModuleAccessors()
+      clearLotaSdkRuntime()
+      void effectRuntime.dispose().catch(() => undefined)
     }
-  } catch (error) {
-    releaseRuntimeToken(runtimeToken)
+    if (runtimeToken) releaseRuntimeToken(runtimeToken)
     throw error
-  }
+  })
 }
 
 function getBuiltInSchemaFiles(): URL[] {
@@ -495,17 +260,3 @@ function getBuiltInSchemaFiles(): URL[] {
     new URL('../infrastructure/schema/10_autonomous_job.surql', import.meta.url),
   ]
 }
-
-function createPluginDatabaseConnector(pluginRuntime: Record<string, LotaPlugin>): () => Promise<void> {
-  return async () => {
-    for (const plugin of Object.values(pluginRuntime)) {
-      const services = plugin.services
-      const connectDatabase = services.connectDatabase
-      if (typeof connectDatabase !== 'function') {
-        continue
-      }
-
-      await Reflect.apply(connectDatabase, services, [])
-    }
-  }
-}