@elevasis/core 0.21.0 → 0.23.0

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

@@ -3,11 +3,14 @@ import {
   OrgKnowledgeNodeSchema,
   OrgKnowledgeKindSchema,
   KnowledgeDomainSchema,
-  KnowledgeLinkSchema
+  KnowledgeLinkSchema,
+  KnowledgeTargetKindSchema,
+  KnowledgeTargetRefSchema
 } from '../domains/knowledge'
 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 +77,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'),
@@ -91,6 +103,54 @@ describe('OrgKnowledgeNodeSchema', () => {
 
     expect(result.success).toBe(false)
   })
+
+  it('accepts an optional externalUrl', () => {
+    const node = OrgKnowledgeNodeSchema.parse({
+      ...makeNode('reference'),
+      externalUrl: 'https://docs.elevasis.com/technical/architecture'
+    })
+
+    expect(node.externalUrl).toBe('https://docs.elevasis.com/technical/architecture')
+  })
+
+  it('rejects an invalid externalUrl', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({
+      ...makeNode('reference'),
+      externalUrl: 'not-a-url'
+    })
+
+    expect(result.success).toBe(false)
+  })
+})
+
+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: { 'role.ops-lead': { id: 'role.ops-lead', order: 10, title: 'Ops Lead' } },
+        // Phase 4: knowledge is a flat Record<id, OrgKnowledgeNode>
+        knowledge: { 'knowledge.test-owner': node }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when ownerIds reference unknown role ids', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        knowledge: { 'knowledge.test-owner': node }
+      })
+    ).toThrow(/unknown owner role/)
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -121,60 +181,79 @@ describe('OrganizationGraphEdgeKindSchema', () => {
 })
 
 // ---------------------------------------------------------------------------
-// DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE — post Wave 2a: nodes is empty array
+// DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE — Phase 4: flat Record<id, OrgKnowledgeNode> (D3).
+// The wrapper shape { version, lastModified, nodes[] } was removed; versioning
+// is in domainMetadata.knowledge. The default is an empty map {}.
 // ---------------------------------------------------------------------------
 
 describe('DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE', () => {
-  it('has an empty nodes array after Wave 2a pilot literal removal', () => {
-    expect(DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE.nodes).toEqual([])
+  it('is an empty object (flat map with no pre-seeded nodes)', () => {
+    expect(DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE).toEqual({})
   })
 
   it('passes KnowledgeDomainSchema.parse without throwing', () => {
     expect(() => KnowledgeDomainSchema.parse(DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE)).not.toThrow()
   })
+
+  it('does not have a .nodes array (wrapper shape was removed in Phase 4)', () => {
+    expect(DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE).not.toHaveProperty('nodes')
+  })
+
+  it('does not have a .version field (moved to domainMetadata.knowledge)', () => {
+    expect(DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE).not.toHaveProperty('version')
+  })
 })
 
 // ---------------------------------------------------------------------------
 // buildOrganizationGraph — knowledge nodes + governs edges
-// Synthetic OM used so tests are independent of DEFAULT_ORGANIZATION_MODEL
-// knowledge nodes (empty after Wave 2a, Decision 2-B).
+// Synthetic OM authored via flat Record<id, OrgKnowledgeNode> per Phase 4 schema.
 // ---------------------------------------------------------------------------
 
+// Phase 4: knowledge is a flat Record<id, OrgKnowledgeNode> — no .nodes array wrapper.
 const SYNTHETIC_OM: OrganizationModel = {
   ...DEFAULT_ORGANIZATION_MODEL,
+  systems: Object.fromEntries(
+    Object.entries(DEFAULT_ORGANIZATION_MODEL.systems).map(([key, system]) => [
+      key,
+      key === 'sales.crm' || key === 'sales.lead-gen'
+        ? { ...system, governedByKnowledge: ['knowledge.test-playbook-1'] }
+        : system
+    ])
+  ),
   knowledge: {
-    nodes: [
-      {
-        id: 'knowledge.test-playbook-1',
-        kind: 'playbook',
-        title: 'Test Playbook',
-        summary: 'Test playbook summary.',
-        body: '## Overview\n\nContent.',
-        links: [{ nodeId: 'feature:sales.crm' }, { nodeId: 'feature:sales.lead-gen' }],
-        ownerIds: [],
-        updatedAt: '2026-01-01'
-      },
-      {
-        id: 'knowledge.test-strategy-1',
-        kind: 'strategy',
-        title: 'Test Strategy',
-        summary: 'Test strategy summary.',
-        body: '## Strategy\n\nContent.',
-        links: [{ nodeId: 'feature:sales.lead-gen' }],
-        ownerIds: [],
-        updatedAt: '2026-01-02'
-      },
-      {
-        id: 'knowledge.test-reference-1',
-        kind: 'reference',
-        title: 'Test Reference',
-        summary: 'Test reference summary.',
-        body: '## Reference\n\nContent.',
-        links: [],
-        ownerIds: [],
-        updatedAt: '2026-01-03'
-      }
-    ]
+    'knowledge.test-playbook-1': {
+      id: 'knowledge.test-playbook-1',
+      kind: 'playbook',
+      title: 'Test Playbook',
+      summary: 'Test playbook summary.',
+      body: '## Overview\n\nContent.',
+      links: [
+        { target: { kind: 'system', id: 'sales.crm' }, nodeId: 'system:sales.crm' },
+        { target: { kind: 'system', id: 'sales.lead-gen' }, nodeId: 'system:sales.lead-gen' }
+      ],
+      ownerIds: [],
+      updatedAt: '2026-01-01'
+    },
+    'knowledge.test-strategy-1': {
+      id: 'knowledge.test-strategy-1',
+      kind: 'strategy',
+      title: 'Test Strategy',
+      summary: 'Test strategy summary.',
+      body: '## Strategy\n\nContent.',
+      links: [],
+      ownerIds: [],
+      updatedAt: '2026-01-02'
+    },
+    'knowledge.test-reference-1': {
+      id: 'knowledge.test-reference-1',
+      kind: 'reference',
+      title: 'Test Reference',
+      summary: 'Test reference summary.',
+      body: '## Reference\n\nContent.',
+      links: [],
+      ownerIds: [],
+      updatedAt: '2026-01-03'
+    }
   }
 }
 
@@ -183,11 +262,11 @@ describe('buildOrganizationGraph with knowledge', () => {
 
   it('emits a knowledge node for each synthetic node', () => {
     const knowledgeNodes = graph.nodes.filter((n) => n.kind === 'knowledge')
-    expect(knowledgeNodes.length).toBe(SYNTHETIC_OM.knowledge.nodes.length)
+    expect(knowledgeNodes.length).toBe(Object.keys(SYNTHETIC_OM.knowledge).length)
   })
 
   it('knowledge nodes carry sourceId matching the OM node id', () => {
-    for (const omNode of SYNTHETIC_OM.knowledge.nodes) {
+    for (const omNode of Object.values(SYNTHETIC_OM.knowledge)) {
       const graphNode = graph.nodes.find((n) => n.sourceId === omNode.id)
       expect(graphNode).toBeDefined()
       expect(graphNode?.kind).toBe('knowledge')
@@ -197,12 +276,12 @@ describe('buildOrganizationGraph with knowledge', () => {
 
   it('emits governs edges for nodes that have links', () => {
     const governsEdges = graph.edges.filter((e) => e.kind === 'governs')
-    const totalLinks = SYNTHETIC_OM.knowledge.nodes.reduce((sum, n) => sum + n.links.length, 0)
+    const totalLinks = Object.values(SYNTHETIC_OM.knowledge).reduce((sum, n) => sum + n.links.length, 0)
     expect(governsEdges.length).toBe(totalLinks)
   })
 
   it('links targetId resolves to an existing graph node id for at least one node', () => {
-    const nodeWithLinks = SYNTHETIC_OM.knowledge.nodes.find((n) => n.links.length > 0)
+    const nodeWithLinks = Object.values(SYNTHETIC_OM.knowledge).find((n) => n.links.length > 0)
     expect(nodeWithLinks).toBeDefined()
 
     const graphNodeIds = new Set(graph.nodes.map((n) => n.id))
@@ -223,9 +302,22 @@ describe('buildOrganizationGraph with knowledge', () => {
 // ---------------------------------------------------------------------------
 
 describe('KnowledgeLinkSchema', () => {
-  it('accepts a valid kind:dotted-path nodeId', () => {
-    expect(() => KnowledgeLinkSchema.parse({ nodeId: 'feature:sales.crm' })).not.toThrow()
-    expect(() => KnowledgeLinkSchema.parse({ nodeId: 'feature:sales.lead-gen' })).not.toThrow()
+  it('accepts and normalizes a canonical typed target', () => {
+    const link = KnowledgeLinkSchema.parse({ target: { kind: 'system', id: 'sales.crm' } })
+
+    expect(link).toEqual({
+      target: { kind: 'system', id: 'sales.crm' },
+      nodeId: 'system:sales.crm'
+    })
+  })
+
+  it('accepts and normalizes a legacy kind:dotted-path nodeId', () => {
+    const link = KnowledgeLinkSchema.parse({ nodeId: 'system:sales.lead-gen' })
+
+    expect(link).toEqual({
+      target: { kind: 'system', id: 'sales.lead-gen' },
+      nodeId: 'system:sales.lead-gen'
+    })
   })
 
   it('accepts resource: and knowledge: prefixed node IDs', () => {
@@ -233,8 +325,11 @@ describe('KnowledgeLinkSchema', () => {
     expect(() => KnowledgeLinkSchema.parse({ nodeId: 'knowledge:knowledge.test-doc' })).not.toThrow()
   })
 
+  it('accepts content-node: prefixed node IDs (D4 — KnowledgeTargetKindSchema includes content-node)', () => {
+    expect(() => KnowledgeLinkSchema.parse({ nodeId: 'content-node:sales.crm:default-pipeline' })).not.toThrow()
+  })
+
   it('rejects a bare dotted ID with no kind: prefix', () => {
-    // NodeIdStringSchema requires kind:dotted-path format
     expect(KnowledgeLinkSchema.safeParse({ nodeId: 'sales.crm' }).success).toBe(false)
   })
 
@@ -243,8 +338,7 @@ describe('KnowledgeLinkSchema', () => {
   })
 
   it('rejects a nodeId with uppercase characters', () => {
-    // NodeIdStringSchema regex requires lowercase
-    expect(KnowledgeLinkSchema.safeParse({ nodeId: 'Feature:Sales.CRM' }).success).toBe(false)
+    expect(KnowledgeLinkSchema.safeParse({ nodeId: 'system:Sales.CRM' }).success).toBe(false)
   })
 
   it('rejects a link missing the nodeId field', () => {
@@ -256,6 +350,73 @@ describe('KnowledgeLinkSchema', () => {
   })
 })
 
+describe('KnowledgeTargetRefSchema', () => {
+  it('accepts modeled target kinds', () => {
+    expect(KnowledgeTargetRefSchema.safeParse({ kind: 'system', id: 'sales.crm' }).success).toBe(true)
+    expect(KnowledgeTargetRefSchema.safeParse({ kind: 'customer-segment', id: 'customer.enterprise' }).success).toBe(
+      true
+    )
+  })
+
+  it('accepts content-node as a target kind (D4)', () => {
+    expect(KnowledgeTargetKindSchema.safeParse('content-node').success).toBe(true)
+    expect(KnowledgeTargetRefSchema.safeParse({ kind: 'content-node', id: 'sales.crm:default-pipeline' }).success).toBe(
+      true
+    )
+  })
+
+  it('rejects unknown target kinds', () => {
+    expect(KnowledgeTargetKindSchema.safeParse('integration').success).toBe(false)
+    expect(KnowledgeTargetRefSchema.safeParse({ kind: 'integration', id: 'hubspot' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// KnowledgeDomainSchema — flat Record shape (Phase 4 D3)
+// ---------------------------------------------------------------------------
+
+describe('KnowledgeDomainSchema — flat Record<id, OrgKnowledgeNode>', () => {
+  it('accepts an empty map', () => {
+    expect(KnowledgeDomainSchema.safeParse({}).success).toBe(true)
+  })
+
+  it('defaults to empty map when undefined', () => {
+    const result = KnowledgeDomainSchema.safeParse(undefined)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual({})
+    }
+  })
+
+  it('accepts a Record keyed by knowledge node ids', () => {
+    const result = KnowledgeDomainSchema.safeParse({
+      'knowledge.my-playbook': {
+        id: 'knowledge.my-playbook',
+        kind: 'playbook',
+        title: 'My Playbook',
+        summary: 'A test playbook.',
+        body: '## Content',
+        links: [],
+        ownerIds: [],
+        updatedAt: '2026-05-01'
+      }
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects the old wrapper shape { version, lastModified, nodes[] }', () => {
+    // The old wrapper-with-array shape does not parse as a Record<id, OrgKnowledgeNode>
+    const result = KnowledgeDomainSchema.safeParse({
+      version: 1,
+      lastModified: '2026-05-10',
+      nodes: []
+    })
+    // Each key ('version', 'lastModified', 'nodes') would be parsed as a knowledge node id,
+    // and the values are not valid OrgKnowledgeNodeSchema — so this should fail
+    expect(result.success).toBe(false)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // OrgKnowledgeNodeSchema — field length constraints
 // ---------------------------------------------------------------------------
@@ -308,7 +469,6 @@ describe('OrgKnowledgeNodeSchema length constraints', () => {
   })
 
   it('rejects id with uppercase characters', () => {
-    // ModelIdSchema requires lowercase kebab/dot/underscore separated IDs
     const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, id: 'Knowledge.Test' })
     expect(result.success).toBe(false)
   })