@lota-sdk/core 0.4.8 → 0.4.9

package/src/create-runtime.ts

@@ -1,121 +1,152 @@
 import type { ChatMessage } from '@lota-sdk/shared'
+import type { Context } from 'effect'
+import { Effect, Layer, ManagedRuntime } from 'effect'
+import { DevTools } from 'effect/unstable/devtools'
+import { FetchHttpClient } from 'effect/unstable/http'
+import { Otlp } from 'effect/unstable/observability'
+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 { AiGatewayLive } from './ai-gateway/ai-gateway'
+import { EmbeddingCacheLive } from './ai/embedding-cache'
 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 { publishDatabaseBootstrapEffect } from './db/startup'
 import { TABLES } from './db/tables'
+import {
+  buildInfrastructureLayer,
+  clearLotaSdkRuntime,
+  DatabaseServiceTag as EffectDatabaseService,
+  RedisServiceTag as EffectRedisService,
+  runPromise,
+  setLotaSdkRuntime,
+} from './effect'
+import type { AwaitableService, AwaitableValue } from './effect/awaitable-effect'
+import { toAwaitableService } from './effect/awaitable-effect'
+import { BadRequestError, ConfigurationError, NotFoundError, 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 { SharedThreadStreamSubscriberLive, SharedThreadStreamSubscriberTag } 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 type { LotaPlugin, SystemNodeExecutor } from './runtime/plugin-types'
-import { configureRuntimeConfig, LOTA_RUNTIME_ENV_KEYS, parseLotaRuntimeConfig } from './runtime/runtime-config'
+import { CompactionCoordinationLive } from './runtime/chat-run-orchestration'
+import { HelperModelLive } from './runtime/helper-model'
+import type { LotaPlugin, PluginLifecycleServices, SystemNodeExecutor } from './runtime/plugin-types'
+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 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 type { LotaRuntimeSocialChat } from './runtime/social-chat/social-chat'
+import { createSocialChatRuntime } from './runtime/social-chat/social-chat'
+// ── Service Layer & Tag imports ────────────────────────────────────────
+import { AgentActivityServiceLive, AgentActivityServiceTag } from './services/agent-activity.service'
+import { AgentExecutorServiceLive } from './services/agent-executor.service'
+import { ArtifactServiceLive, ArtifactServiceTag } from './services/artifact.service'
+import { AttachmentServiceLive, AttachmentServiceTag } from './services/attachment.service'
+import { AutonomousJobServiceLive, AutonomousJobServiceTag } from './services/autonomous-job.service'
+import { ChatRunRegistryLive } from './services/chat-run-registry.service'
+import { ContextCompactionServiceLive, ContextCompactionServiceTag } from './services/context-compaction.service'
+import { DocumentChunkServiceLive, DocumentChunkServiceTag } from './services/document-chunk.service'
+import { ExecutionPlanServiceLive, ExecutionPlanServiceTag } from './services/execution-plan/execution-plan.service'
+import { FeedbackLoopServiceLive } from './services/feedback-loop.service'
+import { GlobalOrchestratorServiceLive } from './services/global-orchestrator.service'
+import { InstitutionalMemoryServiceLive } from './services/institutional-memory.service'
+import { LearnedSkillServiceLive, LearnedSkillServiceTag } from './services/learned-skill.service'
+import { MemoryServiceLive, MemoryServiceTag } from './services/memory/memory.service'
+import { RerankServiceLive, RerankServiceTag } from './services/memory/rerank.service'
+import { MonitoringWindowServiceLive } from './services/monitoring-window.service'
+import { MutatingApprovalServiceLive, MutatingApprovalServiceTag } from './services/mutating-approval.service'
+import { NodeWorkspaceServiceLive } from './services/node-workspace.service'
+import { NotificationServiceLive } from './services/notification.service'
+import { OrganizationMemberServiceLive, OrganizationMemberServiceTag } from './services/organization-member.service'
+import { OrganizationServiceLive, OrganizationServiceTag } from './services/organization.service'
+import { OwnershipDispatcherServiceLive } from './services/ownership-dispatcher.service'
 import {
-  configureSocialChatHistory,
-  socialChatHistoryService as socialChatHistoryServiceSingleton,
-} 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'
+  PlanAgentHeartbeatServiceLive,
+  PlanAgentHeartbeatServiceTag,
+} from './services/plan/plan-agent-heartbeat.service'
+import { PlanAgentQueryServiceLive, PlanAgentQueryServiceTag } from './services/plan/plan-agent-query.service'
+import { PlanApprovalServiceLive } from './services/plan/plan-approval.service'
+import { PlanArtifactServiceLive } from './services/plan/plan-artifact.service'
+import { PlanBuilderServiceLive } from './services/plan/plan-builder.service'
+import { PlanCheckpointServiceLive } from './services/plan/plan-checkpoint.service'
+import { PlanCompilerServiceLive } from './services/plan/plan-compiler.service'
+import { PlanCoordinationServiceLive, PlanCoordinationServiceTag } from './services/plan/plan-coordination.service'
+import { PlanCycleServiceLive, PlanCycleServiceTag } from './services/plan/plan-cycle.service'
+import { PlanDeadlineServiceLive, PlanDeadlineServiceTag } from './services/plan/plan-deadline.service'
+import { PlanEventDeliveryServiceLive } from './services/plan/plan-event-delivery.service'
+import { PlanExecutorServiceLive, PlanExecutorServiceTag } from './services/plan/plan-executor.service'
+import { PlanRunServiceLive, PlanRunServiceTag } from './services/plan/plan-run.service'
+import { PlanSchedulerServiceLive, PlanSchedulerServiceTag } from './services/plan/plan-scheduler.service'
+import { PlanTemplateServiceLive, PlanTemplateServiceTag } from './services/plan/plan-template.service'
+import { PlanValidatorServiceLive } from './services/plan/plan-validator.service'
+import { PlanWorkspaceServiceLive } from './services/plan/plan-workspace.service'
+import { PluginExecutorServiceLive } from './services/plugin-executor.service'
+import { QualityMetricsServiceLive } from './services/quality-metrics.service'
+import { QueueJobServiceLive } from './services/queue-job.service'
+import { RecentActivityTitleServiceLive, RecentActivityTitleServiceTag } from './services/recent-activity-title.service'
+import { RecentActivityServiceLive, RecentActivityServiceTag } from './services/recent-activity.service'
+import { SkillResolverServiceLive } from './services/skill-resolver.service'
+import type { makeSocialChatHistoryService } from './services/social-chat-history.service'
+import { SocialChatHistoryServiceLive, SocialChatHistoryServiceTag } from './services/social-chat-history.service'
+import { getBuiltInSystemExecutors, SystemExecutorServiceLive } from './services/system-executor.service'
+import { ThreadMessageServiceLive, ThreadMessageServiceTag } from './services/thread/thread-message.service'
+import { ThreadTitleServiceLive, ThreadTitleServiceTag } from './services/thread/thread-title.service'
 import type {
   createThreadApprovalContinuationStream,
   createThreadNativeToolApprovalStream,
   createThreadTurnStream,
   runThreadTurnInBackground,
   triggerPlanNodeTurn,
-} from './services/thread-turn'
+} from './services/thread/thread-turn'
+import {
+  isApprovalContinuationRequest as isApprovalContinuationRequestFn,
+  ThreadTurnServiceLive,
+  ThreadTurnServiceTag,
+} from './services/thread/thread-turn'
+import { ThreadTurnPreparationServiceLive } from './services/thread/thread-turn-preparation.service'
+import { ThreadServiceLive, ThreadServiceTag } from './services/thread/thread.service'
+import { UserServiceLive, UserServiceTag } from './services/user.service'
+import { WriteIntentValidatorServiceLive } from './services/write-intent-validator.service'
+import { AttachmentStorageServiceLive } from './storage/attachment-storage.service'
 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'
