@elevasis/core 0.22.0 → 0.23.0

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

@@ -13,6 +13,7 @@ describe('RoleSchema - positive parse', () => {
   it('accepts a fully-populated role', () => {
     const result = RoleSchema.safeParse({
       id: 'role-ceo',
+      order: 10,
       title: 'CEO',
       responsibilities: ['Set company direction', 'Hire and develop leadership team'],
       reportsToId: undefined,
@@ -23,8 +24,8 @@ describe('RoleSchema - positive parse', () => {
     expect(result.success).toBe(true)
   })
 
-  it('accepts a minimal role - only id and title required', () => {
-    const result = RoleSchema.safeParse({ id: 'role-minimal', title: 'Head of Sales' })
+  it('accepts a minimal role - only id, order, and title required', () => {
+    const result = RoleSchema.safeParse({ id: 'role-minimal', order: 10, title: 'Head of Sales' })
 
     expect(result.success).toBe(true)
     if (result.success) {
@@ -39,23 +40,33 @@ describe('RoleSchema - positive parse', () => {
 
   it('accepts human, agent, team, and multi-holder variants', () => {
     expect(
-      RoleSchema.safeParse({ id: 'role-human', title: 'Human', heldBy: { kind: 'human', userId: 'user.alice' } })
-        .success
+      RoleSchema.safeParse({
+        id: 'role-human',
+        order: 10,
+        title: 'Human',
+        heldBy: { kind: 'human', userId: 'user.alice' }
+      }).success
     ).toBe(true)
     expect(
       RoleSchema.safeParse({
         id: 'role-agent',
+        order: 10,
         title: 'Agent',
         heldBy: { kind: 'agent', agentId: 'command-center-assistant' }
       }).success
     ).toBe(true)
     expect(
-      RoleSchema.safeParse({ id: 'role-team', title: 'Team', heldBy: { kind: 'team', memberIds: ['user.alice'] } })
-        .success
+      RoleSchema.safeParse({
+        id: 'role-team',
+        order: 10,
+        title: 'Team',
+        heldBy: { kind: 'team', memberIds: ['user.alice'] }
+      }).success
     ).toBe(true)
     expect(
       RoleSchema.safeParse({
         id: 'role-multi',
+        order: 10,
         title: 'Multi',
         heldBy: [
           { kind: 'human', userId: 'user.alice' },
@@ -68,6 +79,7 @@ describe('RoleSchema - positive parse', () => {
   it('trims whitespace from id and title', () => {
     const result = RoleSchema.safeParse({
       id: '  role-trim  ',
+      order: 10,
       title: '  Trimmed Title  '
     })
 
@@ -81,7 +93,7 @@ describe('RoleSchema - positive parse', () => {
 
 describe('RoleSchema - default values', () => {
   it('responsibilities defaults to empty array when omitted', () => {
-    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
+    const result = RoleSchema.safeParse({ id: 'role-defaults', order: 10, title: 'Engineer' })
 
     expect(result.success).toBe(true)
     if (result.success) {
@@ -90,7 +102,7 @@ describe('RoleSchema - default values', () => {
   })
 
   it('reportsToId, heldBy, and responsibleFor are optional', () => {
-    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
+    const result = RoleSchema.safeParse({ id: 'role-defaults', order: 10, title: 'Engineer' })
 
     expect(result.success).toBe(true)
     if (result.success) {
@@ -104,16 +116,17 @@ describe('RoleSchema - default values', () => {
 describe('RoleSchema - negative parse', () => {
   it('rejects missing or invalid required fields', () => {
     expect(RoleSchema.safeParse({ title: 'No ID Role' }).success).toBe(false)
-    expect(RoleSchema.safeParse({ id: '', title: 'Empty ID' }).success).toBe(false)
-    expect(RoleSchema.safeParse({ id: '   ', title: 'Whitespace ID' }).success).toBe(false)
-    expect(RoleSchema.safeParse({ id: 'role-no-title' }).success).toBe(false)
-    expect(RoleSchema.safeParse({ id: 'role-empty-title', title: '' }).success).toBe(false)
-    expect(RoleSchema.safeParse({ id: 'role-whitespace-title', title: '   ' }).success).toBe(false)
+    expect(RoleSchema.safeParse({ id: '', order: 10, title: 'Empty ID' }).success).toBe(false)
+    expect(RoleSchema.safeParse({ id: '   ', order: 10, title: 'Whitespace ID' }).success).toBe(false)
+    expect(RoleSchema.safeParse({ id: 'role-no-title', order: 10 }).success).toBe(false)
+    expect(RoleSchema.safeParse({ id: 'role-empty-title', order: 10, title: '' }).success).toBe(false)
+    expect(RoleSchema.safeParse({ id: 'role-whitespace-title', order: 10, title: '   ' }).success).toBe(false)
   })
 
   it('rejects responsibilities as a non-array value', () => {
     const result = RoleSchema.safeParse({
       id: 'role-bad-resp',
+      order: 10,
       title: 'Bad Role',
       responsibilities: 'single string'
     })
@@ -122,14 +135,20 @@ describe('RoleSchema - negative parse', () => {
   })
 
   it('rejects legacy string heldBy values and invalid holders', () => {
-    expect(RoleSchema.safeParse({ id: 'role-legacy-holder', title: 'Legacy Holder', heldBy: 'Alice' }).success).toBe(
-      false
-    )
     expect(
-      RoleSchema.safeParse({ id: 'role-empty-team', title: 'Empty Team', heldBy: { kind: 'team', memberIds: [] } })
-        .success
+      RoleSchema.safeParse({ id: 'role-legacy-holder', order: 10, title: 'Legacy Holder', heldBy: 'Alice' }).success
+    ).toBe(false)
+    expect(
+      RoleSchema.safeParse({
+        id: 'role-empty-team',
+        order: 10,
+        title: 'Empty Team',
+        heldBy: { kind: 'team', memberIds: [] }
+      }).success
+    ).toBe(false)
+    expect(
+      RoleSchema.safeParse({ id: 'role-empty-holders', order: 10, title: 'Empty Holders', heldBy: [] }).success
     ).toBe(false)
-    expect(RoleSchema.safeParse({ id: 'role-empty-holders', title: 'Empty Holders', heldBy: [] }).success).toBe(false)
   })
 })
 
@@ -149,6 +168,7 @@ describe('RoleSchema - plain-language field names (no EOS jargon)', () => {
   it('parsed role has the plain-language keys title / responsibilities / reportsToId / heldBy / responsibleFor', () => {
     const result = RoleSchema.safeParse({
       id: 'role-plain',
+      order: 10,
       title: 'Product Lead',
       responsibilities: ['Own roadmap'],
       reportsToId: 'role-ceo',
@@ -173,35 +193,37 @@ describe('RoleSchema - plain-language field names (no EOS jargon)', () => {
 })
 
 describe('RolesDomainSchema - structural', () => {
-  it('accepts an empty roles array', () => {
-    expect(RolesDomainSchema.safeParse({ roles: [] }).success).toBe(true)
+  it('accepts an empty roles record', () => {
+    expect(RolesDomainSchema.safeParse({}).success).toBe(true)
   })
 
-  it('defaults roles to empty array when key is omitted', () => {
+  it('defaults roles to empty record when omitted', () => {
     const result = RolesDomainSchema.safeParse({})
 
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.roles).toEqual([])
+      expect(result.data).toEqual({})
     }
   })
 
   it('accepts multiple valid roles', () => {
     const result = RolesDomainSchema.safeParse({
-      roles: [
-        { id: 'role-a', title: 'CEO' },
-        { id: 'role-b', title: 'COO', reportsToId: 'role-a' }
-      ]
+      'role-a': { id: 'role-a', order: 10, title: 'CEO' },
+      'role-b': { id: 'role-b', order: 20, title: 'COO', reportsToId: 'role-a' }
     })
 
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.roles).toHaveLength(2)
+      expect(Object.keys(result.data)).toHaveLength(2)
     }
   })
 
-  it('rejects roles as a non-array value', () => {
-    expect(RolesDomainSchema.safeParse({ roles: 'not an array' }).success).toBe(false)
+  it('rejects a record where entry id does not match map key', () => {
+    expect(
+      RolesDomainSchema.safeParse({
+        'role-a': { id: 'role-b', order: 10, title: 'Mismatched' }
+      }).success
+    ).toBe(false)
   })
 
   it('DEFAULT_ORGANIZATION_MODEL_ROLES constant matches schema parse of empty object', () => {
@@ -219,10 +241,8 @@ describe('resolveOrganizationModel - roles cross-ref (reportsToId)', () => {
     expect(() =>
       resolveOrganizationModel({
         roles: {
-          roles: [
-            { id: 'role-ceo', title: 'CEO' },
-            { id: 'role-coo', title: 'COO', reportsToId: 'role-ceo' }
-          ]
+          'role-ceo': { id: 'role-ceo', order: 10, title: 'CEO' },
+          'role-coo': { id: 'role-coo', order: 20, title: 'COO', reportsToId: 'role-ceo' }
         }
       })
     ).not.toThrow()
@@ -232,7 +252,7 @@ describe('resolveOrganizationModel - roles cross-ref (reportsToId)', () => {
     expect(() =>
       resolveOrganizationModel({
         roles: {
-          roles: [{ id: 'role-orphan', title: 'Orphan Role', reportsToId: 'nonexistent-role' }]
+          'role-orphan': { id: 'role-orphan', order: 10, title: 'Orphan Role', reportsToId: 'nonexistent-role' }
         }
       })
     ).toThrow()
@@ -242,27 +262,50 @@ describe('resolveOrganizationModel - roles cross-ref (reportsToId)', () => {
     expect(() =>
       resolveOrganizationModel({
         roles: {
-          roles: [{ id: 'role-bad-ref', title: 'Bad Ref Role', reportsToId: 'ghost-role' }]
+          'role-bad-ref': { id: 'role-bad-ref', order: 10, title: 'Bad Ref Role', reportsToId: 'ghost-role' }
         }
       })
     ).toThrow(/ghost-role/)
   })
 
-  it('passes when reportsToId is absent or roles array is empty', () => {
+  it('passes when reportsToId is absent or roles record is empty', () => {
     expect(() =>
       resolveOrganizationModel({
         roles: {
-          roles: [{ id: 'role-top', title: 'Top Level Role' }]
+          'role-top': { id: 'role-top', order: 10, title: 'Top Level Role' }
         }
       })
     ).not.toThrow()
-    expect(() => resolveOrganizationModel({ roles: { roles: [] } })).not.toThrow()
+    expect(() => resolveOrganizationModel({ roles: {} })).not.toThrow()
+  })
+
+  it('throws when reportsToId points to the same role', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          'role-loop': { id: 'role-loop', order: 10, title: 'Loop Role', reportsToId: 'role-loop' }
+        }
+      })
+    ).toThrow(/reportsToId cycle/)
+  })
+
+  it('throws when reportsToId creates an indirect cycle', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          'role-a': { id: 'role-a', order: 10, title: 'Role A', reportsToId: 'role-c' },
+          'role-b': { id: 'role-b', order: 20, title: 'Role B', reportsToId: 'role-a' },
+          'role-c': { id: 'role-c', order: 30, title: 'Role C', reportsToId: 'role-b' }
+        }
+      })
+    ).toThrow(/reportsToId cycle/)
   })
 })
 
 describe('resolveOrganizationModel - roles cross-ref (responsibleFor and heldBy)', () => {
   const validSystem = {
     id: 'sys.platform',
+    order: 10,
     title: 'Platform',
     description: 'Owns platform operations.',
     kind: 'platform' as const,
@@ -271,19 +314,25 @@ describe('resolveOrganizationModel - roles cross-ref (responsibleFor and heldBy)
 
   const validAgentResource = {
     id: 'command-center-assistant',
+    order: 10,
     kind: 'agent' as const,
-    systemId: 'sys.platform',
+    systemPath: 'sys.platform',
     status: 'active' as const,
-    agentKind: 'system' as const,
+    agentKind: 'platform' as const,
     sessionCapable: true
   }
 
   it('passes when responsibleFor references a declared system id', () => {
     expect(() =>
       resolveOrganizationModel({
-        systems: { systems: [validSystem] },
+        systems: { 'sys.platform': validSystem },
         roles: {
-          roles: [{ id: 'role.platform-owner', title: 'Platform Owner', responsibleFor: ['sys.platform'] }]
+          'role.platform-owner': {
+            id: 'role.platform-owner',
+            order: 10,
+            title: 'Platform Owner',
+            responsibleFor: ['sys.platform']
+          }
         }
       })
     ).not.toThrow()
@@ -293,7 +342,12 @@ describe('resolveOrganizationModel - roles cross-ref (responsibleFor and heldBy)
     expect(() =>
       resolveOrganizationModel({
         roles: {
-          roles: [{ id: 'role.platform-owner', title: 'Platform Owner', responsibleFor: ['sys.missing'] }]
+          'role.platform-owner': {
+            id: 'role.platform-owner',
+            order: 10,
+            title: 'Platform Owner',
+            responsibleFor: ['sys.missing']
+          }
         }
       })
     ).toThrow(/unknown responsibleFor system/)
@@ -302,16 +356,17 @@ describe('resolveOrganizationModel - roles cross-ref (responsibleFor and heldBy)
   it('passes when an agent holder references a declared agent resource', () => {
     expect(() =>
       resolveOrganizationModel({
-        systems: { systems: [validSystem] },
-        resources: { entries: [validAgentResource] },
+        systems: { 'sys.platform': validSystem },
+        resources: {
+          'command-center-assistant': validAgentResource
+        },
         roles: {
-          roles: [
-            {
-              id: 'role.platform-assistant',
-              title: 'Platform Assistant',
-              heldBy: { kind: 'agent', agentId: 'command-center-assistant' }
-            }
-          ]
+          'role.platform-assistant': {
+            id: 'role.platform-assistant',
+            order: 10,
+            title: 'Platform Assistant',
+            heldBy: { kind: 'agent', agentId: 'command-center-assistant' }
+          }
         }
       })
     ).not.toThrow()
@@ -321,13 +376,12 @@ describe('resolveOrganizationModel - roles cross-ref (responsibleFor and heldBy)
     expect(() =>
       resolveOrganizationModel({
         roles: {
-          roles: [
-            {
-              id: 'role.platform-assistant',
-              title: 'Platform Assistant',
-              heldBy: { kind: 'agent', agentId: 'missing-agent' }
-            }
-          ]
+          'role.platform-assistant': {
+            id: 'role.platform-assistant',
+            order: 10,
+            title: 'Platform Assistant',
+            heldBy: { kind: 'agent', agentId: 'missing-agent' }
+          }
         }
       })
     ).toThrow(/unknown agent holder resource/)
@@ -336,25 +390,23 @@ describe('resolveOrganizationModel - roles cross-ref (responsibleFor and heldBy)
   it('throws when an agent holder references a non-agent resource', () => {
     expect(() =>
       resolveOrganizationModel({
-        systems: { systems: [validSystem] },
+        systems: { 'sys.platform': validSystem },
         resources: {
-          entries: [
-            {
-              id: 'LGN-01-company-scrape',
-              kind: 'workflow',
-              systemId: 'sys.platform',
-              status: 'active'
-            }
-          ]
+          'LGN-01-company-scrape': {
+            id: 'LGN-01-company-scrape',
+            order: 10,
+            kind: 'workflow' as const,
+            systemPath: 'sys.platform',
+            status: 'active' as const
+          }
         },
         roles: {
-          roles: [
-            {
-              id: 'role.platform-assistant',
-              title: 'Platform Assistant',
-              heldBy: { kind: 'agent', agentId: 'LGN-01-company-scrape' }
-            }
-          ]
+          'role.platform-assistant': {
+            id: 'role.platform-assistant',
+            order: 10,
+            title: 'Platform Assistant',
+            heldBy: { kind: 'agent', agentId: 'LGN-01-company-scrape' }
+          }
         }
       })
     ).toThrow(/must reference an agent resource/)
@@ -363,40 +415,49 @@ describe('resolveOrganizationModel - roles cross-ref (responsibleFor and heldBy)
 
 describe('resolveOrganizationModel - roles domain integration', () => {
   it('merges partial roles override and preserves empty roles default', () => {
-    const model = resolveOrganizationModel({ roles: { roles: [] } })
-    expect(model.roles.roles).toEqual([])
+    const model = resolveOrganizationModel({ roles: {} })
+    expect(Object.keys(model.roles)).toHaveLength(0)
   })
 
   it('omitting roles key entirely resolves to default empty roles', () => {
     const model = resolveOrganizationModel({})
     expect(model.roles).toBeDefined()
-    expect(model.roles.roles).toEqual([])
+    expect(Object.keys(model.roles)).toHaveLength(0)
   })
 
   it('does not bleed roles changes into other top-level domains', () => {
     const model = resolveOrganizationModel({
       roles: {
-        roles: [{ id: 'role-ceo', title: 'CEO' }]
+        'role-ceo': { id: 'role-ceo', order: 10, title: 'CEO' }
       }
     })
 
     expect(model.identity).toBeDefined()
     expect(model.customers).toBeDefined()
     expect(model.offerings).toBeDefined()
-    expect(model.features).toBeDefined()
+    expect(model.systems).toBeDefined()
+    // Phase 4 (D8): model.navigation removed from top-level OM.
     expect(model.navigation).toBeDefined()
+    expect(model.knowledge).toBeDefined()
   })
 
   it('resolved model includes roles domain alongside other new domains', () => {
     const model = resolveOrganizationModel({
-      customers: { segments: [{ id: 'seg-a', name: 'Segment A' }] },
+      customers: {
+        'seg-a': { id: 'seg-a', order: 10, name: 'Segment A' }
+      },
       roles: {
-        roles: [{ id: 'role-ceo', title: 'CEO', heldBy: { kind: 'human', userId: 'user.alice' } }]
+        'role-ceo': {
+          id: 'role-ceo',
+          order: 10,
+          title: 'CEO',
+          heldBy: { kind: 'human', userId: 'user.alice' }
+        }
       }
     })
 
-    expect(model.customers.segments).toHaveLength(1)
-    expect(model.roles.roles).toHaveLength(1)
-    expect(model.roles.roles[0].heldBy).toEqual({ kind: 'human', userId: 'user.alice' })
+    expect(Object.keys(model.customers)).toHaveLength(1)
+    expect(Object.keys(model.roles)).toHaveLength(1)
+    expect(model.roles['role-ceo'].heldBy).toEqual({ kind: 'human', userId: 'user.alice' })
   })
 })