@elevasis/core 0.24.1 → 0.26.0

package/src/organization-model/migration-helpers.ts

@@ -1,252 +1,214 @@
-/**
- * Migration helpers — Phase 4 internals swap
- *
- * External signatures are UNCHANGED from the pre-Phase-4 era so callers remain
- * mechanical. Internally, compatibility reads for old compound-domain data
- * walk System.content via listAllSystems() and filter by (kind, type).
- *
- * Compatibility registry entries read:
- *   'schema:pipeline'      — one pipeline per owning system
- *   'schema:stage'         — stage within a pipeline; parentContentId = pipeline local id
- *   'schema:template'      — prospecting build template
- *   'schema:template-step' — step within a template; parentContentId = template local id
- *   'schema:status-flow'   — status set for a project/milestone/task scope
- *   'schema:status'        — single status within a flow; parentContentId = status-flow local id
- */
-
+/**
+ * Migration helpers
+ *
+ * External signatures are intentionally stable. Internally these helpers now
+ * read first-class ontology catalog records.
+ */
+
 import type { OrganizationModel } from './types'
 import type { z } from 'zod'
+import type { LeadGenStageCatalogEntry } from './catalogs/lead-gen'
 import type { SalesPipelineSchema, SalesStageSchema } from './domains/sales'
