@elevasis/ui 1.4.0 → 1.5.0

package/dist/types/index.d.ts

@@ -62,6 +62,12 @@ interface ExecutionPathContext$1 {
     executionPath: string[];
 }
 type WorkflowLogContext$1 = WorkflowExecutionContext$1 | WorkflowFailureContext$1 | StepStartedContext$1 | StepCompletedContext$1 | StepFailedContext$1 | ConditionalRouteContext$1 | ExecutionPathContext$1;
+interface WorkflowLogMessage {
+    level: ExecutionLogLevel$1;
+    message: string;
+    timestamp: number;
+    context?: WorkflowLogContext$1;
+}
 
 /**
  * Agent-specific logging types
@@ -217,7 +223,7 @@ type FormFieldType$1 = 'text' | 'textarea' | 'number' | 'select' | 'checkbox' |
 /**
  * Serialized form field for API responses
  */
-interface SerializedFormField {
+interface SerializedFormField$1 {
     name: string;
     label: string;
     type: FormFieldType$1;
@@ -235,16 +241,16 @@ interface SerializedFormField {
 /**
  * Serialized form schema for API responses
  */
-interface SerializedFormSchema {
+interface SerializedFormSchema$1 {
     title?: string;
     description?: string;
-    fields: SerializedFormField[];
+    fields: SerializedFormField$1[];
     layout?: 'vertical' | 'horizontal' | 'grid';
 }
 /**
  * Serialized execution form schema for API responses
  */
-interface SerializedExecutionFormSchema extends SerializedFormSchema {
+interface SerializedExecutionFormSchema$1 extends SerializedFormSchema$1 {
     fieldMappings?: Record<string, string>;
     submitButton?: {
         label?: string;
@@ -255,7 +261,7 @@ interface SerializedExecutionFormSchema extends SerializedFormSchema {
 /**
  * Serialized schedule config for API responses
  */
-interface SerializedScheduleConfig {
+interface SerializedScheduleConfig$1 {
     enabled: boolean;
     defaultSchedule?: string;
     allowedPatterns?: string[];
@@ -263,23 +269,23 @@ interface SerializedScheduleConfig {
 /**
  * Serialized webhook config for API responses
  */
-interface SerializedWebhookConfig {
+interface SerializedWebhookConfig$1 {
     enabled: boolean;
     payloadSchema?: unknown;
 }
 /**
  * Serialized execution interface for API responses
  */
-interface SerializedExecutionInterface {
-    form: SerializedExecutionFormSchema;
-    schedule?: SerializedScheduleConfig;
-    webhook?: SerializedWebhookConfig;
+interface SerializedExecutionInterface$1 {
+    form: SerializedExecutionFormSchema$1;
+    schedule?: SerializedScheduleConfig$1;
+    webhook?: SerializedWebhookConfig$1;
 }
 /**
  * Serialized agent definition (JSON-safe)
  * Result of serializeDefinition(AgentDefinition)
  */
-interface SerializedAgentDefinition {
+interface SerializedAgentDefinition$1 {
     config: {
         resourceId: string;
         name: string;
@@ -328,13 +334,13 @@ interface SerializedAgentDefinition {
         }>;
     };
     metricsConfig?: object;
-    interface?: SerializedExecutionInterface;
+    interface?: SerializedExecutionInterface$1;
 }
 /**
  * Serialized workflow definition (JSON-safe)
  * Result of serializeDefinition(WorkflowDefinition)
  */
-interface SerializedWorkflowDefinition {
+interface SerializedWorkflowDefinition$1 {
     config: {
         resourceId: string;
         name: string;
@@ -366,7 +372,33 @@ interface SerializedWorkflowDefinition {
         outputSchema?: object;
     };
     metricsConfig?: object;
-    interface?: SerializedExecutionInterface;
+    interface?: SerializedExecutionInterface$1;
+}
+
+/**
+ * Workflow step state
+ * Aggregates step context events with timing and logs
+ */
+interface StepState {
+    stepId: string;
+    stepName: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    startTime?: number;
+    endTime?: number;
+    duration?: number;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+    logs: WorkflowLogMessage[];
+}
+/**
+ * Complete workflow execution data for node visualization
+ * Parsed from execution logs
+ */
+interface WorkflowNodeVisualizerData {
+    steps: StepState[];
+    totalDuration: number;
+    isRunning: boolean;
 }
 
 /**
@@ -378,13 +410,13 @@ interface SerializedWorkflowDefinition {
  * Use-case agnostic types that describe the purpose of each entry
  * Memory types mirror action types for clarity and filtering
  */
-type MemoryEntryType = 'context' | 'input' | 'reasoning' | 'tool-result' | 'delegation-result' | 'error';
+type MemoryEntryType$1 = 'context' | 'input' | 'reasoning' | 'tool-result' | 'delegation-result' | 'error';
 /**
  * Memory entry - represents a single entry in agent memory
  * Stored in agent memory, translated by adapters to vendor-specific formats
  */
-interface MemoryEntry {
-    type: MemoryEntryType;
+interface MemoryEntry$1 {
+    type: MemoryEntryType$1;
     content: string;
     timestamp: number;
     turnNumber: number | null;
@@ -394,20 +426,20 @@ interface MemoryEntry {
  * Agent memory - Self-orchestrated memory with session + working storage
  * Agent has full control over what persists, framework handles auto-compaction
  */
-interface AgentMemory {
+interface AgentMemory$1 {
     /**
      * Session memory - Persists for session/conversation duration
      * Never auto-trimmed by framework
      * Agent-managed key-value store for critical information
      * Agent provides strings, framework wraps in MemoryEntry
      */
-    sessionMemory: Record<string, MemoryEntry>;
+    sessionMemory: Record<string, MemoryEntry$1>;
     /**
      * Working memory - Execution history
      * Automatically compacted by framework when needed
      * Agent doesn't control compaction
      */
-    history: MemoryEntry[];
+    history: MemoryEntry$1[];
 }
 
 type Json = string | number | boolean | null | {
@@ -1553,6 +1585,276 @@ type Database = {
                     }
                 ];
             };
+            delivery_deliverables: {
+                Row: {
+                    completed_at: string | null;
+                    created_at: string;
+                    description: string | null;
+                    due_date: string | null;
+                    engagement_id: string;
+                    file_url: string | null;
+                    id: string;
+                    metadata: Json | null;
+                    milestone_id: string | null;
+                    name: string;
+                    organization_id: string;
+                    status: string;
+                    type: string;
+                    updated_at: string;
+                };
+                Insert: {
+                    completed_at?: string | null;
+                    created_at?: string;
+                    description?: string | null;
+                    due_date?: string | null;
+                    engagement_id: string;
+                    file_url?: string | null;
+                    id?: string;
+                    metadata?: Json | null;
+                    milestone_id?: string | null;
+                    name: string;
+                    organization_id: string;
+                    status?: string;
+                    type?: string;
+                    updated_at?: string;
+                };
+                Update: {
+                    completed_at?: string | null;
+                    created_at?: string;
+                    description?: string | null;
+                    due_date?: string | null;
+                    engagement_id?: string;
+                    file_url?: string | null;
+                    id?: string;
+                    metadata?: Json | null;
+                    milestone_id?: string | null;
+                    name?: string;
+                    organization_id?: string;
+                    status?: string;
+                    type?: string;
+                    updated_at?: string;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "delivery_deliverables_engagement_id_fkey";
+                        columns: ["engagement_id"];
+                        isOneToOne: false;
+                        referencedRelation: "delivery_engagements";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "delivery_deliverables_milestone_id_fkey";
+                        columns: ["milestone_id"];
+                        isOneToOne: false;
+                        referencedRelation: "delivery_milestones";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "delivery_deliverables_organization_id_fkey";
+                        columns: ["organization_id"];
+                        isOneToOne: false;
+                        referencedRelation: "organizations";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
+            delivery_engagements: {
+                Row: {
+                    actual_end_date: string | null;
+                    client_company_id: string | null;
+                    contract_value: number | null;
+                    created_at: string;
+                    deal_id: string | null;
+                    description: string | null;
+                    id: string;
+                    metadata: Json | null;
+                    name: string;
+                    organization_id: string;
+                    start_date: string | null;
+                    status: string;
+                    target_end_date: string | null;
+                    updated_at: string;
+                };
+                Insert: {
+                    actual_end_date?: string | null;
+                    client_company_id?: string | null;
+                    contract_value?: number | null;
+                    created_at?: string;
+                    deal_id?: string | null;
+                    description?: string | null;
+                    id?: string;
+                    metadata?: Json | null;
+                    name: string;
+                    organization_id: string;
+                    start_date?: string | null;
+                    status?: string;
+                    target_end_date?: string | null;
+                    updated_at?: string;
+                };
+                Update: {
+                    actual_end_date?: string | null;
+                    client_company_id?: string | null;
+                    contract_value?: number | null;
+                    created_at?: string;
+                    deal_id?: string | null;
+                    description?: string | null;
+                    id?: string;
+                    metadata?: Json | null;
+                    name?: string;
+                    organization_id?: string;
+                    start_date?: string | null;
+                    status?: string;
+                    target_end_date?: string | null;
+                    updated_at?: string;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "delivery_engagements_client_company_id_fkey";
+                        columns: ["client_company_id"];
+                        isOneToOne: false;
+                        referencedRelation: "acq_companies";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "delivery_engagements_deal_id_fkey";
+                        columns: ["deal_id"];
+                        isOneToOne: false;
+                        referencedRelation: "acq_deals";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "delivery_engagements_organization_id_fkey";
+                        columns: ["organization_id"];
+                        isOneToOne: false;
+                        referencedRelation: "organizations";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
+            delivery_milestones: {
+                Row: {
+                    checklist: Json | null;
+                    completed_at: string | null;
+                    created_at: string;
+                    description: string | null;
+                    due_date: string | null;
+                    engagement_id: string;
+                    id: string;
+                    metadata: Json | null;
+                    name: string;
+                    organization_id: string;
+                    sequence: number;
+                    status: string;
+                    updated_at: string;
+                };
+                Insert: {
+                    checklist?: Json | null;
+                    completed_at?: string | null;
+                    created_at?: string;
+                    description?: string | null;
+                    due_date?: string | null;
+                    engagement_id: string;
+                    id?: string;
+                    metadata?: Json | null;
+                    name: string;
+                    organization_id: string;
+                    sequence?: number;
+                    status?: string;
+                    updated_at?: string;
+                };
+                Update: {
+                    checklist?: Json | null;
+                    completed_at?: string | null;
+                    created_at?: string;
+                    description?: string | null;
+                    due_date?: string | null;
+                    engagement_id?: string;
+                    id?: string;
+                    metadata?: Json | null;
+                    name?: string;
+                    organization_id?: string;
+                    sequence?: number;
+                    status?: string;
+                    updated_at?: string;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "delivery_milestones_engagement_id_fkey";
+                        columns: ["engagement_id"];
+                        isOneToOne: false;
+                        referencedRelation: "delivery_engagements";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "delivery_milestones_organization_id_fkey";
+                        columns: ["organization_id"];
+                        isOneToOne: false;
+                        referencedRelation: "organizations";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
+            delivery_notes: {
+                Row: {
+                    content: string;
+                    created_at: string;
+                    created_by: string | null;
+                    engagement_id: string;
+                    id: string;
+                    metadata: Json | null;
+                    occurred_at: string;
+                    organization_id: string;
+                    summary: string | null;
+                    type: string;
+                };
+                Insert: {
+                    content: string;
+                    created_at?: string;
+                    created_by?: string | null;
+                    engagement_id: string;
+                    id?: string;
+                    metadata?: Json | null;
+                    occurred_at?: string;
+                    organization_id: string;
+                    summary?: string | null;
+                    type?: string;
+                };
+                Update: {
+                    content?: string;
+                    created_at?: string;
+                    created_by?: string | null;
+                    engagement_id?: string;
+                    id?: string;
+                    metadata?: Json | null;
+                    occurred_at?: string;
+                    organization_id?: string;
+                    summary?: string | null;
+                    type?: string;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "delivery_notes_created_by_fkey";
+                        columns: ["created_by"];
+                        isOneToOne: false;
+                        referencedRelation: "users";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "delivery_notes_engagement_id_fkey";
+                        columns: ["engagement_id"];
+                        isOneToOne: false;
+                        referencedRelation: "delivery_engagements";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "delivery_notes_organization_id_fkey";
+                        columns: ["organization_id"];
+                        isOneToOne: false;
+                        referencedRelation: "organizations";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             deployments: {
                 Row: {
                     compiled_docs: Json | null;
@@ -2512,8 +2814,8 @@ interface ScheduleOriginTracking {
     originResourceType?: OriginResourceType$1;
     originResourceId?: string;
 }
-type TaskScheduleConfig = RecurringScheduleConfig | RelativeScheduleConfig | AbsoluteScheduleConfig;
-interface RecurringScheduleConfig {
+type TaskScheduleConfig = RecurringScheduleConfig$1 | RelativeScheduleConfig$1 | AbsoluteScheduleConfig$1;
+interface RecurringScheduleConfig$1 {
     type: 'recurring';
     cron?: string;
     interval?: 'daily' | 'weekly' | 'monthly';
@@ -2523,24 +2825,24 @@ interface RecurringScheduleConfig {
     endAt?: string | null;
     overduePolicy?: 'skip' | 'execute';
 }
-interface RelativeScheduleConfig {
+interface RelativeScheduleConfig$1 {
     type: 'relative';
     anchorAt: string;
     anchorLabel?: string;
-    items: RelativeScheduleItem[];
+    items: RelativeScheduleItem$1[];
     overduePolicy?: 'skip' | 'execute';
 }
-interface RelativeScheduleItem {
+interface RelativeScheduleItem$1 {
     offset: string;
     payload: Record<string, unknown>;
     label?: string;
 }
-interface AbsoluteScheduleConfig {
+interface AbsoluteScheduleConfig$1 {
     type: 'absolute';
-    items: AbsoluteScheduleItem[];
+    items: AbsoluteScheduleItem$1[];
     overduePolicy?: 'skip' | 'execute';
 }
-interface AbsoluteScheduleItem {
+interface AbsoluteScheduleItem$1 {
     runAt: string;
     payload: Record<string, unknown>;
     label?: string;
@@ -2563,7 +2865,7 @@ interface TaskSchedule extends ScheduleOriginTracking {
     updatedAt: Date;
 }
 
-type MessageType = MessageEvent['type'];
+type MessageType = MessageEvent$1['type'];
 /**
  * Session Data Transfer Object (DTO)
  * Transform type for API responses (snake_case DB → camelCase frontend)
@@ -2577,7 +2879,7 @@ interface SessionDTO {
     turnCount: number;
     isEnded: boolean;
     title?: string | null;
-    memorySnapshot?: AgentMemory;
+    memorySnapshot?: AgentMemory$1;
     metadata?: Record<string, unknown> | null;
     createdAt: Date;
     updatedAt: Date;
@@ -2588,7 +2890,7 @@ interface ChatMessage {
     role: 'user' | 'assistant';
     messageType: MessageType;
     text: string;
-    metadata?: MessageEvent;
+    metadata?: MessageEvent$1;
     turnNumber: number;
     messageIndex?: number;
     createdAt: Date;
@@ -2660,6 +2962,29 @@ interface UserConfig {
     };
 }
 
+/**
+ * Memberships Domain - Zod Validation Schemas
+ *
+ * Validation schemas for membership management endpoints.
+ * Includes request bodies, query params, and path params.
+ *
+ * Security:
+ * - All schemas use .strict() to prevent mass assignment attacks
+ * - UUID validation prevents invalid references
+ * - Role enum validation prevents privilege escalation
+ * - organizationId never accepted in body (from JWT when needed)
+ */
+
+/**
+ * Membership status validation
+ * Note: Database constraint only allows 'active' | 'inactive'
+ */
+declare const MembershipStatusSchema: z.ZodEnum<{
+    active: "active";
+    inactive: "inactive";
+}>;
+type MembershipStatus = z.infer<typeof MembershipStatusSchema>;
+
 /**
  * Organization Membership types based on WorkOS API
  */
@@ -2675,6 +3000,15 @@ interface OrganizationMembership {
     createdAt: string;
     updatedAt: string;
 }
+interface ListMembershipsParams {
+    userId?: string;
+    organizationId?: string;
+    statuses?: MembershipStatus[];
+    limit?: number;
+    before?: string;
+    after?: string;
+    order?: 'asc' | 'desc';
+}
 /**
  * Extended membership with user and organization details for UI
  */
@@ -2712,7 +3046,7 @@ interface MembershipWithDetails extends OrganizationMembership {
  * Structured action metadata attached to assistant messages.
  * Frontend reads this instead of parsing text prefixes.
  */
-type AssistantAction = {
+type AssistantAction$1 = {
     kind: 'navigate';
     path: string;
     reason: string;
@@ -2722,13 +3056,13 @@ type AssistantAction = {
     statusFilter: string | null;
     searchQuery: string | null;
 };
-type MessageEvent = {
+type MessageEvent$1 = {
     type: 'user_message';
     text: string;
 } | {
     type: 'assistant_message';
     text: string;
-    _action?: AssistantAction;
+    _action?: AssistantAction$1;
 } | {
     type: 'agent:started';
 } | {
@@ -2759,7 +3093,7 @@ type MessageEvent = {
  * AgentConfig and WorkflowConfig now extend ResourceDefinition directly.
  * See packages/core/src/registry/types.ts for the base interface definition.
  */
-type AIResourceDefinition = SerializedWorkflowDefinition | SerializedAgentDefinition;
+type AIResourceDefinition = SerializedWorkflowDefinition$1 | SerializedAgentDefinition$1;
 
 /**
  * Resource Registry type definitions
@@ -2768,17 +3102,17 @@ type AIResourceDefinition = SerializedWorkflowDefinition | SerializedAgentDefini
 /**
  * Environment/deployment status for resources
  */
-type ResourceStatus = 'dev' | 'prod';
+type ResourceStatus$1 = 'dev' | 'prod';
 /**
  * All resource types in the platform
  * Used as the discriminator field in ResourceDefinition
  */
-type ResourceType = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human';
+type ResourceType$1 = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human';
 /**
  * Base interface for ALL platform resources
  * Shared by both executable (agents, workflows) and non-executable (triggers, integrations, etc.) resources
  */
-interface ResourceDefinition {
+interface ResourceDefinition$1 {
     /** Unique resource identifier */
     resourceId: string;
     /** Display name */
@@ -2788,11 +3122,11 @@ interface ResourceDefinition {
     /** Version for change tracking and evolution */
     version: string;
     /** Resource type discriminator */
-    type: ResourceType;
+    type: ResourceType$1;
     /** Environment/deployment status */
-    status: ResourceStatus;
+    status: ResourceStatus$1;
     /** Domain tags for filtering and organization */
-    domains?: ResourceDomain[];
+    domains?: ResourceDomain$1[];
     /** Whether the agent supports multi-turn sessions (agents only) */
     sessionCapable?: boolean;
     /** Whether the resource is local (monorepo) or remote (externally deployed) */
@@ -2806,7 +3140,7 @@ interface ResourceDefinition {
  * Centralized domain constants and definitions for all organization resources.
  */
 
-declare const DOMAINS: {
+declare const DOMAINS$1: {
     readonly INBOUND_PIPELINE: "inbound-pipeline";
     readonly LEAD_GEN_PIPELINE: "lead-gen-pipeline";
     readonly SUPPORT: "support";
@@ -2826,28 +3160,28 @@ declare const DOMAINS: {
  * ResourceDomain - Strongly typed domain identifier
  * Use this type for all domain references to ensure compile-time validation.
  */
-type ResourceDomain = (typeof DOMAINS)[keyof typeof DOMAINS];
+type ResourceDomain$1 = (typeof DOMAINS$1)[keyof typeof DOMAINS$1];
 
 type ExecutionStatus$1 = 'pending' | 'running' | 'completed' | 'failed' | 'warning';
-interface APIExecutionSummary {
+interface APIExecutionSummary$1 {
     id: string;
     status: ExecutionStatus$1;
     startTime: number;
     endTime?: number;
-    resourceStatus?: ResourceStatus;
+    resourceStatus?: ResourceStatus$1;
 }
-interface APIExecutionDetail extends APIExecutionSummary {
+interface APIExecutionDetail extends APIExecutionSummary$1 {
     executionLogs: ExecutionLogMessage$1[];
     input?: unknown;
     result?: unknown;
     error?: string;
-    resourceStatus: ResourceStatus;
+    resourceStatus: ResourceStatus$1;
     apiVersion?: string | null;
     resourceVersion?: string | null;
     sdkVersion?: string | null;
 }
 interface APIExecutionListResponse {
-    executions: APIExecutionSummary[];
+    executions: APIExecutionSummary$1[];
 }
 
 /**
@@ -3118,30 +3452,104 @@ interface AgentToolCallEvent {
 type AgentLogContext = AgentLifecycleEvent | AgentIterationEvent | AgentToolCallEvent
 
 /**
- * Base execution logger for Execution Engine
+ * Data for lifecycle 'started' events
  */
-type ExecutionLogLevel = 'debug' | 'info' | 'warn' | 'error'
-
-
-// Union type for all contexts
-type LogContext = WorkflowLogContext | AgentLogContext
-
-// Updated interface with consolidated context
-interface ExecutionLogMessage {
-  level: ExecutionLogLevel
-  message: string
-  timestamp: number
-  context?: LogContext
+interface AgentLifecycleStartedData {
+  startTime: number
+  iteration?: number
 }
 
 /**
- * Shared form field types for dynamic form generation
- * Used by: Command Queue, Execution Runner UI, future form-based features
+ * Data for lifecycle 'completed' events
  */
-
-/**
- * Supported form field types for action payloads
- * Maps to Mantine form components
+interface AgentLifecycleCompletedData {
+  startTime: number
+  endTime: number
+  duration: number
+  iteration?: number
+  attempts?: number
+  memorySize?: {
+    sessionMemoryKeys: number
+    historyEntries: number
+  }
+}
+
+/**
+ * Data for lifecycle 'failed' events
+ */
+interface AgentLifecycleFailedData {
+  startTime: number
+  endTime: number
+  duration: number
+  error: string
+  iteration?: number
+}
+
+/**
+ * Scoped logger for agent execution
+ * Captures logger and agentId to eliminate repetitive parameter passing
+ *
+ * Type-safe lifecycle logging with stage-specific required fields
+ */
+interface AgentScopedLogger {
+  lifecycle(lifecycle: AgentLifecycle, stage: 'started', data: AgentLifecycleStartedData): void
+  lifecycle(lifecycle: AgentLifecycle, stage: 'completed', data: AgentLifecycleCompletedData): void
+  lifecycle(lifecycle: AgentLifecycle, stage: 'failed', data: AgentLifecycleFailedData): void
+  reasoning(output: string, iteration: number, startTime: number, endTime: number, duration: number): void
+  action(
+    actionType: string,
+    message: string,
+    iteration: number,
+    startTime: number,
+    endTime: number,
+    duration: number
+  ): void
+  toolCall(
+    toolName: string,
+    iteration: number,
+    startTime: number,
+    endTime: number,
+    duration: number,
+    success: boolean,
+    error?: string,
+    input?: unknown,
+    output?: unknown
+  ): void
+}
+
+/**
+ * Base execution logger for Execution Engine
+ */
+type ExecutionLogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+
+// Union type for all contexts
+type LogContext = WorkflowLogContext | AgentLogContext
+
+// Updated interface with consolidated context
+interface ExecutionLogMessage {
+  level: ExecutionLogLevel
+  message: string
+  timestamp: number
+  context?: LogContext
+}
+
+// Logger interface - any logger implementation must satisfy this
+interface IExecutionLogger {
+  debug(message: string, context?: LogContext): void
+  info(message: string, context?: LogContext): void
+  warn(message: string, context?: LogContext): void
+  error(message: string, context?: LogContext): void
+}
+
+/**
+ * Shared form field types for dynamic form generation
+ * Used by: Command Queue, Execution Runner UI, future form-based features
+ */
+
+/**
+ * Supported form field types for action payloads
+ * Maps to Mantine form components
  */
 type FormFieldType =
   | 'text'       // TextInput
@@ -3211,427 +3619,2716 @@ interface FormSchema {
  */
 type ExecutionErrorCategory = 'llm' | 'tool' | 'workflow' | 'agent' | 'validation' | 'system'
 
-// ============================================================================
-// API Request/Response Types (Dashboard Observability)
-// ============================================================================
+/**
+ * Memory type definitions
+ * Types for agent memory management with semantic entry types
+ */
 
 /**
- * Time range selector for dashboard metrics
+ * Semantic memory entry types
+ * Use-case agnostic types that describe the purpose of each entry
+ * Memory types mirror action types for clarity and filtering
  */
-type TimeRange = '1h' | '24h' | '7d' | '30d'
+type MemoryEntryType =
+  | 'context' // Pre-loaded context entry (before execution)
+  | 'input' // User request or event payload
+  | 'reasoning' // LLM thought process
+  | 'tool-result' // Result from tool execution
+  | 'delegation-result' // Result from sub-agent delegation (future)
+  | 'error' // Error from failed action (tool error, validation error, etc.)
 
 /**
- * Execution health metrics response
- * Success rate, P95 duration, execution counts, and trend data
- * trendData includes executionCount for throughput visualization (eliminates separate API call)
+ * Memory entry - represents a single entry in agent memory
+ * Stored in agent memory, translated by adapters to vendor-specific formats
  */
-interface ExecutionHealthMetrics {
-  successRate: number
-  p95Duration: number
-  totalExecutions: number
-  trendData: Array<{
-    time: string
-    rate: number
-    successCount: number
-    errorCount: number
-    warningCount: number
-    executionCount: number
-  }>
-  statusCounts: { success: number; failed: number; pending: number; warning: number }
-  peakPeriod: string
-  granularity: 'hour' | 'day'
+interface MemoryEntry {
+  type: MemoryEntryType
+  content: string
+  timestamp: number
+  turnNumber: number | null // Which turn/execution created this entry (1, 2, 3... for session turns, null for session memory or one-off executions)
+  iterationNumber: number | null // Which iteration created this entry (0 = pre-iteration input, null = session memory/non-iteration-specific)
 }
 
 /**
- * Error analysis metrics response
- * Error categories and top failing resources
+ * Agent memory - Self-orchestrated memory with session + working storage
+ * Agent has full control over what persists, framework handles auto-compaction
  */
-interface ErrorAnalysisMetrics {
-  totalErrors: number
-  errorsByCategory: Array<{
-    category: string
-    count: number
-    percentage: number
-  }>
-  topFailingResources: Array<{
-    resourceId: string
-    name: string
-    errorCount: number
-    failureRate: number
-  }>
+interface AgentMemory {
+  /**
+   * Session memory - Persists for session/conversation duration
+   * Never auto-trimmed by framework
+   * Agent-managed key-value store for critical information
+   * Agent provides strings, framework wraps in MemoryEntry
+   */
+  sessionMemory: Record<string, MemoryEntry>
+
+  /**
+   * Working memory - Execution history
+   * Automatically compacted by framework when needed
+   * Agent doesn't control compaction
+   */
+  history: MemoryEntry[]
 }
 
 /**
- * Business impact metrics response
- * ROI, labor savings, and cost analysis
+ * Memory status for agent awareness
  */
-interface BusinessImpactMetrics {
-  totalSavingsUsd: number
-  totalCostUsd: number
-  netSavingsUsd: number
-  roi: number
+interface MemoryStatus {
+  // Session memory
+  sessionMemoryKeys: number // Current count
+  sessionMemoryLimit: number // Max allowed (default: 10)
+  currentKeys: string[] // List of keys currently stored
+
+  // History memory (token-based)
+  historyPercent: number // 0-100 (percentage of token budget used)
+  historyTokens: number // Current token count
+  tokenBudget: number // Total token budget for memory
 }
 
 /**
- * Cost breakdown metrics response
- * Per-resource cost analysis
+ * Memory constraints (optional limits)
  */
-interface CostBreakdownMetrics {
-  resources: Array<{
-    resourceId: string
-    totalCostUsd: number
-    executionCount: number
-    avgCostUsd: number
-  }>
+interface MemoryConstraints {
+  maxSessionMemoryKeys?: number // Max session memory keys (default: 10)
+  maxMemoryTokens?: number // Total token budget for all memory (default: 14000)
 }
 
 /**
- * Dashboard metrics response
- * Aggregates core observability metrics in a single response
- * Note: Throughput data is now included in executionHealth.trendData.executionCount
+ * Generic LLM Types
+ * Universal interfaces for LLM interaction across all resource types
  */
-interface DashboardMetrics {
-  executionHealth: ExecutionHealthMetrics
-  costBreakdown: CostBreakdownMetrics
-  businessImpact: BusinessImpactMetrics
-  /** ISO timestamp of the currently active deployment, or null if none */
-  activeDeploymentDate: string | null
-  /** Deployment version of the active deployment, or null if none */
-  activeDeploymentVersion: string | null
-}
 
 // ============================================================================
-// Error Tracking Types
+// Message Format (OpenAI-compatible)
 // ============================================================================
 
 /**
- * Error record for list view (ErrorBreakdownTable)
+ * Standard chat message format
+ * Compatible with OpenAI, Anthropic, and other providers
  */
-interface ErrorRecord {
-  id: string // execution_errors.id
-  timestamp: string // occurred_at
-  errorType: string // error_type
-  message: string // error_message
-  executionId: string // execution_id
-  resourceId: string // execution_logs.resource_id (via JOIN)
-  resourceName: string // execution_logs.resource_id (TODO: resolve via registry)
-  severity: 'critical' | 'warning' | 'info'
-  category: ExecutionErrorCategory // error_category (moved from metadata to dedicated column)
-  resolved: boolean // resolved flag (human acknowledgment, does not affect execution status)
-  resolvedAt: string | null // timestamp when resolved
-  resolvedBy: string | null // user ID who resolved
+interface LLMMessage {
+  role: 'system' | 'user' | 'assistant'
+  content: string
 }
 
-/**
- * Full error detail for modal view (ErrorDetailsModal)
- */
-interface ErrorDetailFull extends ErrorRecord {
-  stackTrace?: string // error_stack_trace
-  retryAttempt?: number // metadata.retryAttempt
-  stepName?: string // metadata.stepName
-  stepSequence?: number // metadata.stepSequence
-  errorContext?: Record<string, unknown> // metadata.errorContext
-  executionContext?: Record<string, unknown> // metadata.executionContext
-}
+// ============================================================================
+// Generic Request/Response
+// ============================================================================
 
 /**
- * Error details API response (paginated)
+ * Generic LLM generation request
+ * Usable by agents, workflows, tools, etc.
  */
-interface ErrorDetailResponse {
-  errors: ErrorRecord[]
-  total: number
-  page: number
-  limit: number
+interface LLMGenerateRequest {
+  // Prompt (required)
+  messages: LLMMessage[]
+
+  // Output structure (required)
+  responseSchema: unknown // JSON Schema for structured output
+
+  // Constraints (optional)
+  /** Maximum output tokens per LLM call. NOT the model's context window — see ModelInfo.maxTokens for that. */
+  maxOutputTokens?: number
+  temperature?: number
+  topP?: number
+
+  // Cancellation (optional)
+  signal?: AbortSignal // Execution-level abort signal, composed with per-call timeout in base adapters
 }
 
 /**
- * Error trend data for time-series charts
+ * Generic LLM generation response
+ * Usage field is internal-only (stripped by UniversalLLMAdapter wrapper)
  */
-interface ErrorTrend {
-  time: string // Time bucket (ISO timestamp)
-  errorCount: number // Total errors in bucket
-  criticalCount: number // Critical errors in bucket
-  warningCount: number // Warning errors in bucket
-  infoCount: number // Info errors in bucket
+interface LLMGenerateResponse<T = unknown> {
+  output: T // Parsed structured output (validated against responseSchema)
+
+  // Internal use only (for observability tracking)
+  // Not exposed in public interface - wrapper extracts this
+  usage?: {
+    inputTokens: number
+    outputTokens: number
+    totalTokens: number
+  }
+
+  // Actual cost from provider in USD (when available)
+  // Currently only OpenRouter provides this via usage accounting
+  cost?: number
 }
 
 // ============================================================================
-// Cost Analytics Types (Time-Series)
+// LLM Adapter Interface
 // ============================================================================
 
 /**
- * Cost trend data point for time-series charts
- * Represents a single time bucket (hour or day)
+ * LLM Adapter interface
+ * Generic primitive for all resource types (agents, workflows, tools)
+ *
+ * Design principles:
+ * - Single method: generate() - the core LLM primitive
+ * - Generic return type for type safety
+ * - Universal format (not agent-specific)
+ * - Standard message-based input (OpenAI-compatible)
  */
-interface CostTrendDataPoint {
-  time: string // ISO timestamp (bucket start)
-  totalCostUsd: number
-  executionCount: number
-  avgCostPerExecution: number
+interface LLMAdapter {
+  /**
+   * Generate structured output from prompt using LLM
+   *
+   * @param request - Generation request with messages and response schema
+   * @returns Generated output (typed) with optional usage metadata
+   */
+  generate<T = unknown>(request: LLMGenerateRequest): Promise<LLMGenerateResponse<T>>
 }
 
 /**
- * Cost trends response (time-series data)
+ * Model Configuration
+ * Centralized model information, configuration, options, constraints, and validation
+ * Single source of truth for all model-related definitions
+ * Update manually when pricing changes or new models are added
  */
-interface CostTrendsResponse {
-  trendData: CostTrendDataPoint[]
-  granularity: 'hour' | 'day'
-  totalCostUsd: number
-  totalExecutions: number
-}
+
+
+
+// ============================================================================
+// Model Types
+// ============================================================================
 
 /**
- * Cost summary response with MTD and projections
+ * Supported Open AI models (direct SDK access)
  */
-interface CostSummaryResponse {
-  current: {
-    totalCostUsd: number
-    executionCount: number
-  }
-  previous: {
-    totalCostUsd: number
-    executionCount: number
-  }
-  mtd: {
-    totalCostUsd: number
-    daysElapsed: number
-  }
-  projection: {
-    monthlyCostUsd: number
-    confidence: 'low' | 'medium' | 'high'
-  }
-  trend: {
-    changePercent: number
-    direction: 'up' | 'down' | 'flat'
-  }
-}
+type OpenAIModel = 'gpt-5' | 'gpt-5.4-mini' | 'gpt-5.4-nano'
 
 /**
- * Cost by model data for model-level breakdown
+ * Supported OpenRouter models (explicit union for type safety)
  */
-interface CostByModelData {
-  model: string
-  totalCostUsd: number
-  callCount: number
-  totalInputTokens: number
-  totalOutputTokens: number
-  avgCostPerCall: number
-}
+type OpenRouterModel = 'openrouter/z-ai/glm-5'
 
 /**
- * Cost by model response
+ * Supported Google models (direct SDK access)
  */
-interface CostByModelResponse {
-  models: CostByModelData[]
-  totalCostUsd: number
-  totalCallCount: number
-}
+type GoogleModel = 'gemini-3-flash-preview' | 'gemini-3.1-flash-lite-preview'
 
 /**
- * Action configuration for HITL tasks
- * Defines available user actions and their behavior
+ * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
  */
-interface ActionConfig {
-  /** Unique action identifier (e.g., 'approve', 'retry', 'escalate') */
-  id: string
+type AnthropicModel = 'claude-sonnet-4-5'
 
-  /** Display label for UI button */
-  label: string
+/** Supported LLM models */
+type LLMModel = OpenAIModel | OpenRouterModel | GoogleModel | AnthropicModel | 'mock'
 
-  /** Button variant/style */
-  type: 'primary' | 'secondary' | 'danger' | 'outline'
+// ============================================================================
+// Model Configuration Schemas (Schema-First - Single Source of Truth)
+// ============================================================================
 
-  /** Tabler icon name (e.g., 'IconCheck', 'IconRefresh') */
-  icon?: string
+/**
+ * GPT-5 model options schema
+ */
+declare const GPT5OptionsSchema = z.object({
+  reasoning_effort: z.enum(['minimal', 'low', 'medium', 'high']).optional(),
+  verbosity: z.enum(['low', 'medium', 'high']).optional()
+})
 
-  /** Button color (Mantine theme colors) */
-  color?: string
-
-  /** Button variant (Mantine button variant, e.g., 'light', 'filled', 'outline') */
-  variant?: string
+/**
+ * OpenRouter model options schema
+ * OpenRouter-specific options for routing and transforms
+ */
+declare const OpenRouterOptionsSchema = z.object({
+  /** Optional transforms to apply (e.g., 'middle-out' for long context) */
+  transforms: z.array(z.string()).optional(),
+  /** Routing strategy (e.g., 'fallback' for automatic provider failover) */
+  route: z.enum(['fallback']).optional()
+})
 
-  /** Execution target (agent/workflow to invoke) */
-  target?: {
-    resourceType: 'agent' | 'workflow'
-    resourceId: string
-    /**
-     * Optional session ID for agent continuation.
-     * If provided, invokes a new turn on the existing session instead of standalone execution.
-     * Only valid when resourceType is 'agent'.
-     */
-    sessionId?: string
-  }
+/**
+ * Google model options schema
+ * Gemini 3 specific options for thinking depth control
+ */
+declare const GoogleOptionsSchema = z.object({
+  /** Thinking level for Gemini 3 models (controls reasoning depth) */
+  thinkingLevel: z.enum(['minimal', 'low', 'medium', 'high']).optional()
+})
 
-  /** Form schema for collecting action-specific data */
-  form?: FormSchema
+/**
+ * Anthropic model options schema
+ * Currently empty - future options: budget_tokens for extended thinking
+ */
+declare const AnthropicOptionsSchema = z.object({})
 
-  /** Payload template for pre-filling forms */
-  payloadTemplate?: unknown
+/**
+ * Infer TypeScript types from schemas
+ */
+type GPT5Options = z.infer<typeof GPT5OptionsSchema>
+type MockOptions = Record<string, never>
+type OpenRouterOptions = z.infer<typeof OpenRouterOptionsSchema>
+type GoogleOptions = z.infer<typeof GoogleOptionsSchema>
+type AnthropicOptions = z.infer<typeof AnthropicOptionsSchema>
+type ModelSpecificOptions = GPT5Options | MockOptions | OpenRouterOptions | GoogleOptions | AnthropicOptions
 
-  /** Requires confirmation dialog */
-  requiresConfirmation?: boolean
+// ============================================================================
+// Model Configuration
+// ============================================================================
 
-  /** Confirmation message */
-  confirmationMessage?: string
+/**
+ * Model configuration for LLM execution
+ * Belongs in resource definition (AgentDefinition, WorkflowDefinition, etc.)
+ */
+interface ModelConfig {
+  model: LLMModel
+  provider: 'openai' | 'anthropic' | 'openrouter' | 'google' | 'mock'
+  apiKey: string
+  temperature?: number
+  /** Maximum output tokens per LLM call. NOT the model's context window — see ModelInfo.maxTokens for that. */
+  maxOutputTokens?: number
+  topP?: number
 
-  /** Help text / tooltip */
-  description?: string
+  /**
+   * Model-specific options (flat structure)
+   * Options are model-specific, not vendor-specific
+   * Available options defined in MODEL_INFO per model
+   * Validated at build time via validateModelOptions()
+   */
+  modelOptions?: ModelSpecificOptions
 }
 
 /**
- * Origin resource type - where an execution/task originated from.
- * Used for audit trails and tracking execution lineage.
+ * Memory Manager
+ * Encapsulates all memory operations with ultra-simple agent API
+ * Agent provides strings, framework handles wrapping and auto-compaction
  */
-type OriginResourceType = 'agent' | 'workflow' | 'scheduler' | 'api'
+
+
 
 /**
- * Origin tracking metadata - who/what created this execution/task.
- * Used by both TaskScheduler and CommandQueue for complete audit trails.
+ * Memory Manager - Agent memory orchestration
+ * Provides ultra-simple API for agents (strings only)
+ * Handles automatic compaction and token management
  */
-interface OriginTracking {
-  originExecutionId: string
-  originResourceType: OriginResourceType
-  originResourceId: string
+declare class MemoryManager {
+  private cachedSnapshot?: AgentMemory
+
+  constructor(
+    private memory: AgentMemory,
+    private constraints: MemoryConstraints = {},
+    private logger?: AgentScopedLogger
+  ) {}
+
+  // === Agent Operations (Ultra-Simple) ===
+
+  /**
+   * Set session memory entry (agent provides string, framework wraps it)
+   * @param key - Session memory key
+   * @param content - String content from agent
+   */
+  set(key: string, content: string): void {
+    // Check single entry token limit
+    const entryTokens = estimateTokens(content)
+    if (entryTokens > MAX_SINGLE_ENTRY_TOKENS) {
+      const truncateTime = Date.now()
+      this.logger?.action(
+        'memory-truncate',
+        `Single entry exceeds token limit (${entryTokens}/${MAX_SINGLE_ENTRY_TOKENS}): ${key}`,
+        0,
+        truncateTime,
+        truncateTime,
+        0
+      )
+      // Truncate content to fit limit
+      const maxChars = MAX_SINGLE_ENTRY_TOKENS * 4
+      content = content.slice(0, maxChars) + '... [truncated]'
+    }
+
+    this.memory.sessionMemory[key] = {
+      type: 'context',
+      content,
+      timestamp: Date.now(),
+      turnNumber: null, // Session memory entries are not turn-specific
+      iterationNumber: null // Session memory entries are not iteration-specific
+    }
+  }
+
+  /**
+   * Get session memory entry content
+   * @param key - Session memory key
+   * @returns String content if exists, undefined otherwise
+   */
+  get(key: string): string | undefined {
+    const entry = this.memory.sessionMemory[key]
+    return entry?.content
+  }
+
+  /**
+   * Delete session memory entry
+   * @param key - Key to delete
+   * @returns True if key existed and was deleted
+   */
+  delete(key: string): boolean {
+    if (key in this.memory.sessionMemory) {
+      delete this.memory.sessionMemory[key]
+      return true
+    }
+    return false
+  }
+
+  // === Framework Operations (Automatic) ===
+
+  /**
+   * Add entry to history (called by framework after tool results, reasoning, etc.)
+   * Automatically sets timestamp to current time
+   * @param entry - Memory entry to add (without timestamp - auto-generated)
+   */
+  addToHistory(entry: Omit<MemoryEntry, 'timestamp'>): void {
+    // Validate turnNumber is provided for history entries (use null for session memory)
+    if (entry.turnNumber === undefined && entry.type !== 'context') {
+      throw new AgentMemoryValidationError('turnNumber required for history entries (use null for session memory)', {
+        entryType: entry.type,
+        missingField: 'turnNumber',
+        iterationNumber: entry.iterationNumber
+      })
+    }
+
+    // Truncate tool-result content if it exceeds the tool result token limit
+    let content = entry.content
+    if (entry.type === 'tool-result') {
+      const before = content
+      content = truncateToolResult(content, MAX_TOOL_RESULT_TOKENS)
+      if (content !== before) {
+        const truncateTime = Date.now()
+        this.logger?.action(
+          'memory-tool-result-truncate',
+          `Tool result truncated (${estimateTokens(before)} -> ${MAX_TOOL_RESULT_TOKENS} tokens)`,
+          entry.iterationNumber ?? 0,
+          truncateTime,
+          truncateTime,
+          0
+        )
+      }
+    }
+
+    this.memory.history.push({
+      ...entry,
+      content,
+      timestamp: Date.now()
+    })
+    // Auto-compact after adding (if needed)
+    this.autoCompact()
+  }
+
+  /**
+   * Auto-compact history if approaching token budget
+   * Uses preserve-anchors strategy: keep first + recent entries
+   */
+  autoCompact(): void {
+    const status = this.getStatus()
+
+    // Auto-compact when at 100% of token budget
+    if (status.historyPercent >= 100) {
+      const before = this.memory.history.length
+
+      // Preserve-anchors strategy: first entry + last 10 entries
+      this.memory.history = [
+        this.memory.history[0], // First (original input)
+        ...this.memory.history.slice(-10) // Last 10
+      ]
+
+      const compactTime = Date.now()
+      this.logger?.action(
+        'memory-auto-compact',
+        `Auto-compacted: ${before} -> ${this.memory.history.length} entries`,
+        0,
+        compactTime,
+        compactTime,
+        0
+      )
+    }
+  }
+
+  /**
+   * Enforce hard limits (called before LLM request)
+   * Emergency fallback if agent exceeds limits
+   */
+  enforceHardLimits(): void {
+    const maxSessionMemoryKeys = this.constraints.maxSessionMemoryKeys || MAX_SESSION_MEMORY_KEYS
+
+    // Check session memory count
+    const sessionMemoryKeys = Object.keys(this.memory.sessionMemory)
+    if (sessionMemoryKeys.length > maxSessionMemoryKeys) {
+      const limitTime = Date.now()
+      this.logger?.action(
+        'memory-limit-exceeded',
+        `Session memory exceeds hard limit (${sessionMemoryKeys.length}/${maxSessionMemoryKeys})`,
+        0,
+        limitTime,
+        limitTime,
+        0
+      )
+
+      // Remove oldest entries by timestamp
+      const sorted = Object.entries(this.memory.sessionMemory).sort((a, b) => a[1].timestamp - b[1].timestamp)
+
+      this.memory.sessionMemory = Object.fromEntries(sorted.slice(-maxSessionMemoryKeys))
+    }
+
+    // Check total token budget (emergency compaction)
+    const status = this.getStatus()
+    const maxTokens = this.constraints.maxMemoryTokens || MAX_MEMORY_TOKENS
+
+    if (status.historyTokens > maxTokens) {
+      const before = this.memory.history.length
+      const emergencyStartTime = Date.now()
+      this.logger?.action(
+        'memory-emergency',
+        `Total memory exceeds token budget (${status.historyTokens}/${maxTokens}), forcing emergency compaction`,
+        0,
+        emergencyStartTime,
+        emergencyStartTime,
+        0
+      )
+
+      // Emergency: Aggressively compact history
+      this.memory.history = [
+        this.memory.history[0],
+        ...this.memory.history.slice(-5) // Keep only last 5
+      ]
+
+      const emergencyEndTime = Date.now()
+      this.logger?.action(
+        'memory-emergency-compact',
+        `Emergency compaction: ${before} -> ${this.memory.history.length} entries`,
+        0,
+        emergencyStartTime,
+        emergencyEndTime,
+        emergencyEndTime - emergencyStartTime
+      )
+    }
+  }
+
+  /**
+   * Get history length (for logging and introspection)
+   * @returns Number of entries in history
+   */
+  getHistoryLength(): number {
+    return this.memory.history.length
+  }
+
+  /**
+   * Get memory status for agent awareness
+   * @returns Memory status with token usage and key counts
+   */
+  getStatus(): MemoryStatus {
+    const sessionMemoryKeys = Object.keys(this.memory.sessionMemory)
+
+    // Calculate tokens
+    const sessionMemoryContent = Object.values(this.memory.sessionMemory)
+      .map((entry) => entry.content)
+      .join('')
+    const historyContent = this.memory.history.map((entry) => entry.content).join('')
+    const sessionMemoryTokens = estimateTokens(sessionMemoryContent)
+    const historyTokens = estimateTokens(historyContent)
+    const totalTokens = sessionMemoryTokens + historyTokens
+
+    // Token budget
+    const tokenBudget = this.constraints.maxMemoryTokens || MAX_MEMORY_TOKENS
+    const sessionMemoryLimit = this.constraints.maxSessionMemoryKeys || MAX_SESSION_MEMORY_KEYS
+
+    return {
+      sessionMemoryKeys: sessionMemoryKeys.length,
+      sessionMemoryLimit,
+      currentKeys: sessionMemoryKeys,
+      historyPercent: Math.round((totalTokens / tokenBudget) * 100),
+      historyTokens: totalTokens,
+      tokenBudget
+    }
+  }
+
+  /**
+   * Create memory snapshot for persistence
+   * Caches snapshot internally for later retrieval
+   * @returns Deep copy of current memory state
+   */
+  toSnapshot(): AgentMemory {
+    this.cachedSnapshot = structuredClone(this.memory)
+    return this.cachedSnapshot
+  }
+
+  /**
+   * Get cached memory snapshot
+   * Returns snapshot created by toSnapshot()
+   * @returns Cached snapshot (undefined if toSnapshot() not called yet)
+   */
+  getSnapshot(): AgentMemory | undefined {
+    return this.cachedSnapshot
+  }
+
+  /**
+   * Build context string for LLM
+   * Serializes sessionmemory + history memory with clear sections
+   * Shows current iteration entries FIRST (reverse chronological) for LLM attention
+   * @param currentIteration - Current iteration number (0 = pre-iteration)
+   * @param currentTurn - Current turn number (optional, for session context filtering)
+   * @returns Formatted memory context for LLM prompt
+   */
+  toContext(currentIteration: number, currentTurn?: number): string {
+    const status = this.getStatus()
+
+    // Split by turn and iteration number
+    // DUAL FILTERING: Turn scope first (if provided), then iteration scope
+    // null iterations are session memory entries (excluded from history context)
+    // undefined/null turnNumbers are treated as legacy entries (pre-migration) or one-off executions
+    const currentContext = this.memory.history
+      .filter(
+        (entry) =>
+          (!currentTurn || entry.turnNumber === currentTurn || entry.turnNumber === undefined) &&
+          entry.iterationNumber === currentIteration
+      )
+      .reverse() // Most recent first (LLM positional bias)
+
+    const earlierContext = this.memory.history.filter(
+      (entry) =>
+        (!currentTurn || entry.turnNumber === currentTurn || entry.turnNumber === undefined) &&
+        entry.iterationNumber !== null &&
+        entry.iterationNumber < currentIteration
+    )
+    // Earlier entries stay chronological
+
+    // Format entry with simple label
+    const formatEntry = (entry: MemoryEntry): string => {
+      const label = `[${entry.type.toUpperCase()}]`
+      return `${label}\n${entry.content}`
+    }
+
+    // Serialize session memory
+    const sessionMemoryContext = Object.entries(this.memory.sessionMemory)
+      .map(([key, entry]) => `[SESSION:${key}]\n${entry.content}`)
+      .join('\n\n')
+
+    const currentSection = currentContext.map(formatEntry).join('\n\n')
+    const earlierSection =
+      earlierContext.length > 0 ? earlierContext.map(formatEntry).join('\n\n') : '(no earlier context)'
+
+    return `
+=== MEMORY STATUS ===
+${status.sessionMemoryKeys}/${status.sessionMemoryLimit} session keys
+${status.historyPercent}% of token budget
+
+=== SESSION MEMORY (Persists for conversation) ===
+${sessionMemoryContext || '(empty)'}
+
+=== ITERATION ${currentIteration} - CURRENT CONTEXT ===
+
+${currentSection}
+
+=== EARLIER CONTEXT ===
+
+${earlierSection}
+`.trim()
+  }
 }
 
 /**
- * Command queue task with flexible action system
+ * AIUsageCollector
+ * Centralized token tracking that aggregates usage across all LLM calls in an execution
  */
-interface Task extends OriginTracking {
-  id: string
-  organizationId: string
+declare class AIUsageCollector {
+  private model: LLMModel = 'gpt-5' // Default, will be overwritten on first record()
+  private calls: AICallRecord[] = []
+  private callSequence: number = 0
 
-  // NEW: Flexible action system
-  actions: ActionConfig[]
-  context: unknown
-  selectedAction?: string
-  actionPayload?: unknown
+  /**
+   * Record a single AI call with usage metrics
+   *
+   * @param usage - Token usage and latency data from LLM adapter
+   * @param callType - Type discriminator (agent-reasoning, tool, etc.)
+   * @param context - Optional typed context specific to callType
+   */
+  record(usage: LLMUsageData, callType: BaseAICall['callType'] = 'other', context?: AICallContext): void {
+    this.callSequence++
+    this.model = usage.model
+
+    // Use actual cost from provider (e.g., OpenRouter) if available, otherwise calculate
+    const costUsd = usage.cost ?? calculateCost(usage.model, usage.inputTokens, usage.outputTokens)
+
+    this.calls.push({
+      callSequence: this.callSequence,
+      callType,
+      model: usage.model,
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      costUsd,
+      latencyMs: usage.latencyMs,
+      context
+    })
+  }
 
-  // Task metadata
-  description?: string
-  priority: number
+  /**
+   * Get aggregated summary of all AI calls
+   */
+  getSummary(): AIUsageSummary {
+    const totalInputTokens = this.calls.reduce((sum, c) => sum + c.inputTokens, 0)
+    const totalOutputTokens = this.calls.reduce((sum, c) => sum + c.outputTokens, 0)
+    const totalCostUsd = this.calls.reduce((sum, c) => sum + c.costUsd, 0)
+
+    return {
+      model: this.model,
+      totalInputTokens,
+      totalOutputTokens,
+      totalTokens: totalInputTokens + totalOutputTokens,
+      totalCostUsd,
+      callCount: this.calls.length,
+      calls: this.calls
+    }
+  }
 
-  /** Optional checkpoint identifier for grouping related human approval tasks */
-  humanCheckpoint?: string
+  /**
+   * Check if any usage has been recorded
+   */
+  hasUsage(): boolean {
+    return this.calls.length > 0
+  }
+}
 
-  // Status (updated to include 'completed')
-  status: TaskStatus
+/**
+ * MetricsCollector
+ * Tracks execution timing and ROI metrics
+ */
+declare class MetricsCollector {
+  private timings: Map<string, number> = new Map()
+  private durationMs?: number
 
   /**
-   * Target resource tracking — mirrors origin columns.
-   * Set when task is created; patchable to redirect execution to a different resource.
+   * Start a timer with a label
    */
-  targetResourceId?: string
-  targetResourceType?: 'agent' | 'workflow'
+  startTimer(label: string): void {
+    this.timings.set(label, Date.now())
+  }
 
   /**
-   * Execution ID for the action that runs AFTER user approval.
-   * NULL until execution starts.
-   *
-   * Naming distinction:
-   * - originExecutionId = Parent execution that CREATED the HITL task
-   * - targetExecutionId = Child execution that RUNS AFTER user approval
+   * End a timer and calculate duration
+   * If label is 'execution', stores duration for metrics summary
    */
-  targetExecutionId?: string
+  endTimer(label: string): number | null {
+    const start = this.timings.get(label)
+    if (!start) return null
 
-  createdAt: Date
-  completedAt?: Date
-  completedBy?: string
-  expiresAt?: Date
-  idempotencyKey?: string | null
+    const duration = Date.now() - start
+
+    if (label === 'execution') {
+      this.durationMs = duration
+    }
+
+    this.timings.delete(label)
+    return duration
+  }
+
+  /**
+   * Build execution metrics summary with optional ROI calculation
+   */
+  buildExecutionMetrics(metricsConfig?: ResourceMetricsConfig): ExecutionMetricsSummary {
+    const automationSavingsUsd = metricsConfig
+      ? (metricsConfig.estimatedManualMinutes / 60) * metricsConfig.hourlyLaborRateUsd
+      : undefined
+
+    return {
+      durationMs: this.durationMs,
+      automationSavingsUsd
+    }
+  }
+}
+
+// ============================================================================
+// AI Call Tracking Types (SSOT)
+// ============================================================================
+
+interface BaseAICall {
+  callSequence: number // 1, 2, 3... (execution-wide universal counter)
+  callType: 'agent-reasoning' | 'agent-completion' | 'workflow-step' | 'tool' | 'other'
+  model: LLMModel
+  inputTokens: number
+  outputTokens: number
+  costUsd: number // Cost in USD with full decimal precision
+  latencyMs: number
+  context?: AICallContext
+}
+
+type AICallContext =
+  | AgentReasoningContext
+  | AgentCompletionContext
+  | WorkflowStepContext
+  | ToolCallContext
+  | OtherCallContext
+
+interface AgentReasoningContext {
+  type: 'agent-reasoning'
+  iteration: number
+  actionsPlanned?: string[]
+  sessionId?: string
+  turnNumber?: number
+}
+
+interface AgentCompletionContext {
+  type: 'agent-completion'
+  attempt: 1 | 2
+  validationFailed?: boolean
+  sessionId?: string
+  turnNumber?: number
+}
+
+interface WorkflowStepContext {
+  type: 'workflow-step'
+  stepId: string
+  stepName?: string
+  stepSequence?: number
+}
+
+interface ToolCallContext {
+  type: 'tool'
+  toolName: string
+  parentIteration?: number
+  parentStepId?: string
+}
+
+interface OtherCallContext {
+  type: 'other'
+  description?: string
+  metadata?: Record<string, unknown>
 }
 
+type AICallRecord = BaseAICall
+
+// ============================================================================
+// LLM Usage Data (from adapters)
+// ============================================================================
+
 /**
- * Task status values
- * - pending: awaiting action
- * - processing: execution in progress after user approval
- * - completed: action was taken and execution succeeded
- * - failed: execution failed, task can be retried
- * - expired: timed out before action
+ * Raw LLM usage data returned by adapters
+ * Used as input to AIUsageCollector.record()
  */
-type TaskStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'expired'
+interface LLMUsageData {
+  model: LLMModel
+  inputTokens: number
+  outputTokens: number
+  latencyMs: number
+  /** Actual cost from provider in USD (when available, e.g., OpenRouter) */
+  cost?: number
+}
+
+// ============================================================================
+// AI Usage Summary
+// ============================================================================
+
+interface AIUsageSummary {
+  model: LLMModel
+  totalInputTokens: number
+  totalOutputTokens: number
+  totalTokens: number
+  totalCostUsd: number // Total cost in USD with full decimal precision
+  callCount: number
+  calls: AICallRecord[]
+}
+
+// ============================================================================
+// Execution Metrics
+// ============================================================================
+
+interface ExecutionMetricsSummary {
+  durationMs?: number
+  automationSavingsUsd?: number // Automation savings in USD with full decimal precision
+}
+
+// ============================================================================
+// Resource Metrics Configuration
+// ============================================================================
+
+interface ResourceMetricsConfig {
+  estimatedManualMinutes: number
+  hourlyLaborRateUsd: number // Hourly rate in USD (e.g., 75.00 for $75/hour)
+  confidenceLevel?: 'low' | 'medium' | 'high'
+  notes?: string
+}
+
+// ============================================================================
+// API Request/Response Types (Dashboard Observability)
+// ============================================================================
 
 /**
- * Parameters for patching mutable metadata on a task
+ * Time range selector for dashboard metrics
  */
-interface PatchTaskParams {
-  humanCheckpoint?: string | null
-  description?: string
-  priority?: number
-  context?: Record<string, unknown>
-  actions?: unknown[]
-  targetResourceId?: string | null
-  targetResourceType?: 'agent' | 'workflow' | null
-  targetExecutionId?: string
-  status?: 'pending' | 'failed' | 'completed'
-}
+type TimeRange = '1h' | '24h' | '7d' | '30d'
 
 /**
- * Checkpoint list item for sidebar grouping
- * The id field contains the resourceId of the human checkpoint
+ * Execution health metrics response
+ * Success rate, P95 duration, execution counts, and trend data
+ * trendData includes executionCount for throughput visualization (eliminates separate API call)
  */
-interface CheckpointListItem {
-  /** Human checkpoint resourceId (or 'ungrouped' for tasks without checkpoint) */
-  id: string
-  /** Display name (same as id, or "Ungrouped" for null) */
-  name: string
-  /** Task count for this checkpoint */
-  count: number
+interface ExecutionHealthMetrics {
+  successRate: number
+  p95Duration: number
+  totalExecutions: number
+  trendData: Array<{
+    time: string
+    rate: number
+    successCount: number
+    errorCount: number
+    warningCount: number
+    executionCount: number
+  }>
+  statusCounts: { success: number; failed: number; pending: number; warning: number }
+  peakPeriod: string
+  granularity: 'hour' | 'day'
 }
 
 /**
- * Status counts for pie chart display
+ * Error analysis metrics response
+ * Error categories and top failing resources
+ */
+interface ErrorAnalysisMetrics {
+  totalErrors: number
+  errorsByCategory: Array<{
+    category: string
+    count: number
+    percentage: number
+  }>
+  topFailingResources: Array<{
+    resourceId: string
+    name: string
+    errorCount: number
+    failureRate: number
+  }>
+}
+
+/**
+ * Business impact metrics response
+ * ROI, labor savings, and cost analysis
+ */
+interface BusinessImpactMetrics {
+  totalSavingsUsd: number
+  totalCostUsd: number
+  netSavingsUsd: number
+  roi: number
+}
+
+/**
+ * Cost breakdown metrics response
+ * Per-resource cost analysis
+ */
+interface CostBreakdownMetrics {
+  resources: Array<{
+    resourceId: string
+    totalCostUsd: number
+    executionCount: number
+    avgCostUsd: number
+  }>
+}
+
+/**
+ * Detailed execution metrics response
+ * Full execution metrics with AI call breakdown
+ */
+interface ExecutionMetricsDetail {
+  executionId: string
+  organizationId: string
+  resourceId: string
+  totalInputTokens: number
+  totalOutputTokens: number
+  totalCostUsd: number
+  aiCallCount: number
+  aiCalls: AICallRecord[]
+  durationMs?: number
+  automationSavingsUsd?: number
+  createdAt: string
+}
+
+/**
+ * Dashboard metrics response
+ * Aggregates core observability metrics in a single response
+ * Note: Throughput data is now included in executionHealth.trendData.executionCount
+ */
+interface DashboardMetrics {
+  executionHealth: ExecutionHealthMetrics
+  costBreakdown: CostBreakdownMetrics
+  businessImpact: BusinessImpactMetrics
+  /** ISO timestamp of the currently active deployment, or null if none */
+  activeDeploymentDate: string | null
+  /** Deployment version of the active deployment, or null if none */
+  activeDeploymentVersion: string | null
+}
+
+// ============================================================================
+// Error Tracking Types
+// ============================================================================
+
+/**
+ * Error record for list view (ErrorBreakdownTable)
+ */
+interface ErrorRecord {
+  id: string // execution_errors.id
+  timestamp: string // occurred_at
+  errorType: string // error_type
+  message: string // error_message
+  executionId: string // execution_id
+  resourceId: string // execution_logs.resource_id (via JOIN)
+  resourceName: string // execution_logs.resource_id (TODO: resolve via registry)
+  severity: 'critical' | 'warning' | 'info'
+  category: ExecutionErrorCategory // error_category (moved from metadata to dedicated column)
+  resolved: boolean // resolved flag (human acknowledgment, does not affect execution status)
+  resolvedAt: string | null // timestamp when resolved
+  resolvedBy: string | null // user ID who resolved
+}
+
+/**
+ * Full error detail for modal view (ErrorDetailsModal)
+ */
+interface ErrorDetailFull extends ErrorRecord {
+  stackTrace?: string // error_stack_trace
+  retryAttempt?: number // metadata.retryAttempt
+  stepName?: string // metadata.stepName
+  stepSequence?: number // metadata.stepSequence
+  errorContext?: Record<string, unknown> // metadata.errorContext
+  executionContext?: Record<string, unknown> // metadata.executionContext
+}
+
+/**
+ * Error details API response (paginated)
+ */
+interface ErrorDetailResponse {
+  errors: ErrorRecord[]
+  total: number
+  page: number
+  limit: number
+}
+
+/**
+ * Error trend data for time-series charts
+ */
+interface ErrorTrend {
+  time: string // Time bucket (ISO timestamp)
+  errorCount: number // Total errors in bucket
+  criticalCount: number // Critical errors in bucket
+  warningCount: number // Warning errors in bucket
+  infoCount: number // Info errors in bucket
+}
+
+/**
+ * Failing resource data for health monitoring
+ */
+interface FailingResource {
+  resourceId: string
+  resourceName: string // TODO: Resolve via registry
+  errorCount: number
+  criticalCount: number
+  warningCount: number
+  mostCommonError: string
+}
+
+// ============================================================================
+// Recent Executions by Resource Types (Dashboard)
+// ============================================================================
+
+/**
+ * Summary of executions for a single resource
+ * Used by RecentExecutionsByResource dashboard component
+ */
+interface ResourceExecutionSummary {
+  resourceId: string // resource_id from execution_logs
+  resourceType: string // Inferred from resource definitions (resolved by frontend)
+  resourceName: string | null // From resource registry lookup (resolved by frontend)
+  lastExecution: string // ISO timestamp (MAX started_at)
+  totalExecutions: number // COUNT(*)
+  successCount: number // COUNT WHERE status='completed' OR status='warning'
+  failureCount: number // COUNT WHERE status='failed'
+  warningCount: number // COUNT WHERE status='warning' (subset of success)
+  successRate: number // (successCount / totalExecutions) * 100
+}
+
+/**
+ * Response from getRecentExecutionsByResource endpoint
+ */
+interface RecentExecutionsByResourceResponse {
+  resources: ResourceExecutionSummary[]
+}
+
+// ============================================================================
+// Per-Resource Health Types (Dashboard Recent Activity)
+// ============================================================================
+
+/** Resource identifier for health queries */
+interface ResourceIdentifier {
+  entityType: string // 'workflow' | 'agent'
+  entityId: string // Resource ID
+}
+
+/** Time-bucketed health data point */
+interface ResourceHealthDataPoint {
+  time: string // ISO timestamp (bucket start)
+  success: number // Success count in bucket (completed + warning)
+  failure: number // Failure count in bucket
+  warning: number // Warning count in bucket (subset of success)
+  rate: number // Success rate (0-100)
+}
+
+/** Health data for a single resource */
+interface ResourceHealth {
+  entityType: string
+  entityId: string
+  entityName: string | null
+  trendData: ResourceHealthDataPoint[]
+  summary: {
+    total: number
+    successRate: number
+  }
+}
+
+/** Batch response with all requested resources */
+interface ResourcesHealthResponse {
+  resources: ResourceHealth[]
+}
+
+// ============================================================================
+// Cost Analytics Types (Time-Series)
+// ============================================================================
+
+/**
+ * Cost trend data point for time-series charts
+ * Represents a single time bucket (hour or day)
+ */
+interface CostTrendDataPoint {
+  time: string // ISO timestamp (bucket start)
+  totalCostUsd: number
+  executionCount: number
+  avgCostPerExecution: number
+}
+
+/**
+ * Cost trends response (time-series data)
+ */
+interface CostTrendsResponse {
+  trendData: CostTrendDataPoint[]
+  granularity: 'hour' | 'day'
+  totalCostUsd: number
+  totalExecutions: number
+}
+
+/**
+ * Cost summary response with MTD and projections
+ */
+interface CostSummaryResponse {
+  current: {
+    totalCostUsd: number
+    executionCount: number
+  }
+  previous: {
+    totalCostUsd: number
+    executionCount: number
+  }
+  mtd: {
+    totalCostUsd: number
+    daysElapsed: number
+  }
+  projection: {
+    monthlyCostUsd: number
+    confidence: 'low' | 'medium' | 'high'
+  }
+  trend: {
+    changePercent: number
+    direction: 'up' | 'down' | 'flat'
+  }
+}
+
+/**
+ * Cost by model data for model-level breakdown
+ */
+interface CostByModelData {
+  model: string
+  totalCostUsd: number
+  callCount: number
+  totalInputTokens: number
+  totalOutputTokens: number
+  avgCostPerCall: number
+}
+
+/**
+ * Cost by model response
+ */
+interface CostByModelResponse {
+  models: CostByModelData[]
+  totalCostUsd: number
+  totalCallCount: number
+}
+
+/**
+ * Knowledge Map Types
+ *
+ * Enables agents to navigate organizational knowledge through a lightweight
+ * graph that lazy-loads capabilities on-demand.
+ *
+ * @module agent/knowledge-map
+ */
+
+
+
+/**
+ * Lightweight knowledge map (passed as agent property)
+ *
+ * Contains metadata about available knowledge nodes without loading
+ * the full content upfront. Total size: ~300-500 tokens.
+ *
+ * Multi-tenancy is enforced via:
+ * - File-scoped maps (organizations/{org-name}/knowledge/)
+ * - ExecutionContext.organizationId passed to node.load()
+ */
+interface KnowledgeMap {
+  /** Available knowledge nodes indexed by ID */
+  nodes: Record<string, KnowledgeNode>
+}
+
+/**
+ * Single knowledge source
+ *
+ * Represents a domain knowledge area (CRM, brand guidelines, Excel tools)
+ * that can be lazy-loaded to provide instructions and tools to agents.
+ */
+interface KnowledgeNode {
+  /** Unique identifier for this node (e.g., "crm", "brand-guidelines") */
+  id: string
+
+  /**
+   * Description of when to use this knowledge
+   * Used for semantic matching against user intent
+   */
+  description: string
+
+  /**
+   * Load knowledge content on-demand
+   *
+   * @param context - Execution context with organizationId for multi-tenancy
+   * @returns Promise resolving to knowledge content (prompt + optional tools)
+   */
+  load(context: ExecutionContext): Promise<KnowledgeContent>
+
+  /**
+   * Loaded state flag
+   * Set to true after load() is called
+   */
+  loaded?: boolean
+
+  /**
+   * Cached prompt (for system prompt serialization)
+   * Only the prompt is cached - tools go to toolRegistry, children flattened to nodes
+   */
+  prompt?: string
+}
+
+/**
+ * Content returned by knowledge node
+ *
+ * Separates instructions (prompt) from capabilities (tools).
+ * Tools are optional - some nodes only provide context.
+ *
+ * Supports recursive navigation - nodes can contain child nodes
+ * that are discovered when the parent node is loaded.
+ */
+interface KnowledgeContent {
+  /** Instructions and context (markdown format) */
+  prompt: string
+
+  /** Tool implementations (optional) */
+  tools?: Tool[]
+
+  /**
+   * Child knowledge nodes (optional, recursive)
+   *
+   * Enables hierarchical navigation: base → specialized → deep expertise.
+   * Child nodes are flattened into the main knowledge map when parent loads,
+   * making them available for subsequent navigate-knowledge actions.
+   *
+   * Example: CRM base node returns crm-customers and crm-deals as children
+   */
+  nodes?: Record<string, KnowledgeNode>
+}
+
+/**
+ * Execution interface configuration
+ * Defines how a resource is executed via the UI (forms, scheduling, webhooks)
+ * Applies to both agents and workflows
+ */
+interface ExecutionInterface {
+  /** Form configuration for execution inputs */
+  form: ExecutionFormSchema
+
+  /** Optional: Schedule configuration */
+  schedule?: ScheduleConfig
+
+  /** Optional: Webhook trigger configuration */
+  webhook?: WebhookConfig
+}
+
+/**
+ * Execution form schema
+ * Extends FormSchema with execution-specific fields
+ */
+interface ExecutionFormSchema extends FormSchema {
+  /**
+   * Field mappings to resource input schema
+   * Maps form field names to contract input paths
+   * If omitted, field names must match contract input keys exactly
+   */
+  fieldMappings?: Record<string, string>
+
+  /**
+   * Submit button configuration
+   * Default: { label: 'Run', loadingLabel: 'Running...' }
+   */
+  submitButton?: {
+    label?: string
+    loadingLabel?: string
+    confirmMessage?: string  // Optional confirmation dialog
+  }
+}
+
+/**
+ * Schedule configuration for automated execution
+ */
+interface ScheduleConfig {
+  /** Whether scheduling is enabled for this resource */
+  enabled: boolean
+  /** Default schedule (cron expression) */
+  defaultSchedule?: string
+  /** Allowed schedule patterns (if restricted) */
+  allowedPatterns?: string[]
+}
+
+/**
+ * Webhook configuration for external triggers
+ */
+interface WebhookConfig {
+  /** Whether webhook trigger is enabled */
+  enabled: boolean
+  /** Expected payload schema (for documentation) */
+  payloadSchema?: unknown
+}
+
+/**
+ * Agent-specific type definitions
+ * Types for autonomous agents with tools, memory, and constraints
+ */
+
+
+
+/**
+ * Factory function for creating LLM adapters.
+ * Injected into the Agent class to decouple the engine from server-only provider SDKs.
+ * - API process: provides createLLMAdapter (real SDKs + process.env API keys)
+ * - SDK worker: provides PostMessageLLMAdapter (proxies via platform.call)
+ *
+ * Uses `any` for optional params so both the real createLLMAdapter (with typed
+ * AIUsageCollector/AICallContext) and the worker proxy (which ignores them) satisfy the type.
+ */
+type LLMAdapterFactory = (
+  config: ModelConfig,
+  ...args: any[]
+) => LLMAdapter
+
+// Agent configuration
+interface AgentConfig extends ResourceDefinition {
+  type: 'agent'
+
+  // Agent behavior
+  systemPrompt: string // System prompt defining agent behavior
+
+  // Execution constraints (simplified for v1)
+  constraints?: AgentConstraints
+
+  /**
+   * Session capability declaration (opt-in)
+   * If true, agent is designed for multi-turn session interactions
+   * Controls whether agent can use message action and appears in Sessions UI
+   *
+   * Use for:
+   * - Conversational agents with multi-turn interactions
+   * - Agents requiring persistent context across turns
+   * - Agents that need human-in-the-loop communication
+   */
+  sessionCapable?: boolean
+
+  /**
+   * Security level for system prompt hardening (auto-derived if omitted)
+   *
+   * - 'standard': Lightweight defense (3 rules) - default for non-session agents
+   * - 'hardened': Comprehensive defense (6 rules) - default for session-capable agents
+   * - 'none': No security prompt - for pure internal agents with no external input
+   *
+   * If omitted, derived from sessionCapable:
+   *   sessionCapable: true  -> 'hardened'
+   *   sessionCapable: false -> 'standard'
+   */
+  securityLevel?: 'standard' | 'hardened' | 'none'
+
+  /**
+   * Memory management preferences (opt-in)
+   * If provided, agent can use memoryOps to manage session memory
+   * If omitted, agent has no memory management capabilities
+   *
+   * Agent-specific guidance on what to preserve, when to persist, and what to clean up.
+   * This guidance is injected into the system prompt when memory management is enabled.
+   *
+   * Use for:
+   * - Conversational agents needing cross-turn context
+   * - Agents managing complex user preferences
+   * - Agents tracking decisions over multiple iterations
+   */
+  memoryPreferences?: string
+
+  // Lifecycle callbacks for observability (optional) - DEFERRED
+}
+
+// Execution constraints to prevent runaway agents
+interface AgentConstraints {
+  // Agent execution control
+  maxIterations?: number // Prevent infinite loops
+  timeout?: number // Execution time limit (ms)
+
+  // Memory constraints
+  maxSessionMemoryKeys?: number // Max session memory keys (default: 10)
+  maxMemoryTokens?: number // Total token budget for all memory (default: 14000)
+}
+
+// Agent definition - pure configuration without instance state
+// Used by registry to define agents that can be instantiated with fresh memory
+interface AgentDefinition {
+  config: AgentConfig
+  contract: Contract
+  tools: Tool[]
+
+  /**
+   * Model configuration for LLM execution
+   * Specifies provider, API key, and model-specific options
+   */
+  modelConfig: ModelConfig
+
+  /**
+   * Optional knowledge map for lazy-loading capabilities
+   * Enables agents to navigate organizational knowledge on-demand
+   */
+  knowledgeMap?: KnowledgeMap
+
+  /**
+   * Preload memory before execution starts
+   * Handles BOTH context loading AND session restoration
+   *
+   * @param context - Execution context (includes sessionId if session turn)
+   * @returns Initial AgentMemory state (sessionMemory entries + optionally history)
+   */
+  preloadMemory?: (context: ExecutionContext) => Promise<AgentMemory> | AgentMemory
+
+  /**
+   * Metrics configuration for ROI calculations
+   * Optional: Only needed if tracking automation savings
+   */
+  metricsConfig?: ResourceMetricsConfig
+
+  /**
+   * Execution interface configuration (optional)
+   * If provided, agent appears in Execution Runner UI
+   */
+  interface?: ExecutionInterface
+}
+
+/**
+ * Agent execution context
+ * Groups all state needed for agent execution phases
+ */
+interface IterationContext {
+  config: AgentConfig
+  contract: Contract
+  toolRegistry: Map<string, Tool>
+  memoryManager: MemoryManager
+  executionContext: ExecutionContext
+  iteration: number
+  logger: AgentScopedLogger
+  modelConfig: ModelConfig
+  adapterFactory: LLMAdapterFactory
+  knowledgeMap?: KnowledgeMap
+}
+
+/**
+ * Tool definitions
+ *
+ * Tool interface used by agents and workflows.
+ * Provides a universal interface for AI systems to interact with tools.
+ */
+
+
+
+/**
+ * Options for tool execution
+ * Provides named parameters for better API clarity and extensibility
+ */
+interface ToolExecutionOptions {
+  /** Tool input (validated against inputSchema before execution) */
+  input: unknown
+
+  /** Execution context with multi-tenant isolation and observability (optional for simple tools, required for platform/integration tools) */
+  executionContext?: ExecutionContext
+
+  /** Full iteration context for advanced tools (provides access to memoryManager, toolRegistry, logger, etc.) */
+  iterationContext?: IterationContext
+
+  /** Abort signal for timeout/cancellation -- forward to fetch() calls for clean cancellation */
+  signal?: AbortSignal
+}
+
+/**
+ * Tool interface for AI systems
+ *
+ * Used by:
+ * - Agents: For agentic tool use (reasoning loop selects and executes tools)
+ * - Workflows: For workflow step tool invocation (future)
+ * - Platform tools: createApprovalTool(), createSchedulerTool()
+ * - Integration tools: External API calls (Gmail, Slack, etc.)
+ */
+interface Tool {
+  // Required fields
+  name: string // Unique identifier (e.g., 'web_search', 'calculator')
+  description: string // What the tool does (used by LLM for selection)
+
+  // I/O validation (both required for complete type safety)
+  inputSchema: z.ZodSchema // Input validation schema
+  outputSchema: z.ZodSchema // Output validation schema
+
+  // Execution
+  execute: (options: ToolExecutionOptions) => Promise<unknown>
+
+  // Timeout (optional) -- per-tool override in ms, defaults to DEFAULT_TOOL_TIMEOUT (300_000 / 5min) in executor
+  timeout?: number
+}
+
+/**
+ * Action configuration for HITL tasks
+ * Defines available user actions and their behavior
+ */
+interface ActionConfig {
+  /** Unique action identifier (e.g., 'approve', 'retry', 'escalate') */
+  id: string
+
+  /** Display label for UI button */
+  label: string
+
+  /** Button variant/style */
+  type: 'primary' | 'secondary' | 'danger' | 'outline'
+
+  /** Tabler icon name (e.g., 'IconCheck', 'IconRefresh') */
+  icon?: string
+
+  /** Button color (Mantine theme colors) */
+  color?: string
+
+  /** Button variant (Mantine button variant, e.g., 'light', 'filled', 'outline') */
+  variant?: string
+
+  /** Execution target (agent/workflow to invoke) */
+  target?: {
+    resourceType: 'agent' | 'workflow'
+    resourceId: string
+    /**
+     * Optional session ID for agent continuation.
+     * If provided, invokes a new turn on the existing session instead of standalone execution.
+     * Only valid when resourceType is 'agent'.
+     */
+    sessionId?: string
+  }
+
+  /** Form schema for collecting action-specific data */
+  form?: FormSchema
+
+  /** Payload template for pre-filling forms */
+  payloadTemplate?: unknown
+
+  /** Requires confirmation dialog */
+  requiresConfirmation?: boolean
+
+  /** Confirmation message */
+  confirmationMessage?: string
+
+  /** Help text / tooltip */
+  description?: string
+}
+
+/**
+ * Origin resource type - where an execution/task originated from.
+ * Used for audit trails and tracking execution lineage.
+ */
+type OriginResourceType = 'agent' | 'workflow' | 'scheduler' | 'api'
+
+/**
+ * Origin tracking metadata - who/what created this execution/task.
+ * Used by both TaskScheduler and CommandQueue for complete audit trails.
+ */
+interface OriginTracking {
+  originExecutionId: string
+  originResourceType: OriginResourceType
+  originResourceId: string
+}
+
+/**
+ * Command queue task with flexible action system
+ */
+interface Task extends OriginTracking {
+  id: string
+  organizationId: string
+
+  // NEW: Flexible action system
+  actions: ActionConfig[]
+  context: unknown
+  selectedAction?: string
+  actionPayload?: unknown
+
+  // Task metadata
+  description?: string
+  priority: number
+
+  /** Optional checkpoint identifier for grouping related human approval tasks */
+  humanCheckpoint?: string
+
+  // Status (updated to include 'completed')
+  status: TaskStatus
+
+  /**
+   * Target resource tracking — mirrors origin columns.
+   * Set when task is created; patchable to redirect execution to a different resource.
+   */
+  targetResourceId?: string
+  targetResourceType?: 'agent' | 'workflow'
+
+  /**
+   * Execution ID for the action that runs AFTER user approval.
+   * NULL until execution starts.
+   *
+   * Naming distinction:
+   * - originExecutionId = Parent execution that CREATED the HITL task
+   * - targetExecutionId = Child execution that RUNS AFTER user approval
+   */
+  targetExecutionId?: string
+
+  createdAt: Date
+  completedAt?: Date
+  completedBy?: string
+  expiresAt?: Date
+  idempotencyKey?: string | null
+}
+
+/**
+ * Task status values
+ * - pending: awaiting action
+ * - processing: execution in progress after user approval
+ * - completed: action was taken and execution succeeded
+ * - failed: execution failed, task can be retried
+ * - expired: timed out before action
+ */
+type TaskStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'expired'
+
+/**
+ * Parameters for patching mutable metadata on a task
+ */
+interface PatchTaskParams {
+  humanCheckpoint?: string | null
+  description?: string
+  priority?: number
+  context?: Record<string, unknown>
+  actions?: unknown[]
+  targetResourceId?: string | null
+  targetResourceType?: 'agent' | 'workflow' | null
+  targetExecutionId?: string
+  status?: 'pending' | 'failed' | 'completed'
+}
+
+/**
+ * Checkpoint list item for sidebar grouping
+ * The id field contains the resourceId of the human checkpoint
+ */
+interface CheckpointListItem {
+  /** Human checkpoint resourceId (or 'ungrouped' for tasks without checkpoint) */
+  id: string
+  /** Display name (same as id, or "Ungrouped" for null) */
+  name: string
+  /** Task count for this checkpoint */
+  count: number
+}
+
+/**
+ * Status counts for pie chart display
+ */
+interface StatusCounts {
+  pending: number
+  completed: number
+  expired: number
+}
+
+/**
+ * Priority counts for donut chart display
+ */
+interface PriorityCounts {
+  critical: number
+  high: number
+  medium: number
+  low: number
+}
+
+/**
+ * Response from GET /command-queue/checkpoints endpoint
+ */
+interface CheckpointListResponse {
+  checkpoints: CheckpointListItem[]
+  /** Total tasks across all checkpoints */
+  total: number
+  /** Breakdown by status for donut chart */
+  statusCounts: StatusCounts
+  /** Breakdown by priority for donut chart */
+  priorityCounts: PriorityCounts
+}
+
+interface RecurringScheduleConfig {
+  type: 'recurring'
+  cron?: string
+  interval?: 'daily' | 'weekly' | 'monthly'
+  time?: string
+  timezone: string
+  payload: Record<string, unknown>
+  endAt?: string | null
+  overduePolicy?: 'skip' | 'execute' // Default: 'skip'
+}
+
+interface RelativeScheduleConfig {
+  type: 'relative'
+  anchorAt: string
+  anchorLabel?: string
+  items: RelativeScheduleItem[]
+  overduePolicy?: 'skip' | 'execute' // Default: 'skip'
+}
+
+interface RelativeScheduleItem {
+  offset: string // '-7d', '+3d', '-2h', '+1h'
+  payload: Record<string, unknown>
+  label?: string
+}
+
+interface AbsoluteScheduleConfig {
+  type: 'absolute'
+  items: AbsoluteScheduleItem[]
+  overduePolicy?: 'skip' | 'execute' // Default: 'skip'
+}
+
+interface AbsoluteScheduleItem {
+  runAt: string
+  payload: Record<string, unknown>
+  label?: string
+}
+
+/**
+ * Wire-format DTO for notification API responses.
+ * Dates are ISO 8601 strings (not Date objects like the domain Notification type).
+ * Used by frontend hooks that consume /api/notifications.
+ */
+interface NotificationDTO {
+  id: string
+  userId: string
+  organizationId: string
+  category: string
+  title: string
+  message: string
+  actionUrl: string | null
+  read: boolean
+  readAt: string | null
+  createdAt: string
+}
+
+// Workflow configuration
+interface WorkflowConfig extends ResourceDefinition {
+  type: 'workflow'
+}
+
+// Workflow step definition
+interface WorkflowStepDefinition {
+  id: string
+  name: string
+  description: string
+}
+
+// Step handler function type
+type StepHandler = (input: unknown, context: ExecutionContext) => Promise<unknown>
+
+// Next step configuration types
+interface LinearNext {
+  type: 'linear'
+  target: string
+}
+
+interface ConditionalNext {
+  type: 'conditional'
+  routes: Array<{
+    condition: (data: unknown) => boolean
+    target: string
+  }>
+  default: string // Required to avoid ambiguity
+}
+
+type NextConfig =
+  | LinearNext // Go to specific step
+  | ConditionalNext // Conditional routing
+  | null // Explicitly end workflow
+
+// Workflow step with graph-based flow
+interface WorkflowStep extends WorkflowStepDefinition {
+  handler: StepHandler
+
+  // I/O validation (BOTH REQUIRED for complete type safety)
+  inputSchema: z.ZodSchema // Validates input from previous step or workflow
+  outputSchema: z.ZodSchema // Validates output before next step
+
+  next: NextConfig // Required - explicit flow decision for every step
+}
+
+// Workflow definition - pure configuration without instance state
+// Used by registry to define workflows that can be instantiated
+interface WorkflowDefinition {
+  config: WorkflowConfig
+  contract: Contract
+  steps: Record<string, WorkflowStep>
+  entryPoint: string
+
+  /**
+   * Metrics configuration for ROI calculations
+   * Optional: Only needed if tracking automation savings
+   */
+  metricsConfig?: ResourceMetricsConfig
+
+  /**
+   * Execution interface configuration (optional)
+   * If provided, workflow appears in Execution Runner UI
+   */
+  interface?: ExecutionInterface
+}
+
+/**
+ * Standard Domain Definitions
+ * Centralized domain constants and definitions for all organization resources.
+ */
+
+
+
+// ============================================================================
+// Standard Domain IDs
+// ============================================================================
+
+declare const DOMAINS = {
+  // Business domains
+  INBOUND_PIPELINE: 'inbound-pipeline',
+  LEAD_GEN_PIPELINE: 'lead-gen-pipeline',
+  SUPPORT: 'support',
+  CLIENT_SUPPORT: 'client-support',
+  DELIVERY: 'delivery',
+  OPERATIONS: 'operations',
+  FINANCE: 'finance',
+  EXECUTIVE: 'executive',
+  INSTANTLY: 'instantly',
+
+  // Technical domains
+  TESTING: 'testing',
+  INTERNAL: 'internal',
+  INTEGRATION: 'integration',
+  UTILITY: 'utility',
+  DIAGNOSTIC: 'diagnostic'
+} as const
+
+/**
+ * ResourceDomain - Strongly typed domain identifier
+ * Use this type for all domain references to ensure compile-time validation.
+ */
+type ResourceDomain = (typeof DOMAINS)[keyof typeof DOMAINS]
+
+/**
+ * Supported integration types
+ *
+ * These represent the available integration adapters that can be used with tools.
+ * Each integration type corresponds to an adapter implementation.
+ *
+ * Note: Concrete adapter implementations are deferred until needed.
+ * This type provides compile-time safety and auto-completion for tool definitions.
+ */
+type IntegrationType =
+  | 'gmail' // Google Gmail API
+  | 'google-sheets' // Google Sheets API
+  | 'slack' // Slack API
+  | 'github' // GitHub API
+  | 'linear' // Linear API
+  | 'attio' // Attio CRM API
+  | 'airtable' // Airtable API
+  | 'salesforce' // Salesforce API
+  | 'hubspot' // HubSpot API
+  | 'stripe' // Stripe API
+  | 'twilio' // Twilio API
+  | 'sendgrid' // SendGrid API
+  | 'mailgun' // Mailgun API
+  | 'zapier' // Zapier Webhooks
+  | 'webhook' // Generic webhook
+  | 'apify' // Apify actor automation
+  | 'instantly' // Instantly.ai email automation
+  | 'resend' // Resend transactional email API
+  | 'signature-api' // SignatureAPI eSignature service
+  | 'dropbox' // Dropbox file storage API
+  | 'anymailfinder' // Anymailfinder email finder API
+  | 'tomba' // Tomba email discovery API
+  | 'millionverifier'
+
+/**
+ * Resource Registry type definitions
+ */
+
+
+
+// ============================================================================
+// Core Resource Type Definitions
+// ============================================================================
+
+/**
+ * Environment/deployment status for resources
+ */
+type ResourceStatus = 'dev' | 'prod'
+
+/**
+ * All resource types in the platform
+ * Used as the discriminator field in ResourceDefinition
+ */
+type ResourceType = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human'
+
+// ============================================================================
+// Base Resource Interface
+// ============================================================================
+
+/**
+ * Base interface for ALL platform resources
+ * Shared by both executable (agents, workflows) and non-executable (triggers, integrations, etc.) resources
+ */
+interface ResourceDefinition {
+  /** Unique resource identifier */
+  resourceId: string
+
+  /** Display name */
+  name: string
+
+  /** Purpose and functionality description */
+  description: string
+
+  /** Version for change tracking and evolution */
+  version: string
+
+  /** Resource type discriminator */
+  type: ResourceType
+
+  /** Environment/deployment status */
+  status: ResourceStatus
+
+  /** Domain tags for filtering and organization */
+  domains?: ResourceDomain[]
+
+  /** Whether the agent supports multi-turn sessions (agents only) */
+  sessionCapable?: boolean
+
+  /** Whether the resource is local (monorepo) or remote (externally deployed) */
+  origin?: 'local' | 'remote'
+
+  /** Whether this resource is archived and should be excluded from registration and deployment */
+  archived?: boolean
+}
+
+// ============================================================================
+// Domain Definition Types
+// ============================================================================
+
+/**
+ * Domain definition for Command View filtering
+ *
+ * Domains are organizational metadata for UI filtering/grouping.
+ * No execution impact - purely for visualization.
+ *
+ * @example
+ * {
+ *   id: 'support',
+ *   name: 'Customer Support',
+ *   description: 'Ticket triage, knowledge base, escalations',
+ *   color: 'green',
+ *   icon: 'IconHeadset'
+ * }
+ */
+interface DomainDefinition {
+  /** Unique identifier (e.g., 'support') */
+  id: string
+  /** Display name (e.g., 'Customer Support') */
+  name: string
+  /** Purpose description */
+  description: string
+  /** Optional Mantine color for UI (e.g., 'blue', 'green', 'orange') */
+  color?: string
+  /** Optional Tabler icon name (e.g., 'IconHeadset') */
+  icon?: string
+}
+
+// ============================================================================
+// Resource Manifest Types
+// ============================================================================
+
+// ============================================================================
+// Trigger Configuration Types
+// ============================================================================
+
+/** Webhook provider identifiers */
+type WebhookProviderType = 'cal-com' | 'stripe' | 'signature-api' | 'instantly' | 'apify'
+
+/** Webhook trigger configuration */
+interface WebhookTriggerConfig {
+  /** Provider identifier */
+  provider: WebhookProviderType
+  /** Event type for documentation (not used for matching - workflow handles routing) */
+  event?: string
+  /** Optional filtering (e.g., specific form ID for Fillout) */
+  filter?: Record<string, string>
+  /** References credential in credentials table for per-org webhook secrets */
+  credentialName?: string
+}
+
+/** Schedule trigger configuration */
+interface ScheduleTriggerConfig {
+  /** Cron expression (e.g., '0 6 * * *') */
+  cron: string
+  /** Optional timezone (default: UTC) */
+  timezone?: string
+}
+
+/** Event trigger configuration */
+interface EventTriggerConfig {
+  /** Internal event type */
+  eventType: string
+  /** Event source */
+  source?: string
+}
+
+/** Union of all trigger configs */
+type TriggerConfig = WebhookTriggerConfig | ScheduleTriggerConfig | EventTriggerConfig
+
+// ============================================================================
+// Trigger Definition
+// ============================================================================
+
+/**
+ * Trigger metadata - entry points that initiate resource execution
+ *
+ * Triggers represent how executions start: webhooks from external services,
+ * scheduled cron jobs, platform events, or manual user actions.
+ *
+ * BREAKING CHANGES (2025-11-30):
+ * - Now extends ResourceDefinition (inherits: resourceId, name, description, version, type, status, domains)
+ * - Field renames: `id` -> `resourceId` (inherited), `type` -> `triggerType`
+ * - Relationship rename: `invokes` -> `triggers` (unified vocabulary)
+ * - New required fields: `version` (inherited), `type: 'trigger'` (inherited)
+ * - triggers object now includes `externalResources` option
+ *
+ * @example
+ * // TriggerDefinition - metadata only
+ * {
+ *   resourceId: 'trigger-new-order',
+ *   type: 'trigger',
+ *   triggerType: 'webhook',
+ *   name: 'New Order',
+ *   description: 'Webhook from Shopify on new orders',
+ *   version: '1.0.0',
+ *   status: 'prod',
+ *   webhookPath: '/webhooks/shopify/orders'
+ * }
+ *
+ * // Relationships declared in ResourceRelationships (not on TriggerDefinition):
+ * // relationships: {
+ * //   'trigger-new-order': { triggers: { workflows: ['order-fulfillment-workflow'] } }
+ * // }
+ */
+interface TriggerDefinition extends ResourceDefinition {
+  /** Resource type discriminator (narrowed from base union) */
+  type: 'trigger'
+
+  /** Trigger mechanism type (renamed from 'type' to avoid collision with base type discriminator) */
+  triggerType: 'webhook' | 'schedule' | 'manual' | 'event'
+
+  /** Type-specific configuration */
+  config?: TriggerConfig
+
+  // Legacy fields (deprecated, use config instead)
+  /** For webhook triggers: path like '/webhooks/shopify/orders' */
+  webhookPath?: string
+  /** For schedule triggers: cron expression like '0 6 * * *' */
+  schedule?: string
+  /** For event triggers: event type like 'low-stock-alert' */
+  eventType?: string
+
+  // NOTE: What this trigger starts is declared in ResourceRelationships, not here
+  // This prevents duplication - triggers are forward-declared in relationships
+}
+
+/**
+ * Integration metadata - external service connections
+ *
+ * References credentials table for actual connection. No connection status
+ * stored here (queried at runtime from credentials table).
+ *
+ * BREAKING CHANGES (2025-11-30):
+ * - Now extends ResourceDefinition (inherits: resourceId, name, description, version, type, status, domains)
+ * - Field renames: `id` -> `resourceId` (inherited)
+ * - New required field: `status` (inherited) - organizations must add status to all integrations
+ * - New required field: `version` (inherited) - organizations must add version to all integrations
+ * - New required field: `type: 'integration'` (inherited) - resource type discriminator
+ *
+ * @example
+ * {
+ *   resourceId: 'integration-shopify-prod',
+ *   type: 'integration',
+ *   provider: 'shopify',
+ *   credentialName: 'shopify-prod',
+ *   name: 'Shopify Production',
+ *   description: 'E-commerce platform',
+ *   version: '1.0.0',
+ *   status: 'prod'
+ * }
+ */
+interface IntegrationDefinition extends ResourceDefinition {
+  /** Resource type discriminator (narrowed from base union) */
+  type: 'integration'
+
+  /** Integration provider type */
+  provider: IntegrationType
+  /** References credentials table (e.g., 'shopify-prod', 'zendesk-api') */
+  credentialName: string
+}
+
+// ============================================================================
+// External Resource Types
+// ============================================================================
+
+/**
+ * External platform type
+ * Supported third-party automation platforms
+ */
+type ExternalPlatform = 'n8n' | 'make' | 'zapier' | 'other'
+
+/**
+ * External automation resource metadata
+ *
+ * Represents workflows/automations running on third-party platforms
+ * (n8n, Make, Zapier, etc.) for visualization in Command View.
+ *
+ * NOTE: This is metadata ONLY for visualization. No execution logic,
+ * no API integration with external platforms, no status syncing.
+ *
+ * BREAKING CHANGES (2025-11-30):
+ * - Now extends ResourceDefinition (inherits: resourceId, name, description, version, type, status, domains)
+ * - Field renames: `id` -> `resourceId` (inherited)
+ * - New required field: `version` (inherited) - organizations must add version to all external resources
+ * - New required field: `type: 'external'` (inherited) - resource type discriminator
+ * - REMOVED FIELD: `triggeredBy` - per relationship-consolidation design, all relationships are forward-only declarations
+ *
+ * @example
+ * {
+ *   resourceId: 'external-n8n-order-sync',
+ *   type: 'external',
+ *   version: '1.0.0',
+ *   platform: 'n8n',
+ *   name: 'Shopify Order Sync',
+ *   description: 'Legacy n8n workflow for syncing Shopify orders',
+ *   status: 'prod',
+ *   platformUrl: 'https://n8n.client.com/workflow/123',
+ *   triggers: { workflows: ['order-fulfillment-workflow'] },
+ *   uses: { integrations: ['integration-shopify-prod'] }
+ * }
+ */
+interface ExternalResourceDefinition extends ResourceDefinition {
+  /** Resource type discriminator (narrowed from base union) */
+  type: 'external'
+
+  /** Platform type */
+  platform: ExternalPlatform
+
+  // Optional platform-specific metadata
+  /** Link to external platform (e.g., n8n workflow editor URL) */
+  platformUrl?: string
+  /** Platform's internal ID/reference */
+  externalId?: string
+
+  /** What this external resource triggers (external -> internal) */
+  triggers?: {
+    /** Elevasis workflow resourceIds this external automation triggers */
+    workflows?: string[]
+    /** Elevasis agent resourceIds this external automation triggers */
+    agents?: string[]
+  }
+
+  /** Integrations this external resource uses (shared credentials) */
+  uses?: {
+    /** Integration IDs this external automation uses */
+    integrations?: string[]
+  }
+
+  // NOTE: triggeredBy field removed - per relationship-consolidation design,
+  // all relationships are forward-only declarations. Graph edges are built
+  // from forward declarations only.
+}
+
+/**
+ * Human Checkpoint definition - human decision points in automation
+ *
+ * Represents where human judgment is deployed in the automation landscape.
+ * Tasks with matching command_queue_group are routed to this checkpoint.
+ *
+ * BREAKING CHANGES (2025-11-30):
+ * - Now extends ResourceDefinition (inherits: resourceId, name, description, version, type, status, domains)
+ * - Field renames: `id` -> `resourceId` (inherited)
+ * - description is now REQUIRED (was optional) - organizations must add description to all human checkpoints
+ * - New required field: `version` (inherited) - organizations must add version to all human checkpoints
+ * - New required field: `type: 'human'` (inherited) - resource type discriminator
+ *
+ * @example
+ * {
+ *   resourceId: 'sales-approval',
+ *   type: 'human',
+ *   name: 'Sales Approval Queue',
+ *   description: 'High-value order approvals for sales team',
+ *   version: '1.0.0',
+ *   status: 'prod',
+ *   requestedBy: { agents: ['order-processor-agent'] },
+ *   routesTo: { agents: ['order-fulfillment-agent'] }
+ * }
+ */
+interface HumanCheckpointDefinition extends ResourceDefinition {
+  /** Resource type discriminator (narrowed from base union) */
+  type: 'human'
+
+  /** Resources that create tasks for this checkpoint */
+  requestedBy?: {
+    /** Agent resourceIds that request approval here */
+    agents?: string[]
+    /** Workflow resourceIds that request approval here */
+    workflows?: string[]
+  }
+
+  /** Resources that receive approved decisions */
+  routesTo?: {
+    /** Agent resourceIds that handle approved tasks */
+    agents?: string[]
+    /** Workflow resourceIds that handle approved tasks */
+    workflows?: string[]
+  }
+}
+
+/**
+ * Command View Types
+ *
+ * Unified type definitions for the Command View graph visualization.
+ * These types are used by both backend serialization and frontend rendering.
+ *
+ * Command View shows the resource graph: agents, workflows, triggers, integrations,
+ * external resources, and human checkpoints with their relationships.
+ */
+
+
+
+// ============================================================================
+// Node Types - Resources that appear in the graph
+// ============================================================================
+
+/**
+ * Extended agent metadata for Command View
+ * Includes model and capability information for graph display
+ */
+interface CommandViewAgent extends ResourceDefinition {
+  type: 'agent'
+  modelProvider: string // e.g., 'anthropic', 'openai'
+  modelId: string // e.g., 'claude-sonnet-4-20250514'
+  toolCount: number
+  hasKnowledgeMap: boolean
+  hasMemory: boolean
+  sessionCapable: boolean // Explicit session capability declaration
+}
+
+/**
+ * Extended workflow metadata for Command View
+ * Includes step information for graph display
+ */
+interface CommandViewWorkflow extends ResourceDefinition {
+  type: 'workflow'
+  stepCount: number
+  entryPoint: string
+}
+
+/**
+ * Node type categories for Command View
+ * Simplified categorization for UI rendering and layout
+ */
+type CommandViewNodeType = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human'
+
+/**
+ * Union type for all node types in Command View
+ * Frontend can use this for type-safe node handling
+ */
+type CommandViewNode =
+  | CommandViewAgent
+  | CommandViewWorkflow
+  | TriggerDefinition
+  | IntegrationDefinition
+  | ExternalResourceDefinition
+  | HumanCheckpointDefinition
+
+// ============================================================================
+// Edge Types - Relationships between resources
+// ============================================================================
+
+/**
+ * Relationship types between resources
+ *
+ * - triggers: Resource initiates/starts another resource (orange)
+ * - uses: Resource uses an integration (teal)
+ * - approval: Resource requires human approval (yellow)
+ */
+type RelationshipType = 'triggers' | 'uses' | 'approval'
+
+/**
+ * Command View edge (relationship between resources)
+ */
+interface CommandViewEdge {
+  id: string
+  source: string // Source node ID
+  target: string // Target node ID
+  relationship: RelationshipType
+  label?: string // Optional label for the edge
+}
+
+// ============================================================================
+// Graph Data Structure
+// ============================================================================
+
+/**
+ * Command View data structure
+ * Complete graph data for visualization
+ *
+ * Backend serializes this once at startup and serves it via /command-view endpoint.
+ * Frontend consumes this directly for graph rendering.
+ */
+interface CommandViewData {
+  workflows: CommandViewWorkflow[]
+  agents: CommandViewAgent[]
+  triggers: TriggerDefinition[]
+  integrations: IntegrationDefinition[]
+  externalResources: ExternalResourceDefinition[]
+  humanCheckpoints: HumanCheckpointDefinition[]
+  edges: CommandViewEdge[]
+  domainDefinitions?: DomainDefinition[]
+}
+
+/**
+ * Serialized Registry Types
+ *
+ * Pre-computed JSON-safe types for API responses and Command View.
+ * Serialization happens once at API startup, enabling instant response times.
+ */
+
+
+
+// ============================================================================
+// Serialized Interface Types (for Execution Runner UI)
+// ============================================================================
+
+/**
+ * Serialized form field for API responses
+ */
+interface SerializedFormField {
+  name: string
+  label: string
+  type: FormFieldType
+  defaultValue?: unknown
+  required?: boolean
+  placeholder?: string
+  description?: string
+  options?: Array<{ label: string; value: string | number }>
+  min?: number
+  max?: number
+}
+
+/**
+ * Serialized form schema for API responses
+ */
+interface SerializedFormSchema {
+  title?: string
+  description?: string
+  fields: SerializedFormField[]
+  layout?: 'vertical' | 'horizontal' | 'grid'
+}
+
+/**
+ * Serialized execution form schema for API responses
+ */
+interface SerializedExecutionFormSchema extends SerializedFormSchema {
+  fieldMappings?: Record<string, string>
+  submitButton?: {
+    label?: string
+    loadingLabel?: string
+    confirmMessage?: string
+  }
+}
+
+/**
+ * Serialized schedule config for API responses
+ */
+interface SerializedScheduleConfig {
+  enabled: boolean
+  defaultSchedule?: string
+  allowedPatterns?: string[]
+}
+
+/**
+ * Serialized webhook config for API responses
+ */
+interface SerializedWebhookConfig {
+  enabled: boolean
+  payloadSchema?: unknown
+}
+
+/**
+ * Serialized execution interface for API responses
+ */
+interface SerializedExecutionInterface {
+  form: SerializedExecutionFormSchema
+  schedule?: SerializedScheduleConfig
+  webhook?: SerializedWebhookConfig
+}
+
+// ============================================================================
+// Serialized Definition Types
+// ============================================================================
+
+/**
+ * Serialized agent definition (JSON-safe)
+ * Result of serializeDefinition(AgentDefinition)
+ */
+interface SerializedAgentDefinition {
+  config: {
+    resourceId: string
+    name: string
+    description: string
+    version: string
+    type: 'agent'
+    status: 'dev' | 'prod'
+    /** Whether this resource is archived and should be excluded from registration and deployment */
+    archived?: boolean
+    systemPrompt: string
+    constraints?: {
+      maxIterations?: number
+      timeout?: number
+      maxSessionMemoryKeys?: number
+      maxMemoryTokens?: number
+    }
+    sessionCapable?: boolean
+    memoryPreferences?: string
+  }
+  modelConfig: {
+    provider: string
+    model: string
+    apiKey: string // Redacted: "sk-proj..."
+    temperature: number
+    maxOutputTokens: number
+    topP?: number
+    modelOptions?: Record<string, unknown>
+  }
+  contract: {
+    inputSchema: object // JSON Schema
+    outputSchema?: object // JSON Schema
+  }
+  tools: Array<{
+    name: string
+    description: string
+    inputSchema?: object // JSON Schema
+    outputSchema?: object // JSON Schema
+  }>
+  knowledgeMap?: {
+    nodeCount: number
+    nodes: Array<{
+      id: string
+      description: string
+      loaded: boolean
+      hasPrompt: boolean
+    }>
+  }
+  metricsConfig?: object
+  interface?: SerializedExecutionInterface
+}
+
+/**
+ * Serialized workflow definition (JSON-safe)
+ * Result of serializeDefinition(WorkflowDefinition)
+ */
+interface SerializedWorkflowDefinition {
+  config: {
+    resourceId: string
+    name: string
+    description: string
+    version: string
+    type: 'workflow'
+    status: 'dev' | 'prod'
+    /** Whether this resource is archived and should be excluded from registration and deployment */
+    archived?: boolean
+  }
+  entryPoint: string
+  steps: Array<{
+    id: string
+    name: string
+    description: string
+    inputSchema?: object // JSON Schema
+    outputSchema?: object // JSON Schema
+    next: {
+      type: 'linear' | 'conditional'
+      target?: string
+      routes?: Array<{ target: string }>
+      default?: string
+    } | null
+  }>
+  contract: {
+    inputSchema: object // JSON Schema
+    outputSchema?: object // JSON Schema
+  }
+  metricsConfig?: object
+  interface?: SerializedExecutionInterface
+}
+
+/**
+ * Base Execution Engine type definitions
+ * Core types shared across all Execution Engine resources
+ */
+
+
+
+/**
+ * Immutable execution metadata
+ * Represents complete execution identity (who, what, when, where)
+ * Shared across ExecutionContext and ExecutionLoggerContext to eliminate field duplication
+ */
+interface ExecutionMetadata {
+  executionId: string // Unique ID for this execution instance
+  organizationId: string // Required for multi-tenant isolation and security
+  organizationName: string // Required for resource lookup in registry
+  resourceId: string // Required for observability and audit trails
+  userId?: string // Optional: user context for audit trails (API keys, system executions may not have userId)
+  sessionId?: string // Optional: only for session executions
+  sessionTurnNumber?: number // Optional: only for session executions (maps to execution_logs.session_turn_number)
+}
+
+/**
+ * Unified message event type - covers all message types in sessions
+ * Replaces separate SessionTurnMessages and AgentActivityEvent mechanisms
+ */
+/**
+ * Structured action metadata attached to assistant messages.
+ * Frontend reads this instead of parsing text prefixes.
+ */
+type AssistantAction =
+  | { kind: 'navigate'; path: string; reason: string }
+  | {
+      kind: 'update_filters'
+      timeRange: string | null
+      statusFilter: string | null
+      searchQuery: string | null
+    }
+
+type MessageEvent =
+  // User/Assistant text messages
+  | { type: 'user_message'; text: string }
+  | { type: 'assistant_message'; text: string; _action?: AssistantAction }
+
+  // Agent lifecycle events
+  | { type: 'agent:started' }
+  | { type: 'agent:completed' }
+  | { type: 'agent:error'; error: string }
+
+  // Agent activity events (with metadata for UI)
+  | { type: 'agent:reasoning'; iteration: number; reasoning: string }
+  | { type: 'agent:tool_call'; toolName: string; args: Record<string, unknown> }
+  | { type: 'agent:tool_result'; toolName: string; success: boolean; result?: unknown; error?: string }
+
+/**
+ * Execution context for all resources
+ * Unified callback replaces SessionTurnMessages (removed)
+ */
+interface ExecutionContext extends ExecutionMetadata {
+  // Inherited: executionId, organizationId, organizationName, resourceId, userId, sessionId, sessionTurnNumber
+  logger: IExecutionLogger // Required for observability and debugging
+  signal?: AbortSignal // Future: cancellation support for long-running operations
+
+  // Unified message event callback (immediate persistence + streaming)
+  onMessageEvent?: (event: MessageEvent) => Promise<void>
+
+  /** Called per iteration to write heartbeat + check stall status. Non-fatal if it throws. */
+  onHeartbeat?: () => Promise<void>
+
+  // Observability collectors (optional - injected by coordinators)
+  aiUsageCollector?: AIUsageCollector // Tracks AI token usage and costs
+  metricsCollector?: MetricsCollector // Tracks execution timing and ROI metrics
+
+  // Nested execution tracking (Wave 2c - Agent Resource Invocation)
+  parentExecutionId?: string // Parent execution ID for nested invocations
+  executionDepth: number // Nesting depth: 0 = top-level, 1+ = nested
+
+  // Integration credential tracking (for OAuth token refresh persistence)
+  credentialName?: string // Credential name used for current integration call
+
+  // Execution-scoped storage for large data (e.g., PDF buffers) that shouldn't be logged
+  // Automatically garbage collected when execution context ends
+  store: Map<string, unknown>
+}
+
+// Contract definition - validation schemas (Zod)
+interface Contract {
+  inputSchema: z.ZodSchema // Required - use z.object({}) for no input
+  outputSchema?: z.ZodSchema // Optional - if present, agent generates output
+}
+
+/**
+ * Agent timeline and observability types
+ * Used for UI timeline visualization and backend processing
+ */
+
+
+
+/**
+ * Sub-activity within an iteration
+ * Represents reasoning, actions, or tool calls with timing
+ */
+interface SubActivity {
+  type: 'reasoning' | 'action' | 'tool-call'
+  startTime: number
+  endTime: number
+  duration: number
+  details: AgentIterationEvent | AgentToolCallEvent
+}
+
+/**
+ * Agent iteration state
+ * Aggregates lifecycle events and sub-activities for a single iteration
+ */
+interface AgentIteration {
+  iterationNumber: number
+  status: 'running' | 'completed' | 'failed' | 'pending'
+  iterationEvents: AgentIterationEvent[]
+  duration?: number
+  timestamp: number
+  subActivities: SubActivity[]
+
+  // Timeline visualization timing (Phase 2 - optional for backward compatibility)
+  startTime?: number   // From lifecycle 'started' event
+  endTime?: number     // From lifecycle 'completed'/'failed' event
+}
+
+/**
+ * Agent lifecycle node state
+ * Represents initialization or completion phase
+ */
+interface AgentLifecycleNode {
+  type: 'initialization' | 'completion'
+  status: 'running' | 'completed' | 'failed' | 'pending'
+  duration?: number
+  timestamp?: number
+
+  // Timeline visualization timing (Phase 2 - optional for backward compatibility)
+  startTime?: number   // From lifecycle 'started' event
+  endTime?: number     // From lifecycle 'completed'/'failed' event
+}
+
+/**
+ * Complete agent execution data for timeline visualization
+ * Parsed from execution logs
+ */
+interface AgentIterationData {
+  initialization: AgentLifecycleNode
+  iterations: AgentIteration[]
+  completion: AgentLifecycleNode
+  currentIteration: number | null
+  totalIterations: number
+  totalDuration?: number
+  status: 'running' | 'completed' | 'failed' | 'warning'
+}
+
+// Execution status type shared between API and UI
+type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'warning'
+
+/**
+ * Event sent when new execution starts
+ */
+interface ExecutionStartedEvent {
+  type: 'new-execution'
+  resourceId: string
+  executionId: string
+  timestamp: number
+  data?: undefined
+}
+
+/**
+ * Event sent when execution log message is emitted
  */
-interface StatusCounts {
-  pending: number
-  completed: number
-  expired: number
+interface ExecutionLogEvent {
+  type: 'log'
+  resourceId: string
+  executionId: string
+  timestamp: number
+  data: {
+    log: ExecutionLogMessage
+  }
 }
 
 /**
- * Priority counts for donut chart display
+ * Event sent when execution completes (success or failure)
  */
-interface PriorityCounts {
-  critical: number
-  high: number
-  medium: number
-  low: number
+interface ExecutionCompleteEvent {
+  type: 'execution-complete'
+  resourceId: string
+  executionId: string
+  timestamp: number
+  data: {
+    success: boolean
+    status?: ExecutionStatus
+    result?: unknown
+    error?: string
+  }
 }
 
 /**
- * Response from GET /command-queue/checkpoints endpoint
+ * Connection confirmation event
  */
-interface CheckpointListResponse {
-  checkpoints: CheckpointListItem[]
-  /** Total tasks across all checkpoints */
-  total: number
-  /** Breakdown by status for donut chart */
-  statusCounts: StatusCounts
-  /** Breakdown by priority for donut chart */
-  priorityCounts: PriorityCounts
+interface ExecutionConnectedEvent {
+  type: 'connected'
+  resourceId: string
+  executionId?: undefined
+  timestamp: number
+  data?: undefined
 }
 
 /**
- * Wire-format DTO for notification API responses.
- * Dates are ISO 8601 strings (not Date objects like the domain Notification type).
- * Used by frontend hooks that consume /api/notifications.
+ * Union of all execution SSE events
  */
-interface NotificationDTO {
+type ExecutionSSEEvent =
+  | ExecutionStartedEvent
+  | ExecutionLogEvent
+  | ExecutionCompleteEvent
+  | ExecutionConnectedEvent
+
+// API execution types
+interface APIExecutionSummary {
   id: string
-  userId: string
-  organizationId: string
-  category: string
-  title: string
-  message: string
-  actionUrl: string | null
-  read: boolean
-  readAt: string | null
-  createdAt: string
+  status: ExecutionStatus
+  startTime: number
+  endTime?: number
+  resourceStatus?: ResourceStatus // 'dev' | 'prod' - optional for backward compatibility
 }
 
-// Execution status type shared between API and UI
-type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'warning'
-
 /**
  * Execution Runner Types
  *
@@ -3696,6 +6393,462 @@ declare const ExecutionHistoryResponseSchema = z.object({
 type ExecutionHistoryItem = z.infer<typeof ExecutionHistoryItemSchema>
 type ExecutionHistoryResponse = z.infer<typeof ExecutionHistoryResponseSchema>
 
+/**
+ * Calibration Lab Type Definitions
+ * Core types for AI model configuration optimization with cost/performance comparison
+ */
+
+
+
+// ============================================================================
+// Calibration Project Types
+// ============================================================================
+
+/**
+ * Calibration project - groups related optimization runs
+ * Provides organizational structure for iterative testing
+ */
+interface CalibrationProject {
+  id: string
+  organizationId: string
+  resourceId: string
+  resourceType: 'agent' | 'workflow'
+  name: string
+  description?: string | null
+  createdAt: Date
+  updatedAt: Date
+}
+
+// ============================================================================
+// Configuration Variant Types
+// ============================================================================
+
+/**
+ * Configuration variant for testing
+ * Defines what to override in the base agent/workflow definition
+ */
+interface ConfigVariant {
+  variantName: string
+  definitionOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides
+}
+
+/**
+ * Agent definition overrides for calibration
+ * Excludes identity/metadata fields that should not be modified
+ */
+type AgentCalibrationOverrides = Omit<
+  Partial<AgentDefinition>,
+  'config' | 'contract' | 'tools' | 'metricsConfig' | 'interface'
+>
+
+/**
+ * Workflow definition overrides for calibration
+ * Excludes identity/metadata fields that should not be modified
+ */
+type WorkflowCalibrationOverrides = Omit<
+  Partial<WorkflowDefinition>,
+  'config' | 'contract' | 'steps' | 'entryPoint' | 'metricsConfig' | 'interface'
+>
+
+// ============================================================================
+// Grading System Types
+// ============================================================================
+
+/**
+ * Grading rubric for LLM-as-judge evaluation
+ * Defines criteria and passing threshold
+ */
+interface GradingRubric {
+  passingThreshold: number // 0-1, e.g., 0.7 means 70% to pass
+  criteria: GradingCriterion[]
+}
+
+/**
+ * Individual grading criterion
+ * Weight should be 0-1, and all weights should sum to 1
+ */
+interface GradingCriterion {
+  name: string
+  weight: number // 0-1, weights should sum to 1
+  description: string
+  scoringGuide: string
+}
+
+/**
+ * Grading result for a single execution or session
+ * Contains overall score and per-criterion breakdown
+ */
+interface GradeResult {
+  score: number // 0-1
+  passed: boolean
+  details: Record<string, { score: number; justification: string }>
+}
+
+// ============================================================================
+// Result Types
+// ============================================================================
+
+/**
+ * Single-turn calibration result
+ * One result per (variant × input) combination
+ */
+interface SingleCalibrationResult {
+  executionId: string // Reference to execution_logs
+  variantName: string
+  inputIndex: number // Which input from testInputs array (0-based)
+  appliedOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides
+  status: 'pending' | 'running' | 'completed' | 'failed'
+  errorMessage?: string
+  grade?: GradeResult
+  gradeError?: string
+}
+
+/**
+ * Multi-turn session calibration result
+ * Leverages existing sessions infrastructure
+ */
+interface SessionCalibrationResult {
+  sessionId: string // Reference to sessions table
+  variantName: string
+  appliedOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides
+  status: 'pending' | 'running' | 'completed' | 'failed'
+  errorMessage?: string
+  turnCount: number
+  grade?: GradeResult
+  gradeError?: string
+}
+
+// ============================================================================
+// Calibration Run Types
+// ============================================================================
+
+/**
+ * Calibration run - individual test execution within a project
+ * Contains configuration, results, and grading information
+ */
+interface CalibrationRun {
+  id: string
+  organizationId: string
+  projectId: string
+  name: string
+  description?: string | null
+  executionMode: 'single' | 'session'
+  testInputs: unknown[]
+  configVariants: ConfigVariant[]
+  gradingRubric?: GradingRubric | null
+  graderModel?: string | null
+  results: (SingleCalibrationResult | SessionCalibrationResult)[]
+  status: 'pending' | 'running' | 'completed' | 'partial' | 'failed'
+  createdAt: Date
+  completedAt?: Date | null
+}
+
+// ============================================================================
+// Combined Response Types
+// ============================================================================
+
+/**
+ * Execution log subset for comparison view
+ * Contains essential data without full execution context
+ */
+interface ExecutionLog {
+  executionId: string
+  status: 'running' | 'completed' | 'failed'
+  input: unknown
+  output: unknown | null
+  error: CalibrationExecutionError | null
+  startedAt: string
+  completedAt: string | null
+}
+
+/**
+ * Execution error information for calibration display
+ * Subset of full execution error for UI display purposes
+ * Named differently from ExecutionError class to avoid type conflicts
+ */
+interface CalibrationExecutionError {
+  message: string
+  category?: string
+  type?: string
+}
+
+/**
+ * Combined calibration run data for comparison view
+ * Single API call returns run + execution logs + metrics
+ */
+interface CalibrationRunWithFullData {
+  run: CalibrationRun
+  logs: Record<string, ExecutionLog> // keyed by executionId
+  metrics: Record<string, ExecutionMetricsDetail> // keyed by executionId
+}
+
+// ============================================================================
+// Calibration Project Schemas
+// ============================================================================
+
+/**
+ * Create calibration project schema
+ * Validates request body for creating a new calibration project
+ */
+declare const CreateCalibrationProjectSchema = z.object({
+  resourceId: z.string().min(1),
+  resourceType: z.enum(['agent', 'workflow']),
+  name: z.string().min(1),
+  description: z.string().optional()
+})
+
+/**
+ * Update calibration project schema
+ * Validates request body for updating an existing calibration project
+ */
+declare const UpdateCalibrationProjectSchema = z.object({
+  name: z.string().min(1).optional(),
+  description: z.string().optional()
+})
+
+// ============================================================================
+// Calibration Run Schemas
+// ============================================================================
+
+/**
+ * Create calibration run schema
+ * Validates request body for creating a new calibration run
+ * Includes refinement for graderModel requirement when gradingRubric is provided
+ */
+declare const CreateCalibrationRunSchema = z
+  .object({
+    projectId: z.string().uuid(),
+    name: z.string().min(1),
+    description: z.string().optional(),
+    executionMode: z.enum(['single', 'session']).default('single'),
+    testInputs: z.array(z.unknown()).min(1).max(50), // Min 1, max 50 inputs
+    configVariants: z.array(ConfigVariantSchema).min(1).max(10), // Min 1, max 10 variants
+    gradingRubric: GradingRubricSchema.optional(),
+    graderModel: LLMModelSchema.optional()
+  })
+  .refine((data) => !data.gradingRubric || data.graderModel, {
+    message: 'graderModel is required when gradingRubric is provided'
+  })
+
+
+// ============================================================================
+// Inferred Types
+// ============================================================================
+
+type CreateCalibrationProjectInput = z.infer<typeof CreateCalibrationProjectSchema>
+type UpdateCalibrationProjectInput = z.infer<typeof UpdateCalibrationProjectSchema>
+type CreateCalibrationRunInput = z.infer<typeof CreateCalibrationRunSchema>
+
+/**
+ * Calibration SSE Event Types
+ *
+ * Shared event type definitions for calibration real-time streaming.
+ * Used by both the API broadcaster and the command-center UI.
+ */
+
+// Single-turn events
+
+interface CalibrationExecutionStartedEvent {
+  type: 'execution-started'
+  variantName: string
+  inputIndex: number
+  timestamp: number
+}
+
+interface CalibrationExecutionCompletedEvent {
+  type: 'execution-completed'
+  variantName: string
+  inputIndex: number
+  executionId: string
+  timestamp: number
+}
+
+interface CalibrationExecutionFailedEvent {
+  type: 'execution-failed'
+  variantName: string
+  inputIndex?: number
+  error: string
+  timestamp: number
+}
+
+// Session events
+
+interface CalibrationSessionStartedEvent {
+  type: 'session-started'
+  variantName: string
+  sessionId: string
+  timestamp: number
+}
+
+interface CalibrationTurnStartedEvent {
+  type: 'turn-started'
+  variantName: string
+  turnNumber: number
+  timestamp: number
+}
+
+interface CalibrationTurnCompletedEvent {
+  type: 'turn-completed'
+  variantName: string
+  turnNumber: number
+  executionId: string
+  timestamp: number
+}
+
+interface CalibrationSessionCompletedEvent {
+  type: 'session-completed'
+  variantName: string
+  sessionId: string
+  turnCount: number
+  timestamp: number
+}
+
+// Grading events
+
+interface CalibrationGradingStartedEvent {
+  type: 'grading-started'
+  variantName: string
+  timestamp: number
+}
+
+interface CalibrationGradingCompletedEvent {
+  type: 'grading-completed'
+  variantName: string
+  score: number
+  timestamp: number
+}
+
+interface CalibrationGradingFailedEvent {
+  type: 'grading-failed'
+  variantName: string
+  error: string
+  timestamp: number
+}
+
+// Completion events
+
+interface CalibrationCompletedEvent {
+  type: 'calibration-completed'
+  summary: { total: number; completed: number; failed: number }
+  timestamp: number
+}
+
+interface CalibrationFailedEvent {
+  type: 'calibration-failed'
+  error: string
+  timestamp: number
+}
+
+// Connection event
+
+interface CalibrationConnectedEvent {
+  type: 'connected'
+  timestamp: number
+  data?: undefined
+}
+
+/**
+ * Union of all calibration SSE events
+ */
+type CalibrationSSEEvent =
+  | CalibrationExecutionStartedEvent
+  | CalibrationExecutionCompletedEvent
+  | CalibrationExecutionFailedEvent
+  | CalibrationSessionStartedEvent
+  | CalibrationTurnStartedEvent
+  | CalibrationTurnCompletedEvent
+  | CalibrationSessionCompletedEvent
+  | CalibrationGradingStartedEvent
+  | CalibrationGradingCompletedEvent
+  | CalibrationGradingFailedEvent
+  | CalibrationCompletedEvent
+  | CalibrationFailedEvent
+  | CalibrationConnectedEvent
+
+/**
+ * Command Queue SSE Event Types
+ *
+ * Type-safe definitions for command queue related SSE events
+ */
+
+
+
+/**
+ * Event sent when command queue task is updated
+ */
+interface CommandQueueTaskUpdatedEvent {
+  type: 'task_updated'
+  timestamp: number
+  data: {
+    task: Task
+  }
+}
+
+/**
+ * Connection confirmation event
+ */
+interface CommandQueueConnectedEvent {
+  type: 'connected'
+  timestamp: number
+  data?: undefined
+}
+
+/**
+ * Event sent when action execution completes successfully
+ */
+interface CommandQueueExecutionCompletedEvent {
+  type: 'execution_completed'
+  timestamp: number
+  data: {
+    taskId: string
+    targetExecutionId: string
+  }
+}
+
+/**
+ * Event sent when action execution fails
+ */
+interface CommandQueueExecutionFailedEvent {
+  type: 'execution_failed'
+  timestamp: number
+  data: {
+    taskId: string
+    targetExecutionId?: string
+    error: string
+  }
+}
+
+/**
+ * Union of all command queue SSE events
+ */
+type CommandQueueSSEEvent =
+  | CommandQueueTaskUpdatedEvent
+  | CommandQueueConnectedEvent
+  | CommandQueueExecutionCompletedEvent
+  | CommandQueueExecutionFailedEvent
+
+/**
+ * Notification SSE Event Types
+ *
+ * Type-safe definitions for notification-related SSE events
+ */
+
+/**
+ * Event sent when notification unread count changes
+ */
+interface NotificationCountUpdatedEvent {
+  type: 'unread_count_updated'
+  timestamp: number
+  data: {
+    count: number
+  }
+}
+
+/**
+ * Union of all notification SSE events
+ */
+type NotificationSSEEvent = NotificationCountUpdatedEvent
+
 type ActivityType =
   | 'workflow_execution'
   | 'agent_run'
@@ -3727,6 +6880,37 @@ interface Activity {
   createdAt: Date
 }
 
+/**
+ * Activity SSE Event Types
+ *
+ * Type-safe definitions for activity-related SSE events
+ */
+
+
+
+/**
+ * Event sent when new activity is created
+ */
+interface ActivityCreatedEvent {
+  type: 'activity'
+  timestamp: number
+  data: Activity
+}
+
+/**
+ * Connection confirmation event
+ */
+interface ActivityConnectedEvent {
+  type: 'connected'
+  timestamp: number
+  data?: undefined
+}
+
+/**
+ * Union of all activity SSE events
+ */
+type ActivitySSEEvent = ActivityCreatedEvent | ActivityConnectedEvent
+
 /**
  * Webhook Endpoint Domain Types
  *
@@ -3821,6 +7005,26 @@ declare const UpdateWebhookEndpointRequestSchema = z
 
 type UpdateWebhookEndpointRequest = z.infer<typeof UpdateWebhookEndpointRequestSchema>
 
+/**
+ * Response shape for a single webhook endpoint.
+ * NOT strict — response schemas allow extra fields for forward compatibility.
+ */
+declare const WebhookEndpointResponseSchema = z.object({
+  id: UuidSchema,
+  organizationId: UuidSchema,
+  key: z.string(),
+  name: z.string(),
+  description: z.string().nullable(),
+  resourceId: z.string().nullable(),
+  status: WebhookEndpointStatusSchema,
+  lastTriggeredAt: z.string().datetime().nullable(),
+  requestCount: z.number().int().min(0),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+})
+
+type WebhookEndpointResponse = z.infer<typeof WebhookEndpointResponseSchema>
+
 /**
  * GET /api/credentials - List credentials
  */
@@ -3839,4 +7043,68 @@ declare const ListCredentialsResponseSchema = z.object({
 /** API response type for a single credential list item */
 type CredentialListItem = z.infer<typeof ListCredentialsResponseSchema>['credentials'][number]
 
-export type { AIResourceDefinition, APIExecutionDetail, APIExecutionListResponse, Activity, ActivityType, ApiKeyListItem, ChatMessage, CheckpointListResponse, CostByModelResponse, CostSummaryResponse, CostTrendsResponse, CreateWebhookEndpointRequest, CredentialListItem, DashboardMetrics, Deployment, DeploymentStatus, ErrorAnalysisMetrics, ErrorDetailFull, ErrorDetailResponse, ErrorTrend, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogMessage, ExecutionStatus$1 as ExecutionStatus, ExecutionSummary, MembershipFeatureConfig, MembershipWithDetails, MessageEvent, NotificationDTO, OrgFeatureConfig, PatchTaskParams, ResourceDefinition, ResourceStatus, ResourceType, SessionDTO, SessionTokenUsage, SupabaseUserProfile, Task, TaskSchedule, TaskScheduleConfig, TaskStatus, TimeRange, UpdateWebhookEndpointRequest, UserConfig, WebhookEndpoint };
+/**
+ * @deprecated Use TimeRange from '@repo/core' directly. Kept as alias for backward compatibility.
+ */
+type StatsTimeRange = TimeRange
+
+/** Stats returned by /command-view/stats (counts only, no error details) */
+interface ResourceStats {
+  resourceId: string
+  totalRuns: number
+  successCount: number
+  failureCount: number // Used for badge: "X failed"
+  warningCount: number // Completed with warnings (counts toward success)
+  lastRunAt: string | null
+  // NO recentErrors or totalErrors - fetched on-demand via /resource-errors
+}
+
+/** Response from /command-view/resource-errors (on-demand) */
+interface ResourceErrorsResponse {
+  resourceId: string
+  errors: ErrorSummary[]
+  totalErrors: number // Total count for "showing 10 of X" display
+  timeRange: StatsTimeRange
+}
+
+interface ErrorSummary {
+  executionId: string
+  errorType: string
+  errorMessage: string
+  occurredAt: string
+}
+
+/** Single execution summary for Recent Executions list in command view */
+interface CommandViewExecution {
+  executionId: string
+  status: ExecutionStatus
+  startedAt: string
+  completedAt: string | null
+  errorMessage: string | null // Only present if failed
+}
+
+/** Response from /command-view/resource-executions (on-demand) */
+interface ResourceExecutionsResponse {
+  resourceId: string
+  executions: CommandViewExecution[]
+  totalExecutions: number // Total count for "showing 10 of X" display
+  timeRange: StatsTimeRange
+}
+
+interface HumanCheckpointStats {
+  checkpointId: string
+  pendingCount: number
+  completedCount: number
+  expiredCount: number
+  lastDecisionAt: string | null
+}
+
+/** Response from /command-view/stats */
+interface CommandViewStatsResponse {
+  resources: Record<string, ResourceStats>
+  humanCheckpoints: Record<string, HumanCheckpointStats>
+  timeRange: StatsTimeRange
+  generatedAt: string
+}
+
+export type { AIResourceDefinition, APIExecutionDetail, APIExecutionListResponse, APIExecutionSummary, AbsoluteScheduleConfig, AbsoluteScheduleItem, ActionConfig, Activity, ActivitySSEEvent, ActivityStatus, ActivityType, AgentIterationData, AgentMemory, ApiKeyListItem, BusinessImpactMetrics, CalibrationProject, CalibrationRun, CalibrationRunWithFullData, CalibrationSSEEvent, ChatMessage, CheckpointListResponse, CommandQueueSSEEvent, CommandViewAgent, CommandViewData, CommandViewNode, CommandViewNodeType, CommandViewStatsResponse, CommandViewWorkflow, ConfigVariant, CostBreakdownMetrics, CostByModelResponse, CostSummaryResponse, CostTrendsResponse, CreateCalibrationProjectInput, CreateCalibrationRunInput, CreateWebhookEndpointRequest, CredentialListItem, DashboardMetrics, Deployment, DeploymentStatus, DomainDefinition, ErrorAnalysisMetrics, ErrorDetailFull, ErrorDetailResponse, ErrorTrend, ExecutionHealthMetrics, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLog, ExecutionLogMessage, ExecutionMetricsDetail, ExecutionSSEEvent, ExecutionStatus$1 as ExecutionStatus, ExecutionSummary, FailingResource, GradingRubric, HumanCheckpointDefinition, HumanCheckpointStats, ListMembershipsParams, MembershipFeatureConfig, MembershipStatus, MembershipWithDetails, MessageEvent$1 as MessageEvent, MessageType, ModelConfig, NotificationDTO, NotificationSSEEvent, OrgFeatureConfig, PatchTaskParams, RecentExecutionsByResourceResponse, RecurringScheduleConfig, RelativeScheduleConfig, RelativeScheduleItem, ResourceDefinition$1 as ResourceDefinition, ResourceDomain, ResourceErrorsResponse, ResourceExecutionSummary, ResourceExecutionsResponse, ResourceHealth, ResourceIdentifier, ResourceStats, ResourceStatus$1 as ResourceStatus, ResourceType$1 as ResourceType, ResourcesHealthResponse, SerializedAgentDefinition, SerializedExecutionInterface, SerializedWorkflowDefinition, SessionCalibrationResult, SessionDTO, SessionTokenUsage, SingleCalibrationResult, StatsTimeRange, SupabaseUserProfile, Task, TaskSchedule, TaskScheduleConfig, TaskStatus, TimeRange, WorkflowNodeVisualizerData as TimelineData, UpdateCalibrationProjectInput, UpdateWebhookEndpointRequest, UserConfig, WebhookEndpoint, WebhookEndpointResponse };