@lota-sdk/shared 0.1.14 → 0.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/shared",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -25,7 +25,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "ai": "^6.0.116",
+    "ai": "^6.0.137",
     "zod": "^4.3.6"
   }
 }

package/src/constants/model.ts

@@ -0,0 +1,34 @@
+export const OPENAI_REASONING_MODEL_ID = 'openai/gpt-5.4' as const
+
+export const OPENROUTER_TEAM_AGENT_MODEL_ID = 'openrouter/google/gemini-3.1-pro-preview' as const
+export const OPENROUTER_STRUCTURED_HELPER_MODEL_ID = 'openrouter/google/gemini-3-flash-preview:exacto' as const
+export const OPENROUTER_DELEGATED_REASONING_MODEL_ID = 'openrouter/google/gemini-3-flash-preview:exacto' as const
+export const OPENROUTER_WEB_RESEARCH_MODEL_ID = 'openrouter/stepfun/step-3.5-flash' as const
+export const OPENROUTER_FAST_REASONING_MODEL_ID = 'openrouter/openai/gpt-oss-120b:nitro' as const
+export const OPENROUTER_STRUCTURED_REASONING_MODEL_ID = 'openrouter/openai/gpt-oss-120b:exacto' as const
+
+export const BIFROST_REASONING_SUMMARY_LEVEL = 'detailed' as const
+
+export const OPENAI_HIGH_REASONING_PROVIDER_OPTIONS = {
+  openai: { forceReasoning: true, reasoningEffort: 'high', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
+} as const
+
+export const OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS = {
+  openai: { forceReasoning: true, reasoningEffort: 'high', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
+} as const
+
+export const OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS = {
+  openai: { forceReasoning: true, reasoningEffort: 'xhigh', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
+} as const
+
+export const OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS = {
+  openai: { forceReasoning: true, reasoningEffort: 'medium', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
+} as const
+
+export const OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS = {
+  openai: { forceReasoning: true, reasoningEffort: 'low', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
+} as const
+
+export const OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS = {
+  openai: { forceReasoning: true, reasoningEffort: 'minimal', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
+} as const

package/src/constants/search.ts

@@ -0,0 +1 @@
+export const VECTOR_SEARCH_OVERFETCH_MULTIPLIER = 2

package/src/index.ts

@@ -2,14 +2,19 @@ export * from './constants/attachments'
 export * from './constants/workstream'
 export * from './runtime/agent-types'
 export * from './runtime/chat-message-metadata'
+export * from './runtime/execution-plan-result'
 export * from './schemas/chat-api'
 export * from './schemas/chat-message'
 export * from './schemas/common'
+export * from './schemas/confidence'
 export * from './schemas/document'
 export * from './schemas/error'
 export * from './schemas/execution-plan'
+export * from './schemas/graph-designer'
 export * from './schemas/organization'
 export * from './schemas/organization-api'
+export * from './schemas/playbook'
+export * from './schemas/plugin-coordination'
 export * from './schemas/recent-activity'
 export * from './schemas/repository-structure'
 export * from './schemas/tools'
@@ -17,6 +22,11 @@ export * from './schemas/user'
 export * from './schemas/user-api'
 export * from './schemas/workstream'
 export * from './schemas/workstream-api'
+export * from './constants/model'
+export * from './constants/search'
 export * from './utils/assistant-text'
+export * from './utils/confidence'
+export * from './utils/date-time'
+export * from './utils/errors'
 export * from './utils/markdown-normalization'
 export * from './utils/string'

package/src/runtime/agent-types.ts

@@ -9,6 +9,7 @@ export interface CreateRoutedAgentOptions<TTools extends ToolSet = ToolSet> {
   stopWhen?: StopCondition<TTools> | Array<StopCondition<TTools>>
   prepareStep?: PrepareStepFunction<TTools>
   maxRetries?: number
+  output?: Output.Output
   modelOverride?: { model: unknown; providerOptions?: Record<string, unknown> }
   onFinish?: ToolLoopAgentOnFinishCallback<TTools>
 }

package/src/runtime/chat-message-metadata.ts

@@ -1,16 +1,23 @@
+/** Open-ended metadata bag -- index signature required for AI SDK compatibility */
 export interface MessageMetadataLike {
   createdAt?: unknown
   [key: string]: unknown
 }
 
-export function toTimestamp(value: unknown): number {
+export function toTimestamp(value: unknown): number | undefined {
   if (typeof value === 'number' && Number.isFinite(value)) return value
   if (typeof value === 'string') {
     const parsed = Date.parse(value)
     if (Number.isFinite(parsed)) return parsed
   }
   if (value instanceof Date) return value.getTime()
-  return Date.now()
+  return undefined
+}
+
+export function requireTimestamp(value: unknown): number {
+  const ts = toTimestamp(value)
+  if (ts === undefined) throw new Error(`Expected a valid timestamp, got ${String(value)}`)
+  return ts
 }
 
 export function getMessageCreatedAt(
@@ -18,21 +25,25 @@ export function getMessageCreatedAt(
   options?: { fallback?: number },
 ): number {
   const createdAt = toTimestamp(message.metadata?.createdAt)
-  if (Number.isFinite(createdAt)) return createdAt
-  return options?.fallback ?? Date.now()
+  if (createdAt !== undefined) return createdAt
+  if (options?.fallback !== undefined) return options.fallback
+  throw new Error('Message metadata is missing createdAt timestamp')
 }
 
 export function withCreatedAtMetadata<TMetadata extends MessageMetadataLike | undefined>(
   metadata: TMetadata,
-  fallback = Date.now(),
+  createdAt?: number,
 ): NonNullable<TMetadata> & { createdAt: number } {
-  const next =
-    metadata && typeof metadata === 'object'
-      ? ({ ...(metadata as Record<string, unknown>) } as NonNullable<TMetadata>)
-      : ({} as NonNullable<TMetadata>)
+  const next = (
+    metadata && typeof metadata === 'object' ? { ...(metadata as Record<string, unknown>) } : {}
+  ) as NonNullable<TMetadata>
+
+  if (typeof createdAt === 'number' && Number.isFinite(createdAt)) {
+    next.createdAt = createdAt
+  }
 
   if (typeof next.createdAt !== 'number' || !Number.isFinite(next.createdAt)) {
-    next.createdAt = fallback
+    throw new Error('withCreatedAtMetadata: createdAt is required but was not provided or present in metadata')
   }
 
   return next as NonNullable<TMetadata> & { createdAt: number }
@@ -40,8 +51,8 @@ export function withCreatedAtMetadata<TMetadata extends MessageMetadataLike | un
 
 export function withMessageCreatedAt<TMessage extends { metadata?: MessageMetadataLike }>(
   message: TMessage,
-  fallback = Date.now(),
+  createdAt?: number,
 ): TMessage {
-  const metadata = withCreatedAtMetadata(message.metadata, fallback)
+  const metadata = withCreatedAtMetadata(message.metadata, createdAt)
   return { ...message, metadata }
 }

package/src/runtime/execution-plan-result.ts

@@ -0,0 +1,20 @@
+import type { ExecutionPlanToolResultData } from '../schemas/tools'
+
+export function isExecutionPlanResult(value: unknown): value is ExecutionPlanToolResultData {
+  return value !== null && value !== undefined && typeof value === 'object' && 'hasPlan' in value
+}
+
+export function getLatestExecutionPlanResult(output: unknown): ExecutionPlanToolResultData | null {
+  if (isExecutionPlanResult(output)) {
+    return output
+  }
+
+  if (Array.isArray(output)) {
+    for (let index = output.length - 1; index >= 0; index -= 1) {
+      const candidate = getLatestExecutionPlanResult(output[index])
+      if (candidate) return candidate
+    }
+  }
+
+  return null
+}

package/src/schemas/chat-message.ts

@@ -30,7 +30,7 @@ export function parseRowMetadata(raw: unknown): MessageMetadata {
   return result.success ? result.data : undefined
 }
 
-export const dataPartsSchema = {}
+export const dataPartsSchemas = {}
 
 export type CustomDataParts = {}
 

package/src/schemas/common.ts

@@ -2,10 +2,10 @@ import { z } from 'zod'
 
 import { WORKSTREAM } from '../constants/workstream'
 
-export const unixTimestampSchema = z.coerce.date()
-
 const SURREALDB_RECORD_ID_CLASSES = new Set(['RecordId', 'StringRecordId'])
 
+export const unixTimestampSchema = z.coerce.date()
+
 function coerceRecordIdToString(val: unknown): unknown {
   if (val === null || val === undefined) return val
   if (typeof val === 'string') return val

package/src/schemas/confidence.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+
+export const ConfidenceDimensionSchema = z.enum([
+  'data-quality',
+  'source-reliability',
+  'temporal-relevance',
+  'consensus',
+  'completeness',
+])
+export type ConfidenceDimension = z.infer<typeof ConfidenceDimensionSchema>
+
+export const ConfidenceMethodSchema = z.enum(['weighted-average', 'min', 'bayesian'])
+export type ConfidenceMethod = z.infer<typeof ConfidenceMethodSchema>
+
+export const ConfidenceScoreSchema = z.object({
+  overall: z.number().min(0).max(1),
+  dimensions: z.record(z.string(), z.number().min(0).max(1)).default({}),
+  method: ConfidenceMethodSchema.default('weighted-average'),
+})
+export type ConfidenceScore = z.infer<typeof ConfidenceScoreSchema>

package/src/schemas/execution-plan.ts

@@ -1,15 +1,24 @@
 import { z } from 'zod'
 
-import { recordIdSchema, unixTimestampSchema } from './common'
+import { recordIdSchema } from './common'
+
+/** For DB record schemas — accepts Date objects from SurrealDB and coerces strings */
+const dbDateTimeSchema = z.coerce.date()
+
+/** For tool/API schemas that need JSON Schema representation — accepts ISO strings only */
+const apiDateTimeSchema = z.string().datetime({ offset: true })
 
 const planSchemaLiteralSchema = z.union([z.string(), z.number(), z.boolean(), z.null()])
 
+/** JSON Schema enum literal type */
+export type PlanSchemaLiteral = string | number | boolean | null
+
 export type PlanDataSchemaDefinition = {
   type: 'string' | 'number' | 'boolean' | 'object' | 'array'
   description?: string
   nullable?: boolean
   required?: boolean
-  enum?: Array<string | number | boolean | null>
+  enum?: Array<PlanSchemaLiteral>
   properties?: Record<string, PlanDataSchemaDefinition>
   items?: PlanDataSchemaDefinition
   minItems?: number
@@ -46,17 +55,28 @@ export const PlanNodeTypeSchema = z
     'switch',
     'join',
     'subgraph',
+    'monitoring',
+    'deliberation-fork',
   ])
   .meta({ id: 'PlanNodeTypeSchema' })
 export type PlanNodeType = z.infer<typeof PlanNodeTypeSchema>
 
 export const PlanNodeExecutorTypeSchema = z
-  .enum(['agent', 'plugin', 'user', 'system'])
+  .enum(['agent', 'plugin', 'user', 'system', 'skill'])
   .meta({ id: 'PlanNodeExecutorTypeSchema' })
 export type PlanNodeExecutorType = z.infer<typeof PlanNodeExecutorTypeSchema>
 
 export const PlanArtifactKindSchema = z
-  .enum(['json', 'markdown', 'file', 'external-ref', 'record'])
+  .enum([
+    'json',
+    'markdown',
+    'file',
+    'external-ref',
+    'record',
+    'time-series',
+    'deliberation-evidence',
+    'recommendation',
+  ])
   .meta({ id: 'PlanArtifactKindSchema' })
 export type PlanArtifactKind = z.infer<typeof PlanArtifactKindSchema>
 
@@ -92,12 +112,24 @@ export const PlanSpecStatusSchema = z.enum(['compiled', 'superseded']).meta({ id
 export type PlanSpecStatus = z.infer<typeof PlanSpecStatusSchema>
 
 export const PlanRunStatusSchema = z
-  .enum(['running', 'awaiting-human', 'blocked', 'completed', 'failed', 'aborted'])
+  .enum(['running', 'awaiting-human', 'blocked', 'completed', 'failed', 'aborted', 'scheduled'])
   .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'])
+  .enum([
+    'pending',
+    'ready',
+    'running',
+    'awaiting-human',
+    'completed',
+    'partial',
+    'blocked',
+    'failed',
+    'skipped',
+    'scheduled',
+    'monitoring',
+  ])
   .meta({ id: 'PlanNodeRunStatusSchema' })
 export type PlanNodeRunStatus = z.infer<typeof PlanNodeRunStatusSchema>
 
@@ -135,13 +167,49 @@ export const PlanEventTypeSchema = z
     'checkpoint-saved',
     'run-resumed',
     'validation-reported',
+    'schedule-created',
+    'schedule-fired',
+    'schedule-missed',
+    'deadline-warning',
+    'deadline-missed',
+    'node-scheduled',
+    'node-monitoring',
+    'cycle-started',
+    'cycle-completed',
+    'feedback-analyzed',
   ])
   .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) })
+const planOwnerRefSchema = z.string().trim().min(1).max(200)
+const planOwnerOperationSchema = z.string().trim().min(1).max(200)
+
+export const AgentPlanNodeOwnerSchema = z.object({ executorType: z.literal('agent'), ref: planOwnerRefSchema }).strict()
+export type AgentPlanNodeOwner = z.infer<typeof AgentPlanNodeOwnerSchema>
+
+export const PluginPlanNodeOwnerSchema = z
+  .object({ executorType: z.literal('plugin'), ref: planOwnerRefSchema, operation: planOwnerOperationSchema })
+  .strict()
+export type PluginPlanNodeOwner = z.infer<typeof PluginPlanNodeOwnerSchema>
+
+export const UserPlanNodeOwnerSchema = z.object({ executorType: z.literal('user'), ref: planOwnerRefSchema }).strict()
+export type UserPlanNodeOwner = z.infer<typeof UserPlanNodeOwnerSchema>
+
+export const SystemPlanNodeOwnerSchema = z
+  .object({ executorType: z.literal('system'), ref: planOwnerRefSchema, operation: planOwnerOperationSchema })
   .strict()
+export type SystemPlanNodeOwner = z.infer<typeof SystemPlanNodeOwnerSchema>
+
+export const SkillPlanNodeOwnerSchema = z.object({ executorType: z.literal('skill'), ref: planOwnerRefSchema }).strict()
+export type SkillPlanNodeOwner = z.infer<typeof SkillPlanNodeOwnerSchema>
+
+export const PlanNodeOwnerSchema = z.discriminatedUnion('executorType', [
+  AgentPlanNodeOwnerSchema,
+  PluginPlanNodeOwnerSchema,
+  UserPlanNodeOwnerSchema,
+  SystemPlanNodeOwnerSchema,
+  SkillPlanNodeOwnerSchema,
+])
 export type PlanNodeOwner = z.infer<typeof PlanNodeOwnerSchema>
 
 export const PlanArtifactSpecSchema = z
@@ -192,7 +260,241 @@ export const PlanContextPolicySchema = z
   .strict()
 export type PlanContextPolicy = z.infer<typeof PlanContextPolicySchema>
 
-const planStructuredPayloadSchema = z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())])
+export const ScheduleTypeSchema = z.enum(['immediate', 'absolute', 'relative', 'cron', 'monitoring'])
+export type ScheduleType = z.infer<typeof ScheduleTypeSchema>
+
+export const MissedSchedulePolicySchema = z.enum(['skip', 'run-immediately', 'run-next-window'])
+export type MissedSchedulePolicy = z.infer<typeof MissedSchedulePolicySchema>
+
+export const PlanScheduleSpecSchema = z
+  .object({
+    type: ScheduleTypeSchema,
+    at: apiDateTimeSchema.optional(),
+    delayMs: z.number().int().positive().optional(),
+    cron: z.string().trim().min(1).max(200).optional(),
+    intervalMs: z.number().int().positive().optional(),
+    maxFires: z.number().int().positive().optional(),
+    missedPolicy: MissedSchedulePolicySchema.default('run-immediately'),
+  })
+  .strict()
+export type PlanScheduleSpec = z.infer<typeof PlanScheduleSpecSchema>
+
+export const DeadlineActionSchema = z.enum(['notify', 'escalate', 'block', 'fail'])
+export type DeadlineAction = z.infer<typeof DeadlineActionSchema>
+
+export const DeadlineReminderSchema = z
+  .object({
+    beforeMs: z.number().int().positive(),
+    action: DeadlineActionSchema.default('notify'),
+    message: z.string().trim().min(1).max(500).optional(),
+  })
+  .strict()
+export type DeadlineReminder = z.infer<typeof DeadlineReminderSchema>
+
+export const DeadlineSpecSchema = z
+  .object({
+    dueAt: apiDateTimeSchema.optional(),
+    durationMs: z.number().int().positive().optional(),
+    reminders: z.array(DeadlineReminderSchema).default([]),
+    missAction: DeadlineActionSchema.default('fail'),
+  })
+  .strict()
+export type DeadlineSpec = z.infer<typeof DeadlineSpecSchema>
+
+export const NotificationSeveritySchema = z.enum(['info', 'warning', 'urgent', 'critical'])
+export type NotificationSeverity = z.infer<typeof NotificationSeveritySchema>
+
+export const PlanScheduleStatusSchema = z.enum(['active', 'paused', 'completed', 'cancelled'])
+export type PlanScheduleStatus = z.infer<typeof PlanScheduleStatusSchema>
+
+export const PlanScheduleRecordSchema = z.object({
+  id: recordIdSchema,
+  organizationId: recordIdSchema,
+  workstreamId: recordIdSchema,
+  planSpecId: recordIdSchema.optional(),
+  runId: recordIdSchema.optional(),
+  nodeId: z.string().optional(),
+  scheduleSpec: PlanScheduleSpecSchema,
+  status: PlanScheduleStatusSchema,
+  fireCount: z.number().int().nonnegative().default(0),
+  nextFireAt: dbDateTimeSchema.optional(),
+  lastFiredAt: dbDateTimeSchema.optional(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
+})
+export type PlanScheduleRecord = z.infer<typeof PlanScheduleRecordSchema>
+
+export const PlanTemplateSourceSchema = z.enum(['user', 'playbook', 'system']).default('user')
+export type PlanTemplateSource = z.infer<typeof PlanTemplateSourceSchema>
+
+export const CycleFrequencySchema = z.enum(['daily', 'weekly', 'biweekly', 'monthly', 'quarterly', 'custom'])
+export type CycleFrequency = z.infer<typeof CycleFrequencySchema>
+
+export const CarryForwardPolicySchema = z.enum(['none', 'incomplete-only', 'all-pending'])
+export type CarryForwardPolicy = z.infer<typeof CarryForwardPolicySchema>
+
+export const CycleScheduleSchema = z
+  .object({
+    frequency: CycleFrequencySchema,
+    customIntervalMs: z.number().int().positive().optional(),
+    startAt: apiDateTimeSchema,
+    endAt: apiDateTimeSchema.optional(),
+  })
+  .strict()
+export type CycleSchedule = z.infer<typeof CycleScheduleSchema>
+
+export const PlanCycleStatusSchema = z.enum(['active', 'paused', 'completed', 'cancelled'])
+export type PlanCycleStatus = z.infer<typeof PlanCycleStatusSchema>
+
+export const ExecutionModeSchema = z.enum(['linear', 'graph-lite', 'graph-full']).default('linear')
+export type ExecutionMode = z.infer<typeof ExecutionModeSchema>
+
+export const WriteIntentActionSchema = z.enum(['create', 'append', 'update'])
+export type WriteIntentAction = z.infer<typeof WriteIntentActionSchema>
+
+export const WriteIntentSchema = z
+  .object({
+    targetPath: z.string().trim().min(1).max(500),
+    action: WriteIntentActionSchema,
+    payload: z.union([z.record(z.string(), z.unknown()), z.array(z.unknown()), z.string()]),
+  })
+  .strict()
+export type WriteIntent = z.infer<typeof WriteIntentSchema>
+
+export const WriteValidationErrorSchema = z
+  .object({
+    targetPath: z.string(),
+    action: WriteIntentActionSchema,
+    status: z.enum(['pass', 'fail']),
+    issues: z.array(
+      z.object({
+        code: z.string(),
+        message: z.string(),
+        path: z.string().optional(),
+        suggestion: z.string().optional(),
+      }),
+    ),
+  })
+  .strict()
+export type WriteValidationError = z.infer<typeof WriteValidationErrorSchema>
+
+export const NodeWorkspaceEntrySchema = z
+  .object({
+    targetPath: z.string(),
+    action: WriteIntentActionSchema,
+    payload: z.unknown(),
+    validatedAt: apiDateTimeSchema,
+  })
+  .strict()
+export type NodeWorkspaceEntry = z.infer<typeof NodeWorkspaceEntrySchema>
+
+export const NodeResultQualitySchema = z.enum(['full', 'partial']).default('full')
+export type NodeResultQuality = z.infer<typeof NodeResultQualitySchema>
+
+const planJsonValueSchema: z.ZodType<unknown> = z.lazy(() =>
+  z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(planJsonValueSchema), planStructuredObjectSchema]),
+)
+const planStructuredObjectSchema: z.ZodType<Record<string, unknown>> = z.lazy(() =>
+  z.object({}).catchall(planJsonValueSchema),
+)
+const planStructuredPayloadSchema: z.ZodType<Record<string, unknown> | unknown[]> = z.union([
+  planStructuredObjectSchema,
+  z.array(planJsonValueSchema),
+])
+export type PlanStructuredPayload = z.infer<typeof planStructuredPayloadSchema>
+
+export const PlanArtifactSubmissionSchema = z
+  .object({
+    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()
+export type PlanArtifactSubmission = z.infer<typeof PlanArtifactSubmissionSchema>
+
+export const PlanNodeResultSubmissionSchema = z
+  .object({
+    structuredOutput: planStructuredObjectSchema.optional(),
+    artifacts: z.array(PlanArtifactSubmissionSchema).default([]),
+    notes: z.string().trim().min(1).max(2000).optional(),
+    quality: NodeResultQualitySchema.optional(),
+  })
+  .strict()
+export type PlanNodeResultSubmission = z.infer<typeof PlanNodeResultSubmissionSchema>
+export type PlanNodeResult = PlanNodeResultSubmission
+
+export interface OwnershipDispatchContext {
+  organizationId: string
+  workstreamId: string
+  planId: string
+  nodeId: string
+  leadAgentId: string
+  userId?: string
+  userName?: string
+}
+
+export const MonitoringWindowConfigSchema = z.object({
+  durationMs: z.number().int().positive(),
+  initialIntervalMs: z.number().int().positive(),
+  decayFactor: z.number().min(0.1).max(1.0).default(0.8),
+  maxIntervalMs: z.number().int().positive(),
+  earlyTermination: z
+    .object({ condition: z.string().trim().min(1).max(500), minSamples: z.number().int().positive().default(3) })
+    .optional(),
+})
+export type MonitoringWindowConfig = z.infer<typeof MonitoringWindowConfigSchema>
+
+export const PlanDependencyTriggerModeSchema = z.enum(['block', 'notify', 'best-effort'])
+export type PlanDependencyTriggerMode = z.infer<typeof PlanDependencyTriggerModeSchema>
+
+export const PlanDependencySchema = z.object({
+  sourcePlanTitle: z.string().trim().min(1).max(200),
+  sourceNodeId: z.string().trim().min(1).max(200),
+  artifactName: z.string().trim().min(1).max(200),
+  triggerMode: PlanDependencyTriggerModeSchema.default('block'),
+  maxStalenessMs: z.number().int().positive().optional(),
+})
+export type PlanDependency = z.infer<typeof PlanDependencySchema>
+
+export const DeliberationBranchSchema = z.object({
+  branchId: z.string().trim().min(1).max(200),
+  label: z.string().trim().min(1).max(300),
+  entryNodeId: z.string().trim().min(1).max(200),
+})
+export type DeliberationBranch = z.infer<typeof DeliberationBranchSchema>
+
+export const DeliberationForkConfigSchema = z.object({
+  branches: z.array(DeliberationBranchSchema).min(2).max(8),
+  resolutionGateNodeId: z.string().trim().min(1).max(200),
+})
+export type DeliberationForkConfig = z.infer<typeof DeliberationForkConfigSchema>
+
+export const ProvenanceNodeSchema = z.object({
+  nodeId: z.string(),
+  label: z.string(),
+  artifacts: z.array(z.object({ name: z.string(), kind: PlanArtifactKindSchema, id: z.string() })),
+})
+export type ProvenanceNode = z.infer<typeof ProvenanceNodeSchema>
+
+export const ProvenanceChainSchema = z.object({
+  root: z.object({ nodeId: z.string() }),
+  chain: z.array(ProvenanceNodeSchema),
+  depth: z.number().int().nonnegative(),
+})
+export type ProvenanceChain = z.infer<typeof ProvenanceChainSchema>
+
+export const ImpactAnalysisSchema = z.object({
+  sourceNodeId: z.string(),
+  affectedNodes: z.array(z.object({ nodeId: z.string(), label: z.string(), status: PlanNodeRunStatusSchema })),
+  affectedArtifacts: z.array(z.object({ name: z.string(), nodeId: z.string() })),
+})
+export type ImpactAnalysis = z.infer<typeof ImpactAnalysisSchema>
+
+export const ConvergenceStateSchema = z.enum(['progressing', 'stalled', 'diverging', 'converging'])
+export type ConvergenceState = z.infer<typeof ConvergenceStateSchema>
 
 export const PlanNodeSpecSchema = z
   .object({
@@ -216,6 +518,11 @@ export const PlanNodeSpecSchema = z
       attachmentPolicy: 'referenced-only',
       webPolicy: 'allowed',
     }),
+    schedule: PlanScheduleSpecSchema.optional(),
+    deadline: DeadlineSpecSchema.optional(),
+    monitoringConfig: MonitoringWindowConfigSchema.optional(),
+    delayAfterPredecessorMs: z.number().int().positive().optional(),
+    deliberationConfig: DeliberationForkConfigSchema.optional(),
   })
   .strict()
 export type PlanNodeSpec = z.infer<typeof PlanNodeSpecSchema>
@@ -239,10 +546,16 @@ export const PlanDraftSchema = z
     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(),
+    executionMode: ExecutionModeSchema.optional(),
+    schedule: PlanScheduleSpecSchema.optional(),
+    dependencies: z.array(PlanDependencySchema).optional(),
   })
   .strict()
 export type PlanDraft = z.infer<typeof PlanDraftSchema>
 
