@elevasis/core 0.23.0 → 0.24.0

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

@@ -20,7 +20,16 @@ describe('OrganizationModelIconTokenSchema', () => {
   })
 
   it('rejects random strings outside the built-in and custom namespaces', () => {
-    for (const token of ['crm', 'lead-gen', 'settings', 'random.icon', 'custom.', 'custom.Bad']) {
+    for (const token of [
+      'nav.crm',
+      'feature.sales',
+      'surface.dashboard',
+      'action.approve',
+      'status.success',
+      'random.icon',
+      'custom.',
+      'custom.Bad'
+    ]) {
       expect(OrganizationModelIconTokenSchema.safeParse(token).success).toBe(false)
     }
   })

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

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import {
   OrgKnowledgeNodeSchema,
   OrgKnowledgeKindSchema,
@@ -11,10 +11,12 @@ 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 { compileOrganizationOntology } from '../ontology'
+import { byOntology, governedBy, parsePath } from '../../knowledge/queries'
 import type { OrganizationModel } from '../types'
 
 // ---------------------------------------------------------------------------
-// OrgKnowledgeNodeSchema — shape and validation
+// OrgKnowledgeNodeSchema — shape and validation
 // ---------------------------------------------------------------------------
 
 describe('OrgKnowledgeNodeSchema', () => {
@@ -89,10 +91,10 @@ describe('OrgKnowledgeNodeSchema', () => {
   it('accepts an optional semantic icon token', () => {
     const node = OrgKnowledgeNodeSchema.parse({
       ...makeNode('playbook'),
-      icon: 'knowledge.playbook'
+      icon: 'playbook'
     })
 
-    expect(node.icon).toBe('knowledge.playbook')
+    expect(node.icon).toBe('playbook')
   })
 
   it('rejects an unknown icon token', () => {
@@ -121,6 +123,15 @@ describe('OrgKnowledgeNodeSchema', () => {
 
     expect(result.success).toBe(false)
   })
+
+  it('accepts an optional generated sourceFilePath', () => {
+    const node = OrgKnowledgeNodeSchema.parse({
+      ...makeNode('reference'),
+      sourceFilePath: 'packages/elevasis-core/src/knowledge/nodes/platform/reference.mdx'
+    })
+
+    expect(node.sourceFilePath).toBe('packages/elevasis-core/src/knowledge/nodes/platform/reference.mdx')
+  })
 })
 
 describe('resolveOrganizationModel with knowledge owner roles', () => {
@@ -153,8 +164,117 @@ describe('resolveOrganizationModel with knowledge owner roles', () => {
   })
 })
 
+describe('resolveOrganizationModel with ontology knowledge targets', () => {
+  it('accepts knowledge links that directly target compiled ontology records', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sales.crm': {
+            id: 'sales.crm',
+            order: 10,
+            label: 'CRM',
+            enabled: true,
+            ontology: {
+              objectTypes: {
+                'sales.crm:object/deal': {
+                  id: 'sales.crm:object/deal',
+                  label: 'Deal'
+                }
+              }
+            }
+          }
+        },
+        knowledge: {
+          'knowledge.deal-policy': {
+            id: 'knowledge.deal-policy',
+            kind: 'reference',
+            title: 'Deal Policy',
+            summary: 'How deal records are governed.',
+            body: 'Deal policy.',
+            links: [{ target: { kind: 'ontology', id: 'sales.crm:object/deal' } }],
+            updatedAt: '2026-05-14'
+          }
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('rejects knowledge links to unknown ontology records', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        knowledge: {
+          'knowledge.missing-ontology': {
+            id: 'knowledge.missing-ontology',
+            kind: 'reference',
+            title: 'Missing Ontology',
+            summary: 'References a missing ontology record.',
+            body: 'Missing.',
+            links: [{ target: { kind: 'ontology', id: 'sales.crm:object/missing' } }],
+            updatedAt: '2026-05-14'
+          }
+        }
+      })
+    ).toThrow(/unknown ontology target/)
+  })
+
+  it('compiles authored ontology targets without requiring legacy provenance fields', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        'sales.crm': {
+          id: 'sales.crm',
+          order: 10,
+          label: 'CRM',
+          enabled: true,
+          ontology: {
+            objectTypes: {
+              'sales.crm:object/deal': {
+                id: 'sales.crm:object/deal',
+                label: 'Deal'
+              }
+            },
+            actionTypes: {
+              'sales.crm:action/update-deal': {
+                id: 'sales.crm:action/update-deal',
+                label: 'Update Deal',
+                actsOn: ['sales.crm:object/deal']
+              }
+            },
+            catalogTypes: {
+              'sales.crm:catalog/pipeline': {
+                id: 'sales.crm:catalog/pipeline',
+                label: 'Pipeline',
+                appliesTo: 'sales.crm:object/deal'
+              }
+            }
+          }
+        }
+      },
+      knowledge: {
+        'knowledge.pipeline-policy': {
+          id: 'knowledge.pipeline-policy',
+          kind: 'reference',
+          title: 'Pipeline Policy',
+          summary: 'How pipeline ontology is governed.',
+          body: 'Pipeline policy.',
+          links: [{ target: { kind: 'ontology', id: 'sales.crm:catalog/pipeline' } }],
+          updatedAt: '2026-05-14'
+        }
+      }
+    })
+    const compiled = compileOrganizationOntology(model)
+
+    expect(compiled.diagnostics).toEqual([])
+    expect(compiled.ontology.objectTypes['sales.crm:object/deal']).not.toHaveProperty('legacyEntityId')
+    expect(compiled.ontology.actionTypes['sales.crm:action/update-deal']).not.toHaveProperty('legacyActionId')
+    expect(compiled.ontology.catalogTypes['sales.crm:catalog/pipeline']).not.toHaveProperty('legacyContentId')
+    expect(model.knowledge['knowledge.pipeline-policy']?.links[0]?.nodeId).toBe(
+      'ontology:sales.crm:catalog/pipeline'
+    )
+  })
+})
+
 // ---------------------------------------------------------------------------
