@lota-sdk/core 0.4.9 → 0.4.11

package/src/runtime/agent-stream-helpers.ts

@@ -1,8 +1,8 @@
 import type { ChatMessage } from '@lota-sdk/shared'
 import type { LanguageModelUsage, UIMessageStreamOptions } from 'ai'
-import { Duration, Effect, Fiber } from 'effect'
+import { Duration, Effect, Exit, Scope } from 'effect'
 
-import { getAgentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { nowEpochMillis } from '../utils/date-time'
 import { readRecord as _readRecord } from '../utils/string'
 
@@ -106,17 +106,20 @@ export function createTimedAbortSignal(parentSignal: AbortSignal, timeoutMs: num
   const abortFromParent = () => {
     controller.abort((parentSignal as AbortSignal & { reason?: unknown }).reason)
   }
-  const timeoutFiber = Effect.runFork(
-    Effect.sleep(Duration.millis(timeoutMs)).pipe(
-      Effect.tap(() =>
-        Effect.sync(() => {
-          if (disposed || controller.signal.aborted) return
-          didTimeout = true
-          controller.abort(new Error(`Timed out after ${timeoutMs}ms`))
-        }),
-      ),
+
+  // Own a scope so the timeout fiber is cleaned up via Scope.close() on dispose,
+  // matching Effect v4 best practices (forkScoped + scope-bound finalizers).
+  const scope = Scope.makeUnsafe()
+  const timeoutEffect = Effect.sleep(Duration.millis(timeoutMs)).pipe(
+    Effect.andThen(
+      Effect.sync(() => {
+        if (disposed || controller.signal.aborted) return
+        didTimeout = true
+        controller.abort(new Error(`Timed out after ${timeoutMs}ms`))
+      }),
     ),
   )
+  Effect.runFork(Scope.provide(Effect.forkScoped(timeoutEffect), scope))
 
   if (parentSignal.aborted) {
     abortFromParent()
@@ -128,16 +131,22 @@ export function createTimedAbortSignal(parentSignal: AbortSignal, timeoutMs: num
     signal: controller.signal,
     didTimeout: () => didTimeout,
     dispose: () => {
+      if (disposed) return
       disposed = true
       parentSignal.removeEventListener('abort', abortFromParent)
-      void Effect.runFork(Fiber.interrupt(timeoutFiber))
+      void Effect.runPromise(Scope.close(scope, Exit.void).pipe(Effect.catchCause(() => Effect.void)))
     },
   }
 }
 
-export function buildSpecialistTaskMessage(params: { agentId: string; task: string }): ChatMessage {
-  const displayName = getAgentDisplayNames()[params.agentId] ?? params.agentId
-  const leadAgentDisplayName = getLeadAgentDisplayName()
+export function buildSpecialistTaskMessage(params: {
+  agentConfig: ResolvedAgentConfig
+  agentId: string
+  task: string
+}): ChatMessage {
+  const displayName = params.agentConfig.displayNames[params.agentId] ?? params.agentId
+  const leadAgentDisplayName =
+    params.agentConfig.displayNames[params.agentConfig.leadAgentId] ?? params.agentConfig.leadAgentId
   return {
     id: Bun.randomUUIDv7(),
     role: 'user',

package/src/runtime/chat-run-orchestration.ts

@@ -37,7 +37,7 @@ interface CompactionCoordination {
 }
 
 export class CompactionCoordinationTag extends Context.Service<CompactionCoordinationTag, CompactionCoordination>()(
-  'CompactionCoordination',
+  '@lota-sdk/core/CompactionCoordination',
 ) {}
 
 export const CompactionCoordinationLive = Layer.effect(

package/src/runtime/context-compaction/context-compaction-runtime.ts

@@ -48,33 +48,31 @@ function tryContextCompactionPromise<A>(
   })
 }
 
-function runContextCompacter(helperModelRuntime: HelperModelRuntime, params: ContextCompactionRunnerParams) {
-  return Effect.runPromise(
-    tryContextCompactionPromise('Failed to compact runtime context.', () =>
-      helperModelRuntime.generateHelperStructured({
-        tag: 'context-compaction',
-        createAgent: createContextCompactionAgent,
-        messages: [
-          {
-            role: 'user',
-            content: buildContextCompactionPrompt({
-              previousSummary: params.previousSummary,
-              transcript: params.transcript,
-            }),
-          },
-        ],
-        schema: ContextCompactionOutputSchema,
-        maxOutputTokens: 8_000,
-      }),
-    ).pipe(Effect.map(parseCompactionOutput)),
-  )
+function runContextCompacterEffect(helperModelRuntime: HelperModelRuntime, params: ContextCompactionRunnerParams) {
+  return tryContextCompactionPromise('Failed to compact runtime context.', () =>
+    helperModelRuntime.generateHelperStructured({
+      tag: 'context-compaction',
+      createAgent: createContextCompactionAgent,
+      messages: [
+        {
+          role: 'user',
+          content: buildContextCompactionPrompt({
+            previousSummary: params.previousSummary,
+            transcript: params.transcript,
+          }),
+        },
+      ],
+      schema: ContextCompactionOutputSchema,
+      maxOutputTokens: 8_000,
+    }),
+  ).pipe(Effect.flatMap(parseCompactionOutput))
 }
 
 export function createWiredContextCompactionRuntime(deps: CreateContextCompactionRuntimeDeps) {
   const { helperModelRuntime } = deps
 
   const runtime = createContextCompactionRuntime({
-    runCompacter: (params) => runContextCompacter(helperModelRuntime, params),
+    runCompacter: (params) => runContextCompacterEffect(helperModelRuntime, params),
     now: deps.now,
     randomId: deps.randomId,
     thresholdRatio: CONTEXT_COMPACTION_THRESHOLD_RATIO,
@@ -86,20 +84,18 @@ export function createWiredContextCompactionRuntime(deps: CreateContextCompactio
     includedToolPrefixes: CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES,
   })
 
-  function compactMemoryBlockSummary(params: { previousSummary: string; newEntriesText: string }): Promise<string> {
+  function compactMemoryBlockSummary(params: { previousSummary: string; newEntriesText: string }) {
     const previousSummary = params.previousSummary.trim()
     const newEntriesText = params.newEntriesText.trim()
-    if (!previousSummary && !newEntriesText) return Promise.resolve('')
+    if (!previousSummary && !newEntriesText) return Effect.succeed('')
 
-    return Effect.runPromise(
-      tryContextCompactionPromise('Failed to compact memory block summary.', () =>
-        helperModelRuntime.generateHelperText({
-          tag: 'memory-block-compaction',
-          createAgent: createContextCompactionAgent,
-          messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
-          maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
-        }),
-      ),
+    return tryContextCompactionPromise('Failed to compact memory block summary.', () =>
+      helperModelRuntime.generateHelperText({
+        tag: 'memory-block-compaction',
+        createAgent: createContextCompactionAgent,
+        messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
+        maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
+      }),
     )
   }
 

package/src/runtime/context-compaction/context-compaction.ts

@@ -1,7 +1,8 @@
 import type { ChatMessage } from '@lota-sdk/shared'
-import { Schema, Effect } from 'effect'
+import { Duration, Effect, Schedule, Schema } from 'effect'
 import { z } from 'zod'
 
+import { iterateEffect } from '../../effect/helpers'
 import { nowEpochMillis } from '../../utils/date-time'
 import {
   CHARS_PER_TOKEN_ESTIMATE,
@@ -64,6 +65,13 @@ class CompactionError extends Schema.TaggedErrorClass<CompactionError>()('Compac
   cause: Schema.optional(Schema.Defect),
 }) {}
 
+class CompactionParseError extends Schema.TaggedErrorClass<CompactionParseError>()('CompactionParseError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+const COMPACTION_RUNNER_RETRY_OPTIONS = { times: 2, schedule: Schedule.exponential(Duration.millis(500), 2) } as const
+
 export interface ContextCompactionPromptParams {
   previousSummary: string
   transcript: string
@@ -80,7 +88,9 @@ export interface CompactionOutput {
   summary: string
 }
 
-export type ContextCompactionRunner = (params: ContextCompactionRunnerParams) => Promise<CompactionOutput>
+export type ContextCompactionRunner = (
+  params: ContextCompactionRunnerParams,
+) => Effect.Effect<CompactionOutput, unknown>
 
 export interface CreateContextCompactionRuntimeOptions {
   runCompacter: ContextCompactionRunner
@@ -104,7 +114,7 @@ export interface ContextCompactionRuntime {
     liveMessages: ChatMessage[]
     contextSize?: number
   }) => CompactionAssessment
-  compactHistory: (params: CompactHistoryParams) => Promise<CompactHistoryResult>
+  compactHistory: (params: CompactHistoryParams) => Effect.Effect<CompactHistoryResult, CompactionError>
 }
 
 function estimateTokens(text: string): number {
@@ -325,22 +335,32 @@ export function createContextCompactionRuntime(
     return { estimatedTokens, threshold, shouldCompact: estimatedTokens >= threshold }
   }
 
-  const compactContextMessagesEffect = (params: { previousSummary: string; newMessages: ContextMessage[] }) =>
-    Effect.gen(function* () {
-      const chunks = splitByCharBudget(params.newMessages, compactionChunkMaxChars)
-      let summary = normalizeSummary(params.previousSummary)
-
-      for (const chunk of chunks) {
-        const transcript = toCompactionTranscript(chunk)
-        const output = yield* Effect.tryPromise({
-          try: () => options.runCompacter({ previousSummary: summary, chunk, transcript }),
-          catch: (error: unknown) => new CompactionError({ message: String(error), cause: error }),
-        })
-        summary = normalizeSummary(output.summary)
-      }
-
-      return { summary }
-    })
+  const compactContextMessagesEffect = Effect.fn('ContextCompaction.compactContextMessages')(function* (params: {
+    previousSummary: string
+    newMessages: ContextMessage[]
+  }) {
+    const chunks = splitByCharBudget(params.newMessages, compactionChunkMaxChars)
+    const initialSummary = normalizeSummary(params.previousSummary)
+
+    const finalSummary = yield* iterateEffect<{ summary: string; index: number }, CompactionError, never>(
+      { summary: initialSummary, index: 0 },
+      {
+        while: (state) => state.index < chunks.length,
+        body: (state) =>
+          Effect.gen(function* () {
+            const chunk = chunks[state.index]
+            const transcript = toCompactionTranscript(chunk)
+            const output = yield* options.runCompacter({ previousSummary: state.summary, chunk, transcript }).pipe(
+              Effect.mapError((error) => new CompactionError({ message: String(error), cause: error })),
+              Effect.retry(COMPACTION_RUNNER_RETRY_OPTIONS),
+            )
+            return { summary: normalizeSummary(output.summary), index: state.index + 1 }
+          }),
+      },
+    )
+
+    return { summary: finalSummary.summary }
+  })
 
   const rollupSummaryIfOversizedEffect = (summary: string) =>
     Effect.gen(function* () {
@@ -356,81 +376,104 @@ export function createContextCompactionRuntime(
       return normalizeSummary(output.summary)
     })
 
+  type CompactionLoopState = {
+    summaryText: string
+    remainingMessages: ChatMessage[]
+    compactedMessages: ChatMessage[]
+    lastCompactedMessageId: string | undefined
+    estimatedTokens: number
+    done: boolean
+  }
+
   const compactHistoryEffect = (params: CompactHistoryParams) =>
     Effect.gen(function* () {
-      let summaryText = normalizeSummary(params.summaryText)
-      let remainingMessages = [...params.liveMessages]
-      let compactedMessages: ChatMessage[] = []
-      let lastCompactedMessageId: string | undefined
-      const summaryPayload = buildSyntheticSummaryPayload(summaryText)
-      const initialPayload = stringifyUnknown([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages]) ?? ''
+      const initialSummaryText = normalizeSummary(params.summaryText)
+      const initialRemaining = [...params.liveMessages]
+      const summaryPayload = buildSyntheticSummaryPayload(initialSummaryText)
+      const initialPayload = stringifyUnknown([...(summaryPayload ? [summaryPayload] : []), ...initialRemaining]) ?? ''
       const inputChars = initialPayload.length
 
-      const buildEarlyExitResult = (estimatedTokens: number): CompactHistoryResult => {
-        const exitSummaryPayload = buildSyntheticSummaryPayload(summaryText)
+      const buildExitResult = (state: CompactionLoopState): CompactHistoryResult => {
+        const exitSummaryPayload = buildSyntheticSummaryPayload(state.summaryText)
         const outputPayload =
-          stringifyUnknown([...(exitSummaryPayload ? [exitSummaryPayload] : []), ...remainingMessages]) ?? ''
+          stringifyUnknown([...(exitSummaryPayload ? [exitSummaryPayload] : []), ...state.remainingMessages]) ?? ''
         return {
-          compacted: compactedMessages.length > 0,
-          summaryText,
-          ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
-          compactedMessages,
-          compactedMessageCount: compactedMessages.length,
-          remainingMessageCount: remainingMessages.length,
-          estimatedTokens,
+          compacted: state.compactedMessages.length > 0,
+          summaryText: state.summaryText,
+          ...(state.lastCompactedMessageId ? { lastCompactedMessageId: state.lastCompactedMessageId } : {}),
+          compactedMessages: state.compactedMessages,
+          compactedMessageCount: state.compactedMessages.length,
+          remainingMessageCount: state.remainingMessages.length,
+          estimatedTokens: state.estimatedTokens,
           inputChars,
           outputChars: outputPayload.length,
         }
       }
 
-      for (;;) {
-        const assessment = shouldCompactHistory({
-          summaryText,
-          liveMessages: remainingMessages,
-          contextSize: params.contextSize,
-        })
-
-        if (!assessment.shouldCompact) {
-          return buildEarlyExitResult(assessment.estimatedTokens)
-        }
-
-        const boundary = Math.max(0, remainingMessages.length - params.tailMessageCount)
-        if (boundary <= 0) {
-          return buildEarlyExitResult(assessment.estimatedTokens)
-        }
-
-        const candidatePrefix = remainingMessages.slice(0, boundary)
-        const messagesToCompact = candidatePrefix.filter((message) => !readIsCompacted(message))
-        const contextMessages = messagesToCompact
-          .map(toContextMessageFromChatMessage)
-          .filter((message) => compactWhitespace(message.text).length > 0)
-        const sourceText = toCompactionTranscript(contextMessages)
-
-        if (!compactWhitespace(sourceText)) {
-          return buildEarlyExitResult(assessment.estimatedTokens)
-        }
-
-        let nextSummary = normalizeSummary(
-          (yield* compactContextMessagesEffect({ previousSummary: summaryText, newMessages: contextMessages })).summary,
-        )
-        nextSummary = yield* rollupSummaryIfOversizedEffect(nextSummary)
-
-        if (nextSummary.length >= sourceText.length) {
-          return yield* new CompactionError({ message: 'Compaction summary is not shorter than compacted source' })
-        }
+      const initialState: CompactionLoopState = {
+        summaryText: initialSummaryText,
+        remainingMessages: initialRemaining,
+        compactedMessages: [],
+        lastCompactedMessageId: undefined,
+        estimatedTokens: 0,
+        done: false,
+      }
 
-        summaryText = nextSummary
-        compactedMessages = [
-          ...compactedMessages,
-          ...candidatePrefix.map((message) => markMessageCompacted(message, now)),
-        ]
-        lastCompactedMessageId = candidatePrefix.at(-1)?.id ?? lastCompactedMessageId
-        remainingMessages = remainingMessages.slice(boundary)
+      const finalState = yield* iterateEffect<CompactionLoopState, CompactionError, never>(initialState, {
+        while: (state) => !state.done,
+        body: (state) =>
+          Effect.gen(function* () {
+            const assessment = shouldCompactHistory({
+              summaryText: state.summaryText,
+              liveMessages: state.remainingMessages,
+              contextSize: params.contextSize,
+            })
+
+            if (!assessment.shouldCompact) {
+              return { ...state, estimatedTokens: assessment.estimatedTokens, done: true }
+            }
+
+            const boundary = Math.max(0, state.remainingMessages.length - params.tailMessageCount)
+            if (boundary <= 0) {
+              return { ...state, estimatedTokens: assessment.estimatedTokens, done: true }
+            }
+
+            const candidatePrefix = state.remainingMessages.slice(0, boundary)
+            const messagesToCompact = candidatePrefix.filter((message) => !readIsCompacted(message))
+            const contextMessages = messagesToCompact
+              .map(toContextMessageFromChatMessage)
+              .filter((message) => compactWhitespace(message.text).length > 0)
+            const sourceText = toCompactionTranscript(contextMessages)
+
+            if (!compactWhitespace(sourceText)) {
+              return { ...state, estimatedTokens: assessment.estimatedTokens, done: true }
+            }
+
+            const compacted = yield* compactContextMessagesEffect({
+              previousSummary: state.summaryText,
+              newMessages: contextMessages,
+            })
+            const rolledSummary = yield* rollupSummaryIfOversizedEffect(normalizeSummary(compacted.summary))
+
+            if (rolledSummary.length >= sourceText.length) {
+              return yield* new CompactionError({ message: 'Compaction summary is not shorter than compacted source' })
+            }
+
+            return {
+              summaryText: rolledSummary,
+              remainingMessages: state.remainingMessages.slice(boundary),
+              compactedMessages: [
+                ...state.compactedMessages,
+                ...candidatePrefix.map((message) => markMessageCompacted(message, now)),
+              ],
+              lastCompactedMessageId: candidatePrefix.at(-1)?.id ?? state.lastCompactedMessageId,
+              estimatedTokens: assessment.estimatedTokens,
+              done: false,
+            }
+          }),
+      })
 
-        if (remainingMessages.length <= params.tailMessageCount) {
-          continue
-        }
-      }
+      return buildExitResult(finalState)
     })
 
   return {
@@ -438,11 +481,14 @@ export function createContextCompactionRuntime(
     prependSummaryMessage,
     estimateThreshold,
     shouldCompactHistory,
-    compactHistory: (params) => Effect.runPromise(compactHistoryEffect(params)),
+    compactHistory: compactHistoryEffect,
   }
 }
 
-export function parseCompactionOutput(value: unknown): CompactionOutput {
-  const parsed = ContextCompactionOutputSchema.parse(value)
-  return { summary: parsed.summary }
+export function parseCompactionOutput(value: unknown): Effect.Effect<CompactionOutput, CompactionParseError> {
+  const parsed = ContextCompactionOutputSchema.safeParse(value)
+  if (!parsed.success) {
+    return Effect.fail(new CompactionParseError({ message: 'Failed to parse compaction output', cause: parsed.error }))
+  }
+  return Effect.succeed({ summary: parsed.data.summary })
 }

package/src/runtime/domain-layer.ts

@@ -0,0 +1,203 @@
+/**
+ * Builds the domain-service Layer tree for `createLotaRuntime`.
+ *
+ * The services form a 9-tier dependency graph on top of the infrastructure
+ * layer (config, logging, database, redis, agents, threads, extensions).
+ * Each tier is provided with the accumulated context of earlier tiers so
+ * every service resolves cleanly when the ManagedRuntime eagerly loads them.
+ */
+
+import type { Layer as LayerType } from 'effect'
+import { Layer } from 'effect'
+
+import { AiGatewayLive } from '../ai-gateway/ai-gateway'
+import { EmbeddingCacheLive } from '../ai/embedding-cache'
+import type { buildInfrastructureLayer } from '../effect/layers'
+import { LotaQueuesLive } from '../queues/queues.service'
+import { SharedThreadStreamSubscriberLive } from '../redis/stream-context'
+import { AgentActivityServiceLive } from '../services/agent-activity.service'
+import { AgentExecutorServiceLive } from '../services/agent-executor.service'
+import { ArtifactServiceLive } from '../services/artifact.service'
+import { AttachmentServiceLive } from '../services/attachment.service'
+import { AutonomousJobServiceLive } from '../services/autonomous-job.service'
+import { BackgroundWorkServiceLive } from '../services/background-work.service'
+import { ChatRunRegistryLive } from '../services/chat-run-registry.service'
+import { ContextCompactionServiceLive } from '../services/context-compaction.service'
+import { DocumentChunkServiceLive } from '../services/document-chunk.service'
+import { ExecutionPlanServiceLive } 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 } from '../services/learned-skill.service'
+import { MemoryServiceLive } from '../services/memory/memory.service'
+import { RerankServiceLive } from '../services/memory/rerank.service'
+import { MonitoringWindowServiceLive } from '../services/monitoring-window.service'
+import { MutatingApprovalServiceLive } from '../services/mutating-approval.service'
+import { NodeWorkspaceServiceLive } from '../services/node-workspace.service'
+import { NotificationServiceLive } from '../services/notification.service'
+import { OrganizationMemberServiceLive } from '../services/organization-member.service'
+import { OrganizationServiceLive } from '../services/organization.service'
+import { OwnershipDispatcherServiceLive } from '../services/ownership-dispatcher.service'
+import { PlanAgentHeartbeatServiceLive } from '../services/plan/plan-agent-heartbeat.service'
+import { PlanAgentQueryServiceLive } 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 } from '../services/plan/plan-coordination.service'
+import { PlanCycleServiceLive } from '../services/plan/plan-cycle.service'
+import { PlanDeadlineServiceLive } from '../services/plan/plan-deadline.service'
+import { PlanEventDeliveryServiceLive } from '../services/plan/plan-event-delivery.service'
+import { PlanExecutorServiceLive } from '../services/plan/plan-executor.service'
+import { PlanRunServiceLive } from '../services/plan/plan-run.service'
+import { PlanSchedulerServiceLive } from '../services/plan/plan-scheduler.service'
+import { PlanTemplateServiceLive } 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 } from '../services/recent-activity-title.service'
+import { RecentActivityServiceLive } from '../services/recent-activity.service'
+import { SkillResolverServiceLive } from '../services/skill-resolver.service'
+import { SocialChatHistoryServiceLive } from '../services/social-chat-history.service'
+import { SystemExecutorServiceLive } from '../services/system-executor.service'
+import { ThreadMessageServiceLive } from '../services/thread/thread-message.service'
+import { ThreadTitleServiceLive } from '../services/thread/thread-title.service'
+import { ThreadTurnServiceLive } from '../services/thread/thread-turn'
+import { ThreadTurnPreparationServiceLive } from '../services/thread/thread-turn-preparation.service'
+import { ThreadServiceLive } from '../services/thread/thread.service'
+import { UserServiceLive } from '../services/user.service'
+import { WriteIntentValidatorServiceLive } from '../services/write-intent-validator.service'
+import { AttachmentStorageServiceLive } from '../storage/attachment-storage.service'
+import { GeneratedDocumentStorageServiceLive } from '../storage/generated-document-storage.service'
+import { FirecrawlLive } from '../tools/firecrawl-client'
+import { CompactionCoordinationLive } from './chat-run-orchestration'
+import { HelperModelLive } from './helper-model'
+
+function provide<A, E, R extends RCtx, RCtx, E2>(
+  layer: LayerType.Layer<A, E, R>,
+  ctx: LayerType.Layer<RCtx, E2, never>,
+): LayerType.Layer<A, E | E2, never> {
+  return Layer.provideMerge(ctx)(layer)
+}
+
+type InfrastructureLayer = ReturnType<typeof buildInfrastructureLayer>
+
+/**
+ * Compose the domain service layer tree on top of the supplied infrastructure
+ * layer. The returned layer has no remaining requirements and can be fed
+ * straight into `ManagedRuntime.make`.
+ */
+export function buildDomainServiceLayer(infrastructureLayer: InfrastructureLayer) {
+  const tier0 = provide(
+    Layer.mergeAll(
+      BackgroundWorkServiceLive,
+      ChatRunRegistryLive,
+      CompactionCoordinationLive,
+      DocumentChunkServiceLive,
+      NodeWorkspaceServiceLive,
+      NotificationServiceLive,
+      PlanArtifactServiceLive,
+      PlanBuilderServiceLive,
+      WriteIntentValidatorServiceLive,
+    ),
+    infrastructureLayer,
+  )
+  const ctx0 = Layer.mergeAll(
+    infrastructureLayer,
+    provide(Layer.mergeAll(AiGatewayLive, EmbeddingCacheLive, FirecrawlLive, HelperModelLive), infrastructureLayer),
+    tier0,
+  )
+
+  const tier1 = provide(
+    Layer.mergeAll(
+      SharedThreadStreamSubscriberLive,
+      AgentExecutorServiceLive,
+      AttachmentStorageServiceLive,
+      GeneratedDocumentStorageServiceLive,
+      LearnedSkillServiceLive,
+      OrganizationServiceLive,
+      OrganizationMemberServiceLive,
+      PlanApprovalServiceLive,
+      PlanRunServiceLive,
+      PlanWorkspaceServiceLive,
+      PluginExecutorServiceLive,
+      QualityMetricsServiceLive,
+      QueueJobServiceLive,
+      RecentActivityServiceLive,
+      RerankServiceLive,
+      SocialChatHistoryServiceLive,
+      SystemExecutorServiceLive,
+      ThreadMessageServiceLive,
+      UserServiceLive,
+    ),
+    ctx0,
+  )
+  const ctx1Base = Layer.mergeAll(ctx0, tier1)
+
+  // LotaQueuesLive depends only on Redis + QueueJobService from tier1/infra.
+  // It's threaded in before the tiers that need queue enqueue access so the
+  // service layers that enqueue jobs (AutonomousJobService, plan scheduler,
+  // heartbeat, etc.) can resolve LotaQueuesServiceTag cleanly.
+  const queuesTier = provide(LotaQueuesLive, ctx1Base)
+  const ctx1 = Layer.mergeAll(ctx1Base, queuesTier)
+  // PlanSchedulerServiceLive previously sat in tier1; it now depends on the
+  // queue layer, so it moves to the merged ctx1 context with queues available.
+  const planSchedulerTier = provide(PlanSchedulerServiceLive, ctx1)
+  const ctx1WithScheduler = Layer.mergeAll(ctx1, planSchedulerTier)
+
+  const tier2 = provide(
+    Layer.mergeAll(
+      ArtifactServiceLive,
+      AttachmentServiceLive,
+      ContextCompactionServiceLive,
+      FeedbackLoopServiceLive,
+      InstitutionalMemoryServiceLive,
+      MemoryServiceLive,
+      MonitoringWindowServiceLive,
+      MutatingApprovalServiceLive,
+      PlanAgentQueryServiceLive,
+      PlanCheckpointServiceLive,
+      PlanCoordinationServiceLive,
+      PlanEventDeliveryServiceLive,
+      SkillResolverServiceLive,
+      RecentActivityTitleServiceLive,
+    ),
+    ctx1WithScheduler,
+  )
+  const ctx2 = Layer.mergeAll(ctx1WithScheduler, 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)
+  return Layer.mergeAll(ctx8, tier9)
+}