@elevasis/core 0.33.0 → 0.34.1

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

@@ -1,185 +1,218 @@
 import { describe, expect, it } from 'vitest'
 import { DEFAULT_ORGANIZATION_MODEL_BRANDING } from '../domains/branding'
 import { resolveSystemConfig } from '../helpers'
-import { compileOrganizationOntology, formatOntologyId, listResolvedOntologyRecords, parseOntologyId } from '../ontology'
+import {
+  compileOrganizationOntology,
+  formatOntologyId,
+  listResolvedOntologyRecords,
+  parseOntologyId
+} from '../ontology'
 import { resolveOrganizationModelWithResources } from '../resolve'
 import { OrganizationModelSchema } from '../schema'
-
-// 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 makeMinimalModel(systems: Record<string, unknown> = {}) {
-  const entityOwnerId = Object.keys(systems)[0] ?? 'dashboard'
-  return {
-    version: 1 as const,
-    branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-    // 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
-  }
-}
-
-function getIssueMessages(data: unknown): string[] {
-  const result = OrganizationModelSchema.safeParse(data)
-  if (result.success) return []
-  return result.error.issues.map((issue) => issue.message)
-}
-
-describe('system tree validation', () => {
-  it('passes with a flat list that has declared ancestors', () => {
-    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 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('Each system entry id must match its map key'))).toBe(true)
-  })
-
-  it('rejects duplicate effective system paths when explicit and default paths collide', () => {
-    const messages = getIssueMessages(
-      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('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({
-        '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({ sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' } })
-    )
-
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects an active container with no active descendants', () => {
-    const messages = getIssueMessages(
-      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 active descendants'))).toBe(true)
-  })
-
-  it('navigation.sidebar defaults to empty sections when omitted', () => {
-    const model = OrganizationModelSchema.parse(makeMinimalModel({ dashboard: makeSystem('dashboard', '/') }))
-
-    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)
-  })
-
-  // 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.
-  })
-})
-
+
+// 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 makeMinimalModel(systems: Record<string, unknown> = {}) {
+  const entityOwnerId = Object.keys(systems)[0] ?? 'dashboard'
+  return {
+    version: 1 as const,
+    branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
+    // 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
+  }
+}
+
+function getIssueMessages(data: unknown): string[] {
+  const result = OrganizationModelSchema.safeParse(data)
+  if (result.success) return []
+  return result.error.issues.map((issue) => issue.message)
+}
+
+describe('system tree validation', () => {
+  it('passes with a flat list that has declared ancestors', () => {
+    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 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('Each system entry id must match its map key'))).toBe(true)
+  })
+
+  it('rejects duplicate effective system paths when explicit and default paths collide', () => {
+    const messages = getIssueMessages(
+      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('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({
+        '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({ sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' } })
+    )
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects an active container with no active descendants', () => {
+    const messages = getIssueMessages(
+      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 active descendants'))).toBe(true)
+  })
+
+  it('navigation.sidebar defaults to empty sections when omitted', () => {
+    const model = OrganizationModelSchema.parse(makeMinimalModel({ dashboard: makeSystem('dashboard', '/') }))
+
+    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)
+  })
+
+  // 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({ dashboard: makeSystem('dashboard', '/') }),
-      domainMetadata: {
-        knowledge: { version: 1, lastModified: '05/10/2026' }
-      }
-    })
-
-    expect(messages.some((message) => message.includes('lastModified must be an ISO date string'))).toBe(true)
-  })
+  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({ dashboard: makeSystem('dashboard', '/') }),
+      domainMetadata: {
+        knowledge: { version: 1, lastModified: '05/10/2026' }
+      }
+    })
+
+    expect(messages.some((message) => message.includes('lastModified must be an ISO date string'))).toBe(true)
+  })
+})
+
+describe('deployment projection validation', () => {
+  it('rejects old deploy governance projections that omit referenced full-model domains', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel({
+        sales: {
+          ...makeSystem('sales', '/sales'),
+          responsibleRoleId: 'role-ops-lead',
+          drivesGoals: ['goal-qualified-pipeline-q2-2026']
+        }
+      }),
+      resources: {
+        'lead-gen-workflow': {
+          id: 'lead-gen-workflow',
+          order: 10,
+          kind: 'workflow',
+          systemPath: 'sales',
+          status: 'active',
+          ownerRoleId: 'role-ops-lead'
+        }
+      }
+    })
+
+    expect(messages.some((message) => message.includes('unknown responsibleRoleId "role-ops-lead"'))).toBe(true)
+    expect(messages.some((message) => message.includes('unknown goal "goal-qualified-pipeline-q2-2026"'))).toBe(true)
+    expect(messages.some((message) => message.includes('unknown ownerRoleId "role-ops-lead"'))).toBe(true)
+  })
 })
 
 describe('ontology contract validation', () => {
@@ -197,9 +230,9 @@ describe('ontology contract validation', () => {
       localId: 'email',
       isGlobal: true
     })
-    expect(formatOntologyId({ scope: 'enterprise.revenue.sales.crm', kind: 'action', localId: 'deal.update-stage' })).toBe(
-      'enterprise.revenue.sales.crm:action/deal.update-stage'
-    )
+    expect(
+      formatOntologyId({ scope: 'enterprise.revenue.sales.crm', kind: 'action', localId: 'deal.update-stage' })
+    ).toBe('enterprise.revenue.sales.crm:action/deal.update-stage')
     expect(() => parseOntologyId('sales.crm/object/deal')).toThrow()
     expect(() => parseOntologyId('sales.crm:unknown/deal')).toThrow()
   })
