@elevasis/ui 2.41.0 → 2.42.0

package/dist/chunk-FIMGOWOT.js

@@ -1,3644 +0,0 @@
-import { OntologyScopeSchema, OntologyIdSchema, DEFAULT_ONTOLOGY_SCOPE, compileOrganizationOntology, listResolvedOntologyRecords, listAllSystems, defineDomainRecord, ontologyGraphNodeId, parseOntologyId, getAllProspectingStages, getAllPipelines, getAllProjectStatuses, getLeadGenStageCatalog, getAllBuildTemplates, devOnlyFor, requiresAdminFor, topLevel, parentOf, ancestorsOf, childrenOf, findById, findByPath, defaultPathFor } from './chunk-RH5VWWSC.js';
-import { IconMail, IconSend, IconFileText, IconClock, IconArrowUp, IconMessageCircle, IconRocket, IconEye, IconEdit, IconAlertTriangle, IconRefresh, IconX, IconCheck, IconShieldLock, IconActivity, IconTopologyStar3, IconApps, IconBriefcase, IconBuilding, IconBolt, IconSearch, IconChartBar, IconUsers, IconInfoCircle, IconMessagePlus, IconDatabase, IconGitBranch, IconDashboard, IconBuildingStore, IconUser, IconPlug, IconBrain, IconTargetArrow, IconBook, IconLayoutGrid, IconArchive, IconSettings, IconTool, IconCalendar } from '@tabler/icons-react';
-import { jsx } from 'react/jsx-runtime';
-import { createContext, useContext, useMemo, useCallback } from 'react';
-import { z } from 'zod';
-
-var DEFAULT_SEMANTIC_ICON_REGISTRY = {
-  // Navigation / app areas
-  dashboard: IconDashboard,
-  calendar: IconCalendar,
-  sales: IconChartBar,
-  crm: IconBuildingStore,
-  "lead-gen": IconTargetArrow,
-  projects: IconBriefcase,
-  clients: IconUsers,
-  operations: IconTool,
-  monitoring: IconChartBar,
-  knowledge: IconBrain,
-  settings: IconSettings,
-  admin: IconShieldLock,
-  archive: IconArchive,
-  business: IconBriefcase,
-  finance: IconChartBar,
-  platform: IconLayoutGrid,
-  seo: IconSearch,
-  // Knowledge kinds
-  playbook: IconBook,
-  strategy: IconTargetArrow,
-  reference: IconFileText,
-  // Resource kinds
-  agent: IconBrain,
-  workflow: IconGitBranch,
-  integration: IconPlug,
-  database: IconDatabase,
-  user: IconUser,
-  team: IconUsers,
-  // Integration specifics
-  gmail: IconMail,
-  "google-sheets": IconDatabase,
-  attio: IconBuildingStore,
-  // Surface / UI views
-  overview: IconDashboard,
-  "command-view": IconTopologyStar3,
-  "command-queue": IconSend,
-  pipeline: IconGitBranch,
-  lists: IconFileText,
-  resources: IconDatabase,
-  // Topbar action tokens
-  "message-plus": IconMessagePlus,
-  // Actions
-  approve: IconCheck,
-  reject: IconX,
-  retry: IconRefresh,
-  edit: IconEdit,
-  view: IconEye,
-  launch: IconRocket,
-  message: IconMessageCircle,
-  escalate: IconAlertTriangle,
-  promote: IconArrowUp,
-  submit: IconSend,
-  email: IconMail,
-  // Status
-  success: IconCheck,
-  error: IconX,
-  warning: IconAlertTriangle,
-  info: IconInfoCircle,
-  pending: IconClock,
-  // OM / UI group icons
-  bolt: IconBolt,
-  building: IconBuilding,
-  briefcase: IconBriefcase,
-  apps: IconApps,
-  graph: IconTopologyStar3,
-  shield: IconShieldLock,
-  users: IconUsers,
-  "chart-bar": IconChartBar,
-  search: IconSearch,
-  // UI-only om.* group tokens (not in the core enum — kept for registry lookup
-  // by components that reference them directly via extendSemanticIconRegistry)
-  "om.quick-access": IconBolt,
-  "om.profile": IconBuilding,
-  "om.business-model": IconBriefcase,
-  "om.systems": IconApps,
-  "om.graph": IconTopologyStar3,
-  "om.governance-wiring": IconShieldLock,
-  // Graph node-kind fallback tokens (used internally by knowledge-tree helpers)
-  "entity.record": IconActivity,
-  "event.lifecycle": IconActivity,
-  "policy.governance": IconShieldLock,
-  // Compatibility aliases for existing command queue payloads.
-  IconCheck,
-  IconX,
-  IconRefresh,
-  IconAlertTriangle,
-  IconEdit,
-  IconEye,
-  IconRocket,
-  IconMessageCircle,
-  IconArrowUp,
-  IconClock,
-  IconFileText,
-  IconSend,
-  IconMail
-};
-var semanticIconRegistry = { ...DEFAULT_SEMANTIC_ICON_REGISTRY };
-function extendSemanticIconRegistry(overrides) {
-  semanticIconRegistry = { ...semanticIconRegistry, ...overrides };
-}
-function getSemanticIconComponent(token, fallbackToken) {
-  const icon = resolveSemanticIconComponent(token);
-  if (icon) return icon;
-  if (fallbackToken && semanticIconRegistry[fallbackToken]) return semanticIconRegistry[fallbackToken];
-  return IconInfoCircle;
-}
-function resolveSemanticIconComponent(token) {
-  if (!token) return null;
-  return semanticIconRegistry[token] ?? null;
-}
-function SemanticIcon({
-  token,
-  fallbackToken,
-  size = 16,
-  stroke = 1.8,
-  className,
-  style,
-  "aria-hidden": ariaHidden = true
-}) {
-  const Icon = getSemanticIconComponent(token, fallbackToken);
-  return /* @__PURE__ */ jsx(
-    "span",
-    {
-      className,
-      "aria-hidden": ariaHidden,
-      style: {
-        display: "inline-flex",
-        alignItems: "center",
-        justifyContent: "center",
-        width: size,
-        height: size,
-        minWidth: size,
-        color: "currentColor",
-        flexShrink: 0,
-        ...style
-      },
-      children: /* @__PURE__ */ jsx(Icon, { size, stroke })
-    }
-  );
-}
-
-// ../core/src/organization-model/cross-ref.ts
-var ONTOLOGY_REFERENCE_KEY_KINDS = {
-  valueType: "value-type",
-  catalogType: "catalog",
-  objectType: "object",
-  eventType: "event",
-  actionType: "action",
-  linkType: "link",
-  interfaceType: "interface",
-  propertyType: "property",
-  groupType: "group",
-  surfaceType: "surface",
-  stepCatalog: "catalog"
-};
-function buildOmCrossRefIndex(model) {
-  const systemsById = /* @__PURE__ */ new Map();
-  for (const { path, system } of listAllSystems(model)) {
-    systemsById.set(path, system);
-    systemsById.set(system.id, system);
-  }
-  const resourceIds = new Set(Object.keys(model.resources ?? {}));
-  const knowledgeIds = new Set(Object.keys(model.knowledge ?? {}));
-  const roleIds = new Set(Object.keys(model.roles ?? {}));
-  const goalIds = new Set(Object.keys(model.goals ?? {}));
-  const actionIds = new Set(Object.keys(model.actions ?? {}));
-  const customerSegmentIds = new Set(Object.keys(model.customers ?? {}));
-  const offeringIds = new Set(Object.keys(model.offerings ?? {}));
-  const ontologyCompilation = compileOrganizationOntology(model);
-  const ontologyIndexByKind = {
-    object: ontologyCompilation.ontology.objectTypes,
-    link: ontologyCompilation.ontology.linkTypes,
-    action: ontologyCompilation.ontology.actionTypes,
-    catalog: ontologyCompilation.ontology.catalogTypes,
-    event: ontologyCompilation.ontology.eventTypes,
-    interface: ontologyCompilation.ontology.interfaceTypes,
-    "value-type": ontologyCompilation.ontology.valueTypes,
-    property: ontologyCompilation.ontology.sharedProperties,
-    group: ontologyCompilation.ontology.groups,
-    surface: ontologyCompilation.ontology.surfaces
-  };
-  const ontologyIds = new Set(Object.values(ontologyIndexByKind).flatMap((index) => Object.keys(index)));
-  const stageIds = /* @__PURE__ */ new Set();
-  for (const catalog of Object.values(ontologyCompilation.ontology.catalogTypes)) {
-    if (catalog.kind !== "stage") continue;
-    const entries = catalog.entries;
-    if (entries !== void 0) {
-      for (const stageId of Object.keys(entries)) {
-        stageIds.add(stageId);
-      }
-    }
-  }
-  return {
-    systemsById,
-    resourceIds,
-    knowledgeIds,
-    roleIds,
-    goalIds,
-    actionIds,
-    customerSegmentIds,
-    offeringIds,
-    ontologyIds,
-    ontologyIndexByKind,
-    stageIds
-  };
-}
-function knowledgeTargetExists(index, kind, id) {
-  if (kind === "system") return index.systemsById.has(id);
-  if (kind === "resource") return index.resourceIds.has(id);
-  if (kind === "knowledge") return index.knowledgeIds.has(id);
-  if (kind === "stage") return index.stageIds.has(id);
-  if (kind === "action") return index.actionIds.has(id);
-  if (kind === "role") return index.roleIds.has(id);
-  if (kind === "goal") return index.goalIds.has(id);
-  if (kind === "customer-segment") return index.customerSegmentIds.has(id);
-  if (kind === "offering") return index.offeringIds.has(id);
-  if (kind === "ontology") return index.ontologyIds.has(id);
-  return false;
-}
-var ORGANIZATION_MODEL_ICON_TOKENS = [
-  // Navigation / app areas
-  "dashboard",
-  "calendar",
-  "sales",
-  "crm",
-  "lead-gen",
-  "projects",
-  "clients",
-  "operations",
-  "monitoring",
-  "knowledge",
-  "settings",
-  "admin",
-  "archive",
-  "business",
-  "finance",
-  "platform",
-  "seo",
-  // Knowledge kinds
-  "playbook",
-  "strategy",
-  "reference",
-  // Resource kinds
-  "agent",
-  "workflow",
-  "integration",
-  "database",
-  "user",
-  "team",
-  // Integration specifics
-  "gmail",
-  "google-sheets",
-  "attio",
-  // Surface / UI views
-  "overview",
-  "command-view",
-  "command-queue",
-  "pipeline",
-  "lists",
-  "resources",
-  // Actions
-  "approve",
-  "reject",
-  "retry",
-  "edit",
-  "view",
-  "launch",
-  "message",
-  "message-plus",
-  "escalate",
-  "promote",
-  "submit",
-  "email",
-  // Status
-  "success",
-  "error",
-  "warning",
-  "info",
-  "pending",
-  // OM / UI group icons
-  "bolt",
-  "building",
-  "briefcase",
-  "apps",
-  "graph",
-  "shield",
-  "users",
-  "chart-bar",
-  "search"
-];
-var CustomIconTokenSchema = z.string().trim().max(80).regex(
-  /^custom\.[a-z0-9]+(?:[-._][a-z0-9]+)*$/,
-  'Custom icon tokens must start with "custom." followed by lowercase alphanumeric segments'
-);
-var OrganizationModelBuiltinIconTokenSchema = z.enum(ORGANIZATION_MODEL_ICON_TOKENS);
-var OrganizationModelIconTokenSchema = z.union([
-  OrganizationModelBuiltinIconTokenSchema,
-  CustomIconTokenSchema
-]);
-
-// ../core/src/organization-model/domains/shared.ts
-var ModelIdSchema = z.string().trim().min(1).max(100).regex(/^[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "IDs must be lowercase and use -, _, or . separators");
-var LabelSchema = z.string().trim().min(1).max(120);
-var DescriptionSchema = z.string().trim().min(1).max(2e3);
-var ColorTokenSchema = z.string().trim().min(1).max(50);
-var IconNameSchema = OrganizationModelIconTokenSchema;
-var PathSchema = z.string().trim().startsWith("/").max(300);
-var ReferenceIdsSchema = z.array(ModelIdSchema).default([]);
-var DisplayMetadataSchema = z.object({
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  color: ColorTokenSchema.optional(),
-  icon: IconNameSchema.optional()
-});
-var TechStackEntrySchema = z.object({
-  /** Name of the external platform (e.g. "HubSpot", "Stripe", "Notion"). */
-  platform: z.string().trim().min(1).max(200),
-  /** Free-form description of what this integration is used for. */
-  purpose: z.string().trim().min(1).max(500),
-  /**
-   * Health of the credential backing this integration.
-   * - configured: credential present and valid
-   * - pending: not yet set up
-   * - expired: credential existed but has lapsed
-   * - missing: expected but not present
-   */
-  credentialStatus: z.enum(["configured", "pending", "expired", "missing"]),
-  /**
-   * Whether this integration is the primary system of record for its domain
-   * (e.g. HubSpot is SoR for contacts). Defaults to false.
-   */
-  isSystemOfRecord: z.boolean().default(false)
-});
-DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  resourceId: z.string().trim().min(1).max(255),
-  resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]),
-  systemIds: ReferenceIdsSchema,
-  entityIds: ReferenceIdsSchema,
-  surfaceIds: ReferenceIdsSchema,
-  actionIds: ReferenceIdsSchema,
-  /** Optional tech-stack metadata for external-SaaS integrations. */
-  techStack: TechStackEntrySchema.optional()
-});
-
-// ../core/src/organization-model/domains/branding.ts
-var OrganizationModelBrandingSchema = z.object({
-  /**
-   * @deprecated Prefer `identity.organizationName`; branding retains it for back-compat.
-   * Legacy tenants that have not set `identity.organizationName` fall back to this field.
-   */
-  organizationName: LabelSchema,
-  /**
-   * @deprecated Prefer `identity.productName`; branding retains it for back-compat.
-   * Legacy tenants that have not set `identity.productName` fall back to this field.
-   */
-  productName: LabelSchema,
-  /**
-   * @deprecated Prefer `identity.shortName`; branding retains it for back-compat.
-   * Legacy tenants that have not set `identity.shortName` fall back to this field.
-   */
-  shortName: z.string().trim().min(1).max(40),
-  /**
-   * @deprecated Prefer `identity.description`; branding retains it for back-compat.
-   * Legacy tenants that have not set `identity.description` fall back to this field.
-   */
-  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({}),
-  /**
-   * Brand voice — how the organization communicates. Plain-language description
-   * of tone, register, and personality (e.g. "Direct and human — no jargon").
-   * Max 280 characters.
-   */
-  voice: z.string().trim().max(280).optional(),
-  /**
-   * Brand tagline or positioning statement — the memorable one-liner that
-   * captures the brand's promise or differentiator. Max 200 characters.
-   */
-  tagline: z.string().trim().max(200).optional(),
-  /**
-   * Core brand values — an ordered list of principles the organization stands
-   * for (e.g. ["Transparency", "Craftsmanship", "Velocity"]). Each entry must
-   * be a non-empty trimmed string.
-   */
-  values: z.array(z.string().trim().min(1)).optional(),
-  /**
-   * ID of the active UI theme preset from the UI theme-presets registry.
-   * The UI layer resolves this to colors and typography via `usePresetsContext()`.
-   * Free-form string — validation and fallback state are handled at the UI layer.
-   * Min 1, max 64 characters.
-   */
-  themePresetId: z.string().trim().min(1).max(64).optional()
-}).passthrough();
-var DEFAULT_ORGANIZATION_MODEL_BRANDING = {
-  organizationName: "Default Organization",
-  productName: "Organization OS",
-  shortName: "Org OS",
-  logos: {}
-};
-var SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]).meta({ label: "Surface type", color: "blue" });
-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(),
-  systemIds: z.array(ModelIdSchema.meta({ ref: "system" })).default([]),
-  entityIds: z.array(ModelIdSchema.meta({ ref: "entity" })).default([]),
-  resourceIds: z.array(ModelIdSchema.meta({ ref: "resource" })).default([]),
-  actionIds: z.array(ModelIdSchema.meta({ ref: "action" })).default([]),
-  parentId: ModelIdSchema.meta({ ref: "surface" }).optional()
-});
-var SidebarSurfaceTargetsSchema = z.object({
-  systems: z.array(ModelIdSchema.meta({ ref: "system" })).default([]).optional(),
-  entities: z.array(ModelIdSchema.meta({ ref: "entity" })).default([]).optional(),
-  resources: z.array(ModelIdSchema.meta({ ref: "resource" })).default([]).optional(),
-  actions: z.array(ModelIdSchema.meta({ ref: "action" })).default([]).optional()
-}).default({});
-var SidebarNodeSchema = z.lazy(
-  () => z.discriminatedUnion("type", [
-    z.object({
-      type: z.literal("group"),
-      label: LabelSchema,
-      description: DescriptionSchema.optional(),
-      icon: IconNameSchema.optional(),
-      order: z.number().int().optional(),
-      children: z.record(z.string(), SidebarNodeSchema).default({})
-    }),
-    z.object({
-      type: z.literal("surface"),
-      label: LabelSchema,
-      path: PathSchema,
-      surfaceType: SurfaceTypeSchema,
-      description: DescriptionSchema.optional(),
-      icon: IconNameSchema.optional(),
-      order: z.number().int().optional(),
-      targets: SidebarSurfaceTargetsSchema.optional(),
-      devOnly: z.boolean().optional(),
-      requiresAdmin: z.boolean().optional()
-    })
-  ])
-);
-var SidebarSectionSchema = z.record(z.string(), SidebarNodeSchema).default({});
-var SidebarNavigationSchema = z.object({
-  primary: SidebarSectionSchema,
-  bottom: SidebarSectionSchema
-}).default({ primary: {}, bottom: {} });
-var TopbarActionNodeSchema = z.object({
-  id: ModelIdSchema,
-  label: LabelSchema,
-  tooltip: DescriptionSchema.optional(),
-  icon: IconNameSchema.optional(),
-  order: z.number().int().optional(),
-  enabled: z.boolean().default(true),
-  devOnly: z.boolean().optional(),
-  requiresAdmin: z.boolean().optional(),
-  targets: SidebarSurfaceTargetsSchema.optional()
-});
-var TopbarSectionSchema = z.record(z.string(), TopbarActionNodeSchema).default({});
-var OrganizationModelNavigationSchema = z.object({
-  sidebar: SidebarNavigationSchema,
-  topbar: TopbarSectionSchema
-}).default({ sidebar: { primary: {}, bottom: {} }, topbar: {} });
-function getSortedSidebarEntries(nodes) {
-  return Object.entries(nodes).sort(([leftId, left], [rightId, right]) => {
-    const orderDelta = (left.order ?? Number.MAX_SAFE_INTEGER) - (right.order ?? Number.MAX_SAFE_INTEGER);
-    return orderDelta === 0 ? leftId.localeCompare(rightId) : orderDelta;
-  });
-}
-z.object({
-  id: ModelIdSchema,
-  label: LabelSchema,
-  placement: z.string().trim().min(1).max(50),
-  surfaceIds: z.array(ModelIdSchema.meta({ ref: "surface" })).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(""),
-  /**
-   * Display name of the organization as shown to end users.
-   * Recommended placement for display naming — prefer this over the deprecated
-   * `branding.organizationName`. Falls back to `branding.organizationName` for
-   * legacy tenants that have not yet migrated.
-   */
-  organizationName: LabelSchema.optional(),
-  /**
-   * Display name of the primary product or platform.
-   * Recommended placement for display naming — prefer this over the deprecated
-   * `branding.productName`. Falls back to `branding.productName` for legacy tenants.
-   */
-  productName: LabelSchema.optional(),
-  /**
-   * Short abbreviated name used in space-constrained UI surfaces (max 40 chars).
-   * Recommended placement for display naming — prefer this over the deprecated
-   * `branding.shortName`. Falls back to `branding.shortName` for legacy tenants.
-   */
-  shortName: z.string().trim().min(1).max(40).optional(),
-  /**
-   * Plain-language description of the organization for display and discovery.
-   * Recommended placement for display naming — prefer this over the deprecated
-   * `branding.description`. Falls back to `branding.description` for legacy tenants.
-   */
-  description: DescriptionSchema.optional()
-}).passthrough();
-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),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** 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.record(z.string(), CustomerSegmentSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each segment entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_CUSTOMERS = {};
-var PricingModelSchema = z.enum(["one-time", "subscription", "usage-based", "custom"]).meta({ label: "Pricing model", color: "green" });
-var ProductSchema = z.object({
-  /** Stable unique identifier for the product (e.g. "product-starter-plan"). */
-  id: z.string().trim().min(1).max(100),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** 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 system responsible for delivering this product.
-   * When present, must reference a declared `systems.systems[].id`.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  deliveryFeatureId: z.string().trim().min(1).optional()
-});
-var OfferingsDomainSchema = z.record(z.string(), ProductSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each product entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_OFFERINGS = {};
-var EntityIdSchema = ModelIdSchema;
-var EntityLinkKindSchema = z.enum(["belongs-to", "has-many", "has-one", "many-to-many"]).meta({ label: "Link kind" });
-var EntityLinkSchema = z.object({
-  toEntity: EntityIdSchema.meta({ ref: "entity" }),
-  kind: EntityLinkKindSchema,
-  via: z.string().trim().min(1).max(255).optional(),
-  label: LabelSchema.optional()
-});
-var EntitySchema = z.object({
-  id: EntityIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  ownedBySystemId: ModelIdSchema.meta({ ref: "system" }),
-  table: z.string().trim().min(1).max(255).optional(),
-  rowSchema: ModelIdSchema.optional(),
-  stateCatalogId: ModelIdSchema.optional(),
-  links: z.array(EntityLinkSchema).optional()
-});
-var EntitiesDomainSchema = z.record(z.string(), EntitySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each entity entry id must match its map key"
-}).default({});
-function defineEntities(entries) {
-  return defineDomainRecord(EntitySchema, entries);
-}
-
-// ../core/src/organization-model/domains/actions.ts
-var ActionResourceIdSchema = z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, "Resource IDs must use letters, numbers, -, _, or . separators");
-z.enum(["slash-command", "mcp-tool", "api-endpoint", "script-execution"]).meta({ label: "Invocation kind" });
-var ActionIdSchema = ModelIdSchema;
-var ActionScopeSchema = z.union([
-  z.literal("global"),
-  z.object({
-    domain: ModelIdSchema
-  })
-]);
-var ActionRefSchema = z.object({
-  actionId: ActionIdSchema.meta({ ref: "action" }),
-  intent: z.enum(["exposes", "consumes"]).meta({ label: "Intent" })
-});
-var SlashCommandInvocationSchema = z.object({
-  kind: z.literal("slash-command"),
-  command: z.string().trim().min(1).max(200).regex(/^\/[^\s].*$/, "Slash commands must start with /"),
-  toolFactory: ModelIdSchema.optional()
-});
-var McpToolInvocationSchema = z.object({
-  kind: z.literal("mcp-tool"),
-  server: ModelIdSchema,
-  name: ModelIdSchema
-});
-var ApiEndpointInvocationSchema = z.object({
-  kind: z.literal("api-endpoint"),
-  method: z.enum(["GET", "POST", "PATCH", "DELETE"]).meta({ label: "HTTP method" }),
-  path: z.string().trim().startsWith("/").max(500),
-  requestSchema: ModelIdSchema.optional(),
-  responseSchema: ModelIdSchema.optional()
-});
-var ScriptExecutionInvocationSchema = z.object({
-  kind: z.literal("script-execution"),
-  resourceId: ActionResourceIdSchema
-});
-var ActionInvocationSchema = z.discriminatedUnion("kind", [
-  SlashCommandInvocationSchema,
-  McpToolInvocationSchema,
-  ApiEndpointInvocationSchema,
-  ScriptExecutionInvocationSchema
-]);
-var ActionSchema = z.object({
-  id: ActionIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  scope: ActionScopeSchema.default("global"),
-  resourceId: ActionResourceIdSchema.optional(),
-  affects: z.array(EntityIdSchema.meta({ ref: "entity" })).optional(),
-  invocations: z.array(ActionInvocationSchema).default([]),
-  knowledge: z.array(ModelIdSchema.meta({ ref: "knowledge" })).default([]).optional(),
-  lifecycle: z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" }).default("active")
-});
-var ActionsDomainSchema = z.record(z.string(), ActionSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each action entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_ACTIONS = {};
-function defineActions(entries) {
-  return defineDomainRecord(ActionSchema, entries);
-}
-
-// ../core/src/organization-model/domains/systems.ts
-var SystemKindSchema = z.enum(["product", "operational", "platform", "diagnostic"]).meta({ label: "System kind", color: "blue" });
-var SystemLifecycleSchema = z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" });
-var SystemStatusSchema = z.enum(["active", "deprecated", "archived"]).meta({ label: "Status", color: "teal" });
-var SystemIdSchema = ModelIdSchema;
-var SystemPathSchema = z.string().trim().min(1).regex(
-  /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*$/,
-  'must be a dotted lowercase path (e.g. "sales.lead-gen" or "sales.crm")'
-);
-var UiPositionSchema = z.enum(["sidebar-primary", "sidebar-bottom"]).meta({ label: "UI position" });
-var NodeIdStringSchema = z.string().trim().min(1).max(200).regex(
-  /^[a-z][a-z-]*:([a-z0-9-]+)(\.[a-z0-9-]+)*(:[a-z0-9.-]+)*$/,
-  "Node references must use kind:dotted-path (e.g. system:sales.crm or resource:lead-gen.company.qualify)"
-);
-var SystemUiSchema = z.object({
-  path: PathSchema,
-  surfaces: ReferenceIdsSchema,
-  icon: IconNameSchema.optional(),
-  order: z.number().int().optional()
-});
-var SystemInterfaceKeySchema = ModelIdSchema;
-var SystemInterfaceLifecycleSchema = z.enum(["draft", "active", "disabled", "deprecated", "archived"]).meta({ label: "System interface lifecycle", color: "teal" });
-var SystemInterfaceReadinessProfileSchema = z.string().trim().min(1).max(200).regex(
-  /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*(?:\.[a-z0-9][a-z0-9-]*)?$/,
-  'Readiness profiles must use dotted lowercase identifiers (e.g. "sales.lead-gen.api")'
-);
-var SystemInterfaceResourceScopeSchema = z.array(ModelIdSchema).default([]);
-var SystemApiInterfaceSchema = z.object({
-  lifecycle: SystemInterfaceLifecycleSchema.default("active"),
-  readinessProfile: SystemInterfaceReadinessProfileSchema.optional(),
-  /**
-   * Resource ids that participate in this API interface. This scopes readiness
-   * derivation without duplicating authored required/provided contract refs.
-   */
-  resourceIds: SystemInterfaceResourceScopeSchema.optional()
-}).strict();
-var SystemInterfaceRefSchema = z.object({
-  systemPath: SystemPathSchema,
-  interfaceKey: SystemInterfaceKeySchema
-}).strict();
-var JsonValueSchema = z.lazy(
-  () => z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(JsonValueSchema),
-    z.record(z.string(), JsonValueSchema)
-  ])
-);
-var SystemConfigSchema = z.record(z.string().trim().min(1).max(200), JsonValueSchema).default({}).optional();
-var SystemEntrySchema = z.object({
-  /** Stable tenant-defined system id (e.g. "sys.lead-gen" or "sales.crm"). */
-  id: SystemIdSchema,
-  /** Human-readable system label shown in UI, governance, and operations surfaces. */
-  label: LabelSchema.optional(),
-  /** @deprecated Use label. Accepted for pre-consolidation System declarations. */
-  title: LabelSchema.optional(),
-  /** One-paragraph purpose statement for the bounded context. */
-  description: DescriptionSchema.optional(),
-  /** Closed system shape enum; catalog values remain tenant-defined. */
-  kind: SystemKindSchema.optional(),
-  /** Optional self-reference for System hierarchy. */
-  parentSystemId: SystemIdSchema.optional(),
-  /** Optional UI presence. Systems without UI omit this. */
-  ui: SystemUiSchema.optional(),
-  /** Canonical lifecycle state. Replaces Feature.enabled/devOnly and System.status. */
-  lifecycle: SystemLifecycleSchema.optional(),
-  /** Optional role responsible for this system. */
-  responsibleRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
-  /** Optional knowledge nodes that govern this system. */
-  governedByKnowledge: z.array(ModelIdSchema.meta({ ref: "knowledge" })).default([]).optional(),
-  /** Optional actions this system exposes or consumes. */
-  actions: z.array(ActionRefSchema).optional(),
-  /** Optional operational policies that apply to this system. */
-  policies: z.array(ModelIdSchema.meta({ ref: "policy" })).default([]).optional(),
-  /** Optional goals this system contributes to. */
-  drivesGoals: z.array(ModelIdSchema.meta({ ref: "goal" })).default([]).optional(),
-  /** Thin API runtime-boundary marker. Readiness is derived from scoped resources and topology. */
-  apiInterface: SystemApiInterfaceSchema.optional(),
-  /** @deprecated Use lifecycle. Accepted for one publish cycle. */
-  status: SystemStatusSchema.optional(),
-  /** @deprecated Use ui.path. Kept for one-cycle Feature compatibility. */
-  path: PathSchema.optional(),
-  /** @deprecated Use ui.icon. Kept for one-cycle Feature compatibility. */
-  icon: IconNameSchema.optional(),
-  /** @deprecated Feature color token, retained for one-cycle compatibility. */
-  color: ColorTokenSchema.optional(),
-  /** @deprecated UI placement hint, retained for one-cycle compatibility. */
-  uiPosition: UiPositionSchema.optional(),
-  /** @deprecated Use lifecycle. */
-  enabled: z.boolean().optional(),
-  /** @deprecated Use lifecycle: "beta". */
-  devOnly: z.boolean().optional(),
-  requiresAdmin: z.boolean().optional(),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /**
-   * System-local JSON settings and defaults. Strongly typed OM fields,
-   * secrets, credentials, and runtime state stay outside this bucket.
-   */
-  config: SystemConfigSchema,
-  /**
-   * System-owned ontology declarations. `systems` is now the canonical child
-   * key; this scope holds the object, action, catalog, link, event, and
-   * shared contract records owned by this system.
-   */
-  ontology: OntologyScopeSchema.optional(),
-  /**
-   * Recursive child systems, authored via nesting (per L11).
-   * The key is the local system id; the full path is computed by joining
-   * ancestor keys with `.` (e.g. parent key `'sales'` + child key `'crm'` → `'sales.crm'`).
-   * Per Phase 4: `id` and `parentSystemId` fields will be removed in favour of
-   * position-derived paths. Both still exist on this schema for backward compat.
-   */
-  systems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional(),
-  /** @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge. */
-  subsystems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional()
-}).strict().refine((system) => system.label !== void 0 || system.title !== void 0, {
-  path: ["label"],
-  message: "System must provide label or title"
-}).transform((system) => {
-  const normalizedSystem = system.systems !== void 0 && system.subsystems === void 0 ? { ...system, subsystems: system.systems } : system;
-  if (normalizedSystem.status === void 0) return normalizedSystem;
-  console.warn("[organization-model] System.status is deprecated; use System.lifecycle instead.");
-  return normalizedSystem.lifecycle === void 0 ? { ...normalizedSystem, lifecycle: normalizedSystem.status } : normalizedSystem;
-});
-var SystemsDomainSchema = z.record(z.string(), SystemEntrySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each system entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_SYSTEMS = {};
-
-// ../core/src/organization-model/domains/resources.ts
-var ContractRefSchema = z.string().trim().min(1).max(500).regex(
-  /^[A-Za-z0-9@](?:[A-Za-z0-9_./@-]*[A-Za-z0-9_])?\/?[A-Za-z0-9_./@-]*#[A-Za-z_$][A-Za-z0-9_$]*$/,
-  "ContractRef must be in the format package/subpath#ExportName (e.g. @repo/elevasis-core/contracts/apollo-import#inputSchema)"
-);
-z.enum(["workflow", "agent", "integration", "script"]).meta({ label: "Resource kind", color: "orange" });
-var ResourceGovernanceStatusSchema = z.enum(["active", "deprecated", "archived"]).meta({ label: "Governance status", color: "teal" });
-var AgentKindSchema = z.enum(["orchestrator", "specialist", "utility", "platform"]).meta({ label: "Agent kind", color: "violet" });
-var ScriptResourceLanguageSchema = z.enum(["shell", "sql", "typescript", "python"]).meta({ label: "Language" });
-var CodeReferenceRoleSchema = z.enum(["entrypoint", "handler", "schema", "test", "docs", "config"]).meta({ label: "Code reference role", color: "blue" });
-var ResourceIdSchema = z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, "Resource IDs must use letters, numbers, -, _, or . separators");
-var EventIdSchema = z.string().trim().min(1).max(300).regex(
-  /^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*:[a-z0-9]+(?:[-._][a-z0-9]+)*$/,
-  "Event IDs must use <owner-id>:<event-key>"
-);
-var EventKeySchema = ModelIdSchema;
-var EventEmissionDescriptorSchema = z.object({
-  eventKey: EventKeySchema,
-  label: z.string().trim().min(1).max(120),
-  payloadSchema: ModelIdSchema.optional(),
-  lifecycle: SystemLifecycleSchema.optional()
-});
-EventEmissionDescriptorSchema.extend({
-  id: EventIdSchema,
-  ownerId: z.union([ResourceIdSchema, ModelIdSchema]),
-  ownerKind: z.enum(["resource", "entity"]).meta({ label: "Owner kind" })
-});
-var ResourceOntologyBindingSchema = z.object({
-  actions: z.array(OntologyIdSchema).optional(),
-  primaryAction: OntologyIdSchema.optional(),
-  reads: z.array(OntologyIdSchema).optional(),
-  writes: z.array(OntologyIdSchema).optional(),
-  usesCatalogs: z.array(OntologyIdSchema).optional(),
-  emits: z.array(OntologyIdSchema).optional(),
-  /**
-   * Optional typed contract binding for this resource's workflow I/O.
-   * Each ref is a `package/subpath#ExportName` string that resolves to a
-   * Zod schema in `@repo/elevasis-core` (or the consumer's equivalent package).
-   *
-   * Absence of this field preserves all existing behavior — it is additive + optional.
-   * Tier-1 validation (schema.ts): ref-string shape only (browser-safe, no imports).
-   * Tier-2 validation (om:verify): intra-package typed-map resolution asserts ZodType.
-   */
-  contract: z.object({
-    input: ContractRefSchema.optional(),
-    output: ContractRefSchema.optional()
-  }).optional()
-}).superRefine((binding, ctx) => {
-  if (binding.primaryAction === void 0) return;
-  if (binding.actions?.includes(binding.primaryAction)) return;
-  ctx.addIssue({
-    code: z.ZodIssueCode.custom,
-    path: ["primaryAction"],
-    message: "Resource ontology primaryAction must be included in actions"
-  });
-});
-var CodeReferenceSchema = z.object({
-  path: z.string().trim().min(1).max(500).regex(/^[A-Za-z0-9_./$@()[\] -]+$/, "Code reference paths must be repo-relative paths"),
-  role: CodeReferenceRoleSchema,
-  symbol: z.string().trim().min(1).max(200).optional(),
-  description: z.string().trim().min(1).max(300).optional()
-});
-var ResourceEntryBaseSchema = z.object({
-  /** Canonical resource id; runtime resourceId derives from this value. */
-  id: ResourceIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number().default(0),
-  /** Required single System membership — value is a dot-separated system path (e.g. "sales.lead-gen"). */
-  systemPath: SystemPathSchema.meta({ ref: "system" }),
-  /** Executable display title owned by the OM Resource descriptor. */
-  title: LabelSchema.optional(),
-  /** Executable display description owned by the OM Resource descriptor. */
-  description: DescriptionSchema.optional(),
-  /** Optional role responsible for maintaining this resource. */
-  ownerRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
-  status: ResourceGovernanceStatusSchema,
-  /**
-   * Ontology contract bindings for the semantic work this resource performs.
-   * `emits` stays nested here so top-level resource emits descriptors remain
-   * compatible with graph event projection during the bridge.
-   */
-  ontology: ResourceOntologyBindingSchema.optional(),
-  /** Repo-relative implementation breadcrumbs for agents and operators. */
-  codeRefs: z.array(CodeReferenceSchema).default([])
-});
-var WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal("workflow"),
-  emits: z.array(EventEmissionDescriptorSchema).optional()
-});
-var AgentResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal("agent"),
-  /** Mirrors code-side AgentConfig.kind. */
-  agentKind: AgentKindSchema,
-  /** Role this agent embodies, if any. */
-  actsAsRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
-  /** Mirrors AgentConfig.sessionCapable. */
-  sessionCapable: z.boolean(),
-  /** Broad/composite callable entry points orchestrated by this agent. */
-  invocations: z.array(ActionInvocationSchema).default([]),
-  emits: z.array(EventEmissionDescriptorSchema).optional()
-});
-var IntegrationResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal("integration"),
-  provider: z.string().trim().min(1).max(100)
-});
-var ScriptResourceSourceSchema = z.union([
-  z.string().trim().min(1).max(5e4),
-  z.object({
-    file: z.string().trim().min(1).max(500)
-  })
-]);
-var ScriptResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal("script"),
-  language: ScriptResourceLanguageSchema,
-  source: ScriptResourceSourceSchema
-});
-var ResourceEntrySchema = z.discriminatedUnion("kind", [
-  WorkflowResourceEntrySchema,
-  AgentResourceEntrySchema,
-  IntegrationResourceEntrySchema,
-  ScriptResourceEntrySchema
-]);
-var ResourcesDomainSchema = z.record(z.string(), ResourceEntrySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each resource entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_RESOURCES = {};
-function defineResources(resources) {
-  return Object.fromEntries(
-    Object.entries(resources).map(([key, resource]) => [key, ResourceEntrySchema.parse(resource)])
-  );
-}
-
-// ../core/src/organization-model/domains/roles.ts
-var RoleIdSchema = ModelIdSchema;
-var HumanRoleHolderSchema = z.object({
-  kind: z.literal("human"),
-  userId: z.string().trim().min(1).max(200)
-});
-var AgentRoleHolderSchema = z.object({
-  kind: z.literal("agent"),
-  agentId: ResourceIdSchema.meta({ ref: "resource" })
-});
-var TeamRoleHolderSchema = z.object({
-  kind: z.literal("team"),
-  memberIds: z.array(z.string().trim().min(1).max(200)).min(1)
-});
-var RoleHolderSchema = z.discriminatedUnion("kind", [
-  HumanRoleHolderSchema,
-  AgentRoleHolderSchema,
-  TeamRoleHolderSchema
-]);
-var RoleHoldersSchema = z.union([RoleHolderSchema, z.array(RoleHolderSchema).min(1)]);
-var RoleSchema = z.object({
-  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
-  id: RoleIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** 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.
-   */
-  reportsToId: RoleIdSchema.meta({ ref: "role" }).optional(),
-  /**
-   * Optional: human, agent, or team holder currently filling this role.
-   * Agent holders reference OM Resource IDs and are validated at the model level.
-   */
-  heldBy: RoleHoldersSchema.optional(),
-  /**
-   * Optional Systems this role is accountable for.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  responsibleFor: z.array(SystemIdSchema.meta({ ref: "system" })).optional()
-});
-var RolesDomainSchema = z.record(z.string(), RoleSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each role entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_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),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** 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.record(z.string(), ObjectiveSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each objective entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_GOALS = {};
-var KnowledgeTargetKindSchema = z.enum([
-  "system",
-  "resource",
-  "knowledge",
-  "stage",
-  "action",
-  "role",
-  "goal",
-  "customer-segment",
-  "offering",
-  "ontology"
-]).meta({ label: "Target kind" });
-var KnowledgeTargetRefSchema = z.object({
-  kind: KnowledgeTargetKindSchema,
-  // Ontology targets use the canonical '<scope>:<kind>/<local-id>' ontology id format.
-  // Business-logic validation of target existence is done in OrganizationModelSchema.superRefine.
-  id: z.string().trim().min(1).max(300)
-}).superRefine((target, ctx) => {
-  if (target.kind !== "ontology") return;
-  const result = OntologyIdSchema.safeParse(target.id);
-  if (!result.success) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["id"],
-      message: "Ontology knowledge targets must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
-    });
-  }
-});
-var LegacyKnowledgeLinkSchema = z.object({
-  nodeId: z.union([NodeIdStringSchema, z.templateLiteral(["ontology:", OntologyIdSchema])])
-}).superRefine((link, ctx) => {
-  const [kind] = link.nodeId.split(":");
-  if (!KnowledgeTargetKindSchema.safeParse(kind).success) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["nodeId"],
-      message: `Unknown knowledge target kind "${kind}"`
-    });
-  }
-});
-var CanonicalKnowledgeLinkSchema = z.object({
-  target: KnowledgeTargetRefSchema
-});
-function nodeIdFromTarget(target) {
-  return `${target.kind}:${target.id}`;
-}
-function targetFromNodeId(nodeId2) {
-  const [kind, ...idParts] = nodeId2.split(":");
-  return {
-    kind: KnowledgeTargetKindSchema.parse(kind),
-    id: idParts.join(":")
-  };
-}
-var KnowledgeLinkSchema = z.union([CanonicalKnowledgeLinkSchema, LegacyKnowledgeLinkSchema]).transform((link) => {
-  const target = "target" in link ? link.target : targetFromNodeId(link.nodeId);
-  return {
-    target,
-    nodeId: nodeIdFromTarget(target)
-  };
-});
-var OrgKnowledgeKindSchema = z.enum(["playbook", "strategy", "reference"]).meta({ label: "Knowledge kind", color: "grape" });
-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(),
-  /** Canonical documentation URL when body content is a local summary. */
-  externalUrl: z.string().trim().url().max(500).optional(),
-  /** Optional generated source file path for local MDX-backed knowledge nodes. */
-  sourceFilePath: z.string().trim().min(1).max(500).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([]),
-  /** Role identifiers that own this knowledge node. */
-  ownerIds: z.array(RoleIdSchema.meta({ ref: "role" })).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.record(ModelIdSchema, OrgKnowledgeNodeSchema).default({});
-var SecretLikeMetadataKeySchema = /(?:secret|password|passwd|token|api[-_]?key|credential|private[-_]?key)/i;
-var SecretLikeMetadataValueSchema = /(?:sk-[A-Za-z0-9_-]{12,}|pk_live_[A-Za-z0-9_-]{12,}|eyJ[A-Za-z0-9_-]{20,}|-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----)/;
-z.enum([
-  "system",
-  "resource",
-  "ontology",
-  "policy",
-  "role",
-  "trigger",
-  "humanCheckpoint",
-  "externalResource"
-]);
-var OmTopologyRelationshipKindSchema = z.enum(["triggers", "uses", "approval"]);
-var OmTopologyNodeRefSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("system"), id: ModelIdSchema }),
-  z.object({ kind: z.literal("resource"), id: ResourceIdSchema }),
-  z.object({ kind: z.literal("ontology"), id: OntologyIdSchema }),
-  z.object({ kind: z.literal("policy"), id: ModelIdSchema }),
-  z.object({ kind: z.literal("role"), id: ModelIdSchema }),
-  z.object({ kind: z.literal("trigger"), id: ResourceIdSchema }),
-  z.object({ kind: z.literal("humanCheckpoint"), id: ResourceIdSchema }),
-  z.object({ kind: z.literal("externalResource"), id: ResourceIdSchema })
-]);
-var OmTopologyMetadataSchema = z.record(z.string().trim().min(1).max(120), JsonValueSchema).superRefine((metadata, ctx) => {
-  function visit(value, path) {
-    if (typeof value === "string" && SecretLikeMetadataValueSchema.test(value)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path,
-        message: "Topology metadata must not contain secret-like values"
-      });
-      return;
-    }
-    if (Array.isArray(value)) {
-      value.forEach((entry, index) => visit(entry, [...path, index]));
-      return;
-    }
-    if (typeof value !== "object" || value === null) return;
-    Object.entries(value).forEach(([key, entry]) => {
-      if (SecretLikeMetadataKeySchema.test(key)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: [...path, key],
-          message: `Topology metadata key "${key}" looks secret-like`
-        });
-      }
-      visit(entry, [...path, key]);
-    });
-  }
-  visit(metadata, []);
-});
-var OmTopologySystemInterfaceGrantSchema = z.object({
-  consumer: SystemInterfaceRefSchema,
-  provider: SystemInterfaceRefSchema,
-  resourceIds: z.array(ResourceIdSchema).default([]),
-  ontologyIds: z.array(OntologyIdSchema).default([])
-}).strict();
-z.object({
-  systemInterfaceGrant: OmTopologySystemInterfaceGrantSchema
-}).strict();
-var OmTopologyRelationshipSchema = z.object({
-  from: OmTopologyNodeRefSchema,
-  kind: OmTopologyRelationshipKindSchema,
-  to: OmTopologyNodeRefSchema,
-  systemPath: SystemPathSchema.optional(),
-  required: z.boolean().optional(),
-  metadata: OmTopologyMetadataSchema.optional()
-});
-var OmTopologyDomainSchema = z.object({
-  version: z.literal(1).default(1),
-  relationships: z.record(z.string().trim().min(1).max(255), OmTopologyRelationshipSchema).default({})
-}).default({ version: 1, relationships: {} });
-var DEFAULT_ORGANIZATION_MODEL_TOPOLOGY = {
-  version: 1,
-  relationships: {}
-};
-function idFrom(input) {
-  return typeof input === "string" ? input : input.id;
-}
-function parseRef(kind, id) {
-  return OmTopologyNodeRefSchema.parse({ kind, id });
-}
-function isNodeRef(input) {
-  return OmTopologyNodeRefSchema.safeParse(input).success;
-}
-function isResourceEntry(input) {
-  if (typeof input !== "object" || input === null) return false;
-  const candidate = input;
-  return typeof candidate.id === "string" && typeof candidate.systemPath === "string" && typeof candidate.status === "string" && ["workflow", "agent", "integration", "script"].includes(String(candidate.kind));
-}
-var topologyRef = {
-  system: (system) => parseRef("system", idFrom(system)),
-  resource: (resource) => parseRef("resource", idFrom(resource)),
-  ontology: (record) => parseRef("ontology", idFrom(record)),
-  policy: (policy) => parseRef("policy", idFrom(policy)),
-  role: (role) => parseRef("role", idFrom(role)),
-  trigger: (trigger) => parseRef("trigger", idFrom(trigger)),
-  humanCheckpoint: (checkpoint) => parseRef("humanCheckpoint", idFrom(checkpoint)),
-  externalResource: (externalResource) => parseRef("externalResource", idFrom(externalResource))
-};
-var topologyRelationship = {
-  triggers: (from, to, options = {}) => defineTopologyRelationship({
-    ...options,
-    from,
-    kind: "triggers",
-    to
-  }),
-  uses: (from, to, options = {}) => defineTopologyRelationship({
-    ...options,
-    from,
-    kind: "uses",
-    to
-  }),
-  approval: (from, to, options = {}) => defineTopologyRelationship({
-    ...options,
-    from,
-    kind: "approval",
-    to
-  }),
-  usesIntegration: (from, integration, options = {}) => defineTopologyRelationship({
-    required: true,
-    ...options,
-    from,
-    kind: "uses",
-    to: integration
-  }),
-  requestsApproval: (from, checkpoint, options = {}) => defineTopologyRelationship({
-    required: true,
-    ...options,
-    from,
-    kind: "approval",
-    to: topologyRef.humanCheckpoint(checkpoint)
-  }),
-  checkpointRoutesTo: (checkpoint, to, options = {}) => defineTopologyRelationship({
-    required: true,
-    ...options,
-    from: topologyRef.humanCheckpoint(checkpoint),
-    kind: "triggers",
-    to
-  })
-};
-function compileTopologyNodeRef(input) {
-  if (isNodeRef(input)) return input;
-  if (isResourceEntry(input)) return topologyRef.resource(input);
-  throw new Error("Topology node refs must be typed node objects or serializable { kind, id } refs");
-}
-function defineTopologyRelationship(input) {
-  return OmTopologyRelationshipSchema.parse({
-    ...input,
-    from: compileTopologyNodeRef(input.from),
-    to: compileTopologyNodeRef(input.to)
-  });
-}
-function defineTopology(relationships) {
-  const entries = Array.isArray(relationships) ? relationships.map((relationship, index) => [`relationship-${index + 1}`, relationship]) : Object.entries(relationships);
-  return OmTopologyDomainSchema.parse({
-    version: 1,
-    relationships: Object.fromEntries(entries.map(([key, relationship]) => [key, defineTopologyRelationship(relationship)]))
-  });
-}
-var PolicyIdSchema = ModelIdSchema;
-var PolicyApplicabilitySchema = z.object({
-  systemIds: z.array(ModelIdSchema.meta({ ref: "system" })).default([]),
-  actionIds: z.array(ModelIdSchema.meta({ ref: "action" })).default([]),
-  resourceIds: z.array(ModelIdSchema.meta({ ref: "resource" })).default([]),
-  roleIds: z.array(ModelIdSchema.meta({ ref: "role" })).default([])
-});
-var PolicyTriggerSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("event"),
-    eventId: EventIdSchema.meta({ ref: "event" })
-  }),
-  z.object({
-    kind: z.literal("action-invocation"),
-    actionId: ModelIdSchema.meta({ ref: "action" })
-  }),
-  z.object({
-    kind: z.literal("schedule"),
-    cron: z.string().trim().min(1).max(120)
-  }),
-  z.object({
-    kind: z.literal("manual")
-  })
-]);
-var PolicyPredicateSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("always")
-  }),
-  z.object({
-    kind: z.literal("expression"),
-    expression: z.string().trim().min(1).max(2e3)
-  }),
-  z.object({
-    kind: z.literal("threshold"),
-    metric: ModelIdSchema,
-    operator: z.enum(["lt", "lte", "eq", "gte", "gt"]).meta({ label: "Operator" }),
-    value: z.number()
-  })
-]);
-var PolicyEffectSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("require-approval"),
-    roleId: ModelIdSchema.meta({ ref: "role" }).optional()
-  }),
-  z.object({
-    kind: z.literal("invoke-action"),
-    actionId: ModelIdSchema.meta({ ref: "action" })
-  }),
-  z.object({
-    kind: z.literal("notify-role"),
-    roleId: ModelIdSchema.meta({ ref: "role" })
-  }),
-  z.object({
-    kind: z.literal("block")
-  })
-]);
-var PolicySchema = z.object({
-  id: PolicyIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  trigger: PolicyTriggerSchema,
-  predicate: PolicyPredicateSchema.default({ kind: "always" }),
-  actions: z.array(PolicyEffectSchema).min(1),
-  appliesTo: PolicyApplicabilitySchema.default({
-    systemIds: [],
-    actionIds: [],
-    resourceIds: [],
-    roleIds: []
-  }),
-  lifecycle: z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" }).default("active")
-});
-var PoliciesDomainSchema = z.record(z.string(), PolicySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-  message: "Each policy entry id must match its map key"
-}).default({});
-var DEFAULT_ORGANIZATION_MODEL_POLICIES = {};
-function addIssue(ctx, path, message) {
-  ctx.addIssue({
-    code: z.ZodIssueCode.custom,
-    path,
-    message
-  });
-}
-function isLifecycleEnabled(lifecycle, enabled) {
-  if (enabled === false) return false;
-  return lifecycle !== "deprecated" && lifecycle !== "archived";
-}
-function defaultSystemPathFor(id) {
-  return `/${id.replaceAll(".", "/")}`;
-}
-function asRoleHolderArray(heldBy) {
-  return Array.isArray(heldBy) ? heldBy : [heldBy];
-}
-function isKnowledgeKindCompatibleWithTarget(knowledgeKind, targetKind) {
-  if (knowledgeKind === "reference") return true;
-  if (knowledgeKind === "playbook") {
-    return ["system", "resource", "stage", "action", "ontology"].includes(targetKind);
-  }
-  if (knowledgeKind === "strategy") {
-    return ["system", "goal", "offering", "customer-segment", "ontology"].includes(targetKind);
-  }
-  return false;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function refineOrganizationModel(model, ctx) {
-  function collectAllSystems(systems, prefix = "", schemaPath = ["systems"]) {
-    const result = [];
-    for (const [key, system] of Object.entries(systems)) {
-      const path = prefix ? `${prefix}.${key}` : key;
-      const currentSchemaPath = [...schemaPath, key];
-      result.push({ path, schemaPath: currentSchemaPath, system });
-      const childSystems = system.systems ?? system.subsystems;
-      if (childSystems !== void 0) {
-        result.push(
-          ...collectAllSystems(childSystems, path, [
-            ...currentSchemaPath,
-            system.systems !== void 0 ? "systems" : "subsystems"
-          ])
-        );
-      }
-    }
-    return result;
-  }
-  const allSystems = collectAllSystems(model.systems);
-  const systemsById = /* @__PURE__ */ new Map();
-  for (const { path, system } of allSystems) {
-    systemsById.set(path, system);
-    systemsById.set(system.id, system);
-  }
-  const systemIdsByEffectivePath = /* @__PURE__ */ new Map();
-  allSystems.forEach(({ path, schemaPath, system }) => {
-    if (system.parentSystemId !== void 0 && !systemsById.has(system.parentSystemId)) {
-      addIssue(
-        ctx,
-        [...schemaPath, "parentSystemId"],
-        `System "${system.id}" references unknown parent "${system.parentSystemId}"`
-      );
-    }
-    const hasChildren = Object.keys(system.systems ?? system.subsystems ?? {}).length > 0 || allSystems.some(
-      (candidate) => candidate.path.startsWith(`${path}.`) && !candidate.path.slice(path.length + 1).includes(".")
-    );
-    const contributesRoutePath = system.ui?.path !== void 0 || system.path !== void 0 || !hasChildren;
-    if (contributesRoutePath) {
-      const effectivePath = system.ui?.path ?? system.path ?? defaultSystemPathFor(path);
-      const existingSystemId = systemIdsByEffectivePath.get(effectivePath);
-      if (existingSystemId !== void 0) {
-        addIssue(
-          ctx,
-          [...schemaPath, system.ui?.path !== void 0 ? "ui" : "path"],
-          `System "${path}" effective path "${effectivePath}" duplicates system "${existingSystemId}"`
-        );
-      } else {
-        systemIdsByEffectivePath.set(effectivePath, path);
-      }
-    }
-    if (hasChildren && isLifecycleEnabled(system.lifecycle, system.enabled)) {
-      const hasEnabledDescendant = Object.values(system.systems ?? system.subsystems ?? {}).some(
-        (candidate) => isLifecycleEnabled(candidate.lifecycle, candidate.enabled)
-      ) || allSystems.some(
-        (candidate) => candidate.path.startsWith(`${path}.`) && !candidate.path.slice(path.length + 1).includes(".") && isLifecycleEnabled(candidate.system.lifecycle, candidate.system.enabled)
-      );
-      if (!hasEnabledDescendant) {
-        addIssue(ctx, [...schemaPath, "lifecycle"], `System "${path}" is active but has no active descendants`);
-      }
-    }
-  });
-  allSystems.forEach(({ schemaPath, system }) => {
-    const visited = /* @__PURE__ */ new Set();
-    let currentParentId = system.parentSystemId;
-    while (currentParentId !== void 0) {
-      if (currentParentId === system.id || visited.has(currentParentId)) {
-        addIssue(ctx, [...schemaPath, "parentSystemId"], `System "${system.id}" has a parent cycle`);
-        return;
-      }
-      visited.add(currentParentId);
-      currentParentId = systemsById.get(currentParentId)?.parentSystemId;
-    }
-  });
-  function normalizeRoutePath2(path) {
-    return path.length > 1 ? path.replace(/\/+$/, "") : path;
-  }
-  const sidebarNodeIds = /* @__PURE__ */ new Map();
-  const sidebarSurfacePaths = /* @__PURE__ */ new Map();
-  const sidebarSurfaces = [];
-  function collectSidebarNodes(nodes, schemaPath) {
-    Object.entries(nodes).forEach(([nodeId2, node]) => {
-      const nodePath = [...schemaPath, nodeId2];
-      const existingNodePath = sidebarNodeIds.get(nodeId2);
-      if (existingNodePath !== void 0) {
-        addIssue(ctx, nodePath, `Sidebar node id "${nodeId2}" duplicates another sidebar node`);
-      } else {
-        sidebarNodeIds.set(nodeId2, nodePath);
-      }
-      if (node.type === "group") {
-        collectSidebarNodes(node.children, [...nodePath, "children"]);
-        return;
-      }
-      sidebarSurfaces.push({ id: nodeId2, node, path: nodePath });
-      const normalizedPath = normalizeRoutePath2(node.path);
-      const existingSurfaceId = sidebarSurfacePaths.get(normalizedPath);
-      if (existingSurfaceId !== void 0) {
-        addIssue(
-          ctx,
-          [...nodePath, "path"],
-          `Sidebar surface path "${node.path}" duplicates surface "${existingSurfaceId}"`
-        );
-      } else {
-        sidebarSurfacePaths.set(normalizedPath, nodeId2);
-      }
-      node.targets?.systems?.forEach((systemId, systemIndex) => {
-        if (!systemsById.has(systemId)) {
-          addIssue(
-            ctx,
-            [...nodePath, "targets", "systems", systemIndex],
-            `Sidebar surface "${nodeId2}" references unknown system "${systemId}"`
-          );
-        }
-      });
-    });
-  }
-  collectSidebarNodes(model.navigation.sidebar.primary, ["navigation", "sidebar", "primary"]);
-  collectSidebarNodes(model.navigation.sidebar.bottom, ["navigation", "sidebar", "bottom"]);
-  const segmentsById = new Map(Object.entries(model.customers));
-  Object.values(model.offerings).forEach((product) => {
-    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
-      if (!segmentsById.has(segmentId)) {
-        addIssue(
-          ctx,
-          ["offerings", product.id, "targetSegmentIds", segmentIndex],
-          `Product "${product.id}" references unknown customer segment "${segmentId}"`
-        );
-      }
-    });
-    if (product.deliveryFeatureId !== void 0 && !systemsById.has(product.deliveryFeatureId)) {
-      addIssue(
-        ctx,
-        ["offerings", product.id, "deliveryFeatureId"],
-        `Product "${product.id}" references unknown delivery system "${product.deliveryFeatureId}"`
-      );
-    }
-  });
-  Object.values(model.goals).forEach((objective) => {
-    if (objective.periodEnd <= objective.periodStart) {
-      addIssue(
-        ctx,
-        ["goals", objective.id, "periodEnd"],
-        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
-      );
-    }
-  });
-  const goalsById = new Map(Object.entries(model.goals));
-  const knowledgeById = new Map(Object.entries(model.knowledge));
-  const actionsById = new Map(Object.entries(model.actions));
-  const entitiesById = new Map(Object.entries(model.entities));
-  const policiesById = new Map(Object.entries(model.policies));
-  sidebarSurfaces.forEach(({ id, node, path }) => {
-    node.targets?.entities?.forEach((entityId, entityIndex) => {
-      if (!entitiesById.has(entityId)) {
-        addIssue(
-          ctx,
-          [...path, "targets", "entities", entityIndex],
-          `Sidebar surface "${id}" references unknown entity "${entityId}"`
-        );
-      }
-    });
-    node.targets?.actions?.forEach((actionId, actionIndex) => {
-      if (!actionsById.has(actionId)) {
-        addIssue(
-          ctx,
-          [...path, "targets", "actions", actionIndex],
-          `Sidebar surface "${id}" references unknown action "${actionId}"`
-        );
-      }
-    });
-  });
-  Object.values(model.entities).forEach((entity) => {
-    if (systemsById.size > 0 && !systemsById.has(entity.ownedBySystemId)) {
-      addIssue(
-        ctx,
-        ["entities", entity.id, "ownedBySystemId"],
-        `Entity "${entity.id}" references unknown ownedBySystemId "${entity.ownedBySystemId}"`
-      );
-    }
-    entity.links?.forEach((link, linkIndex) => {
-      if (!entitiesById.has(link.toEntity)) {
-        addIssue(
-          ctx,
-          ["entities", entity.id, "links", linkIndex, "toEntity"],
-          `Entity "${entity.id}" links to unknown entity "${link.toEntity}"`
-        );
-      }
-    });
-  });
-  const rolesById = new Map(Object.entries(model.roles));
-  Object.values(model.roles).forEach((role) => {
-    if (role.reportsToId !== void 0 && !rolesById.has(role.reportsToId)) {
-      addIssue(
-        ctx,
-        ["roles", role.id, "reportsToId"],
-        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
-      );
-    }
-  });
-  Object.values(model.roles).forEach((role) => {
-    const visited = /* @__PURE__ */ new Set();
-    let currentReportsToId = role.reportsToId;
-    while (currentReportsToId !== void 0) {
-      if (currentReportsToId === role.id || visited.has(currentReportsToId)) {
-        addIssue(ctx, ["roles", role.id, "reportsToId"], `Role "${role.id}" has a reportsToId cycle`);
-        return;
-      }
-      visited.add(currentReportsToId);
-      currentReportsToId = rolesById.get(currentReportsToId)?.reportsToId;
-    }
-  });
-  Object.values(model.roles).forEach((role) => {
-    role.responsibleFor?.forEach((systemId, systemIndex) => {
-      if (!systemsById.has(systemId)) {
-        addIssue(
-          ctx,
-          ["roles", role.id, "responsibleFor", systemIndex],
-          `Role "${role.id}" references unknown responsibleFor system "${systemId}"`
-        );
-      }
-    });
-  });
-  allSystems.forEach(({ schemaPath, system }) => {
-    if (system.responsibleRoleId !== void 0 && !rolesById.has(system.responsibleRoleId)) {
-      addIssue(
-        ctx,
-        [...schemaPath, "responsibleRoleId"],
-        `System "${system.id}" references unknown responsibleRoleId "${system.responsibleRoleId}"`
-      );
-    }
-    system.governedByKnowledge?.forEach((nodeId2, nodeIndex) => {
-      if (!knowledgeById.has(nodeId2)) {
-        addIssue(
-          ctx,
-          [...schemaPath, "governedByKnowledge", nodeIndex],
-          `System "${system.id}" references unknown knowledge node "${nodeId2}"`
-        );
-      }
-    });
-    system.drivesGoals?.forEach((goalId, goalIndex) => {
-      if (!goalsById.has(goalId)) {
-        addIssue(
-          ctx,
-          [...schemaPath, "drivesGoals", goalIndex],
-          `System "${system.id}" references unknown goal "${goalId}"`
-        );
-      }
-    });
-    system.actions?.forEach((actionRef, actionIndex) => {
-      if (!actionsById.has(actionRef.actionId)) {
-        addIssue(
-          ctx,
-          [...schemaPath, "actions", actionIndex, "actionId"],
-          `System "${system.id}" references unknown action "${actionRef.actionId}"`
-        );
-      }
-    });
-    system.policies?.forEach((policyId, policyIndex) => {
-      if (!policiesById.has(policyId)) {
-        addIssue(
-          ctx,
-          [...schemaPath, "policies", policyIndex],
-          `System "${system.id}" references unknown policy "${policyId}"`
-        );
-      }
-    });
-  });
-  Object.values(model.actions).forEach((action) => {
-    action.affects?.forEach((entityId, entityIndex) => {
-      if (!entitiesById.has(entityId)) {
-        addIssue(
-          ctx,
-          ["actions", action.id, "affects", entityIndex],
-          `Action "${action.id}" affects unknown entity "${entityId}"`
-        );
-      }
-    });
-  });
-  const resourcesById = new Map(Object.entries(model.resources));
-  sidebarSurfaces.forEach(({ id, node, path }) => {
-    node.targets?.resources?.forEach((resourceId, resourceIndex) => {
-      if (!resourcesById.has(resourceId)) {
-        addIssue(
-          ctx,
-          [...path, "targets", "resources", resourceIndex],
-          `Sidebar surface "${id}" references unknown resource "${resourceId}"`
-        );
-      }
-    });
-  });
-  const idx = buildOmCrossRefIndex(model);
-  const { ontologyIndexByKind, ontologyIds } = idx;
-  const ontologyCompilation = compileOrganizationOntology(model);
-  function topologyTargetExists(ref) {
-    if (ref.kind === "system") return systemsById.has(ref.id);
-    if (ref.kind === "resource") return resourcesById.has(ref.id);
-    if (ref.kind === "ontology") return ontologyIds.has(ref.id);
-    if (ref.kind === "policy") return policiesById.has(ref.id);
-    if (ref.kind === "role") return rolesById.has(ref.id);
-    return true;
-  }
-  Object.entries(model.topology.relationships).forEach(([relationshipId, relationship]) => {
-    ["from", "to"].forEach((side) => {
-      const ref = relationship[side];
-      if (topologyTargetExists(ref)) return;
-      addIssue(
-        ctx,
-        ["topology", "relationships", relationshipId, side],
-        `Topology relationship "${relationshipId}" ${side} references unknown ${ref.kind} "${ref.id}"`
-      );
-    });
-  });
-  function validateKnownOntologyReferences(ownerId, value, path, seen = /* @__PURE__ */ new WeakSet()) {
-    if (Array.isArray(value)) {
-      value.forEach((entry, index) => validateKnownOntologyReferences(ownerId, entry, [...path, index], seen));
-      return;
-    }
-    if (!isRecord(value)) return;
-    if (seen.has(value)) return;
-    seen.add(value);
-    Object.entries(value).forEach(([key, entry]) => {
-      const expectedKind = ONTOLOGY_REFERENCE_KEY_KINDS[key];
-      if (expectedKind !== void 0) {
-        if (typeof entry !== "string") {
-          addIssue(ctx, [...path, key], `Ontology record "${ownerId}" ${key} must be an ontology ID string`);
-        } else if (ontologyIndexByKind[expectedKind][entry] === void 0) {
-          addIssue(
-            ctx,
-            [...path, key],
-            `Ontology record "${ownerId}" ${key} references unknown ${expectedKind} ontology ID "${entry}"`
-          );
-        }
-      }
-      validateKnownOntologyReferences(ownerId, entry, [...path, key], seen);
-    });
-  }
-  for (const { id, record } of listResolvedOntologyRecords(ontologyCompilation.ontology)) {
-    validateKnownOntologyReferences(id, record, record.origin.path);
-  }
-  Object.values(model.policies).forEach((policy) => {
-    policy.appliesTo.systemIds.forEach((systemId, systemIndex) => {
-      if (!systemsById.has(systemId)) {
-        addIssue(
-          ctx,
-          ["policies", policy.id, "appliesTo", "systemIds", systemIndex],
-          `Policy "${policy.id}" applies to unknown system "${systemId}"`
-        );
-      }
-    });
-    policy.appliesTo.actionIds.forEach((actionId, actionIndex) => {
-      if (!actionsById.has(actionId)) {
-        addIssue(
-          ctx,
-          ["policies", policy.id, "appliesTo", "actionIds", actionIndex],
-          `Policy "${policy.id}" applies to unknown action "${actionId}"`
-        );
-      }
-    });
-    policy.actions.forEach((action, actionIndex) => {
-      if (action.kind === "invoke-action" && !actionsById.has(action.actionId)) {
-        addIssue(
-          ctx,
-          ["policies", policy.id, "actions", actionIndex, "actionId"],
-          `Policy "${policy.id}" invokes unknown action "${action.actionId}"`
-        );
-      }
-      if ((action.kind === "notify-role" || action.kind === "require-approval") && action.roleId !== void 0 && !rolesById.has(action.roleId)) {
-        addIssue(
-          ctx,
-          ["policies", policy.id, "actions", actionIndex, "roleId"],
-          `Policy "${policy.id}" references unknown role "${action.roleId}"`
-        );
-      }
-    });
-    if (policy.trigger.kind === "action-invocation" && !actionsById.has(policy.trigger.actionId)) {
-      addIssue(
-        ctx,
-        ["policies", policy.id, "trigger", "actionId"],
-        `Policy "${policy.id}" references unknown trigger action "${policy.trigger.actionId}"`
-      );
-    }
-  });
-  Object.entries(model.knowledge).forEach(([nodeId2, node]) => {
-    node.links.forEach((link, linkIndex) => {
-      if (!knowledgeTargetExists(idx, link.target.kind, link.target.id)) {
-        addIssue(
-          ctx,
-          ["knowledge", nodeId2, "links", linkIndex, "target"],
-          `Knowledge node "${node.id}" references unknown ${link.target.kind} target "${link.target.id}"`
-        );
-      }
-      if (!isKnowledgeKindCompatibleWithTarget(node.kind, link.target.kind)) {
-        addIssue(
-          ctx,
-          ["knowledge", nodeId2, "links", linkIndex, "target", "kind"],
-          `Knowledge node "${node.id}" kind "${node.kind}" cannot govern ${link.target.kind} targets`
-        );
-      }
-    });
-  });
-  Object.values(model.resources).forEach((resource) => {
-    if (!systemsById.has(resource.systemPath)) {
-      addIssue(
-        ctx,
-        ["resources", resource.id, "systemPath"],
-        `Resource "${resource.id}" references unknown system path "${resource.systemPath}"`
-      );
-    }
-    if (resource.ownerRoleId !== void 0 && !rolesById.has(resource.ownerRoleId)) {
-      addIssue(
-        ctx,
-        ["resources", resource.id, "ownerRoleId"],
-        `Resource "${resource.id}" references unknown ownerRoleId "${resource.ownerRoleId}"`
-      );
-    }
-    if (resource.kind === "agent" && resource.actsAsRoleId !== void 0 && !rolesById.has(resource.actsAsRoleId)) {
-      addIssue(
-        ctx,
-        ["resources", resource.id, "actsAsRoleId"],
-        `Agent resource "${resource.id}" references unknown actsAsRoleId "${resource.actsAsRoleId}"`
-      );
-    }
-  });
-  allSystems.forEach(({ path: systemPath2, schemaPath, system }) => {
-    system.apiInterface?.resourceIds?.forEach((resourceId, resourceIndex) => {
-      const resource = resourcesById.get(resourceId);
-      if (resource === void 0) {
-        addIssue(
-          ctx,
-          [...schemaPath, "apiInterface", "resourceIds", resourceIndex],
-          `System Interface "${systemPath2}/api" scopes unknown resource "${resourceId}"`
-        );
-        return;
-      }
-      if (resource.systemPath !== systemPath2) {
-        addIssue(
-          ctx,
-          [...schemaPath, "apiInterface", "resourceIds", resourceIndex],
-          `System Interface "${systemPath2}/api" scopes resource "${resourceId}" from system "${resource.systemPath}"`
-        );
-      }
-    });
-  });
-  function validateResourceOntologyBinding(resourceId, bindingKey, expectedKind, ids) {
-    const ontologyIds2 = ids === void 0 ? [] : Array.isArray(ids) ? ids : [ids];
-    ontologyIds2.forEach((ontologyId, ontologyIndex) => {
-      if (ontologyIndexByKind[expectedKind][ontologyId] === void 0) {
-        addIssue(
-          ctx,
-          ["resources", resourceId, "ontology", bindingKey, ...Array.isArray(ids) ? [ontologyIndex] : []],
-          `Resource "${resourceId}" ontology binding "${bindingKey}" references unknown ${expectedKind} ontology ID "${ontologyId}"`
-        );
-      }
-    });
-  }
-  Object.values(model.resources).forEach((resource) => {
-    const binding = resource.ontology;
-    if (binding === void 0) return;
-    validateResourceOntologyBinding(resource.id, "actions", "action", binding.actions);
-    validateResourceOntologyBinding(resource.id, "primaryAction", "action", binding.primaryAction);
-    validateResourceOntologyBinding(resource.id, "reads", "object", binding.reads);
-    validateResourceOntologyBinding(resource.id, "writes", "object", binding.writes);
-    validateResourceOntologyBinding(resource.id, "usesCatalogs", "catalog", binding.usesCatalogs);
-    validateResourceOntologyBinding(resource.id, "emits", "event", binding.emits);
-    if (binding.contract !== void 0) {
-      const contractEntries = [
-        ["input", binding.contract.input],
-        ["output", binding.contract.output]
-      ];
-      for (const [side, ref] of contractEntries) {
-        if (ref === void 0) continue;
-        const result = ContractRefSchema.safeParse(ref);
-        if (!result.success) {
-          addIssue(
-            ctx,
-            ["resources", resource.id, "ontology", "contract", side],
-            `Resource "${resource.id}" contract.${side} "${ref}" is not a valid ContractRef (expected "package/subpath#ExportName")`
-          );
-        }
-      }
-    }
-  });
-  Object.values(model.roles).forEach((role) => {
-    if (role.heldBy === void 0) return;
-    asRoleHolderArray(role.heldBy).forEach((holder, holderIndex) => {
-      if (holder.kind !== "agent") return;
-      const resource = resourcesById.get(holder.agentId);
-      if (resource === void 0) {
-        addIssue(
-          ctx,
-          ["roles", role.id, "heldBy", Array.isArray(role.heldBy) ? holderIndex : "agentId"],
-          `Role "${role.id}" references unknown agent holder resource "${holder.agentId}"`
-        );
-        return;
-      }
-      if (resource.kind !== "agent") {
-        addIssue(
-          ctx,
-          ["roles", role.id, "heldBy", Array.isArray(role.heldBy) ? holderIndex : "agentId"],
-          `Role "${role.id}" agent holder "${holder.agentId}" must reference an agent resource`
-        );
-      }
-    });
-  });
-  Object.entries(model.knowledge).forEach(([nodeId2, node]) => {
-    node.ownerIds.forEach((roleId, ownerIndex) => {
-      if (!rolesById.has(roleId)) {
-        addIssue(
-          ctx,
-          ["knowledge", nodeId2, "ownerIds", ownerIndex],
-          `Knowledge node "${node.id}" references unknown owner role "${roleId}"`
-        );
-      }
-    });
-  });
-  for (const diagnostic of ontologyCompilation.diagnostics) {
-    addIssue(ctx, diagnostic.path, diagnostic.message);
-  }
-}
-
-// ../core/src/organization-model/schema.ts
-z.enum([
-  "branding",
-  "identity",
-  "customers",
-  "offerings",
-  "roles",
-  "goals",
-  "systems",
-  "ontology",
-  "resources",
-  "topology",
-  "actions",
-  "entities",
-  "policies",
-  "knowledge"
-]);
-var OrganizationModelDomainMetadataSchema = z.object({
-  version: z.literal(1).default(1),
-  lastModified: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "lastModified must be an ISO date string (YYYY-MM-DD)")
-});
-var DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA = {
-  branding: { version: 1, lastModified: "2026-05-10" },
-  identity: { version: 1, lastModified: "2026-05-10" },
-  customers: { version: 1, lastModified: "2026-05-10" },
-  offerings: { version: 1, lastModified: "2026-05-10" },
-  roles: { version: 1, lastModified: "2026-05-10" },
-  goals: { version: 1, lastModified: "2026-05-10" },
-  systems: { version: 1, lastModified: "2026-05-10" },
-  ontology: { version: 1, lastModified: "2026-05-14" },
-  resources: { version: 1, lastModified: "2026-05-10" },
-  topology: { version: 1, lastModified: "2026-05-14" },
-  actions: { version: 1, lastModified: "2026-05-10" },
-  entities: { version: 1, lastModified: "2026-05-10" },
-  policies: { version: 1, lastModified: "2026-05-10" },
-  knowledge: { version: 1, lastModified: "2026-05-10" }
-};
-var OrganizationModelDomainMetadataByDomainSchema = z.object({
-  branding: OrganizationModelDomainMetadataSchema,
-  identity: OrganizationModelDomainMetadataSchema,
-  customers: OrganizationModelDomainMetadataSchema,
-  offerings: OrganizationModelDomainMetadataSchema,
-  roles: OrganizationModelDomainMetadataSchema,
-  goals: OrganizationModelDomainMetadataSchema,
-  systems: OrganizationModelDomainMetadataSchema,
-  ontology: OrganizationModelDomainMetadataSchema,
-  resources: OrganizationModelDomainMetadataSchema,
-  topology: OrganizationModelDomainMetadataSchema,
-  actions: OrganizationModelDomainMetadataSchema,
-  entities: OrganizationModelDomainMetadataSchema,
-  policies: OrganizationModelDomainMetadataSchema,
-  knowledge: OrganizationModelDomainMetadataSchema
-}).partial().default(DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA).transform((metadata) => ({ ...DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA, ...metadata }));
-var OrganizationModelSchemaBase = z.object({
-  version: z.literal(1).default(1),
-  domainMetadata: OrganizationModelDomainMetadataByDomainSchema,
-  branding: OrganizationModelBrandingSchema.default(DEFAULT_ORGANIZATION_MODEL_BRANDING),
-  navigation: OrganizationModelNavigationSchema,
-  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),
-  systems: SystemsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_SYSTEMS),
-  ontology: OntologyScopeSchema.default(DEFAULT_ONTOLOGY_SCOPE),
-  resources: ResourcesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_RESOURCES),
-  topology: OmTopologyDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_TOPOLOGY),
-  actions: ActionsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ACTIONS),
-  entities: EntitiesDomainSchema.default({}),
-  policies: PoliciesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_POLICIES),
-  // D3: flat Record<id, OrgKnowledgeNode> — no wrapper object
-  knowledge: KnowledgeDomainSchema.default({})
-});
-var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine(refineOrganizationModel);
-
-// ../core/src/organization-model/contracts.ts
-var PROJECTS_VIEW_ACTION_ID = "delivery.projects.view";
-
-// ../core/src/organization-model/defaults.ts
-var DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE = {};
-var DEFAULT_ORGANIZATION_MODEL_ENTITIES = {};
-var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
-  sidebar: {
-    primary: {},
-    bottom: {}
-  },
-  topbar: {}
-};
-var DEFAULT_ORGANIZATION_MODEL = {
-  version: 1,
-  domainMetadata: DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA,
-  branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-  navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION,
-  identity: DEFAULT_ORGANIZATION_MODEL_IDENTITY,
-  customers: DEFAULT_ORGANIZATION_MODEL_CUSTOMERS,
-  offerings: DEFAULT_ORGANIZATION_MODEL_OFFERINGS,
-  roles: DEFAULT_ORGANIZATION_MODEL_ROLES,
-  goals: DEFAULT_ORGANIZATION_MODEL_GOALS,
-  // Generic empty systems map. Elevasis-specific systems (platform, sales, sales.crm,
-  // sales.lead-gen, monitoring, settings, admin, etc.) have been relocated to
-  // `@repo/elevasis-core/src/organization-model/systems.ts` via `canonicalOrganizationModel`.
-  // Tenant OM configs supply their own systems via `resolveOrganizationModel`.
-  systems: {},
-  ontology: DEFAULT_ONTOLOGY_SCOPE,
-  resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
-  topology: DEFAULT_ORGANIZATION_MODEL_TOPOLOGY,
-  // Generic empty actions map. Elevasis-specific action entries have been relocated to
-  // `@repo/elevasis-core/src/organization-model/actions.ts`.
-  actions: {},
-  entities: DEFAULT_ORGANIZATION_MODEL_ENTITIES,
-  policies: DEFAULT_ORGANIZATION_MODEL_POLICIES,
-  knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE
-};
-
-// ../core/src/organization-model/resolve.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function collectNestedSystemPaths(systems, prefix = "") {
-  const paths = /* @__PURE__ */ new Set();
-  for (const [key, value] of Object.entries(systems)) {
-    if (!isPlainObject(value)) continue;
-    const path = prefix ? `${prefix}.${key}` : key;
-    for (const childKey of ["systems", "subsystems"]) {
-      const childSystems = value[childKey];
-      if (!isPlainObject(childSystems)) continue;
-      for (const childPath of collectNestedSystemPaths(childSystems, path)) {
-        paths.add(childPath);
-      }
-    }
-    if (prefix !== "") {
-      paths.add(path);
-    }
-  }
-  return paths;
-}
-function pruneFlatSystemDescendantCollisions(base, override) {
-  const result = { ...base };
-  for (const nestedPath of collectNestedSystemPaths(override)) {
-    delete result[nestedPath];
-  }
-  return result;
-}
-function deepMerge(base, override) {
-  if (override === void 0) {
-    return base;
-  }
-  if (Array.isArray(base)) {
-    return override ?? base;
-  }
-  if (!isPlainObject(base) || !isPlainObject(override)) {
-    return override ?? base;
-  }
-  const result = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (value === void 0) continue;
-    const existing = result[key];
-    if (key === "systems" && isPlainObject(existing) && isPlainObject(value)) {
-      result[key] = deepMerge(pruneFlatSystemDescendantCollisions(existing, value), value);
-      continue;
-    }
-    result[key] = isPlainObject(existing) && isPlainObject(value) ? deepMerge(existing, value) : value;
-  }
-  return result;
-}
-function resolveOrganizationModel(override, organizationIdOrOptions, options) {
-  const resolvedOptions = typeof organizationIdOrOptions === "object" ? organizationIdOrOptions : options;
-  const mergeDefaults = resolvedOptions?.mergeDefaults ?? true;
-  const merged = mergeDefaults ? deepMerge(DEFAULT_ORGANIZATION_MODEL, override) : override ?? {};
-  return OrganizationModelSchema.parse(merged);
-}
-
-// ../core/src/organization-model/surface-projection.ts
-function collectSystemsById(model) {
-  const systemsById = /* @__PURE__ */ new Map();
-  for (const { path, system } of listAllSystems(model)) {
-    systemsById.set(path, system);
-    systemsById.set(system.id, system);
-  }
-  return systemsById;
-}
-function getSystemWithAncestors(systemsById, systemId) {
-  const systems = [];
-  let current = systemsById.get(systemId);
-  while (current !== void 0) {
-    systems.unshift(current);
-    current = current.parentSystemId ? systemsById.get(current.parentSystemId) : void 0;
-  }
-  return systems;
-}
-function hasInheritedFlag(systemsById, systemIds, flag) {
-  return systemIds.some(
-    (systemId) => getSystemWithAncestors(systemsById, systemId).some((system) => system[flag] === true)
-  );
-}
-function isLifecycleEnabled2(system) {
-  if (system.enabled === false) return false;
-  return system.lifecycle !== "deprecated" && system.lifecycle !== "archived";
-}
-function isLifecycleDevOnly(system) {
-  return system.devOnly === true || system.lifecycle === "beta";
-}
-function isSystemEnabled(systemsById, systemId) {
-  const systemLineage = getSystemWithAncestors(systemsById, systemId);
-  return systemLineage.length > 0 && systemLineage.every(isLifecycleEnabled2);
-}
-function unique(values) {
-  return [...new Set(values)];
-}
-function collectSidebarSurfaces(nodes, schemaPath, surfaces = []) {
-  getSortedSidebarEntries(nodes).forEach(([id, node]) => {
-    const nodePath = [...schemaPath, id];
-    if (node.type === "group") {
-      collectSidebarSurfaces(node.children, [...nodePath, "children"], surfaces);
-      return;
-    }
-    surfaces.push({ id, surface: node, path: nodePath });
-  });
-  return surfaces;
-}
-function getSidebarSurfaces(model) {
-  return [
-    ...collectSidebarSurfaces(model.navigation.sidebar.primary, ["navigation", "sidebar", "primary"]),
-    ...collectSidebarSurfaces(model.navigation.sidebar.bottom, ["navigation", "sidebar", "bottom"])
-  ];
-}
-function projectOrganizationSurfaces(model) {
-  const systemsById = collectSystemsById(model);
-  return getSidebarSurfaces(model).map(({ id, surface }) => {
-    const targets = surface.targets ?? {};
-    const systemIds = unique((targets.systems ?? []).filter((systemId) => systemsById.has(systemId)));
-    const enabled = systemIds.every((candidate) => isSystemEnabled(systemsById, candidate));
-    const devOnly = surface.devOnly === true || hasInheritedFlag(systemsById, systemIds, "devOnly") || systemIds.some((candidate) => getSystemWithAncestors(systemsById, candidate).some(isLifecycleDevOnly));
-    const requiresAdmin = hasInheritedFlag(systemsById, systemIds, "requiresAdmin");
-    return {
-      id,
-      label: surface.label,
-      path: surface.path,
-      surfaceType: surface.surfaceType,
-      ...surface.description !== void 0 ? { description: surface.description } : {},
-      ...surface.icon !== void 0 ? { icon: surface.icon } : {},
-      ...surface.order !== void 0 ? { order: surface.order } : {},
-      systemIds,
-      entityIds: [...targets.entities ?? []],
-      resourceIds: [...targets.resources ?? []],
-      actionIds: [...targets.actions ?? []],
-      enabled,
-      ...devOnly ? { devOnly } : {},
-      ...surface.requiresAdmin === true || requiresAdmin ? { requiresAdmin: true } : {}
-    };
-  });
-}
-var OrganizationGraphNodeKindSchema = z.enum([
-  "organization",
-  "system",
-  "role",
-  "action",
-  "entity",
-  "event",
-  "policy",
-  "stage",
-  "resource",
-  "knowledge",
-  "customer-segment",
-  "offering",
-  "goal",
-  "surface",
-  "navigation-group",
-  // Ontology records are projected from compiled System.ontology scopes.
-  "ontology"
-]);
-var OrganizationGraphEdgeKindSchema = z.enum([
-  "contains",
-  "references",
-  "maps_to",
-  "uses",
-  "governs",
-  "links",
-  "affects",
-  "emits",
-  "originates_from",
-  "triggers",
-  "approval",
-  "applies_to",
-  "effects",
-  "actions",
-  "reads",
-  "writes",
-  "uses_catalog"
-]);
-var OrganizationGraphNodeSchema = z.object({
-  id: z.string().trim().min(1).max(400),
-  kind: OrganizationGraphNodeKindSchema,
-  label: LabelSchema,
-  sourceId: z.string().trim().min(1).max(400).optional(),
-  description: DescriptionSchema.optional(),
-  icon: IconNameSchema.optional(),
-  enabled: z.boolean().optional(),
-  ontologyKind: z.string().trim().min(1).max(80).optional(),
-  resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint", "script"]).optional()
-});
-var OrganizationGraphEdgeSchema = z.object({
-  id: z.string().trim().min(1).max(900),
-  kind: OrganizationGraphEdgeKindSchema,
-  sourceId: z.string().trim().min(1).max(400),
-  targetId: z.string().trim().min(1).max(400),
-  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 collectSidebarGraphNodes(nodes, groups, surfaces, parentGroupId) {
-  Object.entries(nodes).sort(([leftId, left], [rightId, right]) => {
-    const orderDelta = (left.order ?? Number.MAX_SAFE_INTEGER) - (right.order ?? Number.MAX_SAFE_INTEGER);
-    return orderDelta === 0 ? leftId.localeCompare(rightId) : orderDelta;
-  }).forEach(([id, node]) => {
-    if (node.type === "group") {
-      groups.push({ id, node, ...parentGroupId !== void 0 ? { parentGroupId } : {} });
-      collectSidebarGraphNodes(node.children, groups, surfaces, id);
-      return;
-    }
-    surfaces.push({ id, node, ...parentGroupId !== void 0 ? { parentGroupId } : {} });
-  });
-}
-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 normalizeOrganizationModelResourceType(resourceType) {
-  return resourceType;
-}
-function collectCommandViewResources(commandViewData) {
-  return [
-    ...commandViewData.workflows,
-    ...commandViewData.agents,
-    ...commandViewData.triggers,
-    ...commandViewData.integrations,
-    ...commandViewData.externalResources,
-    ...commandViewData.humanCheckpoints
-  ];
-}
-function invocationSignature(invocation) {
-  switch (invocation.kind) {
-    case "slash-command":
-      return `${invocation.kind}:${invocation.command}`;
-    case "mcp-tool":
-      return `${invocation.kind}:${invocation.server}:${invocation.name}`;
-    case "api-endpoint":
-      return `${invocation.kind}:${invocation.method}:${invocation.path}`;
-    case "script-execution":
-      return `${invocation.kind}:${invocation.resourceId}`;
-  }
-}
-function invocationLabel(invocation) {
-  switch (invocation.kind) {
-    case "slash-command":
-      return invocation.command;
-    case "mcp-tool":
-      return `${invocation.server}.${invocation.name}`;
-    case "api-endpoint":
-      return `${invocation.method} ${invocation.path}`;
-    case "script-execution":
-      return `script ${invocation.resourceId}`;
-  }
-}
-function eventNodeId(eventId) {
-  return nodeId("event", eventId);
-}
-function ontologyLabel(id, label) {
-  return label ?? parseOntologyId(id).localId;
-}
-function pushOntologyBindingEdges(edges, edgeIds, resourceNodeId, kind, ids) {
-  ids?.forEach((ontologyId) => {
-    const targetId = ontologyGraphNodeId(ontologyId);
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId(kind, resourceNodeId, targetId),
-      kind,
-      sourceId: resourceNodeId,
-      targetId
-    });
-  });
-}
-function buildResourceEventDescriptor(resourceId, emission) {
-  return {
-    ...emission,
-    id: `${resourceId}:${emission.eventKey}`,
-    ownerId: resourceId,
-    ownerKind: "resource"
-  };
-}
-function buildEntityEventDescriptor(entity, eventKey, label) {
-  return {
-    id: `${entity.id}:${eventKey}`,
-    ownerId: entity.id,
-    ownerKind: "entity",
-    eventKey,
-    label
-  };
-}
-function pushEventProjection(nodes, nodeIds, edges, edgeIds, eventNodeIdsByEventId, event, sourceNodeId, edgeKind) {
-  const id = eventNodeId(event.id);
-  eventNodeIdsByEventId.set(event.id, id);
-  pushUniqueNode(nodes, nodeIds, {
-    id,
-    kind: "event",
-    label: event.label,
-    sourceId: event.id
-  });
-  const sourceId = edgeKind === "originates_from" ? id : sourceNodeId;
-  const targetId = edgeKind === "originates_from" ? sourceNodeId : id;
-  pushUniqueEdge(edges, edgeIds, {
-    id: edgeId(edgeKind, sourceId, targetId),
-    kind: edgeKind,
-    sourceId,
-    targetId
-  });
-}
-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 organizationModelResourceIds = new Set(Object.keys(organizationModel.resources));
-  const actionIdsByInvocation = /* @__PURE__ */ new Map();
-  const projectedEventNodeIdsByEventId = /* @__PURE__ */ new Map();
-  const ontologyCompilation = compileOrganizationOntology(organizationModel);
-  const organizationNode = {
-    id: nodeId("organization"),
-    kind: "organization",
-    label: "Organization Model"
-  };
-  pushUniqueNode(nodes, nodeIds, organizationNode);
-  const systemsWithPaths = listAllSystems(organizationModel);
-  const systemPathByRef = /* @__PURE__ */ new Map();
-  for (const { path, system } of systemsWithPaths) {
-    systemPathByRef.set(path, path);
-    systemPathByRef.set(system.id, path);
-  }
-  const validSystemRefs = new Set(systemPathByRef.keys());
-  const systemNodeId = (systemRef) => nodeId("system", systemPathByRef.get(systemRef) ?? systemRef);
-  function topologyNodeId(ref) {
-    if (ref.kind === "system") return systemNodeId(ref.id);
-    if (ref.kind === "resource") return nodeId("resource", ref.id);
-    if (ref.kind === "ontology") return ontologyGraphNodeId(ref.id);
-    if (ref.kind === "policy") return nodeId("policy", ref.id);
-    if (ref.kind === "role") return nodeId("role", ref.id);
-    return nodeId("resource", ref.id);
-  }
-  function ensureTopologyNode(ref) {
-    const id = topologyNodeId(ref);
-    if (nodeIds.has(id)) return id;
-    if (ref.kind === "resource") {
-      ensureResourceNode(nodes, nodeIds, resourceNodesById, ref.id);
-      return id;
-    }
-    if (ref.kind === "trigger" || ref.kind === "humanCheckpoint" || ref.kind === "externalResource") {
-      pushUniqueNode(nodes, nodeIds, {
-        id,
-        kind: "resource",
-        label: ref.id,
-        sourceId: ref.id,
-        resourceType: ref.kind === "trigger" ? "trigger" : ref.kind === "humanCheckpoint" ? "human_checkpoint" : "external"
-      });
-    }
-    return id;
-  }
-  for (const { path, system } of systemsWithPaths.sort((a, b) => a.path.localeCompare(b.path))) {
-    const id = nodeId("system", path);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "system",
-      label: system.label ?? system.title ?? system.id,
-      sourceId: path,
-      description: system.description,
-      icon: system.ui?.icon ?? system.icon,
-      enabled: system.enabled
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-    const parentSystemId = path.includes(".") ? path.slice(0, path.lastIndexOf(".")) : void 0;
-    if (parentSystemId !== void 0) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("contains", nodeId("system", parentSystemId), id),
-        kind: "contains",
-        sourceId: nodeId("system", parentSystemId),
-        targetId: id
-      });
-    }
-  }
-  for (const { id: ontologyId, kind, record } of listResolvedOntologyRecords(ontologyCompilation.ontology).sort(
-    (a, b) => a.id.localeCompare(b.id)
-  )) {
-    const id = ontologyGraphNodeId(ontologyId);
-    const parsedId = parseOntologyId(ontologyId);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "ontology",
-      label: ontologyLabel(ontologyId, record.label),
-      sourceId: ontologyId,
-      description: record.description,
-      ontologyKind: kind
-    });
-    const ownerSystemId = record.ownerSystemId ?? (parsedId.isGlobal ? void 0 : parsedId.scope);
-    if (ownerSystemId !== void 0 && validSystemRefs.has(ownerSystemId)) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("contains", systemNodeId(ownerSystemId), id, `ontology-${kind}`),
-        kind: "contains",
-        sourceId: systemNodeId(ownerSystemId),
-        targetId: id
-      });
-    } else {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("contains", organizationNode.id, id, `ontology-${kind}`),
-        kind: "contains",
-        sourceId: organizationNode.id,
-        targetId: id
-      });
-    }
-    if (kind === "link") {
-      const link = record;
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("links", ontologyGraphNodeId(link.from), ontologyGraphNodeId(link.to), ontologyId),
-        kind: "links",
-        sourceId: ontologyGraphNodeId(link.from),
-        targetId: ontologyGraphNodeId(link.to),
-        label: link.label ?? parsedId.localId
-      });
-    }
-    if (kind === "action") {
-      const action = record;
-      for (const targetOntologyId of action.actsOn ?? []) {
-        pushUniqueEdge(edges, edgeIds, {
-          id: edgeId("affects", id, ontologyGraphNodeId(targetOntologyId), ontologyId),
-          kind: "affects",
-          sourceId: id,
-          targetId: ontologyGraphNodeId(targetOntologyId)
-        });
-      }
-    }
-    if (kind === "catalog") {
-      const catalog = record;
-      if (catalog.appliesTo === void 0) continue;
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("applies_to", id, ontologyGraphNodeId(catalog.appliesTo), ontologyId),
-        kind: "applies_to",
-        sourceId: id,
-        targetId: ontologyGraphNodeId(catalog.appliesTo)
-      });
-    }
-    if (kind === "group") {
-      const group = record;
-      for (const memberOntologyId of group.members ?? []) {
-        pushUniqueEdge(edges, edgeIds, {
-          id: edgeId("contains", id, ontologyGraphNodeId(memberOntologyId), ontologyId),
-          kind: "contains",
-          sourceId: id,
-          targetId: ontologyGraphNodeId(memberOntologyId)
-        });
-      }
-    }
-  }
-  for (const role of Object.values(organizationModel.roles).sort((a, b) => a.id.localeCompare(b.id))) {
-    const id = nodeId("role", role.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "role",
-      label: role.title,
-      sourceId: role.id,
-      description: role.responsibilities.length > 0 ? role.responsibilities.join("; ") : void 0
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-    if (role.reportsToId !== void 0) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("references", id, nodeId("role", role.reportsToId), "reports-to"),
-        kind: "references",
-        sourceId: id,
-        targetId: nodeId("role", role.reportsToId),
-        label: "reports to"
-      });
-    }
-    for (const systemId of role.responsibleFor ?? []) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("governs", id, systemNodeId(systemId), "responsible-for"),
-        kind: "governs",
-        sourceId: id,
-        targetId: systemNodeId(systemId),
-        label: "responsible for"
-      });
-    }
-  }
-  for (const node of Object.values(organizationModel.knowledge).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) {
-      const targetId = link.target.kind === "system" ? systemNodeId(link.target.id) : link.target.kind === "ontology" ? ontologyGraphNodeId(link.target.id) : link.nodeId;
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("governs", id, targetId),
-        kind: "governs",
-        sourceId: id,
-        targetId
-      });
-    }
-  }
-  const allStages = [
-    ...getAllProspectingStages(organizationModel, "company"),
-    ...getAllProspectingStages(organizationModel, "contact")
-  ].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
-  for (const stage of allStages) {
-    const id = nodeId("stage", stage.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "stage",
-      label: stage.label,
-      sourceId: stage.id,
-      ...stage.description ? { description: stage.description } : {},
-      ...stage.icon ? { icon: stage.icon } : {}
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-  }
-  for (const action of Object.values(organizationModel.actions).sort((a, b) => a.id.localeCompare(b.id))) {
-    const id = nodeId("action", action.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "action",
-      label: action.label,
-      sourceId: action.id,
-      description: action.description
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-    if (action.resourceId !== void 0) {
-      const resourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, action.resourceId);
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("maps_to", id, resourceNode.id),
-        kind: "maps_to",
-        sourceId: id,
-        targetId: resourceNode.id
-      });
-    }
-    for (const entityId of action.affects ?? []) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("affects", id, nodeId("entity", entityId)),
-        kind: "affects",
-        sourceId: id,
-        targetId: nodeId("entity", entityId)
-      });
-    }
-    for (const invocation of action.invocations) {
-      const key = invocationSignature(invocation);
-      const existing = actionIdsByInvocation.get(key);
-      if (existing) {
-        existing.push(id);
-      } else {
-        actionIdsByInvocation.set(key, [id]);
-      }
-    }
-  }
-  for (const entity of Object.values(organizationModel.entities).sort(
-    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
-  )) {
-    const id = nodeId("entity", entity.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "entity",
-      label: entity.label,
-      sourceId: entity.id,
-      description: entity.description
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", systemNodeId(entity.ownedBySystemId), id, "system-entity"),
-      kind: "contains",
-      sourceId: systemNodeId(entity.ownedBySystemId),
-      targetId: id
-    });
-    for (const [linkIndex, link] of (entity.links ?? []).entries()) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("links", id, nodeId("entity", link.toEntity), `${link.kind}-${linkIndex}`),
-        kind: "links",
-        sourceId: id,
-        targetId: nodeId("entity", link.toEntity),
-        label: link.label ?? link.kind
-      });
-    }
-    if (entity.stateCatalogId !== void 0) {
-      const stateEvents = [];
-      if (entity.stateCatalogId === "crm.pipeline") {
-        for (const { pipeline } of getAllPipelines(organizationModel).filter(({ pipeline: p }) => p.entityId === entity.id).sort((a, b) => a.pipeline.id.localeCompare(b.pipeline.id))) {
-          for (const stage of [...pipeline.stages].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))) {
-            stateEvents.push(buildEntityEventDescriptor(entity, stage.id, stage.label));
-          }
-        }
-      }
-      if (entity.stateCatalogId === "delivery.task") {
-        for (const status of getAllProjectStatuses(organizationModel, "task").sort(
-          (a, b) => a.order - b.order || a.id.localeCompare(b.id)
-        )) {
-          stateEvents.push(buildEntityEventDescriptor(entity, status.id, status.label));
-        }
-      }
-      if (entity.stateCatalogId === "lead-gen.company" || entity.stateCatalogId === "lead-gen.contact") {
-        const leadGenEntity = entity.stateCatalogId === "lead-gen.company" ? "company" : "contact";
-        for (const stage of Object.values(getLeadGenStageCatalog(organizationModel)).sort(
-          (a, b) => a.order - b.order || a.key.localeCompare(b.key)
-        )) {
-          if (stage.entity !== leadGenEntity && !(stage.additionalEntities ?? []).includes(leadGenEntity)) continue;
-          stateEvents.push(buildEntityEventDescriptor(entity, stage.key, stage.label));
-        }
-      }
-      for (const event of stateEvents) {
-        pushEventProjection(
-          nodes,
-          nodeIds,
-          edges,
-          edgeIds,
-          projectedEventNodeIdsByEventId,
-          event,
-          id,
-          "originates_from"
-        );
-      }
-    }
-  }
-  for (const { path, system } of systemsWithPaths.sort((a, b) => a.path.localeCompare(b.path))) {
-    for (const actionRef of system.actions ?? []) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("uses", nodeId("system", path), nodeId("action", actionRef.actionId), actionRef.intent),
-        kind: "uses",
-        sourceId: nodeId("system", path),
-        targetId: nodeId("action", actionRef.actionId),
-        label: actionRef.intent
-      });
-    }
-  }
-  const validSystemPaths = /* @__PURE__ */ new Set([...validSystemRefs]);
-  for (const resource of Object.values(organizationModel.resources).sort((a, b) => a.id.localeCompare(b.id))) {
-    const resourceNode = upsertResourceNode(nodes, nodeIds, resourceNodesById, {
-      id: nodeId("resource", resource.id),
-      kind: "resource",
-      label: resource.id,
-      sourceId: resource.id,
-      resourceType: normalizeOrganizationModelResourceType(resource.kind)
-    });
-    if (validSystemPaths.has(resource.systemPath)) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("contains", systemNodeId(resource.systemPath), resourceNode.id, "system-resource"),
-        kind: "contains",
-        sourceId: systemNodeId(resource.systemPath),
-        targetId: resourceNode.id
-      });
-    }
-    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "actions", resource.ontology?.actions);
-    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "reads", resource.ontology?.reads);
-    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "writes", resource.ontology?.writes);
-    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "uses_catalog", resource.ontology?.usesCatalogs);
-    pushOntologyBindingEdges(edges, edgeIds, resourceNode.id, "emits", resource.ontology?.emits);
-    if (resource.kind === "workflow" || resource.kind === "agent") {
-      for (const emission of resource.emits ?? []) {
-        pushEventProjection(
-          nodes,
-          nodeIds,
-          edges,
-          edgeIds,
-          projectedEventNodeIdsByEventId,
-          buildResourceEventDescriptor(resource.id, emission),
-          resourceNode.id,
-          "emits"
-        );
-      }
-    }
-    if (resource.kind === "agent") {
-      for (const [index, invocation] of resource.invocations.entries()) {
-        const label = invocationLabel(invocation);
-        if (invocation.kind === "script-execution") {
-          const targetNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, invocation.resourceId);
-          pushUniqueEdge(edges, edgeIds, {
-            id: edgeId("uses", resourceNode.id, targetNode.id, `agent-invocation-${index}`),
-            kind: "uses",
-            sourceId: resourceNode.id,
-            targetId: targetNode.id,
-            label
-          });
-          continue;
-        }
-        for (const actionNodeId of actionIdsByInvocation.get(invocationSignature(invocation)) ?? []) {
-          pushUniqueEdge(edges, edgeIds, {
-            id: edgeId("references", resourceNode.id, actionNodeId, `agent-invocation-${index}`),
-            kind: "references",
-            sourceId: resourceNode.id,
-            targetId: actionNodeId,
-            label
-          });
-        }
-      }
-    }
-  }
-  for (const policy of Object.values(organizationModel.policies).sort(
-    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
-  )) {
-    const id = nodeId("policy", policy.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "policy",
-      label: policy.label,
-      sourceId: policy.id,
-      description: policy.description
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-    for (const systemId of policy.appliesTo.systemIds) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("applies_to", id, systemNodeId(systemId), "system"),
-        kind: "applies_to",
-        sourceId: id,
-        targetId: systemNodeId(systemId)
-      });
-    }
-    for (const actionId of policy.appliesTo.actionIds) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("applies_to", id, nodeId("action", actionId), "action"),
-        kind: "applies_to",
-        sourceId: id,
-        targetId: nodeId("action", actionId)
-      });
-    }
-    for (const resourceId of policy.appliesTo.resourceIds) {
-      const resourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, resourceId);
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("applies_to", id, resourceNode.id, "resource"),
-        kind: "applies_to",
-        sourceId: id,
-        targetId: resourceNode.id
-      });
-    }
-    for (const roleId of policy.appliesTo.roleIds) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("applies_to", id, nodeId("role", roleId), "role"),
-        kind: "applies_to",
-        sourceId: id,
-        targetId: nodeId("role", roleId)
-      });
-    }
-    if (policy.trigger.kind === "event") {
-      const eventNode = projectedEventNodeIdsByEventId.get(policy.trigger.eventId);
-      if (eventNode !== void 0) {
-        pushUniqueEdge(edges, edgeIds, {
-          id: edgeId("triggers", eventNode, id),
-          kind: "triggers",
-          sourceId: eventNode,
-          targetId: id
-        });
-      }
-    } else if (policy.trigger.kind === "action-invocation") {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("triggers", nodeId("action", policy.trigger.actionId), id),
-        kind: "triggers",
-        sourceId: nodeId("action", policy.trigger.actionId),
-        targetId: id
-      });
-    }
-    for (const [effectIndex, effect] of policy.actions.entries()) {
-      if (effect.kind === "invoke-action") {
-        pushUniqueEdge(edges, edgeIds, {
-          id: edgeId("effects", id, nodeId("action", effect.actionId), `invoke-action-${effectIndex}`),
-          kind: "effects",
-          sourceId: id,
-          targetId: nodeId("action", effect.actionId),
-          label: "invoke action"
-        });
-      }
-      if ((effect.kind === "notify-role" || effect.kind === "require-approval") && effect.roleId !== void 0) {
-        pushUniqueEdge(edges, edgeIds, {
-          id: edgeId("effects", id, nodeId("role", effect.roleId), `${effect.kind}-${effectIndex}`),
-          kind: "effects",
-          sourceId: id,
-          targetId: nodeId("role", effect.roleId),
-          label: effect.kind
-        });
-      }
-    }
-  }
-  for (const [relationshipId, relationship] of Object.entries(organizationModel.topology.relationships).sort(
-    ([a], [b]) => a.localeCompare(b)
-  )) {
-    const sourceId = ensureTopologyNode(relationship.from);
-    const targetId = ensureTopologyNode(relationship.to);
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId(relationship.kind, sourceId, targetId, `topology-${relationshipId}`),
-      kind: relationship.kind,
-      sourceId,
-      targetId,
-      relationshipType: relationship.kind
-    });
-  }
-  for (const segment of Object.values(organizationModel.customers).sort(
-    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
-  )) {
-    const id = nodeId("customer-segment", segment.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "customer-segment",
-      label: segment.name,
-      sourceId: segment.id,
-      description: segment.description || void 0
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-  }
-  for (const product of Object.values(organizationModel.offerings).sort(
-    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
-  )) {
-    const id = nodeId("offering", product.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "offering",
-      label: product.name,
-      sourceId: product.id,
-      description: product.description || void 0
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-    for (const segmentId of product.targetSegmentIds) {
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("applies_to", id, nodeId("customer-segment", segmentId), "targets-segment"),
-        kind: "applies_to",
-        sourceId: id,
-        targetId: nodeId("customer-segment", segmentId),
-        label: "targets"
-      });
-    }
-  }
-  for (const objective of Object.values(organizationModel.goals).sort(
-    (a, b) => a.order - b.order || a.id.localeCompare(b.id)
-  )) {
-    const id = nodeId("goal", objective.id);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "goal",
-      label: objective.description,
-      sourceId: objective.id
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", organizationNode.id, id),
-      kind: "contains",
-      sourceId: organizationNode.id,
-      targetId: id
-    });
-  }
-  const sidebarGroups = [];
-  const sidebarSurfaces = [];
-  collectSidebarGraphNodes(organizationModel.navigation.sidebar.primary, sidebarGroups, sidebarSurfaces);
-  collectSidebarGraphNodes(organizationModel.navigation.sidebar.bottom, sidebarGroups, sidebarSurfaces);
-  for (const { id: surfaceSourceId, node: surface, parentGroupId } of sidebarSurfaces) {
-    const id = nodeId("surface", surfaceSourceId);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "surface",
-      label: surface.label,
-      sourceId: surfaceSourceId,
-      description: surface.description,
-      icon: surface.icon,
-      enabled: true
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", parentGroupId ? nodeId("navigation-group", parentGroupId) : organizationNode.id, id),
-      kind: "contains",
-      sourceId: parentGroupId ? nodeId("navigation-group", parentGroupId) : organizationNode.id,
-      targetId: id
-    });
-    for (const systemId of surface.targets?.systems ?? []) {
-      if (!validSystemRefs.has(systemId)) continue;
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("applies_to", id, systemNodeId(systemId), "surface-system"),
-        kind: "applies_to",
-        sourceId: id,
-        targetId: systemNodeId(systemId)
-      });
-    }
-  }
-  for (const { id: groupSourceId, node: group, parentGroupId } of sidebarGroups) {
-    const id = nodeId("navigation-group", groupSourceId);
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: "navigation-group",
-      label: group.label,
-      sourceId: groupSourceId
-    });
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId("contains", parentGroupId ? nodeId("navigation-group", parentGroupId) : organizationNode.id, id),
-      kind: "contains",
-      sourceId: parentGroupId ? nodeId("navigation-group", parentGroupId) : organizationNode.id,
-      targetId: id
-    });
-  }
-  for (const template of getAllBuildTemplates(organizationModel).sort((a, b) => a.id.localeCompare(b.id))) {
-    const steps = template.steps;
-    const stepById = new Map(steps.map((s) => [s.id, s]));
-    for (const step of [...steps].sort((a, b) => a.id.localeCompare(b.id))) {
-      const stageNodeId = nodeId("stage", step.stageKey);
-      const actionNodeId = nodeId("action", step.actionKey);
-      pushUniqueEdge(edges, edgeIds, {
-        id: edgeId("uses", stageNodeId, actionNodeId, step.id),
-        kind: "uses",
-        sourceId: stageNodeId,
-        targetId: actionNodeId
-      });
-      for (const depId of step.dependsOn ?? []) {
-        const depStep = stepById.get(depId);
-        if (depStep) {
-          const depStageNodeId = nodeId("stage", depStep.stageKey);
-          pushUniqueEdge(edges, edgeIds, {
-            id: edgeId("references", stageNodeId, depStageNodeId, step.id),
-            kind: "references",
-            sourceId: stageNodeId,
-            targetId: depStageNodeId
-          });
-        }
-      }
-    }
-  }
-  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)
-      });
-      if (!organizationModelResourceIds.has(resource.resourceId)) {
-        pushUniqueEdge(edges, edgeIds, {
-          id: edgeId("contains", organizationNode.id, resourceNode.id),
-          kind: "contains",
-          sourceId: organizationNode.id,
-          targetId: resourceNode.id
-        });
-      }
-    }
-    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/provider/resolvers/RouteResolver.ts
-function normalizeRoutePath(path) {
-  const trimmedPath = path.trim();
-  if (!trimmedPath || trimmedPath === "/") {
-    return "/";
-  }
-  return trimmedPath.replace(/\/+$/, "") || "/";
-}
-function isRouteMatch(currentPath, route) {
-  const normalizedCurrentPath = normalizeRoutePath(currentPath);
-  const normalizedRoute = normalizeRoutePath(route);
-  return normalizedCurrentPath === normalizedRoute || normalizedCurrentPath.startsWith(`${normalizedRoute}/`);
-}
-
-// src/provider/resolvers/NavResolver.ts
-function uniqueIds(ids) {
-  return ids ? [...new Set(ids)] : [];
-}
-
-// src/provider/validateManifests.ts
-function listSystemRefs(systems) {
-  const refs = [];
-  function walk(map, prefix = "") {
-    for (const [key, system] of Object.entries(map)) {
-      const path = prefix ? `${prefix}.${key}` : key;
-      refs.push(path, system.id);
-      const subsystems = system.subsystems;
-      if (subsystems) {
-        walk(subsystems, path);
-      }
-    }
-  }
-  walk(systems);
-  return refs;
-}
-function validateManifests(manifests, organizationModel) {
-  if (!organizationModel) {
-    return;
-  }
-  const validSystemIds = /* @__PURE__ */ new Set([
-    ...Object.keys(organizationModel.systems ?? {}),
-    ...listSystemRefs(organizationModel.systems ?? {})
-  ]);
-  const errors = [];
-  for (const manifest of manifests) {
-    const key = manifest.key;
-    const systemId = manifest.systemId;
-    if (!systemId) {
-      continue;
-    }
-    if (!validSystemIds.has(systemId)) {
-      errors.push(
-        `Manifest "${key}": systemId "${systemId}" is not a known system id. Valid values: ${[...validSystemIds].sort().join(", ")}`
-      );
-    }
-  }
-  if (errors.length > 0) {
-    throw new Error(
-      `System manifest validation failed with ${errors.length} error(s):
-` + errors.map((e, i) => `  ${i + 1}. ${e}`).join("\n")
-    );
-  }
-}
-var ElevasisSystemsContext = createContext(null);
-
-// src/provider/sidebarProjection.ts
-function isLifecycleEnabled3(system) {
-  if (system.enabled === false) return false;
-  return system.lifecycle !== "deprecated" && system.lifecycle !== "archived";
-}
-function isSystemAccessible(systemId, context) {
-  const system = context.shellModel.findById(systemId);
-  if (!system || !isLifecycleEnabled3(system)) return false;
-  if (!context.isSystemEnabled(systemId)) return false;
-  if (context.shellModel.requiresAdminFor(systemId) && !context.isPlatformAdmin) return false;
-  if (context.shellModel.devOnlyFor(systemId) && !context.isDev) return false;
-  return true;
-}
-function isSurfaceAccessible(node, context) {
-  if (node.devOnly && !context.isDev) return false;
-  if (node.requiresAdmin && !context.isPlatformAdmin) return false;
-  const systemTargets = node.targets?.systems ?? [];
-  if (systemTargets.length === 0) return true;
-  return systemTargets.some((systemId) => isSystemAccessible(systemId, context));
-}
-function iconForNode(node, context) {
-  if (node.type === "surface") {
-    const targetIcon = node.targets?.systems?.map((systemId) => context.shellModel.findById(systemId)?.iconComponent).find(Boolean);
-    if (targetIcon) return targetIcon;
-  }
-  return getSemanticIconComponent(node.icon);
-}
-function activeMatchPathsForSurface(node, context) {
-  const targets = node.targets?.systems ?? [];
-  if (targets.length !== 1) return void 0;
-  const paths = context.shellModel.childrenOf(targets[0]).map((child) => child.path).filter((path) => Boolean(path && path !== node.path));
-  return paths.length > 0 ? [...new Set(paths)] : void 0;
-}
-function surfaceToLinkItem(node, context, siblings) {
-  if (!isSurfaceAccessible(node, context)) return void 0;
-  const siblingShadows = siblings.some((sibling) => sibling !== node && sibling.path.startsWith(`${node.path}/`));
-  const activeMatchPaths = activeMatchPathsForSurface(node, context);
-  return {
-    label: node.label,
-    link: node.path,
-    ...siblingShadows ? { exact: true } : {},
-    ...activeMatchPaths ? { activeMatchPaths } : {}
-  };
-}
-function projectNode(node, context) {
-  if (node.type === "surface") {
-    if (!isSurfaceAccessible(node, context)) return void 0;
-    return {
-      label: node.label,
-      icon: iconForNode(node, context),
-      link: node.path
-    };
-  }
-  const childEntries = getSortedSidebarEntries(node.children);
-  const childSurfaces = childEntries.map(([, child]) => child).filter((child) => child.type === "surface");
-  const links = childEntries.flatMap(([, child]) => {
-    if (child.type === "surface") {
-      const link = surfaceToLinkItem(child, context, childSurfaces);
-      return link ? [link] : [];
-    }
-    const nestedGroup = projectNode(child, context);
-    return nestedGroup?.link ? [
-      {
-        label: nestedGroup.label,
-        link: nestedGroup.link
-      }
-    ] : nestedGroup?.links ?? [];
-  });
-  if (links.length === 0) return void 0;
-  return {
-    label: node.label,
-    icon: iconForNode(node, context),
-    links
-  };
-}
-function projectSection(section, context) {
-  const entries = getSortedSidebarEntries(section);
-  return entries.flatMap(([, node]) => {
-    const group = projectNode(node, context);
-    return group ? [group] : [];
-  });
-}
-function projectSidebarLinks({
-  shellModel,
-  organizationModel,
-  isSystemEnabled: isSystemEnabled2,
-  isPlatformAdmin = false,
-  isDev = false,
-  section
-}) {
-  const context = {
-    shellModel,
-    isSystemEnabled: isSystemEnabled2,
-    isPlatformAdmin,
-    isDev
-  };
-  const sidebar = organizationModel?.navigation.sidebar;
-  if (!sidebar) return [];
-  if (section) {
-    return projectSection(sidebar[section], context);
-  }
-  return [...projectSection(sidebar.primary, context), ...projectSection(sidebar.bottom, context)];
-}
-
-// src/provider/topbarProjection.ts
-function isTopbarActionVisible(node, context) {
-  if (node.enabled === false) return false;
-  if (node.devOnly && !context.isDev) return false;
-  if (node.requiresAdmin && !context.isPlatformAdmin) return false;
-  return true;
-}
-function resolveTopbarAction(node, index) {
-  return {
-    id: node.id,
-    label: node.label,
-    tooltip: node.tooltip,
-    icon: getSemanticIconComponent(node.icon),
-    order: node.order ?? index
-  };
-}
-function projectTopbarActions(topbar, modules, context) {
-  const modulesByKey = new Map(modules.map((m) => [m.key, m]));
-  const entries = Object.values(topbar);
-  const visibleNodes = entries.filter((node) => isTopbarActionVisible(node, context));
-  visibleNodes.sort((a, b) => {
-    const aOrder = a.order ?? Number.MAX_SAFE_INTEGER;
-    const bOrder = b.order ?? Number.MAX_SAFE_INTEGER;
-    if (aOrder !== bOrder) return aOrder - bOrder;
-    return a.id.localeCompare(b.id);
-  });
-  const result = [];
-  for (let i = 0; i < visibleNodes.length; i++) {
-    const node = visibleNodes[i];
-    const module = modulesByKey.get(node.id);
-    if (!module) continue;
-    result.push({
-      node: resolveTopbarAction(node, i),
-      render: module.render
-    });
-  }
-  return result;
-}
-function useElevasisSystems() {
-  const context = useContext(ElevasisSystemsContext);
-  if (!context) {
-    throw new Error(
-      "useElevasisSystems must be used within an ElevasisSystemsProvider. Wrap your app (or the relevant subtree) with <ElevasisSystemsProvider>."
-    );
-  }
-  return context;
-}
-function useOptionalElevasisSystems() {
-  return useContext(ElevasisSystemsContext);
-}
-function defaultSystems(organizationModel) {
-  if (!organizationModel) return [];
-  return listAllSystems(organizationModel).map(({ path, system }) => ({ ...system, id: path }));
-}
-function systemPath(system) {
-  return system.ui?.path ?? system.path ?? defaultPathFor(system.id);
-}
-function systemLabel(system) {
-  return system.label ?? system.title ?? system.id;
-}
-function moduleSystemId(module) {
-  return module.systemId ?? module.key;
-}
-function isLifecycleEnabled4(system) {
-  if (system.enabled === false) return false;
-  return system.lifecycle !== "deprecated" && system.lifecycle !== "archived";
-}
-function isOrganizationModelSystemEnabled(organizationModel, systemId) {
-  const system = defaultSystems(organizationModel).find((candidate) => candidate.id === systemId);
-  return system ? isLifecycleEnabled4(system) : void 0;
-}
-function resolveSystemModules(systems, isSystemEnabled2) {
-  return systems.map((system) => {
-    const systemId = system.systemId;
-    const accessKey = systemId ?? system.key;
-    return {
-      ...system,
-      systemId,
-      access: {
-        systemKey: system.key,
-        systemId,
-        enabled: isSystemEnabled2(accessKey)
-      },
-      semantics: {
-        capabilityIds: uniqueIds(system.capabilityIds ?? [])
-      }
-    };
-  });
-}
-function buildShellSystems(organizationModel, modules) {
-  const iconBySystemId = new Map(
-    modules.flatMap((module) => module.systemId ? [[moduleSystemId(module), module.icon]] : [])
-  );
-  return defaultSystems(organizationModel).map((system) => ({
-    ...system,
-    label: systemLabel(system),
-    path: systemPath(system),
-    iconComponent: iconBySystemId.get(system.id)
-  }));
-}
-function createShellModel(systems) {
-  const systemsRecord = Object.fromEntries(systems.map((s) => [s.id, s]));
-  return {
-    systems,
-    findByPath: (path) => findByPath(systemsRecord, normalizeRoutePath(path)),
-    findById: (id) => findById(systemsRecord, id),
-    childrenOf: (id) => childrenOf(systemsRecord, id),
-    ancestorsOf: (id) => ancestorsOf(systemsRecord, id),
-    parentOf: (id) => parentOf(systemsRecord, id),
-    topLevel: () => topLevel(systemsRecord),
-    requiresAdminFor: (id) => requiresAdminFor(systemsRecord, id),
-    devOnlyFor: (id) => devOnlyFor(systemsRecord, id)
-  };
-}
-function resolveOrganizationGraphSystem(systems, shellModel) {
-  for (const system of systems) {
-    const graphBridge = system.organizationGraph;
-    if (!graphBridge) continue;
-    const systemId = graphBridge.systemId;
-    if (!systemId) continue;
-    const node = shellModel.findById(systemId);
-    return {
-      available: Boolean(node),
-      systemId,
-      systemPath: node ? systemPath(node) : void 0
-    };
-  }
-  return {
-    available: false
-  };
-}
-function findMatchingNode(shellModel, currentPath) {
-  const normalizedPath = normalizeRoutePath(currentPath);
-  const exact = shellModel.findByPath(normalizedPath);
-  if (exact) return exact;
-  return [...shellModel.systems].filter((system) => {
-    const path = normalizeRoutePath(systemPath(system));
-    return path !== "/" && isRouteMatch(normalizedPath, path);
-  }).sort((a, b) => systemPath(b).length - systemPath(a).length)[0];
-}
-function ownsNode(module, node) {
-  if (!node || !module.systemId) return false;
-  return node.id === module.systemId || node.id.startsWith(`${module.systemId}.`);
-}
-function ownsRoutePrefix(module, normalizedPath) {
-  return (module.routePrefixes ?? []).some((prefix) => isRouteMatch(normalizedPath, normalizeRoutePath(prefix)));
-}
-function resolveRoute(systems, shellModel, currentPath, disabledSubsectionPaths) {
-  const node = findMatchingNode(shellModel, currentPath);
-  const normalizedPath = normalizeRoutePath(currentPath);
-  if (disabledSubsectionPaths.some((disabledPath) => isRouteMatch(normalizedPath, disabledPath))) {
-    return {
-      status: "hidden",
-      path: currentPath,
-      node
-    };
-  }
-  const system = systems.find((candidate) => ownsNode(candidate, node)) ?? systems.filter((candidate) => ownsRoutePrefix(candidate, normalizedPath)).sort(
-    (a, b) => Math.max(...(b.routePrefixes ?? []).map((prefix) => prefix.length)) - Math.max(...(a.routePrefixes ?? []).map((prefix) => prefix.length))
-  )[0];
-  if (!system) {
-    return {
-      status: "unmatched",
-      path: currentPath,
-      node
-    };
-  }
-  return {
-    status: "matched",
-    path: currentPath,
-    system,
-    node
-  };
-}
-function ElevasisSystemsProvider({
-  systems,
-  topbarActions,
-  organizationModel,
-  timeRange,
-  operationsApiUrl,
-  operationsSSEManager,
-  deliveryApiUrl,
-  deliverySSEManager,
-  disabledSubsectionPaths = [],
-  children
-}) {
-  const activeSystems = systems ?? [];
-  const resolvedOrganizationModel = useMemo(() => {
-    if (!organizationModel) {
-      return void 0;
-    }
-    return {
-      ...organizationModel,
-      knowledge: organizationModel.knowledge ?? {}
-    };
-  }, [organizationModel]);
-  useMemo(() => validateManifests(activeSystems, resolvedOrganizationModel), [activeSystems, resolvedOrganizationModel]);
-  const hasResolvedSystem = useCallback(
-    (key) => {
-      const organizationModelSystemEnabled = isOrganizationModelSystemEnabled(resolvedOrganizationModel, key);
-      return organizationModelSystemEnabled ?? true;
-    },
-    [resolvedOrganizationModel]
-  );
-  const shellSystems = useMemo(
-    () => buildShellSystems(resolvedOrganizationModel, activeSystems),
-    [resolvedOrganizationModel, activeSystems]
-  );
-  const shellModel = useMemo(() => createShellModel(shellSystems), [shellSystems]);
-  const normalizedDisabledSubsectionPaths = useMemo(
-    () => [...new Set(disabledSubsectionPaths.map((path) => normalizeRoutePath(path)))],
-    [disabledSubsectionPaths]
-  );
-  const resolvedSystems = useMemo(
-    () => resolveSystemModules(activeSystems, hasResolvedSystem),
-    [activeSystems, hasResolvedSystem]
-  );
-  const enabledResolvedSystems = useMemo(
-    () => resolvedSystems.filter((system) => system.access.enabled),
-    [resolvedSystems]
-  );
-  const organizationGraph = useMemo(
-    () => resolveOrganizationGraphSystem(enabledResolvedSystems, shellModel),
-    [enabledResolvedSystems, shellModel]
-  );
-  const getResolvedSystem = useCallback(
-    (key) => resolvedSystems.find((system) => system.key === key),
-    [resolvedSystems]
-  );
-  const isSystemEnabled2 = useCallback((key) => hasResolvedSystem(key), [hasResolvedSystem]);
-  const getSidebarLinks = useCallback(
-    (options = {}) => projectSidebarLinks({
-      shellModel,
-      organizationModel: resolvedOrganizationModel,
-      isSystemEnabled: isSystemEnabled2,
-      ...options
-    }),
-    [shellModel, resolvedOrganizationModel, isSystemEnabled2]
-  );
-  const activeTopbarActions = topbarActions ?? [];
-  const getTopbarActions = useCallback(
-    (options = {}) => projectTopbarActions(resolvedOrganizationModel?.navigation.topbar ?? {}, activeTopbarActions, {
-      isPlatformAdmin: options.isPlatformAdmin ?? false,
-      isDev: options.isDev ?? false
-    }),
-    [resolvedOrganizationModel, activeTopbarActions]
-  );
-  const resolveRouteByPath = useCallback(
-    (path) => resolveRoute(enabledResolvedSystems, shellModel, path, normalizedDisabledSubsectionPaths),
-    [enabledResolvedSystems, shellModel, normalizedDisabledSubsectionPaths]
-  );
-  const shellRuntime = useMemo(
-    () => ({
-      resolveRoute: resolveRouteByPath
-    }),
-    [resolveRouteByPath]
-  );
-  const value = useMemo(
-    () => ({
-      shellModel,
-      shellRuntime,
-      getSidebarLinks,
-      getTopbarActions,
-      enabledResolvedSystems,
-      resolvedSystems,
-      organizationGraph,
-      organizationModel: resolvedOrganizationModel,
-      timeRange,
-      operationsApiUrl,
-      operationsSSEManager,
-      deliveryApiUrl,
-      deliverySSEManager,
-      disabledSubsectionPaths: normalizedDisabledSubsectionPaths,
-      isSystemEnabled: isSystemEnabled2,
-      getResolvedSystem
-    }),
-    [
-      shellModel,
-      shellRuntime,
-      enabledResolvedSystems,
-      resolvedSystems,
-      organizationGraph,
-      resolvedOrganizationModel,
-      timeRange,
-      operationsApiUrl,
-      operationsSSEManager,
-      deliveryApiUrl,
-      deliverySSEManager,
-      normalizedDisabledSubsectionPaths,
-      isSystemEnabled2,
-      getResolvedSystem,
-      getSidebarLinks,
-      getTopbarActions
-    ]
-  );
-  return /* @__PURE__ */ jsx(ElevasisSystemsContext.Provider, { value, children });
-}
-
-export { ActionSchema, AgentResourceEntrySchema, DEFAULT_ORGANIZATION_MODEL, DEFAULT_SEMANTIC_ICON_REGISTRY, ElevasisSystemsProvider, EntitySchema, IdentityDomainSchema, IntegrationResourceEntrySchema, OrgKnowledgeNodeSchema, PROJECTS_VIEW_ACTION_ID, PolicySchema, RoleSchema, ScriptResourceEntrySchema, SemanticIcon, SurfaceDefinitionSchema, SystemEntrySchema, WorkflowResourceEntrySchema, buildOrganizationGraph, defineActions, defineEntities, defineResources, defineTopology, extendSemanticIconRegistry, getSemanticIconComponent, getSortedSidebarEntries, projectOrganizationSurfaces, resolveOrganizationModel, resolveSemanticIconComponent, topologyRef, topologyRelationship, useElevasisSystems, useOptionalElevasisSystems };