@elevasis/ui 1.7.5 → 1.8.0

package/dist/hooks/published.d.ts

@@ -1,5 +1,8 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import * as react from 'react';
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+import { Edge } from '@xyflow/react';
 import { z } from 'zod';
 
 /**
@@ -685,6 +688,74 @@ interface FormSchema {
     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;
+}
+/**
+ * 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$1 = 'triggers' | 'uses' | 'approval';
+/**
+ * Command View edge (relationship between resources)
+ */
+interface CommandViewEdge$1 {
+    id: string;
+    source: string;
+    target: string;
+    relationship: RelationshipType$1;
+    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$1[];
+    domainDefinitions?: DomainDefinition[];
+}
+
 /**
  * Serialized Registry Types
  *
@@ -3744,6 +3815,27 @@ interface ErrorTrend {
     warningCount: number;
     infoCount: number;
 }
+/**
+ * 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;
@@ -3898,6 +3990,17 @@ type MessageEvent = {
  */
 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
  */
@@ -3937,6 +4040,240 @@ interface ResourceDefinition {
     /** 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';
+/** 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
@@ -3984,6 +4321,62 @@ interface APIExecutionDetail extends APIExecutionSummary {
     sdkVersion?: string | null;
 }
 
+/**
+ * @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;
+}
+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;
+}
+
 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 {
@@ -4047,6 +4440,27 @@ declare const ExecutionHistoryResponseSchema: z.ZodObject<{
 type ExecutionHistoryItem = z.infer<typeof ExecutionHistoryItemSchema>;
 type ExecutionHistoryResponse = z.infer<typeof ExecutionHistoryResponseSchema>;
 
+/**
+ * Deployment types — browser-safe
+ *
+ * Canonical API response types for the deployment resource.
+ * The API's transformRow converts snake_case DB columns to these camelCase fields.
+ */
+type DeploymentStatus = 'deploying' | 'active' | 'failed' | 'rolled_back' | 'stopped';
+interface Deployment {
+    id: string;
+    organizationId: string;
+    status: DeploymentStatus;
+    sdkVersion: string;
+    deploymentVersion: string | null;
+    port: number | null;
+    pid: number | null;
+    tarballPath: string | null;
+    errorMessage: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+
 /**
  * Fetch all available Execution Engine resources (workflows, agents, pipelines).
  *
@@ -4070,6 +4484,24 @@ declare function useResources(): _tanstack_react_query.UseQueryResult<{
  */
 declare function useResourceDefinition(resourceId: string, enabled?: boolean): _tanstack_react_query.UseQueryResult<AIResourceDefinition, Error>;
 
+interface UseScheduledTasksOptions {
+    status?: 'active' | 'paused' | 'completed' | 'cancelled';
+    targetResourceType?: 'agent' | 'workflow';
+}
+/**
+ * Dashboard hook for fetching scheduled tasks.
+ * Simplified read-only hook that returns the schedules array directly.
+ *
+ * @param options - Optional filters for status and target resource type
+ * @returns TanStack Query result with schedules array
+ *
+ * @example
+ * ```tsx
+ * const { data: schedules, isLoading } = useScheduledTasks({ status: 'active' })
+ * ```
+ */
+declare function useScheduledTasks(options?: UseScheduledTasksOptions): _tanstack_react_query.UseQueryResult<TaskSchedule[], Error>;
+
 /**
  * Query key factory for schedule cache management.
  * Provides type-safe, hierarchical keys for TanStack Query.
@@ -4417,6 +4849,8 @@ declare const observabilityKeys: {
     dashboardMetrics: (organizationId: string | null, timeRange: string) => readonly ["observability", "dashboard-metrics", string | null, string];
     businessImpact: (organizationId: string | null, timeRange: string) => readonly ["observability", "business-impact", string | null, string];
     resourcesHealth: (organizationId: string | null, resources: string, startDate: string, endDate: string, granularity: string) => readonly ["observability", "resources-health", string | null, string, string, string, string];
+    unresolvedErrors: (organizationId: string | null, startDate: string, endDate: string) => readonly ["observability", "unresolved-errors", string | null, string, string];
+    recentExecutionsByResource: (organizationId: string | null, timeRange: string, limit: number | undefined) => readonly ["observability", "recent-executions-by-resource", string | null, string, number | undefined];
 };
 
 declare function useErrorAnalysis(timeRange: TimeRange): _tanstack_react_query.UseQueryResult<ErrorAnalysisMetrics, Error>;
@@ -4530,6 +4964,31 @@ declare function useBatchedResourcesHealth(params: UseBatchedResourcesHealthPara
     healthLookup: Map<string, ResourceHealth>;
 };
 
+interface UseUnresolvedErrorsParams {
+    startDate: string;
+    endDate: string;
+}
+/**
+ * Fetches the most recent unresolved errors for the dashboard operational overview.
+ */
+declare function useUnresolvedErrors({ startDate, endDate }: UseUnresolvedErrorsParams): _tanstack_react_query.UseQueryResult<ErrorDetailResponse, Error>;
+
+interface UseRecentExecutionsByResourceParams {
+    timeRange: TimeRange;
+    limit?: number;
+}
+/**
+ * Fetch recent executions grouped by resource.
+ * Single source of truth from execution_logs (includes session-based executions).
+ *
+ * @example
+ * const { data, isLoading } = useRecentExecutionsByResource({
+ *   timeRange: '24h',
+ *   limit: 5
+ * })
+ */
+declare function useRecentExecutionsByResource({ timeRange, limit }: UseRecentExecutionsByResourceParams): _tanstack_react_query.UseQueryResult<RecentExecutionsByResourceResponse, Error>;
+
 declare function useMarkAsRead(): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
 
 declare function useMarkAllAsRead(): _tanstack_react_query.UseMutationResult<void, Error, void, unknown>;
@@ -4579,6 +5038,22 @@ declare function useWarningNotification(): (title: string, message: string) => v
  */
 declare function useBatchDelete(tableName: string, invalidateQueryKeys: readonly (readonly unknown[])[]): _tanstack_react_query.UseMutationResult<void, Error, string[], unknown>;
 
+/**
+ * Mutation hook to send a test notification.
+ * On success, invalidates the notifications query cache.
+ * On error, shows an API error notification via the notification adapter.
+ *
+ * @returns TanStack Mutation for triggering test notifications
+ *
+ * @example
+ * ```tsx
+ * const testNotification = useTestNotification()
+ *
+ * testNotification.mutate()
+ * ```
+ */
+declare function useTestNotification(): _tanstack_react_query.UseMutationResult<void, Error, void, unknown>;
+
 interface SessionListItem {
     sessionId: string;
     resourceId: string;
@@ -4971,13 +5446,14 @@ interface WebSocketState {
     error: string | null;
 }
 
-/** Refetch interval for running executions (ms) */
+/** Active execution detail polling when status is 'running' (2s). */
 declare const REFETCH_INTERVAL_RUNNING = 2000;
-/** WebSocket reconnection: base delay (ms) */
+
+/** WebSocket exponential backoff base delay (1s). */
 declare const WS_RECONNECT_BASE_DELAY = 1000;
-/** WebSocket reconnection: max delay (ms) */
+/** WebSocket reconnect delay cap (30s). */
 declare const WS_RECONNECT_MAX_DELAY = 30000;
-/** WebSocket reconnection: retries before showing error */
+/** WebSocket retries before showing error state. */
 declare const WS_MAX_RETRIES_BEFORE_ERROR = 3;
 
 declare function useCommandQueue({ status, limit, offset, humanCheckpoint, timeRange, priorityMin, priorityMax, }?: {
@@ -5063,6 +5539,390 @@ declare function usePatchTask(): _tanstack_react_query.UseMutationResult<Task, E
     params: PatchTaskParams;
 }, unknown>;
 
+/**
+ * Query key factories for Operations TanStack Query hooks.
+ *
+ * Execution-related keys (executions, resources, definitions) use executionsKeys from @repo/ui.
+ * Non-execution keys (workflows, agents, sessions) stay local in operationsKeys.
+ */
+
+declare const operationsKeys: {
+    all: readonly ["operations"];
+    workflows: (org?: string) => readonly ["operations", "workflows", string | undefined];
+    workflowDetails: (org?: string) => readonly ["operations", "workflows", string | undefined, "details"];
+    workflow: (id: string, org?: string) => readonly ["operations", "workflows", string | undefined, string];
+    agents: (org?: string) => readonly ["operations", "agents", string | undefined];
+    agentDetails: (org?: string) => readonly ["operations", "agents", string | undefined, "details"];
+    agent: (id: string, org?: string) => readonly ["operations", "agents", string | undefined, string];
+    sessions: (org: string, params?: {
+        resourceId?: string;
+    }) => readonly ["operations", "sessions", string, {
+        resourceId?: string;
+    } | undefined];
+    session: (org: string, sessionId: string) => readonly ["operations", "session", string, string];
+};
+
+declare function useExecutionLogSSE(resourceId: string, manager: SSEConnectionManager): {
+    liveExecutions: Set<string>;
+    connected: boolean;
+    error: string | null;
+    runningCount: number;
+    isLive: (executionId: string) => boolean;
+    streamingLogs: Map<string, ExecutionLogMessage[]>;
+};
+
+interface UseExecutionPanelStateOptions {
+    resourceId: string;
+    manager: SSEConnectionManager;
+    limit?: number;
+    onConnectionStatus?: (connected: boolean, runningCount: number) => void;
+}
+interface UseExecutionPanelStateReturn {
+    executions: APIExecutionSummary[];
+    isLoading: boolean;
+    isFetched: boolean;
+    selectedId: string | undefined;
+    setSelectedId: (id: string | undefined) => void;
+    resourceStatusFilter: ResourceStatus | 'all';
+    setResourceStatusFilter: (filter: ResourceStatus | 'all') => void;
+    liveExecutions: Set<string>;
+    connected: boolean;
+    runningCount: number;
+    streamingLogs: Map<string, ExecutionLogMessage[]>;
+}
+/**
+ * Shared execution panel state management hook
+ * Handles execution list fetching, selection, auto-selection logic, and SSE integration
+ *
+ * @param options - Hook configuration options
+ * @returns Execution panel state and controls
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   executions,
+ *   selectedId,
+ *   setSelectedId,
+ *   liveExecutions,
+ *   connected
+ * } = useExecutionPanelState({ resourceId, manager, onConnectionStatus })
+ * ```
+ */
+declare function useExecutionPanelState({ resourceId, manager, limit, onConnectionStatus }: UseExecutionPanelStateOptions): UseExecutionPanelStateReturn;
+
+/**
+ * Utilities for extracting typed properties from resource definitions
+ */
+
+/**
+ * Extract sessionCapable from agent definition config
+ * Returns true only for agents with explicit sessionCapable: true
+ */
+declare function isSessionCapable(type: ResourceType, resourceDefinition: AIResourceDefinition | undefined): boolean;
+
+interface DocFile {
+    path: string;
+    frontmatter: {
+        title: string;
+        order?: number;
+        [key: string]: unknown;
+    };
+    compiledSource: string;
+}
+/**
+ * Fetches deployment documentation for the current organization.
+ *
+ * 1. Fetches all deployments via GET /api/deployments
+ * 2. Auto-selects the latest active deployment (most recent by createdAt)
+ * 3. Fetches docs for the selected deployment via GET /api/deployments/:id/docs
+ *
+ * @returns { files, isLoading, error, activeDeployment, activeDeployments }
+ */
+declare function useDeploymentDocs(selectedDeploymentId?: string): {
+    files: DocFile[];
+    isLoading: boolean;
+    error: Error | null;
+    activeDeployment: Deployment;
+    activeDeployments: Deployment[];
+};
+
+/**
+ * Fetches Command View data for the current organization
+ *
+ * Uses pre-serialized data from the backend for instant responses.
+ * Data includes workflows, agents, triggers, integrations, and relationship edges.
+ *
+ * @returns TanStack Query result with CommandViewData
+ */
+declare function useCommandViewData(): _tanstack_react_query.UseQueryResult<CommandViewData, Error>;
+
+/**
+ * Fetches Command View stats for the current organization
+ *
+ * Returns execution statistics (counts only, no error details) for all resources
+ * within the specified time range. Error details are fetched on-demand via useResourceErrors.
+ *
+ * @param timeRange - Time range for stats aggregation ('24h' or '7d')
+ * @returns TanStack Query result with CommandViewStatsResponse
+ */
+declare function useCommandViewStats(timeRange?: StatsTimeRange): _tanstack_react_query.UseQueryResult<CommandViewStatsResponse, Error>;
+
+/**
+ * Command View Types
+ *
+ * Frontend graph types for React Flow rendering.
+ *
+ * Backend API returns CommandViewData with separate arrays (workflows[], agents[], etc.)
+ * Frontend transforms this to CommandViewGraph with unified nodes[] array.
+ *
+ * @see transformCommandViewData for the mapping logic
+ * @see CommandViewData from @repo/core for backend type
+ */
+
+/**
+ * Base resource node - common fields for all resources
+ */
+interface BaseResourceNode {
+    id: string;
+    name: string;
+    description: string;
+    status: ResourceStatus;
+    stats?: {
+        totalRuns: number;
+        successCount: number;
+        failureCount: number;
+        warningCount: number;
+        lastRunAt: string | null;
+    } | null;
+}
+/**
+ * Agent node - autonomous AI agents
+ */
+interface AgentNode extends BaseResourceNode {
+    type: 'agent';
+    modelProvider: string;
+    modelId: string;
+    toolCount: number;
+    hasKnowledgeMap: boolean;
+    hasMemory: boolean;
+}
+/**
+ * Workflow node - multi-step orchestrations
+ */
+interface WorkflowNode extends BaseResourceNode {
+    type: 'workflow';
+    stepCount: number;
+    entryPoint: string;
+}
+/**
+ * Integration node - external service connections
+ */
+interface IntegrationNode extends BaseResourceNode {
+    type: 'integration';
+    provider: string;
+    connectionStatus: 'connected' | 'disconnected' | 'error';
+    credentialName?: string;
+}
+/**
+ * Trigger node - what initiates executions
+ */
+interface TriggerNode extends BaseResourceNode {
+    type: 'trigger';
+    triggerType: 'webhook' | 'schedule' | 'manual' | 'event';
+    schedule?: string;
+    webhookPath?: string;
+}
+/**
+ * External resource node - third-party automation platforms
+ */
+interface ExternalResourceNode extends BaseResourceNode {
+    type: 'external';
+    platform: 'n8n' | 'make' | 'zapier' | 'other';
+    platformUrl?: string;
+    externalId?: string;
+}
+/**
+ * Human node - approval points requiring human decisions
+ */
+interface HumanNode extends Omit<BaseResourceNode, 'stats'> {
+    type: 'human';
+    stats?: {
+        pendingCount: number;
+        completedCount: number;
+        expiredCount: number;
+        lastDecisionAt: string | null;
+    } | null;
+}
+/**
+ * Union type for all node types
+ */
+type CommandViewNode = AgentNode | WorkflowNode | IntegrationNode | TriggerNode | ExternalResourceNode | HumanNode;
+/**
+ * Relationship types between resources
+ */
+type RelationshipType = 'triggers' | 'uses' | 'approval';
+/**
+ * Edge representing a relationship
+ */
+interface CommandViewEdge {
+    id: string;
+    source: string;
+    target: string;
+    relationship: RelationshipType;
+    label?: string;
+}
+/**
+ * Complete graph data for visualization
+ */
+interface CommandViewGraph {
+    nodes: CommandViewNode[];
+    edges: CommandViewEdge[];
+}
+
+type StatusFilter = ResourceStatus | 'all';
+
+interface CommandViewStore {
+    statusFilter: StatusFilter;
+    setStatusFilter: (v: StatusFilter) => void;
+    showIntegrations: boolean;
+    setShowIntegrations: (v: boolean) => void;
+    fitViewOnFilter: boolean;
+    setFitViewOnFilter: (v: boolean) => void;
+    selectedNodeId: string | null;
+    setSelectedNodeId: (id: string | null) => void;
+}
+/**
+ * Shared store for Command View filter/settings state.
+ * Allows CommandViewPage (graph) and CommandViewSidebarContent (sidebar) to share state.
+ *
+ * Persisted to localStorage: showIntegrations, fitViewOnFilter
+ * Not persisted (reset on reload): statusFilter, selectedNodeId
+ */
+declare const useCommandViewStore: zustand.UseBoundStore<Omit<zustand.StoreApi<CommandViewStore>, "setState" | "persist"> & {
+    setState(partial: CommandViewStore | Partial<CommandViewStore> | ((state: CommandViewStore) => CommandViewStore | Partial<CommandViewStore>), replace?: false | undefined): unknown;
+    setState(state: CommandViewStore | ((state: CommandViewStore) => CommandViewStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<CommandViewStore, {
+            showIntegrations: boolean;
+            fitViewOnFilter: boolean;
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: CommandViewStore) => void) => () => void;
+        onFinishHydration: (fn: (state: CommandViewStore) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<CommandViewStore, {
+            showIntegrations: boolean;
+            fitViewOnFilter: boolean;
+        }, unknown>>;
+    };
+}>;
+
+/**
+ * useCommandViewLayout - Hook to convert CommandViewGraph to ReactFlow nodes/edges
+ *
+ * Uses Dagre for automatic graph layout:
+ * - Left-to-right flow (LR)
+ * - Minimizes edge crossings
+ * - Keeps connected nodes closer together
+ *
+ * Post-processes Dagre output to sort workflow chains by their minimum name prefix
+ * (e.g., INB-01 chain above INB-02 chain, above INB-04 chain). Uses Union-Find
+ * to identify connected components based on 'triggers' and 'approval' edges
+ * (not 'uses' edges, which would connect everything through shared integrations).
+ */
+
+/**
+ * Convert CommandViewGraph to ReactFlow nodes and edges with Dagre layout
+ */
+declare function useCommandViewLayout(graph: CommandViewGraph): {
+    nodes: {
+        id: string;
+        type: string;
+        position: {
+            x: number;
+            y: number;
+        };
+        data: Record<string, unknown>;
+    }[];
+    edges: Edge[];
+};
+/**
+ * Get graph statistics
+ */
+declare function useGraphStats(graph: CommandViewGraph): {
+    agents: number;
+    workflows: number;
+    integrations: number;
+    triggers: number;
+    prodResources: number;
+    devResources: number;
+    connectedIntegrations: number;
+    errorIntegrations: number;
+};
+
+interface UseCheckpointTasksOptions {
+    checkpointId: string | null;
+    enabled?: boolean;
+}
+interface CheckpointTasksResponse {
+    tasks: Task[];
+}
+/**
+ * Fetches pending tasks for a specific human checkpoint (on-demand)
+ *
+ * Only fetches when:
+ * - Organization is ready
+ * - Checkpoint is selected
+ * - enabled is true (default: true when checkpointId is set)
+ *
+ * Returns top 10 pending tasks ordered by priority and creation date
+ *
+ * @param options - Checkpoint ID and enabled flag
+ * @returns TanStack Query result with pending tasks
+ */
+declare function useCheckpointTasks({ checkpointId, enabled }: UseCheckpointTasksOptions): _tanstack_react_query.UseQueryResult<CheckpointTasksResponse, Error>;
+
+interface UseResourceErrorsOptions {
+    resourceId: string | null;
+    timeRange: StatsTimeRange;
+    hasFailures: boolean;
+}
+/**
+ * Fetches error details for a specific resource (on-demand)
+ *
+ * Only fetches when:
+ * - Organization is ready
+ * - Resource is selected
+ * - Resource has failures (lazy loading pattern)
+ *
+ * Returns top 10 errors + total count for "showing X of Y" display
+ *
+ * @param options - Resource ID, time range, and failure flag
+ * @returns TanStack Query result with ResourceErrorsResponse
+ */
+declare function useResourceErrors({ resourceId, timeRange, hasFailures }: UseResourceErrorsOptions): _tanstack_react_query.UseQueryResult<ResourceErrorsResponse, Error>;
+
+interface UseResourceExecutionsOptions {
+    resourceId: string | null;
+    timeRange: StatsTimeRange;
+    enabled?: boolean;
+}
+/**
+ * Fetches recent executions for a specific resource (on-demand)
+ *
+ * Only fetches when:
+ * - Organization is ready
+ * - Resource is selected
+ * - enabled is true (default: true when resourceId is set)
+ *
+ * Returns top 10 executions + total count for "showing X of Y" display
+ *
+ * @param options - Resource ID, time range, and enabled flag
+ * @returns TanStack Query result with ResourceExecutionsResponse
+ */
+declare function useResourceExecutions({ resourceId, timeRange, enabled }: UseResourceExecutionsOptions): _tanstack_react_query.UseQueryResult<ResourceExecutionsResponse, Error>;
+
 /**
  * Hook to fetch sessions list with optional filtering.
  */
@@ -5122,5 +5982,5 @@ declare function useSessionWebSocket(sessionId: string, apiUrl: string): {
     lastTokenUsage: SessionTokenUsage | null;
 };
 
-export { OperationsService, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, createUseFeatureAccess, executionsKeys, observabilityKeys, scheduleKeys, sessionsKeys, sortData, useActivities, useActivityTrend, useArchiveSession, useBatchDelete, useBatchedResourcesHealth, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCommandQueue, useCommandQueueTotals, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useCreateSession, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useDeleteSession, useDeleteTask, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePaginationState, usePatchTask, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResourcesHealth, useResumeSchedule, useRetryExecution, useSSEConnection, useSession, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket, useSessions, useSortedData, useSubmitAction, useSuccessNotification, useTableSelection, useTableSort, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule, useWarningNotification };
-export type { ActivityTrendResponse, BulkDeleteExecutionsParams, BulkDeleteExecutionsResult, BusinessImpactMetrics, CancelExecutionParams, CancelExecutionResult, ChatMessage, CostBreakdownItem, CreateScheduleInput, CreateSessionResponse, DeleteExecutionParams, ErrorDistributionItem, ErrorDistributionParams, ErrorFilters, ErrorTrendsParams, ExecuteAsyncParams, ExecuteAsyncResult, ExecutionErrorDetails, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogsPageResponse, FailingResource, GetMessagesResponse, ListActivitiesResponse, ListSchedulesFilters, ListSchedulesResponse, MessageEvent, MessageType, ResourcesResponse, RetryExecutionParams, SessionDTO, SessionExecution, SessionExecutionsResponse, SessionListItem, SessionTokenUsage, SortDirection, SortState, SubmitActionRequest, SubmitActionResponse, TaskSchedule, TopFailingResourcesParams, UpdateScheduleInput, UseActivitiesParams, UseActivityTrendParams, UseBatchedResourcesHealthParams, UseExecutionHealthParams, UseExecutionLogsParams, UseResourcesHealthParams, UseSSEConnectionOptions, WebSocketState };
+export { OperationsService, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, createUseFeatureAccess, executionsKeys, isSessionCapable, observabilityKeys, operationsKeys, scheduleKeys, sessionsKeys, sortData, useActivities, useActivityTrend, useArchiveSession, useBatchDelete, useBatchedResourcesHealth, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCheckpointTasks, useCommandQueue, useCommandQueueTotals, useCommandViewData, useCommandViewLayout, useCommandViewStats, useCommandViewStore, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useCreateSession, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useDeleteSession, useDeleteTask, useDeploymentDocs, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogSSE, useExecutionLogs, useExecutionPanelState, useExecutions, useGetExecutionHistory, useGetSchedule, useGraphStats, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePaginationState, usePatchTask, usePauseSchedule, useRecentExecutionsByResource, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResourceErrors, useResourceExecutions, useResources, useResourcesHealth, useResumeSchedule, useRetryExecution, useSSEConnection, useScheduledTasks, useSession, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket, useSessions, useSortedData, useSubmitAction, useSuccessNotification, useTableSelection, useTableSort, useTestNotification, useTopFailingResources, useUnresolveError, useUnresolvedErrors, useUpdateAnchor, useUpdateSchedule, useWarningNotification };
+export type { ActivityTrendResponse, BulkDeleteExecutionsParams, BulkDeleteExecutionsResult, BusinessImpactMetrics, CancelExecutionParams, CancelExecutionResult, ChatMessage, CostBreakdownItem, CreateScheduleInput, CreateSessionResponse, DeleteExecutionParams, DocFile, ErrorDistributionItem, ErrorDistributionParams, ErrorFilters, ErrorTrendsParams, ExecuteAsyncParams, ExecuteAsyncResult, ExecutionErrorDetails, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogsPageResponse, FailingResource, GetMessagesResponse, ListActivitiesResponse, ListSchedulesFilters, ListSchedulesResponse, MessageEvent, MessageType, ResourcesResponse, RetryExecutionParams, SessionDTO, SessionExecution, SessionExecutionsResponse, SessionListItem, SessionTokenUsage, SortDirection, SortState, SubmitActionRequest, SubmitActionResponse, TaskSchedule, TopFailingResourcesParams, UpdateScheduleInput, UseActivitiesParams, UseActivityTrendParams, UseBatchedResourcesHealthParams, UseExecutionHealthParams, UseExecutionLogsParams, UseExecutionPanelStateOptions, UseExecutionPanelStateReturn, UseResourcesHealthParams, UseSSEConnectionOptions, UseScheduledTasksOptions, WebSocketState };