@lota-sdk/core 0.4.13 → 0.4.15

package/src/services/organization.service.ts

@@ -6,7 +6,7 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput, RecordIdRef } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { NotFoundError } from '../effect/errors'
+import { ERROR_TAGS, NotFoundError } from '../effect/errors'
 import { DatabaseServiceTag } from '../effect/services'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
 
@@ -17,10 +17,10 @@ interface BackgroundCursor {
   id: string
 }
 
-class OrganizationServiceError extends Schema.TaggedErrorClass<OrganizationServiceError>()('OrganizationServiceError', {
-  operation: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class OrganizationServiceError extends Schema.TaggedErrorClass<OrganizationServiceError>()(
+  ERROR_TAGS.OrganizationServiceError,
+  { operation: Schema.String, cause: Schema.Defect },
+) {}
 
 function toOptionalCursorTimestamp(value: unknown): string | null {
   return toOptionalIsoDateTimeString(value) ?? null
@@ -58,85 +58,80 @@ function toOrganizationServiceError(operation: string, cause: unknown): Organiza
 }
 
 export function makeOrganizationService(db: SurrealDBService) {
-  function createOrganization(params: { name: string }) {
-    return db.create(TABLES.ORGANIZATION, { name: params.name }, sdkOrganizationRecordSchema).pipe(
-      Effect.mapError((cause) => toOrganizationServiceError('createOrganization', cause)),
-      Effect.flatMap(toPublicEffect),
-    )
-  }
+  const createOrganization = Effect.fn('OrganizationService.create')(function* (params: { name: string }) {
+    const record = yield* db
+      .create(TABLES.ORGANIZATION, { name: params.name }, sdkOrganizationRecordSchema)
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('createOrganization', cause)))
+    return yield* toPublicEffect(record)
+  })
 
-  function upsertOrganization(params: { id: RecordIdInput; name: string }) {
+  const upsertOrganization = Effect.fn('OrganizationService.upsert')(function* (params: {
+    id: RecordIdInput
+    name: string
+  }) {
     const organizationRef = ensureRecordId(params.id, TABLES.ORGANIZATION)
-    return db.upsert(TABLES.ORGANIZATION, organizationRef, { name: params.name }, sdkOrganizationRecordSchema).pipe(
-      Effect.mapError((cause) => toOrganizationServiceError('upsertOrganization', cause)),
-      Effect.flatMap(toPublicEffect),
-    )
-  }
+    const record = yield* db
+      .upsert(TABLES.ORGANIZATION, organizationRef, { name: params.name }, sdkOrganizationRecordSchema)
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('upsertOrganization', cause)))
+    return yield* toPublicEffect(record)
+  })
 
-  function listOrganizations() {
-    return db
+  const listOrganizations = Effect.fn('OrganizationService.list')(function* () {
+    const records = yield* db
       .findMany(TABLES.ORGANIZATION, {}, sdkOrganizationRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' })
-      .pipe(
-        Effect.mapError((cause) => toOrganizationServiceError('listOrganizations', cause)),
-        Effect.flatMap((records) => Effect.forEach(records, toPublicEffect)),
-      )
-  }
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('listOrganizations', cause)))
+    return yield* Effect.forEach(records, toPublicEffect)
+  })
 
-  function getOrganizationRecord(organizationId: RecordIdRef) {
-    return db
+  const getOrganizationRecord = Effect.fn('OrganizationService.getRecord')(function* (organizationId: RecordIdRef) {
+    const record = yield* db
       .findOne(
         TABLES.ORGANIZATION,
         { id: ensureRecordId(organizationId, TABLES.ORGANIZATION) },
         sdkOrganizationRecordSchema,
       )
-      .pipe(
-        Effect.mapError((cause) => toOrganizationServiceError('getOrganizationRecord', cause)),
-        Effect.flatMap((record) =>
-          record ? Effect.succeed(record) : Effect.fail(organizationNotFoundError(organizationId)),
-        ),
-      )
-  }
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('getOrganizationRecord', cause)))
+    if (!record) return yield* organizationNotFoundError(organizationId)
+    return record
+  })
 