+  GeneratedDocumentStorageServiceLive,
+  GeneratedDocumentStorageServiceTag,
+} from './storage/generated-document-storage.service'
+import { FirecrawlLive } from './tools/firecrawl-client'
+
+// ── Type helpers ────────────────────────────────────────────────────────
+type Svc<T extends { readonly Service: unknown }> = T['Service']
+type HostSvc<T extends { readonly Service: object }> = AwaitableService<T['Service']>
+type AwaitableThreadService = HostSvc<typeof ThreadServiceTag> &
+  Pick<Svc<typeof ThreadServiceTag>, 'withActiveRunLease'>
+type AwaitableDocumentChunkService = HostSvc<typeof DocumentChunkServiceTag> &
+  Pick<Svc<typeof DocumentChunkServiceTag>, 'syncVersionedChunks'>
 
 type ArchiveSdkThread = (
-  threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
+  threadId: Parameters<Svc<typeof ThreadServiceTag>['updateStatus']>[0],
   status?: 'archived',
-) => ReturnType<typeof threadServiceSingleton.updateStatus>
+) => ReturnType<Svc<typeof ThreadServiceTag>['updateStatus']>
 
 type UnarchiveSdkThread = (
-  threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
+  threadId: Parameters<Svc<typeof ThreadServiceTag>['updateStatus']>[0],
   status?: 'active',
-) => ReturnType<typeof threadServiceSingleton.updateStatus>
+) => ReturnType<Svc<typeof ThreadServiceTag>['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.')
-  }
+function claimRuntimeToken(): Effect.Effect<symbol, ConfigurationError> {
+  return Effect.gen(function* () {
+    if (activeRuntimeToken) {
+      return yield* new ConfigurationError({
+        message: 'createLotaRuntime() is process-scoped. Disconnect the active runtime before creating another one.',
+      })
+    }
 
-  const token = Symbol('lota-runtime')
-  activeRuntimeToken = token
-  return token
+    const token = Symbol('lota-runtime')
+    activeRuntimeToken = token
+    return token
+  })
 }
 
 function releaseRuntimeToken(token: symbol) {
@@ -124,36 +155,69 @@ function releaseRuntimeToken(token: symbol) {
   }
 }
 
