@lota-sdk/core 0.4.12 → 0.4.14

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

@@ -8,8 +8,7 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { DatabaseTransaction } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { BadRequestError, NotFoundError } from '../../effect/errors'
-import { effectTryPromise as effectTryPromiseShared } from '../../effect/helpers'
+import { ERROR_TAGS, BadRequestError, NotFoundError } from '../../effect/errors'
 import { DatabaseServiceTag } from '../../effect/services'
 import type { DelayedNodePromotionQueueRuntime } from '../../queues/delayed-node-promotion.queue'
 import { LotaQueuesServiceTag } from '../../queues/queues.service'
@@ -17,7 +16,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 { BackgroundWorkServiceTag } from '../background-work.service'
 import { FeedbackLoopServiceTag } from '../feedback-loop.service'
 import { InstitutionalMemoryServiceTag } from '../institutional-memory.service'
 import { QualityMetricsServiceTag } from '../quality-metrics.service'
@@ -85,15 +84,12 @@ function saveCheckpointWithContext(
 }
 
 class PlanExecutorInternalError extends Schema.TaggedErrorClass<PlanExecutorInternalError>()(
-  'PlanExecutorInternalError',
+  '@lota-sdk/core/PlanExecutorInternalError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 
-function fromPromise<A>(thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>) {
-  return effectTryPromiseShared(
-    thunk,
-    (cause) => new PlanExecutorInternalError({ message: toError(cause).message, cause }),
-  )
+function toPlanExecutorInternalError(cause: unknown): PlanExecutorInternalError {
+  return new PlanExecutorInternalError({ message: toError(cause).message, cause })
 }
 
 function parseRowOrFail<T>(
@@ -320,25 +316,24 @@ function persistNodeResultAttemptEffect(
       issues: [...submission.validation.blocking, ...submission.validation.warnings],
     })
 
-    const updatedAttemptRow = yield* fromPromise(() =>
-      tx
-        .update(ensureRecordId(attempt.id, TABLES.PLAN_NODE_ATTEMPT))
-        .content({
-          runId: ensureRecordId(attempt.runId, TABLES.PLAN_RUN),
-          nodeRunId: ensureRecordId(attempt.nodeRunId, TABLES.PLAN_NODE_RUN),
-          nodeId: attempt.nodeId,
-          emittedBy: attempt.emittedBy,
-          status: attempt.status,
-          ...(attempt.structuredOutput ? { structuredOutput: attempt.structuredOutput } : {}),
-          ...(attempt.notes ? { notes: attempt.notes } : {}),
-          validationIssueIds: issues.map((issue: { id: RecordIdInput }) =>
-            ensureRecordId(issue.id, TABLES.PLAN_VALIDATION_ISSUE),
-          ),
-          ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
-        })
-        .output('after'),
-    )
-    void (yield* parseRowOrFail(PlanNodeAttemptSchema, updatedAttemptRow, 'plan node attempt'))
+    const updatedAttemptRow = yield* tx
+      .update(ensureRecordId(attempt.id, TABLES.PLAN_NODE_ATTEMPT))
+      .content({
+        runId: ensureRecordId(attempt.runId, TABLES.PLAN_RUN),
+        nodeRunId: ensureRecordId(attempt.nodeRunId, TABLES.PLAN_NODE_RUN),
+        nodeId: attempt.nodeId,
+        emittedBy: attempt.emittedBy,
+        status: attempt.status,
+        ...(attempt.structuredOutput ? { structuredOutput: attempt.structuredOutput } : {}),
+        ...(attempt.notes ? { notes: attempt.notes } : {}),
+        validationIssueIds: issues.map((issue: { id: RecordIdInput }) =>
+          ensureRecordId(issue.id, TABLES.PLAN_VALIDATION_ISSUE),
+        ),
+        ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
+      })
+      .output('after')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
+    yield* Effect.asVoid(parseRowOrFail(PlanNodeAttemptSchema, updatedAttemptRow, 'plan node attempt'))
 
     const publishedArtifacts =
       submission.validation.blocking.length > 0
@@ -362,19 +357,18 @@ function persistNodeResultAttemptEffect(
       artifacts: publishedArtifacts,
     })
 
-    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 nextNodeRunRow = yield* 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')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
     const nextNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, nextNodeRunRow, 'plan node run')
 
     const nodeRuns = yield* context.planRunService.listNodeRuns(submission.run.id)