-  function getOrganization(organizationId: RecordIdInput) {
-    return getOrganizationRecord(ensureRecordId(organizationId, TABLES.ORGANIZATION)).pipe(
-      Effect.flatMap(toPublicEffect),
-    )
-  }
+  const getOrganization = Effect.fn('OrganizationService.get')(function* (organizationId: RecordIdInput) {
+    const record = yield* getOrganizationRecord(ensureRecordId(organizationId, TABLES.ORGANIZATION))
+    return yield* toPublicEffect(record)
+  })
 
-  function updateOrganization(organizationId: RecordIdInput, params: { name: string }) {
-    return db
+  const updateOrganization = Effect.fn('OrganizationService.update')(function* (
+    organizationId: RecordIdInput,
+    params: { name: string },
+  ) {
+    const updated = yield* db
       .update(
         TABLES.ORGANIZATION,
         ensureRecordId(organizationId, TABLES.ORGANIZATION),
         { name: params.name },
         sdkOrganizationRecordSchema,
       )
-      .pipe(
-        Effect.mapError((cause) => toOrganizationServiceError('updateOrganization', cause)),
-        Effect.flatMap((updated) =>
-          updated ? Effect.succeed(updated) : Effect.fail(organizationNotFoundError(organizationId)),
-        ),
-        Effect.flatMap(toPublicEffect),
-      )
-  }
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('updateOrganization', cause)))
+    if (!updated) return yield* organizationNotFoundError(organizationId)
+    return yield* toPublicEffect(updated)
+  })
 
-  function deleteOrganization(organizationId: RecordIdInput) {
+  const deleteOrganization = Effect.fn('OrganizationService.delete')(function* (organizationId: RecordIdInput) {
     const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
-    return Effect.gen(function* () {
-      yield* db
-        .deleteWhere(TABLES.ORGANIZATION_MEMBER, { out: organizationRef })
-        .pipe(Effect.mapError((cause) => toOrganizationServiceError('deleteOrganization.deleteMembers', cause)))
-      const deleted = yield* db
-        .deleteById(TABLES.ORGANIZATION, organizationRef)
-        .pipe(Effect.mapError((cause) => toOrganizationServiceError('deleteOrganization.deleteOrganization', cause)))
-      if (!deleted) {
-        return yield* organizationNotFoundError(organizationId)
-      }
-    })
-  }
+    yield* db
+      .deleteWhere(TABLES.ORGANIZATION_MEMBER, { out: organizationRef })
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('deleteOrganization.deleteMembers', cause)))
+    const deleted = yield* db
+      .deleteById(TABLES.ORGANIZATION, organizationRef)
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('deleteOrganization.deleteOrganization', cause)))
+    if (!deleted) return yield* organizationNotFoundError(organizationId)
+  })
 
-  function updateRegularChatDigestCursor(organizationId: RecordIdRef, cursor: BackgroundCursor) {
-    return db
+  const updateRegularChatDigestCursor = Effect.fn('OrganizationService.updateRegularChatDigestCursor')(function* (
+    organizationId: RecordIdRef,
+    cursor: BackgroundCursor,
+  ) {
+    const updated = yield* db
       .update(
         TABLES.ORGANIZATION,
         ensureRecordId(organizationId, TABLES.ORGANIZATION),
@@ -146,25 +141,24 @@ export function makeOrganizationService(db: SurrealDBService) {
         },
         sdkOrganizationRecordSchema,
       )
-      .pipe(
-        Effect.mapError((cause) => toOrganizationServiceError('updateRegularChatDigestCursor', cause)),
-        Effect.flatMap((updated) => (updated ? Effect.void : Effect.fail(organizationNotFoundError(organizationId)))),
-      )
-  }
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('updateRegularChatDigestCursor', cause)))
+    if (!updated) return yield* organizationNotFoundError(organizationId)
+  })
 
