@lota-sdk/core 0.1.15 → 0.1.16

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

@@ -21,23 +21,30 @@ import {
 } from '@lota-sdk/shared'
 import { RecordId } 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 { toDatabaseDateTime } from '../utils/date-time'
 import { isRecord } from '../utils/string'
+import { feedbackLoopService } from './feedback-loop.service'
+import { institutionalMemoryService } from './institutional-memory.service'
 import { planApprovalService } from './plan-approval.service'
 import { planArtifactService } from './plan-artifact.service'
 import { planCheckpointService } from './plan-checkpoint.service'
+import { planCoordinationService } from './plan-coordination.service'
 import { readPathValue } from './plan-helpers'
 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'
+import { qualityMetricsService } from './quality-metrics.service'
 
-const SUCCESSFUL_TERMINAL_NODE_STATUSES = new Set(['completed', 'partial', 'skipped'])
+const SUCCESSFUL_TERMINAL_NODE_STATUSES = new Set(['completed', 'partial', 'skipped', 'scheduled', 'monitoring'])
 const HUMAN_NODE_TYPES = new Set(['human-input', 'human-approval', 'human-review-edit', 'human-decision'])
-const STRUCTURAL_NODE_TYPES = new Set(['switch', 'join'])
+const STRUCTURAL_NODE_TYPES = new Set(['switch', 'join', 'deliberation-fork'])
 
 function setPathValue(target: Record<string, unknown>, path: string, value: unknown) {
   const segments = path
@@ -146,8 +153,8 @@ type PlanRunUpdate = Omit<
   waitingNodeId?: string | null
   replacedRunId?: RecordIdInput | null
   lastCheckpointId?: RecordIdInput | null
-  startedAt?: Date | null
-  completedAt?: Date | null
+  startedAt?: string | Date | null
+  completedAt?: string | Date | null
 }
 
 type PlanNodeRunUpdate = Omit<
@@ -158,6 +165,7 @@ type PlanNodeRunUpdate = Omit<
   | 'latestStructuredOutput'
   | 'latestNotes'
   | 'latestAttemptId'
+  | 'scheduledAt'
   | 'readyAt'
   | 'startedAt'
   | 'completedAt'
@@ -168,9 +176,10 @@ type PlanNodeRunUpdate = Omit<
   latestStructuredOutput?: Record<string, unknown> | null
   latestNotes?: string | null
   latestAttemptId?: RecordIdInput | null
-  readyAt?: Date | null
-  startedAt?: Date | null
-  completedAt?: Date | null
+  scheduledAt?: string | Date | null
+  readyAt?: string | Date | null
+  startedAt?: string | Date | null
+  completedAt?: string | Date | null
 }
 
 function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
@@ -213,16 +222,16 @@ function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
     ...(patch.startedAt === null
       ? {}
       : patch.startedAt !== undefined
-        ? { startedAt: patch.startedAt }
+        ? { startedAt: toDatabaseDateTime(patch.startedAt) }
         : run.startedAt
-          ? { startedAt: run.startedAt }
+          ? { startedAt: toDatabaseDateTime(run.startedAt) }
           : {}),
     ...(patch.completedAt === null
       ? {}
       : patch.completedAt !== undefined
-        ? { completedAt: patch.completedAt }
+        ? { completedAt: toDatabaseDateTime(patch.completedAt) }
         : run.completedAt
-          ? { completedAt: run.completedAt }
+          ? { completedAt: toDatabaseDateTime(run.completedAt) }
           : {}),
   }
 }
@@ -277,26 +286,33 @@ function toNodeRunData(nodeRun: PlanNodeRunRecord, patch: PlanNodeRunUpdate) {
         : 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: patch.readyAt }
+        ? { readyAt: toDatabaseDateTime(patch.readyAt) }
         : nodeRun.readyAt
-          ? { readyAt: nodeRun.readyAt }
+          ? { readyAt: toDatabaseDateTime(nodeRun.readyAt) }
           : {}),
     ...(patch.startedAt === null
       ? {}
       : patch.startedAt !== undefined
-        ? { startedAt: patch.startedAt }
+        ? { startedAt: toDatabaseDateTime(patch.startedAt) }
         : nodeRun.startedAt
-          ? { startedAt: nodeRun.startedAt }
+          ? { startedAt: toDatabaseDateTime(nodeRun.startedAt) }
           : {}),
     ...(patch.completedAt === null
       ? {}
       : patch.completedAt !== undefined
-        ? { completedAt: patch.completedAt }
+        ? { completedAt: toDatabaseDateTime(patch.completedAt) }
         : nodeRun.completedAt
-          ? { completedAt: nodeRun.completedAt }
+          ? { completedAt: toDatabaseDateTime(nodeRun.completedAt) }
           : {}),
   }
 }
