@elevasis/core 0.2.0 → 0.3.0

package/dist/organization-model/index.js

@@ -14,18 +14,11 @@ var DisplayMetadataSchema = z.object({
   color: ColorTokenSchema.optional(),
   icon: IconNameSchema.optional()
 });
-var SemanticDomainSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  entityIds: ReferenceIdsSchema,
-  surfaceIds: ReferenceIdsSchema,
-  resourceIds: ReferenceIdsSchema,
-  capabilityIds: ReferenceIdsSchema
-});
 var ResourceMappingSchema = DisplayMetadataSchema.extend({
   id: ModelIdSchema,
   resourceId: z.string().trim().min(1).max(255),
   resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]),
-  domainIds: ReferenceIdsSchema,
+  featureIds: ReferenceIdsSchema,
   entityIds: ReferenceIdsSchema,
   surfaceIds: ReferenceIdsSchema,
   capabilityIds: ReferenceIdsSchema
@@ -130,55 +123,18 @@ var DEFAULT_ORGANIZATION_MODEL_DELIVERY = {
     { id: "completed", label: "Completed", order: 9 }
   ]
 };
-var FeatureKeySchema = z.enum([
-  "acquisition",
-  "delivery",
-  "operations",
-  "monitoring",
-  "settings",
-  "seo",
-  "calibration"
-]);
-var OrganizationModelFeaturesSchema = z.object({
-  enabled: z.object({
-    acquisition: z.boolean().default(true),
-    delivery: z.boolean().default(true),
-    operations: z.boolean().default(true),
-    monitoring: z.boolean().default(true),
-    settings: z.boolean().default(true),
-    seo: z.boolean().default(false),
-    calibration: z.boolean().default(false)
-  }).default({
-    acquisition: true,
-    delivery: true,
-    operations: true,
-    monitoring: true,
-    settings: true,
-    seo: false,
-    calibration: false
-  }),
-  labels: z.object({
-    acquisition: z.string().trim().min(1).max(80).optional(),
-    delivery: z.string().trim().min(1).max(80).optional(),
-    operations: z.string().trim().min(1).max(80).optional(),
-    monitoring: z.string().trim().min(1).max(80).optional(),
-    settings: z.string().trim().min(1).max(80).optional(),
-    seo: z.string().trim().min(1).max(80).optional(),
-    calibration: z.string().trim().min(1).max(80).optional()
-  }).default({})
+var FeatureSchema = z.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  enabled: z.boolean().default(true),
+  color: ColorTokenSchema.optional(),
+  icon: IconNameSchema.optional(),
+  entityIds: ReferenceIdsSchema,
+  surfaceIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema,
+  capabilityIds: ReferenceIdsSchema
 });