-  function updateSkillExtractionCursor(organizationId: RecordIdRef, cursor: BackgroundCursor) {
-    return db
+  const updateSkillExtractionCursor = Effect.fn('OrganizationService.updateSkillExtractionCursor')(function* (
+    organizationId: RecordIdRef,
+    cursor: BackgroundCursor,
+  ) {
+    const updated = yield* db
       .update(
         TABLES.ORGANIZATION,
         ensureRecordId(organizationId, TABLES.ORGANIZATION),
         { skillExtractionLastCursorCreatedAt: cursor.createdAt, skillExtractionLastCursorId: cursor.id },
         sdkOrganizationRecordSchema,
       )
-      .pipe(
-        Effect.mapError((cause) => toOrganizationServiceError('updateSkillExtractionCursor', cause)),
-        Effect.flatMap((updated) => (updated ? Effect.void : Effect.fail(organizationNotFoundError(organizationId)))),
-      )
-  }
+      .pipe(Effect.mapError((cause) => toOrganizationServiceError('updateSkillExtractionCursor', cause)))
+    if (!updated) return yield* organizationNotFoundError(organizationId)
+  })
 
   return {
     createOrganization,

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

@@ -23,7 +23,6 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { BadRequestError, ConfigurationError, DatabaseError, ServiceError } from '../effect/errors'
-import { isPromiseLike, makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { AgentConfigServiceTag, DatabaseServiceTag, RuntimeAdaptersServiceTag } from '../effect/services'
 import type { PlanAgentHeartbeatQueueRuntime } from '../queues/plan-agent-heartbeat.queue'
 import { LotaQueuesServiceTag } from '../queues/queues.service'
@@ -142,8 +141,6 @@ 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[] =>
@@ -181,23 +178,25 @@ const shouldAutoDispatchEffect = (deps: OwnershipDispatcherDeps, run: PlanRunRec
       return true
     }
 
-    const workspace = yield* tryDispatchPromise(
-      () => workspaceProvider.getWorkspace(ensureRecordId(run.organizationId, TABLES.ORGANIZATION)),
-      'Failed to load workspace for dispatch eligibility.',
-    )
-    if (!workspaceProvider.getLifecycleState) {
+    const workspace = yield* Effect.tryPromise({
+      try: () => workspaceProvider.getWorkspace(ensureRecordId(run.organizationId, TABLES.ORGANIZATION)),
+      catch: (cause) => new ServiceError({ message: 'Failed to load workspace for dispatch eligibility.', cause }),
+    })
+    const getLifecycleState = workspaceProvider.getLifecycleState
+      ? (() => {
+          const run = workspaceProvider.getLifecycleState.bind(workspaceProvider)
+          return (workspaceRecord: Record<string, unknown>) => run(workspaceRecord)
+        })()
+      : undefined
+    if (!getLifecycleState) {
       return true
     }
 
-    const lifecycleState = yield* Effect.gen(function* () {
-      const result = workspaceProvider.getLifecycleState?.call(workspaceProvider, workspace)
-      if (isPromiseLike(result)) {
-        return yield* tryDispatchPromise(() => result, 'Failed to read workspace lifecycle state.')
-      }
-
-      return result
+    const lifecycleState = yield* Effect.tryPromise({
+      try: () => getLifecycleState(workspace),
+      catch: (cause) => new ServiceError({ message: 'Failed to read workspace lifecycle state.', cause }),
     })
-    return lifecycleState ? lifecycleState.bootstrapActive !== true : true
+    return lifecycleState.bootstrapActive !== true
   })
 
 const buildDispatchContextEffect = (
@@ -457,34 +456,36 @@ const dispatchRunToStableBoundaryEffect = (
             schemaRegistry: spec.schemaRegistry,
           })
 
-          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.',
-          )
+          yield* deps.planExecutor
+            .submitNodeResult({
+              threadId: run.threadId,
+              runId: recordIdToString(run.id, TABLES.PLAN_RUN),
+              nodeId: planNode.id,
+              emittedBy: planNode.owner.ref,
+              result,
+            })
+            .pipe(
+              Effect.mapError((cause) => new ServiceError({ message: 'Failed to submit plan node result.', cause })),
+            )
         }),
       )
 
       if (Exit.isFailure(dispatchExit)) {
         const failure = Cause.squash(dispatchExit.cause)
-        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.',
-        )
+        yield* 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 }),
+          })
+          .pipe(
+            Effect.mapError(
+              (cause) => new ServiceError({ message: 'Failed to block plan node on dispatch failure.', cause }),
+            ),
+          )
         return yield* serializeRunEffect(deps, run.id)
       }
     }

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

