@lota-sdk/core 0.4.9 → 0.4.10

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

@@ -6,6 +6,7 @@ import type {
 } from '@lota-sdk/shared'
 import { PlanNodeAttemptSchema, PlanNodeRunSchema } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
+import type { z } from 'zod'
 
 import { aiLogger } from '../../config/logger'
 import type { RecordIdInput } from '../../db/record-id'
@@ -20,6 +21,7 @@ import { GeneratedDocumentStorageServiceTag } from '../../storage/generated-docu
 import { nowDate } from '../../utils/date-time'
 import { toError } from '../../utils/errors'
 import { ArtifactServiceTag } from '../artifact.service'
+import { BackgroundWorkService } from '../background-work.service'
 import { FeedbackLoopServiceTag } from '../feedback-loop.service'
 import { InstitutionalMemoryServiceTag } from '../institutional-memory.service'
 import { QualityMetricsServiceTag } from '../quality-metrics.service'
@@ -97,6 +99,17 @@ function fromPromise<A>(thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>)
   )
 }
 
+function parseRowOrFail<T>(
+  schema: z.ZodType<T>,
+  value: unknown,
+  operation: string,
+): Effect.Effect<T, PlanExecutorInternalError> {
+  return Effect.try({
+    try: () => schema.parse(value),
+    catch: (cause) => new PlanExecutorInternalError({ message: `Failed to parse ${operation} row`, cause }),
+  })
+}
+
 function withDatabaseTransactionEffect<A, E, R>(
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>,
   run: (tx: DatabaseTransaction) => Effect.Effect<A, E, R>,
@@ -310,7 +323,7 @@ function persistNodeResultAttemptEffect(
       issues: [...submission.validation.blocking, ...submission.validation.warnings],
     })
 
-    void (yield* fromPromise(() =>
+    const updatedAttemptRow = yield* fromPromise(() =>
       tx
         .update(ensureRecordId(attempt.id, TABLES.PLAN_NODE_ATTEMPT))
         .content({
@@ -327,7 +340,8 @@ function persistNodeResultAttemptEffect(
           ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
         })
         .output('after'),
-    ).pipe(Effect.map((row) => PlanNodeAttemptSchema.parse(row))))
+    )
+    void (yield* parseRowOrFail(PlanNodeAttemptSchema, updatedAttemptRow, 'plan node attempt'))
 
     const publishedArtifacts =
       submission.validation.blocking.length > 0
@@ -351,21 +365,20 @@ function persistNodeResultAttemptEffect(
       artifacts: publishedArtifacts,
     })
 
