@elevasis/ui 2.25.5 → 2.26.0

package/dist/{chunk-N2AP4I5N.js → chunk-UY5I2KOZ.js}

@@ -1,34 +1,35 @@
-import { SubshellSidebarLoader, SubshellLoader } from './chunk-N55DVMAG.js';
 import { ChatHeader, ChatSidebar } from './chunk-ROSMICXG.js';
-import { BaseNode, useGraphTheme, BaseEdge, FormFieldRenderer, ExecutionStats, UnifiedWorkflowGraph, WorkflowExecutionTimeline, AgentExecutionVisualizer, AgentExecutionTimeline, GraphBackground, GraphFitViewButton, GraphFitViewHandler } from './chunk-NHHCUECV.js';
-import { OrganizationModelProspectingSchema } from './chunk-IS53MXE4.js';
-import { ResourceHealthPanel } from './chunk-FVKLHLF4.js';
-import { useCyberColors, CyberDonut } from './chunk-KMAXFJPH.js';
+import { getOrganizationGraphLensConfig, useOrganizationGraphFilters, createOrganizationGraphFilters, buildOrganizationGraph, filterOrganizationGraph, getCommandViewVisibilityProjection, resolveOrganizationGraphPathTrace, getCommandViewOperationalOverview, getCommandViewSelectionOperationalSummary, buildCommandViewDrillDownSections, expandAroundGraph, getConnectedHiddenResourceIds, FilterPanel, OrganizationGraphDetailPanel, ExpandAroundPanel, CommandViewSidebarContent, getOrganizationGraphTraceNodeOptions, formatOrganizationGraphTraceNodeOptionLabel } from './chunk-OHXU5WWK.js';
+import { SubshellLoader } from './chunk-JDNEWB5F.js';
+import { resolveSemanticIconComponent } from './chunk-KEFWANZY.js';
+import { SubshellSidebarLoader } from './chunk-XQQEKWTL.js';
+import { BaseNode, useGraphTheme, BaseEdge, ExecutionStats, UnifiedWorkflowGraph, WorkflowExecutionTimeline, AgentExecutionVisualizer, AgentExecutionTimeline, GraphBackground, GraphFitViewButton, GraphFitViewHandler } from './chunk-G66QFZXD.js';
+import { FormFieldRenderer } from './chunk-3MEXPLWT.js';
+import { ResourceHealthPanel } from './chunk-YO2YORW4.js';
+import { useCyberColors, CyberDonut } from './chunk-CW3UNAF2.js';
 import { AppShellLoader } from './chunk-RYTEQBAO.js';
 import { PageContainer } from './chunk-BZZCNLT6.js';
 import { SubshellSidebarSection } from './chunk-IIMU5YAJ.js';
 import { CustomModal, ConfirmationModal } from './chunk-KVJ3LFH2.js';
-import { getResourceStatusColor, useTimelineData, useAgentIterationData, getStatusIcon } from './chunk-E4WQGJNS.js';
-import { useErrorDetail, useExecution, useArchivedLogs, useDeleteExecution, useRetryExecution, useCancelExecution, useCommandQueueTotals, useStatusFilter, useResourceSearch, useResourcesDomainFilters, usePaginationState, useResources, useRecentExecutionsByResource, filterByDomainFilters, collectResourceFilterFacets, useExecuteAsync, useResourceDefinition, isSessionCapable, useDeleteTask, useCommandQueue, useSubmitAction, useCommandViewData, useCommandViewStats, useCommandViewStore, useResourceExecutions, useCheckpointTasks, COMMAND_VIEW_VISUALIZATION_MODES, useExecutionPanelState, useDeleteSession, useCreateSession, useSessions, useSessionExecutions, useSession, useBulkDeleteExecutions, getCommandViewGraphPositions } from './chunk-5BJXMZN4.js';
-import { showApiErrorNotification, showSuccessNotification } from './chunk-HKBEURCV.js';
 import { useGraphHighlighting, calculateGraphHeight, Graph_module_css_default, GRAPH_CONSTANTS } from './chunk-22UVE3RA.js';
+import { getResourceStatusColor, useTimelineData, useAgentIterationData, getStatusIcon } from './chunk-E4WQGJNS.js';
+import { useErrorDetail, useExecution, useArchivedLogs, useDeleteExecution, useRetryExecution, useCancelExecution, useCommandQueueTotals, useStatusFilter, useResourceSearch, useResourcesDomainFilters, usePaginationState, useResources, useRecentExecutionsByResource, filterByDomainFilters, collectResourceFilterFacets, useResourceDefinition, isSessionCapable, useDeleteTask, useCommandQueue, useSubmitAction, useCommandViewData, useCommandViewStats, useCommandViewStore, useResourceExecutions, useCheckpointTasks, COMMAND_VIEW_VISUALIZATION_MODES, useExecutionPanelState, useDeleteSession, useCreateSession, useSessions, useSessionExecutions, useSession, useBulkDeleteExecutions, getCommandViewGraphPositions } from './chunk-YHBPR67D.js';
+import { showApiErrorNotification, showSuccessNotification } from './chunk-G26INIF3.js';
 import { useMergedExecution } from './chunk-3ZMAGTWF.js';
+import { JsonViewer, CardHeader, PageTitleCaption, CollapsibleSection, TabCountBadge, ResourceCard, ContextViewer, EmptyState, APIErrorAlert } from './chunk-RIFTUOPE.js';
+import { StyledMarkdown } from './chunk-3KMDHCAR.js';
+import { useOptionalElevasisFeatures, useElevasisFeatures } from './chunk-V3HUIZJX.js';
 import { SubshellContentContainer } from './chunk-TKAYX2SP.js';
-import { JsonViewer, CardHeader, PageTitleCaption, CollapsibleSection, TabCountBadge, ResourceCard, ContextViewer, EmptyState, APIErrorAlert } from './chunk-U36X6NZM.js';
 import { NavigationButton } from './chunk-NYBEU5TE.js';
-import { LabelSchema, ColorTokenSchema, IconNameSchema, PathSchema, DescriptionSchema, DisplayMetadataSchema, ModelIdSchema, ReferenceIdsSchema, OrganizationModelSalesSchema } from './chunk-JMI7L7Y7.js';
-import { useOptionalElevasisFeatures, useElevasisFeatures } from './chunk-V3HUIZJX.js';
-import { StyledMarkdown } from './chunk-3KMDHCAR.js';
 import { useRouterContext } from './chunk-Q7DJKLEN.js';
 import { useAppearance } from './chunk-E565XMTQ.js';
 import { topbarHeight } from './chunk-DT3QYZVU.js';
-import { getErrorInfo, formatErrorMessage, getResourceIcon, formatRelativeTime, getNodeId, PAGE_SIZE_DEFAULT, debounce } from './chunk-SGXXJE52.js';
+import { getErrorInfo, formatErrorMessage, getResourceIcon, formatRelativeTime, PAGE_SIZE_DEFAULT, debounce } from './chunk-QD4X4H5A.js';
 import { ResourceStatusColors, toWorkflowLogMessages } from './chunk-KRWALB24.js';
 import { useInitialization } from './chunk-WKJ47GIW.js';
 import { useOrganization } from './chunk-DD3CCMCZ.js';
-import { z } from 'zod';
-import { Stack, Group, Text, Badge, Title, Textarea, Alert, Button, ActionIcon, Collapse, Card, ThemeIcon, SimpleGrid, Divider, Paper, Space, CopyButton, Center, Tooltip, Code, Menu, useMantineTheme, UnstyledButton, Select, RangeSlider, Box, Progress, Tabs, Pagination, TextInput, Modal, LoadingOverlay, Loader, SegmentedControl, ScrollArea, Checkbox, NumberInput, MultiSelect, Switch } from '@mantine/core';
-import { IconBrain, IconFileText, IconMail, IconSend, IconClock, IconArrowUp, IconMessageCircle, IconRocket, IconEye, IconEdit, IconAlertTriangle, IconRefresh, IconX, IconCheck, IconCode, IconAlertCircle, IconChevronRight, IconTool, IconSettings, IconCpu, IconClockHour4, IconVersions, IconPlayerPlay, IconNetwork, IconSitemap, IconCopy, IconPlayerStop, IconReload, IconTrash, IconTerminal2, IconBug, IconChevronDown, IconMessage, IconArrowLeft, IconRobot, IconGitBranch, IconDotsVertical, IconFilter, IconCircleCheck, IconCategory, IconDatabase, IconApps, IconRoute, IconAdjustmentsHorizontal, IconSearch, IconCircleX, IconCircleDashed, IconExternalLink, IconFolders, IconBraces, IconBolt, IconTopologyStar3, IconInfoCircle, IconPlus, IconLayoutSidebarRightExpand, IconNote, IconArchive, IconDownload, IconTimeline, IconActivityHeartbeat, IconClockPause, IconArrowsMaximize, IconShare2, IconHistory } from '@tabler/icons-react';
+import { Stack, Group, Text, Badge, Title, Textarea, Alert, Button, ActionIcon, Collapse, Card, ThemeIcon, SimpleGrid, Divider, Paper, Space, CopyButton, Center, Tooltip, Code, Menu, useMantineTheme, UnstyledButton, Select, RangeSlider, Box, Progress, Tabs, Pagination, TextInput, Loader, SegmentedControl, Modal, LoadingOverlay, ScrollArea } from '@mantine/core';
+import { IconBrain, IconFileText, IconMail, IconSend, IconClock, IconArrowUp, IconMessageCircle, IconRocket, IconEye, IconEdit, IconAlertTriangle, IconRefresh, IconX, IconCheck, IconCode, IconAlertCircle, IconChevronRight, IconTool, IconSettings, IconCpu, IconClockHour4, IconVersions, IconNetwork, IconSitemap, IconCopy, IconPlayerStop, IconReload, IconTrash, IconTerminal2, IconBug, IconChevronDown, IconPlayerPlay, IconMessage, IconArrowLeft, IconRobot, IconGitBranch, IconDotsVertical, IconFilter, IconCircleCheck, IconCategory, IconDatabase, IconApps, IconRoute, IconAdjustmentsHorizontal, IconSearch, IconCircleX, IconCircleDashed, IconExternalLink, IconFolders, IconBraces, IconBolt, IconTopologyStar3, IconInfoCircle, IconPlus, IconLayoutSidebarRightExpand, IconNote, IconArchive, IconDownload, IconTimeline, IconActivityHeartbeat, IconClockPause, IconArrowsMaximize, IconHistory } from '@tabler/icons-react';
 import { useForm } from '@mantine/form';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { memo, useState, useMemo, useRef, useCallback, useEffect, useDeferredValue, useEffectEvent } from 'react';
@@ -39,725 +40,7 @@ import { useClipboard } from '@mantine/hooks';
 import { notifications } from '@mantine/notifications';
 import { useNavigate } from '@tanstack/react-router';
 import cytoscape from 'cytoscape';
-import { create } from 'zustand';
-import { formatDistanceToNow } from 'date-fns';
-
-var NodeIdPathSchema = z.string().trim().min(1).max(100).regex(/^([a-z0-9-]+)(\.[a-z0-9-]+)*$/, "Node IDs must be lowercase dotted paths");
-var NodeIdStringSchema = z.string().trim().min(1).max(200).regex(/^[a-z]+:([a-z0-9-]+)(\.[a-z0-9-]+)*$/, "Node references must use kind:dotted-path");
-var UiPositionSchema = z.enum(["sidebar-primary", "sidebar-bottom"]);
-var FeatureSchema = z.object({
-  id: NodeIdPathSchema,
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().default(true),
-  path: PathSchema.optional(),
-  icon: IconNameSchema.optional(),
-  color: ColorTokenSchema.optional(),
-  uiPosition: UiPositionSchema.optional(),
-  requiresAdmin: z.boolean().optional(),
-  devOnly: z.boolean().optional()
-});
-var OrganizationModelBrandingSchema = z.object({
-  organizationName: LabelSchema,
-  productName: LabelSchema,
-  shortName: z.string().trim().min(1).max(40),
-  description: DescriptionSchema.optional(),
-  logos: z.object({
-    light: z.string().trim().min(1).max(2048).optional(),
-    dark: z.string().trim().min(1).max(2048).optional()
-  }).default({})
-});
-var ProjectsDomainStateSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  order: z.number().int().min(0)
-});
-var OrganizationModelProjectsSchema = z.object({
-  projectEntityId: ModelIdSchema,
-  milestoneEntityId: ModelIdSchema,
-  taskEntityId: ModelIdSchema,
-  projectStatuses: z.array(ProjectsDomainStateSchema).min(1),
-  milestoneStatuses: z.array(ProjectsDomainStateSchema).min(1),
-  taskStatuses: z.array(ProjectsDomainStateSchema).min(1)
-});
-var SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]);
-var SurfaceDefinitionSchema = z.object({
-  id: ModelIdSchema,
-  label: LabelSchema,
-  path: PathSchema,
-  surfaceType: SurfaceTypeSchema,
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().default(true),
-  devOnly: z.boolean().optional(),
-  icon: IconNameSchema.optional(),
-  featureId: ModelIdSchema.optional(),
-  featureIds: ReferenceIdsSchema,
-  entityIds: ReferenceIdsSchema,
-  resourceIds: ReferenceIdsSchema,
-  capabilityIds: ReferenceIdsSchema,
-  parentId: ModelIdSchema.optional()
-});
-var NavigationGroupSchema = z.object({
-  id: ModelIdSchema,
-  label: LabelSchema,
-  placement: z.string().trim().min(1).max(50),
-  surfaceIds: z.array(ModelIdSchema).default([])
-});
-var OrganizationModelNavigationSchema = z.object({
-  defaultSurfaceId: ModelIdSchema.optional(),
-  surfaces: z.array(SurfaceDefinitionSchema).default([]),
-  groups: z.array(NavigationGroupSchema).default([])
-});
-var BusinessHoursDaySchema = z.object({
-  open: z.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format"),
-  close: z.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format")
-});
-var BusinessHoursSchema = z.object({
-  monday: BusinessHoursDaySchema.optional(),
-  tuesday: BusinessHoursDaySchema.optional(),
-  wednesday: BusinessHoursDaySchema.optional(),
-  thursday: BusinessHoursDaySchema.optional(),
-  friday: BusinessHoursDaySchema.optional(),
-  saturday: BusinessHoursDaySchema.optional(),
-  sunday: BusinessHoursDaySchema.optional()
-}).default({});
-var IdentityDomainSchema = z.object({
-  /** Why the organization exists — one or two plain-language sentences. */
-  mission: z.string().trim().max(1e3).default(""),
-  /** Long-term direction the organization is moving toward. */
-  vision: z.string().trim().max(1e3).default(""),
-  /** Legal registered name of the entity. */
-  legalName: z.string().trim().max(200).default(""),
-  /**
-   * Type of legal entity (e.g. "LLC", "Corporation", "Sole Proprietor",
-   * "Non-profit"). Free-form string so it covers any jurisdiction.
-   */
-  entityType: z.string().trim().max(100).default(""),
-  /**
-   * Primary jurisdiction of registration or operation
-   * (e.g. "United States – Delaware", "Canada – Ontario").
-   */
-  jurisdiction: z.string().trim().max(200).default(""),
-  /**
-   * Industry category — broad classification (e.g. "Marketing Agency",
-   * "Software / SaaS", "Professional Services").
-   */
-  industryCategory: z.string().trim().max(200).default(""),
-  /**
-   * Geographic focus — where the organization primarily operates or serves
-   * (e.g. "North America", "Global", "Southeast Asia").
-   */
-  geographicFocus: z.string().trim().max(200).default(""),
-  /**
-   * IANA timezone identifier for the organization's primary operating timezone
-   * (e.g. "America/Los_Angeles", "Europe/London", "UTC").
-   */
-  timeZone: z.string().trim().max(100).default("UTC"),
-  /** Typical operating hours per day of week. Empty object means not configured. */
-  businessHours: BusinessHoursSchema,
-  /**
-   * Long-form markdown capturing client context, problem narrative, and domain
-   * background. Populated by /setup; surfaced to agents as organizational context.
-   * Optional — many projects have no external client.
-   */
-  clientBrief: z.string().trim().default("")
-});
-var DEFAULT_ORGANIZATION_MODEL_IDENTITY = {
-  mission: "",
-  vision: "",
-  legalName: "",
-  entityType: "",
-  jurisdiction: "",
-  industryCategory: "",
-  geographicFocus: "",
-  timeZone: "UTC",
-  businessHours: {},
-  clientBrief: ""
-};
-var FirmographicsSchema = z.object({
-  /** Industry vertical (e.g. "Marketing Agency", "Legal", "Real Estate"). */
-  industry: z.string().trim().max(200).optional(),
-  /**
-   * Company headcount band (e.g. "1–10", "11–50", "51–200", "200+").
-   * Free-form string to accommodate any band notation.
-   */
-  companySize: z.string().trim().max(100).optional(),
-  /**
-   * Primary geographic region the segment operates in or is targeted from
-   * (e.g. "North America", "Europe", "Global").
-   */
-  region: z.string().trim().max(200).optional()
-});
-var CustomerSegmentSchema = z.object({
-  /** Stable unique identifier for the segment (e.g. "segment-smb-agencies"). */
-  id: z.string().trim().min(1).max(100),
-  /** Human-readable name shown to agents and in UI (e.g. "SMB Marketing Agencies"). */
-  name: z.string().trim().max(200).default(""),
-  /** One or two sentences describing who this segment is. */
-  description: z.string().trim().max(2e3).default(""),
-  /**
-   * The primary job(s) this segment is trying to get done — the goal they hire
-   * a product/service to accomplish. Plain-language narrative or bullet list.
-   */
-  jobsToBeDone: z.string().trim().max(2e3).default(""),
-  /**
-   * Pains — frustrations, obstacles, and risks the segment experiences
-   * when trying to accomplish their jobs-to-be-done.
-   */
-  pains: z.array(z.string().trim().max(500)).default([]),
-  /**
-   * Gains — outcomes and benefits the segment desires; positive motivators
-   * beyond merely resolving pains.
-   */
-  gains: z.array(z.string().trim().max(500)).default([]),
-  /** Firmographic profile for targeting and filtering. */
-  firmographics: FirmographicsSchema.default({}),
-  /**
-   * Value proposition — one or two sentences stating why this organization's
-   * offering is uniquely suited for this segment's needs.
-   */
-  valueProp: z.string().trim().max(2e3).default("")
-});
-var CustomersDomainSchema = z.object({
-  segments: z.array(CustomerSegmentSchema).default([])
-});
-var DEFAULT_ORGANIZATION_MODEL_CUSTOMERS = {
-  segments: []
-};
-var PricingModelSchema = z.enum(["one-time", "subscription", "usage-based", "custom"]);
-var ProductSchema = z.object({
-  /** Stable unique identifier for the product (e.g. "product-starter-plan"). */
-  id: z.string().trim().min(1).max(100),
-  /** Human-readable name shown to agents and in UI (e.g. "Starter Plan"). */
-  name: z.string().trim().max(200).default(""),
-  /** One or two sentences describing what this product/service delivers. */
-  description: z.string().trim().max(2e3).default(""),
-  /**
-   * How this product is priced:
-   * - "one-time" — single purchase (setup fee, project fee)
-   * - "subscription" — recurring (monthly/annual SaaS, retainer)
-   * - "usage-based" — metered by consumption (API calls, seats)
-   * - "custom" — negotiated or bespoke pricing
-   */
-  pricingModel: PricingModelSchema.default("custom"),
-  /** Base price amount (≥ 0). Currency unit defined by `currency`. */
-  price: z.number().min(0).default(0),
-  /**
-   * ISO 4217 currency code (e.g. "USD", "EUR", "GBP").
-   * Free-form string to accommodate any currency; defaults to "USD".
-   */
-  currency: z.string().trim().max(10).default("USD"),
-  /**
-   * IDs of customer segments this product targets.
-   * Each id must reference a declared `customers.segments[].id`.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  targetSegmentIds: z.array(z.string().trim().min(1)).default([]),
-  /**
-   * Optional: ID of the platform feature responsible for delivering this product.
-   * When present, must reference a declared `features[].id`.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  deliveryFeatureId: z.string().trim().min(1).optional()
-});
-var OfferingsDomainSchema = z.object({
-  products: z.array(ProductSchema).default([])
-});
-var DEFAULT_ORGANIZATION_MODEL_OFFERINGS = {
-  products: []
-};
-var RoleSchema = z.object({
-  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
-  id: z.string().trim().min(1).max(100),
-  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
-  title: z.string().trim().min(1).max(200),
-  /**
-   * List of responsibilities this role owns — plain-language descriptions of
-   * what the person in this role is accountable for delivering.
-   * Defaults to empty array so minimal role definitions stay concise.
-   */
-  responsibilities: z.array(z.string().trim().max(500)).default([]),
-  /**
-   * Optional: ID of another role this role reports to.
-   * When present, must reference another `roles[].id` in the same organization.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   * Absence indicates a top-level role (no reporting line).
-   */
-  reportsToId: z.string().trim().min(1).max(100).optional(),
-  /**
-   * Optional: name or email of the person currently holding this role.
-   * Free-form string — supports "Alice Johnson", "alice@example.com", or
-   * any human-readable identifier. Not validated against any user registry.
-   */
-  heldBy: z.string().trim().max(200).optional()
-});
-var RolesDomainSchema = z.object({
-  roles: z.array(RoleSchema).default([])
-});
-var DEFAULT_ORGANIZATION_MODEL_ROLES = {
-  roles: []
-};
-var KeyResultSchema = z.object({
-  /** Stable unique identifier for the measurable outcome (e.g. "kr-revenue-q1"). */
-  id: z.string().trim().min(1).max(100),
-  /** Plain-language description of this measurable outcome (e.g. "Increase trial-to-paid conversion"). */
-  description: z.string().trim().min(1).max(500),
-  /**
-   * What is being measured — the metric name (e.g. "monthly revenue", "NPS score",
-   * "trial-to-paid conversion rate"). Free-form string.
-   */
-  targetMetric: z.string().trim().min(1).max(200),
-  /** Current measured value. Defaults to 0 when not yet tracked. */
-  currentValue: z.number().default(0),
-  /**
-   * Target value to reach for this measurable outcome to be considered achieved.
-   * Optional — omit if the outcome is directional (e.g. "reduce churn") without
-   * a hard numeric target.
-   */
-  targetValue: z.number().optional()
-});
-var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
-var ObjectiveSchema = z.object({
-  /** Stable unique identifier for the goal (e.g. "goal-grow-arr-q1-2026"). */
-  id: z.string().trim().min(1).max(100),
-  /** Plain-language description of what the organization wants to achieve. */
-  description: z.string().trim().min(1).max(1e3),
-  /**
-   * Start of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
-   * Must be strictly before `periodEnd`.
-   */
-  periodStart: z.string().regex(ISO_DATE_REGEX, "periodStart must be an ISO date string (YYYY-MM-DD)"),
-  /**
-   * End of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
-   * Must be strictly after `periodStart`.
-   * Enforced via `OrganizationModelSchema.superRefine()`.
-   */
-  periodEnd: z.string().regex(ISO_DATE_REGEX, "periodEnd must be an ISO date string (YYYY-MM-DD)"),
-  /**
-   * List of measurable outcomes that define success for this goal.
-   * Defaults to empty array so goals can be declared before outcomes are defined.
-   */
-  keyResults: z.array(KeyResultSchema).default([])
-});
-var GoalsDomainSchema = z.object({
-  objectives: z.array(ObjectiveSchema).default([])
-});
-var DEFAULT_ORGANIZATION_MODEL_GOALS = {
-  objectives: []
-};
-var OperationSemanticClassSchema = z.enum(["queue", "executions", "sessions", "notifications", "schedules"]);
-var OperationEntrySchema = z.object({
-  id: z.string().trim().min(1).max(100),
-  label: z.string().trim().min(1).max(120),
-  semanticClass: OperationSemanticClassSchema,
-  /** Optional reference to the feature that owns this runtime entity. */
-  featureId: z.string().trim().min(1).max(100).optional(),
-  /**
-   * Optional pointer to the status semanticClass values that apply to this
-   * entity — ties operations back to the statuses domain for vibe rendering.
-   */
-  supportedStatusSemanticClass: z.array(z.string().trim().min(1).max(80)).optional()
-});
-var OperationsDomainSchema = z.object({
-  entries: z.array(OperationEntrySchema).default([])
-});
-var StatusSemanticClassSchema = z.enum([
-  "delivery.task",
-  "delivery.project",
-  "delivery.milestone",
-  "queue",
-  "execution",
-  "schedule",
-  "schedule.run",
-  "request"
-]);
-var StatusEntrySchema = z.object({
-  id: z.string().trim().min(1).max(100),
-  label: z.string().trim().min(1).max(120),
-  semanticClass: StatusSemanticClassSchema,
-  category: z.string().trim().min(1).max(80).optional()
-});
-var StatusesDomainSchema = z.object({
-  entries: z.array(StatusEntrySchema).default([])
-});
-var KnowledgeLinkSchema = z.object({
-  nodeId: NodeIdStringSchema
-});
-var OrgKnowledgeKindSchema = z.enum(["playbook", "strategy", "reference"]);
-var OrgKnowledgeNodeSchema = z.object({
-  id: ModelIdSchema,
-  kind: OrgKnowledgeKindSchema,
-  title: z.string().trim().min(1).max(200),
-  summary: z.string().trim().min(1).max(1e3),
-  /** Raw MDX string. Phase 2 will introduce a structured block format. */
-  body: z.string().trim().min(1),
-  /**
-   * Graph links to other OM nodes this knowledge node governs.
-   * Each link emits a `governs` edge: knowledge-node -> target node.
-   */
-  links: z.array(KnowledgeLinkSchema).default([]),
-  /** Identifiers of the roles or members who own this knowledge node. */
-  ownerIds: z.array(ModelIdSchema).default([]),
-  /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
-  updatedAt: z.string().trim().min(1).max(50)
-});
-var KnowledgeDomainSchema = z.object({
-  nodes: z.array(OrgKnowledgeNodeSchema).default([])
-});
-
-// ../core/src/organization-model/schema.ts
-var OrganizationModelSchemaBase = z.object({
-  version: z.literal(1).default(1),
-  features: z.array(FeatureSchema).default([]),
-  branding: OrganizationModelBrandingSchema,
-  navigation: OrganizationModelNavigationSchema.default({ surfaces: [], groups: [] }),
-  sales: OrganizationModelSalesSchema,
-  prospecting: OrganizationModelProspectingSchema,
-  projects: OrganizationModelProjectsSchema,
-  identity: IdentityDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_IDENTITY),
-  customers: CustomersDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_CUSTOMERS),
-  offerings: OfferingsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_OFFERINGS),
-  roles: RolesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ROLES),
-  goals: GoalsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_GOALS),
-  statuses: StatusesDomainSchema.default({ entries: [] }),
-  operations: OperationsDomainSchema.default({ entries: [] }),
-  knowledge: KnowledgeDomainSchema.default({ nodes: [] })
-});
-function addIssue(ctx, path, message) {
-  ctx.addIssue({
-    code: z.ZodIssueCode.custom,
-    path,
-    message
-  });
-}
-function collectIds(items, ctx, collectionPath, label) {
-  const itemsById = /* @__PURE__ */ new Map();
-  items.forEach((item, index) => {
-    if (itemsById.has(item.id)) {
-      addIssue(ctx, [...collectionPath, index, "id"], `${label} id "${item.id}" must be unique`);
-      return;
-    }
-    itemsById.set(item.id, item);
-  });
-  return itemsById;
-}
-var LEGACY_FEATURE_ALIASES = /* @__PURE__ */ new Map([
-  ["crm", "sales.crm"],
-  ["lead-gen", "sales.lead-gen"],
-  ["submitted-requests", "monitoring.submitted-requests"]
-]);
-function hasFeature(featuresById, featureId) {
-  return featuresById.has(featureId) || featuresById.has(LEGACY_FEATURE_ALIASES.get(featureId) ?? "");
-}
-var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
-  const featuresById = collectIds(model.features, ctx, ["features"], "Feature");
-  model.features.forEach((feature, featureIndex) => {
-    const segments = feature.id.split(".");
-    if (segments.length > 1) {
-      const parentId = segments.slice(0, -1).join(".");
-      if (!featuresById.has(parentId)) {
-        addIssue(
-          ctx,
-          ["features", featureIndex, "id"],
-          `Feature "${feature.id}" references unknown parent "${parentId}"`
-        );
-      }
-    }
-    const hasChildren = model.features.some(
-      (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.id !== feature.id
-    );
-    if (hasChildren && feature.enabled) {
-      const hasEnabledDescendant = model.features.some(
-        (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.enabled
-      );
-      if (!hasEnabledDescendant) {
-        addIssue(
-          ctx,
-          ["features", featureIndex, "enabled"],
-          `Feature "${feature.id}" is enabled but has no enabled descendants`
-        );
-      }
-    }
-  });
-  const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]));
-  model.offerings.products.forEach((product, productIndex) => {
-    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
-      if (!segmentsById.has(segmentId)) {
-        addIssue(
-          ctx,
-          ["offerings", "products", productIndex, "targetSegmentIds", segmentIndex],
-          `Product "${product.id}" references unknown customer segment "${segmentId}"`
-        );
-      }
-    });
-    if (product.deliveryFeatureId !== void 0 && !hasFeature(featuresById, product.deliveryFeatureId)) {
-      addIssue(
-        ctx,
-        ["offerings", "products", productIndex, "deliveryFeatureId"],
-        `Product "${product.id}" references unknown delivery feature "${product.deliveryFeatureId}"`
-      );
-    }
-  });
-  model.goals.objectives.forEach((objective, index) => {
-    if (objective.periodEnd <= objective.periodStart) {
-      addIssue(
-        ctx,
-        ["goals", "objectives", index, "periodEnd"],
-        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
-      );
-    }
-  });
-  const rolesById = new Map(model.roles.roles.map((role) => [role.id, role]));
-  model.roles.roles.forEach((role, roleIndex) => {
-    if (role.reportsToId !== void 0 && !rolesById.has(role.reportsToId)) {
-      addIssue(
-        ctx,
-        ["roles", "roles", roleIndex, "reportsToId"],
-        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
-      );
-    }
-  });
-});
-
-// ../core/src/organization-model/graph/schema.ts
-var OrganizationGraphNodeKindSchema = z.enum([
-  "organization",
-  "feature",
-  "surface",
-  "entity",
-  "capability",
-  "resource",
-  "knowledge"
-]);
-var OrganizationGraphEdgeKindSchema = z.enum([
-  "contains",
-  "references",
-  "exposes",
-  "maps_to",
-  "operates-on",
-  "uses",
-  "governs"
-]);
-var OrganizationGraphNodeSchema = z.object({
-  id: z.string().trim().min(1).max(200),
-  kind: OrganizationGraphNodeKindSchema,
-  label: LabelSchema,
-  sourceId: z.string().trim().min(1).max(255).optional(),
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().optional(),
-  featureId: z.string().trim().min(1).max(100).optional(),
-  resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]).optional()
-});
-var OrganizationGraphEdgeSchema = z.object({
-  id: z.string().trim().min(1).max(250),
-  kind: OrganizationGraphEdgeKindSchema,
-  sourceId: z.string().trim().min(1).max(200),
-  targetId: z.string().trim().min(1).max(200),
-  label: z.string().trim().min(1).max(120).optional(),
-  relationshipType: z.enum(["triggers", "uses", "approval"]).optional()
-});
-var OrganizationGraphSchema = z.object({
-  version: z.literal(1),
-  organizationModelVersion: OrganizationModelSchema.shape.version,
-  nodes: z.array(OrganizationGraphNodeSchema),
-  edges: z.array(OrganizationGraphEdgeSchema)
-});
-var BuildOrganizationGraphInputSchema = z.object({
-  organizationModel: OrganizationModelSchema,
-  commandViewData: z.unknown().optional()
-});
 