+export const ContextEnrichmentEntrySchema = z.object({ type: z.string(), content: z.string() })
+export type ContextEnrichmentEntry = z.infer<typeof ContextEnrichmentEntrySchema>
+
 export const PlanSpecSchema = z.object({
   id: recordIdSchema,
   organizationId: recordIdSchema,
@@ -255,10 +568,14 @@ export const PlanSpecSchema = z.object({
   schemaRegistry: PlanSchemaRegistrySchema,
   edges: z.array(PlanEdgeSpecSchema),
   entryNodeIds: z.array(z.string()),
+  executionMode: ExecutionModeSchema,
+  schedule: PlanScheduleSpecSchema.optional(),
+  dependencies: z.array(PlanDependencySchema).optional(),
+  contextEnrichments: z.array(ContextEnrichmentEntrySchema).optional(),
   replacedSpecId: recordIdSchema.optional(),
-  createdAt: unixTimestampSchema,
-  updatedAt: unixTimestampSchema.optional(),
-  compiledAt: unixTimestampSchema.optional(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
+  compiledAt: dbDateTimeSchema.optional(),
 })
 export type PlanSpecRecord = z.infer<typeof PlanSpecSchema>
 
@@ -282,10 +599,15 @@ export const PlanNodeSpecRecordSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   toolPolicy: PlanToolPolicySchema,
   contextPolicy: PlanContextPolicySchema,
+  schedule: PlanScheduleSpecSchema.optional(),
+  deadline: DeadlineSpecSchema.optional(),
+  monitoringConfig: MonitoringWindowConfigSchema.optional(),
+  delayAfterPredecessorMs: z.number().int().positive().optional(),
+  deliberationConfig: DeliberationForkConfigSchema.optional(),
   upstreamNodeIds: z.array(z.string()).default([]),
   downstreamNodeIds: z.array(z.string()).default([]),
-  createdAt: unixTimestampSchema,
-  updatedAt: unixTimestampSchema.optional(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
 })
 export type PlanNodeSpecRecord = z.infer<typeof PlanNodeSpecRecordSchema>
 
@@ -302,10 +624,12 @@ export const PlanRunSchema = z.object({
   failureCount: z.number().int().nonnegative(),
   replacedRunId: recordIdSchema.optional(),
   lastCheckpointId: recordIdSchema.optional(),
-  createdAt: unixTimestampSchema,
-  updatedAt: unixTimestampSchema.optional(),
-  startedAt: unixTimestampSchema.optional(),
-  completedAt: unixTimestampSchema.optional(),
+  scheduledAt: dbDateTimeSchema.optional(),
+  scheduleId: recordIdSchema.optional(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
+  startedAt: dbDateTimeSchema.optional(),
+  completedAt: dbDateTimeSchema.optional(),
 })
 export type PlanRunRecord = z.infer<typeof PlanRunSchema>
 
@@ -323,11 +647,12 @@ export const PlanNodeRunSchema = z.object({
   latestAttemptId: recordIdSchema.optional(),
   blockedReason: z.string().optional(),
   failureClass: PlanFailureClassSchema.optional(),
-  readyAt: unixTimestampSchema.optional(),
-  startedAt: unixTimestampSchema.optional(),
-  completedAt: unixTimestampSchema.optional(),
-  createdAt: unixTimestampSchema,
-  updatedAt: unixTimestampSchema.optional(),
+  scheduledAt: dbDateTimeSchema.optional(),
+  readyAt: dbDateTimeSchema.optional(),
+  startedAt: dbDateTimeSchema.optional(),
+  completedAt: dbDateTimeSchema.optional(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
 })
 export type PlanNodeRunRecord = z.infer<typeof PlanNodeRunSchema>
 
@@ -338,11 +663,11 @@ export const PlanNodeAttemptSchema = z.object({
   nodeId: z.string(),
   emittedBy: z.string(),
   status: PlanAttemptStatusSchema,
-  structuredOutput: z.record(z.string(), z.unknown()).optional(),
+  structuredOutput: planStructuredObjectSchema.optional(),
   notes: z.string().optional(),
   validationIssueIds: z.array(recordIdSchema).default([]),
   failureClass: PlanFailureClassSchema.optional(),
-  createdAt: unixTimestampSchema,
+  createdAt: dbDateTimeSchema,
 })
 export type PlanNodeAttemptRecord = z.infer<typeof PlanNodeAttemptSchema>
 
@@ -357,7 +682,7 @@ export const PlanArtifactSchema = z.object({
   schemaRef: z.string().optional(),
   description: z.string().optional(),
   payload: planStructuredPayloadSchema.optional(),
-  createdAt: unixTimestampSchema,
+  createdAt: dbDateTimeSchema,
 })
 export type PlanArtifactRecord = z.infer<typeof PlanArtifactSchema>
 
@@ -371,7 +696,7 @@ export const PlanValidationIssueSchema = z.object({
   code: z.string(),
   message: z.string(),
   detail: z.record(z.string(), z.unknown()).optional(),
-  createdAt: unixTimestampSchema,
+  createdAt: dbDateTimeSchema,
 })
 export type PlanValidationIssueRecord = z.infer<typeof PlanValidationIssueSchema>
 
@@ -385,7 +710,7 @@ export const PlanCheckpointSchema = z.object({
   artifactIds: z.array(recordIdSchema).default([]),
   lastCompletedNodeIds: z.array(z.string()).default([]),
   snapshot: z.record(z.string(), z.unknown()),
-  createdAt: unixTimestampSchema,
+  createdAt: dbDateTimeSchema,
 })
 export type PlanCheckpointRecord = z.infer<typeof PlanCheckpointSchema>
 
@@ -402,9 +727,9 @@ export const PlanApprovalSchema = z.object({
   approvalMessageId: z.string().optional(),
   comments: z.string().optional(),
   requiredEdits: z.array(z.string()).default([]),
-  createdAt: unixTimestampSchema,
-  updatedAt: unixTimestampSchema.optional(),
-  respondedAt: unixTimestampSchema.optional(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
+  respondedAt: dbDateTimeSchema.optional(),
 })
 export type PlanApprovalRecord = z.infer<typeof PlanApprovalSchema>
 
@@ -421,7 +746,7 @@ export const PlanEventSchema = z.object({
   message: z.string(),
   detail: z.record(z.string(), z.unknown()).optional(),
   emittedBy: z.string(),
-  createdAt: unixTimestampSchema,
+  createdAt: dbDateTimeSchema,
 })
 export type PlanEventRecord = z.infer<typeof PlanEventSchema>
 
@@ -442,6 +767,11 @@ export const SerializablePlanNodeSchema = z.object({
   timeoutMs: z.number().int().positive().nullish(),
   toolPolicy: PlanToolPolicySchema,
   contextPolicy: PlanContextPolicySchema,
+  schedule: PlanScheduleSpecSchema.nullish(),
+  deadline: DeadlineSpecSchema.nullish(),
+  monitoringConfig: MonitoringWindowConfigSchema.nullish(),
+  delayAfterPredecessorMs: z.number().int().positive().nullish(),
+  deliberationConfig: DeliberationForkConfigSchema.nullish(),
   status: PlanNodeRunStatusSchema,
   attemptCount: z.number().int().nonnegative(),
   retryCount: z.number().int().nonnegative(),
@@ -539,6 +869,8 @@ export const SerializableExecutionPlanProgressSchema = z.object({
   blocked: z.number().int().nonnegative(),
   failed: z.number().int().nonnegative(),
   skipped: z.number().int().nonnegative(),
+  scheduled: z.number().int().nonnegative(),
+  monitoring: z.number().int().nonnegative(),
   completionRatio: z.number().min(0).max(1).nullish(),
 })
 export type SerializableExecutionPlanProgress = z.infer<typeof SerializableExecutionPlanProgressSchema>
@@ -553,9 +885,11 @@ export const SerializableExecutionPlanSchema = z.object({
   version: z.number().int().positive(),
   status: PlanRunStatusSchema,
   leadAgentId: z.string(),
+  executionMode: ExecutionModeSchema,
   schemaRegistry: PlanSchemaRegistrySchema,
   entryNodeIds: z.array(z.string()),
   edges: z.array(PlanEdgeSpecSchema),
+  schedule: PlanScheduleSpecSchema.nullish(),
   activeNodeIds: z.array(z.string()),
   readyNodeIds: z.array(z.string()),
   waitingNodeId: z.string().nullish(),
@@ -573,3 +907,97 @@ export const SerializableExecutionPlanSchema = z.object({
   recentEvents: z.array(SerializablePlanEventSchema),
 })
 export type SerializableExecutionPlan = z.infer<typeof SerializableExecutionPlanSchema>
+
+export const PlanTemplateRecordSchema = z.object({
+  id: recordIdSchema,
+  organizationId: recordIdSchema,
+  name: z.string(),
+  description: z.string().optional(),
+  draft: PlanDraftSchema,
+  tags: z.array(z.string()).default([]),
+  source: PlanTemplateSourceSchema,
+  sourceRef: z.string().optional(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
+})
+export type PlanTemplateRecord = z.infer<typeof PlanTemplateRecordSchema>
+
+export const PlanCycleRecordSchema = z.object({
+  id: recordIdSchema,
+  organizationId: recordIdSchema,
+  workstreamId: recordIdSchema,
+  templateId: recordIdSchema,
+  name: z.string(),
+  schedule: CycleScheduleSchema,
+  carryForwardPolicy: CarryForwardPolicySchema.default('incomplete-only'),
+  status: PlanCycleStatusSchema,
+  currentIteration: z.number().int().nonnegative().default(0),
+  currentRunId: recordIdSchema.optional(),
+  scheduleId: recordIdSchema.optional(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
+})
+export type PlanCycleRecord = z.infer<typeof PlanCycleRecordSchema>
+
+export const ContextEnrichmentSchema = z.object({
+  domain: z.string().trim().min(1).max(200),
+  data: z.record(z.string(), z.unknown()),
+  confidence: z.number().min(0).max(1),
+})
+export type ContextEnrichment = z.infer<typeof ContextEnrichmentSchema>
+
+export const EvidenceRecordSchema = z.object({
+  sourceType: z.enum(['artifact', 'metric', 'pattern', 'external']),
+  sourceId: z.string().trim().min(1).max(200),
+  summary: z.string().trim().min(1).max(1000),
+  confidence: z.number().min(0).max(1),
+})
+export type EvidenceRecord = z.infer<typeof EvidenceRecordSchema>
+
+export const RecommendationTypeSchema = z.enum(['optimization', 'warning', 'pattern'])
+export type RecommendationType = z.infer<typeof RecommendationTypeSchema>
+
+export const RecommendationTargetSchema = z.enum(['node', 'edge', 'plan', 'playbook'])
+export type RecommendationTarget = z.infer<typeof RecommendationTargetSchema>
+
+export const RecommendationSchema = z.object({
+  type: RecommendationTypeSchema,
+  target: RecommendationTargetSchema,
+  targetId: z.string().optional(),
+  description: z.string().trim().min(1).max(2000),
+  evidence: z.array(EvidenceRecordSchema),
+  confidence: z.number().min(0).max(1),
+})
+export type Recommendation = z.infer<typeof RecommendationSchema>
+
+export const NodeQualityMetricsSchema = z.object({
+  executionTimeMs: z.number().int().nonnegative(),
+  attemptCount: z.number().int().nonnegative(),
+  artifactCount: z.number().int().nonnegative(),
+  validationIssueCount: z.number().int().nonnegative(),
+  ownerRef: z.string(),
+  ownerType: PlanNodeExecutorTypeSchema,
+  nodeType: PlanNodeTypeSchema,
+})
+export type NodeQualityMetrics = z.infer<typeof NodeQualityMetricsSchema>
+
+export const InstitutionalMemoryTypeSchema = z.enum([
+  'execution-pattern',
+  'failure-pattern',
+  'agent-affinity',
+  'timing-pattern',
+  'quality-pattern',
+])
+export type InstitutionalMemoryType = z.infer<typeof InstitutionalMemoryTypeSchema>
+
+export const InstitutionalMemorySchema = z.object({
+  id: recordIdSchema,
+  organizationId: recordIdSchema,
+  type: InstitutionalMemoryTypeSchema,
+  pattern: z.record(z.string(), z.unknown()),
+  confidence: z.number().min(0).max(1),
+  sampleCount: z.number().int().positive(),
+  createdAt: dbDateTimeSchema,
+  updatedAt: dbDateTimeSchema.optional(),
+})
+export type InstitutionalMemory = z.infer<typeof InstitutionalMemorySchema>

package/src/schemas/graph-designer.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+
+import { PlanArtifactKindSchema, PlanDraftSchema } from './execution-plan'
+
+export const GraphDesignRequestSchema = z.object({
+  objective: z.string().trim().min(1).max(4000),
+  constraints: z.array(z.string().trim().min(1).max(1000)).default([]),
+  availableAgents: z.array(z.object({ agentId: z.string(), capabilities: z.array(z.string()) })),
+  availablePlugins: z.array(z.object({ pluginRef: z.string(), operations: z.array(z.string()) })),
+  contextArtifacts: z
+    .array(z.object({ name: z.string(), kind: PlanArtifactKindSchema, summary: z.string().optional() }))
+    .default([]),
+})
+export type GraphDesignRequest = z.infer<typeof GraphDesignRequestSchema>
+
+export const GraphDesignResponseSchema = z.object({
+  draft: PlanDraftSchema,
+  reasoning: z.string().trim().min(1).max(4000),
+  confidence: z.number().min(0).max(1),
+})
+export type GraphDesignResponse = z.infer<typeof GraphDesignResponseSchema>

package/src/schemas/playbook.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+
+import { recordIdSchema } from './common'
+
+const unixTimestampSchema = z.coerce.date()
+
+export const PlaybookVersionStatusSchema = z.enum(['active', 'testing', 'rolled-back', 'archived'])
+export type PlaybookVersionStatus = z.infer<typeof PlaybookVersionStatusSchema>
+
+export const PlaybookVersionSchema = z.object({
+  id: recordIdSchema,
+  playbookId: recordIdSchema,
+  version: z.number().int().positive(),
+  parentVersionId: recordIdSchema.optional(),
+  appliedRecommendations: z.array(z.string()).default([]),
+  qualityScore: z.number().min(0).max(1).optional(),
+  status: PlaybookVersionStatusSchema,
+  createdAt: unixTimestampSchema,
+})
+export type PlaybookVersion = z.infer<typeof PlaybookVersionSchema>
+
+export const PlaybookSchema = z.object({
+  id: recordIdSchema,
+  organizationId: recordIdSchema,
+  name: z.string().trim().min(1).max(200),
+  objective: z.string().trim().min(1).max(2000),
+  currentVersionId: recordIdSchema,
+  previousVersionId: recordIdSchema.optional(),
+  cycleCount: z.number().int().nonnegative().default(0),
+  createdAt: unixTimestampSchema,
+  updatedAt: unixTimestampSchema.optional(),
+})
+export type Playbook = z.infer<typeof PlaybookSchema>

package/src/schemas/plugin-coordination.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod'
+
+export const SignalDirectionSchema = z.enum(['produces', 'consumes'])
+export type SignalDirection = z.infer<typeof SignalDirectionSchema>
+
+export const SignalDeclarationSchema = z.object({
+  signalName: z.string().trim().min(1).max(200),
+  direction: SignalDirectionSchema,
+  description: z.string().trim().min(1).max(500).optional(),
+})
+export type SignalDeclaration = z.infer<typeof SignalDeclarationSchema>

package/src/schemas/tools.ts

@@ -3,8 +3,8 @@ import { z } from 'zod'
 import { baseChatMessageSchema } from './chat-api'
 import type { AnyChatMessage } from './chat-message'
 import {
-  PlanArtifactKindSchema,
   PlanDraftSchema,
+  PlanNodeResultSubmissionSchema,
   PlanRunStatusSchema,
   SerializableExecutionPlanSchema,
 } from './execution-plan'
@@ -15,6 +15,8 @@ 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 SUBMIT_EXECUTION_NODE_RESULT_TOOL_NAME = 'submitExecutionNodeResult' as const
+export const LIST_EXECUTION_PLANS_TOOL_NAME = 'listExecutionPlans' as const
+export const GET_EXECUTION_PLAN_DETAILS_TOOL_NAME = 'getExecutionPlanDetails' as const
 export const GET_ACTIVE_EXECUTION_PLAN_TOOL_NAME = 'getActiveExecutionPlan' as const
 export const RESUME_EXECUTION_PLAN_RUN_TOOL_NAME = 'resumeExecutionPlanRun' as const
 
@@ -48,29 +50,6 @@ export const ConsultTeamResponseSchema = z
 
 export const ConsultTeamArgsSchema = z.object({ task: z.string().trim().min(1).max(6000) }).strict()
 
-const planStructuredPayloadSchema = z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())])
-
-export const PlanArtifactSubmissionSchema = z
-  .object({
-    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()
-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',
@@ -91,18 +70,41 @@ export const SubmitExecutionNodeResultArgsSchema = z
   .object({ runId: z.string().trim().min(1), nodeId: z.string().trim().min(1), result: PlanNodeResultSubmissionSchema })
   .strict()
 
+export const ListExecutionPlansArgsSchema = z.object({}).strict()
+
 export const GetActiveExecutionPlanArgsSchema = z
   .object({
-    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),
+    runId: z.string().trim().min(1).optional(),
+    includeEvents: z.boolean().default(true),
+    includeArtifacts: z.boolean().default(true),
+    includeApprovals: z.boolean().default(true),
+    includeCheckpoints: z.boolean().default(false),
+    includeValidationIssues: z.boolean().default(true),
   })
   .strict()
 
 export const ResumeExecutionPlanRunArgsSchema = z.object({ runId: z.string().trim().min(1) }).strict()
 
+export const PlanSummarySchema = z
+  .object({ runId: z.string(), title: z.string(), status: PlanRunStatusSchema })
+  .strict()
+
+export const ListExecutionPlansSummarySchema = z
+  .object({
+    runId: z.string(),
+    title: z.string(),
+    status: PlanRunStatusSchema,
+    objective: z.string(),
+    nodeCount: z.number().int().nonnegative(),
+    completedCount: z.number().int().nonnegative(),
+    failedCount: z.number().int().nonnegative(),
+  })
+  .strict()
+
+export const ListExecutionPlansToolResultDataSchema = z
+  .object({ plans: z.array(ListExecutionPlansSummarySchema), totalCount: z.number().int().nonnegative() })
+  .strict()
+
 export const ExecutionPlanToolResultDataSchema = z
   .object({
     action: ExecutionPlanToolActionSchema,
@@ -111,6 +113,8 @@ export const ExecutionPlanToolResultDataSchema = z
     plan: SerializableExecutionPlanSchema.nullish(),
     hasPlan: z.boolean(),
     status: PlanRunStatusSchema.nullish(),
+    planCount: z.number().int().nonnegative().optional(),
+    planSummaries: z.array(PlanSummarySchema).optional(),
   })
   .strict()
 
@@ -128,6 +132,9 @@ export type ConsultTeamResultData = { responses: ConsultTeamResponseData[] }
 export type CreateExecutionPlanArgs = z.infer<typeof CreateExecutionPlanArgsSchema>
 export type ReplaceExecutionPlanArgs = z.infer<typeof ReplaceExecutionPlanArgsSchema>
 export type SubmitExecutionNodeResultArgs = z.infer<typeof SubmitExecutionNodeResultArgsSchema>
+export type ListExecutionPlansArgs = z.infer<typeof ListExecutionPlansArgsSchema>
+export type ListExecutionPlansSummary = z.infer<typeof ListExecutionPlansSummarySchema>
+export type ListExecutionPlansToolResultData = z.infer<typeof ListExecutionPlansToolResultDataSchema>
 export type GetActiveExecutionPlanArgs = z.infer<typeof GetActiveExecutionPlanArgsSchema>
 export type ResumeExecutionPlanRunArgs = z.infer<typeof ResumeExecutionPlanRunArgsSchema>
 export type ExecutionPlanToolResultData = z.infer<typeof ExecutionPlanToolResultDataSchema>
@@ -138,6 +145,7 @@ export type CoreChatTools = {
   createExecutionPlan: { input: CreateExecutionPlanArgs; output: ExecutionPlanToolResultData }
   replaceExecutionPlan: { input: ReplaceExecutionPlanArgs; output: ExecutionPlanToolResultData }
   submitExecutionNodeResult: { input: SubmitExecutionNodeResultArgs; output: ExecutionPlanToolResultData }
-  getActiveExecutionPlan: { input: GetActiveExecutionPlanArgs; output: ExecutionPlanToolResultData }
+  listExecutionPlans: { input: ListExecutionPlansArgs; output: ListExecutionPlansToolResultData }
+  getExecutionPlanDetails: { input: GetActiveExecutionPlanArgs; output: ExecutionPlanToolResultData }
   resumeExecutionPlanRun: { input: ResumeExecutionPlanRunArgs; output: ExecutionPlanToolResultData }
 }

package/src/schemas/workstream.ts

@@ -15,7 +15,7 @@ export const sdkWorkstreamSchema = z.object({
   coreType: z.string().nullable().optional(),
   title: z.string(),
   status: sdkWorkstreamStatusSchema,
-  nameGenerated: z.boolean(),
+  nameGenerated: z.boolean(), // Ideally `isNameGenerated`, but maps directly to SurrealDB column `nameGenerated`
   isRunning: z.boolean(),
   isCompacting: z.boolean(),
   memoryBlock: z.string().optional(),
@@ -28,17 +28,17 @@ export const sdkWorkstreamRecordSchema = z.object({
   organizationId: recordIdSchema,
   userId: recordIdSchema,
   agentId: z.string().nullish(),
-  mode: sdkWorkstreamModeSchema.optional(),
-  core: z.boolean().optional(),
+  mode: sdkWorkstreamModeSchema,
+  core: z.boolean(),
   coreType: z.string().nullish(),
   title: z.string().nullish(),
-  status: sdkWorkstreamStatusSchema.nullish(),
+  status: sdkWorkstreamStatusSchema,
   memoryBlock: z.string().nullish(),
   memoryBlockSummary: z.string().nullish(),
   activeRunId: z.string().nullish(),
   compactionSummary: z.string().nullish(),
   lastCompactedMessageId: z.string().nullish(),
-  nameGenerated: z.boolean().optional(),
+  nameGenerated: z.boolean(), // Ideally `isNameGenerated`, but maps directly to SurrealDB column `nameGenerated`
   isCompacting: z.boolean().optional(),
   state: z.unknown().optional(),
   createdAt: z.coerce.date(),

package/src/utils/confidence.ts

@@ -0,0 +1,18 @@
+import type { ConfidenceScore } from '../schemas/confidence'
+
+export function aggregateConfidence(
+  scores: ConfidenceScore[],
+  method?: 'weighted-average' | 'min' | 'bayesian',
+): number {
+  if (scores.length === 0) return 0
+  const resolvedMethod = method ?? 'weighted-average'
+  const overalls = scores.map((s) => s.overall)
+  switch (resolvedMethod) {
+    case 'weighted-average':
+      return overalls.reduce((a, b) => a + b, 0) / overalls.length
+    case 'min':
+      return Math.min(...overalls)
+    case 'bayesian':
+      return overalls.reduce((a, b) => a * b, 1)
+  }
+}

package/src/utils/date-time.ts

@@ -0,0 +1,34 @@
+export function toIsoDateTimeString(value: unknown): string {
+  if (value instanceof Date) {
+    return value.toISOString()
+  }
+
+  // Assume API boundaries already use ISO strings.
+  if (typeof value === 'string') {
+    return value
+  }
+
+  // Support unix timestamps (seconds or milliseconds).
+  if (typeof value === 'number') {
+    const millis = value < 1_000_000_000_000 ? value * 1000 : value
+    return new Date(millis).toISOString()
+  }
+
+  // Support objects that expose toISOString (e.g., SurrealDB temporal types).
+  if (value && typeof value === 'object') {
+    const maybeToIso = (value as { toISOString?: unknown }).toISOString
+    if (typeof maybeToIso === 'function') {
+      return (value as { toISOString: () => string }).toISOString()
+    }
+  }
+
+  return String(value)
+}
+
+export function toOptionalIsoDateTimeString(value: unknown): string | undefined {
+  if (value === null || value === undefined || value === '') {
+    return undefined
+  }
+
+  return toIsoDateTimeString(value)
+}

package/src/utils/errors.ts

@@ -0,0 +1,10 @@
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message
+  if (typeof error === 'string') return error
+
+  try {
+    return JSON.stringify(error)
+  } catch {
+    return String(error)
+  }
+}