@elevasis/core 0.22.0 → 0.24.0

package/src/organization-model/__tests__/domains/statuses.test.ts

@@ -16,6 +16,7 @@ describe('StatusEntrySchema — positive parse', () => {
   it('accepts a fully-specified entry (id, label, semanticClass, category)', () => {
     const result = StatusEntrySchema.safeParse({
       id: 'delivery.task.planned',
+      order: 10,
       label: 'Planned',
       semanticClass: 'delivery.task',
       category: 'delivery'
@@ -26,6 +27,7 @@ describe('StatusEntrySchema — positive parse', () => {
   it('accepts a minimal entry without category (category is optional)', () => {
     const result = StatusEntrySchema.safeParse({
       id: 'queue.pending',
+      order: 10,
       label: 'Pending',
       semanticClass: 'queue'
     })
@@ -38,6 +40,7 @@ describe('StatusEntrySchema — positive parse', () => {
   it('trims whitespace from id and label', () => {
     const result = StatusEntrySchema.safeParse({
       id: '  trimmed-id  ',
+      order: 10,
       label: '  Trimmed Label  ',
       semanticClass: 'execution'
     })
@@ -111,16 +114,16 @@ describe('StatusEntrySchema — negative parse', () => {
 // ---------------------------------------------------------------------------
 
 describe('StatusesDomainSchema — structural tests', () => {
-  it('accepts an entries-empty domain object', () => {
-    const result = StatusesDomainSchema.safeParse({ entries: [] })
+  it('accepts an empty record', () => {
+    const result = StatusesDomainSchema.safeParse({})
     expect(result.success).toBe(true)
   })
 
-  it('applies an empty-array default when entries is omitted', () => {
-    const result = StatusesDomainSchema.safeParse({})
+  it('applies an empty-record default when the domain is omitted', () => {
+    const result = StatusesDomainSchema.safeParse(undefined)
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.entries).toEqual([])
+      expect(result.data).toEqual({})
     }
   })
 })
@@ -152,7 +155,7 @@ describe('StatusSemanticClassSchema — enum coverage', () => {
 
   it('every entry in the seed uses one of the 8 known semanticClass values', () => {
     const valid = new Set<string>(StatusSemanticClassSchema.options)
-    for (const entry of DEFAULT_ORGANIZATION_MODEL_STATUSES.entries) {
+    for (const entry of Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES)) {
       expect(
         valid.has(entry.semanticClass),
         `Unexpected semanticClass "${entry.semanticClass}" on entry "${entry.id}"`
@@ -161,7 +164,7 @@ describe('StatusSemanticClassSchema — enum coverage', () => {
   })
 
   it('all 8 semanticClass values have at least one seed entry', () => {
-    const presentClasses = new Set(DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.map((e) => e.semanticClass))
+    const presentClasses = new Set(Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES).map((e) => e.semanticClass))
     for (const cls of StatusSemanticClassSchema.options) {
       expect(presentClasses.has(cls), `No seed entry found for semanticClass "${cls}"`).toBe(true)
     }
@@ -174,7 +177,7 @@ describe('StatusSemanticClassSchema — enum coverage', () => {
 
 describe('DEFAULT_ORGANIZATION_MODEL_STATUSES seed — per-group counts', () => {
   function countBySemClass(cls: string) {
-    return DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.filter((e) => e.semanticClass === cls).length
+    return Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES).filter((e) => e.semanticClass === cls).length
   }
 
   it('has 6 delivery.project entries', () => {
@@ -208,7 +211,7 @@ describe('DEFAULT_ORGANIZATION_MODEL_STATUSES seed — per-group counts', () =>
 
 describe('QueueTaskStatus coverage in seed', () => {
   const queueValues: QueueTaskStatus[] = ['pending', 'processing', 'completed', 'failed', 'expired']
-  const queueIds = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries
+  const queueIds = Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES)
     .filter((e) => e.semanticClass === 'queue')
     .map((e) => e.id)
 
@@ -233,7 +236,7 @@ describe('TaskStatus (delivery) coverage in seed', () => {
     'cancelled',
     'completed'
   ]
-  const taskIds = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries
+  const taskIds = Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES)
     .filter((e) => e.semanticClass === 'delivery.task')
     .map((e) => e.id)
 

package/src/organization-model/__tests__/domains/systems.test.ts

@@ -1,193 +1,209 @@
-import { describe, expect, it } from 'vitest'
-import {
-  DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
-  SystemEntrySchema,
-  SystemKindSchema,
-  SystemsDomainSchema,
-  SystemStatusSchema
-} from '../../domains/systems'
-import { resolveOrganizationModel } from '../../resolve'
-
-const VALID_SYSTEM = {
-  id: 'sys.lead-gen',
-  title: 'Lead Generation Pipeline',
-  description: 'Coordinates prospecting, enrichment, qualification, and outreach preparation.',
-  kind: 'operational' as const,
-  status: 'active' as const
-}
-
-describe('SystemEntrySchema - positive parse', () => {
-  it('accepts a minimal tenant-defined system', () => {
-    const result = SystemEntrySchema.safeParse(VALID_SYSTEM)
-
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.governedByKnowledge).toEqual([])
-      expect(result.data.drivesGoals).toEqual([])
-    }
-  })
-
-  it('accepts all optional governance references when present', () => {
-    const result = SystemEntrySchema.safeParse({
-      ...VALID_SYSTEM,
-      responsibleRoleId: 'role.sales-ops',
-      governedByKnowledge: ['knowledge.lead-gen-playbook'],
-      drivesGoals: ['goal.pipeline-coverage']
-    })
-
-    expect(result.success).toBe(true)
-  })
-
-  it('trims id, title, and description', () => {
-    const result = SystemEntrySchema.safeParse({
-      ...VALID_SYSTEM,
-      id: '  sys.crm  ',
-      title: '  CRM  ',
-      description: '  Owns relationship and deal pipeline operations.  '
-    })
-
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.id).toBe('sys.crm')
-      expect(result.data.title).toBe('CRM')
-      expect(result.data.description).toBe('Owns relationship and deal pipeline operations.')
-    }
-  })
-})
-
-describe('SystemEntrySchema - negative parse', () => {
-  it('rejects missing required fields', () => {
-    expect(SystemEntrySchema.safeParse({ id: 'sys.missing' }).success).toBe(false)
-  })
-
-  it('rejects an unknown system kind', () => {
-    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, kind: 'sales' }).success).toBe(false)
-  })
-
-  it('rejects an unknown system status', () => {
-    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, status: 'paused' }).success).toBe(false)
-  })
-
-  it('rejects IDs that do not match the OM model-id format', () => {
-    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, id: 'Sys Lead Gen' }).success).toBe(false)
-  })
-})
-
-describe('SystemsDomainSchema', () => {
-  it('accepts an empty systems array', () => {
-    expect(SystemsDomainSchema.safeParse({ systems: [] }).success).toBe(true)
-  })
-
-  it('defaults systems to an empty array when omitted', () => {
-    const result = SystemsDomainSchema.safeParse({})
-
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_SYSTEMS)
-    }
-  })
-})
-
-describe('SystemKindSchema and SystemStatusSchema', () => {
-  it.each(['product', 'operational', 'platform', 'diagnostic'] as const)('accepts kind "%s"', (kind) => {
-    expect(SystemKindSchema.safeParse(kind).success).toBe(true)
-  })
-
-  it.each(['active', 'deprecated', 'archived'] as const)('accepts status "%s"', (status) => {
-    expect(SystemStatusSchema.safeParse(status).success).toBe(true)
-  })
-})
-
-describe('resolveOrganizationModel - systems domain integration', () => {
-  it('omitting systems resolves to the empty default catalog', () => {
-    const model = resolveOrganizationModel({})
-
-    expect(model.systems).toEqual(DEFAULT_ORGANIZATION_MODEL_SYSTEMS)
-  })
-
-  it('accepts valid responsible role, knowledge, and goal references', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        roles: { roles: [{ id: 'role.sales-ops', title: 'Sales Ops' }] },
-        goals: {
-          objectives: [
-            {
-              id: 'goal.pipeline-coverage',
-              description: 'Improve sales pipeline coverage',
-              periodStart: '2026-01-01',
-              periodEnd: '2026-12-31'
-            }
-          ]
-        },
-        knowledge: {
-          nodes: [
-            {
-              id: 'knowledge.lead-gen-playbook',
-              kind: 'playbook',
-              title: 'Lead Gen Playbook',
-              summary: 'How lead generation is governed.',
-              body: '## Lead Gen',
-              updatedAt: '2026-05-08'
-            }
-          ]
-        },
-        systems: {
-          systems: [
-            {
-              ...VALID_SYSTEM,
-              responsibleRoleId: 'role.sales-ops',
-              governedByKnowledge: ['knowledge.lead-gen-playbook'],
-              drivesGoals: ['goal.pipeline-coverage']
-            }
-          ]
-        }
-      })
-    ).not.toThrow()
-  })
-
-  it('throws when system IDs are duplicated', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        systems: {
-          systems: [
-            VALID_SYSTEM,
-            {
-              ...VALID_SYSTEM,
-              title: 'Duplicate System'
-            }
-          ]
-        }
-      })
-    ).toThrow(/System id \\"sys\.lead-gen\\" must be unique/)
-  })
-
-  it('throws when responsibleRoleId references an unknown role', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        systems: {
-          systems: [{ ...VALID_SYSTEM, responsibleRoleId: 'role.missing' }]
-        }
-      })
-    ).toThrow(/unknown responsibleRoleId \\"role\.missing\\"/)
-  })
-
-  it('throws when governedByKnowledge references an unknown knowledge node', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        systems: {
-          systems: [{ ...VALID_SYSTEM, governedByKnowledge: ['knowledge.missing'] }]
-        }
-      })
-    ).toThrow(/unknown knowledge node \\"knowledge\.missing\\"/)
-  })
-
-  it('throws when drivesGoals references an unknown goal', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        systems: {
-          systems: [{ ...VALID_SYSTEM, drivesGoals: ['goal.missing'] }]
-        }
-      })
-    ).toThrow(/unknown goal \\"goal\.missing\\"/)
-  })
-})
+import { describe, expect, it, vi } from 'vitest'
+import {
+  DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
+  SystemEntrySchema,
+  SystemKindSchema,
+  SystemStatusSchema,
+  SystemsDomainSchema
+} from '../../domains/systems'
+import { resolveOrganizationModel } from '../../resolve'
+
+const VALID_SYSTEM = {
+  id: 'sys.lead-gen',
+  order: 10,
+  title: 'Lead Generation Pipeline',
+  description: 'Coordinates prospecting, enrichment, qualification, and outreach preparation.',
+  kind: 'operational' as const
+}
+
+describe('SystemEntrySchema - positive parse', () => {
+  it('accepts a minimal tenant-defined system', () => {
+    const result = SystemEntrySchema.safeParse(VALID_SYSTEM)
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.governedByKnowledge).toEqual([])
+      expect(result.data.drivesGoals).toEqual([])
+    }
+  })
+
+  it('accepts all optional governance references when present', () => {
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      responsibleRoleId: 'role.sales-ops',
+      governedByKnowledge: ['knowledge.lead-gen-playbook'],
+      drivesGoals: ['goal.pipeline-coverage']
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('trims id, title, and description', () => {
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      id: '  sys.crm  ',
+      title: '  CRM  ',
+      description: '  Owns relationship and deal pipeline operations.  '
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('sys.crm')
+      expect(result.data.title).toBe('CRM')
+      expect(result.data.description).toBe('Owns relationship and deal pipeline operations.')
+    }
+  })
+
+  it('accepts deprecated status and maps it to lifecycle for one-cycle compatibility', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      status: 'deprecated'
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.status).toBe('deprecated')
+      expect(result.data.lifecycle).toBe('deprecated')
+    }
+    expect(warn).toHaveBeenCalledWith('[organization-model] System.status is deprecated; use System.lifecycle instead.')
+
+    warn.mockRestore()
+  })
+})
+
+describe('SystemEntrySchema - negative parse', () => {
+  it('rejects missing required fields', () => {
+    expect(SystemEntrySchema.safeParse({ id: 'sys.missing' }).success).toBe(false)
+  })
+
+  it('rejects an unknown system kind', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, kind: 'sales' }).success).toBe(false)
+  })
+
+  it('rejects an unknown deprecated system status', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, status: 'paused' }).success).toBe(false)
+  })
+
+  it('rejects IDs that do not match the OM model-id format', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, id: 'Sys Lead Gen' }).success).toBe(false)
+  })
+})
+
+describe('SystemsDomainSchema', () => {
+  it('accepts an empty systems record', () => {
+    expect(SystemsDomainSchema.safeParse({}).success).toBe(true)
+  })
+
+  it('defaults systems to an empty record when omitted', () => {
+    const result = SystemsDomainSchema.safeParse({})
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_SYSTEMS)
+    }
+  })
+})
+
+describe('SystemKindSchema', () => {
+  it.each(['product', 'operational', 'platform', 'diagnostic'] as const)('accepts kind "%s"', (kind) => {
+    expect(SystemKindSchema.safeParse(kind).success).toBe(true)
+  })
+})
+
+describe('SystemStatusSchema', () => {
+  it.each(['active', 'deprecated', 'archived'] as const)('accepts deprecated status "%s"', (status) => {
+    expect(SystemStatusSchema.safeParse(status).success).toBe(true)
+  })
+})
+
+describe('resolveOrganizationModel - systems domain integration', () => {
+  it('omitting systems keeps default system entries', () => {
+    const model = resolveOrganizationModel({})
+
+    expect(Object.keys(model.systems).length).toBeGreaterThan(Object.keys(DEFAULT_ORGANIZATION_MODEL_SYSTEMS).length)
+    expect(model.systems['sales.crm']?.path).toBe('/crm')
+  })
+
+  it('accepts valid responsible role, knowledge, and goal references', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          'role.sales-ops': { id: 'role.sales-ops', order: 10, title: 'Sales Ops' }
+        },
+        goals: {
+          'goal.pipeline-coverage': {
+            id: 'goal.pipeline-coverage',
+            order: 10,
+            description: 'Improve sales pipeline coverage',
+            periodStart: '2026-01-01',
+            periodEnd: '2026-12-31'
+          }
+        },
+        knowledge: {
+          'knowledge.lead-gen-playbook': {
+            id: 'knowledge.lead-gen-playbook',
+            kind: 'playbook',
+            title: 'Lead Gen Playbook',
+            summary: 'How lead generation is governed.',
+            body: '## Lead Gen',
+            updatedAt: '2026-05-08'
+          }
+        },
+        systems: {
+          'sys.lead-gen': {
+            ...VALID_SYSTEM,
+            responsibleRoleId: 'role.sales-ops',
+            governedByKnowledge: ['knowledge.lead-gen-playbook'],
+            drivesGoals: ['goal.pipeline-coverage']
+          }
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when system IDs are duplicated', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sys.lead-gen': VALID_SYSTEM,
+          'sys.lead-gen-dup': {
+            ...VALID_SYSTEM,
+            id: 'sys.lead-gen'
+          }
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws when responsibleRoleId references an unknown role', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sys.lead-gen': { ...VALID_SYSTEM, responsibleRoleId: 'role.missing' }
+        }
+      })
+    ).toThrow(/unknown responsibleRoleId \\"role\.missing\\"/)
+  })
+
+  it('throws when governedByKnowledge references an unknown knowledge node', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sys.lead-gen': { ...VALID_SYSTEM, governedByKnowledge: ['knowledge.missing'] }
+        }
+      })
+    ).toThrow(/unknown knowledge node \\"knowledge\.missing\\"/)
+  })
+
+  it('throws when drivesGoals references an unknown goal', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sys.lead-gen': { ...VALID_SYSTEM, drivesGoals: ['goal.missing'] }
+        }
+      })
+    ).toThrow(/unknown goal \\"goal\.missing\\"/)
+  })
+})