@elevasis/core 0.22.0 → 0.23.0

package/src/organization-model/surface-projection.ts

@@ -1,23 +1,30 @@
-import type { OrganizationModel, OrganizationModelFeature, OrganizationModelSurface } from './types'
+import type {
+  OrganizationModel,
+  OrganizationModelSurface,
+  OrganizationModelSidebarNode,
+  OrganizationModelSidebarSurfaceNode,
+  OrganizationModelSystemEntry
+} from './types'
+import { listAllSystems } from './helpers'
+import { getSortedSidebarEntries } from './domains/navigation'
 
 export type OrganizationSurfaceProjectionIssueCode =
   | 'duplicate-surface-id'
   | 'duplicate-surface-path'
-  | 'unknown-default-surface'
-  | 'unknown-group-surface'
-  | 'unknown-surface-feature'
-  | 'unknown-surface-feature-reference'
+  | 'unknown-surface-system'
 
 export interface OrganizationSurfaceProjection {
   id: string
   label: string
   path: string
   surfaceType: OrganizationModelSurface['surfaceType']
-  featureId?: string
-  featureIds: string[]
+  description?: string
+  icon?: string
+  order?: number
+  systemIds: string[]
   entityIds: string[]
   resourceIds: string[]
-  capabilityIds: string[]
+  actionIds: string[]
   enabled: boolean
   devOnly?: boolean
   requiresAdmin?: boolean
@@ -28,104 +35,129 @@ export interface OrganizationSurfaceProjectionIssue {
   message: string
   path: Array<string | number>
   surfaceId?: string
-  featureId?: string
-  groupId?: string
+  systemId?: string
   value?: string
 }
 
-const LEGACY_FEATURE_ALIASES = new Map<string, string>([
-  ['crm', 'sales.crm'],
-  ['lead-gen', 'sales.lead-gen'],
-  ['submitted-requests', 'monitoring.submitted-requests']
-])
+interface SidebarSurfaceWithId {
+  id: string
+  surface: OrganizationModelSidebarSurfaceNode
+  path: Array<string | number>
+}
 
 function normalizePath(path: string): string {
   return path.length > 1 ? path.replace(/\/+$/, '') : path
 }
 
-function collectFeaturesById(model: OrganizationModel): Map<string, OrganizationModelFeature> {
-  return new Map(model.features.map((feature) => [feature.id, feature]))
-}
-
-function resolveFeatureId(featuresById: Map<string, OrganizationModelFeature>, featureId: string): string | undefined {
-  if (featuresById.has(featureId)) {
-    return featureId
+function collectSystemsById(model: OrganizationModel): Map<string, OrganizationModelSystemEntry> {
+  const systemsById = new Map<string, OrganizationModelSystemEntry>()
+  for (const { path, system } of listAllSystems(model)) {
+    systemsById.set(path, system)
+    systemsById.set(system.id, system)
   }
-
-  const aliasTarget = LEGACY_FEATURE_ALIASES.get(featureId)
-  return aliasTarget !== undefined && featuresById.has(aliasTarget) ? aliasTarget : undefined
+  return systemsById
 }
 
-function getFeatureWithAncestors(
-  featuresById: Map<string, OrganizationModelFeature>,
-  featureId: string
-): OrganizationModelFeature[] {
-  const features: OrganizationModelFeature[] = []
-  const segments = featureId.split('.')
-
-  for (let index = 1; index <= segments.length; index += 1) {
-    const candidate = featuresById.get(segments.slice(0, index).join('.'))
-    if (candidate) {
-      features.push(candidate)
-    }
+function getSystemWithAncestors(
+  systemsById: Map<string, OrganizationModelSystemEntry>,
+  systemId: string
+): OrganizationModelSystemEntry[] {
+  const systems: OrganizationModelSystemEntry[] = []
+  let current = systemsById.get(systemId)
+  while (current !== undefined) {
+    systems.unshift(current)
+    current = current.parentSystemId ? systemsById.get(current.parentSystemId) : undefined
   }
-
-  return features
+  return systems
 }
 
 function hasInheritedFlag(
-  featuresById: Map<string, OrganizationModelFeature>,
-  featureIds: string[],
+  systemsById: Map<string, OrganizationModelSystemEntry>,
+  systemIds: string[],
   flag: 'devOnly' | 'requiresAdmin'
 ): boolean {
-  return featureIds.some((featureId) =>
-    getFeatureWithAncestors(featuresById, featureId).some((feature) => feature[flag] === true)
+  return systemIds.some((systemId) =>
+    getSystemWithAncestors(systemsById, systemId).some((system) => system[flag] === true)
   )
 }
 
-function isFeatureEnabled(featuresById: Map<string, OrganizationModelFeature>, featureId: string): boolean {
-  const featureLineage = getFeatureWithAncestors(featuresById, featureId)
-  return featureLineage.length > 0 && featureLineage.every((feature) => feature.enabled)
+function isLifecycleEnabled(system: OrganizationModelSystemEntry): boolean {
+  if (system.enabled === false) return false
+  return system.lifecycle !== 'deprecated' && system.lifecycle !== 'archived'
+}
+
+function isLifecycleDevOnly(system: OrganizationModelSystemEntry): boolean {
+  return system.devOnly === true || system.lifecycle === 'beta'
+}
+
+function isSystemEnabled(systemsById: Map<string, OrganizationModelSystemEntry>, systemId: string): boolean {
+  const systemLineage = getSystemWithAncestors(systemsById, systemId)
+  return systemLineage.length > 0 && systemLineage.every(isLifecycleEnabled)
 }
 
 function unique(values: string[]): string[] {
   return [...new Set(values)]
 }
 
+function collectSidebarSurfaces(
+  nodes: Record<string, OrganizationModelSidebarNode>,
+  schemaPath: Array<string | number>,
+  surfaces: SidebarSurfaceWithId[] = []
+): SidebarSurfaceWithId[] {
+  getSortedSidebarEntries(nodes).forEach(([id, node]) => {
+    const nodePath = [...schemaPath, id]
+    if (node.type === 'group') {
+      collectSidebarSurfaces(node.children, [...nodePath, 'children'], surfaces)
+      return
+    }
+    surfaces.push({ id, surface: node, path: nodePath })
+  })
+
+  return surfaces
+}
+
+function getSidebarSurfaces(model: OrganizationModel): SidebarSurfaceWithId[] {
+  return [
+    ...collectSidebarSurfaces(model.navigation.sidebar.primary, ['navigation', 'sidebar', 'primary']),
+    ...collectSidebarSurfaces(model.navigation.sidebar.bottom, ['navigation', 'sidebar', 'bottom'])
+  ]
+}
+
 export function projectOrganizationSurfaces(model: OrganizationModel): OrganizationSurfaceProjection[] {
-  const featuresById = collectFeaturesById(model)
-
-  return model.navigation.surfaces.map((surface) => {
-    const featureId = surface.featureId ? resolveFeatureId(featuresById, surface.featureId) : undefined
-    const featureIds = unique(
-      [featureId, ...surface.featureIds.map((candidate) => resolveFeatureId(featuresById, candidate))].filter(
-        (candidate): candidate is string => candidate !== undefined
-      )
-    )
-    const enabled = surface.enabled && featureIds.every((candidate) => isFeatureEnabled(featuresById, candidate))
-    const devOnly = surface.devOnly === true || hasInheritedFlag(featuresById, featureIds, 'devOnly')
-    const requiresAdmin = hasInheritedFlag(featuresById, featureId ? [featureId] : featureIds, 'requiresAdmin')
+  const systemsById = collectSystemsById(model)
+
+  return getSidebarSurfaces(model).map(({ id, surface }) => {
+    const targets = surface.targets ?? {}
+    const systemIds = unique((targets.systems ?? []).filter((systemId: string) => systemsById.has(systemId)))
+    const enabled = systemIds.every((candidate) => isSystemEnabled(systemsById, candidate))
+    const devOnly =
+      surface.devOnly === true ||
+      hasInheritedFlag(systemsById, systemIds, 'devOnly') ||
+      systemIds.some((candidate) => getSystemWithAncestors(systemsById, candidate).some(isLifecycleDevOnly))
+    const requiresAdmin = hasInheritedFlag(systemsById, systemIds, 'requiresAdmin')
 
     return {
-      id: surface.id,
+      id,
       label: surface.label,
       path: surface.path,
       surfaceType: surface.surfaceType,
-      featureId,
-      featureIds,
-      entityIds: [...surface.entityIds],
-      resourceIds: [...surface.resourceIds],
-      capabilityIds: [...surface.capabilityIds],
+      ...(surface.description !== undefined ? { description: surface.description } : {}),
+      ...(surface.icon !== undefined ? { icon: surface.icon } : {}),
+      ...(surface.order !== undefined ? { order: surface.order } : {}),
+      systemIds,
+      entityIds: [...(targets.entities ?? [])],
+      resourceIds: [...(targets.resources ?? [])],
+      actionIds: [...(targets.actions ?? [])],
       enabled,
       ...(devOnly ? { devOnly } : {}),
-      ...(requiresAdmin ? { requiresAdmin } : {})
+      ...(surface.requiresAdmin === true || requiresAdmin ? { requiresAdmin: true } : {})
     }
   })
 }
 
 export function validateOrganizationSurfaceProjection(model: OrganizationModel): OrganizationSurfaceProjectionIssue[] {
   const issues: OrganizationSurfaceProjectionIssue[] = []
-  const featuresById = collectFeaturesById(model)
+  const systemsById = collectSystemsById(model)
   const surfaceIds = new Set<string>()
   const surfacePaths = new Map<string, string>()
 
@@ -133,17 +165,17 @@ export function validateOrganizationSurfaceProjection(model: OrganizationModel):
     issues.push(issue)
   }
 
-  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
-    if (surfaceIds.has(surface.id)) {
+  getSidebarSurfaces(model).forEach(({ id, surface, path }) => {
+    if (surfaceIds.has(id)) {
       addIssue({
         code: 'duplicate-surface-id',
-        message: `Surface id "${surface.id}" must be unique`,
-        path: ['navigation', 'surfaces', surfaceIndex, 'id'],
-        surfaceId: surface.id,
-        value: surface.id
+        message: `Surface id "${id}" must be unique`,
+        path,
+        surfaceId: id,
+        value: id
       })
     } else {
-      surfaceIds.add(surface.id)
+      surfaceIds.add(id)
     }
 
     const normalizedPath = normalizePath(surface.path)
@@ -152,64 +184,26 @@ export function validateOrganizationSurfaceProjection(model: OrganizationModel):
       addIssue({
         code: 'duplicate-surface-path',
         message: `Surface path "${surface.path}" is already used by surface "${existingSurfaceId}"`,
-        path: ['navigation', 'surfaces', surfaceIndex, 'path'],
-        surfaceId: surface.id,
+        path: [...path, 'path'],
+        surfaceId: id,
         value: surface.path
       })
     } else {
-      surfacePaths.set(normalizedPath, surface.id)
+      surfacePaths.set(normalizedPath, id)
     }
 
-    if (surface.featureId !== undefined && resolveFeatureId(featuresById, surface.featureId) === undefined) {
-      addIssue({
-        code: 'unknown-surface-feature',
-        message: `Surface "${surface.id}" references unknown feature "${surface.featureId}"`,
-        path: ['navigation', 'surfaces', surfaceIndex, 'featureId'],
-        surfaceId: surface.id,
-        featureId: surface.featureId,
-        value: surface.featureId
-      })
-    }
-
-    surface.featureIds.forEach((featureId, featureIndex) => {
-      if (resolveFeatureId(featuresById, featureId) !== undefined) {
-        return
-      }
-
-      addIssue({
-        code: 'unknown-surface-feature-reference',
-        message: `Surface "${surface.id}" references unknown feature "${featureId}"`,
-        path: ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
-        surfaceId: surface.id,
-        featureId,
-        value: featureId
-      })
-    })
-  })
-
-  if (model.navigation.defaultSurfaceId !== undefined && !surfaceIds.has(model.navigation.defaultSurfaceId)) {
-    addIssue({
-      code: 'unknown-default-surface',
-      message: `Default surface "${model.navigation.defaultSurfaceId}" is not declared in navigation.surfaces`,
-      path: ['navigation', 'defaultSurfaceId'],
-      surfaceId: model.navigation.defaultSurfaceId,
-      value: model.navigation.defaultSurfaceId
-    })
-  }
-
-  model.navigation.groups.forEach((group, groupIndex) => {
-    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      if (surfaceIds.has(surfaceId)) {
+    surface.targets?.systems?.forEach((systemId: string, systemIndex: number) => {
+      if (systemsById.has(systemId)) {
         return
       }
 
       addIssue({
-        code: 'unknown-group-surface',
-        message: `Navigation group "${group.id}" references unknown surface "${surfaceId}"`,
-        path: ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
-        surfaceId,
-        groupId: group.id,
-        value: surfaceId
+        code: 'unknown-surface-system',
+        message: `Surface "${id}" references unknown system "${systemId}"`,
+        path: [...path, 'targets', 'systems', systemIndex],
+        surfaceId: id,
+        systemId,
+        value: systemId
       })
     })
   })

package/src/organization-model/types.ts

@@ -1,12 +1,19 @@
 import type { z } from 'zod'
 import { OrganizationModelBrandingSchema } from './domains/branding'
-import { OrganizationModelSalesSchema } from './domains/sales'
-import { OrganizationModelProjectsSchema } from './domains/projects'
-import { FeatureSchema, NodeIdPathSchema, NodeIdStringSchema } from './domains/features'
-import { OrganizationModelProspectingSchema } from './domains/prospecting'
-import { OrganizationModelNavigationSchema, SurfaceDefinitionSchema } from './domains/navigation'
+import { SalesPipelineSchema, SalesStageSchema } from './domains/sales'
+import { ProjectsDomainStateSchema } from './domains/projects'
+import { NodeIdPathSchema, NodeIdStringSchema } from './domains/systems'
+import { ProspectingBuildTemplateSchema, ProspectingLifecycleStageSchema } from './domains/prospecting'
+import {
+  NavigationGroupSchema,
+  OrganizationModelNavigationSchema,
+  SidebarNavigationSchema,
+  SidebarNodeSchema,
+  SidebarSectionSchema,
+  SidebarSurfaceTargetsSchema,
+  SurfaceDefinitionSchema
+} from './domains/navigation'
 import { TechStackEntrySchema } from './domains/shared'
-import { OperationsDomainSchema, OperationEntrySchema, OperationSemanticClassSchema } from './domains/operations'
 import { StatusesDomainSchema, StatusEntrySchema, StatusSemanticClassSchema } from './domains/statuses'
 import { CustomersDomainSchema, CustomerSegmentSchema, FirmographicsSchema } from './domains/customers'
 import { OfferingsDomainSchema, ProductSchema, PricingModelSchema } from './domains/offerings'
@@ -21,9 +28,10 @@ import {
 } from './domains/roles'
 import { GoalsDomainSchema, ObjectiveSchema, KeyResultSchema } from './domains/goals'
 import {
-  KnowledgeDomainBindingSchema,
   KnowledgeDomainSchema,
-  KnowledgeSkillBindingSchema,
+  KnowledgeLinkSchema,
+  KnowledgeTargetKindSchema,
+  KnowledgeTargetRefSchema,
   OrgKnowledgeKindSchema,
   OrgKnowledgeNodeSchema
 } from './domains/knowledge'
@@ -31,40 +39,83 @@ import {
   SystemEntrySchema,
   SystemIdSchema,
   SystemKindSchema,
-  SystemsDomainSchema,
-  SystemStatusSchema
+  SystemLifecycleSchema,
+  SystemPathSchema,
+  SystemStatusSchema,
+  SystemsDomainSchema
 } from './domains/systems'
 import {
   AgentKindSchema,
   AgentResourceEntrySchema,
+  EventDescriptorSchema,
+  EventEmissionDescriptorSchema,
+  EventIdSchema,
   IntegrationResourceEntrySchema,
   ResourceEntrySchema,
   ResourceGovernanceStatusSchema,
   ResourceIdSchema,
   ResourceKindSchema,
   ResourcesDomainSchema,
+  ScriptResourceEntrySchema,
+  ScriptResourceLanguageSchema,
+  ScriptResourceSourceSchema,
   WorkflowResourceEntrySchema
 } from './domains/resources'
+import {
+  ActionsDomainSchema,
+  ActionIdSchema,
+  ActionInvocationKindSchema,
+  ActionInvocationSchema,
+  ActionRefSchema,
+  ActionSchema,
+  ActionScopeSchema
+} from './domains/actions'
+import { EntitiesDomainSchema, EntityIdSchema, EntityLinkSchema, EntitySchema } from './domains/entities'
+import {
+  PoliciesDomainSchema,
+  PolicyEffectSchema,
+  PolicyApplicabilitySchema,
+  PolicyIdSchema,
+  PolicyPredicateSchema,
+  PolicySchema,
+  PolicyTriggerSchema
+} from './domains/policies'
 import { OrganizationModelIconTokenSchema, OrganizationModelBuiltinIconTokenSchema } from './icons'
-import { OrganizationModelSchema } from './schema'
+import {
+  OrganizationModelDomainKeySchema,
+  OrganizationModelDomainMetadataByDomainSchema,
+  OrganizationModelDomainMetadataSchema,
+  OrganizationModelSchema
+} from './schema'
 
 export type OrganizationModel = z.infer<typeof OrganizationModelSchema>
+export type OrganizationModelDomainKey = z.infer<typeof OrganizationModelDomainKeySchema>
+export type OrganizationModelDomainMetadata = z.infer<typeof OrganizationModelDomainMetadataSchema>
+export type OrganizationModelDomainMetadataByDomain = z.infer<typeof OrganizationModelDomainMetadataByDomainSchema>
 export type OrganizationModelBranding = z.infer<typeof OrganizationModelBrandingSchema>
-export type OrganizationModelSales = z.infer<typeof OrganizationModelSalesSchema>
-export type OrganizationModelProspecting = z.infer<typeof OrganizationModelProspectingSchema>
-export type OrganizationModelProjects = z.infer<typeof OrganizationModelProjectsSchema>
-export type OrganizationModelFeature = z.infer<typeof FeatureSchema>
+// Phase 4: OrganizationModelSales, OrganizationModelProspecting, OrganizationModelProjects,
+// OrganizationModelNavigation removed — compound domain top-level fields deleted per D8/D1.
+// Retained as local aliases for content-kind payload shapes used in migration-helpers:
+export type SalesPipeline = z.infer<typeof SalesPipelineSchema>
+export type SalesStage = z.infer<typeof SalesStageSchema>
+export type ProspectingBuildTemplate = z.infer<typeof ProspectingBuildTemplateSchema>
+export type ProspectingLifecycleStage = z.infer<typeof ProspectingLifecycleStageSchema>
+export type ProjectsDomainState = z.infer<typeof ProjectsDomainStateSchema>
 export type NodeIdPath = z.infer<typeof NodeIdPathSchema>
 export type NodeIdString = z.infer<typeof NodeIdStringSchema>
-export type OrganizationModelNavigation = z.infer<typeof OrganizationModelNavigationSchema>
 export type OrganizationModelSurface = z.infer<typeof SurfaceDefinitionSchema>
+export type OrganizationModelNavigationGroup = z.infer<typeof NavigationGroupSchema>
+export type OrganizationModelNavigation = z.infer<typeof OrganizationModelNavigationSchema>
+export type OrganizationModelSidebar = z.infer<typeof SidebarNavigationSchema>
+export type OrganizationModelSidebarSection = z.infer<typeof SidebarSectionSchema>
+export type OrganizationModelSidebarNode = z.infer<typeof SidebarNodeSchema>
+export type OrganizationModelSidebarSurfaceTargets = z.infer<typeof SidebarSurfaceTargetsSchema>
+export type OrganizationModelSidebarSurfaceNode = Extract<OrganizationModelSidebarNode, { type: 'surface' }>
+export type OrganizationModelSidebarGroupNode = Extract<OrganizationModelSidebarNode, { type: 'group' }>
 export type OrganizationModelTechStackEntry = z.infer<typeof TechStackEntrySchema>
 export type OrganizationModelStatuses = z.infer<typeof StatusesDomainSchema>
 export type OrganizationModelStatusEntry = z.infer<typeof StatusEntrySchema>
 export type OrganizationModelStatusSemanticClass = z.infer<typeof StatusSemanticClassSchema>
-export type OrganizationModelOperations = z.infer<typeof OperationsDomainSchema>
-export type OrganizationModelOperationEntry = z.infer<typeof OperationEntrySchema>
-export type OrganizationModelOperationSemanticClass = z.infer<typeof OperationSemanticClassSchema>
 export type OrganizationModelCustomers = z.infer<typeof CustomersDomainSchema>
 export type OrganizationModelCustomerSegment = z.infer<typeof CustomerSegmentSchema>
 export type OrganizationModelCustomerFirmographics = z.infer<typeof FirmographicsSchema>
@@ -84,22 +135,52 @@ export type OrganizationModelKeyResult = z.infer<typeof KeyResultSchema>
 export type OrganizationModelSystems = z.infer<typeof SystemsDomainSchema>
 export type OrganizationModelSystemEntry = z.infer<typeof SystemEntrySchema>
 export type OrganizationModelSystemId = z.infer<typeof SystemIdSchema>
+export type OrganizationModelSystemPath = z.infer<typeof SystemPathSchema>
 export type OrganizationModelSystemKind = z.infer<typeof SystemKindSchema>
+export type OrganizationModelSystemLifecycle = z.infer<typeof SystemLifecycleSchema>
+/** @deprecated Use OrganizationModelSystemLifecycle. Accepted for one publish cycle. */
 export type OrganizationModelSystemStatus = z.infer<typeof SystemStatusSchema>
 export type OrganizationModelResources = z.infer<typeof ResourcesDomainSchema>
 export type OrganizationModelResourceEntry = z.infer<typeof ResourceEntrySchema>
 export type OrganizationModelResourceId = z.infer<typeof ResourceIdSchema>
+export type EventId = z.infer<typeof EventIdSchema>
+export type EventEmissionDescriptor = z.infer<typeof EventEmissionDescriptorSchema>
+export type EventDescriptor = z.infer<typeof EventDescriptorSchema>
 export type OrganizationModelResourceKind = z.infer<typeof ResourceKindSchema>
 export type OrganizationModelResourceGovernanceStatus = z.infer<typeof ResourceGovernanceStatusSchema>
 export type OrganizationModelAgentKind = z.infer<typeof AgentKindSchema>
+export type OrganizationModelScriptResourceLanguage = z.infer<typeof ScriptResourceLanguageSchema>
+export type OrganizationModelScriptResourceSource = z.infer<typeof ScriptResourceSourceSchema>
 export type OrganizationModelWorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
 export type OrganizationModelAgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>
 export type OrganizationModelIntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
+export type OrganizationModelScriptResourceEntry = z.infer<typeof ScriptResourceEntrySchema>
+export type OrganizationModelActions = z.infer<typeof ActionsDomainSchema>
+export type OrganizationModelAction = z.infer<typeof ActionSchema>
+export type OrganizationModelActionId = z.infer<typeof ActionIdSchema>
+export type OrganizationModelActionScope = z.infer<typeof ActionScopeSchema>
+export type OrganizationModelActionRef = z.infer<typeof ActionRefSchema>
+export type OrganizationModelActionInvocationKind = z.infer<typeof ActionInvocationKindSchema>
+export type OrganizationModelActionInvocation = z.infer<typeof ActionInvocationSchema>
+export type EntityId = z.infer<typeof EntityIdSchema>
+export type EntityLink = z.infer<typeof EntityLinkSchema>
+export type Entity = z.infer<typeof EntitySchema>
+export type OrganizationModelEntity = z.infer<typeof EntitySchema>
+export type OrganizationModelEntities = z.infer<typeof EntitiesDomainSchema>
+export type OrganizationModelPolicies = z.infer<typeof PoliciesDomainSchema>
+export type OrganizationModelPolicy = z.infer<typeof PolicySchema>
+export type OrganizationModelPolicyId = z.infer<typeof PolicyIdSchema>
+export type OrganizationModelPolicyApplicability = z.infer<typeof PolicyApplicabilitySchema>
+export type OrganizationModelPolicyTrigger = z.infer<typeof PolicyTriggerSchema>
+export type OrganizationModelPolicyPredicate = z.infer<typeof PolicyPredicateSchema>
+export type OrganizationModelPolicyEffect = z.infer<typeof PolicyEffectSchema>
 export type OrganizationModelKnowledge = z.infer<typeof KnowledgeDomainSchema>
 export type OrgKnowledgeNode = z.infer<typeof OrgKnowledgeNodeSchema>
+export type OrgKnowledgeNodeInput = z.input<typeof OrgKnowledgeNodeSchema>
 export type OrgKnowledgeKind = z.infer<typeof OrgKnowledgeKindSchema>
-export type KnowledgeSkillBinding = z.infer<typeof KnowledgeSkillBindingSchema>
-export type KnowledgeDomainBinding = z.infer<typeof KnowledgeDomainBindingSchema>
+export type KnowledgeTargetKind = z.infer<typeof KnowledgeTargetKindSchema>
+export type KnowledgeTargetRef = z.infer<typeof KnowledgeTargetRefSchema>
+export type KnowledgeLink = z.infer<typeof KnowledgeLinkSchema>
 export type OrganizationModelIconToken = z.infer<typeof OrganizationModelIconTokenSchema>
 export type OrganizationModelBuiltinIconToken = z.infer<typeof OrganizationModelBuiltinIconTokenSchema>
 

package/src/platform/constants/versions.ts

@@ -1,3 +1,3 @@
 export const VERSION = {
-  CURRENT: '1.8.7'
+  CURRENT: '1.8.8'
 }

package/src/platform/registry/__tests__/command-view.test.ts

@@ -36,13 +36,12 @@ const mockAgent: CommandViewAgent = {
   type: 'agent',
   status: 'dev',
   modelProvider: 'anthropic',
-  modelId: 'claude-sonnet-4-20250514',
+  modelId: 'claude-sonnet-4-20250514',
   toolCount: 5,
   hasKnowledgeMap: true,
   hasMemory: false,
-  links: [{ nodeId: 'feature:sales.crm', kind: 'operates-on' }],
   category: 'production'
-}
+}
 
 const mockWorkflow: CommandViewWorkflow = {
   resourceId: 'test-workflow-456',
@@ -50,11 +49,10 @@ const mockWorkflow: CommandViewWorkflow = {
   description: 'A test workflow for unit testing',
   version: '2.1.0',
   type: 'workflow',
-  status: 'prod',
-  stepCount: 3,
-  entryPoint: 'start',
-  links: [{ nodeId: 'feature:monitoring.submitted-requests', kind: 'operates-on' }]
-}
+  status: 'prod',
+  stepCount: 3,
+  entryPoint: 'start'
+}
 
 const mockTrigger: TriggerDefinition = {
   resourceId: 'test-trigger-789',

package/src/platform/registry/__tests__/resource-link.test.ts

@@ -4,27 +4,32 @@ import type { OrganizationGraph } from '../../../organization-model/graph/types'
 
 describe('resource-link', () => {
   it('parses resource links and categories', () => {
-    expect(ResourceLinkSchema.parse({ nodeId: 'feature:sales.crm', kind: 'operates-on' })).toEqual({
-      nodeId: 'feature:sales.crm',
-      kind: 'operates-on'
+    expect(ResourceLinkSchema.parse({ nodeId: 'system:sales.crm', kind: 'references' })).toEqual({
+      nodeId: 'system:sales.crm',
+      kind: 'references'
     })
     expect(ResourceCategorySchema.parse('diagnostic')).toBe('diagnostic')
   })
 
   it('rejects node ids without a kind prefix', () => {
-    expect(() => ResourceLinkSchema.parse({ nodeId: 'sales.crm', kind: 'operates-on' })).toThrow()
+    expect(() => ResourceLinkSchema.parse({ nodeId: 'sales.crm', kind: 'references' })).toThrow()
+  })
+
+  it('rejects retired ad hoc resource-operation links', () => {
+    const retiredKind = ['operates', 'on'].join('-')
+    expect(() => ResourceLinkSchema.parse({ nodeId: 'system:sales.crm', kind: retiredKind })).toThrow()
   })
 
   it('builds and validates graph node ids', () => {
     const graph: OrganizationGraph = {
       version: 1,
       organizationModelVersion: 1,
-      nodes: [{ id: 'feature:sales.crm', kind: 'feature', label: 'CRM', sourceId: 'sales.crm' }],
+      nodes: [{ id: 'system:sales.crm', kind: 'system', label: 'CRM', sourceId: 'sales.crm' }],
       edges: []
     }
 
-    expect(kindPrefix('feature', 'sales.crm')).toBe('feature:sales.crm')
-    expect(() => validateNodeId('feature:sales.crm', graph)).not.toThrow()
-    expect(() => validateNodeId('feature:missing', graph)).toThrow(/Unknown organization graph node/)
+    expect(kindPrefix('system', 'sales.crm')).toBe('system:sales.crm')
+    expect(() => validateNodeId('system:sales.crm', graph)).not.toThrow()
+    expect(() => validateNodeId('system:missing', graph)).toThrow(/Unknown organization graph node/)
   })
 })