@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -1,1950 +0,0 @@
-import type {
-  ExecutionPlanToolResultData,
-  PlanEventRecord,
-  PlanEventType,
-  PlanFailureAction,
-  PlanFailureClass,
-  PlanNodeResultSubmission,
-  PlanNodeRunRecord,
-  PlanNodeSpecRecord,
-  PlanRunRecord,
-  PlanSpecRecord,
-  PlanValidationIssueRecord,
-  SerializableExecutionPlan,
-} from '@lota-sdk/shared'
-import {
-  HUMAN_NODE_TYPES as HUMAN_NODE_TYPE_VALUES,
-  PlanEventSchema,
-  PlanNodeAttemptSchema,
-  PlanNodeRunSchema,
-  PlanRunSchema,
-  STRUCTURAL_NODE_TYPES as STRUCTURAL_NODE_TYPE_VALUES,
-  PlanValidationIssueSchema,
-} from '@lota-sdk/shared'
-import { RecordId, StringRecordId } from 'surrealdb'
-
-import { aiLogger } from '../config/logger'
-import type { RecordIdInput } from '../db/record-id'
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
-import type { DatabaseTransaction } from '../db/service'
-import { TABLES } from '../db/tables'
-import { generatedDocumentStorageService } from '../storage/generated-document-storage.service'
-import { toDatabaseDateTime } from '../utils/date-time'
-import { isRecord } from '../utils/string'
-import { artifactService } from './artifact.service'
-import { planApprovalService } from './plan-approval.service'
-import { planArtifactService } from './plan-artifact.service'
-import { planCheckpointService } from './plan-checkpoint.service'
-import { runPlanCompletionSideEffectsSafely, runPlanNodeCompletionSideEffects } from './plan-completion-side-effects'
-import { planCoordinationService } from './plan-coordination.service'
-import { planEventDeliveryService } from './plan-event-delivery.service'
-import { isExecutableConditionExpression, readPathValue } from './plan-helpers'
-import { toPlanNodeValidationSpec } from './plan-node-spec'
-import { buildExecutionPlanToolResult, toRunData } from './plan-run-data'
-import type { PlanRunUpdate } from './plan-run-data'
-import { planRunService } from './plan-run.service'
-import { planSchedulerService } from './plan-scheduler.service'
-import type { PlanValidationIssueInput } from './plan-validator.service'
-import { planValidatorService } from './plan-validator.service'
-
-const SUCCESSFUL_TERMINAL_NODE_STATUSES = new Set(['completed', 'partial', 'skipped', 'scheduled', 'monitoring'])
-const HUMAN_NODE_TYPE_SET = new Set<string>(HUMAN_NODE_TYPE_VALUES)
-const STRUCTURAL_NODE_TYPE_SET = new Set<string>(STRUCTURAL_NODE_TYPE_VALUES)
-
-function setPathValue(target: Record<string, unknown>, path: string, value: unknown) {
-  const segments = path
-    .split('.')
-    .map((part) => part.trim())
-    .filter(Boolean)
-  if (segments.length === 0) return
-  const lastSegment = segments.at(-1)
-  if (!lastSegment) return
-
-  let current: Record<string, unknown> = target
-  for (const segment of segments.slice(0, -1)) {
-    const next = current[segment]
-    if (!isRecord(next)) {
-      current[segment] = {}
-    }
-    current = current[segment] as Record<string, unknown>
-  }
-  current[lastSegment] = value
-}
-
-function parseLiteralValue(raw: string): unknown {
-  const trimmed = raw.trim()
-  if (!trimmed.length) return undefined
-  if (trimmed === 'true') return true
-  if (trimmed === 'false') return false
-  if (trimmed === 'null') return null
-  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed)
-  if (
-    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-    (trimmed.startsWith("'") && trimmed.endsWith("'")) ||
-    (trimmed.startsWith('`') && trimmed.endsWith('`'))
-  ) {
-    return trimmed.slice(1, -1)
-  }
-
-  try {
-    return JSON.parse(trimmed)
-  } catch {
-    return trimmed
-  }
-}
-
-function buildArtifactContext(artifacts: Array<{ name: string; kind: string; payload?: unknown }>) {
-  return Object.fromEntries(
-    artifacts.map((artifact) => [artifact.name, { kind: artifact.kind, payload: artifact.payload }]),
-  )
-}
-
-function buildNodeContext(params: {
-  nodeRun: PlanNodeRunRecord | undefined
-  artifacts: Array<{ name: string; kind: string; payload?: unknown }>
-}) {
-  return {
-    input: params.nodeRun?.resolvedInput ?? {},
-    output: params.nodeRun?.latestStructuredOutput ?? {},
-    artifact: buildArtifactContext(params.artifacts),
-  }
-}
-
-function buildPublishedArtifactContent(params: {
-  artifact: PlanNodeResultSubmission['artifacts'][number]
-  notes: string
-}): string {
-  const { artifact, notes } = params
-  if (artifact.content?.trim()) {
-    return artifact.content
-  }
-
-  if (artifact.payload !== undefined) {
-    return `# ${artifact.name}\n\n\`\`\`json\n${JSON.stringify(artifact.payload, null, 2)}\n\`\`\``
-  }
-
-  return `# ${artifact.name}\n\n${notes.trim()}`
-}
-
-function evaluateCondition(expression: string | undefined, context: Record<string, unknown>): boolean {
-  if (!expression?.trim()) return true
-  const normalized = expression.trim()
-  if (normalized === 'always') return true
-
-  const match = normalized.match(/^([a-zA-Z0-9_.]+)\s*(==|!=|>=|<=|>|<)\s*(.+)$/)
-  if (!match) {
-    if (!isExecutableConditionExpression(normalized)) {
-      return true
-    }
-    return Boolean(readPathValue(context, normalized))
-  }
-
-  const [, leftPath, operator, rawRightValue] = match
-  const left = readPathValue(context, leftPath)
-  const right = parseLiteralValue(rawRightValue)
-
-  if (operator === '==') return Object.is(left, right)
-  if (operator === '!=') return !Object.is(left, right)
-  if (typeof left !== 'number' || typeof right !== 'number') return false
-  if (operator === '>=') return left >= right
-  if (operator === '<=') return left <= right
-  if (operator === '>') return left > right
-  return left < right
-}
-
-function isSuccessfulTerminalStatus(status: string): boolean {
-  return SUCCESSFUL_TERMINAL_NODE_STATUSES.has(status)
-}
-
-function isHumanNodeType(type: string): boolean {
-  return HUMAN_NODE_TYPE_SET.has(type)
-}
-
-function isStructuralNodeType(type: string): boolean {
-  return STRUCTURAL_NODE_TYPE_SET.has(type)
-}
-
-type PlanNodeRunUpdate = Omit<
-  Partial<PlanNodeRunRecord>,
-  | 'blockedReason'
-  | 'failureClass'
-  | 'resolvedInput'
-  | 'latestStructuredOutput'
-  | 'latestNotes'
-  | 'latestAttemptId'
-  | 'scheduledAt'
-  | 'readyAt'
-  | 'startedAt'
-  | 'completedAt'
-> & {
-  blockedReason?: string | null
-  failureClass?: PlanFailureClass | null
-  resolvedInput?: Record<string, unknown> | null
-  latestStructuredOutput?: Record<string, unknown> | null
-  latestNotes?: string | null
-  latestAttemptId?: RecordIdInput | null
-  scheduledAt?: string | Date | null
-  readyAt?: string | Date | null
-  startedAt?: string | Date | null
-  completedAt?: string | Date | null
-}
-
-function toNodeRunData(nodeRun: PlanNodeRunRecord, patch: PlanNodeRunUpdate) {
-  return {
-    runId: ensureRecordId(nodeRun.runId, TABLES.PLAN_RUN),
-    planSpecId: ensureRecordId(nodeRun.planSpecId, TABLES.PLAN_SPEC),
-    nodeId: nodeRun.nodeId,
-    status: patch.status ?? nodeRun.status,
-    attemptCount: patch.attemptCount ?? nodeRun.attemptCount,
-    retryCount: patch.retryCount ?? nodeRun.retryCount,
-    ...(patch.resolvedInput === null
-      ? {}
-      : patch.resolvedInput !== undefined
-        ? { resolvedInput: patch.resolvedInput }
-        : nodeRun.resolvedInput
-          ? { resolvedInput: nodeRun.resolvedInput }
-          : {}),
-    ...(patch.latestStructuredOutput === null
-      ? {}
-      : patch.latestStructuredOutput !== undefined
-        ? { latestStructuredOutput: patch.latestStructuredOutput }
-        : nodeRun.latestStructuredOutput
-          ? { latestStructuredOutput: nodeRun.latestStructuredOutput }
-          : {}),
-    ...(patch.latestNotes === null
-      ? {}
-      : patch.latestNotes !== undefined
-        ? { latestNotes: patch.latestNotes }
-        : nodeRun.latestNotes
-          ? { latestNotes: nodeRun.latestNotes }
-          : {}),
-    ...(patch.latestAttemptId === null
-      ? {}
-      : patch.latestAttemptId !== undefined
-        ? { latestAttemptId: ensureRecordId(patch.latestAttemptId, TABLES.PLAN_NODE_ATTEMPT) }
-        : nodeRun.latestAttemptId
-          ? { latestAttemptId: ensureRecordId(nodeRun.latestAttemptId, TABLES.PLAN_NODE_ATTEMPT) }
-          : {}),
-    ...(patch.blockedReason === null
-      ? {}
-      : patch.blockedReason !== undefined
-        ? { blockedReason: patch.blockedReason }
-        : nodeRun.blockedReason
-          ? { blockedReason: nodeRun.blockedReason }
-          : {}),
-    ...(patch.failureClass === null
-      ? {}
-      : patch.failureClass !== undefined
-        ? { failureClass: patch.failureClass }
-        : nodeRun.failureClass
-          ? { failureClass: nodeRun.failureClass }
-          : {}),
-    ...(patch.scheduledAt === null
-      ? {}
-      : patch.scheduledAt !== undefined
-        ? { scheduledAt: toDatabaseDateTime(patch.scheduledAt) }
-        : nodeRun.scheduledAt
-          ? { scheduledAt: toDatabaseDateTime(nodeRun.scheduledAt) }
-          : {}),
-    ...(patch.readyAt === null
-      ? {}
-      : patch.readyAt !== undefined
-        ? { readyAt: toDatabaseDateTime(patch.readyAt) }
-        : nodeRun.readyAt
-          ? { readyAt: toDatabaseDateTime(nodeRun.readyAt) }
-          : {}),
-    ...(patch.startedAt === null
-      ? {}
-      : patch.startedAt !== undefined
-        ? { startedAt: toDatabaseDateTime(patch.startedAt) }
-        : nodeRun.startedAt
-          ? { startedAt: toDatabaseDateTime(nodeRun.startedAt) }
-          : {}),
-    ...(patch.completedAt === null
-      ? {}
-      : patch.completedAt !== undefined
-        ? { completedAt: toDatabaseDateTime(patch.completedAt) }
-        : nodeRun.completedAt
-          ? { completedAt: toDatabaseDateTime(nodeRun.completedAt) }
-          : {}),
-  }
-}
-
-function deriveApprovalStatus(response: Record<string, unknown>): 'approved' | 'rejected' | 'changes-requested' {
-  const approved = response.approved === true
-  const requiredEdits = Array.isArray(response.requiredEdits)
-    ? response.requiredEdits.filter((entry): entry is string => typeof entry === 'string' && entry.trim().length > 0)
-    : []
-
-  if (approved && requiredEdits.length === 0) return 'approved'
-  if (requiredEdits.length > 0) return 'changes-requested'
-  return 'rejected'
-}
-
-class PlanExecutorService {
-  async submitNodeResult(params: {
-    threadId: RecordIdInput
-    runId: string
-    nodeId: string
-    emittedBy: string
-    result: PlanNodeResultSubmission
-  }): Promise<ExecutionPlanToolResultData> {
-    const run = await planRunService.getRunById(params.runId)
-    if (recordIdToString(run.threadId, TABLES.THREAD) !== recordIdToString(params.threadId, TABLES.THREAD)) {
-      throw new Error('Execution node result targets a different thread.')
-    }
-    if (run.status === 'completed' || run.status === 'failed' || run.status === 'aborted') {
-      throw new Error('Execution run is no longer active.')
-    }
-
-    const spec = await planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
-    const nodeSpec = nodeSpecs.find((candidate) => candidate.nodeId === params.nodeId)
-    if (!nodeSpec) {
-      throw new Error(`Execution node "${params.nodeId}" does not exist in this run.`)
-    }
-    if (isHumanNodeType(nodeSpec.type) || isStructuralNodeType(nodeSpec.type)) {
-      throw new Error(
-        `Execution node "${nodeSpec.label}" is executor-owned and cannot accept direct result submission.`,
-      )
-    }
-
-    const nodeRun = await planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-    if (nodeRun.status !== 'running') {
-      throw new Error(`Execution node "${nodeSpec.label}" is not currently running.`)
-    }
-
-    const existingArtifacts = await planRunService.listArtifacts(run.id)
-    const latestCheckpoint = await planRunService.getLatestCheckpoint(run.id)
-    const validation = planValidatorService.validateNodeResult({
-      draft: { schemas: spec.schemaRegistry },
-      node: toPlanNodeValidationSpec(nodeSpec),
-      result: params.result,
-    })
-    const emittedEvents: PlanEventRecord[] = []
-    const publishedArtifactStorageKeys: string[] = []
-
-    try {
-      await databaseService.withTransaction(async (tx) => {
-        const attempt = await this.createAttempt({
-          tx,
-          run,
-          nodeRun,
-          emittedBy: params.emittedBy,
-          result: params.result,
-          status: validation.blocking.length > 0 ? 'failed' : 'completed',
-          failureClass: validation.failureClass,
-        })
-
-        const issues = await this.persistValidationIssues({
-          tx,
-          run,
-          spec,
-          attemptId: attempt.id,
-          nodeId: params.nodeId,
-          issues: [...validation.blocking, ...validation.warnings],
-        })
-
-        const finalizedAttempt = PlanNodeAttemptSchema.parse(
-          await 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) => ensureRecordId(issue.id, TABLES.PLAN_VALIDATION_ISSUE)),
-              ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
-            })
-            .output('after'),
-        )
-
-        const publishedArtifacts =
-          validation.blocking.length > 0
-            ? params.result.artifacts
-            : await Promise.all(
-                params.result.artifacts.map(async (artifact) => {
-                  const deliverable = nodeSpec.deliverables.find((candidate) => candidate.name === artifact.name)
-                  if (!deliverable?.publishAs) {
-                    return artifact
-                  }
-
-                  const content = buildPublishedArtifactContent({ artifact, notes: params.result.notes })
-                  const published = await artifactService.publishArtifactInTransaction(
-                    {
-                      organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-                      authorAgentId: params.emittedBy,
-                      title: artifact.name,
-                      artifactKind: deliverable.publishAs.artifactKind,
-                      templateId: deliverable.publishAs.templateId,
-                      canonicalKey: deliverable.publishAs.canonicalKey,
-                      content,
-                      tags: [],
-                      ...(artifact.description ? { description: artifact.description } : {}),
-                      sourceThreadId: recordIdToString(run.threadId, TABLES.THREAD),
-                      sourcePlanRunId: recordIdToString(run.id, TABLES.PLAN_RUN),
-                      sourcePlanNodeId: params.nodeId,
-                      deliverableName: artifact.name,
-                    },
-                    tx,
-                  )
-                  publishedArtifactStorageKeys.push(published.storageKey)
-
-                  return { ...artifact, content, publishedArtifactId: recordIdToString(published.id, TABLES.ARTIFACT) }
-                }),
-              )
-
-        const persistedArtifacts = await planArtifactService.persistArtifacts({
-          tx,
-          runId: run.id,
-          attemptId: finalizedAttempt.id,
-          nodeId: params.nodeId,
-          artifacts: publishedArtifacts,
-        })
-
-        let nextNodeRun = PlanNodeRunSchema.parse(
-          await tx
-            .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-            .content(
-              toNodeRunData(nodeRun, {
-                attemptCount: nodeRun.attemptCount + 1,
-                latestAttemptId: finalizedAttempt.id,
-                latestStructuredOutput: params.result.structuredOutput ?? null,
-                latestNotes: params.result.notes,
-              }),
-            )
-            .output('after'),
-        )
-
-        const nodeRuns = await planRunService.listNodeRuns(run.id)
-        const withUpdatedNodeRuns = nodeRuns.map((candidate) =>
-          candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-        )
-        const nextArtifacts = [...existingArtifacts, ...persistedArtifacts]
-
-        if (validation.blocking.length > 0) {
-          const shouldRetry =
-            validation.failureClass &&
-            nodeSpec.retryPolicy.maxAttempts > nextNodeRun.retryCount &&
-            (nodeSpec.retryPolicy.retryOn.length === 0 ||
-              nodeSpec.retryPolicy.retryOn.includes(validation.failureClass))
-
-          if (shouldRetry) {
-            nextNodeRun = PlanNodeRunSchema.parse(
-              await tx
-                .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-                .content(
-                  toNodeRunData(nextNodeRun, {
-                    status: 'ready',
-                    retryCount: nextNodeRun.retryCount + 1,
-                    failureClass: validation.failureClass,
-                    blockedReason: validation.blocking[0]?.message ?? null,
-                    readyAt: new Date(),
-                    startedAt: null,
-                    completedAt: null,
-                  }),
-                )
-                .output('after'),
-            )
-
-            await this.emitEvent({
-              tx,
-              run,
-              spec,
-              nodeId: nextNodeRun.nodeId,
-              attemptId: finalizedAttempt.id,
-              eventType: 'validation-reported',
-              message: `Validation failed for node "${nodeSpec.label}", scheduling retry.`,
-              detail: { issues: validation.blocking.map((issue) => issue.code) },
-              emittedBy: params.emittedBy,
-              capturedEvents: emittedEvents,
-            })
-            await this.emitEvent({
-              tx,
-              run,
-              spec,
-              nodeId: nextNodeRun.nodeId,
-              attemptId: finalizedAttempt.id,
-              eventType: 'node-unblocked',
-              fromStatus: nodeRun.status,
-              toStatus: nextNodeRun.status,
-              message: `Node "${nodeSpec.label}" is ready for another attempt.`,
-              detail: { retryCount: nextNodeRun.retryCount },
-              emittedBy: params.emittedBy,
-              capturedEvents: emittedEvents,
-            })
-
-            const synced = await this.syncRunGraph({
-              tx,
-              run,
-              spec,
-              nodeSpecs,
-              nodeRuns: withUpdatedNodeRuns.map((candidate) =>
-                candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-              ),
-              artifacts: nextArtifacts,
-              emittedBy: params.emittedBy,
-              capturedEvents: emittedEvents,
-            })
-
-            const checkpoint = await this.saveCheckpoint({
-              tx,
-              run: synced.run,
-              spec,
-              nodeRuns: synced.nodeRuns,
-              artifacts: synced.artifacts,
-              sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-              reason: 'node-result-retry',
-              capturedEvents: emittedEvents,
-            })
-
-            await this.attachCheckpoint(tx, synced.run, checkpoint)
-            return
-          }
-
-          const failureAction = this.resolveFailureAction(nodeSpec, validation.failureClass)
-          if (failureAction === 'human-review') {
-            nextNodeRun = PlanNodeRunSchema.parse(
-              await tx
-                .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-                .content(
-                  toNodeRunData(nextNodeRun, {
-                    status: 'awaiting-human',
-                    retryCount: nextNodeRun.retryCount + 1,
-                    failureClass: validation.failureClass,
-                    blockedReason: validation.blocking[0]?.message ?? null,
-                    startedAt: nextNodeRun.startedAt ?? new Date(),
-                  }),
-                )
-                .output('after'),
-            )
-
-            const approval = await planApprovalService.createPendingApproval({
-              tx,
-              runId: run.id,
-              nodeRunId: nextNodeRun.id,
-              nodeId: nextNodeRun.nodeId,
-              requestedBy: params.emittedBy,
-              presented: {
-                nodeId: nodeSpec.nodeId,
-                label: nodeSpec.label,
-                objective: nodeSpec.objective,
-                instructions: nodeSpec.instructions,
-                validationIssues: validation.blocking,
-              },
-            })
-
-            const failedRun = await this.replaceRun(tx, run, {
-              status: 'awaiting-human',
-              currentNodeId: nextNodeRun.nodeId,
-              waitingNodeId: nextNodeRun.nodeId,
-              readyNodeIds: [],
-              failureCount: run.failureCount + 1,
-            })
-
-            await this.emitEvent({
-              tx,
-              run: failedRun,
-              spec,
-              nodeId: nextNodeRun.nodeId,
-              attemptId: finalizedAttempt.id,
-              approvalId: approval.id,
-              eventType: 'approval-requested',
-              fromStatus: run.status,
-              toStatus: failedRun.status,
-              message: `Node "${nodeSpec.label}" requires human review before continuing.`,
-              detail: { issues: validation.blocking.map((issue) => issue.code) },
-              emittedBy: params.emittedBy,
-              capturedEvents: emittedEvents,
-            })
-
-            const checkpoint = await this.saveCheckpoint({
-              tx,
-              run: failedRun,
-              spec,
-              nodeRuns: withUpdatedNodeRuns.map((candidate) =>
-                candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-              ),
-              artifacts: nextArtifacts,
-              sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-              reason: 'node-result-human-review',
-              capturedEvents: emittedEvents,
-            })
-
-            await this.attachCheckpoint(tx, failedRun, checkpoint)
-            return
-          }
-
-          if (failureAction === 'replan') {
-            nextNodeRun = PlanNodeRunSchema.parse(
-              await tx
-                .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-                .content(
-                  toNodeRunData(nextNodeRun, {
-                    status: 'blocked',
-                    retryCount: nextNodeRun.retryCount + 1,
-                    failureClass: validation.failureClass,
-                    blockedReason: validation.blocking[0]?.message ?? null,
-                  }),
-                )
-                .output('after'),
-            )
-
-            const blockedRun = await this.replaceRun(tx, run, {
-              status: 'blocked',
-              currentNodeId: nextNodeRun.nodeId,
-              waitingNodeId: null,
-              readyNodeIds: [],
-              failureCount: run.failureCount + 1,
-            })
-
-            await this.emitEvent({
-              tx,
-              run: blockedRun,
-              spec,
-              nodeId: nextNodeRun.nodeId,
-              attemptId: finalizedAttempt.id,
-              eventType: 'node-blocked',
-              fromStatus: nodeRun.status,
-              toStatus: nextNodeRun.status,
-              message: `Node "${nodeSpec.label}" failed validation and requires replanning.`,
-              detail: { failureClass: validation.failureClass, issues: validation.blocking.map((issue) => issue.code) },
-              emittedBy: params.emittedBy,
-              capturedEvents: emittedEvents,
-            })
-
-            const checkpoint = await this.saveCheckpoint({
-              tx,
-              run: blockedRun,
-              spec,
-              nodeRuns: withUpdatedNodeRuns.map((candidate) =>
-                candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-              ),
-              artifacts: nextArtifacts,
-              sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-              reason: 'node-result-replan',
-              capturedEvents: emittedEvents,
-            })
-
-            await this.attachCheckpoint(tx, blockedRun, checkpoint)
-            return
-          }
-
-          nextNodeRun = PlanNodeRunSchema.parse(
-            await tx
-              .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(
-                toNodeRunData(nextNodeRun, {
-                  status: 'failed',
-                  retryCount: nextNodeRun.retryCount + 1,
-                  failureClass: validation.failureClass,
-                  blockedReason: validation.blocking[0]?.message ?? null,
-                  completedAt: new Date(),
-                }),
-              )
-              .output('after'),
-          )
-
-          const failedRun = await this.replaceRun(tx, run, {
-            status: 'failed',
-            currentNodeId: null,
-            waitingNodeId: null,
-            readyNodeIds: [],
-            failureCount: run.failureCount + 1,
-            completedAt: new Date(),
-          })
-
-          await this.emitEvent({
-            tx,
-            run: failedRun,
-            spec,
-            nodeId: nextNodeRun.nodeId,
-            attemptId: finalizedAttempt.id,
-            eventType: 'node-failed',
-            fromStatus: nodeRun.status,
-            toStatus: nextNodeRun.status,
-            message: `Node "${nodeSpec.label}" failed validation and the run has been aborted.`,
-            detail: { failureClass: validation.failureClass, issues: validation.blocking.map((issue) => issue.code) },
-            emittedBy: params.emittedBy,
-            capturedEvents: emittedEvents,
-          })
-
-          const checkpoint = await this.saveCheckpoint({
-            tx,
-            run: failedRun,
-            spec,
-            nodeRuns: withUpdatedNodeRuns.map((candidate) =>
-              candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-            ),
-            artifacts: nextArtifacts,
-            sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-            reason: 'node-result-failed',
-            capturedEvents: emittedEvents,
-          })
-
-          await this.attachCheckpoint(tx, failedRun, checkpoint)
-          return
-        }
-
-        nextNodeRun = PlanNodeRunSchema.parse(
-          await tx
-            .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-            .content(
-              toNodeRunData(nextNodeRun, {
-                status: validation.warnings.length > 0 ? 'partial' : 'completed',
-                latestAttemptId: finalizedAttempt.id,
-                latestStructuredOutput: params.result.structuredOutput ?? null,
-                latestNotes: params.result.notes,
-                blockedReason: null,
-                failureClass: null,
-                completedAt: new Date(),
-              }),
-            )
-            .output('after'),
-        )
-
-        await this.emitEvent({
-          tx,
-          run,
-          spec,
-          nodeId: nextNodeRun.nodeId,
-          attemptId: finalizedAttempt.id,
-          eventType: validation.warnings.length > 0 ? 'node-partial' : 'node-completed',
-          fromStatus: nodeRun.status,
-          toStatus: nextNodeRun.status,
-          message:
-            validation.warnings.length > 0
-              ? `Node "${nodeSpec.label}" completed with warnings.`
-              : `Node "${nodeSpec.label}" completed successfully.`,
-          detail: { warningCount: validation.warnings.length },
-          emittedBy: params.emittedBy,
-          capturedEvents: emittedEvents,
-        })
-
-        const synced = await this.syncRunGraph({
-          tx,
-          run,
-          spec,
-          nodeSpecs,
-          nodeRuns: withUpdatedNodeRuns.map((candidate) =>
-            candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-          ),
-          artifacts: nextArtifacts,
-          emittedBy: params.emittedBy,
-          capturedEvents: emittedEvents,
-        })
-
-        const checkpoint = await this.saveCheckpoint({
-          tx,
-          run: synced.run,
-          spec,
-          nodeRuns: synced.nodeRuns,
-          artifacts: synced.artifacts,
-          sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-          reason: 'node-result-complete',
-          capturedEvents: emittedEvents,
-        })
-
-        await this.attachCheckpoint(tx, synced.run, checkpoint)
-      })
-    } catch (error) {
-      await Promise.allSettled(
-        publishedArtifactStorageKeys.map((storageKey) =>
-          generatedDocumentStorageService.deleteTextArtifact(storageKey),
-        ),
-      )
-      throw error
-    }
-
-    const orgId = recordIdToString(run.organizationId, TABLES.ORGANIZATION)
-    const runIdStr = recordIdToString(run.id, TABLES.PLAN_RUN)
-    void runPlanNodeCompletionSideEffects({
-      runId: runIdStr,
-      organizationId: orgId,
-      nodeId: params.nodeId,
-      nodeLabel: nodeSpec.label,
-      nodeOwnerRef: nodeSpec.owner.ref,
-      nodeOwnerType: nodeSpec.owner.executorType,
-      nodeType: nodeSpec.type,
-      nodeStartedAt: nodeRun.startedAt,
-      nodeAttemptCount: nodeRun.attemptCount + 1,
-      artifactCount: params.result.artifacts.length,
-      validationIssues: [...validation.blocking, ...validation.warnings],
-    }).catch((error) => {
-      aiLogger.warn`Failed to record node completion metrics for run ${runIdStr} node ${params.nodeId}: ${error instanceof Error ? error.message : String(error)}`
-    })
-
-    const updatedRun = await planRunService.getRunById(run.id)
-    if (updatedRun.status === 'completed') {
-      void runPlanCompletionSideEffectsSafely({ runId: runIdStr, organizationId: orgId })
-    }
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-
-    const snapshot = await planRunService.toSerializablePlan(updatedRun, {
-      includeEvents: true,
-      includeArtifacts: true,
-      includeApprovals: true,
-      includeCheckpoints: true,
-      includeValidationIssues: true,
-    })
-
-    return buildExecutionPlanToolResult({
-      action: 'node-result-submitted',
-      plan: snapshot,
-      message: `Submitted result for node "${nodeSpec.label}".`,
-    })
-  }
-
-  async submitHumanNodeResponse(params: {
-    threadId: RecordIdInput
-    approvalId?: string
-    respondedBy: string
-    response: Record<string, unknown>
-    approvalMessageId?: string
-  }): Promise<SerializableExecutionPlan | null> {
-    const run = await planRunService.getActiveRunRecord(params.threadId)
-    if (!run || run.status !== 'awaiting-human' || !run.waitingNodeId) {
-      return null
-    }
-
-    const spec = await planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
-    const nodeSpec = nodeSpecs.find((candidate) => candidate.nodeId === run.waitingNodeId)
-    if (!nodeSpec) {
-      throw new Error(`Waiting node "${run.waitingNodeId}" does not exist.`)
-    }
-
-    const nodeRun = await planRunService.getNodeRunByNodeId(run.id, run.waitingNodeId)
-    const approval =
-      (params.approvalId ? await planApprovalService.getApprovalById(params.approvalId) : null) ??
-      (await planApprovalService.getPendingApprovalForNodeRun(nodeRun.id))
-    if (!approval) {
-      throw new Error(`No pending approval exists for node "${nodeSpec.label}".`)
-    }
-
-    const existingArtifacts = await planRunService.listArtifacts(run.id)
-    const latestCheckpoint = await planRunService.getLatestCheckpoint(run.id)
-    const validation = planValidatorService.validateNodeResult({
-      draft: { schemas: spec.schemaRegistry },
-      node: toPlanNodeValidationSpec(nodeSpec),
-      result: {
-        structuredOutput: params.response,
-        artifacts: [],
-        notes: typeof params.response.comments === 'string' ? params.response.comments : 'Human response submitted.',
-      },
-    })
-    const emittedEvents: PlanEventRecord[] = []
-
-    await databaseService.withTransaction(async (tx) => {
-      const approvalStatus = deriveApprovalStatus(params.response)
-      await planApprovalService.updateApprovalResponse({
-        tx,
-        approval,
-        status: approvalStatus,
-        response: params.response,
-        respondedBy: params.respondedBy,
-        approvalMessageId: params.approvalMessageId,
-        comments: typeof params.response.comments === 'string' ? params.response.comments : undefined,
-        requiredEdits: Array.isArray(params.response.requiredEdits)
-          ? params.response.requiredEdits.filter((entry): entry is string => typeof entry === 'string')
-          : undefined,
-      })
-
-      const attempt = await this.createAttempt({
-        tx,
-        run,
-        nodeRun,
-        emittedBy: params.respondedBy,
-        result: {
-          structuredOutput: params.response,
-          artifacts: [],
-          notes: typeof params.response.comments === 'string' ? params.response.comments : 'Human response submitted.',
-        },
-        status: validation.blocking.length > 0 ? 'failed' : 'completed',
-        failureClass: validation.failureClass,
-      })
-
-      const issues = await this.persistValidationIssues({
-        tx,
-        run,
-        spec,
-        attemptId: attempt.id,
-        nodeId: nodeRun.nodeId,
-        issues: [...validation.blocking, ...validation.warnings],
-      })
-
-      await 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: params.response,
-          validationIssueIds: issues.map((issue) => ensureRecordId(issue.id, TABLES.PLAN_VALIDATION_ISSUE)),
-          ...(attempt.notes ? { notes: attempt.notes } : {}),
-          ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
-        })
-        .output('after')
-
-      const nextNodeRun =
-        validation.blocking.length > 0
-          ? PlanNodeRunSchema.parse(
-              await tx
-                .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-                .content(
-                  toNodeRunData(nodeRun, {
-                    status: 'blocked',
-                    attemptCount: nodeRun.attemptCount + 1,
-                    latestAttemptId: attempt.id,
-                    latestStructuredOutput: params.response,
-                    latestNotes: typeof params.response.comments === 'string' ? params.response.comments : null,
-                    blockedReason: validation.blocking[0]?.message ?? null,
-                    failureClass: validation.failureClass,
-                  }),
-                )
-                .output('after'),
-            )
-          : PlanNodeRunSchema.parse(
-              await tx
-                .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-                .content(
-                  toNodeRunData(nodeRun, {
-                    status: 'completed',
-                    attemptCount: nodeRun.attemptCount + 1,
-                    latestAttemptId: attempt.id,
-                    latestStructuredOutput: params.response,
-                    latestNotes: typeof params.response.comments === 'string' ? params.response.comments : null,
-                    blockedReason: null,
-                    failureClass: null,
-                    completedAt: new Date(),
-                  }),
-                )
-                .output('after'),
-            )
-
-      const nodeRuns = (await planRunService.listNodeRuns(run.id)).map((candidate) =>
-        candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-      )
-
-      if (validation.blocking.length > 0) {
-        const blockedRun = await this.replaceRun(tx, run, {
-          status: 'blocked',
-          currentNodeId: nextNodeRun.nodeId,
-          waitingNodeId: null,
-          readyNodeIds: [],
-          failureCount: run.failureCount + 1,
-        })
-
-        await this.emitEvent({
-          tx,
-          run: blockedRun,
-          spec,
-          nodeId: nextNodeRun.nodeId,
-          attemptId: attempt.id,
-          approvalId: approval.id,
-          eventType: 'approval-resolved',
-          fromStatus: run.status,
-          toStatus: blockedRun.status,
-          message: `Human response for node "${nodeSpec.label}" blocked execution.`,
-          detail: { issues: validation.blocking.map((issue) => issue.code) },
-          emittedBy: params.respondedBy,
-          capturedEvents: emittedEvents,
-        })
-
-        const checkpoint = await this.saveCheckpoint({
-          tx,
-          run: blockedRun,
-          spec,
-          nodeRuns,
-          artifacts: existingArtifacts,
-          sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-          reason: 'human-response-blocked',
-          capturedEvents: emittedEvents,
-        })
-        await this.attachCheckpoint(tx, blockedRun, checkpoint)
-        return
-      }
-
-      const synced = await this.syncRunGraph({
-        tx,
-        run,
-        spec,
-        nodeSpecs,
-        nodeRuns,
-        artifacts: existingArtifacts,
-        emittedBy: params.respondedBy,
-        capturedEvents: emittedEvents,
-      })
-
-      await this.emitEvent({
-        tx,
-        run: synced.run,
-        spec,
-        nodeId: nextNodeRun.nodeId,
-        attemptId: attempt.id,
-        approvalId: approval.id,
-        eventType: 'approval-resolved',
-        fromStatus: run.status,
-        toStatus: synced.run.status,
-        message: `Human response for node "${nodeSpec.label}" accepted.`,
-        detail: { approvalStatus: approvalStatus },
-        emittedBy: params.respondedBy,
-        capturedEvents: emittedEvents,
-      })
-
-      const checkpoint = await this.saveCheckpoint({
-        tx,
-        run: synced.run,
-        spec,
-        nodeRuns: synced.nodeRuns,
-        artifacts: synced.artifacts,
-        sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-        reason: 'human-response-complete',
-        capturedEvents: emittedEvents,
-      })
-      await this.attachCheckpoint(tx, synced.run, checkpoint)
-    })
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-
-    return planRunService.toSerializablePlan(await planRunService.getRunById(run.id), {
-      includeEvents: true,
-      includeArtifacts: true,
-      includeApprovals: true,
-      includeCheckpoints: true,
-      includeValidationIssues: true,
-    })
-  }
-
-  async resumeRun(params: {
-    threadId: RecordIdInput
-    runId: string
-    emittedBy: string
-  }): Promise<ExecutionPlanToolResultData> {
-    const run = await planRunService.getRunById(params.runId)
-
-    const spec = await planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
-    const nodeRuns = await planRunService.listNodeRuns(run.id)
-    const artifacts = await planRunService.listArtifacts(run.id)
-    const latestCheckpoint = await planRunService.getLatestCheckpoint(run.id)
-    const emittedEvents: PlanEventRecord[] = []
-
-    await databaseService.withTransaction(async (tx) => {
-      let currentNodeRuns = [...nodeRuns]
-      for (const nodeRun of currentNodeRuns.filter((candidate) => candidate.status === 'running')) {
-        const resetNodeRun = PlanNodeRunSchema.parse(
-          await tx
-            .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-            .content(
-              toNodeRunData(nodeRun, {
-                status: 'ready',
-                readyAt: new Date(),
-                startedAt: nodeRun.startedAt ?? new Date(),
-              }),
-            )
-            .output('after'),
-        )
-        currentNodeRuns = currentNodeRuns.map((candidate) =>
-          candidate.nodeId === resetNodeRun.nodeId ? resetNodeRun : candidate,
-        )
-      }
-
-      const resetRun = await this.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),
-      })
-
-      await this.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 }
-          : await this.syncRunGraph({
-              tx,
-              run: resetRun,
-              spec,
-              nodeSpecs,
-              nodeRuns: currentNodeRuns,
-              artifacts,
-              emittedBy: params.emittedBy,
-              capturedEvents: emittedEvents,
-            })
-
-      const checkpoint = await this.saveCheckpoint({
-        tx,
-        run: synced.run,
-        spec,
-        nodeRuns: synced.nodeRuns,
-        artifacts: synced.artifacts,
-        sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-        reason: 'run-resumed',
-        capturedEvents: emittedEvents,
-      })
-      await this.attachCheckpoint(tx, synced.run, checkpoint)
-    })
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-
-    const snapshot = await planRunService.toSerializablePlan(await planRunService.getRunById(run.id), {
-      includeEvents: true,
-      includeArtifacts: true,
-      includeApprovals: true,
-      includeCheckpoints: true,
-      includeValidationIssues: true,
-    })
-
-    return buildExecutionPlanToolResult({
-      action: 'run-resumed',
-      plan: snapshot,
-      message: `Resumed execution run "${snapshot.title}".`,
-    })
-  }
-
-  async transitionNodeToRunning(params: { runId: string; nodeId: string }): Promise<void> {
-    const run = await planRunService.getRunById(params.runId)
-    const nodeRun = await planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-    if (nodeRun.status !== 'ready') return
-
-    await databaseService.withTransaction(async (tx) => {
-      const runningNodeRun = PlanNodeRunSchema.parse(
-        await tx
-          .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(toNodeRunData(nodeRun, { status: 'running', startedAt: nodeRun.startedAt ?? new Date() }))
-          .output('after'),
-      )
-
-      const nodeRuns = await planRunService.listNodeRuns(run.id)
-      await this.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),
-      })
-    })
-  }
-
-  async blockNodeOnDispatchFailure(params: {
-    threadId: RecordIdInput
-    runId: string
-    nodeId: string
-    emittedBy: string
-    message: string
-    failureClass: PlanFailureClass
-  }): Promise<SerializableExecutionPlan> {
-    const run = await planRunService.getRunById(params.runId)
-
-    const spec = await planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpec = await planRunService.getNodeSpecByNodeId(spec.id, params.nodeId)
-    const nodeRun = await planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-    const artifacts = await planRunService.listArtifacts(run.id)
-    const latestCheckpoint = await planRunService.getLatestCheckpoint(run.id)
-    const emittedEvents: PlanEventRecord[] = []
-
-    await databaseService.withTransaction(async (tx) => {
-      const blockedNodeRun =
-        nodeRun.status === 'blocked'
-          ? nodeRun
-          : PlanNodeRunSchema.parse(
-              await tx
-                .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-                .content(
-                  toNodeRunData(nodeRun, {
-                    status: 'blocked',
-                    blockedReason: params.message,
-                    failureClass: params.failureClass,
-                  }),
-                )
-                .output('after'),
-            )
-
-      const blockedRun = await this.replaceRun(tx, run, {
-        status: 'blocked',
-        currentNodeId: blockedNodeRun.nodeId,
-        waitingNodeId: null,
-        readyNodeIds: [],
-        failureCount: run.failureCount + 1,
-      })
-
-      await this.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 checkpoint = await this.saveCheckpoint({
-        tx,
-        run: blockedRun,
-        spec,
-        nodeRuns: (await planRunService.listNodeRuns(run.id)).map((candidate) =>
-          candidate.nodeId === blockedNodeRun.nodeId ? blockedNodeRun : candidate,
-        ),
-        artifacts,
-        sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-        reason: 'owner-dispatch-failed',
-        capturedEvents: emittedEvents,
-      })
-      await this.attachCheckpoint(tx, blockedRun, checkpoint)
-    })
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-
-    return planRunService.toSerializablePlan(await planRunService.getRunById(run.id), {
-      includeEvents: true,
-      includeArtifacts: true,
-      includeApprovals: true,
-      includeCheckpoints: true,
-      includeValidationIssues: true,
-    })
-  }
-
-  async promoteDelayedNode(params: { runId: string; nodeId: string; emittedBy: string }): Promise<void> {
-    const run = await planRunService.getRunById(params.runId)
-    if (run.status === 'completed' || run.status === 'failed' || run.status === 'aborted') {
-      return // Run is no longer active, skip promotion
-    }
-
-    const spec = await planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
-    const nodeRun = await planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-
-    // Only promote if still in scheduled state (delay hasn't been superseded)
-    if (nodeRun.status !== 'scheduled') return
-
-    const nodeRuns = await planRunService.listNodeRuns(run.id)
-    const artifacts = await planRunService.listArtifacts(run.id)
-    const latestCheckpoint = await planRunService.getLatestCheckpoint(run.id)
-    const emittedEvents: PlanEventRecord[] = []
-
-    await databaseService.withTransaction(async (tx) => {
-      const readyNodeRun = PlanNodeRunSchema.parse(
-        await tx
-          .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(toNodeRunData(nodeRun, { status: 'ready', readyAt: new Date() }))
-          .output('after'),
-      )
-
-      const updatedNodeRuns = nodeRuns.map((candidate) =>
-        candidate.nodeId === readyNodeRun.nodeId ? readyNodeRun : candidate,
-      )
-
-      const nodeSpec = nodeSpecs.find((s) => s.nodeId === params.nodeId)
-      await this.emitEvent({
-        tx,
-        run,
-        spec,
-        nodeId: readyNodeRun.nodeId,
-        eventType: 'node-ready',
-        fromStatus: nodeRun.status,
-        toStatus: readyNodeRun.status,
-        message: `Node "${nodeSpec?.label ?? params.nodeId}" promoted to ready after delay.`,
-        emittedBy: params.emittedBy,
-        capturedEvents: emittedEvents,
-      })
-
-      const synced = await this.syncRunGraph({
-        tx,
-        run,
-        spec,
-        nodeSpecs,
-        nodeRuns: updatedNodeRuns,
-        artifacts,
-        emittedBy: params.emittedBy,
-        capturedEvents: emittedEvents,
-      })
-
-      const checkpoint = await this.saveCheckpoint({
-        tx,
-        run: synced.run,
-        spec,
-        nodeRuns: synced.nodeRuns,
-        artifacts: synced.artifacts,
-        sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-        reason: 'delayed-node-promoted',
-        capturedEvents: emittedEvents,
-      })
-      await this.attachCheckpoint(tx, synced.run, checkpoint)
-    })
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-  }
-
-  async syncRunGraph(params: {
-    tx: DatabaseTransaction
-    run: PlanRunRecord
-    spec: PlanSpecRecord
-    nodeSpecs: PlanNodeSpecRecord[]
-    nodeRuns: PlanNodeRunRecord[]
-    artifacts: Array<{
-      id: RecordIdInput
-      nodeId: string
-      name: string
-      kind: string
-      pointer: string
-      schemaRef?: string
-      payload?: unknown
-    }>
-    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
-    }>
-  }> {
-    let currentRun = params.run
-    let currentNodeRuns = [...params.nodeRuns]
-    const currentArtifacts = [...params.artifacts]
-    const sortedNodeSpecs = [...params.nodeSpecs].sort((left, right) => left.position - right.position)
-
-    // Cross-plan dependency check: if spec has block-mode dependencies that are unresolved, block the run
-    if (params.spec.dependencies && params.spec.dependencies.length > 0) {
-      const { unresolved } = await planCoordinationService.resolveDependencies({
-        dependencies: params.spec.dependencies,
-        threadId: recordIdToString(params.spec.threadId, TABLES.THREAD),
-      })
-      if (unresolved.length > 0) {
-        currentRun = await this.replaceRun(params.tx, currentRun, { status: 'blocked', readyNodeIds: [] })
-        await this.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 }
-      }
-    }
-
-    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>())
-
-    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
-
-        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
-        }
-
-        const activeIncomingEdges = params.spec.edges.filter((edge) => {
-          if (edge.target !== nodeSpec.nodeId) return false
-          const sourceRun = nodeRunsById.get(edge.source)
-          if (!sourceRun) return false
-          const context = buildNodeContext({ nodeRun: sourceRun, artifacts: artifactsByNodeId.get(edge.source) ?? [] })
-          return evaluateCondition(edge.when, context)
-        })
-
-        if (nodeSpec.upstreamNodeIds.length > 0 && activeIncomingEdges.length === 0) {
-          const skippedNodeRun = PlanNodeRunSchema.parse(
-            await params.tx
-              .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(
-                toNodeRunData(nodeRun, {
-                  status: 'skipped',
-                  completedAt: new Date(),
-                  blockedReason: null,
-                  failureClass: null,
-                }),
-              )
-              .output('after'),
-          )
-          replaceNodeRun(skippedNodeRun)
-          await this.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 resolvedInput = this.buildResolvedInput({ spec: params.spec, nodeSpec, nodeRunsById, artifactsByNodeId })
-
-        const nodeSchedule = nodeSpec.schedule
-        const hasNonImmediateSchedule = nodeSchedule && nodeSchedule.type !== 'immediate'
-
-        if (hasNonImmediateSchedule) {
-          const scheduledNodeRun = PlanNodeRunSchema.parse(
-            await params.tx
-              .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(toNodeRunData(nodeRun, { status: 'scheduled', resolvedInput, scheduledAt: new Date() }))
-              .output('after'),
-          )
-          replaceNodeRun(scheduledNodeRun)
-          await planSchedulerService.createSchedule({
-            organizationId: currentRun.organizationId,
-            threadId: currentRun.threadId,
-            planSpecId: params.spec.id,
-            runId: currentRun.id,
-            nodeId: nodeSpec.nodeId,
-            scheduleSpec: nodeSchedule,
-          })
-          await this.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) {
-          // Event-triggered delay: enqueue a delayed promotion instead of transitioning to ready immediately
-          const { enqueueDelayedNodePromotion } = await import('../queues/delayed-node-promotion.queue')
-          const scheduledNodeRun = PlanNodeRunSchema.parse(
-            await params.tx
-              .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(toNodeRunData(nodeRun, { status: 'scheduled', resolvedInput, scheduledAt: new Date() }))
-              .output('after'),
-          )
-          replaceNodeRun(scheduledNodeRun)
-          await enqueueDelayedNodePromotion(
-            {
-              runId: recordIdToString(currentRun.id, TABLES.PLAN_RUN),
-              nodeId: nodeSpec.nodeId,
-              emittedBy: params.emittedBy,
-            },
-            nodeSpec.delayAfterPredecessorMs,
-          )
-          await this.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 ${nodeSpec.delayAfterPredecessorMs}ms after predecessor.`,
-            emittedBy: params.emittedBy,
-            capturedEvents: params.capturedEvents,
-          })
-          changed = true
-        } else {
-          const readyNodeRun = PlanNodeRunSchema.parse(
-            await params.tx
-              .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(toNodeRunData(nodeRun, { status: 'ready', resolvedInput, readyAt: new Date() }))
-              .output('after'),
-          )
-          replaceNodeRun(readyNodeRun)
-          await this.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
-        }
-      }
-
-      const readyStructuralNodes = sortedNodeSpecs.filter((nodeSpec) => {
-        const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
-        return nodeRun?.status === 'ready' && isStructuralNodeType(nodeSpec.type)
-      })
-
-      for (const nodeSpec of readyStructuralNodes) {
-        const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
-        if (!nodeRun) continue
-
-        const completedNodeRun = PlanNodeRunSchema.parse(
-          await params.tx
-            .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-            .content(
-              toNodeRunData(nodeRun, {
-                status: 'completed',
-                startedAt: nodeRun.startedAt ?? new Date(),
-                completedAt: new Date(),
-              }),
-            )
-            .output('after'),
-        )
-        replaceNodeRun(completedNodeRun)
-        await this.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) {
-          throw new Error(`Expected ready node run for "${nextHumanNodeSpec.nodeId}".`)
-        }
-        const awaitingHumanNodeRun = PlanNodeRunSchema.parse(
-          await params.tx
-            .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-            .content(toNodeRunData(nodeRun, { status: 'awaiting-human', startedAt: nodeRun.startedAt ?? new Date() }))
-            .output('after'),
-        )
-        replaceNodeRun(awaitingHumanNodeRun)
-
-        const approval = await 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 = await this.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),
-        })
-
-        await this.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' && !isStructuralNodeType(nodeSpec.type)
-        })
-
-        if (nextActionNodeSpec) {
-          const nodeRun = nodeRunsById.get(nextActionNodeSpec.nodeId)
-          if (!nodeRun) {
-            throw new Error(`Expected ready node run for "${nextActionNodeSpec.nodeId}".`)
-          }
-          const runningNodeRun = PlanNodeRunSchema.parse(
-            await params.tx
-              .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(toNodeRunData(nodeRun, { status: 'running', startedAt: nodeRun.startedAt ?? new Date() }))
-              .output('after'),
-          )
-          replaceNodeRun(runningNodeRun)
-
-          currentRun = await this.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),
-          })
-
-          await this.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,
-          })
-          await this.emitEvent({
-            tx: params.tx,
-            run: currentRun,
-            spec: params.spec,
-            nodeId: runningNodeRun.nodeId,
-            eventType: 'ownership-transition',
-            fromStatus: params.run.currentNodeId ?? undefined,
-            toStatus: runningNodeRun.nodeId,
-            message: `Execution ownership transitioned to "${nextActionNodeSpec.label}".`,
-            detail: { owner: nextActionNodeSpec.owner },
-            emittedBy: params.emittedBy,
-            capturedEvents: params.capturedEvents,
-          })
-        } else if (currentNodeRuns.every((nodeRun) => isSuccessfulTerminalStatus(nodeRun.status))) {
-          currentRun = await this.replaceRun(params.tx, currentRun, {
-            status: 'completed',
-            currentNodeId: null,
-            waitingNodeId: null,
-            readyNodeIds: [],
-            completedAt: new Date(),
-          })
-
-          await this.emitEvent({
-            tx: params.tx,
-            run: currentRun,
-            spec: params.spec,
-            eventType: 'run-status-changed',
-            fromStatus: params.run.status,
-            toStatus: currentRun.status,
-            message: `Run "${params.spec.title}" completed.`,
-            emittedBy: params.emittedBy,
-            capturedEvents: params.capturedEvents,
-          })
-        } else if (hasScheduledOrMonitoring) {
-          // Nodes are waiting on schedules/monitors — run stays active
-          currentRun = await this.replaceRun(params.tx, currentRun, {
-            status: 'running',
-            currentNodeId: null,
-            waitingNodeId: null,
-            readyNodeIds: currentNodeRuns
-              .filter((candidate) => candidate.status === 'ready')
-              .map((candidate) => candidate.nodeId),
-          })
-        } else {
-          currentRun = await this.replaceRun(params.tx, currentRun, {
-            status: 'blocked',
-            currentNodeId: null,
-            waitingNodeId: null,
-            readyNodeIds: currentNodeRuns
-              .filter((candidate) => candidate.status === 'ready')
-              .map((candidate) => candidate.nodeId),
-          })
-        }
-      }
-    } else {
-      currentRun = await this.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 }
-  }
-
-  private resolveFailureAction(nodeSpec: PlanNodeSpecRecord, failureClass: PlanFailureClass | null): PlanFailureAction {
-    if (!failureClass) return 'abort'
-
-    const matchedRule = nodeSpec.failurePolicy.find((rule) => rule.on === failureClass)
-    return matchedRule?.action ?? 'abort'
-  }
-
-  private buildResolvedInput(params: {
-    spec: PlanSpecRecord
-    nodeSpec: PlanNodeSpecRecord
-    nodeRunsById: Map<string, PlanNodeRunRecord>
-    artifactsByNodeId: Map<
-      string,
-      Array<{ nodeId: string; name: string; kind: string; pointer: string; schemaRef?: string; payload?: unknown }>
-    >
-  }) {
-    const resolvedInput: Record<string, unknown> = {}
-
-    for (const edge of params.spec.edges.filter((candidate) => candidate.target === params.nodeSpec.nodeId)) {
-      const sourceRun = params.nodeRunsById.get(edge.source)
-      if (!sourceRun || !isSuccessfulTerminalStatus(sourceRun.status)) continue
-
-      const context = buildNodeContext({
-        nodeRun: sourceRun,
-        artifacts: params.artifactsByNodeId.get(edge.source) ?? [],
-      })
-      if (!evaluateCondition(edge.when, context)) continue
-
-      for (const [targetPath, sourcePath] of Object.entries(edge.map)) {
-        const value = readPathValue(context, sourcePath)
-        if (value !== undefined) {
-          setPathValue(resolvedInput, targetPath, value)
-        }
-      }
-    }
-
-    return resolvedInput
-  }
-
-  private async createAttempt(params: {
-    tx: DatabaseTransaction
-    run: PlanRunRecord
-    nodeRun: PlanNodeRunRecord
-    emittedBy: string
-    result: PlanNodeResultSubmission
-    status: 'completed' | 'failed'
-    failureClass: PlanFailureClass | null
-  }) {
-    const attemptId = new RecordId(TABLES.PLAN_NODE_ATTEMPT, Bun.randomUUIDv7())
-    return PlanNodeAttemptSchema.parse(
-      await params.tx
-        .create(attemptId)
-        .content({
-          runId: ensureRecordId(params.run.id, TABLES.PLAN_RUN),
-          nodeRunId: ensureRecordId(params.nodeRun.id, TABLES.PLAN_NODE_RUN),
-          nodeId: params.nodeRun.nodeId,
-          emittedBy: params.emittedBy,
-          status: params.status,
-          ...(params.result.structuredOutput ? { structuredOutput: params.result.structuredOutput } : {}),
-          ...(params.result.notes ? { notes: params.result.notes } : {}),
-          validationIssueIds: [],
-          ...(params.failureClass ? { failureClass: params.failureClass } : {}),
-        })
-        .output('after'),
-    )
-  }
-
-  private async persistValidationIssues(params: {
-    tx: DatabaseTransaction
-    run: PlanRunRecord
-    spec: PlanSpecRecord
-    attemptId: RecordIdInput
-    nodeId: string
-    issues: PlanValidationIssueInput[]
-  }): Promise<PlanValidationIssueRecord[]> {
-    const records: PlanValidationIssueRecord[] = []
-
-    for (const issue of params.issues) {
-      const issueId = new RecordId(TABLES.PLAN_VALIDATION_ISSUE, Bun.randomUUIDv7())
-      const created = await params.tx
-        .create(issueId)
-        .content({
-          planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(params.run.id, TABLES.PLAN_RUN),
-          nodeId: issue.nodeId ?? params.nodeId,
-          attemptId: ensureRecordId(params.attemptId, TABLES.PLAN_NODE_ATTEMPT),
-          severity: issue.severity,
-          code: issue.code,
-          message: issue.message,
-          ...(issue.detail ? { detail: issue.detail } : {}),
-        })
-        .output('after')
-
-      records.push(PlanValidationIssueSchema.parse(created))
-    }
-
-    return records
-  }
-
-  private async emitEvent(params: {
-    tx: DatabaseTransaction
-    run: PlanRunRecord
-    spec: PlanSpecRecord
-    eventType: PlanEventType
-    message: string
-    emittedBy: string
-    nodeId?: string
-    attemptId?: RecordIdInput
-    approvalId?: RecordIdInput
-    fromStatus?: string
-    toStatus?: string
-    detail?: Record<string, unknown>
-    capturedEvents?: PlanEventRecord[]
-  }): Promise<PlanEventRecord> {
-    const eventId = new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7())
-    const created = await params.tx
-      .create(eventId)
-      .content({
-        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-        runId: ensureRecordId(params.run.id, TABLES.PLAN_RUN),
-        eventType: params.eventType,
-        message: params.message,
-        emittedBy: params.emittedBy,
-        ...(params.nodeId ? { nodeId: params.nodeId } : {}),
-        ...(params.attemptId ? { attemptId: ensureRecordId(params.attemptId, TABLES.PLAN_NODE_ATTEMPT) } : {}),
-        ...(params.approvalId ? { approvalId: ensureRecordId(params.approvalId, TABLES.PLAN_APPROVAL) } : {}),
-        ...(params.fromStatus ? { fromStatus: params.fromStatus } : {}),
-        ...(params.toStatus ? { toStatus: params.toStatus } : {}),
-        ...(params.detail ? { detail: params.detail } : {}),
-      })
-      .output('after')
-
-    const event = PlanEventSchema.parse(created)
-    params.capturedEvents?.push(event)
-    return event
-  }
-
-  private async replaceRun(tx: DatabaseTransaction, run: PlanRunRecord, patch: PlanRunUpdate): Promise<PlanRunRecord> {
-    return PlanRunSchema.parse(
-      await tx.update(ensureRecordId(run.id, TABLES.PLAN_RUN)).content(toRunData(run, patch)).output('after'),
-    )
-  }
-
-  private async saveCheckpoint(params: {
-    tx: DatabaseTransaction
-    run: PlanRunRecord
-    spec: PlanSpecRecord
-    nodeRuns: PlanNodeRunRecord[]
-    artifacts: Array<{ id: RecordIdInput; nodeId: string }>
-    sequence: number
-    reason: string
-    includeWorkspace?: boolean
-    capturedEvents?: PlanEventRecord[]
-  }) {
-    const checkpoint = await planCheckpointService.createCheckpoint({
-      tx: params.tx,
-      runId: params.run.id,
-      sequence: params.sequence,
-      runStatus: params.run.status,
-      readyNodeIds: params.run.readyNodeIds,
-      activeNodeIds: params.run.currentNodeId ? [params.run.currentNodeId] : [],
-      artifactIds: params.artifacts.map((artifact) => artifact.id),
-      lastCompletedNodeIds: params.nodeRuns
-        .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
-        .map((nodeRun) => nodeRun.nodeId),
-      snapshot: {
-        reason: params.reason,
-        runStatus: params.run.status,
-        currentNodeId: params.run.currentNodeId,
-        waitingNodeId: params.run.waitingNodeId,
-        readyNodeIds: params.run.readyNodeIds,
-        nodeStatuses: Object.fromEntries(params.nodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun.status])),
-      },
-      includeWorkspace: params.includeWorkspace,
-    })
-
-    await this.emitEvent({
-      tx: params.tx,
-      run: params.run,
-      spec: params.spec,
-      eventType: 'checkpoint-saved',
-      message: `Saved checkpoint ${checkpoint.sequence}.`,
-      detail: { checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT), reason: params.reason },
-      emittedBy: 'system',
-      capturedEvents: params.capturedEvents,
-    })
-
-    return checkpoint
-  }
-
-  private async attachCheckpoint(
-    tx: DatabaseTransaction,
-    run: PlanRunRecord,
-    checkpoint: RecordIdInput | { id: RecordIdInput },
-  ) {
-    const checkpointId =
-      checkpoint &&
-      typeof checkpoint === 'object' &&
-      !(checkpoint instanceof RecordId) &&
-      !(checkpoint instanceof StringRecordId) &&
-      'id' in checkpoint
-        ? (checkpoint as { id: RecordIdInput }).id
-        : checkpoint
-
-    await tx
-      .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
-      .content(toRunData(run, { lastCheckpointId: checkpointId }))
-      .output('after')
-  }
-}
-
-export const planExecutorService = new PlanExecutorService()