-// ../core/src/organization-model/graph/build.ts
-function nodeId(kind, sourceId) {
-  return kind === "organization" ? "organization-model" : `${kind}:${sourceId ?? ""}`;
-}
-function edgeId(kind, sourceId, targetId, variant) {
-  return variant ? `edge:${kind}:${variant}:${sourceId}:${targetId}` : `edge:${kind}:${sourceId}:${targetId}`;
-}
-function pushUniqueNode(nodes, seen, node) {
-  if (seen.has(node.id)) return;
-  seen.add(node.id);
-  nodes.push(node);
-}
-function pushUniqueEdge(edges, seen, edge) {
-  if (seen.has(edge.id)) return;
-  seen.add(edge.id);
-  edges.push(edge);
-}
-function upsertResourceNode(nodes, seen, resourceNodesById, node) {
-  const existing = resourceNodesById.get(node.id);
-  if (existing) {
-    if (!existing.label || existing.label === existing.sourceId) {
-      existing.label = node.label;
-    }
-    if (!existing.description && node.description) {
-      existing.description = node.description;
-    }
-    if (!existing.sourceId && node.sourceId) {
-      existing.sourceId = node.sourceId;
-    }
-    if (!existing.resourceType && node.resourceType) {
-      existing.resourceType = node.resourceType;
-    }
-    return existing;
-  }
-  resourceNodesById.set(node.id, node);
-  pushUniqueNode(nodes, seen, node);
-  return node;
-}
-function ensureResourceNode(nodes, seen, resourceNodesById, resourceId) {
-  const existing = resourceNodesById.get(nodeId("resource", resourceId));
-  if (existing) return existing;
-  return upsertResourceNode(nodes, seen, resourceNodesById, {
-    id: nodeId("resource", resourceId),
-    kind: "resource",
-    label: resourceId,
-    sourceId: resourceId
-  });
-}
-function normalizeCommandViewResourceType(resourceType) {
-  return resourceType === "human" ? "human_checkpoint" : resourceType;
-}
-function collectCommandViewResources(commandViewData) {
-  return [
-    ...commandViewData.workflows,
-    ...commandViewData.agents,
-    ...commandViewData.triggers,
-    ...commandViewData.integrations,
-    ...commandViewData.externalResources,
-    ...commandViewData.humanCheckpoints
-  ];
-}
-function pushResourceLinks(edges, edgeIds, resourceNodeId, links) {
-  for (const link of links ?? []) {
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId(link.kind, resourceNodeId, link.nodeId),
-      kind: link.kind,
-      sourceId: resourceNodeId,
-      targetId: link.nodeId
-    });
-  }
-}
-function buildOrganizationGraph(input) {
-  const parsed = BuildOrganizationGraphInputSchema.parse(input);
-  const organizationModel = parsed.organizationModel;
-  const commandViewData = parsed.commandViewData;
-  const nodes = [];
-  const edges = [];
-  const nodeIds = /* @__PURE__ */ new Set();
-  const edgeIds = /* @__PURE__ */ new Set();
-  const resourceNodesById = /* @__PURE__ */ new Map();
-  const organizationNode = {
-    id: nodeId("organization"),
-    kind: "organization",
-    label: "Organization Model"
-  };
-  pushUniqueNode(nodes, nodeIds, organizationNode);
-  for (const feature of [...organizationModel.features].sort((a, b) => a.id.localeCompare(b.id))) {
-    const id = nodeId("feature", feature.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "feature",
-      label: feature.label,
-      sourceId: feature.id,
-      description: feature.description,
-      enabled: feature.enabled,
-      featureId: feature.id
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-    const parentId = feature.id.includes(".") ? feature.id.slice(0, feature.id.lastIndexOf(".")) : void 0;
-    if (parentId) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("contains", nodeId("feature", parentId), id),
-        kind: "contains",
-        sourceId: nodeId("feature", parentId),
-        targetId: id
-      });
-    }
-  }
-  for (const node of [...organizationModel.knowledge?.nodes ?? []].sort((a, b) => a.id.localeCompare(b.id))) {
-    const id = nodeId("knowledge", node.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "knowledge",
-      label: node.title,
-      sourceId: node.id,
-      description: node.summary
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-    for (const link of node.links) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("governs", id, link.nodeId),
-        kind: "governs",
-        sourceId: id,
-        targetId: link.nodeId
-      });
-    }
-  }
-  if (commandViewData) {
-    const commandViewResources = collectCommandViewResources(commandViewData).sort(
-      (a, b) => a.resourceId.localeCompare(b.resourceId)
-    );
-    for (const resource of commandViewResources) {
-      const id = nodeId("resource", resource.resourceId);
-      const resourceNode = upsertResourceNode(nodes, nodeIds, resourceNodesById, {
-        id,
-        kind: "resource",
-        label: resource.name,
-        sourceId: resource.resourceId,
-        description: resource.description,
-        resourceType: normalizeCommandViewResourceType(resource.type)
-      });
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("contains", organizationNode.id, resourceNode.id),
-        kind: "contains",
-        sourceId: organizationNode.id,
-        targetId: resourceNode.id
-      });
-      pushResourceLinks(edges, edgeIds, resourceNode.id, resource.links);
-    }
-    for (const relationship of [...commandViewData.edges].sort((a, b) => a.id.localeCompare(b.id))) {
-      const sourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.source);
-      const targetNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.target);
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("contains", organizationNode.id, sourceNode.id),
-        kind: "contains",
-        sourceId: organizationNode.id,
-        targetId: sourceNode.id
-      });
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("contains", organizationNode.id, targetNode.id),
-        kind: "contains",
-        sourceId: organizationNode.id,
-        targetId: targetNode.id
-      });
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("references", sourceNode.id, targetNode.id, relationship.relationship),
-        kind: "references",
-        sourceId: sourceNode.id,
-        targetId: targetNode.id,
-        label: relationship.relationship,
-        relationshipType: relationship.relationship
-      });
-    }
-  }
-  const graph = {
-    version: 1,
-    organizationModelVersion: organizationModel.version,
-    nodes,
-    edges
-  };
-  return OrganizationGraphSchema.parse(graph);
-}
 var iconMap = {
   IconCheck,
   IconX,
@@ -773,13 +56,35 @@ var iconMap = {
   IconSend,
   IconMail
 };
+var semanticActionIconMap = {
+  "action.approve": IconCheck,
+  "action.reject": IconX,
+  "action.retry": IconRefresh,
+  "action.escalate": IconAlertTriangle,
+  "action.edit": IconEdit,
+  "action.view": IconEye,
+  "action.launch": IconRocket,
+  "action.message": IconMessageCircle,
+  "action.promote": IconArrowUp,
+  "action.submit": IconSend,
+  "action.email": IconMail,
+  "status.pending": IconClock,
+  "status.success": IconCheck,
+  "status.error": IconX,
+  "status.warning": IconAlertTriangle
+};
 function getIcon(iconName) {
   if (!iconName) return null;
-  const icon = iconMap[iconName];
-  if (!icon && process.env.NODE_ENV !== "production") {
-    console.warn(`[iconMap] Unknown icon "${iconName}". Allowed: ${Object.keys(iconMap).join(", ")}`);
+  const icon = iconMap[iconName] ?? semanticActionIconMap[iconName];
+  if (icon) return icon;
+  const semanticIcon = resolveSemanticIconComponent(iconName);
+  if (semanticIcon) return semanticIcon;
+  if (process.env.NODE_ENV !== "production") {
+    console.warn(
+      `[iconMap] Unknown icon "${iconName}". Allowed legacy names: ${Object.keys(iconMap).join(", ")}. Semantic action/status tokens are also supported.`
+    );
   }
-  return icon || null;
+  return null;
 }
 function resolveDefaultValue(context, path) {
   if (!context || typeof context !== "object") return void 0;
@@ -1305,20 +610,6 @@ function AgentDefinitionDisplay({ agent, defaultExpanded = false }) {
                 }
               ]
             }
-          ),
-          /* @__PURE__ */ jsx(
-            ConfigCard,
-            {
-              icon: /* @__PURE__ */ jsx(IconPlayerPlay, { size: 14 }),
-              title: "Execution Interface",
-              color: "teal",
-              items: [
-                {
-                  label: "Has Interface",
-                  value: agent.interface ? /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", color: "green", children: "Yes" }) : /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", color: "gray", children: "No" })
-                }
-              ]
-            }
           )
         ] }),
         /* @__PURE__ */ jsx("div", { style: { paddingLeft: "var(--mantine-spacing-xl)", marginTop: "var(--mantine-spacing-sm)" }, children: /* @__PURE__ */ jsx(ContractDisplay, { contract: agent.contract, defaultExpanded }) })
@@ -1437,36 +728,20 @@ function WorkflowDefinitionDisplay({ workflow, defaultExpanded = false }) {
       }
     ),
     /* @__PURE__ */ jsxs(Collapse, { in: configExpanded, children: [
-      /* @__PURE__ */ jsxs(SimpleGrid, { cols: 2, spacing: "sm", mt: "xs", pl: "xl", children: [
-        /* @__PURE__ */ jsx(
-          ConfigCard,
-          {
-            icon: /* @__PURE__ */ jsx(IconVersions, { size: 14 }),
-            title: "Version",
-            color: "grape",
-            items: [
-              {
-                label: "Version",
-                value: /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", children: workflow.config.version })
-              }
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          ConfigCard,
-          {
-            icon: /* @__PURE__ */ jsx(IconPlayerPlay, { size: 14 }),
-            title: "Execution Interface",
-            color: "teal",
-            items: [
-              {
-                label: "Has Interface",
-                value: workflow.interface ? /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", color: "green", children: "Yes" }) : /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", color: "gray", children: "No" })
-              }
-            ]
-          }
-        )
-      ] }),
+      /* @__PURE__ */ jsx("div", { style: { paddingLeft: "var(--mantine-spacing-xl)" }, children: /* @__PURE__ */ jsx(
+        ConfigCard,
+        {
+          icon: /* @__PURE__ */ jsx(IconVersions, { size: 14 }),
+          title: "Version",
+          color: "grape",
+          items: [
+            {
+              label: "Version",
+              value: /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", children: workflow.config.version })
+            }
+          ]
+        }
+      ) }),
       /* @__PURE__ */ jsx("div", { style: { paddingLeft: "var(--mantine-spacing-xl)", marginTop: "var(--mantine-spacing-sm)" }, children: /* @__PURE__ */ jsx(ContractDisplay, { contract: workflow.contract, defaultExpanded }) })
     ] })
   ] }) });
@@ -3441,174 +2716,12 @@ function ResourceNotFoundState2({ type, resourceId, onNavigateBack }) {
     /* @__PURE__ */ jsx(Button, { variant: "light", leftSection: /* @__PURE__ */ jsx(IconArrowLeft, { size: 16 }), onClick: handleBack, children: "Back to Operations" })
   ] }) }) });
 }