-import type { ProspectingBuildTemplateSchema, ProspectingLifecycleStageSchema } from './domains/prospecting'
-import type { ProjectsDomainStateSchema } from './domains/projects'
-import { listAllSystems } from './helpers'
-
-// Compatibility boundary: these helpers intentionally keep old tenant
-// System.content schema nodes readable. New schema/catalog authoring belongs in
-// System.ontology, and new system-local settings belong in System.config.
-
-// ---------------------------------------------------------------------------
-// Locally-scoped inferred types — external signatures use these shapes.
-// ---------------------------------------------------------------------------
-type Pipeline = z.infer<typeof SalesPipelineSchema>
-type Stage = z.infer<typeof SalesStageSchema>
-type BuildTemplate = z.infer<typeof ProspectingBuildTemplateSchema>
-type ProspectingStage = z.infer<typeof ProspectingLifecycleStageSchema>
-type ProjectStatus = z.infer<typeof ProjectsDomainStateSchema>
-
-// ---------------------------------------------------------------------------
-// Sales — Pipelines + Stages
-// ---------------------------------------------------------------------------
-
-/**
- * Return all sales pipelines defined in the model, each tagged with the
- * system path of the owning system.
- *
- * Compatibility bridge: walks every system via listAllSystems(), finds content nodes where
- * (kind, type) === ('schema', 'pipeline'), and reconstructs the Pipeline shape
- * by pulling sibling stage content nodes (parentContentId === pipeline local id).
- */
-export function getAllPipelines(model: OrganizationModel): Array<{ systemPath: string; pipeline: Pipeline }> {
-  const results: Array<{ systemPath: string; pipeline: Pipeline }> = []
-
-  for (const { path: systemPath, system } of listAllSystems(model)) {
-    const content = system.content ?? {}
-
-    for (const [localId, node] of Object.entries(content)) {
-      if (node.kind !== 'schema' || node.type !== 'pipeline') continue
-
-      const data = (node.data ?? {}) as Record<string, unknown>
-      const stages: Stage[] = Object.entries(content)
-        .filter(([, s]) => s.kind === 'schema' && s.type === 'stage' && s.parentContentId === localId)
-        .map(([stageLocalId, s]) => {
-          const sd = (s.data ?? {}) as Record<string, unknown>
-          return {
-            id: stageLocalId,
-            label: s.label ?? stageLocalId,
-            order: typeof sd.order === 'number' ? sd.order : 0,
-            semanticClass: (sd.semanticClass as Stage['semanticClass']) ?? 'open',
-            surfaceIds: Array.isArray(sd.surfaceIds) ? (sd.surfaceIds as string[]) : [],
-            resourceIds: Array.isArray(sd.resourceIds) ? (sd.resourceIds as string[]) : [],
-            color: typeof sd.color === 'string' ? sd.color : undefined
-          } satisfies Stage
-        })
-        .sort((a, b) => a.order - b.order)
-
-      const pipeline: Pipeline = {
-        id: localId,
-        label: node.label ?? localId,
-        entityId: typeof data.entityId === 'string' ? data.entityId : '',
-        stages,
-        ...(typeof node.description === 'string' ? { description: node.description } : {})
-      }
-
-      results.push({ systemPath, pipeline })
-    }
-  }
-
-  return results
-}
-
-/**
- * Return the stages belonging to a given pipeline, identified by systemPath + pipelineLocalId.
- *
- * Compatibility bridge: resolves the system at systemPath, filters its content for stage nodes
- * where parentContentId === pipelineLocalId.
- *
- * @param model - The resolved organization model.
- * @param systemPath - Dot-separated path to the owning system (e.g. 'sales.crm').
- * @param pipelineLocalId - The local content id of the target pipeline node.
- */
-export function getStagesInPipeline(model: OrganizationModel, systemPath: string, pipelineLocalId: string): Stage[] {
-  const allSystems = listAllSystems(model)
-  const entry = allSystems.find((s) => s.path === systemPath)
-  if (!entry) return []
-
-  const content = entry.system.content ?? {}
-  return Object.entries(content)
-    .filter(([, node]) => node.kind === 'schema' && node.type === 'stage' && node.parentContentId === pipelineLocalId)
-    .map(([stageLocalId, s]) => {
-      const sd = (s.data ?? {}) as Record<string, unknown>
-      return {
-        id: stageLocalId,
-        label: s.label ?? stageLocalId,
-        order: typeof sd.order === 'number' ? sd.order : 0,
-        semanticClass: (sd.semanticClass as Stage['semanticClass']) ?? 'open',
-        surfaceIds: Array.isArray(sd.surfaceIds) ? (sd.surfaceIds as string[]) : [],
-        resourceIds: Array.isArray(sd.resourceIds) ? (sd.resourceIds as string[]) : [],
-        color: typeof sd.color === 'string' ? sd.color : undefined
-      } satisfies Stage
-    })
-    .sort((a, b) => a.order - b.order)
-}
-
-// ---------------------------------------------------------------------------
-// Prospecting — Build templates
-// ---------------------------------------------------------------------------
-
-/**
- * Return all prospecting build templates defined in the model.
- *
- * Compatibility bridge: walks every system, finds content nodes where
- * (kind, type) === ('schema', 'template'), reconstructs BuildTemplate shape
- * by pulling sibling template-step nodes (parentContentId === template local id).
- */
-export function getAllBuildTemplates(model: OrganizationModel): BuildTemplate[] {
-  const results: BuildTemplate[] = []
-
-  for (const { system } of listAllSystems(model)) {
-    const content = system.content ?? {}
-
-    for (const [localId, node] of Object.entries(content)) {
-      if (node.kind !== 'schema' || node.type !== 'template') continue
-      const nd = (node.data ?? {}) as Record<string, unknown>
-
-      const steps = Object.entries(content)
-        .filter(([, s]) => s.kind === 'schema' && s.type === 'template-step' && s.parentContentId === localId)
-        .map(([stepLocalId, s]) => {
-          const sd = (s.data ?? {}) as Record<string, unknown>
-          return {
-            id: stepLocalId,
-            label: s.label ?? stepLocalId,
-            ...(s.description ? { description: s.description } : {}),
-            // Pass through all data fields — template-step payload is richer than Pipeline;
-            // Bridge readers preserve the historical shape for round-trip fidelity.
-            ...sd
-          }
-        })
-
-      results.push({
-        id: localId,
-        label: node.label ?? localId,
-        ...(node.description ? { description: node.description } : {}),
-        ...(typeof nd.color === 'string' ? { color: nd.color } : {}),
-        // BuildTemplate requires steps array — cast via spread; Wave 4 adds type-safe assertions.
-        steps: steps as BuildTemplate['steps']
-      })
-    }
-  }
-
-  return results
-}
-
-/**
- * Return the prospecting lifecycle stages for a given entity kind.
- *
- * Compatibility bridge: walks every system, finds content nodes where
- * (kind, type) === ('schema', 'stage') AND data.entityKind === kind.
- * Prospecting stages are distinguished from pipeline stages by the presence of
- * data.entityKind ('company' | 'contact') retained on bridge compatibility nodes.
- *
- * @param kind - 'company' or 'contact'.
- */
-export function getAllProspectingStages(model: OrganizationModel, kind: 'company' | 'contact'): ProspectingStage[] {
-  const results: ProspectingStage[] = []
-
-  for (const { system } of listAllSystems(model)) {
-    const content = system.content ?? {}
-
-    for (const [localId, node] of Object.entries(content)) {
-      if (node.kind !== 'schema' || node.type !== 'stage') continue
-      const sd = (node.data ?? {}) as Record<string, unknown>
-      if (sd.entityKind !== kind) continue
-
-      results.push({
-        id: localId,
-        label: node.label ?? localId,
-        order: typeof sd.order === 'number' ? sd.order : 0,
-        ...(typeof sd.color === 'string' ? { color: sd.color } : {}),
-        ...(node.description ? { description: node.description } : {})
-      } satisfies ProspectingStage)
-    }
-  }
-
-  return results.sort((a, b) => a.order - b.order)
-}
-
-// ---------------------------------------------------------------------------
-// Projects — Statuses
-// ---------------------------------------------------------------------------
-
-/**
- * Return the project statuses for a given entity type.
- *
- * Compatibility bridge: walks every system, finds status-flow content nodes where
- * data.appliesTo === appliesTo, then collects their child status nodes
- * (parentContentId === status-flow local id), sorted by order.
- *
- * @param appliesTo - 'project', 'milestone', or 'task'.
- */
-export function getAllProjectStatuses(
-  model: OrganizationModel,
-  appliesTo: 'project' | 'milestone' | 'task'
-): ProjectStatus[] {
-  const results: ProjectStatus[] = []
-
-  for (const { system } of listAllSystems(model)) {
-    const content = system.content ?? {}
-
-    // Find the status-flow node for this appliesTo scope.
-    for (const [flowLocalId, flowNode] of Object.entries(content)) {
-      if (flowNode.kind !== 'schema' || flowNode.type !== 'status-flow') continue
-      const fd = (flowNode.data ?? {}) as Record<string, unknown>
-      if (fd.appliesTo !== appliesTo) continue
-
-      // Collect child status nodes.
-      for (const [statusLocalId, statusNode] of Object.entries(content)) {
-        if (statusNode.kind !== 'schema' || statusNode.type !== 'status') continue
-        if (statusNode.parentContentId !== flowLocalId) continue
-
-        const sd = (statusNode.data ?? {}) as Record<string, unknown>
-        results.push({
-          id: statusLocalId,
-          label: statusNode.label ?? statusLocalId,
-          order: typeof sd.order === 'number' ? sd.order : 0,
-          ...(typeof sd.color === 'string' ? { color: sd.color } : {}),
-          ...(statusNode.description ? { description: statusNode.description } : {})
-        } satisfies ProjectStatus)
-      }
-    }
-  }
-
-  return results.sort((a, b) => a.order - b.order)
-}
+import type { ProspectingBuildTemplateSchema, ProspectingLifecycleStageSchema } from './domains/prospecting'
+import type { ProjectsDomainStateSchema } from './domains/projects'
+import { compileOrganizationOntology, parseOntologyId, type OntologyCatalogType, type OntologyId } from './ontology'
+
+type Pipeline = z.infer<typeof SalesPipelineSchema>
+type Stage = z.infer<typeof SalesStageSchema>
+type BuildTemplate = z.infer<typeof ProspectingBuildTemplateSchema>
+type ProspectingStage = z.infer<typeof ProspectingLifecycleStageSchema>
+type ProjectStatus = z.infer<typeof ProjectsDomainStateSchema>
+
+type CatalogRecord = OntologyCatalogType & { origin?: { systemPath?: string } }
+type CatalogEntry = Record<string, unknown>
+
+function catalogRecords(model: OrganizationModel): CatalogRecord[] {
+  return Object.values(compileOrganizationOntology(model).ontology.catalogTypes) as CatalogRecord[]
+}
+
+function localId(id: string): string {
+  return parseOntologyId(id).localId
+}
+
+function systemScope(id: string, fallback?: string): string {
+  return parseOntologyId(id).scope || fallback || ''
+}
+
+function entriesOf(catalog: CatalogRecord): Array<[string, CatalogEntry]> {
+  return Object.entries(catalog.entries ?? {}).map(([id, value]) => [
+    id,
+    value && typeof value === 'object' && !Array.isArray(value) ? (value as CatalogEntry) : {}
+  ])
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : []
+}
+
+function numberValue(value: unknown, fallback = 0): number {
+  return typeof value === 'number' ? value : fallback
+}
+
+function stageFromEntry(entryId: string, entry: CatalogEntry): Stage {
+  return {
+    id: entryId,
+    label: stringValue(entry.label) ?? entryId,
+    order: numberValue(entry.order),
+    semanticClass: (stringValue(entry.semanticClass) as Stage['semanticClass']) ?? 'open',
+    surfaceIds: stringArray(entry.surfaceIds),
+    resourceIds: stringArray(entry.resourceIds),
+    color: stringValue(entry.color)
+  }
+}
+
+function appliesToLocalId(catalog: CatalogRecord): string | undefined {
+  const appliesTo = catalog.appliesTo
+  if (appliesTo === undefined) return undefined
+  return parseOntologyId(appliesTo).localId
+}
+
+function appliesToEntityKind(catalog: CatalogRecord): 'company' | 'contact' | 'project' | 'milestone' | 'task' | undefined {
+  const id = appliesToLocalId(catalog)
+  if (id === 'company' || id === 'contact' || id === 'project' || id === 'milestone' || id === 'task') return id
+  if (id === 'deal') return undefined
+  return undefined
+}
+
+export function getAllPipelines(model: OrganizationModel): Array<{ systemPath: string; pipeline: Pipeline }> {
+  return catalogRecords(model)
+    .filter((catalog) => catalog.kind === 'pipeline')
+    .map((catalog) => {
+      const pipeline: Pipeline = {
+        id: localId(catalog.id),
+        label: catalog.label ?? localId(catalog.id),
+        ...(catalog.description ? { description: catalog.description } : {}),
+        entityId: appliesToLocalId(catalog) ?? '',
+        stages: entriesOf(catalog)
+          .map(([entryId, entry]) => stageFromEntry(entryId, entry))
+          .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+      }
+
+      return { systemPath: catalog.ownerSystemId ?? systemScope(catalog.id), pipeline }
+    })
+    .sort((a, b) => a.systemPath.localeCompare(b.systemPath) || a.pipeline.id.localeCompare(b.pipeline.id))
+}
+
+export function getStagesInPipeline(model: OrganizationModel, systemPath: string, pipelineLocalId: string): Stage[] {
+  const catalog = catalogRecords(model).find(
+    (record) =>
+      record.kind === 'pipeline' &&
+      (record.ownerSystemId ?? systemScope(record.id)) === systemPath &&
+      localId(record.id) === pipelineLocalId
+  )
+
+  if (catalog === undefined) return []
+
+  return entriesOf(catalog)
+    .map(([entryId, entry]) => stageFromEntry(entryId, entry))
+    .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+}
+
+export function getAllBuildTemplates(model: OrganizationModel): BuildTemplate[] {
+  const catalogs = catalogRecords(model)
+  const stepCatalogs = new Map<OntologyId, CatalogRecord>(
+    catalogs.filter((catalog) => catalog.kind === 'template-step').map((catalog) => [catalog.id as OntologyId, catalog])
+  )
+
+  return catalogs
+    .filter((catalog) => catalog.kind === 'template')
+    .flatMap((catalog) =>
+      entriesOf(catalog).map(([templateId, templateEntry]) => {
+        const stepCatalogId = stringValue(templateEntry.stepCatalog) as OntologyId | undefined
+        const stepCatalog = stepCatalogId !== undefined ? stepCatalogs.get(stepCatalogId) : undefined
+        const steps = stepCatalog === undefined ? [] : entriesOf(stepCatalog)
+
+        return {
+          id: templateId,
+          label: stringValue(templateEntry.label) ?? templateId,
+          ...(stringValue(templateEntry.description) ? { description: stringValue(templateEntry.description) } : {}),
+          ...(stringValue(templateEntry.color) ? { color: stringValue(templateEntry.color) } : {}),
+          steps: steps.map(([stepId, step]) => ({
+            id: stepId,
+            label: stringValue(step.label) ?? stepId,
+            ...(stringValue(step.description) ? { description: stringValue(step.description) } : {}),
+            ...step
+          })) as BuildTemplate['steps']
+        } satisfies BuildTemplate
+      })
+    )
+    .sort((a, b) => a.id.localeCompare(b.id))
+}
+
+export function getAllProspectingStages(model: OrganizationModel, kind: 'company' | 'contact'): ProspectingStage[] {
+  return catalogRecords(model)
+    .filter((catalog) => catalog.kind === 'stage' && appliesToEntityKind(catalog) === kind)
+    .flatMap((catalog) =>
+      entriesOf(catalog).map(([entryId, entry]) => ({
+        id: entryId,
+        label: stringValue(entry.label) ?? entryId,
+        order: numberValue(entry.order),
+        ...(stringValue(entry.color) ? { color: stringValue(entry.color) } : {}),
+        ...(stringValue(entry.description) ? { description: stringValue(entry.description) } : {})
+      }))
+    )
+    .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+}
+
+export function getLeadGenStageCatalog(model: OrganizationModel): Record<string, LeadGenStageCatalogEntry> {
+  const results: Record<string, LeadGenStageCatalogEntry> = {}
+
+  for (const catalog of catalogRecords(model).filter(
+    (record) => record.kind === 'stage' && (record.ownerSystemId ?? systemScope(record.id)) === 'sales.lead-gen'
+  )) {
+    const catalogEntity = appliesToEntityKind(catalog)
+    if (catalogEntity !== 'company' && catalogEntity !== 'contact') continue
+
+    for (const [entryId, entry] of entriesOf(catalog)) {
+      const entity =
+        entry.entity === 'contact' ? 'contact' : entry.entity === 'company' ? 'company' : catalogEntity
+      const additionalEntities = stringArray(entry.additionalEntities).filter(
+        (item): item is 'company' | 'contact' => item === 'company' || item === 'contact'
+      )
+      const recordEntity =
+        entry.recordEntity === 'company' || entry.recordEntity === 'contact' ? entry.recordEntity : undefined
+      const recordStageKey = stringValue(entry.recordStageKey)
+
+      results[entryId] = {
+        key: entryId,
+        label: stringValue(entry.label) ?? entryId,
+        description: stringValue(entry.description) ?? '',
+        order: numberValue(entry.order),
+        entity,
+        ...(additionalEntities.length > 0 ? { additionalEntities } : {}),
+        ...(recordEntity ? { recordEntity } : {}),
+        ...(recordStageKey ? { recordStageKey } : {})
+      }
+    }
+  }
+
+  return Object.fromEntries(
+    Object.entries(results).sort(([, a], [, b]) => a.order - b.order || a.key.localeCompare(b.key))
+  )
+}
+
+export function getAllProjectStatuses(
+  model: OrganizationModel,
+  appliesTo: 'project' | 'milestone' | 'task'
+): ProjectStatus[] {
+  return catalogRecords(model)
+    .filter((catalog) => catalog.kind === 'status-flow' && appliesToEntityKind(catalog) === appliesTo)
+    .flatMap((catalog) =>
+      entriesOf(catalog).map(([entryId, entry]) => ({
+        id: entryId,
+        label: stringValue(entry.label) ?? entryId,
+        order: numberValue(entry.order),
+        ...(stringValue(entry.color) ? { color: stringValue(entry.color) } : {}),
+        ...(stringValue(entry.description) ? { description: stringValue(entry.description) } : {})
+      }))
+    )
+    .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+}

