@lota-sdk/core 0.4.9 → 0.4.11

package/src/runtime/execution-plan-visibility.ts

@@ -1,8 +1,10 @@
 import type { PlanExecutionVisibility, PlanNodeSpecRecord, PlanSpecRecord } from '@lota-sdk/shared'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { isAgentName } from '../config/agent-defaults'
 
 export function resolvePlanNodeExecutionVisibility(
+  agentConfig: ResolvedAgentConfig,
   plan: Pick<PlanSpecRecord, 'defaultExecutionVisibility'>,
   node: Pick<PlanNodeSpecRecord, 'executionVisibility' | 'owner'>,
 ): PlanExecutionVisibility {
@@ -12,12 +14,13 @@ export function resolvePlanNodeExecutionVisibility(
     return configuredVisibility
   }
 
-  return node.owner.executorType === 'agent' && isAgentName(node.owner.ref) ? 'visible' : 'silent'
+  return node.owner.executorType === 'agent' && isAgentName(agentConfig, node.owner.ref) ? 'visible' : 'silent'
 }
 
 export function shouldPlanNodeUseVisibleTurn(
+  agentConfig: ResolvedAgentConfig,
   plan: Pick<PlanSpecRecord, 'defaultExecutionVisibility'>,
   node: Pick<PlanNodeSpecRecord, 'executionVisibility' | 'owner'>,
 ): boolean {
-  return resolvePlanNodeExecutionVisibility(plan, node) === 'visible'
+  return resolvePlanNodeExecutionVisibility(agentConfig, plan, node) === 'visible'
 }

package/src/runtime/graph-designer.ts

@@ -1,19 +1,5 @@
 import type { GraphDesignRequest, GraphDesignResponse } from '@lota-sdk/shared'
-import { Effect } from 'effect'
-
-import { getOptionalCurrentRuntime } from '../effect/runtime-ref'
-import { RuntimeConfigServiceTag } from '../effect/services'
 
 export interface GraphDesigner {
   designGraph(request: GraphDesignRequest): Promise<GraphDesignResponse>
 }
-
-export function getGraphDesigner(): GraphDesigner | null {
-  const runtime = getOptionalCurrentRuntime()
-  if (!runtime) {
-    return null
-  }
-
-  const runtimeConfig = runtime.runSync(Effect.service(RuntimeConfigServiceTag))
-  return runtimeConfig.graphDesigner ?? null
-}

package/src/runtime/helper-model.ts

