@elevasis/core 0.22.0 → 0.24.0

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

@@ -15,6 +15,7 @@ describe('CustomerSegmentSchema — positive parse', () => {
   it('accepts a fully-populated segment', () => {
     const result = CustomerSegmentSchema.safeParse({
       id: 'segment-smb-agencies',
+      order: 10,
       name: 'SMB Marketing Agencies',
       description: 'Small marketing agencies with 1–50 employees seeking automation.',
       jobsToBeDone: 'Automate client reporting and lead generation workflows.',
@@ -30,8 +31,8 @@ describe('CustomerSegmentSchema — positive parse', () => {
     expect(result.success).toBe(true)
   })
 
-  it('accepts a minimal segment — only id required', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-minimal' })
+  it('accepts a minimal segment — only id and order required', () => {
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-minimal', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.id).toBe('seg-minimal')
@@ -48,6 +49,7 @@ describe('CustomerSegmentSchema — positive parse', () => {
   it('trims whitespace from string fields', () => {
     const result = CustomerSegmentSchema.safeParse({
       id: '  seg-trim  ',
+      order: 10,
       name: '  Trimmed Name  ',
       valueProp: '  Trimmed value prop.  '
     })
@@ -62,6 +64,7 @@ describe('CustomerSegmentSchema — positive parse', () => {
   it('accepts pains and gains as non-empty arrays', () => {
     const result = CustomerSegmentSchema.safeParse({
       id: 'seg-arrays',
+      order: 10,
       pains: ['Pain A', 'Pain B', 'Pain C'],
       gains: ['Gain X', 'Gain Y']
     })
@@ -79,7 +82,7 @@ describe('CustomerSegmentSchema — positive parse', () => {
 
 describe('CustomerSegmentSchema — default values', () => {
   it('pains defaults to empty array', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-defaults' })
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.pains).toEqual([])
@@ -87,7 +90,7 @@ describe('CustomerSegmentSchema — default values', () => {
   })
 
   it('gains defaults to empty array', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-defaults' })
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.gains).toEqual([])
@@ -95,7 +98,7 @@ describe('CustomerSegmentSchema — default values', () => {
   })
 
   it('firmographics defaults to empty object', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-defaults' })
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.firmographics).toEqual({})
@@ -103,7 +106,7 @@ describe('CustomerSegmentSchema — default values', () => {
   })
 
   it('all string fields default to empty string', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-str-defaults' })
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-str-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.name).toBe('')
@@ -120,42 +123,42 @@ describe('CustomerSegmentSchema — default values', () => {
 
 describe('CustomerSegmentSchema — negative parse', () => {
   it('rejects missing id', () => {
-    const result = CustomerSegmentSchema.safeParse({ name: 'No ID Segment' })
+    const result = CustomerSegmentSchema.safeParse({ order: 10, name: 'No ID Segment' })
     expect(result.success).toBe(false)
   })
 
   it('rejects empty string id', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: '' })
+    const result = CustomerSegmentSchema.safeParse({ id: '', order: 10 })
     expect(result.success).toBe(false)
   })
 
   it('rejects whitespace-only id (trims to empty string)', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: '   ' })
+    const result = CustomerSegmentSchema.safeParse({ id: '   ', order: 10 })
     expect(result.success).toBe(false)
   })
 
   it('rejects id as a number', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 42 })
+    const result = CustomerSegmentSchema.safeParse({ id: 42, order: 10 })
     expect(result.success).toBe(false)
   })
 
   it('rejects pains as a non-array value', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-bad-pains', pains: 'not an array' })
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-bad-pains', order: 10, pains: 'not an array' })
     expect(result.success).toBe(false)
   })
 
   it('rejects gains containing a non-string element', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-bad-gains', gains: [42, 'valid'] })
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-bad-gains', order: 10, gains: [42, 'valid'] })
     expect(result.success).toBe(false)
   })
 
   it('rejects name exceeding 200 characters', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-long-name', name: 'x'.repeat(201) })
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-long-name', order: 10, name: 'x'.repeat(201) })
     expect(result.success).toBe(false)
   })
 
   it('rejects description exceeding 2000 characters', () => {
-    const result = CustomerSegmentSchema.safeParse({ id: 'seg-long-desc', description: 'x'.repeat(2001) })
+    const result = CustomerSegmentSchema.safeParse({ id: 'seg-long-desc', order: 10, description: 'x'.repeat(2001) })
     expect(result.success).toBe(false)
   })
 })
@@ -205,34 +208,34 @@ describe('FirmographicsSchema', () => {
 // ---------------------------------------------------------------------------
 
 describe('CustomersDomainSchema — structural', () => {
-  it('accepts an empty segments array', () => {
-    const result = CustomersDomainSchema.safeParse({ segments: [] })
+  it('accepts an empty segments record', () => {
+    const result = CustomersDomainSchema.safeParse({})
     expect(result.success).toBe(true)
   })
 
-  it('defaults segments to empty array when key is omitted', () => {
+  it('defaults segments to empty record when omitted', () => {
     const result = CustomersDomainSchema.safeParse({})
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.segments).toEqual([])
+      expect(result.data).toEqual({})
     }
   })
 
   it('accepts multiple valid segments', () => {
     const result = CustomersDomainSchema.safeParse({
-      segments: [
-        { id: 'seg-a', name: 'Segment A' },
-        { id: 'seg-b', name: 'Segment B', pains: ['Pain 1'] }
-      ]
+      'seg-a': { id: 'seg-a', order: 10, name: 'Segment A' },
+      'seg-b': { id: 'seg-b', order: 20, name: 'Segment B', pains: ['Pain 1'] }
     })
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.segments).toHaveLength(2)
+      expect(Object.keys(result.data)).toHaveLength(2)
     }
   })
 
-  it('rejects segments as a non-array value', () => {
-    const result = CustomersDomainSchema.safeParse({ segments: 'not an array' })
+  it('rejects a record where entry id does not match map key', () => {
+    const result = CustomersDomainSchema.safeParse({
+      'seg-a': { id: 'seg-b', order: 10, name: 'Mismatched' }
+    })
     expect(result.success).toBe(false)
   })
 
@@ -252,44 +255,45 @@ describe('CustomersDomainSchema — structural', () => {
 describe('resolveOrganizationModel — customers domain integration', () => {
   it('merges partial customers override and preserves empty segments default', () => {
     const model = resolveOrganizationModel({
-      customers: { segments: [] }
+      customers: {}
     })
-    expect(model.customers.segments).toEqual([])
+    expect(Object.keys(model.customers)).toHaveLength(0)
   })
 
   it('merges a customers override with populated segments into resolved model', () => {
     const model = resolveOrganizationModel({
       customers: {
-        segments: [
-          {
-            id: 'seg-agencies',
-            name: 'Agency Owners',
-            pains: ['Too much manual work'],
-            gains: ['More client capacity'],
-            valueProp: 'Automate the repetitive parts of agency ops.'
-          }
-        ]
+        'seg-agencies': {
+          id: 'seg-agencies',
+          order: 10,
+          name: 'Agency Owners',
+          pains: ['Too much manual work'],
+          gains: ['More client capacity'],
+          valueProp: 'Automate the repetitive parts of agency ops.'
+        }
       }
     })
-    expect(model.customers.segments).toHaveLength(1)
-    expect(model.customers.segments[0].id).toBe('seg-agencies')
-    expect(model.customers.segments[0].pains).toEqual(['Too much manual work'])
-    expect(model.customers.segments[0].description).toBe('')
+    expect(Object.keys(model.customers)).toHaveLength(1)
+    expect(model.customers['seg-agencies'].id).toBe('seg-agencies')
+    expect(model.customers['seg-agencies'].pains).toEqual(['Too much manual work'])
+    expect(model.customers['seg-agencies'].description).toBe('')
   })
 
   it('does not bleed customers changes into other top-level domains', () => {
     const model = resolveOrganizationModel({
-      customers: { segments: [{ id: 'seg-isolated' }] }
+      customers: { 'seg-isolated': { id: 'seg-isolated', order: 10 } }
     })
     expect(model.identity).toBeDefined()
-    expect(model.features).toBeDefined()
-    expect(model.statuses).toBeDefined()
+    expect(model.systems).toBeDefined()
+    // Phase 4 (D1, D8): model.statuses and model.navigation removed from top-level OM.
+    // Verify other sibling domains are still intact instead.
+    expect(model.knowledge).toBeDefined()
     expect(model.navigation).toBeDefined()
   })
 
   it('omitting customers key entirely resolves to default empty segments', () => {
     const model = resolveOrganizationModel({})
     expect(model.customers).toBeDefined()
-    expect(model.customers.segments).toEqual([])
+    expect(Object.keys(model.customers)).toHaveLength(0)
   })
 })

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

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+import {
+  DEFAULT_ORGANIZATION_MODEL_ENTITIES,
+  EntitiesDomainSchema,
+  EntityLinkSchema,
+  EntitySchema
+} from '../../domains/entities'
+
+describe('entities domain', () => {
+  it('defaults the initial entity catalog with ordered entries', () => {
+    const domain = EntitiesDomainSchema.parse(DEFAULT_ORGANIZATION_MODEL_ENTITIES)
+
+    expect(Object.keys(domain)).toEqual([
+      'crm.deal',
+      'crm.contact',
+      'leadgen.list',
+      'leadgen.company',
+      'leadgen.contact',
+      'delivery.project',
+      'delivery.milestone',
+      'delivery.task'
+    ])
+    expect(Object.values(domain).map((entity) => entity.order)).toEqual([10, 20, 30, 40, 50, 60, 70, 80])
+    expect(domain['crm.deal']).toMatchObject({
+      id: 'crm.deal',
+      label: 'Deal',
+      ownedBySystemId: 'sales.crm'
+    })
+  })
+
+  it('enforces map key equals entity id', () => {
+    expect(() =>
+      EntitiesDomainSchema.parse({
+        'crm.deal': {
+          id: 'crm.contact',
+          order: 10,
+          label: 'Deal',
+          ownedBySystemId: 'sales.crm'
+        }
+      })
+    ).toThrow(/Each entity entry id must match its map key/)
+  })
+
+  it('accepts declared entity links', () => {
+    expect(() => EntityLinkSchema.parse({ toEntity: 'crm.contact', kind: 'has-many' })).not.toThrow()
+    expect(() =>
+      EntitySchema.parse({
+        id: 'crm.deal',
+        order: 10,
+        label: 'Deal',
+        ownedBySystemId: 'sales.crm',
+        links: [{ toEntity: 'crm.contact', kind: 'belongs-to', via: 'contact_id', label: 'contact' }]
+      })
+    ).not.toThrow()
+  })
+})

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

@@ -102,6 +102,7 @@ describe('ObjectiveSchema — positive parse', () => {
   it('accepts a fully-populated objective with measurable outcomes', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-grow-arr-q1-2026',
+      order: 10,
       description: 'Grow annual recurring revenue by 50% in Q1 2026',
       periodStart: '2026-01-01',
       periodEnd: '2026-03-31',
@@ -126,6 +127,7 @@ describe('ObjectiveSchema — positive parse', () => {
   it('accepts a minimal objective — no measurable outcomes', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-minimal',
+      order: 10,
       description: 'Establish brand presence in new market',
       periodStart: '2026-04-01',
       periodEnd: '2026-06-30'
@@ -139,6 +141,7 @@ describe('ObjectiveSchema — positive parse', () => {
   it('keyResults defaults to empty array when omitted', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-defaults',
+      order: 10,
       description: 'Launch new product line',
       periodStart: '2026-01-01',
       periodEnd: '2026-12-31'
@@ -157,6 +160,7 @@ describe('ObjectiveSchema — positive parse', () => {
 describe('ObjectiveSchema — negative parse', () => {
   it('rejects missing id', () => {
     const result = ObjectiveSchema.safeParse({
+      order: 10,
       description: 'No id provided',
       periodStart: '2026-01-01',
       periodEnd: '2026-12-31'
@@ -167,6 +171,7 @@ describe('ObjectiveSchema — negative parse', () => {
   it('rejects empty string id', () => {
     const result = ObjectiveSchema.safeParse({
       id: '',
+      order: 10,
       description: 'Empty id',
       periodStart: '2026-01-01',
       periodEnd: '2026-12-31'
@@ -177,6 +182,7 @@ describe('ObjectiveSchema — negative parse', () => {
   it('rejects missing description', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-no-desc',
+      order: 10,
       periodStart: '2026-01-01',
       periodEnd: '2026-12-31'
     })
@@ -186,6 +192,7 @@ describe('ObjectiveSchema — negative parse', () => {
   it('rejects empty string description', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-empty-desc',
+      order: 10,
       description: '',
       periodStart: '2026-01-01',
       periodEnd: '2026-12-31'
@@ -196,6 +203,7 @@ describe('ObjectiveSchema — negative parse', () => {
   it('rejects periodStart with wrong date format (non-ISO string)', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-bad-start',
+      order: 10,
       description: 'Bad date format',
       periodStart: '01/01/2026',
       periodEnd: '2026-12-31'
@@ -206,6 +214,7 @@ describe('ObjectiveSchema — negative parse', () => {
   it('rejects periodEnd with wrong date format (non-ISO string)', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-bad-end',
+      order: 10,
       description: 'Bad date format',
       periodStart: '2026-01-01',
       periodEnd: 'December 31, 2026'
@@ -216,6 +225,7 @@ describe('ObjectiveSchema — negative parse', () => {
   it('rejects periodStart as a Date object (must be ISO string)', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-date-obj',
+      order: 10,
       description: 'Date object not allowed',
       periodStart: new Date('2026-01-01'),
       periodEnd: '2026-12-31'
@@ -229,16 +239,16 @@ describe('ObjectiveSchema — negative parse', () => {
 // ---------------------------------------------------------------------------
 
 describe('GoalsDomainSchema — structural', () => {
-  it('accepts an empty objectives array', () => {
-    const result = GoalsDomainSchema.safeParse({ objectives: [] })
+  it('accepts an empty goals record', () => {
+    const result = GoalsDomainSchema.safeParse({})
     expect(result.success).toBe(true)
   })
 
-  it('defaults objectives to empty array when key is omitted', () => {
+  it('defaults goals to empty record when key is omitted', () => {
     const result = GoalsDomainSchema.safeParse({})
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.objectives).toEqual([])
+      expect(result.data).toEqual({})
     }
   })
 
@@ -252,14 +262,24 @@ describe('GoalsDomainSchema — structural', () => {
 
   it('accepts multiple valid objectives', () => {
     const result = GoalsDomainSchema.safeParse({
-      objectives: [
-        { id: 'goal-a', description: 'First goal', periodStart: '2026-01-01', periodEnd: '2026-03-31' },
-        { id: 'goal-b', description: 'Second goal', periodStart: '2026-04-01', periodEnd: '2026-06-30' }
-      ]
+      'goal-a': {
+        id: 'goal-a',
+        order: 10,
+        description: 'First goal',
+        periodStart: '2026-01-01',
+        periodEnd: '2026-03-31'
+      },
+      'goal-b': {
+        id: 'goal-b',
+        order: 20,
+        description: 'Second goal',
+        periodStart: '2026-04-01',
+        periodEnd: '2026-06-30'
+      }
     })
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.objectives).toHaveLength(2)
+      expect(Object.keys(result.data)).toHaveLength(2)
     }
   })
 })
@@ -274,6 +294,7 @@ describe('ObjectiveSchema — plain-language field names (no OKR jargon exposed)
   it('parsed objective has expected field names including keyResults for tooling compat', () => {
     const result = ObjectiveSchema.safeParse({
       id: 'goal-plain',
+      order: 10,
       description: 'Expand into new markets',
       periodStart: '2026-01-01',
       periodEnd: '2026-12-31',
@@ -302,14 +323,13 @@ describe('resolveOrganizationModel — goals period-range validation', () => {
     expect(() =>
       resolveOrganizationModel({
         goals: {
-          objectives: [
-            {
-              id: 'goal-valid',
-              description: 'Valid date range',
-              periodStart: '2026-01-01',
-              periodEnd: '2026-12-31'
-            }
-          ]
+          'goal-valid': {
+            id: 'goal-valid',
+            order: 10,
+            description: 'Valid date range',
+            periodStart: '2026-01-01',
+            periodEnd: '2026-12-31'
+          }
         }
       })
     ).not.toThrow()
@@ -319,14 +339,13 @@ describe('resolveOrganizationModel — goals period-range validation', () => {
     expect(() =>
       resolveOrganizationModel({
         goals: {
-          objectives: [
-            {
-              id: 'goal-one-day',
-              description: 'Single day range',
-              periodStart: '2026-06-01',
-              periodEnd: '2026-06-02'
-            }
-          ]
+          'goal-one-day': {
+            id: 'goal-one-day',
+            order: 10,
+            description: 'Single day range',
+            periodStart: '2026-06-01',
+            periodEnd: '2026-06-02'
+          }
         }
       })
     ).not.toThrow()
@@ -336,14 +355,13 @@ describe('resolveOrganizationModel — goals period-range validation', () => {
     expect(() =>
       resolveOrganizationModel({
         goals: {
-          objectives: [
-            {
-              id: 'goal-same-date',
-              description: 'Same start and end',
-              periodStart: '2026-03-01',
-              periodEnd: '2026-03-01'
-            }
-          ]
+          'goal-same-date': {
+            id: 'goal-same-date',
+            order: 10,
+            description: 'Same start and end',
+            periodStart: '2026-03-01',
+            periodEnd: '2026-03-01'
+          }
         }
       })
     ).toThrow()
@@ -353,14 +371,13 @@ describe('resolveOrganizationModel — goals period-range validation', () => {
     expect(() =>
       resolveOrganizationModel({
         goals: {
-          objectives: [
-            {
-              id: 'goal-reversed',
-              description: 'Reversed date range',
-              periodStart: '2026-12-31',
-              periodEnd: '2026-01-01'
-            }
-          ]
+          'goal-reversed': {
+            id: 'goal-reversed',
+            order: 10,
+            description: 'Reversed date range',
+            periodStart: '2026-12-31',
+            periodEnd: '2026-01-01'
+          }
         }
       })
     ).toThrow()
@@ -371,14 +388,13 @@ describe('resolveOrganizationModel — goals period-range validation', () => {
     try {
       resolveOrganizationModel({
         goals: {
-          objectives: [
-            {
-              id: 'goal-bad-range',
-              description: 'Bad range for error message check',
-              periodStart: '2026-06-01',
-              periodEnd: '2026-01-01'
-            }
-          ]
+          'goal-bad-range': {
+            id: 'goal-bad-range',
+            order: 10,
+            description: 'Bad range for error message check',
+            periodStart: '2026-06-01',
+            periodEnd: '2026-01-01'
+          }
         }
       })
     } catch (e) {
@@ -387,10 +403,10 @@ describe('resolveOrganizationModel — goals period-range validation', () => {
     expect(errorMessage).toContain('periodEnd')
   })
 
-  it('passes when goals objectives array is empty (no ranges to validate)', () => {
+  it('passes when goals record is empty (no ranges to validate)', () => {
     expect(() =>
       resolveOrganizationModel({
-        goals: { objectives: [] }
+        goals: {}
       })
     ).not.toThrow()
   })
@@ -401,79 +417,77 @@ describe('resolveOrganizationModel — goals period-range validation', () => {
 // ---------------------------------------------------------------------------
 
 describe('resolveOrganizationModel — goals domain integration', () => {
-  it('omitting goals key entirely resolves to default empty objectives', () => {
+  it('omitting goals key entirely resolves to default empty goals', () => {
     const model = resolveOrganizationModel({})
     expect(model.goals).toBeDefined()
-    expect(model.goals.objectives).toEqual([])
+    expect(Object.keys(model.goals)).toHaveLength(0)
   })
 
-  it('merges partial goals override and preserves empty objectives default', () => {
-    const model = resolveOrganizationModel({ goals: { objectives: [] } })
-    expect(model.goals.objectives).toEqual([])
+  it('merges partial goals override and preserves empty goals default', () => {
+    const model = resolveOrganizationModel({ goals: {} })
+    expect(Object.keys(model.goals)).toHaveLength(0)
   })
 
   it('goals domain is registered after roles — both present in resolved model', () => {
     const model = resolveOrganizationModel({
-      roles: { roles: [{ id: 'role-ceo', title: 'CEO' }] },
+      roles: { 'role-ceo': { id: 'role-ceo', order: 10, title: 'CEO' } },
       goals: {
-        objectives: [
-          {
-            id: 'goal-grow',
-            description: 'Grow the business',
-            periodStart: '2026-01-01',
-            periodEnd: '2026-12-31'
-          }
-        ]
+        'goal-grow': {
+          id: 'goal-grow',
+          order: 10,
+          description: 'Grow the business',
+          periodStart: '2026-01-01',
+          periodEnd: '2026-12-31'
+        }
       }
     })
-    expect(model.roles.roles).toHaveLength(1)
-    expect(model.goals.objectives).toHaveLength(1)
-    expect(model.goals.objectives[0].id).toBe('goal-grow')
+    expect(Object.keys(model.roles)).toHaveLength(1)
+    expect(Object.keys(model.goals)).toHaveLength(1)
+    expect(model.goals['goal-grow'].id).toBe('goal-grow')
   })
 
   it('does not bleed goals changes into other top-level domains', () => {
     const model = resolveOrganizationModel({
       goals: {
-        objectives: [
-          {
-            id: 'goal-isolated',
-            description: 'Should not affect other domains',
-            periodStart: '2026-01-01',
-            periodEnd: '2026-06-30'
-          }
-        ]
+        'goal-isolated': {
+          id: 'goal-isolated',
+          order: 10,
+          description: 'Should not affect other domains',
+          periodStart: '2026-01-01',
+          periodEnd: '2026-06-30'
+        }
       }
     })
     expect(model.identity).toBeDefined()
     expect(model.customers).toBeDefined()
     expect(model.offerings).toBeDefined()
     expect(model.roles).toBeDefined()
-    expect(model.features).toBeDefined()
+    expect(model.systems).toBeDefined()
   })
 
   it('resolved objective carries keyResults with defaulted currentValue', () => {
     const model = resolveOrganizationModel({
       goals: {
-        objectives: [
-          {
-            id: 'goal-with-kr',
-            description: 'Goal with measurable outcomes',
-            periodStart: '2026-01-01',
-            periodEnd: '2026-12-31',
-            keyResults: [
-              {
-                id: 'kr-1',
-                description: 'Hit revenue target',
-                targetMetric: 'monthly revenue',
-                targetValue: 50000
-              }
-            ]
-          }
-        ]
+        'goal-with-kr': {
+          id: 'goal-with-kr',
+          order: 10,
+          description: 'Goal with measurable outcomes',
+          periodStart: '2026-01-01',
+          periodEnd: '2026-12-31',
+          keyResults: [
+            {
+              id: 'kr-1',
+              description: 'Hit revenue target',
+              targetMetric: 'monthly revenue',
+              targetValue: 50000
+            }
+          ]
+        }
       }
     })
-    expect(model.goals.objectives[0].keyResults).toHaveLength(1)
-    expect(model.goals.objectives[0].keyResults[0].currentValue).toBe(0)
-    expect(model.goals.objectives[0].keyResults[0].targetValue).toBe(50000)
+    const objective = model.goals['goal-with-kr']
+    expect(objective.keyResults).toHaveLength(1)
+    expect(objective.keyResults[0].currentValue).toBe(0)
+    expect(objective.keyResults[0].targetValue).toBe(50000)
   })
 })