@elevasis/core 0.1.0 → 0.2.0

package/dist/index.js

@@ -304,7 +304,7 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
 };
 
 // src/organization-model/schema.ts
-var OrganizationModelSchema = z.object({
+var OrganizationModelSchemaBase = z.object({
   version: z.literal(1).default(1),
   domains: z.array(SemanticDomainSchema).default([]),
   branding: OrganizationModelBrandingSchema,
@@ -315,6 +315,181 @@ var OrganizationModelSchema = z.object({
   delivery: OrganizationModelDeliverySchema,
   resourceMappings: z.array(ResourceMappingSchema).default([])
 });
+function addIssue(ctx, path, message) {
+  ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    path,
+    message
+  });
+}
+function collectIds(items, ctx, collectionPath, label) {
+  const itemsById = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    if (itemsById.has(item.id)) {
+      addIssue(ctx, [...collectionPath, index, "id"], `${label} id "${item.id}" must be unique`);
+      return;
+    }
+    itemsById.set(item.id, item);
+  });
+  return itemsById;
+}
+var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
+  const domainsById = collectIds(model.domains, ctx, ["domains"], "Domain");
+  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");
+  const resourceMappingsByResourceId = /* @__PURE__ */ new Map();
+  model.resourceMappings.forEach((resourceMapping, index) => {
+    if (resourceMappingsByResourceId.has(resourceMapping.resourceId)) {
+      addIssue(
+        ctx,
+        ["resourceMappings", index, "resourceId"],
+        `Resource mapping resourceId "${resourceMapping.resourceId}" must be unique`
+      );
+      return;
+    }
+    resourceMappingsByResourceId.set(resourceMapping.resourceId, resourceMapping);
+  });
+  if (model.navigation.defaultSurfaceId && !surfacesById.has(model.navigation.defaultSurfaceId)) {
+    addIssue(
+      ctx,
+      ["navigation", "defaultSurfaceId"],
+      `Default surface "${model.navigation.defaultSurfaceId}" must reference a declared navigation surface`
+    );
+  }
+  model.navigation.groups.forEach((group, groupIndex) => {
+    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      if (!surfacesById.has(surfaceId)) {
+        addIssue(
+          ctx,
+          ["navigation", "groups", groupIndex, "surfaceIds", surfaceIndex],
+          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
+        );
+      }
+    });
+  });
+  model.domains.forEach((domain, domainIndex) => {
+    domain.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      const surface = surfacesById.get(surfaceId);
+      if (!surface) {
+        addIssue(
+          ctx,
+          ["domains", domainIndex, "surfaceIds", surfaceIndex],
+          `Domain "${domain.id}" references unknown surface "${surfaceId}"`
+        );
+        return;
+      }
+      if (!surface.domainIds.includes(domain.id)) {
+        addIssue(
+          ctx,
+          ["domains", domainIndex, "surfaceIds", surfaceIndex],
+          `Domain "${domain.id}" references surface "${surfaceId}" but that surface does not include domain "${domain.id}"`
+        );
+      }
+    });
+    domain.resourceIds.forEach((resourceId, resourceIndex) => {
+      const resourceMapping = resourceMappingsByResourceId.get(resourceId);
+      if (!resourceMapping) {
+        addIssue(
+          ctx,
+          ["domains", domainIndex, "resourceIds", resourceIndex],
+          `Domain "${domain.id}" references unknown resource "${resourceId}"`
+        );
+        return;
+      }
+      if (!resourceMapping.domainIds.includes(domain.id)) {
+        addIssue(
+          ctx,
+          ["domains", domainIndex, "resourceIds", resourceIndex],
+          `Domain "${domain.id}" references resource "${resourceId}" but that resource mapping does not include domain "${domain.id}"`
+        );
+      }
+    });
+  });
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surface.parentId && !surfacesById.has(surface.parentId)) {
+      addIssue(
+        ctx,
+        ["navigation", "surfaces", surfaceIndex, "parentId"],
+        `Surface "${surface.id}" references unknown parent surface "${surface.parentId}"`
+      );
+    }
+    surface.domainIds.forEach((domainId, domainIndex) => {
+      const domain = domainsById.get(domainId);
+      if (!domain) {
+        addIssue(
+          ctx,
+          ["navigation", "surfaces", surfaceIndex, "domainIds", domainIndex],
+          `Surface "${surface.id}" references unknown domain "${domainId}"`
+        );
+        return;
+      }
+      if (!domain.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}"`
+        );
+      }
+    });
+    surface.resourceIds.forEach((resourceId, resourceIndex) => {
+      const resourceMapping = resourceMappingsByResourceId.get(resourceId);
+      if (!resourceMapping) {
+        addIssue(
+          ctx,
+          ["navigation", "surfaces", surfaceIndex, "resourceIds", resourceIndex],
+          `Surface "${surface.id}" references unknown resource "${resourceId}"`
+        );
+        return;
+      }
+      if (!resourceMapping.surfaceIds.includes(surface.id)) {
+        addIssue(
+          ctx,
+          ["navigation", "surfaces", surfaceIndex, "resourceIds", resourceIndex],
+          `Surface "${surface.id}" references resource "${resourceId}" but that resource mapping does not include surface "${surface.id}"`
+        );
+      }
+    });
+  });
+  model.resourceMappings.forEach((resourceMapping, resourceIndex) => {
+    resourceMapping.domainIds.forEach((domainId, domainIndex) => {
+      const domain = domainsById.get(domainId);
+      if (!domain) {
+        addIssue(
+          ctx,
+          ["resourceMappings", resourceIndex, "domainIds", domainIndex],
+          `Resource mapping "${resourceMapping.id}" references unknown domain "${domainId}"`
+        );
+        return;
+      }
+      if (!domain.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}"`
+        );
+      }
+    });
+    resourceMapping.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      const surface = surfacesById.get(surfaceId);
+      if (!surface) {
+        addIssue(
+          ctx,
+          ["resourceMappings", resourceIndex, "surfaceIds", surfaceIndex],
+          `Resource mapping "${resourceMapping.id}" references unknown surface "${surfaceId}"`
+        );
+        return;
+      }
+      if (!surface.resourceIds.includes(resourceMapping.resourceId)) {
+        addIssue(
+          ctx,
+          ["resourceMappings", resourceIndex, "surfaceIds", surfaceIndex],
+          `Resource mapping "${resourceMapping.id}" references surface "${surfaceId}" but that surface does not include resource "${resourceMapping.resourceId}"`
+        );
+      }
+    });
+  });
+});
 
 // src/organization-model/defaults.ts
 var DEFAULT_ORGANIZATION_MODEL = {
@@ -342,7 +517,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
     },
     {
       id: "delivery",
-      label: "Delivery",
+      label: "Projects",
       description: "Projects, milestones, and client work execution",
       color: "orange",
       entityIds: ["delivery.project", "delivery.milestone", "delivery.task"],
@@ -392,11 +567,28 @@ function deepMerge(base, override) {
   }
   return result;
 }