-var DEFAULT_ORGANIZATION_MODEL_FEATURES = {
-  enabled: {
-    acquisition: true,
-    delivery: true,
-    operations: true,
-    monitoring: true,
-    settings: true,
-    seo: false,
-    calibration: false
-  },
-  labels: {}
-};
 var LeadGenLifecycleStageSchema = DisplayMetadataSchema.extend({
   id: ModelIdSchema,
   order: z.number().int().min(0)
@@ -207,6 +163,13 @@ var DEFAULT_ORGANIZATION_MODEL_LEAD_GEN = {
     { id: "uploaded", label: "Uploaded", order: 4 }
   ]
 };
+
+// src/organization-model/contracts.ts
+var PROJECTS_FEATURE_ID = "projects";
+var PROJECTS_INDEX_SURFACE_ID = "projects.index";
+var DELIVERY_PROJECTS_VIEW_CAPABILITY_ID = "delivery.projects.view";
+
+// src/organization-model/domains/navigation.ts
 var SurfaceTypeSchema = z.enum(["page", "dashboard", "graph", "detail", "list", "settings"]);
 var SurfaceDefinitionSchema = z.object({
   id: ModelIdSchema,
@@ -215,8 +178,8 @@ var SurfaceDefinitionSchema = z.object({
   surfaceType: SurfaceTypeSchema,
   description: DescriptionSchema.optional(),
   icon: IconNameSchema.optional(),
-  featureKey: FeatureKeySchema.optional(),
-  domainIds: ReferenceIdsSchema,
+  featureId: ModelIdSchema.optional(),
+  featureIds: ReferenceIdsSchema,
   entityIds: ReferenceIdsSchema,
   resourceIds: ReferenceIdsSchema,
   capabilityIds: ReferenceIdsSchema,
@@ -241,8 +204,8 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
       label: "Pipeline",
       path: "/crm/pipeline",
       surfaceType: "graph",
-      featureKey: "acquisition",
-      domainIds: ["crm"],
+      featureId: "crm",
+      featureIds: ["crm"],
       entityIds: ["crm.deal"],
       resourceIds: [],
       capabilityIds: ["crm.pipeline.manage"]
@@ -252,30 +215,30 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
       label: "Lists",
       path: "/lead-gen/lists",
       surfaceType: "list",
-      featureKey: "acquisition",
-      domainIds: ["lead-gen"],
+      featureId: "lead-gen",
+      featureIds: ["lead-gen"],
       entityIds: ["leadgen.list"],
       resourceIds: [],
       capabilityIds: ["leadgen.lists.manage"]
     },
     {
-      id: "projects.index",
+      id: PROJECTS_INDEX_SURFACE_ID,
       label: "Projects",
       path: "/projects",
       surfaceType: "list",
-      featureKey: "delivery",
-      domainIds: ["delivery"],
+      featureId: PROJECTS_FEATURE_ID,
+      featureIds: [PROJECTS_FEATURE_ID],
       entityIds: ["delivery.project"],
       resourceIds: [],
-      capabilityIds: ["delivery.projects.view"]
+      capabilityIds: [DELIVERY_PROJECTS_VIEW_CAPABILITY_ID]
     },
     {
       id: "operations.organization-graph",
       label: "Organization Graph",
       path: "/operations/organization-graph",
       surfaceType: "graph",
-      featureKey: "operations",
-      domainIds: ["operations"],
+      featureId: "operations",
+      featureIds: ["operations"],
       entityIds: [],
       resourceIds: [],
       capabilityIds: ["operations.organization-graph"]
@@ -285,15 +248,20 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
       label: "Command View",
       path: "/operations/command-view",
       surfaceType: "graph",
-      featureKey: "operations",
-      domainIds: ["operations"],
+      featureId: "operations",
+      featureIds: ["operations"],
       entityIds: [],
       resourceIds: [],
       capabilityIds: ["operations.command-view"]
     }
   ],
   groups: [
-    { id: "primary-workspace", label: "Workspace", placement: "primary", surfaceIds: ["crm.pipeline", "lead-gen.lists", "projects.index"] },
+    {
+      id: "primary-workspace",
+      label: "Workspace",
+      placement: "primary",
+      surfaceIds: ["crm.pipeline", "lead-gen.lists", PROJECTS_INDEX_SURFACE_ID]
+    },
     {
       id: "primary-operations",
       label: "Operations",
@@ -306,9 +274,8 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
 // src/organization-model/schema.ts
 var OrganizationModelSchemaBase = z.object({
   version: z.literal(1).default(1),
-  domains: z.array(SemanticDomainSchema).default([]),
+  features: z.array(FeatureSchema).default([]),
   branding: OrganizationModelBrandingSchema,
-  features: OrganizationModelFeaturesSchema,
   navigation: OrganizationModelNavigationSchema,
   crm: OrganizationModelCrmSchema,
   leadGen: OrganizationModelLeadGenSchema,
@@ -334,7 +301,7 @@ function collectIds(items, ctx, collectionPath, label) {
   return itemsById;
 }
 var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
-  const domainsById = collectIds(model.domains, ctx, ["domains"], "Domain");
+  const featuresById = collectIds(model.features, ctx, ["features"], "Feature");
   const surfacesById = collectIds(model.navigation.surfaces, ctx, ["navigation", "surfaces"], "Surface");
   collectIds(model.navigation.groups, ctx, ["navigation", "groups"], "Navigation group");
   collectIds(model.resourceMappings, ctx, ["resourceMappings"], "Resource mapping");
@@ -368,40 +335,40 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
       }
     });
   });
-  model.domains.forEach((domain, domainIndex) => {
-    domain.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+  model.features.forEach((feature, featureIndex) => {
+    feature.surfaceIds.forEach((surfaceId, surfaceIndex) => {
       const surface = surfacesById.get(surfaceId);
       if (!surface) {
         addIssue(
           ctx,
-          ["domains", domainIndex, "surfaceIds", surfaceIndex],
-          `Domain "${domain.id}" references unknown surface "${surfaceId}"`
+          ["features", featureIndex, "surfaceIds", surfaceIndex],
+          `Feature "${feature.id}" references unknown surface "${surfaceId}"`
         );
         return;
       }
-      if (!surface.domainIds.includes(domain.id)) {
+      if (!surface.featureIds.includes(feature.id)) {
         addIssue(
           ctx,
-          ["domains", domainIndex, "surfaceIds", surfaceIndex],
-          `Domain "${domain.id}" references surface "${surfaceId}" but that surface does not include domain "${domain.id}"`
+          ["features", featureIndex, "surfaceIds", surfaceIndex],
+          `Feature "${feature.id}" references surface "${surfaceId}" but that surface does not include feature "${feature.id}"`
         );
       }
     });
-    domain.resourceIds.forEach((resourceId, resourceIndex) => {
+    feature.resourceIds.forEach((resourceId, resourceIndex) => {
       const resourceMapping = resourceMappingsByResourceId.get(resourceId);
       if (!resourceMapping) {
         addIssue(
           ctx,
-          ["domains", domainIndex, "resourceIds", resourceIndex],
-          `Domain "${domain.id}" references unknown resource "${resourceId}"`
+          ["features", featureIndex, "resourceIds", resourceIndex],
+          `Feature "${feature.id}" references unknown resource "${resourceId}"`
         );
         return;
       }
-      if (!resourceMapping.domainIds.includes(domain.id)) {
+      if (!resourceMapping.featureIds.includes(feature.id)) {
         addIssue(
           ctx,
-          ["domains", domainIndex, "resourceIds", resourceIndex],
-          `Domain "${domain.id}" references resource "${resourceId}" but that resource mapping does not include domain "${domain.id}"`
+          ["features", featureIndex, "resourceIds", resourceIndex],
+          `Feature "${feature.id}" references resource "${resourceId}" but that resource mapping does not include feature "${feature.id}"`
         );
       }
     });
@@ -414,21 +381,21 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
         `Surface "${surface.id}" references unknown parent surface "${surface.parentId}"`
       );
     }
-    surface.domainIds.forEach((domainId, domainIndex) => {
-      const domain = domainsById.get(domainId);
-      if (!domain) {
+    surface.featureIds.forEach((featureId, featureIndex) => {
+      const feature = featuresById.get(featureId);
+      if (!feature) {
         addIssue(
           ctx,
-          ["navigation", "surfaces", surfaceIndex, "domainIds", domainIndex],
-          `Surface "${surface.id}" references unknown domain "${domainId}"`
+          ["navigation", "surfaces", surfaceIndex, "featureIds", featureIndex],
+          `Surface "${surface.id}" references unknown feature "${featureId}"`
         );
         return;
       }
-      if (!domain.surfaceIds.includes(surface.id)) {
+      if (!feature.surfaceIds.includes(surface.id)) {
         addIssue(
           ctx,
-          ["navigation", "surfaces", surfaceIndex, "domainIds", domainIndex],
-          `Surface "${surface.id}" references domain "${domainId}" but that domain does not include surface "${surface.id}"`
+          ["navigation", "surfaces", surfaceIndex, "featureIds", featureIndex],
+          `Surface "${surface.id}" references feature "${featureId}" but that feature does not include surface "${surface.id}"`
         );
       }
     });
@@ -452,21 +419,21 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
     });
   });
   model.resourceMappings.forEach((resourceMapping, resourceIndex) => {
-    resourceMapping.domainIds.forEach((domainId, domainIndex) => {
-      const domain = domainsById.get(domainId);
-      if (!domain) {
+    resourceMapping.featureIds.forEach((featureId, featureIndex) => {
+      const feature = featuresById.get(featureId);
+      if (!feature) {
         addIssue(
           ctx,
-          ["resourceMappings", resourceIndex, "domainIds", domainIndex],
-          `Resource mapping "${resourceMapping.id}" references unknown domain "${domainId}"`
+          ["resourceMappings", resourceIndex, "featureIds", featureIndex],
+          `Resource mapping "${resourceMapping.id}" references unknown feature "${featureId}"`
         );
         return;
       }
-      if (!domain.resourceIds.includes(resourceMapping.resourceId)) {
+      if (!feature.resourceIds.includes(resourceMapping.resourceId)) {
         addIssue(
           ctx,
-          ["resourceMappings", resourceIndex, "domainIds", domainIndex],
-          `Resource mapping "${resourceMapping.id}" references domain "${domainId}" but that domain does not include resource "${resourceMapping.resourceId}"`
+          ["resourceMappings", resourceIndex, "featureIds", featureIndex],
+          `Resource mapping "${resourceMapping.id}" references feature "${featureId}" but that feature does not include resource "${resourceMapping.resourceId}"`
         );
       }
     });
@@ -494,11 +461,12 @@ var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ct
 // src/organization-model/defaults.ts
 var DEFAULT_ORGANIZATION_MODEL = {
   version: 1,
-  domains: [
+  features: [
     {
       id: "crm",
       label: "CRM",
       description: "Relationship pipeline and deal management",
+      enabled: true,
       color: "blue",
       entityIds: ["crm.deal"],
       surfaceIds: ["crm.pipeline"],
@@ -509,6 +477,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
       id: "lead-gen",
       label: "Lead Gen",
       description: "Prospecting, qualification, and outreach preparation",
+      enabled: true,
       color: "cyan",
       entityIds: ["leadgen.list", "leadgen.company", "leadgen.contact"],
       surfaceIds: ["lead-gen.lists"],
@@ -516,28 +485,56 @@ var DEFAULT_ORGANIZATION_MODEL = {
       capabilityIds: ["leadgen.lists.manage"]
     },
     {
-      id: "delivery",
+      id: PROJECTS_FEATURE_ID,
       label: "Projects",
       description: "Projects, milestones, and client work execution",
+      enabled: true,
       color: "orange",
       entityIds: ["delivery.project", "delivery.milestone", "delivery.task"],
-      surfaceIds: ["projects.index"],
+      surfaceIds: [PROJECTS_INDEX_SURFACE_ID],
       resourceIds: [],
-      capabilityIds: ["delivery.projects.view"]
+      capabilityIds: [DELIVERY_PROJECTS_VIEW_CAPABILITY_ID]
     },
     {
       id: "operations",
       label: "Operations",
       description: "Operational resources, topology, and orchestration visibility",
+      enabled: true,
       color: "violet",
       entityIds: [],
       surfaceIds: ["operations.organization-graph", "operations.command-view"],
       resourceIds: [],
       capabilityIds: ["operations.organization-graph", "operations.command-view"]
+    },
+    {
+      id: "monitoring",
+      label: "Monitoring",
+      enabled: true,
+      entityIds: [],
+      surfaceIds: [],
+      resourceIds: [],
+      capabilityIds: []
+    },
+    {
+      id: "settings",
+      label: "Settings",
+      enabled: true,
+      entityIds: [],
+      surfaceIds: [],
+      resourceIds: [],
+      capabilityIds: []
+    },
+    {
+      id: "seo",
+      label: "SEO",
+      enabled: false,
+      entityIds: [],
+      surfaceIds: [],
+      resourceIds: [],
+      capabilityIds: []
     }
   ],
   branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-  features: DEFAULT_ORGANIZATION_MODEL_FEATURES,
   navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION,
   crm: DEFAULT_ORGANIZATION_MODEL_CRM,
   leadGen: DEFAULT_ORGANIZATION_MODEL_LEAD_GEN,
@@ -592,4 +589,60 @@ function resolveOrganizationModel(override) {
   return OrganizationModelSchema.parse(merged);
 }
 
-export { DEFAULT_ORGANIZATION_MODEL, OrganizationModelSchema, defineOrganizationModel, resolveOrganizationModel };
+// src/organization-model/foundation.ts
+function createFoundationOrganizationModel(branding) {
+  const canonical = resolveOrganizationModel({ branding });
+  function requireCoreSurface(surfaceId) {
+    const surface = canonical.navigation.surfaces.find((candidate) => candidate.id === surfaceId);
+    if (!surface) {
+      throw new Error(`Missing organization surface: ${surfaceId}`);
+    }
+    return surface;
+  }
+  const operationsGraphSurface = requireCoreSurface("operations.organization-graph");
+  const projectsSurface = requireCoreSurface(PROJECTS_INDEX_SURFACE_ID);
+  const leadGenSurface = requireCoreSurface("lead-gen.lists");
+  const crmSurface = requireCoreSurface("crm.pipeline");
+  const navigationSurfaces = [
+    { ...operationsGraphSurface, id: "operations", path: "/operations", icon: "operations" },
+    { ...operationsGraphSurface, path: "/operations", icon: "operations" },
+    { ...projectsSurface, id: PROJECTS_FEATURE_ID, icon: "projects" },
+    { ...leadGenSurface, id: "lead-gen", icon: "lead-gen" },
+    { ...crmSurface, id: "crm", icon: "crm" },
+    {
+      id: "settings",
+      label: "Settings",
+      path: "/settings/account",
+      surfaceType: "settings",
+      icon: "settings",
+      featureId: "settings",
+      featureIds: ["settings"],
+      entityIds: [],
+      resourceIds: [],
+      capabilityIds: []
+    }
+  ];
+  const homeLabel = "Dashboard";
+  const quickAccessSurfaceIds = ["operations", PROJECTS_FEATURE_ID, "lead-gen", "crm"];
+  const model = {
+    ...canonical,
+    navigation: {
+      defaultSurfaceId: "operations",
+      homeLabel,
+      quickAccessSurfaceIds: [...quickAccessSurfaceIds],
+      surfaces: navigationSurfaces
+    }
+  };
+  function getOrganizationSurface(surfaceId) {
+    return model.navigation.surfaces.find((candidate) => candidate.id === surfaceId);
+  }
+  return {
+    canonical,
+    model,
+    homeLabel,
+    quickAccessSurfaceIds,
+    getOrganizationSurface
+  };
+}
+
+export { DEFAULT_ORGANIZATION_MODEL, DELIVERY_PROJECTS_VIEW_CAPABILITY_ID, FeatureSchema, OrganizationModelSchema, PROJECTS_FEATURE_ID, PROJECTS_INDEX_SURFACE_ID, createFoundationOrganizationModel, defineOrganizationModel, resolveOrganizationModel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "MIT",
   "description": "Minimal shared constants across Elevasis monorepo",
   "sideEffects": false,

package/src/README.md

@@ -6,26 +6,33 @@ This package is the source of truth for shared types, schemas, and contract help
 
 ## Import Rules
 
-- Use `@elevasis/core` for browser-safe shared types and schemas.
-- Use `@elevasis/core/server` only for Node.js-only helpers and services.
-- Use `@elevasis/core/test-utils` for test fixtures and mocks.
-- Prefer the narrowest published subpath that matches the work you are doing.
+- Use `@elevasis/core` (root export) for browser-safe shared types and schemas.
+- Use `@elevasis/core/organization-model` for the semantic contract layer.
+- These are the only two subpaths available to external consumers of the published npm package.
+- Paths like `@elevasis/core/server`, `@elevasis/core/test-utils`, `@elevasis/core/platform`, etc. are internal monorepo paths (`@repo/core/...`) and are NOT available to external consumers.
 
 ## Published Surface Groups
 
-- `platform` - shared constants, utilities, registry, SSE, and API types.
-- `auth` - multi-tenancy types for organizations, users, memberships, invitations, and credentials.
-- `execution` - workflow, agent, scheduler, calibration, and execution-interface contracts.
-- `commands` - command queue types and schemas.
-- `deployments` - deployment response types.
-- `operations` - sessions, notifications, observability, activities, triggers, and debug logs.
-- `business` - acquisition and SEO contracts, plus the PDF surface under its own subpaths.
-- `organization-model` - the semantic contract layer for CRM, lead gen, delivery, features, branding, and navigation.
-- `supabase` - generated database types and helpers.
-- `forms` - shared form schemas and form-facing types.
-- `integrations` - OAuth and credential contracts.
-- `projects` - project management request and response schemas.
-- `content` - published content metadata types.
+The published `@elevasis/core` npm package exposes exactly two subpaths:
+
+- `.` (`@elevasis/core`) - browser-safe shared types, schemas, and constants.
+- `./organization-model` (`@elevasis/core/organization-model`) - the semantic contract layer for CRM, lead gen, delivery, features, branding, and navigation.
+
+Within the monorepo, the internal `@repo/core` package exposes additional subpaths for use by `apps/` and other packages:
+
+- `@repo/core/server` - Node.js-only helpers and services.
+- `@repo/core/platform` - shared constants, utilities, registry, SSE, and API types.
+- `@repo/core/auth` - multi-tenancy types for organizations, users, memberships, invitations, and credentials.
+- `@repo/core/execution` - workflow, agent, scheduler, and execution-interface contracts.
+- `@repo/core/commands` - command queue types and schemas.
+- `@repo/core/operations` - sessions, notifications, observability, activities, triggers, and debug logs.
+- `@repo/core/supabase` - generated database types and helpers.
+- `@repo/core/integrations/...` - OAuth and credential contracts.
+- `@repo/core/projects/api-schemas` - project management request and response schemas.
+- `@repo/core/content` - published content metadata types.
+- `@repo/core/test-utils` - test fixtures and mocks (internal use only).
+
+These `@repo/core/*` subpaths are NOT available in the published `@elevasis/core` package.
 
 ## When To Read Deeper
 

package/src/__tests__/template-foundations-compatibility.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest'
+import { DELIVERY_PROJECTS_VIEW_CAPABILITY_ID, PROJECTS_FEATURE_ID } from '../organization-model/published'
 import {
   getOrganizationSurface,
   homeLabel,
@@ -14,18 +15,18 @@ describe('template foundations compatibility', () => {
     expect(foundationOrganizationModel.navigation.defaultSurfaceId).toBe('operations')
     expect(getOrganizationSurface('operations')).toMatchObject({
       id: 'operations',
-      label: 'Operations',
+      label: 'Organization Graph',
       path: '/operations',
       surfaceType: 'graph',
-      featureKey: 'operations'
+      featureId: 'operations'
     })
 
     expect(getOrganizationSurface('operations.organization-graph')).toMatchObject({
       id: 'operations.organization-graph',
-      label: 'Operations',
+      label: 'Organization Graph',
       path: '/operations',
       surfaceType: 'graph',
-      featureKey: 'operations'
+      featureId: 'operations'
     })
   })
 
@@ -33,45 +34,41 @@ describe('template foundations compatibility', () => {
     const legacySurfaces = [
       {
         id: 'operations',
-        label: 'Operations',
+        label: 'Organization Graph',
         surfaceType: 'graph',
-        expectedFeatureKey: 'operations',
+        expectedFeatureId: 'operations',
         expectedIcon: 'operations',
         expectedPath: '/operations',
-        expectedDomainIds: ['operations'],
         expectedEntityIds: [],
-        expectedCapabilityIds: ['operations.organization-graph', 'operations.command-view']
+        expectedCapabilityIds: ['operations.organization-graph']
       },
       {
-        id: 'projects',
+        id: PROJECTS_FEATURE_ID,
         label: 'Projects',
         surfaceType: 'list',
-        expectedFeatureKey: 'projects',
+        expectedFeatureId: PROJECTS_FEATURE_ID,
         expectedIcon: 'projects',
         expectedPath: '/projects',
-        expectedDomainIds: ['delivery'],
         expectedEntityIds: ['delivery.project'],
-        expectedCapabilityIds: ['delivery.projects.view']
+        expectedCapabilityIds: [DELIVERY_PROJECTS_VIEW_CAPABILITY_ID]
       },
       {
         id: 'lead-gen',
-        label: 'Lead Gen',
+        label: 'Lists',
         surfaceType: 'list',
-        expectedFeatureKey: 'lead-gen',
+        expectedFeatureId: 'lead-gen',
         expectedIcon: 'lead-gen',
-        expectedPath: '/lead-gen',
-        expectedDomainIds: ['lead-gen'],
+        expectedPath: '/lead-gen/lists',
         expectedEntityIds: ['leadgen.list'],
         expectedCapabilityIds: ['leadgen.lists.manage']
       },
       {
         id: 'crm',
-        label: 'CRM',
+        label: 'Pipeline',
         surfaceType: 'graph',
-        expectedFeatureKey: 'crm',
+        expectedFeatureId: 'crm',
         expectedIcon: 'crm',
-        expectedPath: '/crm',
-        expectedDomainIds: ['crm'],
+        expectedPath: '/crm/pipeline',
         expectedEntityIds: ['crm.deal'],
         expectedCapabilityIds: ['crm.pipeline.manage']
       }
@@ -86,8 +83,7 @@ describe('template foundations compatibility', () => {
         path: surface.expectedPath,
         surfaceType: surface.surfaceType,
         icon: surface.expectedIcon,
-        featureKey: surface.expectedFeatureKey,
-        domainIds: surface.expectedDomainIds,
+        featureId: surface.expectedFeatureId,
         entityIds: surface.expectedEntityIds,
         resourceIds: [],
         capabilityIds: surface.expectedCapabilityIds
@@ -96,20 +92,16 @@ describe('template foundations compatibility', () => {
   })
 
   it('maps grouped core features onto the legacy template feature vocabulary', () => {
-    expect(foundationOrganizationModel.features.enabled.acquisition).toBe(true)
-    expect(foundationOrganizationModel.features.enabled.delivery).toBe(true)
-    expect(foundationOrganizationModel.features.enabled.crm).toBe(
-      foundationOrganizationModel.features.enabled.acquisition
-    )
-    expect(foundationOrganizationModel.features.enabled['lead-gen']).toBe(
-      foundationOrganizationModel.features.enabled.acquisition
-    )
-    expect(foundationOrganizationModel.features.enabled.projects).toBe(
-      foundationOrganizationModel.features.enabled.delivery
-    )
+    const features = foundationOrganizationModel.features as Array<{ id: string; label: string; enabled: boolean }>
+    const featureById = (id: string) => features.find((f) => f.id === id)
 
-    expect(foundationOrganizationModel.features.labels.crm).toBe('CRM')
-    expect(foundationOrganizationModel.features.labels['lead-gen']).toBe('Lead Gen')
-    expect(foundationOrganizationModel.features.labels.projects).toBe('Projects')
+    expect(featureById('crm')?.enabled).toBe(true)
+    expect(featureById('lead-gen')?.enabled).toBe(true)
+    expect(featureById('projects')?.enabled).toBe(true)
+    expect(featureById('operations')?.enabled).toBe(true)
+
+    expect(featureById('crm')?.label).toBe('CRM')
+    expect(featureById('lead-gen')?.label).toBe('Lead Gen')
+    expect(featureById('projects')?.label).toBe('Projects')
   })
 })