@elevasis/core 0.22.0 → 0.23.0

package/src/knowledge/__tests__/queries.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it } from 'vitest'
-import { byFeature, byKind, byOwner, governs, governedBy, parsePath } from '../queries'
+import { describe, expect, it } from 'vitest'
+import { bySystem, byKind, byOwner, governs, governedBy, parsePath } from '../queries'
 import { formatText, formatJson, formatIdsOnly } from '../format'
 import type { OrganizationGraph } from '../../organization-model/graph/types'
 import type { OrgKnowledgeNode } from '../../organization-model/domains/knowledge'
@@ -10,8 +10,8 @@ import type { OrgKnowledgeNode } from '../../organization-model/domains/knowledg
 
 /**
  * Three knowledge nodes covering all three kinds.
- * - playbook-a governs feature:sales.crm and feature:sales.lead-gen
- * - strategy-b governs feature:sales.lead-gen
+ * - playbook-a governs system:sales.crm and system:sales.lead-gen
+ * - strategy-b governs system:sales.lead-gen
  * - reference-c has no links (no governs edges)
  * - playbook-d is owned by "role.ops-lead"
  */
@@ -22,7 +22,7 @@ const NODES: OrgKnowledgeNode[] = [
     title: 'Playbook A',
     summary: 'Playbook A summary.',
     body: '## Playbook A\n\nContent.',
-    links: [{ nodeId: 'feature:sales.crm' }, { nodeId: 'feature:sales.lead-gen' }],
+    links: [{ nodeId: 'system:sales.crm' }, { nodeId: 'system:sales.lead-gen' }],
     ownerIds: [],
     updatedAt: '2026-01-01'
   },
@@ -32,7 +32,7 @@ const NODES: OrgKnowledgeNode[] = [
     title: 'Strategy B',
     summary: 'Strategy B summary.',
     body: '## Strategy B\n\nContent.',
-    links: [{ nodeId: 'feature:sales.lead-gen' }],
+    links: [{ nodeId: 'system:sales.lead-gen' }],
     ownerIds: ['role.ops-lead'],
     updatedAt: '2026-01-02'
   },
