@elevasis/core 0.24.1 → 0.26.0

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

@@ -332,14 +332,28 @@ describe('DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE', () => {
 // 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
-    ])
-  ),
+  systems: {
+    sales: {
+      id: 'sales',
+      order: 10,
+      label: 'Sales',
+      lifecycle: 'active'
+    },
+    'sales.crm': {
+      id: 'sales.crm',
+      order: 20,
+      label: 'CRM',
+      lifecycle: 'active',
+      governedByKnowledge: ['knowledge.test-playbook-1']
+    },
+    'sales.lead-gen': {
+      id: 'sales.lead-gen',
+      order: 30,
+      label: 'Lead Gen',
+      lifecycle: 'active',
+      governedByKnowledge: ['knowledge.test-playbook-1']
+    }
+  },
   knowledge: {
     'knowledge.test-playbook-1': {
       id: 'knowledge.test-playbook-1',
@@ -532,8 +546,8 @@ 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 retired content-node prefixed node IDs', () => {
+    expect(KnowledgeLinkSchema.safeParse({ nodeId: 'content-node:sales.crm:default-pipeline' }).success).toBe(false)
   })
 
   it('accepts and normalizes ontology graph node IDs', () => {
@@ -574,21 +588,21 @@ describe('KnowledgeTargetRefSchema', () => {
     )
   })
 
-  it('accepts content-node as a target kind (D4)', () => {
-    expect(KnowledgeTargetKindSchema.safeParse('content-node').success).toBe(true)
+  it('rejects content-node as a retired target kind', () => {
+    expect(KnowledgeTargetKindSchema.safeParse('content-node').success).toBe(false)
     expect(KnowledgeTargetRefSchema.safeParse({ kind: 'content-node', id: 'sales.crm:default-pipeline' }).success).toBe(
-      true
+      false
     )
   })
 
-  it('keeps content-node targets as compatibility pass-through links', () => {
+  it('keeps ontology catalog targets as the supported replacement for content-node links', () => {
     const link = KnowledgeLinkSchema.parse({
-      target: { kind: 'content-node', id: 'sales.crm:default-pipeline' }
+      target: { kind: 'ontology', id: 'sales.crm:catalog/default-pipeline' }
     })
 
     expect(link).toEqual({
-      target: { kind: 'content-node', id: 'sales.crm:default-pipeline' },
-      nodeId: 'content-node:sales.crm:default-pipeline'
+      target: { kind: 'ontology', id: 'sales.crm:catalog/default-pipeline' },
+      nodeId: 'ontology:sales.crm:catalog/default-pipeline'
     })
   })
 

package/src/organization-model/__tests__/lookup-helpers.test.ts

@@ -1,438 +1,128 @@
-/**
- * lookup-helpers.test.ts
- *
- * Tests for the Wave 1B recursive system-tree helpers:
- *   getSystem, getSystemAncestors, listAllSystems, getContent, resolveSystemContent
- *
- * NOTE: getSystem / getSystemAncestors / getContent / resolveSystemContent walk
- * systems via the `subsystems` nesting field (per the Wave 1B docstrings). The
- * `model.systems` map holds TOP-LEVEL systems only; nested systems live in
- * `parent.subsystems.<childKey>`. Fixtures must author hierarchies via
- * `subsystems`, not via flat dot-notation keys in `model.systems`.
- */
-import { describe, expect, it } from 'vitest'
-import { resolveOrganizationModel } from '../resolve'
-import { getSystem, getSystemAncestors, listAllSystems, getContent, resolveSystemContent } from '../helpers'
-import type { OrganizationModel } from '../types'
-
-// ---------------------------------------------------------------------------
-// Minimal model factory — uses `subsystems` nesting so Wave 1B helpers work
-// ---------------------------------------------------------------------------
-
-/**
- * Build a minimal valid model with a 3-level nested system tree:
- *   root (top-level, no content)
- *   └── mid  (subsystem of root, has content)
- *       └── leaf (subsystem of mid, has content)
- */
-function makeNestedModel(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      root: {
-        id: 'root',
-        order: 10,
-        label: 'Root',
-        enabled: true,
-        path: '/root',
-        subsystems: {
-          mid: {
-            id: 'mid',
-            order: 20,
-            label: 'Mid',
-            enabled: true,
-            path: '/root/mid',
-            content: {
-              'mid-pipeline': {
-                kind: 'schema',
-                type: 'pipeline',
-                label: 'Mid Pipeline',
-                data: { entityId: 'crm.deal' }
-              }
-            },
-            subsystems: {
-              leaf: {
-                id: 'leaf',
-                order: 30,
-                label: 'Leaf',
-                enabled: true,
-                path: '/root/mid/leaf',
-                content: {
-                  'leaf-config': {
-                    kind: 'config',
-                    type: 'kv',
-                    label: 'Leaf Config',
-                    data: { entries: { timeout: 5000 } }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-}
-
-/**
- * Build a model where 'ancestor' has content and 'ancestor.child' (in subsystems)
- * overrides one localId while inheriting the other.
- */
-function makeInheritanceModel(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      ancestor: {
-        id: 'ancestor',
-        order: 10,
-        label: 'Ancestor',
-        enabled: true,
-        path: '/ancestor',
-        content: {
-          shared: {
-            kind: 'config',
-            type: 'kv',
-            label: 'Shared Config',
-            order: 10,
-            data: { entries: { globalFlag: true } }
-          },
-          'ancestor-only': {
-            kind: 'config',
-            type: 'kv',
-            label: 'Ancestor Only',
-            order: 20,
-            data: { entries: { ancestorProp: 'yes' } }
-          }
-        },
-        subsystems: {
-          child: {
-            id: 'child',
-            order: 20,
-            label: 'Child',
-            enabled: true,
-            path: '/ancestor/child',
-            content: {
-              // 'shared' localId shadows the ancestor's 'shared' — override
-              shared: {
-                kind: 'config',
-                type: 'kv',
-                label: 'Child Override Config',
-                order: 10,
-                data: { entries: { localFlag: false } }
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-}
-
-// ---------------------------------------------------------------------------
-// getSystem
-// ---------------------------------------------------------------------------
-
-describe('getSystem', () => {
-  it('returns a root-level system by single-segment path', () => {
-    const model = makeNestedModel()
-    const sys = getSystem(model, 'root')
-    expect(sys).toBeDefined()
-    expect(sys?.label).toBe('Root')
-  })
-
-  it('returns a 2-level nested system by dot-separated path', () => {
-    const model = makeNestedModel()
-    const sys = getSystem(model, 'root.mid')
-    expect(sys).toBeDefined()
-    expect(sys?.label).toBe('Mid')
-  })
-
-  it('returns a 3-level nested system by dot-separated path', () => {
-    const model = makeNestedModel()
-    const sys = getSystem(model, 'root.mid.leaf')
-    expect(sys).toBeDefined()
-    expect(sys?.label).toBe('Leaf')
-  })
-
-  it('returns undefined for an unknown top-level segment', () => {
-    const model = makeNestedModel()
-    expect(getSystem(model, 'nonexistent')).toBeUndefined()
-  })
-
-  it('returns undefined when a middle segment is missing', () => {
-    const model = makeNestedModel()
-    expect(getSystem(model, 'root.missing.leaf')).toBeUndefined()
-  })
-
-  it('returns undefined for a path that is too deep (past a leaf)', () => {
-    const model = makeNestedModel()
-    // 'leaf' has no subsystems, so 'root.mid.leaf.deeper' must return undefined
-    expect(getSystem(model, 'root.mid.leaf.deeper')).toBeUndefined()
-  })
-
-  it('returns the content map for a system that has content', () => {
-    const model = makeNestedModel()
-    const sys = getSystem(model, 'root.mid')
-    expect(sys?.content).toBeDefined()
-    expect(Object.keys(sys?.content ?? {})).toContain('mid-pipeline')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// getSystemAncestors
-// ---------------------------------------------------------------------------
-
-describe('getSystemAncestors', () => {
-  it('returns [root] for a single-segment path (root-first order)', () => {
-    const model = makeNestedModel()
-    const ancestors = getSystemAncestors(model, 'root')
-    expect(ancestors).toHaveLength(1)
-    expect(ancestors[0]?.label).toBe('Root')
-  })
-
-  it('returns [root, mid] for a 2-level path', () => {
-    const model = makeNestedModel()
-    const ancestors = getSystemAncestors(model, 'root.mid')
-    expect(ancestors).toHaveLength(2)
-    expect(ancestors[0]?.label).toBe('Root')
-    expect(ancestors[1]?.label).toBe('Mid')
-  })
-
-  it('returns [root, mid, leaf] for a 3-level path', () => {
-    const model = makeNestedModel()
-    const ancestors = getSystemAncestors(model, 'root.mid.leaf')
-    expect(ancestors).toHaveLength(3)
-    expect(ancestors[0]?.label).toBe('Root')
-    expect(ancestors[1]?.label).toBe('Mid')
-    expect(ancestors[2]?.label).toBe('Leaf')
-  })
-
-  it('returns empty array when the path does not resolve', () => {
-    const model = makeNestedModel()
-    expect(getSystemAncestors(model, 'does.not.exist')).toEqual([])
-  })
-
-  it('returns empty array when the first segment is unknown', () => {
-    const model = makeNestedModel()
-    expect(getSystemAncestors(model, 'unknown.mid')).toEqual([])
-  })
-})
-
-// ---------------------------------------------------------------------------
-// listAllSystems
-// ---------------------------------------------------------------------------
-
-describe('listAllSystems', () => {
-  it('enumerates root-level systems from the default model', () => {
-    const model = resolveOrganizationModel()
-    const all = listAllSystems(model)
-    const paths = all.map((e) => e.path)
-    // Default model has 'sales', 'dashboard', etc. as top-level systems
-    expect(paths.some((p) => p === 'sales')).toBe(true)
-    expect(paths.some((p) => p === 'dashboard')).toBe(true)
-  })
-
-  it('enumerates nested systems via subsystems when they exist', () => {
-    const model = makeNestedModel()
-    const all = listAllSystems(model)
-    const paths = all.map((e) => e.path)
-    expect(paths).toContain('root')
-    expect(paths).toContain('root.mid')
-    expect(paths).toContain('root.mid.leaf')
-  })
-
-  it('returns pre-order DFS order (parent before children)', () => {
-    const model = makeNestedModel()
-    const all = listAllSystems(model)
-    const rootIdx = all.findIndex((e) => e.path === 'root')
-    const midIdx = all.findIndex((e) => e.path === 'root.mid')
-    const leafIdx = all.findIndex((e) => e.path === 'root.mid.leaf')
-    expect(rootIdx).toBeGreaterThanOrEqual(0)
-    expect(midIdx).toBeGreaterThanOrEqual(0)
-    expect(leafIdx).toBeGreaterThanOrEqual(0)
-    expect(rootIdx).toBeLessThan(midIdx)
-    expect(midIdx).toBeLessThan(leafIdx)
-  })
-
-  it('each entry has a non-empty string path and an object system', () => {
-    const model = makeNestedModel()
-    const all = listAllSystems(model)
-    for (const entry of all) {
-      expect(typeof entry.path).toBe('string')
-      expect(entry.path.length).toBeGreaterThan(0)
-      expect(typeof entry.system).toBe('object')
-      expect(entry.system).not.toBeNull()
-    }
-  })
-
-  it('flat model (no subsystems) returns only top-level systems', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        lone: { id: 'lone', order: 10, label: 'Lone', enabled: true, path: '/lone' }
-      }
-    })
-    const all = listAllSystems(model)
-    const paths = all.map((e) => e.path)
-    expect(paths).toContain('lone')
-    // Should not contain any path with a dot from 'lone'
-    expect(paths.filter((p) => p.startsWith('lone.')).length).toBe(0)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// getContent
-// ---------------------------------------------------------------------------
-
-describe('getContent', () => {
-  it('resolves a content node by qualified id for a 2-level path', () => {
-    const model = makeNestedModel()
-    const node = getContent(model, 'root.mid:mid-pipeline')
-    expect(node).toBeDefined()
-    expect(node?.label).toBe('Mid Pipeline')
-    expect(node?.kind).toBe('schema')
-    expect(node?.type).toBe('pipeline')
-  })
-
-  it('resolves a leaf system content node by 3-level qualified id', () => {
-    const model = makeNestedModel()
-    const node = getContent(model, 'root.mid.leaf:leaf-config')
-    expect(node).toBeDefined()
-    expect(node?.label).toBe('Leaf Config')
-    expect(node?.kind).toBe('config')
-    expect(node?.type).toBe('kv')
-  })
-
-  it('returns undefined for an unknown local-id within a valid system', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, 'root.mid:does-not-exist')).toBeUndefined()
-  })
-
-  it('returns undefined for an unknown system path', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, 'ghost:some-node')).toBeUndefined()
-  })
-
-  it('returns undefined for a qualified id with no colon separator', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, 'root.mid')).toBeUndefined()
-  })
-
-  it('returns undefined when the system path segment is empty (colon at start)', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, ':local-id')).toBeUndefined()
-  })
-
-  it('returns undefined when the local-id is empty (colon at end)', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, 'root.mid:')).toBeUndefined()
-  })
-})
-
-// ---------------------------------------------------------------------------
-// resolveSystemContent — own, inherited, and override-by-localId
-// ---------------------------------------------------------------------------
-
-describe('resolveSystemContent', () => {
-  it('returns empty own and inherited for a system with no content and no ancestor content', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        bare: { id: 'bare', order: 10, label: 'Bare', enabled: true, path: '/bare' }
-      }
-    })
-    const result = resolveSystemContent(model, 'bare')
-    expect(result.own).toEqual({})
-    expect(result.inherited).toEqual([])
-  })
-
-  it('returns empty own and inherited for an unknown system path', () => {
-    const model = makeNestedModel()
-    const result = resolveSystemContent(model, 'nonexistent')
-    expect(result.own).toEqual({})
-    expect(result.inherited).toEqual([])
-  })
-
-  it('returns only own content for a system whose ancestor has no content', () => {
-    const model = makeNestedModel()
-    // 'root' has no content, so 'root.mid' inherits nothing
-    const result = resolveSystemContent(model, 'root.mid')
-    expect(Object.keys(result.own)).toContain('mid-pipeline')
-    expect(result.inherited).toHaveLength(0)
-  })
-
-  it('own section contains only the direct content of the queried system', () => {
-    const model = makeInheritanceModel()
-    // 'ancestor.child' path = 'ancestor.child' using subsystems nesting
-    const result = resolveSystemContent(model, 'ancestor.child')
-    expect(Object.keys(result.own)).toContain('shared')
-    expect(Object.keys(result.own)).not.toContain('ancestor-only')
-  })
-
-  it('inherited section contains ancestor content not shadowed by own', () => {
-    const model = makeInheritanceModel()
-    const result = resolveSystemContent(model, 'ancestor.child')
-    const inheritedIds = result.inherited.map((e) => e.localId)
-    expect(inheritedIds).toContain('ancestor-only')
-  })
-
-  it('override-by-localId: shadowed ancestor entry does NOT appear in inherited', () => {
-    const model = makeInheritanceModel()
-    const result = resolveSystemContent(model, 'ancestor.child')
-    // 'shared' is in both ancestor and child; child's own shadows it
-    const inheritedIds = result.inherited.map((e) => e.localId)
-    expect(inheritedIds).not.toContain('shared')
-  })
-
-  it('inherited entries carry fromPath pointing to the source ancestor system', () => {
-    const model = makeInheritanceModel()
-    const result = resolveSystemContent(model, 'ancestor.child')
-    const ancestorEntry = result.inherited.find((e) => e.localId === 'ancestor-only')
-    expect(ancestorEntry).toBeDefined()
-    expect(ancestorEntry?.fromPath).toBe('ancestor')
-  })
-
-  it('inherited entries appear in root-first display order (shallower before deeper)', () => {
-    // 3-level chain: gp → parent → child
-    // gp has 'gp-node', parent has 'p-node', child has own content
-    const model = resolveOrganizationModel({
-      systems: {
-        gp: {
-          id: 'gp',
-          order: 10,
-          label: 'Grandparent',
-          enabled: true,
-          path: '/gp',
-          content: {
-            'gp-node': { kind: 'config', type: 'kv', label: 'GP Node', data: { entries: { a: 1 } } }
-          },
-          subsystems: {
-            parent: {
-              id: 'parent',
-              order: 20,
-              label: 'Parent',
-              enabled: true,
-              path: '/gp/parent',
-              content: {
-                'p-node': { kind: 'config', type: 'kv', label: 'P Node', data: { entries: { b: 2 } } }
-              },
-              subsystems: {
-                child: {
-                  id: 'child',
-                  order: 30,
-                  label: 'Child',
-                  enabled: true,
-                  path: '/gp/parent/child'
-                }
-              }
-            }
-          }
-        }
-      }
-    })
-    const result = resolveSystemContent(model, 'gp.parent.child')
-    const fromPaths = result.inherited.map((e) => e.fromPath)
-    const gpIdx = fromPaths.indexOf('gp')
-    const pIdx = fromPaths.indexOf('gp.parent')
-    expect(gpIdx).toBeGreaterThanOrEqual(0)
-    expect(pIdx).toBeGreaterThanOrEqual(0)
-    // Shallow ancestor (gp) must appear before deeper ancestor (gp.parent)
-    expect(gpIdx).toBeLessThan(pIdx)
-  })
-})
+/**
+ * lookup-helpers.test.ts
+ *
+ * Tests for recursive system-tree helpers:
+ *   getSystem, getSystemAncestors, listAllSystems
+ *
+ * Fixtures author hierarchies through `subsystems` to verify the compatibility
+ * alias still resolves into the canonical recursive `systems` tree.
+ */
+import { describe, expect, it } from 'vitest'
+import { resolveOrganizationModel } from '../resolve'
+import { getSystem, getSystemAncestors, listAllSystems } from '../helpers'
+import type { OrganizationModel } from '../types'
+
+function makeNestedModel(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      root: {
+        id: 'root',
+        order: 10,
+        label: 'Root',
+        enabled: true,
+        path: '/root',
+        subsystems: {
+          mid: {
+            id: 'mid',
+            order: 20,
+            label: 'Mid',
+            enabled: true,
+            path: '/root/mid',
+            config: { timeoutMs: 5000 },
+            subsystems: {
+              leaf: {
+                id: 'leaf',
+                order: 30,
+                label: 'Leaf',
+                enabled: true,
+                path: '/root/mid/leaf'
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+describe('getSystem', () => {
+  it('returns a root-level system by single-segment path', () => {
+    const sys = getSystem(makeNestedModel(), 'root')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Root')
+  })
+
+  it('returns a 2-level nested system by dot-separated path', () => {
+    const sys = getSystem(makeNestedModel(), 'root.mid')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Mid')
+  })
+
+  it('returns a 3-level nested system by dot-separated path', () => {
+    const sys = getSystem(makeNestedModel(), 'root.mid.leaf')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Leaf')
+  })
+
+  it('returns undefined for unresolved paths', () => {
+    const model = makeNestedModel()
+    expect(getSystem(model, 'nonexistent')).toBeUndefined()
+    expect(getSystem(model, 'root.missing.leaf')).toBeUndefined()
+    expect(getSystem(model, 'root.mid.leaf.deeper')).toBeUndefined()
+  })
+
+  it('returns the first-class config for a system that has config', () => {
+    const sys = getSystem(makeNestedModel(), 'root.mid')
+    expect(sys?.config).toEqual({ timeoutMs: 5000 })
+  })
+})
+
+describe('getSystemAncestors', () => {
+  it('returns root-first ancestors for resolved paths', () => {
+    const model = makeNestedModel()
+
+    expect(getSystemAncestors(model, 'root').map((system) => system.label)).toEqual(['Root'])
+    expect(getSystemAncestors(model, 'root.mid').map((system) => system.label)).toEqual(['Root', 'Mid'])
+    expect(getSystemAncestors(model, 'root.mid.leaf').map((system) => system.label)).toEqual([
+      'Root',
+      'Mid',
+      'Leaf'
+    ])
+  })
+
+  it('returns empty arrays for unresolved paths', () => {
+    const model = makeNestedModel()
+    expect(getSystemAncestors(model, 'does.not.exist')).toEqual([])
+    expect(getSystemAncestors(model, 'unknown.mid')).toEqual([])
+  })
+})
+
+describe('listAllSystems', () => {
+  it('returns an empty list for the generic default model', () => {
+    expect(listAllSystems(resolveOrganizationModel())).toEqual([])
+  })
+
+  it('enumerates nested systems via subsystems in pre-order DFS order', () => {
+    const paths = listAllSystems(makeNestedModel()).map((entry) => entry.path)
+
+    expect(paths).toEqual(['root', 'root.mid', 'root.mid.leaf'])
+  })
+
+  it('each entry has a non-empty path and system object', () => {
+    for (const entry of listAllSystems(makeNestedModel())) {
+      expect(entry.path.length).toBeGreaterThan(0)
+      expect(typeof entry.system).toBe('object')
+      expect(entry.system).not.toBeNull()
+    }
+  })
+
+  it('flat model returns only top-level systems', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        lone: { id: 'lone', order: 10, label: 'Lone', enabled: true, path: '/lone' }
+      }
+    })
+
+    expect(listAllSystems(model).map((entry) => entry.path)).toEqual(['lone'])
+  })
+})