@elevasis/core 0.21.0 → 0.23.0

package/dist/test-utils/index.js

@@ -19416,6 +19416,190 @@ function makeTask(overrides = {}) {
     ...overrides
   });
 }
+
+// src/organization-model/content-kinds/registry.ts
+function defineContentType(def) {
+  return def;
+}
+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 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: []
+});
+
+// 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 ORGANIZATION_MODEL_ICON_TOKENS = [
   "nav.dashboard",
   "nav.calendar",
@@ -19434,6 +19618,7 @@ var ORGANIZATION_MODEL_ICON_TOKENS = [
   "knowledge.reference",
   "feature.dashboard",
   "feature.calendar",
+  "feature.business",
   "feature.sales",
   "feature.crm",
   "feature.finance",
@@ -19526,10 +19711,10 @@ DisplayMetadataSchema.extend({
   id: ModelIdSchema,
   resourceId: z.string().trim().min(1).max(255),
   resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]),
-  featureIds: ReferenceIdsSchema,
+  systemIds: ReferenceIdsSchema,
   entityIds: ReferenceIdsSchema,
   surfaceIds: ReferenceIdsSchema,
-  capabilityIds: ReferenceIdsSchema,
+  actionIds: ReferenceIdsSchema,
   /** Optional tech-stack metadata for external-SaaS integrations. */
   techStack: TechStackEntrySchema.optional()
 });
@@ -19551,637 +19736,8 @@ var DEFAULT_ORGANIZATION_MODEL_BRANDING = {
   shortName: "Elevasis",
   logos: {}
 };
