@lota-sdk/core 0.1.15 → 0.1.16

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

@@ -55,6 +55,8 @@ function buildProgress(nodeRuns: PlanNodeRunRecord[]) {
       blocked: 0,
       failed: 0,
       skipped: 0,
+      scheduled: 0,
+      monitoring: 0,
     } satisfies Record<PlanNodeRunStatus, number>,
   )
 
@@ -72,6 +74,8 @@ function buildProgress(nodeRuns: PlanNodeRunRecord[]) {
     blocked: counts.blocked,
     failed: counts.failed,
     skipped: counts.skipped,
+    scheduled: counts.scheduled,
+    monitoring: counts.monitoring,
     completionRatio: total > 0 ? Number((completedWork / total).toFixed(4)) : undefined,
   }
 }
@@ -164,8 +168,26 @@ class PlanRunService {
     return spec
   }
 
+  async listPlanSpecsByWorkstream(workstreamId: RecordIdInput): Promise<PlanSpecRecord[]> {
+    return databaseService.findMany(
+      TABLES.PLAN_SPEC,
+      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      PlanSpecSchema,
+      { orderBy: 'createdAt', orderDir: 'DESC' },
+    )
+  }
+
+  async listRunsBySpec(planSpecId: RecordIdInput): Promise<PlanRunRecord[]> {
+    return databaseService.findMany(
+      TABLES.PLAN_RUN,
+      { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC) },
+      PlanRunSchema,
+      { orderBy: 'createdAt', orderDir: 'DESC' },
+    )
+  }
+
   async listNodeSpecs(planSpecId: RecordIdInput): Promise<PlanNodeSpecRecord[]> {
-    return await databaseService.findMany(
+    return databaseService.findMany(
       TABLES.PLAN_NODE_SPEC,
       { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC) },
       PlanNodeSpecRecordSchema,
@@ -198,6 +220,11 @@ class PlanRunService {
   }
 
   async getActiveRunRecord(workstreamId: RecordIdInput): Promise<PlanRunRecord | null> {
+    const runs = await this.getActiveRunRecords(workstreamId)
+    return runs[0] ?? null
+  }
+
+  async getActiveRunRecords(workstreamId: RecordIdInput): Promise<PlanRunRecord[]> {
     const runs = await databaseService.findMany(
       TABLES.PLAN_RUN,
       { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
@@ -205,11 +232,11 @@ class PlanRunService {
       { orderBy: 'updatedAt', orderDir: 'DESC' },
     )
 
-    return runs.find((run) => ACTIVE_RUN_STATUSES.has(run.status)) ?? null
+    return runs.filter((run) => ACTIVE_RUN_STATUSES.has(run.status))
   }
 
   async listNodeRuns(runId: RecordIdInput): Promise<PlanNodeRunRecord[]> {
-    return await databaseService.findMany(
+    return databaseService.findMany(
       TABLES.PLAN_NODE_RUN,
       { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
       PlanNodeRunSchema,
@@ -230,7 +257,7 @@ class PlanRunService {
   }
 
   async listArtifacts(runId: RecordIdInput): Promise<PlanArtifactRecord[]> {
-    return await databaseService.findMany(
+    return databaseService.findMany(
       TABLES.PLAN_ARTIFACT,
       { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
       PlanArtifactSchema,
@@ -239,7 +266,7 @@ class PlanRunService {
   }
 
   async listAttempts(runId: RecordIdInput): Promise<PlanNodeAttemptRecord[]> {
-    return await databaseService.findMany(
+    return databaseService.findMany(
       TABLES.PLAN_NODE_ATTEMPT,
       { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
       PlanNodeAttemptSchema,
@@ -257,14 +284,14 @@ class PlanRunService {
     if (params.planSpecId) filter.planSpecId = ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC)
     if (params.attemptId) filter.attemptId = ensureRecordId(params.attemptId, TABLES.PLAN_NODE_ATTEMPT)
 
-    return await databaseService.findMany(TABLES.PLAN_VALIDATION_ISSUE, filter, PlanValidationIssueSchema, {
+    return databaseService.findMany(TABLES.PLAN_VALIDATION_ISSUE, filter, PlanValidationIssueSchema, {
       orderBy: 'createdAt',
       orderDir: 'ASC',
     })
   }
 
   async listApprovals(runId: RecordIdInput): Promise<PlanApprovalRecord[]> {
-    return await databaseService.findMany(
+    return databaseService.findMany(
       TABLES.PLAN_APPROVAL,
       { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
       PlanApprovalSchema,
@@ -352,6 +379,11 @@ class PlanRunService {
           attachmentPolicy: nodeSpec.contextPolicy.attachmentPolicy,
           webPolicy: nodeSpec.contextPolicy.webPolicy,
         },
+        schedule: nodeSpec.schedule,
+        deadline: nodeSpec.deadline,
+        monitoringConfig: nodeSpec.monitoringConfig,
+        delayAfterPredecessorMs: nodeSpec.delayAfterPredecessorMs,
+        deliberationConfig: nodeSpec.deliberationConfig,
         status: nodeRun.status,
         attemptCount: nodeRun.attemptCount,
         retryCount: nodeRun.retryCount,
@@ -378,9 +410,11 @@ class PlanRunService {
       version: spec.version,
       status: run.status,
       leadAgentId: run.leadAgentId,
+      executionMode: spec.executionMode,
       schemaRegistry: structuredClone(spec.schemaRegistry),
       entryNodeIds: [...spec.entryNodeIds],
       edges: [...spec.edges],
+      schedule: spec.schedule,
       activeNodeIds: run.currentNodeId ? [run.currentNodeId] : [],
       readyNodeIds: [...run.readyNodeIds],
       waitingNodeId: run.waitingNodeId,

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

@@ -0,0 +1,240 @@
+import { PlanCycleRecordSchema, PlanScheduleRecordSchema } from '@lota-sdk/shared'
+import type { PlanScheduleRecord, PlanScheduleSpec } from '@lota-sdk/shared'
+import { CronExpressionParser } from 'cron-parser'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId, recordIdToString } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { TABLES } from '../db/tables'
+import { toDatabaseDateTime } from '../utils/date-time'
+
+class PlanSchedulerService {
+  computeNextFireAt(spec: PlanScheduleSpec, baseTime: Date = new Date()): Date | null {
+    switch (spec.type) {
+      case 'immediate':
+        return baseTime
+
+      case 'absolute':
+        return spec.at ? new Date(spec.at) : null
+
+      case 'relative':
+        return spec.delayMs !== undefined ? new Date(baseTime.getTime() + spec.delayMs) : null
+
+      case 'cron': {
+        if (!spec.cron) return null
+        try {
+          const expr = CronExpressionParser.parse(spec.cron, { currentDate: baseTime })
+          const next = expr.next()
+          return next.toDate()
+        } catch {
+          return null
+        }
+      }
+
+      case 'monitoring':
+        return spec.intervalMs !== undefined ? new Date(baseTime.getTime() + spec.intervalMs) : null
+
+      default:
+        return null
+    }
+  }
+
+  async createSchedule(params: {
+    organizationId: RecordIdInput
+    workstreamId: RecordIdInput
+    planSpecId?: RecordIdInput
+    runId?: RecordIdInput
+    nodeId?: string
+    scheduleSpec: PlanScheduleSpec
+  }): Promise<PlanScheduleRecord> {
+    const nextFireAt = this.computeNextFireAt(params.scheduleSpec)
+    const now = new Date()
+
+    const record = await databaseService.create(
+      TABLES.PLAN_SCHEDULE,
+      {
+        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+        workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+        planSpecId: params.planSpecId ? ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC) : undefined,
+        runId: params.runId ? ensureRecordId(params.runId, TABLES.PLAN_RUN) : undefined,
+        nodeId: params.nodeId,
+        scheduleSpec: params.scheduleSpec,
+        status: 'active',
+        fireCount: 0,
+        ...(nextFireAt ? { nextFireAt: toDatabaseDateTime(nextFireAt) } : {}),
+        createdAt: now,
+      },
+      PlanScheduleRecordSchema,
+    )
+
+    // Enqueue a delayed BullMQ job to fire at the scheduled time
+    if (nextFireAt) {
+      const delay = Math.max(0, nextFireAt.getTime() - Date.now())
+      const { enqueueScheduleFire } = await import('../queues/plan-scheduler.queue')
+      await enqueueScheduleFire(recordIdToString(record.id, TABLES.PLAN_SCHEDULE), delay)
+    }
+
+    return record
+  }
+
+  /** Called by the BullMQ worker when a fire-schedule job executes. */
+  async fireScheduleById(scheduleId: string): Promise<void> {
+    const schedule = await databaseService.findOne(
+      TABLES.PLAN_SCHEDULE,
+      { id: ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE) },
+      PlanScheduleRecordSchema,
+    )
+
+    if (!schedule || schedule.status !== 'active') return
+
+    await this.fireSchedule(schedule)
+  }
+
+  async fireSchedule(schedule: PlanScheduleRecord): Promise<void> {
+    const now = new Date()
+    const newFireCount = schedule.fireCount + 1
+    const isRecurring = schedule.scheduleSpec.type === 'cron' || schedule.scheduleSpec.type === 'monitoring'
+    const maxReached = schedule.scheduleSpec.maxFires !== undefined && newFireCount >= schedule.scheduleSpec.maxFires
+
+    let nextFireAt: Date | null = null
+    let newStatus: 'active' | 'completed' = 'completed'
+
+    if (isRecurring && !maxReached) {
+      nextFireAt = this.computeNextFireAt(schedule.scheduleSpec, now)
+      newStatus = nextFireAt ? 'active' : 'completed'
+    }
+
+    await databaseService.update(
+      TABLES.PLAN_SCHEDULE,
+      schedule.id,
+      { fireCount: newFireCount, lastFiredAt: now, nextFireAt: toDatabaseDateTime(nextFireAt), status: newStatus },
+      PlanScheduleRecordSchema,
+    )
+
+    // Enqueue next fire for recurring schedules
+    if (newStatus === 'active' && nextFireAt) {
+      const delay = Math.max(0, nextFireAt.getTime() - Date.now())
+      const scheduleIdStr = recordIdToString(schedule.id, TABLES.PLAN_SCHEDULE)
+      const { enqueueScheduleFire } = await import('../queues/plan-scheduler.queue')
+      await enqueueScheduleFire(scheduleIdStr, delay)
+    }
+
+    let shouldRecoverDeadlineChecks = false
+
+    // Dispatch: node-level schedule — promote the delayed node
+    if (schedule.runId && schedule.nodeId) {
+      const { planExecutorService } = await import('./plan-executor.service')
+      await planExecutorService.promoteDelayedNode({
+        runId: recordIdToString(schedule.runId, TABLES.PLAN_RUN),
+        nodeId: schedule.nodeId,
+        emittedBy: 'plan-scheduler',
+      })
+      shouldRecoverDeadlineChecks = true
+    }
+
+    // Dispatch: plan-level schedule — advance a linked cycle or create a new run
+    if (schedule.planSpecId && !schedule.runId) {
+      const cycle = await databaseService.findOne(
+        TABLES.PLAN_CYCLE,
+        { scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE) },
+        PlanCycleRecordSchema,
+      )
+
+      if (cycle) {
+        const { planCycleService } = await import('./plan-cycle.service')
+        await planCycleService.advanceCycle(cycle.id)
+        shouldRecoverDeadlineChecks = true
+      }
+    }
+
+    if (shouldRecoverDeadlineChecks) {
+      const { planDeadlineService } = await import('./plan-deadline.service')
+      await planDeadlineService.recoverDeadlineChecks()
+    }
+  }
+
+  /** Re-enqueue BullMQ jobs for all active schedules. Called once at worker startup. */
+  async recoverActiveSchedules(): Promise<void> {
+    const activeSchedules = await databaseService.queryMany(
+      {
+        query: `SELECT * FROM ${TABLES.PLAN_SCHEDULE} WHERE status = $status ORDER BY nextFireAt ASC`,
+        bindings: { status: 'active' },
+      },
+      PlanScheduleRecordSchema,
+    )
+
+    const { enqueueScheduleFire } = await import('../queues/plan-scheduler.queue')
+
+    for (const schedule of activeSchedules) {
+      if (!schedule.nextFireAt) continue
+      const scheduleId = recordIdToString(schedule.id, TABLES.PLAN_SCHEDULE)
+      const delay = Math.max(0, new Date(schedule.nextFireAt).getTime() - Date.now())
+      await enqueueScheduleFire(scheduleId, delay)
+    }
+  }
+
+  async cancelSchedule(scheduleId: RecordIdInput): Promise<void> {
+    const idStr = recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)
+    const { removeScheduleFireJob } = await import('../queues/plan-scheduler.queue')
+    await removeScheduleFireJob(idStr)
+
+    await databaseService.update(
+      TABLES.PLAN_SCHEDULE,
+      ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
+      { status: 'cancelled' },
+      PlanScheduleRecordSchema,
+    )
+  }
+
+  async pauseSchedule(scheduleId: RecordIdInput): Promise<void> {
+    const idStr = recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)
+    const { removeScheduleFireJob } = await import('../queues/plan-scheduler.queue')
+    await removeScheduleFireJob(idStr)
+
+    await databaseService.update(
+      TABLES.PLAN_SCHEDULE,
+      ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
+      { status: 'paused' },
+      PlanScheduleRecordSchema,
+    )
+  }
+
+  async resumeSchedule(scheduleId: RecordIdInput): Promise<void> {
+    const schedule = await databaseService.findOne(
+      TABLES.PLAN_SCHEDULE,
+      { id: ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE) },
+      PlanScheduleRecordSchema,
+    )
+    if (!schedule) {
+      throw new Error(`Schedule not found: ${recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)}`)
+    }
+
+    const nextFireAt = this.computeNextFireAt(schedule.scheduleSpec)
+
+    await databaseService.update(
+      TABLES.PLAN_SCHEDULE,
+      ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
+      { status: 'active', nextFireAt: toDatabaseDateTime(nextFireAt) },
+      PlanScheduleRecordSchema,
+    )
+
+    // Re-enqueue the delayed fire job
+    if (nextFireAt) {
+      const delay = Math.max(0, nextFireAt.getTime() - Date.now())
+      const idStr = recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)
+      const { enqueueScheduleFire } = await import('../queues/plan-scheduler.queue')
+      await enqueueScheduleFire(idStr, delay)
+    }
+  }
+
+  async listSchedules(workstreamId: RecordIdInput): Promise<PlanScheduleRecord[]> {
+    return databaseService.findMany(
+      TABLES.PLAN_SCHEDULE,
+      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      PlanScheduleRecordSchema,
+      { orderBy: 'createdAt', orderDir: 'ASC' },
+    )
+  }
+}
+
+export const planSchedulerService = new PlanSchedulerService()

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

@@ -0,0 +1,117 @@
+import { PlanTemplateRecordSchema } from '@lota-sdk/shared'
+import type { ExecutionPlanToolResultData, PlanArtifactRecord, PlanDraft, PlanTemplateRecord } from '@lota-sdk/shared'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId, recordIdToString } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { TABLES } from '../db/tables'
+import { executionPlanService } from './execution-plan.service'
+
+class PlanTemplateService {
+  async createTemplate(params: {
+    organizationId: RecordIdInput
+    name: string
+    description?: string
+    draft: PlanDraft
+    tags?: string[]
+    source?: 'user' | 'playbook' | 'system'
+    sourceRef?: string
+  }): Promise<PlanTemplateRecord> {
+    const now = new Date()
+    return databaseService.create(
+      TABLES.PLAN_TEMPLATE,
+      {
+        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+        name: params.name,
+        ...(params.description ? { description: params.description } : {}),
+        draft: params.draft,
+        tags: params.tags ?? [],
+        source: params.source ?? 'user',
+        ...(params.sourceRef ? { sourceRef: params.sourceRef } : {}),
+        createdAt: now,
+      },
+      PlanTemplateRecordSchema,
+    )
+  }
+
+  async getTemplate(templateId: RecordIdInput): Promise<PlanTemplateRecord | null> {
+    return databaseService.findOne(
+      TABLES.PLAN_TEMPLATE,
+      { id: ensureRecordId(templateId, TABLES.PLAN_TEMPLATE) },
+      PlanTemplateRecordSchema,
+    )
+  }
+
+  async listTemplates(
+    organizationId: RecordIdInput,
+    params?: { tags?: string[]; source?: string },
+  ): Promise<PlanTemplateRecord[]> {
+    const filter: Record<string, unknown> = { organizationId: ensureRecordId(organizationId, TABLES.ORGANIZATION) }
+    if (params?.source) {
+      filter.source = params.source
+    }
+
+    const templates = await databaseService.findMany(TABLES.PLAN_TEMPLATE, filter, PlanTemplateRecordSchema, {
+      orderBy: 'createdAt',
+      orderDir: 'ASC',
+    })
+
+    if (params?.tags && params.tags.length > 0) {
+      const tagSet = new Set(params.tags)
+      return templates.filter((t) => t.tags.some((tag) => tagSet.has(tag)))
+    }
+
+    return templates
+  }
+
+  async updateTemplate(
+    templateId: RecordIdInput,
+    patch: Partial<{ name: string; description: string; draft: PlanDraft; tags: string[] }>,
+  ): Promise<PlanTemplateRecord> {
+    const updated = await databaseService.update(
+      TABLES.PLAN_TEMPLATE,
+      ensureRecordId(templateId, TABLES.PLAN_TEMPLATE),
+      patch,
+      PlanTemplateRecordSchema,
+    )
+    if (!updated) {
+      throw new Error(`Template not found: ${recordIdToString(templateId, TABLES.PLAN_TEMPLATE)}`)
+    }
+    return updated
+  }
+
+  async deleteTemplate(templateId: RecordIdInput): Promise<void> {
+    await databaseService.deleteById(TABLES.PLAN_TEMPLATE, ensureRecordId(templateId, TABLES.PLAN_TEMPLATE))
+  }
+
+  async instantiate(params: {
+    templateId: RecordIdInput
+    organizationId: RecordIdInput
+    workstreamId: RecordIdInput
+    leadAgentId: string
+    overrides?: Partial<PlanDraft>
+    carryForwardArtifacts?: PlanArtifactRecord[]
+  }): Promise<ExecutionPlanToolResultData> {
+    const template = await this.getTemplate(params.templateId)
+    if (!template) {
+      throw new Error(`Template not found: ${recordIdToString(params.templateId, TABLES.PLAN_TEMPLATE)}`)
+    }
+
+    const draft: PlanDraft = { ...template.draft, ...params.overrides }
+
+    if (params.carryForwardArtifacts && params.carryForwardArtifacts.length > 0) {
+      const carryContext = params.carryForwardArtifacts.map((a) => `[carry-forward] ${a.name}: ${a.pointer}`)
+      draft.objective = `${draft.objective}\n\nCarry-forward context:\n${carryContext.join('\n')}`
+    }
+
+    return executionPlanService.createPlan({
+      organizationId: params.organizationId,
+      workstreamId: params.workstreamId,
+      leadAgentId: params.leadAgentId,
+      dispatchMode: 'stable-boundary',
+      input: draft,
+    })
+  }
+}
+
+export const planTemplateService = new PlanTemplateService()

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

@@ -9,9 +9,10 @@ import type {
 } from '@lota-sdk/shared'
 
 import { isRecord } from '../utils/string'
+import { planCoordinationService } from './plan-coordination.service'
 import { readPathValue } from './plan-helpers'
 
-const STRUCTURAL_NODE_TYPES = new Set(['switch', 'join'])
+const STRUCTURAL_NODE_TYPES = new Set(['switch', 'join', 'deliberation-fork'])
 const HUMAN_NODE_TYPES = new Set(['human-input', 'human-approval', 'human-review-edit', 'human-decision'])
 
 export interface PlanValidationIssueInput {
@@ -54,7 +55,7 @@ function hasAllFields(value: unknown, fields: string[]): boolean {
   return fields.every((field) => readPathValue(value, field) !== undefined)
 }
 
-function validateSchemaValue(params: { schema: PlanDataSchema; value: unknown; path: string }): string[] {
+export function validateSchemaValue(params: { schema: PlanDataSchema; value: unknown; path: string }): string[] {
   const issues: string[] = []
   const { schema, value, path } = params
 
@@ -236,6 +237,24 @@ class PlanValidatorService {
           }),
         )
       }
+      if (node.owner.executorType === 'plugin' && node.owner.operation.trim().length === 0) {
+        blocking.push(
+          createIssue({
+            code: 'plugin_owner_operation_missing',
+            message: `Plugin-owned node "${node.label}" must declare an operation.`,
+            nodeId: node.id,
+          }),
+        )
+      }
+      if (node.owner.executorType === 'system' && node.owner.operation.trim().length === 0) {
+        blocking.push(
+          createIssue({
+            code: 'system_owner_operation_missing',
+            message: `System-owned node "${node.label}" must declare an operation.`,
+            nodeId: node.id,
+          }),
+        )
+      }
       if (node.inputSchemaRef && !resolveSchemaRef(draft, node.inputSchemaRef)) {
         blocking.push(
           createIssue({
@@ -289,6 +308,61 @@ class PlanValidatorService {
           }),
         )
       }
+
+      // Validate deliberation-fork nodes
+      if (node.type === 'deliberation-fork') {
+        if (!node.deliberationConfig) {
+          blocking.push(
+            createIssue({
+              code: 'deliberation_fork_missing_config',
+              message: `Deliberation-fork node "${node.label}" must define deliberationConfig.`,
+              nodeId: node.id,
+            }),
+          )
+        } else {
+          if (node.deliberationConfig.branches.length < 2) {
+            blocking.push(
+              createIssue({
+                code: 'deliberation_fork_insufficient_branches',
+                message: `Deliberation-fork node "${node.label}" must define at least 2 branches.`,
+                nodeId: node.id,
+              }),
+            )
+          }
+          for (const branch of node.deliberationConfig.branches) {
+            if (!nodesById.has(branch.entryNodeId)) {
+              blocking.push(
+                createIssue({
+                  code: 'deliberation_fork_missing_branch_entry',
+                  message: `Deliberation-fork node "${node.label}" references missing branch entry node "${branch.entryNodeId}".`,
+                  nodeId: node.id,
+                  detail: { branchId: branch.branchId, entryNodeId: branch.entryNodeId },
+                }),
+              )
+            }
+          }
+          const gateNode = nodesById.get(node.deliberationConfig.resolutionGateNodeId)
+          if (!gateNode) {
+            blocking.push(
+              createIssue({
+                code: 'deliberation_fork_missing_gate',
+                message: `Deliberation-fork node "${node.label}" references missing resolution gate node "${node.deliberationConfig.resolutionGateNodeId}".`,
+                nodeId: node.id,
+                detail: { resolutionGateNodeId: node.deliberationConfig.resolutionGateNodeId },
+              }),
+            )
+          } else if (gateNode.type !== 'human-decision') {
+            blocking.push(
+              createIssue({
+                code: 'deliberation_fork_gate_type_mismatch',
+                message: `Resolution gate node "${gateNode.label}" must be of type "human-decision".`,
+                nodeId: node.id,
+                detail: { gateNodeId: gateNode.id, gateNodeType: gateNode.type },
+              }),
+            )
+          }
+        }
+      }
     }
 
     const entryNodeIds = draft.entryNodeIds ?? []
@@ -431,6 +505,14 @@ class PlanValidatorService {
       )
     }
 
+    // Validate cross-plan dependency cycles
+    if (draft.dependencies && draft.dependencies.length > 0) {
+      const cycleIssues = planCoordinationService.validateNoCycles([
+        { title: draft.title, dependencies: draft.dependencies },
+      ])
+      blocking.push(...cycleIssues)
+    }
+
     return { blocking, warnings }
   }
 

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

@@ -0,0 +1,83 @@
+import { z } from 'zod'
+
+import { getRedisConnection } from '../redis'
+
+const PlanWorkspaceEntrySchema = z.object({
+  value: z.unknown(),
+  version: z.number(),
+  writeSequence: z.number(),
+  nodeId: z.string(),
+  timestamp: z.number(),
+})
+
+export type PlanWorkspaceEntry = z.infer<typeof PlanWorkspaceEntrySchema>
+
+class PlanWorkspaceService {
+  private keyPrefix = 'plan-workspace:'
+
+  async write(params: {
+    runId: string
+    nodeId: string
+    key: string
+    value: unknown
+    version: number
+    checkpointSequence: number
+  }): Promise<void> {
+    const redis = getRedisConnection()
+    const hashKey = `${this.keyPrefix}${params.runId}`
+    const fieldKey = `${params.nodeId}:${params.key}`
+    const entry: PlanWorkspaceEntry = {
+      value: params.value,
+      version: params.version,
+      writeSequence: params.checkpointSequence,
+      nodeId: params.nodeId,
+      timestamp: Date.now(),
+    }
+    await redis.hset(hashKey, fieldKey, JSON.stringify(entry))
+  }
+
+  async snapshotRead(params: {
+    runId: string
+    readerNodeId: string
+    snapshotSequence?: number
+  }): Promise<Record<string, PlanWorkspaceEntry>> {
+    const redis = getRedisConnection()
+    const hashKey = `${this.keyPrefix}${params.runId}`
+    const nodePrefix = `${params.readerNodeId}:`
+    const all = await redis.hgetall(hashKey)
+    const result: Record<string, PlanWorkspaceEntry> = {}
+    for (const [fieldKey, raw] of Object.entries(all)) {
+      if (!fieldKey.startsWith(nodePrefix)) continue
+      const entry = PlanWorkspaceEntrySchema.parse(JSON.parse(raw))
+      if (params.snapshotSequence !== undefined && entry.writeSequence > params.snapshotSequence) {
+        continue
+      }
+      result[fieldKey] = entry
+    }
+    return result
+  }
+
+  async currentRead(params: { runId: string; key?: string }): Promise<Record<string, PlanWorkspaceEntry>> {
+    const redis = getRedisConnection()
+    const hashKey = `${this.keyPrefix}${params.runId}`
+    if (params.key) {
+      // Support both raw field keys (e.g. 'nodeId:key') and plain keys
+      const raw = await redis.hget(hashKey, params.key)
+      if (!raw) return {}
+      return { [params.key]: PlanWorkspaceEntrySchema.parse(JSON.parse(raw)) }
+    }
+    const all = await redis.hgetall(hashKey)
+    const result: Record<string, PlanWorkspaceEntry> = {}
+    for (const [k, v] of Object.entries(all)) {
+      result[k] = PlanWorkspaceEntrySchema.parse(JSON.parse(v))
+    }
+    return result
+  }
+
+  async cleanup(runId: string): Promise<void> {
+    const redis = getRedisConnection()
+    await redis.del(`${this.keyPrefix}${runId}`)
+  }
+}
+
+export const planWorkspaceService = new PlanWorkspaceService()