@elevasis/core 0.21.0 → 0.23.0

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

@@ -0,0 +1,209 @@
+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\\"/)
+  })
+})

package/src/organization-model/__tests__/flatten-additive-merge.test.ts

@@ -0,0 +1,361 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
+import { listDomain } from '../helpers'
+import { resolveOrganizationModel } from '../resolve'
+import type { DeepPartial, OrganizationModel } from '../types'
+
+// ---------------------------------------------------------------------------
+// Step 5 of om-flatten-single-array-domains: lock in additive-by-id merge
+// across all 9 flattened domains.
+//
+// Before the flatten, every domain was `{ field: Entry[] }` and deepMerge's
+// array branch (`Array.isArray(base) -> return override`) caused tenant
+// overrides to wholesale-replace the array. The systems domain needed a
+// special-case mergeSystemsById helper (sidebar-regression-fix.mdx OD1) to
+// produce additive behavior.
+//
+// After the flatten, every domain is `Record<string, Entry>` keyed by id, so
+// deepMerge's object branch (`isPlainObject(base) && isPlainObject(override)
+// -> deepMerge per key`) gives additive-by-id semantics for free.
+//
+// These tests pin that semantic in place. If anyone re-introduces array shape
+// on these domains, or special-cases merge logic, these tests will surface it.
+// ---------------------------------------------------------------------------
+
+describe('flatten: deepMerge produces additive-by-id behavior across all 9 flattened domains', () => {
+  // Phase 4 (D1): 'statuses' top-level field removed from OrganizationModel.
+  // Status data moved into system.content as (schema:status-flow) / (schema:status) nodes.
+  // The remaining 8 domains are all Record<string, Entry> after the flatten.
+  const FLATTENED_DOMAINS = [
+    'systems',
+    'roles',
+    'goals',
+    'customers',
+    'actions',
+    'offerings',
+    'resources',
+    'policies'
+  ] as const
+
+  it.each(FLATTENED_DOMAINS)('%s domain shape is Record<string, Entry>, not an array wrapper', (domain) => {
+    const value = DEFAULT_ORGANIZATION_MODEL[domain]
+    expect(Array.isArray(value)).toBe(false)
+    expect(typeof value).toBe('object')
+    expect(value).not.toBeNull()
+  })
+
+  it('adds a tenant system to the merged record without dropping defaults', () => {
+    const baseSize = Object.keys(DEFAULT_ORGANIZATION_MODEL.systems).length
+
+    const model = resolveOrganizationModel({
+      systems: {
+        'tenant.workspace': {
+          id: 'tenant.workspace',
+          order: 10000,
+          label: 'Tenant Workspace',
+          lifecycle: 'active',
+          path: '/tenant'
+        }
+      }
+    })
+
+    expect(Object.keys(model.systems)).toHaveLength(baseSize + 1)
+    expect(model.systems['tenant.workspace']?.label).toBe('Tenant Workspace')
+    // Default systems survive
+    expect(model.systems['dashboard']).toBeDefined()
+    expect(model.systems['operations']).toBeDefined()
+  })
+
+  it('merges a tenant role additively without clobbering default roles', () => {
+    const baseSize = Object.keys(DEFAULT_ORGANIZATION_MODEL.roles).length
+
+    const model = resolveOrganizationModel({
+      roles: {
+        'role.tenant-lead': {
+          id: 'role.tenant-lead',
+          order: 10000,
+          title: 'Tenant Lead'
+        }
+      }
+    })
+
+    expect(Object.keys(model.roles)).toHaveLength(baseSize + 1)
+    expect(model.roles['role.tenant-lead']?.title).toBe('Tenant Lead')
+  })
+
+  it('merges a tenant action additively while preserving the default 13 lead-gen actions', () => {
+    const baseSize = Object.keys(DEFAULT_ORGANIZATION_MODEL.actions).length
+    expect(baseSize).toBe(13)
+
+    const model = resolveOrganizationModel({
+      actions: {
+        'tenant.custom-action': {
+          id: 'tenant.custom-action',
+          order: 10000,
+          label: 'Custom Action',
+          scope: 'global',
+          resourceId: 'tenant-workflow'
+        }
+      }
+    })
+
+    expect(Object.keys(model.actions)).toHaveLength(baseSize + 1)
+    expect(model.actions['tenant.custom-action']?.label).toBe('Custom Action')
+    expect(model.actions['lead-gen.company.source']).toBeDefined()
+  })
+
+  it('overrides an existing system by id (last write wins on the same map key)', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: 10,
+          label: 'Tenant Dashboard',
+          lifecycle: 'active',
+          path: '/'
+        }
+      }
+    })
+
+    expect(model.systems['dashboard']?.label).toBe('Tenant Dashboard')
+    // Other defaults remain
+    expect(model.systems['operations']).toBeDefined()
+  })
+
+  it('merges nested fields within a single entry deeply (not replacing the whole entry)', () => {
+    // Overriding only `label` on a default system preserves its other fields.
+    const defaultDashboard = DEFAULT_ORGANIZATION_MODEL.systems['dashboard']
+    expect(defaultDashboard).toBeDefined()
+
+    const model = resolveOrganizationModel({
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: defaultDashboard!.order,
+          label: 'Renamed'
+        }
+      }
+    })
+
+    const merged = model.systems['dashboard']
+    expect(merged?.label).toBe('Renamed')
+    // Path from defaults survives because object merge is deep per-key.
+    expect(merged?.path).toBe(defaultDashboard!.path)
+  })
+
+  it('confirms no special-case mergeSystemsById helper exists in resolve.ts', async () => {
+    // The OD1 special case from sidebar-regression-fix.mdx is superseded by
+    // this flatten. If anyone reintroduces it under any of these names,
+    // surface that drift.
+    const source = await import('node:fs/promises').then((fs) =>
+      fs.readFile(new URL('../resolve.ts', import.meta.url), 'utf-8')
+    )
+
+    expect(source).not.toMatch(/mergeSystemsById/)
+    expect(source).not.toMatch(/mergeById/)
+    expect(source).not.toMatch(/mergeRecordById/)
+  })
+
+  it('multiple flattened domains receive independent additive merges in one call', () => {
+    const baseSystems = Object.keys(DEFAULT_ORGANIZATION_MODEL.systems).length
+    const baseRoles = Object.keys(DEFAULT_ORGANIZATION_MODEL.roles).length
+    const baseActions = Object.keys(DEFAULT_ORGANIZATION_MODEL.actions).length
+
+    const model = resolveOrganizationModel({
+      systems: {
+        'tenant.a': { id: 'tenant.a', order: 10000, label: 'A', lifecycle: 'active', path: '/a' }
+      },
+      roles: {
+        'role.a': { id: 'role.a', order: 10000, title: 'A' }
+      },
+      actions: {
+        'tenant.a': {
+          id: 'tenant.a',
+          order: 10000,
+          label: 'A Action',
+          scope: 'global',
+          resourceId: 'a-workflow'
+        }
+      }
+    })
+
+    expect(Object.keys(model.systems)).toHaveLength(baseSystems + 1)
+    expect(Object.keys(model.roles)).toHaveLength(baseRoles + 1)
+    expect(Object.keys(model.actions)).toHaveLength(baseActions + 1)
+  })
+
+  // ---------------------------------------------------------------------------
+  // Override merge edge cases
+  // ---------------------------------------------------------------------------
+
+  it('order override on existing entry takes precedence and re-sorts the listed domain', () => {
+    const override: DeepPartial<OrganizationModel> = {
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: 1000,
+          label: 'Dashboard',
+          lifecycle: 'active',
+          path: '/'
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+
+    expect(resolved.systems['dashboard']!.order).toBe(1000)
+
+    const listed = listDomain(resolved.systems)
+    const dashboardIndex = listed.findIndex((s) => s.id === 'dashboard')
+    const systemsBefore = listed.filter((s) => s.order < 1000)
+    expect(dashboardIndex).toBeGreaterThan(systemsBefore.length - 1)
+    // All entries with order < 1000 must appear before dashboard in the sorted list
+    systemsBefore.forEach((s) => {
+      expect(listed.indexOf(s)).toBeLessThan(dashboardIndex)
+    })
+  })
+
+  it('override entry omitting order preserves the base order value', () => {
+    const baseOrder = DEFAULT_ORGANIZATION_MODEL.systems['dashboard']!.order
+
+    const override: DeepPartial<OrganizationModel> = {
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          label: 'Renamed Dashboard'
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+
+    expect(resolved.systems['dashboard']!.order).toBe(baseOrder)
+    expect(resolved.systems['dashboard']!.label).toBe('Renamed Dashboard')
+  })
+
+  it('throws when system map key does not match the entry id', () => {
+    const badOverride: DeepPartial<OrganizationModel> = {
+      systems: {
+        'wrong-key': {
+          id: 'different-id',
+          order: 10,
+          label: 'Mismatch',
+          lifecycle: 'active',
+          path: '/mismatch'
+        }
+      }
+    }
+
+    expect(() => resolveOrganizationModel(badOverride)).toThrow(/map key/)
+  })
+
+  it('replaces nested arrays rather than merging them', () => {
+    // sales.lead-gen has a top-level `actions` array field on the entry.
+    // deepMerge hits Array.isArray(existing) => returns override value directly.
+    const singleRef = [{ actionId: 'lead-gen.company.source', intent: 'exposes' as const }]
+
+    const override: DeepPartial<OrganizationModel> = {
+      systems: {
+        'sales.lead-gen': {
+          id: 'sales.lead-gen',
+          order: DEFAULT_ORGANIZATION_MODEL.systems['sales.lead-gen']!.order,
+          label: 'Lead Gen',
+          actions: singleRef
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+    const entry = resolved.systems['sales.lead-gen']!
+
+    expect(entry.actions).toHaveLength(1)
+    expect(entry.actions).toEqual(singleRef)
+  })
+
+  it('empty systems override produces same systems domain as no override', () => {
+    const withEmpty = resolveOrganizationModel({ systems: {} })
+    const withNone = resolveOrganizationModel()
+
+    expect(withEmpty.systems).toEqual(withNone.systems)
+  })
+
+  it('field set to undefined in override is skipped and retains the base value', () => {
+    const basePath = DEFAULT_ORGANIZATION_MODEL.systems['dashboard']!.path
+
+    const override: DeepPartial<OrganizationModel> = {
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: DEFAULT_ORGANIZATION_MODEL.systems['dashboard']!.order,
+          label: 'Dashboard',
+          path: undefined
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+
+    expect(resolved.systems['dashboard']!.path).toBe(basePath)
+  })
+
+  it('simultaneous override of systems, roles, and actions merges each domain independently without cross-contamination', () => {
+    const baseSystems = Object.keys(DEFAULT_ORGANIZATION_MODEL.systems).length
+    const baseRoles = Object.keys(DEFAULT_ORGANIZATION_MODEL.roles).length
+    const baseActions = Object.keys(DEFAULT_ORGANIZATION_MODEL.actions).length
+    const baseCustomers = DEFAULT_ORGANIZATION_MODEL.customers
+    const baseGoals = DEFAULT_ORGANIZATION_MODEL.goals
+
+    const model = resolveOrganizationModel({
+      systems: {
+        'multi.sys': { id: 'multi.sys', order: 50000, label: 'Multi Sys', lifecycle: 'active', path: '/multi-sys' }
+      },
+      roles: {
+        'multi.role': { id: 'multi.role', order: 50000, title: 'Multi Role' }
+      },
+      actions: {
+        'multi.action': {
+          id: 'multi.action',
+          order: 50000,
+          label: 'Multi Action',
+          scope: 'global',
+          resourceId: 'multi-workflow'
+        }
+      }
+    })
+
+    expect(Object.keys(model.systems)).toHaveLength(baseSystems + 1)
+    expect(model.systems['multi.sys']).toBeDefined()
+
+    expect(Object.keys(model.roles)).toHaveLength(baseRoles + 1)
+    expect(model.roles['multi.role']).toBeDefined()
+
+    expect(Object.keys(model.actions)).toHaveLength(baseActions + 1)
+    expect(model.actions['multi.action']).toBeDefined()
+
+    expect(model.customers).toEqual(baseCustomers)
+    expect(model.goals).toEqual(baseGoals)
+  })
+
+  it('override sets top-level array field on entry to single-element array replacing the original', () => {
+    // The `invocations` field on an action entry is a top-level array.
+    // deepMerge sees Array.isArray(existing) and returns override directly.
+    const replacementInvocations = [{ kind: 'slash-command' as const, command: '/custom-source' }]
+
+    const override: DeepPartial<OrganizationModel> = {
+      actions: {
+        'lead-gen.company.source': {
+          id: 'lead-gen.company.source',
+          order: DEFAULT_ORGANIZATION_MODEL.actions['lead-gen.company.source']!.order,
+          label: 'Source companies',
+          invocations: replacementInvocations
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+    const entry = resolved.actions['lead-gen.company.source']!
+
+    expect(entry.invocations).toHaveLength(1)
+    expect(entry.invocations).toEqual(replacementInvocations)
+  })
+})