@@ -314,36 +347,34 @@ describe('ontology contract validation', () => {
   })
 
   it('projects legacy entities and actions while reading catalogs from authored ontology', () => {
-    const model = OrganizationModelSchema.parse(
-      {
-        ...makeMinimalModel({
-          dashboard: {
-            ...makeSystem('dashboard', '/'),
-            ontology: {
-              catalogTypes: {
-                'dashboard:catalog/pipeline': {
-                  id: 'dashboard:catalog/pipeline',
-                  kind: 'pipeline',
-                  appliesTo: 'dashboard:object/crm.deal',
+    const model = OrganizationModelSchema.parse({
+      ...makeMinimalModel({
+        dashboard: {
+          ...makeSystem('dashboard', '/'),
+          ontology: {
+            catalogTypes: {
+              'dashboard:catalog/pipeline': {
+                id: 'dashboard:catalog/pipeline',
+                kind: 'pipeline',
+                appliesTo: 'dashboard:object/crm.deal',
                 label: 'Pipeline',
-                  entries: {
-                    open: { label: 'Open', order: 10, semanticClass: 'open' }
-                  }
+                entries: {
+                  open: { label: 'Open', order: 10, semanticClass: 'open' }
                 }
               }
             }
           }
-        }),
-        actions: {
-          send_reply: {
-            id: 'send_reply',
-            order: 10,
-            label: 'Send Reply',
-            affects: ['crm.deal']
-          }
+        }
+      }),
+      actions: {
+        send_reply: {
+          id: 'send_reply',
+          order: 10,
+          label: 'Send Reply',
+          affects: ['crm.deal']
         }
       }
-    )
+    })
 
     const compilation = compileOrganizationOntology(model)
 
@@ -424,9 +455,7 @@ describe('ontology contract validation', () => {
       }
     })
 
-    expect(messages.some((message) => message.includes('Duplicate ontology ID "dashboard:object/crm.deal"'))).toBe(
-      true
-    )
+    expect(messages.some((message) => message.includes('Duplicate ontology ID "dashboard:object/crm.deal"'))).toBe(true)
     expect(messages.some((message) => message.includes('legacy.entities'))).toBe(true)
   })
 
@@ -725,76 +754,76 @@ describe('system config contract', () => {
 })
 
 describe('entity validation', () => {
-  it('rejects entities owned by unknown systems', () => {
-    const messages = getIssueMessages({
-      ...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('references unknown ownedBySystemId "missing.system"'))).toBe(
-      true
-    )
-  })
-
-  it('rejects entity links to unknown entities', () => {
-    const messages = getIssueMessages({
-      ...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('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')
-      }),
+  it('rejects entities owned by unknown systems', () => {
+    const messages = getIssueMessages({
+      ...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('references unknown ownedBySystemId "missing.system"'))).toBe(
+      true
+    )
+  })
+
+  it('rejects entity links to unknown entities', () => {
+    const messages = getIssueMessages({
+      ...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('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' }],
+          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']
         }
       },
@@ -806,129 +835,129 @@ describe('system action and policy validation', () => {
         }
       },
       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 systems that attach unknown actions or policies', () => {
-    const messages = getIssueMessages({
-      ...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('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
-    }
-  }
-
-  // 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({
-        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)
-  })
-})
+        '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 systems that attach unknown actions or policies', () => {
+    const messages = getIssueMessages({
+      ...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('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
+    }
+  }
+
+  // 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({
+        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)
+  })
+})