@lota-sdk/core 0.4.9 → 0.4.10

package/src/services/ownership-dispatcher.service.ts

@@ -4,6 +4,7 @@ import type {
   PlanArtifactRecord,
   PlanArtifactSubmission,
   PlanFailureClass,
+  PlanNodeResultSubmission,
   PlanNodeRunRecord,
   PlanNodeSpec,
   PlanNodeSpecRecord,
@@ -14,15 +15,15 @@ import type {
   PlanDraft,
   UpstreamHandoff,
 } from '@lota-sdk/shared'
-import { Cause, Context, Effect, Layer, Match } from 'effect'
+import { Cause, Context, Effect, Exit, Layer, Match } from 'effect'
 
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { BadRequestError, ConfigurationError, DatabaseError } from '../effect/errors'
-import { isPromiseLike } from '../effect/helpers'
+import { BadRequestError, ConfigurationError, DatabaseError, ServiceError } from '../effect/errors'
+import { isPromiseLike, makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { AgentConfigServiceTag, DatabaseServiceTag, RuntimeAdaptersServiceTag } from '../effect/services'
 import { resolvePlanNodeExecutionVisibility, shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
 import type { LotaRuntimeAdapters } from '../runtime/runtime-extensions'
@@ -51,14 +52,20 @@ interface OwnershipDispatcherDeps {
   db: SurrealDBService
   agentConfig: ResolvedAgentConfig
   runtimeAdapters: LotaRuntimeAdapters
-  agentExecutor: ReturnType<typeof makeAgentExecutorService>
-  monitoringWindow: ReturnType<typeof makeMonitoringWindowService>
+  agentExecutor: NoContextService<Pick<ReturnType<typeof makeAgentExecutorService>, 'executeNode'>>
+  monitoringWindow: NoContextService<Pick<ReturnType<typeof makeMonitoringWindowService>, 'startMonitoringWindow'>>
   planExecutor: ReturnType<typeof makePlanExecutorService>
   planRun: ReturnType<typeof makePlanRunService>
-  pluginExecutor: ReturnType<typeof makePluginExecutorService>
-  skillResolver: SkillResolverService
-  systemExecutor: ReturnType<typeof makeSystemExecutorService>
-  user: ReturnType<typeof makeUserService>
+  pluginExecutor: NoContextService<Pick<ReturnType<typeof makePluginExecutorService>, 'executeNode' | 'validateOwner'>>
+  skillResolver: NoContextService<Pick<SkillResolverService, 'resolve'>>
+  systemExecutor: NoContextService<Pick<ReturnType<typeof makeSystemExecutorService>, 'executeNode' | 'validateOwner'>>
+  user: NoContextService<Pick<ReturnType<typeof makeUserService>, 'getUser'>>
+}
+
+type NoContextService<TService> = {
+  [K in keyof TService]: TService[K] extends (...args: infer TArgs) => Effect.Effect<infer A, infer E, unknown>
+    ? (...args: TArgs) => Effect.Effect<A, E, never>
+    : TService[K]
 }
 
 const STABLE_RUN_STATUSES = new Set(['pending-approval', 'awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
@@ -132,6 +139,8 @@ function toDispatchDatabaseError(message: string, cause: unknown) {
   return new DatabaseError({ message, cause })
 }
 
+const tryDispatchPromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
+
 const matchDraftExecutor = (deps: OwnershipDispatcherDeps, node: { id: string; label: string }) =>
   Match.type<PlanNodeOwner>().pipe(
     Match.discriminator('executorType')('agent', (owner): PlanValidationIssueInput[] =>
@@ -169,8 +178,9 @@ const shouldAutoDispatchEffect = (deps: OwnershipDispatcherDeps, run: PlanRunRec
       return true
     }
 
-    const workspace = yield* Effect.tryPromise(() =>
-      workspaceProvider.getWorkspace(ensureRecordId(run.organizationId, TABLES.ORGANIZATION)),
+    const workspace = yield* tryDispatchPromise(
+      () => workspaceProvider.getWorkspace(ensureRecordId(run.organizationId, TABLES.ORGANIZATION)),
+      'Failed to load workspace for dispatch eligibility.',
     )
     if (!workspaceProvider.getLifecycleState) {
       return true
@@ -179,7 +189,7 @@ const shouldAutoDispatchEffect = (deps: OwnershipDispatcherDeps, run: PlanRunRec
     const lifecycleState = yield* Effect.gen(function* () {
       const result = workspaceProvider.getLifecycleState?.call(workspaceProvider, workspace)
       if (isPromiseLike(result)) {
-        return yield* Effect.tryPromise(() => result)
+        return yield* tryDispatchPromise(() => result, 'Failed to read workspace lifecycle state.')
       }
 
       return result
@@ -210,7 +220,9 @@ const buildDispatchContextEffect = (
     ])
     const userId = thread?.userId ? recordIdToString(thread.userId, TABLES.USER) : undefined
     const userResult = userId ? yield* Effect.exit(deps.user.getUser(userId)) : undefined
-    const userName = userResult?._tag === 'Success' ? userResult.value.name : undefined
+    const userName = userResult
+      ? Exit.match(userResult, { onSuccess: (user) => user.name, onFailure: () => undefined })
+      : undefined
     const nodeSpecsById = new Map(nodeSpecs.map((candidate) => [candidate.nodeId, candidate]))
     const upstreamHandoffs: UpstreamHandoff[] = nodeRuns
       .filter(
@@ -274,71 +286,81 @@ const dispatchNodeEffect = (
       }
     }
 
-    switch (params.nodeSpec.owner.executorType) {
-      case 'agent':
-        return yield* deps.agentExecutor.executeNode({
+    return yield* Match.value(params.nodeSpec.owner.executorType).pipe(
+      Match.when('agent', () =>
+        deps.agentExecutor.executeNode({
           nodeSpec: params.nodeSpec,
           resolvedInput: params.resolvedInput,
           inputArtifacts: params.inputArtifacts,
           context: params.context,
           executionMode: effectiveExecutionMode,
           schemaRegistry: params.schemaRegistry,
-        })
-      case 'plugin':
-        return yield* deps.pluginExecutor.executeNode({
+        }),
+      ),
+      Match.when('plugin', () =>
+        deps.pluginExecutor.executeNode({
           nodeSpec: params.nodeSpec,
           resolvedInput: params.resolvedInput,
           context: params.context,
-        })
-      case 'system':
-        return yield* deps.systemExecutor.executeNode({
+        }),
+      ),
+      Match.when('system', () =>
+        deps.systemExecutor.executeNode({
           nodeSpec: params.nodeSpec,
           resolvedInput: params.resolvedInput,
           context: params.context,
-        })
-      case 'skill': {
-        const resolved = yield* deps.skillResolver.resolve({
-          skillRef: params.nodeSpec.owner.ref,
-          organizationId: params.context.organizationId,
-        })
-        if (!resolved) {
-          return yield* new ConfigurationError({
-            message: `Skill "${params.nodeSpec.owner.ref}" could not be resolved. This is a configuration error.`,
+        }),
+      ),
+      Match.when('skill', () =>
+        Effect.gen(function* () {
+          const resolved = yield* deps.skillResolver.resolve({
+            skillRef: params.nodeSpec.owner.ref,
+            organizationId: params.context.organizationId,
           })
-        }
-
-        if (resolved.executorType === 'agent') {
-          const skillNodeSpec = { ...params.nodeSpec, owner: { executorType: 'agent' as const, ref: resolved.ref } }
-          return yield* deps.agentExecutor.executeNode({
-            nodeSpec: skillNodeSpec,
+          if (!resolved) {
+            return yield* new ConfigurationError({
+              message: `Skill "${params.nodeSpec.owner.ref}" could not be resolved. This is a configuration error.`,
+            })
+          }
+
+          if (resolved.executorType === 'agent') {
+            const skillNodeSpec = { ...params.nodeSpec, owner: { executorType: 'agent' as const, ref: resolved.ref } }
+            return yield* deps.agentExecutor.executeNode({
+              nodeSpec: skillNodeSpec,
+              resolvedInput: params.resolvedInput,
+              inputArtifacts: params.inputArtifacts,
+              context: params.context,
+              executionMode: effectiveExecutionMode,
+              schemaRegistry: params.schemaRegistry,
+            })
+          }
+
+          return yield* deps.pluginExecutor.executeNode({
+            nodeSpec: {
+              ...params.nodeSpec,
+              owner: {
+                executorType: 'plugin' as const,
+                ref: resolved.ref,
+                operation: resolved.operation ?? params.nodeSpec.owner.ref,
+              },
+            },
             resolvedInput: params.resolvedInput,
-            inputArtifacts: params.inputArtifacts,
             context: params.context,
-            executionMode: effectiveExecutionMode,
-            schemaRegistry: params.schemaRegistry,
           })
-        }
-
-        return yield* deps.pluginExecutor.executeNode({
-          nodeSpec: {
-            ...params.nodeSpec,
-            owner: {
-              executorType: 'plugin' as const,
-              ref: resolved.ref,
-              operation: resolved.operation ?? params.nodeSpec.owner.ref,
-            },
-          },
-          resolvedInput: params.resolvedInput,
-          context: params.context,
-        })
-      }
-      case 'user':
-        return yield* new BadRequestError({
-          message: `User-owned node "${params.nodeSpec.id}" cannot be auto-dispatched.`,
-        })
-    }
+        }),
+      ),
+      Match.when(
+        'user',
+        () => new BadRequestError({ message: `User-owned node "${params.nodeSpec.id}" cannot be auto-dispatched.` }),
+      ),
+      Match.exhaustive,
+    )
   })
 
+type GraphFullDispatchReadyNode = (
+  params: Parameters<typeof dispatchReadyNodeEffect>[1],
+) => Effect.Effect<PlanNodeResultSubmission, Effect.Error<ReturnType<typeof dispatchReadyNodeEffect>>, never>
+
 const dispatchRunToStableBoundaryEffect = (
   deps: OwnershipDispatcherDeps,
   params: { runId: RecordIdInput; emittedBy: string },
@@ -359,20 +381,22 @@ const dispatchRunToStableBoundaryEffect = (
       const spec = yield* deps.planRun.getPlanSpecById(run.planSpecId)
 
       if (spec.executionMode === 'graph-full') {
+        const dispatchReadyNodeForGraphFull: GraphFullDispatchReadyNode = (dispatchParams) =>
+          dispatchReadyNodeEffect(deps, dispatchParams)
+
         yield* routeGraphFullEffect(
           { threadId: recordIdToString(run.threadId, TABLES.THREAD), runId: recordIdToString(run.id, TABLES.PLAN_RUN) },
           {
-            dispatchReadyNode: (dispatchParams) => dispatchReadyNodeEffect(deps, dispatchParams),
+            dispatchReadyNode: dispatchReadyNodeForGraphFull,
             planExecutorService: deps.planExecutor,
             planRunService: deps.planRun,
           },
         ).pipe(
-          Effect.catch(() =>
-            Effect.fail(
+          Effect.mapError(
+            () =>
               new ConfigurationError({
                 message: `Failed to route graph-full execution for run ${recordIdToString(run.id, TABLES.PLAN_RUN)}.`,
               }),
-            ),
           ),
         )
         return yield* serializeRunEffect(deps, run.id)
@@ -428,29 +452,33 @@ const dispatchRunToStableBoundaryEffect = (
             schemaRegistry: spec.schemaRegistry,
           })
 
-          yield* Effect.tryPromise(() =>
-            deps.planExecutor.submitNodeResult({
-              threadId: run.threadId,
-              runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-              nodeId: planNode.id,
-              emittedBy: planNode.owner.ref,
-              result,
-            }),
+          yield* tryDispatchPromise(
+            () =>
+              deps.planExecutor.submitNodeResult({
+                threadId: run.threadId,
+                runId: recordIdToString(run.id, TABLES.PLAN_RUN),
+                nodeId: planNode.id,
+                emittedBy: planNode.owner.ref,
+                result,
+              }),
+            'Failed to submit plan node result.',
           )
         }),
       )
 
-      if (dispatchExit._tag === 'Failure') {
+      if (Exit.isFailure(dispatchExit)) {
         const failure = Cause.squash(dispatchExit.cause)
-        yield* Effect.tryPromise(() =>
-          deps.planExecutor.blockNodeOnDispatchFailure({
-            threadId: run.threadId,
-            runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-            nodeId: planNode.id,
-            emittedBy: planNode.owner.ref,
-            message: formatDispatchError(failure),
-            failureClass: classifyDispatchFailure({ ownerType: planNode.owner.executorType, error: failure }),
-          }),
+        yield* tryDispatchPromise(
+          () =>
+            deps.planExecutor.blockNodeOnDispatchFailure({
+              threadId: run.threadId,
+              runId: recordIdToString(run.id, TABLES.PLAN_RUN),
+              nodeId: planNode.id,
+              emittedBy: planNode.owner.ref,
+              message: formatDispatchError(failure),
+              failureClass: classifyDispatchFailure({ ownerType: planNode.owner.executorType, error: failure }),
+            }),
+          'Failed to block plan node on dispatch failure.',
         )
         return yield* serializeRunEffect(deps, run.id)
       }
@@ -541,14 +569,19 @@ export function makeOwnershipDispatcherService(deps: OwnershipDispatcherDeps) {
   } as const
 }
 
+export interface OwnershipDispatcherService extends ReturnType<typeof makeOwnershipDispatcherService> {}
+
 export class OwnershipDispatcherServiceTag extends Context.Service<
   OwnershipDispatcherServiceTag,
-  ReturnType<typeof makeOwnershipDispatcherService>
->()('OwnershipDispatcherService') {}
+  OwnershipDispatcherService
+>()('@lota-sdk/core/OwnershipDispatcherService') {}
 
 export const OwnershipDispatcherServiceLive = Layer.effect(
   OwnershipDispatcherServiceTag,
   Effect.gen(function* () {
+    const currentContext = yield* Effect.context()
+    const provideCurrentContext = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, never> =>
+      effect.pipe(Effect.provide(currentContext)) as Effect.Effect<A, E, never>
     const db = yield* DatabaseServiceTag
     const agentConfig = yield* AgentConfigServiceTag
     const runtimeAdapters = yield* RuntimeAdaptersServiceTag
@@ -560,18 +593,27 @@ export const OwnershipDispatcherServiceLive = Layer.effect(
     const skillResolver = yield* SkillResolverServiceTag
     const systemExecutor = yield* SystemExecutorServiceTag
     const user = yield* UserServiceTag
+    const executeAgentNode = agentExecutor.executeNode as OwnershipDispatcherDeps['agentExecutor']['executeNode']
     return makeOwnershipDispatcherService({
       db,
       agentConfig,
       runtimeAdapters,
-      agentExecutor,
-      monitoringWindow,
+      agentExecutor: { executeNode: executeAgentNode },
+      monitoringWindow: {
+        startMonitoringWindow: (params) => provideCurrentContext(monitoringWindow.startMonitoringWindow(params)),
+      },
       planExecutor,
       planRun,
-      pluginExecutor,
-      skillResolver,
-      systemExecutor,
-      user,
+      pluginExecutor: {
+        validateOwner: (owner, nodeId) => pluginExecutor.validateOwner(owner, nodeId),
+        executeNode: (params) => provideCurrentContext(pluginExecutor.executeNode(params)),
+      },
+      skillResolver: { resolve: (params) => provideCurrentContext(skillResolver.resolve(params)) },
+      systemExecutor: {
+        validateOwner: (owner, nodeId) => systemExecutor.validateOwner(owner, nodeId),
+        executeNode: (params) => provideCurrentContext(systemExecutor.executeNode(params)),
+      },
+      user: { getUser: (userId) => provideCurrentContext(user.getUser(userId)) },
     })
   }),
 )

package/src/services/plan/plan-agent-heartbeat.service.ts

@@ -213,7 +213,7 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
 export class PlanAgentHeartbeatServiceTag extends Context.Service<
   PlanAgentHeartbeatServiceTag,
   ReturnType<typeof makePlanAgentHeartbeatService>
->()('PlanAgentHeartbeatService') {}
+>()('@lota-sdk/core/PlanAgentHeartbeatService') {}
 
 export const PlanAgentHeartbeatServiceLive = Layer.effect(
   PlanAgentHeartbeatServiceTag,

package/src/services/plan/plan-agent-query.service.ts

@@ -310,7 +310,7 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
 export class PlanAgentQueryServiceTag extends Context.Service<
   PlanAgentQueryServiceTag,
   ReturnType<typeof makePlanAgentQueryService>
->()('PlanAgentQueryService') {}
+>()('@lota-sdk/core/PlanAgentQueryService') {}
 
 export const PlanAgentQueryServiceLive = Layer.effect(
   PlanAgentQueryServiceTag,

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

@@ -12,48 +12,53 @@ import { nowDate } from '../../utils/date-time'
 import type { HumanNodeResponsePayload } from './plan-executor-helpers'
 
 export function makePlanApprovalService(db: SurrealDBService) {
-  const createPendingApprovalEffect = (params: {
+  const createPendingApprovalEffect = Effect.fn('PlanApproval.createPendingApproval')(function* (params: {
     tx: DatabaseTransaction
     runId: RecordIdInput
     nodeRunId: RecordIdInput
     nodeId: string
     requestedBy: string
     presented: Record<string, unknown>
-  }) =>
-    Effect.gen(function* () {
-      const approvalId = new RecordId(TABLES.PLAN_APPROVAL, Bun.randomUUIDv7())
-      const created = yield* params.tx
-        .create(approvalId)
-        .content({
-          runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
-          nodeRunId: ensureRecordId(params.nodeRunId, TABLES.PLAN_NODE_RUN),
-          nodeId: params.nodeId,
-          status: 'pending',
-          requestedBy: params.requestedBy,
-          presented: params.presented,
-          requiredEdits: [],
-        })
-        .output('after')
+  }) {
+    const approvalId = new RecordId(TABLES.PLAN_APPROVAL, Bun.randomUUIDv7())
+    const created = yield* params.tx
+      .create(approvalId)
+      .content({
+        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+        nodeRunId: ensureRecordId(params.nodeRunId, TABLES.PLAN_NODE_RUN),
+        nodeId: params.nodeId,
+        status: 'pending',
+        requestedBy: params.requestedBy,
+        presented: params.presented,
+        requiredEdits: [],
+      })
+      .output('after')
 
-      return PlanApprovalSchema.parse(created)
-    })
+    return PlanApprovalSchema.parse(created)
+  })
 
-  const getApprovalByIdEffect = (approvalId: RecordIdInput) =>
-    db.findOne(TABLES.PLAN_APPROVAL, { id: ensureRecordId(approvalId, TABLES.PLAN_APPROVAL) }, PlanApprovalSchema)
+  const getApprovalByIdEffect = Effect.fn('PlanApproval.getApprovalById')(function* (approvalId: RecordIdInput) {
+    return yield* db.findOne(
+      TABLES.PLAN_APPROVAL,
+      { id: ensureRecordId(approvalId, TABLES.PLAN_APPROVAL) },
+      PlanApprovalSchema,
+    )
+  })
 
-  const getPendingApprovalForNodeRunEffect = (nodeRunId: RecordIdInput) =>
-    Effect.gen(function* () {
-      const approvals = yield* db.findMany(
-        TABLES.PLAN_APPROVAL,
-        { nodeRunId: ensureRecordId(nodeRunId, TABLES.PLAN_NODE_RUN), status: 'pending' },
-        PlanApprovalSchema,
-        { orderBy: 'createdAt', orderDir: 'DESC', limit: 1 },
-      )
+  const getPendingApprovalForNodeRunEffect = Effect.fn('PlanApproval.getPendingApprovalForNodeRun')(function* (
+    nodeRunId: RecordIdInput,
+  ) {
+    const approvals = yield* db.findMany(
+      TABLES.PLAN_APPROVAL,
+      { nodeRunId: ensureRecordId(nodeRunId, TABLES.PLAN_NODE_RUN), status: 'pending' },
+      PlanApprovalSchema,
+      { orderBy: 'createdAt', orderDir: 'DESC', limit: 1 },
+    )
 
-      return approvals.at(0) ?? null
-    })
+    return approvals.at(0) ?? null
+  })
 
-  const updateApprovalResponseEffect = (params: {
+  const updateApprovalResponseEffect = Effect.fn('PlanApproval.updateApprovalResponse')(function* (params: {
     tx: DatabaseTransaction
     approval: PlanApprovalRecord
     status: PlanApprovalStatus
@@ -62,23 +67,22 @@ export function makePlanApprovalService(db: SurrealDBService) {
     approvalMessageId?: string
     comments?: string
     requiredEdits?: string[]
-  }) =>
-    Effect.gen(function* () {
-      const updated = yield* params.tx
-        .update(ensureRecordId(params.approval.id, TABLES.PLAN_APPROVAL))
-        .merge({
-          status: params.status,
-          response: params.response,
-          respondedBy: params.respondedBy,
-          ...(params.approvalMessageId ? { approvalMessageId: params.approvalMessageId } : {}),
-          ...(params.comments ? { comments: params.comments } : {}),
-          ...(params.requiredEdits ? { requiredEdits: params.requiredEdits } : {}),
-          respondedAt: nowDate(),
-        })
-        .output('after')
+  }) {
+    const updated = yield* params.tx
+      .update(ensureRecordId(params.approval.id, TABLES.PLAN_APPROVAL))
+      .merge({
+        status: params.status,
+        response: params.response,
+        respondedBy: params.respondedBy,
+        ...(params.approvalMessageId ? { approvalMessageId: params.approvalMessageId } : {}),
+        ...(params.comments ? { comments: params.comments } : {}),
+        ...(params.requiredEdits ? { requiredEdits: params.requiredEdits } : {}),
+        respondedAt: nowDate(),
+      })
+      .output('after')
 
-      return PlanApprovalSchema.parse(updated)
-    })
+    return PlanApprovalSchema.parse(updated)
+  })
 
   return {
     createPendingApproval: createPendingApprovalEffect,
@@ -91,7 +95,7 @@ export function makePlanApprovalService(db: SurrealDBService) {
 export class PlanApprovalServiceTag extends Context.Service<
   PlanApprovalServiceTag,
   ReturnType<typeof makePlanApprovalService>
->()('PlanApprovalService') {}
+>()('@lota-sdk/core/PlanApprovalService') {}
 
 export const PlanApprovalServiceLive = Layer.effect(
   PlanApprovalServiceTag,

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

@@ -55,6 +55,6 @@ export function makePlanArtifactService() {
 export class PlanArtifactServiceTag extends Context.Service<
   PlanArtifactServiceTag,
   ReturnType<typeof makePlanArtifactService>
->()('PlanArtifactService') {}
+>()('@lota-sdk/core/PlanArtifactService') {}
 
-export const PlanArtifactServiceLive = Layer.succeed(PlanArtifactServiceTag, makePlanArtifactService())
+export const PlanArtifactServiceLive = Layer.sync(PlanArtifactServiceTag, () => makePlanArtifactService())

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

@@ -71,6 +71,6 @@ export function makePlanBuilderService() {
 export class PlanBuilderServiceTag extends Context.Service<
   PlanBuilderServiceTag,
   ReturnType<typeof makePlanBuilderService>
->()('PlanBuilderService') {}
+>()('@lota-sdk/core/PlanBuilderService') {}
 
-export const PlanBuilderServiceLive = Layer.succeed(PlanBuilderServiceTag, makePlanBuilderService())
+export const PlanBuilderServiceLive = Layer.sync(PlanBuilderServiceTag, () => makePlanBuilderService())

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

@@ -91,7 +91,7 @@ export function makePlanCheckpointService(deps: PlanCheckpointDeps) {
 export class PlanCheckpointServiceTag extends Context.Service<
   PlanCheckpointServiceTag,
   ReturnType<typeof makePlanCheckpointService>
->()('PlanCheckpointService') {}
+>()('@lota-sdk/core/PlanCheckpointService') {}
 
 export const PlanCheckpointServiceLive = Layer.effect(
   PlanCheckpointServiceTag,

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

@@ -95,7 +95,7 @@ export function makePlanCompilerService(planValidatorService: ReturnType<typeof
 export class PlanCompilerServiceTag extends Context.Service<
   PlanCompilerServiceTag,
   ReturnType<typeof makePlanCompilerService>
->()('PlanCompilerService') {}
+>()('@lota-sdk/core/PlanCompilerService') {}
 
 export const PlanCompilerServiceLive = Layer.effect(
   PlanCompilerServiceTag,

package/src/services/plan/plan-completion-side-effects.ts

@@ -6,6 +6,7 @@ import { aiLogger } from '../../config/logger'
 import { ensureRecordId } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { runPromise } from '../../effect/runtime'
 import { nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
 import type { makeFeedbackLoopService } from '../feedback-loop.service'
@@ -33,25 +34,15 @@ class PlanCompletionSideEffectsError extends Schema.TaggedErrorClass<PlanComplet
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
+const effectTryPlanCompletionPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new PlanCompletionSideEffectsError({ message, cause }),
+)
+
 function tryPlanCompletionPromise<A>(
   message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
 ): Effect.Effect<A, PlanCompletionSideEffectsError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new PlanCompletionSideEffectsError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new PlanCompletionSideEffectsError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new PlanCompletionSideEffectsError({ message, cause }))
-    }
-  })
+  return effectTryPlanCompletionPromise(evaluate, message)
 }
 
 export function makePlanCompletionSideEffects({
@@ -134,14 +125,17 @@ export function makePlanCompletionSideEffects({
               PlanEventSchema,
             ),
           )
-          yield* Effect.tryPromise({
-            try: () => planEventDeliveryService.dispatchEvent(event),
-            catch: (cause) =>
-              new PlanCompletionSideEffectsError({
-                message: 'Failed to dispatch feedback analyzed plan event.',
-                cause,
-              }),
-          })
+          yield* planEventDeliveryService
+            .dispatchEventEffect(event)
+            .pipe(
+              Effect.mapError(
+                (error) =>
+                  new PlanCompletionSideEffectsError({
+                    message: 'Failed to dispatch feedback analyzed plan event.',
+                    cause: error,
+                  }),
+              ),
+            )
         }
 
         yield* institutionalMemoryService

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

@@ -170,7 +170,7 @@ export function makePlanCoordinationService(planRunService: ReturnType<typeof ma
 export class PlanCoordinationServiceTag extends Context.Service<
   PlanCoordinationServiceTag,
   ReturnType<typeof makePlanCoordinationService>
->()('PlanCoordinationService') {}
+>()('@lota-sdk/core/PlanCoordinationService') {}
 
 export const PlanCoordinationServiceLive = Layer.effect(
   PlanCoordinationServiceTag,