@lota-sdk/core 0.1.23 → 0.1.25

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

@@ -1,16 +1,14 @@
 import type {
   ChatMessage,
-  CreateExecutionPlanArgs,
   ExecutionPlanToolResultData,
   GetActiveExecutionPlanArgs,
   ListExecutionPlansSummary,
   ListExecutionPlansToolResultData,
   PlanEventRecord,
+  PlanDraft,
   PlanNodeRunRecord,
   PlanNodeSpecRecord,
-  PlanRunRecord,
   PlanSpecRecord,
-  ReplaceExecutionPlanArgs,
   ResumeExecutionPlanRunArgs,
   SerializableExecutionPlan,
   SubmitPlanTurnResultArgs,
@@ -26,7 +24,6 @@ import {
 } from '@lota-sdk/shared'
 import { RecordId } from 'surrealdb'
 
-import { serverLogger } from '../config/logger'
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import { databaseService } from '../db/service'
@@ -35,33 +32,17 @@ import { TABLES } from '../db/tables'
 import { readApprovalContinuationResponse } from '../runtime/approval-continuation'
 import { extractMessageText } from '../runtime/workstream-chat-helpers'
 import { toDatabaseDateTime } from '../utils/date-time'
-import { contextEnrichmentService } from './context-enrichment.service'
 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 buildToolResult(params: {
-  action: ExecutionPlanToolResultData['action']
-  plan: SerializableExecutionPlan | null
-  message: string
-  changedNodeId?: string
-}): ExecutionPlanToolResultData {
-  return {
-    action: params.action,
-    message: params.message,
-    ...(params.changedNodeId ? { changedNodeId: params.changedNodeId } : {}),
-    ...(params.plan ? { plan: params.plan } : {}),
-    hasPlan: params.plan !== null,
-    status: params.plan?.status,
-  }
-}
-
 function aggregateBlockingIssues(issues: Array<{ code: string; message: string }>): string {
   return issues.map((issue) => `${issue.code}: ${issue.message}`).join(' | ')
 }
@@ -100,72 +81,6 @@ function toSpecData(spec: PlanSpecRecord, patch: Partial<PlanSpecRecord> & { rep
   }
 }
 
-type PlanRunUpdate = Omit<
-  Partial<PlanRunRecord>,
-  'currentNodeId' | 'waitingNodeId' | 'replacedRunId' | 'lastCheckpointId' | 'startedAt' | 'completedAt'
-> & {
-  currentNodeId?: string | null
-  waitingNodeId?: string | null
-  replacedRunId?: RecordIdInput | null
-  lastCheckpointId?: RecordIdInput | null
-  startedAt?: string | Date | null
-  completedAt?: string | Date | null
-}
-
-function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
-  return {
-    planSpecId: ensureRecordId(run.planSpecId, TABLES.PLAN_SPEC),
-    organizationId: ensureRecordId(run.organizationId, TABLES.ORGANIZATION),
-    workstreamId: ensureRecordId(run.workstreamId, TABLES.WORKSTREAM),
-    leadAgentId: patch.leadAgentId ?? run.leadAgentId,
-    status: patch.status ?? run.status,
-    ...(patch.currentNodeId === null
-      ? {}
-      : patch.currentNodeId !== undefined
-        ? { currentNodeId: patch.currentNodeId }
-        : run.currentNodeId
-          ? { currentNodeId: run.currentNodeId }
-          : {}),
-    ...(patch.waitingNodeId === null
-      ? {}
-      : patch.waitingNodeId !== undefined
-        ? { waitingNodeId: patch.waitingNodeId }
-        : run.waitingNodeId
-          ? { waitingNodeId: run.waitingNodeId }
-          : {}),
-    readyNodeIds: patch.readyNodeIds ? [...patch.readyNodeIds] : [...run.readyNodeIds],
-    failureCount: patch.failureCount ?? run.failureCount,
-    ...(patch.replacedRunId === null
-      ? {}
-      : patch.replacedRunId
-        ? { replacedRunId: ensureRecordId(patch.replacedRunId, TABLES.PLAN_RUN) }
-        : run.replacedRunId
-          ? { replacedRunId: ensureRecordId(run.replacedRunId, TABLES.PLAN_RUN) }
-          : {}),
-    ...(patch.lastCheckpointId === null
-      ? {}
-      : patch.lastCheckpointId
-        ? { lastCheckpointId: ensureRecordId(patch.lastCheckpointId, TABLES.PLAN_CHECKPOINT) }
-        : run.lastCheckpointId
-          ? { lastCheckpointId: ensureRecordId(run.lastCheckpointId, TABLES.PLAN_CHECKPOINT) }
-          : {}),
-    ...(patch.startedAt === null
-      ? {}
-      : patch.startedAt !== undefined
-        ? { startedAt: toDatabaseDateTime(patch.startedAt) }
-        : run.startedAt
-          ? { startedAt: toDatabaseDateTime(run.startedAt) }
-          : {}),
-    ...(patch.completedAt === null
-      ? {}
-      : patch.completedAt !== undefined
-        ? { completedAt: toDatabaseDateTime(patch.completedAt) }
-        : run.completedAt
-          ? { completedAt: toDatabaseDateTime(run.completedAt) }
-          : {}),
-  }
-}
-
 function buildApprovalResponseFromMessages(
   messages: ChatMessage[],
 ): { approvalId: string; response: Record<string, unknown> } | null {
@@ -188,6 +103,38 @@ function buildApprovalResponseFromMessages(
   return null
 }
 
+function buildCompiledSpecCreateData(params: {
+  organizationId: RecordIdInput
+  workstreamId: RecordIdInput
+  leadAgentId: string
+  compiled: ReturnType<typeof planCompilerService.compile>
+  version: number
+  replacedSpecId?: RecordIdInput
+  contextEnrichments?: PlanSpecRecord['contextEnrichments']
+}) {
+  return {
+    organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+    workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+    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(workstreamId: RecordIdInput): Promise<boolean> {
     return (await planRunService.getActiveRunRecord(workstreamId)) !== null
@@ -275,12 +222,12 @@ class ExecutionPlanService {
       const plan = await planRunService
         .getRunById(params.runId)
         .then((run) => planRunService.toSerializablePlan(run, serializeOptions))
-      return buildToolResult({ action: 'loaded', plan, message: `Loaded execution run "${plan.title}".` })
+      return buildExecutionPlanToolResult({ action: 'loaded', plan, message: `Loaded execution run "${plan.title}".` })
     }
 
     const runs = await planRunService.getActiveRunRecords(params.workstreamId)
     if (runs.length === 0) {
-      return buildToolResult({ action: 'none', plan: null, message: 'No active execution run.' })
+      return buildExecutionPlanToolResult({ action: 'none', plan: null, message: 'No active execution run.' })
     }
 
     const plan = await planRunService.toSerializablePlan(runs[0], serializeOptions)
@@ -292,7 +239,7 @@ class ExecutionPlanService {
     )
 
     return {
-      ...buildToolResult({
+      ...buildExecutionPlanToolResult({
         action: 'loaded',
         plan,
         message:
@@ -309,7 +256,7 @@ class ExecutionPlanService {
     organizationId: RecordIdInput
     workstreamId: RecordIdInput
     leadAgentId: string
-    input: CreateExecutionPlanArgs
+    input: PlanDraft
   }): Promise<ExecutionPlanToolResultData> {
     const preparedDraft = planBuilderService.prepareDraft(params.input)
     const validation = planValidatorService.validateDraft(preparedDraft)
@@ -319,17 +266,6 @@ class ExecutionPlanService {
     await this.assertDispatchExecutors(preparedDraft)
     const compiled = planCompilerService.compile(preparedDraft)
 
-    // Context enrichment — best-effort, failures do not block plan creation
-    const enrichments = await contextEnrichmentService
-      .enrichForPlanCreation({
-        objective: compiled.draft.objective,
-        organizationId: recordIdToString(params.organizationId, TABLES.ORGANIZATION),
-      })
-      .catch((error: unknown) => {
-        serverLogger.error`Context enrichment failed: ${error instanceof Error ? error.message : String(error)}`
-        return []
-      })
-
     const specId = new RecordId(TABLES.PLAN_SPEC, Bun.randomUUIDv7())
     const runId = new RecordId(TABLES.PLAN_RUN, Bun.randomUUIDv7())
     const emittedEvents: PlanEventRecord[] = []
@@ -338,113 +274,31 @@ class ExecutionPlanService {
       const spec = PlanSpecSchema.parse(
         await tx
           .create(specId)
-          .content({
-            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-            workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
-            title: compiled.draft.title,
-            objective: compiled.draft.objective,
-            version: 1,
-            status: 'compiled',
-            leadAgentId: params.leadAgentId,
-            schemaRegistry: structuredClone(compiled.draft.schemas),
-            defaultExecutionVisibility: compiled.draft.defaultExecutionVisibility,
-            ...(enrichments.length > 0
-              ? { contextEnrichments: enrichments.map((e) => ({ type: e.domain, content: JSON.stringify(e.data) })) }
-              : {}),
-            edges: [...compiled.draft.edges],
-            entryNodeIds: [...(compiled.draft.entryNodeIds ?? [])],
-            executionMode: compiled.draft.executionMode ?? 'linear',
-            ...(compiled.draft.schedule ? { schedule: compiled.draft.schedule } : {}),
-            ...(compiled.draft.dependencies ? { dependencies: compiled.draft.dependencies } : {}),
-            compiledAt: new Date(),
-          })
-          .output('after'),
-      )
-
-      const nodeSpecs = await this.createNodeSpecs(tx, spec.id, compiled.nodes)
-      const run = PlanRunSchema.parse(
-        await tx
-          .create(runId)
-          .content({
-            planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-            workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
-            leadAgentId: params.leadAgentId,
-            status: 'running',
-            readyNodeIds: [],
-            failureCount: 0,
-            startedAt: new Date(),
-          })
+          .content(
+            buildCompiledSpecCreateData({
+              organizationId: params.organizationId,
+              workstreamId: params.workstreamId,
+              leadAgentId: params.leadAgentId,
+              compiled,
+              version: 1,
+            }),
+          )
           .output('after'),
       )
-
-      const nodeRuns = await this.createNodeRuns(tx, run.id, spec.id, nodeSpecs)
-      const synced = await planExecutorService.syncRunGraph({
+      await this.createInitializedRunGraph({
         tx,
-        run,
+        runId,
         spec,
-        nodeSpecs,
-        nodeRuns,
-        artifacts: [],
-        emittedBy: params.leadAgentId,
-        capturedEvents: emittedEvents,
+        organizationId: params.organizationId,
+        workstreamId: params.workstreamId,
+        leadAgentId: params.leadAgentId,
+        nodes: compiled.nodes,
+        emittedEvents,
+        createdEventType: 'plan-created',
+        createdEventMessage: `Created execution plan "${spec.title}".`,
+        createdEventDetail: { title: spec.title, objective: spec.objective },
+        checkpointReason: 'plan-created',
       })
-
-      const event = await tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-          eventType: 'plan-created',
-          message: `Created execution plan "${spec.title}".`,
-          emittedBy: params.leadAgentId,
-          detail: { title: spec.title, objective: spec.objective, nodeCount: nodeSpecs.length },
-        })
-        .output('after')
-      emittedEvents.push(PlanEventSchema.parse(event))
-
-      const checkpoint = PlanCheckpointSchema.parse(
-        await 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: 'plan-created',
-              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 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 1.',
-          emittedBy: 'system',
-          detail: { checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT), reason: 'plan-created' },
-        })
-        .output('after')
-      emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
     })
 
     await planEventDeliveryService.dispatchEvents(emittedEvents)
@@ -472,14 +326,14 @@ class ExecutionPlanService {
 
     const plan = await this.finalizePlanSnapshot({ runId, emittedBy: params.leadAgentId })
 
-    return buildToolResult({ action: 'created', plan, message: `Created execution plan "${plan.title}".` })
+    return buildExecutionPlanToolResult({ action: 'created', plan, message: `Created execution plan "${plan.title}".` })
   }
 
   async replacePlan(params: {
     workstreamId: RecordIdInput
     organizationId: RecordIdInput
     leadAgentId: string
-    input: ReplaceExecutionPlanArgs
+    input: PlanDraft & { runId: string; reason: string }
   }): Promise<ExecutionPlanToolResultData> {
     const activeRun = await planRunService.getRunById(params.input.runId)
     if (
@@ -547,119 +401,47 @@ class ExecutionPlanService {
       const spec = PlanSpecSchema.parse(
         await tx
           .create(specId)
-          .content({
-            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-            workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
-            title: compiled.draft.title,
-            objective: compiled.draft.objective,
-            version: supersededSpec.version + 1,
-            status: 'compiled',
-            leadAgentId: params.leadAgentId,
-            schemaRegistry: structuredClone(compiled.draft.schemas),
-            defaultExecutionVisibility: compiled.draft.defaultExecutionVisibility,
-            edges: [...compiled.draft.edges],
-            entryNodeIds: [...(compiled.draft.entryNodeIds ?? [])],
-            executionMode: compiled.draft.executionMode ?? 'linear',
-            ...(compiled.draft.schedule ? { schedule: compiled.draft.schedule } : {}),
-            ...(compiled.draft.dependencies ? { dependencies: compiled.draft.dependencies } : {}),
-            replacedSpecId: ensureRecordId(supersededSpec.id, TABLES.PLAN_SPEC),
-            compiledAt: new Date(),
-          })
-          .output('after'),
-      )
-
-      const nodeSpecs = await this.createNodeSpecs(tx, spec.id, compiled.nodes)
-      const run = PlanRunSchema.parse(
-        await tx
-          .create(runId)
-          .content({
-            planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-            workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
-            leadAgentId: params.leadAgentId,
-            status: 'running',
-            readyNodeIds: [],
-            failureCount: 0,
-            replacedRunId: ensureRecordId(abortedRun.id, TABLES.PLAN_RUN),
-            startedAt: new Date(),
-          })
+          .content(
+            buildCompiledSpecCreateData({
+              organizationId: params.organizationId,
+              workstreamId: params.workstreamId,
+              leadAgentId: params.leadAgentId,
+              compiled,
+              version: supersededSpec.version + 1,
+              replacedSpecId: supersededSpec.id,
+            }),
+          )
           .output('after'),
       )
-
-      const nodeRuns = await this.createNodeRuns(tx, run.id, spec.id, nodeSpecs)
-      const synced = await planExecutorService.syncRunGraph({
+      await this.createInitializedRunGraph({
         tx,
-        run,
+        runId,
         spec,
-        nodeSpecs,
-        nodeRuns,
-        artifacts: [],
-        emittedBy: params.leadAgentId,
-        capturedEvents: emittedEvents,
+        organizationId: params.organizationId,
+        workstreamId: params.workstreamId,
+        leadAgentId: params.leadAgentId,
+        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',
       })
-
-      const replaceEvent = await tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-          eventType: 'plan-replaced',
-          message: `Replaced execution plan "${activeSpec.title}" with "${spec.title}".`,
-          emittedBy: params.leadAgentId,
-          detail: { reason: params.input.reason, replacedRunId: recordIdToString(abortedRun.id, TABLES.PLAN_RUN) },
-        })
-        .output('after')
-      emittedEvents.push(PlanEventSchema.parse(replaceEvent))
-
-      const checkpoint = PlanCheckpointSchema.parse(
-        await 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: 'plan-replaced',
-              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 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 1.',
-          emittedBy: 'system',
-          detail: { checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT), reason: 'plan-replaced' },
-        })
-        .output('after')
-      emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
     })
 
     await planEventDeliveryService.dispatchEvents(emittedEvents)
 
     const plan = await this.finalizePlanSnapshot({ runId, emittedBy: params.leadAgentId })
 
-    return buildToolResult({ action: 'replaced', plan, message: `Replaced execution plan with "${plan.title}".` })
+    return buildExecutionPlanToolResult({
+      action: 'replaced',
+      plan,
+      message: `Replaced execution plan with "${plan.title}".`,
+    })
   }
 
   async submitNodeResult(params: {
@@ -667,23 +449,12 @@ class ExecutionPlanService {
     emittedBy: string
     input: SubmitExecutionNodeResultArgs
   }): Promise<ExecutionPlanToolResultData> {
-    const result = await planExecutorService.submitNodeResult({
+    return await this.submitPlanTurnResult({
       workstreamId: params.workstreamId,
-      runId: params.input.runId,
-      nodeId: params.input.nodeId,
       emittedBy: params.emittedBy,
-      result: params.input.result,
-    })
-    const plan = await ownershipDispatcherService.dispatchRunToStableBoundary({
       runId: params.input.runId,
-      emittedBy: params.emittedBy,
-    })
-
-    return buildToolResult({
-      action: result.action,
-      plan,
-      message: result.message ?? `Submitted result for node "${params.input.nodeId}".`,
-      changedNodeId: result.changedNodeId ?? undefined,
+      nodeId: params.input.nodeId,
+      input: params.input.result,
     })
   }
 
@@ -706,7 +477,7 @@ class ExecutionPlanService {
       emittedBy: params.emittedBy,
     })
 
-    return buildToolResult({
+    return buildExecutionPlanToolResult({
       action: result.action,
       plan,
       message: result.message ?? `Submitted result for node "${params.nodeId}".`,
@@ -729,7 +500,7 @@ class ExecutionPlanService {
       emittedBy: params.emittedBy,
     })
 
-    return buildToolResult({
+    return buildExecutionPlanToolResult({
       action: result.action,
       plan,
       message: result.message ?? `Resumed execution run "${params.input.runId}".`,
@@ -745,18 +516,11 @@ class ExecutionPlanService {
     const approvalResponse = buildApprovalResponseFromMessages(params.approvalMessages)
     if (!approvalResponse) return null
 
-    const run = await planRunService.getActiveRunRecord(params.workstreamId)
-    if (!run) return null
-
-    const plan = await planExecutorService.submitHumanNodeResponse({
+    return await this.respondToApproval({
       workstreamId: params.workstreamId,
-      approvalId: approvalResponse.approvalId,
-      respondedBy: params.respondedBy,
-      response: approvalResponse.response,
+      emittedBy: params.respondedBy,
+      input: approvalResponse,
     })
-    if (!plan) return null
-
-    return ownershipDispatcherService.dispatchRunToStableBoundary({ runId: run.id, emittedBy: params.respondedBy })
   }
 
   async respondToApproval(params: {
@@ -912,6 +676,113 @@ class ExecutionPlanService {
 
     return createdNodeRuns
   }
+
+  private async createInitializedRunGraph(params: {
+    tx: DatabaseTransaction
+    runId: RecordIdInput
+    spec: PlanSpecRecord
+    organizationId: RecordIdInput
+    workstreamId: RecordIdInput
+    leadAgentId: string
+    nodes: CompiledPlanNode[]
+    emittedEvents: PlanEventRecord[]
+    createdEventType: 'plan-created' | 'plan-replaced'
+    createdEventMessage: string
+    createdEventDetail: Record<string, unknown>
+    checkpointReason: 'plan-created' | 'plan-replaced'
+    runPatch?: { replacedRunId?: RecordIdInput }
+  }): Promise<void> {
+    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),
+          workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+          leadAgentId: params.leadAgentId,
+          status: 'running',
+          readyNodeIds: [],
+          failureCount: 0,
+          ...(params.runPatch?.replacedRunId
+            ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
+            : {}),
+          startedAt: new Date(),
+        })
+        .output('after'),
+    )
+
+    const nodeRuns = await this.createNodeRuns(params.tx, run.id, params.spec.id, nodeSpecs)
+    const synced = 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))
+
+    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))
+  }
 }
 
 export const executionPlanService = new ExecutionPlanService()