@@ -67,13 +67,13 @@ const GRAPH: OrganizationGraph = {
   organizationModelVersion: 1,
   nodes: [
     { id: 'organization-model', kind: 'organization', label: 'Organization Model' },
-    { id: 'feature:sales.crm', kind: 'feature', label: 'CRM', sourceId: 'sales.crm', featureId: 'sales.crm' },
+    { id: 'system:sales.crm', kind: 'system', label: 'CRM', sourceId: 'sales.crm', systemId: 'sales.crm' },
     {
-      id: 'feature:sales.lead-gen',
-      kind: 'feature',
+      id: 'system:sales.lead-gen',
+      kind: 'system',
       label: 'Lead Gen',
       sourceId: 'sales.lead-gen',
-      featureId: 'sales.lead-gen'
+      systemId: 'sales.lead-gen'
     },
     {
       id: 'knowledge:knowledge.playbook-a',
@@ -128,50 +128,50 @@ const GRAPH: OrganizationGraph = {
     },
     // governs edges
     {
-      id: 'edge:governs:knowledge:knowledge.playbook-a:feature:sales.crm',
+      id: 'edge:governs:knowledge:knowledge.playbook-a:system:sales.crm',
       kind: 'governs',
       sourceId: 'knowledge:knowledge.playbook-a',
-      targetId: 'feature:sales.crm'
+      targetId: 'system:sales.crm'
     },
     {
-      id: 'edge:governs:knowledge:knowledge.playbook-a:feature:sales.lead-gen',
+      id: 'edge:governs:knowledge:knowledge.playbook-a:system:sales.lead-gen',
       kind: 'governs',
       sourceId: 'knowledge:knowledge.playbook-a',
-      targetId: 'feature:sales.lead-gen'
+      targetId: 'system:sales.lead-gen'
     },
     {
-      id: 'edge:governs:knowledge:knowledge.strategy-b:feature:sales.lead-gen',
+      id: 'edge:governs:knowledge:knowledge.strategy-b:system:sales.lead-gen',
       kind: 'governs',
       sourceId: 'knowledge:knowledge.strategy-b',
-      targetId: 'feature:sales.lead-gen'
+      targetId: 'system:sales.lead-gen'
     }
   ]
 }
 
 // ---------------------------------------------------------------------------
-// byFeature
+// bySystem
 // ---------------------------------------------------------------------------
 
-describe('byFeature', () => {
-  it('returns nodes that have governs edges to the given feature', () => {
-    const result = byFeature(GRAPH, 'sales.crm', NODES)
+describe('bySystem', () => {
+  it('returns nodes that have governs edges to the given system', () => {
+    const result = bySystem(GRAPH, 'sales.crm', NODES)
     expect(result).toHaveLength(1)
     expect(result[0].id).toBe('knowledge.playbook-a')
   })
 
-  it('returns multiple nodes when multiple knowledge nodes govern the same feature', () => {
-    const result = byFeature(GRAPH, 'sales.lead-gen', NODES)
+  it('returns multiple nodes when multiple knowledge nodes govern the same system', () => {
+    const result = bySystem(GRAPH, 'sales.lead-gen', NODES)
     const ids = result.map((n) => n.id).sort()
     expect(ids).toEqual(['knowledge.playbook-a', 'knowledge.strategy-b'].sort())
   })
 
-  it('returns empty array when no node governs the feature', () => {
-    const result = byFeature(GRAPH, 'feature.does-not-exist', NODES)
+  it('returns empty array when no node governs the system', () => {
+    const result = bySystem(GRAPH, 'system.does-not-exist', NODES)
     expect(result).toHaveLength(0)
   })
 
   it('returns full OrgKnowledgeNode objects (not just graph stubs)', () => {
-    const result = byFeature(GRAPH, 'sales.crm', NODES)
+    const result = bySystem(GRAPH, 'sales.crm', NODES)
     expect(result[0].body).toBeDefined()
     expect(result[0].links).toBeDefined()
     expect(result[0].ownerIds).toBeDefined()
@@ -237,17 +237,17 @@ describe('byOwner', () => {
 describe('governs', () => {
   it('returns target graph node IDs for outgoing governs edges (OM node id input)', () => {
     const result = governs(GRAPH, 'knowledge.playbook-a')
-    expect(result.sort()).toEqual(['feature:sales.crm', 'feature:sales.lead-gen'].sort())
+    expect(result.sort()).toEqual(['system:sales.crm', 'system:sales.lead-gen'].sort())
   })
 
   it('accepts graph node ID format input', () => {
     const result = governs(GRAPH, 'knowledge:knowledge.playbook-a')
-    expect(result.sort()).toEqual(['feature:sales.crm', 'feature:sales.lead-gen'].sort())
+    expect(result.sort()).toEqual(['system:sales.crm', 'system:sales.lead-gen'].sort())
   })
 
   it('returns single target for a node with one link', () => {
     const result = governs(GRAPH, 'knowledge.strategy-b')
-    expect(result).toEqual(['feature:sales.lead-gen'])
+    expect(result).toEqual(['system:sales.lead-gen'])
   })
 
   it('returns empty array for a node with no governs edges', () => {
@@ -266,69 +266,69 @@ describe('governs', () => {
 // ---------------------------------------------------------------------------
 
 describe('governedBy', () => {
-  it('returns knowledge graph node IDs for incoming governs edges (prefixed feature id)', () => {
-    const result = governedBy(GRAPH, 'feature:sales.lead-gen')
+  it('returns knowledge graph node IDs for incoming governs edges (prefixed system id)', () => {
+    const result = governedBy(GRAPH, 'system:sales.lead-gen')
     const sorted = result.sort()
     expect(sorted).toEqual(['knowledge:knowledge.playbook-a', 'knowledge:knowledge.strategy-b'].sort())
   })
 
-  it('accepts bare feature id (auto-prefixes with feature:)', () => {
+  it('accepts bare system id (auto-prefixes with system:)', () => {
     const result = governedBy(GRAPH, 'sales.crm')
     expect(result).toEqual(['knowledge:knowledge.playbook-a'])
   })
 
   it('returns empty array when no knowledge node governs the target', () => {
-    const result = governedBy(GRAPH, 'feature:dashboard')
+    const result = governedBy(GRAPH, 'system:dashboard')
     expect(result).toHaveLength(0)
   })
 
   it('returns empty array for unknown target node id', () => {
-    const result = governedBy(GRAPH, 'feature:does-not-exist')
+    const result = governedBy(GRAPH, 'system:does-not-exist')
     expect(result).toHaveLength(0)
   })
 })
 
 // ---------------------------------------------------------------------------
-// parsePath — happy paths (all five mount axes)
+// parsePath — happy paths (all five mount axes)
 // ---------------------------------------------------------------------------
 
-describe('parsePath — happy paths', () => {
-  it('/by-kind/playbook → mount:by-kind args:[playbook]', () => {
+describe('parsePath — happy paths', () => {
+  it('/by-kind/playbook → mount:by-kind args:[playbook]', () => {
     expect(parsePath('/by-kind/playbook')).toEqual({ mount: 'by-kind', args: ['playbook'] })
   })
 
-  it('/by-kind/strategy → mount:by-kind args:[strategy]', () => {
+  it('/by-kind/strategy → mount:by-kind args:[strategy]', () => {
     expect(parsePath('/by-kind/strategy')).toEqual({ mount: 'by-kind', args: ['strategy'] })
   })
 
-  it('/by-feature/sales.crm → mount:by-feature args:[sales.crm]', () => {
-    expect(parsePath('/by-feature/sales.crm')).toEqual({ mount: 'by-feature', args: ['sales.crm'] })
+  it('/by-system/sales.crm → mount:by-system args:[sales.crm]', () => {
+    expect(parsePath('/by-system/sales.crm')).toEqual({ mount: 'by-system', args: ['sales.crm'] })
   })
 
-  it('/by-feature/sales/crm (slash-delimited) → mount:by-feature args:[sales/crm]', () => {
-    // featureId with slashes is joined and passed as-is for the caller to interpret
-    expect(parsePath('/by-feature/sales/crm')).toEqual({ mount: 'by-feature', args: ['sales/crm'] })
+  it('/by-system/sales/crm (slash-delimited) → mount:by-system args:[sales/crm]', () => {
+    // systemId with slashes is joined and passed as-is for the caller to interpret
+    expect(parsePath('/by-system/sales/crm')).toEqual({ mount: 'by-system', args: ['sales/crm'] })
   })
 
-  it('/by-owner/role.ops-lead → mount:by-owner args:[role.ops-lead]', () => {
+  it('/by-owner/role.ops-lead → mount:by-owner args:[role.ops-lead]', () => {
     expect(parsePath('/by-owner/role.ops-lead')).toEqual({ mount: 'by-owner', args: ['role.ops-lead'] })
   })
 
-  it('/graph/knowledge.outreach-playbook/governs → mount:graph args:[knowledge.outreach-playbook,governs]', () => {
+  it('/graph/knowledge.outreach-playbook/governs → mount:graph args:[knowledge.outreach-playbook,governs]', () => {
     expect(parsePath('/graph/knowledge.outreach-playbook/governs')).toEqual({
       mount: 'graph',
       args: ['knowledge.outreach-playbook', 'governs']
     })
   })
 
-  it('/graph/knowledge.outreach-playbook/governed-by → mount:graph args:[knowledge.outreach-playbook,governed-by]', () => {
+  it('/graph/knowledge.outreach-playbook/governed-by → mount:graph args:[knowledge.outreach-playbook,governed-by]', () => {
     expect(parsePath('/graph/knowledge.outreach-playbook/governed-by')).toEqual({
       mount: 'graph',
       args: ['knowledge.outreach-playbook', 'governed-by']
     })
   })
 
-  it('/<nodeId> single segment → mount:node args:[nodeId]', () => {
+  it('/<nodeId> single segment → mount:node args:[nodeId]', () => {
     expect(parsePath('/knowledge.outreach-playbook')).toEqual({
       mount: 'node',
       args: ['knowledge.outreach-playbook']
@@ -341,10 +341,10 @@ describe('parsePath — happy paths', () => {
 })
 
 // ---------------------------------------------------------------------------
-// parsePath — invalid inputs (5+)
+// parsePath — invalid inputs (5+)
 // ---------------------------------------------------------------------------
 
-describe('parsePath — invalid inputs', () => {
+describe('parsePath — invalid inputs', () => {
   it('throws on empty string', () => {
     expect(() => parsePath('')).toThrow('parsePath: path must be a non-empty string')
   })
@@ -357,8 +357,8 @@ describe('parsePath — invalid inputs', () => {
     expect(() => parsePath('/')).toThrow('parsePath: path resolves to root with no mount')
   })
 
-  it('throws on /by-feature with no featureId argument', () => {
-    expect(() => parsePath('/by-feature')).toThrow('/by-feature requires a featureId argument')
+  it('throws on /by-system with no systemId argument', () => {
+    expect(() => parsePath('/by-system')).toThrow('/by-system requires a systemId argument')
   })
 
   it('throws on /by-kind with no kind argument', () => {
@@ -385,11 +385,11 @@ describe('parsePath — invalid inputs', () => {
 })
 
 // ---------------------------------------------------------------------------
-// parsePath — edge cases
+// parsePath — edge cases
 // ---------------------------------------------------------------------------
 
 describe('parsePath edge cases', () => {
-  // Whitespace handling — the parser does NOT trim the incoming string.
+  // Whitespace handling — the parser does NOT trim the incoming string.
   // A path with leading whitespace does not start with '/' so it throws.
   it('throws on path with leading whitespace', () => {
     expect(() => parsePath(' /by-kind/playbook')).toThrow('parsePath: path must start with "/"')
@@ -409,13 +409,13 @@ describe('parsePath edge cases', () => {
     expect(parsePath('/by-kind/playbook///')).toEqual({ mount: 'by-kind', args: ['playbook'] })
   })
 
-  // Lone-slash variants — a path of only slashes normalises to an empty
+  // Lone-slash variants — a path of only slashes normalises to an empty
   // segments list and must throw the root-with-no-mount error.
   it('throws on path consisting only of slashes', () => {
     expect(() => parsePath('///')).toThrow('parsePath: path resolves to root with no mount')
   })
 
-  // Case sensitivity — parsePath does not normalise case.
+  // Case sensitivity — parsePath does not normalise case.
   // 'Playbook' (capitalised) is passed through as-is to the caller.
   it('preserves node-id case (no case normalisation)', () => {
     // /by-kind takes rest[0] verbatim
@@ -423,16 +423,16 @@ describe('parsePath edge cases', () => {
     expect(result.args[0]).toBe('Playbook')
   })
 
-  // Feature ID: dot notation passes through unchanged.
-  it('/by-feature/sales.crm preserves dot notation', () => {
-    expect(parsePath('/by-feature/sales.crm')).toEqual({ mount: 'by-feature', args: ['sales.crm'] })
+  // system id: dot notation passes through unchanged.
+  it('/by-system/sales.crm preserves dot notation', () => {
+    expect(parsePath('/by-system/sales.crm')).toEqual({ mount: 'by-system', args: ['sales.crm'] })
   })
 
-  // Feature ID: slash notation joins rest segments with '/'.
-  // The parser does NOT convert slashes to dots — the caller must normalise.
-  it('/by-feature/sales/crm joins segments with slash (no dot conversion)', () => {
-    const result = parsePath('/by-feature/sales/crm')
-    expect(result.mount).toBe('by-feature')
+  // system id: slash notation joins rest segments with '/'.
+  // The parser does NOT convert slashes to dots — the caller must normalise.
+  it('/by-system/sales/crm joins segments with slash (no dot conversion)', () => {
+    const result = parsePath('/by-system/sales/crm')
+    expect(result.mount).toBe('by-system')
     // args[0] is 'sales/crm', NOT 'sales.crm'
     expect(result.args[0]).toBe('sales/crm')
   })
@@ -446,7 +446,7 @@ describe('parsePath edge cases', () => {
     expect(result.args).toHaveLength(1)
   })
 
-  // /by-owner joins rest with '/' (same behaviour as /by-feature).
+  // /by-owner joins rest with '/' (same behaviour as /by-system).
   it('/by-owner/role.ops-lead/sub joins segments with slash', () => {
     const result = parsePath('/by-owner/role.ops-lead/sub')
     expect(result.mount).toBe('by-owner')
@@ -454,7 +454,7 @@ describe('parsePath edge cases', () => {
   })
 
   // Graph node ID may contain a colon prefix (e.g. knowledge:knowledge.foo).
-  // The parser accepts it — the rest before the verb is joined with '/'.
+  // The parser accepts it — the rest before the verb is joined with '/'.
   it('/graph/<prefixed-nodeId>/governs round-trips the prefixed id', () => {
     const result = parsePath('/graph/knowledge:knowledge.test-node/governs')
     expect(result.mount).toBe('graph')
@@ -467,7 +467,7 @@ describe('parsePath edge cases', () => {
     expect(() => parsePath('/graph')).toThrow('/graph requires <nodeId>/<verb>')
   })
 
-  // /node mount — single-segment path works for any non-reserved first segment.
+  // /node mount — single-segment path works for any non-reserved first segment.
   it('single-segment non-reserved path is treated as node mount', () => {
     expect(parsePath('/knowledge.my-doc')).toEqual({ mount: 'node', args: ['knowledge.my-doc'] })
   })
@@ -504,7 +504,7 @@ describe('formatText', () => {
 })
 
 // ---------------------------------------------------------------------------
-// formatJson — envelope shape
+// formatJson — envelope shape
 // ---------------------------------------------------------------------------
 
 describe('formatJson', () => {
@@ -538,8 +538,8 @@ describe('formatJson', () => {
 
   it('preserves args array in envelope', () => {
     const raw = formatJson({
-      path: '/by-feature/sales.crm',
-      parsed: { mount: 'by-feature', args: ['sales.crm'] },
+      path: '/by-system/sales.crm',
+      parsed: { mount: 'by-system', args: ['sales.crm'] },
       results: []
     })
     expect(JSON.parse(raw)).toMatchObject({ args: ['sales.crm'] })
@@ -549,13 +549,13 @@ describe('formatJson', () => {
     const raw = formatJson({
       path: '/graph/knowledge.playbook-a/governs',
       parsed: { mount: 'graph', args: ['knowledge.playbook-a', 'governs'] },
-      results: ['feature:sales.crm', 'feature:sales.lead-gen']
+      results: ['system:sales.crm', 'system:sales.lead-gen']
     })
     const parsed = JSON.parse(raw) as { results: string[] }
-    expect(parsed.results).toEqual(['feature:sales.crm', 'feature:sales.lead-gen'])
+    expect(parsed.results).toEqual(['system:sales.crm', 'system:sales.lead-gen'])
   })
 
-  it('envelope is NOT flat { results } — must have path/mount/args siblings', () => {
+  it('envelope is NOT flat { results } — must have path/mount/args siblings', () => {
     const raw = formatJson({
       path: '/by-kind/playbook',
       parsed: { mount: 'by-kind', args: ['playbook'] },
@@ -587,7 +587,8 @@ describe('formatIdsOnly', () => {
   })
 
   it('returns newline-separated strings for string[] (governs results)', () => {
-    const output = formatIdsOnly(['feature:sales.crm', 'feature:sales.lead-gen'])
-    expect(output).toBe('feature:sales.crm\nfeature:sales.lead-gen')
+    const output = formatIdsOnly(['system:sales.crm', 'system:sales.lead-gen'])
+    expect(output).toBe('system:sales.crm\nsystem:sales.lead-gen')
   })
 })
+

package/src/knowledge/format.ts

@@ -1,4 +1,4 @@
-import type { OrgKnowledgeNode } from '../organization-model/domains/knowledge'
+import type { OrgKnowledgeNode } from '../organization-model/domains/knowledge'
 import type { KnowledgeMount, ParsedKnowledgePath } from './queries'
 
 // ---------------------------------------------------------------------------
@@ -9,7 +9,7 @@ import type { KnowledgeMount, ParsedKnowledgePath } from './queries'
  * Renders a list of `OrgKnowledgeNode` results as a human-friendly text table.
  *
  * Output format (one row per node):
- *   `<kind>  <id>  <title>  —  <summary (truncated to 80 chars)>`
+ *   `<kind>  <id>  <title>  —  <summary (truncated to 80 chars)>`
  *
  * Returns `"(no results)"` when the array is empty.
  */
@@ -26,7 +26,7 @@ export function formatText(results: OrgKnowledgeNode[]): string {
 
   const rows = results.map((n) => {
     const summary = n.summary.length > 80 ? n.summary.slice(0, 77) + '...' : n.summary
-    return `${n.kind.padEnd(kindWidth)}  ${n.id.padEnd(idWidth)}  ${n.title}  —  ${summary}`
+    return `${n.kind.padEnd(kindWidth)}  ${n.id.padEnd(idWidth)}  ${n.title}  —  ${summary}`
   })
 
   return [header, divider, ...rows].join('\n')
@@ -41,10 +41,10 @@ export function formatText(results: OrgKnowledgeNode[]): string {
  *
  * Shape: `{ path, mount, args, results }`
  *
- * - `path`    — the original path string passed to `parsePath`
- * - `mount`   — the resolved mount axis
- * - `args`    — the parsed arguments array
- * - `results` — the query results (array of `OrgKnowledgeNode` or string IDs)
+ * - `path`    — the original path string passed to `parsePath`
+ * - `mount`   — the resolved mount axis
+ * - `args`    — the parsed arguments array
+ * - `results` — the query results (array of `OrgKnowledgeNode` or string IDs)
  */
 export interface KnowledgeJsonEnvelope {
   path: string
@@ -57,10 +57,10 @@ export interface KnowledgeJsonEnvelope {
  * Formats query results as a wrapped JSON envelope string.
  *
  * The envelope shape is `{ path, mount, args, results }`.  This is intentionally
- * NOT flat `{ results }` — consumers (agent skills, jq pipelines) need the
+ * NOT flat `{ results }` — consumers (agent skills, jq pipelines) need the
  * mount + args to know how to interpret the results array.
  *
- * @param input.path    - The original path string (e.g. `"/by-feature/sales.crm"`).
+ * @param input.path    - The original path string (e.g. `"/by-system/sales.crm"`).
  * @param input.mount   - The resolved mount axis.
  * @param input.args    - The parsed argument array.
  * @param input.results - The query results.
@@ -97,3 +97,4 @@ export function formatIdsOnly(results: OrgKnowledgeNode[] | string[]): string {
   const ids = results.map((r) => (typeof r === 'string' ? r : r.id))
   return ids.join('\n')
 }
+

package/src/knowledge/index.ts

@@ -1,4 +1,4 @@
-export { byFeature, byKind, byOwner, governs, governedBy, parsePath } from './queries'
+export { bySystem, byKind, byOwner, governs, governedBy, parsePath } from './queries'
 export type { KnowledgeMount, ParsedKnowledgePath } from './queries'
 
 export { formatText, formatJson, formatIdsOnly } from './format'

package/src/knowledge/published.ts

@@ -1,4 +1,4 @@
-export { byFeature, byKind, byOwner, governs, governedBy, parsePath } from './queries'
+export { bySystem, byKind, byOwner, governs, governedBy, parsePath } from './queries'
 export type { KnowledgeMount, ParsedKnowledgePath } from './queries'
 
 export { formatText, formatJson, formatIdsOnly } from './format'

package/src/knowledge/queries.ts

@@ -1,4 +1,4 @@
-import type { OrganizationGraph } from '../organization-model/graph/types'
+import type { OrganizationGraph } from '../organization-model/graph/types'
 import type { OrgKnowledgeKind, OrgKnowledgeNode } from '../organization-model/domains/knowledge'
 
 // ---------------------------------------------------------------------------
@@ -35,17 +35,17 @@ function buildKnowledgeSourceIdMap(graph: OrganizationGraph): Map<string, string
 
 /**
  * Returns all knowledge nodes whose `governs` edges point to the given
- * featureId (graph node ID: `feature:<featureId>`).
+ * systemId (graph node ID: `system:<systemId>`).
  *
  * @param graph   - The built OrganizationGraph.
- * @param featureId - The dotted feature id (e.g. `sales.crm`).
+ * @param systemId - The dotted system id (e.g. `sales.crm`).
  */
-export function byFeature(
+export function bySystem(
   graph: OrganizationGraph,
-  featureId: string,
+  systemId: string,
   knowledgeNodes: OrgKnowledgeNode[]
 ): OrgKnowledgeNode[] {
-  const targetGraphNodeId = `feature:${featureId}`
+  const targetGraphNodeId = `system:${systemId}`
 
   // Find all knowledge graph node IDs that have a `governs` edge to the target
   const governingKnowledgeNodeIds = new Set<string>()
@@ -107,7 +107,7 @@ export function byOwner(
  * @param graph    - The built OrganizationGraph.
  * @param nodeId   - The OM knowledge node id (e.g. `knowledge.outreach-playbook`).
  *                   Also accepts the graph node ID format (`knowledge:knowledge.outreach-playbook`).
- * @returns Array of target graph node IDs (e.g. `['feature:sales.crm', ...]`).
+ * @returns Array of target graph node IDs (e.g. `['system:sales.crm', ...]`).
  */
 export function governs(graph: OrganizationGraph, nodeId: string): string[] {
   const graphNodeId = nodeId.startsWith('knowledge:') ? nodeId : toGraphNodeId(nodeId)
@@ -126,16 +126,16 @@ export function governs(graph: OrganizationGraph, nodeId: string): string[] {
  * (incoming `governs` edges pointing to `nodeId`).
  *
  * @param graph   - The built OrganizationGraph.
- * @param nodeId  - The target graph node ID (e.g. `feature:sales.crm`) or a
- *                  bare feature id (e.g. `sales.crm` — will be prefixed with `feature:`).
+ * @param nodeId  - The target graph node ID (e.g. `system:sales.crm`) or a
+ *                  bare system id (e.g. `sales.crm` — will be prefixed with `system:`).
  * @returns Array of source graph node IDs (e.g. `['knowledge:knowledge.outreach-playbook', ...]`).
  */
 export function governedBy(graph: OrganizationGraph, nodeId: string): string[] {
-  // Accept both `feature:sales.crm` and bare `sales.crm`
+  // Accept both `system:sales.crm` and bare `sales.crm`
   const targetId =
-    nodeId.startsWith('feature:') || nodeId.startsWith('knowledge:') || nodeId.startsWith('resource:')
+    nodeId.startsWith('system:') || nodeId.startsWith('knowledge:') || nodeId.startsWith('resource:')
       ? nodeId
-      : `feature:${nodeId}`
+      : `system:${nodeId}`
 
   const results: string[] = []
   for (const edge of graph.edges) {
@@ -151,7 +151,7 @@ export function governedBy(graph: OrganizationGraph, nodeId: string): string[] {
 // ---------------------------------------------------------------------------
 
 /** The recognized mount axes for Knowledge Map paths. */
-export type KnowledgeMount = 'by-feature' | 'by-kind' | 'by-owner' | 'graph' | 'node'
+export type KnowledgeMount = 'by-system' | 'by-kind' | 'by-owner' | 'graph' | 'node'
 
 /**
  * The result of parsing a Knowledge Map path string.
@@ -159,7 +159,7 @@ export type KnowledgeMount = 'by-feature' | 'by-kind' | 'by-owner' | 'graph' | '
  * Shape: `{ mount: KnowledgeMount, args: string[] }`
  *
  * Per-mount arg arrays:
- * - `by-feature`: `[featureId]`  (e.g. `['sales.crm']`)
+ * - `by-system`:  `[systemId]`   (e.g. `['sales.crm']`)
  * - `by-kind`:    `[kind]`       (e.g. `['playbook']`)
  * - `by-owner`:   `[ownerId]`    (e.g. `['role.ops-lead']`)
  * - `graph`:      `[nodeId, verb]` where verb is `'governs'` or `'governed-by'`
@@ -174,12 +174,12 @@ export interface ParsedKnowledgePath {
  * Parses a Knowledge Map path string into a `{ mount, args }` descriptor.
  *
  * Supported path patterns:
- *   `/by-feature/<featureId>`         → `{ mount: 'by-feature', args: ['<featureId>'] }`
- *   `/by-kind/<kind>`                 → `{ mount: 'by-kind',    args: ['<kind>'] }`
- *   `/by-owner/<ownerId>`             → `{ mount: 'by-owner',   args: ['<ownerId>'] }`
- *   `/graph/<nodeId>/governs`         → `{ mount: 'graph',      args: ['<nodeId>', 'governs'] }`
- *   `/graph/<nodeId>/governed-by`     → `{ mount: 'graph',      args: ['<nodeId>', 'governed-by'] }`
- *   `/<nodeId>`                       → `{ mount: 'node',       args: ['<nodeId>'] }`
+ *   `/by-system/<systemId>`           -> `{ mount: 'by-system', args: ['<systemId>'] }`
+ *   `/by-kind/<kind>`                 → `{ mount: 'by-kind',    args: ['<kind>'] }`
+ *   `/by-owner/<ownerId>`             → `{ mount: 'by-owner',   args: ['<ownerId>'] }`
+ *   `/graph/<nodeId>/governs`         → `{ mount: 'graph',      args: ['<nodeId>', 'governs'] }`
+ *   `/graph/<nodeId>/governed-by`     → `{ mount: 'graph',      args: ['<nodeId>', 'governed-by'] }`
+ *   `/<nodeId>`                       → `{ mount: 'node',       args: ['<nodeId>'] }`
  *
  * The path MUST start with `/`.  Trailing slashes are stripped before parsing.
  *
@@ -205,12 +205,12 @@ export function parsePath(pathString: string): ParsedKnowledgePath {
 
   const [first, ...rest] = segments
 
-  // /by-feature/<featureId>
-  if (first === 'by-feature') {
+  // /by-system/<systemId>
+  if (first === 'by-system') {
     if (rest.length === 0) {
-      throw new Error(`parsePath: /by-feature requires a featureId argument, got: "${pathString}"`)
+      throw new Error(`parsePath: /by-system requires a systemId argument, got: "${pathString}"`)
     }
-    return { mount: 'by-feature', args: [rest.join('/')] }
+    return { mount: 'by-system', args: [rest.join('/')] }
   }
 
   // /by-kind/<kind>
@@ -251,6 +251,7 @@ export function parsePath(pathString: string): ParsedKnowledgePath {
   }
 
   throw new Error(
-    `parsePath: unrecognized path pattern "${pathString}". Supported: /by-feature/<id>, /by-kind/<kind>, /by-owner/<id>, /graph/<nodeId>/governs, /graph/<nodeId>/governed-by, /<nodeId>`
+    `parsePath: unrecognized path pattern "${pathString}". Supported: /by-system/<id>, /by-kind/<kind>, /by-owner/<id>, /graph/<nodeId>/governs, /graph/<nodeId>/governed-by, /<nodeId>`
   )
 }
+