@elevasis/ui 2.25.4 → 2.25.6

package/dist/chunk-6U7AIIHF.js

@@ -0,0 +1,880 @@
+import { OrganizationModelProspectingSchema } from './chunk-BDKM56TP.js';
+import { LabelSchema, DescriptionSchema, DisplayMetadataSchema, ModelIdSchema, ColorTokenSchema, IconNameSchema, PathSchema, ReferenceIdsSchema, OrganizationModelSalesSchema } from './chunk-5RLYII6P.js';
+import { z } from 'zod';
+
+var OrganizationModelBrandingSchema = z.object({
+  organizationName: LabelSchema,
+  productName: LabelSchema,
+  shortName: z.string().trim().min(1).max(40),
+  description: DescriptionSchema.optional(),
+  logos: z.object({
+    light: z.string().trim().min(1).max(2048).optional(),
+    dark: z.string().trim().min(1).max(2048).optional()
+  }).default({})
+});
+var DEFAULT_ORGANIZATION_MODEL_BRANDING = {
+  organizationName: "Default Organization",
+  productName: "Elevasis",
+  shortName: "Elevasis",
+  logos: {}
+};
+var ProjectsDomainStateSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: z.number().int().min(0)
+});
+var OrganizationModelProjectsSchema = z.object({
+  projectEntityId: ModelIdSchema,
+  milestoneEntityId: ModelIdSchema,
+  taskEntityId: ModelIdSchema,
+  projectStatuses: z.array(ProjectsDomainStateSchema).min(1),
+  milestoneStatuses: z.array(ProjectsDomainStateSchema).min(1),
+  taskStatuses: z.array(ProjectsDomainStateSchema).min(1)
+});
+var DEFAULT_ORGANIZATION_MODEL_PROJECTS = {
+  projectEntityId: "delivery.project",
+  milestoneEntityId: "delivery.milestone",
+  taskEntityId: "delivery.task",
+  projectStatuses: [
+    { id: "active", label: "Active", order: 1 },
+    { id: "on_track", label: "On Track", order: 2 },
+    { id: "at_risk", label: "At Risk", order: 3 },
+    { id: "blocked", label: "Blocked", order: 4 },
+    { id: "paused", label: "Paused", order: 5 },
+    { id: "completed", label: "Completed", order: 6 }
+  ],
+  milestoneStatuses: [
+    { id: "upcoming", label: "Upcoming", order: 1 },
+    { id: "in_progress", label: "In Progress", order: 2 },
+    { id: "blocked", label: "Blocked", order: 3 },
+    { id: "overdue", label: "Overdue", order: 4 },
+    { id: "completed", label: "Completed", order: 5 }
+  ],
+  taskStatuses: [
+    { id: "planned", label: "Planned", order: 1 },
+    { id: "in_progress", label: "In Progress", order: 2 },
+    { id: "blocked", label: "Blocked", order: 3 },
+    { id: "submitted", label: "Submitted", order: 4 },
+    { id: "approved", label: "Approved", order: 5 },
+    { id: "revision_requested", label: "Revision Requested", order: 6 },
+    { id: "rejected", label: "Rejected", order: 7 },
+    { id: "cancelled", label: "Cancelled", order: 8 },
+    { id: "completed", label: "Completed", order: 9 }
+  ]
+};
+var NodeIdPathSchema = z.string().trim().min(1).max(100).regex(/^([a-z0-9-]+)(\.[a-z0-9-]+)*$/, "Node IDs must be lowercase dotted paths");
+var NodeIdStringSchema = z.string().trim().min(1).max(200).regex(/^[a-z]+:([a-z0-9-]+)(\.[a-z0-9-]+)*$/, "Node references must use kind:dotted-path");
+var UiPositionSchema = z.enum(["sidebar-primary", "sidebar-bottom"]);
+var FeatureSchema = z.object({
+  id: NodeIdPathSchema,
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  enabled: z.boolean().default(true),
+  path: PathSchema.optional(),
+  icon: IconNameSchema.optional(),
+  color: ColorTokenSchema.optional(),
+  uiPosition: UiPositionSchema.optional(),
+  requiresAdmin: z.boolean().optional(),
+  devOnly: z.boolean().optional()
+});
+var SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]);
+var SurfaceDefinitionSchema = z.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  path: PathSchema,
+  surfaceType: SurfaceTypeSchema,
+  description: DescriptionSchema.optional(),
+  enabled: z.boolean().default(true),
+  devOnly: z.boolean().optional(),
+  icon: IconNameSchema.optional(),
+  featureId: ModelIdSchema.optional(),
+  featureIds: ReferenceIdsSchema,
+  entityIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema,
+  capabilityIds: ReferenceIdsSchema,
+  parentId: ModelIdSchema.optional()
+});
+var NavigationGroupSchema = z.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  placement: z.string().trim().min(1).max(50),
+  surfaceIds: z.array(ModelIdSchema).default([])
+});
+var OrganizationModelNavigationSchema = z.object({
+  defaultSurfaceId: ModelIdSchema.optional(),
+  surfaces: z.array(SurfaceDefinitionSchema).default([]),
+  groups: z.array(NavigationGroupSchema).default([])
+});
+var BusinessHoursDaySchema = z.object({
+  open: z.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format"),
+  close: z.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format")
+});
+var BusinessHoursSchema = z.object({
+  monday: BusinessHoursDaySchema.optional(),
+  tuesday: BusinessHoursDaySchema.optional(),
+  wednesday: BusinessHoursDaySchema.optional(),
+  thursday: BusinessHoursDaySchema.optional(),
+  friday: BusinessHoursDaySchema.optional(),
+  saturday: BusinessHoursDaySchema.optional(),
+  sunday: BusinessHoursDaySchema.optional()
+}).default({});
+var IdentityDomainSchema = z.object({
+  /** Why the organization exists — one or two plain-language sentences. */
+  mission: z.string().trim().max(1e3).default(""),
+  /** Long-term direction the organization is moving toward. */
+  vision: z.string().trim().max(1e3).default(""),
+  /** Legal registered name of the entity. */
+  legalName: z.string().trim().max(200).default(""),
+  /**
+   * Type of legal entity (e.g. "LLC", "Corporation", "Sole Proprietor",
+   * "Non-profit"). Free-form string so it covers any jurisdiction.
+   */
+  entityType: z.string().trim().max(100).default(""),
+  /**
+   * Primary jurisdiction of registration or operation
+   * (e.g. "United States – Delaware", "Canada – Ontario").
+   */
+  jurisdiction: z.string().trim().max(200).default(""),
+  /**
+   * Industry category — broad classification (e.g. "Marketing Agency",
+   * "Software / SaaS", "Professional Services").
+   */
+  industryCategory: z.string().trim().max(200).default(""),
+  /**
+   * Geographic focus — where the organization primarily operates or serves
+   * (e.g. "North America", "Global", "Southeast Asia").
+   */
+  geographicFocus: z.string().trim().max(200).default(""),
+  /**
+   * IANA timezone identifier for the organization's primary operating timezone
+   * (e.g. "America/Los_Angeles", "Europe/London", "UTC").
+   */
+  timeZone: z.string().trim().max(100).default("UTC"),
+  /** Typical operating hours per day of week. Empty object means not configured. */
+  businessHours: BusinessHoursSchema,
+  /**
+   * Long-form markdown capturing client context, problem narrative, and domain
+   * background. Populated by /setup; surfaced to agents as organizational context.
+   * Optional — many projects have no external client.
+   */
+  clientBrief: z.string().trim().default("")
+});
+var DEFAULT_ORGANIZATION_MODEL_IDENTITY = {
+  mission: "",
+  vision: "",
+  legalName: "",
+  entityType: "",
+  jurisdiction: "",
+  industryCategory: "",
+  geographicFocus: "",
+  timeZone: "UTC",
+  businessHours: {},
+  clientBrief: ""
+};
+var FirmographicsSchema = z.object({
+  /** Industry vertical (e.g. "Marketing Agency", "Legal", "Real Estate"). */
+  industry: z.string().trim().max(200).optional(),
+  /**
+   * Company headcount band (e.g. "1–10", "11–50", "51–200", "200+").
+   * Free-form string to accommodate any band notation.
+   */
+  companySize: z.string().trim().max(100).optional(),
+  /**
+   * Primary geographic region the segment operates in or is targeted from
+   * (e.g. "North America", "Europe", "Global").
+   */
+  region: z.string().trim().max(200).optional()
+});
+var CustomerSegmentSchema = z.object({
+  /** Stable unique identifier for the segment (e.g. "segment-smb-agencies"). */
+  id: z.string().trim().min(1).max(100),
+  /** Human-readable name shown to agents and in UI (e.g. "SMB Marketing Agencies"). */
+  name: z.string().trim().max(200).default(""),
+  /** One or two sentences describing who this segment is. */
+  description: z.string().trim().max(2e3).default(""),
+  /**
+   * The primary job(s) this segment is trying to get done — the goal they hire
+   * a product/service to accomplish. Plain-language narrative or bullet list.
+   */
+  jobsToBeDone: z.string().trim().max(2e3).default(""),
+  /**
+   * Pains — frustrations, obstacles, and risks the segment experiences
+   * when trying to accomplish their jobs-to-be-done.
+   */
+  pains: z.array(z.string().trim().max(500)).default([]),
+  /**
+   * Gains — outcomes and benefits the segment desires; positive motivators
+   * beyond merely resolving pains.
+   */
+  gains: z.array(z.string().trim().max(500)).default([]),
+  /** Firmographic profile for targeting and filtering. */
+  firmographics: FirmographicsSchema.default({}),
+  /**
+   * Value proposition — one or two sentences stating why this organization's
+   * offering is uniquely suited for this segment's needs.
+   */
+  valueProp: z.string().trim().max(2e3).default("")
+});
+var CustomersDomainSchema = z.object({
+  segments: z.array(CustomerSegmentSchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_CUSTOMERS = {
+  segments: []
+};
+var PricingModelSchema = z.enum(["one-time", "subscription", "usage-based", "custom"]);
+var ProductSchema = z.object({
+  /** Stable unique identifier for the product (e.g. "product-starter-plan"). */
+  id: z.string().trim().min(1).max(100),
+  /** Human-readable name shown to agents and in UI (e.g. "Starter Plan"). */
+  name: z.string().trim().max(200).default(""),
+  /** One or two sentences describing what this product/service delivers. */
+  description: z.string().trim().max(2e3).default(""),
+  /**
+   * How this product is priced:
+   * - "one-time" — single purchase (setup fee, project fee)
+   * - "subscription" — recurring (monthly/annual SaaS, retainer)
+   * - "usage-based" — metered by consumption (API calls, seats)
+   * - "custom" — negotiated or bespoke pricing
+   */
+  pricingModel: PricingModelSchema.default("custom"),
+  /** Base price amount (≥ 0). Currency unit defined by `currency`. */
+  price: z.number().min(0).default(0),
+  /**
+   * ISO 4217 currency code (e.g. "USD", "EUR", "GBP").
+   * Free-form string to accommodate any currency; defaults to "USD".
+   */
+  currency: z.string().trim().max(10).default("USD"),
+  /**
+   * IDs of customer segments this product targets.
+   * Each id must reference a declared `customers.segments[].id`.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  targetSegmentIds: z.array(z.string().trim().min(1)).default([]),
+  /**
+   * Optional: ID of the platform feature responsible for delivering this product.
+   * When present, must reference a declared `features[].id`.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  deliveryFeatureId: z.string().trim().min(1).optional()
+});
+var OfferingsDomainSchema = z.object({
+  products: z.array(ProductSchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_OFFERINGS = {
+  products: []
+};
+var RoleSchema = z.object({
+  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
+  id: z.string().trim().min(1).max(100),
+  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
+  title: z.string().trim().min(1).max(200),
+  /**
+   * List of responsibilities this role owns — plain-language descriptions of
+   * what the person in this role is accountable for delivering.
+   * Defaults to empty array so minimal role definitions stay concise.
+   */
+  responsibilities: z.array(z.string().trim().max(500)).default([]),
+  /**
+   * Optional: ID of another role this role reports to.
+   * When present, must reference another `roles[].id` in the same organization.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   * Absence indicates a top-level role (no reporting line).
+   */
+  reportsToId: z.string().trim().min(1).max(100).optional(),
+  /**
+   * Optional: name or email of the person currently holding this role.
+   * Free-form string — supports "Alice Johnson", "alice@example.com", or
+   * any human-readable identifier. Not validated against any user registry.
+   */
+  heldBy: z.string().trim().max(200).optional()
+});
+var RolesDomainSchema = z.object({
+  roles: z.array(RoleSchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_ROLES = {
+  roles: []
+};
+var KeyResultSchema = z.object({
+  /** Stable unique identifier for the measurable outcome (e.g. "kr-revenue-q1"). */
+  id: z.string().trim().min(1).max(100),
+  /** Plain-language description of this measurable outcome (e.g. "Increase trial-to-paid conversion"). */
+  description: z.string().trim().min(1).max(500),
+  /**
+   * What is being measured — the metric name (e.g. "monthly revenue", "NPS score",
+   * "trial-to-paid conversion rate"). Free-form string.
+   */
+  targetMetric: z.string().trim().min(1).max(200),
+  /** Current measured value. Defaults to 0 when not yet tracked. */
+  currentValue: z.number().default(0),
+  /**
+   * Target value to reach for this measurable outcome to be considered achieved.
+   * Optional — omit if the outcome is directional (e.g. "reduce churn") without
+   * a hard numeric target.
+   */
+  targetValue: z.number().optional()
+});
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var ObjectiveSchema = z.object({
+  /** Stable unique identifier for the goal (e.g. "goal-grow-arr-q1-2026"). */
+  id: z.string().trim().min(1).max(100),
+  /** Plain-language description of what the organization wants to achieve. */
+  description: z.string().trim().min(1).max(1e3),
+  /**
+   * Start of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
+   * Must be strictly before `periodEnd`.
+   */
+  periodStart: z.string().regex(ISO_DATE_REGEX, "periodStart must be an ISO date string (YYYY-MM-DD)"),
+  /**
+   * End of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
+   * Must be strictly after `periodStart`.
+   * Enforced via `OrganizationModelSchema.superRefine()`.
+   */
+  periodEnd: z.string().regex(ISO_DATE_REGEX, "periodEnd must be an ISO date string (YYYY-MM-DD)"),
+  /**
+   * List of measurable outcomes that define success for this goal.
+   * Defaults to empty array so goals can be declared before outcomes are defined.
+   */
+  keyResults: z.array(KeyResultSchema).default([])
+});
+var GoalsDomainSchema = z.object({
+  objectives: z.array(ObjectiveSchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_GOALS = {
+  objectives: []
+};
+var OperationSemanticClassSchema = z.enum(["queue", "executions", "sessions", "notifications", "schedules"]);
+var OperationEntrySchema = z.object({
+  id: z.string().trim().min(1).max(100),
+  label: z.string().trim().min(1).max(120),
+  semanticClass: OperationSemanticClassSchema,
+  /** Optional reference to the feature that owns this runtime entity. */
+  featureId: z.string().trim().min(1).max(100).optional(),
+  /**
+   * Optional pointer to the status semanticClass values that apply to this
+   * entity — ties operations back to the statuses domain for vibe rendering.
+   */
+  supportedStatusSemanticClass: z.array(z.string().trim().min(1).max(80)).optional()
+});
+var OperationsDomainSchema = z.object({
+  entries: z.array(OperationEntrySchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_OPERATIONS = {
+  entries: [
+    // --- queue (HITL command queue) ---
+    {
+      id: "operations.queue",
+      label: "HITL Queue",
+      semanticClass: "queue",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["queue"]
+    },
+    // --- executions (workflow / agent executions) ---
+    {
+      id: "operations.executions",
+      label: "Executions",
+      semanticClass: "executions",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["execution"]
+    },
+    // --- sessions (agent conversation sessions) ---
+    {
+      id: "operations.sessions",
+      label: "Sessions",
+      semanticClass: "sessions",
+      featureId: "operations"
+    },
+    // --- notifications (platform in-app notifications) ---
+    {
+      id: "operations.notifications",
+      label: "Notifications",
+      semanticClass: "notifications",
+      featureId: "monitoring"
+    },
+    // --- schedules (task scheduler) ---
+    {
+      id: "operations.schedules",
+      label: "Schedules",
+      semanticClass: "schedules",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["schedule", "schedule.run"]
+    }
+  ]
+};
+var StatusSemanticClassSchema = z.enum([
+  "delivery.task",
+  "delivery.project",
+  "delivery.milestone",
+  "queue",
+  "execution",
+  "schedule",
+  "schedule.run",
+  "request"
+]);
+var StatusEntrySchema = z.object({
+  id: z.string().trim().min(1).max(100),
+  label: z.string().trim().min(1).max(120),
+  semanticClass: StatusSemanticClassSchema,
+  category: z.string().trim().min(1).max(80).optional()
+});
+var StatusesDomainSchema = z.object({
+  entries: z.array(StatusEntrySchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_STATUSES = {
+  entries: [
+    // --- delivery.task (TaskStatus — 9 values) ---
+    { id: "delivery.task.planned", label: "Planned", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.in_progress", label: "In Progress", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.blocked", label: "Blocked", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.submitted", label: "Submitted", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.approved", label: "Approved", semanticClass: "delivery.task", category: "delivery" },
+    {
+      id: "delivery.task.revision_requested",
+      label: "Revision Requested",
+      semanticClass: "delivery.task",
+      category: "delivery"
+    },
+    { id: "delivery.task.rejected", label: "Rejected", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.cancelled", label: "Cancelled", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.completed", label: "Completed", semanticClass: "delivery.task", category: "delivery" },
+    // --- delivery.project (ProjectStatus — 6 values) ---
+    { id: "delivery.project.active", label: "Active", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.on_track", label: "On Track", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.at_risk", label: "At Risk", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.blocked", label: "Blocked", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.paused", label: "Paused", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.completed", label: "Completed", semanticClass: "delivery.project", category: "delivery" },
+    // --- delivery.milestone (MilestoneStatus — 5 values) ---
+    {
+      id: "delivery.milestone.upcoming",
+      label: "Upcoming",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    {
+      id: "delivery.milestone.in_progress",
+      label: "In Progress",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    {
+      id: "delivery.milestone.blocked",
+      label: "Blocked",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    { id: "delivery.milestone.overdue", label: "Overdue", semanticClass: "delivery.milestone", category: "delivery" },
+    {
+      id: "delivery.milestone.completed",
+      label: "Completed",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    // --- queue (QueueTaskStatus — 5 values, maps hitl/command-queue tasks) ---
+    { id: "queue.pending", label: "Pending", semanticClass: "queue", category: "queue" },
+    { id: "queue.processing", label: "Processing", semanticClass: "queue", category: "queue" },
+    { id: "queue.completed", label: "Completed", semanticClass: "queue", category: "queue" },
+    { id: "queue.failed", label: "Failed", semanticClass: "queue", category: "queue" },
+    { id: "queue.expired", label: "Expired", semanticClass: "queue", category: "queue" },
+    // --- execution (ExecutionStatus — 5 values) ---
+    { id: "execution.pending", label: "Pending", semanticClass: "execution", category: "execution" },
+    { id: "execution.running", label: "Running", semanticClass: "execution", category: "execution" },
+    { id: "execution.completed", label: "Completed", semanticClass: "execution", category: "execution" },
+    { id: "execution.failed", label: "Failed", semanticClass: "execution", category: "execution" },
+    { id: "execution.warning", label: "Warning", semanticClass: "execution", category: "execution" },
+    // --- schedule (schedule status — 4 values) ---
+    { id: "schedule.active", label: "Active", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.paused", label: "Paused", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.completed", label: "Completed", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.cancelled", label: "Cancelled", semanticClass: "schedule", category: "schedule" },
+    // --- schedule.run (schedule run status — 4 values) ---
+    { id: "schedule.run.running", label: "Running", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.completed", label: "Completed", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.failed", label: "Failed", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.cancelled", label: "Cancelled", semanticClass: "schedule.run", category: "schedule" },
+    // --- request (RequestStatus — 4 values, maps reported_requests) ---
+    { id: "request.open", label: "Open", semanticClass: "request", category: "request" },
+    { id: "request.investigating", label: "Investigating", semanticClass: "request", category: "request" },
+    { id: "request.resolved", label: "Resolved", semanticClass: "request", category: "request" },
+    { id: "request.wont_fix", label: "Won't Fix", semanticClass: "request", category: "request" }
+  ]
+};
+var KnowledgeLinkSchema = z.object({
+  nodeId: NodeIdStringSchema
+});
+var OrgKnowledgeKindSchema = z.enum(["playbook", "strategy", "reference"]);
+var OrgKnowledgeNodeSchema = z.object({
+  id: ModelIdSchema,
+  kind: OrgKnowledgeKindSchema,
+  title: z.string().trim().min(1).max(200),
+  summary: z.string().trim().min(1).max(1e3),
+  /** Raw MDX string. Phase 2 will introduce a structured block format. */
+  body: z.string().trim().min(1),
+  /**
+   * Graph links to other OM nodes this knowledge node governs.
+   * Each link emits a `governs` edge: knowledge-node -> target node.
+   */
+  links: z.array(KnowledgeLinkSchema).default([]),
+  /** Identifiers of the roles or members who own this knowledge node. */
+  ownerIds: z.array(ModelIdSchema).default([]),
+  /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
+  updatedAt: z.string().trim().min(1).max(50)
+});
+var KnowledgeDomainSchema = z.object({
+  nodes: z.array(OrgKnowledgeNodeSchema).default([])
+});
+
+// ../core/src/organization-model/schema.ts
+var OrganizationModelSchemaBase = z.object({
+  version: z.literal(1).default(1),
+  features: z.array(FeatureSchema).default([]),
+  branding: OrganizationModelBrandingSchema,
+  navigation: OrganizationModelNavigationSchema.default({ surfaces: [], groups: [] }),
+  sales: OrganizationModelSalesSchema,
+  prospecting: OrganizationModelProspectingSchema,
+  projects: OrganizationModelProjectsSchema,
+  identity: IdentityDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_IDENTITY),
+  customers: CustomersDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_CUSTOMERS),
+  offerings: OfferingsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_OFFERINGS),
+  roles: RolesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ROLES),
+  goals: GoalsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_GOALS),
+  statuses: StatusesDomainSchema.default({ entries: [] }),
+  operations: OperationsDomainSchema.default({ entries: [] }),
+  knowledge: KnowledgeDomainSchema.default({ nodes: [] })
+});
+function addIssue(ctx, path, message) {
+  ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    path,
+    message
+  });
+}
+function collectIds(items, ctx, collectionPath, label) {
+  const itemsById = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    if (itemsById.has(item.id)) {
+      addIssue(ctx, [...collectionPath, index, "id"], `${label} id "${item.id}" must be unique`);
+      return;
+    }
+    itemsById.set(item.id, item);
+  });
+  return itemsById;
+}
+var LEGACY_FEATURE_ALIASES = /* @__PURE__ */ new Map([
+  ["crm", "sales.crm"],
+  ["lead-gen", "sales.lead-gen"],
+  ["submitted-requests", "monitoring.submitted-requests"]
+]);
+function hasFeature(featuresById, featureId) {
+  return featuresById.has(featureId) || featuresById.has(LEGACY_FEATURE_ALIASES.get(featureId) ?? "");
+}
+var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
+  const featuresById = collectIds(model.features, ctx, ["features"], "Feature");
+  model.features.forEach((feature, featureIndex) => {
+    const segments = feature.id.split(".");
+    if (segments.length > 1) {
+      const parentId = segments.slice(0, -1).join(".");
+      if (!featuresById.has(parentId)) {
+        addIssue(
+          ctx,
+          ["features", featureIndex, "id"],
+          `Feature "${feature.id}" references unknown parent "${parentId}"`
+        );
+      }
+    }
+    const hasChildren = model.features.some(
+      (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.id !== feature.id
+    );
+    if (hasChildren && feature.enabled) {
+      const hasEnabledDescendant = model.features.some(
+        (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.enabled
+      );
+      if (!hasEnabledDescendant) {
+        addIssue(
+          ctx,
+          ["features", featureIndex, "enabled"],
+          `Feature "${feature.id}" is enabled but has no enabled descendants`
+        );
+      }
+    }
+  });
+  const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]));
+  model.offerings.products.forEach((product, productIndex) => {
+    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
+      if (!segmentsById.has(segmentId)) {
+        addIssue(
+          ctx,
+          ["offerings", "products", productIndex, "targetSegmentIds", segmentIndex],
+          `Product "${product.id}" references unknown customer segment "${segmentId}"`
+        );
+      }
+    });
+    if (product.deliveryFeatureId !== void 0 && !hasFeature(featuresById, product.deliveryFeatureId)) {
+      addIssue(
+        ctx,
+        ["offerings", "products", productIndex, "deliveryFeatureId"],
+        `Product "${product.id}" references unknown delivery feature "${product.deliveryFeatureId}"`
+      );
+    }
+  });
+  model.goals.objectives.forEach((objective, index) => {
+    if (objective.periodEnd <= objective.periodStart) {
+      addIssue(
+        ctx,
+        ["goals", "objectives", index, "periodEnd"],
+        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
+      );
+    }
+  });
+  const rolesById = new Map(model.roles.roles.map((role) => [role.id, role]));
+  model.roles.roles.forEach((role, roleIndex) => {
+    if (role.reportsToId !== void 0 && !rolesById.has(role.reportsToId)) {
+      addIssue(
+        ctx,
+        ["roles", "roles", roleIndex, "reportsToId"],
+        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
+      );
+    }
+  });
+});
+
+// ../core/src/organization-model/graph/schema.ts
+var OrganizationGraphNodeKindSchema = z.enum([
+  "organization",
+  "feature",
+  "surface",
+  "entity",
+  "capability",
+  "resource",
+  "knowledge"
+]);
+var OrganizationGraphEdgeKindSchema = z.enum([
+  "contains",
+  "references",
+  "exposes",
+  "maps_to",
+  "operates-on",
+  "uses",
+  "governs"
+]);
+var OrganizationGraphNodeSchema = z.object({
+  id: z.string().trim().min(1).max(200),
+  kind: OrganizationGraphNodeKindSchema,
+  label: LabelSchema,
+  sourceId: z.string().trim().min(1).max(255).optional(),
+  description: DescriptionSchema.optional(),
+  enabled: z.boolean().optional(),
+  featureId: z.string().trim().min(1).max(100).optional(),
+  resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]).optional()
+});
+var OrganizationGraphEdgeSchema = z.object({
+  id: z.string().trim().min(1).max(250),
+  kind: OrganizationGraphEdgeKindSchema,
+  sourceId: z.string().trim().min(1).max(200),
+  targetId: z.string().trim().min(1).max(200),
+  label: z.string().trim().min(1).max(120).optional(),
+  relationshipType: z.enum(["triggers", "uses", "approval"]).optional()
+});
+var OrganizationGraphSchema = z.object({
+  version: z.literal(1),
+  organizationModelVersion: OrganizationModelSchema.shape.version,
+  nodes: z.array(OrganizationGraphNodeSchema),
+  edges: z.array(OrganizationGraphEdgeSchema)
+});
+var BuildOrganizationGraphInputSchema = z.object({
+  organizationModel: OrganizationModelSchema,
+  commandViewData: z.unknown().optional()
+});
+
+// ../core/src/organization-model/graph/build.ts
+function nodeId(kind, sourceId) {
+  return kind === "organization" ? "organization-model" : `${kind}:${sourceId ?? ""}`;
+}
+function edgeId(kind, sourceId, targetId, variant) {
+  return variant ? `edge:${kind}:${variant}:${sourceId}:${targetId}` : `edge:${kind}:${sourceId}:${targetId}`;
+}
+function pushUniqueNode(nodes, seen, node) {
+  if (seen.has(node.id)) return;
+  seen.add(node.id);
+  nodes.push(node);
+}
+function pushUniqueEdge(edges, seen, edge) {
+  if (seen.has(edge.id)) return;
+  seen.add(edge.id);
+  edges.push(edge);
+}
+function upsertResourceNode(nodes, seen, resourceNodesById, node) {
+  const existing = resourceNodesById.get(node.id);
+  if (existing) {
+    if (!existing.label || existing.label === existing.sourceId) {
+      existing.label = node.label;
+    }
+    if (!existing.description && node.description) {
+      existing.description = node.description;
+    }
+    if (!existing.sourceId && node.sourceId) {
+      existing.sourceId = node.sourceId;
+    }
+    if (!existing.resourceType && node.resourceType) {
+      existing.resourceType = node.resourceType;
+    }
+    return existing;
+  }
+  resourceNodesById.set(node.id, node);
+  pushUniqueNode(nodes, seen, node);
+  return node;
+}
+function ensureResourceNode(nodes, seen, resourceNodesById, resourceId) {
+  const existing = resourceNodesById.get(nodeId("resource", resourceId));
+  if (existing) return existing;
+  return upsertResourceNode(nodes, seen, resourceNodesById, {
+    id: nodeId("resource", resourceId),
+    kind: "resource",
+    label: resourceId,
+    sourceId: resourceId
+  });
+}
+function normalizeCommandViewResourceType(resourceType) {
+  return resourceType === "human" ? "human_checkpoint" : resourceType;
+}
+function collectCommandViewResources(commandViewData) {
+  return [
+    ...commandViewData.workflows,
+    ...commandViewData.agents,
+    ...commandViewData.triggers,
+    ...commandViewData.integrations,
+    ...commandViewData.externalResources,
+    ...commandViewData.humanCheckpoints
+  ];
+}
+function pushResourceLinks(edges, edgeIds, resourceNodeId, links) {
+  for (const link of links ?? []) {
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId(link.kind, resourceNodeId, link.nodeId),
+      kind: link.kind,
+      sourceId: resourceNodeId,
+      targetId: link.nodeId
+    });
+  }
+}
+function buildOrganizationGraph(input) {
+  const parsed = BuildOrganizationGraphInputSchema.parse(input);
+  const organizationModel = parsed.organizationModel;
+  const commandViewData = parsed.commandViewData;
+  const nodes = [];
+  const edges = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  const edgeIds = /* @__PURE__ */ new Set();
+  const resourceNodesById = /* @__PURE__ */ new Map();
+  const organizationNode = {
+    id: nodeId("organization"),
+    kind: "organization",
+    label: "Organization Model"
+  };
+  pushUniqueNode(nodes, nodeIds, organizationNode);
+  for (const feature of [...organizationModel.features].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId("feature", feature.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "feature",
+      label: feature.label,
+      sourceId: feature.id,
+      description: feature.description,
+      enabled: feature.enabled,
+      featureId: feature.id
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    const parentId = feature.id.includes(".") ? feature.id.slice(0, feature.id.lastIndexOf(".")) : void 0;
+    if (parentId) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", nodeId("feature", parentId), id),
+        kind: "contains",
+        sourceId: nodeId("feature", parentId),
+        targetId: id
+      });
+    }
+  }
+  for (const node of [...organizationModel.knowledge?.nodes ?? []].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId("knowledge", node.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "knowledge",
+      label: node.title,
+      sourceId: node.id,
+      description: node.summary
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    for (const link of node.links) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("governs", id, link.nodeId),
+        kind: "governs",
+        sourceId: id,
+        targetId: link.nodeId
+      });
+    }
+  }
+  if (commandViewData) {
+    const commandViewResources = collectCommandViewResources(commandViewData).sort(
+      (a, b) => a.resourceId.localeCompare(b.resourceId)
+    );
+    for (const resource of commandViewResources) {
+      const id = nodeId("resource", resource.resourceId);
+      const resourceNode = upsertResourceNode(nodes, nodeIds, resourceNodesById, {
+        id,
+        kind: "resource",
+        label: resource.name,
+        sourceId: resource.resourceId,
+        description: resource.description,
+        resourceType: normalizeCommandViewResourceType(resource.type)
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, resourceNode.id),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: resourceNode.id
+      });
+      pushResourceLinks(edges, edgeIds, resourceNode.id, resource.links);
+    }
+    for (const relationship of [...commandViewData.edges].sort((a, b) => a.id.localeCompare(b.id))) {
+      const sourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.source);
+      const targetNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.target);
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, sourceNode.id),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: sourceNode.id
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, targetNode.id),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: targetNode.id
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("references", sourceNode.id, targetNode.id, relationship.relationship),
+        kind: "references",
+        sourceId: sourceNode.id,
+        targetId: targetNode.id,
+        label: relationship.relationship,
+        relationshipType: relationship.relationship
+      });
+    }
+  }
+  const graph = {
+    version: 1,
+    organizationModelVersion: organizationModel.version,
+    nodes,
+    edges
+  };
+  return OrganizationGraphSchema.parse(graph);
+}
+
+export { DEFAULT_ORGANIZATION_MODEL_BRANDING, DEFAULT_ORGANIZATION_MODEL_CUSTOMERS, DEFAULT_ORGANIZATION_MODEL_GOALS, DEFAULT_ORGANIZATION_MODEL_IDENTITY, DEFAULT_ORGANIZATION_MODEL_OFFERINGS, DEFAULT_ORGANIZATION_MODEL_OPERATIONS, DEFAULT_ORGANIZATION_MODEL_PROJECTS, DEFAULT_ORGANIZATION_MODEL_ROLES, DEFAULT_ORGANIZATION_MODEL_STATUSES, OrganizationModelSchema, buildOrganizationGraph };