@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -1,1118 +0,0 @@
-import type {
-  ChatMessage,
-  ExecutionPlanQueryArgs,
-  ExecutionPlanToolResultData,
-  ListExecutionPlansSummary,
-  ListExecutionPlansToolResultData,
-  PlanEventRecord,
-  PlanDraft,
-  PlanNodeRunRecord,
-  PlanNodeSpecRecord,
-  PlanRunRecord,
-  PlanSpecRecord,
-  SerializableExecutionPlan,
-  SubmitPlanTurnResultArgs,
-  SubmitExecutionNodeResultArgs,
-} from '@lota-sdk/shared'
-import {
-  PlanCheckpointSchema,
-  PlanDraftSchema,
-  PlanEventSchema,
-  PlanNodeRunSchema,
-  PlanNodeSpecRecordSchema,
-  PlanRunSchema,
-  PlanSpecSchema,
-} from '@lota-sdk/shared'
-import { RecordId } from 'surrealdb'
-
-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 { readApprovalContinuationResponse } from '../runtime/approval-continuation'
-import { extractMessageText } from '../runtime/thread-chat-helpers'
-import { toDatabaseDateTime } from '../utils/date-time'
-import { ownershipDispatcherService } from './ownership-dispatcher.service'
-import { planBuilderService } from './plan-builder.service'
-import type { CompiledPlanNode } from './plan-compiler.service'
-import { planCompilerService } from './plan-compiler.service'
-import { planEventDeliveryService } from './plan-event-delivery.service'
-import { planExecutorService } from './plan-executor.service'
-import { buildExecutionPlanToolResult, toRunData } from './plan-run-data'
-import { planRunService } from './plan-run.service'
-import { planSchedulerService } from './plan-scheduler.service'
-import { planValidatorService } from './plan-validator.service'
-
-function aggregateBlockingIssues(issues: Array<{ code: string; message: string }>): string {
-  return issues.map((issue) => `${issue.code}: ${issue.message}`).join(' | ')
-}
-
-function hasCrossThreadSourceContext(sourceThreadId: RecordIdInput | undefined, threadId: RecordIdInput): boolean {
-  if (!sourceThreadId) {
-    return false
-  }
-
-  return recordIdToString(sourceThreadId, TABLES.THREAD) !== recordIdToString(threadId, TABLES.THREAD)
-}
-
-function isPlanVisibleInThreadContext(
-  threadId: RecordIdInput,
-  params: { threadId: RecordIdInput; sourceThreadId?: RecordIdInput },
-): boolean {
-  const currentThreadId = recordIdToString(threadId, TABLES.THREAD)
-  return (
-    currentThreadId === recordIdToString(params.threadId, TABLES.THREAD) ||
-    (params.sourceThreadId !== undefined && currentThreadId === recordIdToString(params.sourceThreadId, TABLES.THREAD))
-  )
-}
-
-function toSpecData(spec: PlanSpecRecord, patch: Partial<PlanSpecRecord> & { replacedSpecId?: RecordIdInput | null }) {
-  return {
-    organizationId: ensureRecordId(spec.organizationId, TABLES.ORGANIZATION),
-    threadId: ensureRecordId(spec.threadId, TABLES.THREAD),
-    title: patch.title ?? spec.title,
-    objective: patch.objective ?? spec.objective,
-    version: patch.version ?? spec.version,
-    status: patch.status ?? spec.status,
-    leadAgentId: patch.leadAgentId ?? spec.leadAgentId,
-    schemaRegistry: patch.schemaRegistry ? structuredClone(patch.schemaRegistry) : structuredClone(spec.schemaRegistry),
-    edges: patch.edges ? [...patch.edges] : [...spec.edges],
-    entryNodeIds: patch.entryNodeIds ? [...patch.entryNodeIds] : [...spec.entryNodeIds],
-    defaultExecutionVisibility: patch.defaultExecutionVisibility ?? spec.defaultExecutionVisibility,
-    executionMode: patch.executionMode ?? spec.executionMode,
-    ...(patch.schedule !== undefined ? { schedule: patch.schedule } : spec.schedule ? { schedule: spec.schedule } : {}),
-    ...(patch.dependencies !== undefined
-      ? { dependencies: patch.dependencies }
-      : spec.dependencies
-        ? { dependencies: spec.dependencies }
-        : {}),
-    ...(spec.contextEnrichments ? { contextEnrichments: spec.contextEnrichments } : {}),
-    ...(patch.replacedSpecId
-      ? { replacedSpecId: ensureRecordId(patch.replacedSpecId, TABLES.PLAN_SPEC) }
-      : spec.replacedSpecId
-        ? { replacedSpecId: ensureRecordId(spec.replacedSpecId, TABLES.PLAN_SPEC) }
-        : {}),
-    ...(patch.compiledAt !== undefined
-      ? { compiledAt: toDatabaseDateTime(patch.compiledAt) }
-      : spec.compiledAt
-        ? { compiledAt: toDatabaseDateTime(spec.compiledAt) }
-        : {}),
-  }
-}
-
-function buildApprovalResponseFromMessages(
-  messages: ChatMessage[],
-): { approvalId: string; response: Record<string, unknown> } | null {
-  for (const message of [...messages].reverse()) {
-    if (message.role !== 'assistant') continue
-    const approvalResponse = readApprovalContinuationResponse(message)
-    if (!approvalResponse) continue
-
-    const response: Record<string, unknown> = {
-      approved: approvalResponse.approved,
-      requiredEdits: [...approvalResponse.requiredEdits],
-    }
-    if (approvalResponse.comments) {
-      response.comments = approvalResponse.comments
-    }
-
-    return { approvalId: approvalResponse.approvalId, response }
-  }
-
-  return null
-}
-
-function buildCompiledSpecCreateData(params: {
-  organizationId: RecordIdInput
-  threadId: RecordIdInput
-  leadAgentId: string
-  compiled: ReturnType<typeof planCompilerService.compile>
-  version: number
-  replacedSpecId?: RecordIdInput
-  contextEnrichments?: PlanSpecRecord['contextEnrichments']
-}) {
-  return {
-    organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-    threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-    title: params.compiled.draft.title,
-    objective: params.compiled.draft.objective,
-    version: params.version,
-    status: 'compiled' as const,
-    leadAgentId: params.leadAgentId,
-    schemaRegistry: structuredClone(params.compiled.draft.schemas),
-    defaultExecutionVisibility: params.compiled.draft.defaultExecutionVisibility,
-    ...(params.contextEnrichments?.length
-      ? { contextEnrichments: params.contextEnrichments.map((entry) => ({ ...entry })) }
-      : {}),
-    edges: [...params.compiled.draft.edges],
-    entryNodeIds: [...(params.compiled.draft.entryNodeIds ?? [])],
-    executionMode: params.compiled.draft.executionMode ?? 'linear',
-    ...(params.compiled.draft.schedule ? { schedule: params.compiled.draft.schedule } : {}),
-    ...(params.compiled.draft.dependencies ? { dependencies: params.compiled.draft.dependencies } : {}),
-    ...(params.replacedSpecId ? { replacedSpecId: ensureRecordId(params.replacedSpecId, TABLES.PLAN_SPEC) } : {}),
-    compiledAt: new Date(),
-  }
-}
-
-class ExecutionPlanService {
-  async hasActivePlan(threadId: RecordIdInput): Promise<boolean> {
-    return (await planRunService.getActiveRunRecord(threadId)) !== null
-  }
-
-  async getActivePlanForThread(
-    threadId: RecordIdInput,
-    options?: Partial<ExecutionPlanQueryArgs> & { runId?: RecordIdInput },
-  ): Promise<SerializableExecutionPlan | null> {
-    const plans = await this.getActivePlansForThread(threadId, options)
-    return plans[0] ?? null
-  }
-
-  async getActivePlansForThread(
-    threadId: RecordIdInput,
-    options?: Partial<ExecutionPlanQueryArgs> & { runId?: RecordIdInput },
-  ): Promise<SerializableExecutionPlan[]> {
-    if (options?.runId) {
-      const run = await planRunService.getRunById(options.runId)
-      return [
-        await planRunService.toSerializablePlan(run, {
-          includeEvents: options.includeEvents,
-          includeArtifacts: options.includeArtifacts,
-          includeApprovals: options.includeApprovals,
-          includeCheckpoints: options.includeCheckpoints,
-          includeValidationIssues: options.includeValidationIssues,
-        }),
-      ]
-    }
-
-    const runs = await planRunService.getActiveRunRecords(threadId)
-    if (runs.length === 0) return []
-
-    return await this.serializeRuns(runs, options)
-  }
-
-  async getPlansCreatedInContext(params: {
-    organizationId: RecordIdInput
-    sourceThreadId?: RecordIdInput
-    createdByAgentId?: string
-    statuses?: ReadonlyArray<PlanRunRecord['status']>
-    includeEvents?: boolean
-    includeArtifacts?: boolean
-    includeApprovals?: boolean
-    includeCheckpoints?: boolean
-    includeValidationIssues?: boolean
-  }): Promise<SerializableExecutionPlan[]> {
-    const runs = await planRunService.getRunsCreatedInContext({
-      organizationId: params.organizationId,
-      sourceThreadId: params.sourceThreadId,
-      createdByAgentId: params.createdByAgentId,
-      statuses: params.statuses,
-    })
-    if (runs.length === 0) return []
-
-    return await this.serializeRuns(runs, params)
-  }
-
-  async listActivePlanSummaries(threadId: RecordIdInput): Promise<ListExecutionPlansToolResultData> {
-    const runs = await planRunService.getActiveRunRecords(threadId)
-    const plans: ListExecutionPlansSummary[] = await Promise.all(
-      runs.map(async (run) => {
-        const spec = await planRunService.getPlanSpecById(run.planSpecId)
-        const nodeRuns = await planRunService.listNodeRuns(run.id)
-        return {
-          runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-          title: spec.title,
-          status: run.status,
-          objective: spec.objective,
-          nodeCount: nodeRuns.length,
-          completedCount: nodeRuns.filter((n) => n.status === 'completed' || n.status === 'partial').length,
-          failedCount: nodeRuns.filter((n) => n.status === 'failed').length,
-        }
-      }),
-    )
-    return { plans, totalCount: plans.length }
-  }
-
-  async getActivePlanToolResult(params: {
-    threadId: RecordIdInput
-    runId?: string
-    includeEvents?: boolean
-    includeArtifacts?: boolean
-    includeApprovals?: boolean
-    includeCheckpoints?: boolean
-    includeValidationIssues?: boolean
-  }): Promise<ExecutionPlanToolResultData> {
-    const serializeOptions = {
-      includeEvents: params.includeEvents,
-      includeArtifacts: params.includeArtifacts,
-      includeApprovals: params.includeApprovals,
-      includeCheckpoints: params.includeCheckpoints,
-      includeValidationIssues: params.includeValidationIssues,
-    }
-
-    if (params.runId) {
-      const plan = await planRunService
-        .getRunById(params.runId)
-        .then((run) => planRunService.toSerializablePlan(run, serializeOptions))
-      return buildExecutionPlanToolResult({ action: 'loaded', plan, message: `Loaded execution run "${plan.title}".` })
-    }
-
-    const runs = await planRunService.getActiveRunRecords(params.threadId)
-    if (runs.length === 0) {
-      return buildExecutionPlanToolResult({ action: 'none', plan: null, message: 'No active execution run.' })
-    }
-
-    const plan = await planRunService.toSerializablePlan(runs[0], serializeOptions)
-
-    return buildExecutionPlanToolResult({
-      action: 'loaded',
-      plan,
-      message:
-        runs.length === 1
-          ? `Loaded execution run "${plan.title}".`
-          : `Loaded ${runs.length} active execution runs. Showing most recent: "${plan.title}".`,
-    })
-  }
-
-  async createPlan(params: {
-    organizationId: RecordIdInput
-    threadId: RecordIdInput
-    sourceThreadId?: RecordIdInput
-    leadAgentId: string
-    createdByAgentId?: string
-    requireApproval?: boolean
-    input: PlanDraft
-  }): Promise<ExecutionPlanToolResultData> {
-    const requireApproval =
-      params.requireApproval ?? hasCrossThreadSourceContext(params.sourceThreadId, params.threadId)
-    const preparedDraft = planBuilderService.prepareDraft(PlanDraftSchema.parse(params.input))
-    const validation = planValidatorService.validateDraft(preparedDraft)
-    if (validation.blocking.length > 0) {
-      throw new Error(`Plan draft failed validation: ${aggregateBlockingIssues(validation.blocking)}`)
-    }
-    await this.assertDispatchExecutors(preparedDraft)
-    const compiled = planCompilerService.compile(preparedDraft)
-
-    const specId = new RecordId(TABLES.PLAN_SPEC, Bun.randomUUIDv7())
-    const runId = new RecordId(TABLES.PLAN_RUN, Bun.randomUUIDv7())
-    const emittedEvents: PlanEventRecord[] = []
-
-    await databaseService.withTransaction(async (tx) => {
-      const spec = PlanSpecSchema.parse(
-        await tx
-          .create(specId)
-          .content(
-            buildCompiledSpecCreateData({
-              organizationId: params.organizationId,
-              threadId: params.threadId,
-              leadAgentId: params.leadAgentId,
-              compiled,
-              version: 1,
-            }),
-          )
-          .output('after'),
-      )
-      await this.createInitializedRunGraph({
-        tx,
-        runId,
-        spec,
-        organizationId: params.organizationId,
-        threadId: params.threadId,
-        sourceThreadId: params.sourceThreadId,
-        leadAgentId: params.leadAgentId,
-        createdByAgentId: params.createdByAgentId,
-        requireApproval,
-        nodes: compiled.nodes,
-        emittedEvents,
-        createdEventType: 'plan-created',
-        createdEventMessage: `Created execution plan "${spec.title}".`,
-        createdEventDetail: { title: spec.title, objective: spec.objective },
-        checkpointReason: 'plan-created',
-      })
-    })
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-
-    if (!requireApproval) {
-      await this.attachPlanScheduleIfNeeded({
-        organizationId: params.organizationId,
-        threadId: params.threadId,
-        runId,
-        planSpecId: specId,
-      })
-    }
-
-    const plan = await this.finalizePlanSnapshot({ runId, emittedBy: params.leadAgentId })
-
-    return buildExecutionPlanToolResult({ action: 'created', plan, message: `Created execution plan "${plan.title}".` })
-  }
-
-  async replacePlan(params: {
-    threadId: RecordIdInput
-    organizationId: RecordIdInput
-    leadAgentId: string
-    createdByAgentId?: string
-    input: PlanDraft & { runId: string; reason: string; requireApproval?: boolean }
-  }): Promise<ExecutionPlanToolResultData> {
-    const activeRun = await planRunService.getRunById(params.input.runId)
-    const resolvedThreadId = activeRun.threadId
-
-    const activeRuns = await planRunService.getActiveRunRecords(resolvedThreadId)
-    if (activeRuns.length === 0) {
-      throw new Error('No active execution run exists for this thread.')
-    }
-    if (!activeRuns.some((run) => recordIdToString(run.id, TABLES.PLAN_RUN) === params.input.runId)) {
-      throw new Error('Only an active execution run can be replaced.')
-    }
-
-    const activeSpec = await planRunService.getPlanSpecById(activeRun.planSpecId)
-    const { runId: _runId, reason: _reason, requireApproval: requestedRequireApproval, ...draftInput } = params.input
-    const preparedDraft = planBuilderService.prepareDraft(PlanDraftSchema.parse(draftInput))
-    const validation = planValidatorService.validateDraft(preparedDraft)
-    if (validation.blocking.length > 0) {
-      throw new Error(`Plan draft failed validation: ${aggregateBlockingIssues(validation.blocking)}`)
-    }
-    await this.assertDispatchExecutors(preparedDraft)
-    const compiled = planCompilerService.compile(preparedDraft)
-
-    const specId = new RecordId(TABLES.PLAN_SPEC, Bun.randomUUIDv7())
-    const runId = new RecordId(TABLES.PLAN_RUN, Bun.randomUUIDv7())
-    const emittedEvents: PlanEventRecord[] = []
-
-    await databaseService.withTransaction(async (tx) => {
-      const supersededSpec = PlanSpecSchema.parse(
-        await tx
-          .update(ensureRecordId(activeSpec.id, TABLES.PLAN_SPEC))
-          .content(toSpecData(activeSpec, { status: 'superseded' }))
-          .output('after'),
-      )
-
-      const abortedRun = PlanRunSchema.parse(
-        await tx
-          .update(ensureRecordId(activeRun.id, TABLES.PLAN_RUN))
-          .content(
-            toRunData(activeRun, {
-              status: 'aborted',
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: [],
-              completedAt: new Date(),
-            }),
-          )
-          .output('after'),
-      )
-
-      const spec = PlanSpecSchema.parse(
-        await tx
-          .create(specId)
-          .content(
-            buildCompiledSpecCreateData({
-              organizationId: params.organizationId,
-              threadId: resolvedThreadId,
-              leadAgentId: params.leadAgentId,
-              compiled,
-              version: supersededSpec.version + 1,
-              replacedSpecId: supersededSpec.id,
-            }),
-          )
-          .output('after'),
-      )
-      await this.createInitializedRunGraph({
-        tx,
-        runId,
-        spec,
-        organizationId: params.organizationId,
-        threadId: resolvedThreadId,
-        sourceThreadId: activeRun.sourceThreadId,
-        leadAgentId: params.leadAgentId,
-        createdByAgentId: params.createdByAgentId ?? params.leadAgentId,
-        requireApproval:
-          requestedRequireApproval ?? hasCrossThreadSourceContext(activeRun.sourceThreadId, resolvedThreadId),
-        nodes: compiled.nodes,
-        emittedEvents,
-        runPatch: { replacedRunId: abortedRun.id },
-        createdEventType: 'plan-replaced',
-        createdEventMessage: `Replaced execution plan "${activeSpec.title}" with "${spec.title}".`,
-        createdEventDetail: {
-          reason: params.input.reason,
-          replacedRunId: recordIdToString(abortedRun.id, TABLES.PLAN_RUN),
-        },
-        checkpointReason: 'plan-replaced',
-      })
-    })
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-
-    if (!(requestedRequireApproval ?? hasCrossThreadSourceContext(activeRun.sourceThreadId, resolvedThreadId))) {
-      await this.attachPlanScheduleIfNeeded({
-        organizationId: params.organizationId,
-        threadId: resolvedThreadId,
-        runId,
-        planSpecId: specId,
-      })
-    }
-
-    const plan = await this.finalizePlanSnapshot({ runId, emittedBy: params.leadAgentId })
-
-    return buildExecutionPlanToolResult({
-      action: 'replaced',
-      plan,
-      message: `Replaced execution plan with "${plan.title}".`,
-    })
-  }
-
-  async submitNodeResult(params: {
-    threadId: RecordIdInput
-    emittedBy: string
-    input: SubmitExecutionNodeResultArgs
-  }): Promise<ExecutionPlanToolResultData> {
-    const { runId, nodeId, ...result } = params.input
-    return await this.submitPlanTurnResult({
-      threadId: params.threadId,
-      emittedBy: params.emittedBy,
-      runId,
-      nodeId,
-      input: result,
-    })
-  }
-
-  async submitPlanTurnResult(params: {
-    threadId: RecordIdInput
-    runId: string
-    nodeId: string
-    emittedBy: string
-    input: SubmitPlanTurnResultArgs
-  }): Promise<ExecutionPlanToolResultData> {
-    const result = await planExecutorService.submitNodeResult({
-      threadId: params.threadId,
-      runId: params.runId,
-      nodeId: params.nodeId,
-      emittedBy: params.emittedBy,
-      result: params.input,
-    })
-    const plan = await ownershipDispatcherService.dispatchRunToStableBoundary({
-      runId: params.runId,
-      emittedBy: params.emittedBy,
-    })
-
-    return buildExecutionPlanToolResult({
-      action: result.action,
-      plan,
-      message: result.message ?? `Submitted result for node "${params.nodeId}".`,
-    })
-  }
-
-  async resumeRun(params: {
-    threadId: RecordIdInput
-    emittedBy: string
-    input: { runId: string }
-  }): Promise<ExecutionPlanToolResultData> {
-    const result = await planExecutorService.resumeRun({
-      threadId: params.threadId,
-      runId: params.input.runId,
-      emittedBy: params.emittedBy,
-    })
-    const plan = await ownershipDispatcherService.dispatchRunToStableBoundary({
-      runId: params.input.runId,
-      emittedBy: params.emittedBy,
-    })
-
-    return buildExecutionPlanToolResult({
-      action: result.action,
-      plan,
-      message: result.message ?? `Resumed execution run "${params.input.runId}".`,
-    })
-  }
-
-  async approvePlan(params: {
-    organizationId: RecordIdInput
-    threadId: RecordIdInput
-    runId: RecordIdInput
-    emittedBy: string
-  }): Promise<SerializableExecutionPlan> {
-    const run = await planRunService.getRunById(params.runId)
-    if (
-      recordIdToString(run.organizationId, TABLES.ORGANIZATION) !==
-      recordIdToString(params.organizationId, TABLES.ORGANIZATION)
-    ) {
-      throw new Error('Plan run belongs to a different organization.')
-    }
-    if (!isPlanVisibleInThreadContext(params.threadId, run)) {
-      throw new Error('Plan run is not available in this thread context.')
-    }
-    if (run.status !== 'pending-approval') {
-      throw new Error('Only pending-approval plans can be approved.')
-    }
-
-    const [spec, nodeSpecs, nodeRuns, latestCheckpoint] = await Promise.all([
-      planRunService.getPlanSpecById(run.planSpecId),
-      planRunService.listNodeSpecs(run.planSpecId),
-      planRunService.listNodeRuns(run.id),
-      planRunService.getLatestCheckpoint(run.id),
-    ])
-    const emittedEvents: PlanEventRecord[] = []
-
-    await databaseService.withTransaction(async (tx) => {
-      const activatedRun = PlanRunSchema.parse(
-        await tx
-          .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
-          .content(toRunData(run, { status: 'running', startedAt: run.startedAt ?? new Date() }))
-          .output('after'),
-      )
-
-      const synced = await planExecutorService.syncRunGraph({
-        tx,
-        run: activatedRun,
-        spec,
-        nodeSpecs,
-        nodeRuns,
-        artifacts: [],
-        emittedBy: params.emittedBy,
-        capturedEvents: emittedEvents,
-      })
-
-      const checkpoint = PlanCheckpointSchema.parse(
-        await tx
-          .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
-          .content({
-            runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-            sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-            runStatus: synced.run.status,
-            readyNodeIds: [...synced.run.readyNodeIds],
-            activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
-            artifactIds: [],
-            lastCompletedNodeIds: synced.nodeRuns
-              .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
-              .map((nodeRun) => nodeRun.nodeId),
-            snapshot: {
-              reason: 'plan-approved',
-              currentNodeId: synced.run.currentNodeId,
-              waitingNodeId: synced.run.waitingNodeId,
-              readyNodeIds: synced.run.readyNodeIds,
-            },
-          })
-          .output('after'),
-      )
-
-      const updatedRun = PlanRunSchema.parse(
-        await tx
-          .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
-          .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
-          .output('after'),
-      )
-
-      const approvedEvent = await tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
-          eventType: 'plan-approved',
-          fromStatus: run.status,
-          toStatus: updatedRun.status,
-          message: `Approved execution plan "${spec.title}".`,
-          emittedBy: params.emittedBy,
-          detail: { title: spec.title, objective: spec.objective },
-        })
-        .output('after')
-      emittedEvents.push(PlanEventSchema.parse(approvedEvent))
-
-      const checkpointEvent = await tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
-          eventType: 'checkpoint-saved',
-          message: `Saved checkpoint ${(latestCheckpoint?.sequence ?? 0) + 1}.`,
-          emittedBy: 'system',
-          detail: { checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT), reason: 'plan-approved' },
-        })
-        .output('after')
-      emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
-    })
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-    await this.attachPlanScheduleIfNeeded({
-      organizationId: run.organizationId,
-      threadId: run.threadId,
-      runId: run.id,
-      planSpecId: run.planSpecId,
-    })
-
-    return await this.finalizePlanSnapshot({ runId: run.id, emittedBy: params.emittedBy })
-  }
-
-  async rejectPlan(params: {
-    organizationId: RecordIdInput
-    threadId: RecordIdInput
-    runId: RecordIdInput
-    emittedBy: string
-    reason?: string
-    resolution?: 'rejected' | 'changes-requested'
-  }): Promise<SerializableExecutionPlan> {
-    const resolution = params.resolution ?? 'rejected'
-    const eventType = resolution === 'changes-requested' ? 'plan-changes-requested' : 'plan-rejected'
-    const run = await planRunService.getRunById(params.runId)
-    if (
-      recordIdToString(run.organizationId, TABLES.ORGANIZATION) !==
-      recordIdToString(params.organizationId, TABLES.ORGANIZATION)
-    ) {
-      throw new Error('Plan run belongs to a different organization.')
-    }
-    if (!isPlanVisibleInThreadContext(params.threadId, run)) {
-      throw new Error('Plan run is not available in this thread context.')
-    }
-    if (run.status !== 'pending-approval') {
-      throw new Error('Only pending-approval plans can be rejected.')
-    }
-
-    const [spec, nodeRuns, latestCheckpoint] = await Promise.all([
-      planRunService.getPlanSpecById(run.planSpecId),
-      planRunService.listNodeRuns(run.id),
-      planRunService.getLatestCheckpoint(run.id),
-    ])
-    const emittedEvents: PlanEventRecord[] = []
-    const checkpointReason = resolution === 'changes-requested' ? 'plan-changes-requested' : 'plan-rejected'
-
-    await databaseService.withTransaction(async (tx) => {
-      const rejectedRun = PlanRunSchema.parse(
-        await tx
-          .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
-          .content(
-            toRunData(run, {
-              status: 'aborted',
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: [],
-              completedAt: new Date(),
-            }),
-          )
-          .output('after'),
-      )
-
-      const event = await tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(rejectedRun.id, TABLES.PLAN_RUN),
-          eventType,
-          fromStatus: run.status,
-          toStatus: rejectedRun.status,
-          message:
-            resolution === 'changes-requested'
-              ? `Requested changes for execution plan "${spec.title}".`
-              : `Rejected execution plan "${spec.title}".`,
-          emittedBy: params.emittedBy,
-          detail: { resolution, ...(params.reason ? { reason: params.reason } : {}) },
-        })
-        .output('after')
-      emittedEvents.push(PlanEventSchema.parse(event))
-
-      const checkpoint = PlanCheckpointSchema.parse(
-        await tx
-          .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
-          .content({
-            runId: ensureRecordId(rejectedRun.id, TABLES.PLAN_RUN),
-            sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-            runStatus: rejectedRun.status,
-            readyNodeIds: [],
-            activeNodeIds: [],
-            artifactIds: [],
-            lastCompletedNodeIds: nodeRuns
-              .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
-              .map((nodeRun) => nodeRun.nodeId),
-            snapshot: {
-              reason: checkpointReason,
-              resolution,
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: [],
-            },
-          })
-          .output('after'),
-      )
-
-      const updatedRun = PlanRunSchema.parse(
-        await tx
-          .update(ensureRecordId(rejectedRun.id, TABLES.PLAN_RUN))
-          .content(toRunData(rejectedRun, { lastCheckpointId: checkpoint.id }))
-          .output('after'),
-      )
-
-      const checkpointEvent = await tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
-          eventType: 'checkpoint-saved',
-          message: `Saved checkpoint ${(latestCheckpoint?.sequence ?? 0) + 1}.`,
-          emittedBy: 'system',
-          detail: {
-            checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT),
-            reason: checkpointReason,
-            resolution,
-          },
-        })
-        .output('after')
-      emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
-    })
-
-    await planEventDeliveryService.dispatchEvents(emittedEvents)
-
-    return await planRunService.toSerializablePlan(await planRunService.getRunById(run.id))
-  }
-
-  async applyApprovalResponseFromMessages(params: {
-    threadId: RecordIdInput
-    approvalMessages: ChatMessage[]
-    respondedBy: string
-  }): Promise<SerializableExecutionPlan | null> {
-    const approvalResponse = buildApprovalResponseFromMessages(params.approvalMessages)
-    if (!approvalResponse) return null
-
-    return await this.respondToApproval({
-      threadId: params.threadId,
-      emittedBy: params.respondedBy,
-      input: approvalResponse,
-    })
-  }
-
-  async respondToApproval(params: {
-    threadId: RecordIdInput
-    emittedBy: string
-    input: { approvalId: string; response: Record<string, unknown>; approvalMessageId?: string }
-  }): Promise<SerializableExecutionPlan | null> {
-    const run = await planRunService.getActiveRunRecord(params.threadId)
-    if (!run) return null
-
-    const plan = await planExecutorService.submitHumanNodeResponse({
-      threadId: params.threadId,
-      approvalId: params.input.approvalId,
-      respondedBy: params.emittedBy,
-      response: params.input.response,
-      approvalMessageId: params.input.approvalMessageId,
-    })
-    if (!plan) return null
-
-    return ownershipDispatcherService.dispatchRunToStableBoundary({ runId: run.id, emittedBy: params.emittedBy })
-  }
-
-  async applyHumanInputFromUserMessage(params: {
-    threadId: RecordIdInput
-    message: ChatMessage
-    respondedBy: string
-  }): Promise<SerializableExecutionPlan | null> {
-    const run = await planRunService.getActiveRunRecord(params.threadId)
-    if (!run || run.status !== 'awaiting-human' || !run.waitingNodeId) return null
-
-    const nodeSpec = await planRunService.getNodeSpecByNodeId(run.planSpecId, run.waitingNodeId)
-    if (nodeSpec.type === 'human-approval') {
-      return null
-    }
-    if (
-      nodeSpec.type !== 'human-input' &&
-      nodeSpec.type !== 'human-review-edit' &&
-      nodeSpec.type !== 'human-decision'
-    ) {
-      return null
-    }
-
-    const response = {
-      responseText: extractMessageText(params.message).trim(),
-      messageId: params.message.id,
-      approved: nodeSpec.type === 'human-decision' ? true : undefined,
-    } satisfies Record<string, unknown>
-
-    const plan = await planExecutorService.submitHumanNodeResponse({
-      threadId: params.threadId,
-      respondedBy: params.respondedBy,
-      response,
-      approvalMessageId: params.message.id,
-    })
-    if (!plan) return null
-
-    return ownershipDispatcherService.dispatchRunToStableBoundary({ runId: run.id, emittedBy: params.respondedBy })
-  }
-
-  private async serializeRuns(
-    runs: PlanRunRecord[],
-    options?: Partial<ExecutionPlanQueryArgs>,
-  ): Promise<SerializableExecutionPlan[]> {
-    return await Promise.all(
-      runs.map((run) =>
-        planRunService.toSerializablePlan(run, {
-          includeEvents: options?.includeEvents,
-          includeArtifacts: options?.includeArtifacts,
-          includeApprovals: options?.includeApprovals,
-          includeCheckpoints: options?.includeCheckpoints,
-          includeValidationIssues: options?.includeValidationIssues,
-        }),
-      ),
-    )
-  }
-
-  private async assertDispatchExecutors(preparedDraft: Parameters<typeof planValidatorService.validateDraft>[0]) {
-    const issues = ownershipDispatcherService.validateDraftExecutors(preparedDraft)
-    if (issues.length > 0) {
-      throw new Error(`Plan draft failed validation: ${aggregateBlockingIssues(issues)}`)
-    }
-  }
-
-  private async finalizePlanSnapshot(params: {
-    runId: RecordIdInput
-    emittedBy: string
-  }): Promise<SerializableExecutionPlan> {
-    return ownershipDispatcherService.dispatchRunToStableBoundary({ runId: params.runId, emittedBy: params.emittedBy })
-  }
-
-  private async attachPlanScheduleIfNeeded(params: {
-    organizationId: RecordIdInput
-    threadId: RecordIdInput
-    runId: RecordIdInput
-    planSpecId: RecordIdInput
-  }): Promise<PlanRunRecord> {
-    const [run, spec] = await Promise.all([
-      planRunService.getRunById(params.runId),
-      planRunService.getPlanSpecById(params.planSpecId),
-    ])
-    if (!spec.schedule || run.scheduleId) {
-      return run
-    }
-
-    const schedule = await planSchedulerService.createSchedule({
-      organizationId: params.organizationId,
-      threadId: params.threadId,
-      planSpecId: params.planSpecId,
-      runId: params.runId,
-      scheduleSpec: spec.schedule,
-    })
-
-    const updatedRun = await databaseService.update(
-      TABLES.PLAN_RUN,
-      ensureRecordId(params.runId, TABLES.PLAN_RUN),
-      toRunData(run, {
-        scheduleId: schedule.id,
-        scheduledAt: schedule.nextFireAt ? toDatabaseDateTime(schedule.nextFireAt) : undefined,
-      }),
-      PlanRunSchema,
-    )
-
-    return updatedRun ?? run
-  }
-
-  private async createNodeSpecs(
-    tx: DatabaseTransaction,
-    planSpecId: RecordIdInput,
-    nodes: CompiledPlanNode[],
-  ): Promise<PlanNodeSpecRecord[]> {
-    const createdRecords: PlanNodeSpecRecord[] = []
-
-    // Sequential: SurrealDB transactions require ordered operations
-    for (const compiledNode of nodes) {
-      const nodeSpecId = new RecordId(TABLES.PLAN_NODE_SPEC, Bun.randomUUIDv7())
-      const created = await tx
-        .create(nodeSpecId)
-        .content({
-          planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC),
-          nodeId: compiledNode.node.id,
-          position: compiledNode.position,
-          type: compiledNode.node.type,
-          label: compiledNode.node.label,
-          owner: compiledNode.node.owner,
-          objective: compiledNode.node.objective,
-          instructions: compiledNode.node.instructions,
-          ...(compiledNode.node.inputSchemaRef ? { inputSchemaRef: compiledNode.node.inputSchemaRef } : {}),
-          ...(compiledNode.node.outputSchemaRef ? { outputSchemaRef: compiledNode.node.outputSchemaRef } : {}),
-          deliverables: [...compiledNode.node.deliverables],
-          successCriteria: [...compiledNode.node.successCriteria],
-          completionChecks: [...compiledNode.node.completionChecks],
-          retryPolicy: { ...compiledNode.node.retryPolicy, retryOn: [...compiledNode.node.retryPolicy.retryOn] },
-          failurePolicy: [...compiledNode.node.failurePolicy],
-          ...(compiledNode.node.timeoutMs ? { timeoutMs: compiledNode.node.timeoutMs } : {}),
-          toolPolicy: { allow: [...compiledNode.node.toolPolicy.allow], deny: [...compiledNode.node.toolPolicy.deny] },
-          contextPolicy: {
-            retrievalScopes: [...compiledNode.node.contextPolicy.retrievalScopes],
-            attachmentPolicy: compiledNode.node.contextPolicy.attachmentPolicy,
-            webPolicy: compiledNode.node.contextPolicy.webPolicy,
-          },
-          executionVisibility: compiledNode.node.executionVisibility,
-          ...(compiledNode.node.schedule ? { schedule: compiledNode.node.schedule } : {}),
-          ...(compiledNode.node.deadline ? { deadline: compiledNode.node.deadline } : {}),
-          ...(compiledNode.node.escalation ? { escalation: compiledNode.node.escalation } : {}),
-          ...(compiledNode.node.monitoringConfig ? { monitoringConfig: compiledNode.node.monitoringConfig } : {}),
-          ...(compiledNode.node.delayAfterPredecessorMs
-            ? { delayAfterPredecessorMs: compiledNode.node.delayAfterPredecessorMs }
-            : {}),
-          ...(compiledNode.node.deliberationConfig ? { deliberationConfig: compiledNode.node.deliberationConfig } : {}),
-          upstreamNodeIds: [...compiledNode.upstreamNodeIds],
-          downstreamNodeIds: [...compiledNode.downstreamNodeIds],
-        })
-        .output('after')
-
-      createdRecords.push(PlanNodeSpecRecordSchema.parse(created))
-    }
-
-    return createdRecords
-  }
-
-  private async createNodeRuns(
-    tx: DatabaseTransaction,
-    runId: RecordIdInput,
-    planSpecId: RecordIdInput,
-    nodeSpecs: PlanNodeSpecRecord[],
-  ): Promise<PlanNodeRunRecord[]> {
-    const createdNodeRuns: PlanNodeRunRecord[] = []
-    // Sequential: SurrealDB transactions require ordered operations
-    for (const nodeSpec of nodeSpecs) {
-      const nodeRunId = new RecordId(TABLES.PLAN_NODE_RUN, Bun.randomUUIDv7())
-      const created = await tx
-        .create(nodeRunId)
-        .content({
-          runId: ensureRecordId(runId, TABLES.PLAN_RUN),
-          planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC),
-          nodeId: nodeSpec.nodeId,
-          status: 'pending',
-          attemptCount: 0,
-          retryCount: 0,
-        })
-        .output('after')
-
-      createdNodeRuns.push(PlanNodeRunSchema.parse(created))
-    }
-
-    return createdNodeRuns
-  }
-
-  private async createInitializedRunGraph(params: {
-    tx: DatabaseTransaction
-    runId: RecordIdInput
-    spec: PlanSpecRecord
-    organizationId: RecordIdInput
-    threadId: RecordIdInput
-    sourceThreadId?: RecordIdInput
-    leadAgentId: string
-    createdByAgentId?: string
-    requireApproval: boolean
-    nodes: CompiledPlanNode[]
-    emittedEvents: PlanEventRecord[]
-    createdEventType: 'plan-created' | 'plan-replaced'
-    createdEventMessage: string
-    createdEventDetail: Record<string, unknown>
-    checkpointReason: 'plan-created' | 'plan-replaced'
-    runPatch?: { replacedRunId?: RecordIdInput }
-  }): Promise<PlanRunRecord> {
-    const nodeSpecs = await this.createNodeSpecs(params.tx, params.spec.id, params.nodes)
-    const run = PlanRunSchema.parse(
-      await params.tx
-        .create(ensureRecordId(params.runId, TABLES.PLAN_RUN))
-        .content({
-          planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-          organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-          threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-          ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
-          leadAgentId: params.leadAgentId,
-          ...(params.createdByAgentId ? { createdByAgentId: params.createdByAgentId } : {}),
-          status: params.requireApproval ? 'pending-approval' : 'running',
-          readyNodeIds: [],
-          failureCount: 0,
-          ...(params.runPatch?.replacedRunId
-            ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
-            : {}),
-          ...(params.requireApproval ? {} : { startedAt: new Date() }),
-        })
-        .output('after'),
-    )
-
-    const nodeRuns = await this.createNodeRuns(params.tx, run.id, params.spec.id, nodeSpecs)
-    const synced = params.requireApproval
-      ? { run, nodeRuns }
-      : await planExecutorService.syncRunGraph({
-          tx: params.tx,
-          run,
-          spec: params.spec,
-          nodeSpecs,
-          nodeRuns,
-          artifacts: [],
-          emittedBy: params.leadAgentId,
-          capturedEvents: params.emittedEvents,
-        })
-
-    const event = await params.tx
-      .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-      .content({
-        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-        runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-        eventType: params.createdEventType,
-        message: params.createdEventMessage,
-        emittedBy: params.leadAgentId,
-        detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
-      })
-      .output('after')
-    params.emittedEvents.push(PlanEventSchema.parse(event))
-
-    if (params.requireApproval) {
-      const pendingApprovalEvent = await params.tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-          eventType: 'plan-pending-approval',
-          toStatus: synced.run.status,
-          message: `Execution plan "${params.spec.title}" is pending approval.`,
-          emittedBy: params.leadAgentId,
-          detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
-        })
-        .output('after')
-      params.emittedEvents.push(PlanEventSchema.parse(pendingApprovalEvent))
-    }
-
-    const checkpoint = PlanCheckpointSchema.parse(
-      await params.tx
-        .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
-        .content({
-          runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-          sequence: 1,
-          runStatus: synced.run.status,
-          readyNodeIds: [...synced.run.readyNodeIds],
-          activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
-          artifactIds: [],
-          lastCompletedNodeIds: synced.nodeRuns
-            .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
-            .map((nodeRun) => nodeRun.nodeId),
-          snapshot: {
-            reason: params.checkpointReason,
-            currentNodeId: synced.run.currentNodeId,
-            waitingNodeId: synced.run.waitingNodeId,
-            readyNodeIds: synced.run.readyNodeIds,
-          },
-        })
-        .output('after'),
-    )
-
-    const updatedRun = PlanRunSchema.parse(
-      await params.tx
-        .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
-        .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
-        .output('after'),
-    )
-
-    const checkpointEvent = await params.tx
-      .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-      .content({
-        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-        runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
-        eventType: 'checkpoint-saved',
-        message: 'Saved checkpoint 1.',
-        emittedBy: 'system',
-        detail: {
-          checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT),
-          reason: params.checkpointReason,
-        },
-      })
-      .output('after')
-    params.emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
-
-    return updatedRun
-  }
-}
-
-export const executionPlanService = new ExecutionPlanService()