package/src/organization-model/ontology.ts

@@ -292,7 +292,6 @@ type SystemLike = {
   title?: string
   description?: string
   ontology?: OntologyScope
-  content?: Record<string, ContentLike>
   systems?: Record<string, SystemLike>
   subsystems?: Record<string, SystemLike>
 }
@@ -319,15 +318,6 @@ type ActionLike = {
   lifecycle?: string
 }
 
-type ContentLike = {
-  kind: string
-  type: string
-  label?: string
-  description?: string
-  parentContentId?: string
-  data?: Record<string, unknown>
-}
-
 type SourceContext = {
   source: string
   path: Array<string | number>
@@ -568,55 +558,6 @@ function addLegacyActionProjections(
   }
 }
 
-function addSystemContentProjections(
-  index: ResolvedOntologyIndex,
-  diagnostics: OntologyDiagnostic[],
-  sourcesById: Map<string, SourceContext>,
-  systemPath: string,
-  system: SystemLike,
-  schemaPath: Array<string | number>
-): void {
-  const content = system.content ?? {}
-  for (const [localId, node] of Object.entries(content)) {
-    if (node.kind !== 'schema') continue
-
-    const entries = Object.fromEntries(
-      Object.entries(content)
-        .filter(([, candidate]) => candidate.parentContentId === localId)
-        .map(([entryId, candidate]) => [
-          entryId,
-          {
-            label: candidate.label ?? entryId,
-            type: candidate.type,
-            ...(candidate.description !== undefined ? { description: candidate.description } : {}),
-            ...(candidate.data !== undefined ? candidate.data : {})
-          }
-        ])
-    )
-
-    const catalogType: OntologyCatalogType = {
-      id: formatOntologyId({ scope: systemPath, kind: 'catalog', localId }),
-      label: node.label ?? localId,
-      description: node.description,
-      ownerSystemId: systemPath,
-      kind: node.type,
-      ...(typeof node.data?.['entityId'] === 'string'
-        ? { appliesTo: formatOntologyId({ scope: systemPath, kind: 'object', localId: node.data['entityId'] }) }
-        : {}),
-      ...(Object.keys(entries).length > 0 ? { entries } : {}),
-      ...(node.data !== undefined ? { data: node.data } : {})
-    }
-
-    addRecord(index, diagnostics, sourcesById, 'catalogTypes', catalogType, {
-      source: 'legacy.system.content',
-      path: [...schemaPath, 'content', localId],
-      kind: 'projected',
-      systemPath,
-      legacyId: `${systemPath}:${localId}`
-    })
-  }
-}
-
 function addSystemScopes(
   index: ResolvedOntologyIndex,
   diagnostics: OntologyDiagnostic[],
@@ -632,7 +573,6 @@ function addSystemScopes(
       ...currentPath,
       'ontology'
     ])