-function ExecuteWorkflowModal({
-  opened,
-  onClose,
-  resource,
-  isPending = false,
-  error,
-  result,
-  onViewExecution,
-  onReset,
-  children
-}) {
-  const canClose = !isPending;
-  const title = resource.name ?? resource.resourceId;
-  return /* @__PURE__ */ jsx(
-    Modal,
-    {
-      opened,
-      onClose: canClose ? onClose : () => void 0,
-      centered: true,
-      size: "lg",
-      closeOnClickOutside: canClose,
-      closeOnEscape: canClose,
-      withCloseButton: canClose,
-      title: /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
-        /* @__PURE__ */ jsxs(Text, { fw: 600, children: [
-          "Run ",
-          resource.resourceType
-        ] }),
-        /* @__PURE__ */ jsx(Badge, { color: "blue", variant: "light", size: "sm", children: resource.resourceType })
-      ] }),
-      children: /* @__PURE__ */ jsxs(Stack, { gap: "md", children: [
-        /* @__PURE__ */ jsxs(Group, { gap: 4, wrap: "nowrap", children: [
-          /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "Target:" }),
-          /* @__PURE__ */ jsx(Text, { size: "sm", fw: 500, children: title }),
-          /* @__PURE__ */ jsx(Code, { children: resource.resourceId })
-        ] }),
-        /* @__PURE__ */ jsx(Divider, {}),
-        result ? /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
-          /* @__PURE__ */ jsx(Alert, { variant: "light", color: "teal", title: "Execution started", icon: /* @__PURE__ */ jsx(IconCheck, { size: 16 }), children: /* @__PURE__ */ jsxs(Stack, { gap: 4, children: [
-            /* @__PURE__ */ jsxs(Text, { size: "sm", children: [
-              "The ",
-              resource.resourceType,
-              " is now running."
-            ] }),
-            /* @__PURE__ */ jsxs(Group, { gap: 4, children: [
-              /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: "Execution ID:" }),
-              /* @__PURE__ */ jsx(Code, { children: result.executionId })
-            ] })
-          ] }) }),
-          /* @__PURE__ */ jsxs(Group, { justify: "flex-end", gap: "xs", children: [
-            onReset && /* @__PURE__ */ jsx(Button, { variant: "default", onClick: onReset, children: "Run again" }),
-            onViewExecution && /* @__PURE__ */ jsx(
-              Button,
-              {
-                leftSection: /* @__PURE__ */ jsx(IconExternalLink, { size: 16 }),
-                onClick: () => onViewExecution(result.executionId),
-                children: "View execution"
-              }
-            ),
-            /* @__PURE__ */ jsx(Button, { variant: "light", onClick: onClose, children: "Close" })
-          ] })
-        ] }) : error ? /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
-          /* @__PURE__ */ jsx(Alert, { variant: "light", color: "red", title: "Execution failed to start", icon: /* @__PURE__ */ jsx(IconAlertCircle, { size: 16 }), children: /* @__PURE__ */ jsx(Text, { size: "sm", children: error.message || "An unknown error occurred." }) }),
-          /* @__PURE__ */ jsxs(Group, { justify: "flex-end", gap: "xs", children: [
-            onReset && /* @__PURE__ */ jsx(Button, { variant: "default", onClick: onReset, children: "Try again" }),
-            /* @__PURE__ */ jsx(Button, { variant: "light", onClick: onClose, children: "Close" })
-          ] })
-        ] }) : /* @__PURE__ */ jsxs("div", { style: { position: "relative" }, children: [
-          /* @__PURE__ */ jsx(LoadingOverlay, { visible: isPending, zIndex: 1e3, overlayProps: { blur: 2 } }),
-          children ?? /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "No input form provided." })
-        ] })
-      ] })
-    }
-  );
-}
-function getInitialValues(fields) {
-  const values = {};
-  for (const field of fields) {
-    values[field.name] = field.defaultValue ?? (field.type === "checkbox" ? false : "");
-  }
-  return values;
-}
-function applyFieldMappings(values, mappings) {
-  if (!mappings) return values;
-  const mapped = {};
-  for (const [key, value] of Object.entries(values)) {
-    const targetKey = mappings[key] ?? key;
-    mapped[targetKey] = value;
-  }
-  return mapped;
-}
-function ResourceExecuteForm({
-  formSchema,
-  onSubmit,
-  isPending = false,
-  disabled = false,
-  submitLabel = "Run"
-}) {
-  const hasFields = formSchema?.fields?.length > 0;
-  const form = useForm({
-    initialValues: hasFields ? getInitialValues(formSchema.fields) : {},
-    validate: hasFields ? Object.fromEntries(
-      formSchema.fields.filter((f) => f.required).map((f) => [
-        f.name,
-        (value) => !value && value !== false ? `${f.label} is required` : null
-      ])
-    ) : {}
-  });
-  const handleSubmit = (values) => {
-    const input = applyFieldMappings(values, formSchema?.fieldMappings);
-    void onSubmit(input);
-  };
-  if (!hasFields) {
-    return /* @__PURE__ */ jsxs(Stack, { children: [
-      /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "This workflow takes no input." }),
-      /* @__PURE__ */ jsx(Button, { onClick: () => void onSubmit({}), loading: isPending, disabled, fullWidth: true, children: isPending ? formSchema?.submitButton?.loadingLabel ?? "Running..." : submitLabel })
-    ] });
-  }
-  return /* @__PURE__ */ jsx("form", { onSubmit: form.onSubmit(handleSubmit), children: /* @__PURE__ */ jsxs(Stack, { children: [
-    formSchema.fields.map((field) => /* @__PURE__ */ jsx(FormFieldRenderer, { field, form }, field.name)),
-    /* @__PURE__ */ jsx(Button, { type: "submit", loading: isPending, disabled, fullWidth: true, children: isPending ? formSchema.submitButton?.loadingLabel ?? "Running..." : submitLabel })
-  ] }) });
-}
-function ResourceExecuteDialog({ opened, onClose, resource, onViewExecution }) {
-  const mutation = useExecuteAsync();
-  const handleSubmit = async (input) => {
-    await mutation.mutateAsync({
-      resourceId: resource.resourceId,
-      resourceType: resource.resourceType,
-      input
-    });
-  };
-  const handleReset = () => {
-    mutation.reset();
-  };
-  const modalResource = {
-    resourceId: resource.resourceId,
-    resourceType: resource.resourceType,
-    name: resource.name
-  };
-  return /* @__PURE__ */ jsx(
-    ExecuteWorkflowModal,
-    {
-      opened,
-      onClose,
-      resource: modalResource,
-      isPending: mutation.isPending,
-      error: mutation.error,
-      result: mutation.data ?? null,
-      onViewExecution,
-      onReset: handleReset,
-      children: /* @__PURE__ */ jsx(
-        ResourceExecuteForm,
-        {
-          formSchema: resource.formSchema ?? { fields: [] },
-          onSubmit: handleSubmit,
-          isPending: mutation.isPending,
-          disabled: mutation.isPending
-        }
-      )
-    }
-  );
-}
 function ResourceDetailPage({
   type,
   resourceId,
   timeRange,
   renderExecutionPanel,
+  renderExecuteDialog,
   onNavigateToResources,
   onNavigateToSessions,
   onNavigateBack
@@ -3644,19 +2757,13 @@ function ResourceDetailPage({
   const validResource = resource;
   const sessionCapable = isSessionCapable(type, resourceDefinition);
   return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(
-      ResourceExecuteDialog,
-      {
-        opened: runOpened,
-        onClose: () => setRunOpened(false),
-        resource: {
-          resourceId,
-          resourceType: type,
-          name: validResource.name,
-          formSchema: resourceDefinition?.interface?.form
-        }
-      }
-    ),
+    renderExecuteDialog({
+      opened: runOpened,
+      onClose: () => setRunOpened(false),
+      resourceId,
+      resourceType: type,
+      name: validResource.name
+    }),
     /* @__PURE__ */ jsxs(Stack, { children: [
       /* @__PURE__ */ jsx(
         ResourceHeader,
@@ -4265,2534 +3372,74 @@ function CommandQueueDetailPage({
     ] }) })
   ] });
 }
-
-// src/features/operations/organization-graph/organizationGraphDetail.ts
-var NODE_KIND_LABELS = {
-  organization: "Organization root",
-  feature: "Feature",
-  surface: "Surface",
-  entity: "Entity",
-  capability: "Capability",
-  resource: "Resource",
-  knowledge: "Knowledge"
-};
-var NODE_KIND_MEANINGS = {
-  organization: "The root of the shared organization model and the parent for every derived node.",
-  feature: "A feature that enables or disables downstream surfaces and model surfaces.",
-  surface: "A user-facing or operational surface that exposes feature behavior in the model.",
-  entity: "A shared business concept that can be referenced by surfaces, resources, or capabilities.",
-  capability: "A reusable capability that can be attached to a feature or surface.",
-  resource: "A concrete command-view or mapped resource that bridges execution topology into the model.",
-  knowledge: "An operational knowledge node that documents a process, strategy, or runbook in the org model."
-};
-var EDGE_KIND_LABELS = {
-  contains: "Containment",
-  references: "Reference",
-  exposes: "Exposure",
-  maps_to: "Mapping",
-  "operates-on": "Operates on",
-  uses: "Uses",
-  governs: "Governs"
-};
-var EDGE_KIND_MEANINGS = {
-  contains: "A hierarchy or ownership link inside the shared graph.",
-  references: "A semantic association or dependency between two graph nodes.",
-  exposes: "A feature enables a surface to be visible or reachable.",
-  maps_to: "A concrete resource is aligned to a domain, entity, capability, or surface.",
-  "operates-on": "A concrete resource operates on an Organization Model node.",
-  uses: "A concrete resource depends on another graph node or integration.",
-  governs: "A knowledge node governs or provides authoritative guidance for another node."
-};
-var RELATIONSHIP_MEANINGS = {
-  triggers: "Executable handoff: the source resource starts the target resource.",
-  uses: "Operational dependency: the source resource relies on the target integration.",
-  approval: "Human gate: the source resource pauses for approval at the target checkpoint."
+var cellStyle = {
+  padding: "var(--mantine-spacing-sm) var(--mantine-spacing-md)",
+  display: "flex",
+  alignItems: "center",
+  gap: "var(--mantine-spacing-sm)",
+  minWidth: 0
 };
-function titleCase(value) {
-  return value.replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim().split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
-function getGraphIndex(graph) {
-  const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
-  const edgesById = new Map(graph.edges.map((edge) => [edge.id, edge]));
-  return { nodesById, edgesById };
-}
-function getNodeKindLabel(kind) {
-  return NODE_KIND_LABELS[kind];
-}
-function getNodeMeaning(node) {
-  const baseMeaning = NODE_KIND_MEANINGS[node.kind];
-  if (node.kind === "feature") {
-    return node.enabled === false ? `${baseMeaning} This feature is currently disabled in the organization model.` : `${baseMeaning} This feature is currently enabled in the organization model.`;
-  }
-  if (node.kind === "resource" && node.resourceType) {
-    return `${baseMeaning} Resource type: ${titleCase(node.resourceType)}.`;
-  }
-  if (node.description) {
-    return `${baseMeaning} ${node.description}`;
-  }
-  return baseMeaning;
-}
-function getEdgeKindLabel(kind) {
-  return EDGE_KIND_LABELS[kind];
-}
-function getEdgeMeaning(edge, sourceNode, targetNode) {
-  const sourceLabel = sourceNode?.label ?? edge.sourceId;
-  const targetLabel = targetNode?.label ?? edge.targetId;
-  if (edge.relationshipType) {
-    const relationshipMeaning = RELATIONSHIP_MEANINGS[edge.relationshipType];
-    return `${relationshipMeaning} The graph renders the link from ${sourceLabel} to ${targetLabel} as a ${getEdgeKindLabel(edge.kind).toLowerCase()} edge.`;
-  }
-  return `${EDGE_KIND_MEANINGS[edge.kind]} This link connects ${sourceLabel} to ${targetLabel}.`;
-}
-function countByKind(nodes) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    counts.set(node.kind, (counts.get(node.kind) ?? 0) + 1);
-  }
-  return [...counts.entries()].map(([kind, count]) => ({
-    kind,
-    label: getNodeKindLabel(kind),
-    count
-  })).sort((left, right) => left.label.localeCompare(right.label));
-}
-function uniqueNodesById(nodes) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    byId.set(node.id, node);
-  }
-  return [...byId.values()];
-}
-function uniqueEdgesById(edges) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    byId.set(edge.id, edge);
-  }
-  return [...byId.values()];
-}
-function buildNodeState(graph, node, nodesById) {
-  const incidentEdges = graph.edges.filter((edge) => edge.sourceId === node.id || edge.targetId === node.id);
-  const incomingEdges = incidentEdges.filter((edge) => edge.targetId === node.id);
-  const outgoingEdges = incidentEdges.filter((edge) => edge.sourceId === node.id);
-  const adjacentNodes = uniqueNodesById(
-    incidentEdges.map((edge) => edge.sourceId === node.id ? nodesById.get(edge.targetId) : nodesById.get(edge.sourceId)).filter((value) => Boolean(value))
-  );
-  const relatedNodes = adjacentNodes.slice().sort((left, right) => left.label.localeCompare(right.label)).map((adjacentNode) => {
-    const contexts = incidentEdges.filter(
-      (edge) => edge.sourceId === node.id ? edge.targetId === adjacentNode.id : edge.sourceId === adjacentNode.id
-    ).map(
-      (edge) => `${edge.sourceId === node.id ? "outgoing" : "incoming"} via ${edge.label ?? getEdgeKindLabel(edge.kind).toLowerCase()}`
-    );
-    return {
-      id: adjacentNode.id,
-      label: adjacentNode.label,
-      kind: adjacentNode.kind,
-      kindLabel: getNodeKindLabel(adjacentNode.kind),
-      context: contexts.slice(0, 2).join(", ")
-    };
-  });
-  const relatedEdges = incidentEdges.slice().sort((left, right) => left.id.localeCompare(right.id)).map((edge) => {
-    const connectedId = edge.sourceId === node.id ? edge.targetId : edge.sourceId;
-    const connectedNode = nodesById.get(connectedId);
-    return {
-      id: edge.id,
-      label: edge.label ?? edge.relationshipType ?? getEdgeKindLabel(edge.kind),
-      kind: edge.kind,
-      kindLabel: getEdgeKindLabel(edge.kind),
-      context: `${edge.sourceId === node.id ? "outgoing" : "incoming"}${connectedNode ? ` to ${connectedNode.label}` : ""}`
-    };
-  });
-  const metadata = [
-    { label: "Graph ID", value: node.id },
-    { label: "Source ID", value: node.sourceId ?? node.id },
-    { label: "Kind", value: getNodeKindLabel(node.kind) }
-  ];
-  if (node.enabled !== void 0) {
-    metadata.push({ label: "Enabled", value: node.enabled ? "Yes" : "No" });
-  }
-  if (node.featureId) {
-    metadata.push({ label: "Feature ID", value: node.featureId });
-  }
-  if (node.resourceType) {
-    metadata.push({ label: "Resource Type", value: titleCase(node.resourceType) });
-  }
-  const meaningfulEdges = incidentEdges.filter((edge) => edge.kind !== "contains" || edge.relationshipType);
-  return {
-    state: "node",
-    title: node.label,
-    semanticCategory: getNodeKindLabel(node.kind),
-    operationalMeaning: getNodeMeaning(node),
-    description: node.description,
-    metrics: [
-      {
-        label: "Connected edges",
-        value: String(incidentEdges.length),
-        hint: "All direct relationships attached to this node"
-      },
-      { label: "Incoming", value: String(incomingEdges.length), hint: "Edges that point into this node" },
-      { label: "Outgoing", value: String(outgoingEdges.length), hint: "Edges that start at this node" },
-      {
-        label: "Meaningful links",
-        value: String(meaningfulEdges.length),
-        hint: "Edges with semantic or operational meaning"
-      }
-    ],
-    metadata,
-    adjacentKindCounts: countByKind(adjacentNodes),
-    node,
-    relatedNodes,
-    relatedEdges
-  };
-}
-function buildEdgeState(graph, edge, nodesById) {
-  const sourceNode = nodesById.get(edge.sourceId);
-  const targetNode = nodesById.get(edge.targetId);
-  const sourceIncidentEdges = graph.edges.filter(
-    (candidate) => candidate.sourceId === edge.sourceId || candidate.targetId === edge.sourceId
-  );
-  const targetIncidentEdges = graph.edges.filter(
-    (candidate) => candidate.sourceId === edge.targetId || candidate.targetId === edge.targetId
-  );
-  const adjacentNodes = uniqueNodesById(
-    [...sourceIncidentEdges, ...targetIncidentEdges].map((candidate) => {
-      if (candidate.sourceId === edge.sourceId) return nodesById.get(candidate.targetId);
-      if (candidate.targetId === edge.sourceId) return nodesById.get(candidate.sourceId);
-      if (candidate.sourceId === edge.targetId) return nodesById.get(candidate.targetId);
-      if (candidate.targetId === edge.targetId) return nodesById.get(candidate.sourceId);
-      return null;
-    }).filter((value) => Boolean(value)).filter((candidate) => candidate.id !== edge.sourceId && candidate.id !== edge.targetId)
-  );
-  const sourceNeighborIds = new Set(
-    sourceIncidentEdges.map((candidate) => {
-      if (candidate.sourceId === edge.sourceId) return candidate.targetId;
-      if (candidate.targetId === edge.sourceId) return candidate.sourceId;
-      return null;
-    }).filter((value) => Boolean(value))
-  );
-  const targetNeighborIds = new Set(
-    targetIncidentEdges.map((candidate) => {
-      if (candidate.sourceId === edge.targetId) return candidate.targetId;
-      if (candidate.targetId === edge.targetId) return candidate.sourceId;
-      return null;
-    }).filter((value) => Boolean(value))
-  );
-  const sharedNeighborCount = [...sourceNeighborIds].filter((neighborId) => targetNeighborIds.has(neighborId)).length;
-  const relatedNodes = adjacentNodes.slice().sort((left, right) => left.label.localeCompare(right.label)).map((adjacentNode) => {
-    const sourceContext = sourceIncidentEdges.some(
-      (candidate) => candidate.sourceId === edge.sourceId && candidate.targetId === adjacentNode.id || candidate.targetId === edge.sourceId && candidate.sourceId === adjacentNode.id
-    );
-    const targetContext = targetIncidentEdges.some(
-      (candidate) => candidate.sourceId === edge.targetId && candidate.targetId === adjacentNode.id || candidate.targetId === edge.targetId && candidate.sourceId === adjacentNode.id
-    );
-    const contextParts = [];
-    if (sourceContext) contextParts.push("source neighborhood");
-    if (targetContext) contextParts.push("target neighborhood");
-    return {
-      id: adjacentNode.id,
-      label: adjacentNode.label,
-      kind: adjacentNode.kind,
-      kindLabel: getNodeKindLabel(adjacentNode.kind),
-      context: contextParts.join(" + ")
-    };
-  });
-  const surroundingEdges = uniqueEdgesById([...sourceIncidentEdges, ...targetIncidentEdges]).filter((candidate) => candidate.id !== edge.id).sort((left, right) => left.id.localeCompare(right.id)).map((candidate) => {
-    const leftNode = nodesById.get(candidate.sourceId);
-    const rightNode = nodesById.get(candidate.targetId);
-    return {
-      id: candidate.id,
-      label: candidate.label ?? candidate.relationshipType ?? getEdgeKindLabel(candidate.kind),
-      kind: candidate.kind,
-      kindLabel: getEdgeKindLabel(candidate.kind),
-      context: `${leftNode?.label ?? candidate.sourceId} -> ${rightNode?.label ?? candidate.targetId}`
-    };
-  });
-  const metadata = [
-    { label: "Graph ID", value: edge.id },
-    { label: "Source ID", value: edge.sourceId },
-    { label: "Target ID", value: edge.targetId },
-    { label: "Edge kind", value: getEdgeKindLabel(edge.kind) }
-  ];
-  if (edge.label) {
-    metadata.push({ label: "Label", value: edge.label });
-  }
-  if (edge.relationshipType) {
-    metadata.push({ label: "Relationship", value: titleCase(edge.relationshipType) });
-  }
-  return {
-    state: "edge",
-    title: edge.label ?? `${sourceNode?.label ?? edge.sourceId} \u2192 ${targetNode?.label ?? edge.targetId}`,
-    semanticCategory: edge.relationshipType ? titleCase(edge.relationshipType) : getEdgeKindLabel(edge.kind),
-    operationalMeaning: getEdgeMeaning(edge, sourceNode, targetNode),
-    description: edge.label,
-    metrics: [
-      {
-        label: "Source degree",
-        value: String(sourceIncidentEdges.length),
-        hint: "Relationships attached to the source node"
-      },
-      {
-        label: "Target degree",
-        value: String(targetIncidentEdges.length),
-        hint: "Relationships attached to the target node"
-      },
-      {
-        label: "Nearby nodes",
-        value: String(adjacentNodes.length),
-        hint: "Unique nodes in the source and target neighborhoods"
-      },
-      {
-        label: "Shared peers",
-        value: String(sharedNeighborCount),
-        hint: "Neighbors that appear in both node neighborhoods"
-      }
-    ],
-    metadata,
-    adjacentKindCounts: countByKind(adjacentNodes),
-    edge,
-    sourceNode,
-    targetNode,
-    relatedNodes,
-    relatedEdges: surroundingEdges
-  };
-}
-function getOrganizationGraphDetailState(graph, selectedElement) {
-  if (!selectedElement) {
-    return {
-      state: "empty",
-      title: "No element selected",
-      semanticCategory: "Selection",
-      operationalMeaning: "Select a node or edge to inspect its semantic and operational context.",
-      metrics: [],
-      metadata: [],
-      adjacentKindCounts: []
-    };
-  }
-  if (!graph) {
-    return {
-      state: "missing",
-      title: "Graph unavailable",
-      semanticCategory: selectedElement.type === "node" ? "Selected node" : "Selected edge",
-      operationalMeaning: "The graph data is not available yet, so this selection cannot be resolved.",
-      metrics: [],
-      metadata: [{ label: "Selected ID", value: selectedElement.id }],
-      adjacentKindCounts: [],
-      missingId: selectedElement.id
-    };
-  }
-  const { nodesById, edgesById } = getGraphIndex(graph);
-  if (selectedElement.type === "node") {
-    const node = nodesById.get(selectedElement.id);
-    if (!node) {
-      return {
-        state: "missing",
-        title: "Selected node unavailable",
-        semanticCategory: "Node",
-        operationalMeaning: "The selected node is no longer present in the current graph build.",
-        metrics: [],
-        metadata: [{ label: "Selected ID", value: selectedElement.id }],
-        adjacentKindCounts: [],
-        missingId: selectedElement.id
-      };
-    }
-    return buildNodeState(graph, node, nodesById);
-  }
-  const edge = edgesById.get(selectedElement.id);
-  if (!edge) {
-    return {
-      state: "missing",
-      title: "Selected edge unavailable",
-      semanticCategory: "Edge",
-      operationalMeaning: "The selected edge is no longer present in the current graph build.",
-      metrics: [],
-      metadata: [{ label: "Selected ID", value: selectedElement.id }],
-      adjacentKindCounts: [],
-      missingId: selectedElement.id
-    };
-  }
-  return buildEdgeState(graph, edge, nodesById);
-}
-function getNodeKindColor(kind) {
-  switch (kind) {
-    case "organization":
-      return "gray";
-    case "feature":
-      return "blue";
-    case "domain":
-      return "violet";
-    case "surface":
-      return "cyan";
-    case "entity":
-      return "pink";
-    case "capability":
-      return "green";
-    case "resource":
-      return "orange";
-    default:
-      return "gray";
-  }
-}
-function getEdgeKindColor(kind) {
-  switch (kind) {
-    case "contains":
-      return "gray";
-    case "references":
-      return "cyan";
-    case "exposes":
-      return "blue";
-    case "maps_to":
-      return "violet";
-    default:
-      return "gray";
-  }
-}
-function getNodeKindLabel2(kind) {
-  switch (kind) {
-    case "organization":
-      return "Organization root";
-    case "feature":
-      return "Feature gate";
-    case "domain":
-      return "Domain boundary";
-    case "surface":
-      return "Surface";
-    case "entity":
-      return "Entity";
-    case "capability":
-      return "Capability";
-    case "resource":
-      return "Resource";
-    default:
-      return kind;
-  }
-}
-function titleCase2(value) {
-  return value.charAt(0).toUpperCase() + value.slice(1);
-}
-function MetricCard({ metric }) {
-  return /* @__PURE__ */ jsx(Card, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: 2, children: [
-    /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, c: "dimmed", children: metric.label }),
-    /* @__PURE__ */ jsx(Text, { size: "lg", fw: 800, children: metric.value }),
-    metric.hint ? /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: metric.hint }) : null
-  ] }) });
-}
-function RelatedItemCard({ item, itemType }) {
-  const badgeColor = itemType === "node" ? getNodeKindColor(item.kind) : getEdgeKindColor(item.kind);
-  return /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: 4, children: [
-    /* @__PURE__ */ jsxs(Group, { gap: "xs", justify: "space-between", align: "flex-start", children: [
-      /* @__PURE__ */ jsx(Text, { fw: 700, size: "sm", style: { lineHeight: 1.2 }, children: item.label }),
-      /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", color: badgeColor, children: item.kindLabel })
-    ] }),
-    /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: item.context }),
-    /* @__PURE__ */ jsx(Text, { size: "xs", ff: "monospace", c: "dimmed", children: item.id })
-  ] }) });
-}
-function getStatusColor3(value) {
-  switch (value) {
-    case "failed":
-      return "red";
-    case "warning":
-      return "yellow";
-    case "running":
-    case "processing":
-      return "blue";
-    case "completed":
-      return "green";
-    case "pending":
-      return "orange";
-    case "expired":
-      return "gray";
-    default:
-      return "gray";
-  }
-}
-function FollowUpSectionCard({ section }) {
-  return /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
-    /* @__PURE__ */ jsxs(Group, { justify: "space-between", align: "flex-start", children: [
-      /* @__PURE__ */ jsxs(Stack, { gap: 2, children: [
-        /* @__PURE__ */ jsx(Text, { size: "sm", fw: 700, children: section.title }),
-        section.description ? /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: section.description }) : null
-      ] }),
-      section.primaryAction ? /* @__PURE__ */ jsx(
-        Button,
-        {
-          size: "xs",
-          variant: "light",
-          component: "a",
-          href: section.primaryAction.href,
-          target: "_blank",
-          rel: "noreferrer",
-          children: section.primaryAction.label
-        }
-      ) : null
-    ] }),
-    section.items.length > 0 ? /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 1, sm: 2 }, spacing: "sm", children: section.items.map((item) => /* @__PURE__ */ jsx(
-      Paper,
-      {
-        withBorder: true,
-        radius: "md",
-        p: "sm",
-        component: "a",
-        href: item.href,
-        target: "_blank",
-        rel: "noreferrer",
-        style: { display: "block", textDecoration: "none", color: "inherit" },
-        children: /* @__PURE__ */ jsxs(Stack, { gap: 4, children: [
-          /* @__PURE__ */ jsxs(Group, { gap: "xs", justify: "space-between", align: "flex-start", children: [
-            /* @__PURE__ */ jsx(Text, { fw: 700, size: "sm", style: { lineHeight: 1.2 }, children: item.label }),
-            item.badgeLabel ? /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", color: item.badgeColor ?? getStatusColor3(item.badgeLabel), children: item.badgeLabel }) : null
-          ] }),
-          item.description ? /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: item.description }) : null,
-          item.meta ? /* @__PURE__ */ jsx(Text, { size: "xs", ff: "monospace", c: "dimmed", children: item.meta }) : null
-        ] })
-      },
-      item.id
-    )) }) : /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: section.emptyMessage })
-  ] }) });
-}
-function OrganizationGraphDetailPanel({
-  graph,
-  selectedElement,
-  supplementalSummary,
-  followUpSections,
-  expandAroundPanel,
-  onClearSelection,
-  className
+function CommandViewHealthStrip({
+  overview,
+  hotspots,
+  visibleResources,
+  hiddenResources = 0,
+  resourcesHidden,
+  selectedLabel,
+  onFocusHotspot,
+  onResourcesHiddenChange,
+  onResetFocus
 }) {
-  const state = getOrganizationGraphDetailState(graph, selectedElement);
-  if (state.state === "empty") {
-    return /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "lg", p: "md", className, children: /* @__PURE__ */ jsx(EmptyState, { icon: IconShare2, title: state.title, description: state.operationalMeaning, py: "md" }) });
-  }
-  if (state.state === "missing") {
-    return /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "lg", p: "md", className, children: /* @__PURE__ */ jsxs(Stack, { gap: "md", children: [
-      /* @__PURE__ */ jsxs(Group, { justify: "space-between", align: "flex-start", children: [
-        /* @__PURE__ */ jsxs(Stack, { gap: 4, children: [
-          /* @__PURE__ */ jsx(Text, { fw: 800, size: "lg", children: state.title }),
-          /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: state.operationalMeaning })
-        ] }),
-        onClearSelection ? /* @__PURE__ */ jsx(Button, { size: "xs", variant: "subtle", onClick: onClearSelection, children: "Clear" }) : null
-      ] }),
-      /* @__PURE__ */ jsx(Badge, { variant: "light", color: "gray", children: state.semanticCategory }),
-      /* @__PURE__ */ jsxs(Paper, { withBorder: true, radius: "md", p: "sm", children: [
-        /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, c: "dimmed", children: "Selected ID" }),
-        /* @__PURE__ */ jsx(Text, { size: "sm", ff: "monospace", children: state.missingId })
-      ] })
-    ] }) });
-  }
-  return /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "lg", p: "md", className, children: /* @__PURE__ */ jsxs(Stack, { gap: "md", children: [
-    /* @__PURE__ */ jsxs(Group, { justify: "space-between", align: "flex-start", children: [
-      /* @__PURE__ */ jsxs(Stack, { gap: 4, children: [
-        /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
-          /* @__PURE__ */ jsx(Badge, { variant: "light", color: "violet", children: state.semanticCategory }),
-          state.state === "node" ? /* @__PURE__ */ jsx(Badge, { variant: "light", color: state.node.enabled === false ? "gray" : "green", children: state.node.enabled === false ? "Disabled" : "Enabled" }) : null,
-          state.state === "edge" && state.edge.relationshipType ? /* @__PURE__ */ jsx(Badge, { variant: "light", color: "orange", children: titleCase2(state.edge.relationshipType) }) : null
-        ] }),
-        /* @__PURE__ */ jsx(Text, { fw: 800, size: "lg", children: state.title }),
-        /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: state.operationalMeaning })
+  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+    /* @__PURE__ */ jsxs("div", { style: cellStyle, children: [
+      /* @__PURE__ */ jsx(IconActivityHeartbeat, { size: 16, style: { flexShrink: 0, color: "var(--color-text-dimmed)" } }),
+      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 700, style: { flexShrink: 0 }, children: overview?.successRate == null ? "N/A" : `${Math.round(overview.successRate)}%` }),
+      /* @__PURE__ */ jsxs(Group, { gap: 4, wrap: "nowrap", children: [
+        /* @__PURE__ */ jsx(Badge, { variant: "light", color: "green", size: "xs", children: overview?.successCount ?? 0 }),
+        /* @__PURE__ */ jsx(Badge, { variant: "light", color: "red", size: "xs", children: overview?.failureCount ?? 0 }),
+        /* @__PURE__ */ jsx(Badge, { variant: "light", color: "yellow", size: "xs", children: overview?.warningCount ?? 0 })
       ] }),
-      onClearSelection ? /* @__PURE__ */ jsx(Button, { size: "xs", variant: "subtle", onClick: onClearSelection, children: "Clear" }) : null
+      /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", truncate: true, style: { flexShrink: 1, minWidth: 0 }, children: overview ? `${overview.totalRuns} runs / ${overview.trackedResources} resources` : "" })
     ] }),
-    /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 2, md: 4 }, spacing: "sm", children: state.metrics.map((metric) => /* @__PURE__ */ jsx(MetricCard, { metric }, metric.label)) }),
-    expandAroundPanel,
-    supplementalSummary && (supplementalSummary.metrics.length > 0 || supplementalSummary.metadata.length > 0) ? /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx(
-        Divider,
-        {
-          label: /* @__PURE__ */ jsxs(Group, { gap: 6, children: [
-            /* @__PURE__ */ jsx(IconTopologyStar3, { size: 14 }),
-            /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, children: supplementalSummary.title })
-          ] }),
-          labelPosition: "center"
-        }
-      ),
-      supplementalSummary.description ? /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: supplementalSummary.description }) : null,
-      supplementalSummary.metrics.length > 0 ? /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 2, md: 4 }, spacing: "sm", children: supplementalSummary.metrics.map((metric) => /* @__PURE__ */ jsx(MetricCard, { metric }, `supplemental-${metric.label}`)) }) : null,
-      supplementalSummary.metadata.length > 0 ? /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 1, sm: 2 }, spacing: "sm", children: supplementalSummary.metadata.map((item) => /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: 2, children: [
-        /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, c: "dimmed", children: item.label }),
-        /* @__PURE__ */ jsx(Text, { size: "sm", fw: 600, children: item.value })
-      ] }) }, `supplemental-${item.label}`)) }) : null
-    ] }) : null,
-    followUpSections && followUpSections.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx(
-        Divider,
-        {
-          label: /* @__PURE__ */ jsxs(Group, { gap: 6, children: [
-            /* @__PURE__ */ jsx(IconShare2, { size: 14 }),
-            /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, children: "Follow-up actions" })
-          ] }),
-          labelPosition: "center"
-        }
-      ),
-      /* @__PURE__ */ jsx(Stack, { gap: "sm", children: followUpSections.map((section) => /* @__PURE__ */ jsx(FollowUpSectionCard, { section }, section.title)) })
-    ] }) : null,
-    /* @__PURE__ */ jsx(
-      Divider,
-      {
-        label: /* @__PURE__ */ jsxs(Group, { gap: 6, children: [
-          /* @__PURE__ */ jsx(IconTopologyStar3, { size: 14 }),
-          /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, children: "Linked metadata" })
-        ] }),
-        labelPosition: "center"
-      }
-    ),
-    /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 1, sm: 2 }, spacing: "sm", children: state.metadata.map((item) => /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: 2, children: [
-      /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, c: "dimmed", children: item.label }),
-      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 600, children: item.value })
-    ] }) }, item.label)) }),
-    state.adjacentKindCounts.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx(
-        Divider,
-        {
-          label: /* @__PURE__ */ jsxs(Group, { gap: 6, children: [
-            /* @__PURE__ */ jsx(IconShare2, { size: 14 }),
-            /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, children: "Nearby kinds" })
-          ] }),
-          labelPosition: "center"
-        }
-      ),
-      /* @__PURE__ */ jsx(Group, { gap: "xs", children: state.adjacentKindCounts.map((item) => /* @__PURE__ */ jsxs(Badge, { variant: "light", color: getNodeKindColor(item.kind), children: [
-        item.count,
-        " ",
-        item.label
-      ] }, item.kind)) })
-    ] }) : null,
-    state.state === "edge" ? /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx(
-        Divider,
+    /* @__PURE__ */ jsxs("div", { style: cellStyle, children: [
+      /* @__PURE__ */ jsx(IconAlertTriangle, { size: 16, style: { flexShrink: 0, color: "var(--color-text-dimmed)" } }),
+      hotspots.length > 0 ? /* @__PURE__ */ jsx(Group, { gap: "xs", wrap: "nowrap", style: { minWidth: 0, overflow: "hidden" }, children: hotspots.map((hotspot) => /* @__PURE__ */ jsx(Group, { gap: 4, wrap: "nowrap", children: /* @__PURE__ */ jsx(
+        Badge,
         {
-          label: /* @__PURE__ */ jsxs(Group, { gap: 6, children: [
-            /* @__PURE__ */ jsx(IconShare2, { size: 14 }),
-            /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, children: "Endpoints" })
-          ] }),
-          labelPosition: "center"
-        }
-      ),
-      /* @__PURE__ */ jsxs(SimpleGrid, { cols: { base: 1, sm: 2 }, spacing: "sm", children: [
-        /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: 2, children: [
-          /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, c: "dimmed", children: "Source" }),
-          /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
-            /* @__PURE__ */ jsx(Text, { fw: 700, children: state.sourceNode?.label ?? state.edge.sourceId }),
-            /* @__PURE__ */ jsx(
-              Badge,
-              {
-                size: "xs",
-                variant: "light",
-                color: state.sourceNode ? getNodeKindColor(state.sourceNode.kind) : "gray",
-                children: state.sourceNode ? getNodeKindLabel2(state.sourceNode.kind) : "unresolved"
-              }
-            )
-          ] })
-        ] }) }),
-        /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: 2, children: [
-          /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, c: "dimmed", children: "Target" }),
-          /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
-            /* @__PURE__ */ jsx(Text, { fw: 700, children: state.targetNode?.label ?? state.edge.targetId }),
-            /* @__PURE__ */ jsx(
-              Badge,
-              {
-                size: "xs",
-                variant: "light",
-                color: state.targetNode ? getNodeKindColor(state.targetNode.kind) : "gray",
-                children: state.targetNode ? getNodeKindLabel2(state.targetNode.kind) : "unresolved"
-              }
-            )
-          ] })
-        ] }) })
-      ] })
-    ] }) : null,
-    /* @__PURE__ */ jsx(
-      Divider,
-      {
-        label: /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, children: state.state === "edge" ? "Surrounding nodes" : "Direct nodes" }),
-        labelPosition: "center"
-      }
-    ),
-    state.relatedNodes.length > 0 ? /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 1, sm: 2 }, spacing: "sm", children: state.relatedNodes.map((item) => /* @__PURE__ */ jsx(RelatedItemCard, { item, itemType: "node" }, item.id)) }) : /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "No nearby nodes were found in the current graph selection." }),
-    /* @__PURE__ */ jsx(
-      Divider,
-      {
-        label: /* @__PURE__ */ jsx(Text, { size: "xs", tt: "uppercase", fw: 700, children: state.state === "edge" ? "Surrounding edges" : "Direct edges" }),
-        labelPosition: "center"
-      }
-    ),
-    state.relatedEdges.length > 0 ? /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 1, sm: 2 }, spacing: "sm", children: state.relatedEdges.map((item) => /* @__PURE__ */ jsx(RelatedItemCard, { item, itemType: "edge" }, item.id)) }) : /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "No adjacent edges were found for the current selection." })
-  ] }) });
-}
-
-// src/features/operations/organization-graph/types.ts
-var ORGANIZATION_GRAPH_NODE_KIND_ORDER = [
-  "organization",
-  "feature",
-  "surface",
-  "entity",
-  "capability",
-  "resource",
-  "knowledge"
-];
-var ORGANIZATION_GRAPH_NODE_KIND_LABELS = {
-  organization: "Organization",
-  feature: "Feature",
-  surface: "Surface",
-  entity: "Entity",
-  capability: "Capability",
-  resource: "Resource",
-  knowledge: "Knowledge"
-};
-var DEFAULT_ORGANIZATION_GRAPH_FILTERS = {
-  search: "",
-  nodeKinds: [],
-  topologyPresence: "all",
-  environmentStatus: "all",
-  resourceTypes: [],
-  showIntegrations: true,
-  domainFilters: {}
-};
-
-// src/features/operations/organization-graph/helpers.ts
-var TOPLOGY_EDGE_TYPES = /* @__PURE__ */ new Set(["maps_to", "triggers", "uses", "approval"]);
-function getCommandViewNodes(data) {
-  return [
-    ...data.agents,
-    ...data.workflows,
-    ...data.triggers,
-    ...data.integrations,
-    ...data.externalResources,
-    ...data.humanCheckpoints
-  ];
-}
-function getCommandViewNodeForGraphNode(node, commandViewData) {
-  if (!commandViewData || node.kind !== "resource" || !node.sourceId) {
-    return null;
-  }
-  return getCommandViewNodes(commandViewData).find((item) => item.resourceId === node.sourceId) ?? null;
-}
-function normalizeText(value) {
-  return value.trim().toLowerCase();
-}
-function includesQuery(value, query) {
-  if (!value) return false;
-  return normalizeText(value).includes(query);
-}
-function titleCase3(value) {
-  return value.replace(/_/g, " ").split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
-function isTopologyEdge(edge) {
-  return TOPLOGY_EDGE_TYPES.has(edge.kind) || Boolean(edge.relationshipType);
-}
-function isSemanticEdge(edge) {
-  return !isTopologyEdge(edge);
-}
-function getIncidentEdges(graph, nodeId2) {
-  return graph.edges.filter((edge) => edge.sourceId === nodeId2 || edge.targetId === nodeId2);
-}
-function createOrganizationGraphFilters(partial) {
-  return {
-    search: partial?.search ?? DEFAULT_ORGANIZATION_GRAPH_FILTERS.search,
-    nodeKinds: partial?.nodeKinds ? [...partial.nodeKinds] : [...DEFAULT_ORGANIZATION_GRAPH_FILTERS.nodeKinds],
-    topologyPresence: partial?.topologyPresence ?? DEFAULT_ORGANIZATION_GRAPH_FILTERS.topologyPresence,
-    environmentStatus: partial?.environmentStatus ?? DEFAULT_ORGANIZATION_GRAPH_FILTERS.environmentStatus,
-    resourceTypes: partial?.resourceTypes ? [...partial.resourceTypes] : [...DEFAULT_ORGANIZATION_GRAPH_FILTERS.resourceTypes],
-    showIntegrations: partial?.showIntegrations ?? DEFAULT_ORGANIZATION_GRAPH_FILTERS.showIntegrations,
-    domainFilters: partial?.domainFilters ? { ...partial.domainFilters } : { ...DEFAULT_ORGANIZATION_GRAPH_FILTERS.domainFilters }
-  };
-}
-function normalizeOrganizationGraphSearch(search) {
-  return search.trim().toLowerCase();
-}
-function getOrganizationGraphNodePresence(node, incidentEdges) {
-  if (node.kind === "resource") {
-    const relevantEdges = incidentEdges.filter((edge) => edge.kind !== "contains");
-    const hasTopologyEdges2 = relevantEdges.some(isTopologyEdge);
-    const hasSemanticEdges2 = relevantEdges.some(isSemanticEdge);
-    if (hasTopologyEdges2 && hasSemanticEdges2) {
-      return "bridge";
-    }
-    if (hasTopologyEdges2) {
-      return "topology-only";
-    }
-    return "semantic-only";
-  }
-  const hasTopologyEdges = incidentEdges.some(isTopologyEdge);
-  const hasSemanticEdges = incidentEdges.some(isSemanticEdge);
-  if (hasTopologyEdges && hasSemanticEdges) {
-    return "bridge";
-  }
-  if (hasTopologyEdges) {
-    return "topology-only";
-  }
-  return "semantic-only";
-}
-function getOrganizationGraphNodePresenceMap(graph) {
-  const presenceByNodeId = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    presenceByNodeId.set(node.id, getOrganizationGraphNodePresence(node, getIncidentEdges(graph, node.id)));
-  }
-  return presenceByNodeId;
-}
-function getOrganizationGraphNodeKindOptions(kinds = ORGANIZATION_GRAPH_NODE_KIND_ORDER) {
-  return kinds.map((kind) => ({
-    kind,
-    label: ORGANIZATION_GRAPH_NODE_KIND_LABELS[kind]
-  }));
-}
-function getOrganizationGraphResourceTypeOptions(resourceTypes = [
-  "workflow",
-  "agent",
-  "trigger",
-  "integration",
-  "external",
-  "human_checkpoint"
-]) {
-  return resourceTypes.map((resourceType) => ({
-    resourceType,
-    label: titleCase3(resourceType)
-  }));
-}
-function getNodeStatus(node, commandViewData) {
-  const commandViewNode = getCommandViewNodeForGraphNode(node, commandViewData);
-  if (commandViewNode) {
-    return commandViewNode.status;
-  }
-  return "status" in node && typeof node.status === "string" ? node.status : void 0;
-}
-function getExplicitNodeFacets(node, commandViewData) {
-  const commandViewNode = getCommandViewNodeForGraphNode(node, commandViewData);
-  if (commandViewNode) {
-    return [
-      ...commandViewNode.category ? [`category:${commandViewNode.category}`] : [],
-      ...commandViewNode.links?.map((link) => link.nodeId) ?? []
-    ];
-  }
-  return [];
-}
-function getNodeFacets(graph, node, commandViewData) {
-  const explicitFacets = getExplicitNodeFacets(node, commandViewData);
-  if (explicitFacets.length > 0) {
-    return explicitFacets;
-  }
-  if (node.kind === "feature") {
-    return node.sourceId ? [node.sourceId] : [];
-  }
-  if (node.kind !== "resource") {
-    return [];
-  }
-  const facetIds = /* @__PURE__ */ new Set();
-  for (const edge of graph.edges) {
-    if (edge.sourceId !== node.id) {
-      continue;
-    }
-    const targetNode = graph.nodes.find((candidate) => candidate.id === edge.targetId);
-    if (targetNode?.kind === "feature" && targetNode.sourceId) {
-      facetIds.add(targetNode.id);
-    }
-  }
-  return [...facetIds];
-}
-function matchesOrganizationGraphNodeSearch(node, search) {
-  const query = normalizeOrganizationGraphSearch(search);
-  if (!query) return true;
-  const nodeStatus = getNodeStatus(node);
-  const nodeFacets = getExplicitNodeFacets(node);
-  return includesQuery(node.id, query) || includesQuery(node.label, query) || includesQuery(node.description, query) || includesQuery(node.sourceId, query) || includesQuery(node.featureId, query) || includesQuery(node.resourceType, query) || includesQuery(nodeStatus, query) || nodeFacets.some((facet) => includesQuery(facet, query)) || includesQuery(node.kind, query);
-}
-function matchesOrganizationGraphEdgeSearch(edge, graph, search) {
-  const query = normalizeOrganizationGraphSearch(search);
-  if (!query) return true;
-  const sourceNode = graph.nodes.find((node) => node.id === edge.sourceId);
-  const targetNode = graph.nodes.find((node) => node.id === edge.targetId);
-  return includesQuery(edge.id, query) || includesQuery(edge.label, query) || includesQuery(edge.kind, query) || includesQuery(edge.relationshipType, query) || includesQuery(sourceNode?.label, query) || includesQuery(sourceNode?.sourceId, query) || includesQuery(targetNode?.label, query) || includesQuery(targetNode?.sourceId, query);
-}
-function matchesTopologyPresence(nodePresence, topologyPresence) {
-  if (topologyPresence === "all") return true;
-  return nodePresence === topologyPresence;
-}
-function hasActiveDomainFilters(domainFilters) {
-  return Object.values(domainFilters).some((filterState) => filterState !== "neutral");
-}
-function matchesDomainFilters(graph, node, domainFilters, commandViewData) {
-  if (!hasActiveDomainFilters(domainFilters)) {
-    return true;
-  }
-  const includedDomains = Object.entries(domainFilters).filter(([, filterState]) => filterState === "include").map(([domainId]) => domainId);
-  const excludedDomains = Object.entries(domainFilters).filter(([, filterState]) => filterState === "exclude").map(([domainId]) => domainId);
-  const nodeFacets = getNodeFacets(graph, node, commandViewData);
-  if (excludedDomains.length > 0 && nodeFacets.some((domainId) => excludedDomains.includes(domainId))) {
-    return false;
-  }
-  if (includedDomains.length > 0 && !nodeFacets.some((domainId) => includedDomains.includes(domainId))) {
-    return false;
-  }
-  return true;
-}
-function matchesEnvironmentStatus(node, environmentStatus, commandViewData) {
-  if (environmentStatus === "all") {
-    return true;
-  }
-  const nodeStatus = getNodeStatus(node, commandViewData);
-  if (!nodeStatus) {
-    return true;
-  }
-  return nodeStatus === environmentStatus;
-}
-function matchesResourceTypeFilters(node, resourceTypes) {
-  if (node.kind !== "resource" || resourceTypes.length === 0) {
-    return true;
-  }
-  return Boolean(node.resourceType && resourceTypes.includes(node.resourceType));
-}
-function matchesIntegrationVisibility(node, showIntegrations) {
-  if (showIntegrations) {
-    return true;
-  }
-  return !(node.kind === "resource" && node.resourceType === "integration");
-}
-function filterOrganizationGraph(graph, filters, options) {
-  const normalizedFilters = createOrganizationGraphFilters(filters);
-  const normalizedSearch = normalizeOrganizationGraphSearch(normalizedFilters.search);
-  const nodePresenceMap = getOrganizationGraphNodePresenceMap(graph);
-  const selectedKinds = new Set(normalizedFilters.nodeKinds);
-  const commandViewData = options?.commandViewData;
-  const visibleNodeIds = /* @__PURE__ */ new Set();
-  for (const node of graph.nodes) {
-    if (selectedKinds.size > 0 && !selectedKinds.has(node.kind)) {
-      continue;
-    }
-    if (!matchesIntegrationVisibility(node, normalizedFilters.showIntegrations)) {
-      continue;
-    }
-    if (!matchesResourceTypeFilters(node, normalizedFilters.resourceTypes)) {
-      continue;
-    }
-    if (!matchesEnvironmentStatus(node, normalizedFilters.environmentStatus, commandViewData)) {
-      continue;
-    }
-    if (!matchesDomainFilters(graph, node, normalizedFilters.domainFilters, commandViewData)) {
-      continue;
-    }
-    const presence = nodePresenceMap.get(node.id) ?? "semantic-only";
-    if (!matchesTopologyPresence(presence, normalizedFilters.topologyPresence)) {
-      continue;
-    }
-    if (normalizedSearch && !matchesOrganizationGraphNodeSearch(node, normalizedSearch)) {
-      const incidentEdges = getIncidentEdges(graph, node.id);
-      const edgeMatch = incidentEdges.some((edge) => matchesOrganizationGraphEdgeSearch(edge, graph, normalizedSearch));
-      if (!edgeMatch) {
-        continue;
-      }
-    }
-    visibleNodeIds.add(node.id);
-  }
-  const visibleEdges = graph.edges.filter((edge) => {
-    const sourceVisible = visibleNodeIds.has(edge.sourceId);
-    const targetVisible = visibleNodeIds.has(edge.targetId);
-    if (!sourceVisible || !targetVisible) {
-      return false;
-    }
-    if (normalizedSearch && !matchesOrganizationGraphEdgeSearch(edge, graph, normalizedSearch)) {
-      const sourceNode = graph.nodes.find((node) => node.id === edge.sourceId);
-      const targetNode = graph.nodes.find((node) => node.id === edge.targetId);
-      const nodeSearchMatch = Boolean(sourceNode && matchesOrganizationGraphNodeSearch(sourceNode, normalizedSearch)) || Boolean(targetNode && matchesOrganizationGraphNodeSearch(targetNode, normalizedSearch));
-      if (!nodeSearchMatch) {
-        return false;
-      }
-    }
-    return true;
-  });
-  return {
-    ...graph,
-    nodes: graph.nodes.filter((node) => visibleNodeIds.has(node.id)),
-    edges: visibleEdges
-  };
-}
-function getCommandViewResourceCategory(node, commandViewData) {
-  return getCommandViewNodeForGraphNode(node, commandViewData)?.category ?? null;
-}
-function getConnectedHiddenResourceIds(graph, nodeId2, hiddenIds) {
-  if (!nodeId2) {
-    return /* @__PURE__ */ new Set();
-  }
-  const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
-  const connectedIds = /* @__PURE__ */ new Set();
-  for (const edge of graph.edges) {
-    const neighborId = edge.sourceId === nodeId2 ? edge.targetId : edge.targetId === nodeId2 ? edge.sourceId : null;
-    if (!neighborId || !hiddenIds.has(neighborId)) {
-      continue;
-    }
-    if (nodesById.get(neighborId)?.kind === "resource") {
-      connectedIds.add(neighborId);
-    }
-  }
-  return connectedIds;
-}
-function getCommandViewVisibilityProjection({
-  graph,
-  commandViewData,
-  resourcesHidden,
-  diagnosticsHidden,
-  diagnosticCategories,
-  revealedIds = /* @__PURE__ */ new Set(),
-  mode
-}) {
-  const hiddenIds = /* @__PURE__ */ new Set();
-  const hiddenEdgeIds = /* @__PURE__ */ new Set();
-  const diagnosticCategorySet = new Set(diagnosticCategories);
-  let totalResourceCount = 0;
-  let hiddenDiagnosticResourceCount = 0;
-  if (mode === "trace" || mode === "impact") {
-    const resourceCount = graph.nodes.filter((node) => node.kind === "resource").length;
-    return {
-      hiddenIds,
-      hiddenEdgeIds,
-      totalResourceCount: resourceCount,
-      visibleResourceCount: resourceCount,
-      hiddenResourceCount: 0,
-      hiddenDiagnosticResourceCount: 0
-    };
-  }
-  for (const node of graph.nodes) {
-    if (node.kind !== "resource") {
-      continue;
-    }
-    totalResourceCount += 1;
-    const category = getCommandViewResourceCategory(node, commandViewData);
-    const isDiagnostic = Boolean(category && diagnosticCategorySet.has(category));
-    if (isDiagnostic && diagnosticsHidden) {
-      hiddenDiagnosticResourceCount += 1;
-    }
-    if (revealedIds.has(node.id)) {
-      continue;
-    }
-    if (resourcesHidden || diagnosticsHidden && isDiagnostic) {
-      hiddenIds.add(node.id);
-    }
-  }
-  for (const edge of graph.edges) {
-    if (hiddenIds.has(edge.sourceId) || hiddenIds.has(edge.targetId)) {
-      hiddenEdgeIds.add(edge.id);
-    }
-  }
-  const hiddenResourceCount = hiddenIds.size;
-  return {
-    hiddenIds,
-    hiddenEdgeIds,
-    totalResourceCount,
-    visibleResourceCount: totalResourceCount - hiddenResourceCount,
-    hiddenResourceCount,
-    hiddenDiagnosticResourceCount
-  };
-}
-function isOrganizationGraphFilterPristine(filters) {
-  return normalizeOrganizationGraphSearch(filters.search) === "" && filters.nodeKinds.length === 0 && filters.topologyPresence === DEFAULT_ORGANIZATION_GRAPH_FILTERS.topologyPresence && filters.environmentStatus === DEFAULT_ORGANIZATION_GRAPH_FILTERS.environmentStatus && filters.resourceTypes.length === 0 && filters.showIntegrations === DEFAULT_ORGANIZATION_GRAPH_FILTERS.showIntegrations && !hasActiveDomainFilters(filters.domainFilters);
-}
-var TOPOLOGY_PRESENCE_OPTIONS = [
-  { label: "All", value: "all" },
-  { label: "Semantic only", value: "semantic-only" },
-  { label: "Topology only", value: "topology-only" }
-];
-var ENVIRONMENT_STATUS_OPTIONS = [
-  { label: "All", value: "all" },
-  { label: "Prod", value: "prod" },
-  { label: "Dev", value: "dev" }
-];
-function OrganizationGraphFilterToolbar({
-  value,
-  onChange,
-  availableKinds,
-  disabled = false,
-  searchPlaceholder = "Search nodes, relationships, or IDs",
-  kindLabel = "Node kinds",
-  resourceTypeLabel = "Resource types",
-  topologyLabel = "Relationship presence",
-  environmentLabel = "Environment",
-  showIntegrationsLabel = "Show integrations",
-  resetLabel = "Reset filters",
-  resetValue = createOrganizationGraphFilters()
-}) {
-  const kindOptions = getOrganizationGraphNodeKindOptions(availableKinds);
-  const resourceTypeOptions = getOrganizationGraphResourceTypeOptions();
-  const canReset = !isOrganizationGraphFilterPristine(value);
-  return /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
-    /* @__PURE__ */ jsx(
-      TextInput,
-      {
-        label: "Search",
-        placeholder: searchPlaceholder,
-        value: value.search,
-        onChange: (event) => onChange({
-          ...value,
-          search: event.currentTarget.value
-        }),
-        leftSection: /* @__PURE__ */ jsx(IconSearch, { size: 14 }),
-        disabled
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      MultiSelect,
-      {
-        label: kindLabel,
-        placeholder: "All kinds",
-        data: kindOptions.map((option) => ({ value: option.kind, label: option.label })),
-        value: value.nodeKinds,
-        onChange: (nodeKinds) => onChange({
-          ...value,
-          nodeKinds
-        }),
-        searchable: true,
-        clearable: true,
-        disabled
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      MultiSelect,
-      {
-        label: resourceTypeLabel,
-        placeholder: "All resource types",
-        data: resourceTypeOptions.map((option) => ({ value: option.resourceType, label: option.label })),
-        value: value.resourceTypes,
-        onChange: (resourceTypes) => onChange({
-          ...value,
-          resourceTypes
-        }),
-        searchable: true,
-        clearable: true,
-        disabled
-      }
-    ),
-    /* @__PURE__ */ jsxs(Stack, { gap: 6, children: [
-      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 500, children: topologyLabel }),
-      /* @__PURE__ */ jsx(
-        SegmentedControl,
-        {
-          value: value.topologyPresence,
-          onChange: (topologyPresence) => onChange({
-            ...value,
-            topologyPresence
-          }),
-          data: TOPOLOGY_PRESENCE_OPTIONS,
-          size: "sm",
-          fullWidth: true,
-          disabled
-        }
-      )
-    ] }),
-    /* @__PURE__ */ jsxs(Stack, { gap: 6, children: [
-      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 500, children: environmentLabel }),
-      /* @__PURE__ */ jsx(
-        SegmentedControl,
-        {
-          value: value.environmentStatus,
-          onChange: (environmentStatus) => onChange({
-            ...value,
-            environmentStatus
-          }),
-          data: ENVIRONMENT_STATUS_OPTIONS,
-          size: "sm",
-          fullWidth: true,
-          disabled
-        }
-      )
-    ] }),
-    /* @__PURE__ */ jsx(
-      Switch,
-      {
-        label: showIntegrationsLabel,
-        description: "Hide integration resources and their relationship edges.",
-        checked: value.showIntegrations,
-        onChange: (event) => onChange({
-          ...value,
-          showIntegrations: event.currentTarget.checked
-        }),
-        size: "sm",
-        disabled
-      }
-    ),
-    /* @__PURE__ */ jsx(Group, { justify: "flex-end", children: /* @__PURE__ */ jsx(
-      Button,
-      {
-        variant: "subtle",
-        leftSection: /* @__PURE__ */ jsx(IconRefresh, { size: 14 }),
-        onClick: () => onChange(resetValue),
-        disabled: disabled || !canReset,
-        children: resetLabel
-      }
-    ) })
-  ] });
-}
-var useOrganizationGraphFiltersStore = create((set) => ({
-  filtersByScope: {},
-  initializeScope: (scope, initialFilters) => set((state) => {
-    if (state.filtersByScope[scope]) {
-      return state;
-    }
-    return {
-      filtersByScope: {
-        ...state.filtersByScope,
-        [scope]: createOrganizationGraphFilters(initialFilters)
-      }
-    };
-  }),
-  updateScope: (scope, next) => set((state) => ({
-    filtersByScope: {
-      ...state.filtersByScope,
-      [scope]: createOrganizationGraphFilters({
-        ...state.filtersByScope[scope],
-        ...next
-      })
-    }
-  })),
-  resetScope: (scope, initialFilters) => set((state) => ({
-    filtersByScope: {
-      ...state.filtersByScope,
-      [scope]: createOrganizationGraphFilters(initialFilters)
-    }
-  }))
-}));
-function getOrganizationGraphFilterScope(initialFilters) {
-  return JSON.stringify(createOrganizationGraphFilters(initialFilters));
-}
-function useOrganizationGraphFilters(initialFilters) {
-  const scopeRef = useRef(getOrganizationGraphFilterScope(initialFilters));
-  const fallbackFiltersRef = useRef(createOrganizationGraphFilters(initialFilters));
-  const filters = useOrganizationGraphFiltersStore(
-    (state) => state.filtersByScope[scopeRef.current] ?? fallbackFiltersRef.current
-  );
-  const initializeScope = useOrganizationGraphFiltersStore((state) => state.initializeScope);
-  const updateScope = useOrganizationGraphFiltersStore((state) => state.updateScope);
-  const resetScope = useOrganizationGraphFiltersStore((state) => state.resetScope);
-  useEffect(() => {
-    initializeScope(scopeRef.current, initialFilters);
-  }, [initialFilters, initializeScope]);
-  const updateFilters = (next) => {
-    updateScope(scopeRef.current, next);
-  };
-  const setSearch = (search) => {
-    updateFilters({ search });
-  };
-  const setNodeKinds = (nodeKinds) => {
-    updateFilters({ nodeKinds });
-  };
-  const setTopologyPresence = (topologyPresence) => {
-    updateFilters({ topologyPresence });
-  };
-  const resetFilters = () => {
-    resetScope(scopeRef.current, initialFilters);
-  };
-  return {
-    filters,
-    setSearch,
-    setNodeKinds,
-    setTopologyPresence,
-    resetFilters,
-    updateFilters
-  };
-}
-
-// src/features/operations/organization-graph/lenses.ts
-var COMMAND_VIEW_NODE_KINDS = [
-  "organization",
-  "feature",
-  "surface",
-  "entity",
-  "capability",
-  "resource"
-];
-function getOrganizationGraphLensConfig(lens) {
-  if (lens === "command-view") {
-    return {
-      title: "Command View",
-      caption: "Operations lens backed by the shared organization graph. This preset focuses the graph on bridged runtime resources and their operational relationships.",
-      initialMode: "map",
-      initialFilters: {
-        nodeKinds: COMMAND_VIEW_NODE_KINDS,
-        topologyPresence: "all"
-      },
-      filterSummary: "Command View lens keeps the organization structure visible while resource visibility is controlled progressively."
-    };
-  }
-  return {
-    title: "Organization Graph",
-    caption: "Cytoscape-based shared graph surface built from the organization model and bridged Command View topology.",
-    initialMode: "map",
-    filterSummary: "Filter by node kind, semantic-vs-topology presence, and free-text search across nodes and relationships."
-  };
-}
-
-// src/features/operations/organization-graph/commandViewOperationalSummary.ts
-function toPercentage(numerator, denominator) {
-  if (denominator <= 0) return null;
-  return numerator / denominator * 100;
-}
-function formatPercent(value) {
-  return value == null ? "N/A" : `${Math.round(value)}%`;
-}
-function formatTimestamp(value) {
-  if (!value) return "N/A";
-  return new Intl.DateTimeFormat("en-US", {
-    month: "short",
-    day: "numeric",
-    hour: "numeric",
-    minute: "2-digit"
-  }).format(new Date(value));
-}
-function getCommandViewNodes2(data) {
-  return [
-    ...data.agents,
-    ...data.workflows,
-    ...data.triggers,
-    ...data.integrations,
-    ...data.externalResources,
-    ...data.humanCheckpoints
-  ];
-}
-function getNodeByResourceId(data, resourceId) {
-  return getCommandViewNodes2(data).find((node) => node.resourceId === resourceId) ?? null;
-}
-function getCommandViewOperationalOverview(data, stats) {
-  if (!stats) {
-    return null;
-  }
-  const resourceEntries = Object.entries(stats.resources);
-  const humanEntries = Object.entries(stats.humanCheckpoints);
-  const totalRuns = resourceEntries.reduce((sum, [, item]) => sum + item.totalRuns, 0);
-  const successCount = resourceEntries.reduce((sum, [, item]) => sum + item.successCount, 0);
-  const failureCount = resourceEntries.reduce((sum, [, item]) => sum + item.failureCount, 0);
-  const warningCount = resourceEntries.reduce((sum, [, item]) => sum + item.warningCount, 0);
-  const pendingApprovals = humanEntries.reduce((sum, [, item]) => sum + item.pendingCount, 0);
-  const activeHumanCheckpoints = humanEntries.filter(([, item]) => item.pendingCount > 0).length;
-  const topFailingResources = resourceEntries.map(([resourceId, item]) => ({
-    id: resourceId,
-    label: data ? getNodeByResourceId(data, resourceId)?.name ?? resourceId : resourceId,
-    failureCount: item.failureCount,
-    warningCount: item.warningCount
-  })).filter((item) => item.failureCount > 0 || item.warningCount > 0).sort((left, right) => {
-    if (right.failureCount !== left.failureCount) {
-      return right.failureCount - left.failureCount;
-    }
-    if (right.warningCount !== left.warningCount) {
-      return right.warningCount - left.warningCount;
-    }
-    return left.label.localeCompare(right.label);
-  }).slice(0, 3);
-  return {
-    totalRuns,
-    successCount,
-    failureCount,
-    warningCount,
-    successRate: toPercentage(successCount, totalRuns),
-    trackedResources: resourceEntries.length,
-    pendingApprovals,
-    activeHumanCheckpoints,
-    topFailingResources,
-    timeRange: stats.timeRange,
-    generatedAt: stats.generatedAt
-  };
-}
-function buildResourceSelectionSummary(node, stats) {
-  const successRate = toPercentage(stats.successCount, stats.totalRuns);
-  const metadata = [
-    { label: "Operational Type", value: node.type },
-    { label: "Environment", value: node.status.toUpperCase() },
-    { label: "Version", value: node.version },
-    { label: "Origin", value: node.origin ? node.origin : "local" }
-  ];
-  if (node.category) {
-    metadata.push({ label: "Category", value: node.category });
-  }
-  if (node.links?.length) {
-    metadata.push({ label: "Links", value: node.links.map((link) => `${link.kind} ${link.nodeId}`).join(", ") });
-  }
-  if (node.type === "agent") {
-    metadata.push({ label: "Model", value: `${node.modelProvider}/${node.modelId}` });
-    metadata.push({ label: "Tools", value: String(node.toolCount) });
-    metadata.push({ label: "Memory", value: node.hasMemory ? "Enabled" : "Disabled" });
-  }
-  if (node.type === "workflow") {
-    metadata.push({ label: "Entry Point", value: node.entryPoint });
-    metadata.push({ label: "Steps", value: String(node.stepCount) });
-  }
-  if (node.type === "integration") {
-    metadata.push({ label: "Provider", value: node.provider });
-    metadata.push({ label: "Credential", value: node.credentialName });
-  }
-  if (node.type === "trigger") {
-    metadata.push({ label: "Trigger Type", value: node.triggerType });
-  }
-  if (node.type === "external") {
-    metadata.push({ label: "Platform", value: node.platform });
-  }
-  return {
-    title: "Operational Summary",
-    description: "Execution telemetry for this resource inside the Command View lens.",
-    metrics: [
-      { label: "Runs", value: String(stats.totalRuns), hint: "Total tracked executions in the selected time range" },
-      { label: "Success rate", value: formatPercent(successRate), hint: "Completed and warning runs as a percentage of all runs" },
-      { label: "Failures", value: String(stats.failureCount), hint: "Runs that ended in a failed state" },
-      { label: "Warnings", value: String(stats.warningCount), hint: "Completed runs that surfaced warnings" }
-    ],
-    metadata: [...metadata, { label: "Last Run", value: formatTimestamp(stats.lastRunAt) }]
-  };
-}
-function buildHumanSelectionSummary(node, stats) {
-  const metadata = [
-    { label: "Operational Type", value: "human checkpoint" },
-    { label: "Environment", value: node.status.toUpperCase() },
-    { label: "Version", value: node.version },
-    { label: "Origin", value: node.origin ? node.origin : "local" }
-  ];
-  if (node.category) {
-    metadata.push({ label: "Category", value: node.category });
-  }
-  if (node.links?.length) {
-    metadata.push({ label: "Links", value: node.links.map((link) => `${link.kind} ${link.nodeId}`).join(", ") });
-  }
-  return {
-    title: "Approval Queue Summary",
-    description: "Human checkpoint activity for the current Command View lens.",
-    metrics: [
-      { label: "Pending", value: String(stats.pendingCount), hint: "Tasks currently waiting on a decision" },
-      { label: "Completed", value: String(stats.completedCount), hint: "Tasks completed in the selected time range" },
-      { label: "Expired", value: String(stats.expiredCount), hint: "Tasks that expired before resolution" }
-    ],
-    metadata: [...metadata, { label: "Last Decision", value: formatTimestamp(stats.lastDecisionAt) }]
-  };
-}
-function getCommandViewSelectionOperationalSummary(data, stats, selectedElement) {
-  if (!data || !stats || !selectedElement || selectedElement.type !== "node") {
-    return null;
-  }
-  if (!selectedElement.id.startsWith("resource:")) {
-    return null;
-  }
-  const resourceId = selectedElement.id.slice("resource:".length);
-  const node = getNodeByResourceId(data, resourceId);
-  if (!node) {
-    return null;
-  }
-  if (node.type === "human") {
-    const checkpointStats = stats.humanCheckpoints[resourceId];
-    return checkpointStats ? buildHumanSelectionSummary(node, checkpointStats) : null;
-  }
-  const resourceStats = stats.resources[resourceId];
-  return resourceStats ? buildResourceSelectionSummary(node, resourceStats) : null;
-}
-function formatRelativeTime3(date) {
-  if (!date) return "N/A";
-  const dateObj = typeof date === "string" ? new Date(date) : date;
-  return formatDistanceToNow(dateObj, { addSuffix: true });
-}
-
-// src/hooks/operations/command-view/utils/mergeStatsWithTopology.ts
-function mergeStatsWithTopology(topology, stats) {
-  return {
-    ...topology,
-    agents: topology.agents.map((agent) => ({
-      ...agent,
-      stats: stats.resources[agent.resourceId] || null
-    })),
-    workflows: topology.workflows.map((workflow) => ({
-      ...workflow,
-      stats: stats.resources[workflow.resourceId] || null
-    })),
-    humanCheckpoints: topology.humanCheckpoints.map((checkpoint) => ({
-      ...checkpoint,
-      stats: stats.humanCheckpoints[checkpoint.resourceId] || null
-    }))
-  };
-}
-
-// src/features/operations/organization-graph/commandViewDrillDown.ts
-function titleCase4(value) {
-  return value.replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim().split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
-function getResourceHref(resourceType, resourceId) {
-  if (resourceType === "agent") {
-    return `/operations/resources/agent/${resourceId}`;
-  }
-  if (resourceType === "workflow") {
-    return `/operations/resources/workflow/${resourceId}`;
-  }
-  if (resourceType === "human_checkpoint") {
-    return `/operations/command-queue?checkpoint=${resourceId}`;
-  }
-  return null;
-}
-function getExecutionBadgeColor(status) {
-  switch (status) {
-    case "failed":
-      return "red";
-    case "warning":
-      return "yellow";
-    case "running":
-      return "blue";
-    case "completed":
-      return "green";
-    case "pending":
-    default:
-      return "gray";
-  }
-}
-function getTaskBadgeColor(status) {
-  switch (status) {
-    case "pending":
-      return "orange";
-    case "processing":
-      return "blue";
-    case "completed":
-      return "green";
-    case "failed":
-      return "red";
-    case "expired":
-    default:
-      return "gray";
-  }
-}
-function getExecutionDescription(execution) {
-  if (execution.errorMessage) {
-    return execution.errorMessage;
-  }
-  if (execution.status === "running") {
-    return "Currently running";
-  }
-  if (execution.status === "warning") {
-    return "Completed with warnings";
-  }
-  if (execution.status === "completed") {
-    return "Completed successfully";
-  }
-  return titleCase4(execution.status);
-}
-function getTaskDescription(task) {
-  if (task.description) {
-    return task.description;
-  }
-  if (task.humanCheckpoint) {
-    return `Checkpoint: ${task.humanCheckpoint}`;
-  }
-  return "Pending approval task";
-}
-function buildCommandViewDrillDownSections({
-  node,
-  timeRange,
-  executions,
-  checkpointTasks
-}) {
-  if (!node || node.kind !== "resource" || !node.sourceId || !node.resourceType) {
-    return [];
-  }
-  const sections = [];
-  const resourceHref = getResourceHref(node.resourceType, node.sourceId);
-  if ((node.resourceType === "agent" || node.resourceType === "workflow") && executions) {
-    sections.push({
-      title: "Recent executions",
-      description: `Latest runs for this ${titleCase4(node.resourceType)} in the ${timeRange} window.`,
-      emptyMessage: `No executions were recorded for this ${titleCase4(node.resourceType).toLowerCase()} in the current window.`,
-      primaryAction: resourceHref ? {
-        label: "Open resource",
-        href: resourceHref
-      } : void 0,
-      items: executions.map((execution) => ({
-        id: execution.executionId,
-        label: execution.executionId,
-        href: `${resourceHref ?? "#"}?exec=${execution.executionId}`,
-        description: getExecutionDescription(execution),
-        badgeLabel: execution.status,
-        badgeColor: getExecutionBadgeColor(execution.status),
-        meta: `Started ${formatRelativeTime3(execution.startedAt)}`
-      }))
-    });
-  }
-  if (node.resourceType === "human_checkpoint" && checkpointTasks) {
-    sections.push({
-      title: "Pending tasks",
-      description: "Human approval tasks waiting on this checkpoint.",
-      emptyMessage: "No pending tasks are currently assigned to this checkpoint.",
-      primaryAction: resourceHref ? {
-        label: "Open queue",
-        href: resourceHref
-      } : void 0,
-      items: checkpointTasks.map((task) => ({
-        id: task.id,
-        label: task.description ?? task.id,
-        href: `/operations/command-queue?task=${task.id}`,
-        description: getTaskDescription(task),
-        badgeLabel: task.status,
-        badgeColor: getTaskBadgeColor(task.status),
-        meta: `Created ${formatRelativeTime3(task.createdAt)}`
-      }))
-    });
-  }
-  return sections;
-}
-
-// src/features/operations/organization-graph/path-tracing/trace.ts
-var NODE_KIND_ORDER = {
-  organization: 0,
-  feature: 1,
-  surface: 2,
-  capability: 3,
-  entity: 4,
-  resource: 5,
-  knowledge: 6
-};
-var NODE_KIND_LABEL = {
-  organization: "Organization",
-  feature: "Feature",
-  surface: "Surface",
-  capability: "Capability",
-  entity: "Entity",
-  resource: "Resource",
-  knowledge: "Knowledge"
-};
-function getNodeLabel(node) {
-  return node.label || node.sourceId || node.id;
-}
-function compareTraceNodes(a, b) {
-  const kindDelta = NODE_KIND_ORDER[a.kind] - NODE_KIND_ORDER[b.kind];
-  if (kindDelta !== 0) {
-    return kindDelta;
-  }
-  const labelDelta = getNodeLabel(a).localeCompare(getNodeLabel(b));
-  if (labelDelta !== 0) {
-    return labelDelta;
-  }
-  return a.id.localeCompare(b.id);
-}
-function buildMissingNodeMessage(selection, missingNodeIds) {
-  if (missingNodeIds.length === 0) {
-    return "The selected trace is not available.";
-  }
-  if (missingNodeIds.length === 1) {
-    const missingId = missingNodeIds[0];
-    return `Graph node "${missingId}" is not available.`;
-  }
-  return `Graph nodes "${selection.sourceId}" and "${selection.targetId}" are not available.`;
-}
-function buildPathNotFoundMessage(source, target) {
-  return `No directed path found from "${source.label}" to "${target.label}".`;
-}
-function buildOrganizationGraphTraceIndex(graph) {
-  const nodesById = /* @__PURE__ */ new Map();
-  const edgesById = /* @__PURE__ */ new Map();
-  const outgoingEdgesByNodeId = /* @__PURE__ */ new Map();
-  const incomingEdgesByNodeId = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    nodesById.set(node.id, node);
-    outgoingEdgesByNodeId.set(node.id, []);
-    incomingEdgesByNodeId.set(node.id, []);
-  }
-  for (const edge of graph.edges) {
-    edgesById.set(edge.id, edge);
-    const outgoingEdges = outgoingEdgesByNodeId.get(edge.sourceId);
-    if (outgoingEdges) {
-      outgoingEdges.push(edge);
-    }
-    const incomingEdges = incomingEdgesByNodeId.get(edge.targetId);
-    if (incomingEdges) {
-      incomingEdges.push(edge);
-    }
-  }
-  return {
-    nodesById,
-    edgesById,
-    outgoingEdgesByNodeId,
-    incomingEdgesByNodeId
-  };
-}
-function getOrganizationGraphTraceNodeKindLabel(kind) {
-  return NODE_KIND_LABEL[kind];
-}
-function formatOrganizationGraphTraceNodeOptionLabel(option) {
-  return `${option.label} \xB7 ${getOrganizationGraphTraceNodeKindLabel(option.kind)}`;
-}
-function getOrganizationGraphTraceNodeOptions(graph) {
-  return [...graph.nodes].sort(compareTraceNodes).map((node) => ({
-    id: node.id,
-    label: getNodeLabel(node),
-    kind: node.kind,
-    sourceId: node.sourceId,
-    description: node.description,
-    enabled: node.enabled
-  }));
-}
-function resolveOrganizationGraphPathTrace(graph, selection) {
-  const index = buildOrganizationGraphTraceIndex(graph);
-  const source = selection.sourceId ? index.nodesById.get(selection.sourceId) ?? null : null;
-  const target = selection.targetId ? index.nodesById.get(selection.targetId) ?? null : null;
-  const missingNodeIds = [
-    selection.sourceId && !source ? selection.sourceId : null,
-    selection.targetId && !target ? selection.targetId : null
-  ].filter((value) => Boolean(value));
-  if (!selection.sourceId && !selection.targetId) {
-    return {
-      status: "idle",
-      selection,
-      source,
-      target,
-      missingNodeIds: [],
-      pathNodes: [],
-      pathEdges: [],
-      highlightNodeIds: [],
-      highlightEdgeIds: [],
-      distance: 0,
-      message: "Select a source and target to trace a path."
-    };
-  }
-  if (!selection.sourceId || !selection.targetId) {
-    return {
-      status: "incomplete",
-      selection,
-      source,
-      target,
-      missingNodeIds,
-      pathNodes: [],
-      pathEdges: [],
-      highlightNodeIds: [],
-      highlightEdgeIds: [],
-      distance: 0,
-      message: "Select both a source and a target to resolve a path."
-    };
-  }
-  if (missingNodeIds.length > 0 || !source || !target) {
-    return {
-      status: "missing-node",
-      selection,
-      source,
-      target,
-      missingNodeIds,
-      pathNodes: [],
-      pathEdges: [],
-      highlightNodeIds: [],
-      highlightEdgeIds: [],
-      distance: 0,
-      message: buildMissingNodeMessage(selection, missingNodeIds)
-    };
-  }
-  if (source.id === target.id) {
-    return {
-      status: "found",
-      selection,
-      source,
-      target,
-      missingNodeIds: [],
-      pathNodes: [source],
-      pathEdges: [],
-      highlightNodeIds: [source.id],
-      highlightEdgeIds: [],
-      distance: 0,
-      message: `Source and target already point to "${source.label}".`
-    };
-  }
-  const visitedNodeIds = /* @__PURE__ */ new Set([source.id]);
-  const predecessorByNodeId = /* @__PURE__ */ new Map();
-  const queue = [source.id];
-  while (queue.length > 0) {
-    const currentNodeId = queue.shift();
-    if (!currentNodeId) {
-      continue;
-    }
-    const outgoingEdges = index.outgoingEdgesByNodeId.get(currentNodeId) ?? [];
-    for (const edge of outgoingEdges) {
-      if (visitedNodeIds.has(edge.targetId)) {
-        continue;
-      }
-      visitedNodeIds.add(edge.targetId);
-      predecessorByNodeId.set(edge.targetId, {
-        nodeId: currentNodeId,
-        edgeId: edge.id
-      });
-      if (edge.targetId === target.id) {
-        queue.length = 0;
-        break;
-      }
-      queue.push(edge.targetId);
-    }
-  }
-  if (!predecessorByNodeId.has(target.id)) {
-    return {
-      status: "not-found",
-      selection,
-      source,
-      target,
-      missingNodeIds: [],
-      pathNodes: [],
-      pathEdges: [],
-      highlightNodeIds: [],
-      highlightEdgeIds: [],
-      distance: 0,
-      message: buildPathNotFoundMessage(source, target)
-    };
-  }
-  const pathNodes = [target];
-  const pathEdges = [];
-  let cursorNodeId = target.id;
-  while (cursorNodeId !== source.id) {
-    const predecessor = predecessorByNodeId.get(cursorNodeId);
-    if (!predecessor) {
-      break;
-    }
-    const edge = index.edgesById.get(predecessor.edgeId);
-    const previousNode = index.nodesById.get(predecessor.nodeId);
-    if (edge) {
-      pathEdges.push(edge);
-    }
-    if (previousNode) {
-      pathNodes.push(previousNode);
-    }
-    cursorNodeId = predecessor.nodeId;
-  }
-  pathNodes.reverse();
-  pathEdges.reverse();
-  return {
-    status: "found",
-    selection,
-    source,
-    target,
-    missingNodeIds: [],
-    pathNodes,
-    pathEdges,
-    highlightNodeIds: pathNodes.map((node) => node.id),
-    highlightEdgeIds: pathEdges.map((edge) => edge.id),
-    distance: pathEdges.length,
-    message: `Path found from "${source.label}" to "${target.label}" across ${pathEdges.length} edge${pathEdges.length === 1 ? "" : "s"}.`
-  };
-}
-
-// src/features/operations/organization-graph/expand-around/expandAroundGraph.ts
-var DEFAULT_MAX_DEPTH = 1;
-var DEFAULT_MAX_RESULTS = 25;
-var ORG_MODEL_ROOT_KINDS = /* @__PURE__ */ new Set([
-  "feature",
-  "surface",
-  "entity",
-  "capability"
-]);
-var PRESET_EDGE_KINDS = {
-  coverage: ["contains", "exposes", "operates-on", "maps_to", "references"],
-  "operational-dependencies": ["references"],
-  "org-context": ["contains", "exposes", "operates-on", "maps_to"],
-  "impact-path": ["references"]
-};
-var PRESET_RELATIONSHIP_TYPES = {
-  "operational-dependencies": ["triggers", "uses", "approval"],
-  "impact-path": ["triggers", "uses", "approval"]
-};
-var PRESET_DIRECTIONS = {
-  coverage: "both",
-  "operational-dependencies": "both",
-  "org-context": "both",
-  "impact-path": "both"
-};
-function toSet(values) {
-  if (!values || values.length === 0) {
-    return null;
-  }
-  return new Set(values);
-}
-function clampMaxDepth(maxDepth) {
-  if (maxDepth === 2 || maxDepth === 3) {
-    return maxDepth;
-  }
-  return 1;
-}
-function resolvePreset(rootNode, preset) {
-  if (preset) {
-    return preset;
-  }
-  if (!rootNode) {
-    return null;
-  }
-  if (ORG_MODEL_ROOT_KINDS.has(rootNode.kind)) {
-    return "coverage";
-  }
-  if (rootNode.kind === "resource") {
-    return "operational-dependencies";
-  }
-  return null;
-}
-function resolveRequest(rootNode, request) {
-  const preset = resolvePreset(rootNode, request.preset);
-  const maxResults = request.maxResults === void 0 || !Number.isFinite(request.maxResults) ? DEFAULT_MAX_RESULTS : Math.max(0, request.maxResults);
-  return {
-    rootNodeId: request.rootNodeId,
-    direction: request.direction ?? (preset ? PRESET_DIRECTIONS[preset] : "both"),
-    maxDepth: clampMaxDepth(request.maxDepth ?? DEFAULT_MAX_DEPTH),
-    maxResults,
-    edgeKinds: toSet(request.edgeKinds ?? (preset ? PRESET_EDGE_KINDS[preset] : void 0)),
-    relationshipTypes: toSet(
-      request.relationshipTypes ?? (preset ? PRESET_RELATIONSHIP_TYPES[preset] : void 0)
-    ),
-    preset,
-    nodeKinds: toSet(request.nodeKinds),
-    resourceTypes: toSet(request.resourceTypes),
-    includeHiddenResources: request.includeHiddenResources ?? false
-  };
-}
-function getOppositeNodeId(edge, currentNodeId) {
-  if (edge.sourceId === currentNodeId) {
-    return edge.targetId;
-  }
-  if (edge.targetId === currentNodeId) {
-    return edge.sourceId;
-  }
-  return null;
-}
-function getCandidateEdges(index, nodeId2, direction) {
-  if (direction === "outgoing") {
-    return index.outgoingEdgesByNodeId.get(nodeId2) ?? [];
-  }
-  if (direction === "incoming") {
-    return index.incomingEdgesByNodeId.get(nodeId2) ?? [];
-  }
-  const seenEdgeIds = /* @__PURE__ */ new Set();
-  const edges = [];
-  for (const edge of [
-    ...index.outgoingEdgesByNodeId.get(nodeId2) ?? [],
-    ...index.incomingEdgesByNodeId.get(nodeId2) ?? []
-  ]) {
-    if (seenEdgeIds.has(edge.id)) {
-      continue;
-    }
-    seenEdgeIds.add(edge.id);
-    edges.push(edge);
-  }
-  return edges;
-}
-function matchesPresetTraversalDirection(edge, currentNodeId, request) {
-  if (request.preset === "coverage" && (edge.kind === "contains" || edge.kind === "exposes")) {
-    return edge.sourceId === currentNodeId;
-  }
-  return true;
-}
-function matchesEdgeFilters(edge, currentNodeId, request) {
-  if (request.edgeKinds && !request.edgeKinds.has(edge.kind)) {
-    return false;
-  }
-  if (request.relationshipTypes && (!edge.relationshipType || !request.relationshipTypes.has(edge.relationshipType))) {
-    return false;
-  }
-  return matchesPresetTraversalDirection(edge, currentNodeId, request);
-}
-function matchesNodeFilters(node, request) {
-  if (request.nodeKinds && !request.nodeKinds.has(node.kind)) {
-    return false;
-  }
-  if (request.resourceTypes) {
-    if (node.kind !== "resource") {
-      return false;
-    }
-    if (!node.resourceType || !request.resourceTypes.has(node.resourceType)) {
-      return false;
-    }
-  }
-  return true;
-}
-function pluralize(count, singular, plural = `${singular}s`) {
-  return `${count} ${count === 1 ? singular : plural}`;
-}
-function getNodeDisplayName(node) {
-  return node.label || node.sourceId || node.id;
-}
-function buildSummaryMessages(input) {
-  const { rootNode, preset, expandedNodes, counts, truncated } = input;
-  if (!rootNode) {
-    return ["Select an available node to expand around."];
-  }
-  if (!preset && rootNode.kind === "organization") {
-    return ["Choose a feature, surface, capability, entity, or resource before expanding."];
-  }
-  if (expandedNodes.length === 0) {
-    return [`No matching graph context found around "${getNodeDisplayName(rootNode)}".`];
-  }
-  const resourceCount = expandedNodes.filter((node) => node.kind === "resource").length;
-  const semanticContextCount = expandedNodes.length - resourceCount;
-  const rootLabel = getNodeDisplayName(rootNode);
-  const messages = [];
-  if (preset === "coverage" && ORG_MODEL_ROOT_KINDS.has(rootNode.kind)) {
-    if (resourceCount > 0 && semanticContextCount > 0) {
-      messages.push(
-        `${pluralize(resourceCount, "resource")} and ${pluralize(
-          semanticContextCount,
-          "semantic context node"
-        )} support "${rootLabel}".`
-      );
-    } else if (resourceCount > 0) {
-      messages.push(`${pluralize(resourceCount, "resource")} support "${rootLabel}".`);
-    } else {
-      messages.push(
-        `${pluralize(semanticContextCount, "semantic context node")} found around "${rootLabel}"; no mapped resources matched this coverage preset.`
-      );
-    }
-  } else if (preset === "operational-dependencies") {
-    messages.push(`${pluralize(resourceCount, "operational dependency resource")} found around "${rootLabel}".`);
-  } else if (preset === "org-context") {
-    messages.push(`${pluralize(expandedNodes.length, "semantic context node")} found around "${rootLabel}".`);
-  } else if (preset === "impact-path") {
-    messages.push(`${pluralize(resourceCount, "resource")} can call or be affected by "${rootLabel}".`);
-  } else {
-    messages.push(`${pluralize(expandedNodes.length, "node")} found around "${rootLabel}".`);
-  }
-  if (counts.hiddenResourceNodes > 0) {
-    messages.push(`${pluralize(counts.hiddenResourceNodes, "hidden resource")} matched current visibility settings.`);
-  }
-  if (counts.alreadyVisibleNodes > 0) {
-    messages.push(`${pluralize(counts.alreadyVisibleNodes, "node")} already visible in the graph.`);
-  }
-  if (truncated) {
-    messages.push(`Results were limited to ${pluralize(expandedNodes.length, "node")}.`);
-  }
-  return messages;
-}
-function expandAroundGraph(graph, request, options = {}) {
-  const index = buildOrganizationGraphTraceIndex(graph);
-  const rootNode = index.nodesById.get(request.rootNodeId) ?? null;
-  const resolved = resolveRequest(rootNode, request);
-  const alreadyVisibleNodeIds = new Set(options.alreadyVisibleNodeIds ?? []);
-  const hiddenResourceNodeIds = new Set(options.hiddenResourceNodeIds ?? []);
-  const expandedNodeIds = /* @__PURE__ */ new Set();
-  const expandedEdgeIds = /* @__PURE__ */ new Set();
-  const frontierNodeIds = /* @__PURE__ */ new Set();
-  const visitedDepthByNodeId = /* @__PURE__ */ new Map([[resolved.rootNodeId, 0]]);
-  const hasExplicitTraversalFilter = Boolean(
-    request.preset || request.edgeKinds?.length || request.relationshipTypes?.length || request.nodeKinds?.length || request.resourceTypes?.length
-  );
-  const queue = rootNode && (resolved.preset || hasExplicitTraversalFilter) ? [{ nodeId: rootNode.id, depth: 0 }] : [];
-  let truncated = false;
-  for (let queueIndex = 0; queueIndex < queue.length; queueIndex += 1) {
-    const current = queue[queueIndex];
-    if (current.depth >= resolved.maxDepth) {
-      if (current.nodeId !== resolved.rootNodeId) {
-        frontierNodeIds.add(current.nodeId);
-      }
-      continue;
-    }
-    for (const edge of getCandidateEdges(index, current.nodeId, resolved.direction)) {
-      if (!matchesEdgeFilters(edge, current.nodeId, resolved)) {
-        continue;
-      }
-      const nextNodeId = getOppositeNodeId(edge, current.nodeId);
-      if (!nextNodeId) {
-        continue;
-      }
-      const nextNode = index.nodesById.get(nextNodeId);
-      if (!nextNode || !matchesNodeFilters(nextNode, resolved)) {
-        continue;
-      }
-      if (!resolved.includeHiddenResources && hiddenResourceNodeIds.has(nextNode.id)) {
-        continue;
-      }
-      const nextDepth = current.depth + 1;
-      const previousDepth = visitedDepthByNodeId.get(nextNode.id);
-      if (previousDepth !== void 0) {
-        if (nextNode.id === resolved.rootNodeId || expandedNodeIds.has(nextNode.id)) {
-          expandedEdgeIds.add(edge.id);
-        }
-        continue;
-      }
-      if (expandedNodeIds.size >= resolved.maxResults) {
-        truncated = true;
-        frontierNodeIds.add(nextNode.id);
-        continue;
-      }
-      visitedDepthByNodeId.set(nextNode.id, nextDepth);
-      expandedNodeIds.add(nextNode.id);
-      expandedEdgeIds.add(edge.id);
-      if (nextDepth >= resolved.maxDepth) {
-        frontierNodeIds.add(nextNode.id);
-        continue;
-      }
-      queue.push({ nodeId: nextNode.id, depth: nextDepth });
-    }
-  }
-  const expandedNodes = [...expandedNodeIds].map((nodeId2) => index.nodesById.get(nodeId2)).filter((node) => Boolean(node));
-  const hiddenResourceNodes = expandedNodes.filter((node) => hiddenResourceNodeIds.has(node.id)).length;
-  const alreadyVisibleNodes = expandedNodes.filter((node) => alreadyVisibleNodeIds.has(node.id)).length;
-  const newNodes = expandedNodes.filter(
-    (node) => !hiddenResourceNodeIds.has(node.id) && !alreadyVisibleNodeIds.has(node.id)
-  ).length;
-  const counts = {
-    newNodes,
-    newEdges: expandedEdgeIds.size,
-    alreadyVisibleNodes,
-    hiddenResourceNodes
-  };
-  const summaryMessages = buildSummaryMessages({
-    rootNode,
-    preset: resolved.preset,
-    expandedNodes,
-    counts,
-    truncated
-  });
-  return {
-    rootNodeId: request.rootNodeId,
-    rootNode,
-    preset: resolved.preset,
-    direction: resolved.direction,
-    maxDepth: resolved.maxDepth,
-    maxResults: resolved.maxResults,
-    expandedNodeIds: [...expandedNodeIds],
-    expandedEdgeIds: [...expandedEdgeIds],
-    frontierNodeIds: [...frontierNodeIds].filter((nodeId2) => nodeId2 !== resolved.rootNodeId),
-    truncated,
-    counts,
-    summaryMessages,
-    message: summaryMessages[0] ?? ""
-  };
-}
-var PRESET_OPTIONS = [
-  { value: "coverage", label: "Coverage" },
-  { value: "operational-dependencies", label: "Operational dependencies" },
-  { value: "org-context", label: "Org context" },
-  { value: "impact-path", label: "Impact path" }
-];
-var DIRECTION_OPTIONS = [
-  { value: "both", label: "Both" },
-  { value: "outgoing", label: "Outgoing" },
-  { value: "incoming", label: "Incoming" }
-];
-var EDGE_KIND_OPTIONS = [
-  { value: "contains", label: "Containment" },
-  { value: "references", label: "References" },
-  { value: "exposes", label: "Exposes" },
-  { value: "maps_to", label: "Maps to" },
-  { value: "operates-on", label: "Operates on" },
-  { value: "uses", label: "Uses" }
-];
-var RELATIONSHIP_OPTIONS = [
-  { value: "triggers", label: "Triggers" },
-  { value: "uses", label: "Uses" },
-  { value: "approval", label: "Approval" }
-];
-var RESOURCE_TYPE_OPTIONS = [
-  { value: "workflow", label: "Workflow" },
-  { value: "agent", label: "Agent" },
-  { value: "trigger", label: "Trigger" },
-  { value: "integration", label: "Integration" },
-  { value: "external", label: "External" },
-  { value: "human_checkpoint", label: "Human checkpoint" }
-];
-function updateValue(value, key, nextValue, onChange) {
-  onChange({
-    ...value,
-    [key]: nextValue
-  });
-}
-function toOptionalArray(values) {
-  return values.length > 0 ? values : void 0;
-}
-function toMaxDepth(value) {
-  const numeric = typeof value === "number" ? value : Number.parseInt(value, 10);
-  if (numeric === 3) return 3;
-  if (numeric === 2) return 2;
-  return 1;
-}
-function ExpandAroundPanel({
-  selectedNode,
-  value,
-  result,
-  appliedNodeCount,
-  appliedEdgeCount,
-  onChange,
-  onPreview,
-  onApply,
-  onClear
-}) {
-  const disabled = !selectedNode;
-  const canApply = Boolean(result && result.expandedNodeIds.length > 0);
-  const rootIsTooBroad = selectedNode?.kind === "organization" && !value.preset;
-  return /* @__PURE__ */ jsx(Paper, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
-    /* @__PURE__ */ jsxs(Group, { justify: "space-between", align: "flex-start", wrap: "wrap", children: [
-      /* @__PURE__ */ jsxs(Stack, { gap: 2, children: [
-        /* @__PURE__ */ jsx(Text, { size: "sm", fw: 800, children: "Expand Around" }),
-        /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: selectedNode ? `Preview typed graph context around ${selectedNode.label}.` : "Select a graph node to preview nearby operational context." })
-      ] }),
-      appliedNodeCount > 0 || appliedEdgeCount > 0 ? /* @__PURE__ */ jsxs(Badge, { variant: "light", color: "blue", children: [
-        appliedNodeCount,
-        " nodes / ",
-        appliedEdgeCount,
-        " edges applied"
-      ] }) : null
-    ] }),
-    /* @__PURE__ */ jsxs(SimpleGrid, { cols: { base: 1, sm: 2 }, spacing: "sm", children: [
-      /* @__PURE__ */ jsx(
-        Select,
-        {
-          label: "Preset",
-          placeholder: "Auto",
-          data: PRESET_OPTIONS,
-          value: value.preset ?? null,
-          onChange: (preset) => updateValue(value, "preset", preset ?? void 0, onChange),
-          disabled,
-          clearable: true
-        }
-      ),
-      /* @__PURE__ */ jsx(
-        Select,
-        {
-          label: "Direction",
-          data: DIRECTION_OPTIONS,
-          value: value.direction ?? "both",
-          onChange: (direction) => updateValue(value, "direction", direction ?? "both", onChange),
-          disabled
-        }
-      ),
-      /* @__PURE__ */ jsx(
-        NumberInput,
-        {
-          label: "Depth",
-          min: 1,
-          max: 3,
-          value: value.maxDepth ?? 1,
-          onChange: (maxDepth) => updateValue(value, "maxDepth", toMaxDepth(maxDepth), onChange),
-          disabled
-        }
-      ),
-      /* @__PURE__ */ jsx(
-        NumberInput,
-        {
-          label: "Max results",
-          min: 1,
-          max: 100,
-          value: value.maxResults ?? 25,
-          onChange: (maxResults) => updateValue(
-            value,
-            "maxResults",
-            Math.max(1, typeof maxResults === "number" ? maxResults : Number.parseInt(maxResults, 10) || 25),
-            onChange
-          ),
-          disabled
-        }
-      )
-    ] }),
-    /* @__PURE__ */ jsx(
-      MultiSelect,
-      {
-        label: "Relationship filters",
-        placeholder: "Preset defaults",
-        data: RELATIONSHIP_OPTIONS,
-        value: value.relationshipTypes ?? [],
-        onChange: (relationshipTypes) => updateValue(value, "relationshipTypes", toOptionalArray(relationshipTypes), onChange),
-        disabled,
-        clearable: true
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      MultiSelect,
-      {
-        label: "Edge kind filters",
-        placeholder: "Preset defaults",
-        data: EDGE_KIND_OPTIONS,
-        value: value.edgeKinds ?? [],
-        onChange: (edgeKinds) => updateValue(value, "edgeKinds", toOptionalArray(edgeKinds), onChange),
-        disabled,
-        clearable: true
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      MultiSelect,
-      {
-        label: "Resource type filters",
-        placeholder: "All resource types",
-        data: RESOURCE_TYPE_OPTIONS,
-        value: value.resourceTypes ?? [],
-        onChange: (resourceTypes) => updateValue(value, "resourceTypes", toOptionalArray(resourceTypes), onChange),
-        disabled,
-        clearable: true
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      Switch,
-      {
-        label: "Include hidden resources",
-        checked: value.includeHiddenResources ?? true,
-        onChange: (event) => updateValue(value, "includeHiddenResources", event.currentTarget.checked, onChange),
-        disabled
-      }
-    ),
-    rootIsTooBroad ? /* @__PURE__ */ jsx(Text, { size: "xs", c: "orange", children: "The organization root is broad. Choose a narrower node or a semantic preset before previewing." }) : null,
-    result ? /* @__PURE__ */ jsx(Card, { withBorder: true, radius: "md", p: "sm", children: /* @__PURE__ */ jsxs(Stack, { gap: 6, children: [
-      /* @__PURE__ */ jsxs(Group, { gap: "xs", wrap: "wrap", children: [
-        /* @__PURE__ */ jsxs(Badge, { variant: "light", children: [
-          result.counts.newNodes,
-          " new"
-        ] }),
-        /* @__PURE__ */ jsxs(Badge, { variant: "light", children: [
-          result.counts.alreadyVisibleNodes,
-          " visible"
-        ] }),
-        /* @__PURE__ */ jsxs(Badge, { variant: "light", color: result.counts.hiddenResourceNodes > 0 ? "orange" : "gray", children: [
-          result.counts.hiddenResourceNodes,
-          " hidden"
-        ] }),
-        result.truncated ? /* @__PURE__ */ jsx(Badge, { variant: "light", color: "yellow", children: "Truncated" }) : null
-      ] }),
-      result.summaryMessages.map((message) => /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: message }, message))
-    ] }) }) : null,
-    /* @__PURE__ */ jsxs(Group, { gap: "xs", justify: "space-between", wrap: "wrap", children: [
-      /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
-        /* @__PURE__ */ jsx(Button, { size: "xs", variant: "light", onClick: onPreview, disabled: disabled || rootIsTooBroad, children: "Preview" }),
-        /* @__PURE__ */ jsx(Button, { size: "xs", onClick: onApply, disabled: !canApply, children: "Apply" })
-      ] }),
-      /* @__PURE__ */ jsx(Button, { size: "xs", variant: "subtle", onClick: onClear, disabled: !result && appliedNodeCount === 0, children: "Clear expansion" })
-    ] })
-  ] }) });
-}
-var cellStyle = {
-  padding: "var(--mantine-spacing-sm) var(--mantine-spacing-md)",
-  display: "flex",
-  alignItems: "center",
-  gap: "var(--mantine-spacing-sm)",
-  minWidth: 0
-};
-function CommandViewHealthStrip({
-  overview,
-  hotspots,
-  visibleResources,
-  hiddenResources = 0,
-  resourcesHidden,
-  selectedLabel,
-  onFocusHotspot,
-  onResourcesHiddenChange,
-  onResetFocus
-}) {
-  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
-    /* @__PURE__ */ jsxs("div", { style: cellStyle, children: [
-      /* @__PURE__ */ jsx(IconActivityHeartbeat, { size: 16, style: { flexShrink: 0, color: "var(--color-text-dimmed)" } }),
-      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 700, style: { flexShrink: 0 }, children: overview?.successRate == null ? "N/A" : `${Math.round(overview.successRate)}%` }),
-      /* @__PURE__ */ jsxs(Group, { gap: 4, wrap: "nowrap", children: [
-        /* @__PURE__ */ jsx(Badge, { variant: "light", color: "green", size: "xs", children: overview?.successCount ?? 0 }),
-        /* @__PURE__ */ jsx(Badge, { variant: "light", color: "red", size: "xs", children: overview?.failureCount ?? 0 }),
-        /* @__PURE__ */ jsx(Badge, { variant: "light", color: "yellow", size: "xs", children: overview?.warningCount ?? 0 })
-      ] }),
-      /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", truncate: true, style: { flexShrink: 1, minWidth: 0 }, children: overview ? `${overview.totalRuns} runs / ${overview.trackedResources} resources` : "" })
-    ] }),
-    /* @__PURE__ */ jsxs("div", { style: cellStyle, children: [
-      /* @__PURE__ */ jsx(IconAlertTriangle, { size: 16, style: { flexShrink: 0, color: "var(--color-text-dimmed)" } }),
-      hotspots.length > 0 ? /* @__PURE__ */ jsx(Group, { gap: "xs", wrap: "nowrap", style: { minWidth: 0, overflow: "hidden" }, children: hotspots.map((hotspot) => /* @__PURE__ */ jsx(Group, { gap: 4, wrap: "nowrap", children: /* @__PURE__ */ jsx(
-        Badge,
-        {
-          variant: "light",
-          color: "red",
-          size: "xs",
-          style: { cursor: "pointer", flexShrink: 0 },
-          onClick: () => onFocusHotspot(hotspot.resourceId),
-          children: hotspot.label
-        }
-      ) }, hotspot.nodeId)) }) : /* @__PURE__ */ jsx(Badge, { variant: "light", color: "green", size: "xs", leftSection: /* @__PURE__ */ jsx(IconCircleCheck, { size: 10 }), children: "No hotspots" })
-    ] }),
-    /* @__PURE__ */ jsxs("div", { style: cellStyle, children: [
-      /* @__PURE__ */ jsx(IconClockPause, { size: 16, style: { flexShrink: 0, color: "var(--color-text-dimmed)" } }),
-      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 700, style: { flexShrink: 0 }, children: overview?.pendingApprovals ?? 0 }),
-      /* @__PURE__ */ jsxs(Text, { size: "xs", c: "dimmed", truncate: true, children: [
-        "pending / ",
-        overview?.activeHumanCheckpoints ?? 0,
-        " queues"
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxs("div", { style: cellStyle, children: [
-      /* @__PURE__ */ jsx(IconTopologyStar3, { size: 16, style: { flexShrink: 0, color: "var(--color-text-dimmed)" } }),
-      /* @__PURE__ */ jsx(Text, { size: "xs", fw: 600, truncate: true, style: { minWidth: 0 }, children: selectedLabel ?? `${visibleResources} visible / ${hiddenResources} hidden` }),
-      /* @__PURE__ */ jsx(
-        Button,
-        {
-          size: "compact-xs",
-          variant: resourcesHidden ? "light" : "subtle",
-          onClick: () => onResourcesHiddenChange(!resourcesHidden),
-          style: { flexShrink: 0 },
-          children: resourcesHidden ? "Show resources" : "Hide resources"
-        }
-      ),
-      /* @__PURE__ */ jsx(Button, { size: "compact-xs", variant: "subtle", onClick: onResetFocus, style: { flexShrink: 0 }, children: "Reset" })
-    ] })
-  ] });
-}
-var FILTER_STATE_ICONS2 = {
-  neutral: IconCircleDashed,
-  include: IconCircleCheck,
-  exclude: IconCircleX
-};
-var FILTER_STATE_COLORS2 = {
-  neutral: "var(--color-text-dimmed)",
-  include: "var(--mantine-color-green-6)",
-  exclude: "var(--mantine-color-red-6)"
-};
-var FILTER_STATE_LABELS2 = {
-  neutral: "Not filtered",
-  include: "Include only",
-  exclude: "Exclude"
-};
-function getCommandViewResources(commandViewData) {
-  if (!commandViewData) {
-    return [];
-  }
-  return [
-    ...commandViewData.agents,
-    ...commandViewData.workflows,
-    ...commandViewData.triggers,
-    ...commandViewData.integrations,
-    ...commandViewData.externalResources,
-    ...commandViewData.humanCheckpoints
-  ];
-}
-function nextDomainFilterState(current) {
-  if (current === "neutral") return "include";
-  if (current === "include") return "exclude";
-  return "neutral";
-}
-function FilterPanel({
-  filters,
-  onChangeFilters,
-  resetValue,
-  disabled = false,
-  commandViewData,
-  lens,
-  resourcesHidden,
-  diagnosticsHidden,
-  onResourcesHiddenChange,
-  onDiagnosticsHiddenChange,
-  onRevealResources,
-  onResetFilters,
-  visibilityCounts,
-  graph,
-  baseGraph,
-  layout = "grid"
-}) {
-  const resourceFacets = collectResourceFilterFacets(getCommandViewResources(commandViewData));
-  const Section = ({ children }) => layout === "stack" ? /* @__PURE__ */ jsx(
-    Stack,
-    {
-      gap: "sm",
-      pb: "sm",
-      style: {
-        borderBottom: "1px solid var(--color-border)"
-      },
-      children
-    }
-  ) : /* @__PURE__ */ jsx(Paper, { withBorder: true, p: "md", radius: "md", style: { background: "var(--color-surface)" }, children });
-  const updateDomainFilter = (domainId) => {
-    const current = filters.domainFilters[domainId] ?? "neutral";
-    onChangeFilters({
-      ...filters,
-      domainFilters: {
-        ...filters.domainFilters,
-        [domainId]: nextDomainFilterState(current)
-      }
-    });
-  };
-  const handleResourceVisibilityAction = () => {
-    if (resourcesHidden) {
-      onRevealResources();
-      return;
-    }
-    onResourcesHiddenChange(true);
-  };
-  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(Section, { children: /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
-      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 700, children: "Filters" }),
-      /* @__PURE__ */ jsx(
-        OrganizationGraphFilterToolbar,
-        {
-          value: filters,
-          onChange: onChangeFilters,
-          disabled,
-          resetValue
-        }
-      )
-    ] }) }),
-    /* @__PURE__ */ jsx(Section, { children: /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
-      /* @__PURE__ */ jsxs(Group, { justify: "space-between", align: "center", children: [
-        /* @__PURE__ */ jsx(Text, { size: "sm", fw: 700, children: "Visibility" }),
-        /* @__PURE__ */ jsxs(Badge, { variant: "light", children: [
-          visibilityCounts.visibleResourceCount,
-          "/",
-          visibilityCounts.totalResourceCount,
-          " resources"
-        ] })
-      ] }),
-      lens === "command-view" ? /* @__PURE__ */ jsxs(Fragment, { children: [
-        /* @__PURE__ */ jsx(
-          Checkbox,
-          {
-            label: "Hide resource nodes",
-            description: "Keep the organization structure readable and reveal resource nodes as needed.",
-            checked: resourcesHidden,
-            onChange: (event) => onResourcesHiddenChange(event.currentTarget.checked),
-            disabled
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          Checkbox,
-          {
-            label: "Hide diagnostic and testing resources",
-            description: "Diagnostics stay available through filters, trace, impact, and contextual reveal.",
-            checked: diagnosticsHidden,
-            onChange: (event) => onDiagnosticsHiddenChange(event.currentTarget.checked),
-            disabled
-          }
-        ),
-        /* @__PURE__ */ jsxs(Group, { gap: "xs", wrap: "wrap", children: [
-          /* @__PURE__ */ jsxs(Badge, { variant: "light", color: visibilityCounts.hiddenResourceCount > 0 ? "yellow" : "green", children: [
-            visibilityCounts.hiddenResourceCount,
-            " hidden"
-          ] }),
-          /* @__PURE__ */ jsxs(Badge, { variant: "light", color: visibilityCounts.hiddenDiagnosticResourceCount > 0 ? "yellow" : "gray", children: [
-            visibilityCounts.hiddenDiagnosticResourceCount,
-            " diagnostic/testing"
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs(Group, { justify: "space-between", children: [
-          /* @__PURE__ */ jsx(Button, { size: "xs", variant: "light", onClick: handleResourceVisibilityAction, disabled, children: resourcesHidden ? "Reveal resources" : "Hide resources" }),
-          /* @__PURE__ */ jsx(
-            Button,
-            {
-              size: "xs",
-              variant: "subtle",
-              leftSection: /* @__PURE__ */ jsx(IconRefresh, { size: 14 }),
-              onClick: onResetFilters,
-              disabled,
-              children: "Reset filters"
-            }
-          )
-        ] })
-      ] }) : /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "Visibility controls are available in the Command View lens." })
-    ] }) }),
-    /* @__PURE__ */ jsx(Section, { children: /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
-      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 700, children: "Resource Facets" }),
-      resourceFacets.length > 0 ? /* @__PURE__ */ jsx(Stack, { gap: 4, children: resourceFacets.map((facet) => {
-        const filterState = filters.domainFilters[facet.id] ?? "neutral";
-        const StateIcon = FILTER_STATE_ICONS2[filterState];
-        return /* @__PURE__ */ jsx(
-          UnstyledButton,
-          {
-            title: FILTER_STATE_LABELS2[filterState],
-            onClick: () => updateDomainFilter(facet.id),
-            disabled,
-            style: {
-              border: "1px solid var(--color-border)",
-              borderRadius: "var(--mantine-radius-sm)",
-              padding: "6px 8px"
-            },
-            children: /* @__PURE__ */ jsxs(Group, { gap: "xs", wrap: "nowrap", children: [
-              /* @__PURE__ */ jsx(StateIcon, { size: 16, style: { color: FILTER_STATE_COLORS2[filterState], flexShrink: 0 } }),
-              /* @__PURE__ */ jsx(Text, { size: "sm", truncate: true, c: filterState === "neutral" ? "dimmed" : void 0, children: facet.label })
-            ] })
-          },
-          facet.id
-        );
-      }) }) : /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "No resource facets are available for the current topology." }),
-      /* @__PURE__ */ jsxs(Text, { size: "xs", c: "dimmed", children: [
-        "Showing ",
-        graph?.nodes.length ?? 0,
-        " nodes and ",
-        graph?.edges.length ?? 0,
-        " edges from",
-        " ",
-        baseGraph?.nodes.length ?? 0,
-        " total nodes."
+          variant: "light",
+          color: "red",
+          size: "xs",
+          style: { cursor: "pointer", flexShrink: 0 },
+          onClick: () => onFocusHotspot(hotspot.resourceId),
+          children: hotspot.label
+        }
+      ) }, hotspot.nodeId)) }) : /* @__PURE__ */ jsx(Badge, { variant: "light", color: "green", size: "xs", leftSection: /* @__PURE__ */ jsx(IconCircleCheck, { size: 10 }), children: "No hotspots" })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { style: cellStyle, children: [
+      /* @__PURE__ */ jsx(IconClockPause, { size: 16, style: { flexShrink: 0, color: "var(--color-text-dimmed)" } }),
+      /* @__PURE__ */ jsx(Text, { size: "sm", fw: 700, style: { flexShrink: 0 }, children: overview?.pendingApprovals ?? 0 }),
+      /* @__PURE__ */ jsxs(Text, { size: "xs", c: "dimmed", truncate: true, children: [
+        "pending / ",
+        overview?.activeHumanCheckpoints ?? 0,
+        " queues"
       ] })
-    ] }) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { style: cellStyle, children: [
+      /* @__PURE__ */ jsx(IconTopologyStar3, { size: 16, style: { flexShrink: 0, color: "var(--color-text-dimmed)" } }),
+      /* @__PURE__ */ jsx(Text, { size: "xs", fw: 600, truncate: true, style: { minWidth: 0 }, children: selectedLabel ?? `${visibleResources} visible / ${hiddenResources} hidden` }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          size: "compact-xs",
+          variant: resourcesHidden ? "light" : "subtle",
+          onClick: () => onResourcesHiddenChange(!resourcesHidden),
+          style: { flexShrink: 0 },
+          children: resourcesHidden ? "Show resources" : "Hide resources"
+        }
+      ),
+      /* @__PURE__ */ jsx(Button, { size: "compact-xs", variant: "subtle", onClick: onResetFocus, style: { flexShrink: 0 }, children: "Reset" })
+    ] })
   ] });