+function normalizeInheritedNavigationGroups(model, override) {
+  if (override?.navigation?.surfaces === void 0 || override.navigation.groups !== void 0) {
+    return model;
+  }
+  const validSurfaceIds = new Set(model.navigation.surfaces.map((surface) => surface.id));
+  const groups = model.navigation.groups.map((group) => ({
+    ...group,
+    surfaceIds: group.surfaceIds.filter((surfaceId) => validSurfaceIds.has(surfaceId))
+  })).filter((group) => group.surfaceIds.length > 0);
+  return {
+    ...model,
+    navigation: {
+      ...model.navigation,
+      groups
+    }
+  };
+}
 function defineOrganizationModel(model) {
   return model;
 }
 function resolveOrganizationModel(override) {
-  const merged = deepMerge(DEFAULT_ORGANIZATION_MODEL, override);
+  const merged = normalizeInheritedNavigationGroups(deepMerge(DEFAULT_ORGANIZATION_MODEL, override), override);
   return OrganizationModelSchema.parse(merged);
 }
 

package/dist/organization-model/index.js

@@ -304,7 +304,7 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
 };
 
 // src/organization-model/schema.ts
-var OrganizationModelSchema = z.object({
+var OrganizationModelSchemaBase = z.object({
   version: z.literal(1).default(1),
   domains: z.array(SemanticDomainSchema).default([]),
   branding: OrganizationModelBrandingSchema,
@@ -315,6 +315,181 @@ var OrganizationModelSchema = z.object({
   delivery: OrganizationModelDeliverySchema,
   resourceMappings: z.array(ResourceMappingSchema).default([])
 });
+function addIssue(ctx, path, message) {
+  ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    path,
+    message
+  });
+}
+function collectIds(items, ctx, collectionPath, label) {
+  const itemsById = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    if (itemsById.has(item.id)) {
+      addIssue(ctx, [...collectionPath, index, "id"], `${label} id "${item.id}" must be unique`);
+      return;
+    }
+    itemsById.set(item.id, item);
+  });
+  return itemsById;
+}
+var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
+  const domainsById = collectIds(model.domains, ctx, ["domains"], "Domain");
+  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");
+  const resourceMappingsByResourceId = /* @__PURE__ */ new Map();
+  model.resourceMappings.forEach((resourceMapping, index) => {
+    if (resourceMappingsByResourceId.has(resourceMapping.resourceId)) {
+      addIssue(
+        ctx,
+        ["resourceMappings", index, "resourceId"],
+        `Resource mapping resourceId "${resourceMapping.resourceId}" must be unique`
+      );
+      return;
+    }
+    resourceMappingsByResourceId.set(resourceMapping.resourceId, resourceMapping);
+  });
+  if (model.navigation.defaultSurfaceId && !surfacesById.has(model.navigation.defaultSurfaceId)) {
+    addIssue(
+      ctx,
+      ["navigation", "defaultSurfaceId"],
+      `Default surface "${model.navigation.defaultSurfaceId}" must reference a declared navigation surface`
+    );
+  }
+  model.navigation.groups.forEach((group, groupIndex) => {
+    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      if (!surfacesById.has(surfaceId)) {
+        addIssue(
+          ctx,
+          ["navigation", "groups", groupIndex, "surfaceIds", surfaceIndex],
+          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
+        );
+      }
+    });
+  });
+  model.domains.forEach((domain, domainIndex) => {
+    domain.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      const surface = surfacesById.get(surfaceId);
+      if (!surface) {
+        addIssue(
+          ctx,
+          ["domains", domainIndex, "surfaceIds", surfaceIndex],
+          `Domain "${domain.id}" references unknown surface "${surfaceId}"`
+        );
+        return;
+      }
+      if (!surface.domainIds.includes(domain.id)) {
+        addIssue(
+          ctx,
+          ["domains", domainIndex, "surfaceIds", surfaceIndex],
+          `Domain "${domain.id}" references surface "${surfaceId}" but that surface does not include domain "${domain.id}"`
+        );
+      }
+    });
+    domain.resourceIds.forEach((resourceId, resourceIndex) => {
+      const resourceMapping = resourceMappingsByResourceId.get(resourceId);
+      if (!resourceMapping) {
+        addIssue(
+          ctx,
+          ["domains", domainIndex, "resourceIds", resourceIndex],
+          `Domain "${domain.id}" references unknown resource "${resourceId}"`
+        );
+        return;
+      }
+      if (!resourceMapping.domainIds.includes(domain.id)) {
+        addIssue(
+          ctx,
+          ["domains", domainIndex, "resourceIds", resourceIndex],
+          `Domain "${domain.id}" references resource "${resourceId}" but that resource mapping does not include domain "${domain.id}"`
+        );
+      }
+    });
+  });
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surface.parentId && !surfacesById.has(surface.parentId)) {
+      addIssue(
+        ctx,
+        ["navigation", "surfaces", surfaceIndex, "parentId"],
+        `Surface "${surface.id}" references unknown parent surface "${surface.parentId}"`
+      );
+    }
+    surface.domainIds.forEach((domainId, domainIndex) => {
+      const domain = domainsById.get(domainId);
+      if (!domain) {
+        addIssue(
+          ctx,
+          ["navigation", "surfaces", surfaceIndex, "domainIds", domainIndex],
+          `Surface "${surface.id}" references unknown domain "${domainId}"`
+        );
+        return;
+      }
+      if (!domain.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}"`
+        );
+      }
+    });
+    surface.resourceIds.forEach((resourceId, resourceIndex) => {
+      const resourceMapping = resourceMappingsByResourceId.get(resourceId);
+      if (!resourceMapping) {
+        addIssue(
+          ctx,
+          ["navigation", "surfaces", surfaceIndex, "resourceIds", resourceIndex],
+          `Surface "${surface.id}" references unknown resource "${resourceId}"`
+        );
+        return;
+      }
+      if (!resourceMapping.surfaceIds.includes(surface.id)) {
+        addIssue(
+          ctx,
+          ["navigation", "surfaces", surfaceIndex, "resourceIds", resourceIndex],
+          `Surface "${surface.id}" references resource "${resourceId}" but that resource mapping does not include surface "${surface.id}"`
+        );
+      }
+    });
+  });
+  model.resourceMappings.forEach((resourceMapping, resourceIndex) => {
+    resourceMapping.domainIds.forEach((domainId, domainIndex) => {
+      const domain = domainsById.get(domainId);
+      if (!domain) {
+        addIssue(
+          ctx,
+          ["resourceMappings", resourceIndex, "domainIds", domainIndex],
+          `Resource mapping "${resourceMapping.id}" references unknown domain "${domainId}"`
+        );
+        return;
+      }
+      if (!domain.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}"`
+        );
+      }
+    });
+    resourceMapping.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      const surface = surfacesById.get(surfaceId);
+      if (!surface) {
+        addIssue(
+          ctx,
+          ["resourceMappings", resourceIndex, "surfaceIds", surfaceIndex],
+          `Resource mapping "${resourceMapping.id}" references unknown surface "${surfaceId}"`
+        );
+        return;
+      }
+      if (!surface.resourceIds.includes(resourceMapping.resourceId)) {
+        addIssue(
+          ctx,
+          ["resourceMappings", resourceIndex, "surfaceIds", surfaceIndex],
+          `Resource mapping "${resourceMapping.id}" references surface "${surfaceId}" but that surface does not include resource "${resourceMapping.resourceId}"`
+        );
+      }
+    });
+  });
+});
 
 // src/organization-model/defaults.ts
 var DEFAULT_ORGANIZATION_MODEL = {
@@ -342,7 +517,7 @@ var DEFAULT_ORGANIZATION_MODEL = {
     },
     {
       id: "delivery",
-      label: "Delivery",
+      label: "Projects",
       description: "Projects, milestones, and client work execution",
       color: "orange",
       entityIds: ["delivery.project", "delivery.milestone", "delivery.task"],
@@ -392,11 +567,28 @@ function deepMerge(base, override) {
   }
   return result;
 }
+function normalizeInheritedNavigationGroups(model, override) {
+  if (override?.navigation?.surfaces === void 0 || override.navigation.groups !== void 0) {
+    return model;
+  }
+  const validSurfaceIds = new Set(model.navigation.surfaces.map((surface) => surface.id));
+  const groups = model.navigation.groups.map((group) => ({
+    ...group,
+    surfaceIds: group.surfaceIds.filter((surfaceId) => validSurfaceIds.has(surfaceId))
+  })).filter((group) => group.surfaceIds.length > 0);
+  return {
+    ...model,
+    navigation: {
+      ...model.navigation,
+      groups
+    }
+  };
+}
 function defineOrganizationModel(model) {
   return model;
 }
 function resolveOrganizationModel(override) {
-  const merged = deepMerge(DEFAULT_ORGANIZATION_MODEL, override);
+  const merged = normalizeInheritedNavigationGroups(deepMerge(DEFAULT_ORGANIZATION_MODEL, override), override);
   return OrganizationModelSchema.parse(merged);
 }
 

package/package.json

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

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

@@ -5,22 +5,13 @@ import {
   organizationModel as foundationOrganizationModel,
   quickAccessSurfaceIds
 } from '../../../../external/_template/foundations/config/organization-model'
-import { resolveOrganizationModel } from '../published'
 
 describe('template foundations compatibility', () => {
-  it('adapts the foundations organization model onto the published core contract while preserving UI helpers', () => {
-    const resolved = resolveOrganizationModel(foundationOrganizationModel)
-
+  it('preserves the adapter-level shell helpers on top of the canonical model', () => {
     expect(foundationOrganizationModel.navigation.homeLabel).toBe(homeLabel)
     expect(foundationOrganizationModel.navigation.quickAccessSurfaceIds).toEqual(quickAccessSurfaceIds)
-    expect(resolved.branding.organizationName).toBe(foundationOrganizationModel.branding.organizationName)
-    expect(resolved.branding.productName).toBe(foundationOrganizationModel.branding.productName)
-    expect(resolved.navigation.defaultSurfaceId).toBe('operations')
-    expect(resolved.navigation.surfaces.map((surface) => surface.id)).toEqual(
-      foundationOrganizationModel.navigation.surfaces.map((surface) => surface.id)
-    )
-    expect(resolved.features.enabled.acquisition).toBe(true)
-    expect(resolved.features.enabled.calibration).toBe(false)
+    expect(foundationOrganizationModel.version).toBe(1)
+    expect(foundationOrganizationModel.navigation.defaultSurfaceId).toBe('operations')
     expect(getOrganizationSurface('operations')).toMatchObject({
       id: 'operations',
       label: 'Operations',
@@ -28,7 +19,97 @@ describe('template foundations compatibility', () => {
       surfaceType: 'graph',
       featureKey: 'operations'
     })
-    expect(resolved.crm.pipelines.length).toBeGreaterThan(0)
-    expect(resolved.delivery.projectStatuses.length).toBeGreaterThan(0)
+
+    expect(getOrganizationSurface('operations.organization-graph')).toMatchObject({
+      id: 'operations.organization-graph',
+      label: 'Operations',
+      path: '/operations',
+      surfaceType: 'graph',
+      featureKey: 'operations'
+    })
+  })
+
+  it('projects legacy template aliases with canonical navigation metadata', () => {
+    const legacySurfaces = [
+      {
+        id: 'operations',
+        label: 'Operations',
+        surfaceType: 'graph',
+        expectedFeatureKey: 'operations',
+        expectedIcon: 'operations',
+        expectedPath: '/operations',
+        expectedDomainIds: ['operations'],
+        expectedEntityIds: [],
+        expectedCapabilityIds: ['operations.organization-graph', 'operations.command-view']
+      },
+      {
+        id: 'projects',
+        label: 'Projects',
+        surfaceType: 'list',
+        expectedFeatureKey: 'projects',
+        expectedIcon: 'projects',
+        expectedPath: '/projects',
+        expectedDomainIds: ['delivery'],
+        expectedEntityIds: ['delivery.project'],
+        expectedCapabilityIds: ['delivery.projects.view']
+      },
+      {
+        id: 'lead-gen',
+        label: 'Lead Gen',
+        surfaceType: 'list',
+        expectedFeatureKey: 'lead-gen',
+        expectedIcon: 'lead-gen',
+        expectedPath: '/lead-gen',
+        expectedDomainIds: ['lead-gen'],
+        expectedEntityIds: ['leadgen.list'],
+        expectedCapabilityIds: ['leadgen.lists.manage']
+      },
+      {
+        id: 'crm',
+        label: 'CRM',
+        surfaceType: 'graph',
+        expectedFeatureKey: 'crm',
+        expectedIcon: 'crm',
+        expectedPath: '/crm',
+        expectedDomainIds: ['crm'],
+        expectedEntityIds: ['crm.deal'],
+        expectedCapabilityIds: ['crm.pipeline.manage']
+      }
+    ] as const
+
+    expect(getOrganizationSurface('operations.organization-graph')).toBeDefined()
+
+    for (const surface of legacySurfaces) {
+      expect(getOrganizationSurface(surface.id)).toMatchObject({
+        id: surface.id,
+        label: surface.label,
+        path: surface.expectedPath,
+        surfaceType: surface.surfaceType,
+        icon: surface.expectedIcon,
+        featureKey: surface.expectedFeatureKey,
+        domainIds: surface.expectedDomainIds,
+        entityIds: surface.expectedEntityIds,
+        resourceIds: [],
+        capabilityIds: surface.expectedCapabilityIds
+      })
+    }
+  })
+
+  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
+    )
+
+    expect(foundationOrganizationModel.features.labels.crm).toBe('CRM')
+    expect(foundationOrganizationModel.features.labels['lead-gen']).toBe('Lead Gen')
+    expect(foundationOrganizationModel.features.labels.projects).toBe('Projects')
   })
 })

package/src/auth/multi-tenancy/types.ts

@@ -10,13 +10,14 @@
 /**
  * Per-user-per-org config (stored in org_memberships.config)
  * Controls which features a specific member can access within their org
- * Valid feature keys: operations, monitoring, acquisition, calibration, seo
+ * Valid feature keys: operations, monitoring, acquisition, delivery, calibration, seo
  */
 export interface MembershipFeatureConfig {
   features?: {
     operations?: boolean
     monitoring?: boolean
     acquisition?: boolean
+    delivery?: boolean
     calibration?: boolean
     seo?: boolean
   }

package/src/execution/engine/__tests__/fixtures/test-agents.ts

@@ -1,7 +1,7 @@
-import { z } from 'zod'
-import type { AgentDefinition } from '../../agent/core/types'
-import type { KnowledgeMap } from '../../agent/knowledge-map/types'
-import { createApprovalTool } from '../../tools/platform'
+import { z } from 'zod'
+import type { AgentDefinition } from '../../agent/core/types'
+import type { KnowledgeMap } from '../../agent/knowledge-map/types'
+import { createApprovalTool } from '../../tools/platform/approval/tool'
 
 /**
  * Create test agent with platform tools

package/src/execution/engine/index.ts

@@ -244,6 +244,8 @@ export {
   type INotificationsService,
   type ICredentialsService,
   type IIntegrationService,
+  type ICrmService,
+  type IProjectsService,
   // Email Service types
   type IEmailService,
   type SendPlatformEmailParams,
@@ -321,24 +323,8 @@ export {
 } from './tools/registry'
 
 // Platform Tools (server-side only)
+// Retained internal/compatibility surface. Deployed SDK workers use platform.call() -> dispatcher.
 export {
-  createApprovalTool,
-  createSchedulerTool,
-  createNotificationTool,
-  type ApprovalToolConfig,
-  type SchedulerToolConfig,
-  type NotificationToolConfig,
-  // Resource Invocation (service, types, and tool factories)
-  ResourceInvocationService,
-  createResourceInvocationService,
-  type ResourceExecutionRequest,
-  type ResourceInvocationResult,
-  // Tool factories (Wave 2a)
-  createResourceInvocationTool,
-  createDynamicResourceInvocationTool,
-  type ResourceInvocationToolConfig,
-  dynamicResourceInvocationSchema,
-  dynamicResourceInvocationOutputSchema,
   // Storage Tools
   createStorageUploadTool,
   createStorageSignedUrlTool,
@@ -387,8 +373,6 @@ export {
   CancelScheduleByKeyOutputSchema,
   DeleteScheduleByKeyInputSchema,
   DeleteScheduleByKeyOutputSchema,
-  // HITL Cancel by Metadata Tool
-  createHitlCancelByMetadataTool,
   type HitlCancelByMetadataInput,
   type HitlCancelByMetadataOutput,
   HitlCancelByMetadataInputSchema,
@@ -428,6 +412,8 @@ export type {
   StorageToolMap,
   NotificationToolMap,
   NotificationSDKInput,
+  ProjectsToolMap,
+  CrmToolMap,
   LeadToolMap,
   ListToolMap,
   PdfToolMap,