-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
-});
-var SalesPipelineSchema = z.object({
-  id: ModelIdSchema,
-  label: z.string().trim().min(1).max(120),
-  description: DescriptionSchema.optional(),
-  entityId: ModelIdSchema,
-  stages: z.array(SalesStageSchema).min(1)
-});
-var OrganizationModelSalesSchema = z.object({
-  entityId: ModelIdSchema,
-  defaultPipelineId: ModelIdSchema,
-  pipelines: z.array(SalesPipelineSchema).min(1)
-});
-var DEFAULT_ORGANIZATION_MODEL_SALES = {
-  entityId: "crm.deal",
-  defaultPipelineId: "default",
-  pipelines: [
-    {
-      id: "default",
-      label: "Default Pipeline",
-      entityId: "crm.deal",
-      stages: [
-        {
-          id: "interested",
-          label: "Interested",
-          color: "blue",
-          order: 1,
-          semanticClass: "open",
-          surfaceIds: ["crm.pipeline"],
-          resourceIds: []
-        },
-        {
-          id: "proposal",
-          label: "Proposal",
-          color: "yellow",
-          order: 2,
-          semanticClass: "active",
-          surfaceIds: ["crm.pipeline"],
-          resourceIds: []
-        },
-        {
-          id: "closing",
-          label: "Closing",
-          color: "lime",
-          order: 3,
-          semanticClass: "active",
-          surfaceIds: ["crm.pipeline"],
-          resourceIds: []
-        },
-        {
-          id: "closed_won",
-          label: "Closed Won",
-          color: "green",
-          order: 4,
-          semanticClass: "closed_won",
-          surfaceIds: ["crm.pipeline"],
-          resourceIds: []
-        },
-        {
-          id: "closed_lost",
-          label: "Closed Lost",
-          color: "red",
-          order: 5,
-          semanticClass: "closed_lost",
-          surfaceIds: ["crm.pipeline"],
-          resourceIds: []
-        },
-        {
-          id: "nurturing",
-          label: "Nurturing",
-          color: "grape",
-          order: 6,
-          semanticClass: "nurturing",
-          surfaceIds: ["crm.pipeline"],
-          resourceIds: []
-        }
-      ]
-    }
-  ]
-};
-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"
-  }
-};
-var ProjectsDomainStateSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  order: z.number().int().min(0)
-});
-var OrganizationModelProjectsSchema = z.object({
-  projectEntityId: ModelIdSchema,
-  milestoneEntityId: ModelIdSchema,
-  taskEntityId: ModelIdSchema,
-  projectStatuses: z.array(ProjectsDomainStateSchema).min(1),
-  milestoneStatuses: z.array(ProjectsDomainStateSchema).min(1),
-  taskStatuses: z.array(ProjectsDomainStateSchema).min(1)
-});
-var DEFAULT_ORGANIZATION_MODEL_PROJECTS = {
-  projectEntityId: "delivery.project",
-  milestoneEntityId: "delivery.milestone",
-  taskEntityId: "delivery.task",
-  projectStatuses: [
-    { id: "active", label: "Active", order: 1 },
-    { id: "on_track", label: "On Track", order: 2 },
-    { id: "at_risk", label: "At Risk", order: 3 },
-    { id: "blocked", label: "Blocked", order: 4 },
-    { id: "paused", label: "Paused", order: 5 },
-    { id: "completed", label: "Completed", order: 6 }
-  ],
-  milestoneStatuses: [
-    { id: "upcoming", label: "Upcoming", order: 1 },
-    { id: "in_progress", label: "In Progress", order: 2 },
-    { id: "blocked", label: "Blocked", order: 3 },
-    { id: "overdue", label: "Overdue", order: 4 },
-    { id: "completed", label: "Completed", order: 5 }
-  ],
-  taskStatuses: [
-    { id: "planned", label: "Planned", order: 1 },
-    { id: "in_progress", label: "In Progress", order: 2 },
-    { id: "blocked", label: "Blocked", order: 3 },
-    { id: "submitted", label: "Submitted", order: 4 },
-    { id: "approved", label: "Approved", order: 5 },
-    { id: "revision_requested", label: "Revision Requested", order: 6 },
-    { id: "rejected", label: "Rejected", order: 7 },
-    { id: "cancelled", label: "Cancelled", order: 8 },
-    { id: "completed", label: "Completed", order: 9 }
-  ]
-};
-var NodeIdPathSchema = z.string().trim().min(1).max(100).regex(/^([a-z0-9-]+)(\.[a-z0-9-]+)*$/, "Node IDs must be lowercase dotted paths");
-var NodeIdStringSchema = z.string().trim().min(1).max(200).regex(/^[a-z]+:([a-z0-9-]+)(\.[a-z0-9-]+)*$/, "Node references must use kind:dotted-path");
-var UiPositionSchema = z.enum(["sidebar-primary", "sidebar-bottom"]);
-var FeatureSchema = z.object({
-  id: NodeIdPathSchema,
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().default(true),
-  path: PathSchema.optional(),
-  icon: IconNameSchema.optional(),
-  color: ColorTokenSchema.optional(),
-  uiPosition: UiPositionSchema.optional(),
-  requiresAdmin: z.boolean().optional(),
-  devOnly: z.boolean().optional()
-});
-var ProspectingLifecycleStageSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  order: z.number().min(0)
-});
-var RecordColumnConfigSchema = z.object({
-  key: ModelIdSchema,
-  label: z.string().trim().min(1).max(120),
-  path: z.string().trim().min(1).max(500),
-  width: z.union([z.number().positive(), z.string().trim().min(1).max(100)]).optional(),
-  renderType: z.enum(["text", "badge", "datetime", "count", "json"]).optional(),
-  badgeColor: z.string().trim().min(1).max(40).optional()
-});
-var RecordColumnsConfigSchema = z.object({
-  company: z.array(RecordColumnConfigSchema).optional(),
-  contact: z.array(RecordColumnConfigSchema).optional()
-}).refine((columns) => Boolean(columns.company?.length || columns.contact?.length), {
-  message: "recordColumns must include at least one entity column set"
-});
-var CredentialRequirementSchema = z.object({
-  key: ModelIdSchema,
-  provider: ModelIdSchema,
-  credentialType: z.enum(["api-key", "api-key-secret", "oauth", "webhook-secret"]),
-  label: z.string().trim().min(1).max(120),
-  required: z.boolean(),
-  selectionMode: z.enum(["single", "multiple"]).optional(),
-  inputPath: z.string().trim().min(1).max(500),
-  verifyOnRun: z.boolean().optional()
-});
-var ProspectingBuildTemplateStepSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  primaryEntity: z.enum(["company", "contact"]),
-  outputs: z.array(z.enum(["company", "contact", "export"])).min(1),
-  stageKey: ModelIdSchema,
-  recordEntity: z.enum(["company", "contact"]).optional(),
-  recordsStageKey: ModelIdSchema.optional(),
-  recordSourceStageKey: ModelIdSchema.optional(),
-  dependsOn: z.array(ModelIdSchema).optional(),
-  dependencyMode: z.literal("per-record-eligibility"),
-  capabilityKey: ModelIdSchema,
-  defaultBatchSize: z.number().int().positive(),
-  maxBatchSize: z.number().int().positive(),
-  recordColumns: RecordColumnsConfigSchema.optional(),
-  credentialRequirements: z.array(CredentialRequirementSchema).optional()
-}).refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
-  message: "defaultBatchSize must be less than or equal to maxBatchSize",
-  path: ["defaultBatchSize"]
-});
-var ProspectingBuildTemplateSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  steps: z.array(ProspectingBuildTemplateStepSchema).min(1)
-});
-var DTC_RECORD_COLUMNS = {
-  populated: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "employee-count", label: "Employees", path: "company.numEmployees", renderType: "count" },
-      { key: "apollo-industry", label: "Apollo industry", path: "company.category" },
-      { key: "location", label: "Location", path: "company.locationState" }
-    ]
-  },
-  crawled: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "page-count", label: "Pages", path: "company.enrichmentData.websiteCrawl.pageCount", renderType: "count" },
-      { key: "crawl-status", label: "Crawl status", path: "processingState.crawled.status", renderType: "badge" }
-    ]
-  },
-  extracted: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "description", label: "Description", path: "company.enrichmentData.websiteCrawl.companyDescription" },
-      { key: "services", label: "Services", path: "company.enrichmentData.websiteCrawl.services", renderType: "json" },
-      { key: "automation-gaps", label: "Automation gaps", path: "company.enrichmentData.websiteCrawl.automationGaps", renderType: "json" },
-      { key: "contact-count", label: "Contacts", path: "company.enrichmentData.websiteCrawl.emailCount", renderType: "count" }
-    ]
-  },
-  qualified: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "score", label: "Score", path: "company.qualificationScore", renderType: "badge", badgeColor: "green" },
-      { key: "signals", label: "Signals", path: "company.qualificationSignals", renderType: "json" },
-      { key: "disqualified-reason", label: "Disqualified reason", path: "processingState.qualified.data.disqualifiedReason" }
-    ]
-  },
-  decisionMakers: {
-    contact: [
-      { key: "name", label: "Name", path: "contact.name" },
-      { key: "title", label: "Title", path: "contact.title" },
-      { key: "email", label: "Email", path: "contact.email" },
-      { key: "linkedin", label: "LinkedIn", path: "contact.linkedinUrl" },
-      { key: "priority-score", label: "Priority", path: "contact.enrichmentData.apollo.priorityScore", renderType: "badge" }
-    ]
-  },
-  uploaded: {
-    company: [
-      { key: "name", label: "Company", path: "company.name" },
-      { key: "domain", label: "Domain", path: "company.domain" },
-      { key: "contacts", label: "Contacts", path: "company.enrichmentData.approvedLeadListExport.contacts", renderType: "json" },
-      { key: "score", label: "Score", path: "company.qualificationScore", renderType: "badge", badgeColor: "green" },
-      { key: "approval", label: "Approval", path: "company.enrichmentData.approvedLeadListExport.approvalStatus", renderType: "badge" }
-    ]
-  }
-};
+var SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]).meta({ label: "Surface type", color: "blue" });
 z.object({
-  id: ModelIdSchema,
-  label: z.string(),
-  description: z.string(),
-  resourceId: ModelIdSchema
-});
-var PROSPECTING_STEPS = {
-  localServices: {
-    sourceCompanies: {
-      id: "source-companies",
-      label: "Companies found",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "populated",
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.company.source",
-      defaultBatchSize: 100,
-      maxBatchSize: 250
-    },
-    analyzeWebsites: {
-      id: "analyze-websites",
-      label: "Websites analyzed",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "extracted",
-      dependsOn: ["source-companies"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.company.website-extract",
-      defaultBatchSize: 50,
-      maxBatchSize: 100
-    },
-    qualifyCompanies: {
-      id: "qualify-companies",
-      label: "Companies qualified",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "qualified",
-      dependsOn: ["analyze-websites"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.company.qualify",
-      defaultBatchSize: 100,
-      maxBatchSize: 250
-    },
-    findContacts: {
-      id: "find-contacts",
-      label: "Decision-makers found",
-      primaryEntity: "contact",
-      outputs: ["contact"],
-      stageKey: "discovered",
-      dependsOn: ["qualify-companies"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.contact.discover",
-      defaultBatchSize: 50,
-      maxBatchSize: 100
-    },
-    verifyEmails: {
-      id: "verify-emails",
-      label: "Emails verified",
-      primaryEntity: "contact",
-      outputs: ["contact"],
-      stageKey: "verified",
-      dependsOn: ["find-contacts"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.contact.verify-email",
-      defaultBatchSize: 100,
-      maxBatchSize: 500
-    },
-    personalize: {
-      id: "personalize",
-      label: "Personalize",
-      primaryEntity: "contact",
-      outputs: ["contact"],
-      stageKey: "personalized",
-      dependsOn: ["verify-emails"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.contact.personalize",
-      defaultBatchSize: 25,
-      maxBatchSize: 100
-    },
-    review: {
-      id: "review",
-      label: "Reviewed and exported",
-      primaryEntity: "contact",
-      outputs: ["export"],
-      stageKey: "uploaded",
-      dependsOn: ["personalize"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.review.outreach-ready",
-      defaultBatchSize: 25,
-      maxBatchSize: 100
-    }
-  },
-  dtcApolloClickup: {
-    importApolloSearch: {
-      id: "import-apollo-search",
-      label: "Companies found",
-      description: "Pull companies and seed contact data from a predefined Apollo search or list.",
-      primaryEntity: "company",
-      outputs: ["company", "contact"],
-      stageKey: "populated",
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.company.apollo-import",
-      defaultBatchSize: 250,
-      maxBatchSize: 1e3,
-      recordColumns: DTC_RECORD_COLUMNS.populated,
-      credentialRequirements: [
-        {
-          key: "apollo",
-          provider: "apollo",
-          credentialType: "api-key-secret",
-          label: "Apollo API key",
-          required: true,
-          selectionMode: "single",
-          inputPath: "credential"
-        }
-      ]
-    },
-    apifyCrawl: {
-      id: "apify-crawl",
-      label: "Websites crawled",
-      description: "Crawl company websites via Apify and store raw page markdown in enrichmentData.websiteCrawl.pages for downstream LLM analysis. Overwrites the synthetic seed Apollo Import wrote with real page content.",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "crawled",
-      dependsOn: ["import-apollo-search"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.company.apify-crawl",
-      defaultBatchSize: 50,
-      maxBatchSize: 100,
-      recordColumns: DTC_RECORD_COLUMNS.crawled,
-      credentialRequirements: [
-        {
-          key: "apify",
-          provider: "apify",
-          credentialType: "api-key-secret",
-          label: "Apify API token",
-          required: true,
-          selectionMode: "single",
-          inputPath: "credential",
-          verifyOnRun: true
-        }
-      ]
-    },
-    analyzeWebsites: {
-      id: "analyze-websites",
-      label: "Websites analyzed",
-      description: "Extract subscription, product, retention, and tech-stack signals from each brand website.",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "extracted",
-      dependsOn: ["apify-crawl"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.company.website-extract",
-      defaultBatchSize: 50,
-      maxBatchSize: 100,
-      recordColumns: DTC_RECORD_COLUMNS.extracted
-    },
-    scoreDtcFit: {
-      id: "score-dtc-fit",
-      label: "Companies qualified",
-      description: "Classify subscription potential, consumable-product fit, retention maturity, and disqualifiers.",
-      primaryEntity: "company",
-      outputs: ["company"],
-      stageKey: "qualified",
-      dependsOn: ["analyze-websites"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.company.dtc-subscription-qualify",
-      defaultBatchSize: 100,
-      maxBatchSize: 250,
-      recordColumns: DTC_RECORD_COLUMNS.qualified
-    },
-    enrichDecisionMakers: {
-      id: "enrich-decision-makers",
-      label: "Decision-makers found",
-      description: "Use Apollo to find qualified contacts at qualified companies - founders, retention leads, lifecycle leads, and marketing owners.",
-      primaryEntity: "company",
-      outputs: ["contact"],
-      stageKey: "decision-makers-enriched",
-      recordEntity: "contact",
-      dependsOn: ["score-dtc-fit"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.contact.apollo-decision-maker-enrich",
-      defaultBatchSize: 100,
-      maxBatchSize: 250,
-      recordColumns: DTC_RECORD_COLUMNS.decisionMakers,
-      credentialRequirements: [
-        {
-          key: "apollo",
-          provider: "apollo",
-          credentialType: "api-key-secret",
-          label: "Apollo API key",
-          required: true,
-          selectionMode: "single",
-          inputPath: "credential"
-        }
-      ]
-    },
-    reviewAndExport: {
-      id: "review-and-export",
-      label: "Reviewed and exported",
-      description: "Operator QC approves or rejects qualified companies, then approved records are exported as a lead list with unverified emails.",
-      primaryEntity: "company",
-      outputs: ["export"],
-      stageKey: "uploaded",
-      recordsStageKey: "uploaded",
-      recordSourceStageKey: "qualified",
-      dependsOn: ["enrich-decision-makers"],
-      dependencyMode: "per-record-eligibility",
-      capabilityKey: "lead-gen.export.list",
-      defaultBatchSize: 100,
-      maxBatchSize: 250,
-      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
-        }
-      ]
-    }
-  }
-};
-var OrganizationModelProspectingSchema = z.object({
-  listEntityId: ModelIdSchema,
-  companyEntityId: ModelIdSchema,
-  contactEntityId: ModelIdSchema,
-  description: DescriptionSchema.optional(),
-  companyStages: z.array(ProspectingLifecycleStageSchema).min(1),
-  contactStages: z.array(ProspectingLifecycleStageSchema).min(1),
-  defaultBuildTemplateId: ModelIdSchema,
-  buildTemplates: z.array(ProspectingBuildTemplateSchema).min(1)
-});
-function toProspectingLifecycleStage(stage) {
-  return {
-    id: stage.key,
-    label: stage.label,
-    order: stage.order
-  };
-}
-function leadGenStagesForEntity(entity) {
-  return Object.values(LEAD_GEN_STAGE_CATALOG).filter((stage) => stage.entity === entity || stage.additionalEntities?.includes(entity)).sort((a3, b2) => a3.order - b2.order).map(toProspectingLifecycleStage);
-}
-var DEFAULT_ORGANIZATION_MODEL_PROSPECTING = {
-  listEntityId: "leadgen.list",
-  companyEntityId: "leadgen.company",
-  contactEntityId: "leadgen.contact",
-  companyStages: leadGenStagesForEntity("company"),
-  contactStages: leadGenStagesForEntity("contact"),
-  defaultBuildTemplateId: "local-services",
-  buildTemplates: [
-    {
-      id: "local-services",
-      label: "Local Services Prospecting",
-      description: "Curated local-services list build using company sourcing, website analysis, qualification, contact discovery, verification, personalization, and review.",
-      steps: [
-        PROSPECTING_STEPS.localServices.sourceCompanies,
-        PROSPECTING_STEPS.localServices.analyzeWebsites,
-        PROSPECTING_STEPS.localServices.qualifyCompanies,
-        PROSPECTING_STEPS.localServices.findContacts,
-        PROSPECTING_STEPS.localServices.verifyEmails,
-        PROSPECTING_STEPS.localServices.personalize,
-        PROSPECTING_STEPS.localServices.review
-      ]
-    },
-    {
-      id: "dtc-subscription-apollo-clickup",
-      label: "DTC Subscription Apollo Export",
-      description: "Prospecting pipeline for DTC subscription or subscription-ready brands where Apollo is the source and contact-enrichment layer, Elevasis handles company research and fit scoring, and approved leads export as an approved lead list.",
-      steps: [
-        PROSPECTING_STEPS.dtcApolloClickup.importApolloSearch,
-        PROSPECTING_STEPS.dtcApolloClickup.apifyCrawl,
-        PROSPECTING_STEPS.dtcApolloClickup.analyzeWebsites,
-        PROSPECTING_STEPS.dtcApolloClickup.scoreDtcFit,
-        PROSPECTING_STEPS.dtcApolloClickup.enrichDecisionMakers,
-        PROSPECTING_STEPS.dtcApolloClickup.reviewAndExport
-      ]
-    }
-  ]
-};
-var SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]);
-var SurfaceDefinitionSchema = z.object({
   id: ModelIdSchema,
   label: LabelSchema,
   path: PathSchema,
@@ -20190,23 +19746,55 @@ var SurfaceDefinitionSchema = z.object({
   enabled: z.boolean().default(true),
   devOnly: z.boolean().optional(),
   icon: IconNameSchema.optional(),
-  featureId: ModelIdSchema.optional(),
-  featureIds: ReferenceIdsSchema,
-  entityIds: ReferenceIdsSchema,
-  resourceIds: ReferenceIdsSchema,
-  capabilityIds: ReferenceIdsSchema,
-  parentId: ModelIdSchema.optional()
+  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 NavigationGroupSchema = z.object({
+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).default([])
-});
-var OrganizationModelNavigationSchema = z.object({
-  defaultSurfaceId: ModelIdSchema.optional(),
-  surfaces: z.array(SurfaceDefinitionSchema).default([]),
-  groups: z.array(NavigationGroupSchema).default([])
+  surfaceIds: z.array(ModelIdSchema.meta({ ref: "surface" })).default([])
 });
 var BusinessHoursDaySchema = z.object({
   open: z.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format"),
@@ -20291,6 +19879,8 @@ var FirmographicsSchema = z.object({
 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. */
@@ -20318,16 +19908,16 @@ var CustomerSegmentSchema = z.object({
    */
   valueProp: z.string().trim().max(2e3).default("")
 });
-var CustomersDomainSchema = z.object({
-  segments: z.array(CustomerSegmentSchema).default([])
-});
-var DEFAULT_ORGANIZATION_MODEL_CUSTOMERS = {
-  segments: []
-};
-var PricingModelSchema = z.enum(["one-time", "subscription", "usage-based", "custom"]);
+var 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. */
@@ -20354,25 +19944,526 @@ var ProductSchema = z.object({
    */
   targetSegmentIds: z.array(z.string().trim().min(1)).default([]),
   /**
-   * Optional: ID of the platform feature responsible for delivering this product.
-   * When present, must reference a declared `features[].id`.
+   * 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.object({
-  products: z.array(ProductSchema).default([])
+var OfferingsDomainSchema = z.record(z.string(), ProductSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+  message: "Each product entry id must match its map key"
+}).default({});
+var DEFAULT_ORGANIZATION_MODEL_OFFERINGS = {};
+var EntityIdSchema = ModelIdSchema;
+var EntityLinkKindSchema = z.enum(["belongs-to", "has-many", "has-one", "many-to-many"]).meta({ label: "Link kind" });
+var EntityLinkSchema = z.object({
+  toEntity: EntityIdSchema.meta({ ref: "entity" }),
+  kind: EntityLinkKindSchema,
+  via: z.string().trim().min(1).max(255).optional(),
+  label: LabelSchema.optional()
 });
-var DEFAULT_ORGANIZATION_MODEL_OFFERINGS = {
-  products: []
-};
+var EntitySchema = z.object({
+  id: EntityIdSchema,
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  ownedBySystemId: ModelIdSchema.meta({ ref: "system" }),
+  table: z.string().trim().min(1).max(255).optional(),
+  rowSchema: ModelIdSchema.optional(),
+  stateCatalogId: ModelIdSchema.optional(),
+  links: z.array(EntityLinkSchema).optional()
+});
+var EntitiesDomainSchema = z.record(z.string(), EntitySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+  message: "Each entity entry id must match its map key"
+}).default({});
+var ENTITY_ENTRY_INPUTS = [
+  {
+    id: "crm.deal",
+    order: 10,
+    label: "Deal",
+    description: "A CRM opportunity or sales pipeline record.",
+    ownedBySystemId: "sales.crm",
+    table: "crm_deals",
+    stateCatalogId: "crm.pipeline",
+    links: [{ toEntity: "crm.contact", kind: "has-many", via: "deal_contacts", label: "contacts" }]
+  },
+  {
+    id: "crm.contact",
+    order: 20,
+    label: "CRM Contact",
+    description: "A person associated with a CRM relationship or deal.",
+    ownedBySystemId: "sales.crm",
+    table: "crm_contacts"
+  },
+  {
+    id: "leadgen.list",
+    order: 30,
+    label: "Lead List",
+    description: "A prospecting list that groups companies and contacts for acquisition workflows.",
+    ownedBySystemId: "sales.lead-gen",
+    table: "acq_lists",
+    links: [
+      { toEntity: "leadgen.company", kind: "has-many", via: "acq_list_companies", label: "companies" },
+      { toEntity: "leadgen.contact", kind: "has-many", via: "acq_list_members", label: "contacts" }
+    ]
+  },
+  {
+    id: "leadgen.company",
+    order: 40,
+    label: "Lead Company",
+    description: "A company record sourced, enriched, and qualified during prospecting.",
+    ownedBySystemId: "sales.lead-gen",
+    table: "acq_list_companies",
+    stateCatalogId: "lead-gen.company",
+    links: [
+      { toEntity: "leadgen.list", kind: "belongs-to", via: "list_id", label: "list" },
+      { toEntity: "leadgen.contact", kind: "has-many", via: "company_id", label: "contacts" }
+    ]
+  },
+  {
+    id: "leadgen.contact",
+    order: 50,
+    label: "Lead Contact",
+    description: "A prospect contact discovered or enriched during lead generation.",
+    ownedBySystemId: "sales.lead-gen",
+    table: "acq_list_members",
+    stateCatalogId: "lead-gen.contact",
+    links: [
+      { toEntity: "leadgen.list", kind: "belongs-to", via: "list_id", label: "list" },
+      { toEntity: "leadgen.company", kind: "belongs-to", via: "company_id", label: "company" }
+    ]
+  },
+  {
+    id: "delivery.project",
+    order: 60,
+    label: "Project",
+    description: "A client delivery project.",
+    ownedBySystemId: "projects",
+    table: "projects",
+    links: [
+      { toEntity: "delivery.milestone", kind: "has-many", via: "project_id", label: "milestones" },
+      { toEntity: "delivery.task", kind: "has-many", via: "project_id", label: "tasks" }
+    ]
+  },
+  {
+    id: "delivery.milestone",
+    order: 70,
+    label: "Milestone",
+    description: "A delivery checkpoint within a project.",
+    ownedBySystemId: "projects",
+    table: "project_milestones",
+    links: [
+      { toEntity: "delivery.project", kind: "belongs-to", via: "project_id", label: "project" },
+      { toEntity: "delivery.task", kind: "has-many", via: "milestone_id", label: "tasks" }
+    ]
+  },
+  {
+    id: "delivery.task",
+    order: 80,
+    label: "Task",
+    description: "A delivery task that can move through the task status catalog.",
+    ownedBySystemId: "projects",
+    table: "project_tasks",
+    stateCatalogId: "delivery.task",
+    links: [
+      { toEntity: "delivery.project", kind: "belongs-to", via: "project_id", label: "project" },
+      { toEntity: "delivery.milestone", kind: "belongs-to", via: "milestone_id", label: "milestone" }
+    ]
+  }
+];
+var DEFAULT_ORGANIZATION_MODEL_ENTITIES = Object.fromEntries(
+  ENTITY_ENTRY_INPUTS.map((entity) => {
+    const parsed = EntitySchema.parse(entity);
+    return [parsed.id, parsed];
+  })
+);
+
+// src/organization-model/domains/actions.ts
+var ActionResourceIdSchema = z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, "Resource IDs must use letters, numbers, -, _, or . separators");
+z.enum(["slash-command", "mcp-tool", "api-endpoint", "script-execution"]).meta({ label: "Invocation kind" });
+var ActionIdSchema = ModelIdSchema;
+var ActionScopeSchema = z.union([
+  z.literal("global"),
+  z.object({
+    domain: ModelIdSchema
+  })
+]);
+var ActionRefSchema = z.object({
+  actionId: ActionIdSchema.meta({ ref: "action" }),
+  intent: z.enum(["exposes", "consumes"]).meta({ label: "Intent" })
+});
+var SlashCommandInvocationSchema = z.object({
+  kind: z.literal("slash-command"),
+  command: z.string().trim().min(1).max(200).regex(/^\/[^\s].*$/, "Slash commands must start with /"),
+  toolFactory: ModelIdSchema.optional()
+});
+var McpToolInvocationSchema = z.object({
+  kind: z.literal("mcp-tool"),
+  server: ModelIdSchema,
+  name: ModelIdSchema
+});
+var ApiEndpointInvocationSchema = z.object({
+  kind: z.literal("api-endpoint"),
+  method: z.enum(["GET", "POST", "PATCH", "DELETE"]).meta({ label: "HTTP method" }),
+  path: z.string().trim().startsWith("/").max(500),
+  requestSchema: ModelIdSchema.optional(),
+  responseSchema: ModelIdSchema.optional()
+});
+var ScriptExecutionInvocationSchema = z.object({
+  kind: z.literal("script-execution"),
+  resourceId: ActionResourceIdSchema
+});
+var ActionInvocationSchema = z.discriminatedUnion("kind", [
+  SlashCommandInvocationSchema,
+  McpToolInvocationSchema,
+  ApiEndpointInvocationSchema,
+  ScriptExecutionInvocationSchema
+]);
+var ActionSchema = z.object({
+  id: ActionIdSchema,
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  scope: ActionScopeSchema.default("global"),
+  resourceId: ActionResourceIdSchema.optional(),
+  affects: z.array(EntityIdSchema.meta({ ref: "entity" })).optional(),
+  invocations: z.array(ActionInvocationSchema).default([]),
+  knowledge: z.array(ModelIdSchema.meta({ ref: "knowledge" })).default([]).optional(),
+  lifecycle: z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" }).default("active")
+});
+var ActionsDomainSchema = z.record(z.string(), ActionSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+  message: "Each action entry id must match its map key"
+}).default({});
+var LEAD_GEN_ACTION_ENTRY_INPUTS = [
+  {
+    id: "lead-gen.company.source",
+    order: 10,
+    label: "Source companies",
+    description: "Import source companies from a list provider.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-import-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/source" }]
+  },
+  {
+    id: "lead-gen.company.apollo-import",
+    order: 20,
+    label: "Import from Apollo",
+    description: "Pull companies and seed contact data from an Apollo search or list.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-01c-apollo-import-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/apollo-import" }]
+  },
+  {
+    id: "lead-gen.contact.discover",
+    order: 30,
+    label: "Discover contact emails",
+    description: "Find email addresses for contacts at qualified companies.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-04-email-discovery-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/contacts/discover" }]
+  },
+  {
+    id: "lead-gen.contact.verify-email",
+    order: 40,
+    label: "Verify emails",
+    description: "Check email deliverability before outreach.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-05-email-verification-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/contacts/verify-email" }]
+  },
+  {
+    id: "lead-gen.company.apify-crawl",
+    order: 50,
+    label: "Crawl websites",
+    description: "Crawl company websites via Apify and store raw page markdown in enrichmentData.websiteCrawl.pages for downstream LLM analysis.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-02a-apify-website-crawl-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/apify-crawl" }]
+  },
+  {
+    id: "lead-gen.company.website-extract",
+    order: 60,
+    label: "Extract website signals",
+    description: "Scrape and analyze company websites for qualification signals.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-02-website-extract-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/website-extract" }]
+  },
+  {
+    id: "lead-gen.company.qualify",
+    order: 70,
+    label: "Qualify companies",
+    description: "Score and filter companies against the ICP rubric.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-03-company-qualification-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/qualify" }]
+  },
+  {
+    id: "lead-gen.company.dtc-subscription-qualify",
+    order: 80,
+    label: "Qualify DTC subscription fit",
+    description: "Classify subscription potential and consumable-product fit for DTC brands.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-03b-dtc-subscription-score-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/dtc-subscription-qualify" }]
+  },
+  {
+    id: "lead-gen.contact.apollo-decision-maker-enrich",
+    order: 90,
+    label: "Enrich decision-makers",
+    description: "Find and enrich qualified contacts at qualified companies via Apollo.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-04b-apollo-decision-maker-enrich-workflow",
+    invocations: [
+      { kind: "api-endpoint", method: "POST", path: "/api/prospecting/contacts/apollo-decision-maker-enrich" }
+    ]
+  },
+  {
+    id: "lead-gen.contact.personalize",
+    order: 100,
+    label: "Personalize outreach",
+    description: "Generate personalized opening lines for each contact.",
+    scope: { domain: "sales" },
+    resourceId: "ist-personalization-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/contacts/personalize" }]
+  },
+  {
+    id: "lead-gen.review.outreach-ready",
+    order: 110,
+    label: "Upload to outreach",
+    description: "Upload approved contacts to the outreach sequence after QC review.",
+    scope: { domain: "sales" },
+    resourceId: "ist-upload-contacts-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/review/outreach-ready" }]
+  },
+  {
+    id: "lead-gen.export.list",
+    order: 120,
+    label: "Export lead list",
+    description: "Export approved leads as a downloadable lead list.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-06-export-list-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/export/list" }]
+  },
+  {
+    id: "lead-gen.company.cleanup",
+    order: 130,
+    label: "Clean up companies",
+    description: "Remove disqualified or duplicate companies from the list.",
+    scope: { domain: "sales" },
+    resourceId: "lgn-company-cleanup-workflow",
+    invocations: [{ kind: "api-endpoint", method: "POST", path: "/api/prospecting/companies/cleanup" }]
+  }
+];
+var LEAD_GEN_ACTION_ENTRIES = Object.fromEntries(
+  LEAD_GEN_ACTION_ENTRY_INPUTS.map((action) => {
+    const parsed = ActionSchema.parse(action);
+    return [parsed.id, parsed];
+  })
+);
+var DEFAULT_ORGANIZATION_MODEL_ACTIONS = LEAD_GEN_ACTION_ENTRIES;
+
+// 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 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-scoped operational data, co-located with the owning system.
+   * Per L1, L3, L13: keyed by local NodeId (the key is the local id; qualified
+   * id is `<system-path>:<local-id>`, computed by graph projection).
+   * Per L14: every ContentNode carries both `kind` and `type`.
+   * Per D2: unregistered (kind, type) pairs parse successfully.
+   */
+  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.
+   */
+  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) => {
+  if (system.status === void 0) return system;
+  console.warn("[organization-model] System.status is deprecated; use System.lifecycle instead.");
+  return system.lifecycle === void 0 ? { ...system, lifecycle: system.status } : system;
+});
+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 = {};
+
+// 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 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 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
+});
+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 = {};
+
+// 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: z.string().trim().min(1).max(100),
+  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
+   * 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.
    */
@@ -20380,23 +20471,23 @@ var RoleSchema = z.object({
   /**
    * Optional: ID of another role this role reports to.
    * When present, must reference another `roles[].id` in the same organization.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   * Absence indicates a top-level role (no reporting line).
    */
-  reportsToId: z.string().trim().min(1).max(100).optional(),
+  reportsToId: RoleIdSchema.meta({ ref: "role" }).optional(),
   /**
-   * Optional: name or email of the person currently holding this role.
-   * Free-form string — supports "Alice Johnson", "alice@example.com", or
-   * any human-readable identifier. Not validated against any user registry.
+   * Optional: human, agent, or team holder currently filling this role.
+   * Agent holders reference OM Resource IDs and are validated at the model level.
    */
-  heldBy: z.string().trim().max(200).optional()
-});
-var RolesDomainSchema = z.object({
-  roles: z.array(RoleSchema).default([])
+  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 DEFAULT_ORGANIZATION_MODEL_ROLES = {
-  roles: []
-};
+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),
@@ -20420,6 +20511,8 @@ 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),
   /**
@@ -20439,180 +20532,63 @@ var ObjectiveSchema = z.object({
    */
   keyResults: z.array(KeyResultSchema).default([])
 });
-var GoalsDomainSchema = z.object({
-  objectives: z.array(ObjectiveSchema).default([])
-});
-var DEFAULT_ORGANIZATION_MODEL_GOALS = {
-  objectives: []
-};
-var OperationSemanticClassSchema = z.enum(["queue", "executions", "sessions", "notifications", "schedules"]);
-var OperationEntrySchema = z.object({
-  id: z.string().trim().min(1).max(100),
-  label: z.string().trim().min(1).max(120),
-  semanticClass: OperationSemanticClassSchema,
-  /** Optional reference to the feature that owns this runtime entity. */
-  featureId: z.string().trim().min(1).max(100).optional(),
-  /**
-   * Optional pointer to the status semanticClass values that apply to this
-   * entity — ties operations back to the statuses domain for vibe rendering.
-   */
-  supportedStatusSemanticClass: z.array(z.string().trim().min(1).max(80)).optional()
-});
-var OperationsDomainSchema = z.object({
-  entries: z.array(OperationEntrySchema).default([])
+var GoalsDomainSchema = z.record(z.string(), ObjectiveSchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+  message: "Each objective entry id must match its map key"
+}).default({});
+var DEFAULT_ORGANIZATION_MODEL_GOALS = {};
+var KnowledgeTargetKindSchema = z.enum([
+  "system",
+  "resource",
+  "knowledge",
+  "stage",
+  "action",
+  "role",
+  "goal",
+  "customer-segment",
+  "offering",
+  // 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>'
+  // which contains a colon separator and cannot satisfy ModelIdSchema. Use a permissive
+  // string schema here; business-logic validation of target existence is done in
+  // OrganizationModelSchema.superRefine (knowledgeTargetExists).
+  id: z.string().trim().min(1).max(300)
 });
-var DEFAULT_ORGANIZATION_MODEL_OPERATIONS = {
-  entries: [
-    // --- queue (HITL command queue) ---
-    {
-      id: "operations.queue",
-      label: "HITL Queue",
-      semanticClass: "queue",
-      featureId: "operations",
-      supportedStatusSemanticClass: ["queue"]
-    },
-    // --- executions (workflow / agent executions) ---
-    {
-      id: "operations.executions",
-      label: "Executions",
-      semanticClass: "executions",
-      featureId: "operations",
-      supportedStatusSemanticClass: ["execution"]
-    },
-    // --- sessions (agent conversation sessions) ---
-    {
-      id: "operations.sessions",
-      label: "Sessions",
-      semanticClass: "sessions",
-      featureId: "operations"
-    },
-    // --- notifications (platform in-app notifications) ---
-    {
-      id: "operations.notifications",
-      label: "Notifications",
-      semanticClass: "notifications",
-      featureId: "monitoring"
-    },
-    // --- schedules (task scheduler) ---
-    {
-      id: "operations.schedules",
-      label: "Schedules",
-      semanticClass: "schedules",
-      featureId: "operations",
-      supportedStatusSemanticClass: ["schedule", "schedule.run"]
-    }
-  ]
-};
-var StatusSemanticClassSchema = z.enum([
-  "delivery.task",
-  "delivery.project",
-  "delivery.milestone",
-  "queue",
-  "execution",
-  "schedule",
-  "schedule.run",
-  "request"
-]);
-var StatusEntrySchema = z.object({
-  id: z.string().trim().min(1).max(100),
-  label: z.string().trim().min(1).max(120),
-  semanticClass: StatusSemanticClassSchema,
-  category: z.string().trim().min(1).max(80).optional()
+var LegacyKnowledgeLinkSchema = z.object({
+  nodeId: NodeIdStringSchema
 });
-var StatusesDomainSchema = z.object({
-  entries: z.array(StatusEntrySchema).default([])
+var CanonicalKnowledgeLinkSchema = z.object({
+  target: KnowledgeTargetRefSchema
 });
-var DEFAULT_ORGANIZATION_MODEL_STATUSES = {
-  entries: [
-    // --- delivery.task (TaskStatus — 9 values) ---
-    { id: "delivery.task.planned", label: "Planned", semanticClass: "delivery.task", category: "delivery" },
-    { id: "delivery.task.in_progress", label: "In Progress", semanticClass: "delivery.task", category: "delivery" },
-    { id: "delivery.task.blocked", label: "Blocked", semanticClass: "delivery.task", category: "delivery" },
-    { id: "delivery.task.submitted", label: "Submitted", semanticClass: "delivery.task", category: "delivery" },
-    { id: "delivery.task.approved", label: "Approved", semanticClass: "delivery.task", category: "delivery" },
-    {
-      id: "delivery.task.revision_requested",
-      label: "Revision Requested",
-      semanticClass: "delivery.task",
-      category: "delivery"
-    },
-    { id: "delivery.task.rejected", label: "Rejected", semanticClass: "delivery.task", category: "delivery" },
-    { id: "delivery.task.cancelled", label: "Cancelled", semanticClass: "delivery.task", category: "delivery" },
-    { id: "delivery.task.completed", label: "Completed", semanticClass: "delivery.task", category: "delivery" },
-    // --- delivery.project (ProjectStatus — 6 values) ---
-    { id: "delivery.project.active", label: "Active", semanticClass: "delivery.project", category: "delivery" },
-    { id: "delivery.project.on_track", label: "On Track", semanticClass: "delivery.project", category: "delivery" },
-    { id: "delivery.project.at_risk", label: "At Risk", semanticClass: "delivery.project", category: "delivery" },
-    { id: "delivery.project.blocked", label: "Blocked", semanticClass: "delivery.project", category: "delivery" },
-    { id: "delivery.project.paused", label: "Paused", semanticClass: "delivery.project", category: "delivery" },
-    { id: "delivery.project.completed", label: "Completed", semanticClass: "delivery.project", category: "delivery" },
-    // --- delivery.milestone (MilestoneStatus — 5 values) ---
-    {
-      id: "delivery.milestone.upcoming",
-      label: "Upcoming",
-      semanticClass: "delivery.milestone",
-      category: "delivery"
-    },
-    {
-      id: "delivery.milestone.in_progress",
-      label: "In Progress",
-      semanticClass: "delivery.milestone",
-      category: "delivery"
-    },
-    {
-      id: "delivery.milestone.blocked",
-      label: "Blocked",
-      semanticClass: "delivery.milestone",
-      category: "delivery"
-    },
-    { id: "delivery.milestone.overdue", label: "Overdue", semanticClass: "delivery.milestone", category: "delivery" },
-    {
-      id: "delivery.milestone.completed",
-      label: "Completed",
-      semanticClass: "delivery.milestone",
-      category: "delivery"
-    },
-    // --- queue (QueueTaskStatus — 5 values, maps hitl/command-queue tasks) ---
-    { id: "queue.pending", label: "Pending", semanticClass: "queue", category: "queue" },
-    { id: "queue.processing", label: "Processing", semanticClass: "queue", category: "queue" },
-    { id: "queue.completed", label: "Completed", semanticClass: "queue", category: "queue" },
-    { id: "queue.failed", label: "Failed", semanticClass: "queue", category: "queue" },
-    { id: "queue.expired", label: "Expired", semanticClass: "queue", category: "queue" },
-    // --- execution (ExecutionStatus — 5 values) ---
-    { id: "execution.pending", label: "Pending", semanticClass: "execution", category: "execution" },
-    { id: "execution.running", label: "Running", semanticClass: "execution", category: "execution" },
-    { id: "execution.completed", label: "Completed", semanticClass: "execution", category: "execution" },
-    { id: "execution.failed", label: "Failed", semanticClass: "execution", category: "execution" },
-    { id: "execution.warning", label: "Warning", semanticClass: "execution", category: "execution" },
-    // --- schedule (schedule status — 4 values) ---
-    { id: "schedule.active", label: "Active", semanticClass: "schedule", category: "schedule" },
-    { id: "schedule.paused", label: "Paused", semanticClass: "schedule", category: "schedule" },
-    { id: "schedule.completed", label: "Completed", semanticClass: "schedule", category: "schedule" },
-    { id: "schedule.cancelled", label: "Cancelled", semanticClass: "schedule", category: "schedule" },
-    // --- schedule.run (schedule run status — 4 values) ---
-    { id: "schedule.run.running", label: "Running", semanticClass: "schedule.run", category: "schedule" },
-    { id: "schedule.run.completed", label: "Completed", semanticClass: "schedule.run", category: "schedule" },
-    { id: "schedule.run.failed", label: "Failed", semanticClass: "schedule.run", category: "schedule" },
-    { id: "schedule.run.cancelled", label: "Cancelled", semanticClass: "schedule.run", category: "schedule" },
-    // --- request (RequestStatus — 4 values, maps reported_requests) ---
-    { id: "request.open", label: "Open", semanticClass: "request", category: "request" },
-    { id: "request.investigating", label: "Investigating", semanticClass: "request", category: "request" },
-    { id: "request.resolved", label: "Resolved", semanticClass: "request", category: "request" },
-    { id: "request.wont_fix", label: "Won't Fix", semanticClass: "request", category: "request" }
-  ]
-};
-var KnowledgeLinkSchema = z.object({
-  nodeId: NodeIdStringSchema
+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 KnowledgeSkillBindingSchema = z.string().trim().min(1).max(120);
-var KnowledgeDomainBindingSchema = z.string().trim().min(1).max(80);
-var OrgKnowledgeKindSchema = z.enum(["playbook", "strategy", "reference"]);
+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(),
   /** Raw MDX string. Phase 2 will introduce a structured block format. */
   body: z.string().trim().min(1),
   /**
@@ -20620,36 +20596,154 @@ var OrgKnowledgeNodeSchema = z.object({
    * Each link emits a `governs` edge: knowledge-node -> target node.
    */
   links: z.array(KnowledgeLinkSchema).default([]),
-  /** Operator skill or command bindings relevant to this node. */
-  skills: z.array(KnowledgeSkillBindingSchema).optional(),
-  /** Domain key used to derive fast graph->skill registries. */
-  domain: KnowledgeDomainBindingSchema.optional(),
-  /** Identifiers of the roles or members who own this knowledge node. */
-  ownerIds: z.array(ModelIdSchema).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.object({
-  nodes: z.array(OrgKnowledgeNodeSchema).default([])
+var KnowledgeDomainSchema = z.record(ModelIdSchema, OrgKnowledgeNodeSchema).default({});
+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 = {};
 
 // src/organization-model/schema.ts
+z.enum([
+  "branding",
+  "identity",
+  "customers",
+  "offerings",
+  "roles",
+  "goals",
+  "systems",
+  "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" },
+  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,
+  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),
-  features: z.array(FeatureSchema).default([]),
+  domainMetadata: OrganizationModelDomainMetadataByDomainSchema,
   branding: OrganizationModelBrandingSchema,
-  navigation: OrganizationModelNavigationSchema.default({ surfaces: [], groups: [] }),
-  sales: OrganizationModelSalesSchema,
-  prospecting: OrganizationModelProspectingSchema,
-  projects: OrganizationModelProjectsSchema,
+  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),
-  statuses: StatusesDomainSchema.default({ entries: [] }),
-  operations: OperationsDomainSchema.default({ entries: [] }),
-  knowledge: KnowledgeDomainSchema.default({ nodes: [] })
+  systems: SystemsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_SYSTEMS),
+  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({
@@ -20658,470 +20752,1245 @@ function addIssue(ctx, path, message) {
     message
   });
 }
-function collectIds(items, ctx, collectionPath, label) {
-  const itemsById = /* @__PURE__ */ new Map();
-  items.forEach((item, index2) => {
-    if (itemsById.has(item.id)) {
-      addIssue(ctx, [...collectionPath, index2, "id"], `${label} id "${item.id}" must be unique`);
-      return;
+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"].includes(targetKind);
+  }
+  if (knowledgeKind === "strategy") {
+    return ["system", "goal", "offering", "customer-segment"].includes(targetKind);
+  }
+  return false;
+}
+var OrganizationModelSchema = 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 });
+      if (system.subsystems !== void 0) {
+        result.push(...collectAllSystems(system.subsystems, path, [...currentSchemaPath, "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.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.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}"`
+      );
     }
-    itemsById.set(item.id, item);
   });
-  return itemsById;
-}
-var LEGACY_FEATURE_ALIASES = /* @__PURE__ */ new Map([
-  ["crm", "sales.crm"],
-  ["lead-gen", "sales.lead-gen"],
-  ["submitted-requests", "monitoring.submitted-requests"]
-]);
-function hasFeature(featuresById, featureId) {
-  return featuresById.has(featureId) || featuresById.has(LEGACY_FEATURE_ALIASES.get(featureId) ?? "");
-}
-function defaultFeaturePathFor(id) {
-  return `/${id.replaceAll(".", "/")}`;
-}
-var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
-  const featuresById = collectIds(model.features, ctx, ["features"], "Feature");
-  const featureIdsByEffectivePath = /* @__PURE__ */ new Map();
-  model.features.forEach((feature, featureIndex) => {
-    const segments = feature.id.split(".");
-    if (segments.length > 1) {
-      const parentId = segments.slice(0, -1).join(".");
-      if (!featuresById.has(parentId)) {
+  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,
-          ["features", featureIndex, "id"],
-          `Feature "${feature.id}" references unknown parent "${parentId}"`
+          [...path, "targets", "entities", entityIndex],
+          `Sidebar surface "${id}" references unknown entity "${entityId}"`
         );
       }
-    }
-    const hasChildren = model.features.some(
-      (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.id !== feature.id
-    );
-    const contributesRoutePath = feature.path !== void 0 || !hasChildren;
-    if (contributesRoutePath) {
-      const effectivePath = feature.path ?? defaultFeaturePathFor(feature.id);
-      const existingFeatureId = featureIdsByEffectivePath.get(effectivePath);
-      if (existingFeatureId !== void 0) {
+    });
+    node.targets?.actions?.forEach((actionId, actionIndex) => {
+      if (!actionsById.has(actionId)) {
         addIssue(
           ctx,
-          ["features", featureIndex, feature.path === void 0 ? "id" : "path"],
-          `Feature "${feature.id}" effective path "${effectivePath}" duplicates feature "${existingFeatureId}"`
+          [...path, "targets", "actions", actionIndex],
+          `Sidebar surface "${id}" references unknown action "${actionId}"`
         );
-      } else {
-        featureIdsByEffectivePath.set(effectivePath, feature.id);
       }
-    }
-    if (hasChildren && feature.enabled) {
-      const hasEnabledDescendant = model.features.some(
-        (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.enabled
+    });
+  });
+  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}"`
       );
-      if (!hasEnabledDescendant) {
+    }
+    entity.links?.forEach((link, linkIndex) => {
+      if (!entitiesById.has(link.toEntity)) {
         addIssue(
           ctx,
-          ["features", featureIndex, "enabled"],
-          `Feature "${feature.id}" is enabled but has no enabled descendants`
+          ["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}"`
+      );
     }
   });
-  const surfacesById = collectIds(model.navigation.surfaces, ctx, ["navigation", "surfaces"], "Navigation surface");
-  if (model.navigation.defaultSurfaceId !== void 0 && !surfacesById.has(model.navigation.defaultSurfaceId)) {
-    addIssue(
-      ctx,
-      ["navigation", "defaultSurfaceId"],
-      `Navigation defaultSurfaceId references unknown surface "${model.navigation.defaultSurfaceId}"`
-    );
-  }
-  model.navigation.groups.forEach((group, groupIndex) => {
-    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      if (!surfacesById.has(surfaceId)) {
+  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,
-          ["navigation", "groups", groupIndex, "surfaceIds", surfaceIndex],
-          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
+          ["roles", role.id, "responsibleFor", systemIndex],
+          `Role "${role.id}" references unknown responsibleFor system "${systemId}"`
         );
       }
     });
   });
-  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
-    if (surface.featureId !== void 0 && !hasFeature(featuresById, surface.featureId)) {
+  allSystems.forEach(({ schemaPath, system }) => {
+    if (system.responsibleRoleId !== void 0 && !rolesById.has(system.responsibleRoleId)) {
       addIssue(
         ctx,
-        ["navigation", "surfaces", surfaceIndex, "featureId"],
-        `Navigation surface "${surface.id}" references unknown feature "${surface.featureId}"`
+        [...schemaPath, "responsibleRoleId"],
+        `System "${system.id}" references unknown responsibleRoleId "${system.responsibleRoleId}"`
       );
     }
-    surface.featureIds.forEach((featureId, featureIndex) => {
-      if (!hasFeature(featuresById, featureId)) {
+    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,
-          ["navigation", "surfaces", surfaceIndex, "featureIds", featureIndex],
-          `Navigation surface "${surface.id}" references unknown feature "${featureId}"`
+          [...schemaPath, "policies", policyIndex],
+          `System "${system.id}" references unknown policy "${policyId}"`
         );
       }
     });
   });
-  const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]));
-  model.offerings.products.forEach((product, productIndex) => {
-    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
-      if (!segmentsById.has(segmentId)) {
+  Object.values(model.actions).forEach((action) => {
+    action.affects?.forEach((entityId, entityIndex) => {
+      if (!entitiesById.has(entityId)) {
         addIssue(
           ctx,
-          ["offerings", "products", productIndex, "targetSegmentIds", segmentIndex],
-          `Product "${product.id}" references unknown customer segment "${segmentId}"`
+          ["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));
+  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}"`
         );
       }
     });
-    if (product.deliveryFeatureId !== void 0 && !hasFeature(featuresById, product.deliveryFeatureId)) {
+    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,
-        ["offerings", "products", productIndex, "deliveryFeatureId"],
-        `Product "${product.id}" references unknown delivery feature "${product.deliveryFeatureId}"`
+        ["policies", policy.id, "trigger", "actionId"],
+        `Policy "${policy.id}" references unknown trigger action "${policy.trigger.actionId}"`
       );
     }
   });
-  model.goals.objectives.forEach((objective, index2) => {
-    if (objective.periodEnd <= objective.periodStart) {
+  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);
+    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,
-        ["goals", "objectives", index2, "periodEnd"],
-        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
+        ["resources", resource.id, "systemPath"],
+        `Resource "${resource.id}" references unknown system path "${resource.systemPath}"`
       );
     }
-  });
-  const rolesById = new Map(model.roles.roles.map((role) => [role.id, role]));
-  model.roles.roles.forEach((role, roleIndex) => {
-    if (role.reportsToId !== void 0 && !rolesById.has(role.reportsToId)) {
+    if (resource.ownerRoleId !== void 0 && !rolesById.has(resource.ownerRoleId)) {
       addIssue(
         ctx,
-        ["roles", "roles", roleIndex, "reportsToId"],
-        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
+        ["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}"`
       );
     }
   });
+  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 content = system.content;
+    if (content === void 0 || Object.keys(content).length === 0) {
+      if (system.subsystems !== void 0) {
+        Object.entries(system.subsystems).forEach(([childKey, child]) => {
+          validateSystemContent(child, [...systemPath, "subsystems", childKey]);
+        });
+      }
+      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 (system.subsystems !== void 0) {
+      Object.entries(system.subsystems).forEach(([childKey, child]) => {
+        validateSystemContent(child, [...systemPath, "subsystems", childKey]);
+      });
+    }
+  }
+  Object.entries(model.systems).forEach(([systemKey, system]) => {
+    validateSystemContent(system, ["systems", systemKey]);
+  });
 });
 
 // src/organization-model/defaults.ts
-var DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE = {
-  nodes: []
+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: "feature.dashboard",
+        order: 10,
+        targets: { systems: ["dashboard"] }
+      },
+      business: {
+        type: "group",
+        label: "Business",
+        icon: "feature.business",
+        order: 20,
+        children: {
+          sales: {
+            type: "surface",
+            label: "Sales",
+            path: "/sales",
+            surfaceType: "page",
+            icon: "feature.sales",
+            order: 10,
+            targets: { systems: ["sales"] }
+          },
+          clients: {
+            type: "surface",
+            label: "Clients",
+            path: "/clients",
+            surfaceType: "list",
+            icon: "feature.projects",
+            order: 20,
+            targets: { systems: ["clients"] }
+          },
+          projects: {
+            type: "surface",
+            label: "Projects",
+            path: "/projects",
+            surfaceType: "page",
+            icon: "feature.projects",
+            order: 30,
+            targets: { systems: ["projects"] }
+          }
+        }
+      },
+      operations: {
+        type: "group",
+        label: "Operations",
+        icon: "feature.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: "feature.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: "group",
+        label: "Knowledge",
+        icon: "feature.knowledge",
+        order: 50,
+        children: {
+          "knowledge-base": {
+            type: "surface",
+            label: "Knowledge Base",
+            path: "/knowledge",
+            surfaceType: "page",
+            order: 10,
+            targets: { systems: ["knowledge.base"] }
+          },
+          "knowledge-command-view": {
+            type: "surface",
+            label: "Command View",
+            path: "/knowledge/command-view",
+            surfaceType: "graph",
+            order: 20,
+            targets: { systems: ["knowledge.command-view"] },
+            devOnly: true
+          }
+        }
+      }
+    },
+    bottom: {
+      settings: {
+        type: "group",
+        label: "Settings",
+        icon: "feature.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: "feature.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,
-  features: [
-    {
+  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: "feature.dashboard",
-      uiPosition: "sidebar-primary"
+      icon: "feature.dashboard"
     },
-    {
-      id: "identity",
-      label: "Identity",
-      description: "Company identity, positioning, and market context",
-      enabled: true,
-      color: "indigo"
-    },
-    {
+    platform: {
       id: "platform",
+      order: 30,
       label: "Platform",
       description: "Elevasis platform architecture, capabilities, and implementation patterns",
       enabled: true,
+      lifecycle: "active",
       color: "cyan",
       icon: "feature.platform"
     },
-    {
+    finance: {
       id: "finance",
+      order: 40,
       label: "Finance",
       description: "Finance operations, accounting, billing, reconciliation, and tax prep",
       enabled: true,
+      lifecycle: "active",
       color: "green",
       icon: "feature.finance"
     },
-    {
+    sales: {
       id: "sales",
+      order: 60,
       label: "Sales",
       description: "Revenue workflows and customer acquisition",
       enabled: true,
+      lifecycle: "active",
       color: "blue",
       icon: "feature.sales",
-      uiPosition: "sidebar-primary"
+      path: "/sales"
     },
-    {
+    "sales.crm": {
       id: "sales.crm",
+      order: 70,
       label: "CRM",
       description: "Relationship pipeline and deal management",
       enabled: true,
+      lifecycle: "active",
       color: "blue",
       icon: "feature.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(DEFAULT_ORGANIZATION_MODEL_ACTIONS).map((action) => ({
+        actionId: action.id,
+        intent: "exposes"
+      })),
       color: "cyan",
       icon: "feature.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: "feature.projects",
-      path: "/projects",
-      uiPosition: "sidebar-primary"
+      path: "/projects"
     },
-    {
+    clients: {
+      id: "clients",
+      order: 100,
+      label: "Clients",
+      description: "Client relationships, accounts, and business context",
+      enabled: true,
+      lifecycle: "active",
+      color: "orange",
+      icon: "feature.projects",
+      path: "/clients"
+    },
+    operations: {
       id: "operations",
+      order: 110,
       label: "Operations",
       description: "Operational resources, topology, and orchestration visibility",
       enabled: true,
+      lifecycle: "active",
       color: "violet",
-      icon: "feature.operations",
-      uiPosition: "sidebar-primary"
+      icon: "feature.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,
-      uiPosition: "sidebar-primary"
+      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: "feature.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,
-      icon: "feature.settings",
-      uiPosition: "sidebar-bottom"
+      lifecycle: "active",
+      icon: "feature.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: "feature.admin",
-      uiPosition: "sidebar-bottom",
       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: "feature.archive",
-      uiPosition: "sidebar-bottom",
       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: "feature.knowledge",
-      uiPosition: "sidebar-primary"
+      icon: "feature.knowledge"
     },
-    {
+    "knowledge.base": {
       id: "knowledge.base",
+      order: 460,
       label: "Knowledge Base",
       enabled: true,
+      lifecycle: "active",
       path: "/knowledge"
     }
-  ],
-  branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-  navigation: { surfaces: [], groups: [] },
-  sales: DEFAULT_ORGANIZATION_MODEL_SALES,
-  prospecting: DEFAULT_ORGANIZATION_MODEL_PROSPECTING,
-  projects: DEFAULT_ORGANIZATION_MODEL_PROJECTS,
-  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,
-  statuses: DEFAULT_ORGANIZATION_MODEL_STATUSES,
-  operations: DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
+  },
+  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; status data lives in system.content.
   knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE
 };
 
@@ -21149,14 +22018,7 @@ function deepMerge2(base, override) {
 }
 function resolveOrganizationModel(override, organizationId) {
   const merged = deepMerge2(DEFAULT_ORGANIZATION_MODEL, override);
-  const model = OrganizationModelSchema.parse(merged);
-  if (!model.sales?.pipelines || model.sales.pipelines.length === 0) {
-    const orgLabel = "Organization";
-    throw new Error(
-      `${orgLabel} has no sales pipeline configuration. This indicates an incomplete provisioning state. Run org provisioning to seed defaults.`
-    );
-  }
-  return model;
+  return OrganizationModelSchema.parse(merged);
 }
 
 // src/test-utils/organization-model.ts