@@ -401,22 +395,21 @@ function handleRetryNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy } = params
 
   return Effect.gen(function* () {
-    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 retryNodeRunRow = yield* 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')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
     const retryNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, retryNodeRunRow, 'plan node run')
 
     yield* emitEvent({
@@ -447,18 +440,16 @@ function handleRetryNodeResultEffect(
       capturedEvents: emittedEvents,
     })
 
-    const synced = yield* fromPromise(() =>
-      syncRunGraph(context, {
-        tx,
-        run: submission.run,
-        spec: submission.spec,
-        nodeSpecs: submission.nodeSpecs,
-        nodeRuns: replaceNodeRunInList(persisted.withUpdatedNodeRuns, retryNodeRun),
-        artifacts: persisted.nextArtifacts,
-        emittedBy,
-        capturedEvents: emittedEvents,
-      }),
-    )
+    const synced = yield* syncRunGraph(context, {
+      tx,
+      run: submission.run,
+      spec: submission.spec,
+      nodeSpecs: submission.nodeSpecs,
+      nodeRuns: replaceNodeRunInList(persisted.withUpdatedNodeRuns, retryNodeRun),
+      artifacts: persisted.nextArtifacts,
+      emittedBy,
+      capturedEvents: emittedEvents,
+    }).pipe(Effect.mapError(toPlanExecutorInternalError))
 
     yield* saveAndAttachCheckpointEffect(context, {
       tx,
@@ -486,20 +477,19 @@ function handleHumanReviewNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy } = params
 
   return Effect.gen(function* () {
-    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 awaitingHumanNodeRunRow = yield* 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')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
     const awaitingHumanNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, awaitingHumanNodeRunRow, 'plan node run')
 
     const approval = yield* context.planApprovalService
@@ -517,7 +507,7 @@ function handleHumanReviewNodeResultEffect(
           validationIssues: submission.validation.blocking,
         },
       })
-      .pipe(Effect.mapError((cause) => new PlanExecutorInternalError({ message: toError(cause).message, cause })))
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
 
     const awaitingHumanRun = yield* replaceRun(tx, submission.run, {
       status: 'awaiting-human',
@@ -569,19 +559,18 @@ function handleReplanNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy } = params
 
   return Effect.gen(function* () {
-    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 blockedNodeRunRow = yield* 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')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
     const blockedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, blockedNodeRunRow, 'plan node run')
 
     const blockedRun = yield* replaceRun(tx, submission.run, {
@@ -636,20 +625,19 @@ function handleFailedNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy } = params
 
   return Effect.gen(function* () {
-    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 failedNodeRunRow = yield* 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')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
     const failedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, failedNodeRunRow, 'plan node run')
 
     const failedRun = yield* replaceRun(tx, submission.run, {
@@ -741,22 +729,21 @@ function handleSuccessfulNodeResultEffect(
   const { tx, emittedEvents, submission, persisted, emittedBy, result } = params
 
   return Effect.gen(function* () {
-    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 completedNodeRunRow = yield* 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')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
     const completedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, completedNodeRunRow, 'plan node run')
 
     yield* emitEvent({
@@ -777,18 +764,16 @@ function handleSuccessfulNodeResultEffect(
       capturedEvents: emittedEvents,
     })
 
-    const synced = yield* fromPromise(() =>
-      syncRunGraph(context, {
-        tx,
-        run: submission.run,
-        spec: submission.spec,
-        nodeSpecs: submission.nodeSpecs,
-        nodeRuns: replaceNodeRunInList(persisted.withUpdatedNodeRuns, completedNodeRun),
-        artifacts: persisted.nextArtifacts,
-        emittedBy,
-        capturedEvents: emittedEvents,
-      }),
-    )
+    const synced = yield* syncRunGraph(context, {
+      tx,
+      run: submission.run,
+      spec: submission.spec,
+      nodeSpecs: submission.nodeSpecs,
+      nodeRuns: replaceNodeRunInList(persisted.withUpdatedNodeRuns, completedNodeRun),
+      artifacts: persisted.nextArtifacts,
+      emittedBy,
+      capturedEvents: emittedEvents,
+    }).pipe(Effect.mapError(toPlanExecutorInternalError))
 
     yield* saveAndAttachCheckpointEffect(context, {
       tx,
@@ -954,43 +939,41 @@ function persistHumanNodeResponseAttemptEffect(
       issues: [...submission.validation.blocking, ...submission.validation.warnings],
     })
 
-    const updatedHumanAttemptRow = yield* fromPromise(() =>
-      tx
-        .update(ensureRecordId(attempt.id, TABLES.PLAN_NODE_ATTEMPT))
-        .content({
-          runId: ensureRecordId(attempt.runId, TABLES.PLAN_RUN),
-          nodeRunId: ensureRecordId(attempt.nodeRunId, TABLES.PLAN_NODE_RUN),
-          nodeId: attempt.nodeId,
-          emittedBy: attempt.emittedBy,
-          status: attempt.status,
-          structuredOutput: response,
-          validationIssueIds: issues.map((issue: { id: RecordIdInput }) =>
-            ensureRecordId(issue.id, TABLES.PLAN_VALIDATION_ISSUE),
-          ),
-          ...(attempt.notes ? { notes: attempt.notes } : {}),
-          ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
-        })
-        .output('after'),
-    )
-    void (yield* parseRowOrFail(PlanNodeAttemptSchema, updatedHumanAttemptRow, 'plan node attempt'))
-
-    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 updatedHumanAttemptRow = yield* tx
+      .update(ensureRecordId(attempt.id, TABLES.PLAN_NODE_ATTEMPT))
+      .content({
+        runId: ensureRecordId(attempt.runId, TABLES.PLAN_RUN),
+        nodeRunId: ensureRecordId(attempt.nodeRunId, TABLES.PLAN_NODE_RUN),
+        nodeId: attempt.nodeId,
+        emittedBy: attempt.emittedBy,
+        status: attempt.status,
+        structuredOutput: response,
+        validationIssueIds: issues.map((issue: { id: RecordIdInput }) =>
+          ensureRecordId(issue.id, TABLES.PLAN_VALIDATION_ISSUE),
+        ),
+        ...(attempt.notes ? { notes: attempt.notes } : {}),
+        ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
+      })
+      .output('after')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
+    yield* Effect.asVoid(parseRowOrFail(PlanNodeAttemptSchema, updatedHumanAttemptRow, 'plan node attempt'))
+
+    const nextNodeRunRow = yield* 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')
+      .pipe(Effect.mapError(toPlanExecutorInternalError))
     const nextNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, nextNodeRunRow, 'plan node run')
 
     const nodeRuns = replaceNodeRunInList(yield* context.planRunService.listNodeRuns(submission.run.id), nextNodeRun)
@@ -1065,18 +1048,16 @@ function handleAcceptedHumanNodeResponseEffect(
   const { tx, emittedEvents, submission, persisted, respondedBy } = params
 
   return Effect.gen(function* () {
-    const synced = yield* fromPromise(() =>
-      syncRunGraph(context, {
-        tx,
-        run: submission.run,
-        spec: submission.spec,
-        nodeSpecs: submission.nodeSpecs,
-        nodeRuns: persisted.nodeRuns,
-        artifacts: submission.existingArtifacts,
-        emittedBy: respondedBy,
-        capturedEvents: emittedEvents,
-      }),
-    )
+    const synced = yield* syncRunGraph(context, {
+      tx,
+      run: submission.run,
+      spec: submission.spec,
+      nodeSpecs: submission.nodeSpecs,
+      nodeRuns: persisted.nodeRuns,
+      artifacts: submission.existingArtifacts,
+      emittedBy: respondedBy,
+      capturedEvents: emittedEvents,
+    }).pipe(Effect.mapError(toPlanExecutorInternalError))
 
     yield* emitEvent({
       tx,
@@ -1176,11 +1157,11 @@ const submitNodeResult = Effect.fn('PlanExecutor.submitNodeResult')(function* (
   const orgId = recordIdToString(submission.run.organizationId, TABLES.ORGANIZATION)
   const runIdStr = recordIdToString(submission.run.id, TABLES.PLAN_RUN)
 
-  const background = yield* BackgroundWorkService
+  const background = yield* BackgroundWorkServiceTag
 
   yield* background.run(
-    fromPromise(() =>
-      planCompletionSideEffects.runPlanNodeCompletionSideEffects({
+    planCompletionSideEffects
+      .runPlanNodeCompletionSideEffects({
         runId: runIdStr,
         organizationId: orgId,
         nodeId: params.nodeId,
@@ -1192,24 +1173,24 @@ const submitNodeResult = Effect.fn('PlanExecutor.submitNodeResult')(function* (
         nodeAttemptCount: submission.nodeRun.attemptCount + 1,
         artifactCount: params.result.artifacts.length,
         validationIssues: [...submission.validation.blocking, ...submission.validation.warnings],
-      }),
-    ).pipe(
-      Effect.catchTag('PlanExecutorInternalError', (error) =>
-        Effect.sync(() => {
-          aiLogger.warn`Failed to record node completion metrics for run ${runIdStr} node ${params.nodeId}: ${error.message}`
-        }),
+      })
+      .pipe(
+        Effect.mapError(toPlanExecutorInternalError),
+        Effect.catchTag(ERROR_TAGS.PlanExecutorInternalError, (error) =>
+          Effect.sync(() => {
+            aiLogger.warn`Failed to record node completion metrics for run ${runIdStr} node ${params.nodeId}: ${error.message}`
+          }),
+        ),
       ),
-    ),
     'plan-executor.recordNodeCompletionMetrics',
   )
 
   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', (error) =>
+      planCompletionSideEffects.runPlanCompletionSideEffectsSafely({ runId: runIdStr, organizationId: orgId }).pipe(
+        Effect.mapError(toPlanExecutorInternalError),
+        Effect.catchTag(ERROR_TAGS.PlanExecutorInternalError, (error) =>
           Effect.sync(() => {
             aiLogger.warn`Plan completion side-effects failed for run ${runIdStr}: ${error.message}`
           }),
@@ -1302,18 +1283,17 @@ const resumeRun = Effect.fn('PlanExecutor.resumeRun')(function* (
       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 resetNodeRunRow = yield* tx
+            .update(ensureRecordId(currentNodeRun.id, TABLES.PLAN_NODE_RUN))
+            .content(
+              toNodeRunData(currentNodeRun, {
+                status: 'ready',
+                readyAt: nowDate(),
+                startedAt: currentNodeRun.startedAt ?? nowDate(),
+              }),
+            )
+            .output('after')
+            .pipe(Effect.mapError(toPlanExecutorInternalError))
           const resetNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, resetNodeRunRow, 'plan node run')
           currentNodeRuns = currentNodeRuns.map((candidate) =>
             candidate.nodeId === resetNodeRun.nodeId ? resetNodeRun : candidate,
@@ -1347,18 +1327,16 @@ const resumeRun = Effect.fn('PlanExecutor.resumeRun')(function* (
         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,
-                }),
-              )
+            : yield* syncRunGraph(context, {
+                tx,
+                run: resetRun,
+                spec,
+                nodeSpecs,
+                nodeRuns: currentNodeRuns,
+                artifacts,
+                emittedBy: params.emittedBy,
+                capturedEvents: emittedEvents,
+              }).pipe(Effect.mapError(toPlanExecutorInternalError))
 
         const checkpoint = yield* saveCheckpointWithContext(context, {
           tx,
@@ -1395,12 +1373,11 @@ const transitionNodeToRunning = Effect.fn('PlanExecutor.transitionNodeToRunning'
 
   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 runningNodeRunRow = yield* tx
+        .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(toNodeRunData(nodeRun, { status: 'running', startedAt: nodeRun.startedAt ?? nowDate() }))
+        .output('after')
+        .pipe(Effect.mapError(toPlanExecutorInternalError))
       const runningNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, runningNodeRunRow, 'plan node run')
 
       const nodeRuns = yield* planRunService.listNodeRuns(run.id)
@@ -1447,18 +1424,17 @@ const blockNodeOnDispatchFailure = Effect.fn('PlanExecutor.blockNodeOnDispatchFa
         if (nodeRun.status === 'blocked') {
           blockedNodeRun = nodeRun
         } else {
-          const blockedNodeRunRow = 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 blockedNodeRunRow = yield* tx
+            .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
+            .content(
+              toNodeRunData(nodeRun, {
+                status: 'blocked',
+                blockedReason: params.message,
+                failureClass: params.failureClass,
+              }),
+            )
+            .output('after')
+            .pipe(Effect.mapError(toPlanExecutorInternalError))
           blockedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, blockedNodeRunRow, 'plan node run')
         }
 
@@ -1531,12 +1507,11 @@ const promoteDelayedNode = Effect.fn('PlanExecutor.promoteDelayedNode')(function
     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 readyNodeRunRow = yield* tx
+          .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
+          .content(toNodeRunData(nodeRun, { status: 'ready', readyAt: nowDate() }))
+          .output('after')
+          .pipe(Effect.mapError(toPlanExecutorInternalError))
         const readyNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, readyNodeRunRow, 'plan node run')
 
         const updatedNodeRuns = nodeRuns.map((candidate) =>
@@ -1557,18 +1532,16 @@ const promoteDelayedNode = Effect.fn('PlanExecutor.promoteDelayedNode')(function
           capturedEvents: emittedEvents,
         })
 
-        const synced = yield* fromPromise(() =>
-          syncRunGraph(context, {
-            tx,
-            run,
-            spec,
-            nodeSpecs,
-            nodeRuns: updatedNodeRuns,
-            artifacts,
-            emittedBy: params.emittedBy,
-            capturedEvents: emittedEvents,
-          }),
-        )
+        const synced = yield* syncRunGraph(context, {
+          tx,
+          run,
+          spec,
+          nodeSpecs,
+          nodeRuns: updatedNodeRuns,
+          artifacts,
+          emittedBy: params.emittedBy,
+          capturedEvents: emittedEvents,
+        }).pipe(Effect.mapError(toPlanExecutorInternalError))
 
         const checkpoint = yield* saveCheckpointWithContext(context, {
           tx,