@@ -4,13 +4,15 @@ import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { serverLogger } from '../../config/logger'
 import { ensureRecordId } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
-import { effectTryPromise } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import { AgentConfigServiceTag, RedisServiceTag } from '../../effect/services'
 import type { PlanAgentHeartbeatQueueRuntime } from '../../queues/plan-agent-heartbeat.queue'
 import { LotaQueuesServiceTag } from '../../queues/queues.service'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { withLeaseLock } from '../../redis/redis-lease-lock'
 import { resolvePlanNodeExecutionVisibility } from '../../runtime/execution-plan-visibility'
+import type { makeThreadTurnService } from '../thread/thread-turn'
+import { ThreadTurnServiceTag } from '../thread/thread-turn'
 import type { makeThreadService } from '../thread/thread.service'
 import { ThreadServiceTag } from '../thread/thread.service'
 import type { makePlanAgentQueryService } from './plan-agent-query.service'
@@ -37,17 +39,10 @@ function buildWakeDedupeKey(params: {
   return `${params.organizationId}:${params.threadId}:${params.runId}:${params.nodeId}:${params.agentId}`
 }
 
-class PlanAgentHeartbeatError extends Schema.TaggedErrorClass<PlanAgentHeartbeatError>()('PlanAgentHeartbeatError', {
-  operation: Schema.String,
-  cause: Schema.Defect,
-}) {}
-
-function tryHeartbeatPromise<A, R = never>(
-  operation: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown, R>,
-): Effect.Effect<A, PlanAgentHeartbeatError, R> {
-  return effectTryPromise(thunk, (cause) => new PlanAgentHeartbeatError({ operation, cause }))
-}
+class PlanAgentHeartbeatError extends Schema.TaggedErrorClass<PlanAgentHeartbeatError>()(
+  ERROR_TAGS.PlanAgentHeartbeatError,
+  { operation: Schema.String, cause: Schema.Defect },
+) {}
 
 function heartbeatServiceEffect<A, E, R = never>(
   operation: string,
@@ -63,6 +58,7 @@ interface PlanAgentHeartbeatDeps {
   planExecutorService: ReturnType<typeof makePlanExecutorService>
   planRunService: ReturnType<typeof makePlanRunService>
   threadService: ReturnType<typeof makeThreadService>
+  threadTurnService: ReturnType<typeof makeThreadTurnService>
   planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime
 }
 
@@ -74,6 +70,7 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
     redis,
     planAgentQueryService,
     threadService,
+    threadTurnService,
     planAgentHeartbeatQueue,
   } = deps
 
@@ -84,7 +81,7 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
     nodeId: string
     agentId: string
     reason: string
-  }): Effect.Effect<boolean, PlanAgentHeartbeatError, unknown> =>
+  }): Effect.Effect<boolean, PlanAgentHeartbeatError, never> =>
     Effect.gen(function* () {
       const threadRef = ensureRecordId(params.threadId, TABLES.THREAD)
       yield* heartbeatServiceEffect(
@@ -148,27 +145,23 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
             }
 
             if (nodeRun.status === 'ready' && run.currentNodeId === params.nodeId) {
-              yield* tryHeartbeatPromise('transition-node-to-running', () =>
+              yield* heartbeatServiceEffect(
+                'transition-node-to-running',
                 planExecutorService.transitionNodeToRunning({ runId: params.runId, nodeId: params.nodeId }),
               )
             }
 
-            const { triggerPlanNodeTurn } = yield* tryHeartbeatPromise(
-              'import-thread-turn',
-              () => import('../thread/thread-turn'),
-            )
-
-            yield* tryHeartbeatPromise('trigger-plan-node-turn', () =>
-              triggerPlanNodeTurn({ runId: params.runId, nodeId: params.nodeId }),
+            yield* heartbeatServiceEffect(
+              'trigger-plan-node-turn',
+              threadTurnService.triggerPlanNodeTurn({ runId: params.runId, nodeId: params.nodeId }),
             )
             return true
           }),
       ).pipe(Effect.mapError((cause) => new PlanAgentHeartbeatError({ operation: 'wake-node-lock', cause })))
     })
 