@@ -751,7 +767,63 @@ class PlanExecutorService {
       await this.attachCheckpoint(tx, synced.run, checkpoint)
     })
 
-    const snapshot = await planRunService.toSerializablePlan(await planRunService.getRunById(run.id), {
+    // Record node-level quality metrics (fire-and-forget)
+    const orgId = recordIdToString(run.organizationId, TABLES.ORGANIZATION)
+    const runIdStr = recordIdToString(run.id, TABLES.PLAN_RUN)
+    const nodeStartedAt = nodeRun.startedAt
+    const executionTimeMs = nodeStartedAt ? Date.now() - new Date(nodeStartedAt).getTime() : 0
+    qualityMetricsService
+      .recordNodeMetrics({
+        organizationId: orgId,
+        runId: runIdStr,
+        nodeId: params.nodeId,
+        metrics: {
+          executionTimeMs: Math.max(0, executionTimeMs),
+          attemptCount: nodeRun.attemptCount + 1,
+          artifactCount: params.result.artifacts.length,
+          validationIssueCount: validation.blocking.length + validation.warnings.length,
+          ownerRef: nodeSpec.owner.ref,
+          ownerType: nodeSpec.owner.executorType,
+          nodeType: nodeSpec.type,
+        },
+      })
+      .catch((error) => {
+        aiLogger.warn`Failed to record node quality metrics for run ${runIdStr} node ${params.nodeId}: ${error instanceof Error ? error.message : String(error)}`
+      })
+
+    // If the run just completed, record cycle metrics, persist feedback recommendations, and extract patterns
+    const updatedRun = await planRunService.getRunById(run.id)
+    if (updatedRun.status === 'completed') {
+      qualityMetricsService.recordCycleMetrics({ organizationId: orgId, runId: runIdStr }).catch((error) => {
+        aiLogger.warn`Failed to record cycle quality metrics for run ${runIdStr}: ${error instanceof Error ? error.message : String(error)}`
+      })
+      feedbackLoopService
+        .analyzeOutcomes({ runId: runIdStr, organizationId: orgId })
+        .then(async (recommendations) => {
+          if (recommendations.length === 0) return
+          const specRecord = await planRunService.getPlanSpecById(updatedRun.planSpecId)
+          await databaseService.create(
+            TABLES.PLAN_EVENT,
+            {
+              planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
+              runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
+              eventType: 'feedback-analyzed',
+              message: `Feedback analysis produced ${recommendations.length} recommendation(s).`,
+              detail: { recommendations },
+              emittedBy: 'system',
+            },
+            PlanEventSchema,
+          )
+        })
+        .catch((error) => {
+          aiLogger.warn`Failed to analyze feedback outcomes for run ${runIdStr}: ${error instanceof Error ? error.message : String(error)}`
+        })
+      institutionalMemoryService.extractPatterns({ organizationId: orgId, runId: runIdStr }).catch((error) => {
+        aiLogger.warn`Failed to extract institutional memory patterns for run ${runIdStr}: ${error instanceof Error ? error.message : String(error)}`
+      })
+    }
+
+    const snapshot = await planRunService.toSerializablePlan(updatedRun, {
       includeEvents: true,
       includeArtifacts: true,
       includeApprovals: true,
@@ -992,7 +1064,7 @@ class PlanExecutorService {
       await this.attachCheckpoint(tx, synced.run, checkpoint)
     })
 
-    return await planRunService.toSerializablePlan(await planRunService.getRunById(run.id), {
+    return planRunService.toSerializablePlan(await planRunService.getRunById(run.id), {
       includeEvents: true,
       includeArtifacts: true,
       includeApprovals: true,
@@ -1099,6 +1171,176 @@ class PlanExecutorService {
     })
   }
 
+  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: {
+    workstreamId: RecordIdInput
+    runId: string
+    nodeId: string
+    emittedBy: string
+    message: string
+    failureClass: PlanFailureClass
+  }): Promise<SerializableExecutionPlan> {
+    const run = await planRunService.getRunById(params.runId)
+    if (
+      recordIdToString(run.workstreamId, TABLES.WORKSTREAM) !== recordIdToString(params.workstreamId, TABLES.WORKSTREAM)
+    ) {
+      throw new Error('Execution run belongs to a different workstream.')
+    }
+
+    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)
+
+    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,
+      })
+
+      const checkpoint = await this.saveCheckpoint({
+        tx,
+        run: blockedRun,
+        nodeRuns: (await planRunService.listNodeRuns(run.id)).map((candidate) =>
+          candidate.nodeId === blockedNodeRun.nodeId ? blockedNodeRun : candidate,
+        ),
+        artifacts,
+        sequence: (latestCheckpoint?.sequence ?? 0) + 1,
+        reason: 'owner-dispatch-failed',
+      })
+      await this.attachCheckpoint(tx, blockedRun, checkpoint)
+    })
+
+    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)
+
+    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,
+      })
+
+      const synced = await this.syncRunGraph({
+        tx,
+        run,
+        spec,
+        nodeSpecs,
+        nodeRuns: updatedNodeRuns,
+        artifacts,
+        emittedBy: params.emittedBy,
+      })
+
+      const checkpoint = await this.saveCheckpoint({
+        tx,
+        run: synced.run,
+        nodeRuns: synced.nodeRuns,
+        artifacts: synced.artifacts,
+        sequence: (latestCheckpoint?.sequence ?? 0) + 1,
+        reason: 'delayed-node-promoted',
+      })
+      await this.attachCheckpoint(tx, synced.run, checkpoint)
+    })
+  }
+
   async syncRunGraph(params: {
     tx: DatabaseTransaction
     run: PlanRunRecord
@@ -1133,6 +1375,28 @@ class PlanExecutorService {
     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,
+        workstreamId: recordIdToString(params.spec.workstreamId, TABLES.WORKSTREAM),
+      })
+      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.sourcePlanTitle).join(', ')}).`,
+          emittedBy: params.emittedBy,
+        })
+        return { run: currentRun, nodeRuns: currentNodeRuns, artifacts: currentArtifacts }
+      }
+    }
+
     const replaceNodeRun = (nextNodeRun: PlanNodeRunRecord) => {
       currentNodeRuns = currentNodeRuns.map((candidate) =>
         candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
@@ -1207,25 +1471,89 @@ class PlanExecutorService {
         }
 
         const resolvedInput = this.buildResolvedInput({ spec: params.spec, nodeSpec, nodeRunsById, artifactsByNodeId })
-        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,
-        })
-        changed = true
+
+        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,
+            workstreamId: currentRun.workstreamId,
+            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,
+          })
+          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,
+          })
+          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,
+          })
+          changed = true
+        }
       }
 
       const readyStructuralNodes = sortedNodeSpecs.filter((nodeSpec) => {
@@ -1268,8 +1596,12 @@ class PlanExecutorService {
     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) {
+    if (!activeRunningNode && !activeHumanNode && !activeMonitoringNode) {
       const nextHumanNodeSpec = sortedNodeSpecs.find((nodeSpec) => {
         const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
         return nodeRun?.status === 'ready' && isHumanNodeType(nodeSpec.type)
@@ -1384,6 +1716,16 @@ class PlanExecutorService {
             message: `Run "${params.spec.title}" completed.`,
             emittedBy: params.emittedBy,
           })
+        } 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',
@@ -1398,7 +1740,7 @@ class PlanExecutorService {
     } else {
       currentRun = await this.replaceRun(params.tx, currentRun, {
         status: activeHumanNode ? 'awaiting-human' : 'running',
-        currentNodeId: activeHumanNode?.nodeId ?? activeRunningNode?.nodeId ?? null,
+        currentNodeId: activeHumanNode?.nodeId ?? activeMonitoringNode?.nodeId ?? activeRunningNode?.nodeId ?? null,
         waitingNodeId: activeHumanNode?.nodeId ?? null,
         readyNodeIds: currentNodeRuns
           .filter((candidate) => candidate.status === 'ready')
@@ -1556,6 +1898,7 @@ class PlanExecutorService {
     artifacts: Array<{ id: RecordIdInput; nodeId: string }>
     sequence: number
     reason: string
+    includeWorkspace?: boolean
   }) {
     const checkpoint = await planCheckpointService.createCheckpoint({
       tx: params.tx,
@@ -1576,6 +1919,7 @@ class PlanExecutorService {
         readyNodeIds: params.run.readyNodeIds,
         nodeStatuses: Object.fromEntries(params.nodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun.status])),
       },
+      includeWorkspace: params.includeWorkspace,
     })
 
     await this.emitEvent({