-// OrgKnowledgeKindSchema — enum shape
+// OrgKnowledgeKindSchema — enum shape
 // ---------------------------------------------------------------------------
 
 describe('OrgKnowledgeKindSchema', () => {
@@ -171,7 +291,7 @@ describe('OrgKnowledgeKindSchema', () => {
 })
 
 // ---------------------------------------------------------------------------
-// OrganizationGraphEdgeKindSchema — governs edge is present
+// OrganizationGraphEdgeKindSchema — governs edge is present
 // ---------------------------------------------------------------------------
 
 describe('OrganizationGraphEdgeKindSchema', () => {
@@ -181,7 +301,7 @@ describe('OrganizationGraphEdgeKindSchema', () => {
 })
 
 // ---------------------------------------------------------------------------
-// DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE — Phase 4: flat Record<id, OrgKnowledgeNode> (D3).
+// 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 {}.
 // ---------------------------------------------------------------------------
@@ -205,11 +325,11 @@ describe('DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE', () => {
 })
 
 // ---------------------------------------------------------------------------
-// buildOrganizationGraph — knowledge nodes + governs edges
+// buildOrganizationGraph — knowledge nodes + governs edges
 // 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.
+// Phase 4: knowledge is a flat Record<id, OrgKnowledgeNode> — no .nodes array wrapper.
 const SYNTHETIC_OM: OrganizationModel = {
   ...DEFAULT_ORGANIZATION_MODEL,
   systems: Object.fromEntries(
@@ -295,10 +415,97 @@ describe('buildOrganizationGraph with knowledge', () => {
     const defaultKnowledgeNodes = defaultGraph.nodes.filter((n) => n.kind === 'knowledge')
     expect(defaultKnowledgeNodes).toHaveLength(0)
   })
+
+  it('emits governs edges from knowledge directly to ontology graph nodes', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        'sales.crm': {
+          id: 'sales.crm',
+          order: 10,
+          label: 'CRM',
+          enabled: true,
+          ontology: {
+            objectTypes: {
+              'sales.crm:object/deal': {
+                id: 'sales.crm:object/deal',
+                label: 'Deal'
+              }
+            }
+          }
+        }
+      },
+      knowledge: {
+        'knowledge.deal-policy': {
+          id: 'knowledge.deal-policy',
+          kind: 'reference',
+          title: 'Deal Policy',
+          summary: 'How deal records are governed.',
+          body: 'Deal policy.',
+          links: [{ target: { kind: 'ontology', id: 'sales.crm:object/deal' } }],
+          ownerIds: [],
+          updatedAt: '2026-05-14'
+        }
+      }
+    })
+    const ontologyGraph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(
+      ontologyGraph.edges.find(
+        (edge) =>
+          edge.kind === 'governs' &&
+          edge.sourceId === 'knowledge:knowledge.deal-policy' &&
+          edge.targetId === 'ontology:sales.crm:object/deal'
+      )
+    ).toBeDefined()
+  })
+
+  it('knowledge query helpers traverse ontology graph node IDs', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        'sales.crm': {
+          id: 'sales.crm',
+          order: 10,
+          label: 'CRM',
+          enabled: true,
+          ontology: {
+            objectTypes: {
+              'sales.crm:object/deal': {
+                id: 'sales.crm:object/deal',
+                label: 'Deal'
+              }
+            }
+          }
+        }
+      },
+      knowledge: {
+        'knowledge.deal-policy': {
+          id: 'knowledge.deal-policy',
+          kind: 'reference',
+          title: 'Deal Policy',
+          summary: 'How deal records are governed.',
+          body: 'Deal policy.',
+          links: [{ target: { kind: 'ontology', id: 'sales.crm:object/deal' } }],
+          ownerIds: [],
+          updatedAt: '2026-05-14'
+        }
+      }
+    })
+    const ontologyGraph = buildOrganizationGraph({ organizationModel: model })
+    const nodes = Object.values(model.knowledge)
+
+    expect(byOntology(ontologyGraph, 'sales.crm:object/deal', nodes).map((node) => node.id)).toEqual([
+      'knowledge.deal-policy'
+    ])
+    expect(governedBy(ontologyGraph, 'ontology:sales.crm:object/deal')).toEqual(['knowledge:knowledge.deal-policy'])
+    expect(parsePath('/by-ontology/sales.crm:object/deal')).toEqual({
+      mount: 'by-ontology',
+      args: ['sales.crm:object/deal']
+    })
+  })
 })
 
 // ---------------------------------------------------------------------------