@@ -253,7 +253,7 @@ export function createHelperModelRuntime() {
   }
 
   function generateHelperText(params: GenerateHelperTextParams): Promise<string> {
-    return Effect.runPromise(generateHelperTextEffect(params))
+    return Effect.runPromise(generateHelperTextEffect(params).pipe(Effect.withSpan('HelperModel.generateHelperText')))
   }
 
   function generateHelperStructuredEffect<T>(
@@ -300,7 +300,9 @@ export function createHelperModelRuntime() {
   }
 
   function generateHelperStructured<T>(params: GenerateHelperStructuredParams<T>): Promise<T> {
-    return Effect.runPromise(generateHelperStructuredEffect(params))
+    return Effect.runPromise(
+      generateHelperStructuredEffect(params).pipe(Effect.withSpan('HelperModel.generateHelperStructured')),
+    )
   }
 
   return { generateHelperTextEffect, generateHelperText, generateHelperStructuredEffect, generateHelperStructured }
@@ -308,6 +310,8 @@ export function createHelperModelRuntime() {
 
 export type HelperModelRuntime = ReturnType<typeof createHelperModelRuntime>
 
-export class HelperModelTag extends Context.Service<HelperModelTag, HelperModelRuntime>()('HelperModel') {}
+export class HelperModelTag extends Context.Service<HelperModelTag, HelperModelRuntime>()(
+  '@lota-sdk/core/HelperModel',
+) {}
 
-export const HelperModelLive = Layer.succeed(HelperModelTag, createHelperModelRuntime())
+export const HelperModelLive = Layer.sync(HelperModelTag, () => createHelperModelRuntime())

package/src/runtime/index.ts

@@ -1,8 +1,8 @@
 export * from './approval-continuation'
 export * from './agent-runtime-policy'
 export * from './agent-stream-helpers'
-export * from './agent-types'
 export * from './chat-request-routing'
+export * from './chat-run-orchestration'
 export * from './chat-run-registry'
 export * from './context-compaction/context-compaction'
 export * from './execution-plan'

package/src/runtime/indexed-repositories-policy.ts

@@ -1,5 +1,3 @@
-import { getAgentRoster } from '../config/agent-defaults'
-
 export type IndexedRepoAgentName = string
 
 export const REPO_SECTION_NAMES = [
@@ -16,13 +14,11 @@ export type RepoSectionName = (typeof REPO_SECTION_NAMES)[number]
 const ALL_REPO_SECTIONS: RepoSectionName[] = [...REPO_SECTION_NAMES]
 
 export function buildDefaultRepoSectionsByAgent(
-  roster: readonly IndexedRepoAgentName[] = getAgentRoster(),
+  roster: readonly IndexedRepoAgentName[],
 ): Record<IndexedRepoAgentName, RepoSectionName[]> {
   return Object.fromEntries(roster.map((agentId) => [agentId, [...ALL_REPO_SECTIONS]]))
 }
 
-export function emptyAgentContextMap(
-  roster: readonly IndexedRepoAgentName[] = getAgentRoster(),
-): Record<IndexedRepoAgentName, string> {
+export function emptyAgentContextMap(roster: readonly IndexedRepoAgentName[]): Record<IndexedRepoAgentName, string> {
   return Object.fromEntries(roster.map((agentId) => [agentId, '']))
 }

package/src/runtime/memory/memory-block.ts

@@ -1,10 +1,14 @@
-import type { Cause } from 'effect'
-import { DateTime, Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import { z } from 'zod'
 
-import { effectTryPromise } from '../../effect/helpers'
+import { nowDate } from '../../utils/date-time'
 import { compactWhitespace } from '../../utils/string'
 
+export class MemoryBlockCompactError extends Schema.TaggedErrorClass<MemoryBlockCompactError>()(
+  'MemoryBlockCompactError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
 function escapeRegex(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
@@ -61,7 +65,7 @@ export interface CompactMemoryBlockEntriesParams {
   compact: (params: {
     previousSummary: string
     newEntriesText: string
-  }) => PromiseLike<string> | Effect.Effect<string, unknown>
+  }) => PromiseLike<string> | Effect.Effect<string, MemoryBlockCompactError>
 }
 
 export interface CompactMemoryBlockEntriesResult {
@@ -106,7 +110,7 @@ function toMemoryBlockEntriesSource(entries: Array<{ role: string; content: stri
 
 export function compactMemoryBlockEntries(
   params: CompactMemoryBlockEntriesParams,
-): Effect.Effect<CompactMemoryBlockEntriesResult, Cause.UnknownError> {
+): Effect.Effect<CompactMemoryBlockEntriesResult, MemoryBlockCompactError> {
   return Effect.gen(function* () {
     let summary = typeof params.previousSummary === 'string' ? params.previousSummary.trim() : ''
     let entries = [...params.entries]
@@ -114,9 +118,15 @@ export function compactMemoryBlockEntries(
 
     while (entries.length >= params.triggerEntries) {
       const chunk = entries.slice(0, params.chunkEntries)
-      const nextSummary = (yield* effectTryPromise(() =>
-        params.compact({ previousSummary: summary, newEntriesText: toMemoryBlockEntriesSource(chunk) }),
-      )).trim()
+      const compactParams = { previousSummary: summary, newEntriesText: toMemoryBlockEntriesSource(chunk) }
+      const value = params.compact(compactParams)
+      const raw = yield* Effect.isEffect(value)
+        ? value
+        : Effect.tryPromise({
+            try: () => Promise.resolve(value),
+            catch: (cause) => new MemoryBlockCompactError({ message: 'compact callback failed', cause }),
+          })
+      const nextSummary = raw.trim()
 
       if (!nextSummary) {
         break
@@ -162,7 +172,7 @@ export interface CreateMemoryBlockRuntimeOptions {
 export function createMemoryBlockRuntime(options: CreateMemoryBlockRuntimeOptions = {}): MemoryBlockRuntime {
   const labelPrefixRegex = createLabelPrefixRegex(options.labelRoles ?? [])
   const memoryBlockMaxChars = options.maxChars ?? 400
-  const now = options.now ?? (() => Effect.runSync(DateTime.nowAsDate))
+  const now = options.now ?? nowDate
 
   const normalizeMemoryBlockEntry = (entry: string): string => {
     const normalizedLines = entry

package/src/runtime/memory/memory-pipeline.ts

@@ -1,3 +1,5 @@
+import { Match } from 'effect'
+
 import { clampImportance, compactWhitespace } from '../../utils/string'
 
 const SCORE_WEIGHTS = {
@@ -123,20 +125,17 @@ function scoreFact<T extends MemoryFactInput>(fact: T): number {
   const durability = fact.durability ?? 'standard'
   const type = fact.type ?? 'fact'
 
-  const durabilityWeight =
-    durability === 'core'
-      ? SCORE_WEIGHTS.durability.core
-      : durability === 'standard'
-        ? SCORE_WEIGHTS.durability.standard
-        : SCORE_WEIGHTS.durability.weak
-  const typeWeight =
-    type === 'decision'
-      ? SCORE_WEIGHTS.type.decision
-      : type === 'fact'
-        ? SCORE_WEIGHTS.type.fact
-        : type === 'preference'
-          ? SCORE_WEIGHTS.type.preference
-          : SCORE_WEIGHTS.type.default
+  const durabilityWeight = Match.value(durability).pipe(
+    Match.when('core', () => SCORE_WEIGHTS.durability.core),
+    Match.when('standard', () => SCORE_WEIGHTS.durability.standard),
+    Match.orElse(() => SCORE_WEIGHTS.durability.weak),
+  )
+  const typeWeight = Match.value(type).pipe(
+    Match.when('decision', () => SCORE_WEIGHTS.type.decision),
+    Match.when('fact', () => SCORE_WEIGHTS.type.fact),
+    Match.when('preference', () => SCORE_WEIGHTS.type.preference),
+    Match.orElse(() => SCORE_WEIGHTS.type.default),
+  )
   const lengthWeight =
     Math.min(fact.content.length, SCORE_WEIGHTS.maxContentLength) / SCORE_WEIGHTS.maxContentLength / 10
 
@@ -340,61 +339,49 @@ export function compileMemoryUpdatesFromDelta(params: {
       deleteSet.add(invalidateId)
     }
 
-    if (item.classification === 'duplicate') {
-      const targetId = item.targetMemoryIds[0]
-      if (targetId) {
-        updates.push({ id: targetId, text: existingById.get(targetId) ?? item.fact, event: 'NONE' })
-      } else {
-        updates.push({ id: `noop_${item.index}`, text: item.fact, event: 'NONE' })
-      }
-      continue
-    }
-
-    if (item.classification === 'enriches') {
-      const targetId = item.targetMemoryIds[0]
-      if (targetId) {
-        const relations = buildRelations(item, 'new').filter((relation) => relation.memoryId !== targetId)
-        updates.push({
-          id: targetId,
-          text: item.fact,
-          event: 'UPDATE',
-          oldMemory: existingById.get(targetId),
-          ...(relations.length > 0 ? { relatesTo: relations } : {}),
-        })
-        continue
-      }
+    const nextUpdates = Match.value(item.classification).pipe(
+      Match.when('duplicate', (): MemoryUpdateItemLike[] => {
+        const targetId = item.targetMemoryIds[0]
+        if (targetId) {
+          return [{ id: targetId, text: existingById.get(targetId) ?? item.fact, event: 'NONE' }]
+        }
+        return [{ id: `noop_${item.index}`, text: item.fact, event: 'NONE' }]
+      }),
+      Match.when('enriches', (): MemoryUpdateItemLike[] => {
+        const targetId = item.targetMemoryIds[0]
+        if (targetId) {
+          const relations = buildRelations(item, 'new').filter((relation) => relation.memoryId !== targetId)
+          return [
+            {
+              id: targetId,
+              text: item.fact,
+              event: 'UPDATE',
+              oldMemory: existingById.get(targetId),
+              ...(relations.length > 0 ? { relatesTo: relations } : {}),
+            },
+          ]
+        }
 
-      const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
-      const relations = buildRelations(item, 'new')
-      updates.push({
-        id: addId,
-        text: item.fact,
-        event: 'ADD',
-        ...(relations.length > 0 ? { relatesTo: relations } : {}),
-      })
-      continue
-    }
+        const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
+        const relations = buildRelations(item, 'new')
+        return [{ id: addId, text: item.fact, event: 'ADD', ...(relations.length > 0 ? { relatesTo: relations } : {}) }]
+      }),
+      Match.whenOr('supersedes', 'contradicts', (classification): MemoryUpdateItemLike[] => {
+        const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
+        const relations = buildRelations(item, classification)
+        return [{ id: addId, text: item.fact, event: 'ADD', ...(relations.length > 0 ? { relatesTo: relations } : {}) }]
+      }),
+      Match.when('new', (): MemoryUpdateItemLike[] => {
+        const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
+        const relations = buildRelations(item, 'new')
+        return [{ id: addId, text: item.fact, event: 'ADD', ...(relations.length > 0 ? { relatesTo: relations } : {}) }]
+      }),
+      Match.exhaustive,
+    )
 
-    if (item.classification === 'supersedes' || item.classification === 'contradicts') {
-      const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
-      const relations = buildRelations(item, item.classification)
-      updates.push({
-        id: addId,
-        text: item.fact,
-        event: 'ADD',
-        ...(relations.length > 0 ? { relatesTo: relations } : {}),
-      })
-      continue
+    for (const update of nextUpdates) {
+      updates.push(update)
     }
-
-    const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
-    const relations = buildRelations(item, 'new')
-    updates.push({
-      id: addId,
-      text: item.fact,
-      event: 'ADD',
-      ...(relations.length > 0 ? { relatesTo: relations } : {}),
-    })
   }
 
   const preservedRelationTargetIds = new Set<string>()

package/src/runtime/memory/memory-scope.ts

@@ -1,4 +1,4 @@
-import { Schema } from 'effect'
+import { Effect, Schema } from 'effect'
 
 export const ORG_SCOPE_PREFIX = 'org'
 
@@ -9,41 +9,45 @@ export class MemoryScopeError extends Schema.TaggedErrorClass<MemoryScopeError>(
   message: Schema.String,
 }) {}
 
-function stripRecordPrefix(id: string): string {
+function stripRecordPrefix(id: string): Effect.Effect<string, MemoryScopeError> {
   if (typeof id !== 'string' || id.length === 0) {
-    throw new MemoryScopeError({ message: 'id must be a non-empty string' })
+    return Effect.fail(new MemoryScopeError({ message: 'id must be a non-empty string' }))
   }
   const [, ...rest] = id.split(':')
-  return rest.length > 0 ? rest.join(':') : id
+  return Effect.succeed(rest.length > 0 ? rest.join(':') : id)
 }
 
-export function scopeId(prefix: string, id: string): string {
-  if (typeof prefix !== 'string' || prefix.length === 0) {
-    throw new MemoryScopeError({ message: 'prefix must be a non-empty string' })
-  }
-  if (!SCOPE_PREFIX_REGEX.test(prefix)) {
-    throw new MemoryScopeError({ message: `Invalid scope prefix: ${prefix}` })
-  }
-
-  const stripped = stripRecordPrefix(id)
-  const scoped = `${prefix}:${stripped}`
-  if (scoped.length > SCOPE_ID_MAX_LENGTH) {
-    throw new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
-  }
-
-  return scoped
+export function scopeId(prefix: string, id: string): Effect.Effect<string, MemoryScopeError> {
+  return Effect.gen(function* () {
+    if (typeof prefix !== 'string' || prefix.length === 0) {
+      return yield* new MemoryScopeError({ message: 'prefix must be a non-empty string' })
+    }
+    if (!SCOPE_PREFIX_REGEX.test(prefix)) {
+      return yield* new MemoryScopeError({ message: `Invalid scope prefix: ${prefix}` })
+    }
+
+    const stripped = yield* stripRecordPrefix(id)
+    const scoped = `${prefix}:${stripped}`
+    if (scoped.length > SCOPE_ID_MAX_LENGTH) {
+      return yield* new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
+    }
+
+    return scoped
+  })
 }
 
-export function agentScopeId(orgId: string, agentName: string): string {
-  if (typeof agentName !== 'string' || agentName.trim().length === 0) {
-    throw new MemoryScopeError({ message: 'agentName must be a non-empty string' })
-  }
-  const strippedOrgId = stripRecordPrefix(orgId)
-  const scoped = `agent:${strippedOrgId}:${agentName.trim()}`
+export function agentScopeId(orgId: string, agentName: string): Effect.Effect<string, MemoryScopeError> {
+  return Effect.gen(function* () {
+    if (typeof agentName !== 'string' || agentName.trim().length === 0) {
+      return yield* new MemoryScopeError({ message: 'agentName must be a non-empty string' })
+    }
+    const strippedOrgId = yield* stripRecordPrefix(orgId)
+    const scoped = `agent:${strippedOrgId}:${agentName.trim()}`
 
-  if (scoped.length > SCOPE_ID_MAX_LENGTH) {
-    throw new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
-  }
+    if (scoped.length > SCOPE_ID_MAX_LENGTH) {
+      return yield* new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
+    }
 
-  return scoped
+    return scoped
+  })
 }

package/src/runtime/plugin-resolution.ts

@@ -1,9 +1,7 @@
 import { Schema, Effect } from 'effect'
 
-import { getPluginRuntime } from '../config/agent-defaults'
 import type { RecordIdRef } from '../db/record-id'
-import type { LotaRuntimeIndexedRepositoriesContext } from './runtime-extensions'
-import { getRuntimeAdapters } from './runtime-extensions'
+import type { LotaRuntimeAdapters, LotaRuntimeIndexedRepositoriesContext } from './runtime-extensions'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null
@@ -35,79 +33,68 @@ function readFunctionEffect(
   return Effect.succeed(value as (...args: unknown[]) => PromiseLike<unknown>)
 }
 
+function configError(message: string): PluginResolutionError {
+  return new PluginResolutionError({ stage: 'configuration', message, cause: undefined })
+}
+
+function requireRecord(value: unknown, message: string): Effect.Effect<Record<string, unknown>, PluginResolutionError> {
+  return isRecord(value) ? Effect.succeed(value) : Effect.fail(configError(message))
+}
+
 function resolvePluginServiceEffect(
+  pluginRuntime: Record<string, unknown> | undefined,
   pluginName: string,
   serviceName: string,
   methodName: string,
 ): Effect.Effect<(...args: unknown[]) => PromiseLike<unknown>, PluginResolutionError> {
-  const pluginRuntime = getPluginRuntime()
-  if (!pluginRuntime) {
-    return Effect.fail(
-      new PluginResolutionError({
-        stage: 'configuration',
-        message: `Plugin runtime is not configured. Missing "${pluginName}" integration.`,
-        cause: undefined,
-      }),
-    )
-  }
-
-  const plugin = pluginRuntime[pluginName]
-  if (!isRecord(plugin)) {
-    return Effect.fail(
-      new PluginResolutionError({
-        stage: 'configuration',
-        message: `Plugin "${pluginName}" is not configured in the current runtime.`,
-        cause: undefined,
-      }),
-    )
-  }
-
-  const services = plugin.services
-  if (!isRecord(services)) {
-    return Effect.fail(
-      new PluginResolutionError({
-        stage: 'configuration',
-        message: `Plugin "${pluginName}" does not expose a services registry.`,
-        cause: undefined,
-      }),
-    )
-  }
-
-  const service = services[serviceName]
-  if (!isRecord(service)) {
-    return Effect.fail(
-      new PluginResolutionError({
-        stage: 'configuration',
-        message: `Plugin "${pluginName}" service "${serviceName}" is not configured.`,
-        cause: undefined,
-      }),
-    )
-  }
-
-  return readFunctionEffect(
-    service[methodName],
-    `Plugin "${pluginName}" service "${serviceName}" is missing method "${methodName}".`,
-  ).pipe(
-    Effect.map(
-      (method) =>
-        (...args: unknown[]) =>
-          Reflect.apply(method, service, args),
+  return Effect.fromNullishOr(pluginRuntime).pipe(
+    Effect.mapError(() => configError(`Plugin runtime is not configured. Missing "${pluginName}" integration.`)),
+    Effect.flatMap((runtime) =>
+      requireRecord(runtime[pluginName], `Plugin "${pluginName}" is not configured in the current runtime.`),
+    ),
+    Effect.flatMap((plugin) =>
+      requireRecord(plugin.services, `Plugin "${pluginName}" does not expose a services registry.`),
+    ),
+    Effect.flatMap((services) =>
+      requireRecord(services[serviceName], `Plugin "${pluginName}" service "${serviceName}" is not configured.`).pipe(
+        Effect.flatMap((service) =>
+          readFunctionEffect(
+            service[methodName],
+            `Plugin "${pluginName}" service "${serviceName}" is missing method "${methodName}".`,
+          ).pipe(
+            Effect.map(
+              (method) =>
+                (...args: unknown[]) =>
+                  Reflect.apply(method, service, args),
+            ),
+          ),
+        ),
+      ),
     ),
   )
 }
 
 function tryResolvePluginServiceEffect(
+  pluginRuntime: Record<string, unknown> | undefined,
   pluginName: string,
   serviceName: string,
   methodName: string,
-): Effect.Effect<((...args: unknown[]) => PromiseLike<unknown>) | undefined> {
-  return Effect.catch(resolvePluginServiceEffect(pluginName, serviceName, methodName), () => Effect.succeed(undefined))
+): Effect.Effect<((...args: unknown[]) => PromiseLike<unknown>) | void, never, never> {
+  return Effect.catch(resolvePluginServiceEffect(pluginRuntime, pluginName, serviceName, methodName), () => Effect.void)
 }
 
-export function getLinearInstallationByOrgId(organizationId: RecordIdRef): Promise<unknown> {
+export function getLinearInstallationByOrgId(
+  pluginRuntime: Record<string, unknown> | undefined,
+  organizationId: RecordIdRef,
+): Promise<unknown> {
   return Effect.runPromise(
     Effect.gen(function* () {
-      const fn = yield* tryResolvePluginServiceEffect('linear', 'linearService', 'getInstallationByOrgId')
+      const fn = yield* tryResolvePluginServiceEffect(
+        pluginRuntime,
+        'linear',
+        'linearService',
+        'getInstallationByOrgId',
+      )
       if (!fn) return null
       return yield* Effect.tryPromise({
         try: () => fn(organizationId),
@@ -117,10 +104,18 @@ export function getLinearInstallationByOrgId(organizationId: RecordIdRef): Promi
   )
 }
 
-export function getGithubInstallationForOrganization(organizationId: string): Promise<unknown> {
+export function getGithubInstallationForOrganization(
+  pluginRuntime: Record<string, unknown> | undefined,
+  organizationId: string,
+): Promise<unknown> {
   return Effect.runPromise(
     Effect.gen(function* () {
-      const fn = yield* tryResolvePluginServiceEffect('github', 'githubService', 'getInstallationForOrganization')
+      const fn = yield* tryResolvePluginServiceEffect(
+        pluginRuntime,
+        'github',
+        'githubService',
+        'getInstallationForOrganization',
+      )
       if (!fn) return null
       return yield* Effect.tryPromise({
         try: () => fn(organizationId),
@@ -137,9 +132,10 @@ const EMPTY_INDEXED_REPO_CONTEXT: LotaRuntimeIndexedRepositoriesContext = {
 }
 
 export function buildIndexedRepositoriesContext(
+  adapters: LotaRuntimeAdapters,
   organizationId: string,
 ): Promise<LotaRuntimeIndexedRepositoriesContext> {
-  const buildContext = getRuntimeAdapters().buildIndexedRepositoriesContext
+  const buildContext = adapters.buildIndexedRepositoriesContext
   if (!buildContext) return Promise.resolve(EMPTY_INDEXED_REPO_CONTEXT)
   return Effect.runPromise(
     Effect.tryPromise({