-  if (layout === "stack") {
-    return /* @__PURE__ */ jsx(Stack, { gap: "sm", children: content });
-  }
-  return /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 1, lg: 3 }, spacing: "md", children: content });
 }
 
 // src/features/operations/organization-graph/commandViewGraphHealth.ts
@@ -7499,14 +4146,14 @@ function syncGraphClasses(cy, selectedElement, traceResult, hiddenIds, hiddenEdg
     cy.elements().removeClass(
       "is-hidden is-faded is-context is-selected is-connected is-trace-node is-trace-edge is-trace-endpoint is-expanded-node is-expanded-edge"
     );
-    for (const nodeId2 of hiddenIds) {
-      const node = cy.getElementById(nodeId2);
+    for (const nodeId of hiddenIds) {
+      const node = cy.getElementById(nodeId);
       if (!node.empty()) {
         node.addClass("is-hidden");
       }
     }
-    for (const edgeId2 of hiddenEdgeIds) {
-      const edge2 = cy.getElementById(edgeId2);
+    for (const edgeId of hiddenEdgeIds) {
+      const edge2 = cy.getElementById(edgeId);
       if (!edge2.empty()) {
         edge2.addClass("is-hidden");
       }
@@ -7515,14 +4162,14 @@ function syncGraphClasses(cy, selectedElement, traceResult, hiddenIds, hiddenEdg
       traceResult && (traceResult.highlightNodeIds.length > 0 || traceResult.highlightEdgeIds.length > 0)
     );
     if (!selectedElement && !hasTrace) {
-      for (const nodeId2 of expandedNodeIds) {
-        const node = cy.getElementById(nodeId2);
+      for (const nodeId of expandedNodeIds) {
+        const node = cy.getElementById(nodeId);
         if (!node.empty()) {
           node.addClass("is-expanded-node");
         }
       }
-      for (const edgeId2 of expandedEdgeIds) {
-        const edge2 = cy.getElementById(edgeId2);
+      for (const edgeId of expandedEdgeIds) {
+        const edge2 = cy.getElementById(edgeId);
         if (!edge2.empty()) {
           edge2.addClass("is-expanded-edge");
         }
@@ -7530,27 +4177,27 @@ function syncGraphClasses(cy, selectedElement, traceResult, hiddenIds, hiddenEdg
       return;
     }
     cy.elements().addClass("is-faded");
-    for (const nodeId2 of expandedNodeIds) {
-      const node = cy.getElementById(nodeId2);
+    for (const nodeId of expandedNodeIds) {
+      const node = cy.getElementById(nodeId);
       if (!node.empty()) {
         node.removeClass("is-faded").addClass("is-context is-expanded-node");
       }
     }
-    for (const edgeId2 of expandedEdgeIds) {
-      const edge2 = cy.getElementById(edgeId2);
+    for (const edgeId of expandedEdgeIds) {
+      const edge2 = cy.getElementById(edgeId);
       if (!edge2.empty()) {
         edge2.removeClass("is-faded").addClass("is-connected is-expanded-edge");
       }
     }
     if (traceResult) {
-      for (const nodeId2 of traceResult.highlightNodeIds) {
-        const node = cy.getElementById(nodeId2);
+      for (const nodeId of traceResult.highlightNodeIds) {
+        const node = cy.getElementById(nodeId);
         if (!node.empty()) {
           node.removeClass("is-faded").addClass("is-context is-trace-node");
         }
       }
-      for (const edgeId2 of traceResult.highlightEdgeIds) {
-        const edge2 = cy.getElementById(edgeId2);
+      for (const edgeId of traceResult.highlightEdgeIds) {
+        const edge2 = cy.getElementById(edgeId);
         if (!edge2.empty()) {
           edge2.removeClass("is-faded").addClass("is-connected is-trace-edge");
         }
@@ -8031,9 +4678,9 @@ function OrganizationGraphPage({ lens = "default", timeRange = "30d" }) {
     })).sort((left, right) => left.label.localeCompare(right.label)),
     [visibleGraph]
   );
-  const focusGraphNode = useEffectEvent((nodeId2) => {
+  const focusGraphNode = useEffectEvent((nodeId) => {
     setFocusRequest({
-      nodeId: nodeId2,
+      nodeId,
       nonce: Date.now()
     });
   });
@@ -8154,7 +4801,7 @@ function OrganizationGraphPage({ lens = "default", timeRange = "30d" }) {
       return;
     }
     const graphNodeIds = new Set(graph.nodes.map((node) => node.id));
-    const expansionStillExists = [...appliedExpandAroundNodeIds].some((nodeId2) => graphNodeIds.has(nodeId2));
+    const expansionStillExists = [...appliedExpandAroundNodeIds].some((nodeId) => graphNodeIds.has(nodeId));
     if (!expansionStillExists) {
       clearExpandAroundState();
     }
@@ -8581,362 +5228,6 @@ function OrganizationGraphPage({ lens = "default", timeRange = "30d" }) {
 function CommandViewPage({ timeRange }) {
   return /* @__PURE__ */ jsx(OrganizationGraphPage, { lens: "command-view", timeRange });
 }
-var EXECUTION_SECTIONS = [
-  { status: "failed", title: "Failed Executions", badgeColor: "red" },
-  { status: "warning", title: "Warning Executions", badgeColor: "yellow" },
-  { status: "completed", title: "Successful Executions", badgeColor: null }
-];
-var HOVER_CARD_STYLE = {
-  cursor: "pointer",
-  transition: "box-shadow var(--duration-fast) var(--easing)",
-  textDecoration: "none",
-  color: "inherit"
-};
-function handleHoverEnter(e) {
-  e.currentTarget.style.boxShadow = "var(--standard-box-shadow)";
-}
-function handleHoverLeave(e) {
-  e.currentTarget.style.boxShadow = "";
-}
-function ExecutionStatusSection({ executions, status, title, badgeColor, resourceUrl }) {
-  const filtered = executions.filter((e) => e.status === status);
-  if (filtered.length === 0) return null;
-  return /* @__PURE__ */ jsxs("div", { children: [
-    /* @__PURE__ */ jsxs(Group, { justify: "space-between", mb: 8, children: [
-      /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", fw: 600, tt: "uppercase", children: title }),
-      /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: filtered.length })
-    ] }),
-    /* @__PURE__ */ jsx(Stack, { gap: "xs", children: filtered.map((execution) => /* @__PURE__ */ jsxs(
-      Card,
-      {
-        padding: "xs",
-        withBorder: true,
-        component: "a",
-        href: `${resourceUrl}?exec=${execution.executionId}`,
-        target: "_blank",
-        rel: "noopener noreferrer",
-        style: HOVER_CARD_STYLE,
-        onMouseEnter: handleHoverEnter,
-        onMouseLeave: handleHoverLeave,
-        children: [
-          /* @__PURE__ */ jsxs(Group, { justify: "space-between", mb: status === "failed" && execution.errorMessage ? 4 : 0, children: [
-            badgeColor ? /* @__PURE__ */ jsx(Badge, { size: "xs", color: badgeColor, variant: "light", children: status }) : /* @__PURE__ */ jsx(Text, { size: "xs", c: "green", children: "\u2713 Completed" }),
-            /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: formatRelativeTime3(execution.startedAt) })
-          ] }),
-          status === "failed" && execution.errorMessage && /* @__PURE__ */ jsx(Text, { size: "xs", c: "red", lineClamp: 2, children: execution.errorMessage })
-        ]
-      },
-      execution.executionId
-    )) }),
-    /* @__PURE__ */ jsx(Space, { h: "sm" })
-  ] });
-}
-function CommandViewSidebarContent({ timeRange }) {
-  const theme = useMantineTheme();
-  const colors = useCyberColors();
-  const { organizationModel } = useElevasisFeatures();
-  const lensConfig = useMemo(() => getOrganizationGraphLensConfig("command-view"), []);
-  const { filters, resetFilters, updateFilters } = useOrganizationGraphFilters(lensConfig.initialFilters);
-  const toolbarResetValue = useMemo(
-    () => createOrganizationGraphFilters(lensConfig.initialFilters),
-    [lensConfig.initialFilters]
-  );
-  const selectedNodeId = useCommandViewStore((s) => s.selectedNodeId);
-  const resourcesHidden = useCommandViewStore((s) => s.resourcesHidden);
-  const setResourcesHidden = useCommandViewStore((s) => s.setResourcesHidden);
-  const diagnosticsHidden = useCommandViewStore((s) => s.diagnosticsHidden);
-  const setDiagnosticsHidden = useCommandViewStore((s) => s.setDiagnosticsHidden);
-  const diagnosticCategories = useCommandViewStore((s) => s.diagnosticCategories);
-  const revealedIds = useCommandViewStore((s) => s.revealedIds);
-  const clearRevealedIds = useCommandViewStore((s) => s.clearRevealedIds);
-  const { data, isLoading } = useCommandViewData();
-  const { data: statsData } = useCommandViewStats(timeRange);
-  const cleanData = data ?? null;
-  const dataWithStats = useMemo(() => {
-    if (!cleanData) return null;
-    if (!statsData) return cleanData;
-    return mergeStatsWithTopology(cleanData, statsData);
-  }, [cleanData, statsData]);
-  const baseGraph = useMemo(() => {
-    if (!organizationModel) {
-      return null;
-    }
-    return buildOrganizationGraph({
-      organizationModel,
-      commandViewData: cleanData ?? void 0
-    });
-  }, [cleanData, organizationModel]);
-  const graph = useMemo(() => {
-    if (!baseGraph) {
-      return null;
-    }
-    return filterOrganizationGraph(baseGraph, filters, {
-      commandViewData: cleanData
-    });
-  }, [baseGraph, cleanData, filters]);
-  const visibilityProjection = useMemo(() => {
-    if (!graph) {
-      return {
-        hiddenIds: /* @__PURE__ */ new Set(),
-        hiddenEdgeIds: /* @__PURE__ */ new Set(),
-        totalResourceCount: 0,
-        visibleResourceCount: 0,
-        hiddenResourceCount: 0,
-        hiddenDiagnosticResourceCount: 0
-      };
-    }
-    return getCommandViewVisibilityProjection({
-      graph,
-      commandViewData: cleanData,
-      resourcesHidden,
-      diagnosticsHidden,
-      diagnosticCategories,
-      revealedIds,
-      mode: "map"
-    });
-  }, [cleanData, diagnosticCategories, diagnosticsHidden, graph, resourcesHidden, revealedIds]);
-  const visibleGraph = useMemo(() => {
-    if (!graph || visibilityProjection.hiddenIds.size === 0) {
-      return graph;
-    }
-    return {
-      ...graph,
-      nodes: graph.nodes.filter((node) => !visibilityProjection.hiddenIds.has(node.id)),
-      edges: graph.edges.filter((edge) => !visibilityProjection.hiddenEdgeIds.has(edge.id))
-    };
-  }, [graph, visibilityProjection]);
-  const handleResetFilters = () => {
-    resetFilters();
-    clearRevealedIds();
-  };
-  const handleResourcesHiddenChange = (value) => {
-    setResourcesHidden(value);
-    if (value) {
-      clearRevealedIds();
-    }
-  };
-  const handleDiagnosticsHiddenChange = (value) => {
-    setDiagnosticsHidden(value);
-    if (value) {
-      clearRevealedIds();
-    }
-  };
-  const revealAllResources = () => {
-    setResourcesHidden(false);
-    setDiagnosticsHidden(false);
-    clearRevealedIds();
-  };
-  const { donutSuccessCount, donutFailedCount } = useMemo(() => {
-    if (!cleanData || !statsData) return { donutSuccessCount: 0, donutFailedCount: 0 };
-    const allResources = [
-      ...cleanData.agents,
-      ...cleanData.workflows,
-      ...cleanData.triggers,
-      ...cleanData.integrations,
-      ...cleanData.externalResources ?? [],
-      ...cleanData.humanCheckpoints ?? []
-    ];
-    const filteredIds = new Set(allResources.map((resource) => resource.resourceId));
-    let success = 0;
-    let failed = 0;
-    for (const [id, stats] of Object.entries(statsData.resources)) {
-      if (filteredIds.has(id)) {
-        success += stats.successCount;
-        failed += stats.failureCount;
-      }
-    }
-    return { donutSuccessCount: success, donutFailedCount: failed };
-  }, [cleanData, statsData]);
-  const selectedNode = useMemo(() => {
-    if (!selectedNodeId || !dataWithStats) return null;
-    const allNodes = [
-      ...dataWithStats.agents || [],
-      ...dataWithStats.workflows || [],
-      ...dataWithStats.triggers || [],
-      ...dataWithStats.integrations || [],
-      ...dataWithStats.externalResources || [],
-      ...dataWithStats.humanCheckpoints || []
-    ];
-    return allNodes.find((node) => {
-      const nodeId2 = getNodeId(node);
-      return nodeId2 === selectedNodeId || node.name === selectedNodeId;
-    }) || null;
-  }, [selectedNodeId, dataWithStats]);
-  const isNavigable = selectedNode?.type === "agent" || selectedNode?.type === "workflow";
-  const isHumanCheckpoint = selectedNode?.type === "human";
-  const selectedResourceId = useMemo(() => {
-    if (!selectedNode) return null;
-    return getNodeId(selectedNode);
-  }, [selectedNode]);
-  const {
-    page: executionPage,
-    setPage: setExecutionPage,
-    totalPages: totalExecutionPages
-  } = usePaginationState(10, [selectedResourceId, timeRange]);
-  const getNavigationUrl = () => {
-    if (!selectedNode || !selectedResourceId) return null;
-    if (selectedNode.type === "agent") return `/operations/resources/agent/${selectedResourceId}`;
-    if (selectedNode.type === "workflow") return `/operations/resources/workflow/${selectedResourceId}`;
-    if (selectedNode.type === "human") return `/operations/command-queue?checkpoint=${selectedResourceId}`;
-    return null;
-  };
-  const resourceUrl = selectedNode?.type === "agent" ? `/operations/resources/agent/${selectedResourceId}` : `/operations/resources/workflow/${selectedResourceId}`;
-  const {
-    data: executionsData,
-    isLoading: executionsLoading,
-    error: executionsError
-  } = useResourceExecutions({
-    resourceId: selectedResourceId,
-    timeRange,
-    page: executionPage,
-    limit: 10,
-    enabled: isNavigable
-  });
-  const {
-    data: checkpointTasksData,
-    isLoading: checkpointTasksLoading,
-    error: checkpointTasksError
-  } = useCheckpointTasks({
-    checkpointId: selectedResourceId,
-    enabled: isHumanCheckpoint
-  });
-  const totalExecutions = donutSuccessCount + donutFailedCount;
-  const successRate = totalExecutions > 0 ? donutSuccessCount / totalExecutions * 100 : 0;
-  const healthSegments = [
-    { name: "Completed", value: donutSuccessCount, color: colors.green },
-    { name: "Failed", value: donutFailedCount, color: colors.red }
-  ];
-  const centerValueColor = totalExecutions === 0 ? "var(--mantine-color-dimmed)" : successRate >= 95 ? colors.green : successRate >= 80 ? colors.yellow : colors.red;
-  if (isLoading && !data) {
-    return /* @__PURE__ */ jsx(SubshellSidebarLoader, {});
-  }
-  return /* @__PURE__ */ jsx(
-    Box,
-    {
-      style: {
-        flex: 1,
-        height: "100%",
-        minHeight: 0,
-        display: "flex",
-        flexDirection: "column",
-        overflow: "hidden"
-      },
-      children: /* @__PURE__ */ jsxs("div", { style: { flex: 1, minHeight: 0, overflowY: "auto", overflowX: "hidden" }, children: [
-        /* @__PURE__ */ jsx(SubshellSidebarSection, { icon: IconSitemap, label: "Command View" }),
-        /* @__PURE__ */ jsx(Box, { style: { padding: theme.spacing.sm, paddingBottom: 0 }, children: /* @__PURE__ */ jsx(Box, { pb: "xs", mb: 4, children: /* @__PURE__ */ jsx(
-          CyberDonut,
-          {
-            title: `Execution Health (${timeRange})`,
-            segments: healthSegments,
-            centerValue: totalExecutions === 0 ? "\u2014" : `${Math.round(successRate)}%`,
-            centerLabel: `${totalExecutions} runs`,
-            centerValueColor,
-            glowId: "cvHealthGlow",
-            colors
-          }
-        ) }) }),
-        /* @__PURE__ */ jsx(Box, { p: "sm", children: /* @__PURE__ */ jsx(
-          FilterPanel,
-          {
-            filters,
-            onChangeFilters: updateFilters,
-            resetValue: toolbarResetValue,
-            disabled: !baseGraph,
-            commandViewData: cleanData,
-            lens: "command-view",
-            resourcesHidden,
-            diagnosticsHidden,
-            onResourcesHiddenChange: handleResourcesHiddenChange,
-            onDiagnosticsHiddenChange: handleDiagnosticsHiddenChange,
-            onRevealResources: revealAllResources,
-            onResetFilters: handleResetFilters,
-            visibilityCounts: visibilityProjection,
-            graph: visibleGraph,
-            baseGraph,
-            layout: "stack"
-          }
-        ) }),
-        selectedNode && /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(Divider, {}),
-          /* @__PURE__ */ jsxs(Stack, { gap: "xs", p: "sm", mt: 8, children: [
-            /* @__PURE__ */ jsx(Title, { order: 4, children: selectedNode.name }),
-            selectedNode.description && /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: selectedNode.description }),
-            (isNavigable || isHumanCheckpoint) && /* @__PURE__ */ jsxs(
-              Button,
-              {
-                component: "a",
-                href: getNavigationUrl() || "#",
-                target: "_blank",
-                rel: "noopener noreferrer",
-                variant: "light",
-                size: "xs",
-                leftSection: /* @__PURE__ */ jsx(IconExternalLink, { size: 14 }),
-                mt: 4,
-                children: [
-                  "Go to",
-                  " ",
-                  selectedNode.type === "agent" ? "Agent" : selectedNode.type === "workflow" ? "Workflow" : "Queue"
-                ]
-              }
-            ),
-            /* @__PURE__ */ jsx(Space, { h: "sm" })
-          ] })
-        ] }),
-        selectedNode && isNavigable && /* @__PURE__ */ jsx(Stack, { p: "sm", children: executionsLoading ? /* @__PURE__ */ jsx(Center, { py: "md", children: /* @__PURE__ */ jsx(Loader, { size: "sm" }) }) : executionsError ? /* @__PURE__ */ jsx(APIErrorAlert, { error: executionsError, title: "Failed to load executions" }) : executionsData && executionsData.executions.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          EXECUTION_SECTIONS.map((section) => /* @__PURE__ */ jsx(
-            ExecutionStatusSection,
-            {
-              executions: executionsData.executions,
-              status: section.status,
-              title: section.title,
-              badgeColor: section.badgeColor,
-              resourceUrl
-            },
-            section.status
-          )),
-          totalExecutionPages(executionsData.totalExecutions) > 1 && /* @__PURE__ */ jsx(Group, { justify: "center", children: /* @__PURE__ */ jsx(
-            Pagination,
-            {
-              size: "sm",
-              total: totalExecutionPages(executionsData.totalExecutions),
-              value: executionPage,
-              onChange: setExecutionPage,
-              boundaries: 1
-            }
-          ) })
-        ] }) : executionsData ? /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: "No executions in the selected time range" }) : null }),
-        selectedNode && isHumanCheckpoint && /* @__PURE__ */ jsx(Stack, { p: "sm", children: checkpointTasksLoading ? /* @__PURE__ */ jsx(Center, { py: "md", children: /* @__PURE__ */ jsx(Loader, { size: "sm" }) }) : checkpointTasksError ? /* @__PURE__ */ jsx(APIErrorAlert, { error: checkpointTasksError, title: "Failed to load pending tasks" }) : checkpointTasksData && checkpointTasksData.tasks.length > 0 ? /* @__PURE__ */ jsxs("div", { children: [
-          /* @__PURE__ */ jsxs(Group, { justify: "space-between", mb: 8, children: [
-            /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", fw: 600, tt: "uppercase", children: "Pending Tasks" }),
-            /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: checkpointTasksData.tasks.length })
-          ] }),
-          /* @__PURE__ */ jsx(Stack, { gap: "xs", children: checkpointTasksData.tasks.map((task) => /* @__PURE__ */ jsxs(
-            Card,
-            {
-              padding: "xs",
-              withBorder: true,
-              component: "a",
-              href: `/operations/command-queue?task=${task.id}`,
-              target: "_blank",
-              rel: "noopener noreferrer",
-              style: HOVER_CARD_STYLE,
-              onMouseEnter: handleHoverEnter,
-              onMouseLeave: handleHoverLeave,
-              children: [
-                /* @__PURE__ */ jsxs(Group, { justify: "space-between", mb: task.description ? 4 : 0, children: [
-                  /* @__PURE__ */ jsx(Badge, { size: "xs", color: "orange", variant: "light", children: "pending" }),
-                  /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: formatRelativeTime3(task.createdAt) })
-                ] }),
-                task.description && /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", lineClamp: 2, children: task.description })
-              ]
-            },
-            task.id
-          )) })
-        ] }) : checkpointTasksData ? /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: "No pending tasks" }) : null })
-      ] })
-    }
-  );
-}
 function WorkflowExecutionPanel({
   resourceId,
   resourceDefinition,
@@ -9121,6 +5412,81 @@ function ExecutionPanel({
       return isWorkflowDefinition2(resourceDefinition) ? /* @__PURE__ */ jsx(WorkflowExecutionPanel, { ...diProps, resourceDefinition }) : /* @__PURE__ */ jsx(ResourceDefinitionError, { resourceId, resourceType, resourceName });
   }
 }
+function ExecuteWorkflowModal({
+  opened,
+  onClose,
+  resource,
+  isPending = false,
+  error,
+  result,
+  onViewExecution,
+  onReset,
+  children
+}) {
+  const canClose = !isPending;
+  const title = resource.name ?? resource.resourceId;
+  return /* @__PURE__ */ jsx(
+    Modal,
+    {
+      opened,
+      onClose: canClose ? onClose : () => void 0,
+      centered: true,
+      size: "lg",
+      closeOnClickOutside: canClose,
+      closeOnEscape: canClose,
+      withCloseButton: canClose,
+      title: /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+        /* @__PURE__ */ jsxs(Text, { fw: 600, children: [
+          "Run ",
+          resource.resourceType
+        ] }),
+        /* @__PURE__ */ jsx(Badge, { color: "blue", variant: "light", size: "sm", children: resource.resourceType })
+      ] }),
+      children: /* @__PURE__ */ jsxs(Stack, { gap: "md", children: [
+        /* @__PURE__ */ jsxs(Group, { gap: 4, wrap: "nowrap", children: [
+          /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "Target:" }),
+          /* @__PURE__ */ jsx(Text, { size: "sm", fw: 500, children: title }),
+          /* @__PURE__ */ jsx(Code, { children: resource.resourceId })
+        ] }),
+        /* @__PURE__ */ jsx(Divider, {}),
+        result ? /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
+          /* @__PURE__ */ jsx(Alert, { variant: "light", color: "teal", title: "Execution started", icon: /* @__PURE__ */ jsx(IconCheck, { size: 16 }), children: /* @__PURE__ */ jsxs(Stack, { gap: 4, children: [
+            /* @__PURE__ */ jsxs(Text, { size: "sm", children: [
+              "The ",
+              resource.resourceType,
+              " is now running."
+            ] }),
+            /* @__PURE__ */ jsxs(Group, { gap: 4, children: [
+              /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: "Execution ID:" }),
+              /* @__PURE__ */ jsx(Code, { children: result.executionId })
+            ] })
+          ] }) }),
+          /* @__PURE__ */ jsxs(Group, { justify: "flex-end", gap: "xs", children: [
+            onReset && /* @__PURE__ */ jsx(Button, { variant: "default", onClick: onReset, children: "Run again" }),
+            onViewExecution && /* @__PURE__ */ jsx(
+              Button,
+              {
+                leftSection: /* @__PURE__ */ jsx(IconExternalLink, { size: 16 }),
+                onClick: () => onViewExecution(result.executionId),
+                children: "View execution"
+              }
+            ),
+            /* @__PURE__ */ jsx(Button, { variant: "light", onClick: onClose, children: "Close" })
+          ] })
+        ] }) : error ? /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
+          /* @__PURE__ */ jsx(Alert, { variant: "light", color: "red", title: "Execution failed to start", icon: /* @__PURE__ */ jsx(IconAlertCircle, { size: 16 }), children: /* @__PURE__ */ jsx(Text, { size: "sm", children: error.message || "An unknown error occurred." }) }),
+          /* @__PURE__ */ jsxs(Group, { justify: "flex-end", gap: "xs", children: [
+            onReset && /* @__PURE__ */ jsx(Button, { variant: "default", onClick: onReset, children: "Try again" }),
+            /* @__PURE__ */ jsx(Button, { variant: "light", onClick: onClose, children: "Close" })
+          ] })
+        ] }) : /* @__PURE__ */ jsxs("div", { style: { position: "relative" }, children: [
+          /* @__PURE__ */ jsx(LoadingOverlay, { visible: isPending, zIndex: 1e3, overlayProps: { blur: 2 } }),
+          children ?? /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "No input form provided." })
+        ] })
+      ] })
+    }
+  );
+}
 function SessionListItem({ session, onClick, isSelected = false, onDeleted }) {
   const deleteSession = useDeleteSession();
   const [isDeleting, setIsDeleting] = useState(false);
@@ -10248,10 +6614,10 @@ var defaultOperationsSidebarWidth = 250;
 var operationsManifest = {
   key: "operations",
   featureId: "operations",
-  capabilityIds: ["operations.command-view"],
+  capabilityIds: ["knowledge.command-view"],
   icon: IconCode,
   sidebar: OperationsSidebar,
-  sidebarWidth: ({ currentPath }) => currentPath.startsWith("/operations/command-view") ? commandViewSidebarWidth : defaultOperationsSidebarWidth
+  sidebarWidth: ({ currentPath }) => currentPath.startsWith("/knowledge/command-view") ? commandViewSidebarWidth : defaultOperationsSidebarWidth
 };
 
-export { ActionModal, AgentDefinitionDisplay, AgentExecutionLogs, AgentExecutionPanel, AgentSessionGroup, BaseExecutionLogs, BaseExecutionLogsHeader, BaseExecutionLogsStates, CheckpointGroup, CollapsibleJsonSection, CommandQueueDetailPage, CommandQueuePage, CommandQueueShell, CommandQueueSidebar, CommandQueueSidebarMiddle, CommandQueueSidebarTop, CommandQueueTaskRow, CommandViewPage, CommandViewSidebarContent, ConfigCard, ContentSections, ContextUsageBadge, ContractDisplay, ExecuteWorkflowModal, ExecutionErrorSection, ExecutionPanel, LogEntry, LogGroup, NewKnowledgeMapEdge, NewKnowledgeMapGraph, NewKnowledgeMapNode, OperationsSidebar, OperationsSidebarMiddle, OperationsSidebarTop, OrganizationGraphPage, ResourceDefinitionSection, ResourceDetailPage, ResourceErrorState, ResourceExecuteDialog, ResourceExecuteForm, ResourceFilter, ResourceHeader, ResourceNotFoundState, ResourcesPage, ResourcesSidebar, SessionChatArea, SessionChatInterface, SessionChatPage, SessionDetailsSidebar, SessionExecutionLogs, SessionHeader, SessionListItem, SessionMemory, SessionsPage, SessionsSidebar, ToolsListDisplay, WorkflowDefinitionDisplay, WorkflowExecutionLogs, WorkflowExecutionPanel, getExecutionStatusConfig, getIcon, getLogLevelConfig, iconMap, operationsManifest, useNewKnowledgeMapLayout };
+export { ActionModal, AgentDefinitionDisplay, AgentExecutionLogs, AgentExecutionPanel, AgentSessionGroup, BaseExecutionLogs, BaseExecutionLogsHeader, BaseExecutionLogsStates, CheckpointGroup, CollapsibleJsonSection, CommandQueueDetailPage, CommandQueuePage, CommandQueueShell, CommandQueueSidebar, CommandQueueSidebarMiddle, CommandQueueSidebarTop, CommandQueueTaskRow, CommandViewPage, ConfigCard, ContentSections, ContextUsageBadge, ContractDisplay, ExecuteWorkflowModal, ExecutionErrorSection, ExecutionPanel, LogEntry, LogGroup, NewKnowledgeMapEdge, NewKnowledgeMapGraph, NewKnowledgeMapNode, OperationsSidebar, OperationsSidebarMiddle, OperationsSidebarTop, OrganizationGraphPage, ResourceDefinitionSection, ResourceDetailPage, ResourceErrorState, ResourceFilter, ResourceHeader, ResourceNotFoundState, ResourcesPage, ResourcesSidebar, SessionChatArea, SessionChatInterface, SessionChatPage, SessionDetailsSidebar, SessionExecutionLogs, SessionHeader, SessionListItem, SessionMemory, SessionsPage, SessionsSidebar, ToolsListDisplay, WorkflowDefinitionDisplay, WorkflowExecutionLogs, WorkflowExecutionPanel, getExecutionStatusConfig, getIcon, getLogLevelConfig, iconMap, operationsManifest, useNewKnowledgeMapLayout };