@elevasis/ui 2.17.2 → 2.19.0

package/dist/types/index.d.ts

@@ -1,10 +1,16 @@
 import { z } from 'zod';
 
+/**
+ * Error categories for observability grouping and classification.
+ * Used to categorize errors in the execution_errors table metadata.
+ */
+type ExecutionErrorCategory = 'llm' | 'tool' | 'workflow' | 'agent' | 'validation' | 'system';
+
 /**
  * Workflow-specific logging types and utilities
  */
 
-interface WorkflowExecutionContext$1 {
+interface WorkflowExecutionContext {
     type: 'workflow';
     contextType: 'workflow-execution';
     executionId: string;
@@ -13,14 +19,14 @@ interface WorkflowExecutionContext$1 {
     organizationId: string;
     executionPath?: string[];
 }
-interface WorkflowFailureContext$1 {
+interface WorkflowFailureContext {
     type: 'workflow';
     contextType: 'workflow-failure';
     executionId: string;
     workflowId: string;
     error: string;
 }
-interface StepStartedContext$1 {
+interface StepStartedContext {
     type: 'workflow';
     contextType: 'step-started';
     stepId: string;
@@ -28,7 +34,7 @@ interface StepStartedContext$1 {
     input: unknown;
     startTime: number;
 }
-interface StepCompletedContext$1 {
+interface StepCompletedContext {
     type: 'workflow';
     contextType: 'step-completed';
     stepId: string;
@@ -39,7 +45,7 @@ interface StepCompletedContext$1 {
     startTime: number;
     endTime: number;
 }
-interface StepFailedContext$1 {
+interface StepFailedContext {
     type: 'workflow';
     contextType: 'step-failed';
     stepId: string;
@@ -49,24 +55,24 @@ interface StepFailedContext$1 {
     startTime: number;
     endTime: number;
 }
-interface ConditionalRouteContext$1 {
+interface ConditionalRouteContext {
     type: 'workflow';
     contextType: 'conditional-route';
     stepId: string;
     target: string;
     error?: string;
 }
-interface ExecutionPathContext$1 {
+interface ExecutionPathContext {
     type: 'workflow';
     contextType: 'execution-path';
     executionPath: string[];
 }
-type WorkflowLogContext$1 = WorkflowExecutionContext$1 | WorkflowFailureContext$1 | StepStartedContext$1 | StepCompletedContext$1 | StepFailedContext$1 | ConditionalRouteContext$1 | ExecutionPathContext$1;
+type WorkflowLogContext = WorkflowExecutionContext | WorkflowFailureContext | StepStartedContext | StepCompletedContext | StepFailedContext | ConditionalRouteContext | ExecutionPathContext;
 interface WorkflowLogMessage {
-    level: ExecutionLogLevel$1;
+    level: ExecutionLogLevel;
     message: string;
     timestamp: number;
-    context?: WorkflowLogContext$1;
+    context?: WorkflowLogContext;
 }
 
 /**
@@ -82,26 +88,26 @@ interface WorkflowLogMessage {
  * Agent lifecycle stages
  * Universal checkpoints that apply to all agent executions
  */
-type AgentLifecycle$1 = 'initialization' | 'iteration' | 'completion';
+type AgentLifecycle = 'initialization' | 'iteration' | 'completion';
 /**
  * Iteration event types
  * Activities that occur during agent iterations
  */
-type IterationEventType$1 = 'reasoning' | 'action' | 'tool-call';
+type IterationEventType = 'reasoning' | 'action' | 'tool-call';
 /**
  * Base fields shared by all lifecycle events
  */
-interface AgentLifecycleEventBase$1 {
+interface AgentLifecycleEventBase {
     type: 'agent';
     agentId: string;
-    lifecycle: AgentLifecycle$1;
+    lifecycle: AgentLifecycle;
     sessionId?: string;
 }
 /**
  * Lifecycle started event - emitted when a phase begins
  * REQUIRED: startTime (phase has started, no end yet)
  */
-interface AgentLifecycleStartedEvent$1 extends AgentLifecycleEventBase$1 {
+interface AgentLifecycleStartedEvent extends AgentLifecycleEventBase {
     stage: 'started';
     startTime: number;
     iteration?: number;
@@ -110,7 +116,7 @@ interface AgentLifecycleStartedEvent$1 extends AgentLifecycleEventBase$1 {
  * Lifecycle completed event - emitted when a phase succeeds
  * REQUIRED: startTime, endTime, duration (phase has finished successfully)
  */
-interface AgentLifecycleCompletedEvent$1 extends AgentLifecycleEventBase$1 {
+interface AgentLifecycleCompletedEvent extends AgentLifecycleEventBase {
     stage: 'completed';
     startTime: number;
     endTime: number;
@@ -126,7 +132,7 @@ interface AgentLifecycleCompletedEvent$1 extends AgentLifecycleEventBase$1 {
  * Lifecycle failed event - emitted when a phase fails
  * REQUIRED: startTime, endTime, duration, error (phase has finished with error)
  */
-interface AgentLifecycleFailedEvent$1 extends AgentLifecycleEventBase$1 {
+interface AgentLifecycleFailedEvent extends AgentLifecycleEventBase {
     stage: 'failed';
     startTime: number;
     endTime: number;
@@ -138,23 +144,23 @@ interface AgentLifecycleFailedEvent$1 extends AgentLifecycleEventBase$1 {
  * Union type for all lifecycle events
  * Discriminated by 'stage' field for type narrowing
  */
-type AgentLifecycleEvent$1 = AgentLifecycleStartedEvent$1 | AgentLifecycleCompletedEvent$1 | AgentLifecycleFailedEvent$1;
+type AgentLifecycleEvent = AgentLifecycleStartedEvent | AgentLifecycleCompletedEvent | AgentLifecycleFailedEvent;
 /**
  * Placeholder data for MVP
  * Will be typed per actionType in future
  */
-interface ActionPlaceholderData$1 {
+interface ActionPlaceholderData {
     message: string;
 }
 /**
  * Iteration event - captures activities during agent iterations
  * Consolidates reasoning (LLM thought process) and actions (tool use, memory ops, etc.)
  */
-interface AgentIterationEvent$1 {
+interface AgentIterationEvent {
     type: 'agent';
     agentId: string;
     lifecycle: 'iteration';
-    eventType: IterationEventType$1;
+    eventType: IterationEventType;
     iteration: number;
     sessionId?: string;
     startTime: number;
@@ -162,13 +168,13 @@ interface AgentIterationEvent$1 {
     duration: number;
     output?: string;
     actionType?: string;
-    data?: ActionPlaceholderData$1;
+    data?: ActionPlaceholderData;
 }
 /**
  * Tool call event - captures individual tool executions during iterations
  * Provides granular timing for each tool invocation
  */
-interface AgentToolCallEvent$1 {
+interface AgentToolCallEvent {
     type: 'agent';
     agentId: string;
     lifecycle: 'iteration';
@@ -188,19 +194,19 @@ interface AgentToolCallEvent$1 {
  * Union type for all agent log contexts
  * 3 event types total (lifecycle, iteration, tool-call)
  */
-type AgentLogContext$1 = AgentLifecycleEvent$1 | AgentIterationEvent$1 | AgentToolCallEvent$1;
+type AgentLogContext = AgentLifecycleEvent | AgentIterationEvent | AgentToolCallEvent;
 
 /**
  * Base execution logger for Execution Engine
  */
-type ExecutionLogLevel$1 = 'debug' | 'info' | 'warn' | 'error';
+type ExecutionLogLevel = 'debug' | 'info' | 'warn' | 'error';
 
-type LogContext$1 = WorkflowLogContext$1 | AgentLogContext$1;
-interface ExecutionLogMessage$1 {
-    level: ExecutionLogLevel$1;
+type LogContext = WorkflowLogContext | AgentLogContext;
+interface ExecutionLogMessage {
+    level: ExecutionLogLevel;
     message: string;
     timestamp: number;
-    context?: LogContext$1;
+    context?: LogContext;
 }
 
 /**
@@ -211,7 +217,125 @@ interface ExecutionLogMessage$1 {
  * Supported form field types for action payloads
  * Maps to Mantine form components
  */
-type FormFieldType$1 = 'text' | 'textarea' | 'number' | 'select' | 'checkbox' | 'radio' | 'richtext';
+type FormFieldType = 'text' | 'textarea' | 'number' | 'select' | 'checkbox' | 'radio' | 'richtext';
+/**
+ * Form field definition
+ */
+interface FormField {
+    /** Field key in payload object */
+    name: string;
+    /** Field label for UI */
+    label: string;
+    /** Field type (determines UI component) */
+    type: FormFieldType;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Required field */
+    required?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Help text */
+    description?: string;
+    /** Options for select/radio */
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    /** Min/max for number */
+    min?: number;
+    max?: number;
+    /** Path to context value for pre-filling (dot notation, e.g., 'proposal.summary') */
+    defaultValueFromContext?: string;
+}
+/**
+ * Form schema for action payload collection
+ */
+interface FormSchema {
+    /** Form title */
+    title?: string;
+    /** Form description */
+    description?: string;
+    /** Form fields */
+    fields: FormField[];
+}
+
+/**
+ * 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.
+ */
+
+/**
+ * Extended agent metadata for Command View
+ * Includes model and capability information for graph display
+ */
+interface CommandViewAgent extends ResourceDefinition {
+    type: 'agent';
+    modelProvider: string;
+    modelId: string;
+    toolCount: number;
+    hasKnowledgeMap: boolean;
+    hasMemory: boolean;
+    sessionCapable: boolean;
+}
+/**
+ * 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;
+/**
+ * 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;
+    target: string;
+    relationship: RelationshipType;
+    label?: string;
+}
+/**
+ * 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
@@ -223,10 +347,10 @@ type FormFieldType$1 = 'text' | 'textarea' | 'number' | 'select' | 'checkbox' |
 /**
  * Serialized form field for API responses
  */
-interface SerializedFormField$1 {
+interface SerializedFormField {
     name: string;
     label: string;
-    type: FormFieldType$1;
+    type: FormFieldType;
     defaultValue?: unknown;
     required?: boolean;
     placeholder?: string;
@@ -241,16 +365,16 @@ interface SerializedFormField$1 {
 /**
  * Serialized form schema for API responses
  */
-interface SerializedFormSchema$1 {
+interface SerializedFormSchema {
     title?: string;
     description?: string;
-    fields: SerializedFormField$1[];
+    fields: SerializedFormField[];
     layout?: 'vertical' | 'horizontal' | 'grid';
 }
 /**
  * Serialized execution form schema for API responses
  */
-interface SerializedExecutionFormSchema$1 extends SerializedFormSchema$1 {
+interface SerializedExecutionFormSchema extends SerializedFormSchema {
     fieldMappings?: Record<string, string>;
     submitButton?: {
         label?: string;
@@ -261,7 +385,7 @@ interface SerializedExecutionFormSchema$1 extends SerializedFormSchema$1 {
 /**
  * Serialized schedule config for API responses
  */
-interface SerializedScheduleConfig$1 {
+interface SerializedScheduleConfig {
     enabled: boolean;
     defaultSchedule?: string;
     allowedPatterns?: string[];
@@ -269,23 +393,23 @@ interface SerializedScheduleConfig$1 {
 /**
  * Serialized webhook config for API responses
  */
-interface SerializedWebhookConfig$1 {
+interface SerializedWebhookConfig {
     enabled: boolean;
     payloadSchema?: unknown;
 }
 /**
  * Serialized execution interface for API responses
  */
-interface SerializedExecutionInterface$1 {
-    form: SerializedExecutionFormSchema$1;
-    schedule?: SerializedScheduleConfig$1;
-    webhook?: SerializedWebhookConfig$1;
+interface SerializedExecutionInterface {
+    form: SerializedExecutionFormSchema;
+    schedule?: SerializedScheduleConfig;
+    webhook?: SerializedWebhookConfig;
 }
 /**
  * Serialized agent definition (JSON-safe)
  * Result of serializeDefinition(AgentDefinition)
  */
-interface SerializedAgentDefinition$1 {
+interface SerializedAgentDefinition {
     config: {
         resourceId: string;
         name: string;
@@ -334,13 +458,13 @@ interface SerializedAgentDefinition$1 {
         }>;
     };
     metricsConfig?: object;
-    interface?: SerializedExecutionInterface$1;
+    interface?: SerializedExecutionInterface;
 }
 /**
  * Serialized workflow definition (JSON-safe)
  * Result of serializeDefinition(WorkflowDefinition)
  */
-interface SerializedWorkflowDefinition$1 {
+interface SerializedWorkflowDefinition {
     config: {
         resourceId: string;
         name: string;
@@ -372,7 +496,105 @@ interface SerializedWorkflowDefinition$1 {
         outputSchema?: object;
     };
     metricsConfig?: object;
-    interface?: SerializedExecutionInterface$1;
+    interface?: SerializedExecutionInterface;
+}
+
+/**
+ * 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
+ */
+
+/**
+ * Supported Open AI models (direct SDK access)
+ */
+type OpenAIModel = 'gpt-5' | 'gpt-5.4-mini' | 'gpt-5.4-nano';
+/**
+ * Supported OpenRouter models (explicit union for type safety)
+ */
+type OpenRouterModel = 'openrouter/z-ai/glm-5';
+/**
+ * Supported Google models (direct SDK access)
+ */
+type GoogleModel = 'gemini-3-flash-preview' | 'gemini-3.1-flash-lite-preview';
+/**
+ * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
+ */
+type AnthropicModel = 'claude-sonnet-4-5';
+/** Supported LLM models */
+type LLMModel = OpenAIModel | OpenRouterModel | GoogleModel | AnthropicModel | 'mock';
+/**
+ * GPT-5 model options schema
+ */
+declare const GPT5OptionsSchema: z.ZodObject<{
+    reasoning_effort: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+}, z.core.$strip>;
+/**
+ * OpenRouter model options schema
+ * OpenRouter-specific options for routing and transforms
+ */
+declare const OpenRouterOptionsSchema: z.ZodObject<{
+    transforms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    route: z.ZodOptional<z.ZodEnum<{
+        fallback: "fallback";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Google model options schema
+ * Gemini 3 specific options for thinking depth control
+ */
+declare const GoogleOptionsSchema: z.ZodObject<{
+    thinkingLevel: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Anthropic model options schema
+ * Currently empty - future options: budget_tokens for extended thinking
+ */
+declare const AnthropicOptionsSchema: z.ZodObject<{}, z.core.$strip>;
+/**
+ * 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;
+/**
+ * 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;
+    /**
+     * 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;
 }
 
 /**
@@ -410,13 +632,13 @@ interface WorkflowNodeVisualizerData {
  * Use-case agnostic types that describe the purpose of each entry
  * Memory types mirror action types for clarity and filtering
  */
-type MemoryEntryType$1 = 'context' | 'input' | 'reasoning' | 'tool-result' | 'delegation-result' | 'error';
+type MemoryEntryType = '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$1 {
-    type: MemoryEntryType$1;
+interface MemoryEntry {
+    type: MemoryEntryType;
     content: string;
     timestamp: number;
     turnNumber: number | null;
@@ -426,20 +648,20 @@ interface MemoryEntry$1 {
  * Agent memory - Self-orchestrated memory with session + working storage
  * Agent has full control over what persists, framework handles auto-compaction
  */
-interface AgentMemory$1 {
+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$1>;
+    sessionMemory: Record<string, MemoryEntry>;
     /**
      * Working memory - Execution history
      * Automatically compacted by framework when needed
      * Agent doesn't control compaction
      */
-    history: MemoryEntry$1[];
+    history: MemoryEntry[];
 }
 
 type Json = string | number | boolean | null | {
@@ -3097,6 +3319,62 @@ type SupabaseApiKey = Tables<'api_keys'>;
 /** API response type for API key list items (omits sensitive key_hash) */
 type ApiKeyListItem = Omit<SupabaseApiKey, 'key_hash'>;
 
+/**
+ * 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[];
+    startTime?: number;
+    endTime?: number;
+}
+/**
+ * Agent lifecycle node state
+ * Represents initialization or completion phase
+ */
+interface AgentLifecycleNode {
+    type: 'initialization' | 'completion';
+    status: 'running' | 'completed' | 'failed' | 'pending';
+    duration?: number;
+    timestamp?: number;
+    startTime?: number;
+    endTime?: number;
+}
+/**
+ * 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';
+}
+
 /** Raw database row type for acq_deals table */
 type AcqDealRow = Database['public']['Tables']['acq_deals']['Row'];
 type DealStage = 'interested' | 'proposal' | 'closing' | 'closed_won' | 'closed_lost' | 'nurturing';
@@ -3131,11 +3409,162 @@ interface DealListItem extends AcqDealRow {
     contact: DealContact | null;
 }
 
+/**
+ * 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$1 = 'agent' | 'workflow' | 'scheduler' | 'api';
+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;
+    actions: ActionConfig[];
+    context: unknown;
+    selectedAction?: string;
+    actionPayload?: unknown;
+    description?: string;
+    priority: number;
+    /** Optional checkpoint identifier for grouping related human approval tasks */
+    humanCheckpoint?: string;
+    status: QueueTaskStatus;
+    /**
+     * 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 QueueTaskStatus = '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;
+}
 
 /**
  * Target for schedule execution - identifies what resource to execute.
@@ -3153,11 +3582,11 @@ interface ScheduleTarget {
  */
 interface ScheduleOriginTracking {
     originExecutionId?: string;
-    originResourceType?: OriginResourceType$1;
+    originResourceType?: OriginResourceType;
     originResourceId?: string;
 }
-type TaskScheduleConfig = RecurringScheduleConfig$1 | RelativeScheduleConfig$1 | AbsoluteScheduleConfig$1;
-interface RecurringScheduleConfig$1 {
+type TaskScheduleConfig = RecurringScheduleConfig | RelativeScheduleConfig | AbsoluteScheduleConfig;
+interface RecurringScheduleConfig {
     type: 'recurring';
     cron?: string;
     interval?: 'daily' | 'weekly' | 'monthly';
@@ -3167,24 +3596,24 @@ interface RecurringScheduleConfig$1 {
     endAt?: string | null;
     overduePolicy?: 'skip' | 'execute';
 }
-interface RelativeScheduleConfig$1 {
+interface RelativeScheduleConfig {
     type: 'relative';
     anchorAt: string;
     anchorLabel?: string;
-    items: RelativeScheduleItem$1[];
+    items: RelativeScheduleItem[];
     overduePolicy?: 'skip' | 'execute';
 }
-interface RelativeScheduleItem$1 {
+interface RelativeScheduleItem {
     offset: string;
     payload: Record<string, unknown>;
     label?: string;
 }
-interface AbsoluteScheduleConfig$1 {
+interface AbsoluteScheduleConfig {
     type: 'absolute';
-    items: AbsoluteScheduleItem$1[];
+    items: AbsoluteScheduleItem[];
     overduePolicy?: 'skip' | 'execute';
 }
-interface AbsoluteScheduleItem$1 {
+interface AbsoluteScheduleItem {
     runAt: string;
     payload: Record<string, unknown>;
     label?: string;
@@ -3207,6 +3636,24 @@ interface TaskSchedule extends ScheduleOriginTracking {
     updatedAt: Date;
 }
 
+/**
+ * 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;
+}
+
 type MessageType = MessageEvent['type'];
 /**
  * Session Data Transfer Object (DTO)
@@ -3221,7 +3668,7 @@ interface SessionDTO {
     turnCount: number;
     isEnded: boolean;
     title?: string | null;
-    memorySnapshot?: AgentMemory$1;
+    memorySnapshot?: AgentMemory;
     metadata?: Record<string, unknown> | null;
     createdAt: Date;
     updatedAt: Date;
@@ -3364,100 +3811,454 @@ interface MembershipWithDetails extends OrganizationMembership {
     config?: MembershipFeatureConfig;
 }
 
-/**
- * Base Execution Engine type definitions
- * Core types shared across all Execution Engine resources
- */
+interface OAuthToken extends Record<string, unknown> {
+    provider: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: string;
+    tokenType: 'Bearer';
+    scope?: string;
+}
+interface OAuthProviderConfig {
+    id: string;
+    name: string;
+    authUrl: string;
+    tokenUrl: string;
+    scopes?: string[];
+    authParams?: Record<string, string>;
+    tokenExchange: 'basic-auth' | 'form-encoded' | 'json-body';
+    usePKCE?: boolean;
+    customAuthFlow?: (config: OAuthProviderConfig, state: OAuthState) => URL;
+    customTokenExchange?: (code: string, config: OAuthProviderConfig) => Promise<OAuthToken>;
+}
+interface OAuthState {
+    organizationId: string;
+    nonce: string;
+    timestamp: number;
+    credentialName: string;
+    provider: string;
+}
 
-/**
- * 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 = {
-    type: 'user_message';
-    text: string;
-} | {
-    type: 'assistant_message';
-    text: string;
-    _action?: AssistantAction;
-} | {
-    type: 'agent:started';
-} | {
-    type: 'agent:completed';
-} | {
-    type: 'agent:error';
-    error: string;
-} | {
-    type: 'agent:reasoning';
+interface BaseAICall {
+    callSequence: number;
+    callType: 'agent-reasoning' | 'agent-completion' | 'workflow-step' | 'tool' | 'other';
+    model: LLMModel;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    context?: AICallContext;
+}
+type AICallContext = AgentReasoningContext | AgentCompletionContext | WorkflowStepContext | ToolCallContext | OtherCallContext;
+interface AgentReasoningContext {
+    type: 'agent-reasoning';
     iteration: number;
-    reasoning: string;
-} | {
-    type: 'agent:tool_call';
-    toolName: string;
-    args: Record<string, unknown>;
-} | {
-    type: 'agent:tool_result';
+    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;
-    success: boolean;
-    result?: unknown;
-    error?: string;
-};
+    parentIteration?: number;
+    parentStepId?: string;
+}
+interface OtherCallContext {
+    type: 'other';
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+type AICallRecord = BaseAICall;
 /**
- * NOTE: AIResource interface has been removed and replaced with ResourceDefinition
- * from registry/types.ts. All resources (executable and non-executable) now extend
- * the unified ResourceDefinition base interface.
- *
- * AgentConfig and WorkflowConfig now extend ResourceDefinition directly.
- * See packages/core/src/registry/types.ts for the base interface definition.
+ * Time range selector for dashboard metrics
  */
-type AIResourceDefinition = SerializedWorkflowDefinition$1 | SerializedAgentDefinition$1;
-
+type TimeRange = '1h' | '24h' | '7d' | '30d';
 /**
- * Resource Registry type definitions
+ * Execution health metrics response
+ * Success rate, P95 duration, execution counts, and trend data
+ * trendData includes executionCount for throughput visualization (eliminates separate API call)
  */
-
+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';
+}
 /**
- * Environment/deployment status for resources
+ * Error analysis metrics response
+ * Error categories and top failing resources
  */
-type ResourceStatus$1 = 'dev' | 'prod';
+interface ErrorAnalysisMetrics {
+    totalErrors: number;
+    errorsByCategory: Array<{
+        category: string;
+        count: number;
+        percentage: number;
+    }>;
+    topFailingResources: Array<{
+        resourceId: string;
+        name: string;
+        errorCount: number;
+        failureRate: number;
+    }>;
+}
 /**
- * All resource types in the platform
- * Used as the discriminator field in ResourceDefinition
+ * Business impact metrics response
+ * ROI, labor savings, and cost analysis
  */
-type ResourceType$1 = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human';
+interface BusinessImpactMetrics {
+    totalSavingsUsd: number;
+    totalCostUsd: number;
+    netSavingsUsd: number;
+    roi: number;
+}
 /**
- * Base interface for ALL platform resources
- * Shared by both executable (agents, workflows) and non-executable (triggers, integrations, etc.) resources
+ * Cost breakdown metrics response
+ * Per-resource cost analysis
  */
-interface ResourceDefinition$1 {
-    /** Unique resource identifier */
-    resourceId: string;
-    /** Display name */
-    name: string;
+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 record for list view (ErrorBreakdownTable)
+ */
+interface ErrorRecord {
+    id: string;
+    timestamp: string;
+    errorType: string;
+    message: string;
+    executionId: string;
+    resourceId: string;
+    resourceName: string;
+    severity: 'critical' | 'warning' | 'info';
+    category: ExecutionErrorCategory;
+    resolved: boolean;
+    resolvedAt: string | null;
+    resolvedBy: string | null;
+}
+/**
+ * Full error detail for modal view (ErrorDetailsModal)
+ */
+interface ErrorDetailFull extends ErrorRecord {
+    stackTrace?: string;
+    retryAttempt?: number;
+    stepName?: string;
+    stepSequence?: number;
+    errorContext?: Record<string, unknown>;
+    executionContext?: Record<string, unknown>;
+}
+/**
+ * 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;
+    errorCount: number;
+    criticalCount: number;
+    warningCount: number;
+    infoCount: number;
+}
+/**
+ * Failing resource data for health monitoring
+ */
+interface FailingResource {
+    resourceId: string;
+    resourceName: string;
+    errorCount: number;
+    criticalCount: number;
+    warningCount: number;
+    mostCommonError: string;
+}
+/**
+ * Summary of executions for a single resource
+ * Used by RecentExecutionsByResource dashboard component
+ */
+interface ResourceExecutionSummary {
+    resourceId: string;
+    resourceType: string;
+    resourceName: string | null;
+    lastExecution: string;
+    totalExecutions: number;
+    successCount: number;
+    failureCount: number;
+    warningCount: number;
+    successRate: number;
+}
+/**
+ * Response from getRecentExecutionsByResource endpoint
+ */
+interface RecentExecutionsByResourceResponse {
+    resources: ResourceExecutionSummary[];
+}
+/** Resource identifier for health queries */
+interface ResourceIdentifier {
+    entityType: string;
+    entityId: string;
+}
+/** Time-bucketed health data point */
+interface ResourceHealthDataPoint {
+    time: string;
+    success: number;
+    failure: number;
+    warning: number;
+    rate: number;
+}
+/** 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 trend data point for time-series charts
+ * Represents a single time bucket (hour or day)
+ */
+interface CostTrendDataPoint {
+    time: string;
+    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;
+}
+
+/**
+ * Base Execution Engine type definitions
+ * Core types shared across all Execution Engine resources
+ */
+
+/**
+ * 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 = {
+    type: 'user_message';
+    text: string;
+} | {
+    type: 'assistant_message';
+    text: string;
+    _action?: AssistantAction;
+} | {
+    type: 'agent:started';
+} | {
+    type: 'agent:completed';
+} | {
+    type: 'agent:error';
+    error: string;
+} | {
+    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;
+};
+/**
+ * NOTE: AIResource interface has been removed and replaced with ResourceDefinition
+ * from registry/types.ts. All resources (executable and non-executable) now extend
+ * the unified ResourceDefinition base interface.
+ *
+ * AgentConfig and WorkflowConfig now extend ResourceDefinition directly.
+ * See packages/core/src/registry/types.ts for the base interface definition.
+ */
+type AIResourceDefinition = SerializedWorkflowDefinition | SerializedAgentDefinition;
+
+/**
+ * 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-sheets' | 'slack' | 'github' | 'linear' | 'attio' | 'airtable' | 'salesforce' | 'hubspot' | 'stripe' | 'twilio' | 'sendgrid' | 'mailgun' | 'zapier' | 'webhook' | 'apify' | 'instantly' | 'resend' | 'signature-api' | 'dropbox' | 'anymailfinder' | 'tomba' | 'millionverifier';
+
+/**
+ * Resource Registry 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 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$1;
+    type: ResourceType;
     /** Environment/deployment status */
-    status: ResourceStatus$1;
+    status: ResourceStatus;
     /** Domain tags for filtering and organization */
-    domains?: ResourceDomain$1[];
+    domains?: ResourceDomain[];
     /** Whether the agent supports multi-turn sessions (agents only) */
     sessionCapable?: boolean;
     /** Whether the resource is local (monorepo) or remote (externally deployed) */
@@ -3465,13 +4266,247 @@ interface ResourceDefinition$1 {
     /** Whether this resource is archived and should be excluded from registration and deployment */
     archived?: boolean;
 }
+/**
+ * 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;
+}
+/** Webhook provider identifiers */
+type WebhookProviderType = 'cal-com' | 'stripe' | 'signature-api' | 'instantly' | 'apify' | 'test';
+/** 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 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;
+    /** 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;
+}
+/**
+ * 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 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;
+    /** 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[];
+    };
+}
+/**
+ * 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[];
+    };
+}
 
 /**
  * Standard Domain Definitions
  * Centralized domain constants and definitions for all organization resources.
  */
 
-declare const DOMAINS$1: {
+declare const DOMAINS: {
     readonly INBOUND_PIPELINE: "inbound-pipeline";
     readonly LEAD_GEN_PIPELINE: "lead-gen-pipeline";
     readonly SUPPORT: "support";
@@ -3491,22 +4526,73 @@ declare const DOMAINS$1: {
  * ResourceDomain - Strongly typed domain identifier
  * Use this type for all domain references to ensure compile-time validation.
  */
-type ResourceDomain$1 = (typeof DOMAINS$1)[keyof typeof DOMAINS$1];
+type ResourceDomain = (typeof DOMAINS)[keyof typeof DOMAINS];
 
-type ExecutionStatus$1 = 'pending' | 'running' | 'completed' | 'failed' | 'warning';
-interface APIExecutionSummary$1 {
+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 ExecutionLogEvent {
+    type: 'log';
+    resourceId: string;
+    executionId: string;
+    timestamp: number;
+    data: {
+        log: ExecutionLogMessage;
+    };
+}
+/**
+ * Event sent when execution completes (success or failure)
+ */
+interface ExecutionCompleteEvent {
+    type: 'execution-complete';
+    resourceId: string;
+    executionId: string;
+    timestamp: number;
+    data: {
+        success: boolean;
+        status?: ExecutionStatus;
+        result?: unknown;
+        error?: string;
+    };
+}
+/**
+ * Connection confirmation event
+ */
+interface ExecutionConnectedEvent {
+    type: 'connected';
+    resourceId: string;
+    executionId?: undefined;
+    timestamp: number;
+    data?: undefined;
+}
+/**
+ * Union of all execution SSE events
+ */
+type ExecutionSSEEvent = ExecutionStartedEvent | ExecutionLogEvent | ExecutionCompleteEvent | ExecutionConnectedEvent;
+interface APIExecutionSummary {
     id: string;
-    status: ExecutionStatus$1;
+    status: ExecutionStatus;
     startTime: number;
     endTime?: number;
-    resourceStatus?: ResourceStatus$1;
+    resourceStatus?: ResourceStatus;
 }
-interface APIExecutionDetail extends APIExecutionSummary$1 {
-    executionLogs: ExecutionLogMessage$1[];
+interface APIExecutionDetail extends APIExecutionSummary {
+    executionLogs: ExecutionLogMessage[];
     input?: unknown;
     result?: unknown;
     error?: string;
-    resourceStatus: ResourceStatus$1;
+    resourceStatus: ResourceStatus;
     apiVersion?: string | null;
     resourceVersion?: string | null;
     sdkVersion?: string | null;
@@ -3514,8 +4600,188 @@ interface APIExecutionDetail extends APIExecutionSummary$1 {
     archivedLogCount?: number;
 }
 interface APIExecutionListResponse {
-    executions: APIExecutionSummary$1[];
+    executions: APIExecutionSummary[];
+    total?: number;
+    limit?: number;
+    offset?: number;
+    hasMore?: boolean;
+}
+
+/**
+ * @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;
+    warningCount: number;
+    lastRunAt: string | null;
+}
+/** Response from /command-view/resource-errors (on-demand) */
+interface ResourceErrorsResponse {
+    resourceId: string;
+    errors: ErrorSummary[];
+    totalErrors: number;
+    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;
+}
+/** Response from /command-view/resource-executions (on-demand) */
+interface ResourceExecutionsResponse {
+    resourceId: string;
+    executions: CommandViewExecution[];
+    totalExecutions: number;
+    timeRange: StatsTimeRange;
+    page: number;
+    limit: number;
+}
+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;
+}
+
+/**
+ * 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' | 'hitl_action' | 'webhook_received' | 'webhook_executed' | 'webhook_failed' | 'credential_change' | 'api_key_change' | 'deployment_change' | 'membership_change';
+type ActivityStatus = 'success' | 'failure' | 'pending' | 'approved' | 'rejected' | 'completed';
+interface Activity {
+    id: string;
+    organizationId: string;
+    activityType: ActivityType;
+    status: ActivityStatus;
+    title: string;
+    description: string | null;
+    entityType: string;
+    entityId: string;
+    entityName: string | null;
+    metadata: Record<string, unknown> | null;
+    actorId: string | null;
+    actorType: string | null;
+    occurredAt: Date;
+    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;
+
+/**
+ * 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;
 
 /**
  * Execution Runner Types
@@ -3524,6 +4790,11 @@ interface APIExecutionListResponse {
  * Used by both API (apps/api) and frontend (apps/command-center).
  */
 
+interface ExecutionMetrics {
+    tokenCount?: number;
+    stepCount?: number;
+    toolCallCount?: number;
+}
 interface ExecutionRunnerCatalogItem {
     resourceId: string;
     resourceName: string;
@@ -3531,9 +4802,68 @@ interface ExecutionRunnerCatalogItem {
     description?: string;
     status: 'dev' | 'prod';
     version: string;
-    interface: SerializedExecutionInterface$1;
+    interface: SerializedExecutionInterface;
+}
+interface ExecutionSummary {
+    id: string;
+    resourceId: string;
+    resourceName: string;
+    status: ExecutionStatus;
+    startedAt: string;
+    completedAt?: string;
+    durationMs?: number;
+    metrics?: ExecutionMetrics;
+    input?: unknown;
+    output?: unknown;
+    error?: {
+        message: string;
+    };
 }
 
+/**
+ * Execution history item.
+ * Represents a single execution triggered by a schedule.
+ */
+declare const ExecutionHistoryItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        running: "running";
+        cancelled: "cancelled";
+    }>;
+    step: z.ZodNullable<z.ZodNumber>;
+    itemLabel: z.ZodNullable<z.ZodString>;
+    duration: z.ZodNullable<z.ZodNumber>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Execution history response.
+ * Returned by GET /schedules/:id/executions with pagination.
+ */
+declare const ExecutionHistoryResponseSchema: z.ZodObject<{
+    executions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            running: "running";
+            cancelled: "cancelled";
+        }>;
+        step: z.ZodNullable<z.ZodNumber>;
+        itemLabel: z.ZodNullable<z.ZodString>;
+        duration: z.ZodNullable<z.ZodNumber>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+type ExecutionHistoryItem = z.infer<typeof ExecutionHistoryItemSchema>;
+type ExecutionHistoryResponse = z.infer<typeof ExecutionHistoryResponseSchema>;
+
 /**
  * Deployment types — browser-safe
  *
@@ -3555,2350 +4885,141 @@ interface Deployment {
     updatedAt: string;
 }
 
-/**
- * Workflow-specific logging types and utilities
- */
-
-
-
-// Workflow start/end log context
-interface WorkflowExecutionContext {
-  type: 'workflow'
-  contextType: 'workflow-execution'
-  executionId: string
-  workflowId: string
-  workflowName?: string
-  organizationId: string
-  executionPath?: string[]
-}
-
-// Workflow failure log context
-interface WorkflowFailureContext {
-  type: 'workflow'
-  contextType: 'workflow-failure'
-  executionId: string
-  workflowId: string
-  error: string
-}
-
-// Step started log context
-interface StepStartedContext {
-  type: 'workflow'
-  contextType: 'step-started'
-  stepId: string
-  stepStatus: 'started'
-  input: unknown
-  startTime: number // Explicit start timestamp for timeline
-}
-
-// Step completed log context
-interface StepCompletedContext {
-  type: 'workflow'
-  contextType: 'step-completed'
-  stepId: string
-  stepStatus: 'completed'
-  output: unknown
-  duration: number
-  isTerminal: boolean
-  startTime: number // Explicit start timestamp for timeline
-  endTime: number // Explicit end timestamp for timeline
-}
-
-// Step failed log context
-interface StepFailedContext {
-  type: 'workflow'
-  contextType: 'step-failed'
-  stepId: string
-  stepStatus: 'failed'
-  error: string
-  duration: number
-  startTime: number // Explicit start timestamp for timeline
-  endTime: number // Explicit end timestamp for timeline
-}
-
-// Conditional routing log context
-interface ConditionalRouteContext {
-  type: 'workflow'
-  contextType: 'conditional-route'
-  stepId: string
-  target: string
-  error?: string
-}
-
-// Execution path log context
-interface ExecutionPathContext {
-  type: 'workflow'
-  contextType: 'execution-path'
-  executionPath: string[]
-}
-
-// Union of all workflow log contexts
-type WorkflowLogContext =
-  | WorkflowExecutionContext
-  | WorkflowFailureContext
-  | StepStartedContext
-  | StepCompletedContext
-  | StepFailedContext
-  | ConditionalRouteContext
-  | ExecutionPathContext
-
-/**
- * Agent-specific logging types
- * Simplified 2-event model: lifecycle, iteration
- *
- * Design Philosophy:
- * - LIFECYCLE EVENTS: Structural checkpoints (initialization, iteration, completion)
- * - ITERATION EVENTS: Execution activities (reasoning, actions during iterations)
- */
-
-
-
-// ============================================================================
-// FORMAL TYPES
-// ============================================================================
-
-/**
- * Agent lifecycle stages
- * Universal checkpoints that apply to all agent executions
- */
-type AgentLifecycle = 'initialization' | 'iteration' | 'completion'
-
-/**
- * Iteration event types
- * Activities that occur during agent iterations
- */
-type IterationEventType = 'reasoning' | 'action' | 'tool-call'
-
-// ============================================================================
-// LIFECYCLE EVENTS (Structural Checkpoints)
-// ============================================================================
-
-/**
- * Base fields shared by all lifecycle events
- */
-interface AgentLifecycleEventBase {
-  type: 'agent'
-  agentId: string
-  lifecycle: AgentLifecycle
-  sessionId?: string // Optional: only present when agent runs in session context
-}
-
-/**
- * Lifecycle started event - emitted when a phase begins
- * REQUIRED: startTime (phase has started, no end yet)
- */
-interface AgentLifecycleStartedEvent extends AgentLifecycleEventBase {
-  stage: 'started'
-  startTime: number // REQUIRED: Phase start timestamp
-  iteration?: number // Only for 'iteration' lifecycle
-}
-
-/**
- * Lifecycle completed event - emitted when a phase succeeds
- * REQUIRED: startTime, endTime, duration (phase has finished successfully)
- */
-interface AgentLifecycleCompletedEvent extends AgentLifecycleEventBase {
-  stage: 'completed'
-  startTime: number // REQUIRED: Phase start timestamp
-  endTime: number // REQUIRED: Phase end timestamp
-  duration: number // REQUIRED: Calculated duration (endTime - startTime)
-  iteration?: number // Only for 'iteration' lifecycle
-
-  // Optional fields specific to certain lifecycles
-  attempts?: number // Only for 'completion' lifecycle (tracks output generation attempts: 1 or 2)
-  memorySize?: {
-    sessionMemoryKeys: number
-    historyEntries: number
-  } // Only for 'completion' lifecycle (memory snapshot metadata)
-}
-
-/**
- * Lifecycle failed event - emitted when a phase fails
- * REQUIRED: startTime, endTime, duration, error (phase has finished with error)
- */
-interface AgentLifecycleFailedEvent extends AgentLifecycleEventBase {
-  stage: 'failed'
-  startTime: number // REQUIRED: Phase start timestamp
-  endTime: number // REQUIRED: Phase end timestamp
-  duration: number // REQUIRED: Calculated duration (endTime - startTime)
-  error: string // REQUIRED: Error message
-  iteration?: number // Only for 'iteration' lifecycle
-}
-
-/**
- * Union type for all lifecycle events
- * Discriminated by 'stage' field for type narrowing
- */
-type AgentLifecycleEvent = AgentLifecycleStartedEvent | AgentLifecycleCompletedEvent | AgentLifecycleFailedEvent
-
-// ============================================================================
-// ITERATION EVENTS (Execution Activities)
-// ============================================================================
-
-/**
- * Placeholder data for MVP
- * Will be typed per actionType in future
- */
-interface ActionPlaceholderData {
-  message: string
-}
-
-/**
- * Iteration event - captures activities during agent iterations
- * Consolidates reasoning (LLM thought process) and actions (tool use, memory ops, etc.)
- */
-interface AgentIterationEvent {
-  type: 'agent'
-  agentId: string
-  lifecycle: 'iteration' // Always iteration
-  eventType: IterationEventType
-  iteration: number
-  sessionId?: string // Optional: only present when agent runs in session context
-
-  // Timeline timing fields (v2 - Clean Break)
-  startTime: number // Activity start timestamp
-  endTime: number // Activity end timestamp
-  duration: number // Calculated duration (endTime - startTime)
-
-  // Conditional fields based on eventType
-  output?: string // For reasoning events
-  actionType?: string // For action events (tool-use, delegate, memory-write, etc.)
-  data?: ActionPlaceholderData // For action events
-}
-
-/**
- * Tool call event - captures individual tool executions during iterations
- * Provides granular timing for each tool invocation
- */
-interface AgentToolCallEvent {
-  type: 'agent'
-  agentId: string
-  lifecycle: 'iteration' // Always iteration
-  eventType: 'tool-call' // Specific event type for tool calls
-  iteration: number
-  sessionId?: string // Optional: only present when agent runs in session context
-
-  // Tool identification and timing
-  toolName: string // Tool identifier
-  startTime: number // Tool call start timestamp
-  endTime: number // Tool call end timestamp
-  duration: number // Calculated duration
-
-  // Execution results
-  success: boolean // Whether tool execution succeeded
-  error?: string // Error message if failed
-  input?: Record<string, unknown> // Tool input parameters
-  output?: unknown // Tool output result
-}
-
-// ============================================================================
-// UNION TYPES
-// ============================================================================
-
-/**
- * Union type for all agent log contexts
- * 3 event types total (lifecycle, iteration, tool-call)
- */
-type AgentLogContext = AgentLifecycleEvent | AgentIterationEvent | AgentToolCallEvent
-
-/**
- * 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
-}
-
-/**
- * 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
-  | 'textarea'   // Textarea
-  | 'number'     // NumberInput
-  | 'select'     // Select dropdown
-  | 'checkbox'   // Checkbox
-  | 'radio'      // Radio group
-  | 'richtext'   // Rich text editor (TipTap)
-
-/**
- * Form field definition
- */
-interface FormField {
-  /** Field key in payload object */
-  name: string
-
-  /** Field label for UI */
-  label: string
-
-  /** Field type (determines UI component) */
-  type: FormFieldType
-
-  /** Default value */
-  defaultValue?: unknown
-
-  /** Required field */
-  required?: boolean
-
-  /** Placeholder text */
-  placeholder?: string
-
-  /** Help text */
-  description?: string
-
-  /** Options for select/radio */
-  options?: Array<{
-    label: string
-    value: string | number
-  }>
-
-  /** Min/max for number */
-  min?: number
-  max?: number
-
-  /** Path to context value for pre-filling (dot notation, e.g., 'proposal.summary') */
-  defaultValueFromContext?: string
-}
-
-/**
- * Form schema for action payload collection
- */
-interface FormSchema {
-  /** Form title */
-  title?: string
-
-  /** Form description */
-  description?: string
-
-  /** Form fields */
-  fields: FormField[]
-}
-
-/**
- * Error categories for observability grouping and classification.
- * Used to categorize errors in the execution_errors table metadata.
- */
-type ExecutionErrorCategory = 'llm' | 'tool' | 'workflow' | 'agent' | 'validation' | 'system'
-
-/**
- * Memory type definitions
- * Types for agent memory management with semantic entry types
- */
-
-/**
- * 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 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.)
-
-/**
- * Memory entry - represents a single entry in agent memory
- * Stored in agent memory, translated by adapters to vendor-specific formats
- */
-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)
-}
-
-/**
- * Agent memory - Self-orchestrated memory with session + working storage
- * Agent has full control over what persists, framework handles auto-compaction
- */
-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[]
-}
-
-/**
- * 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
- */
-
-
-
-// ============================================================================
-// Model Types
-// ============================================================================
-
-/**
- * Supported Open AI models (direct SDK access)
- */
-type OpenAIModel = 'gpt-5' | 'gpt-5.4-mini' | 'gpt-5.4-nano'
-
-/**
- * Supported OpenRouter models (explicit union for type safety)
- */
-type OpenRouterModel = 'openrouter/z-ai/glm-5'
-
-/**
- * Supported Google models (direct SDK access)
- */
-type GoogleModel = 'gemini-3-flash-preview' | 'gemini-3.1-flash-lite-preview'
-
-/**
- * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
- */
-type AnthropicModel = 'claude-sonnet-4-5'
-
-/** Supported LLM models */
-type LLMModel = OpenAIModel | OpenRouterModel | GoogleModel | AnthropicModel | 'mock'
-
-// ============================================================================
-// Model Configuration Schemas (Schema-First - Single Source of Truth)
-// ============================================================================
-
-/**
- * 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()
-})
-
-/**
- * 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()
-})
-
-/**
- * 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()
-})
-
-/**
- * Anthropic model options schema
- * Currently empty - future options: budget_tokens for extended thinking
- */
-declare const AnthropicOptionsSchema = z.object({})
-
-/**
- * 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
-
-// ============================================================================
-// Model Configuration
-// ============================================================================
-
-/**
- * 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
-
-  /**
-   * 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
-}
-
-// ============================================================================
-// 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
-
-// ============================================================================
-// API Request/Response Types (Dashboard Observability)
-// ============================================================================
-
-/**
- * Time range selector for dashboard metrics
- */
-type TimeRange = '1h' | '24h' | '7d' | '30d'
-
-/**
- * Execution health metrics response
- * Success rate, P95 duration, execution counts, and trend data
- * trendData includes executionCount for throughput visualization (eliminates separate API call)
- */
-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'
-}
-
-/**
- * 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
-}
-
-/**
- * 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: QueueTaskStatus
-
-  /**
-   * 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 QueueTaskStatus = '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
-}
-
-/**
- * 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'
-
-/**
- * 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]
-
-/**
- * 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' | 'test'
-
-/** 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
-}
-
-/**
- * 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 ExecutionLogEvent {
-  type: 'log'
-  resourceId: string
-  executionId: string
-  timestamp: number
-  data: {
-    log: ExecutionLogMessage
-  }
-}
-
-/**
- * Event sent when execution completes (success or failure)
- */
-interface ExecutionCompleteEvent {
-  type: 'execution-complete'
-  resourceId: string
-  executionId: string
-  timestamp: number
-  data: {
-    success: boolean
-    status?: ExecutionStatus
-    result?: unknown
-    error?: string
-  }
-}
-
-/**
- * Connection confirmation event
- */
-interface ExecutionConnectedEvent {
-  type: 'connected'
-  resourceId: string
-  executionId?: undefined
-  timestamp: number
-  data?: undefined
-}
-
-/**
- * Union of all execution SSE events
- */
-type ExecutionSSEEvent =
-  | ExecutionStartedEvent
-  | ExecutionLogEvent
-  | ExecutionCompleteEvent
-  | ExecutionConnectedEvent
-
-// API execution types
-interface APIExecutionSummary {
-  id: string
-  status: ExecutionStatus
-  startTime: number
-  endTime?: number
-  resourceStatus?: ResourceStatus // 'dev' | 'prod' - optional for backward compatibility
-}
-
-/**
- * Execution Runner Types
- *
- * Shared types for the Execution Runner UI feature.
- * Used by both API (apps/api) and frontend (apps/command-center).
- */
-
-
-
-// ============================================================================
-// EXECUTION METRICS
-// ============================================================================
-
-interface ExecutionMetrics {
-  tokenCount?: number
-  stepCount?: number
-  toolCallCount?: number
-}
-
-// ============================================================================
-// EXECUTION HISTORY TYPES
-// ============================================================================
-
-interface ExecutionSummary {
-  id: string
-  resourceId: string
-  resourceName: string
-  status: ExecutionStatus
-  startedAt: string
-  completedAt?: string
-  durationMs?: number
-  metrics?: ExecutionMetrics
-  input?: unknown
-  output?: unknown
-  error?: { message: string }
+/**
+ * Credential field definition
+ */
+interface CredentialField {
+    key: string;
+    label: string;
+    type: 'password' | 'text';
+    required: boolean;
+    placeholder?: string;
+    description?: string;
 }
-
-/**
- * Execution history item.
- * Represents a single execution triggered by a schedule.
- */
-declare const ExecutionHistoryItemSchema = z.object({
-  id: z.string().uuid(),
-  createdAt: z.string().datetime(),
-  status: z.enum(['running', 'completed', 'failed', 'cancelled']),
-  step: z.number().int().nullable(),
-  itemLabel: z.string().nullable(),
-  duration: z.number().nullable(), // milliseconds
-  error: z.string().nullable()
-})
-
-/**
- * Execution history response.
- * Returned by GET /schedules/:id/executions with pagination.
- */
-declare const ExecutionHistoryResponseSchema = z.object({
-  executions: z.array(ExecutionHistoryItemSchema),
-  total: z.number().int(),
-  limit: z.number().int(),
-  offset: z.number().int()
-})
-type ExecutionHistoryItem = z.infer<typeof ExecutionHistoryItemSchema>
-type ExecutionHistoryResponse = z.infer<typeof ExecutionHistoryResponseSchema>
-
-/**
- * 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'
-  | 'hitl_action'
-  | 'webhook_received'
-  | 'webhook_executed'
-  | 'webhook_failed'
-  | 'credential_change'
-  | 'api_key_change'
-  | 'deployment_change'
-  | 'membership_change'
-
-type ActivityStatus = 'success' | 'failure' | 'pending' | 'approved' | 'rejected' | 'completed'
-
-interface Activity {
-  id: string
-  organizationId: string
-  activityType: ActivityType
-  status: ActivityStatus
-  title: string
-  description: string | null
-  entityType: string
-  entityId: string
-  entityName: string | null
-  metadata: Record<string, unknown> | null
-  actorId: string | null
-  actorType: string | null
-  occurredAt: Date
-  createdAt: Date
+/**
+ * Credential schema definition
+ */
+interface CredentialSchema {
+    type: string;
+    label: string;
+    description: string;
+    fields?: CredentialField[];
+    docsUrl?: string;
+    nameSuggestions: string[];
+    oauthProvider?: string;
 }
 
-/**
- * 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
+/**
+ * GET /api/credentials - List credentials
+ */
+declare const ListCredentialsResponseSchema: z.ZodObject<{
+    credentials: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodString;
+        provider: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** API response type for a single credential list item */
+type CredentialListItem = z.infer<typeof ListCredentialsResponseSchema>['credentials'][number];
 
-/**
- * Webhook Endpoint Domain Types
- *
- * Browser-safe domain types for generic inbound webhook endpoints.
- * These are camelCase representations of the `webhook_endpoints` DB table.
- *
- * Transform from snake_case DB rows happens in the API service layer,
- * not here (per core-package.md conventions).
- */
-
-/**
- * Lifecycle status of a webhook endpoint.
- * - `active`: Endpoint accepts inbound requests and triggers the target workflow
- * - `paused`: Endpoint exists but rejects inbound requests with 404
- */
-type WebhookEndpointStatus = 'active' | 'paused'
-
-/**
- * Generic inbound webhook endpoint domain type.
- *
- * Each endpoint gets a unique opaque URL (`/api/webhooks/inbound/:key`)
- * that maps to a target workflow resource within an organization.
- */
-interface WebhookEndpoint {
-  /** UUID primary key */
-  id: string
-  /** Organization this endpoint belongs to */
-  organizationId: string
-  /**
-   * Unique opaque key used in the inbound URL.
-   * Format: `wh_` + 32 crypto-random hex chars (128 bits of entropy).
-   * This key IS the credential — it must be kept secret.
-   */
-  key: string
-  /** User-facing label (e.g., "Zapier → Lead Intake") */
-  name: string
-  /** Optional description for the endpoint */
-  description: string | null
-  /** Target workflow resourceId to invoke on inbound request, or null if not yet assigned */
-  resourceId: string | null
-  /** Whether the endpoint is accepting requests */
-  status: WebhookEndpointStatus
-  /** Timestamp of the most recent successful inbound request, or null */
-  lastTriggeredAt: string | null
-  /** Running total of inbound requests received */
-  requestCount: number
-  /** ISO 8601 creation timestamp */
-  createdAt: string
-  /** ISO 8601 last-updated timestamp */
-  updatedAt: string
+/**
+ * Webhook Endpoint Domain Types
+ *
+ * Browser-safe domain types for generic inbound webhook endpoints.
+ * These are camelCase representations of the `webhook_endpoints` DB table.
+ *
+ * Transform from snake_case DB rows happens in the API service layer,
+ * not here (per core-package.md conventions).
+ */
+/**
+ * Lifecycle status of a webhook endpoint.
+ * - `active`: Endpoint accepts inbound requests and triggers the target workflow
+ * - `paused`: Endpoint exists but rejects inbound requests with 404
+ */
+type WebhookEndpointStatus = 'active' | 'paused';
+/**
+ * Generic inbound webhook endpoint domain type.
+ *
+ * Each endpoint gets a unique opaque URL (`/api/webhooks/inbound/:key`)
+ * that maps to a target workflow resource within an organization.
+ */
+interface WebhookEndpoint {
+    /** UUID primary key */
+    id: string;
+    /** Organization this endpoint belongs to */
+    organizationId: string;
+    /**
+     * Unique opaque key used in the inbound URL.
+     * Format: `wh_` + 32 crypto-random hex chars (128 bits of entropy).
+     * This key IS the credential — it must be kept secret.
+     */
+    key: string;
+    /** User-facing label (e.g., "Zapier → Lead Intake") */
+    name: string;
+    /** Optional description for the endpoint */
+    description: string | null;
+    /** Target workflow resourceId to invoke on inbound request, or null if not yet assigned */
+    resourceId: string | null;
+    /** Whether the endpoint is accepting requests */
+    status: WebhookEndpointStatus;
+    /** Timestamp of the most recent successful inbound request, or null */
+    lastTriggeredAt: string | null;
+    /** Running total of inbound requests received */
+    requestCount: number;
+    /** ISO 8601 creation timestamp */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp */
+    updatedAt: string;
 }
 
-/**
- * POST /api/webhook-endpoints - Create a new webhook endpoint
- *
- * The `key` and `id` are generated server-side and not accepted in the request.
- */
-declare const CreateWebhookEndpointRequestSchema = z
-  .object({
-    /** User-facing label for the endpoint */
-    name: NonEmptyStringSchema,
-    /** Target workflow resourceId to invoke on inbound requests (can be set later) */
-    resourceId: NonEmptyStringSchema.optional(),
-    /** Optional description */
-    description: z.string().optional()
-  })
-  .strict()
-
-type CreateWebhookEndpointRequest = z.infer<typeof CreateWebhookEndpointRequestSchema>
-
-/**
- * PATCH /api/webhook-endpoints/:id - Update an existing webhook endpoint
- *
- * At least one field must be provided.
- */
-declare const UpdateWebhookEndpointRequestSchema = z
-  .object({
-    name: NonEmptyStringSchema.optional(),
-    description: z.string().optional(),
-    resourceId: NonEmptyStringSchema.optional(),
-    status: WebhookEndpointStatusSchema.optional()
-  })
-  .strict()
-  .refine(
-    (data) =>
-      data.name !== undefined ||
-      data.description !== undefined ||
-      data.resourceId !== undefined ||
-      data.status !== undefined,
-    { message: 'At least one field (name, description, resourceId, or status) must be provided' }
-  )
-
-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
- */
-declare const ListCredentialsResponseSchema = z.object({
-  credentials: z.array(
-    z.object({
-      id: UuidSchema,
-      name: z.string(),
-      type: z.string(),
-      provider: z.string().nullable(), // OAuth provider or null for non-OAuth
-      createdAt: z.string().datetime()
-    })
-  )
-})
-
-/** API response type for a single credential list item */
-type CredentialListItem = z.infer<typeof ListCredentialsResponseSchema>['credentials'][number]
-
-/**
- * @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
-}
+/**
+ * POST /api/webhook-endpoints - Create a new webhook endpoint
+ *
+ * The `key` and `id` are generated server-side and not accepted in the request.
+ */
+declare const CreateWebhookEndpointRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    resourceId: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type CreateWebhookEndpointRequest = z.infer<typeof CreateWebhookEndpointRequestSchema>;
+/**
+ * PATCH /api/webhook-endpoints/:id - Update an existing webhook endpoint
+ *
+ * At least one field must be provided.
+ */
+declare const UpdateWebhookEndpointRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    resourceId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+    }>>;
+}, z.core.$strict>;
+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.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    key: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    resourceId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+    }>;
+    lastTriggeredAt: z.ZodNullable<z.ZodString>;
+    requestCount: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+type WebhookEndpointResponse = z.infer<typeof WebhookEndpointResponseSchema>;
 
-export type { AIResourceDefinition, APIExecutionDetail, APIExecutionListResponse, APIExecutionSummary, AbsoluteScheduleConfig, AbsoluteScheduleItem, ActionConfig, Activity, ActivitySSEEvent, ActivityStatus, ActivityType, AgentIterationData, AgentMemory, ApiKeyListItem, BusinessImpactMetrics, ChatMessage, CheckpointListResponse, CommandQueueSSEEvent, CommandViewAgent, CommandViewData, CommandViewNode, CommandViewNodeType, CommandViewStatsResponse, CommandViewWorkflow, CostBreakdownMetrics, CostByModelResponse, CostSummaryResponse, CostTrendsResponse, CreateWebhookEndpointRequest, CredentialListItem, DashboardMetrics, DealListItem, DealStage, Deployment, DeploymentStatus, DomainDefinition, ErrorAnalysisMetrics, ErrorDetailFull, ErrorDetailResponse, ErrorTrend, ExecutionHealthMetrics, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogMessage, ExecutionMetricsDetail, ExecutionRunnerCatalogItem, ExecutionSSEEvent, ExecutionStatus$1 as ExecutionStatus, ExecutionSummary, FailingResource, HumanCheckpointDefinition, HumanCheckpointStats, KanbanBoardConfig, ListMembershipsParams, MembershipFeatureConfig, MembershipStatus, MembershipWithDetails, MessageEvent, MessageType, ModelConfig, NotificationDTO, NotificationSSEEvent, PatchTaskParams, QueueTaskStatus, 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, SessionDTO, SessionTokenUsage, StatsTimeRange, SupabaseUserProfile, Task, TaskSchedule, TaskScheduleConfig, TimeRange, WorkflowNodeVisualizerData as TimelineData, UpdateWebhookEndpointRequest, UserConfig, WebhookEndpoint, WebhookEndpointResponse };
+export type { AIResourceDefinition, APIExecutionDetail, APIExecutionListResponse, APIExecutionSummary, AbsoluteScheduleConfig, AbsoluteScheduleItem, ActionConfig, Activity, ActivitySSEEvent, ActivityStatus, ActivityType, AgentIterationData, AgentMemory, ApiKeyListItem, BusinessImpactMetrics, ChatMessage, CheckpointListResponse, CommandQueueSSEEvent, CommandViewAgent, CommandViewData, CommandViewNode, CommandViewNodeType, CommandViewStatsResponse, CommandViewWorkflow, CostBreakdownMetrics, CostByModelResponse, CostSummaryResponse, CostTrendsResponse, CreateWebhookEndpointRequest, CredentialField, CredentialListItem, CredentialSchema, DashboardMetrics, DealListItem, DealStage, Deployment, DeploymentStatus, DomainDefinition, ErrorAnalysisMetrics, ErrorDetailFull, ErrorDetailResponse, ErrorTrend, ExecutionHealthMetrics, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogMessage, ExecutionMetricsDetail, ExecutionRunnerCatalogItem, ExecutionSSEEvent, ExecutionStatus, ExecutionSummary, FailingResource, HumanCheckpointDefinition, HumanCheckpointStats, KanbanBoardConfig, ListMembershipsParams, MembershipFeatureConfig, MembershipStatus, MembershipWithDetails, MessageEvent, MessageType, ModelConfig, NotificationDTO, NotificationSSEEvent, OAuthProviderConfig, PatchTaskParams, QueueTaskStatus, RecentExecutionsByResourceResponse, RecurringScheduleConfig, RelativeScheduleConfig, RelativeScheduleItem, ResourceDefinition, ResourceDomain, ResourceErrorsResponse, ResourceExecutionSummary, ResourceExecutionsResponse, ResourceHealth, ResourceIdentifier, ResourceStats, ResourceStatus, ResourceType, ResourcesHealthResponse, SerializedAgentDefinition, SerializedExecutionInterface, SerializedWorkflowDefinition, SessionDTO, SessionTokenUsage, StatsTimeRange, SupabaseUserProfile, Task, TaskSchedule, TaskScheduleConfig, TimeRange, WorkflowNodeVisualizerData as TimelineData, UpdateWebhookEndpointRequest, UserConfig, WebhookEndpoint, WebhookEndpointResponse };