@lota-sdk/core 0.4.9 → 0.4.10

package/src/services/autonomous-job.service.ts

@@ -22,7 +22,7 @@ import type {
   UpdateAutonomousJobInput,
 } from '@lota-sdk/shared'
 import type { Job } from 'bullmq'
-import { Context, Cron, Schema, Effect, Layer } from 'effect'
+import { Context, Cron, Schema, Effect, Layer, Ref } from 'effect'
 import { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
@@ -968,70 +968,72 @@ function executeQueuedRunEffect(
   deps: AutonomousJobDeps,
   job: Job<AutonomousJobQueuePayload>,
 ): Effect.Effect<{ status: string; summary?: string }, AutonomousJobServiceError> {
-  let autonomousJobRow: AutonomousJobRow | null = null
-  let runRow: AutonomousJobRunRow | null = null
-
   return Effect.gen(function* () {
-    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
-    autonomousJobRow = yield* getRowEffect(deps, job.data.autonomousJobId)
-    const currentJobRow = autonomousJobRow
-    const { queueJobId, runRow: initialRunRow } = yield* getOrCreateQueuedRunRowEffect(deps, job, currentJobRow)
+    const autonomousJobRowRef = yield* Ref.make<AutonomousJobRow | null>(null)
+    const runRowRef = yield* Ref.make<AutonomousJobRunRow | null>(null)
+
+    return yield* Effect.gen(function* () {
+      yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
+      const currentJobRow = yield* getRowEffect(deps, job.data.autonomousJobId)
+      yield* Ref.set(autonomousJobRowRef, currentJobRow)
+      const { queueJobId, runRow: initialRunRow } = yield* getOrCreateQueuedRunRowEffect(deps, job, currentJobRow)
+
+      yield* Ref.set(runRowRef, initialRunRow)
+      if (currentJobRow.status !== 'active' && job.data.trigger === 'scheduled') {
+        return { status: 'skipped' }
+      }
 
-    runRow = initialRunRow
-    if (currentJobRow.status !== 'active' && job.data.trigger === 'scheduled') {
-      return { status: 'skipped' }
-    }
+      const currentRunRow = yield* markQueuedRunRunningEffect(deps, initialRunRow, queueJobId)
+      yield* Ref.set(runRowRef, currentRunRow)
+      const inputMessage = buildSyntheticUserMessage(currentJobRow.prompt)
+
+      const [thread, turnModule] = yield* Effect.all([
+        deps.thread
+          .getThread(currentJobRow.threadId)
+          .pipe(
+            Effect.mapError(
+              (cause) => new AutonomousJobServiceError({ message: 'Failed to load autonomous job thread.', cause }),
+            ),
+          ),
+        effectTryPromise<ThreadTurnModule>(() => import('./thread/thread-turn'), 'Failed to load thread turn runtime.'),
+      ])
 
-    runRow = yield* markQueuedRunRunningEffect(deps, initialRunRow, queueJobId)
-    const currentRunRow = runRow
-    const inputMessage = buildSyntheticUserMessage(currentJobRow.prompt)
+      const turnResult = yield* effectTryPromise(
+        () =>
+          turnModule.runThreadTurnInBackground({
+            thread,
+            threadRef: ensureRecordId(currentJobRow.threadId, TABLES.THREAD),
+            orgRef: ensureRecordId(currentJobRow.organizationId, TABLES.ORGANIZATION),
+            userRef: ensureRecordId(currentJobRow.ownerUserId, TABLES.USER),
+            userName: currentJobRow.ownerUserName,
+            agentIdOverride: currentJobRow.agentId,
+            inputMessage,
+          }),
+        'Failed to run autonomous job thread turn.',
+      )
 
-    const [thread, turnModule] = yield* Effect.all([
-      deps.thread
-        .getThread(currentJobRow.threadId)
+      const activePlan = yield* deps.executionPlan
+        .getActivePlanForThread(currentJobRow.threadId)
         .pipe(
           Effect.mapError(
-            (cause) => new AutonomousJobServiceError({ message: 'Failed to load autonomous job thread.', cause }),
+            (cause) => new AutonomousJobServiceError({ message: 'Failed to load active execution plan.', cause }),
           ),
-        ),
-      effectTryPromise<ThreadTurnModule>(() => import('./thread/thread-turn'), 'Failed to load thread turn runtime.'),
-    ])
+        )
 
-    const turnResult = yield* effectTryPromise(
-      () =>
-        turnModule.runThreadTurnInBackground({
-          thread,
-          threadRef: ensureRecordId(currentJobRow.threadId, TABLES.THREAD),
-          orgRef: ensureRecordId(currentJobRow.organizationId, TABLES.ORGANIZATION),
-          userRef: ensureRecordId(currentJobRow.ownerUserId, TABLES.USER),
-          userName: currentJobRow.ownerUserName,
-          agentIdOverride: currentJobRow.agentId,
-          inputMessage,
+      return yield* completeQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, turnResult, activePlan })
+    }).pipe(
+      Effect.catch((error: unknown) =>
+        Effect.gen(function* () {
+          const currentJobRow = yield* Ref.get(autonomousJobRowRef)
+          const currentRunRow = yield* Ref.get(runRowRef)
+          if (!currentJobRow || !currentRunRow) {
+            return yield* new AutonomousJobServiceError({ message: 'Failed to execute autonomous job.', cause: error })
+          }
+          return yield* failQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, error })
         }),
-      'Failed to run autonomous job thread turn.',
+      ),
     )
-
-    const activePlan = yield* deps.executionPlan
-      .getActivePlanForThread(currentJobRow.threadId)
-      .pipe(
-        Effect.mapError(
-          (cause) => new AutonomousJobServiceError({ message: 'Failed to load active execution plan.', cause }),
-        ),
-      )
-
-    return yield* completeQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, turnResult, activePlan })
-  }).pipe(
-    Effect.catch((error: unknown) =>
-      Effect.gen(function* () {
-        const currentJobRow = autonomousJobRow
-        const currentRunRow = runRow
-        if (!currentJobRow || !currentRunRow) {
-          return yield* new AutonomousJobServiceError({ message: 'Failed to execute autonomous job.', cause: error })
-        }
-        return yield* failQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, error })
-      }),
-    ),
-  )
+  })
 }
 
 function createAutonomousJobService(deps: AutonomousJobDeps) {
@@ -1068,7 +1070,7 @@ export function makeAutonomousJobService(deps: AutonomousJobDeps) {
 export class AutonomousJobServiceTag extends Context.Service<
   AutonomousJobServiceTag,
   ReturnType<typeof makeAutonomousJobService>
->()('AutonomousJobService') {}
+>()('@lota-sdk/core/AutonomousJobService') {}
 
 export const AutonomousJobServiceLive = Layer.effect(
   AutonomousJobServiceTag,

package/src/services/background-work.service.ts

@@ -0,0 +1,54 @@
+import { Context, Effect, FiberSet, Layer, Schema } from 'effect'
+
+/**
+ * Tagged error for the BackgroundWorkService surface. The service itself
+ * never returns this — it's reserved for future API extensions.
+ */
+export class BackgroundWorkError extends Schema.TaggedErrorClass<BackgroundWorkError>()(
+  '@lota-sdk/core/BackgroundWorkError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
+/**
+ * Supervised fire-and-forget fork pool.
+ *
+ * `run` schedules an effect on a process-wide FiberSet that is interrupted
+ * when the runtime scope closes — replaces ad-hoc `Effect.runFork`,
+ * `Effect.runForkWith`, and `Effect.forkDetach` call sites that would
+ * otherwise leak fibers across shutdown.
+ *
+ * Both methods accept any `Effect.Effect<A, E>`; failures are logged via
+ * `Effect.logError` and never propagate to the caller. `runForget` ignores
+ * both the result and the cause — use it for best-effort metrics, cache
+ * touches, and other strictly cosmetic side effects.
+ */
+export class BackgroundWorkService extends Context.Service<
+  BackgroundWorkService,
+  {
+    readonly run: <A, E>(effect: Effect.Effect<A, E>, label?: string) => Effect.Effect<void>
+    readonly runForget: <A, E>(effect: Effect.Effect<A, E>, label?: string) => Effect.Effect<void>
+  }
+>()('@lota-sdk/core/BackgroundWorkService') {}
+
+export const BackgroundWorkServiceLive = Layer.effect(
+  BackgroundWorkService,
+  Effect.gen(function* () {
+    const set = yield* FiberSet.make<unknown, unknown>()
+
+    const run = <A, E>(effect: Effect.Effect<A, E>, label?: string): Effect.Effect<void> =>
+      Effect.asVoid(
+        FiberSet.run(
+          set,
+          effect.pipe(
+            Effect.withLogSpan(label ?? 'background'),
+            Effect.catchCause((cause) => Effect.logError(cause)),
+          ),
+        ),
+      )
+
+    const runForget = <A, E>(effect: Effect.Effect<A, E>, label?: string): Effect.Effect<void> =>
+      Effect.asVoid(FiberSet.run(set, effect.pipe(Effect.withLogSpan(label ?? 'background-forget'), Effect.ignore)))
+
+    return { run, runForget } as const
+  }),
+)

package/src/services/chat-run-registry.service.ts

@@ -2,7 +2,9 @@ import { Context, Effect, FiberMap, Layer } from 'effect'
 
 import { ChatRunRegistry } from '../runtime/chat-run-registry'
 
-export class ChatRunRegistryTag extends Context.Service<ChatRunRegistryTag, ChatRunRegistry>()('ChatRunRegistry') {}
+export class ChatRunRegistryTag extends Context.Service<ChatRunRegistryTag, ChatRunRegistry>()(
+  '@lota-sdk/core/ChatRunRegistry',
+) {}
 
 export const ChatRunRegistryLive = Layer.effect(
   ChatRunRegistryTag,

package/src/services/context-compaction.service.ts

@@ -146,7 +146,7 @@ export function makeContextCompactionService(deps: ContextCompactionDeps) {
 export class ContextCompactionServiceTag extends Context.Service<
   ContextCompactionServiceTag,
   ReturnType<typeof makeContextCompactionService>
->()('ContextCompactionService') {}
+>()('@lota-sdk/core/ContextCompactionService') {}
 
 export const ContextCompactionServiceLive = Layer.effect(
   ContextCompactionServiceTag,

package/src/services/document-chunk.service.ts

@@ -2,6 +2,7 @@ import { Context, Schema, Effect, Layer } from 'effect'
 
 import { chunkMarkdownDocument, chunkPagedDocument, chunkPlainTextDocument } from '../document/org-document-chunking'
 import type { ParsedDocumentChunk } from '../document/org-document-chunking'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { RuntimeConfigServiceTag } from '../effect/services'
 import { ProviderEmbeddings } from '../embeddings/provider'
 import { sha256Hex } from '../utils/crypto'
@@ -71,25 +72,15 @@ class DocumentChunkServiceError extends Schema.TaggedErrorClass<DocumentChunkSer
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
+const effectTryDocumentChunkPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new DocumentChunkServiceError({ message, cause }),
+)
+
 function tryDocumentChunkPromise<A>(
   message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
 ): Effect.Effect<A, DocumentChunkServiceError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new DocumentChunkServiceError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new DocumentChunkServiceError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new DocumentChunkServiceError({ message, cause }))
-    }
-  })
+  return effectTryDocumentChunkPromise(evaluate, message)
 }
 
 export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): DocumentChunkService {
@@ -200,7 +191,7 @@ export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): D
 }
 
 export class DocumentChunkServiceTag extends Context.Service<DocumentChunkServiceTag, DocumentChunkService>()(
-  'DocumentChunkService',
+  '@lota-sdk/core/DocumentChunkService',
 ) {}
 
 export const DocumentChunkServiceLive = Layer.effect(

package/src/services/execution-plan/execution-plan-graph.ts

@@ -8,17 +8,30 @@ import {
 } from '@lota-sdk/shared'
 import { Effect } from 'effect'
 import { RecordId } from 'surrealdb'
+import type { z } from 'zod'
 
 import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { DatabaseTransaction } from '../../db/service'
 import { TABLES } from '../../db/tables'
+import { ServiceError } from '../../effect/errors'
 import { runPromise } from '../../effect/runtime'
 import { nowDate } from '../../utils/date-time'
 import type { CompiledPlanNode } from '../plan/plan-compiler.service'
 import type { syncRunGraph } from '../plan/plan-executor-graph'
 import { toRunData } from '../plan/plan-run-data'
 
+function parseRowOrFail<TSchema extends z.ZodTypeAny>(
+  schema: TSchema,
+  value: unknown,
+  operation: string,
+): Effect.Effect<z.infer<TSchema>, ServiceError> {
+  return Effect.try({
+    try: () => schema.parse(value) as z.infer<TSchema>,
+    catch: (cause) => new ServiceError({ message: `Failed to parse row for ${operation}.`, cause }),
+  })
+}
+
 type SyncRunGraphParams = Parameters<typeof syncRunGraph>[1]
 type SyncRunGraphResult = Awaited<ReturnType<typeof syncRunGraph>>
 
@@ -86,7 +99,7 @@ function createNodeSpecs(tx: DatabaseTransaction, planSpecId: RecordIdInput, nod
         .create(nodeSpecId)
         .content(buildNodeSpecCreateContent(compiledNode, planSpecId))
         .output('after')
-      createdRecords.push(PlanNodeSpecRecordSchema.parse(created))
+      createdRecords.push(yield* parseRowOrFail(PlanNodeSpecRecordSchema, created, 'createNodeSpecs'))
     }
 
     return createdRecords
@@ -109,7 +122,7 @@ function createNodeRuns(
         .create(nodeRunId)
         .content(buildNodeRunCreateContent(runId, planSpecId, nodeSpec))
         .output('after')
-      createdNodeRuns.push(PlanNodeRunSchema.parse(created))
+      createdNodeRuns.push(yield* parseRowOrFail(PlanNodeRunSchema, created, 'createNodeRuns'))
     }
 
     return createdNodeRuns
@@ -138,26 +151,25 @@ export function createInitializedRunGraph(params: {
   return runPromise(
     Effect.gen(function* () {
       const nodeSpecs = yield* createNodeSpecs(params.tx, params.spec.id, params.nodes)
-      const run = PlanRunSchema.parse(
-        yield* params.tx
-          .create(ensureRecordId(params.runId, TABLES.PLAN_RUN))
-          .content({
-            planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-            threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-            ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
-            leadAgentId: params.leadAgentId,
-            ...(params.createdByAgentId ? { createdByAgentId: params.createdByAgentId } : {}),
-            status: params.requireApproval ? 'pending-approval' : 'running',
-            readyNodeIds: [],
-            failureCount: 0,
-            ...(params.runPatch?.replacedRunId
-              ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
-              : {}),
-            ...(params.requireApproval ? {} : { startedAt: nowDate() }),
-          })
-          .output('after'),
-      )
+      const runRaw = yield* params.tx
+        .create(ensureRecordId(params.runId, TABLES.PLAN_RUN))
+        .content({
+          planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
+          organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+          threadId: ensureRecordId(params.threadId, TABLES.THREAD),
+          ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
+          leadAgentId: params.leadAgentId,
+          ...(params.createdByAgentId ? { createdByAgentId: params.createdByAgentId } : {}),
+          status: params.requireApproval ? 'pending-approval' : 'running',
+          readyNodeIds: [],
+          failureCount: 0,
+          ...(params.runPatch?.replacedRunId
+            ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
+            : {}),
+          ...(params.requireApproval ? {} : { startedAt: nowDate() }),
+        })
+        .output('after')
+      const run = yield* parseRowOrFail(PlanRunSchema, runRaw, 'createInitializedRunGraph:run')
 
       const nodeRuns = yield* createNodeRuns(params.tx, run.id, params.spec.id, nodeSpecs)
       const synced = params.requireApproval
@@ -186,7 +198,7 @@ export function createInitializedRunGraph(params: {
           detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
         })
         .output('after')
-      params.emittedEvents.push(PlanEventSchema.parse(event))
+      params.emittedEvents.push(yield* parseRowOrFail(PlanEventSchema, event, 'createInitializedRunGraph:createdEvent'))
 
       if (params.requireApproval) {
         const pendingApprovalEvent = yield* params.tx
@@ -201,38 +213,46 @@ export function createInitializedRunGraph(params: {
             detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
           })
           .output('after')
-        params.emittedEvents.push(PlanEventSchema.parse(pendingApprovalEvent))
+        params.emittedEvents.push(
+          yield* parseRowOrFail(
+            PlanEventSchema,
+            pendingApprovalEvent,
+            'createInitializedRunGraph:pendingApprovalEvent',
+          ),
+        )
       }
 
-      const checkpoint = PlanCheckpointSchema.parse(
-        yield* params.tx
-          .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
-          .content({
-            runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-            sequence: 1,
-            runStatus: synced.run.status,
-            readyNodeIds: [...synced.run.readyNodeIds],
-            activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
-            artifactIds: [],
-            lastCompletedNodeIds: synced.nodeRuns
-              .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
-              .map((nodeRun) => nodeRun.nodeId),
-            snapshot: {
-              reason: params.checkpointReason,
-              currentNodeId: synced.run.currentNodeId,
-              waitingNodeId: synced.run.waitingNodeId,
-              readyNodeIds: synced.run.readyNodeIds,
-            },
-          })
-          .output('after'),
+      const checkpointRaw = yield* params.tx
+        .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
+        .content({
+          runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
+          sequence: 1,
+          runStatus: synced.run.status,
+          readyNodeIds: [...synced.run.readyNodeIds],
+          activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
+          artifactIds: [],
+          lastCompletedNodeIds: synced.nodeRuns
+            .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
+            .map((nodeRun) => nodeRun.nodeId),
+          snapshot: {
+            reason: params.checkpointReason,
+            currentNodeId: synced.run.currentNodeId,
+            waitingNodeId: synced.run.waitingNodeId,
+            readyNodeIds: synced.run.readyNodeIds,
+          },
+        })
+        .output('after')
+      const checkpoint = yield* parseRowOrFail(
+        PlanCheckpointSchema,
+        checkpointRaw,
+        'createInitializedRunGraph:checkpoint',
       )
 
-      const updatedRun = PlanRunSchema.parse(
-        yield* params.tx
-          .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
-          .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
-          .output('after'),
-      )
+      const updatedRunRaw = yield* params.tx
+        .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
+        .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
+        .output('after')
+      const updatedRun = yield* parseRowOrFail(PlanRunSchema, updatedRunRaw, 'createInitializedRunGraph:updatedRun')
 
       const checkpointEvent = yield* params.tx
         .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
@@ -248,7 +268,9 @@ export function createInitializedRunGraph(params: {
           },
         })
         .output('after')
-      params.emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
+      params.emittedEvents.push(
+        yield* parseRowOrFail(PlanEventSchema, checkpointEvent, 'createInitializedRunGraph:checkpointEvent'),
+      )
 
       return updatedRun
     }),

package/src/services/execution-plan/execution-plan.service.ts

@@ -1010,7 +1010,7 @@ export function makeExecutionPlanService(deps: ExecutionPlanDeps) {
 export class ExecutionPlanServiceTag extends Context.Service<
   ExecutionPlanServiceTag,
   ReturnType<typeof makeExecutionPlanService>
->()('ExecutionPlanService') {}
+>()('@lota-sdk/core/ExecutionPlanService') {}
 
 export const ExecutionPlanServiceLive = Layer.effect(
   ExecutionPlanServiceTag,

package/src/services/feedback-loop.service.ts

@@ -141,7 +141,7 @@ export function makeFeedbackLoopService(planRunService: ReturnType<typeof makePl
 export class FeedbackLoopServiceTag extends Context.Service<
   FeedbackLoopServiceTag,
   ReturnType<typeof makeFeedbackLoopService>
->()('FeedbackLoopService') {}
+>()('@lota-sdk/core/FeedbackLoopService') {}
 
 export const FeedbackLoopServiceLive = Layer.effect(
   FeedbackLoopServiceTag,

package/src/services/global-orchestrator.service.ts

@@ -1,10 +1,17 @@
-import type { ConvergenceState } from '@lota-sdk/shared'
+import type {
+  ConvergenceState,
+  ExecutionMode,
+  PlanNodeResultSubmission,
+  PlanNodeRunRecord,
+  PlanNodeSpecRecord,
+  PlanRunRecord,
+  PlanSpecRecord,
+} from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 
 import { runPromise } from '../effect/runtime'
-import { getCurrentRuntime } from '../effect/runtime-ref'
 import { routeGraphFullEffect } from './graph-full-routing'
-import type { makeOwnershipDispatcherService } from './ownership-dispatcher.service'
+import type { OwnershipDispatcherService } from './ownership-dispatcher.service'
 import { OwnershipDispatcherServiceTag } from './ownership-dispatcher.service'
 import type { makePlanExecutorService } from './plan/plan-executor.service'
 import { PlanExecutorServiceTag } from './plan/plan-executor.service'
@@ -48,18 +55,30 @@ function decideRerouteAction(params: {
 }
 
 interface GlobalOrchestratorDeps {
-  ownershipDispatcherService: ReturnType<typeof makeOwnershipDispatcherService>
+  ownershipDispatcherService: Pick<OwnershipDispatcherService, 'dispatchReadyNode'>
   planExecutorService: ReturnType<typeof makePlanExecutorService>
   planRunService: ReturnType<typeof makePlanRunService>
 }
 
+type DispatchReadyNodeParams = {
+  run: PlanRunRecord
+  nodeSpecRecord: PlanNodeSpecRecord
+  nodeRun: PlanNodeRunRecord
+  spec: PlanSpecRecord
+  executionModeOverride?: ExecutionMode
+}
+
+type DispatchReadyNode = (params: DispatchReadyNodeParams) => Effect.Effect<PlanNodeResultSubmission, unknown, never>
+
 export function makeGlobalOrchestratorService(deps: GlobalOrchestratorDeps) {
+  const dispatchReadyNode: DispatchReadyNode = (params) => deps.ownershipDispatcherService.dispatchReadyNode(params)
+
   return {
     detectConvergence,
     decideRerouteAction,
     routeGraphFull: (params: { threadId: string; runId: string }) =>
       routeGraphFullEffect(params, {
-        dispatchReadyNode: (dispatchParams) => deps.ownershipDispatcherService.dispatchReadyNode(dispatchParams),
+        dispatchReadyNode,
         planExecutorService: deps.planExecutorService,
         planRunService: deps.planRunService,
       }),
@@ -69,7 +88,7 @@ export function makeGlobalOrchestratorService(deps: GlobalOrchestratorDeps) {
 export class GlobalOrchestratorServiceTag extends Context.Service<
   GlobalOrchestratorServiceTag,
   ReturnType<typeof makeGlobalOrchestratorService>
->()('GlobalOrchestratorService') {}
+>()('@lota-sdk/core/GlobalOrchestratorService') {}
 
 export const GlobalOrchestratorServiceLive = Layer.effect(
   GlobalOrchestratorServiceTag,
@@ -81,10 +100,14 @@ export const GlobalOrchestratorServiceLive = Layer.effect(
   }),
 )
 
-function getGlobalOrchestratorService() {
-  return getCurrentRuntime().runSync(Effect.service(GlobalOrchestratorServiceTag))
-}
+const routeGraphFullWithRuntime = Effect.fn('GlobalOrchestrator.routeGraphFullWithRuntime')(function* (params: {
+  threadId: string
+  runId: string
+}) {
+  const globalOrchestratorService = yield* GlobalOrchestratorServiceTag
+  return yield* globalOrchestratorService.routeGraphFull(params)
+})
 
 export function routeGraphFull(params: { threadId: string; runId: string }): Promise<void> {
-  return runPromise(getGlobalOrchestratorService().routeGraphFull(params))
+  return runPromise(routeGraphFullWithRuntime(params))
 }