@elevasis/ui 1.20.0 → 1.20.1

package/dist/features/operations/index.d.ts

@@ -1,29 +1,1771 @@
-export { ResourcesPage } from './ResourcesPage';
-export type { ResourcesPageProps } from './ResourcesPage';
-export { ResourcesSidebar } from './ResourcesSidebar';
-export type { ResourcesSidebarProps } from './ResourcesSidebar';
-export { ResourceDetailPage } from './ResourceDetailPage';
-export type { ResourceDetailPageProps, ResourceDetailPageRenderExecutionPanelArgs } from './ResourceDetailPage';
-export { CommandQueuePage } from './CommandQueuePage';
-export type { CommandQueuePageProps } from './CommandQueuePage';
-export { CommandQueueDetailPage } from './CommandQueueDetailPage';
-export type { CommandQueueDetailPageProps, CommandQueueDetailPageRichTextArgs } from './CommandQueueDetailPage';
-export { CommandViewPage } from './CommandViewPage';
-export type { CommandViewPageProps } from './CommandViewPage';
-export { CalibrationPage } from './CalibrationPage';
-export type { CalibrationPageProps } from './CalibrationPage';
-export { CalibrationProjectDetailPage } from './CalibrationProjectDetailPage';
-export type { CalibrationProjectDetailPageProps, CalibrationProjectDetailPageRenderRunCardArgs, CalibrationProjectDetailPageRenderCreateModalArgs } from './CalibrationProjectDetailPage';
-export { CalibrationProjectsPage } from './CalibrationProjectsPage';
-export type { CalibrationProjectsPageProps } from './CalibrationProjectsPage';
-export { CommandViewSidebarContent } from './CommandViewSidebarContent';
-export type { CommandViewSidebarContentProps } from './CommandViewSidebarContent';
-export { CalibrationRunDetailPage } from './CalibrationRunDetailPage';
-export type { CalibrationRunDetailPageProps } from './CalibrationRunDetailPage';
-export { ExecutionPanel } from './executions/index.js';
-export type { ExecutionPanelProps } from './executions/index.js';
-export { WorkflowExecutionPanel } from './executions/index.js';
-export type { WorkflowExecutionPanelProps } from './executions/index.js';
-export { AgentExecutionPanel } from './executions/index.js';
-export type { AgentExecutionPanelProps } from './executions/index.js';
-//# sourceMappingURL=index.d.ts.map
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { z } from 'zod';
+import { ReactNode } from 'react';
+
+/**
+ * Workflow-specific logging types and utilities
+ */
+
+interface WorkflowExecutionContext {
+    type: 'workflow';
+    contextType: 'workflow-execution';
+    executionId: string;
+    workflowId: string;
+    workflowName?: string;
+    organizationId: string;
+    executionPath?: string[];
+}
+interface WorkflowFailureContext {
+    type: 'workflow';
+    contextType: 'workflow-failure';
+    executionId: string;
+    workflowId: string;
+    error: string;
+}
+interface StepStartedContext {
+    type: 'workflow';
+    contextType: 'step-started';
+    stepId: string;
+    stepStatus: 'started';
+    input: unknown;
+    startTime: number;
+}
+interface StepCompletedContext {
+    type: 'workflow';
+    contextType: 'step-completed';
+    stepId: string;
+    stepStatus: 'completed';
+    output: unknown;
+    duration: number;
+    isTerminal: boolean;
+    startTime: number;
+    endTime: number;
+}
+interface StepFailedContext {
+    type: 'workflow';
+    contextType: 'step-failed';
+    stepId: string;
+    stepStatus: 'failed';
+    error: string;
+    duration: number;
+    startTime: number;
+    endTime: number;
+}
+interface ConditionalRouteContext {
+    type: 'workflow';
+    contextType: 'conditional-route';
+    stepId: string;
+    target: string;
+    error?: string;
+}
+interface ExecutionPathContext {
+    type: 'workflow';
+    contextType: 'execution-path';
+    executionPath: string[];
+}
+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)
+ */
+
+/**
+ * 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';
+/**
+ * Base fields shared by all lifecycle events
+ */
+interface AgentLifecycleEventBase {
+    type: 'agent';
+    agentId: string;
+    lifecycle: AgentLifecycle;
+    sessionId?: string;
+}
+/**
+ * Lifecycle started event - emitted when a phase begins
+ * REQUIRED: startTime (phase has started, no end yet)
+ */
+interface AgentLifecycleStartedEvent extends AgentLifecycleEventBase {
+    stage: 'started';
+    startTime: number;
+    iteration?: number;
+}
+/**
+ * Lifecycle completed event - emitted when a phase succeeds
+ * REQUIRED: startTime, endTime, duration (phase has finished successfully)
+ */
+interface AgentLifecycleCompletedEvent extends AgentLifecycleEventBase {
+    stage: 'completed';
+    startTime: number;
+    endTime: number;
+    duration: number;
+    iteration?: number;
+    attempts?: number;
+    memorySize?: {
+        sessionMemoryKeys: number;
+        historyEntries: number;
+    };
+}
+/**
+ * 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;
+    endTime: number;
+    duration: number;
+    error: string;
+    iteration?: number;
+}
+/**
+ * Union type for all lifecycle events
+ * Discriminated by 'stage' field for type narrowing
+ */
+type AgentLifecycleEvent = AgentLifecycleStartedEvent | AgentLifecycleCompletedEvent | AgentLifecycleFailedEvent;
+/**
+ * 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';
+    eventType: IterationEventType;
+    iteration: number;
+    sessionId?: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    output?: string;
+    actionType?: string;
+    data?: ActionPlaceholderData;
+}
+/**
+ * Tool call event - captures individual tool executions during iterations
+ * Provides granular timing for each tool invocation
+ */
+interface AgentToolCallEvent {
+    type: 'agent';
+    agentId: string;
+    lifecycle: 'iteration';
+    eventType: 'tool-call';
+    iteration: number;
+    sessionId?: string;
+    toolName: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    success: boolean;
+    error?: string;
+    input?: Record<string, unknown>;
+    output?: unknown;
+}
+/**
+ * Union type for all agent log contexts
+ * 3 event types total (lifecycle, iteration, tool-call)
+ */
+type AgentLogContext = AgentLifecycleEvent | AgentIterationEvent | AgentToolCallEvent;
+/**
+ * Data for lifecycle 'started' events
+ */
+interface AgentLifecycleStartedData {
+    startTime: number;
+    iteration?: number;
+}
+/**
+ * Data for lifecycle 'completed' events
+ */
+interface AgentLifecycleCompletedData {
+    startTime: number;
+    endTime: number;
+    duration: number;
+    iteration?: number;
+    attempts?: number;
+    memorySize?: {
+        sessionMemoryKeys: number;
+        historyEntries: number;
+    };
+}
+/**
+ * Data for lifecycle 'failed' events
+ */
+interface AgentLifecycleFailedData {
+    startTime: number;
+    endTime: number;
+    duration: number;
+    error: string;
+    iteration?: number;
+}
+/**
+ * Scoped logger for agent execution
+ * Captures logger and agentId to eliminate repetitive parameter passing
+ *
+ * Type-safe lifecycle logging with stage-specific required fields
+ */
+interface AgentScopedLogger {
+    lifecycle(lifecycle: AgentLifecycle, stage: 'started', data: AgentLifecycleStartedData): void;
+    lifecycle(lifecycle: AgentLifecycle, stage: 'completed', data: AgentLifecycleCompletedData): void;
+    lifecycle(lifecycle: AgentLifecycle, stage: 'failed', data: AgentLifecycleFailedData): void;
+    reasoning(output: string, iteration: number, startTime: number, endTime: number, duration: number): void;
+    action(actionType: string, message: string, iteration: number, startTime: number, endTime: number, duration: number): void;
+    toolCall(toolName: string, iteration: number, startTime: number, endTime: number, duration: number, success: boolean, error?: string, input?: unknown, output?: unknown): void;
+}
+
+type LogContext = WorkflowLogContext | AgentLogContext;
+interface IExecutionLogger {
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}
+
+/**
+ * Shared form field types for dynamic form generation
+ * Used by: Command Queue, Execution Runner UI, future form-based features
+ */
+/**
+ * Supported form field types for action payloads
+ * Maps to Mantine form components
+ */
+type FormFieldType = 'text' | '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[];
+}
+
+/**
+ * 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 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 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;
+        temperature: number;
+        maxOutputTokens: number;
+        topP?: number;
+        modelOptions?: Record<string, unknown>;
+    };
+    contract: {
+        inputSchema: object;
+        outputSchema?: object;
+    };
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema?: object;
+        outputSchema?: object;
+    }>;
+    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;
+        outputSchema?: object;
+        next: {
+            type: 'linear' | 'conditional';
+            target?: string;
+            routes?: Array<{
+                target: string;
+            }>;
+            default?: string;
+        } | null;
+    }>;
+    contract: {
+        inputSchema: object;
+        outputSchema?: object;
+    };
+    metricsConfig?: object;
+    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;
+}
+
+/**
+ * Execution interface configuration
+ * Defines how a resource is executed via the UI (forms, scheduling, webhooks)
+ * Applies to both agents and workflows
+ */
+interface ExecutionInterface {
+    /** Form configuration for execution inputs */
+    form: ExecutionFormSchema;
+    /** Optional: Schedule configuration */
+    schedule?: ScheduleConfig;
+    /** Optional: Webhook trigger configuration */
+    webhook?: WebhookConfig;
+}
+/**
+ * Execution form schema
+ * Extends FormSchema with execution-specific fields
+ */
+interface ExecutionFormSchema extends FormSchema {
+    /**
+     * Field mappings to resource input schema
+     * Maps form field names to contract input paths
+     * If omitted, field names must match contract input keys exactly
+     */
+    fieldMappings?: Record<string, string>;
+    /**
+     * Submit button configuration
+     * Default: { label: 'Run', loadingLabel: 'Running...' }
+     */
+    submitButton?: {
+        label?: string;
+        loadingLabel?: string;
+        confirmMessage?: string;
+    };
+}
+/**
+ * Schedule configuration for automated execution
+ */
+interface ScheduleConfig {
+    /** Whether scheduling is enabled for this resource */
+    enabled: boolean;
+    /** Default schedule (cron expression) */
+    defaultSchedule?: string;
+    /** Allowed schedule patterns (if restricted) */
+    allowedPatterns?: string[];
+}
+/**
+ * Webhook configuration for external triggers
+ */
+interface WebhookConfig {
+    /** Whether webhook trigger is enabled */
+    enabled: boolean;
+    /** Expected payload schema (for documentation) */
+    payloadSchema?: unknown;
+}
+
+interface WorkflowConfig extends ResourceDefinition {
+    type: 'workflow';
+}
+interface WorkflowStepDefinition {
+    id: string;
+    name: string;
+    description: string;
+}
+type StepHandler = (input: unknown, context: ExecutionContext) => Promise<unknown>;
+interface LinearNext {
+    type: 'linear';
+    target: string;
+}
+interface ConditionalNext {
+    type: 'conditional';
+    routes: Array<{
+        condition: (data: unknown) => boolean;
+        target: string;
+    }>;
+    default: string;
+}
+type NextConfig = LinearNext | ConditionalNext | null;
+interface WorkflowStep extends WorkflowStepDefinition {
+    handler: StepHandler;
+    inputSchema: z.ZodSchema;
+    outputSchema: z.ZodSchema;
+    next: NextConfig;
+}
+interface WorkflowDefinition {
+    config: WorkflowConfig;
+    contract: Contract;
+    steps: Record<string, WorkflowStep>;
+    entryPoint: string;
+    /**
+     * Metrics configuration for ROI calculations
+     * Optional: Only needed if tracking automation savings
+     */
+    metricsConfig?: ResourceMetricsConfig;
+    /**
+     * Execution interface configuration (optional)
+     * If provided, workflow appears in Execution Runner UI
+     */
+    interface?: ExecutionInterface;
+}
+
+/**
+ * Generic LLM Types
+ * Universal interfaces for LLM interaction across all resource types
+ */
+/**
+ * Standard chat message format
+ * Compatible with OpenAI, Anthropic, and other providers
+ */
+interface LLMMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * Generic LLM generation request
+ * Usable by agents, workflows, tools, etc.
+ */
+interface LLMGenerateRequest {
+    messages: LLMMessage[];
+    responseSchema: unknown;
+    /** Maximum output tokens per LLM call. NOT the model's context window — see ModelInfo.maxTokens for that. */
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Generic LLM generation response
+ * Usage field is internal-only (stripped by UniversalLLMAdapter wrapper)
+ */
+interface LLMGenerateResponse<T = unknown> {
+    output: T;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    cost?: number;
+}
+/**
+ * LLM Adapter interface
+ * Generic primitive for all resource types (agents, workflows, tools)
+ *
+ * Design principles:
+ * - Single method: generate() - the core LLM primitive
+ * - Generic return type for type safety
+ * - Universal format (not agent-specific)
+ * - Standard message-based input (OpenAI-compatible)
+ */
+interface LLMAdapter {
+    /**
+     * Generate structured output from prompt using LLM
+     *
+     * @param request - Generation request with messages and response schema
+     * @returns Generated output (typed) with optional usage metadata
+     */
+    generate<T = unknown>(request: LLMGenerateRequest): Promise<LLMGenerateResponse<T>>;
+}
+
+/**
+ * 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' | 'input' | 'reasoning' | 'tool-result' | 'delegation-result' | 'error';
+/**
+ * Memory entry - represents a single entry in agent memory
+ * Stored in agent memory, translated by adapters to vendor-specific formats
+ */
+interface MemoryEntry {
+    type: MemoryEntryType;
+    content: string;
+    timestamp: number;
+    turnNumber: number | null;
+    iterationNumber: number | null;
+}
+/**
+ * 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[];
+}
+/**
+ * Memory status for agent awareness
+ */
+interface MemoryStatus {
+    sessionMemoryKeys: number;
+    sessionMemoryLimit: number;
+    currentKeys: string[];
+    historyPercent: number;
+    historyTokens: number;
+    tokenBudget: number;
+}
+/**
+ * Memory constraints (optional limits)
+ */
+interface MemoryConstraints {
+    maxSessionMemoryKeys?: number;
+    maxMemoryTokens?: number;
+}
+
+/**
+ * Memory Manager
+ * Encapsulates all memory operations with ultra-simple agent API
+ * Agent provides strings, framework handles wrapping and auto-compaction
+ */
+
+/**
+ * Memory Manager - Agent memory orchestration
+ * Provides ultra-simple API for agents (strings only)
+ * Handles automatic compaction and token management
+ */
+declare class MemoryManager {
+    private memory;
+    private constraints;
+    private logger?;
+    private cachedSnapshot?;
+    constructor(memory: AgentMemory, constraints?: MemoryConstraints, logger?: AgentScopedLogger | undefined);
+    /**
+     * Set session memory entry (agent provides string, framework wraps it)
+     * @param key - Session memory key
+     * @param content - String content from agent
+     */
+    set(key: string, content: string): void;
+    /**
+     * Get session memory entry content
+     * @param key - Session memory key
+     * @returns String content if exists, undefined otherwise
+     */
+    get(key: string): string | undefined;
+    /**
+     * Delete session memory entry
+     * @param key - Key to delete
+     * @returns True if key existed and was deleted
+     */
+    delete(key: string): boolean;
+    /**
+     * Add entry to history (called by framework after tool results, reasoning, etc.)
+     * Automatically sets timestamp to current time
+     * @param entry - Memory entry to add (without timestamp - auto-generated)
+     */
+    addToHistory(entry: Omit<MemoryEntry, 'timestamp'>): void;
+    /**
+     * Auto-compact history if approaching token budget
+     * Uses preserve-anchors strategy: keep first + recent entries
+     */
+    autoCompact(): void;
+    /**
+     * Enforce hard limits (called before LLM request)
+     * Emergency fallback if agent exceeds limits
+     */
+    enforceHardLimits(): void;
+    /**
+     * Get history length (for logging and introspection)
+     * @returns Number of entries in history
+     */
+    getHistoryLength(): number;
+    /**
+     * Get memory status for agent awareness
+     * @returns Memory status with token usage and key counts
+     */
+    getStatus(): MemoryStatus;
+    /**
+     * Create memory snapshot for persistence
+     * Caches snapshot internally for later retrieval
+     * @returns Deep copy of current memory state
+     */
+    toSnapshot(): AgentMemory;
+    /**
+     * Get cached memory snapshot
+     * Returns snapshot created by toSnapshot()
+     * @returns Cached snapshot (undefined if toSnapshot() not called yet)
+     */
+    getSnapshot(): AgentMemory | undefined;
+    /**
+     * Build context string for LLM
+     * Serializes sessionmemory + history memory with clear sections
+     * Shows current iteration entries FIRST (reverse chronological) for LLM attention
+     * @param currentIteration - Current iteration number (0 = pre-iteration)
+     * @param currentTurn - Current turn number (optional, for session context filtering)
+     * @returns Formatted memory context for LLM prompt
+     */
+    toContext(currentIteration: number, currentTurn?: number): string;
+}
+
+/**
+ * Knowledge Map Types
+ *
+ * Enables agents to navigate organizational knowledge through a lightweight
+ * graph that lazy-loads capabilities on-demand.
+ *
+ * @module agent/knowledge-map
+ */
+
+/**
+ * Lightweight knowledge map (passed as agent property)
+ *
+ * Contains metadata about available knowledge nodes without loading
+ * the full content upfront. Total size: ~300-500 tokens.
+ *
+ * Multi-tenancy is enforced via:
+ * - File-scoped maps (organizations/{org-name}/knowledge/)
+ * - ExecutionContext.organizationId passed to node.load()
+ */
+interface KnowledgeMap {
+    /** Available knowledge nodes indexed by ID */
+    nodes: Record<string, KnowledgeNode>;
+}
+/**
+ * Single knowledge source
+ *
+ * Represents a domain knowledge area (CRM, brand guidelines, Excel tools)
+ * that can be lazy-loaded to provide instructions and tools to agents.
+ */
+interface KnowledgeNode {
+    /** Unique identifier for this node (e.g., "crm", "brand-guidelines") */
+    id: string;
+    /**
+     * Description of when to use this knowledge
+     * Used for semantic matching against user intent
+     */
+    description: string;
+    /**
+     * Load knowledge content on-demand
+     *
+     * @param context - Execution context with organizationId for multi-tenancy
+     * @returns Promise resolving to knowledge content (prompt + optional tools)
+     */
+    load(context: ExecutionContext): Promise<KnowledgeContent>;
+    /**
+     * Loaded state flag
+     * Set to true after load() is called
+     */
+    loaded?: boolean;
+    /**
+     * Cached prompt (for system prompt serialization)
+     * Only the prompt is cached - tools go to toolRegistry, children flattened to nodes
+     */
+    prompt?: string;
+}
+/**
+ * Content returned by knowledge node
+ *
+ * Separates instructions (prompt) from capabilities (tools).
+ * Tools are optional - some nodes only provide context.
+ *
+ * Supports recursive navigation - nodes can contain child nodes
+ * that are discovered when the parent node is loaded.
+ */
+interface KnowledgeContent {
+    /** Instructions and context (markdown format) */
+    prompt: string;
+    /** Tool implementations (optional) */
+    tools?: Tool[];
+    /**
+     * Child knowledge nodes (optional, recursive)
+     *
+     * Enables hierarchical navigation: base → specialized → deep expertise.
+     * Child nodes are flattened into the main knowledge map when parent loads,
+     * making them available for subsequent navigate-knowledge actions.
+     *
+     * Example: CRM base node returns crm-customers and crm-deals as children
+     */
+    nodes?: Record<string, KnowledgeNode>;
+}
+
+/**
+ * Agent-specific type definitions
+ * Types for autonomous agents with tools, memory, and constraints
+ */
+
+/**
+ * Factory function for creating LLM adapters.
+ * Injected into the Agent class to decouple the engine from server-only provider SDKs.
+ * - API process: provides createLLMAdapter (real SDKs + process.env API keys)
+ * - SDK worker: provides PostMessageLLMAdapter (proxies via platform.call)
+ *
+ * Uses `any` for optional params so both the real createLLMAdapter (with typed
+ * AIUsageCollector/AICallContext) and the worker proxy (which ignores them) satisfy the type.
+ */
+type LLMAdapterFactory = (config: ModelConfig, ...args: any[]) => LLMAdapter;
+interface AgentConfig extends ResourceDefinition {
+    type: 'agent';
+    systemPrompt: string;
+    constraints?: AgentConstraints;
+    /**
+     * Session capability declaration (opt-in)
+     * If true, agent is designed for multi-turn session interactions
+     * Controls whether agent can use message action and appears in Sessions UI
+     *
+     * Use for:
+     * - Conversational agents with multi-turn interactions
+     * - Agents requiring persistent context across turns
+     * - Agents that need human-in-the-loop communication
+     */
+    sessionCapable?: boolean;
+    /**
+     * Security level for system prompt hardening (auto-derived if omitted)
+     *
+     * - 'standard': Lightweight defense (3 rules) - default for non-session agents
+     * - 'hardened': Comprehensive defense (6 rules) - default for session-capable agents
+     * - 'none': No security prompt - for pure internal agents with no external input
+     *
+     * If omitted, derived from sessionCapable:
+     *   sessionCapable: true  -> 'hardened'
+     *   sessionCapable: false -> 'standard'
+     */
+    securityLevel?: 'standard' | 'hardened' | 'none';
+    /**
+     * Memory management preferences (opt-in)
+     * If provided, agent can use memoryOps to manage session memory
+     * If omitted, agent has no memory management capabilities
+     *
+     * Agent-specific guidance on what to preserve, when to persist, and what to clean up.
+     * This guidance is injected into the system prompt when memory management is enabled.
+     *
+     * Use for:
+     * - Conversational agents needing cross-turn context
+     * - Agents managing complex user preferences
+     * - Agents tracking decisions over multiple iterations
+     */
+    memoryPreferences?: string;
+}
+interface AgentConstraints {
+    maxIterations?: number;
+    timeout?: number;
+    maxSessionMemoryKeys?: number;
+    maxMemoryTokens?: number;
+}
+interface AgentDefinition {
+    config: AgentConfig;
+    contract: Contract;
+    tools: Tool[];
+    /**
+     * Model configuration for LLM execution
+     * Specifies provider, API key, and model-specific options
+     */
+    modelConfig: ModelConfig;
+    /**
+     * Optional knowledge map for lazy-loading capabilities
+     * Enables agents to navigate organizational knowledge on-demand
+     */
+    knowledgeMap?: KnowledgeMap;
+    /**
+     * Preload memory before execution starts
+     * Handles BOTH context loading AND session restoration
+     *
+     * @param context - Execution context (includes sessionId if session turn)
+     * @returns Initial AgentMemory state (sessionMemory entries + optionally history)
+     */
+    preloadMemory?: (context: ExecutionContext) => Promise<AgentMemory> | AgentMemory;
+    /**
+     * Metrics configuration for ROI calculations
+     * Optional: Only needed if tracking automation savings
+     */
+    metricsConfig?: ResourceMetricsConfig;
+    /**
+     * Execution interface configuration (optional)
+     * If provided, agent appears in Execution Runner UI
+     */
+    interface?: ExecutionInterface;
+}
+/**
+ * Agent execution context
+ * Groups all state needed for agent execution phases
+ */
+interface IterationContext {
+    config: AgentConfig;
+    contract: Contract;
+    toolRegistry: Map<string, Tool>;
+    memoryManager: MemoryManager;
+    executionContext: ExecutionContext;
+    iteration: number;
+    logger: AgentScopedLogger;
+    modelConfig: ModelConfig;
+    adapterFactory: LLMAdapterFactory;
+    knowledgeMap?: KnowledgeMap;
+}
+
+/**
+ * MetricsCollector
+ * Tracks execution timing and ROI metrics
+ */
+declare class MetricsCollector {
+    private timings;
+    private durationMs?;
+    /**
+     * Start a timer with a label
+     */
+    startTimer(label: string): void;
+    /**
+     * End a timer and calculate duration
+     * If label is 'execution', stores duration for metrics summary
+     */
+    endTimer(label: string): number | null;
+    /**
+     * Build execution metrics summary with optional ROI calculation
+     */
+    buildExecutionMetrics(metricsConfig?: ResourceMetricsConfig): ExecutionMetricsSummary;
+}
+
+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;
+    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;
+/**
+ * Raw LLM usage data returned by adapters
+ * Used as input to AIUsageCollector.record()
+ */
+interface LLMUsageData {
+    model: LLMModel;
+    inputTokens: number;
+    outputTokens: number;
+    latencyMs: number;
+    /** Actual cost from provider in USD (when available, e.g., OpenRouter) */
+    cost?: number;
+}
+interface AIUsageSummary {
+    model: LLMModel;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    totalCostUsd: number;
+    callCount: number;
+    calls: AICallRecord[];
+}
+interface ExecutionMetricsSummary {
+    durationMs?: number;
+    automationSavingsUsd?: number;
+}
+interface ResourceMetricsConfig {
+    estimatedManualMinutes: number;
+    hourlyLaborRateUsd: number;
+    confidenceLevel?: 'low' | 'medium' | 'high';
+    notes?: string;
+}
+/**
+ * Time range selector for dashboard metrics
+ */
+type TimeRange = '1h' | '24h' | '7d' | '30d';
+
+/**
+ * AIUsageCollector
+ * Centralized token tracking that aggregates usage across all LLM calls in an execution
+ */
+declare class AIUsageCollector {
+    private model;
+    private calls;
+    private callSequence;
+    /**
+     * Record a single AI call with usage metrics
+     *
+     * @param usage - Token usage and latency data from LLM adapter
+     * @param callType - Type discriminator (agent-reasoning, tool, etc.)
+     * @param context - Optional typed context specific to callType
+     */
+    record(usage: LLMUsageData, callType?: BaseAICall['callType'], context?: AICallContext): void;
+    /**
+     * Get aggregated summary of all AI calls
+     */
+    getSummary(): AIUsageSummary;
+    /**
+     * Check if any usage has been recorded
+     */
+    hasUsage(): boolean;
+}
+
+/**
+ * Base Execution Engine type definitions
+ * Core types shared across all Execution Engine resources
+ */
+
+/**
+ * Immutable execution metadata
+ * Represents complete execution identity (who, what, when, where)
+ * Shared across ExecutionContext and ExecutionLoggerContext to eliminate field duplication
+ */
+interface ExecutionMetadata {
+    executionId: string;
+    organizationId: string;
+    organizationName: string;
+    resourceId: string;
+    userId?: string;
+    sessionId?: string;
+    sessionTurnNumber?: number;
+}
+/**
+ * Unified message event type - covers all message types in sessions
+ * Replaces separate SessionTurnMessages and AgentActivityEvent mechanisms
+ */
+/**
+ * Structured action metadata attached to assistant messages.
+ * Frontend reads this instead of parsing text prefixes.
+ */
+type AssistantAction = {
+    kind: 'navigate';
+    path: string;
+    reason: string;
+} | {
+    kind: 'update_filters';
+    timeRange: string | null;
+    statusFilter: string | null;
+    searchQuery: string | null;
+};
+type MessageEvent = {
+    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;
+};
+/**
+ * Execution context for all resources
+ * Unified callback replaces SessionTurnMessages (removed)
+ */
+interface ExecutionContext extends ExecutionMetadata {
+    logger: IExecutionLogger;
+    signal?: AbortSignal;
+    onMessageEvent?: (event: MessageEvent) => Promise<void>;
+    /** Called per iteration to write heartbeat + check stall status. Non-fatal if it throws. */
+    onHeartbeat?: () => Promise<void>;
+    aiUsageCollector?: AIUsageCollector;
+    metricsCollector?: MetricsCollector;
+    parentExecutionId?: string;
+    executionDepth: number;
+    credentialName?: string;
+    store: Map<string, unknown>;
+}
+interface Contract {
+    inputSchema: z.ZodSchema;
+    outputSchema?: z.ZodSchema;
+}
+/**
+ * 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;
+
+/**
+ * Tool definitions
+ *
+ * Tool interface used by agents and workflows.
+ * Provides a universal interface for AI systems to interact with tools.
+ */
+
+/**
+ * Options for tool execution
+ * Provides named parameters for better API clarity and extensibility
+ */
+interface ToolExecutionOptions {
+    /** Tool input (validated against inputSchema before execution) */
+    input: unknown;
+    /** Execution context with multi-tenant isolation and observability (optional for simple tools, required for platform/integration tools) */
+    executionContext?: ExecutionContext;
+    /** Full iteration context for advanced tools (provides access to memoryManager, toolRegistry, logger, etc.) */
+    iterationContext?: IterationContext;
+    /** Abort signal for timeout/cancellation -- forward to fetch() calls for clean cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Tool interface for AI systems
+ *
+ * Used by:
+ * - Agents: For agentic tool use (reasoning loop selects and executes tools)
+ * - Workflows: For workflow step tool invocation (future)
+ * - Platform tools: createApprovalTool(), createSchedulerTool()
+ * - Integration tools: External API calls (Gmail, Slack, etc.)
+ */
+interface Tool {
+    name: string;
+    description: string;
+    inputSchema: z.ZodSchema;
+    outputSchema: z.ZodSchema;
+    execute: (options: ToolExecutionOptions) => Promise<unknown>;
+    timeout?: number;
+}
+
+/**
+ * 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;
+    /** 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;
+}
+
+/**
+ * Standard Domain Definitions
+ * Centralized domain constants and definitions for all organization resources.
+ */
+
+declare const DOMAINS: {
+    readonly INBOUND_PIPELINE: "inbound-pipeline";
+    readonly LEAD_GEN_PIPELINE: "lead-gen-pipeline";
+    readonly SUPPORT: "support";
+    readonly CLIENT_SUPPORT: "client-support";
+    readonly DELIVERY: "delivery";
+    readonly OPERATIONS: "operations";
+    readonly FINANCE: "finance";
+    readonly EXECUTIVE: "executive";
+    readonly INSTANTLY: "instantly";
+    readonly TESTING: "testing";
+    readonly INTERNAL: "internal";
+    readonly INTEGRATION: "integration";
+    readonly UTILITY: "utility";
+    readonly DIAGNOSTIC: "diagnostic";
+};
+/**
+ * ResourceDomain - Strongly typed domain identifier
+ * Use this type for all domain references to ensure compile-time validation.
+ */
+type ResourceDomain = (typeof DOMAINS)[keyof typeof DOMAINS];
+
+/**
+ * Calibration Lab Type Definitions
+ * Core types for AI model configuration optimization with cost/performance comparison
+ */
+
+/**
+ * Configuration variant for testing
+ * Defines what to override in the base agent/workflow definition
+ */
+interface ConfigVariant {
+    variantName: string;
+    definitionOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides;
+}
+/**
+ * Agent definition overrides for calibration
+ * Excludes identity/metadata fields that should not be modified
+ */
+type AgentCalibrationOverrides = Omit<Partial<AgentDefinition>, 'config' | 'contract' | 'tools' | 'metricsConfig' | 'interface'>;
+/**
+ * Workflow definition overrides for calibration
+ * Excludes identity/metadata fields that should not be modified
+ */
+type WorkflowCalibrationOverrides = Omit<Partial<WorkflowDefinition>, 'config' | 'contract' | 'steps' | 'entryPoint' | 'metricsConfig' | 'interface'>;
+/**
+ * Grading rubric for LLM-as-judge evaluation
+ * Defines criteria and passing threshold
+ */
+interface GradingRubric {
+    passingThreshold: number;
+    criteria: GradingCriterion[];
+}
+/**
+ * Individual grading criterion
+ * Weight should be 0-1, and all weights should sum to 1
+ */
+interface GradingCriterion {
+    name: string;
+    weight: number;
+    description: string;
+    scoringGuide: string;
+}
+/**
+ * Grading result for a single execution or session
+ * Contains overall score and per-criterion breakdown
+ */
+interface GradeResult {
+    score: number;
+    passed: boolean;
+    details: Record<string, {
+        score: number;
+        justification: string;
+    }>;
+}
+/**
+ * Single-turn calibration result
+ * One result per (variant × input) combination
+ */
+interface SingleCalibrationResult {
+    executionId: string;
+    variantName: string;
+    inputIndex: number;
+    appliedOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    errorMessage?: string;
+    grade?: GradeResult;
+    gradeError?: string;
+}
+/**
+ * Multi-turn session calibration result
+ * Leverages existing sessions infrastructure
+ */
+interface SessionCalibrationResult {
+    sessionId: string;
+    variantName: string;
+    appliedOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    errorMessage?: string;
+    turnCount: number;
+    grade?: GradeResult;
+    gradeError?: string;
+}
+/**
+ * Calibration run - individual test execution within a project
+ * Contains configuration, results, and grading information
+ */
+interface CalibrationRun {
+    id: string;
+    organizationId: string;
+    projectId: string;
+    name: string;
+    description?: string | null;
+    executionMode: 'single' | 'session';
+    testInputs: unknown[];
+    configVariants: ConfigVariant[];
+    gradingRubric?: GradingRubric | null;
+    graderModel?: string | null;
+    results: (SingleCalibrationResult | SessionCalibrationResult)[];
+    status: 'pending' | 'running' | 'completed' | 'partial' | 'failed';
+    createdAt: Date;
+    completedAt?: Date | null;
+}
+
+interface ResourcesPageProps {
+    /** Initial filter type from the URL search param (caller-managed) */
+    initialFilter?: ResourceType;
+    /** Called when the user changes the tab filter — caller should update its URL */
+    onTypeChange: (type: ResourceType | undefined) => void;
+    /** Current time range value — caller passes from its own store */
+    timeRange: TimeRange;
+    /** Called when the user clicks a resource row — caller handles navigation */
+    onResourceClick: (resource: ResourceDefinition) => void;
+    /** Items per page (defaults to 20) */
+    pageSize?: number;
+}
+declare function ResourcesPage({ initialFilter, onTypeChange, timeRange, onResourceClick, pageSize }: ResourcesPageProps): react_jsx_runtime.JSX.Element;
+
+interface ResourcesSidebarProps {
+    timeRange: TimeRange;
+}
+/**
+ * Resources sidebar - shows execution health donut, domain filters and search
+ */
+declare function ResourcesSidebar({ timeRange }: ResourcesSidebarProps): react_jsx_runtime.JSX.Element;
+
+interface ResourceDetailPageRenderExecutionPanelArgs {
+    resourceId: string;
+    resourceType: ResourceType;
+    resourceName: string;
+    resourceDefinition: AIResourceDefinition;
+    onConnectionStatus: (connected: boolean, count: number) => void;
+}
+interface ResourceDetailPageProps {
+    /** Resource type (workflow, agent, etc.) */
+    type: ResourceType;
+    /** Resource identifier */
+    resourceId: string;
+    /** Current time range value — caller passes from its own store */
+    timeRange: TimeRange;
+    /**
+     * Render-prop slot for the consumer's ExecutionPanel. The shared layout owns connection
+     * state and passes it to the slot via `onConnectionStatus`. The resolved
+     * `resourceDefinition` is threaded through so the execution panel does not refetch.
+     */
+    renderExecutionPanel: (args: ResourceDetailPageRenderExecutionPanelArgs) => ReactNode;
+}
+declare function ResourceDetailPage({ type, resourceId, timeRange, renderExecutionPanel }: ResourceDetailPageProps): react_jsx_runtime.JSX.Element;
+
+interface EventSourceMessage {
+    id: string;
+    event: string;
+    data: string;
+    retry?: number;
+}
+
+interface FetchEventSourceWithTokenRefreshOptions {
+    url: string;
+    getToken: () => Promise<string | undefined>;
+    headers?: Record<string, string>;
+    signal: AbortSignal;
+    /** Delay in ms before reconnecting after token refresh. Defaults to 2000. */
+    tokenRefreshDelayMs?: number;
+    onopen?: (response: Response) => void | Promise<void>;
+    onmessage?: (event: EventSourceMessage) => void;
+    onerror?: (error: unknown) => void;
+    onclose?: () => void;
+}
+
+interface SSEConnectionManagerOptions {
+    /** Grace period in ms before closing idle connections. Defaults to 5000. */
+    closeGracePeriodMs?: number;
+}
+/**
+ * SSE Connection Manager
+ *
+ * Ensures only ONE SSE connection exists per endpoint, preventing duplicate
+ * connections when components re-render or remount.
+ *
+ * Benefits:
+ * - Prevents resource waste from duplicate connections
+ * - Eliminates race conditions from overlapping connections
+ * - Automatically manages connection lifecycle
+ * - Shares single connection across multiple subscribers
+ */
+declare class SSEConnectionManager {
+    private connections;
+    private closeGracePeriodMs;
+    constructor(options?: SSEConnectionManagerOptions);
+    /**
+     * Subscribe to an SSE endpoint
+     *
+     * If a connection already exists for this endpoint, reuses it.
+     * Otherwise, creates a new connection.
+     *
+     * @param key - Unique identifier for the connection (e.g., 'notifications', 'resource-executive-agent')
+     * @param subscriberId - Unique identifier for this subscriber (usually component instance)
+     * @param options - SSE connection options
+     * @returns Unsubscribe function to call when component unmounts
+     */
+    subscribe(key: string, subscriberId: string, options: Omit<FetchEventSourceWithTokenRefreshOptions, 'signal'>): () => void;
+    /**
+     * Unsubscribe from an SSE endpoint
+     *
+     * If this is the last subscriber, closes the connection after grace period.
+     */
+    private unsubscribe;
+    /**
+     * Force close a connection and all its subscribers
+     */
+    closeConnection(key: string): void;
+    /**
+     * Get current connection status
+     */
+    getConnectionInfo(): Map<string, {
+        url: string;
+        subscribers: number;
+    }>;
+}
+
+type TaskFilterStatus = 'all' | 'pending' | 'completed' | 'expired';
+
+interface CommandQueuePageProps {
+    timeRange: TimeRange;
+    pageSize?: number;
+    onNavigateToTask: (taskId: string) => void;
+    /** Filter props forwarded from the sidebar */
+    selectedCheckpoint?: string;
+    status?: TaskFilterStatus;
+    priorityRange?: [number, number];
+}
+declare function CommandQueuePage({ timeRange, pageSize, onNavigateToTask, selectedCheckpoint, status, priorityRange }: CommandQueuePageProps): react_jsx_runtime.JSX.Element;
+
+interface CommandQueueDetailPageRichTextArgs {
+    content: string;
+    onChange: (content: string) => void;
+    placeholder?: string;
+}
+interface CommandQueueDetailPageProps {
+    taskId: string;
+    orgName: string;
+    renderRichText?: (args: CommandQueueDetailPageRichTextArgs) => ReactNode;
+    onNavigateToTask: (taskId: string) => void;
+    onNavigateBack: () => void;
+    onViewExecution: (type: string, resourceId: string, executionId: string) => void;
+}
+declare function CommandQueueDetailPage({ taskId, orgName, renderRichText, onNavigateBack, onViewExecution }: CommandQueueDetailPageProps): react_jsx_runtime.JSX.Element;
+
+interface CommandViewPageProps {
+    timeRange: TimeRange;
+}
+declare function CommandViewPage({ timeRange }: CommandViewPageProps): react_jsx_runtime.JSX.Element;
+
+interface CalibrationPageProps {
+    /** The resource this calibration tab is embedded within */
+    resourceId: string;
+    resourceType: 'agent' | 'workflow';
+    /** Called when the user clicks a project card. Caller handles navigation. */
+    onProjectNavigate: (projectId: string) => void;
+}
+declare function CalibrationPage({ resourceId, resourceType, onProjectNavigate }: CalibrationPageProps): react_jsx_runtime.JSX.Element;
+
+interface CalibrationProjectDetailPageRenderRunCardArgs {
+    run: CalibrationRun;
+    projectId: string;
+}
+interface CalibrationProjectDetailPageRenderCreateModalArgs {
+    opened: boolean;
+    onClose: () => void;
+    projectId: string;
+}
+interface CalibrationProjectDetailPageProps {
+    /** ID of the calibration project to display */
+    projectId: string;
+    /** Root path for the calibration section, e.g. '/operations/calibration' */
+    calibrationRootPath: string;
+    /**
+     * Called when the organization changes while viewing this page.
+     * The CC wrapper navigates back to the calibration root on org switch.
+     */
+    onOrgChange?: () => void;
+    /**
+     * Render-prop slot for a single run card.
+     * Required because CalibrationRunCard has CC-local hook dependencies
+     * (useDeleteRun, useExecuteRun) that cannot be co-extracted yet.
+     */
+    renderRunCard: (args: CalibrationProjectDetailPageRenderRunCardArgs) => ReactNode;
+    /**
+     * Render-prop slot for the create run modal.
+     * Required because CreateRunModal has CC-local hook dependencies
+     * (useCreateRun) that cannot be co-extracted yet.
+     */
+    renderCreateModal: (args: CalibrationProjectDetailPageRenderCreateModalArgs) => ReactNode;
+    /**
+     * Runs array to display. Kept in CC because useCalibrationRuns is deferred
+     * to batch 3 extraction. Pass `undefined` while loading.
+     */
+    runs: CalibrationRun[] | undefined;
+    /** Whether the runs data is still loading */
+    runsLoading: boolean;
+}
+declare function CalibrationProjectDetailPage({ projectId, calibrationRootPath, renderRunCard, renderCreateModal, runs, runsLoading }: CalibrationProjectDetailPageProps): react_jsx_runtime.JSX.Element | null;
+
+interface CalibrationProjectsPageProps {
+    /** Called when the user clicks a project card. Caller handles navigation. */
+    onNavigateToProject: (projectId: string) => void;
+}
+/**
+ * Main Calibration Lab landing page
+ * Shows all calibration projects across the organization
+ */
+declare function CalibrationProjectsPage({ onNavigateToProject }: CalibrationProjectsPageProps): react_jsx_runtime.JSX.Element;
+
+interface CommandViewSidebarContentProps {
+    /** Current time range value — caller passes from its own store (e.g. useAppStore) */
+    timeRange: TimeRange;
+}
+/**
+ * Contextual sidebar for the Command View page.
+ * Shown in the shared Operations subshell sidebar when on /operations/command-view.
+ *
+ * Contains:
+ * - Execution health donut chart (filtered by domain + status)
+ * - Environment filter (All/Prod/Dev)
+ * - Show integrations toggle
+ * - Domain filters (collapsible)
+ * - Settings (fit view on filter)
+ * - Selected node details + executions/tasks (lazy loaded)
+ */
+declare function CommandViewSidebarContent({ timeRange }: CommandViewSidebarContentProps): react_jsx_runtime.JSX.Element;
+
+interface CalibrationRunDetailPageProps {
+    /** ID of the calibration run to display */
+    runId: string;
+    /** Root path for the calibration section, e.g. '/operations/calibration' */
+    calibrationRootPath: string;
+    /**
+     * Called when the user clicks the back-to-project button.
+     * Receives the project ID to navigate to.
+     */
+    onNavigateToProject: (projectId: string) => void;
+    /**
+     * Called when the organization changes while viewing this page.
+     * The CC wrapper should navigate back to the calibration root on org switch.
+     */
+    onOrgChange?: () => void;
+    /**
+     * Render-prop slot for the session comparison panel.
+     * Required because SessionComparison has CC-local hook dependencies
+     * (useSessionMessages, ChatInterface from @/shared/components/chat).
+     */
+    renderSessionComparison?: (args: {
+        run: CalibrationRun;
+    }) => ReactNode;
+    /**
+     * Render-prop slot for the live progress panel shown during execution.
+     * Required because CalibrationProgress uses CC-local useCalibrationSSE.
+     */
+    renderProgressPanel?: (args: {
+        runId: string;
+    }) => ReactNode;
+}
+declare function CalibrationRunDetailPage({ runId, onNavigateToProject, renderSessionComparison, renderProgressPanel }: CalibrationRunDetailPageProps): react_jsx_runtime.JSX.Element | null;
+
+interface ExecutionPanelProps {
+    resourceId: string;
+    resourceType: ResourceType;
+    resourceName?: string;
+    resourceDefinition: AIResourceDefinition;
+    sseManager: SSEConnectionManager;
+    apiUrl: string;
+    onConnectionStatus?: (connected: boolean, runningCount: number) => void;
+}
+declare function ExecutionPanel({ resourceId, resourceType, resourceName, resourceDefinition, sseManager, apiUrl, onConnectionStatus }: ExecutionPanelProps): react_jsx_runtime.JSX.Element;
+
+interface WorkflowExecutionPanelProps {
+    resourceId: string;
+    resourceName?: string;
+    resourceDefinition: SerializedWorkflowDefinition;
+    sseManager: SSEConnectionManager;
+    apiUrl: string;
+    onConnectionStatus?: (connected: boolean, runningCount: number) => void;
+}
+declare function WorkflowExecutionPanel({ resourceId, resourceDefinition, sseManager, apiUrl, onConnectionStatus }: WorkflowExecutionPanelProps): react_jsx_runtime.JSX.Element;
+
+interface AgentExecutionPanelProps {
+    resourceId: string;
+    resourceName?: string;
+    resourceDefinition: SerializedAgentDefinition;
+    sseManager: SSEConnectionManager;
+    apiUrl: string;
+    onConnectionStatus?: (connected: boolean, runningCount: number) => void;
+}
+declare function AgentExecutionPanel({ resourceId, resourceDefinition, sseManager, apiUrl, onConnectionStatus }: AgentExecutionPanelProps): react_jsx_runtime.JSX.Element;
+
+export { AgentExecutionPanel, CalibrationPage, CalibrationProjectDetailPage, CalibrationProjectsPage, CalibrationRunDetailPage, CommandQueueDetailPage, CommandQueuePage, CommandViewPage, CommandViewSidebarContent, ExecutionPanel, ResourceDetailPage, ResourcesPage, ResourcesSidebar, WorkflowExecutionPanel };
+export type { AgentExecutionPanelProps, CalibrationPageProps, CalibrationProjectDetailPageProps, CalibrationProjectDetailPageRenderCreateModalArgs, CalibrationProjectDetailPageRenderRunCardArgs, CalibrationProjectsPageProps, CalibrationRunDetailPageProps, CommandQueueDetailPageProps, CommandQueueDetailPageRichTextArgs, CommandQueuePageProps, CommandViewPageProps, CommandViewSidebarContentProps, ExecutionPanelProps, ResourceDetailPageProps, ResourceDetailPageRenderExecutionPanelArgs, ResourcesPageProps, ResourcesSidebarProps, WorkflowExecutionPanelProps };