@lota-sdk/core 0.4.9 → 0.4.11

package/src/runtime/team-consultation/team-consultation-orchestrator.ts

@@ -1,9 +1,9 @@
 import { ConsultTeamArgsSchema, withMessageCreatedAt } from '@lota-sdk/shared'
 import type { ChatMessage, ConsultTeamResultData } from '@lota-sdk/shared'
 import { convertToModelMessages, tool as createTool } from 'ai'
-import { Schema, Effect, Fiber, Queue, Ref } from 'effect'
+import { Schema, Deferred, Effect, Exit, Fiber, Queue, Ref, Scope } from 'effect'
 
-import { getAgentDisplayNames, getTeamConsultParticipants } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { nowEpochMillis } from '../../utils/date-time'
 import { createTimedAbortSignal } from '../agent-stream-helpers'
 import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataText } from '../chat-attachments'
@@ -91,6 +91,7 @@ export interface TeamConsultationParticipantRunner {
 }
 
 export interface CreateConsultTeamToolParams {
+  agentConfig: ResolvedAgentConfig
   historyMessages: ChatMessage[]
   latestUserMessageId: string
   availableUploads: ReadableUploadMetadataLike[]
@@ -114,8 +115,6 @@ interface ConsultTeamStreamResources {
   workerFiber: Fiber.Fiber<unknown, unknown>
 }
 
-type TeamConsultationResourcesError = TeamConsultationError
-
 function createConsultTeamStreamResources(params: {
   task: string
   uploadMetadataText: string
@@ -272,14 +271,17 @@ function createConsultTeamStreamResources(params: {
 }
 
 class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamResultData> {
-  private readonly initPromise: Promise<ConsultTeamStreamResources>
+  private readonly scope: Scope.Closeable
+  private readonly resourcesDeferred: Deferred.Deferred<ConsultTeamStreamResources, TeamConsultationError>
+  private readonly buildEffect: Effect.Effect<ConsultTeamStreamResources, TeamConsultationError>
+  private initStarted = false
   private closed = false
   private completed = false
 
   constructor(params: CreateConsultTeamToolParams, task: string) {
-    const teamConsultParticipants = getTeamConsultParticipants()
+    const teamConsultParticipants = params.agentConfig.teamConsultParticipants
     const uploadMetadataText = buildReadableUploadMetadataText(params.availableUploads)
-    const agentDisplayNames = getAgentDisplayNames()
+    const agentDisplayNames = params.agentConfig.displayNames
     const resolveDisplayName = (agentId: string) => {
       if (params.displayNamesById && Object.hasOwn(params.displayNamesById, agentId)) {
         const override = params.displayNamesById[agentId]
@@ -291,38 +293,52 @@ class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamRe
       return agentDisplayNames[agentId] ?? agentId
     }
 
-    this.initPromise = Effect.runPromise(
-      createConsultTeamStreamResources({
-        task,
-        uploadMetadataText,
-        teamConsultParticipants,
-        resolveDisplayName,
-        historyMessages: params.historyMessages,
-        latestUserMessageId: params.latestUserMessageId,
-        availableUploads: params.availableUploads,
-        systemWorkspaceDetails: params.systemWorkspaceDetails,
-        getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
-        retrievedKnowledgeSection: params.retrievedKnowledgeSection,
-        abortSignal: params.abortSignal,
-        participantRunner: params.participantRunner,
-        onReadError: params.onReadError,
-      }),
-    )
+    this.scope = Scope.makeUnsafe()
+    this.resourcesDeferred = Deferred.makeUnsafe<ConsultTeamStreamResources, TeamConsultationError>()
+    this.buildEffect = createConsultTeamStreamResources({
+      task,
+      uploadMetadataText,
+      teamConsultParticipants,
+      resolveDisplayName,
+      historyMessages: params.historyMessages,
+      latestUserMessageId: params.latestUserMessageId,
+      availableUploads: params.availableUploads,
+      systemWorkspaceDetails: params.systemWorkspaceDetails,
+      getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
+      retrievedKnowledgeSection: params.retrievedKnowledgeSection,
+      abortSignal: params.abortSignal,
+      participantRunner: params.participantRunner,
+      onReadError: params.onReadError,
+    })
   }
 
-  private initResourcesEffect(): Effect.Effect<ConsultTeamStreamResources, TeamConsultationResourcesError> {
-    return Effect.tryPromise({
-      try: () => this.initPromise,
-      catch: (error) =>
-        new TeamConsultationError({ message: 'Failed to initialize team consultation stream.', cause: error }),
-    })
+  /**
+   * Acquire-release: on first call, build the stream resources and register
+   * cleanup as a finalizer in the iterable's scope. Subsequent calls await the
+   * cached `Deferred`. If init fails, no finalizer is registered, so closing
+   * the scope is a no-op for the leaked-resource path.
+   */
+  private acquireResourcesEffect(): Effect.Effect<ConsultTeamStreamResources, TeamConsultationError> {
+    if (this.initStarted) {
+      return Deferred.await(this.resourcesDeferred)
+    }
+    this.initStarted = true
+
+    const acquire = Effect.acquireRelease(this.buildEffect, ({ snapshotQueue, workerFiber }) =>
+      Fiber.interrupt(workerFiber).pipe(Effect.andThen(Queue.shutdown(snapshotQueue))),
+    ).pipe(Scope.provide(this.scope))
+
+    return acquire.pipe(
+      Effect.exit,
+      Effect.flatMap((exit) =>
+        Deferred.done(this.resourcesDeferred, exit).pipe(Effect.andThen(Deferred.await(this.resourcesDeferred))),
+      ),
+    )
   }
 
-  private cleanupEffect(
-    snapshotQueue: Queue.Queue<ConsultTeamSnapshotItem>,
-    workerFiber: Fiber.Fiber<unknown, unknown>,
-  ): Effect.Effect<void, never> {
-    return Effect.andThen(Fiber.interrupt(workerFiber), Queue.shutdown(snapshotQueue))
+  /** Close the scope idempotently. Runs cleanup finalizers iff init succeeded. */
+  private closeScopeEffect(): Effect.Effect<void, never> {
+    return Scope.close(this.scope, Exit.void).pipe(Effect.catchCause(() => Effect.void))
   }
 
   [Symbol.asyncIterator](): AsyncIterableIterator<ConsultTeamResultData> {
@@ -337,7 +353,7 @@ class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamRe
     return Effect.runPromise(
       Effect.gen(
         function* (this: ConsultTeamSnapshotIterable) {
-          const { snapshotQueue, workerFiber } = yield* this.initResourcesEffect()
+          const { snapshotQueue } = yield* this.acquireResourcesEffect()
 
           if (this.completed) {
             return { done: true, value: undefined as never }
@@ -346,46 +362,37 @@ class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamRe
           const item = yield* Queue.take(snapshotQueue)
           if (item === DONE) {
             this.completed = true
-            yield* this.cleanupEffect(snapshotQueue, workerFiber)
+            this.closed = true
+            yield* this.closeScopeEffect()
             return { done: true, value: undefined as never }
           }
 
           return { done: false, value: item }
         }.bind(this),
+      ).pipe(
+        Effect.tapCause(() =>
+          Effect.sync(() => {
+            this.closed = true
+          }).pipe(Effect.andThen(this.closeScopeEffect())),
+        ),
       ),
     )
   }
 
   return(): Promise<IteratorResult<ConsultTeamResultData>> {
     this.closed = true
-    return Effect.runPromise(
-      Effect.gen(
-        function* (this: ConsultTeamSnapshotIterable) {
-          const { snapshotQueue, workerFiber } = yield* this.initResourcesEffect()
-          yield* this.cleanupEffect(snapshotQueue, workerFiber)
-          return { done: true, value: undefined as never }
-        }.bind(this),
-      ),
-    )
+    return Effect.runPromise(this.closeScopeEffect().pipe(Effect.as({ done: true, value: undefined as never })))
   }
 
   throw(error: unknown): Promise<never> {
     this.closed = true
-    return Effect.runPromise(
-      Effect.gen(
-        function* (this: ConsultTeamSnapshotIterable) {
-          const { snapshotQueue, workerFiber } = yield* this.initResourcesEffect()
-          yield* this.cleanupEffect(snapshotQueue, workerFiber)
-          return yield* Effect.fail(error as never)
-        }.bind(this),
-      ),
-    )
+    return Effect.runPromise(this.closeScopeEffect().pipe(Effect.andThen(Effect.fail(error as never))))
   }
 }
 
 export function createConsultTeamTool(params: CreateConsultTeamToolParams) {
-  const teamConsultParticipants = getTeamConsultParticipants()
-  const agentDisplayNames = getAgentDisplayNames()
+  const teamConsultParticipants = params.agentConfig.teamConsultParticipants
+  const agentDisplayNames = params.agentConfig.displayNames
   const resolveDisplayName = (agentId: string) => {
     if (params.displayNamesById && Object.hasOwn(params.displayNamesById, agentId)) {
       const override = params.displayNamesById[agentId]

package/src/runtime/team-consultation/team-consultation-prompts.ts

@@ -1,12 +1,17 @@
-import { getAgentDisplayNames, getLeadAgentDisplayName } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 
-function resolveDisplayName(agentId: string): string {
-  return getAgentDisplayNames()[agentId] ?? agentId
+function resolveDisplayName(agentConfig: ResolvedAgentConfig, agentId: string): string {
+  return agentConfig.displayNames[agentId] ?? agentId
 }
 
-export function buildTeamConsultationResponseGuard(params: { agentId: string; task: string }) {
-  const agentName = resolveDisplayName(params.agentId)
-  const leadAgentDisplayName = getLeadAgentDisplayName()
+export function buildTeamConsultationResponseGuard(params: {
+  agentConfig: ResolvedAgentConfig
+  agentId: string
+  task: string
+}) {
+  const agentName = resolveDisplayName(params.agentConfig, params.agentId)
+  const leadAgentDisplayName =
+    params.agentConfig.displayNames[params.agentConfig.leadAgentId] ?? params.agentConfig.leadAgentId
   const mentorConstraint =
     params.agentId === 'mentor'
       ? ['- As Mentor, answer as an experienced operator reviewing launch discipline, not as a coach or therapist.']

package/src/runtime/thread-chat-helpers.ts

@@ -1,7 +1,8 @@
 import { toTimestamp } from '@lota-sdk/shared'
 import type { ChatMessage } from '@lota-sdk/shared'
 
-import { getAgentDisplayNames, resolveAgentNameAlias } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { resolveAgentNameAlias } from '../config/agent-defaults'
 import type { ChatMessageLike, ReadableUploadMetadataLike } from './chat-types'
 
 export interface ThreadHistoryMessage {
@@ -29,13 +30,13 @@ export function readInstructionSections(value: unknown): string[] {
     .filter((section) => section.length > 0)
 }
 
-function getAgentName(message: ChatMessageLike): string | undefined {
+function getAgentName(agentConfig: ResolvedAgentConfig, message: ChatMessageLike): string | undefined {
   const metadata = message.metadata
   if (!metadata || typeof metadata !== 'object') return undefined
   const value = (metadata as Record<string, unknown>).agentName
   if (typeof value !== 'string' || !value.trim()) return undefined
-  const resolvedAgentName = resolveAgentNameAlias(value)
-  return resolvedAgentName ? (getAgentDisplayNames()[resolvedAgentName] ?? value.trim()) : value.trim()
+  const resolvedAgentName = resolveAgentNameAlias(agentConfig, value)
+  return resolvedAgentName ? (agentConfig.displayNames[resolvedAgentName] ?? value.trim()) : value.trim()
 }
 
 export function extractMessageText(message: ChatMessageLike): string {
@@ -45,7 +46,11 @@ export function extractMessageText(message: ChatMessageLike): string {
     .trim()
 }
 
-export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): ThreadHistoryMessage[] {
+export function toHistoryMessages(
+  agentConfig: ResolvedAgentConfig,
+  messages: ChatMessageLike[],
+  maxItems = 24,
+): ThreadHistoryMessage[] {
   return messages
     .map((message): ThreadHistoryMessage | null => {
       const content = extractMessageText(message)
@@ -55,7 +60,7 @@ export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): T
         return { role: 'user', content }
       }
       if (message.role === 'assistant') {
-        const agentName = getAgentName(message)
+        const agentName = getAgentName(agentConfig, message)
         return { role: 'agent', content, ...(agentName ? { agentName } : {}) }
       }
       return null
@@ -65,6 +70,7 @@ export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): T
 }
 
 export function buildConversationSummary(params: {
+  agentConfig: ResolvedAgentConfig
   userMessageText: string
   assistantMessages: ChatMessageLike[]
 }): string {
@@ -76,15 +82,18 @@ export function buildConversationSummary(params: {
   for (const message of params.assistantMessages) {
     const content = extractMessageText(message)
     if (!content) continue
-    const agentName = getAgentName(message)
+    const agentName = getAgentName(params.agentConfig, message)
     lines.push(agentName ? `${agentName}: ${content}` : `Assistant: ${content}`)
   }
 
   return lines.join('\n\n').trim()
 }
 
-export function buildAgentHistoryMessages(messages: ChatMessageLike[]): Array<{ content: string; agentName?: string }> {
-  return toHistoryMessages(messages)
+export function buildAgentHistoryMessages(
+  agentConfig: ResolvedAgentConfig,
+  messages: ChatMessageLike[],
+): Array<{ content: string; agentName?: string }> {
+  return toHistoryMessages(agentConfig, messages)
     .filter((message) => message.role === 'agent')
     .map((message) => ({ content: message.content, ...(message.agentName ? { agentName: message.agentName } : {}) }))
 }

package/src/runtime/thread-turn-context.ts

@@ -1,12 +1,7 @@
 import { Schema, Effect } from 'effect'
 
 import type { RecordIdRef } from '../db/record-id'
-import { recordIdToString } from '../db/record-id'
-import { TABLES } from '../db/tables'
-import {
-  effectTryMaybeAsync as effectTryMaybeAsyncShared,
-  effectTryPromise as effectTryPromiseShared,
-} from '../effect/helpers'
+import { effectTryMaybeAsync as effectTryMaybeAsyncShared, makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { buildAgentPromptContext } from './agent-prompt-context'
 import {
   buildIndexedRepositoriesContext,
@@ -14,10 +9,9 @@ import {
   getLinearInstallationByOrgId,
 } from './plugin-resolution'
 import type {
+  LotaRuntimeAdapters,
   LotaRuntimeIndexedRepositoriesContext,
   LotaRuntimeTurnHooks,
-  LotaRuntimeWorkspaceLifecycleState,
-  LotaRuntimeWorkspaceProjectionState,
   LotaRuntimeWorkspaceProvider,
 } from './runtime-extensions'
 import { readInstructionSections, readOptionalString } from './thread-chat-helpers'
@@ -35,9 +29,9 @@ class ThreadTurnContextError extends Schema.TaggedErrorClass<ThreadTurnContextEr
   cause: Schema.optional(Schema.Defect),
 }) {}
 
-function effectTryPromise<A>(thunk: () => PromiseLike<A>, message: string): Effect.Effect<A, ThreadTurnContextError> {
-  return effectTryPromiseShared(thunk, (cause) => new ThreadTurnContextError({ message, cause }))
-}
+const effectTryPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ThreadTurnContextError({ message, cause }),
+)
 
 function effectTryMaybeAsync<A>(
   evaluate: () => A | PromiseLike<A>,
@@ -46,21 +40,7 @@ function effectTryMaybeAsync<A>(
   return effectTryMaybeAsyncShared(evaluate, (cause) => new ThreadTurnContextError({ message, cause }))
 }
 
-interface AssembledThreadTurnContext {
-  workspace: Record<string, unknown>
-  workspaceLifecycleState: LotaRuntimeWorkspaceLifecycleState | undefined
-  workspaceProfileState: LotaRuntimeWorkspaceProjectionState | undefined
-  onboardingActive: boolean
-  linearInstalled: boolean
-  githubInstalled: boolean
-  indexedRepoContext: LotaRuntimeIndexedRepositoriesContext
-  promptContext: { systemWorkspaceDetails?: string }
-  retrievedKnowledgeSection: string | undefined
-  buildContextResult: Record<string, unknown> | null
-  hookInstructionSections: string[]
-}
-
-const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(function* (params: {
+export const assembleThreadTurnContext = Effect.fn('ThreadTurnContext.assemble')(function* (params: {
   thread: unknown
   threadRef: RecordIdRef
   orgRef: RecordIdRef
@@ -72,6 +52,8 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
   workspacePromise: Promise<Record<string, unknown>>
   workspaceProvider?: LotaRuntimeWorkspaceProvider
   turnHooks: LotaRuntimeTurnHooks
+  runtimeAdapters: LotaRuntimeAdapters
+  pluginRuntime?: Record<string, unknown>
 }) {
   const workspace = yield* effectTryPromise(() => params.workspacePromise, 'Failed to load thread workspace').pipe(
     Effect.withSpan('ThreadTurnContext.loadWorkspace'),
@@ -88,21 +70,21 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
 
   const onboardingActive = workspaceLifecycleState?.bootstrapActive ?? false
   const linearInstallation = yield* effectTryPromise(
-    () => getLinearInstallationByOrgId(params.orgRef),
+    () => getLinearInstallationByOrgId(params.pluginRuntime, params.orgRef),
     'Failed to load Linear installation',
   ).pipe(
     Effect.catch(() => Effect.succeed(null)),
     Effect.withSpan('ThreadTurnContext.loadLinearInstallation'),
   )
   const githubInstallation = yield* effectTryPromise(
-    () => getGithubInstallationForOrganization(params.orgIdString),
+    () => getGithubInstallationForOrganization(params.pluginRuntime, params.orgIdString),
     'Failed to load GitHub installation',
   ).pipe(
     Effect.catch(() => Effect.succeed(null)),
     Effect.withSpan('ThreadTurnContext.loadGithubInstallation'),
   )
   const indexedRepoContext = yield* effectTryPromise(
-    () => buildIndexedRepositoriesContext(params.orgIdString),
+    () => buildIndexedRepositoriesContext(params.runtimeAdapters, params.orgIdString),
     'Failed to build indexed repository context',
   ).pipe(
     Effect.catch(() =>
@@ -129,16 +111,16 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
           Effect.withSpan('ThreadTurnContext.buildPromptSummary'),
         )
 
-  let linearInstalled = Boolean(linearInstallation)
-  let githubInstalled = Boolean(githubInstallation)
-  let promptContext = buildAgentPromptContext({
+  const initialLinearInstalled = Boolean(linearInstallation)
+  const initialGithubInstalled = Boolean(githubInstallation)
+  const initialPromptContext = buildAgentPromptContext({
     workspaceName: workspaceProfileState?.workspaceName ?? readOptionalString(workspace.name) ?? undefined,
     summaryBlock: workspaceProfileState?.summaryBlock,
     promptSummary,
     userName: params.userName ?? undefined,
     recentDomainEvents,
   })
-  let retrievedKnowledgeSection: string | undefined = !params.messageText
+  const initialRetrievedKnowledgeSection: string | undefined = !params.messageText
     ? undefined
     : yield* effectTryMaybeAsync(
         () =>
@@ -161,36 +143,33 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
         workspace,
         onboardingActive,
         messageText: params.messageText,
-        linearInstalled,
-        githubInstalled,
+        linearInstalled: initialLinearInstalled,
+        githubInstalled: initialGithubInstalled,
         indexedRepoContext,
-        promptContext,
+        promptContext: initialPromptContext,
         workspaceLifecycleState,
         workspaceProfileState,
         promptSummary,
         recentDomainEvents,
-        retrievedKnowledgeSection,
+        retrievedKnowledgeSection: initialRetrievedKnowledgeSection,
       }),
     'Failed to build thread context',
   ).pipe(Effect.withSpan('ThreadTurnContext.buildContextHook'))
   const buildContextResult = isRecord(buildContextResultValue) ? buildContextResultValue : null
 
   const buildContextPromptDetails = readOptionalString(buildContextResult?.systemWorkspaceDetails)
-  if (buildContextPromptDetails) {
-    promptContext = { systemWorkspaceDetails: buildContextPromptDetails }
-  }
+  const promptContext = buildContextPromptDetails
+    ? { systemWorkspaceDetails: buildContextPromptDetails }
+    : initialPromptContext
   const buildContextRetrievedKnowledge = readOptionalString(buildContextResult?.retrievedKnowledgeSection)
-  if (buildContextRetrievedKnowledge !== undefined) {
-    retrievedKnowledgeSection = buildContextRetrievedKnowledge
-  }
+  const retrievedKnowledgeSection =
+    buildContextRetrievedKnowledge !== undefined ? buildContextRetrievedKnowledge : initialRetrievedKnowledgeSection
   const buildContextLinearInstalled = readOptionalBoolean(buildContextResult?.linearInstalled)
-  if (buildContextLinearInstalled !== undefined) {
-    linearInstalled = buildContextLinearInstalled
-  }
+  const linearInstalled =
+    buildContextLinearInstalled !== undefined ? buildContextLinearInstalled : initialLinearInstalled
   const buildContextGithubInstalled = readOptionalBoolean(buildContextResult?.githubInstalled)
-  if (buildContextGithubInstalled !== undefined) {
-    githubInstalled = buildContextGithubInstalled
-  }
+  const githubInstalled =
+    buildContextGithubInstalled !== undefined ? buildContextGithubInstalled : initialGithubInstalled
 
   const hookInstructionSections = readInstructionSections(
     yield* effectTryMaybeAsync(
@@ -233,28 +212,3 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
     hookInstructionSections,
   }
 })
-
-export function assembleThreadTurnContext(params: {
-  thread: unknown
-  threadRef: RecordIdRef
-  orgRef: RecordIdRef
-  userRef: RecordIdRef
-  userName?: string | null
-  orgIdString: string
-  userIdString: string
-  messageText: string
-  workspacePromise: Promise<Record<string, unknown>>
-  workspaceProvider?: LotaRuntimeWorkspaceProvider
-  turnHooks: LotaRuntimeTurnHooks
-}): Promise<AssembledThreadTurnContext> {
-  return Effect.runPromise(
-    assembleThreadTurnContextEffect(params).pipe(
-      Effect.annotateSpans({
-        threadId: recordIdToString(params.threadRef, TABLES.THREAD),
-        orgId: params.orgIdString,
-        userId: params.userIdString,
-        messageLength: params.messageText.length,
-      }),
-    ),
-  )
-}

package/src/runtime/turn-lifecycle.ts

@@ -86,17 +86,9 @@ export function finalizeTurnRunEffect(params: {
   })
 }
 
-export function finalizeTurnRun(params: {
-  serverRunId: string
-  getEntity: () => MaybeEffect<{ lastCompactedMessageId?: string | null; compactionSummary?: string | null }>
-  getUncompactedMessages: (cursor?: string) => MaybeEffect<ChatMessage[]>
-  assessCompaction: (summaryText: string, messages: ChatMessage[]) => { shouldCompact: boolean }
-  enqueueCompaction: () => MaybeEffect<void>
-  unregisterRun: (runId: string) => void
-  clearActiveRunId: (runId: string) => MaybeEffect<void>
-  disposeAbort: () => void
-  activeStreamId?: string
-  clearActiveStreamId?: (streamId: string) => MaybeEffect<void>
-}): Promise<void> {
-  return Effect.runPromise(finalizeTurnRunEffect(params))
-}
+/**
+ * Alias for `finalizeTurnRunEffect`. Kept as the public name consumers use.
+ * Callers pipe the returned Effect through their own runtime rather than
+ * relying on a process-wide promise adapter.
+ */
+export { finalizeTurnRunEffect as finalizeTurnRun }