@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -6,14 +6,14 @@ import type {
   PlanSpecRecord,
 } from '@lota-sdk/shared'
 import { PlanNodeRunSchema } from '@lota-sdk/shared'
-import { Effect } from 'effect'
+import { Effect, Match, Schema } from 'effect'
+import type { z } from 'zod'
 
 import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { DatabaseTransaction } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { NotFoundError } from '../../effect/errors'
-import { runPromise } from '../../effect/runtime'
 import { nowDate } from '../../utils/date-time'
 import type { PlanExecutorContext } from './plan-executor-context'
 import {
@@ -27,7 +27,21 @@ import {
 } from './plan-executor-helpers'
 import { emitEvent, replaceRun } from './plan-executor-persistence'
 
-const delayedNodePromotionQueueModule = Effect.tryPromise(() => import('../../queues/delayed-node-promotion.queue'))
+class PlanExecutorGraphError extends Schema.TaggedErrorClass<PlanExecutorGraphError>()('PlanExecutorGraphError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+function parseRowOrFail<T>(
+  schema: z.ZodType<T>,
+  value: unknown,
+  operation: string,
+): Effect.Effect<T, PlanExecutorGraphError> {
+  return Effect.try({
+    try: () => schema.parse(value),
+    catch: (cause) => new PlanExecutorGraphError({ message: `Failed to parse ${operation} row`, cause }),
+  })
+}
 
 export function syncRunGraph(
   context: PlanExecutorContext,
@@ -49,245 +63,203 @@ export function syncRunGraph(
     emittedBy: string
     capturedEvents?: PlanEventRecord[]
   },
-): Promise<{
-  run: PlanRunRecord
-  nodeRuns: PlanNodeRunRecord[]
-  artifacts: Array<{
-    id: RecordIdInput
-    nodeId: string
-    name: string
-    kind: string
-    pointer: string
-    schemaRef?: string
-    payload?: unknown
-  }>
-}> {
-  return runPromise(
-    Effect.gen(function* () {
-      const { planApprovalService, planCoordinationService, planSchedulerService } = context
-      const currentTime = nowDate()
-      let currentRun = params.run
-      let currentNodeRuns = [...params.nodeRuns]
-      const currentArtifacts = [...params.artifacts]
-      const sortedNodeSpecs = [...params.nodeSpecs].sort((left, right) => left.position - right.position)
-      const dependencies = params.spec.dependencies
+) {
+  return Effect.gen(function* () {
+    const { planApprovalService, planCoordinationService, planSchedulerService, delayedNodePromotionQueue } = context
+    const currentTime = nowDate()
+    let currentRun = params.run
+    let currentNodeRuns = [...params.nodeRuns]
+    const currentArtifacts = [...params.artifacts]
+    const sortedNodeSpecs = [...params.nodeSpecs].sort((left, right) => left.position - right.position)
+    const dependencies = params.spec.dependencies
 
-      const updateNodeRun = (nodeRun: PlanNodeRunRecord, patch: Parameters<typeof toNodeRunData>[1]) =>
-        params.tx
-          .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(toNodeRunData(nodeRun, patch))
-          .output('after')
+    const updateNodeRun = (nodeRun: PlanNodeRunRecord, patch: Parameters<typeof toNodeRunData>[1]) =>
+      params.tx
+        .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
+        .content(toNodeRunData(nodeRun, patch))
+        .output('after')
 
-      const replaceNodeRun = (nextNodeRun: PlanNodeRunRecord) => {
-        currentNodeRuns = currentNodeRuns.map((candidate) =>
-          candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-        )
-      }
+    const replaceNodeRun = (nextNodeRun: PlanNodeRunRecord) => {
+      currentNodeRuns = currentNodeRuns.map((candidate) =>
+        candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
+      )
+    }
 
-      const getNodeRunsById = () => new Map(currentNodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
-      const getArtifactsByNodeId = () =>
-        currentArtifacts.reduce((groups, artifact) => {
-          const list = groups.get(artifact.nodeId) ?? []
-          list.push(artifact)
-          groups.set(artifact.nodeId, list)
-          return groups
-        }, new Map<string, typeof currentArtifacts>())
+    const getNodeRunsById = () => new Map(currentNodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
+    const getArtifactsByNodeId = () =>
+      currentArtifacts.reduce((groups, artifact) => {
+        const list = groups.get(artifact.nodeId) ?? []
+        list.push(artifact)
+        groups.set(artifact.nodeId, list)
+        return groups
+      }, new Map<string, typeof currentArtifacts>())
 
-      if (dependencies && dependencies.length > 0) {
-        const { unresolved } = yield* planCoordinationService.resolveDependencies({
-          dependencies,
-          threadId: recordIdToString(params.spec.threadId, TABLES.THREAD),
+    if (dependencies && dependencies.length > 0) {
+      const { unresolved } = yield* planCoordinationService.resolveDependencies({
+        dependencies,
+        threadId: recordIdToString(params.spec.threadId, TABLES.THREAD),
+      })
+      if (unresolved.length > 0) {
+        currentRun = yield* replaceRun(params.tx, currentRun, { status: 'blocked', readyNodeIds: [] })
+        yield* emitEvent({
+          tx: params.tx,
+          run: currentRun,
+          spec: params.spec,
+          eventType: 'run-status-changed',
+          fromStatus: params.run.status,
+          toStatus: currentRun.status,
+          message: `Run blocked: unresolved cross-plan dependencies (${unresolved.map((d) => d.sourcePlanSpecId).join(', ')}).`,
+          emittedBy: params.emittedBy,
+          capturedEvents: params.capturedEvents,
         })
-        if (unresolved.length > 0) {
-          currentRun = yield* replaceRun(params.tx, currentRun, { status: 'blocked', readyNodeIds: [] })
-          yield* emitEvent({
-            tx: params.tx,
-            run: currentRun,
-            spec: params.spec,
-            eventType: 'run-status-changed',
-            fromStatus: params.run.status,
-            toStatus: currentRun.status,
-            message: `Run blocked: unresolved cross-plan dependencies (${unresolved.map((d) => d.sourcePlanSpecId).join(', ')}).`,
-            emittedBy: params.emittedBy,
-            capturedEvents: params.capturedEvents,
-          })
-          return { run: currentRun, nodeRuns: currentNodeRuns, artifacts: currentArtifacts }
-        }
+        return { run: currentRun, nodeRuns: currentNodeRuns, artifacts: currentArtifacts }
       }
+    }
 
-      let changed = true
-      while (changed) {
-        changed = false
-        const nodeRunsById = getNodeRunsById()
-        const artifactsByNodeId = getArtifactsByNodeId()
-
-        for (const nodeSpec of sortedNodeSpecs) {
-          const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
-          if (!nodeRun || nodeRun.status !== 'pending') continue
+    let changed = true
+    while (changed) {
+      changed = false
+      const nodeRunsById = getNodeRunsById()
+      const artifactsByNodeId = getArtifactsByNodeId()
 
-          const upstreamRuns = nodeSpec.upstreamNodeIds
-            .map((nodeId) => nodeRunsById.get(nodeId))
-            .filter(Boolean) as PlanNodeRunRecord[]
-          if (
-            nodeSpec.upstreamNodeIds.length > 0 &&
-            !upstreamRuns.every((upstreamRun) => isSuccessfulTerminalStatus(upstreamRun.status))
-          ) {
-            continue
-          }
+      for (const nodeSpec of sortedNodeSpecs) {
+        const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
+        if (!nodeRun || nodeRun.status !== 'pending') continue
 
-          const activeIncomingEdges: typeof params.spec.edges = []
-          for (const edge of params.spec.edges) {
-            if (edge.target !== nodeSpec.nodeId) continue
-            const sourceRun = nodeRunsById.get(edge.source)
-            if (!sourceRun) continue
-            const context = buildNodeContext({
-              nodeRun: sourceRun,
-              artifacts: artifactsByNodeId.get(edge.source) ?? [],
-            })
-            if (yield* evaluateCondition(edge.when, context)) {
-              activeIncomingEdges.push(edge)
-            }
-          }
+        const upstreamRuns = nodeSpec.upstreamNodeIds
+          .map((nodeId) => nodeRunsById.get(nodeId))
+          .filter(Boolean) as PlanNodeRunRecord[]
+        if (
+          nodeSpec.upstreamNodeIds.length > 0 &&
+          !upstreamRuns.every((upstreamRun) => isSuccessfulTerminalStatus(upstreamRun.status))
+        ) {
+          continue
+        }
 
-          if (nodeSpec.upstreamNodeIds.length > 0 && activeIncomingEdges.length === 0) {
-            const skippedNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, {
-                status: 'skipped',
-                completedAt: currentTime,
-                blockedReason: null,
-                failureClass: null,
-              }),
-            )
-            replaceNodeRun(skippedNodeRun)
-            yield* emitEvent({
-              tx: params.tx,
-              run: currentRun,
-              spec: params.spec,
-              nodeId: skippedNodeRun.nodeId,
-              eventType: 'node-skipped',
-              fromStatus: nodeRun.status,
-              toStatus: skippedNodeRun.status,
-              message: `Node "${nodeSpec.label}" was skipped because no inbound branch was activated.`,
-              emittedBy: params.emittedBy,
-              capturedEvents: params.capturedEvents,
-            })
-            changed = true
-            continue
+        const activeIncomingEdges: typeof params.spec.edges = []
+        for (const edge of params.spec.edges) {
+          if (edge.target !== nodeSpec.nodeId) continue
+          const sourceRun = nodeRunsById.get(edge.source)
+          if (!sourceRun) continue
+          const context = buildNodeContext({ nodeRun: sourceRun, artifacts: artifactsByNodeId.get(edge.source) ?? [] })
+          if (yield* evaluateCondition(edge.when, context)) {
+            activeIncomingEdges.push(edge)
           }
+        }
 
-          const resolvedInput = yield* buildResolvedInput({
+        if (nodeSpec.upstreamNodeIds.length > 0 && activeIncomingEdges.length === 0) {
+          const skippedNodeRunRow = yield* updateNodeRun(nodeRun, {
+            status: 'skipped',
+            completedAt: currentTime,
+            blockedReason: null,
+            failureClass: null,
+          })
+          const skippedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, skippedNodeRunRow, 'plan node run')
+          replaceNodeRun(skippedNodeRun)
+          yield* emitEvent({
+            tx: params.tx,
+            run: currentRun,
             spec: params.spec,
-            nodeSpec,
-            nodeRunsById,
-            artifactsByNodeId,
+            nodeId: skippedNodeRun.nodeId,
+            eventType: 'node-skipped',
+            fromStatus: nodeRun.status,
+            toStatus: skippedNodeRun.status,
+            message: `Node "${nodeSpec.label}" was skipped because no inbound branch was activated.`,
+            emittedBy: params.emittedBy,
+            capturedEvents: params.capturedEvents,
           })
-
-          const nodeSchedule = nodeSpec.schedule
-          const hasNonImmediateSchedule = nodeSchedule && nodeSchedule.type !== 'immediate'
-
-          if (hasNonImmediateSchedule) {
-            const scheduledNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, { status: 'scheduled', resolvedInput, scheduledAt: currentTime }),
-            )
-            replaceNodeRun(scheduledNodeRun)
-            yield* planSchedulerService.createSchedule({
-              organizationId: currentRun.organizationId,
-              threadId: currentRun.threadId,
-              planSpecId: params.spec.id,
-              runId: currentRun.id,
-              nodeId: nodeSpec.nodeId,
-              scheduleSpec: nodeSchedule,
-            })
-            yield* emitEvent({
-              tx: params.tx,
-              run: currentRun,
-              spec: params.spec,
-              nodeId: scheduledNodeRun.nodeId,
-              eventType: 'node-scheduled',
-              fromStatus: nodeRun.status,
-              toStatus: scheduledNodeRun.status,
-              message: `Node "${nodeSpec.label}" is scheduled (${nodeSchedule.type}).`,
-              emittedBy: params.emittedBy,
-              capturedEvents: params.capturedEvents,
-            })
-            changed = true
-          } else if (nodeSpec.delayAfterPredecessorMs) {
-            const delayAfterPredecessorMs = nodeSpec.delayAfterPredecessorMs
-            const { enqueueDelayedNodePromotion } = yield* delayedNodePromotionQueueModule
-            const scheduledNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, { status: 'scheduled', resolvedInput, scheduledAt: currentTime }),
-            )
-            replaceNodeRun(scheduledNodeRun)
-            yield* Effect.tryPromise(() =>
-              enqueueDelayedNodePromotion(
-                {
-                  runId: recordIdToString(currentRun.id, TABLES.PLAN_RUN),
-                  nodeId: nodeSpec.nodeId,
-                  emittedBy: params.emittedBy,
-                },
-                delayAfterPredecessorMs,
-              ),
-            )
-            yield* emitEvent({
-              tx: params.tx,
-              run: currentRun,
-              spec: params.spec,
-              nodeId: scheduledNodeRun.nodeId,
-              eventType: 'node-scheduled',
-              fromStatus: nodeRun.status,
-              toStatus: scheduledNodeRun.status,
-              message: `Node "${nodeSpec.label}" is delayed by ${delayAfterPredecessorMs}ms after predecessor.`,
-              emittedBy: params.emittedBy,
-              capturedEvents: params.capturedEvents,
-            })
-            changed = true
-          } else {
-            const readyNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, { status: 'ready', resolvedInput, readyAt: currentTime }),
-            )
-            replaceNodeRun(readyNodeRun)
-            yield* emitEvent({
-              tx: params.tx,
-              run: currentRun,
-              spec: params.spec,
-              nodeId: readyNodeRun.nodeId,
-              eventType: 'node-ready',
-              fromStatus: nodeRun.status,
-              toStatus: readyNodeRun.status,
-              message: `Node "${nodeSpec.label}" is ready to execute.`,
-              emittedBy: params.emittedBy,
-              capturedEvents: params.capturedEvents,
-            })
-            changed = true
-          }
+          changed = true
+          continue
         }
 
-        const readyStructuralNodes = sortedNodeSpecs.filter((nodeSpec) => {
-          const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
-          return nodeRun?.status === 'ready' && isStructuralNodeType(nodeSpec.type)
+        const resolvedInput = yield* buildResolvedInput({
+          spec: params.spec,
+          nodeSpec,
+          nodeRunsById,
+          artifactsByNodeId,
         })
 
-        for (const nodeSpec of readyStructuralNodes) {
-          const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
-          if (!nodeRun) continue
+        const nodeSchedule = nodeSpec.schedule
+        const hasNonImmediateSchedule = nodeSchedule && nodeSchedule.type !== 'immediate'
 
-          const completedNodeRun = PlanNodeRunSchema.parse(
-            yield* updateNodeRun(nodeRun, {
-              status: 'completed',
-              startedAt: nodeRun.startedAt ?? currentTime,
-              completedAt: currentTime,
-            }),
+        if (hasNonImmediateSchedule) {
+          const scheduledNodeRunRow = yield* updateNodeRun(nodeRun, {
+            status: 'scheduled',
+            resolvedInput,
+            scheduledAt: currentTime,
+          })
+          const scheduledNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, scheduledNodeRunRow, 'plan node run')
+          replaceNodeRun(scheduledNodeRun)
+          yield* planSchedulerService.createSchedule({
+            organizationId: currentRun.organizationId,
+            threadId: currentRun.threadId,
+            planSpecId: params.spec.id,
+            runId: currentRun.id,
+            nodeId: nodeSpec.nodeId,
+            scheduleSpec: nodeSchedule,
+          })
+          yield* emitEvent({
+            tx: params.tx,
+            run: currentRun,
+            spec: params.spec,
+            nodeId: scheduledNodeRun.nodeId,
+            eventType: 'node-scheduled',
+            fromStatus: nodeRun.status,
+            toStatus: scheduledNodeRun.status,
+            message: `Node "${nodeSpec.label}" is scheduled (${nodeSchedule.type}).`,
+            emittedBy: params.emittedBy,
+            capturedEvents: params.capturedEvents,
+          })
+          changed = true
+        } else if (nodeSpec.delayAfterPredecessorMs) {
+          const delayAfterPredecessorMs = nodeSpec.delayAfterPredecessorMs
+          const scheduledNodeRunRow = yield* updateNodeRun(nodeRun, {
+            status: 'scheduled',
+            resolvedInput,
+            scheduledAt: currentTime,
+          })
+          const scheduledNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, scheduledNodeRunRow, 'plan node run')
+          replaceNodeRun(scheduledNodeRun)
+          yield* Effect.tryPromise(() =>
+            delayedNodePromotionQueue.enqueueDelayedNodePromotion(
+              {
+                runId: recordIdToString(currentRun.id, TABLES.PLAN_RUN),
+                nodeId: nodeSpec.nodeId,
+                emittedBy: params.emittedBy,
+              },
+              delayAfterPredecessorMs,
+            ),
           )
-          replaceNodeRun(completedNodeRun)
           yield* emitEvent({
             tx: params.tx,
             run: currentRun,
             spec: params.spec,
-            nodeId: completedNodeRun.nodeId,
-            eventType: 'node-auto-completed',
+            nodeId: scheduledNodeRun.nodeId,
+            eventType: 'node-scheduled',
             fromStatus: nodeRun.status,
-            toStatus: completedNodeRun.status,
-            message: `Structural node "${nodeSpec.label}" auto-completed.`,
+            toStatus: scheduledNodeRun.status,
+            message: `Node "${nodeSpec.label}" is delayed by ${delayAfterPredecessorMs}ms after predecessor.`,
+            emittedBy: params.emittedBy,
+            capturedEvents: params.capturedEvents,
+          })
+          changed = true
+        } else {
+          const readyNodeRunRow = yield* updateNodeRun(nodeRun, {
+            status: 'ready',
+            resolvedInput,
+            readyAt: currentTime,
+          })
+          const readyNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, readyNodeRunRow, 'plan node run')
+          replaceNodeRun(readyNodeRun)
+          yield* emitEvent({
+            tx: params.tx,
+            run: currentRun,
+            spec: params.spec,
+            nodeId: readyNodeRun.nodeId,
+            eventType: 'node-ready',
+            fromStatus: nodeRun.status,
+            toStatus: readyNodeRun.status,
+            message: `Node "${nodeSpec.label}" is ready to execute.`,
             emittedBy: params.emittedBy,
             capturedEvents: params.capturedEvents,
           })
@@ -295,57 +267,135 @@ export function syncRunGraph(
         }
       }
 
-      const nodeRunsById = getNodeRunsById()
-      const activeRunningNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'running')
-      const activeHumanNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'awaiting-human')
-      const activeMonitoringNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'monitoring')
-      const hasScheduledOrMonitoring = currentNodeRuns.some(
-        (nodeRun) => nodeRun.status === 'scheduled' || nodeRun.status === 'monitoring',
-      )
+      const readyStructuralNodes = sortedNodeSpecs.filter((nodeSpec) => {
+        const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
+        return nodeRun?.status === 'ready' && isStructuralNodeType(nodeSpec.type)
+      })
 
-      if (!activeRunningNode && !activeHumanNode && !activeMonitoringNode) {
-        const nextHumanNodeSpec = sortedNodeSpecs.find((nodeSpec) => {
+      for (const nodeSpec of readyStructuralNodes) {
+        const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
+        if (!nodeRun) continue
+
+        const completedNodeRunRow = yield* updateNodeRun(nodeRun, {
+          status: 'completed',
+          startedAt: nodeRun.startedAt ?? currentTime,
+          completedAt: currentTime,
+        })
+        const completedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, completedNodeRunRow, 'plan node run')
+        replaceNodeRun(completedNodeRun)
+        yield* emitEvent({
+          tx: params.tx,
+          run: currentRun,
+          spec: params.spec,
+          nodeId: completedNodeRun.nodeId,
+          eventType: 'node-auto-completed',
+          fromStatus: nodeRun.status,
+          toStatus: completedNodeRun.status,
+          message: `Structural node "${nodeSpec.label}" auto-completed.`,
+          emittedBy: params.emittedBy,
+          capturedEvents: params.capturedEvents,
+        })
+        changed = true
+      }
+    }
+
+    const nodeRunsById = getNodeRunsById()
+    const activeRunningNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'running')
+    const activeHumanNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'awaiting-human')
+    const activeMonitoringNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'monitoring')
+    const hasScheduledOrMonitoring = currentNodeRuns.some(
+      (nodeRun) => nodeRun.status === 'scheduled' || nodeRun.status === 'monitoring',
+    )
+
+    if (!activeRunningNode && !activeHumanNode && !activeMonitoringNode) {
+      const nextHumanNodeSpec = sortedNodeSpecs.find((nodeSpec) => {
+        const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
+        return nodeRun?.status === 'ready' && isHumanNodeType(nodeSpec.type)
+      })
+
+      if (nextHumanNodeSpec) {
+        const nodeRun = nodeRunsById.get(nextHumanNodeSpec.nodeId)
+        if (!nodeRun) {
+          return yield* new NotFoundError({
+            resource: 'plan node run',
+            id: nextHumanNodeSpec.nodeId,
+            message: `Expected ready node run for "${nextHumanNodeSpec.nodeId}".`,
+          })
+        }
+        const awaitingHumanNodeRunRow = yield* updateNodeRun(nodeRun, {
+          status: 'awaiting-human',
+          startedAt: nodeRun.startedAt ?? currentTime,
+        })
+        const awaitingHumanNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, awaitingHumanNodeRunRow, 'plan node run')
+        replaceNodeRun(awaitingHumanNodeRun)
+
+        const approval = yield* planApprovalService.createPendingApproval({
+          tx: params.tx,
+          runId: currentRun.id,
+          nodeRunId: awaitingHumanNodeRun.id,
+          nodeId: awaitingHumanNodeRun.nodeId,
+          requestedBy: params.emittedBy,
+          presented: {
+            nodeId: nextHumanNodeSpec.nodeId,
+            label: nextHumanNodeSpec.label,
+            objective: nextHumanNodeSpec.objective,
+            instructions: nextHumanNodeSpec.instructions,
+            deliverables: nextHumanNodeSpec.deliverables,
+            successCriteria: nextHumanNodeSpec.successCriteria,
+            resolvedInput: awaitingHumanNodeRun.resolvedInput ?? {},
+          },
+        })
+
+        currentRun = yield* replaceRun(params.tx, currentRun, {
+          status: 'awaiting-human',
+          currentNodeId: awaitingHumanNodeRun.nodeId,
+          waitingNodeId: awaitingHumanNodeRun.nodeId,
+          readyNodeIds: currentNodeRuns
+            .filter((candidate) => candidate.status === 'ready' && candidate.nodeId !== awaitingHumanNodeRun.nodeId)
+            .map((candidate) => candidate.nodeId),
+        })
+
+        yield* emitEvent({
+          tx: params.tx,
+          run: currentRun,
+          spec: params.spec,
+          nodeId: awaitingHumanNodeRun.nodeId,
+          approvalId: approval.id,
+          eventType: 'approval-requested',
+          fromStatus: params.run.status,
+          toStatus: currentRun.status,
+          message: `Node "${nextHumanNodeSpec.label}" is awaiting human input.`,
+          emittedBy: params.emittedBy,
+          capturedEvents: params.capturedEvents,
+        })
+      } else {
+        const nextActionNodeSpec = sortedNodeSpecs.find((nodeSpec) => {
           const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
-          return nodeRun?.status === 'ready' && isHumanNodeType(nodeSpec.type)
+          return nodeRun?.status === 'ready' && !isStructuralNodeType(nodeSpec.type)
         })
 
-        if (nextHumanNodeSpec) {
-          const nodeRun = nodeRunsById.get(nextHumanNodeSpec.nodeId)
+        if (nextActionNodeSpec) {
+          const nodeRun = nodeRunsById.get(nextActionNodeSpec.nodeId)
           if (!nodeRun) {
             return yield* new NotFoundError({
               resource: 'plan node run',
-              id: nextHumanNodeSpec.nodeId,
-              message: `Expected ready node run for "${nextHumanNodeSpec.nodeId}".`,
+              id: nextActionNodeSpec.nodeId,
+              message: `Expected ready node run for "${nextActionNodeSpec.nodeId}".`,
             })
           }
-          const awaitingHumanNodeRun = PlanNodeRunSchema.parse(
-            yield* updateNodeRun(nodeRun, { status: 'awaiting-human', startedAt: nodeRun.startedAt ?? currentTime }),
-          )
-          replaceNodeRun(awaitingHumanNodeRun)
-
-          const approval = yield* planApprovalService.createPendingApproval({
-            tx: params.tx,
-            runId: currentRun.id,
-            nodeRunId: awaitingHumanNodeRun.id,
-            nodeId: awaitingHumanNodeRun.nodeId,
-            requestedBy: params.emittedBy,
-            presented: {
-              nodeId: nextHumanNodeSpec.nodeId,
-              label: nextHumanNodeSpec.label,
-              objective: nextHumanNodeSpec.objective,
-              instructions: nextHumanNodeSpec.instructions,
-              deliverables: nextHumanNodeSpec.deliverables,
-              successCriteria: nextHumanNodeSpec.successCriteria,
-              resolvedInput: awaitingHumanNodeRun.resolvedInput ?? {},
-            },
+          const runningNodeRunRow = yield* updateNodeRun(nodeRun, {
+            status: 'running',
+            startedAt: nodeRun.startedAt ?? currentTime,
           })
+          const runningNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, runningNodeRunRow, 'plan node run')
+          replaceNodeRun(runningNodeRun)
 
           currentRun = yield* replaceRun(params.tx, currentRun, {
-            status: 'awaiting-human',
-            currentNodeId: awaitingHumanNodeRun.nodeId,
-            waitingNodeId: awaitingHumanNodeRun.nodeId,
+            status: 'running',
+            currentNodeId: runningNodeRun.nodeId,
+            waitingNodeId: null,
             readyNodeIds: currentNodeRuns
-              .filter((candidate) => candidate.status === 'ready' && candidate.nodeId !== awaitingHumanNodeRun.nodeId)
+              .filter((candidate) => candidate.status === 'ready' && candidate.nodeId !== runningNodeRun.nodeId)
               .map((candidate) => candidate.nodeId),
           })
 
@@ -353,80 +403,70 @@ export function syncRunGraph(
             tx: params.tx,
             run: currentRun,
             spec: params.spec,
-            nodeId: awaitingHumanNodeRun.nodeId,
-            approvalId: approval.id,
-            eventType: 'approval-requested',
-            fromStatus: params.run.status,
-            toStatus: currentRun.status,
-            message: `Node "${nextHumanNodeSpec.label}" is awaiting human input.`,
+            nodeId: runningNodeRun.nodeId,
+            eventType: 'node-running',
+            fromStatus: nodeRun.status,
+            toStatus: runningNodeRun.status,
+            message: `Node "${nextActionNodeSpec.label}" is now running.`,
             emittedBy: params.emittedBy,
             capturedEvents: params.capturedEvents,
           })
-        } else {
-          const nextActionNodeSpec = sortedNodeSpecs.find((nodeSpec) => {
-            const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
-            return nodeRun?.status === 'ready' && !isStructuralNodeType(nodeSpec.type)
+          yield* emitEvent({
+            tx: params.tx,
+            run: currentRun,
+            spec: params.spec,
+            nodeId: runningNodeRun.nodeId,
+            eventType: 'ownership-transition',
+            message: `Execution ownership transitioned to "${nextActionNodeSpec.label}".`,
+            detail: {
+              owner: nextActionNodeSpec.owner,
+              fromNodeId: params.run.currentNodeId ?? null,
+              toNodeId: runningNodeRun.nodeId,
+            },
+            emittedBy: params.emittedBy,
+            capturedEvents: params.capturedEvents,
           })
+        } else {
+          const allTerminalSuccess = currentNodeRuns.every((nodeRun) => isSuccessfulTerminalStatus(nodeRun.status))
+          const runStatus: 'completed' | 'running' | 'blocked' = allTerminalSuccess
+            ? 'completed'
+            : hasScheduledOrMonitoring
+              ? 'running'
+              : 'blocked'
+          const readyIds = currentNodeRuns
+            .filter((candidate) => candidate.status === 'ready')
+            .map((candidate) => candidate.nodeId)
 
-          if (nextActionNodeSpec) {
-            const nodeRun = nodeRunsById.get(nextActionNodeSpec.nodeId)
-            if (!nodeRun) {
-              return yield* new NotFoundError({
-                resource: 'plan node run',
-                id: nextActionNodeSpec.nodeId,
-                message: `Expected ready node run for "${nextActionNodeSpec.nodeId}".`,
-              })
-            }
-            const runningNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, { status: 'running', startedAt: nodeRun.startedAt ?? currentTime }),
-            )
-            replaceNodeRun(runningNodeRun)
-
-            currentRun = yield* replaceRun(params.tx, currentRun, {
-              status: 'running',
-              currentNodeId: runningNodeRun.nodeId,
-              waitingNodeId: null,
-              readyNodeIds: currentNodeRuns
-                .filter((candidate) => candidate.status === 'ready' && candidate.nodeId !== runningNodeRun.nodeId)
-                .map((candidate) => candidate.nodeId),
-            })
-
-            yield* emitEvent({
-              tx: params.tx,
-              run: currentRun,
-              spec: params.spec,
-              nodeId: runningNodeRun.nodeId,
-              eventType: 'node-running',
-              fromStatus: nodeRun.status,
-              toStatus: runningNodeRun.status,
-              message: `Node "${nextActionNodeSpec.label}" is now running.`,
-              emittedBy: params.emittedBy,
-              capturedEvents: params.capturedEvents,
-            })
-            yield* emitEvent({
-              tx: params.tx,
-              run: currentRun,
-              spec: params.spec,
-              nodeId: runningNodeRun.nodeId,
-              eventType: 'ownership-transition',
-              message: `Execution ownership transitioned to "${nextActionNodeSpec.label}".`,
-              detail: {
-                owner: nextActionNodeSpec.owner,
-                fromNodeId: params.run.currentNodeId ?? null,
-                toNodeId: runningNodeRun.nodeId,
-              },
-              emittedBy: params.emittedBy,
-              capturedEvents: params.capturedEvents,
-            })
-          } else if (currentNodeRuns.every((nodeRun) => isSuccessfulTerminalStatus(nodeRun.status))) {
-            currentRun = yield* replaceRun(params.tx, currentRun, {
-              status: 'completed',
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: [],
-              completedAt: currentTime,
-            })
+          currentRun = yield* Match.value(runStatus).pipe(
+            Match.when('completed', () =>
+              replaceRun(params.tx, currentRun, {
+                status: 'completed',
+                currentNodeId: null,
+                waitingNodeId: null,
+                readyNodeIds: [],
+                completedAt: currentTime,
+              }),
+            ),
+            Match.when('running', () =>
+              replaceRun(params.tx, currentRun, {
+                status: 'running',
+                currentNodeId: null,
+                waitingNodeId: null,
+                readyNodeIds: readyIds,
+              }),
+            ),
+            Match.when('blocked', () =>
+              replaceRun(params.tx, currentRun, {
+                status: 'blocked',
+                currentNodeId: null,
+                waitingNodeId: null,
+                readyNodeIds: readyIds,
+              }),
+            ),
+            Match.exhaustive,
+          )
 
+          if (runStatus === 'completed') {
             yield* emitEvent({
               tx: params.tx,
               run: currentRun,
@@ -438,38 +478,20 @@ export function syncRunGraph(
               emittedBy: params.emittedBy,
               capturedEvents: params.capturedEvents,
             })
-          } else if (hasScheduledOrMonitoring) {
-            currentRun = yield* replaceRun(params.tx, currentRun, {
-              status: 'running',
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: currentNodeRuns
-                .filter((candidate) => candidate.status === 'ready')
-                .map((candidate) => candidate.nodeId),
-            })
-          } else {
-            currentRun = yield* replaceRun(params.tx, currentRun, {
-              status: 'blocked',
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: currentNodeRuns
-                .filter((candidate) => candidate.status === 'ready')
-                .map((candidate) => candidate.nodeId),
-            })
           }
         }
-      } else {
-        currentRun = yield* replaceRun(params.tx, currentRun, {
-          status: activeHumanNode ? 'awaiting-human' : 'running',
-          currentNodeId: activeHumanNode?.nodeId ?? activeMonitoringNode?.nodeId ?? activeRunningNode?.nodeId ?? null,
-          waitingNodeId: activeHumanNode?.nodeId ?? null,
-          readyNodeIds: currentNodeRuns
-            .filter((candidate) => candidate.status === 'ready')
-            .map((candidate) => candidate.nodeId),
-        })
       }
+    } else {
+      currentRun = yield* replaceRun(params.tx, currentRun, {
+        status: activeHumanNode ? 'awaiting-human' : 'running',
+        currentNodeId: activeHumanNode?.nodeId ?? activeMonitoringNode?.nodeId ?? activeRunningNode?.nodeId ?? null,
+        waitingNodeId: activeHumanNode?.nodeId ?? null,
+        readyNodeIds: currentNodeRuns
+          .filter((candidate) => candidate.status === 'ready')
+          .map((candidate) => candidate.nodeId),
+      })
+    }
 
-      return { run: currentRun, nodeRuns: currentNodeRuns, artifacts: currentArtifacts }
-    }),
-  )
+    return { run: currentRun, nodeRuns: currentNodeRuns, artifacts: currentArtifacts }
+  })
 }