-  const sweepEffect = (params?: { organizationId?: string }): Effect.Effect<void, PlanAgentHeartbeatError, unknown> =>
+  const sweepEffect = (params?: { organizationId?: string }): Effect.Effect<void, PlanAgentHeartbeatError, never> =>
     Effect.gen(function* () {
-      const enqueuePlanAgentHeartbeatWake = planAgentHeartbeatQueue.enqueuePlanAgentHeartbeatWake
       const [actionable, recentlyUnblocked, approachingDeadlines] = yield* Effect.all([
         heartbeatServiceEffect(
           'get-actionable-nodes-for-agent',
@@ -213,7 +206,10 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
       }
 
       for (const target of wakeTargets.values()) {
-        yield* tryHeartbeatPromise('enqueue-heartbeat-wake', () => enqueuePlanAgentHeartbeatWake(target))
+        yield* Effect.tryPromise({
+          try: () => planAgentHeartbeatQueue.enqueuePlanAgentHeartbeatWake(target),
+          catch: (cause) => new PlanAgentHeartbeatError({ operation: 'enqueue-heartbeat-wake', cause }),
+        })
       }
     })
 
@@ -234,6 +230,7 @@ export const PlanAgentHeartbeatServiceLive = Layer.effect(
     const planRunService = yield* PlanRunServiceTag
     const planExecutor = yield* PlanExecutorServiceTag
     const threadSvc = yield* ThreadServiceTag
+    const threadTurnSvc = yield* ThreadTurnServiceTag
     const queues = yield* LotaQueuesServiceTag
     return makePlanAgentHeartbeatService({
       agentConfig,
@@ -242,6 +239,7 @@ export const PlanAgentHeartbeatServiceLive = Layer.effect(
       planExecutorService: planExecutor,
       planRunService,
       threadService: threadSvc,
+      threadTurnService: threadTurnSvc,
       planAgentHeartbeatQueue: queues.planAgentHeartbeat,
     })
   }),

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

@@ -8,7 +8,7 @@ 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 { effectTryPromise } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import { AgentConfigServiceTag, DatabaseServiceTag } from '../../effect/services'
 import { resolvePlanNodeExecutionVisibility } from '../../runtime/execution-plan-visibility'
 import { nowDate, unsafeDateFrom } from '../../utils/date-time'
@@ -71,7 +71,7 @@ function isVisibleAgentNode(params: {
   return { agentId: params.nodeSpec.owner.ref, visibility }
 }
 
-class PlanAgentQueryError extends Schema.TaggedErrorClass<PlanAgentQueryError>()('PlanAgentQueryError', {
+class PlanAgentQueryError extends Schema.TaggedErrorClass<PlanAgentQueryError>()(ERROR_TAGS.PlanAgentQueryError, {
   operation: Schema.String,
   cause: Schema.Defect,
 }) {}
@@ -80,20 +80,6 @@ function toPlanAgentQueryError(operation: string, cause: unknown): PlanAgentQuer
   return new PlanAgentQueryError({ operation, cause })
 }
 
-function queryEffect<A>(
-  operation: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, PlanAgentQueryError> {
-  return effectTryPromise(thunk, (cause) => toPlanAgentQueryError(operation, cause))
-}
-
-function queryServiceEffect<A, E>(
-  operation: string,
-  effect: Effect.Effect<A, E>,
-): Effect.Effect<A, PlanAgentQueryError> {
-  return effect.pipe(Effect.mapError((cause) => toPlanAgentQueryError(operation, cause)))
-}
-
 interface PlanAgentQueryDeps {
   agentConfig: ResolvedAgentConfig
   db: SurrealDBService
@@ -110,15 +96,15 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
     }
 
     const whereOrganization = organizationId ? ' AND organizationId = $organizationId' : ''
-    return queryEffect('list-active-runs', () =>
-      db.queryMany(
+    return db
+      .queryMany(
         new BoundQuery(
           `SELECT * FROM ${TABLES.PLAN_RUN} WHERE status INSIDE $statuses${whereOrganization} ORDER BY updatedAt DESC`,
           bindings,
         ),
         PlanRunSchema,
-      ),
-    )
+      )
+      .pipe(Effect.mapError((cause) => toPlanAgentQueryError('list-active-runs', cause)))
   }
 
   const getActionableNodesForAgentEffect = (params: {
@@ -130,12 +116,18 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
       const actionable: ActionablePlanAgentNode[] = []
 
       for (const run of runs) {
-        const spec = yield* queryServiceEffect('get-plan-spec-by-id', planRunService.getPlanSpecById(run.planSpecId))
+        const spec = yield* planRunService
+          .getPlanSpecById(run.planSpecId)
+          .pipe(Effect.mapError((cause) => toPlanAgentQueryError('get-plan-spec-by-id', cause)))
 
         if (spec.executionMode === 'graph-full') {
           const [nodeSpecs, nodeRuns] = yield* Effect.all([
-            queryServiceEffect('list-node-specs', planRunService.listNodeSpecs(spec.id)),
-            queryServiceEffect('list-node-runs', planRunService.listNodeRuns(run.id)),
+            planRunService
+              .listNodeSpecs(spec.id)
+              .pipe(Effect.mapError((cause) => toPlanAgentQueryError('list-node-specs', cause))),
+            planRunService
+              .listNodeRuns(run.id)
+              .pipe(Effect.mapError((cause) => toPlanAgentQueryError('list-node-runs', cause))),
           ])
           for (const nodeRun of nodeRuns) {
             if (!ACTIONABLE_NODE_STATUSES.has(nodeRun.status)) continue
@@ -163,8 +155,12 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
         }
 
         const [nodeSpec, nodeRun] = yield* Effect.all([
-          queryServiceEffect('get-node-spec-by-node-id', planRunService.getNodeSpecByNodeId(spec.id, currentNodeId)),
-          queryServiceEffect('get-node-run-by-node-id', planRunService.getNodeRunByNodeId(run.id, currentNodeId)),
+          planRunService
+            .getNodeSpecByNodeId(spec.id, currentNodeId)
+            .pipe(Effect.mapError((cause) => toPlanAgentQueryError('get-node-spec-by-node-id', cause))),
+          planRunService
+            .getNodeRunByNodeId(run.id, currentNodeId)
+            .pipe(Effect.mapError((cause) => toPlanAgentQueryError('get-node-run-by-node-id', cause))),
         ])
         if (!ACTIONABLE_NODE_STATUSES.has(nodeRun.status)) {
           continue
@@ -202,10 +198,16 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
       const matches: ApproachingDeadlineNode[] = []
 
       for (const run of runs) {
-        const spec = yield* queryServiceEffect('get-plan-spec-by-id', planRunService.getPlanSpecById(run.planSpecId))
+        const spec = yield* planRunService
+          .getPlanSpecById(run.planSpecId)
+          .pipe(Effect.mapError((cause) => toPlanAgentQueryError('get-plan-spec-by-id', cause)))
         const [nodeSpecs, nodeRuns] = yield* Effect.all([
-          queryServiceEffect('list-node-specs', planRunService.listNodeSpecs(spec.id)),
-          queryServiceEffect('list-node-runs', planRunService.listNodeRuns(run.id)),
+          planRunService
+            .listNodeSpecs(spec.id)
+            .pipe(Effect.mapError((cause) => toPlanAgentQueryError('list-node-specs', cause))),
+          planRunService
+            .listNodeRuns(run.id)
+            .pipe(Effect.mapError((cause) => toPlanAgentQueryError('list-node-runs', cause))),
         ])
         const nodeRunsById = new Map(nodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
 
@@ -257,10 +259,16 @@ export function makePlanAgentQueryService(deps: PlanAgentQueryDeps) {
       const matches: RecentlyUnblockedNode[] = []
 
       for (const run of runs) {
-        const spec = yield* queryServiceEffect('get-plan-spec-by-id', planRunService.getPlanSpecById(run.planSpecId))
+        const spec = yield* planRunService
+          .getPlanSpecById(run.planSpecId)
+          .pipe(Effect.mapError((cause) => toPlanAgentQueryError('get-plan-spec-by-id', cause)))
         const [nodeSpecs, events] = yield* Effect.all([
-          queryServiceEffect('list-node-specs', planRunService.listNodeSpecs(spec.id)),
-          queryServiceEffect('list-events', planRunService.listEvents(run.id, 200)),
+          planRunService
+            .listNodeSpecs(spec.id)
+            .pipe(Effect.mapError((cause) => toPlanAgentQueryError('list-node-specs', cause))),
+          planRunService
+            .listEvents(run.id, 200)
+            .pipe(Effect.mapError((cause) => toPlanAgentQueryError('list-events', cause))),
         ])
         const nodeSpecsById = new Map(nodeSpecs.map((nodeSpec) => [nodeSpec.nodeId, nodeSpec]))
 

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

@@ -6,7 +6,6 @@ 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 { nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
 import type { makeFeedbackLoopService } from '../feedback-loop.service'
 import type { makeInstitutionalMemoryService } from '../institutional-memory.service'
@@ -29,21 +28,10 @@ interface PlanCompletionSideEffectsDeps {
 }
 
 class PlanCompletionSideEffectsError extends Schema.TaggedErrorClass<PlanCompletionSideEffectsError>()(
-  'PlanCompletionSideEffectsError',
+  '@lota-sdk/core/PlanCompletionSideEffectsError',
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
-const effectTryPlanCompletionPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new PlanCompletionSideEffectsError({ message, cause }),
-)
-
-function tryPlanCompletionPromise<A>(
-  message: string,
-  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, PlanCompletionSideEffectsError> {
-  return effectTryPlanCompletionPromise(evaluate, message)
-}
-
 export function makePlanCompletionSideEffects({
   databaseService,
   feedbackLoopService,
@@ -107,8 +95,8 @@ export function makePlanCompletionSideEffects({
       if (recommendations.length > 0) {
         const run = yield* planRunService.getRunById(params.runId)
         const specRecord = yield* planRunService.getPlanSpecById(run.planSpecId)
-        const event = yield* tryPlanCompletionPromise('Failed to create feedback analyzed plan event.', () =>
-          databaseService.create(
+        const event = yield* databaseService
+          .create(
             TABLES.PLAN_EVENT,
             {
               planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
@@ -119,8 +107,16 @@ export function makePlanCompletionSideEffects({
               emittedBy: 'system',
             },
             PlanEventSchema,
-          ),
-        )
+          )
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new PlanCompletionSideEffectsError({
+                  message: 'Failed to create feedback analyzed plan event.',
+                  cause,
+                }),
+            ),
+          )
         yield* planEventDeliveryService
           .dispatchEvent(event)
           .pipe(

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

@@ -4,6 +4,7 @@ import { Context, Schema, Effect, Layer } from 'effect'
 import { serverLogger } from '../../config/logger'
 import { recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
+import { ERROR_TAGS } from '../../effect/errors'
 import { nowEpochMillis } from '../../utils/date-time'
 import type { makePlanRunService } from './plan-run.service'
 import { PlanRunServiceTag } from './plan-run.service'
@@ -15,7 +16,7 @@ export interface DependencyResolutionResult {
   notifications: Array<{ dependency: PlanDependency; reason: string }>
 }
 
-class PlanCoordinationError extends Schema.TaggedErrorClass<PlanCoordinationError>()('PlanCoordinationError', {
+class PlanCoordinationError extends Schema.TaggedErrorClass<PlanCoordinationError>()(ERROR_TAGS.PlanCoordinationError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}