@elevasis/sdk 1.21.0 → 1.22.0

package/dist/test-utils/index.js

@@ -6512,73 +6512,78 @@ Fix the errors and generate a valid output.
   }
 };
 var ORGANIZATION_MODEL_ICON_TOKENS = [
-  "nav.dashboard",
-  "nav.calendar",
-  "nav.sales",
-  "nav.crm",
-  "nav.lead-gen",
-  "nav.projects",
-  "nav.operations",
-  "nav.monitoring",
-  "nav.knowledge",
-  "nav.settings",
-  "nav.admin",
-  "nav.archive",
-  "knowledge.playbook",
-  "knowledge.strategy",
-  "knowledge.reference",
-  "feature.dashboard",
-  "feature.calendar",
-  "feature.business",
-  "feature.sales",
-  "feature.crm",
-  "feature.finance",
-  "feature.lead-gen",
-  "feature.platform",
-  "feature.projects",
-  "feature.operations",
-  "feature.knowledge",
-  "feature.monitoring",
-  "feature.settings",
-  "feature.admin",
-  "feature.archive",
-  "feature.seo",
-  "resource.agent",
-  "resource.workflow",
-  "resource.integration",
-  "resource.database",
-  "resource.user",
-  "resource.team",
-  "integration.gmail",
-  "integration.google-sheets",
-  "integration.attio",
-  "surface.dashboard",
-  "surface.calendar",
-  "surface.overview",
-  "surface.command-view",
-  "surface.command-queue",
-  "surface.pipeline",
-  "surface.lists",
-  "surface.resources",
-  "surface.settings",
-  "status.success",
-  "status.error",
-  "status.warning",
-  "status.info",
-  "status.pending",
-  "action.approve",
-  "action.reject",
-  "action.retry",
-  "action.edit",
-  "action.view",
-  "action.launch",
-  "action.message",
-  "action.escalate",
-  "action.promote",
-  "action.submit",
-  "action.email"
+  // Navigation / app areas
+  "dashboard",
+  "calendar",
+  "sales",
+  "crm",
+  "lead-gen",
+  "projects",
+  "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",
+  "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.");
+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,
@@ -6591,7 +6596,7 @@ 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;
-z.string().trim().startsWith("/").max(300);
+var PathSchema = z.string().trim().startsWith("/").max(300);
 var ReferenceIdsSchema = z.array(ModelIdSchema).default([]);
 var DisplayMetadataSchema = z.object({
   label: LabelSchema,
@@ -6651,7 +6656,7 @@ var EntitySchema = z.object({
   stateCatalogId: ModelIdSchema.optional(),
   links: z.array(EntityLinkSchema).optional()
 });
-z.record(z.string(), EntitySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+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({});
 var ENTITY_ENTRY_INPUTS = [
@@ -6749,7 +6754,7 @@ var ENTITY_ENTRY_INPUTS = [
     ]
   }
 ];
-Object.fromEntries(
+var DEFAULT_ORGANIZATION_MODEL_ENTITIES = Object.fromEntries(
   ENTITY_ENTRY_INPUTS.map((entity) => {
     const parsed = EntitySchema.parse(entity);
     return [parsed.id, parsed];
@@ -6766,7 +6771,7 @@ var ActionScopeSchema = z.union([
     domain: ModelIdSchema
   })
 ]);
-z.object({
+var ActionRefSchema = z.object({
   actionId: ActionIdSchema.meta({ ref: "action" }),
   intent: z.enum(["exposes", "consumes"]).meta({ label: "Intent" })
 });
@@ -6810,7 +6815,7 @@ var ActionSchema = z.object({
   knowledge: z.array(ModelIdSchema.meta({ ref: "knowledge" })).default([]).optional(),
   lifecycle: z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" }).default("active")
 });
-z.record(z.string(), ActionSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+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 LEAD_GEN_ACTION_ENTRY_INPUTS = [
@@ -6940,6 +6945,99 @@ var LEAD_GEN_ACTION_ENTRIES = Object.fromEntries(
     return [parsed.id, parsed];
   })
 );
+var CRM_ACTION_ENTRY_INPUTS = [
+  {
+    id: "send_reply",
+    order: 210,
+    label: "Send Reply",
+    description: "Send a contextual reply for an active CRM deal.",
+    scope: { domain: "sales" },
+    resourceId: "crm-send-reply-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "send_link",
+    order: 220,
+    label: "Send Booking Link",
+    description: "Send a booking link to move a deal toward a scheduled call.",
+    scope: { domain: "sales" },
+    resourceId: "crm-send-booking-link-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "send_nudge",
+    order: 230,
+    label: "Send Nudge",
+    description: "Send a follow-up nudge for a stalled CRM deal.",
+    scope: { domain: "sales" },
+    resourceId: "crm-send-nudge-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "rebook",
+    order: 240,
+    label: "Rebook",
+    description: "Rebook a missed or rescheduled CRM appointment.",
+    scope: { domain: "sales" },
+    resourceId: "crm-rebook-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_proposal",
+    order: 250,
+    label: "Move to Proposal",
+    description: "Advance a qualified CRM deal into the proposal stage.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_proposal-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_closing",
+    order: 260,
+    label: "Move to Closing",
+    description: "Advance a proposal-stage CRM deal into closing.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_closing-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_closed_won",
+    order: 270,
+    label: "Close Won",
+    description: "Mark a CRM deal as closed won.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_closed_won-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_closed_lost",
+    order: 280,
+    label: "Close Lost",
+    description: "Mark a CRM deal as closed lost.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_closed_lost-workflow",
+    affects: ["crm.deal"]
+  },
+  {
+    id: "move_to_nurturing",
+    order: 290,
+    label: "Move to Nurturing",
+    description: "Move a CRM deal into nurturing for future follow-up.",
+    scope: { domain: "sales" },
+    resourceId: "move_to_nurturing-workflow",
+    affects: ["crm.deal"]
+  }
+];
+var CRM_ACTION_ENTRIES = Object.fromEntries(
+  CRM_ACTION_ENTRY_INPUTS.map((action) => {
+    const parsed = ActionSchema.parse(action);
+    return [parsed.id, parsed];
+  })
+);
+var DEFAULT_ORGANIZATION_MODEL_ACTIONS = {
+  ...LEAD_GEN_ACTION_ENTRIES,
+  ...CRM_ACTION_ENTRIES
+};
 
 // ../core/src/organization-model/domains/prospecting.ts
 DisplayMetadataSchema.extend({
@@ -7078,7 +7176,7 @@ var DTC_RECORD_COLUMNS = {
     ]
   }
 };
-var ACTION_REGISTRY = Object.values(LEAD_GEN_ACTION_ENTRIES);
+Object.values(LEAD_GEN_ACTION_ENTRIES);
 var PROSPECTING_STEPS = {
   localServices: {
     sourceCompanies: {
@@ -7287,223 +7385,3088 @@ var PROSPECTING_STEPS = {
       recordColumns: DTC_RECORD_COLUMNS.uploaded,
       credentialRequirements: [
         {
-          key: "clickup",
-          provider: "clickup",
-          credentialType: "api-key-secret",
-          label: "ClickUp API token",
-          required: true,
-          selectionMode: "single",
-          inputPath: "clickupCredential",
-          verifyOnRun: true
+          key: "clickup",
+          provider: "clickup",
+          credentialType: "api-key-secret",
+          label: "ClickUp API token",
+          required: true,
+          selectionMode: "single",
+          inputPath: "clickupCredential",
+          verifyOnRun: true
+        }
+      ]
+    }
+  }
+};
+
+// ../core/src/business/acquisition/build-templates.ts
+var BUILD_TEMPLATE_CATALOG = [
+  {
+    id: "local-services",
+    label: "Local Services",
+    description: "Source, analyze, qualify, and personalize local service businesses for outreach.",
+    steps: Object.values(PROSPECTING_STEPS.localServices)
+  },
+  {
+    id: "dtc-subscription-apollo-clickup",
+    label: "DTC Subscription (Apollo + ClickUp)",
+    description: "Import DTC brand leads from Apollo, crawl their websites, score fit, enrich contacts, and export via ClickUp.",
+    steps: Object.values(PROSPECTING_STEPS.dtcApolloClickup)
+  }
+];
+var PROSPECTING_BUILD_TEMPLATE_OPTIONS = BUILD_TEMPLATE_CATALOG.map(({ id, label, description }) => ({
+  id,
+  label,
+  description
+}));
+function isProspectingBuildTemplateId(value) {
+  return PROSPECTING_BUILD_TEMPLATE_OPTIONS.some((template) => template.id === value);
+}
+
+// ../core/src/organization-model/catalogs/lead-gen.ts
+var LEAD_GEN_STAGE_CATALOG = {
+  // Prospecting - company population
+  scraped: {
+    key: "scraped",
+    label: "Scraped",
+    description: "Company was scraped from a source directory (Apify actor run).",
+    order: 1,
+    entity: "company"
+  },
+  populated: {
+    key: "populated",
+    label: "Companies found",
+    description: "Companies have been found and added to the lead-gen list.",
+    order: 2,
+    entity: "company"
+  },
+  crawled: {
+    key: "crawled",
+    label: "Websites crawled",
+    description: "Company websites have been crawled (e.g. via Apify) and raw page content stored for downstream LLM analysis.",
+    order: 2.5,
+    entity: "company"
+  },
+  extracted: {
+    key: "extracted",
+    label: "Websites analyzed",
+    description: "Company websites have been analyzed for business signals.",
+    order: 3,
+    entity: "company"
+  },
+  enriched: {
+    key: "enriched",
+    label: "Enriched",
+    description: "Company or contact enriched with third-party data (e.g. Tomba, Anymailfinder).",
+    order: 4,
+    entity: "company"
+  },
+  "decision-makers-enriched": {
+    key: "decision-makers-enriched",
+    label: "Decision-makers found",
+    description: "Decision-maker contacts discovered and attached to a qualified company.",
+    order: 6,
+    entity: "company",
+    recordEntity: "contact",
+    recordStageKey: "discovered"
+  },
+  // Prospecting - contact discovery
+  discovered: {
+    key: "discovered",
+    label: "Decision-makers found",
+    description: "Decision-maker contact details have been found.",
+    order: 5,
+    entity: "contact"
+  },
+  verified: {
+    key: "verified",
+    label: "Emails verified",
+    description: "Contact email addresses have been checked for deliverability.",
+    order: 7,
+    entity: "contact"
+  },
+  // Qualification
+  qualified: {
+    key: "qualified",
+    label: "Companies qualified",
+    description: "Companies have been scored against the qualification criteria.",
+    order: 8,
+    entity: "company"
+  },
+  // Outreach
+  personalized: {
+    key: "personalized",
+    label: "Personalized",
+    description: "Outreach message personalized for the contact (Instantly personalization workflow).",
+    order: 9,
+    entity: "contact"
+  },
+  uploaded: {
+    key: "uploaded",
+    label: "Reviewed and exported",
+    description: "Approved records have been reviewed and exported for handoff.",
+    order: 10,
+    entity: "company",
+    additionalEntities: ["contact"]
+  },
+  interested: {
+    key: "interested",
+    label: "Interested",
+    description: "Contact replied with a positive signal (Instantly reply-handler transition).",
+    order: 11,
+    entity: "contact"
+  }
+};
+
+// ../core/src/organization-model/domains/sales.ts
+var SalesStageSemanticClassSchema = z.enum(["open", "active", "nurturing", "closed_won", "closed_lost"]);
+var SalesStageSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: z.number().int().min(0),
+  semanticClass: SalesStageSemanticClassSchema,
+  surfaceIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema
+});
+z.object({
+  id: ModelIdSchema,
+  label: z.string().trim().min(1).max(120),
+  description: DescriptionSchema.optional(),
+  entityId: ModelIdSchema,
+  stages: z.array(SalesStageSchema).min(1)
+});
+var CRM_DISCOVERY_REPLIED_STATE = {
+  stateKey: "discovery_replied",
+  label: "Discovery Replied"
+};
+var CRM_DISCOVERY_LINK_SENT_STATE = {
+  stateKey: "discovery_link_sent",
+  label: "Discovery Link Sent"
+};
+var CRM_DISCOVERY_NUDGING_STATE = {
+  stateKey: "discovery_nudging",
+  label: "Discovery Nudging"
+};
+var CRM_DISCOVERY_BOOKING_CANCELLED_STATE = {
+  stateKey: "discovery_booking_cancelled",
+  label: "Discovery Booking Cancelled"
+};
+var CRM_REPLY_SENT_STATE = {
+  stateKey: "reply_sent",
+  label: "Reply Sent"
+};
+var CRM_FOLLOWUP_1_SENT_STATE = {
+  stateKey: "followup_1_sent",
+  label: "Follow-up 1 Sent"
+};
+var CRM_FOLLOWUP_2_SENT_STATE = {
+  stateKey: "followup_2_sent",
+  label: "Follow-up 2 Sent"
+};
+var CRM_FOLLOWUP_3_SENT_STATE = {
+  stateKey: "followup_3_sent",
+  label: "Follow-up 3 Sent"
+};
+var CRM_PIPELINE_DEFINITION = {
+  pipelineKey: "crm",
+  label: "CRM",
+  entityKey: "crm.deal",
+  stages: [
+    {
+      stageKey: "interested",
+      label: "Interested",
+      color: "blue",
+      states: [
+        CRM_DISCOVERY_REPLIED_STATE,
+        CRM_DISCOVERY_LINK_SENT_STATE,
+        CRM_DISCOVERY_NUDGING_STATE,
+        CRM_DISCOVERY_BOOKING_CANCELLED_STATE,
+        CRM_REPLY_SENT_STATE,
+        CRM_FOLLOWUP_1_SENT_STATE,
+        CRM_FOLLOWUP_2_SENT_STATE,
+        CRM_FOLLOWUP_3_SENT_STATE
+      ]
+    },
+    { stageKey: "proposal", label: "Proposal", color: "yellow", states: [] },
+    { stageKey: "closing", label: "Closing", color: "orange", states: [] },
+    { stageKey: "closed_won", label: "Closed Won", color: "green", states: [] },
+    { stageKey: "closed_lost", label: "Closed Lost", color: "red", states: [] },
+    { stageKey: "nurturing", label: "Nurturing", color: "grape", states: [] }
+  ]
+};
+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 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),
+  /** 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 ContentNodeBaseSchema = z.object({
+  /** Human-readable label for the content node. */
+  label: z.string().trim().min(1).max(120).meta({ label: "Label" }),
+  /** Optional one-paragraph description. */
+  description: z.string().trim().min(1).max(2e3).optional().meta({ label: "Description" }),
+  /** Optional display order within the system content map. */
+  order: z.number().int().optional().meta({ label: "Order" }),
+  /**
+   * Local NodeId of the parent content node within the SAME system.
+   * Per B4/L9: MUST resolve to a sibling in the same `system.content` map.
+   * Per L19: parent and child MUST share the same `kind` (meta-category).
+   */
+  parentContentId: z.string().trim().min(1).max(200).optional().meta({ label: "Parent content id" })
+});
+var ContentNodeSchema = ContentNodeBaseSchema.extend({
+  /** Meta-category (e.g. 'schema', 'config', 'knowledge', tenant-defined). */
+  kind: z.string().trim().min(1).max(100).meta({ label: "Kind" }),
+  /** Specific family within the meta-category (e.g. 'pipeline', 'kv'). */
+  type: z.string().trim().min(1).max(100).meta({ label: "Type" }),
+  /** Payload data; validated against registered payloadSchema when (kind, type) is known. */
+  data: z.record(z.string(), z.unknown()).optional().meta({ label: "Data" })
+});
+z.object({
+  /** Meta-category (tenant-defined or registry-shipped). */
+  kind: z.string().trim().min(1).max(100).meta({ label: "Kind" }),
+  /** Specific family within the meta-category. */
+  type: z.string().trim().min(1).max(100).meta({ label: "Type" }),
+  /** Human-readable label shown in the KB tree and describe views. */
+  label: z.string().trim().min(1).max(120).meta({ label: "Label" }),
+  /** Optional description. */
+  description: z.string().trim().min(1).max(2e3).optional().meta({ label: "Description" }),
+  /**
+   * Which KB tree group this extension renders in.
+   * Per L6: 'business-model' places it alongside Customers / Offerings / Goals.
+   */
+  treeGroup: z.union([z.enum(["profile", "business-model", "systems", "graph", "governance-wiring"]), z.string().min(1).max(100)]).meta({ label: "Tree group" }),
+  /** Untyped payload; shape governed by the registered payloadSchema when available. */
+  data: z.record(z.string(), z.unknown()).optional().meta({ label: "Data" })
+});
+var OntologyKindSchema = z.enum([
+  "object",
+  "link",
+  "action",
+  "catalog",
+  "event",
+  "interface",
+  "value-type",
+  "property",
+  "group",
+  "surface"
+]);
+var SYSTEM_PATH_PATTERN = "[a-z0-9][a-z0-9-]*(?:\\.[a-z0-9][a-z0-9-]*)*";
+var LOCAL_ID_PATTERN = "[a-z0-9][a-z0-9._-]*";
+var ONTOLOGY_ID_PATTERN = `^(global|${SYSTEM_PATH_PATTERN}):(${OntologyKindSchema.options.join("|")})\\/(${LOCAL_ID_PATTERN})$`;
+var ONTOLOGY_ID_REGEX = new RegExp(ONTOLOGY_ID_PATTERN);
+var OntologyIdSchema = z.string().trim().min(1).max(300).regex(
+  ONTOLOGY_ID_REGEX,
+  "Ontology IDs must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
+);
+function parseOntologyId(id) {
+  const normalized = OntologyIdSchema.parse(id);
+  const match = ONTOLOGY_ID_REGEX.exec(normalized);
+  if (match === null) {
+    throw new Error(`Invalid ontology ID "${id}"`);
+  }
+  return {
+    id: normalized,
+    scope: match[1],
+    kind: match[2],
+    localId: match[3],
+    isGlobal: match[1] === "global"
+  };
+}
+function formatOntologyId(input) {
+  return OntologyIdSchema.parse(`${input.scope}:${input.kind}/${input.localId}`);
+}
+var OntologyReferenceListSchema = z.array(OntologyIdSchema).default([]).optional();
+var OntologyRecordBaseSchema = z.object({
+  id: OntologyIdSchema,
+  label: z.string().trim().min(1).max(160).optional(),
+  description: z.string().trim().min(1).max(2e3).optional(),
+  ownerSystemId: z.string().trim().min(1).max(200).optional(),
+  aliases: z.array(OntologyIdSchema).optional()
+}).passthrough();
+var OntologyObjectTypeSchema = OntologyRecordBaseSchema.extend({
+  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  storage: z.record(z.string(), z.unknown()).optional()
+});
+var OntologyLinkTypeSchema = OntologyRecordBaseSchema.extend({
+  from: OntologyIdSchema,
+  to: OntologyIdSchema,
+  cardinality: z.string().trim().min(1).max(80).optional(),
+  via: z.string().trim().min(1).max(255).optional()
+});
+var OntologyActionTypeSchema = OntologyRecordBaseSchema.extend({
+  actsOn: OntologyReferenceListSchema,
+  input: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  effects: z.array(z.record(z.string(), z.unknown())).optional()
+});
+var OntologyCatalogTypeSchema = OntologyRecordBaseSchema.extend({
+  kind: z.string().trim().min(1).max(120).optional(),
+  appliesTo: OntologyIdSchema.optional(),
+  entries: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyEventTypeSchema = OntologyRecordBaseSchema.extend({
+  payload: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyInterfaceTypeSchema = OntologyRecordBaseSchema.extend({
+  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyValueTypeSchema = OntologyRecordBaseSchema.extend({
+  primitive: z.string().trim().min(1).max(120).optional()
+});
+var OntologySharedPropertySchema = OntologyRecordBaseSchema.extend({
+  valueType: OntologyIdSchema.optional(),
+  searchable: z.boolean().optional(),
+  pii: z.boolean().optional()
+});
+var OntologyGroupSchema = OntologyRecordBaseSchema.extend({
+  members: OntologyReferenceListSchema
+});
+var OntologySurfaceTypeSchema = OntologyRecordBaseSchema.extend({
+  route: z.string().trim().min(1).max(500).optional()
+});
+var OntologyScopeSchema = z.object({
+  objectTypes: z.record(OntologyIdSchema, OntologyObjectTypeSchema).default({}).optional(),
+  linkTypes: z.record(OntologyIdSchema, OntologyLinkTypeSchema).default({}).optional(),
+  actionTypes: z.record(OntologyIdSchema, OntologyActionTypeSchema).default({}).optional(),
+  catalogTypes: z.record(OntologyIdSchema, OntologyCatalogTypeSchema).default({}).optional(),
+  eventTypes: z.record(OntologyIdSchema, OntologyEventTypeSchema).default({}).optional(),
+  interfaceTypes: z.record(OntologyIdSchema, OntologyInterfaceTypeSchema).default({}).optional(),
+  valueTypes: z.record(OntologyIdSchema, OntologyValueTypeSchema).default({}).optional(),
+  sharedProperties: z.record(OntologyIdSchema, OntologySharedPropertySchema).default({}).optional(),
+  groups: z.record(OntologyIdSchema, OntologyGroupSchema).default({}).optional(),
+  surfaces: z.record(OntologyIdSchema, OntologySurfaceTypeSchema).default({}).optional()
+}).default({});
+var DEFAULT_ONTOLOGY_SCOPE = {
+  valueTypes: {
+    "global:value-type/uuid": {
+      id: "global:value-type/uuid",
+      label: "UUID",
+      primitive: "string"
+    },
+    "global:value-type/text": {
+      id: "global:value-type/text",
+      label: "Text",
+      primitive: "string"
+    },
+    "global:value-type/url": {
+      id: "global:value-type/url",
+      label: "URL",
+      primitive: "string"
+    },
+    "global:value-type/email": {
+      id: "global:value-type/email",
+      label: "Email",
+      primitive: "string"
+    }
+  }
+};
+var SCOPE_KIND = {
+  objectTypes: "object",
+  linkTypes: "link",
+  actionTypes: "action",
+  catalogTypes: "catalog",
+  eventTypes: "event",
+  interfaceTypes: "interface",
+  valueTypes: "value-type",
+  sharedProperties: "property",
+  groups: "group",
+  surfaces: "surface"
+};
+var SCOPE_KEYS = Object.keys(SCOPE_KIND);
+function listResolvedOntologyRecords(index2) {
+  return SCOPE_KEYS.flatMap((scopeKey) => {
+    const kind = SCOPE_KIND[scopeKey];
+    return Object.entries(index2[scopeKey]).sort(([leftId], [rightId]) => leftId.localeCompare(rightId)).map(([id, record]) => ({
+      id,
+      kind,
+      record
+    }));
+  });
+}
+function originFromContext(context) {
+  return {
+    kind: context.kind,
+    source: context.source,
+    path: context.path,
+    ...context.systemPath !== void 0 ? { systemPath: context.systemPath } : {},
+    ...context.legacyId !== void 0 ? { legacyId: context.legacyId } : {}
+  };
+}
+function createEmptyIndex() {
+  return {
+    objectTypes: {},
+    linkTypes: {},
+    actionTypes: {},
+    catalogTypes: {},
+    eventTypes: {},
+    interfaceTypes: {},
+    valueTypes: {},
+    sharedProperties: {},
+    groups: {},
+    surfaces: {}
+  };
+}
+function sortResolvedOntologyIndex(index2) {
+  const sorted = createEmptyIndex();
+  for (const scopeKey of SCOPE_KEYS) {
+    const target = sorted[scopeKey];
+    for (const [id, record] of Object.entries(index2[scopeKey]).sort(
+      ([leftId], [rightId]) => leftId.localeCompare(rightId)
+    )) {
+      target[id] = record;
+    }
+  }
+  return sorted;
+}
+function childSystemsOf(system) {
+  return system.systems ?? system.subsystems ?? {};
+}
+function addRecord(index2, diagnostics, sourcesById, scopeKey, record, context) {
+  let parsed;
+  try {
+    parsed = parseOntologyId(record.id);
+  } catch {
+    diagnostics.push({
+      code: "invalid_ontology_id",
+      message: `Invalid ontology ID "${record.id}" from ${context.source} at ${context.path.join(".")}`,
+      id: record.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context)
+    });
+    return;
+  }
+  const expectedKind = SCOPE_KIND[scopeKey];
+  if (parsed.kind !== expectedKind) {
+    diagnostics.push({
+      code: "ontology_kind_mismatch",
+      message: `Ontology ID "${record.id}" has kind "${parsed.kind}" but was authored in ${scopeKey} (${expectedKind}) at ${context.path.join(".")}`,
+      id: record.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context)
+    });
+    return;
+  }
+  const existing = sourcesById.get(parsed.id);
+  if (existing !== void 0) {
+    diagnostics.push({
+      code: "duplicate_ontology_id",
+      message: `Duplicate ontology ID "${parsed.id}" from ${context.source} at ${context.path.join(".")} conflicts with ${existing.source} at ${existing.path.join(".")}`,
+      id: parsed.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context),
+      existingSource: existing.source,
+      existingOrigin: originFromContext(existing)
+    });
+    return;
+  }
+  sourcesById.set(parsed.id, context);
+  index2[scopeKey][parsed.id] = {
+    ...record,
+    origin: originFromContext(context)
+  };
+}
+function addScope(index2, diagnostics, sourcesById, scope, source, path) {
+  if (scope === void 0) return;
+  for (const scopeKey of SCOPE_KEYS) {
+    const records = scope[scopeKey] ?? {};
+    for (const [key, record] of Object.entries(records)) {
+      addRecord(index2, diagnostics, sourcesById, scopeKey, record, {
+        source,
+        path: [...path, scopeKey, key],
+        kind: "authored",
+        systemPath: source.startsWith("system:") ? source.slice("system:".length, -".ontology".length) : void 0
+      });
+    }
+  }
+}
+function legacyObjectId(entity) {
+  return formatOntologyId({ scope: entity.ownedBySystemId, kind: "object", localId: entity.id });
+}
+function legacyActionOwner(action, entities) {
+  const firstAffectedEntityId = action.affects?.find((entityId) => entities[entityId] !== void 0);
+  if (firstAffectedEntityId !== void 0) {
+    return entities[firstAffectedEntityId].ownedBySystemId;
+  }
+  if (typeof action.scope === "object") {
+    return action.scope.domain;
+  }
+  return "global";
+}
+function addLegacyEntityProjections(index2, diagnostics, sourcesById, entities) {
+  for (const entity of Object.values(entities)) {
+    const objectType = {
+      id: legacyObjectId(entity),
+      label: entity.label,
+      description: entity.description,
+      ownerSystemId: entity.ownedBySystemId,
+      ...entity.table !== void 0 ? {
+        storage: {
+          kind: "table",
+          table: entity.table
+        }
+      } : {},
+      legacyEntityId: entity.id,
+      ...entity.rowSchema !== void 0 ? { rowSchema: entity.rowSchema } : {},
+      ...entity.stateCatalogId !== void 0 ? { stateCatalogId: entity.stateCatalogId } : {}
+    };
+    addRecord(index2, diagnostics, sourcesById, "objectTypes", objectType, {
+      source: "legacy.entities",
+      path: ["entities", entity.id],
+      kind: "projected",
+      systemPath: entity.ownedBySystemId,
+      legacyId: entity.id
+    });
+    entity.links?.forEach((link, linkIndex) => {
+      const targetEntity = entities[link.toEntity];
+      if (targetEntity === void 0) return;
+      const linkType = {
+        id: formatOntologyId({
+          scope: entity.ownedBySystemId,
+          kind: "link",
+          localId: `${entity.id}-${link.toEntity}-${linkIndex}`
+        }),
+        label: link.label ?? link.kind,
+        ownerSystemId: entity.ownedBySystemId,
+        from: legacyObjectId(entity),
+        to: legacyObjectId(targetEntity),
+        cardinality: link.kind,
+        ...link.via !== void 0 ? { via: link.via } : {},
+        legacyEntityId: entity.id
+      };
+      addRecord(index2, diagnostics, sourcesById, "linkTypes", linkType, {
+        source: "legacy.entities.links",
+        path: ["entities", entity.id, "links", linkIndex],
+        kind: "projected",
+        systemPath: entity.ownedBySystemId,
+        legacyId: `${entity.id}.links.${linkIndex}`
+      });
+    });
+  }
+}
+function addLegacyActionProjections(index2, diagnostics, sourcesById, actions, entities) {
+  for (const action of Object.values(actions)) {
+    const ownerSystemId = legacyActionOwner(action, entities);
+    const actionType = {
+      id: formatOntologyId({ scope: ownerSystemId, kind: "action", localId: action.id }),
+      label: action.label,
+      description: action.description,
+      ownerSystemId,
+      actsOn: action.affects?.map((entityId) => entities[entityId] ? legacyObjectId(entities[entityId]) : void 0).filter((id) => id !== void 0),
+      ...action.resourceId !== void 0 ? { resourceId: action.resourceId } : {},
+      ...action.invocations !== void 0 ? { invocations: action.invocations } : {},
+      ...action.lifecycle !== void 0 ? { lifecycle: action.lifecycle } : {},
+      legacyActionId: action.id
+    };
+    addRecord(index2, diagnostics, sourcesById, "actionTypes", actionType, {
+      source: "legacy.actions",
+      path: ["actions", action.id],
+      kind: "projected",
+      systemPath: ownerSystemId,
+      legacyId: action.id
+    });
+  }
+}
+function addSystemContentProjections(index2, diagnostics, sourcesById, systemPath, system, schemaPath) {
+  const content = system.content ?? {};
+  for (const [localId, node] of Object.entries(content)) {
+    if (node.kind !== "schema") continue;
+    const entries = Object.fromEntries(
+      Object.entries(content).filter(([, candidate]) => candidate.parentContentId === localId).map(([entryId, candidate]) => [
+        entryId,
+        {
+          label: candidate.label ?? entryId,
+          type: candidate.type,
+          ...candidate.description !== void 0 ? { description: candidate.description } : {},
+          ...candidate.data !== void 0 ? candidate.data : {}
+        }
+      ])
+    );
+    const catalogType = {
+      id: formatOntologyId({ scope: systemPath, kind: "catalog", localId }),
+      label: node.label ?? localId,
+      description: node.description,
+      ownerSystemId: systemPath,
+      kind: node.type,
+      ...typeof node.data?.["entityId"] === "string" ? { appliesTo: formatOntologyId({ scope: systemPath, kind: "object", localId: node.data["entityId"] }) } : {},
+      ...Object.keys(entries).length > 0 ? { entries } : {},
+      ...node.data !== void 0 ? { data: node.data } : {},
+      legacyContentId: `${systemPath}:${localId}`
+    };
+    addRecord(index2, diagnostics, sourcesById, "catalogTypes", catalogType, {
+      source: "legacy.system.content",
+      path: [...schemaPath, "content", localId],
+      kind: "projected",
+      systemPath,
+      legacyId: `${systemPath}:${localId}`
+    });
+  }
+}
+function addSystemScopes(index2, diagnostics, sourcesById, systems, prefix, schemaPath) {
+  for (const [key, system] of Object.entries(systems)) {
+    const systemPath = prefix ? `${prefix}.${key}` : key;
+    const currentPath = [...schemaPath, key];
+    addScope(index2, diagnostics, sourcesById, system.ontology, `system:${systemPath}.ontology`, [
+      ...currentPath,
+      "ontology"
+    ]);
+    addSystemContentProjections(index2, diagnostics, sourcesById, systemPath, system, currentPath);
+    addSystemScopes(index2, diagnostics, sourcesById, childSystemsOf(system), systemPath, [
+      ...currentPath,
+      system.systems !== void 0 ? "systems" : "subsystems"
+    ]);
+  }
+}
+function compileOrganizationOntology(model) {
+  const ontology = createEmptyIndex();
+  const diagnostics = [];
+  const sourcesById = /* @__PURE__ */ new Map();
+  addScope(ontology, diagnostics, sourcesById, model.ontology, "organization.ontology", ["ontology"]);
+  addSystemScopes(ontology, diagnostics, sourcesById, model.systems ?? {}, "", ["systems"]);
+  addLegacyEntityProjections(ontology, diagnostics, sourcesById, model.entities ?? {});
+  addLegacyActionProjections(ontology, diagnostics, sourcesById, model.actions ?? {}, model.entities ?? {});
+  return { ontology: sortResolvedOntologyIndex(ontology), diagnostics };
+}
+
+// ../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 content-node:sales.crm:pipeline-id)"
+);
+var SystemUiSchema = z.object({
+  path: PathSchema,
+  surfaces: ReferenceIdsSchema,
+  icon: IconNameSchema.optional(),
+  order: z.number().int().optional()
+});
+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(),
+  /** @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(),
+  /**
+   * @deprecated Compatibility-only bridge for old tenant content nodes and
+   * migration readers. New schema/catalog authoring belongs in ontology;
+   * new system-local settings belong in config. Bridge nodes are keyed by
+   * local NodeId and may still project to content-node:* graph IDs.
+   */
+  content: z.record(z.string().trim().min(1).max(200), ContentNodeSchema).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()
+}).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
+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({
+  implements: z.array(OntologyIdSchema).optional(),
+  reads: z.array(OntologyIdSchema).optional(),
+  writes: z.array(OntologyIdSchema).optional(),
+  usesCatalogs: z.array(OntologyIdSchema).optional(),
+  emits: z.array(OntologyIdSchema).optional()
+});
+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" }),
+  /** 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"),
+  /** Mirrors WorkflowConfig.actionKey when the runtime workflow has one. */
+  actionKey: z.string().trim().min(1).max(255).optional(),
+  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 = {};
+
+// ../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 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 = {};
+
+// ../core/src/organization-model/content-kinds/registry.ts
+function defineContentType(def) {
+  return def;
+}
+var PipelinePayloadSchema = z.object({
+  /**
+   * Local NodeId of the entity this pipeline applies to (e.g. 'crm.deal').
+   * `.meta({ ref: 'entity' })` enables SchemaDrivenFieldList to render a
+   * clickable graph link to the referenced entity node.
+   */
+  entityId: z.string().trim().min(1).max(200).meta({ label: "Entity", ref: "entity", hint: "The entity type this pipeline tracks" }),
+  /**
+   * Optional Kanban column color token for UI rendering.
+   */
+  kanbanColor: z.string().trim().min(1).max(40).optional().meta({ label: "Kanban color", hint: "UI color token" })
+});
+var pipelineKind = defineContentType({
+  kind: "schema",
+  type: "pipeline",
+  label: "Pipeline",
+  description: "A named progression pipeline that applies to a specific entity type.",
+  payloadSchema: PipelinePayloadSchema,
+  parentTypes: []
+});
+var StagePayloadSchema = z.object({
+  /**
+   * Semantic classification for this stage.
+   * Drives color, icon, and CRM-priority logic in consuming views.
+   * Optional — prospecting stages use data.entityKind instead.
+   * Enum aligned with SalesStageSemanticClassSchema (sales.ts).
+   */
+  semanticClass: z.enum(["open", "active", "nurturing", "closed_won", "closed_lost", "won", "lost", "closed"]).optional().meta({ label: "Semantic class", hint: "Semantic meaning of this stage", color: "blue" })
+});
+var stageKind = defineContentType({
+  kind: "schema",
+  type: "stage",
+  label: "Stage",
+  description: "A stage within a pipeline. Must be parented under a schema:pipeline content node.",
+  payloadSchema: StagePayloadSchema,
+  parentTypes: ["schema:pipeline"]
+});
+var TemplatePayloadSchema = z.object({
+  /**
+   * Optional description surfaced in the KB describe view and tooling.
+   */
+  description: z.string().trim().min(1).max(2e3).optional().meta({ label: "Description", hint: "What this template is used for" })
+});
+var templateKind = defineContentType({
+  kind: "schema",
+  type: "template",
+  label: "Template",
+  description: "A named build template (e.g. a prospecting pipeline sequence).",
+  payloadSchema: TemplatePayloadSchema,
+  parentTypes: []
+});
+var TemplateStepPayloadSchema = z.object({
+  /**
+   * Which entity type this step primarily operates on.
+   */
+  primaryEntity: z.enum(["company", "contact"]).meta({ label: "Primary entity", hint: "Entity type this step processes", color: "blue" }),
+  /**
+   * Action key identifying the workflow action executed by this step.
+   * `.meta({ ref: 'action' })` enables SchemaDrivenFieldList to render a
+   * clickable graph link.
+   */
+  actionKey: z.string().trim().min(1).max(200).meta({ label: "Action", ref: "action", hint: "Workflow action executed by this step" }),
+  /**
+   * IDs of sibling step local NodeIds this step depends on.
+   */
+  dependsOn: z.array(z.string().trim().min(1).max(200)).optional().meta({ label: "Depends on", hint: "Local NodeIds of prerequisite steps" })
+});
+var templateStepKind = defineContentType({
+  kind: "schema",
+  type: "template-step",
+  label: "Template Step",
+  description: "A step within a build template. Must be parented under a schema:template content node.",
+  payloadSchema: TemplateStepPayloadSchema,
+  parentTypes: ["schema:template"]
+});
+var StatusFlowPayloadSchema = z.object({
+  /**
+   * Which entity scope this status flow governs.
+   */
+  appliesTo: z.enum(["project", "milestone", "task"]).meta({ label: "Applies to", hint: "Entity scope governed by this status flow", color: "blue" })
+});
+var statusFlowKind = defineContentType({
+  kind: "schema",
+  type: "status-flow",
+  label: "Status Flow",
+  description: "A named set of statuses governing a project, milestone, or task entity.",
+  payloadSchema: StatusFlowPayloadSchema,
+  parentTypes: []
+});
+var StatusPayloadSchema = z.object({
+  /**
+   * Semantic classification string for this status.
+   * Free-form to allow tenant-defined classifications (e.g. 'active', 'blocked',
+   * 'completed'). Used by UI to apply color and icon fallbacks.
+   * Optional — status nodes may omit this when the label is self-descriptive.
+   */
+  semanticClass: z.string().trim().min(1).max(100).optional().meta({ label: "Semantic class", hint: "Semantic meaning of this status (e.g. active, blocked, completed)" }),
+  /**
+   * Optional UI color token override for this status.
+   */
+  color: z.string().trim().min(1).max(40).optional().meta({ label: "Color", hint: "UI color token" })
+});
+var statusKind = defineContentType({
+  kind: "schema",
+  type: "status",
+  label: "Status",
+  description: "A single status within a status flow. Must be parented under a schema:status-flow content node.",
+  payloadSchema: StatusPayloadSchema,
+  parentTypes: ["schema:status-flow"]
+});
+var ConfigKvPayloadSchema = z.object({
+  /**
+   * Flat key-value entries. Values are JSON primitives.
+   * Keys are short identifiers (e.g. 'maxBatchSize', 'featureEnabled').
+   */
+  entries: z.record(z.string().trim().min(1).max(200), z.union([z.string(), z.number(), z.boolean(), z.null()])).meta({ label: "Entries", hint: "Key-value configuration entries (string, number, boolean, or null values)" })
+});
+var configKvKind = defineContentType({
+  kind: "config",
+  type: "kv",
+  label: "Key-Value Config",
+  description: "A flat key-value configuration store co-located with a system. Values are JSON primitives.",
+  payloadSchema: ConfigKvPayloadSchema,
+  parentTypes: []
+});
+
+// ../core/src/organization-model/content-kinds/index.ts
+var CONTENT_KIND_REGISTRY = {
+  "schema:pipeline": pipelineKind,
+  "schema:stage": stageKind,
+  "schema:template": templateKind,
+  "schema:template-step": templateStepKind,
+  "schema:status-flow": statusFlowKind,
+  "schema:status": statusKind,
+  "config:kv": configKvKind
+};
+function lookupContentType(kind, type3) {
+  const key = `${kind}:${type3}`;
+  return CONTENT_KIND_REGISTRY[key];
+}
+var SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]).meta({ label: "Surface type", color: "blue" });
+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 OrganizationModelNavigationSchema = z.object({
+  sidebar: SidebarNavigationSchema
+}).default({ sidebar: { primary: {}, bottom: {} } });
+z.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  placement: z.string().trim().min(1).max(50),
+  surfaceIds: z.array(ModelIdSchema.meta({ ref: "surface" })).default([])
+});
+var KnowledgeTargetKindSchema = z.enum([
+  "system",
+  "resource",
+  "knowledge",
+  "stage",
+  "action",
+  "role",
+  "goal",
+  "customer-segment",
+  "offering",
+  "ontology",
+  // D4: content nodes are a valid knowledge target after compound-domain data moved into system.content
+  "content-node"
+]).meta({ label: "Target kind" });
+var KnowledgeTargetRefSchema = z.object({
+  kind: KnowledgeTargetKindSchema,
+  // D4: content-node targets use a qualified id format '<system-path>:<local-content-id>'.
+  // 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])])
+});
+var CanonicalKnowledgeLinkSchema = z.object({
+  target: KnowledgeTargetRefSchema
+});
+function nodeIdFromTarget(target) {
+  return `${target.kind}:${target.id}`;
+}
+function targetFromNodeId(nodeId) {
+  const [kind, ...idParts] = nodeId.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({});
+
+// ../core/src/organization-model/schema.ts
+z.enum([
+  "branding",
+  "identity",
+  "customers",
+  "offerings",
+  "roles",
+  "goals",
+  "systems",
+  "ontology",
+  "resources",
+  "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" },
+  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,
+  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,
+  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),
+  actions: ActionsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ACTIONS),
+  entities: EntitiesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ENTITIES),
+  policies: PoliciesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_POLICIES),
+  // D3: flat Record<id, OrgKnowledgeNode> — no wrapper object
+  knowledge: KnowledgeDomainSchema.default({})
+});
+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);
+}
+OrganizationModelSchemaBase.superRefine((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 normalizeRoutePath(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(([nodeId, node]) => {
+      const nodePath = [...schemaPath, nodeId];
+      const existingNodePath = sidebarNodeIds.get(nodeId);
+      if (existingNodePath !== void 0) {
+        addIssue(ctx, nodePath, `Sidebar node id "${nodeId}" duplicates another sidebar node`);
+      } else {
+        sidebarNodeIds.set(nodeId, nodePath);
+      }
+      if (node.type === "group") {
+        collectSidebarNodes(node.children, [...nodePath, "children"]);
+        return;
+      }
+      sidebarSurfaces.push({ id: nodeId, node, path: nodePath });
+      const normalizedPath = normalizeRoutePath(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, nodeId);
+      }
+      node.targets?.systems?.forEach((systemId, systemIndex) => {
+        if (!systemsById.has(systemId)) {
+          addIssue(
+            ctx,
+            [...nodePath, "targets", "systems", systemIndex],
+            `Sidebar surface "${nodeId}" 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.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((nodeId, nodeIndex) => {
+      if (!knowledgeById.has(nodeId)) {
+        addIssue(
+          ctx,
+          [...schemaPath, "governedByKnowledge", nodeIndex],
+          `System "${system.id}" references unknown knowledge node "${nodeId}"`
+        );
+      }
+    });
+    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 stageIds = /* @__PURE__ */ new Set();
+  const actionIds = new Set(Object.keys(model.actions));
+  const offeringsById = new Map(Object.entries(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((index2) => Object.keys(index2)));
+  const ontologyReferenceKeyKinds = {
+    valueType: "value-type",
+    catalogType: "catalog",
+    objectType: "object",
+    eventType: "event",
+    actionType: "action",
+    linkType: "link",
+    interfaceType: "interface",
+    propertyType: "property",
+    groupType: "group",
+    surfaceType: "surface",
+    stepCatalog: "catalog"
+  };
+  function validateKnownOntologyReferences(ownerId, value, path, seen = /* @__PURE__ */ new WeakSet()) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index2) => validateKnownOntologyReferences(ownerId, entry, [...path, index2], seen));
+      return;
+    }
+    if (!isRecord(value)) return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    Object.entries(value).forEach(([key, entry]) => {
+      const expectedKind = ontologyReferenceKeyKinds[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}"`
+      );
+    }
+  });
+  function knowledgeTargetExists(kind, id) {
+    if (kind === "system") return systemsById.has(id);
+    if (kind === "resource") return resourcesById.has(id);
+    if (kind === "knowledge") return knowledgeById.has(id);
+    if (kind === "stage") return stageIds.has(id);
+    if (kind === "action") return actionIds.has(id);
+    if (kind === "role") return rolesById.has(id);
+    if (kind === "goal") return goalsById.has(id);
+    if (kind === "customer-segment") return segmentsById.has(id);
+    if (kind === "offering") return offeringsById.has(id);
+    if (kind === "ontology") return ontologyIds.has(id);
+    return false;
+  }
+  Object.entries(model.knowledge).forEach(([nodeId, node]) => {
+    node.links.forEach((link, linkIndex) => {
+      if (!knowledgeTargetExists(link.target.kind, link.target.id)) {
+        addIssue(
+          ctx,
+          ["knowledge", nodeId, "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", nodeId, "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}"`
+      );
+    }
+  });
+  function validateResourceOntologyBinding(resourceId, bindingKey, expectedKind, ids) {
+    ids?.forEach((ontologyId, ontologyIndex) => {
+      if (ontologyIndexByKind[expectedKind][ontologyId] === void 0) {
+        addIssue(
+          ctx,
+          ["resources", resourceId, "ontology", bindingKey, 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, "implements", "action", binding.implements);
+    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);
+  });
+  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(([nodeId, node]) => {
+    node.ownerIds.forEach((roleId, ownerIndex) => {
+      if (!rolesById.has(roleId)) {
+        addIssue(
+          ctx,
+          ["knowledge", nodeId, "ownerIds", ownerIndex],
+          `Knowledge node "${node.id}" references unknown owner role "${roleId}"`
+        );
+      }
+    });
+  });
+  function validateSystemContent(system, systemPath) {
+    const childSystems = system.systems ?? system.subsystems;
+    const childKey = system.systems !== void 0 ? "systems" : "subsystems";
+    const content = system.content;
+    if (content === void 0 || Object.keys(content).length === 0) {
+      if (childSystems !== void 0) {
+        Object.entries(childSystems).forEach(([childLocalId, child]) => {
+          validateSystemContent(child, [...systemPath, childKey, childLocalId]);
+        });
+      }
+      return;
+    }
+    Object.entries(content).forEach(([localId, node]) => {
+      if (node.parentContentId !== void 0 && !(node.parentContentId in content)) {
+        addIssue(
+          ctx,
+          [...systemPath, "content", localId, "parentContentId"],
+          `Content node "${localId}" parentContentId "${node.parentContentId}" does not resolve within the same system`
+        );
+      }
+    });
+    Object.entries(content).forEach(([localId, node]) => {
+      const visited = /* @__PURE__ */ new Set();
+      let currentId = node.parentContentId;
+      while (currentId !== void 0) {
+        if (currentId === localId || visited.has(currentId)) {
+          addIssue(
+            ctx,
+            [...systemPath, "content", localId, "parentContentId"],
+            `Content node "${localId}" has a parentContentId cycle`
+          );
+          break;
+        }
+        visited.add(currentId);
+        currentId = content[currentId]?.parentContentId;
+      }
+    });
+    Object.entries(content).forEach(([localId, node]) => {
+      const childDef = lookupContentType(node.kind, node.type);
+      if (childDef !== void 0 && node.data !== void 0) {
+        const result = childDef.payloadSchema.safeParse(node.data);
+        if (!result.success) {
+          addIssue(
+            ctx,
+            [...systemPath, "content", localId, "data"],
+            `Content node "${localId}" (${node.kind}:${node.type}) data failed payload validation: ${result.error.message}`
+          );
+        }
+      }
+      if (node.parentContentId !== void 0 && childDef !== void 0) {
+        const parentNode = content[node.parentContentId];
+        if (parentNode !== void 0) {
+          const parentDef = lookupContentType(parentNode.kind, parentNode.type);
+          if (parentDef !== void 0 && childDef.kind !== parentDef.kind) {
+            addIssue(
+              ctx,
+              [...systemPath, "content", localId, "parentContentId"],
+              `Content node "${localId}" kind "${childDef.kind}" cannot parent under "${node.parentContentId}" kind "${parentDef.kind}": parentContentId must be same-meta-kind (per L19)`
+            );
+          }
+        }
+      }
+    });
+    if (childSystems !== void 0) {
+      Object.entries(childSystems).forEach(([childLocalId, child]) => {
+        validateSystemContent(child, [...systemPath, childKey, childLocalId]);
+      });
+    }
+  }
+  Object.entries(model.systems).forEach(([systemKey, system]) => {
+    validateSystemContent(system, ["systems", systemKey]);
+  });
+  for (const diagnostic of ontologyCompilation.diagnostics) {
+    addIssue(ctx, diagnostic.path, diagnostic.message);
+  }
+});
+
+// ../core/src/organization-model/defaults.ts
+var DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE = {};
+var DEFAULT_ORGANIZATION_MODEL_ENTITIES2 = DEFAULT_ORGANIZATION_MODEL_ENTITIES;
+var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
+  sidebar: {
+    primary: {
+      dashboard: {
+        type: "surface",
+        label: "Dashboard",
+        path: "/",
+        surfaceType: "dashboard",
+        icon: "dashboard",
+        order: 10,
+        targets: { systems: ["dashboard"] }
+      },
+      business: {
+        type: "group",
+        label: "Business",
+        icon: "business",
+        order: 20,
+        children: {
+          sales: {
+            type: "surface",
+            label: "Sales",
+            path: "/sales",
+            surfaceType: "page",
+            icon: "sales",
+            order: 10,
+            targets: { systems: ["sales"] }
+          },
+          clients: {
+            type: "surface",
+            label: "Clients",
+            path: "/clients",
+            surfaceType: "list",
+            icon: "projects",
+            order: 20,
+            targets: { systems: ["clients"] }
+          },
+          projects: {
+            type: "surface",
+            label: "Projects",
+            path: "/projects",
+            surfaceType: "page",
+            icon: "projects",
+            order: 30,
+            targets: { systems: ["projects"] }
+          }
+        }
+      },
+      operations: {
+        type: "group",
+        label: "Operations",
+        icon: "operations",
+        order: 30,
+        children: {
+          "operations-overview": {
+            type: "surface",
+            label: "Overview",
+            path: "/operations",
+            surfaceType: "page",
+            order: 10,
+            targets: { systems: ["operations.overview"] }
+          },
+          "operations-systems": {
+            type: "surface",
+            label: "Systems",
+            path: "/operations/systems",
+            surfaceType: "page",
+            order: 20,
+            targets: { systems: ["operations"] }
+          },
+          "operations-resources": {
+            type: "surface",
+            label: "Resources",
+            path: "/operations/resources",
+            surfaceType: "list",
+            order: 30,
+            targets: { systems: ["operations.resources"] }
+          },
+          "operations-command-queue": {
+            type: "surface",
+            label: "Command Queue",
+            path: "/operations/command-queue",
+            surfaceType: "list",
+            order: 40,
+            targets: { systems: ["operations.command-queue"] }
+          },
+          "operations-task-scheduler": {
+            type: "surface",
+            label: "Task Scheduler",
+            path: "/operations/task-scheduler",
+            surfaceType: "list",
+            order: 50,
+            targets: { systems: ["operations.task-scheduler"] }
+          }
+        }
+      },
+      monitoring: {
+        type: "group",
+        label: "Monitoring",
+        icon: "monitoring",
+        order: 40,
+        children: {
+          "monitoring-overview": {
+            type: "surface",
+            label: "Overview",
+            path: "/monitoring",
+            surfaceType: "page",
+            order: 10,
+            targets: { systems: ["monitoring"] }
+          },
+          "monitoring-calendar": {
+            type: "surface",
+            label: "Calendar",
+            path: "/monitoring/calendar",
+            surfaceType: "page",
+            order: 20,
+            targets: { systems: ["monitoring.calendar"] }
+          },
+          "monitoring-activity-log": {
+            type: "surface",
+            label: "Activity Log",
+            path: "/monitoring/activity-log",
+            surfaceType: "list",
+            order: 30,
+            targets: { systems: ["monitoring.activity-log"] }
+          },
+          "monitoring-execution-logs": {
+            type: "surface",
+            label: "Execution Logs",
+            path: "/monitoring/execution-logs",
+            surfaceType: "list",
+            order: 40,
+            targets: { systems: ["monitoring.execution-logs"] }
+          },
+          "monitoring-execution-health": {
+            type: "surface",
+            label: "Execution Health",
+            path: "/monitoring/execution-health",
+            surfaceType: "dashboard",
+            order: 50,
+            targets: { systems: ["monitoring.execution-health"] }
+          },
+          "monitoring-notifications": {
+            type: "surface",
+            label: "Notifications",
+            path: "/monitoring/notifications",
+            surfaceType: "list",
+            order: 60,
+            targets: { systems: ["monitoring.notifications"] }
+          },
+          "monitoring-requests": {
+            type: "surface",
+            label: "Requests",
+            path: "/monitoring/requests",
+            surfaceType: "list",
+            order: 70,
+            targets: { systems: ["monitoring.submitted-requests"] }
+          }
+        }
+      },
+      knowledge: {
+        type: "surface",
+        label: "Knowledge Base",
+        path: "/knowledge",
+        surfaceType: "page",
+        icon: "knowledge",
+        order: 50
+      }
+    },
+    bottom: {
+      settings: {
+        type: "group",
+        label: "Settings",
+        icon: "settings",
+        order: 10,
+        children: {
+          "settings-account": {
+            type: "surface",
+            label: "Account",
+            path: "/settings/account",
+            surfaceType: "settings",
+            order: 10,
+            targets: { systems: ["settings.account"] }
+          },
+          "settings-appearance": {
+            type: "surface",
+            label: "Appearance",
+            path: "/settings/appearance",
+            surfaceType: "settings",
+            order: 20,
+            targets: { systems: ["settings.appearance"] }
+          },
+          "settings-roles": {
+            type: "surface",
+            label: "My Roles",
+            path: "/settings/roles",
+            surfaceType: "settings",
+            order: 30,
+            targets: { systems: ["settings.roles"] }
+          },
+          "settings-organization": {
+            type: "surface",
+            label: "Organization",
+            path: "/settings/organization",
+            surfaceType: "settings",
+            order: 40,
+            targets: { systems: ["settings.organization"] }
+          },
+          "settings-credentials": {
+            type: "surface",
+            label: "Credentials",
+            path: "/settings/credentials",
+            surfaceType: "settings",
+            order: 50,
+            targets: { systems: ["settings.credentials"] }
+          },
+          "settings-api-keys": {
+            type: "surface",
+            label: "API Keys",
+            path: "/settings/api-keys",
+            surfaceType: "settings",
+            order: 60,
+            targets: { systems: ["settings.api-keys"] }
+          },
+          "settings-webhooks": {
+            type: "surface",
+            label: "Webhooks",
+            path: "/settings/webhooks",
+            surfaceType: "settings",
+            order: 70,
+            targets: { systems: ["settings.webhooks"] }
+          },
+          "settings-deployments": {
+            type: "surface",
+            label: "Deployments",
+            path: "/settings/deployments",
+            surfaceType: "settings",
+            order: 80,
+            targets: { systems: ["settings.deployments"] }
+          }
+        }
+      },
+      admin: {
+        type: "group",
+        label: "Admin",
+        icon: "admin",
+        order: 20,
+        children: {
+          "admin-dashboard": {
+            type: "surface",
+            label: "Dashboard",
+            path: "/admin/dashboard",
+            surfaceType: "dashboard",
+            order: 10,
+            targets: { systems: ["admin"] },
+            requiresAdmin: true
+          },
+          "admin-system-health": {
+            type: "surface",
+            label: "System Health",
+            path: "/admin/system-health",
+            surfaceType: "dashboard",
+            order: 20,
+            targets: { systems: ["admin.system-health"] },
+            requiresAdmin: true
+          },
+          "admin-organizations": {
+            type: "surface",
+            label: "Organizations",
+            path: "/admin/organizations",
+            surfaceType: "list",
+            order: 30,
+            targets: { systems: ["admin.organizations"] },
+            requiresAdmin: true
+          },
+          "admin-users": {
+            type: "surface",
+            label: "Users",
+            path: "/admin/users",
+            surfaceType: "list",
+            order: 40,
+            targets: { systems: ["admin.users"] },
+            requiresAdmin: true
+          },
+          "admin-design-showcase": {
+            type: "surface",
+            label: "Design Showcase",
+            path: "/admin/design-showcase",
+            surfaceType: "page",
+            order: 50,
+            targets: { systems: ["admin.design-showcase"] },
+            requiresAdmin: true
+          },
+          "admin-debug": {
+            type: "surface",
+            label: "Debug",
+            path: "/admin/debug",
+            surfaceType: "page",
+            order: 60,
+            targets: { systems: ["admin.debug"] },
+            requiresAdmin: true
+          }
+        }
+      }
+    }
+  }
+};
+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,
+  systems: {
+    dashboard: {
+      id: "dashboard",
+      order: 10,
+      label: "Dashboard",
+      enabled: true,
+      lifecycle: "active",
+      path: "/",
+      icon: "dashboard"
+    },
+    platform: {
+      id: "platform",
+      order: 30,
+      label: "Platform",
+      description: "Elevasis platform architecture, capabilities, and implementation patterns",
+      enabled: true,
+      lifecycle: "active",
+      color: "cyan",
+      icon: "platform"
+    },
+    finance: {
+      id: "finance",
+      order: 40,
+      label: "Finance",
+      description: "Finance operations, accounting, billing, reconciliation, and tax prep",
+      enabled: true,
+      lifecycle: "active",
+      color: "green",
+      icon: "finance"
+    },
+    sales: {
+      id: "sales",
+      order: 60,
+      label: "Sales",
+      description: "Revenue workflows and customer acquisition",
+      enabled: true,
+      lifecycle: "active",
+      color: "blue",
+      icon: "sales",
+      path: "/sales"
+    },
+    "sales.crm": {
+      id: "sales.crm",
+      order: 70,
+      label: "CRM",
+      description: "Relationship pipeline and deal management",
+      enabled: true,
+      lifecycle: "active",
+      actions: Object.values(CRM_ACTION_ENTRIES).map((action) => ({
+        actionId: action.id,
+        intent: "exposes"
+      })),
+      color: "blue",
+      icon: "crm",
+      path: "/crm"
+    },
+    "sales.lead-gen": {
+      id: "sales.lead-gen",
+      order: 80,
+      label: "Lead Gen",
+      description: "Prospecting, qualification, and outreach preparation",
+      enabled: true,
+      lifecycle: "active",
+      actions: Object.values(LEAD_GEN_ACTION_ENTRIES).map((action) => ({
+        actionId: action.id,
+        intent: "exposes"
+      })),
+      color: "cyan",
+      icon: "lead-gen",
+      path: "/lead-gen"
+    },
+    projects: {
+      id: "projects",
+      order: 90,
+      label: "Projects",
+      description: "Projects, milestones, and client work execution",
+      enabled: true,
+      lifecycle: "active",
+      color: "orange",
+      icon: "projects",
+      path: "/projects"
+    },
+    clients: {
+      id: "clients",
+      order: 100,
+      label: "Clients",
+      description: "Client relationships, accounts, and business context",
+      enabled: true,
+      lifecycle: "active",
+      color: "orange",
+      icon: "projects",
+      path: "/clients"
+    },
+    operations: {
+      id: "operations",
+      order: 110,
+      label: "Operations",
+      description: "Operational resources, topology, and orchestration visibility",
+      enabled: true,
+      lifecycle: "active",
+      color: "violet",
+      icon: "operations"
+    },
+    "knowledge.command-view": {
+      id: "knowledge.command-view",
+      order: 120,
+      label: "Command View",
+      enabled: true,
+      lifecycle: "active",
+      path: "/knowledge/command-view",
+      devOnly: true
+    },
+    "operations.overview": {
+      id: "operations.overview",
+      order: 130,
+      label: "Overview",
+      enabled: true,
+      lifecycle: "active",
+      path: "/operations"
+    },
+    "operations.resources": {
+      id: "operations.resources",
+      order: 140,
+      label: "Resources",
+      enabled: true,
+      lifecycle: "active",
+      path: "/operations/resources"
+    },
+    "operations.command-queue": {
+      id: "operations.command-queue",
+      order: 150,
+      label: "Command Queue",
+      enabled: true,
+      lifecycle: "active",
+      path: "/operations/command-queue"
+    },
+    "operations.sessions": {
+      id: "operations.sessions",
+      order: 160,
+      label: "Sessions",
+      enabled: false,
+      lifecycle: "deprecated",
+      path: "/operations/sessions"
+    },
+    "operations.task-scheduler": {
+      id: "operations.task-scheduler",
+      order: 170,
+      label: "Task Scheduler",
+      enabled: true,
+      lifecycle: "active",
+      path: "/operations/task-scheduler"
+    },
+    monitoring: {
+      id: "monitoring",
+      order: 180,
+      label: "Monitoring",
+      enabled: true,
+      lifecycle: "active"
+    },
+    "monitoring.calendar": {
+      id: "monitoring.calendar",
+      order: 190,
+      label: "Calendar",
+      description: "Google Calendar events and agenda views",
+      enabled: true,
+      lifecycle: "active",
+      path: "/monitoring/calendar",
+      icon: "calendar"
+    },
+    "monitoring.activity-log": {
+      id: "monitoring.activity-log",
+      order: 200,
+      label: "Activity Log",
+      enabled: true,
+      lifecycle: "active",
+      path: "/monitoring/activity-log"
+    },
+    "monitoring.execution-logs": {
+      id: "monitoring.execution-logs",
+      order: 210,
+      label: "Execution Logs",
+      enabled: true,
+      lifecycle: "active",
+      path: "/monitoring/execution-logs"
+    },
+    "monitoring.execution-health": {
+      id: "monitoring.execution-health",
+      order: 220,
+      label: "Execution Health",
+      enabled: true,
+      lifecycle: "active",
+      path: "/monitoring/execution-health"
+    },
+    "monitoring.cost-analytics": {
+      id: "monitoring.cost-analytics",
+      order: 230,
+      label: "Cost Analytics",
+      enabled: false,
+      lifecycle: "deprecated",
+      path: "/monitoring/cost-analytics"
+    },
+    "monitoring.notifications": {
+      id: "monitoring.notifications",
+      order: 240,
+      label: "Notifications",
+      enabled: true,
+      lifecycle: "active",
+      path: "/monitoring/notifications"
+    },
+    "monitoring.submitted-requests": {
+      id: "monitoring.submitted-requests",
+      order: 250,
+      label: "Submitted Requests",
+      enabled: true,
+      lifecycle: "active",
+      path: "/monitoring/requests"
+    },
+    settings: {
+      id: "settings",
+      order: 260,
+      label: "Settings",
+      enabled: true,
+      lifecycle: "active",
+      icon: "settings"
+    },
+    "settings.account": {
+      id: "settings.account",
+      order: 270,
+      label: "Account",
+      enabled: true,
+      lifecycle: "active",
+      path: "/settings/account"
+    },
+    "settings.appearance": {
+      id: "settings.appearance",
+      order: 280,
+      label: "Appearance",
+      enabled: true,
+      lifecycle: "active",
+      path: "/settings/appearance"
+    },
+    "settings.roles": {
+      id: "settings.roles",
+      order: 290,
+      label: "My Roles",
+      enabled: true,
+      lifecycle: "active",
+      path: "/settings/roles"
+    },
+    "settings.organization": {
+      id: "settings.organization",
+      order: 300,
+      label: "Organization",
+      enabled: true,
+      lifecycle: "active",
+      path: "/settings/organization"
+    },
+    "settings.credentials": {
+      id: "settings.credentials",
+      order: 310,
+      label: "Credentials",
+      enabled: true,
+      lifecycle: "active",
+      path: "/settings/credentials"
+    },
+    "settings.api-keys": {
+      id: "settings.api-keys",
+      order: 320,
+      label: "API Keys",
+      enabled: true,
+      lifecycle: "active",
+      path: "/settings/api-keys"
+    },
+    "settings.webhooks": {
+      id: "settings.webhooks",
+      order: 330,
+      label: "Webhooks",
+      enabled: true,
+      lifecycle: "active",
+      path: "/settings/webhooks"
+    },
+    "settings.deployments": {
+      id: "settings.deployments",
+      order: 340,
+      label: "Deployments",
+      enabled: true,
+      lifecycle: "active",
+      path: "/settings/deployments"
+    },
+    admin: {
+      id: "admin",
+      order: 350,
+      label: "Admin",
+      enabled: true,
+      lifecycle: "active",
+      path: "/admin",
+      icon: "admin",
+      requiresAdmin: true
+    },
+    "admin.system-health": {
+      id: "admin.system-health",
+      order: 360,
+      label: "System Health",
+      enabled: true,
+      lifecycle: "active",
+      path: "/admin/system-health"
+    },
+    "admin.organizations": {
+      id: "admin.organizations",
+      order: 370,
+      label: "Organizations",
+      enabled: true,
+      lifecycle: "active",
+      path: "/admin/organizations"
+    },
+    "admin.users": {
+      id: "admin.users",
+      order: 380,
+      label: "Users",
+      enabled: true,
+      lifecycle: "active",
+      path: "/admin/users"
+    },
+    "admin.design-showcase": {
+      id: "admin.design-showcase",
+      order: 390,
+      label: "Design Showcase",
+      enabled: true,
+      lifecycle: "active",
+      path: "/admin/design-showcase"
+    },
+    "admin.debug": {
+      id: "admin.debug",
+      order: 400,
+      label: "Debug",
+      enabled: true,
+      lifecycle: "active",
+      path: "/admin/debug"
+    },
+    archive: {
+      id: "archive",
+      order: 410,
+      label: "Archive",
+      enabled: true,
+      lifecycle: "active",
+      path: "/archive",
+      icon: "archive",
+      devOnly: true
+    },
+    "archive.agent-chat": {
+      id: "archive.agent-chat",
+      order: 420,
+      label: "Agent Chat",
+      enabled: true,
+      lifecycle: "active",
+      path: "/archive/agent-chat"
+    },
+    "archive.execution-runner": {
+      id: "archive.execution-runner",
+      order: 430,
+      label: "Execution Runner",
+      enabled: true,
+      lifecycle: "active",
+      path: "/archive/execution-runner"
+    },
+    seo: {
+      id: "seo",
+      order: 440,
+      label: "SEO",
+      enabled: false,
+      lifecycle: "deprecated",
+      path: "/seo"
+    },
+    knowledge: {
+      id: "knowledge",
+      order: 450,
+      label: "Knowledge",
+      description: "Operational knowledge, playbooks, and strategy docs",
+      enabled: true,
+      lifecycle: "active",
+      color: "teal",
+      icon: "knowledge"
+    },
+    "knowledge.base": {
+      id: "knowledge.base",
+      order: 460,
+      label: "Knowledge Base",
+      enabled: true,
+      lifecycle: "active",
+      path: "/knowledge"
+    }
+  },
+  ontology: DEFAULT_ONTOLOGY_SCOPE,
+  resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
+  actions: DEFAULT_ORGANIZATION_MODEL_ACTIONS,
+  entities: DEFAULT_ORGANIZATION_MODEL_ENTITIES2,
+  policies: DEFAULT_ORGANIZATION_MODEL_POLICIES,
+  // Phase 4 (D1): statuses top-level field removed; bridge status mirrors may
+  // still project from System.content, but primary authoring belongs in ontology.
+  knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE
+};
+
+// ../core/src/business/acquisition/ontology-validation.ts
+var CRM_PIPELINE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.crm",
+  kind: "catalog",
+  localId: "crm.pipeline"
+});
+var LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "lead-gen.stage-catalog"
+});
+var CRM_DEAL_OBJECT_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.crm",
+  kind: "object",
+  localId: "crm.deal"
+});
+function createCrmPipelineCatalog() {
+  return {
+    id: CRM_PIPELINE_CATALOG_ONTOLOGY_ID,
+    label: CRM_PIPELINE_DEFINITION.label,
+    ownerSystemId: "sales.crm",
+    kind: "pipeline",
+    appliesTo: CRM_DEAL_OBJECT_ONTOLOGY_ID,
+    entries: Object.fromEntries(
+      CRM_PIPELINE_DEFINITION.stages.map((stage, index2) => [
+        stage.stageKey,
+        {
+          key: stage.stageKey,
+          label: stage.label,
+          order: (index2 + 1) * 10,
+          ...stage.color !== void 0 ? { color: stage.color } : {},
+          states: stage.states.map((state) => ({ ...state }))
         }
-      ]
+      ])
+    ),
+    legacyPipelineKey: CRM_PIPELINE_DEFINITION.pipelineKey,
+    legacyEntityKey: CRM_PIPELINE_DEFINITION.entityKey
+  };
+}
+function createLeadGenStageCatalog() {
+  return {
+    id: LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID,
+    label: "Lead Gen Processing Stages",
+    ownerSystemId: "sales.lead-gen",
+    kind: "processing-stage-catalog",
+    entries: Object.fromEntries(
+      Object.entries(LEAD_GEN_STAGE_CATALOG).map(([key, entry]) => [
+        key,
+        {
+          ...entry
+        }
+      ])
+    ),
+    legacyCatalogKey: "LEAD_GEN_STAGE_CATALOG"
+  };
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeBridgeCatalogs(model) {
+  const baseCatalogTypes = model.ontology?.catalogTypes ?? {};
+  const bridgeCatalogTypes = {};
+  if (baseCatalogTypes[CRM_PIPELINE_CATALOG_ONTOLOGY_ID] === void 0) {
+    bridgeCatalogTypes[CRM_PIPELINE_CATALOG_ONTOLOGY_ID] = createCrmPipelineCatalog();
+  }
+  if (baseCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] === void 0) {
+    bridgeCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] = createLeadGenStageCatalog();
+  }
+  if (Object.keys(bridgeCatalogTypes).length === 0) return model;
+  return {
+    ...model,
+    ontology: {
+      ...model.ontology ?? {},
+      catalogTypes: {
+        ...baseCatalogTypes,
+        ...bridgeCatalogTypes
+      }
     }
+  };
+}
+function compileBusinessOntologyValidationIndex(model = DEFAULT_ORGANIZATION_MODEL) {
+  const compilation = compileOrganizationOntology(mergeBridgeCatalogs(model));
+  if (compilation.diagnostics.length > 0) {
+    const summary = compilation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+    throw new Error(`Business ontology validation index failed to compile: ${summary}`);
   }
-};
-
-// ../core/src/business/acquisition/build-templates.ts
-var BUILD_TEMPLATE_CATALOG = [
-  {
-    id: "local-services",
-    label: "Local Services",
-    description: "Source, analyze, qualify, and personalize local service businesses for outreach.",
-    steps: Object.values(PROSPECTING_STEPS.localServices)
-  },
-  {
-    id: "dtc-subscription-apollo-clickup",
-    label: "DTC Subscription (Apollo + ClickUp)",
-    description: "Import DTC brand leads from Apollo, crawl their websites, score fit, enrich contacts, and export via ClickUp.",
-    steps: Object.values(PROSPECTING_STEPS.dtcApolloClickup)
+  const crmPipelineCatalog = compilation.ontology.catalogTypes[CRM_PIPELINE_CATALOG_ONTOLOGY_ID];
+  const leadGenStageCatalog = compilation.ontology.catalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID];
+  if (crmPipelineCatalog === void 0 || leadGenStageCatalog === void 0) {
+    throw new Error("Business ontology validation index is missing CRM or lead-gen catalog bridge records");
   }
-];
-var PROSPECTING_BUILD_TEMPLATE_OPTIONS = BUILD_TEMPLATE_CATALOG.map(({ id, label, description }) => ({
-  id,
-  label,
-  description
-}));
-function isProspectingBuildTemplateId(value) {
-  return PROSPECTING_BUILD_TEMPLATE_OPTIONS.some((template) => template.id === value);
+  return {
+    ontology: compilation.ontology,
+    crmPipelineCatalog,
+    leadGenStageCatalog,
+    actionTypesByLegacyId: indexActionTypesByLegacyId(compilation.ontology.actionTypes)
+  };
 }
-
-// ../core/src/organization-model/catalogs/lead-gen.ts
-var LEAD_GEN_STAGE_CATALOG = {
-  // Prospecting - company population
-  scraped: {
-    key: "scraped",
-    label: "Scraped",
-    description: "Company was scraped from a source directory (Apify actor run).",
-    order: 1,
-    entity: "company"
-  },
-  populated: {
-    key: "populated",
-    label: "Companies found",
-    description: "Companies have been found and added to the lead-gen list.",
-    order: 2,
-    entity: "company"
-  },
-  crawled: {
-    key: "crawled",
-    label: "Websites crawled",
-    description: "Company websites have been crawled (e.g. via Apify) and raw page content stored for downstream LLM analysis.",
-    order: 2.5,
-    entity: "company"
-  },
-  extracted: {
-    key: "extracted",
-    label: "Websites analyzed",
-    description: "Company websites have been analyzed for business signals.",
-    order: 3,
-    entity: "company"
-  },
-  enriched: {
-    key: "enriched",
-    label: "Enriched",
-    description: "Company or contact enriched with third-party data (e.g. Tomba, Anymailfinder).",
-    order: 4,
-    entity: "company"
-  },
-  "decision-makers-enriched": {
-    key: "decision-makers-enriched",
-    label: "Decision-makers found",
-    description: "Decision-maker contacts discovered and attached to a qualified company.",
-    order: 6,
-    entity: "company",
-    recordEntity: "contact",
-    recordStageKey: "discovered"
-  },
-  // Prospecting - contact discovery
-  discovered: {
-    key: "discovered",
-    label: "Decision-makers found",
-    description: "Decision-maker contact details have been found.",
-    order: 5,
-    entity: "contact"
-  },
-  verified: {
-    key: "verified",
-    label: "Emails verified",
-    description: "Contact email addresses have been checked for deliverability.",
-    order: 7,
-    entity: "contact"
-  },
-  // Qualification
-  qualified: {
-    key: "qualified",
-    label: "Companies qualified",
-    description: "Companies have been scored against the qualification criteria.",
-    order: 8,
-    entity: "company"
-  },
-  // Outreach
-  personalized: {
-    key: "personalized",
-    label: "Personalized",
-    description: "Outreach message personalized for the contact (Instantly personalization workflow).",
-    order: 9,
-    entity: "contact"
-  },
-  uploaded: {
-    key: "uploaded",
-    label: "Reviewed and exported",
-    description: "Approved records have been reviewed and exported for handoff.",
-    order: 10,
-    entity: "company",
-    additionalEntities: ["contact"]
-  },
-  interested: {
-    key: "interested",
-    label: "Interested",
-    description: "Contact replied with a positive signal (Instantly reply-handler transition).",
-    order: 11,
-    entity: "contact"
+function indexActionTypesByLegacyId(actionTypes) {
+  const byLegacyId = {};
+  for (const actionType of Object.values(actionTypes)) {
+    const legacyActionId = actionType["legacyActionId"];
+    if (typeof legacyActionId === "string") {
+      byLegacyId[legacyActionId] = actionType;
+    }
   }
-};
-
-// ../core/src/organization-model/domains/sales.ts
-var SalesStageSemanticClassSchema = z.enum(["open", "active", "nurturing", "closed_won", "closed_lost"]);
-var SalesStageSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  order: z.number().int().min(0),
-  semanticClass: SalesStageSemanticClassSchema,
-  surfaceIds: ReferenceIdsSchema,
-  resourceIds: ReferenceIdsSchema
-});
-z.object({
-  id: ModelIdSchema,
-  label: z.string().trim().min(1).max(120),
-  description: DescriptionSchema.optional(),
-  entityId: ModelIdSchema,
-  stages: z.array(SalesStageSchema).min(1)
+  return byLegacyId;
+}
+var BUSINESS_ONTOLOGY_VALIDATION_INDEX = compileBusinessOntologyValidationIndex();
+function getCatalogEntries(catalog) {
+  return isPlainRecord(catalog.entries) ? catalog.entries : {};
+}
+function asCrmStageEntry(key, value) {
+  const record = isPlainRecord(value) ? value : {};
+  const label = typeof record.label === "string" ? record.label : key;
+  const order = typeof record.order === "number" ? record.order : 0;
+  const color = typeof record.color === "string" ? record.color : void 0;
+  const rawStates = Array.isArray(record.states) ? record.states : [];
+  const states = rawStates.flatMap((state) => {
+    if (!isPlainRecord(state) || typeof state.stateKey !== "string") return [];
+    return [
+      {
+        stateKey: state.stateKey,
+        label: typeof state.label === "string" ? state.label : state.stateKey
+      }
+    ];
+  });
+  return {
+    key,
+    label,
+    order,
+    ...color !== void 0 ? { color } : {},
+    states
+  };
+}
+function asLeadGenStageEntry(key, value) {
+  const record = isPlainRecord(value) ? value : {};
+  const entity = record.entity === "contact" ? "contact" : "company";
+  const additionalEntities = Array.isArray(record.additionalEntities) ? record.additionalEntities.filter(
+    (item) => item === "company" || item === "contact"
+  ) : void 0;
+  const recordEntity = record.recordEntity === "company" || record.recordEntity === "contact" ? record.recordEntity : void 0;
+  const recordStageKey = typeof record.recordStageKey === "string" ? record.recordStageKey : void 0;
+  return {
+    key: typeof record.key === "string" ? record.key : key,
+    label: typeof record.label === "string" ? record.label : key,
+    description: typeof record.description === "string" ? record.description : "",
+    order: typeof record.order === "number" ? record.order : 0,
+    entity,
+    ...additionalEntities !== void 0 ? { additionalEntities } : {},
+    ...recordEntity !== void 0 ? { recordEntity } : {},
+    ...recordStageKey !== void 0 ? { recordStageKey } : {}
+  };
+}
+var CRM_STAGE_KEYS_FROM_ONTOLOGY = Object.keys(
+  getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.crmPipelineCatalog)
+);
+var CRM_STATE_KEYS_FROM_ONTOLOGY = Object.values(
+  getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.crmPipelineCatalog)
+).flatMap((entry, index2) => {
+  const stageKey = CRM_STAGE_KEYS_FROM_ONTOLOGY[index2];
+  if (stageKey === void 0) return [];
+  return asCrmStageEntry(stageKey, entry).states.map((state) => state.stateKey);
 });
-var CRM_DISCOVERY_REPLIED_STATE = {
-  stateKey: "discovery_replied",
-  label: "Discovery Replied"
-};
-var CRM_DISCOVERY_LINK_SENT_STATE = {
-  stateKey: "discovery_link_sent",
-  label: "Discovery Link Sent"
-};
-var CRM_DISCOVERY_NUDGING_STATE = {
-  stateKey: "discovery_nudging",
-  label: "Discovery Nudging"
-};
-var CRM_DISCOVERY_BOOKING_CANCELLED_STATE = {
-  stateKey: "discovery_booking_cancelled",
-  label: "Discovery Booking Cancelled"
-};
-var CRM_REPLY_SENT_STATE = {
-  stateKey: "reply_sent",
-  label: "Reply Sent"
-};
-var CRM_FOLLOWUP_1_SENT_STATE = {
-  stateKey: "followup_1_sent",
-  label: "Follow-up 1 Sent"
-};
-var CRM_FOLLOWUP_2_SENT_STATE = {
-  stateKey: "followup_2_sent",
-  label: "Follow-up 2 Sent"
-};
-var CRM_FOLLOWUP_3_SENT_STATE = {
-  stateKey: "followup_3_sent",
-  label: "Follow-up 3 Sent"
-};
-var CRM_PIPELINE_DEFINITION = {
-  pipelineKey: "crm",
-  stages: [
-    {
-      stageKey: "interested",
-      label: "Interested",
-      color: "blue",
-      states: [
-        CRM_DISCOVERY_REPLIED_STATE,
-        CRM_DISCOVERY_LINK_SENT_STATE,
-        CRM_DISCOVERY_NUDGING_STATE,
-        CRM_DISCOVERY_BOOKING_CANCELLED_STATE,
-        CRM_REPLY_SENT_STATE,
-        CRM_FOLLOWUP_1_SENT_STATE,
-        CRM_FOLLOWUP_2_SENT_STATE,
-        CRM_FOLLOWUP_3_SENT_STATE
-      ]
-    },
-    { stageKey: "proposal", label: "Proposal", color: "yellow", states: [] },
-    { stageKey: "closing", label: "Closing", color: "orange", states: [] },
-    { stageKey: "closed_won", label: "Closed Won", color: "green", states: [] },
-    { stageKey: "closed_lost", label: "Closed Lost", color: "red", states: [] },
-    { stageKey: "nurturing", label: "Nurturing", color: "grape", states: [] }
-  ]
-};
+Object.keys(
+  getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.leadGenStageCatalog)
+);
+function getLeadGenStageCatalogFromOntology() {
+  return Object.fromEntries(
+    Object.entries(getCatalogEntries(BUSINESS_ONTOLOGY_VALIDATION_INDEX.leadGenStageCatalog)).map(([key, value]) => [
+      key,
+      asLeadGenStageEntry(key, value)
+    ])
+  );
+}
+function getLeadGenStageEntry(stageKey) {
+  return getLeadGenStageCatalogFromOntology()[stageKey];
+}
+function isLeadGenStageKey(stageKey) {
+  return getLeadGenStageEntry(stageKey) !== void 0;
+}
+function isLeadGenRecordStageValidForEntity(stageKey, entity) {
+  const stage = getLeadGenStageEntry(stageKey);
+  return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true || stage.recordEntity === entity);
+}
+function isLeadGenActionKey(actionKey) {
+  return actionKey.startsWith("lead-gen.") && BUSINESS_ONTOLOGY_VALIDATION_INDEX.actionTypesByLegacyId[actionKey] !== void 0;
+}
 
 // ../core/src/business/acquisition/api-schemas.ts
 var ProcessingStageStatusSchema = z.enum(["success", "no_result", "skipped", "error"]);
-var LeadGenStageKeySchema = z.string().refine((value) => Object.prototype.hasOwnProperty.call(LEAD_GEN_STAGE_CATALOG, value), {
+var LeadGenStageKeySchema = z.string().refine((value) => isLeadGenStageKey(value), {
   message: "processing state key must match LEAD_GEN_STAGE_CATALOG"
 });
-var LeadGenActionKeySchema = z.string().refine((value) => ACTION_REGISTRY.some((c) => c.id === value), {
+var LeadGenActionKeySchema = z.string().refine((value) => isLeadGenActionKey(value), {
   message: "actionKey must match ACTION_REGISTRY"
 });
-var crmStageKeys = CRM_PIPELINE_DEFINITION.stages.map((stage) => stage.stageKey);
-var crmStateKeys = CRM_PIPELINE_DEFINITION.stages.flatMap((stage) => stage.states.map((state) => state.stateKey));
+var crmStageKeys = CRM_STAGE_KEYS_FROM_ONTOLOGY;
+var crmStateKeys = CRM_STATE_KEYS_FROM_ONTOLOGY;
 var CrmStageKeySchema = z.enum(crmStageKeys);
 var CrmStateKeySchema = z.enum(crmStateKeys);
 var ProcessingStateEntrySchema = z.object({
@@ -7758,7 +10721,7 @@ var IcpRubricSchema = z.object({
   customRules: z.string().optional()
 });
 var PipelineStageSchema = z.object({
-  key: z.string().refine((value) => Object.prototype.hasOwnProperty.call(LEAD_GEN_STAGE_CATALOG, value), {
+  key: z.string().refine((value) => isLeadGenStageKey(value), {
     message: "pipeline stage key must match LEAD_GEN_STAGE_CATALOG"
   }),
   label: z.string().optional(),
@@ -8230,9 +11193,7 @@ z.object({
   offset: z.coerce.number().int().min(0).default(0)
 }).strict().superRefine((query, ctx) => {
   if (!query.stage) return;
-  const stage = LEAD_GEN_STAGE_CATALOG[query.stage];
-  const validEntity = stage?.entity === query.entity || stage?.additionalEntities?.includes(query.entity) || stage?.recordEntity === query.entity;
-  if (!validEntity) {
+  if (!isLeadGenRecordStageValidForEntity(query.stage, query.entity)) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
       message: `stage "${query.stage}" is not valid for ${query.entity} records`,
@@ -8698,14 +11659,18 @@ createAdapter("execution", ["trigger", "triggerAsync"]);
 createAdapter("email", ["send"]);
 
 // ../core/src/organization-model/helpers.ts
+function childSystemsOf2(system) {
+  return system.systems ?? system.subsystems ?? {};
+}
 function listAllSystems(model) {
   const results = [];
   function walk(map2, prefix) {
     for (const [localId, system] of Object.entries(map2)) {
       const fullPath = prefix ? `${prefix}.${localId}` : localId;
       results.push({ path: fullPath, system });
-      if (system.subsystems) {
-        walk(system.subsystems, fullPath);
+      const childSystems = childSystemsOf2(system);
+      if (Object.keys(childSystems).length > 0) {
+        walk(childSystems, fullPath);
       }
     }
   }