@lota-sdk/shared 0.1.8 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/shared",
-  "version": "0.1.8",
+  "version": "0.1.11",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/schemas/chat-message.ts

@@ -3,8 +3,6 @@ import { z } from 'zod'
 
 import type { CoreChatTools } from './tools'
 
-const publicWorkstreamStateSchema = z.record(z.string(), z.unknown())
-
 export const messageMetadataSchema = z
   .object({
     agentId: z.string().optional(),
@@ -32,9 +30,9 @@ export function parseRowMetadata(raw: unknown): MessageMetadata {
   return result.success ? result.data : undefined
 }
 
-export const dataPartsSchema = { workstreamTracker: publicWorkstreamStateSchema }
+export const dataPartsSchema = {}
 
-export type CustomDataParts = { workstreamTracker: z.infer<typeof publicWorkstreamStateSchema> }
+export type CustomDataParts = {}
 
 export type AnyChatTools = Record<string, { input: unknown; output: unknown }>
 export type HostExtensionChatTools = AnyChatTools

package/src/schemas/execution-plan.ts

@@ -2,101 +2,420 @@ import { z } from 'zod'
 
 import { recordIdSchema, unixTimestampSchema } from './common'
 
-export const ExecutionPlanStatusSchema = z
-  .enum(['draft', 'executing', 'blocked', 'completed', 'aborted'])
-  .meta({ id: 'ExecutionPlanStatusSchema' })
-export type ExecutionPlanStatus = z.infer<typeof ExecutionPlanStatusSchema>
-
-export const ExecutionPlanTaskStatusSchema = z
-  .enum(['pending', 'in-progress', 'completed', 'blocked', 'skipped', 'failed'])
-  .meta({ id: 'ExecutionPlanTaskStatusSchema' })
-export type ExecutionPlanTaskStatus = z.infer<typeof ExecutionPlanTaskStatusSchema>
-
-export const ExecutionPlanTaskResultStatusSchema = z
-  .enum(['not-started', 'success', 'partial', 'failed'])
-  .meta({ id: 'ExecutionPlanTaskResultStatusSchema' })
-export type ExecutionPlanTaskResultStatus = z.infer<typeof ExecutionPlanTaskResultStatusSchema>
-
-export const ExecutionPlanTaskKindSchema = z
-  .enum(['agent', 'user-input', 'plugin'])
-  .meta({ id: 'ExecutionPlanTaskKindSchema' })
-export type ExecutionPlanTaskKind = z.infer<typeof ExecutionPlanTaskKindSchema>
-
-export const ExecutionPlanTaskOwnerTypeSchema = z
-  .enum(['agent', 'plugin', 'user'])
-  .meta({ id: 'ExecutionPlanTaskOwnerTypeSchema' })
-export type ExecutionPlanTaskOwnerType = z.infer<typeof ExecutionPlanTaskOwnerTypeSchema>
-
-export const ExecutionPlanEventTypeSchema = z
+const planSchemaLiteralSchema = z.union([z.string(), z.number(), z.boolean(), z.null()])
+
+export type PlanDataSchemaDefinition = {
+  type: 'string' | 'number' | 'boolean' | 'object' | 'array'
+  description?: string
+  nullable?: boolean
+  required?: boolean
+  enum?: Array<string | number | boolean | null>
+  properties?: Record<string, PlanDataSchemaDefinition>
+  items?: PlanDataSchemaDefinition
+  minItems?: number
+  maxItems?: number
+}
+
+export const PlanDataSchemaDefinitionSchema: z.ZodType<PlanDataSchemaDefinition> = z.lazy(() =>
+  z
+    .object({
+      type: z.enum(['string', 'number', 'boolean', 'object', 'array']),
+      description: z.string().optional(),
+      nullable: z.boolean().optional(),
+      required: z.boolean().optional(),
+      enum: z.array(planSchemaLiteralSchema).optional(),
+      properties: z.record(z.string(), PlanDataSchemaDefinitionSchema).optional(),
+      items: PlanDataSchemaDefinitionSchema.optional(),
+      minItems: z.number().int().nonnegative().optional(),
+      maxItems: z.number().int().nonnegative().optional(),
+    })
+    .strict(),
+)
+export type PlanDataSchema = z.infer<typeof PlanDataSchemaDefinitionSchema>
+
+export const PlanSchemaRegistrySchema = z.record(z.string(), PlanDataSchemaDefinitionSchema)
+export type PlanSchemaRegistry = z.infer<typeof PlanSchemaRegistrySchema>
+
+export const PlanNodeTypeSchema = z
+  .enum([
+    'action',
+    'human-input',
+    'human-approval',
+    'human-review-edit',
+    'human-decision',
+    'switch',
+    'join',
+    'subgraph',
+  ])
+  .meta({ id: 'PlanNodeTypeSchema' })
+export type PlanNodeType = z.infer<typeof PlanNodeTypeSchema>
+
+export const PlanNodeExecutorTypeSchema = z
+  .enum(['agent', 'plugin', 'user', 'system'])
+  .meta({ id: 'PlanNodeExecutorTypeSchema' })
+export type PlanNodeExecutorType = z.infer<typeof PlanNodeExecutorTypeSchema>
+
+export const PlanArtifactKindSchema = z
+  .enum(['json', 'markdown', 'file', 'external-ref', 'record'])
+  .meta({ id: 'PlanArtifactKindSchema' })
+export type PlanArtifactKind = z.infer<typeof PlanArtifactKindSchema>
+
+export const PlanCompletionCheckTypeSchema = z
+  .enum(['schema', 'assertion', 'llm-judge', 'human-approval', 'tool-check'])
+  .meta({ id: 'PlanCompletionCheckTypeSchema' })
+export type PlanCompletionCheckType = z.infer<typeof PlanCompletionCheckTypeSchema>
+
+export const PlanFailureClassSchema = z
+  .enum([
+    'schema_validation_failed',
+    'required_artifact_missing',
+    'tool_access_denied',
+    'external_system_unavailable',
+    'human_rejected',
+    'insufficient_context',
+    'policy_blocked',
+    'timeout_exceeded',
+    'non_recoverable_logic_error',
+  ])
+  .meta({ id: 'PlanFailureClassSchema' })
+export type PlanFailureClass = z.infer<typeof PlanFailureClassSchema>
+
+export const PlanFailureTriggerSchema = z.union([PlanFailureClassSchema, z.string().trim().min(1)])
+export type PlanFailureTrigger = z.infer<typeof PlanFailureTriggerSchema>
+
+export const PlanFailureActionSchema = z
+  .enum(['retry', 'human-review', 'replan', 'abort'])
+  .meta({ id: 'PlanFailureActionSchema' })
+export type PlanFailureAction = z.infer<typeof PlanFailureActionSchema>
+
+export const PlanSpecStatusSchema = z.enum(['compiled', 'superseded']).meta({ id: 'PlanSpecStatusSchema' })
+export type PlanSpecStatus = z.infer<typeof PlanSpecStatusSchema>
+
+export const PlanRunStatusSchema = z
+  .enum(['running', 'awaiting-human', 'blocked', 'completed', 'failed', 'aborted'])
+  .meta({ id: 'PlanRunStatusSchema' })
+export type PlanRunStatus = z.infer<typeof PlanRunStatusSchema>
+
+export const PlanNodeRunStatusSchema = z
+  .enum(['pending', 'ready', 'running', 'awaiting-human', 'completed', 'partial', 'blocked', 'failed', 'skipped'])
+  .meta({ id: 'PlanNodeRunStatusSchema' })
+export type PlanNodeRunStatus = z.infer<typeof PlanNodeRunStatusSchema>
+
+export const PlanAttemptStatusSchema = z
+  .enum(['submitted', 'validated', 'completed', 'failed', 'rejected'])
+  .meta({ id: 'PlanAttemptStatusSchema' })
+export type PlanAttemptStatus = z.infer<typeof PlanAttemptStatusSchema>
+
+export const PlanValidationIssueSeveritySchema = z
+  .enum(['warning', 'blocking'])
+  .meta({ id: 'PlanValidationIssueSeveritySchema' })
+export type PlanValidationIssueSeverity = z.infer<typeof PlanValidationIssueSeveritySchema>
+
+export const PlanApprovalStatusSchema = z
+  .enum(['pending', 'approved', 'rejected', 'changes-requested'])
+  .meta({ id: 'PlanApprovalStatusSchema' })
+export type PlanApprovalStatus = z.infer<typeof PlanApprovalStatusSchema>
+
+export const PlanEventTypeSchema = z
   .enum([
     'plan-created',
     'plan-replaced',
-    'plan-status-changed',
-    'task-started',
-    'task-progress',
-    'task-completed',
-    'task-failed',
-    'task-blocked',
-    'task-skipped',
-    'task-restarted',
-    'replan',
+    'run-status-changed',
+    'node-ready',
+    'node-running',
+    'node-awaiting-human',
+    'node-completed',
+    'node-partial',
+    'node-blocked',
+    'node-failed',
+    'node-skipped',
+    'node-auto-completed',
+    'approval-requested',
+    'approval-resolved',
+    'checkpoint-saved',
+    'run-resumed',
+    'validation-reported',
   ])
-  .meta({ id: 'ExecutionPlanEventTypeSchema' })
-export type ExecutionPlanEventType = z.infer<typeof ExecutionPlanEventTypeSchema>
+  .meta({ id: 'PlanEventTypeSchema' })
+export type PlanEventType = z.infer<typeof PlanEventTypeSchema>
+
+export const PlanNodeOwnerSchema = z
+  .object({ executorType: PlanNodeExecutorTypeSchema, ref: z.string().trim().min(1).max(200) })
+  .strict()
+export type PlanNodeOwner = z.infer<typeof PlanNodeOwnerSchema>
+
+export const PlanArtifactSpecSchema = z
+  .object({
+    name: z.string().trim().min(1).max(200),
+    kind: PlanArtifactKindSchema,
+    required: z.boolean().default(true),
+    schemaRef: z.string().trim().min(1).max(200).optional(),
+    description: z.string().trim().min(1).max(1000),
+  })
+  .strict()
+export type PlanArtifactSpec = z.infer<typeof PlanArtifactSpecSchema>
+
+export const PlanCompletionCheckSchema = z
+  .object({
+    type: PlanCompletionCheckTypeSchema,
+    config: z.record(z.string(), z.unknown()).default({}),
+    blocking: z.boolean().default(true),
+    description: z.string().trim().min(1).max(1000),
+  })
+  .strict()
+export type PlanCompletionCheck = z.infer<typeof PlanCompletionCheckSchema>
+
+export const PlanFailureRuleSchema = z
+  .object({ on: PlanFailureTriggerSchema, action: PlanFailureActionSchema, note: z.string().trim().min(1).max(1000) })
+  .strict()
+export type PlanFailureRule = z.infer<typeof PlanFailureRuleSchema>
+
+export const PlanRetryPolicySchema = z
+  .object({ maxAttempts: z.number().int().min(0).default(0), retryOn: z.array(PlanFailureTriggerSchema).default([]) })
+  .strict()
+export type PlanRetryPolicy = z.infer<typeof PlanRetryPolicySchema>
+
+export const PlanToolPolicySchema = z
+  .object({
+    allow: z.array(z.string().trim().min(1).max(200)).default([]),
+    deny: z.array(z.string().trim().min(1).max(200)).default([]),
+  })
+  .strict()
+export type PlanToolPolicy = z.infer<typeof PlanToolPolicySchema>
 
-export const ExecutionPlanTaskInputSchema = z.union([z.string(), z.record(z.string(), z.unknown())])
-export type ExecutionPlanTaskInput = z.infer<typeof ExecutionPlanTaskInputSchema>
+export const PlanContextPolicySchema = z
+  .object({
+    retrievalScopes: z.array(z.string().trim().min(1).max(200)).default([]),
+    attachmentPolicy: z.enum(['none', 'referenced-only', 'all-visible']).default('referenced-only'),
+    webPolicy: z.enum(['forbidden', 'allowed', 'required-fresh']).default('allowed'),
+  })
+  .strict()
+export type PlanContextPolicy = z.infer<typeof PlanContextPolicySchema>
 
-export const ExecutionPlanSchema = z.object({
+const planStructuredPayloadSchema = z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())])
+
+export const PlanNodeSpecSchema = z
+  .object({
+    id: z.string().trim().min(1).max(200),
+    type: PlanNodeTypeSchema,
+    label: z.string().trim().min(1).max(300),
+    owner: PlanNodeOwnerSchema,
+    objective: z.string().trim().min(1).max(2000),
+    instructions: z.string().trim().min(1).max(4000),
+    inputSchemaRef: z.string().trim().min(1).max(200).optional(),
+    outputSchemaRef: z.string().trim().min(1).max(200).optional(),
+    deliverables: z.array(PlanArtifactSpecSchema).default([]),
+    successCriteria: z.array(z.string().trim().min(1).max(1000)).default([]),
+    completionChecks: z.array(PlanCompletionCheckSchema).default([]),
+    retryPolicy: PlanRetryPolicySchema.default({ maxAttempts: 0, retryOn: [] }),
+    failurePolicy: z.array(PlanFailureRuleSchema).default([]),
+    timeoutMs: z.number().int().positive().optional(),
+    toolPolicy: PlanToolPolicySchema.default({ allow: [], deny: [] }),
+    contextPolicy: PlanContextPolicySchema.default({
+      retrievalScopes: [],
+      attachmentPolicy: 'referenced-only',
+      webPolicy: 'allowed',
+    }),
+  })
+  .strict()
+export type PlanNodeSpec = z.infer<typeof PlanNodeSpecSchema>
+
+export const PlanEdgeSpecSchema = z
+  .object({
+    id: z.string().trim().min(1).max(200),
+    source: z.string().trim().min(1).max(200),
+    target: z.string().trim().min(1).max(200),
+    when: z.string().trim().min(1).max(500).optional(),
+    map: z.record(z.string(), z.string()).default({}),
+  })
+  .strict()
+export type PlanEdgeSpec = z.infer<typeof PlanEdgeSpecSchema>
+
+export const PlanDraftSchema = z
+  .object({
+    title: z.string().trim().min(1).max(200),
+    objective: z.string().trim().min(1).max(2000),
+    schemas: PlanSchemaRegistrySchema.default({}),
+    nodes: z.array(PlanNodeSpecSchema).min(1).max(32),
+    edges: z.array(PlanEdgeSpecSchema).default([]),
+    entryNodeIds: z.array(z.string().trim().min(1).max(200)).min(1).optional(),
+  })
+  .strict()
+export type PlanDraft = z.infer<typeof PlanDraftSchema>
+
+export const PlanSpecSchema = z.object({
   id: recordIdSchema,
   organizationId: recordIdSchema,
   workstreamId: recordIdSchema,
   title: z.string(),
   objective: z.string(),
-  status: ExecutionPlanStatusSchema,
+  version: z.number().int().positive(),
+  status: PlanSpecStatusSchema,
   leadAgentId: z.string(),
-  currentTaskId: recordIdSchema.optional(),
-  restartFromTaskId: recordIdSchema.optional(),
-  replacedPlanId: recordIdSchema.optional(),
-  failureCount: z.number().int().nonnegative(),
+  schemaRegistry: PlanSchemaRegistrySchema,
+  edges: z.array(PlanEdgeSpecSchema),
+  entryNodeIds: z.array(z.string()),
+  replacedSpecId: recordIdSchema.optional(),
+  createdAt: unixTimestampSchema,
+  updatedAt: unixTimestampSchema.optional(),
+  compiledAt: unixTimestampSchema.optional(),
+})
+export type PlanSpecRecord = z.infer<typeof PlanSpecSchema>
+
+export const PlanNodeSpecRecordSchema = z.object({
+  id: recordIdSchema,
+  planSpecId: recordIdSchema,
+  nodeId: z.string(),
+  position: z.number().int().nonnegative(),
+  type: PlanNodeTypeSchema,
+  label: z.string(),
+  owner: PlanNodeOwnerSchema,
+  objective: z.string(),
+  instructions: z.string(),
+  inputSchemaRef: z.string().optional(),
+  outputSchemaRef: z.string().optional(),
+  deliverables: z.array(PlanArtifactSpecSchema),
+  successCriteria: z.array(z.string()),
+  completionChecks: z.array(PlanCompletionCheckSchema),
+  retryPolicy: PlanRetryPolicySchema,
+  failurePolicy: z.array(PlanFailureRuleSchema),
+  timeoutMs: z.number().int().positive().optional(),
+  toolPolicy: PlanToolPolicySchema,
+  contextPolicy: PlanContextPolicySchema,
+  upstreamNodeIds: z.array(z.string()).default([]),
+  downstreamNodeIds: z.array(z.string()).default([]),
   createdAt: unixTimestampSchema,
   updatedAt: unixTimestampSchema.optional(),
-  startedAt: unixTimestampSchema.optional(),
-  completedAt: unixTimestampSchema.optional(),
 })
-export type ExecutionPlanRecord = z.infer<typeof ExecutionPlanSchema>
+export type PlanNodeSpecRecord = z.infer<typeof PlanNodeSpecRecordSchema>
 
-export const ExecutionPlanTaskSchema = z.object({
+export const PlanRunSchema = z.object({
   id: recordIdSchema,
-  planId: recordIdSchema,
+  planSpecId: recordIdSchema,
   organizationId: recordIdSchema,
   workstreamId: recordIdSchema,
-  position: z.number().int().nonnegative(),
-  title: z.string(),
-  rationale: z.string(),
-  kind: ExecutionPlanTaskKindSchema,
-  ownerType: ExecutionPlanTaskOwnerTypeSchema,
-  ownerRef: z.string(),
-  status: ExecutionPlanTaskStatusSchema,
-  resultStatus: ExecutionPlanTaskResultStatusSchema,
-  input: ExecutionPlanTaskInputSchema.optional(),
-  outputSummary: z.string().optional(),
-  blockedReason: z.string().optional(),
-  externalRef: z.string().optional(),
-  retryCount: z.number().int().nonnegative(),
-  idempotencyKey: z.string(),
+  leadAgentId: z.string(),
+  status: PlanRunStatusSchema,
+  currentNodeId: z.string().optional(),
+  waitingNodeId: z.string().optional(),
+  readyNodeIds: z.array(z.string()).default([]),
+  failureCount: z.number().int().nonnegative(),
+  replacedRunId: recordIdSchema.optional(),
+  lastCheckpointId: recordIdSchema.optional(),
   createdAt: unixTimestampSchema,
   updatedAt: unixTimestampSchema.optional(),
   startedAt: unixTimestampSchema.optional(),
   completedAt: unixTimestampSchema.optional(),
 })
-export type ExecutionPlanTaskRecord = z.infer<typeof ExecutionPlanTaskSchema>
+export type PlanRunRecord = z.infer<typeof PlanRunSchema>
+
+export const PlanNodeRunSchema = z.object({
+  id: recordIdSchema,
+  runId: recordIdSchema,
+  planSpecId: recordIdSchema,
+  nodeId: z.string(),
+  status: PlanNodeRunStatusSchema,
+  attemptCount: z.number().int().nonnegative(),
+  retryCount: z.number().int().nonnegative(),
+  resolvedInput: z.record(z.string(), z.unknown()).optional(),
+  latestStructuredOutput: z.record(z.string(), z.unknown()).optional(),
+  latestNotes: z.string().optional(),
+  latestAttemptId: recordIdSchema.optional(),
+  blockedReason: z.string().optional(),
+  failureClass: PlanFailureClassSchema.optional(),
+  readyAt: unixTimestampSchema.optional(),
+  startedAt: unixTimestampSchema.optional(),
+  completedAt: unixTimestampSchema.optional(),
+  createdAt: unixTimestampSchema,
+  updatedAt: unixTimestampSchema.optional(),
+})
+export type PlanNodeRunRecord = z.infer<typeof PlanNodeRunSchema>
+
+export const PlanNodeAttemptSchema = z.object({
+  id: recordIdSchema,
+  runId: recordIdSchema,
+  nodeRunId: recordIdSchema,
+  nodeId: z.string(),
+  emittedBy: z.string(),
+  status: PlanAttemptStatusSchema,
+  structuredOutput: z.record(z.string(), z.unknown()).optional(),
+  notes: z.string().optional(),
+  validationIssueIds: z.array(recordIdSchema).default([]),
+  failureClass: PlanFailureClassSchema.optional(),
+  createdAt: unixTimestampSchema,
+})
+export type PlanNodeAttemptRecord = z.infer<typeof PlanNodeAttemptSchema>
+
+export const PlanArtifactSchema = z.object({
+  id: recordIdSchema,
+  runId: recordIdSchema,
+  nodeId: z.string(),
+  attemptId: recordIdSchema,
+  name: z.string(),
+  kind: PlanArtifactKindSchema,
+  pointer: z.string(),
+  schemaRef: z.string().optional(),
+  description: z.string().optional(),
+  payload: planStructuredPayloadSchema.optional(),
+  createdAt: unixTimestampSchema,
+})
+export type PlanArtifactRecord = z.infer<typeof PlanArtifactSchema>
+
+export const PlanValidationIssueSchema = z.object({
+  id: recordIdSchema,
+  planSpecId: recordIdSchema.optional(),
+  runId: recordIdSchema.optional(),
+  nodeId: z.string().optional(),
+  attemptId: recordIdSchema.optional(),
+  severity: PlanValidationIssueSeveritySchema,
+  code: z.string(),
+  message: z.string(),
+  detail: z.record(z.string(), z.unknown()).optional(),
+  createdAt: unixTimestampSchema,
+})
+export type PlanValidationIssueRecord = z.infer<typeof PlanValidationIssueSchema>
+
+export const PlanCheckpointSchema = z.object({
+  id: recordIdSchema,
+  runId: recordIdSchema,
+  sequence: z.number().int().positive(),
+  runStatus: PlanRunStatusSchema,
+  readyNodeIds: z.array(z.string()).default([]),
+  activeNodeIds: z.array(z.string()).default([]),
+  artifactIds: z.array(recordIdSchema).default([]),
+  lastCompletedNodeIds: z.array(z.string()).default([]),
+  snapshot: z.record(z.string(), z.unknown()),
+  createdAt: unixTimestampSchema,
+})
+export type PlanCheckpointRecord = z.infer<typeof PlanCheckpointSchema>
+
+export const PlanApprovalSchema = z.object({
+  id: recordIdSchema,
+  runId: recordIdSchema,
+  nodeId: z.string(),
+  nodeRunId: recordIdSchema,
+  status: PlanApprovalStatusSchema,
+  presented: z.record(z.string(), z.unknown()).optional(),
+  response: z.record(z.string(), z.unknown()).optional(),
+  requestedBy: z.string(),
+  respondedBy: z.string().optional(),
+  approvalMessageId: z.string().optional(),
+  comments: z.string().optional(),
+  requiredEdits: z.array(z.string()).default([]),
+  createdAt: unixTimestampSchema,
+  updatedAt: unixTimestampSchema.optional(),
+  respondedAt: unixTimestampSchema.optional(),
+})
+export type PlanApprovalRecord = z.infer<typeof PlanApprovalSchema>
 
-export const ExecutionPlanEventSchema = z.object({
+export const PlanEventSchema = z.object({
   id: recordIdSchema,
-  planId: recordIdSchema,
-  taskId: recordIdSchema.optional(),
-  eventType: ExecutionPlanEventTypeSchema,
+  planSpecId: recordIdSchema,
+  runId: recordIdSchema,
+  nodeId: z.string().optional(),
+  attemptId: recordIdSchema.optional(),
+  approvalId: recordIdSchema.optional(),
+  eventType: PlanEventTypeSchema,
   fromStatus: z.string().optional(),
   toStatus: z.string().optional(),
   message: z.string(),
@@ -104,33 +423,102 @@ export const ExecutionPlanEventSchema = z.object({
   emittedBy: z.string(),
   createdAt: unixTimestampSchema,
 })
-export type ExecutionPlanEventRecord = z.infer<typeof ExecutionPlanEventSchema>
+export type PlanEventRecord = z.infer<typeof PlanEventSchema>
 
-export const SerializableExecutionPlanTaskSchema = z.object({
+export const SerializablePlanNodeSchema = z.object({
   id: z.string(),
-  position: z.number().int().nonnegative(),
-  title: z.string(),
-  rationale: z.string(),
-  kind: ExecutionPlanTaskKindSchema,
-  ownerType: ExecutionPlanTaskOwnerTypeSchema,
-  ownerRef: z.string(),
-  status: ExecutionPlanTaskStatusSchema,
-  resultStatus: ExecutionPlanTaskResultStatusSchema,
-  input: ExecutionPlanTaskInputSchema.optional(),
-  outputSummary: z.string().nullish(),
-  blockedReason: z.string().nullish(),
-  externalRef: z.string().nullish(),
+  type: PlanNodeTypeSchema,
+  label: z.string(),
+  owner: PlanNodeOwnerSchema,
+  objective: z.string(),
+  instructions: z.string(),
+  inputSchemaRef: z.string().nullish(),
+  outputSchemaRef: z.string().nullish(),
+  deliverables: z.array(PlanArtifactSpecSchema),
+  successCriteria: z.array(z.string()),
+  completionChecks: z.array(PlanCompletionCheckSchema),
+  retryPolicy: PlanRetryPolicySchema,
+  failurePolicy: z.array(PlanFailureRuleSchema),
+  timeoutMs: z.number().int().positive().nullish(),
+  toolPolicy: PlanToolPolicySchema,
+  contextPolicy: PlanContextPolicySchema,
+  status: PlanNodeRunStatusSchema,
+  attemptCount: z.number().int().nonnegative(),
   retryCount: z.number().int().nonnegative(),
-  idempotencyKey: z.string(),
+  resolvedInput: z.record(z.string(), z.unknown()).nullish(),
+  latestStructuredOutput: z.record(z.string(), z.unknown()).nullish(),
+  latestNotes: z.string().nullish(),
+  blockedReason: z.string().nullish(),
+  failureClass: PlanFailureClassSchema.nullish(),
+  upstreamNodeIds: z.array(z.string()),
+  downstreamNodeIds: z.array(z.string()),
+  readyAt: z.iso.datetime().nullish(),
   startedAt: z.iso.datetime().nullish(),
   completedAt: z.iso.datetime().nullish(),
 })
-export type SerializableExecutionPlanTask = z.infer<typeof SerializableExecutionPlanTaskSchema>
+export type SerializablePlanNode = z.infer<typeof SerializablePlanNodeSchema>
+
+export const SerializablePlanArtifactSchema = z.object({
+  id: z.string(),
+  nodeId: z.string(),
+  attemptId: z.string(),
+  name: z.string(),
+  kind: PlanArtifactKindSchema,
+  pointer: z.string(),
+  schemaRef: z.string().nullish(),
+  description: z.string().nullish(),
+  payload: planStructuredPayloadSchema.nullish(),
+  createdAt: z.iso.datetime(),
+})
+export type SerializablePlanArtifact = z.infer<typeof SerializablePlanArtifactSchema>
+
+export const SerializablePlanValidationIssueSchema = z.object({
+  id: z.string(),
+  nodeId: z.string().nullish(),
+  attemptId: z.string().nullish(),
+  severity: PlanValidationIssueSeveritySchema,
+  code: z.string(),
+  message: z.string(),
+  detail: z.record(z.string(), z.unknown()).nullish(),
+  createdAt: z.iso.datetime(),
+})
+export type SerializablePlanValidationIssue = z.infer<typeof SerializablePlanValidationIssueSchema>
 
-export const SerializableExecutionPlanEventSchema = z.object({
+export const SerializablePlanApprovalSchema = z.object({
   id: z.string(),
-  taskId: z.string().nullish(),
-  eventType: ExecutionPlanEventTypeSchema,
+  nodeId: z.string(),
+  status: PlanApprovalStatusSchema,
+  presented: z.record(z.string(), z.unknown()).nullish(),
+  response: z.record(z.string(), z.unknown()).nullish(),
+  requestedBy: z.string(),
+  respondedBy: z.string().nullish(),
+  approvalMessageId: z.string().nullish(),
+  comments: z.string().nullish(),
+  requiredEdits: z.array(z.string()),
+  createdAt: z.iso.datetime(),
+  respondedAt: z.iso.datetime().nullish(),
+})
+export type SerializablePlanApproval = z.infer<typeof SerializablePlanApprovalSchema>
+
+export const SerializablePlanCheckpointSchema = z.object({
+  id: z.string(),
+  sequence: z.number().int().positive(),
+  runStatus: PlanRunStatusSchema,
+  readyNodeIds: z.array(z.string()),
+  activeNodeIds: z.array(z.string()),
+  artifactIds: z.array(z.string()),
+  lastCompletedNodeIds: z.array(z.string()),
+  snapshot: z.record(z.string(), z.unknown()),
+  createdAt: z.iso.datetime(),
+})
+export type SerializablePlanCheckpoint = z.infer<typeof SerializablePlanCheckpointSchema>
+
+export const SerializablePlanEventSchema = z.object({
+  id: z.string(),
+  nodeId: z.string().nullish(),
+  attemptId: z.string().nullish(),
+  approvalId: z.string().nullish(),
+  eventType: PlanEventTypeSchema,
   fromStatus: z.string().nullish(),
   toStatus: z.string().nullish(),
   message: z.string(),
@@ -138,22 +526,16 @@ export const SerializableExecutionPlanEventSchema = z.object({
   emittedBy: z.string(),
   createdAt: z.iso.datetime(),
 })
-export type SerializableExecutionPlanEvent = z.infer<typeof SerializableExecutionPlanEventSchema>
-
-export const SerializableExecutionPlanCarriedTaskSchema = z.object({
-  planId: z.string(),
-  taskId: z.string(),
-  title: z.string(),
-  resultStatus: ExecutionPlanTaskResultStatusSchema,
-  outputSummary: z.string(),
-})
-export type SerializableExecutionPlanCarriedTask = z.infer<typeof SerializableExecutionPlanCarriedTaskSchema>
+export type SerializablePlanEvent = z.infer<typeof SerializablePlanEventSchema>
 
 export const SerializableExecutionPlanProgressSchema = z.object({
   total: z.number().int().nonnegative(),
   pending: z.number().int().nonnegative(),
-  inProgress: z.number().int().nonnegative(),
+  ready: z.number().int().nonnegative(),
+  running: z.number().int().nonnegative(),
+  awaitingHuman: z.number().int().nonnegative(),
   completed: z.number().int().nonnegative(),
+  partial: z.number().int().nonnegative(),
   blocked: z.number().int().nonnegative(),
   failed: z.number().int().nonnegative(),
   skipped: z.number().int().nonnegative(),
@@ -162,22 +544,32 @@ export const SerializableExecutionPlanProgressSchema = z.object({
 export type SerializableExecutionPlanProgress = z.infer<typeof SerializableExecutionPlanProgressSchema>
 
 export const SerializableExecutionPlanSchema = z.object({
-  planId: z.string(),
+  specId: z.string(),
+  runId: z.string(),
   workstreamId: z.string(),
   organizationId: z.string(),
   title: z.string(),
   objective: z.string(),
-  status: ExecutionPlanStatusSchema,
+  version: z.number().int().positive(),
+  status: PlanRunStatusSchema,
   leadAgentId: z.string(),
-  currentTaskId: z.string().nullish(),
-  restartFromTaskId: z.string().nullish(),
-  replacedPlanId: z.string().nullish(),
+  schemaRegistry: PlanSchemaRegistrySchema,
+  entryNodeIds: z.array(z.string()),
+  edges: z.array(PlanEdgeSpecSchema),
+  activeNodeIds: z.array(z.string()),
+  readyNodeIds: z.array(z.string()),
+  waitingNodeId: z.string().nullish(),
+  replacedRunId: z.string().nullish(),
   failureCount: z.number().int().nonnegative(),
   startedAt: z.iso.datetime().nullish(),
   completedAt: z.iso.datetime().nullish(),
   progress: SerializableExecutionPlanProgressSchema,
-  tasks: z.array(SerializableExecutionPlanTaskSchema),
-  recentEvents: z.array(SerializableExecutionPlanEventSchema),
-  carriedTasks: z.array(SerializableExecutionPlanCarriedTaskSchema),
+  nodes: z.array(SerializablePlanNodeSchema),
+  artifacts: z.array(SerializablePlanArtifactSchema),
+  lineageArtifacts: z.array(SerializablePlanArtifactSchema),
+  validationIssues: z.array(SerializablePlanValidationIssueSchema),
+  approvals: z.array(SerializablePlanApprovalSchema),
+  latestCheckpoint: SerializablePlanCheckpointSchema.nullish(),
+  recentEvents: z.array(SerializablePlanEventSchema),
 })
 export type SerializableExecutionPlan = z.infer<typeof SerializableExecutionPlanSchema>

package/src/schemas/tools.ts

@@ -3,10 +3,9 @@ import { z } from 'zod'
 import { baseChatMessageSchema } from './chat-api'
 import type { AnyChatMessage } from './chat-message'
 import {
-  ExecutionPlanStatusSchema,
-  ExecutionPlanTaskInputSchema,
-  ExecutionPlanTaskResultStatusSchema,
-  ExecutionPlanTaskStatusSchema,
+  PlanArtifactKindSchema,
+  PlanDraftSchema,
+  PlanRunStatusSchema,
   SerializableExecutionPlanSchema,
 } from './execution-plan'
 
@@ -15,9 +14,9 @@ export const CONSULT_SPECIALIST_TOOL_NAME = 'consultSpecialist' as const
 export const CONSULT_TEAM_TOOL_NAME = 'consultTeam' as const
 export const CREATE_EXECUTION_PLAN_TOOL_NAME = 'createExecutionPlan' as const
 export const REPLACE_EXECUTION_PLAN_TOOL_NAME = 'replaceExecutionPlan' as const
-export const SET_EXECUTION_TASK_STATUS_TOOL_NAME = 'setExecutionTaskStatus' as const
+export const SUBMIT_EXECUTION_NODE_RESULT_TOOL_NAME = 'submitExecutionNodeResult' as const
 export const GET_ACTIVE_EXECUTION_PLAN_TOOL_NAME = 'getActiveExecutionPlan' as const
-export const RESTART_EXECUTION_TASK_TOOL_NAME = 'restartExecutionTask' as const
+export const RESUME_EXECUTION_PLAN_RUN_TOOL_NAME = 'resumeExecutionPlanRun' as const
 
 const UserQuestionItemSchema = z
   .object({
@@ -49,88 +48,69 @@ export const ConsultTeamResponseSchema = z
 
 export const ConsultTeamArgsSchema = z.object({ task: z.string().trim().min(1).max(6000) }).strict()
 
-const ExecutionPlanCreateTaskKindSchema = z.enum(['agent', 'user-input'])
-const ExecutionPlanCreateTaskOwnerTypeSchema = z.enum(['agent', 'user'])
+const planStructuredPayloadSchema = z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())])
 
-const ExecutionPlanTaskDefinitionSchema = z
+export const PlanArtifactSubmissionSchema = z
   .object({
-    title: z.string().trim().min(1).max(300),
-    rationale: z.string().trim().min(1).max(500),
-    kind: ExecutionPlanCreateTaskKindSchema,
-    ownerType: ExecutionPlanCreateTaskOwnerTypeSchema,
-    ownerRef: z.string().trim().min(1).max(200),
-    input: ExecutionPlanTaskInputSchema.optional(),
+    name: z.string().trim().min(1).max(200),
+    kind: PlanArtifactKindSchema,
+    pointer: z.string().trim().min(1).max(500),
+    schemaRef: z.string().trim().min(1).max(200).optional(),
+    description: z.string().trim().min(1).max(1000).optional(),
+    payload: planStructuredPayloadSchema.optional(),
   })
   .strict()
-  .refine(
-    (task) =>
-      (task.kind === 'agent' && task.ownerType === 'agent') ||
-      (task.kind === 'user-input' && task.ownerType === 'user'),
-    {
-      message: 'agent tasks must be owned by an agent and user-input tasks must be owned by a user.',
-      path: ['ownerType'],
-    },
-  )
+export type PlanArtifactSubmission = z.infer<typeof PlanArtifactSubmissionSchema>
+
+export const PlanNodeResultSubmissionSchema = z
+  .object({
+    structuredOutput: z.record(z.string(), z.unknown()).optional(),
+    artifacts: z.array(PlanArtifactSubmissionSchema).default([]),
+    notes: z.string().trim().min(1).max(2000).optional(),
+  })
+  .strict()
+export type PlanNodeResultSubmission = z.infer<typeof PlanNodeResultSubmissionSchema>
 
 const ExecutionPlanToolActionSchema = z.enum([
   'created',
   'replaced',
   'loaded',
-  'task-status-updated',
-  'task-restarted',
+  'node-result-submitted',
+  'run-resumed',
   'none',
 ])
 
-export const CreateExecutionPlanArgsSchema = z
-  .object({
-    title: z.string().trim().min(1).max(200),
-    objective: z.string().trim().min(1).max(1500),
-    tasks: z.array(ExecutionPlanTaskDefinitionSchema).min(1).max(10),
-  })
-  .strict()
+export const CreateExecutionPlanArgsSchema = PlanDraftSchema
 
-export const ReplaceExecutionPlanArgsSchema = z
-  .object({
-    planId: z.string().trim().min(1),
-    reason: z.string().trim().min(1).max(1000),
-    title: z.string().trim().min(1).max(200),
-    objective: z.string().trim().min(1).max(1500),
-    tasks: CreateExecutionPlanArgsSchema.shape.tasks,
-  })
-  .strict()
+export const ReplaceExecutionPlanArgsSchema = PlanDraftSchema.extend({
+  runId: z.string().trim().min(1),
+  reason: z.string().trim().min(1).max(1000),
+}).strict()
 
-export const SetExecutionTaskStatusArgsSchema = z
-  .object({
-    planId: z.string().trim().min(1),
-    taskId: z.string().trim().min(1),
-    status: ExecutionPlanTaskStatusSchema,
-    resultStatus: ExecutionPlanTaskResultStatusSchema.optional(),
-    outputSummary: z.string().trim().max(1500).optional(),
-    blockedReason: z.string().trim().max(1000).optional(),
-    externalRef: z.string().trim().max(300).optional(),
-  })
+export const SubmitExecutionNodeResultArgsSchema = z
+  .object({ runId: z.string().trim().min(1), nodeId: z.string().trim().min(1), result: PlanNodeResultSubmissionSchema })
   .strict()
 
 export const GetActiveExecutionPlanArgsSchema = z
-  .object({ includeEvents: z.boolean().optional().default(false) })
-  .strict()
-
-export const RestartExecutionTaskArgsSchema = z
   .object({
-    planId: z.string().trim().min(1),
-    taskId: z.string().trim().min(1),
-    resetDownstream: z.boolean().optional().default(true),
+    includeEvents: z.boolean().optional().default(true),
+    includeArtifacts: z.boolean().optional().default(true),
+    includeApprovals: z.boolean().optional().default(true),
+    includeCheckpoints: z.boolean().optional().default(false),
+    includeValidationIssues: z.boolean().optional().default(true),
   })
   .strict()
 
+export const ResumeExecutionPlanRunArgsSchema = z.object({ runId: z.string().trim().min(1) }).strict()
+
 export const ExecutionPlanToolResultDataSchema = z
   .object({
     action: ExecutionPlanToolActionSchema,
     message: z.string().trim().min(1).optional(),
-    changedTaskId: z.string().nullish(),
+    changedNodeId: z.string().nullish(),
     plan: SerializableExecutionPlanSchema.nullish(),
     hasPlan: z.boolean(),
-    status: ExecutionPlanStatusSchema.nullish(),
+    status: PlanRunStatusSchema.nullish(),
   })
   .strict()
 
@@ -147,9 +127,9 @@ export type ConsultTeamResponseData = Omit<z.infer<typeof ConsultTeamResponseSch
 export type ConsultTeamResultData = { responses: ConsultTeamResponseData[] }
 export type CreateExecutionPlanArgs = z.infer<typeof CreateExecutionPlanArgsSchema>
 export type ReplaceExecutionPlanArgs = z.infer<typeof ReplaceExecutionPlanArgsSchema>
-export type SetExecutionTaskStatusArgs = z.infer<typeof SetExecutionTaskStatusArgsSchema>
+export type SubmitExecutionNodeResultArgs = z.infer<typeof SubmitExecutionNodeResultArgsSchema>
 export type GetActiveExecutionPlanArgs = z.infer<typeof GetActiveExecutionPlanArgsSchema>
-export type RestartExecutionTaskArgs = z.infer<typeof RestartExecutionTaskArgsSchema>
+export type ResumeExecutionPlanRunArgs = z.infer<typeof ResumeExecutionPlanRunArgsSchema>
 export type ExecutionPlanToolResultData = z.infer<typeof ExecutionPlanToolResultDataSchema>
 export type CoreChatTools = {
   userQuestions: { input: UserQuestionsArgs; output: unknown }
@@ -157,7 +137,7 @@ export type CoreChatTools = {
   consultTeam: { input: ConsultTeamArgs; output: ConsultTeamResultData }
   createExecutionPlan: { input: CreateExecutionPlanArgs; output: ExecutionPlanToolResultData }
   replaceExecutionPlan: { input: ReplaceExecutionPlanArgs; output: ExecutionPlanToolResultData }
-  setExecutionTaskStatus: { input: SetExecutionTaskStatusArgs; output: ExecutionPlanToolResultData }
+  submitExecutionNodeResult: { input: SubmitExecutionNodeResultArgs; output: ExecutionPlanToolResultData }
   getActiveExecutionPlan: { input: GetActiveExecutionPlanArgs; output: ExecutionPlanToolResultData }
-  restartExecutionTask: { input: RestartExecutionTaskArgs; output: ExecutionPlanToolResultData }
+  resumeExecutionPlanRun: { input: ResumeExecutionPlanRunArgs; output: ExecutionPlanToolResultData }
 }

package/src/schemas/workstream.ts

@@ -36,7 +36,7 @@ export const sdkWorkstreamRecordSchema = z.object({
   memoryBlock: z.string().nullish(),
   memoryBlockSummary: z.string().nullish(),
   activeRunId: z.string().nullish(),
-  chatSummary: z.string().nullish(),
+  compactionSummary: z.string().nullish(),
   lastCompactedMessageId: z.string().nullish(),
   nameGenerated: z.boolean().optional(),
   isCompacting: z.boolean().optional(),