-    const nextNodeRun = PlanNodeRunSchema.parse(
-      yield* fromPromise(() =>
-        tx
-          .update(ensureRecordId(submission.nodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(submission.nodeRun, {
-              attemptCount: submission.nodeRun.attemptCount + 1,
-              latestAttemptId: attempt.id,
-              latestStructuredOutput: result.structuredOutput ?? null,
-              latestNotes: result.notes,
-            }),
-          )
-          .output('after'),
-      ),
+    const nextNodeRunRow = yield* fromPromise(() =>
+      tx
+        .update(ensureRecordId(submission.nodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(
+          toNodeRunData(submission.nodeRun, {
+            attemptCount: submission.nodeRun.attemptCount + 1,
+            latestAttemptId: attempt.id,
+            latestStructuredOutput: result.structuredOutput ?? null,
+            latestNotes: result.notes,
+          }),
+        )
+        .output('after'),
     )
+    const nextNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, nextNodeRunRow, 'plan node run')
 
     const nodeRuns = yield* context.planRunService.listNodeRuns(submission.run.id)
 
@@ -391,24 +404,23 @@ function handleRetryNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy } = params
 
   return Effect.gen(function* () {
-    const retryNodeRun = PlanNodeRunSchema.parse(
-      yield* fromPromise(() =>
-        tx
-          .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(persisted.nextNodeRun, {
-              status: 'ready',
-              retryCount: persisted.nextNodeRun.retryCount + 1,
-              failureClass: submission.validation.failureClass,
-              blockedReason: submission.validation.blocking[0]?.message ?? null,
-              readyAt: nowDate(),
-              startedAt: null,
-              completedAt: null,
-            }),
-          )
-          .output('after'),
-      ),
+    const retryNodeRunRow = yield* fromPromise(() =>
+      tx
+        .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(
+          toNodeRunData(persisted.nextNodeRun, {
+            status: 'ready',
+            retryCount: persisted.nextNodeRun.retryCount + 1,
+            failureClass: submission.validation.failureClass,
+            blockedReason: submission.validation.blocking[0]?.message ?? null,
+            readyAt: nowDate(),
+            startedAt: null,
+            completedAt: null,
+          }),
+        )
+        .output('after'),
     )
+    const retryNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, retryNodeRunRow, 'plan node run')
 
     yield* emitEvent({
       tx,
@@ -477,22 +489,21 @@ function handleHumanReviewNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy } = params
 
   return Effect.gen(function* () {
-    const awaitingHumanNodeRun = PlanNodeRunSchema.parse(
-      yield* fromPromise(() =>
-        tx
-          .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(persisted.nextNodeRun, {
-              status: 'awaiting-human',
-              retryCount: persisted.nextNodeRun.retryCount + 1,
-              failureClass: submission.validation.failureClass,
-              blockedReason: submission.validation.blocking[0]?.message ?? null,
-              startedAt: persisted.nextNodeRun.startedAt ?? nowDate(),
-            }),
-          )
-          .output('after'),
-      ),
+    const awaitingHumanNodeRunRow = yield* fromPromise(() =>
+      tx
+        .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(
+          toNodeRunData(persisted.nextNodeRun, {
+            status: 'awaiting-human',
+            retryCount: persisted.nextNodeRun.retryCount + 1,
+            failureClass: submission.validation.failureClass,
+            blockedReason: submission.validation.blocking[0]?.message ?? null,
+            startedAt: persisted.nextNodeRun.startedAt ?? nowDate(),
+          }),
+        )
+        .output('after'),
     )
+    const awaitingHumanNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, awaitingHumanNodeRunRow, 'plan node run')
 
     const approval = yield* context.planApprovalService
       .createPendingApproval({
@@ -561,21 +572,20 @@ function handleReplanNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy } = params
 
   return Effect.gen(function* () {
-    const blockedNodeRun = PlanNodeRunSchema.parse(
-      yield* fromPromise(() =>
-        tx
-          .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(persisted.nextNodeRun, {
-              status: 'blocked',
-              retryCount: persisted.nextNodeRun.retryCount + 1,
-              failureClass: submission.validation.failureClass,
-              blockedReason: submission.validation.blocking[0]?.message ?? null,
-            }),
-          )
-          .output('after'),
-      ),
+    const blockedNodeRunRow = yield* fromPromise(() =>
+      tx
+        .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(
+          toNodeRunData(persisted.nextNodeRun, {
+            status: 'blocked',
+            retryCount: persisted.nextNodeRun.retryCount + 1,
+            failureClass: submission.validation.failureClass,
+            blockedReason: submission.validation.blocking[0]?.message ?? null,
+          }),
+        )
+        .output('after'),
     )
+    const blockedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, blockedNodeRunRow, 'plan node run')
 
     const blockedRun = yield* replaceRun(tx, submission.run, {
       status: 'blocked',
@@ -629,22 +639,21 @@ function handleFailedNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy } = params
 
   return Effect.gen(function* () {
-    const failedNodeRun = PlanNodeRunSchema.parse(
-      yield* fromPromise(() =>
-        tx
-          .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(persisted.nextNodeRun, {
-              status: 'failed',
-              retryCount: persisted.nextNodeRun.retryCount + 1,
-              failureClass: submission.validation.failureClass,
-              blockedReason: submission.validation.blocking[0]?.message ?? null,
-              completedAt: nowDate(),
-            }),
-          )
-          .output('after'),
-      ),
+    const failedNodeRunRow = yield* fromPromise(() =>
+      tx
+        .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(
+          toNodeRunData(persisted.nextNodeRun, {
+            status: 'failed',
+            retryCount: persisted.nextNodeRun.retryCount + 1,
+            failureClass: submission.validation.failureClass,
+            blockedReason: submission.validation.blocking[0]?.message ?? null,
+            completedAt: nowDate(),
+          }),
+        )
+        .output('after'),
     )
+    const failedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, failedNodeRunRow, 'plan node run')
 
     const failedRun = yield* replaceRun(tx, submission.run, {
       status: 'failed',
@@ -735,24 +744,23 @@ function handleSuccessfulNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy, result } = params
 
   return Effect.gen(function* () {
-    const completedNodeRun = PlanNodeRunSchema.parse(
-      yield* fromPromise(() =>
-        tx
-          .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(persisted.nextNodeRun, {
-              status: submission.validation.warnings.length > 0 ? 'partial' : 'completed',
-              latestAttemptId: persisted.attemptId,
-              latestStructuredOutput: result.structuredOutput ?? null,
-              latestNotes: result.notes,
-              blockedReason: null,
-              failureClass: null,
-              completedAt: nowDate(),
-            }),
-          )
-          .output('after'),
-      ),
+    const completedNodeRunRow = yield* fromPromise(() =>
+      tx
+        .update(ensureRecordId(persisted.nextNodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(
+          toNodeRunData(persisted.nextNodeRun, {
+            status: submission.validation.warnings.length > 0 ? 'partial' : 'completed',
+            latestAttemptId: persisted.attemptId,
+            latestStructuredOutput: result.structuredOutput ?? null,
+            latestNotes: result.notes,
+            blockedReason: null,
+            failureClass: null,
+            completedAt: nowDate(),
+          }),
+        )
+        .output('after'),
     )
+    const completedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, completedNodeRunRow, 'plan node run')
 
     yield* emitEvent({
       tx,
@@ -949,7 +957,7 @@ function persistHumanNodeResponseAttemptEffect(
       issues: [...submission.validation.blocking, ...submission.validation.warnings],
     })
 
-    void (yield* fromPromise(() =>
+    const updatedHumanAttemptRow = yield* fromPromise(() =>
       tx
         .update(ensureRecordId(attempt.id, TABLES.PLAN_NODE_ATTEMPT))
         .content({
@@ -966,27 +974,27 @@ function persistHumanNodeResponseAttemptEffect(
           ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
         })
         .output('after'),
-    ).pipe(Effect.map((row) => PlanNodeAttemptSchema.parse(row))))
+    )
+    void (yield* parseRowOrFail(PlanNodeAttemptSchema, updatedHumanAttemptRow, 'plan node attempt'))
 
-    const nextNodeRun = PlanNodeRunSchema.parse(
-      yield* fromPromise(() =>
-        tx
-          .update(ensureRecordId(submission.nodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(submission.nodeRun, {
-              status: submission.validation.blocking.length > 0 ? 'blocked' : 'completed',
-              attemptCount: submission.nodeRun.attemptCount + 1,
-              latestAttemptId: attempt.id,
-              latestStructuredOutput: response,
-              latestNotes: submission.responseComments ?? null,
-              blockedReason: submission.validation.blocking[0]?.message ?? null,
-              failureClass: submission.validation.blocking.length > 0 ? submission.validation.failureClass : null,
-              ...(submission.validation.blocking.length > 0 ? {} : { completedAt: nowDate() }),
-            }),
-          )
-          .output('after'),
-      ),
+    const nextNodeRunRow = yield* fromPromise(() =>
+      tx
+        .update(ensureRecordId(submission.nodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(
+          toNodeRunData(submission.nodeRun, {
+            status: submission.validation.blocking.length > 0 ? 'blocked' : 'completed',
+            attemptCount: submission.nodeRun.attemptCount + 1,
+            latestAttemptId: attempt.id,
+            latestStructuredOutput: response,
+            latestNotes: submission.responseComments ?? null,
+            blockedReason: submission.validation.blocking[0]?.message ?? null,
+            failureClass: submission.validation.blocking.length > 0 ? submission.validation.failureClass : null,
+            ...(submission.validation.blocking.length > 0 ? {} : { completedAt: nowDate() }),
+          }),
+        )
+        .output('after'),
     )
+    const nextNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, nextNodeRunRow, 'plan node run')
 
     const nodeRuns = replaceNodeRunInList(yield* context.planRunService.listNodeRuns(submission.run.id), nextNodeRun)
 
@@ -1105,8 +1113,7 @@ function handleAcceptedHumanNodeResponseEffect(
   })
 }
 
-/** @lintignore */
-function submitNodeResult(
+const submitNodeResultEffect = Effect.fn('PlanExecutor.submitNodeResult')(function* (
   context: PlanExecutorContext,
   params: {
     threadId: RecordIdInput
@@ -1115,7 +1122,7 @@ function submitNodeResult(
     emittedBy: string
     result: PlanNodeResultSubmission
   },
-): Promise<ExecutionPlanToolResultData> {
+) {
   const {
     databaseService,
     generatedDocumentStorageService,
@@ -1124,55 +1131,58 @@ function submitNodeResult(
     planRunService,
   } = context
 
-  return Effect.gen(function* () {
-    const submission = yield* loadNodeResultSubmissionContextEffect(context, params)
-    const publishedArtifactStorageKeys: string[] = []
-
-    yield* withTransactionAndEventsEffect({
-      db: databaseService,
-      planEventDeliveryService,
-      run: (tx, emittedEvents) =>
-        Effect.gen(function* () {
-          const persisted = yield* persistNodeResultAttemptEffect(context, {
-            tx,
-            submission,
-            nodeId: params.nodeId,
-            emittedBy: params.emittedBy,
-            result: params.result,
-            publishedArtifactStorageKeys,
-          })
+  const submission = yield* loadNodeResultSubmissionContextEffect(context, params)
+  const publishedArtifactStorageKeys: string[] = []
 
-          if (submission.validation.blocking.length > 0) {
-            return yield* handleBlockedNodeResultEffect(context, {
-              tx,
-              emittedEvents,
-              submission,
-              persisted,
-              emittedBy: params.emittedBy,
-            })
-          }
-
-          return yield* handleSuccessfulNodeResultEffect(context, {
+  yield* withTransactionAndEventsEffect({
+    db: databaseService,
+    planEventDeliveryService,
+    run: (tx, emittedEvents) =>
+      Effect.gen(function* () {
+        const persisted = yield* persistNodeResultAttemptEffect(context, {
+          tx,
+          submission,
+          nodeId: params.nodeId,
+          emittedBy: params.emittedBy,
+          result: params.result,
+          publishedArtifactStorageKeys,
+        })
+
+        if (submission.validation.blocking.length > 0) {
+          return yield* handleBlockedNodeResultEffect(context, {
             tx,
             emittedEvents,
             submission,
             persisted,
             emittedBy: params.emittedBy,
-            result: params.result,
           })
-        }),
-    }).pipe(
-      Effect.tapError(() =>
-        Effect.forEach(publishedArtifactStorageKeys, (storageKey) =>
-          generatedDocumentStorageService.deleteTextArtifact(storageKey).pipe(Effect.ignore),
-        ).pipe(Effect.asVoid),
-      ),
-    )
+        }
 
-    const orgId = recordIdToString(submission.run.organizationId, TABLES.ORGANIZATION)
-    const runIdStr = recordIdToString(submission.run.id, TABLES.PLAN_RUN)
+        return yield* handleSuccessfulNodeResultEffect(context, {
+          tx,
+          emittedEvents,
+          submission,
+          persisted,
+          emittedBy: params.emittedBy,
+          result: params.result,
+        })
+      }),
+  }).pipe(
+    Effect.withSpan('PlanExecutor.submitNodeResult.persistTransaction'),
+    Effect.tapError(() =>
+      Effect.forEach(publishedArtifactStorageKeys, (storageKey) =>
+        generatedDocumentStorageService.deleteTextArtifact(storageKey).pipe(Effect.ignore),
+      ).pipe(Effect.asVoid),
+    ),
+  )
 
-    yield* fromPromise(() =>
+  const orgId = recordIdToString(submission.run.organizationId, TABLES.ORGANIZATION)
+  const runIdStr = recordIdToString(submission.run.id, TABLES.PLAN_RUN)
+
+  const background = yield* BackgroundWorkService
+
+  yield* background.run(
+    fromPromise(() =>
       planCompletionSideEffects.runPlanNodeCompletionSideEffects({
         runId: runIdStr,
         organizationId: orgId,
@@ -1192,31 +1202,50 @@ function submitNodeResult(
           aiLogger.warn`Failed to record node completion metrics for run ${runIdStr} node ${params.nodeId}: ${error.message}`
         }),
       ),
-      Effect.forkDetach,
-    )
+    ),
+    'plan-executor.recordNodeCompletionMetrics',
+  )
 
-    const updatedRun = yield* planRunService.getRunById(submission.run.id)
-    if (updatedRun.status === 'completed') {
-      yield* fromPromise(() =>
+  const updatedRun = yield* planRunService.getRunById(submission.run.id)
+  if (updatedRun.status === 'completed') {
+    yield* background.run(
+      fromPromise(() =>
         planCompletionSideEffects.runPlanCompletionSideEffectsSafely({ runId: runIdStr, organizationId: orgId }),
       ).pipe(
-        Effect.catchTag('PlanExecutorInternalError', () => Effect.void),
-        Effect.forkDetach,
-      )
-    }
+        Effect.catchTag('PlanExecutorInternalError', (error) =>
+          Effect.sync(() => {
+            aiLogger.warn`Plan completion side-effects failed for run ${runIdStr}: ${error.message}`
+          }),
+        ),
+      ),
+      'plan-executor.runPlanCompletionSideEffects',
+    )
+  }
 
-    const snapshot = yield* serializeRunFull(planRunService, updatedRun)
+  const snapshot = yield* serializeRunFull(planRunService, updatedRun)
 
-    return buildExecutionPlanToolResult({
-      action: 'node-result-submitted',
-      plan: snapshot,
-      message: `Submitted result for node "${submission.nodeSpec.label}".`,
-    })
-  }).pipe(runPromise)
-}
+  return buildExecutionPlanToolResult({
+    action: 'node-result-submitted',
+    plan: snapshot,
+    message: `Submitted result for node "${submission.nodeSpec.label}".`,
+  })
+})
 
 /** @lintignore */
-function submitHumanNodeResponse(
+function submitNodeResult(
+  context: PlanExecutorContext,
+  params: {
+    threadId: RecordIdInput
+    runId: string
+    nodeId: string
+    emittedBy: string
+    result: PlanNodeResultSubmission
+  },
+): Promise<ExecutionPlanToolResultData> {
+  return submitNodeResultEffect(context, params).pipe(runPromise)
+}
+
+const submitHumanNodeResponseEffect = Effect.fn('PlanExecutor.submitHumanNodeResponse')(function* (
   context: PlanExecutorContext,
   params: {
     threadId: RecordIdInput
@@ -1225,192 +1254,302 @@ function submitHumanNodeResponse(
     response: HumanNodeResponsePayload
     approvalMessageId?: string
   },
-): Promise<SerializableExecutionPlan | null> {
+) {
   const { databaseService, planEventDeliveryService } = context
 
-  return Effect.gen(function* () {
-    const submission = yield* loadHumanNodeResponseContextEffect(context, params)
-    if (!submission) {
-      return null
-    }
+  const submission = yield* loadHumanNodeResponseContextEffect(context, params)
+  if (!submission) {
+    return null
+  }
 
-    return yield* withTransactionAndEventsEffect({
-      db: databaseService,
-      planEventDeliveryService,
-      run: (tx, emittedEvents) =>
-        Effect.gen(function* () {
-          const persisted = yield* persistHumanNodeResponseAttemptEffect(context, {
-            tx,
-            submission,
-            respondedBy: params.respondedBy,
-            approvalMessageId: params.approvalMessageId,
-            response: params.response,
-          })
+  return yield* withTransactionAndEventsEffect({
+    db: databaseService,
+    planEventDeliveryService,
+    run: (tx, emittedEvents) =>
+      Effect.gen(function* () {
+        const persisted = yield* persistHumanNodeResponseAttemptEffect(context, {
+          tx,
+          submission,
+          respondedBy: params.respondedBy,
+          approvalMessageId: params.approvalMessageId,
+          response: params.response,
+        })
 
-          if (submission.validation.blocking.length > 0) {
-            return yield* handleBlockedHumanNodeResponseEffect(context, {
-              tx,
-              emittedEvents,
-              submission,
-              persisted,
-              respondedBy: params.respondedBy,
-            })
-          }
-
-          return yield* handleAcceptedHumanNodeResponseEffect(context, {
+        if (submission.validation.blocking.length > 0) {
+          return yield* handleBlockedHumanNodeResponseEffect(context, {
             tx,
             emittedEvents,
             submission,
             persisted,
             respondedBy: params.respondedBy,
           })
-        }),
-    })
-  }).pipe(runPromise)
-}
+        }
+
+        return yield* handleAcceptedHumanNodeResponseEffect(context, {
+          tx,
+          emittedEvents,
+          submission,
+          persisted,
+          respondedBy: params.respondedBy,
+        })
+      }),
+  }).pipe(Effect.withSpan('PlanExecutor.submitHumanNodeResponse.persistTransaction'))
+})
 
 /** @lintignore */
-function resumeRun(
+function submitHumanNodeResponse(
+  context: PlanExecutorContext,
+  params: {
+    threadId: RecordIdInput
+    approvalId?: string
+    respondedBy: string
+    response: HumanNodeResponsePayload
+    approvalMessageId?: string
+  },
+): Promise<SerializableExecutionPlan | null> {
+  return submitHumanNodeResponseEffect(context, params).pipe(runPromise)
+}
+
+const resumeRunEffect = Effect.fn('PlanExecutor.resumeRun')(function* (
   context: PlanExecutorContext,
   params: { threadId: RecordIdInput; runId: string; emittedBy: string },
-): Promise<ExecutionPlanToolResultData> {
+) {
   const { databaseService, planEventDeliveryService, planRunService } = context
 
-  return Effect.gen(function* () {
-    const run = yield* planRunService.getRunById(params.runId)
-    const spec = yield* planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = yield* planRunService.listNodeSpecs(spec.id)
-    const nodeRuns = yield* planRunService.listNodeRuns(run.id)
-    const artifacts = yield* planRunService.listArtifacts(run.id)
-    const latestCheckpoint = yield* planRunService.getLatestCheckpoint(run.id)
-    const nextCheckpointSequence = yield* planRunService.getNextCheckpointSequence(run.id)
-
-    const snapshot = yield* withTransactionAndEventsEffect({
-      db: databaseService,
-      planEventDeliveryService,
-      run: (tx, emittedEvents) =>
-        Effect.gen(function* () {
-          let currentNodeRuns = [...nodeRuns]
-          for (const currentNodeRun of currentNodeRuns.filter((candidate) => candidate.status === 'running')) {
-            const resetNodeRun = PlanNodeRunSchema.parse(
-              yield* fromPromise(() =>
-                tx
-                  .update(ensureRecordId(currentNodeRun.id, TABLES.PLAN_NODE_RUN))
-                  .content(
-                    toNodeRunData(currentNodeRun, {
-                      status: 'ready',
-                      readyAt: nowDate(),
-                      startedAt: currentNodeRun.startedAt ?? nowDate(),
-                    }),
-                  )
-                  .output('after'),
-              ),
-            )
-            currentNodeRuns = currentNodeRuns.map((candidate) =>
-              candidate.nodeId === resetNodeRun.nodeId ? resetNodeRun : candidate,
-            )
-          }
-
-          const resetRun = yield* replaceRun(tx, run, {
-            status: run.status === 'awaiting-human' ? 'awaiting-human' : 'running',
-            currentNodeId: run.status === 'awaiting-human' ? (run.currentNodeId ?? null) : null,
-            waitingNodeId: run.status === 'awaiting-human' ? (run.waitingNodeId ?? null) : null,
-            readyNodeIds: currentNodeRuns
-              .filter((candidate) => candidate.status === 'ready')
-              .map((candidate) => candidate.nodeId),
-          })
+  const run = yield* planRunService.getRunById(params.runId)
+  const spec = yield* planRunService.getPlanSpecById(run.planSpecId)
+  const [nodeSpecs, nodeRuns, artifacts, latestCheckpoint, nextCheckpointSequence] = yield* Effect.all([
+    planRunService.listNodeSpecs(spec.id),
+    planRunService.listNodeRuns(run.id),
+    planRunService.listArtifacts(run.id),
+    planRunService.getLatestCheckpoint(run.id),
+    planRunService.getNextCheckpointSequence(run.id),
+  ]).pipe(Effect.withSpan('PlanExecutor.resumeRun.loadRunGraph'))
+
+  const snapshot = yield* withTransactionAndEventsEffect({
+    db: databaseService,
+    planEventDeliveryService,
+    run: (tx, emittedEvents) =>
+      Effect.gen(function* () {
+        let currentNodeRuns = [...nodeRuns]
+        for (const currentNodeRun of currentNodeRuns.filter((candidate) => candidate.status === 'running')) {
+          const resetNodeRunRow = yield* fromPromise(() =>
+            tx
+              .update(ensureRecordId(currentNodeRun.id, TABLES.PLAN_NODE_RUN))
+              .content(
+                toNodeRunData(currentNodeRun, {
+                  status: 'ready',
+                  readyAt: nowDate(),
+                  startedAt: currentNodeRun.startedAt ?? nowDate(),
+                }),
+              )
+              .output('after'),
+          )
+          const resetNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, resetNodeRunRow, 'plan node run')
+          currentNodeRuns = currentNodeRuns.map((candidate) =>
+            candidate.nodeId === resetNodeRun.nodeId ? resetNodeRun : candidate,
+          )
+        }
+
+        const resetRun = yield* replaceRun(tx, run, {
+          status: run.status === 'awaiting-human' ? 'awaiting-human' : 'running',
+          currentNodeId: run.status === 'awaiting-human' ? (run.currentNodeId ?? null) : null,
+          waitingNodeId: run.status === 'awaiting-human' ? (run.waitingNodeId ?? null) : null,
+          readyNodeIds: currentNodeRuns
+            .filter((candidate) => candidate.status === 'ready')
+            .map((candidate) => candidate.nodeId),
+        })
 
-          yield* emitEvent({
-            tx,
-            run: resetRun,
-            spec,
-            eventType: 'run-resumed',
-            fromStatus: run.status,
-            toStatus: resetRun.status,
-            message: `Run "${spec.title}" resumed from the latest checkpoint.`,
-            detail: latestCheckpoint
-              ? { checkpointId: recordIdToString(latestCheckpoint.id, TABLES.PLAN_CHECKPOINT) }
-              : {},
-            emittedBy: params.emittedBy,
-            capturedEvents: emittedEvents,
-          })
+        yield* emitEvent({
+          tx,
+          run: resetRun,
+          spec,
+          eventType: 'run-resumed',
+          fromStatus: run.status,
+          toStatus: resetRun.status,
+          message: `Run "${spec.title}" resumed from the latest checkpoint.`,
+          detail: latestCheckpoint
+            ? { checkpointId: recordIdToString(latestCheckpoint.id, TABLES.PLAN_CHECKPOINT) }
+            : {},
+          emittedBy: params.emittedBy,
+          capturedEvents: emittedEvents,
+        })
 
-          const synced =
-            resetRun.status === 'awaiting-human'
-              ? { run: resetRun, nodeRuns: currentNodeRuns, artifacts }
-              : yield* fromPromise(() =>
-                  syncRunGraph(context, {
-                    tx,
-                    run: resetRun,
-                    spec,
-                    nodeSpecs,
-                    nodeRuns: currentNodeRuns,
-                    artifacts,
-                    emittedBy: params.emittedBy,
-                    capturedEvents: emittedEvents,
-                  }),
-                )
-
-          const checkpoint = yield* saveCheckpointWithContext(context, {
-            tx,
-            run: synced.run,
-            spec,
-            nodeRuns: synced.nodeRuns,
-            artifacts: synced.artifacts,
-            sequence: nextCheckpointSequence,
-            reason: 'run-resumed',
-            capturedEvents: emittedEvents,
-          })
-          yield* attachCheckpoint(tx, synced.run, checkpoint)
-          const latestRun = yield* planRunService.getRunById(run.id)
-          return yield* serializeRunFull(planRunService, latestRun)
-        }),
-    })
+        const synced =
+          resetRun.status === 'awaiting-human'
+            ? { run: resetRun, nodeRuns: currentNodeRuns, artifacts }
+            : yield* fromPromise(() =>
+                syncRunGraph(context, {
+                  tx,
+                  run: resetRun,
+                  spec,
+                  nodeSpecs,
+                  nodeRuns: currentNodeRuns,
+                  artifacts,
+                  emittedBy: params.emittedBy,
+                  capturedEvents: emittedEvents,
+                }),
+              )
+
+        const checkpoint = yield* saveCheckpointWithContext(context, {
+          tx,
+          run: synced.run,
+          spec,
+          nodeRuns: synced.nodeRuns,
+          artifacts: synced.artifacts,
+          sequence: nextCheckpointSequence,
+          reason: 'run-resumed',
+          capturedEvents: emittedEvents,
+        })
+        yield* attachCheckpoint(tx, synced.run, checkpoint)
+        const latestRun = yield* planRunService.getRunById(run.id)
+        return yield* serializeRunFull(planRunService, latestRun)
+      }),
+  }).pipe(Effect.withSpan('PlanExecutor.resumeRun.persistTransaction'))
 
-    return buildExecutionPlanToolResult({
-      action: 'run-resumed',
-      plan: snapshot,
-      message: `Resumed execution run "${snapshot.title}".`,
-    })
-  }).pipe(runPromise)
+  return buildExecutionPlanToolResult({
+    action: 'run-resumed',
+    plan: snapshot,
+    message: `Resumed execution run "${snapshot.title}".`,
+  })
+})
+
+/** @lintignore */
+function resumeRun(
+  context: PlanExecutorContext,
+  params: { threadId: RecordIdInput; runId: string; emittedBy: string },
+): Promise<ExecutionPlanToolResultData> {
+  return resumeRunEffect(context, params).pipe(runPromise)
 }
 
+const transitionNodeToRunningEffect = Effect.fn('PlanExecutor.transitionNodeToRunning')(function* (
+  context: PlanExecutorContext,
+  params: { runId: string; nodeId: string },
+) {
+  const { databaseService, planRunService } = context
+
+  const run = yield* planRunService.getRunById(params.runId)
+  const nodeRun = yield* planRunService.getNodeRunByNodeId(run.id, params.nodeId)
+  if (nodeRun.status !== 'ready') return
+
+  yield* withDatabaseTransactionEffect(databaseService, (tx) =>
+    Effect.gen(function* () {
+      const runningNodeRunRow = yield* fromPromise(() =>
+        tx
+          .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
+          .content(toNodeRunData(nodeRun, { status: 'running', startedAt: nodeRun.startedAt ?? nowDate() }))
+          .output('after'),
+      )
+      const runningNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, runningNodeRunRow, 'plan node run')
+
+      const nodeRuns = yield* planRunService.listNodeRuns(run.id)
+      yield* replaceRun(tx, run, {
+        status: 'running',
+        currentNodeId: runningNodeRun.nodeId,
+        waitingNodeId: null,
+        readyNodeIds: nodeRuns
+          .filter((candidate) => candidate.status === 'ready' && candidate.nodeId !== runningNodeRun.nodeId)
+          .map((candidate) => candidate.nodeId),
+      })
+    }),
+  ).pipe(Effect.withSpan('PlanExecutor.transitionNodeToRunning.persistTransaction'))
+})
+
 /** @lintignore */
 function transitionNodeToRunning(
   context: PlanExecutorContext,
   params: { runId: string; nodeId: string },
 ): Promise<void> {
-  const { databaseService, planRunService } = context
+  return transitionNodeToRunningEffect(context, params).pipe(runPromise)
+}
 
-  return Effect.gen(function* () {
-    const run = yield* planRunService.getRunById(params.runId)
-    const nodeRun = yield* planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-    if (nodeRun.status !== 'ready') return
+const blockNodeOnDispatchFailureEffect = Effect.fn('PlanExecutor.blockNodeOnDispatchFailure')(function* (
+  context: PlanExecutorContext,
+  params: {
+    threadId: RecordIdInput
+    runId: string
+    nodeId: string
+    emittedBy: string
+    message: string
+    failureClass: PlanFailureClass
+  },
+) {
+  const { databaseService, planEventDeliveryService, planRunService } = context
 
-    yield* withDatabaseTransactionEffect(databaseService, (tx) =>
+  const run = yield* planRunService.getRunById(params.runId)
+  const spec = yield* planRunService.getPlanSpecById(run.planSpecId)
+  const [nodeSpec, nodeRun, artifacts, nextCheckpointSequence] = yield* Effect.all([
+    planRunService.getNodeSpecByNodeId(spec.id, params.nodeId),
+    planRunService.getNodeRunByNodeId(run.id, params.nodeId),
+    planRunService.listArtifacts(run.id),
+    planRunService.getNextCheckpointSequence(run.id),
+  ]).pipe(Effect.withSpan('PlanExecutor.blockNodeOnDispatchFailure.loadNodeContext'))
+
+  return yield* withTransactionAndEventsEffect({
+    db: databaseService,
+    planEventDeliveryService,
+    run: (tx, emittedEvents) =>
       Effect.gen(function* () {
-        const runningNodeRun = PlanNodeRunSchema.parse(
-          yield* fromPromise(() =>
+        let blockedNodeRun: PlanNodeRunRecord
+        if (nodeRun.status === 'blocked') {
+          blockedNodeRun = nodeRun
+        } else {
+          const blockedNodeRunRow = yield* fromPromise(() =>
             tx
               .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(toNodeRunData(nodeRun, { status: 'running', startedAt: nodeRun.startedAt ?? nowDate() }))
+              .content(
+                toNodeRunData(nodeRun, {
+                  status: 'blocked',
+                  blockedReason: params.message,
+                  failureClass: params.failureClass,
+                }),
+              )
               .output('after'),
-          ),
-        )
+          )
+          blockedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, blockedNodeRunRow, 'plan node run')
+        }
 
-        const nodeRuns = yield* planRunService.listNodeRuns(run.id)
-        yield* replaceRun(tx, run, {
-          status: 'running',
-          currentNodeId: runningNodeRun.nodeId,
+        const blockedRun = yield* replaceRun(tx, run, {
+          status: 'blocked',
+          currentNodeId: blockedNodeRun.nodeId,
           waitingNodeId: null,
-          readyNodeIds: nodeRuns
-            .filter((candidate) => candidate.status === 'ready' && candidate.nodeId !== runningNodeRun.nodeId)
-            .map((candidate) => candidate.nodeId),
+          readyNodeIds: [],
+          failureCount: run.failureCount + 1,
         })
+
+        yield* emitEvent({
+          tx,
+          run: blockedRun,
+          spec,
+          nodeId: blockedNodeRun.nodeId,
+          eventType: 'node-blocked',
+          fromStatus: nodeRun.status,
+          toStatus: blockedNodeRun.status,
+          message: `Node "${nodeSpec.label}" failed during owner dispatch.`,
+          detail: { failureClass: params.failureClass, phase: 'dispatch', error: params.message },
+          emittedBy: params.emittedBy,
+          capturedEvents: emittedEvents,
+        })
+
+        const checkpointNodeRuns = (yield* planRunService.listNodeRuns(run.id)).map((candidate) =>
+          candidate.nodeId === blockedNodeRun.nodeId ? blockedNodeRun : candidate,
+        )
+        const checkpoint = yield* saveCheckpointWithContext(context, {
+          tx,
+          run: blockedRun,
+          spec,
+          nodeRuns: checkpointNodeRuns,
+          artifacts,
+          sequence: nextCheckpointSequence,
+          reason: 'owner-dispatch-failed',
+          capturedEvents: emittedEvents,
+        })
+        yield* attachCheckpoint(tx, blockedRun, checkpoint)
+        const latestRun = yield* planRunService.getRunById(run.id)
+        return yield* serializeRunFull(planRunService, latestRun)
       }),
-    )
-  }).pipe(runPromise)
-}
+  }).pipe(Effect.withSpan('PlanExecutor.blockNodeOnDispatchFailure.persistTransaction'))
+})
 
 /** @lintignore */
 function blockNodeOnDispatchFailure(
@@ -1424,163 +1563,96 @@ function blockNodeOnDispatchFailure(
     failureClass: PlanFailureClass
   },
 ): Promise<SerializableExecutionPlan> {
-  const { databaseService, planEventDeliveryService, planRunService } = context
-
-  return Effect.gen(function* () {
-    const run = yield* planRunService.getRunById(params.runId)
-    const spec = yield* planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpec = yield* planRunService.getNodeSpecByNodeId(spec.id, params.nodeId)
-    const nodeRun = yield* planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-    const artifacts = yield* planRunService.listArtifacts(run.id)
-    const nextCheckpointSequence = yield* planRunService.getNextCheckpointSequence(run.id)
-
-    return yield* withTransactionAndEventsEffect({
-      db: databaseService,
-      planEventDeliveryService,
-      run: (tx, emittedEvents) =>
-        Effect.gen(function* () {
-          const blockedNodeRun =
-            nodeRun.status === 'blocked'
-              ? nodeRun
-              : PlanNodeRunSchema.parse(
-                  yield* fromPromise(() =>
-                    tx
-                      .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-                      .content(
-                        toNodeRunData(nodeRun, {
-                          status: 'blocked',
-                          blockedReason: params.message,
-                          failureClass: params.failureClass,
-                        }),
-                      )
-                      .output('after'),
-                  ),
-                )
-
-          const blockedRun = yield* replaceRun(tx, run, {
-            status: 'blocked',
-            currentNodeId: blockedNodeRun.nodeId,
-            waitingNodeId: null,
-            readyNodeIds: [],
-            failureCount: run.failureCount + 1,
-          })
-
-          yield* emitEvent({
-            tx,
-            run: blockedRun,
-            spec,
-            nodeId: blockedNodeRun.nodeId,
-            eventType: 'node-blocked',
-            fromStatus: nodeRun.status,
-            toStatus: blockedNodeRun.status,
-            message: `Node "${nodeSpec.label}" failed during owner dispatch.`,
-            detail: { failureClass: params.failureClass, phase: 'dispatch', error: params.message },
-            emittedBy: params.emittedBy,
-            capturedEvents: emittedEvents,
-          })
-
-          const checkpointNodeRuns = (yield* planRunService.listNodeRuns(run.id)).map((candidate) =>
-            candidate.nodeId === blockedNodeRun.nodeId ? blockedNodeRun : candidate,
-          )
-          const checkpoint = yield* saveCheckpointWithContext(context, {
-            tx,
-            run: blockedRun,
-            spec,
-            nodeRuns: checkpointNodeRuns,
-            artifacts,
-            sequence: nextCheckpointSequence,
-            reason: 'owner-dispatch-failed',
-            capturedEvents: emittedEvents,
-          })
-          yield* attachCheckpoint(tx, blockedRun, checkpoint)
-          const latestRun = yield* planRunService.getRunById(run.id)
-          return yield* serializeRunFull(planRunService, latestRun)
-        }),
-    })
-  }).pipe(runPromise)
+  return blockNodeOnDispatchFailureEffect(context, params).pipe(runPromise)
 }
 
-/** @lintignore */
-function promoteDelayedNode(
+const promoteDelayedNodeEffect = Effect.fn('PlanExecutor.promoteDelayedNode')(function* (
   context: PlanExecutorContext,
   params: { runId: string; nodeId: string; emittedBy: string },
-): Promise<void> {
+) {
   const { databaseService, planEventDeliveryService, planRunService } = context
 
-  return Effect.gen(function* () {
-    const run = yield* planRunService.getRunById(params.runId)
-    if (run.status === 'completed' || run.status === 'failed' || run.status === 'aborted') {
-      return
-    }
+  const run = yield* planRunService.getRunById(params.runId)
+  if (run.status === 'completed' || run.status === 'failed' || run.status === 'aborted') {
+    return
+  }
 
-    const spec = yield* planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = yield* planRunService.listNodeSpecs(spec.id)
-    const nodeRun = yield* planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-    if (nodeRun.status !== 'scheduled') return
-
-    const nodeRuns = yield* planRunService.listNodeRuns(run.id)
-    const artifacts = yield* planRunService.listArtifacts(run.id)
-    const nextCheckpointSequence = yield* planRunService.getNextCheckpointSequence(run.id)
-
-    yield* withTransactionAndEventsEffect({
-      db: databaseService,
-      planEventDeliveryService,
-      run: (tx, emittedEvents) =>
-        Effect.gen(function* () {
-          const readyNodeRun = PlanNodeRunSchema.parse(
-            yield* fromPromise(() =>
-              tx
-                .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-                .content(toNodeRunData(nodeRun, { status: 'ready', readyAt: nowDate() }))
-                .output('after'),
-            ),
-          )
+  const spec = yield* planRunService.getPlanSpecById(run.planSpecId)
+  const nodeSpecs = yield* planRunService.listNodeSpecs(spec.id)
+  const nodeRun = yield* planRunService.getNodeRunByNodeId(run.id, params.nodeId)
+  if (nodeRun.status !== 'scheduled') return
 
-          const updatedNodeRuns = nodeRuns.map((candidate) =>
-            candidate.nodeId === readyNodeRun.nodeId ? readyNodeRun : candidate,
-          )
+  const [nodeRuns, artifacts, nextCheckpointSequence] = yield* Effect.all([
+    planRunService.listNodeRuns(run.id),
+    planRunService.listArtifacts(run.id),
+    planRunService.getNextCheckpointSequence(run.id),
+  ]).pipe(Effect.withSpan('PlanExecutor.promoteDelayedNode.loadRunContext'))
 
-          const currentNodeSpec = nodeSpecs.find((s) => s.nodeId === params.nodeId)
-          yield* emitEvent({
+  yield* withTransactionAndEventsEffect({
+    db: databaseService,
+    planEventDeliveryService,
+    run: (tx, emittedEvents) =>
+      Effect.gen(function* () {
+        const readyNodeRunRow = yield* fromPromise(() =>
+          tx
+            .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
+            .content(toNodeRunData(nodeRun, { status: 'ready', readyAt: nowDate() }))
+            .output('after'),
+        )
+        const readyNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, readyNodeRunRow, 'plan node run')
+
+        const updatedNodeRuns = nodeRuns.map((candidate) =>
+          candidate.nodeId === readyNodeRun.nodeId ? readyNodeRun : candidate,
+        )
+
+        const currentNodeSpec = nodeSpecs.find((s) => s.nodeId === params.nodeId)
+        yield* emitEvent({
+          tx,
+          run,
+          spec,
+          nodeId: readyNodeRun.nodeId,
+          eventType: 'node-ready',
+          fromStatus: nodeRun.status,
+          toStatus: readyNodeRun.status,
+          message: `Node "${currentNodeSpec?.label ?? params.nodeId}" promoted to ready after delay.`,
+          emittedBy: params.emittedBy,
+          capturedEvents: emittedEvents,
+        })
+
+        const synced = yield* fromPromise(() =>
+          syncRunGraph(context, {
             tx,
             run,
             spec,
-            nodeId: readyNodeRun.nodeId,
-            eventType: 'node-ready',
-            fromStatus: nodeRun.status,
-            toStatus: readyNodeRun.status,
-            message: `Node "${currentNodeSpec?.label ?? params.nodeId}" promoted to ready after delay.`,
+            nodeSpecs,
+            nodeRuns: updatedNodeRuns,
+            artifacts,
             emittedBy: params.emittedBy,
             capturedEvents: emittedEvents,
-          })
+          }),
+        )
 
-          const synced = yield* fromPromise(() =>
-            syncRunGraph(context, {
-              tx,
-              run,
-              spec,
-              nodeSpecs,
-              nodeRuns: updatedNodeRuns,
-              artifacts,
-              emittedBy: params.emittedBy,
-              capturedEvents: emittedEvents,
-            }),
-          )
+        const checkpoint = yield* saveCheckpointWithContext(context, {
+          tx,
+          run: synced.run,
+          spec,
+          nodeRuns: synced.nodeRuns,
+          artifacts: synced.artifacts,
+          sequence: nextCheckpointSequence,
+          reason: 'delayed-node-promoted',
+          capturedEvents: emittedEvents,
+        })
+        yield* attachCheckpoint(tx, synced.run, checkpoint)
+      }),
+  }).pipe(Effect.withSpan('PlanExecutor.promoteDelayedNode.persistTransaction'))
+})
 
-          const checkpoint = yield* saveCheckpointWithContext(context, {
-            tx,
-            run: synced.run,
-            spec,
-            nodeRuns: synced.nodeRuns,
-            artifacts: synced.artifacts,
-            sequence: nextCheckpointSequence,
-            reason: 'delayed-node-promoted',
-            capturedEvents: emittedEvents,
-          })
-          yield* attachCheckpoint(tx, synced.run, checkpoint)
-        }),
-    })
-  }).pipe(runPromise)
+/** @lintignore */
+function promoteDelayedNode(
+  context: PlanExecutorContext,
+  params: { runId: string; nodeId: string; emittedBy: string },
+): Promise<void> {
+  return promoteDelayedNodeEffect(context, params).pipe(runPromise)
 }
 
 export function makePlanExecutorService(deps: PlanExecutorDeps) {
@@ -1611,14 +1683,25 @@ export function makePlanExecutorService(deps: PlanExecutorDeps) {
 
   return {
     submitNodeResult: (params: Parameters<typeof submitNodeResult>[1]) => submitNodeResult(context, params),
+    submitNodeResultEffect: (params: Parameters<typeof submitNodeResultEffect>[1]) =>
+      submitNodeResultEffect(context, params),
     submitHumanNodeResponse: (params: Parameters<typeof submitHumanNodeResponse>[1]) =>
       submitHumanNodeResponse(context, params),
+    submitHumanNodeResponseEffect: (params: Parameters<typeof submitHumanNodeResponseEffect>[1]) =>
+      submitHumanNodeResponseEffect(context, params),
     resumeRun: (params: Parameters<typeof resumeRun>[1]) => resumeRun(context, params),
+    resumeRunEffect: (params: Parameters<typeof resumeRunEffect>[1]) => resumeRunEffect(context, params),
     transitionNodeToRunning: (params: Parameters<typeof transitionNodeToRunning>[1]) =>
       transitionNodeToRunning(context, params),
+    transitionNodeToRunningEffect: (params: Parameters<typeof transitionNodeToRunningEffect>[1]) =>
+      transitionNodeToRunningEffect(context, params),
     blockNodeOnDispatchFailure: (params: Parameters<typeof blockNodeOnDispatchFailure>[1]) =>
       blockNodeOnDispatchFailure(context, params),
+    blockNodeOnDispatchFailureEffect: (params: Parameters<typeof blockNodeOnDispatchFailureEffect>[1]) =>
+      blockNodeOnDispatchFailureEffect(context, params),
     promoteDelayedNode: (params: Parameters<typeof promoteDelayedNode>[1]) => promoteDelayedNode(context, params),
+    promoteDelayedNodeEffect: (params: Parameters<typeof promoteDelayedNodeEffect>[1]) =>
+      promoteDelayedNodeEffect(context, params),
     syncRunGraph: (params: Parameters<typeof syncRunGraph>[1]) => syncRunGraph(context, params),
     resolveFailureAction,
     buildResolvedInput,
@@ -1626,7 +1709,7 @@ export function makePlanExecutorService(deps: PlanExecutorDeps) {
 }
 
 export class PlanExecutorServiceTag extends Context.Service<PlanExecutorServiceTag, PlanExecutorService>()(
-  'PlanExecutorService',
+  '@lota-sdk/core/PlanExecutorService',
 ) {}
 
 export const PlanExecutorServiceLive = Layer.effect(