@elevasis/core 0.20.0 → 0.22.0

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

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

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

@@ -8,6 +8,7 @@ import {
 import { OrganizationGraphEdgeKindSchema } from '../graph/schema'
 import { buildOrganizationGraph } from '../graph/build'
 import { DEFAULT_ORGANIZATION_MODEL, DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE } from '../defaults'
+import { resolveOrganizationModel } from '../resolve'
 import type { OrganizationModel } from '../types'
 
 // ---------------------------------------------------------------------------
@@ -74,6 +75,15 @@ describe('OrgKnowledgeNodeSchema', () => {
     expect(node.ownerIds).toEqual([])
   })
 
+  it('accepts role ids as knowledge owners', () => {
+    const node = OrgKnowledgeNodeSchema.parse({
+      ...makeNode('strategy'),
+      ownerIds: ['role.ops-lead', 'role.ceo']
+    })
+
+    expect(node.ownerIds).toEqual(['role.ops-lead', 'role.ceo'])
+  })
+
   it('accepts an optional semantic icon token', () => {
     const node = OrgKnowledgeNodeSchema.parse({
       ...makeNode('playbook'),
@@ -93,6 +103,35 @@ describe('OrgKnowledgeNodeSchema', () => {
   })
 })
 
+describe('resolveOrganizationModel with knowledge owner roles', () => {
+  const node = {
+    id: 'knowledge.test-owner',
+    kind: 'playbook' as const,
+    title: 'Owned Knowledge',
+    summary: 'A knowledge node with role ownership.',
+    body: '## Body\n\nContent.',
+    ownerIds: ['role.ops-lead'],
+    updatedAt: '2026-05-08'
+  }
+
+  it('passes when ownerIds reference declared role ids', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: { roles: [{ id: 'role.ops-lead', title: 'Ops Lead' }] },
+        knowledge: { nodes: [node] }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when ownerIds reference unknown role ids', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        knowledge: { nodes: [node] }
+      })
+    ).toThrow(/unknown owner role/)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // OrgKnowledgeKindSchema — enum shape
 // ---------------------------------------------------------------------------

package/src/organization-model/__tests__/prospecting-ssot.test.ts

@@ -5,6 +5,7 @@ import { CAPABILITY_REGISTRY, DEFAULT_ORGANIZATION_MODEL_PROSPECTING, PROSPECTIN
 const EXPECTED_CAPABILITY_RESOURCE_BY_ID: Record<string, string> = {
   'lead-gen.company.source': 'lgn-import-workflow',
   'lead-gen.company.apollo-import': 'lgn-01c-apollo-import-workflow',
+  'lead-gen.company.apify-crawl': 'lgn-02a-apify-website-crawl-workflow',
   'lead-gen.contact.discover': 'lgn-04-email-discovery-workflow',
   'lead-gen.contact.verify-email': 'lgn-05-email-verification-workflow',
   'lead-gen.company.website-extract': 'lgn-02-website-extract-workflow',
@@ -24,7 +25,9 @@ describe('prospecting organization-model SSOT', () => {
       label: 'Decision-makers found',
       description: 'Decision-maker contacts discovered and attached to a qualified company.',
       order: 6,
-      entity: 'company'
+      entity: 'company',
+      recordEntity: 'contact',
+      recordStageKey: 'discovered'
     })
   })
 
@@ -63,12 +66,12 @@ describe('prospecting organization-model SSOT', () => {
 
   it('derives prospecting lifecycle stages from the stage catalog by entity', () => {
     const expectedCompanyStages = Object.values(LEAD_GEN_STAGE_CATALOG)
-      .filter((stage) => stage.entity === 'company')
+      .filter((stage) => stage.entity === 'company' || stage.additionalEntities?.includes('company'))
       .sort((a, b) => a.order - b.order)
       .map(({ key, label, order }) => ({ id: key, label, order }))
 
     const expectedContactStages = Object.values(LEAD_GEN_STAGE_CATALOG)
-      .filter((stage) => stage.entity === 'contact')
+      .filter((stage) => stage.entity === 'contact' || stage.additionalEntities?.includes('contact'))
       .sort((a, b) => a.order - b.order)
       .map(({ key, label, order }) => ({ id: key, label, order }))
 
@@ -84,7 +87,7 @@ describe('prospecting organization-model SSOT', () => {
   })
 
   it('covers all known lead-gen capability registry entries', () => {
-    expect(CAPABILITY_REGISTRY).toHaveLength(12)
+    expect(CAPABILITY_REGISTRY).toHaveLength(13)
     const actualResourceById = Object.fromEntries(CAPABILITY_REGISTRY.map((c) => [c.id, c.resourceId]))
     expect(actualResourceById).toEqual(EXPECTED_CAPABILITY_RESOURCE_BY_ID)
   })

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

@@ -7,7 +7,7 @@ describe('organization-model resolve', () => {
 
     expect(model.version).toBe(1)
     expect(model.features.find((feature) => feature.id === 'dashboard')?.path).toBe('/')
-    expect(model.features.find((feature) => feature.id === 'sales')?.path).toBeUndefined()
+    expect(model.features.find((feature) => feature.id === 'sales')?.path).toBe('/sales')
     expect(model.features.find((feature) => feature.id === 'sales.crm')?.path).toBe('/crm')
     expect(model.features.find((feature) => feature.id === 'admin')?.requiresAdmin).toBe(true)
     expect(model.features.find((feature) => feature.id === 'archive')?.devOnly).toBe(true)

package/src/organization-model/defaults.ts

@@ -20,6 +20,8 @@ import { DEFAULT_ORGANIZATION_MODEL_PROSPECTING } from './domains/prospecting'
 import { DEFAULT_ORGANIZATION_MODEL_OPERATIONS } from './domains/operations'
 import { DEFAULT_ORGANIZATION_MODEL_ROLES } from './domains/roles'
 import { DEFAULT_ORGANIZATION_MODEL_GOALS } from './domains/goals'
+import { DEFAULT_ORGANIZATION_MODEL_SYSTEMS } from './domains/systems'
+import { DEFAULT_ORGANIZATION_MODEL_RESOURCES } from './domains/resources'
 import { DEFAULT_ORGANIZATION_MODEL_STATUSES } from './domains/statuses'
 import type { KnowledgeDomain } from './domains/knowledge'
 
@@ -61,6 +63,15 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       color: 'green',
       icon: 'feature.finance'
     },
+    {
+      id: 'business',
+      label: 'Business',
+      description: 'Revenue, client relationships, and project delivery',
+      enabled: true,
+      color: 'blue',
+      icon: 'feature.business',
+      uiPosition: 'sidebar-primary'
+    },
     {
       id: 'sales',
       label: 'Sales',
@@ -68,7 +79,7 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       enabled: true,
       color: 'blue',
       icon: 'feature.sales',
-      uiPosition: 'sidebar-primary'
+      path: '/sales'
     },
     {
       id: 'sales.crm',
@@ -95,8 +106,16 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       enabled: true,
       color: 'orange',
       icon: 'feature.projects',
-      path: '/projects',
-      uiPosition: 'sidebar-primary'
+      path: '/projects'
+    },
+    {
+      id: 'clients',
+      label: 'Clients',
+      description: 'Client relationships, accounts, and business context',
+      enabled: true,
+      color: 'orange',
+      icon: 'feature.projects',
+      path: '/business/clients'
     },
     {
       id: 'operations',
@@ -341,6 +360,8 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
   offerings: DEFAULT_ORGANIZATION_MODEL_OFFERINGS,
   roles: DEFAULT_ORGANIZATION_MODEL_ROLES,
   goals: DEFAULT_ORGANIZATION_MODEL_GOALS,
+  systems: DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
+  resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
   statuses: DEFAULT_ORGANIZATION_MODEL_STATUSES,
   operations: DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
   knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE

package/src/organization-model/domains/knowledge.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod'
 import { IconNameSchema, ModelIdSchema } from './shared'
 import { NodeIdStringSchema } from './features'
+import { RoleIdSchema } from './roles'
 
 // ---------------------------------------------------------------------------
 // KnowledgeLink — a typed graph link pointing to another OM node.
@@ -40,8 +41,8 @@ export const OrgKnowledgeNodeSchema = z.object({
   skills: z.array(KnowledgeSkillBindingSchema).optional(),
   /** Domain key used to derive fast graph->skill registries. */
   domain: KnowledgeDomainBindingSchema.optional(),
-  /** Identifiers of the roles or members who own this knowledge node. */
-  ownerIds: z.array(ModelIdSchema).default([]),
+  /** Role identifiers that own this knowledge node. */
+  ownerIds: z.array(RoleIdSchema).default([]),
   /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
   updatedAt: z.string().trim().min(1).max(50)
 })