@de./types 1.0.0

package/src/realm/pipelines.ts

@@ -0,0 +1,1607 @@
+import { Type, Static, type TObject } from '@sinclair/typebox'
+import { LSPOrderTypeSchema } from '../lsp'
+import { ContextTypeSchema, ContextSchema } from '../context'
+import { CarrierMatchingCriteriaSchema } from '../lsp/carrier/utilities'
+import { HubMatchingCriteriaSchema } from '../lsp/hub/utilities'
+import { WarehouseMatchingCriteriaSchema } from '../lsp/warehouse/utilities'
+import { TerminalMatchingCriteriaSchema } from '../lsp/terminal/utilities'
+import { ActionRecordSchema, DateTimeZoneSchema } from '../time'
+import { APIResponseBaseSchema, APIResponseDataSchemaFactory, FetchByQueryRequestSchema } from '../api'
+
+/**
+ * Pipeline System - Three-Phase Architecture
+ * 
+ * Phase 1: PipelineTemplate - Design-time workflow definition
+ * Phase 2: Pipeline - Validated, continuously-monitored executable
+ * Phase 3: PipelineExecution - Runtime order processing
+ */
+
+export const PipelineHealthStatusSchema = Type.Object({
+  status: Type.Union([
+    Type.Literal('HEALTHY'),
+    Type.Literal('WARNING'),
+    Type.Literal('CRITICAL')
+  ]),
+  warnings: Type.Array(Type.String()),
+  lastCheck: Type.String({ format: 'date-time' })
+})
+
+// ============================================================================
+// DYNAMIC SERVICE RESOLUTION
+// ============================================================================
+
+/**
+ * Dynamic Query for Stage Service Selection
+ * Allows runtime resolution of service providers
+ */
+export const DynamicServiceQuerySchema = Type.Object({
+  // Query type
+  queryType: Type.Union([
+    Type.Literal('CARRIER'),
+    Type.Literal('WAREHOUSE'),
+    Type.Literal('HUB'),
+    Type.Literal('TERMINAL'),
+    Type.Literal('IOTSP'),
+    Type.Literal('PIPELINE')  // For future recursive composition
+  ]),
+  
+  // Selection criteria based on queryType
+  criteria: Type.Union([
+    Type.Object({
+      type: Type.Literal('CARRIER'),
+      filters: CarrierMatchingCriteriaSchema
+    }),
+    Type.Object({
+      type: Type.Literal('WAREHOUSE'),
+      filters: WarehouseMatchingCriteriaSchema
+    }),
+    Type.Object({
+      type: Type.Literal('HUB'),
+      filters: HubMatchingCriteriaSchema
+    }),
+    Type.Object({
+      type: Type.Literal('TERMINAL'),
+      filters: TerminalMatchingCriteriaSchema
+    }),
+    Type.Object({
+      type: Type.Literal('IOTSP'),
+      filters: Type.Object({
+        capabilities: Type.Array(Type.String()),
+        location: Type.Optional(Type.Object({
+          city: Type.Optional(Type.String()),
+          region: Type.Optional(Type.String()),
+          country: Type.Optional(Type.String())
+        })),
+        maxCost: Type.Optional(Type.Number())
+      })
+    })
+  ]),
+  
+  // Selection strategy when multiple matches found
+  selectionStrategy: Type.Union([
+    Type.Literal('BEST_MATCH'),     // Highest capability score
+    Type.Literal('CHEAPEST'),       // Lowest cost
+    Type.Literal('FASTEST'),        // Shortest estimated time
+    Type.Literal('HIGHEST_RATED'),  // Best performance history
+    Type.Literal('CLOSEST'),        // Geographic proximity
+    Type.Literal('RANDOM')          // Random selection (load balancing)
+  ]), // Default as BEST_MATCH
+  
+  // Fallback options if primary query fails
+  fallbackOptions: Type.Optional(Type.Array(Type.Object({
+    criteria: Type.Any(),
+    priority: Type.Number({ minimum: 1 })
+  }))),
+  
+  // Cache duration for query results (seconds)
+  cacheDuration: Type.Optional(Type.Number({ minimum: 0 })) // Default as 300
+})
+
+/**
+ * Stage Assignment Type
+ * Either fixed processor or dynamic query
+ */
+export const StageAssignmentSchema = Type.Union([
+  // Fixed assignment
+  Type.Object({
+    assignmentType: Type.Literal('FIXED'),
+    processor: ContextSchema
+  }),
+  // Dynamic query-based assignment
+  Type.Object({
+    assignmentType: Type.Literal('DYNAMIC'),
+    query: DynamicServiceQuerySchema
+  }),
+  // Manual selection
+  Type.Object({
+    assignmentType: Type.Literal('MANUAL')
+  })
+])
+
+// ============================================================================
+// PIPELINE EXECUTION (RUNTIME)
+// ============================================================================
+
+/**
+ * Pre-Execution Validation
+ */
+export const PreExecutionValidationSchema = Type.Object({
+  pid: Type.String(),
+  orderReference: Type.String(),
+  
+  passed: Type.Boolean(),
+  
+  // Stage-specific validations
+  stageValidations: Type.Array(Type.Object({
+    stageId: Type.String(),
+    stageName: Type.String(),
+    passed: Type.Boolean(),
+    
+    // Capacity validation
+    hasCapacity: Type.Boolean(),
+    capacityDetails: Type.Optional(Type.String()),
+    
+    // Provider availability
+    providerAvailable: Type.Boolean(),
+    assignedProvider: Type.Optional(ContextSchema),
+    
+    // Issues
+    issues: Type.Optional(Type.Array(Type.String()))
+  })),
+  
+  // Overall issues
+  failureReasons: Type.Optional(Type.Array(Type.String())),
+  
+  // Alternative suggestions
+  suggestedAlternatives: Type.Optional(Type.Array(Type.String())),
+  
+  // Timestamp
+  validated: ActionRecordSchema
+})
+
+/**
+ * Enhanced Stage Execution Status
+ */
+export const StageExecutionStatusSchema = Type.Union([
+  Type.Literal('PENDING'),
+  Type.Literal('VALIDATING'),              // Pre-execution validation
+  Type.Literal('READY'),
+  Type.Literal('ASSIGNING_PROCESSOR'),     // Dynamic processor assignment
+  Type.Literal('IN_PROGRESS'),
+  Type.Literal('WAITING'),
+  Type.Literal('COMPLETED'),
+  Type.Literal('FAILED'),
+  Type.Literal('SKIPPED'),
+  Type.Literal('CANCELLED'),
+  Type.Literal('RETRY_PENDING'),
+  Type.Literal('FALLBACK_IN_PROGRESS'),    // Using fallback processor
+  Type.Literal('ESCALATED'),
+  Type.Literal('REQUIRES_MANUAL_INTERVENTION')
+])
+
+/**
+ * Enhanced Stage Execution
+ */
+export const StageExecutionSchema = Type.Object({
+  stageId: Type.String(),
+  stageName: Type.String(),
+  order: Type.Number({ minimum: 1 }),
+  
+  // Processor assignment
+  processorType: ContextTypeSchema,
+  assignmentType: Type.Union([
+    Type.Literal('FIXED'),
+    Type.Literal('DYNAMIC'),
+    Type.Literal('MANUAL')
+  ]),
+  
+  // Assigned processor (resolved at runtime)
+  assignedProcessor: Type.Optional(ContextSchema),
+  assigned: Type.Optional(ActionRecordSchema),
+  
+  // Dynamic query results (if applicable)
+  queryResults: Type.Optional(Type.Object({
+    queryExecuted: ActionRecordSchema,
+    candidatesFound: Type.Number({ minimum: 0 }),
+    selectedProvider: ContextSchema,
+    selectionReason: Type.String(),
+    cached: Type.Boolean()
+  })),
+  
+  // Fallback tracking
+  usingFallback: Type.Optional(Type.Boolean()),
+  fallbackReason: Type.Optional(Type.String()),
+  
+  // Child order
+  orderType: Type.Optional(LSPOrderTypeSchema),
+  childOrderReference: Type.Optional(Type.String()),
+  
+  // Execution state
+  status: StageExecutionStatusSchema,
+  started: Type.Optional(ActionRecordSchema),
+  completed: Type.Optional(ActionRecordSchema),
+  durationMinutes: Type.Optional(Type.Number({ minimum: 0 })),
+  
+  // Transition tracking
+  currentTransition: Type.Optional(Type.Object({
+    ruleIndex: Type.Number(),
+    type: Type.String(),
+    attempts: Type.Number({ minimum: 0 }),
+    lastAttempt: Type.Optional(DateTimeZoneSchema),
+    nextAttempt: Type.Optional(DateTimeZoneSchema)
+  })),
+  
+  // State transitions history
+  transitions: Type.Array(Type.Object({
+    from: StageExecutionStatusSchema,
+    to: StageExecutionStatusSchema,
+    triggered: ActionRecordSchema,
+    reason: Type.Optional(Type.String()),
+    metadata: Type.Optional(Type.Record(Type.String(), Type.Any()))
+  })),
+  
+  // Error tracking
+  errors: Type.Optional(Type.Array(Type.Object({
+    datetime: DateTimeZoneSchema,
+    error: Type.String(),
+    code: Type.Optional(Type.String()),
+    recoverable: Type.Boolean(),
+    retryAttempt: Type.Optional(Type.Number())
+  }))),
+  
+  // Retry management
+  retryAttempts: Type.Optional(Type.Number({ minimum: 0 })),
+  nextRetryAt: Type.Optional(DateTimeZoneSchema),
+  
+  // Cost tracking
+  actualCost: Type.Optional(Type.Number()),
+  estimatedCost: Type.Optional(Type.Number())
+})
+
+/**
+ * Pipeline Execution Instance - Phase 3 (Runtime)
+ */
+export const PipelineExecutionSchema = Type.Object({
+  id: Type.String(),
+  context: ContextSchema,
+  
+  // Deployed pipeline reference
+  pid: Type.String(),
+  
+  // Order reference
+  orderReference: Type.Optional(Type.String()),
+  
+  // Template snapshot (for audit)
+  template: Type.Object({
+    id: Type.String(),
+    version: Type.String(),
+    name: Type.String()
+  }),
+  
+  // Pre-execution validation
+  preExecutionValidation: Type.Optional(PreExecutionValidationSchema),
+  
+  // Current position
+  currentStageIndex: Type.Number({ minimum: 0 }),
+  currentStageId: Type.Optional(Type.String()),
+  
+  // Overall status
+  status: Type.Union([
+    Type.Literal('INITIALIZED'),
+    Type.Literal('VALIDATING'),
+    Type.Literal('RUNNING'),
+    Type.Literal('WAITING'),
+    Type.Literal('COMPLETED'),
+    Type.Literal('FAILED'),
+    Type.Literal('CANCELLED'),
+    Type.Literal('PAUSED'),
+    Type.Literal('HALTED')
+  ]),
+  
+  // Halt information
+  halted: Type.Optional(ActionRecordSchema),
+  haltReason: Type.Optional(Type.String()),
+  
+  // Stage executions
+  stages: Type.Array(StageExecutionSchema),
+  
+  // Timing
+  initiated: ActionRecordSchema,
+  started: Type.Optional(ActionRecordSchema),
+  completed: Type.Optional(ActionRecordSchema),
+  estimatedCompletion: Type.Optional(ActionRecordSchema),
+  
+  // Duration tracking
+  actualDurationMinutes: Type.Optional(Type.Number({ minimum: 0 })),
+  estimatedDurationMinutes: Type.Optional(Type.Number({ minimum: 0 })),
+  
+  // Cost tracking
+  actualCost: Type.Optional(Type.Number()),
+  estimatedCost: Type.Optional(Type.Number()),
+  
+  // Metrics
+  metrics: Type.Optional(Type.Object({
+    totalStages: Type.Number(),
+    completedStages: Type.Number(),
+    failedStages: Type.Number(),
+    skippedStages: Type.Number(),
+    progressPercentage: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    // Performance
+    averageStageCompletionTime: Type.Optional(Type.Number()),
+    bottleneckStages: Type.Optional(Type.Array(Type.String()))
+  })),
+  
+  // Parent/child relationships (for pipeline composition)
+  parentExecutionId: Type.Optional(Type.String()),
+  childExecutionIds: Type.Optional(Type.Array(Type.String()))
+})
+
+export const PipelineExecutionWithHealthSchema = Type.Object({
+  executionId: Type.String(),
+  orderReference: Type.Optional(Type.String()),
+  execution: PipelineExecutionSchema,
+  health: PipelineHealthStatusSchema
+})
+
+// ============================================================================
+// PIPELINE ESCALATION
+// ============================================================================
+
+export const EscalationSeveritySchema = Type.Union([
+	Type.Literal('LOW'),
+	Type.Literal('HIGH'),
+	Type.Literal('CRITICAL')
+])
+
+export const EscalationStatusSchema = Type.Union([
+	Type.Literal('OPEN'),
+	Type.Literal('IN_PROGRESS'),
+	Type.Literal('RESOLVED')
+])
+
+/**
+ * Pipeline Escalation - created when automatic recovery is exhausted
+ */
+export const PipelineEscalationSchema = Type.Object({
+	id: Type.String(),
+	context: ContextSchema,
+
+	// References
+	executionId: Type.String(),
+	stageId: Type.String(),
+
+	// Escalation detail
+	reason: Type.String(),
+	severity: EscalationSeveritySchema,
+	status: EscalationStatusSchema,
+	failureReason: Type.String(),
+
+	// Lifecycle
+	created: ActionRecordSchema,
+	resolved: Type.Optional(ActionRecordSchema),
+	resolution: Type.Optional(Type.String())
+})
+
+// ============================================================================
+// PIPELINE TEMPLATE (DESIGN-TIME)
+// ============================================================================
+
+/**
+ * Template Status - Design phase
+ */
+export const PipelineTemplateStatusSchema = Type.Union([
+  Type.Literal('DRAFT'),        // Being edited
+  Type.Literal('READY'),        // Ready for deployment
+  Type.Literal('ARCHIVED')      // Historical record
+])
+
+/**
+ * Enhanced Stage Transition Rule
+ */
+export const StageTransitionRuleSchema = Type.Object({
+  type: Type.Union([
+    Type.Literal('STATUS_MATCH'),
+    Type.Literal('WEBHOOK_RECEIVED'),
+    Type.Literal('MANUAL_TRIGGER'),
+    Type.Literal('TIME_ELAPSED'),
+    Type.Literal('API_CHECK'),
+    Type.Literal('CONDITION_MET')  // Custom condition evaluation
+  ]),
+  
+  condition: Type.Object({
+    targetStatus: Type.Optional(Type.String()),
+    webhookEvent: Type.Optional(Type.String()),
+    delayMinutes: Type.Optional(Type.Number({ minimum: 0 })),
+    endpoint: Type.Optional(Type.String()),
+    checkInterval: Type.Optional(Type.Number({ minimum: 1 })),
+    maxAttempts: Type.Optional(Type.Number({ minimum: 1 })),
+    
+    // Field-based conditions (for CONDITION_MET)
+    field: Type.Optional(Type.String()),
+    operator: Type.Optional(Type.Union([
+      Type.Literal('EQUALS'),
+      Type.Literal('NOT_EQUALS'),
+      Type.Literal('GREATER_THAN'),
+      Type.Literal('LESS_THAN'),
+      Type.Literal('GREATER_THAN_OR_EQUAL'),
+      Type.Literal('LESS_THAN_OR_EQUAL'),
+      Type.Literal('CONTAINS'),
+      Type.Literal('IN'),
+      Type.Literal('EXISTS')
+    ])),
+    value: Type.Optional(Type.Any()),
+    
+    // Custom condition (JSONPath or expression)
+    expression: Type.Optional(Type.String())
+  }),
+  
+  onSuccess: Type.Object({
+    action: Type.Union([
+      Type.Literal('CREATE_CHILD_ORDER'),
+      Type.Literal('UPDATE_PARENT'),
+      Type.Literal('TRIGGER_WEBHOOK'),
+      Type.Literal('COMPLETE_STAGE'),
+      Type.Literal('NEXT_STAGE'),
+      Type.Literal('SKIP_TO'),
+      Type.Literal('COMPLETE_PIPELINE')
+    ]),
+    params: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    targetStageId: Type.Optional(Type.String()),
+    nextStage: Type.Optional(StageExecutionStatusSchema)
+  }),
+  
+  onFailure: Type.Optional(Type.Object({
+    action: Type.Union([
+      Type.Literal('RETRY'),
+      Type.Literal('FALLBACK'),           // Use fallback processor
+      Type.Literal('SKIP_STAGE'),
+      Type.Literal('HALT_PIPELINE'),
+      Type.Literal('MANUAL_INTERVENTION'),
+      Type.Literal('ESCALATE'),
+      Type.Literal('AUTO_FAIL'),
+      Type.Literal('ALERT')
+    ]),
+    retryCount: Type.Optional(Type.Number({ minimum: 0, maximum: 10 })),
+    retryDelay: Type.Optional(Type.Number({ minimum: 0 })),
+    retryBackoff: Type.Optional(Type.Union([
+      Type.Literal('LINEAR'),
+      Type.Literal('EXPONENTIAL')
+    ])),
+    
+    // Fallback processor options
+    fallbackProcessor: Type.Optional(StageAssignmentSchema),
+    fallbackStageId: Type.Optional(Type.String())
+  }))
+})
+
+/**
+ * Enhanced Pipeline Stage Template
+ */
+export const PipelineStageTemplateSchema: TObject<any> = Type.Object({
+  id: Type.String(),
+  name: Type.String({ minLength: 1, maxLength: 100 }),
+  description: Type.Optional(Type.String({ maxLength: 500 })),
+  order: Type.Number({ minimum: 1 }),
+  
+  // Processor assignment
+  processorType: ContextTypeSchema,
+  assignment: StageAssignmentSchema,
+  
+  // Order type for this stage
+  orderType: Type.Optional(LSPOrderTypeSchema),
+  
+  // Required capabilities
+  requiredCapabilities: Type.Optional(Type.Array(Type.String())),
+  
+  // Transitions
+  transitions: Type.Array(StageTransitionRuleSchema),
+  
+  // Skip conditions
+  skippable: Type.Boolean(),
+  skipConditions: Type.Optional(Type.Array(Type.Object({
+    field: Type.String(),
+    operator: Type.Union([
+      Type.Literal('EQUALS'),
+      Type.Literal('NOT_EQUALS'),
+      Type.Literal('GREATER_THAN'),
+      Type.Literal('LESS_THAN'),
+      Type.Literal('GREATER_THAN_OR_EQUAL'),
+      Type.Literal('LESS_THAN_OR_EQUAL'),
+      Type.Literal('CONTAINS'),
+      Type.Literal('IN'),
+      Type.Literal('EXISTS')
+    ]),
+    value: Type.Any()
+  }))),
+  
+  // Timeout
+  timeout: Type.Optional(Type.Object({
+    duration: Type.Number({ minimum: 1, description: 'minutes' }),
+    action: Type.Union([
+      Type.Literal('ALERT'),
+      Type.Literal('ESCALATE'),
+      Type.Literal('AUTO_FAIL')
+    ])
+  })),
+  
+  // Estimated metrics
+  estimatedDuration: Type.Optional(Type.Number({ minimum: 0, description: 'minutes' })),
+  estimatedCost: Type.Optional(Type.Number({ minimum: 0 }))
+})
+
+/**
+ * Pipeline Template Type
+ */
+export const PipelineTemplateTypeSchema = Type.Union([
+  Type.Literal('CSP_TO_CUSTOMER'),
+  Type.Literal('CSP_TO_WAREHOUSE'),
+  Type.Literal('WAREHOUSE_TO_CUSTOMER'),
+  Type.Literal('CROSS_DOCK'),
+  Type.Literal('COLD_CHAIN'),
+  Type.Literal('MULTI_HUB'),
+  Type.Literal('RETURN'),
+  Type.Literal('CUSTOM')
+])
+
+/**
+ * Pipeline Template - Phase 1 (Design-time)
+ */
+export const PipelineTemplateSchema = Type.Object({
+  id: Type.String(),
+  context: ContextSchema,
+
+  version: Type.String({ pattern: '^[0-9]+\\.[0-9]+\\.[0-9]+$' }),
+  name: Type.String({ minLength: 1, maxLength: 100 }),
+  description: Type.Optional(Type.String({ maxLength: 1000 })),
+  type: PipelineTemplateTypeSchema,
+  
+  // Visibility
+  visibility: Type.Union([
+    Type.Literal('PUBLIC'),      // Available to all providers
+    Type.Literal('PRIVATE'),     // Only creator can use
+    Type.Literal('SHARED')       // Shared with specific providers
+  ]),
+  
+  // Shared with (if visibility = SHARED)
+  sharedWith: Type.Optional(Type.Array(Type.String())),
+  
+  // Stages
+  stages: Type.Array(PipelineStageTemplateSchema, { minItems: 1 }),
+  
+  // Applicability rules
+  applicableWhen: Type.Optional(Type.Object({
+    orderPriority: Type.Optional(Type.Array(Type.String())),
+    orderRequirements: Type.Optional(Type.Array(Type.String())),
+    originType: Type.Optional(Type.Array(Type.String())),
+    destinationType: Type.Optional(Type.Array(Type.String())),
+    serviceLevel: Type.Optional(Type.Array(Type.String())),
+    temperatureControlled: Type.Optional(Type.Boolean()),
+    
+    // Geographic constraints
+    regions: Type.Optional(Type.Array(Type.String())),
+    countries: Type.Optional(Type.Array(Type.String())),
+    
+    // Cost constraints
+    maxCost: Type.Optional(Type.Number()),
+    
+    // Custom conditions
+    customRules: Type.Optional(Type.Array(Type.Object({
+      field: Type.String(),
+      operator: Type.String(),
+      value: Type.Any()
+    })))
+  })),
+  
+  // Metadata
+  tags: Type.Optional(Type.Array(Type.String())),
+  category: Type.Optional(Type.String()),
+  
+  // Status
+  status: PipelineTemplateStatusSchema,
+  
+  // Timestamps
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// ============================================================================
+// DEPLOYED PIPELINE (ESTABLISHMENT)
+// ============================================================================
+
+/**
+ * Deployed Pipeline Status
+ */
+export const PipelineStatusSchema = Type.Union([
+  Type.Literal('DEPLOYING'),      // Initial deployment processing
+  Type.Literal('VALIDATING'),     // Schema and capability validation
+  Type.Literal('SIMULATING'),     // Initial simulation tests
+  Type.Literal('ACTIVE'),         // Healthy and assignable
+  Type.Literal('DEGRADED'),       // Health issues detected
+  Type.Literal('DEPRECATED'),     // Marked for retirement
+  Type.Literal('ARCHIVED')        // Historical record
+])
+
+/**
+ * Validation Result
+ */
+export const ValidationResultSchema = Type.Object({
+  validationType: Type.Union([
+    Type.Literal('SCHEMA'),         // Template schema validation
+    Type.Literal('CAPABILITY'),     // Provider capability check
+    Type.Literal('SIMULATION'),     // Simulation test
+    Type.Literal('CAPACITY'),       // Real-time capacity check
+    Type.Literal('PRE_EXECUTION')   // Just-in-time order validation
+  ]),
+  
+  passed: Type.Boolean(),
+  
+  datetime: DateTimeZoneSchema,
+  
+  // Validation details
+  details: Type.Object({
+    message: Type.String(),
+    
+    // Specific checks
+    checks: Type.Array(Type.Object({
+      name: Type.String(),
+      passed: Type.Boolean(),
+      message: Type.Optional(Type.String()),
+      stageId: Type.Optional(Type.String())
+    })),
+    
+    // Issues found
+    issues: Type.Optional(Type.Array(Type.Object({
+      severity: Type.Union([
+        Type.Literal('ERROR'),
+        Type.Literal('WARNING'),
+        Type.Literal('INFO')
+      ]),
+      stageId: Type.Optional(Type.String()),
+      message: Type.String(),
+      suggestion: Type.Optional(Type.String())
+    })))
+  }),
+  
+  // Validation duration
+  durationMs: Type.Number({ minimum: 0 })
+})
+
+/**
+ * Simulation Result
+ */
+export const SimulationResultSchema = Type.Object({
+  simulationId: Type.String(),
+  
+  // Simulation type
+  simulationType: Type.Union([
+    Type.Literal('INITIAL'),       // First deployment simulation
+    Type.Literal('CONTINUOUS'),    // Background health check
+    Type.Literal('ON_DEMAND')      // Manual retest
+  ]),
+  
+  // Test scenario
+  scenario: Type.Object({
+    orderProfile: Type.String(),    // Order type tested
+    testData: Type.Optional(Type.Record(Type.String(), Type.Any()))
+  }),
+  
+  // Results
+  passed: Type.Boolean(),
+  
+  // Stage-by-stage results
+  stageResults: Type.Array(Type.Object({
+    stageId: Type.String(),
+    stageName: Type.String(),
+    passed: Type.Boolean(),
+    
+    // Provider that would be assigned
+    assignedProvider: Type.Optional(ContextSchema),
+    
+    // Capacity check
+    hasCapacity: Type.Boolean(),
+    availableCapacity: Type.Optional(Type.Number()),
+    
+    // Estimated metrics
+    estimatedDuration: Type.Optional(Type.Number()),
+    estimatedCost: Type.Optional(Type.Number()),
+    
+    // Issues
+    issues: Type.Optional(Type.Array(Type.String()))
+  })),
+  
+  // Overall metrics
+  totalEstimatedDuration: Type.Optional(Type.Number({ description: 'minutes' })),
+  totalEstimatedCost: Type.Optional(Type.Number()),
+  
+  // Timing
+  started: ActionRecordSchema,
+  completed: ActionRecordSchema,
+  durationMs: Type.Number({ minimum: 0 })
+})
+
+/**
+ * Health Score Calculation
+ */
+export const HealthScoreSchema = Type.Object({
+  // Overall score (0-100)
+  score: Type.Number({ minimum: 0, maximum: 100 }),
+  
+  // Component scores
+  components: Type.Object({
+    // Simulation success rate
+    simulationSuccess: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    // Execution success rate (historical)
+    executionSuccess: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    // Capacity availability
+    capacityAvailability: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    // Performance (speed)
+    performance: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    // Cost predictability
+    costPredictability: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  
+  // Grade
+  grade: Type.Union([
+    Type.Literal('A'),  // 90-100
+    Type.Literal('B'),  // 80-89
+    Type.Literal('C'),  // 70-79
+    Type.Literal('D'),  // 60-69
+    Type.Literal('F')   // <60
+  ]),
+  
+  // Calculation timestamp
+  calculated: ActionRecordSchema
+})
+
+/**
+ * Deployed Pipeline - Phase 2 (Establishment)
+ */
+export const PipelineSchema = Type.Object({
+  id: Type.String(),
+  context: ContextSchema,
+  
+  // Template reference (locked version)
+  template: Type.Object({
+    id: Type.String(),
+    version: Type.String(), // Frozen copy version
+    copy: PipelineTemplateSchema // Frozen copy
+  }),
+  
+  // Status
+  status: Type.Object({
+    current: PipelineStatusSchema,
+    reason: Type.Optional(Type.String()),
+    updated: Type.Optional(ActionRecordSchema),
+  }),
+  
+  // Validation history
+  validations: Type.Array(ValidationResultSchema),
+  lastValidation: Type.Optional(ValidationResultSchema),
+  
+  // Simulation history
+  simulations: Type.Array(SimulationResultSchema),
+  lastSimulation: Type.Optional(SimulationResultSchema),
+  
+  // Health monitoring
+  healthScore: Type.Optional(HealthScoreSchema),
+  healthHistory: Type.Optional(Type.Array(Type.Object({
+    score: Type.Number(),
+    datetime: DateTimeZoneSchema
+  }))),
+  
+  // Continuous testing schedule
+  testingSchedule: Type.Object({
+    frequency: Type.Union([
+      Type.Literal('DAILY'),
+      Type.Literal('EVERY_12_HOURS'),
+      Type.Literal('EVERY_6_HOURS'),
+      Type.Literal('HOURLY')
+    ]),
+    
+    lastTestAt: Type.Optional(DateTimeZoneSchema),
+    nextTestAt: Type.Optional(DateTimeZoneSchema)
+  }),
+  
+  // Event triggers
+  webhookTriggers: Type.Optional(Type.Array(Type.Object({
+    event: Type.String(),
+    url: Type.String(),
+    description: Type.Optional(Type.String())
+  }))),
+  
+  // Usage statistics
+  stats: Type.Optional(Type.Object({
+    totalExecutions: Type.Number({ minimum: 0 }),
+    activeExecutions: Type.Number({ minimum: 0 }),
+    completedExecutions: Type.Number({ minimum: 0 }),
+    failedExecutions: Type.Number({ minimum: 0 }),
+    
+    // Success rate
+    successRate: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    // Performance metrics
+    averageDuration: Type.Optional(Type.Number({ description: 'minutes' })),
+    averageCost: Type.Optional(Type.Number()),
+    
+    // Timing
+    firstExecuted: Type.Optional(ActionRecordSchema),
+    lastExecuted: Type.Optional(ActionRecordSchema)
+  })),
+  
+  // Deprecation info
+  deprecationReason: Type.Optional(Type.String()),
+  replacedBy: Type.Optional(Type.String({ description: 'New deployed pipeline ID' })),
+  
+  // Deployment metadata
+  deployed: ActionRecordSchema,
+  deprecated: Type.Optional(ActionRecordSchema),
+
+  // Archival
+  archived: Type.Optional(ActionRecordSchema)
+})
+
+// ============================================================================
+// PIPELINE SEARCH & DISCOVERY
+// ============================================================================
+
+/**
+ * Pipeline Search Query
+ */
+export const PipelineSearchQuerySchema = Type.Object({
+  // Text search
+  query: Type.Optional(Type.String()),
+  
+  // Filters
+  filters: Type.Optional(Type.Object({
+    type: Type.Optional(PipelineTemplateTypeSchema),
+    createdBy: Type.Optional(Type.String()),
+    
+    // Capabilities
+    requiredCapabilities: Type.Optional(Type.Array(Type.String())),
+    
+    // Geographic
+    regions: Type.Optional(Type.Array(Type.String())),
+    countries: Type.Optional(Type.Array(Type.String())),
+    
+    // Performance
+    minHealthScore: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    minSuccessRate: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    
+    // Cost
+    maxCost: Type.Optional(Type.Number()),
+    
+    // Service level
+    serviceLevel: Type.Optional(Type.Array(Type.String())),
+    
+    // Temperature control
+    temperatureControlled: Type.Optional(Type.Boolean()),
+    
+    // Status
+    status: Type.Optional(Type.Array(PipelineStatusSchema)),
+    
+    // Tags
+    tags: Type.Optional(Type.Array(Type.String()))
+  })),
+  
+  // Sorting
+  sortBy: Type.Optional(Type.Union([
+    Type.Literal('HEALTH_SCORE'),
+    Type.Literal('SUCCESS_RATE'),
+    Type.Literal('COST'),
+    Type.Literal('DURATION'),
+    Type.Literal('POPULARITY'),
+    Type.Literal('CREATED_AT'),
+    Type.Literal('UPDATED_AT')
+  ])),
+  
+  sortOrder: Type.Optional(Type.Union([
+    Type.Literal('ASC'),
+    Type.Literal('DESC')
+  ])),
+  
+  // Pagination
+  page: Type.Optional(Type.Number({ minimum: 1 })),
+  limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100 })) // default 20
+})
+
+/**
+ * Pipeline Search Result
+ */
+export const PipelineSearchResultSchema = Type.Object({
+  pipeline: PipelineSchema,
+  
+  // Match score
+  relevanceScore: Type.Number({ minimum: 0, maximum: 100 }),
+  
+  // Highlight why this matches
+  matchReasons: Type.Array(Type.String()),
+  
+  // Quick stats
+  quickStats: Type.Object({
+    healthScore: Type.Number({ minimum: 0, maximum: 100 }),
+    successRate: Type.Number({ minimum: 0, maximum: 100 }),
+    totalExecutions: Type.Number({ minimum: 0 }),
+    avgDuration: Type.Optional(Type.Number()),
+    avgCost: Type.Optional(Type.Number())
+  })
+})
+  
+
+// ============================================================================
+// TYPE EXPORTS
+// ============================================================================
+
+export type DynamicServiceQuery = Static<typeof DynamicServiceQuerySchema>
+export type StageAssignment = Static<typeof StageAssignmentSchema>
+
+export type PipelineTemplateStatus = Static<typeof PipelineTemplateStatusSchema>
+export type StageTransitionRule = Static<typeof StageTransitionRuleSchema>
+export type PipelineStageTemplate = Static<typeof PipelineStageTemplateSchema>
+export type PipelineTemplateType = Static<typeof PipelineTemplateTypeSchema>
+export type PipelineTemplate = Static<typeof PipelineTemplateSchema>
+
+export type ValidationResult = Static<typeof ValidationResultSchema>
+export type SimulationResult = Static<typeof SimulationResultSchema>
+export type HealthScore = Static<typeof HealthScoreSchema>
+export type PipelineHealthStatus = Static<typeof PipelineHealthStatusSchema>
+export type PipelineStatus = Static<typeof PipelineStatusSchema>
+export type Pipeline = Static<typeof PipelineSchema>
+
+export type PreExecutionValidation = Static<typeof PreExecutionValidationSchema>
+export type StageExecutionStatus = Static<typeof StageExecutionStatusSchema>
+export type StageExecution = Static<typeof StageExecutionSchema>
+export type PipelineExecution = Static<typeof PipelineExecutionSchema>
+export type PipelineExecutionWithHealth = Static<typeof PipelineExecutionWithHealthSchema>
+
+export type PipelineSearchQuery = Static<typeof PipelineSearchQuerySchema>
+export type PipelineSearchResult = Static<typeof PipelineSearchResultSchema>
+
+export type EscalationSeverity = Static<typeof EscalationSeveritySchema>
+export type EscalationStatus = Static<typeof EscalationStatusSchema>
+export type PipelineEscalation = Static<typeof PipelineEscalationSchema>
+
+
+// ============================================================================
+// REQUEST VALIDATION SCHEMAS
+// ============================================================================
+// The sufix `RVS` stands for `Request Validation Schema` to keep it short
+
+export const PipelineQueriesSearchRVS = {
+  params: Type.Object({
+    wid: Type.Optional(Type.String()),
+    xcode: Type.Optional(Type.String())
+  }),
+  body: PipelineSearchQuerySchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      results: Type.Array(PipelineSearchResultSchema),
+      total: Type.Number(),
+      page: Type.Number(),
+      limit: Type.Number(),
+      facets: Type.Optional(Type.Any())
+    })
+  ])
+}
+
+export type PipelineQueriesSearchValidation = {
+  params: Static<typeof PipelineQueriesSearchRVS.params>
+  body: Static<typeof PipelineQueriesSearchRVS.body>
+  response: Static<typeof PipelineQueriesSearchRVS.response>
+}
+
+export const PipelineQueriesRecommendRVS = {
+  body: Type.Object({
+    orderData: Type.Any(),
+    limit: Type.Optional(Type.Number())
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      recommendations: Type.Array(PipelineSearchResultSchema)
+    })
+  ])
+}
+export type PipelineQueriesRecommendValidation = {
+  body: Static<typeof PipelineQueriesRecommendRVS.body>
+  response: Static<typeof PipelineQueriesRecommendRVS.response>
+}
+
+// ─── Pipelines (main) ────────────────────────────────────────────────────────
+
+export const PipelineListRVS = {
+  querystring: Type.Intersect([
+    FetchByQueryRequestSchema,
+    Type.Object({
+      status: Type.Optional(PipelineStatusSchema),
+      minHealthScore: Type.Optional(Type.Number())
+    })
+  ]),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      pipelines: Type.Array(PipelineSchema),
+      total: Type.Number()
+    })
+  ])
+}
+export type PipelineListValidation = {
+  querystring: Static<typeof PipelineListRVS.querystring>
+  response: Static<typeof PipelineListRVS.response>
+}
+
+export const PipelineRetrieveRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ pipeline: PipelineSchema })
+  ])
+}
+export type PipelineRetrieveValidation = {
+  response: Static<typeof PipelineRetrieveRVS.response>
+}
+
+export const PipelineDeployRVS = {
+  body: Type.Object({
+    templateId: Type.String(),
+    version: Type.Optional(Type.String()),
+    testingSchedule: Type.Optional(Type.Object({
+      frequency: Type.Union([
+        Type.Literal('DAILY'),
+        Type.Literal('EVERY_12_HOURS'),
+        Type.Literal('EVERY_6_HOURS'),
+        Type.Literal('HOURLY')
+      ])
+    }))
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      pid: Type.String(),
+      deploymentStatus: Type.String()
+    })
+  ])
+}
+export type PipelineDeployValidation = {
+  body: Static<typeof PipelineDeployRVS.body>
+  response: Static<typeof PipelineDeployRVS.response>
+}
+
+export const PipelineValidateRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ validation: ValidationResultSchema })
+  ])
+}
+export type PipelineValidateValidation = {
+  response: Static<typeof PipelineValidateRVS.response>
+}
+
+export const PipelineSimulateRVS = {
+  body: Type.Object({
+    scenario: Type.Optional(Type.Object({
+      orderProfile: Type.String(),
+      testData: Type.Optional(Type.Any())
+    }))
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ simulation: SimulationResultSchema })
+  ])
+}
+export type PipelineSimulateValidation = {
+  body: Static<typeof PipelineSimulateRVS.body>
+  response: Static<typeof PipelineSimulateRVS.response>
+}
+
+export const PipelineSetStatusRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ pipeline: PipelineSchema })
+  ])
+}
+export type PipelineSetStatusValidation = {
+  response: Static<typeof PipelineSetStatusRVS.response>
+}
+
+// ─── Monitor ─────────────────────────────────────────────────────────────────
+
+export const PipelineMonitorListRVS = {
+  querystring: Type.Object({
+    status: Type.Optional(Type.Union([
+      Type.Literal('INITIALIZED'),
+      Type.Literal('RUNNING'),
+      Type.Literal('WAITING'),
+      Type.Literal('COMPLETED'),
+      Type.Literal('FAILED'),
+      Type.Literal('HALTED')
+    ])),
+    pid: Type.Optional(Type.String()),
+    limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100 })),
+    offset: Type.Optional(Type.Number({ minimum: 0 }))
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      executions: Type.Array(PipelineExecutionWithHealthSchema),
+      total: Type.Number()
+    })
+  ])
+}
+export type PipelineMonitorListValidation = {
+  querystring: Static<typeof PipelineMonitorListRVS.querystring>
+  response: Static<typeof PipelineMonitorListRVS.response>
+}
+
+export const PipelineMonitorGetRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      execution: PipelineExecutionSchema,
+      health: PipelineHealthStatusSchema,
+      pipeline: Type.Optional(Type.Any()),
+      metrics: Type.Optional(Type.Object({
+        totalStages: Type.Number(),
+        completedStages: Type.Number(),
+        failedStages: Type.Number(),
+        skippedStages: Type.Number(),
+        progressPercentage: Type.Number()
+      }))
+    })
+  ])
+}
+export type PipelineMonitorGetValidation = {
+  response: Static<typeof PipelineMonitorGetRVS.response>
+}
+
+export const PipelineMonitorOverviewRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      stats: Type.Object({
+        activeExecutions: Type.Number(),
+        stalledStages: Type.Number(),
+        timedOutStages: Type.Number(),
+        completedToday: Type.Number(),
+        failedToday: Type.Number()
+      }),
+      alerts: Type.Array(Type.Object({
+        severity: Type.Union([
+          Type.Literal('LOW'),
+          Type.Literal('WARNING'),
+          Type.Literal('HIGH'),
+          Type.Literal('CRITICAL')
+        ]),
+        message: Type.String(),
+        executionId: Type.String(),
+        stageId: Type.Optional(Type.String()),
+        timestamp: Type.Number()
+      })),
+      recentFailures: Type.Array(Type.Object({
+        executionId: Type.String(),
+        orderReference: Type.String(),
+        failedAt: Type.Number(),
+        reason: Type.String()
+      }))
+    })
+  ])
+}
+export type PipelineMonitorOverviewValidation = {
+  response: Static<typeof PipelineMonitorOverviewRVS.response>
+}
+
+// ─── Webhooks ─────────────────────────────────────────────────────────────────
+
+export const PipelineWebhookEventTypeSchema = Type.Union([
+  Type.Literal('CAPACITY_CHANGE'),
+  Type.Literal('PROVIDER_UNAVAILABLE'),
+  Type.Literal('COST_CHANGE'),
+  Type.Literal('COMPLIANCE_UPDATE'),
+  Type.Literal('CUSTOM')
+])
+export type PipelineWebhookEventType = Static<typeof PipelineWebhookEventTypeSchema>
+
+export const PipelineWebhookProcessRVS = {
+  body: Type.Object({
+    type: PipelineWebhookEventTypeSchema,
+    source: Type.String(),
+    timestamp: Type.String(),
+    data: Type.Any(),
+    affectedEntities: Type.Optional(Type.Array(Type.Object({
+      type: Type.Union([
+        Type.Literal('WAREHOUSE'),
+        Type.Literal('CARRIER'),
+        Type.Literal('HUB'),
+        Type.Literal('TERMINAL'),
+        Type.Literal('IOTSP')
+      ]),
+      id: Type.String()
+    })))
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      result: Type.Object({
+        processed: Type.Boolean(),
+        pipelinesAffected: Type.Number(),
+        validationsTriggered: Type.Number(),
+        simulationsTriggered: Type.Number(),
+        errors: Type.Array(Type.String())
+      })
+    })
+  ])
+}
+export type PipelineWebhookProcessValidation = {
+  body: Static<typeof PipelineWebhookProcessRVS.body>
+  response: Static<typeof PipelineWebhookProcessRVS.response>
+}
+
+export const PipelineWebhookRegisterRVS = {
+  body: Type.Object({
+    url: Type.String(),
+    events: Type.Array(PipelineWebhookEventTypeSchema),
+    secret: Type.Optional(Type.String())
+  })
+}
+export type PipelineWebhookRegisterValidation = {
+  body: Static<typeof PipelineWebhookRegisterRVS.body>
+}
+
+// ─── Templates ────────────────────────────────────────────────────────────────
+
+export const PipelineTemplateCreateRVS = {
+  body: Type.Omit(PipelineTemplateSchema, ['id', 'created', 'status', 'context']),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ template: PipelineTemplateSchema })
+  ])
+}
+export type PipelineTemplateCreateValidation = {
+  body: Static<typeof PipelineTemplateCreateRVS.body>
+  response: Static<typeof PipelineTemplateCreateRVS.response>
+}
+
+export const PipelineTemplateListRVS = {
+  querystring: Type.Intersect([
+    FetchByQueryRequestSchema,
+    Type.Object({
+      status: Type.Optional(PipelineTemplateStatusSchema),
+      type: Type.Optional(Type.String()),
+      createdBy: Type.Optional(Type.String())
+    })
+  ]),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      templates: Type.Array(PipelineTemplateSchema),
+      total: Type.Number()
+    })
+  ])
+}
+export type PipelineTemplateListValidation = {
+  querystring: Static<typeof PipelineTemplateListRVS.querystring>
+  response: Static<typeof PipelineTemplateListRVS.response>
+}
+
+export const PipelineTemplateGetRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      template: PipelineTemplateSchema,
+      versions: Type.Array(Type.String())
+    })
+  ])
+}
+export type PipelineTemplateGetValidation = {
+  response: Static<typeof PipelineTemplateGetRVS.response>
+}
+
+export const PipelineTemplateUpdateRVS = {
+  body: Type.Partial(Type.Omit(PipelineTemplateSchema, ['id', 'created'])),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ template: PipelineTemplateSchema })
+  ])
+}
+export type PipelineTemplateUpdateValidation = {
+  body: Static<typeof PipelineTemplateUpdateRVS.body>
+  response: Static<typeof PipelineTemplateUpdateRVS.response>
+}
+
+// ─── Analytics ────────────────────────────────────────────────────────────────
+
+export const PipelineAnalyticsOverviewRVS = {
+  querystring: Type.Object({
+    timeRange: Type.Optional(Type.Union([
+      Type.Literal('24h'),
+      Type.Literal('7d'),
+      Type.Literal('30d'),
+      Type.Literal('90d')
+    ])),
+    includeArchived: Type.Optional(Type.Boolean())
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      analytics: Type.Object({
+        summary: Type.Object({
+          totalTemplates: Type.Number(),
+          totalDeployedPipelines: Type.Number(),
+          totalExecutions: Type.Number(),
+          activeExecutions: Type.Number()
+        }),
+        health: Type.Object({
+          averageHealthScore: Type.Number(),
+          healthDistribution: Type.Record(Type.String(), Type.Number())
+        }),
+        performance: Type.Object({
+          averageSuccessRate: Type.Number(),
+          totalSuccessfulExecutions: Type.Number(),
+          totalFailedExecutions: Type.Number(),
+          averageDuration: Type.Optional(Type.Number()),
+          averageCost: Type.Optional(Type.Number())
+        }),
+        trends: Type.Optional(Type.Object({
+          executionsOverTime: Type.Array(Type.Object({ date: Type.String(), count: Type.Number() })),
+          successRateOverTime: Type.Array(Type.Object({ date: Type.String(), rate: Type.Number() }))
+        }))
+      })
+    })
+  ])
+}
+export type PipelineAnalyticsOverviewValidation = {
+  querystring: Static<typeof PipelineAnalyticsOverviewRVS.querystring>
+  response: Static<typeof PipelineAnalyticsOverviewRVS.response>
+}
+
+export const PipelineAnalyticsPipelineRVS = {
+  querystring: Type.Object({
+    timeRange: Type.Optional(Type.String())
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      stats: Type.Object({
+        executions: Type.Object({
+          total: Type.Number(),
+          successful: Type.Number(),
+          failed: Type.Number(),
+          successRate: Type.Number()
+        }),
+        performance: Type.Object({
+          averageDuration: Type.Optional(Type.Number()),
+          averageCost: Type.Optional(Type.Number()),
+          stagePerformance: Type.Optional(Type.Array(Type.Object({
+            stageId: Type.String(),
+            stageName: Type.String(),
+            averageDuration: Type.Number(),
+            successRate: Type.Number()
+          })))
+        }),
+        health: Type.Object({
+          currentScore: Type.Number(),
+          trend: Type.String(),
+          recentIssues: Type.Array(Type.String())
+        })
+      })
+    })
+  ])
+}
+export type PipelineAnalyticsPipelineValidation = {
+  querystring: Static<typeof PipelineAnalyticsPipelineRVS.querystring>
+  response: Static<typeof PipelineAnalyticsPipelineRVS.response>
+}
+
+// ─── Executions ───────────────────────────────────────────────────────────────
+
+export const PipelineExecutionCreateRVS = {
+  body: Type.Object({
+    pid: Type.String(),
+    orderReference: Type.String(),
+    preValidate: Type.Optional(Type.Boolean())
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      execution: Type.Optional(PipelineExecutionSchema),
+      validationFailed: Type.Optional(Type.Boolean())
+    })
+  ])
+}
+export type PipelineExecutionCreateValidation = {
+  body: Static<typeof PipelineExecutionCreateRVS.body>
+  response: Static<typeof PipelineExecutionCreateRVS.response>
+}
+
+export const PipelineExecutionListRVS = {
+  querystring: Type.Intersect([
+    FetchByQueryRequestSchema,
+    Type.Object({
+      pid: Type.Optional(Type.String()),
+      status: Type.Optional(Type.String()),
+      orderReference: Type.Optional(Type.String())
+    })
+  ]),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      executions: Type.Array(PipelineExecutionSchema),
+      total: Type.Number()
+    })
+  ])
+}
+export type PipelineExecutionListValidation = {
+  querystring: Static<typeof PipelineExecutionListRVS.querystring>
+  response: Static<typeof PipelineExecutionListRVS.response>
+}
+
+export const PipelineExecutionGetRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ execution: PipelineExecutionSchema })
+  ])
+}
+export type PipelineExecutionGetValidation = {
+  response: Static<typeof PipelineExecutionGetRVS.response>
+}
+
+export const PipelineExecutionActionRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ execution: PipelineExecutionSchema })
+  ])
+}
+export type PipelineExecutionActionValidation = {
+  response: Static<typeof PipelineExecutionActionRVS.response>
+}
+
+export const PipelineExecutionCancelRVS = {
+  body: Type.Object({
+    reason: Type.String()
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ execution: PipelineExecutionSchema })
+  ])
+}
+export type PipelineExecutionCancelValidation = {
+  body: Static<typeof PipelineExecutionCancelRVS.body>
+  response: Static<typeof PipelineExecutionCancelRVS.response>
+}
+
+// ─── Escalations ──────────────────────────────────────────────────────────────
+
+export const PipelineEscalationListRVS = {
+  querystring: Type.Object({
+    status: Type.Optional(EscalationStatusSchema),
+    severity: Type.Optional(EscalationSeveritySchema),
+    limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100 })),
+    offset: Type.Optional(Type.Number({ minimum: 0 }))
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      escalations: Type.Array(Type.Omit(PipelineEscalationSchema, ['context'])),
+      total: Type.Number()
+    })
+  ])
+}
+export type PipelineEscalationListValidation = {
+  querystring: Static<typeof PipelineEscalationListRVS.querystring>
+  response: Static<typeof PipelineEscalationListRVS.response>
+}
+
+export const PipelineEscalationResolveRVS = {
+  body: Type.Object({
+    resolution: Type.String({ minLength: 10, maxLength: 1000 }),
+    resumeStage: Type.Boolean(),
+    metadata: Type.Optional(Type.Record(Type.String(), Type.Any()))
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      resolved: Type.Boolean(),
+      execution: Type.Optional(PipelineExecutionSchema),
+      message: Type.String()
+    })
+  ])
+}
+export type PipelineEscalationResolveValidation = {
+  body: Static<typeof PipelineEscalationResolveRVS.body>
+  response: Static<typeof PipelineEscalationResolveRVS.response>
+}
+
+// ─── Interventions ────────────────────────────────────────────────────────────
+
+export const PipelineInterventionStageRVS = {
+  body: Type.Object({
+    action: Type.Union([
+      Type.Literal('RETRY_STAGE'),
+      Type.Literal('COMPLETE_STAGE'),
+      Type.Literal('FAIL_STAGE'),
+      Type.Literal('SKIP_STAGE'),
+      Type.Literal('RESELECT_PROCESSOR')
+    ]),
+    reason: Type.String({ minLength: 10, maxLength: 500 }),
+    metadata: Type.Optional(Type.Record(Type.String(), Type.Any()))
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      applied: Type.Boolean(),
+      execution: PipelineExecutionSchema,
+      message: Type.String(),
+      recoveryAttempted: Type.Optional(Type.Boolean()),
+      newProcessor: Type.Optional(Type.Object({
+        wid: Type.String(),
+        type: Type.String(),
+        xcode: Type.String()
+      }))
+    })
+  ])
+}
+export type PipelineInterventionStageValidation = {
+  body: Static<typeof PipelineInterventionStageRVS.body>
+  response: Static<typeof PipelineInterventionStageRVS.response>
+}
+
+export const PipelineInterventionExecutionRVS = {
+  body: Type.Object({
+    action: Type.Union([
+      Type.Literal('HALT_EXECUTION'),
+      Type.Literal('RESUME_EXECUTION'),
+      Type.Literal('FORCE_PROGRESS'),
+      Type.Literal('CANCEL_EXECUTION')
+    ]),
+    reason: Type.String({ minLength: 10, maxLength: 500 }),
+    metadata: Type.Optional(Type.Record(Type.String(), Type.Any()))
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      applied: Type.Boolean(),
+      execution: PipelineExecutionSchema,
+      message: Type.String()
+    })
+  ])
+}
+export type PipelineInterventionExecutionValidation = {
+  body: Static<typeof PipelineInterventionExecutionRVS.body>
+  response: Static<typeof PipelineInterventionExecutionRVS.response>
+}
+
+// ─── Workers ──────────────────────────────────────────────────────────────────
+
+export const PipelineWorkerInitializeRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ workers: Type.Array(Type.String()) })
+  ])
+}
+export type PipelineWorkerInitializeValidation = {
+  response: Static<typeof PipelineWorkerInitializeRVS.response>
+}
+
+export const PipelineWorkerStatsRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ workers: Type.Array(Type.Any()) })
+  ])
+}
+export type PipelineWorkerStatsValidation = {
+  response: Static<typeof PipelineWorkerStatsRVS.response>
+}
+
+export const PipelineWorkerStatsByNameRVS = {
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({ worker: Type.Any() })
+  ])
+}
+export type PipelineWorkerStatsByNameValidation = {
+  response: Static<typeof PipelineWorkerStatsByNameRVS.response>
+}