-    addSystemContentProjections(index, diagnostics, sourcesById, systemPath, system, currentPath)
     addSystemScopes(index, diagnostics, sourcesById, childSystemsOf(system), systemPath, [
       ...currentPath,
       system.systems !== undefined ? 'systems' : 'subsystems'

package/src/organization-model/organization-graph.mdx

@@ -1,6 +1,6 @@
 ---
 title: Organization Graph
-description: Organization OS graph layer documentation for the organization graph derived from Organization Model Systems, resources, actions, entities, content nodes, and typed links.
+description: Organization OS graph layer documentation for the organization graph derived from Organization Model Systems, resources, actions, entities, ontology catalogs, and typed links.
 ---
 
 ## Overview
@@ -38,7 +38,6 @@ Node kinds:
 - `goal`
 - `surface`
 - `navigation-group`
-- `content-node`
 
 Edge kinds:
 
@@ -58,7 +57,7 @@ Edge kinds:
 
 System nodes come from the id-keyed `OrganizationModel.systems` map. Their graph IDs use `system:<id>`, such as `system:sales.crm`.
 
-Resource, action, entity, policy, navigation, and content edges are derived from canonical OM maps:
+Resource, action, entity, policy, navigation, and ontology catalog edges are derived from canonical OM maps:
 
 ```ts
 // ResourceEntry.systemPath => system -> resource contains
@@ -67,7 +66,7 @@ Resource, action, entity, policy, navigation, and content edges are derived from
 // Action.affects[] => action -> entity affects
 // Entity.links[] => entity -> entity links
 // ResourceEntry.emits[] => resource -> event emits
-// System.content => system -> content-node contains
+// System.ontology.catalogTypes => ontology catalog nodes and relationships
 // AgentResource.invocations[] => agent resource -> invocation target uses/references
 ```
 
@@ -84,7 +83,7 @@ interface BuildOrganizationGraphInput {
 
 1. Reads Organization Model Systems and derives `system:*` nodes.
 2. Reads OM resources, including workflow, agent, integration, and script resources, as `resource` nodes.
-3. Emits derived graph links from System, Resource, Action, Entity, Policy, Agent invocation, Knowledge, navigation, and System content contracts.
+3. Emits derived graph links from System, Resource, Action, Entity, Policy, Agent invocation, Knowledge, navigation, and ontology catalog contracts.
 4. Bridges Command View runtime topology into resource nodes and relationship edges.
 5. Returns a renderer-agnostic DTO.
 

package/src/organization-model/organization-model.mdx

@@ -179,7 +179,7 @@ The model keeps business semantics in named domains:
 - `policies` -- operational governance rules over systems, actions, resources, and roles
 - `knowledge` -- playbooks, strategies, references, and graph-governing links
 
-System-local operational catalogs now live under `System.content`, including pipeline, stage, template, template-step, status-flow, status, and config nodes. The legacy compound and status domains should not be used for new authoring.
+System-local operational catalogs live under `System.ontology.catalogTypes`, including pipeline, stage, template, template-step, status-flow, and status records. System-local settings live in `System.config`. The legacy compound and status domains should not be used for new authoring.
 
 ## Authoring and Resolution