-// KnowledgeLinkSchema — nodeId format validation
+// KnowledgeLinkSchema — nodeId format validation
 // ---------------------------------------------------------------------------
 
 describe('KnowledgeLinkSchema', () => {
@@ -325,10 +532,19 @@ describe('KnowledgeLinkSchema', () => {
     expect(() => KnowledgeLinkSchema.parse({ nodeId: 'knowledge:knowledge.test-doc' })).not.toThrow()
   })
 
-  it('accepts content-node: prefixed node IDs (D4 — KnowledgeTargetKindSchema includes content-node)', () => {
+  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('accepts and normalizes ontology graph node IDs', () => {
+    const link = KnowledgeLinkSchema.parse({ nodeId: 'ontology:sales.crm:object/deal' })
+
+    expect(link).toEqual({
+      target: { kind: 'ontology', id: 'sales.crm:object/deal' },
+      nodeId: 'ontology:sales.crm:object/deal'
+    })
+  })
+
   it('rejects a bare dotted ID with no kind: prefix', () => {
     expect(KnowledgeLinkSchema.safeParse({ nodeId: 'sales.crm' }).success).toBe(false)
   })
@@ -365,6 +581,26 @@ describe('KnowledgeTargetRefSchema', () => {
     )
   })
 
+  it('keeps content-node targets as compatibility pass-through links', () => {
+    const link = KnowledgeLinkSchema.parse({
+      target: { kind: 'content-node', id: 'sales.crm:default-pipeline' }
+    })
+
+    expect(link).toEqual({
+      target: { kind: 'content-node', id: 'sales.crm:default-pipeline' },
+      nodeId: 'content-node:sales.crm:default-pipeline'
+    })
+  })
+
+  it('accepts ontology as a target kind when the id is a valid ontology id', () => {
+    expect(KnowledgeTargetKindSchema.safeParse('ontology').success).toBe(true)
+    expect(KnowledgeTargetRefSchema.safeParse({ kind: 'ontology', id: 'sales.crm:object/deal' }).success).toBe(true)
+  })
+
+  it('rejects ontology targets with malformed ontology ids', () => {
+    expect(KnowledgeTargetRefSchema.safeParse({ kind: 'ontology', id: 'sales.crm.deal' }).success).toBe(false)
+  })
+
   it('rejects unknown target kinds', () => {
     expect(KnowledgeTargetKindSchema.safeParse('integration').success).toBe(false)
     expect(KnowledgeTargetRefSchema.safeParse({ kind: 'integration', id: 'hubspot' }).success).toBe(false)
@@ -372,10 +608,10 @@ describe('KnowledgeTargetRefSchema', () => {
 })
 
 // ---------------------------------------------------------------------------
-// KnowledgeDomainSchema — flat Record shape (Phase 4 D3)
+// KnowledgeDomainSchema — flat Record shape (Phase 4 D3)
 // ---------------------------------------------------------------------------
 
-describe('KnowledgeDomainSchema — flat Record<id, OrgKnowledgeNode>', () => {
+describe('KnowledgeDomainSchema — flat Record<id, OrgKnowledgeNode>', () => {
   it('accepts an empty map', () => {
     expect(KnowledgeDomainSchema.safeParse({}).success).toBe(true)
   })
@@ -412,13 +648,13 @@ describe('KnowledgeDomainSchema — flat Record<id, OrgKnowledgeNode>', () => {
       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
+    // and the values are not valid OrgKnowledgeNodeSchema — so this should fail
     expect(result.success).toBe(false)
   })
 })
 
 // ---------------------------------------------------------------------------
-// OrgKnowledgeNodeSchema — field length constraints
+// OrgKnowledgeNodeSchema — field length constraints
 // ---------------------------------------------------------------------------
 
 describe('OrgKnowledgeNodeSchema length constraints', () => {