+function buildObservabilityLayer(runtimeConfig: ResolvedLotaRuntimeConfig): Layer.Layer<never> {
+  let layer = Layer.empty
+  const observability = runtimeConfig.observability
+
+  if (observability.otlpBaseUrl) {
+    layer = Layer.merge(
+      layer,
+      Otlp.layerJson({
+        baseUrl: observability.otlpBaseUrl,
+        resource: {
+          serviceName: observability.serviceName,
+          ...(observability.serviceVersion ? { serviceVersion: observability.serviceVersion } : {}),
+        },
+        ...(observability.otlpHeaders ? { headers: observability.otlpHeaders } : {}),
+      }).pipe(Layer.provide(FetchHttpClient.layer)),
+    )
+  }
+
+  if (observability.devToolsUrl && Bun.env.NODE_ENV !== 'production') {
+    layer = Layer.merge(layer, DevTools.layer(observability.devToolsUrl))
+  }
+
+  return layer
+}
+
 export interface LotaRuntime {
+  /** 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: {
     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
+    agentActivityService: HostSvc<typeof AgentActivityServiceTag>
+    artifactService: HostSvc<typeof ArtifactServiceTag>
+    attachmentService: HostSvc<typeof AttachmentServiceTag>
+    autonomousJobService: HostSvc<typeof AutonomousJobServiceTag>
+    contextCompactionService: HostSvc<typeof ContextCompactionServiceTag>
+    documentChunkService: AwaitableDocumentChunkService
+    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: AwaitableThreadService
+    threadTitleService: HostSvc<typeof ThreadTitleServiceTag>
     createThreadApprovalContinuationStream: typeof createThreadApprovalContinuationStream
     createThreadNativeToolApprovalStream: typeof createThreadNativeToolApprovalStream
     createThreadTurnStream: typeof createThreadTurnStream
@@ -163,37 +227,37 @@ export interface LotaRuntime {
   }
   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
+      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']>
     }
     users: {
-      upsert: typeof userServiceSingleton.upsertUser
-      get: typeof userServiceSingleton.getUser
-      list: typeof userServiceSingleton.listUsers
-      update: typeof userServiceSingleton.updateUser
-      delete: typeof userServiceSingleton.deleteUser
+      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']>
     }
     memberships: {
-      add: typeof organizationMemberServiceSingleton.addMembership
-      listForOrganization: typeof organizationMemberServiceSingleton.listMembershipsForOrganization
-      listForUser: typeof organizationMemberServiceSingleton.listMembershipsForUser
-      remove: typeof organizationMemberServiceSingleton.removeMembership
-      isMember: typeof organizationMemberServiceSingleton.isMember
+      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']>
     }
     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
+      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']>
       getMessage: (params: { threadId: string; messageId: string }) => Promise<ChatMessage>
       sendMessage: (params: {
         threadId: string
@@ -209,11 +273,12 @@ export interface LotaRuntime {
         userName: string
         messages: Parameters<typeof routeThreadChatMessages>[0]
       }) => Promise<Awaited<ReturnType<typeof createThreadApprovalContinuationStream>>>
-      uploadAttachment: typeof attachmentServiceSingleton.uploadThreadAttachment
+      uploadAttachment: AwaitableValue<Svc<typeof AttachmentServiceTag>['uploadThreadAttachment']>
     }
   }
   redis: {
     manager: RedisConnectionManager
+    subscriber: Subscriber
     getConnection: () => ReturnType<RedisConnectionManager['getConnection']>
     getConnectionForBullMQ: () => ReturnType<RedisConnectionManager['getConnectionForBullMQ']>
     closeConnection: () => Promise<void>
@@ -230,253 +295,483 @@ export interface LotaRuntime {
   disconnect(): Promise<void>
 }
 
-export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
-  const runtimeToken = claimRuntimeToken()
-
-  try {
-    const resolvedConfig = parseLotaRuntimeConfig(config)
-    const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
-    const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
-    configureRuntimeConfig(runtimeConfig)
-
-    await configureLotaLogger(runtimeConfig.logging.level)
-
-    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 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)) {
-      throw new Error(`socialChat.agentId must be present in agents.roster: ${socialChatAgentId}`)
-    }
-    const agentDisplayNames = runtimeConfig.socialChat
-      ? { ...runtimeConfig.agents.displayNames, [socialChatAgentId]: socialChatAgentDisplayName }
-      : runtimeConfig.agents.displayNames
-
-    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 pluginRuntime = runtimeConfig.pluginRuntime ?? {}
-    if (runtimeConfig.graphDesigner) {
-      configureGraphDesigner(runtimeConfig.graphDesigner)
-    }
+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),
+  )
+}
+
+export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
+  let runtimeToken: symbol | null = null
+  let effectRuntime: { dispose(): Promise<void> } | null = null
+
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      runtimeToken = yield* claimRuntimeToken()
+      const resolvedConfig = parseLotaRuntimeConfig(config)
+      const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
+      const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
+
+      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 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,
-    })
-
-    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,
+      // ── Infrastructure layers ───────────────────────────────────────────
+      const infrastructureLayer = buildInfrastructureLayer(runtimeConfig, {
+        resolvedAgentDisplayNames,
+        observabilityLayer: buildObservabilityLayer(runtimeConfig),
+      })
+
+      // ── Domain service layers ───────────────────────────────────────────
+      function provide<A, E, R extends RCtx, RCtx, E2>(
+        layer: Layer.Layer<A, E, R>,
+        ctx: Layer.Layer<RCtx, E2, never>,
+      ): Layer.Layer<A, E | E2, never> {
+        return Layer.provideMerge(ctx)(layer)
+      }
+
+      const tier0 = provide(
+        Layer.mergeAll(
+          ChatRunRegistryLive,
+          CompactionCoordinationLive,
+          DocumentChunkServiceLive,
+          NodeWorkspaceServiceLive,
+          NotificationServiceLive,
+          PlanArtifactServiceLive,
+          PlanBuilderServiceLive,
+          WriteIntentValidatorServiceLive,
         ),
-        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.')
-          }
+        infrastructureLayer,
+      )
+      const ctx0 = Layer.mergeAll(
+        infrastructureLayer,
+        provide(Layer.mergeAll(AiGatewayLive, EmbeddingCacheLive, FirecrawlLive, HelperModelLive), infrastructureLayer),
+        tier0,
+      )
 
-          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.',
-            )
-          }
+      const tier1 = provide(
+        Layer.mergeAll(
+          SharedThreadStreamSubscriberLive,
+          AgentExecutorServiceLive,
+          AttachmentStorageServiceLive,
+          GeneratedDocumentStorageServiceLive,
+          LearnedSkillServiceLive,
+          OrganizationServiceLive,
+          OrganizationMemberServiceLive,
+          PlanApprovalServiceLive,
+          PlanRunServiceLive,
+          PlanSchedulerServiceLive,
+          PlanWorkspaceServiceLive,
+          PluginExecutorServiceLive,
+          QualityMetricsServiceLive,
+          QueueJobServiceLive,
+          RecentActivityServiceLive,
+          RerankServiceLive,
+          SocialChatHistoryServiceLive,
+          SystemExecutorServiceLive,
+          ThreadMessageServiceLive,
+          UserServiceLive,
+        ),
+        ctx0,
+      )
+      const ctx1 = Layer.mergeAll(ctx0, tier1)
 
-          return createThreadApprovalContinuationStreamSingleton({
-            thread,
-            threadRef,
-            orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
-            userRef: ensureRecordId(userId, TABLES.USER),
-            userName,
-            approvalMessages: routed.approvalMessages,
-          })
-        },
-        uploadAttachment: attachmentServiceSingleton.uploadThreadAttachment.bind(attachmentServiceSingleton),
-      },
-    } satisfies LotaRuntime['lota']
+      const tier2 = provide(
+        Layer.mergeAll(
+          ArtifactServiceLive,
+          AttachmentServiceLive,
+          ContextCompactionServiceLive,
+          FeedbackLoopServiceLive,
+          InstitutionalMemoryServiceLive,
+          MemoryServiceLive,
+          MonitoringWindowServiceLive,
+          MutatingApprovalServiceLive,
+          PlanAgentQueryServiceLive,
+          PlanCheckpointServiceLive,
+          PlanCoordinationServiceLive,
+          PlanEventDeliveryServiceLive,
+          SkillResolverServiceLive,
+          RecentActivityTitleServiceLive,
+        ),
+        ctx1,
+      )
+      const ctx2 = Layer.mergeAll(ctx1, tier2)
+
+      const tier3 = provide(Layer.mergeAll(PlanValidatorServiceLive, ThreadServiceLive), ctx2)
+      const ctx3 = Layer.mergeAll(ctx2, tier3)
+
+      const tier4 = provide(Layer.mergeAll(PlanCompilerServiceLive, ThreadTitleServiceLive), ctx3)
+      const ctx4 = Layer.mergeAll(ctx3, tier4)
+
+      const tier5 = provide(PlanExecutorServiceLive, ctx4)
+      const ctx5 = Layer.mergeAll(ctx4, tier5)
+
+      const tier6 = provide(
+        Layer.mergeAll(OwnershipDispatcherServiceLive, PlanAgentHeartbeatServiceLive, PlanDeadlineServiceLive),
+        ctx5,
+      )
+      const ctx6 = Layer.mergeAll(ctx5, tier6)
+
+      const tier7 = provide(Layer.mergeAll(ExecutionPlanServiceLive, GlobalOrchestratorServiceLive), ctx6)
+      const ctx7 = Layer.mergeAll(ctx6, tier7)
+
+      const tier8 = provide(
+        Layer.mergeAll(
+          PlanTemplateServiceLive,
+          AutonomousJobServiceLive,
+          AgentActivityServiceLive,
+          ThreadTurnPreparationServiceLive,
+        ),
+        ctx7,
+      )
+      const ctx8 = Layer.mergeAll(ctx7, tier8)
+
+      const tier9 = provide(Layer.mergeAll(PlanCycleServiceLive, ThreadTurnServiceLive), ctx8)
+      const fullLayer = Layer.mergeAll(ctx8, tier9)
+
+      const managedRuntime = ManagedRuntime.make(fullLayer)
+      effectRuntime = managedRuntime
+      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
+
+      setLotaSdkRuntime(managedRuntime)
 
-    let disconnected = false
+      type RuntimeServices = Layer.Success<typeof fullLayer>
+      const resolve = <I extends RuntimeServices, T>(tag: Context.Key<I, T>): T =>
+        managedRuntime.runSync(Effect.service(tag))
+      const resolveAwaitableService = <I extends RuntimeServices, T extends object>(
+        tag: Context.Key<I, T>,
+      ): AwaitableService<T> =>
+        toAwaitableService(resolve(tag), { runPromise: (effect) => managedRuntime.runPromise(effect) })
 
-    return {
-      services: {
+      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(pluginRuntime, connectedPluginDatabases)
+      const disconnectPluginDatabases = createPluginDatabaseDisconnector(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 services: LotaRuntime['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)
-        }
-      },
+        closeRedisConnection: () => runPromise(effectTryPromise(() => redisManager.closeConnection())),
+        get agentActivityService() {
+          return resolveAwaitableService(AgentActivityServiceTag)
+        },
+        get artifactService() {
+          return resolveAwaitableService(ArtifactServiceTag)
+        },
+        get attachmentService() {
+          return resolveAwaitableService(AttachmentServiceTag)
+        },
+        get autonomousJobService() {
+          return resolveAwaitableService(AutonomousJobServiceTag)
+        },
+        get contextCompactionService() {
+          return resolveAwaitableService(ContextCompactionServiceTag)
+        },
+        get documentChunkService() {
+          return resolveAwaitableService(DocumentChunkServiceTag) as AwaitableDocumentChunkService
+        },
+        get generatedDocumentStorageService() {
+          return resolveAwaitableService(GeneratedDocumentStorageServiceTag)
+        },
+        get memoryService() {
+          return resolveAwaitableService(MemoryServiceTag)
+        },
+        get rerankService() {
+          return resolveAwaitableService(RerankServiceTag)
+        },
+        get verifyMutatingApproval() {
+          return resolveAwaitableService(MutatingApprovalServiceTag)
+        },
+        get organizationService() {
+          return resolveAwaitableService(OrganizationServiceTag)
+        },
+        get organizationMemberService() {
+          return resolveAwaitableService(OrganizationMemberServiceTag)
+        },
+        get userService() {
+          return resolveAwaitableService(UserServiceTag)
+        },
+        get recentActivityService() {
+          return resolveAwaitableService(RecentActivityServiceTag)
+        },
+        get recentActivityTitleService() {
+          return resolveAwaitableService(RecentActivityTitleServiceTag)
+        },
+        socialChatHistoryService,
+        get executionPlanService() {
+          return resolveAwaitableService(ExecutionPlanServiceTag)
+        },
+        get planDeadlineService() {
+          return resolveAwaitableService(PlanDeadlineServiceTag)
+        },
+        get planExecutorService() {
+          return resolveAwaitableService(PlanExecutorServiceTag)
+        },
+        get planRunService() {
+          return resolveAwaitableService(PlanRunServiceTag)
+        },
+        get planTemplateService() {
+          return resolveAwaitableService(PlanTemplateServiceTag)
+        },
+        get planCoordinationService() {
+          return resolveAwaitableService(PlanCoordinationServiceTag)
+        },
+        get planSchedulerService() {
+          return resolveAwaitableService(PlanSchedulerServiceTag)
+        },
+        get planAgentHeartbeatService() {
+          return resolveAwaitableService(PlanAgentHeartbeatServiceTag)
+        },
+        get planAgentQueryService() {
+          return resolveAwaitableService(PlanAgentQueryServiceTag)
+        },
+        get planCycleService() {
+          return resolveAwaitableService(PlanCycleServiceTag)
+        },
+        get threadMessageService() {
+          return resolveAwaitableService(ThreadMessageServiceTag)
+        },
+        get threadService() {
+          return resolveAwaitableService(ThreadServiceTag) as AwaitableThreadService
+        },
+        get threadTitleService() {
+          return resolveAwaitableService(ThreadTitleServiceTag)
+        },
+        createThreadApprovalContinuationStream: (...args) =>
+          runPromise(threadTurnService.createThreadApprovalContinuationStream(...args)),
+        createThreadNativeToolApprovalStream: (...args) =>
+          runPromise(threadTurnService.createThreadNativeToolApprovalStream(...args)),
+        createThreadTurnStream: (...args) => runPromise(threadTurnService.createThreadTurnStream(...args)),
+        isApprovalContinuationRequest: isApprovalContinuationRequestFn,
+        runThreadTurnInBackground: (...args) => runPromise(threadTurnService.runThreadTurnInBackground(...args)),
+        triggerPlanNodeTurn: (...args) => runPromise(threadTurnService.triggerPlanNodeTurn(...args)),
+      }
+
+      const lota: LotaRuntime['lota'] = {
+        organizations: {
+          create: (...args) => resolveAwaitableService(OrganizationServiceTag).createOrganization(...args),
+          upsert: (...args) => resolveAwaitableService(OrganizationServiceTag).upsertOrganization(...args),
+          get: (...args) => resolveAwaitableService(OrganizationServiceTag).getOrganization(...args),
+          list: (...args) => resolveAwaitableService(OrganizationServiceTag).listOrganizations(...args),
+          update: (...args) => resolveAwaitableService(OrganizationServiceTag).updateOrganization(...args),
+          delete: (...args) => resolveAwaitableService(OrganizationServiceTag).deleteOrganization(...args),
+        },
+        users: {
+          upsert: (...args) => resolveAwaitableService(UserServiceTag).upsertUser(...args),
+          get: (...args) => resolveAwaitableService(UserServiceTag).getUser(...args),
+          list: (...args) => resolveAwaitableService(UserServiceTag).listUsers(...args),
+          update: (...args) => resolveAwaitableService(UserServiceTag).updateUser(...args),
+          delete: (...args) => resolveAwaitableService(UserServiceTag).deleteUser(...args),
+        },
+        memberships: {
+          add: (...args) => resolveAwaitableService(OrganizationMemberServiceTag).addMembership(...args),
+          listForOrganization: (...args) =>
+            resolveAwaitableService(OrganizationMemberServiceTag).listMembershipsForOrganization(...args),
+          listForUser: (...args) =>
+            resolveAwaitableService(OrganizationMemberServiceTag).listMembershipsForUser(...args),
+          remove: (...args) => resolveAwaitableService(OrganizationMemberServiceTag).removeMembership(...args),
+          isMember: (...args) => resolveAwaitableService(OrganizationMemberServiceTag).isMember(...args),
+        },
+        threads: {
+          create: (...args) => resolveAwaitableService(ThreadServiceTag).createThread(...args),
+          list: (...args) => resolveAwaitableService(ThreadServiceTag).listThreads(...args),
+          get: (...args) => resolveAwaitableService(ThreadServiceTag).getThread(...args),
+          update: (...args) => resolveAwaitableService(ThreadServiceTag).updateTitle(...args),
+          archive: (threadId, status = 'archived') =>
+            resolveAwaitableService(ThreadServiceTag).updateStatus(threadId, status),
+          unarchive: (threadId, status = 'active') =>
+            resolveAwaitableService(ThreadServiceTag).updateStatus(threadId, status),
+          delete: (...args) => resolveAwaitableService(ThreadServiceTag).deleteThread(...args),
+          stop: (...args) => resolveAwaitableService(ThreadServiceTag).stopActiveRun(...args),
+          listMessages: (...args) => resolveAwaitableService(ThreadMessageServiceTag).listMessageHistoryPage(...args),
+          getMessage: ({ threadId, messageId }) =>
+            runPromise(
+              Effect.gen(function* () {
+                const messages = yield* resolve(ThreadMessageServiceTag).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* resolve(ThreadServiceTag).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* resolve(ThreadServiceTag).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) => resolveAwaitableService(AttachmentServiceTag).uploadThreadAttachment(...args),
+        },
+      }
+
+      let disconnectPromise: Promise<void> | null = null
+
+      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: () => runPromise(effectTryPromise(() => redisManager.closeConnection())),
+        },
+        workers,
+        socialChat,
+        schemaFiles,
+        contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
+        config: runtimeConfig,
+        plugins: pluginRuntime,
+        systemExecutors,
+        connectPluginDatabases: () => runPromise(effectTryPromise(() => connectPluginDatabases())),
+        connect: () =>
+          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: () => {
+          if (disconnectPromise) {
+            return disconnectPromise
+          }
+
+          disconnectPromise = Effect.runPromise(
+            Effect.gen(function* () {
+              yield* Effect.ignore(effectTryPromise(() => socialChat.shutdown()))
+              yield* Effect.ignore(effectTryPromise(() => disconnectPluginDatabases()))
+              yield* effectTryPromise(() => managedRuntime.dispose())
+            }).pipe(
+              Effect.ensuring(
+                Effect.sync(() => {
+                  clearLotaSdkRuntime()
+                  if (runtimeToken) releaseRuntimeToken(runtimeToken)
+                }),
+              ),
+            ),
+          )
+          return disconnectPromise
+        },
+      }
+      return lotaRuntime
+    }),
+  ).catch((error) => {
+    if (effectRuntime) {
+      clearLotaSdkRuntime()
+      void effectRuntime.dispose().catch(() => undefined)
     }
-  } catch (error) {
-    releaseRuntimeToken(runtimeToken)
+    if (runtimeToken) releaseRuntimeToken(runtimeToken)
     throw error
-  }
+  })
 }
 
 function getBuiltInSchemaFiles(): URL[] {
@@ -496,16 +791,59 @@ function getBuiltInSchemaFiles(): 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
-      }
+function getPluginLifecycleServices(plugin: LotaPlugin): PluginLifecycleServices {
+  return plugin.services as PluginLifecycleServices
+}
 
-      await Reflect.apply(connectDatabase, services, [])
-    }
-  }
+function createPluginDatabaseConnector(
+  pluginRuntime: Record<string, LotaPlugin>,
+  connectedPluginDatabases: Set<string>,
+): () => Promise<void> {
+  return () =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        for (const [pluginName, plugin] of Object.entries(pluginRuntime)) {
+          if (connectedPluginDatabases.has(pluginName)) {
+            continue
+          }
+
+          const services = getPluginLifecycleServices(plugin)
+          const connectDatabase = Reflect.get(services, 'connectDatabase')
+          if (typeof connectDatabase !== 'function') {
+            continue
+          }
+
+          const connectDatabaseFn = connectDatabase as (this: typeof services) => Promise<void>
+          yield* effectTryPromise(() => connectDatabaseFn.call(services))
+          connectedPluginDatabases.add(pluginName)
+        }
+      }),
+    )
+}
+
+function createPluginDatabaseDisconnector(
+  pluginRuntime: Record<string, LotaPlugin>,
+  connectedPluginDatabases: Set<string>,
+): () => Promise<void> {
+  return () =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        for (const [pluginName, plugin] of Object.entries(pluginRuntime)) {
+          if (!connectedPluginDatabases.has(pluginName)) {
+            continue
+          }
+
+          const services = getPluginLifecycleServices(plugin)
+          const disconnectDatabase = Reflect.get(services, 'disconnectDatabase')
+          if (typeof disconnectDatabase !== 'function') {
+            connectedPluginDatabases.delete(pluginName)
+            continue
+          }
+
+          const disconnectDatabaseFn = disconnectDatabase as (this: typeof services) => Promise<void>
+          yield* effectTryPromise(() => disconnectDatabaseFn.call(services))
+          connectedPluginDatabases.delete(pluginName)
+        }
+      }),
+    )
 }