@elevasis/core 0.22.0 → 0.23.0

package/src/organization-model/__tests__/schema.test.ts

@@ -1,41 +1,39 @@
 import { describe, expect, it } from 'vitest'
 import { DEFAULT_ORGANIZATION_MODEL_BRANDING } from '../domains/branding'
-import { DEFAULT_ORGANIZATION_MODEL_SALES } from '../domains/sales'
-import { DEFAULT_ORGANIZATION_MODEL_PROJECTS } from '../domains/projects'
-import { DEFAULT_ORGANIZATION_MODEL_PROSPECTING } from '../domains/prospecting'
 import { OrganizationModelSchema } from '../schema'
 
-function makeFeature(id: string, path = `/${id.replaceAll('.', '/')}`) {
+// Phase 4 (D8): sales, prospecting, projects, navigation top-level fields removed.
+// DEFAULT_ORGANIZATION_MODEL_SALES / _PROSPECTING / _PROJECTS / OrganizationModelSalesSchema etc.
+// no longer exported. makeMinimalModel no longer includes those fields.
+// knowledge is now a flat Record<id, OrgKnowledgeNode> (D3) — wrapper shape removed.
+
+function makeSystem(id: string, path = `/${id.replaceAll('.', '/')}`) {
   return {
     id,
+    order: 10,
     label: id,
     enabled: true,
+    lifecycle: 'active' as const,
     path
   }
 }
 
-function makeSurface(id: string, featureId?: string, featureIds: string[] = []) {
-  return {
-    id,
-    label: id,
-    path: `/${id.replaceAll('.', '/')}`,
-    surfaceType: 'page' as const,
-    featureId,
-    featureIds,
-    entityIds: [],
-    resourceIds: [],
-    capabilityIds: []
-  }
-}
-
-function makeMinimalModel(features: unknown[] = []) {
+function makeMinimalModel(systems: Record<string, unknown> = {}) {
+  const entityOwnerId = Object.keys(systems)[0] ?? 'dashboard'
   return {
     version: 1 as const,
-    features,
     branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-    sales: DEFAULT_ORGANIZATION_MODEL_SALES,
-    prospecting: DEFAULT_ORGANIZATION_MODEL_PROSPECTING,
-    projects: DEFAULT_ORGANIZATION_MODEL_PROJECTS
+    // Phase 4: sales, prospecting, projects removed from top-level OM fields.
+    entities: {
+      'crm.deal': { id: 'crm.deal', order: 10, label: 'Deal', ownedBySystemId: entityOwnerId },
+      'leadgen.list': { id: 'leadgen.list', order: 20, label: 'Lead List', ownedBySystemId: entityOwnerId },
+      'leadgen.company': { id: 'leadgen.company', order: 30, label: 'Lead Company', ownedBySystemId: entityOwnerId },
+      'leadgen.contact': { id: 'leadgen.contact', order: 40, label: 'Lead Contact', ownedBySystemId: entityOwnerId },
+      'delivery.project': { id: 'delivery.project', order: 50, label: 'Project', ownedBySystemId: entityOwnerId },
+      'delivery.milestone': { id: 'delivery.milestone', order: 60, label: 'Milestone', ownedBySystemId: entityOwnerId },
+      'delivery.task': { id: 'delivery.task', order: 70, label: 'Task', ownedBySystemId: entityOwnerId }
+    },
+    systems
   }
 }
 
@@ -45,161 +43,340 @@ function getIssueMessages(data: unknown): string[] {
   return result.error.issues.map((issue) => issue.message)
 }
 
-describe('flat feature tree validation', () => {
+describe('system tree validation', () => {
   it('passes with a flat list that has declared ancestors', () => {
-    const model = makeMinimalModel([
-      { id: 'sales', label: 'Sales', enabled: true },
-      makeFeature('sales.crm', '/sales/crm/pipeline'),
-      makeFeature('sales.lead-gen', '/lead-gen/lists')
-    ])
+    const model = makeMinimalModel({
+      sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+      'sales.crm': makeSystem('sales.crm', '/sales/crm/pipeline'),
+      'sales.lead-gen': makeSystem('sales.lead-gen', '/lead-gen/lists')
+    })
 
     expect(() => OrganizationModelSchema.parse(model)).not.toThrow()
   })
 
-  it('rejects duplicate feature ids', () => {
-    const messages = getIssueMessages(makeMinimalModel([makeFeature('sales'), makeFeature('sales')]))
+  it('rejects duplicate system ids', () => {
+    // In a record, duplicate keys are impossible at the JS level.
+    // The schema refine checks that entry.id === mapKey, so mismatched ids are caught.
+    const messages = getIssueMessages(
+      makeMinimalModel({
+        sales: { id: 'NOT_sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' }
+      })
+    )
 
-    expect(messages.some((message) => message.includes('Feature id "sales" must be unique'))).toBe(true)
+    expect(messages.some((message) => message.includes('Each system entry id must match its map key'))).toBe(true)
   })
 
-  it('rejects duplicate effective feature paths when explicit and default paths collide', () => {
+  it('rejects duplicate effective system paths when explicit and default paths collide', () => {
     const messages = getIssueMessages(
-      makeMinimalModel([
-        { id: 'sales', label: 'Sales', enabled: true },
-        makeFeature('sales.crm', '/sales/lead-gen'),
-        { id: 'sales.lead-gen', label: 'Lead Gen', enabled: true }
-      ])
+      makeMinimalModel({
+        sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+        'sales.crm': makeSystem('sales.crm', '/sales/lead-gen'),
+        'sales.lead-gen': { id: 'sales.lead-gen', order: 20, label: 'Lead Gen', enabled: true, lifecycle: 'active' }
+      })
     )
 
     expect(
       messages.some((message) =>
-        message.includes('Feature "sales.lead-gen" effective path "/sales/lead-gen" duplicates feature "sales.crm"')
+        message.includes('System "sales.lead-gen" effective path "/sales/lead-gen" duplicates system "sales.crm"')
       )
     ).toBe(true)
   })
 
   it('rejects a dotted child when its immediate parent is missing', () => {
-    const messages = getIssueMessages(makeMinimalModel([makeFeature('sales.crm.pipeline')]))
+    const messages = getIssueMessages(
+      makeMinimalModel({
+        'sales.crm.pipeline': { ...makeSystem('sales.crm.pipeline', '/pipeline'), parentSystemId: 'sales.crm' }
+      })
+    )
 
     expect(messages.some((message) => message.includes('unknown parent "sales.crm"'))).toBe(true)
   })
 
   it('allows a leaf without a path so resolvers can derive a default path', () => {
-    const result = OrganizationModelSchema.safeParse(makeMinimalModel([{ id: 'sales', label: 'Sales', enabled: true }]))
+    const result = OrganizationModelSchema.safeParse(
+      makeMinimalModel({ sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' } })
+    )
 
     expect(result.success).toBe(true)
   })
 
-  it('rejects an enabled container with no enabled descendants', () => {
+  it('rejects an active container with no active descendants', () => {
     const messages = getIssueMessages(
-      makeMinimalModel([
-        { id: 'sales', label: 'Sales', enabled: true },
-        { id: 'sales.crm', label: 'CRM', enabled: false, path: '/sales/crm/pipeline' }
-      ])
+      makeMinimalModel({
+        sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+        'sales.crm': {
+          id: 'sales.crm',
+          order: 20,
+          label: 'CRM',
+          enabled: false,
+          lifecycle: 'deprecated',
+          path: '/sales/crm/pipeline'
+        }
+      })
     )
 
-    expect(messages.some((message) => message.includes('has no enabled descendants'))).toBe(true)
+    expect(messages.some((message) => message.includes('has no active descendants'))).toBe(true)
   })
 
-  it('keeps legacy navigation inert during the release train', () => {
-    const model = OrganizationModelSchema.parse(
-      makeMinimalModel([makeFeature('dashboard', '/')])
-    )
+  it('navigation.sidebar defaults to empty sections when omitted', () => {
+    const model = OrganizationModelSchema.parse(makeMinimalModel({ dashboard: makeSystem('dashboard', '/') }))
 
-    expect(model.navigation.surfaces).toEqual([])
-    expect(model.navigation.groups).toEqual([])
+    expect(model.navigation.sidebar.primary).toEqual({})
+    expect(model.navigation.sidebar.bottom).toEqual({})
+    expect('surfaces' in model).toBe(false)
+    expect('navigationGroups' in model).toBe(false)
     expect('resourceMappings' in model).toBe(false)
   })
 
-  it('rejects an unknown navigation default surface when surfaces are explicitly empty', () => {
+  // Phase 4: the old model.navigation.defaultSurfaceId validation no longer exists.
+  // Navigation defaults are now managed at the foundation layer (createFoundationOrganizationModel).
+  // The following tests that exercised model.navigation.* refines are skipped with a reason.
+  it.skip('rejects an unknown navigation default surface when surfaces are explicitly empty (deferred — Phase 4: navigation field removed)', () => {
+    // Previously tested: model.navigation.defaultSurfaceId referencing a missing surface.
+    // The navigation domain no longer exists at the top-level OM schema level.
+  })
+
+  it.skip('rejects navigation group surfaceIds that reference missing surfaces (deferred — Phase 4: navigation field removed)', () => {
+    // Previously tested: model.navigation.groups[*].surfaceIds referencing missing surfaces.
+    // Navigation groups are now top-level navigationGroups Record — cross-ref validation
+    // is handled at the resolveOrganizationModel refine layer if/when re-added.
+  })
+
+  it.skip('rejects navigation surface systemIds references to missing systems (deferred — Phase 4: navigation field removed)', () => {
+    // Previously tested: model.navigation.surfaces[*].systemIds referencing missing systems.
+    // Surfaces are now top-level surfaces Record — cross-ref validation is handled separately.
+  })
+
+  it.skip('accepts navigation systemIds when canonical systems exist (deferred — Phase 4: navigation field removed)', () => {
+    // Previously tested: model.navigation.surfaces[*].systemIds with valid system refs.
+    // See navigation.test.ts for top-level surfaces/navigationGroups coverage.
+  })
+})
+
+describe('domain metadata validation', () => {
+  it('defaults domain metadata and knowledge domain versioning', () => {
+    const model = OrganizationModelSchema.parse(makeMinimalModel({ dashboard: makeSystem('dashboard', '/') }))
+
+    expect(model.domainMetadata.knowledge).toEqual({ version: 1, lastModified: '2026-05-10' })
+    expect(model.domainMetadata.actions).toEqual({ version: 1, lastModified: '2026-05-10' })
+    expect(model.domainMetadata.entities).toEqual({ version: 1, lastModified: '2026-05-10' })
+    expect(model.domainMetadata.policies).toEqual({ version: 1, lastModified: '2026-05-10' })
+    // Phase 4 (D7): knowledge version/lastModified moved to domainMetadata.knowledge.
+    // model.knowledge is now a flat Record<id, OrgKnowledgeNode> — no .version or .lastModified.
+    expect(model.domainMetadata.knowledge.version).toBe(1)
+    expect(model.domainMetadata.knowledge.lastModified).toBe('2026-05-10')
+  })
+
+  it('rejects malformed domain lastModified dates', () => {
     const messages = getIssueMessages({
-      ...makeMinimalModel([makeFeature('dashboard', '/')]),
-      navigation: {
-        defaultSurfaceId: 'missing.surface',
-        surfaces: [],
-        groups: []
+      ...makeMinimalModel({ dashboard: makeSystem('dashboard', '/') }),
+      domainMetadata: {
+        knowledge: { version: 1, lastModified: '05/10/2026' }
       }
     })
 
-    expect(
-      messages.some((message) =>
-        message.includes('Navigation defaultSurfaceId references unknown surface "missing.surface"')
-      )
-    ).toBe(true)
+    expect(messages.some((message) => message.includes('lastModified must be an ISO date string'))).toBe(true)
   })
+})
 
-  it('rejects navigation group surfaceIds that reference missing surfaces', () => {
+describe('entity validation', () => {
+  it('rejects entities owned by unknown systems', () => {
     const messages = getIssueMessages({
-      ...makeMinimalModel([makeFeature('dashboard', '/')]),
-      navigation: {
-        surfaces: [makeSurface('dashboard.home', 'dashboard')],
-        groups: [
-          {
-            id: 'primary',
-            label: 'Primary',
-            placement: 'primary',
-            surfaceIds: ['missing.surface']
-          }
-        ]
+      ...makeMinimalModel({ dashboard: makeSystem('dashboard', '/') }),
+      entities: {
+        'crm.deal': { id: 'crm.deal', order: 10, label: 'Deal', ownedBySystemId: 'missing.system' },
+        'leadgen.list': { id: 'leadgen.list', order: 20, label: 'Lead List', ownedBySystemId: 'dashboard' },
+        'leadgen.company': { id: 'leadgen.company', order: 30, label: 'Lead Company', ownedBySystemId: 'dashboard' },
+        'leadgen.contact': { id: 'leadgen.contact', order: 40, label: 'Lead Contact', ownedBySystemId: 'dashboard' },
+        'delivery.project': { id: 'delivery.project', order: 50, label: 'Project', ownedBySystemId: 'dashboard' },
+        'delivery.milestone': { id: 'delivery.milestone', order: 60, label: 'Milestone', ownedBySystemId: 'dashboard' },
+        'delivery.task': { id: 'delivery.task', order: 70, label: 'Task', ownedBySystemId: 'dashboard' }
       }
     })
 
-    expect(
-      messages.some((message) =>
-        message.includes('Navigation group "primary" references unknown surface "missing.surface"')
-      )
-    ).toBe(true)
+    expect(messages.some((message) => message.includes('references unknown ownedBySystemId "missing.system"'))).toBe(
+      true
+    )
   })
 
-  it('rejects navigation surface featureId references to missing features', () => {
+  it('rejects entity links to unknown entities', () => {
     const messages = getIssueMessages({
-      ...makeMinimalModel([makeFeature('dashboard', '/')]),
-      navigation: {
-        surfaces: [makeSurface('dashboard.home', 'missing.feature')],
-        groups: []
+      ...makeMinimalModel({ dashboard: makeSystem('dashboard', '/') }),
+      entities: {
+        'crm.deal': {
+          id: 'crm.deal',
+          order: 10,
+          label: 'Deal',
+          ownedBySystemId: 'dashboard',
+          links: [{ toEntity: 'missing.entity', kind: 'belongs-to' }]
+        },
+        'leadgen.list': { id: 'leadgen.list', order: 20, label: 'Lead List', ownedBySystemId: 'dashboard' },
+        'leadgen.company': { id: 'leadgen.company', order: 30, label: 'Lead Company', ownedBySystemId: 'dashboard' },
+        'leadgen.contact': { id: 'leadgen.contact', order: 40, label: 'Lead Contact', ownedBySystemId: 'dashboard' },
+        'delivery.project': { id: 'delivery.project', order: 50, label: 'Project', ownedBySystemId: 'dashboard' },
+        'delivery.milestone': { id: 'delivery.milestone', order: 60, label: 'Milestone', ownedBySystemId: 'dashboard' },
+        'delivery.task': { id: 'delivery.task', order: 70, label: 'Task', ownedBySystemId: 'dashboard' }
       }
     })
 
-    expect(
-      messages.some((message) =>
-        message.includes('Navigation surface "dashboard.home" references unknown feature "missing.feature"')
-      )
-    ).toBe(true)
+    expect(messages.some((message) => message.includes('links to unknown entity "missing.entity"'))).toBe(true)
+  })
+
+  // Phase 4: Prospecting.contactEntityId validation removed (prospecting domain deleted).
+  // The separate test for prospecting entity refs is skipped below.
+  it.skip('rejects prospecting contactEntityId referencing unknown entity (deferred — Phase 4: prospecting domain removed)', () => {
+    // Previously tested: model.prospecting.contactEntityId referencing a missing entity.
+    // The prospecting domain no longer exists at the top-level OM schema level.
+  })
+})
+
+describe('system action and policy validation', () => {
+  it('accepts systems that attach known actions and policies', () => {
+    const result = OrganizationModelSchema.safeParse({
+      ...makeMinimalModel({
+        sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+        'sales.lead-gen': makeSystem('sales.lead-gen')
+      }),
+      systems: {
+        sales: {
+          id: 'sales',
+          order: 10,
+          label: 'Sales',
+          lifecycle: 'active'
+        },
+        'sales.lead-gen': {
+          id: 'sales.lead-gen',
+          order: 20,
+          label: 'Lead Gen',
+          lifecycle: 'active',
+          actions: [{ actionId: 'lead-gen.company.source', intent: 'exposes' }],
+          policies: ['policy.lead-gen.approval']
+        }
+      },
+      policies: {
+        'policy.lead-gen.approval': {
+          id: 'policy.lead-gen.approval',
+          order: 10,
+          label: 'Lead Gen Approval',
+          trigger: { kind: 'manual' },
+          actions: [{ kind: 'block' }],
+          appliesTo: { systemIds: ['sales.lead-gen'] }
+        }
+      }
+    })
+
+    expect(result.success).toBe(true)
   })
 
-  it('rejects navigation surface featureIds references to missing features', () => {
+  it('rejects systems that attach unknown actions or policies', () => {
     const messages = getIssueMessages({
-      ...makeMinimalModel([makeFeature('dashboard', '/')]),
-      navigation: {
-        surfaces: [makeSurface('dashboard.home', 'dashboard', ['dashboard', 'missing.feature'])],
-        groups: []
+      ...makeMinimalModel({
+        sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+        'sales.lead-gen': makeSystem('sales.lead-gen')
+      }),
+      systems: {
+        sales: {
+          id: 'sales',
+          order: 10,
+          label: 'Sales',
+          lifecycle: 'active'
+        },
+        'sales.lead-gen': {
+          id: 'sales.lead-gen',
+          order: 20,
+          label: 'Lead Gen',
+          lifecycle: 'active',
+          actions: [{ actionId: 'missing.action', intent: 'exposes' }],
+          policies: ['missing.policy']
+        }
       }
     })
 
-    expect(
-      messages.some((message) =>
-        message.includes('Navigation surface "dashboard.home" references unknown feature "missing.feature"')
-      )
-    ).toBe(true)
+    expect(messages.some((message) => message.includes('references unknown action "missing.action"'))).toBe(true)
+    expect(messages.some((message) => message.includes('references unknown policy "missing.policy"'))).toBe(true)
   })
+})
+
+describe('knowledge governs validation', () => {
+  function makeKnowledgeNode(overrides: Record<string, unknown> = {}) {
+    return {
+      id: 'knowledge.sales-crm-playbook',
+      kind: 'playbook' as const,
+      title: 'Sales CRM Playbook',
+      summary: 'How CRM work is governed.',
+      body: '## CRM',
+      updatedAt: '2026-05-10',
+      links: [{ target: { kind: 'system', id: 'sales.crm' } }],
+      ...overrides
+    }
+  }
 
-  it('allows legacy navigation feature aliases when canonical features exist', () => {
+  // Phase 4 (D3): knowledge is now a flat Record<id, OrgKnowledgeNode>.
+  // Fixtures updated from { nodes: [...] } to { 'knowledge.id': {...node} }.
+
+  it('accepts typed knowledge links when the target exists', () => {
     const result = OrganizationModelSchema.safeParse({
-      ...makeMinimalModel([
-        { id: 'sales', label: 'Sales', enabled: true },
-        makeFeature('sales.crm', '/sales/crm/pipeline'),
-        makeFeature('sales.lead-gen', '/lead-gen/lists')
-      ]),
-      navigation: {
-        defaultSurfaceId: 'crm.pipeline',
-        surfaces: [
-          makeSurface('crm.pipeline', 'crm', ['crm']),
-          makeSurface('lead-gen.lists', 'lead-gen', ['lead-gen'])
-        ],
-        groups: []
+      ...makeMinimalModel({
+        sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+        'sales.crm': makeSystem('sales.crm', '/crm')
+      }),
+      knowledge: {
+        'knowledge.sales-crm-playbook': makeKnowledgeNode()
       }
     })
 
     expect(result.success).toBe(true)
   })
+
+  it('rejects typed knowledge links to unknown modeled targets', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel({
+        sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+        'sales.crm': makeSystem('sales.crm', '/crm')
+      }),
+      knowledge: {
+        'knowledge.sales-crm-playbook': makeKnowledgeNode({
+          links: [{ target: { kind: 'resource', id: 'missing.workflow' } }]
+        })
+      }
+    })
+
+    expect(messages.some((message) => message.includes('references unknown resource target "missing.workflow"'))).toBe(
+      true
+    )
+  })
+
+  it('allows strategy nodes to target systems', () => {
+    const result = OrganizationModelSchema.safeParse({
+      ...makeMinimalModel({
+        sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+        'sales.crm': makeSystem('sales.crm', '/crm')
+      }),
+      knowledge: {
+        'knowledge.sales-crm-playbook': makeKnowledgeNode({
+          kind: 'strategy',
+          links: [{ target: { kind: 'system', id: 'sales.crm' } }]
+        })
+      }
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects incompatible knowledge kind to target kind pairings', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel({
+        sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
+        'sales.crm': makeSystem('sales.crm', '/crm')
+      }),
+      knowledge: {
+        'knowledge.sales-crm-playbook': makeKnowledgeNode({
+          kind: 'playbook',
+          links: [{ target: { kind: 'goal', id: 'missing.goal' } }]
+        })
+      }
+    })
+
+    expect(messages.some((message) => message.includes('kind "playbook" cannot govern goal targets'))).toBe(true)
+  })
 })