@elevasis/ui 2.25.5 → 2.26.0

package/dist/chunk-OHXU5WWK.js

@@ -0,0 +1,3731 @@
+import { SemanticIcon } from './chunk-KEFWANZY.js';
+import { SubshellSidebarLoader } from './chunk-XQQEKWTL.js';
+import { OrganizationModelProspectingSchema } from './chunk-4KTLOK7K.js';
+import { useCyberColors, CyberDonut } from './chunk-CW3UNAF2.js';
+import { SubshellSidebarSection } from './chunk-IIMU5YAJ.js';
+import { collectResourceFilterFacets, useCommandViewStore, useCommandViewData, useCommandViewStats, usePaginationState, useResourceExecutions, useCheckpointTasks } from './chunk-YHBPR67D.js';
+import { EmptyState, APIErrorAlert } from './chunk-RIFTUOPE.js';
+import { LabelSchema, ColorTokenSchema, IconNameSchema, PathSchema, DescriptionSchema, DisplayMetadataSchema, ModelIdSchema, ReferenceIdsSchema, OrganizationModelSalesSchema } from './chunk-W2ZTLH7Y.js';
+import { useElevasisFeatures } from './chunk-V3HUIZJX.js';
+import { getNodeId } from './chunk-QD4X4H5A.js';
+import { useRef, useEffect, useMemo } from 'react';
+import { Paper, Stack, Group, Text, Button, Badge, SimpleGrid, Divider, Select, NumberInput, MultiSelect, Switch, Card, Checkbox, UnstyledButton, useMantineTheme, Box, Title, Space, Center, Loader, Pagination, TextInput, SegmentedControl } from '@mantine/core';
+import { IconShare2, IconTopologyStar3, IconRefresh, IconCircleX, IconCircleCheck, IconCircleDashed, IconSitemap, IconExternalLink, IconSearch } from '@tabler/icons-react';
+import { z } from 'zod';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+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 DEFAULT_ORGANIZATION_MODEL_BRANDING = {
+  organizationName: "Default Organization",
+  productName: "Elevasis",
+  shortName: "Elevasis",
+  logos: {}
+};
+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 DEFAULT_ORGANIZATION_MODEL_PROJECTS = {
+  projectEntityId: "delivery.project",
+  milestoneEntityId: "delivery.milestone",
+  taskEntityId: "delivery.task",
+  projectStatuses: [
+    { id: "active", label: "Active", order: 1 },
+    { id: "on_track", label: "On Track", order: 2 },
+    { id: "at_risk", label: "At Risk", order: 3 },
+    { id: "blocked", label: "Blocked", order: 4 },
+    { id: "paused", label: "Paused", order: 5 },
+    { id: "completed", label: "Completed", order: 6 }
+  ],
+  milestoneStatuses: [
+    { id: "upcoming", label: "Upcoming", order: 1 },
+    { id: "in_progress", label: "In Progress", order: 2 },
+    { id: "blocked", label: "Blocked", order: 3 },
+    { id: "overdue", label: "Overdue", order: 4 },
+    { id: "completed", label: "Completed", order: 5 }
+  ],
+  taskStatuses: [
+    { id: "planned", label: "Planned", order: 1 },
+    { id: "in_progress", label: "In Progress", order: 2 },
+    { id: "blocked", label: "Blocked", order: 3 },
+    { id: "submitted", label: "Submitted", order: 4 },
+    { id: "approved", label: "Approved", order: 5 },
+    { id: "revision_requested", label: "Revision Requested", order: 6 },
+    { id: "rejected", label: "Rejected", order: 7 },
+    { id: "cancelled", label: "Cancelled", order: 8 },
+    { id: "completed", label: "Completed", order: 9 }
+  ]
+};
+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 DEFAULT_ORGANIZATION_MODEL_OPERATIONS = {
+  entries: [
+    // --- queue (HITL command queue) ---
+    {
+      id: "operations.queue",
+      label: "HITL Queue",
+      semanticClass: "queue",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["queue"]
+    },
+    // --- executions (workflow / agent executions) ---
+    {
+      id: "operations.executions",
+      label: "Executions",
+      semanticClass: "executions",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["execution"]
+    },
+    // --- sessions (agent conversation sessions) ---
+    {
+      id: "operations.sessions",
+      label: "Sessions",
+      semanticClass: "sessions",
+      featureId: "operations"
+    },
+    // --- notifications (platform in-app notifications) ---
+    {
+      id: "operations.notifications",
+      label: "Notifications",
+      semanticClass: "notifications",
+      featureId: "monitoring"
+    },
+    // --- schedules (task scheduler) ---
+    {
+      id: "operations.schedules",
+      label: "Schedules",
+      semanticClass: "schedules",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["schedule", "schedule.run"]
+    }
+  ]
+};
+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 DEFAULT_ORGANIZATION_MODEL_STATUSES = {
+  entries: [
+    // --- delivery.task (TaskStatus — 9 values) ---
+    { id: "delivery.task.planned", label: "Planned", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.in_progress", label: "In Progress", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.blocked", label: "Blocked", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.submitted", label: "Submitted", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.approved", label: "Approved", semanticClass: "delivery.task", category: "delivery" },
+    {
+      id: "delivery.task.revision_requested",
+      label: "Revision Requested",
+      semanticClass: "delivery.task",
+      category: "delivery"
+    },
+    { id: "delivery.task.rejected", label: "Rejected", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.cancelled", label: "Cancelled", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.completed", label: "Completed", semanticClass: "delivery.task", category: "delivery" },
+    // --- delivery.project (ProjectStatus — 6 values) ---
+    { id: "delivery.project.active", label: "Active", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.on_track", label: "On Track", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.at_risk", label: "At Risk", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.blocked", label: "Blocked", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.paused", label: "Paused", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.completed", label: "Completed", semanticClass: "delivery.project", category: "delivery" },
+    // --- delivery.milestone (MilestoneStatus — 5 values) ---
+    {
+      id: "delivery.milestone.upcoming",
+      label: "Upcoming",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    {
+      id: "delivery.milestone.in_progress",
+      label: "In Progress",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    {
+      id: "delivery.milestone.blocked",
+      label: "Blocked",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    { id: "delivery.milestone.overdue", label: "Overdue", semanticClass: "delivery.milestone", category: "delivery" },
+    {
+      id: "delivery.milestone.completed",
+      label: "Completed",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    // --- queue (QueueTaskStatus — 5 values, maps hitl/command-queue tasks) ---
+    { id: "queue.pending", label: "Pending", semanticClass: "queue", category: "queue" },
+    { id: "queue.processing", label: "Processing", semanticClass: "queue", category: "queue" },
+    { id: "queue.completed", label: "Completed", semanticClass: "queue", category: "queue" },
+    { id: "queue.failed", label: "Failed", semanticClass: "queue", category: "queue" },
+    { id: "queue.expired", label: "Expired", semanticClass: "queue", category: "queue" },
+    // --- execution (ExecutionStatus — 5 values) ---
+    { id: "execution.pending", label: "Pending", semanticClass: "execution", category: "execution" },
+    { id: "execution.running", label: "Running", semanticClass: "execution", category: "execution" },
+    { id: "execution.completed", label: "Completed", semanticClass: "execution", category: "execution" },
+    { id: "execution.failed", label: "Failed", semanticClass: "execution", category: "execution" },
+    { id: "execution.warning", label: "Warning", semanticClass: "execution", category: "execution" },
+    // --- schedule (schedule status — 4 values) ---
+    { id: "schedule.active", label: "Active", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.paused", label: "Paused", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.completed", label: "Completed", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.cancelled", label: "Cancelled", semanticClass: "schedule", category: "schedule" },
+    // --- schedule.run (schedule run status — 4 values) ---
+    { id: "schedule.run.running", label: "Running", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.completed", label: "Completed", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.failed", label: "Failed", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.cancelled", label: "Cancelled", semanticClass: "schedule.run", category: "schedule" },
+    // --- request (RequestStatus — 4 values, maps reported_requests) ---
+    { id: "request.open", label: "Open", semanticClass: "request", category: "request" },
+    { id: "request.investigating", label: "Investigating", semanticClass: "request", category: "request" },
+    { id: "request.resolved", label: "Resolved", semanticClass: "request", category: "request" },
+    { id: "request.wont_fix", label: "Won't Fix", semanticClass: "request", category: "request" }
+  ]
+};
+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),
+  icon: IconNameSchema.optional(),
+  /** 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(),
+  icon: IconNameSchema.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,
+      icon: feature.icon,
+      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,
+      icon: node.icon
+    });
+    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);
+}
+
+// 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."
+};
+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 getNodeIconFallbackKind(kind) {
+  if (kind === "knowledge") return "knowledge";
+  if (kind === "feature") return "feature";
+  if (kind === "resource") return "resource";
+  return "unknown";
+}
+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 getStatusColor(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 ?? getStatusColor(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
+}) {
+  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__ */ jsxs(Group, { gap: "xs", wrap: "nowrap", align: "center", children: [
+          state.state === "node" ? /* @__PURE__ */ jsx(
+            SemanticIcon,
+            {
+              token: state.node.icon,
+              fallbackKind: getNodeIconFallbackKind(state.node.kind),
+              size: 18,
+              style: { color: "var(--color-text-subtle)" }
+            }
+          ) : null,
+          /* @__PURE__ */ jsx(Text, { fw: 800, size: "lg", style: { minWidth: 0 }, 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(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,
+        {
+          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 formatRelativeTime(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 ${formatRelativeTime(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 ${formatRelativeTime(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 FILTER_STATE_ICONS = {
+  neutral: IconCircleDashed,
+  include: IconCircleCheck,
+  exclude: IconCircleX
+};
+var FILTER_STATE_COLORS = {
+  neutral: "var(--color-text-dimmed)",
+  include: "var(--mantine-color-green-6)",
+  exclude: "var(--mantine-color-red-6)"
+};
+var FILTER_STATE_LABELS = {
+  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_ICONS[filterState];
+        return /* @__PURE__ */ jsx(
+          UnstyledButton,
+          {
+            title: FILTER_STATE_LABELS[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_COLORS[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."
+      ] })
+    ] }) })
+  ] });
+  if (layout === "stack") {
+    return /* @__PURE__ */ jsx(Stack, { gap: "sm", children: content });
+  }
+  return /* @__PURE__ */ jsx(SimpleGrid, { cols: { base: 1, lg: 3 }, spacing: "md", children: content });
+}
+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: formatRelativeTime(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: formatRelativeTime(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 })
+      ] })
+    }
+  );
+}
+
+export { CommandViewSidebarContent, DEFAULT_ORGANIZATION_MODEL_BRANDING, DEFAULT_ORGANIZATION_MODEL_CUSTOMERS, DEFAULT_ORGANIZATION_MODEL_GOALS, DEFAULT_ORGANIZATION_MODEL_IDENTITY, DEFAULT_ORGANIZATION_MODEL_OFFERINGS, DEFAULT_ORGANIZATION_MODEL_OPERATIONS, DEFAULT_ORGANIZATION_MODEL_PROJECTS, DEFAULT_ORGANIZATION_MODEL_ROLES, DEFAULT_ORGANIZATION_MODEL_STATUSES, ExpandAroundPanel, FilterPanel, OrganizationGraphDetailPanel, OrganizationModelSchema, buildCommandViewDrillDownSections, buildOrganizationGraph, createOrganizationGraphFilters, expandAroundGraph, filterOrganizationGraph, formatOrganizationGraphTraceNodeOptionLabel, getCommandViewOperationalOverview, getCommandViewSelectionOperationalSummary, getCommandViewVisibilityProjection, getConnectedHiddenResourceIds, getOrganizationGraphLensConfig, getOrganizationGraphTraceNodeOptions, resolveOrganizationGraphPathTrace, useOrganizationGraphFilters };