helixevo 0.4.1 → 0.6.0

package/dashboard/lib/data.ts

@@ -16,6 +16,20 @@ function readJsonl<T>(filename: string): T[] {
   return readFileSync(path, 'utf-8').trim().split('\n').filter(Boolean).map(l => JSON.parse(l))
 }
 
+function readOntologyJson<T>(filename: string, fallback: T): T {
+  const path = join(SG_DIR, 'ontology', filename)
+  if (!existsSync(path)) return fallback
+  return JSON.parse(readFileSync(path, 'utf-8'))
+}
+
+function readOntologyJsonl<T>(filename: string): T[] {
+  const path = join(SG_DIR, 'ontology', filename)
+  if (!existsSync(path)) return []
+  const raw = readFileSync(path, 'utf-8').trim()
+  if (!raw) return []
+  return raw.split('\n').filter(Boolean).map((l) => JSON.parse(l))
+}
+
 // ─── Types ──────────────────────────────────────────────────────
 
 export type CognitiveRole = 'generalist' | 'specialist' | 'hybrid'
@@ -78,7 +92,7 @@ export interface CanaryEntry {
   skillSlug: string; version: string; deployedAt: string; expiresAt: string
 }
 
-export type ArtifactProvenance = 'native-evolution' | 'native-topology' | 'derived-history'
+export type ArtifactProvenance = 'native-evolution' | 'native-topology' | 'native-ontology' | 'derived-history'
 export type ActivationProvenance = 'capture-derived' | 'project-analysis' | 'derived-failure'
 export type PressureProvenance = 'failure-native' | 'project-analysis-native' | 'failure-derived' | 'profile-gap-derived'
 
@@ -174,6 +188,8 @@ export interface PressureRouteRecommendation {
   governanceMode: GovernanceModeName
   triggeredBy: PressureRouteTrigger
   reasons: string[]
+  semanticInfluence?: OntologySemanticInfluence
+  semanticConceptIds?: string[]
 }
 
 export interface PressureIntervention {
@@ -296,6 +312,8 @@ export interface TopologyReviewDecision {
 export interface ResolvedTopologyReviewCandidate extends TopologyReviewCandidate {
   status: TopologyReviewStatus
   latestDecision?: TopologyReviewDecision
+  semanticBindings?: ResolvedOntologyBinding[]
+  semanticConceptIds?: string[]
   lastActivityAt: string
 }
 
@@ -387,6 +405,8 @@ export interface ResolvedPressureSignal extends PressureSignal {
   interventionTypes: PressureInterventionType[]
   motifIds?: string[]
   routeRecommendation?: PressureRouteRecommendation
+  semanticBindings?: ResolvedOntologyBinding[]
+  semanticConceptIds?: string[]
   lastActivityAt: string
   addressedAt?: string
   responseSummary: string
@@ -395,6 +415,8 @@ export interface ResolvedPressureSignal extends PressureSignal {
 export interface ResolvedPressureMotif extends PressureMotif {
   lifecycle: PressureLifecycleState
   interventionTypes: PressureInterventionType[]
+  semanticBindings?: ResolvedOntologyBinding[]
+  semanticConceptIds?: string[]
   lastActivityAt: string
   addressedAt?: string
   responseSummary: string
@@ -418,6 +440,11 @@ export interface ProjectResponseSummary extends ProjectPressureSummary {
   recentInterventionTypes: PressureInterventionType[]
 }
 
+export interface ResolvedTransferEvent extends TransferEvent {
+  semanticBindings?: ResolvedOntologyBinding[]
+  semanticConceptIds?: string[]
+}
+
 export interface CoEvolutionDashboardSummary {
   pressureSignals: {
     total: number
@@ -480,7 +507,7 @@ export interface CoEvolutionDashboardSummary {
   promoteQueue: ResolvedPressureMotif[]
   recentAddressed: ResolvedPressureSignal[]
   recentInterventions: PressureIntervention[]
-  recentTransfers: TransferEvent[]
+  recentTransfers: ResolvedTransferEvent[]
   topologyBacklog: ResolvedTopologyReviewCandidate[]
   recentTopologyDecisions: ResolvedTopologyReviewCandidate[]
 }
@@ -497,9 +524,128 @@ export interface TopologyDashboardSummary {
   candidates: ResolvedTopologyReviewCandidate[]
 }
 
+export type OntologyConceptKind = 'entity' | 'relation-subtype' | 'capability' | 'pressure-type' | 'topology-motif' | 'health-signal' | 'governance-pattern'
+export type OntologyLayer = 'kernel' | 'extension' | 'frontier'
+export type OntologyReviewDecisionStatus = 'promote' | 'reject' | 'defer'
+export type OntologyReviewStatus = 'open' | 'promoted' | 'rejected' | 'deferred'
+export type OntologyBindingTargetType = 'pressure-signal' | 'pressure-motif' | 'route-recommendation' | 'transfer-event' | 'topology-review'
+export type OntologyBindingSourceKind = 'capability-match' | 'pressure-region' | 'motif-match' | 'transfer-motif' | 'topology-descriptor'
+export type OntologySemanticInfluence = 'none' | 'explanatory' | 'weighted'
+
+export interface OntologyKernelSnapshot {
+  version: string
+  updatedAt: string
+  pillars: string[]
+  layers: string[]
+  entityNames: string[]
+  relationFamilies: string[]
+  mutationOperations: string[]
+  invariantIds: string[]
+}
+
+export interface OntologyConcept {
+  id: string
+  name: string
+  conceptKind: OntologyConceptKind
+  layer: OntologyLayer
+  status: 'active' | 'provisional' | 'deprecated'
+  createdAt: string
+  parentConceptId?: string
+  description?: string
+  aliases?: string[]
+  promotionCriteria?: string[]
+  migrationMap?: Record<string, string>
+  reviewKey?: string
+  lastObservedAt?: string
+  sourceSummary?: string
+  projectIds?: string[]
+  evidenceIds?: string[]
+  observationCount?: number
+  confidence?: number
+  relatedSignalIds?: string[]
+  relatedMotifIds?: string[]
+  relatedReviewIds?: string[]
+  relatedTransferEventIds?: string[]
+  derivedFromKinds?: string[]
+}
+
+export interface OntologyReviewDecision {
+  id: string
+  conceptId: string
+  decision: OntologyReviewDecisionStatus
+  decidedAt: string
+  governanceMode: GovernanceModeName
+  rationale: string
+  decidedBy?: 'operator' | 'system'
+}
+
+export interface ResolvedOntologyConcept extends OntologyConcept {
+  reviewStatus: OntologyReviewStatus
+  latestReview?: OntologyReviewDecision
+  lastActivityAt: string
+}
+
+export interface ResolvedOntologyBinding {
+  id: string
+  conceptId: string
+  conceptName: string
+  conceptKind: OntologyConceptKind
+  targetType: OntologyBindingTargetType
+  targetId: string
+  sourceKind: OntologyBindingSourceKind
+  confidence: number
+  reasons: string[]
+  effectSummary?: string
+}
+
+export interface OntologyConsumerSummary {
+  conceptId: string
+  conceptName: string
+  conceptKind: OntologyConceptKind
+  status: OntologyConcept['status']
+  totalBindings: number
+  bindingsByTargetType: Partial<Record<OntologyBindingTargetType, number>>
+  activeTargetIds: string[]
+  lastActivityAt?: string
+  warning?: string
+}
+
+export interface ResolvedOntologyExtension extends OntologyConcept {
+  semanticBindings: ResolvedOntologyBinding[]
+  adoptionCount: number
+  bindingsByTargetType: Partial<Record<OntologyBindingTargetType, number>>
+  lastActivityAt: string
+  warning?: string
+}
+
+export interface OntologyAdoptionSummary {
+  activeConcepts: number
+  unusedExtensions: number
+  totalBindings: number
+  routesInfluenced: number
+  conceptsWithConsumers: number
+  conceptsAtDeprecationRisk: number
+  bindingsByTargetType: Partial<Record<OntologyBindingTargetType, number>>
+  usageByConceptKind: Partial<Record<OntologyConceptKind, number>>
+  topActiveConcepts: OntologyConsumerSummary[]
+  atRiskConcepts: OntologyConsumerSummary[]
+}
+
+export interface OntologyChangeEvent {
+  id: string
+  timestamp: string
+  changeType: 'concept-hypothesized' | 'concept-promoted' | 'concept-rejected' | 'concept-split' | 'concept-merged' | 'concept-deprecated' | 'relation-refined' | 'mapping-migrated' | 'invariant-added' | 'invariant-relaxed'
+  conceptIds: string[]
+  reason: string
+  evidenceIds?: string[]
+  proposalId?: string
+  approvedBy?: string
+  ontologyVersion?: string
+}
+
 export interface OntologyDashboardSummary {
   specVersion: string
-  source: 'graph' | 'compat-derived'
+  source: 'graph' | 'compat-derived' | 'hybrid-native-derived'
   skillRoles: Record<CognitiveRole, number>
   stabilityStates: Record<StabilityState, number>
   plasticityStates: Record<PlasticityState, number>
@@ -551,6 +697,27 @@ export interface OntologyDashboardSummary {
     candidate: number
     rejected: number
   }
+  ontologyLoop: {
+    kernelConcepts: number
+    extensions: number
+    frontier: number
+    reviewOpen: number
+    promoted: number
+    rejected: number
+    deferred: number
+    deprecated: number
+    changeEvents: number
+    byConceptKind: Partial<Record<OntologyConceptKind, number>>
+    adoption: {
+      activeConcepts: number
+      unusedExtensions: number
+      totalBindings: number
+      routesInfluenced: number
+      conceptsAtDeprecationRisk: number
+      bindingsByTargetType: Partial<Record<OntologyBindingTargetType, number>>
+      usageByConceptKind: Partial<Record<OntologyConceptKind, number>>
+    }
+  }
   governance: {
     activeMode: GovernanceModeName
     derivedMode: GovernanceModeName
@@ -590,12 +757,30 @@ export interface OntologyDashboardSummary {
   }
 }
 
+export interface OntologyControlDashboardSummary {
+  governance: ActiveGovernanceSummary
+  kernel: OntologyKernelSnapshot
+  summary: OntologyDashboardSummary['ontologyLoop']
+  adoption: OntologyAdoptionSummary
+  frontier: ResolvedOntologyConcept[]
+  extensions: ResolvedOntologyExtension[]
+  recentChanges: OntologyChangeEvent[]
+}
+
 const DASHBOARD_ONTOLOGY_SPEC_VERSION = '0.1.0'
 
 function emptyCounts<T extends string>(values: readonly T[]): Record<T, number> {
   return Object.fromEntries(values.map((value) => [value, 0])) as Record<T, number>
 }
 
+function uniqueStrings(values: Array<string | undefined | null>): string[] {
+  return [...new Set(values.filter((value): value is string => Boolean(value && value.trim())))]
+}
+
+function slugFragment(value: string): string {
+  return value.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-').slice(0, 80)
+}
+
 function inferCognitiveRole(node: SkillNode): CognitiveRole {
   if (node.cognitiveRole) return node.cognitiveRole
   if (node.layer === 'project' || Boolean(node.project)) return 'specialist'
@@ -679,6 +864,211 @@ export function loadCanaries(): { entries: CanaryEntry[] } {
   return readJson<{ entries: CanaryEntry[] }>('canary-registry.json', { entries: [] })
 }
 
+export function loadOntologyKernelSnapshot(): OntologyKernelSnapshot {
+  return readOntologyJson<OntologyKernelSnapshot>('kernel.json', {
+    version: DASHBOARD_ONTOLOGY_SPEC_VERSION,
+    updatedAt: '',
+    pillars: [
+      'Operational World',
+      'Perception / Pressure',
+      'Working Memory / Activation',
+      'Long-Term Memory',
+      'Plasticity / Topology',
+      'Evidence / Immune System',
+      'Executive / Governance',
+      'Metacognition / Health',
+      'Time / Lineage',
+    ],
+    layers: ['kernel', 'extension', 'frontier'],
+    entityNames: [
+      'ProjectRecord',
+      'SessionRecord',
+      'TaskRecord',
+      'FailureRecord',
+      'PressureSignal',
+      'Capability',
+      'SkillNode',
+      'SkillRelation',
+      'ActivationEvent',
+      'MutationProposal',
+      'TopologyChange',
+      'EvidenceArtifact',
+      'EvaluationResult',
+      'TransferEvent',
+      'GovernanceMode',
+      'HealthMetric',
+      'LineageRecord',
+      'OntologyConcept',
+      'OntologyChangeEvent',
+    ],
+    relationFamilies: [
+      'belongs_to',
+      'derived_from',
+      'replaced_by',
+      'parent_of',
+      'child_of',
+      'specializes',
+      'generalizes_from',
+      'depends_on',
+      'enhances',
+      'conflicts_with',
+      'co_evolves_with',
+      'covers',
+      'activated_for',
+      'suppressed_by',
+      'contributed_to',
+      'competed_with',
+      'triggered_by',
+      'validated_by',
+      'contradicted_by',
+      'survived_in',
+      'requires_review',
+      'proposed_due_to',
+      'benefits',
+      'transferred_to',
+      'refined_by',
+      'promoted_from',
+      'executed_under',
+      'deferred_by',
+      'prioritized_by',
+      'locked_by',
+      'measures',
+      'signals_weakness_in',
+      'suggests_repair_for',
+    ],
+    mutationOperations: [
+      'create_skill',
+      'edit_skill',
+      'specialize_skill',
+      'generalize_skill',
+      'promote_skill',
+      'demote_skill',
+      'retire_skill',
+      'merge_skills',
+      'split_skill',
+      'rewire_relation',
+      'prune_branch',
+      'consolidate_cluster',
+    ],
+    invariantIds: [
+      'accepted-change-requires-evidence',
+      'specialist-requires-local-context',
+      'promotion-requires-repeated-evidence',
+      'relation-requires-family-and-confidence',
+      'topology-change-preserves-lineage',
+      'deprecated-state-remains-recoverable',
+      'ontology-promotion-requires-migration',
+      'frontier-concepts-stay-provisional',
+      'transfer-requires-source-and-target',
+      'high-risk-topology-change-requires-validation',
+    ],
+  })
+}
+
+export function loadOntologyExtensions(): OntologyConcept[] {
+  return readOntologyJson<OntologyConcept[]>('extensions.json', [])
+    .slice()
+    .sort((a, b) => (b.lastObservedAt ?? b.createdAt).localeCompare(a.lastObservedAt ?? a.createdAt) || a.name.localeCompare(b.name))
+}
+
+export function loadOntologyFrontier(): OntologyConcept[] {
+  return readOntologyJson<OntologyConcept[]>('frontier.json', [])
+    .slice()
+    .sort((a, b) => (b.lastObservedAt ?? b.createdAt).localeCompare(a.lastObservedAt ?? a.createdAt) || a.name.localeCompare(b.name))
+}
+
+export function loadOntologyReviewDecisions(): OntologyReviewDecision[] {
+  return readOntologyJsonl<OntologyReviewDecision>('reviews.jsonl')
+    .slice()
+    .sort((a, b) => b.decidedAt.localeCompare(a.decidedAt))
+}
+
+export function loadOntologyChangeEvents(): OntologyChangeEvent[] {
+  return readOntologyJsonl<OntologyChangeEvent>('change-log.jsonl')
+    .slice()
+    .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+}
+
+function ontologyStatusRank(status: OntologyReviewStatus): number {
+  return status === 'open' ? 4 : status === 'deferred' ? 3 : status === 'rejected' ? 2 : 1
+}
+
+export function loadResolvedOntologyFrontierConcepts(): ResolvedOntologyConcept[] {
+  const concepts = loadOntologyFrontier()
+  const latestByConcept = new Map<string, OntologyReviewDecision>()
+  for (const decision of loadOntologyReviewDecisions()) {
+    const existing = latestByConcept.get(decision.conceptId)
+    if (!existing || decision.decidedAt > existing.decidedAt) latestByConcept.set(decision.conceptId, decision)
+  }
+  return concepts
+    .map((concept) => {
+      const latestReview = latestByConcept.get(concept.id)
+      const reviewStatus: OntologyReviewStatus = latestReview?.decision === 'promote'
+        ? 'promoted'
+        : latestReview?.decision === 'reject'
+          ? 'rejected'
+          : latestReview?.decision === 'defer'
+            ? 'deferred'
+            : 'open'
+      return {
+        ...concept,
+        reviewStatus,
+        latestReview,
+        lastActivityAt: maxTimestamp(concept.lastObservedAt, latestReview?.decidedAt, concept.createdAt),
+      }
+    })
+    .sort((a, b) => ontologyStatusRank(b.reviewStatus) - ontologyStatusRank(a.reviewStatus)
+      || (b.confidence ?? 0) - (a.confidence ?? 0)
+      || (b.observationCount ?? 0) - (a.observationCount ?? 0)
+      || b.lastActivityAt.localeCompare(a.lastActivityAt)
+      || a.name.localeCompare(b.name))
+}
+
+function ontologyKindCounts(): Partial<Record<OntologyConceptKind, number>> {
+  return {}
+}
+
+export function getOntologyReviewSummary() {
+  const kernel = loadOntologyKernelSnapshot()
+  const frontier = loadResolvedOntologyFrontierConcepts()
+  const extensions = loadOntologyExtensions()
+  const resolvedExtensions = loadResolvedOntologyExtensions()
+  const changes = loadOntologyChangeEvents()
+  const adoption = getOntologyAdoptionSummary()
+  const byConceptKind = ontologyKindCounts()
+  for (const concept of [...frontier, ...extensions]) {
+    byConceptKind[concept.conceptKind] = (byConceptKind[concept.conceptKind] ?? 0) + 1
+  }
+  return {
+    kernelConcepts: kernel.entityNames.length,
+    extensions: extensions.length,
+    frontier: frontier.length,
+    reviewOpen: frontier.filter((concept) => concept.reviewStatus === 'open').length,
+    promoted: extensions.filter((concept) => concept.status === 'active').length,
+    rejected: frontier.filter((concept) => concept.reviewStatus === 'rejected').length,
+    deferred: frontier.filter((concept) => concept.reviewStatus === 'deferred').length,
+    deprecated: extensions.filter((concept) => concept.status === 'deprecated').length,
+    changeEvents: changes.length,
+    byConceptKind,
+    adoption,
+    backlog: frontier.filter((concept) => concept.reviewStatus === 'open' || concept.reviewStatus === 'deferred').slice(0, 10),
+    recentChanges: changes.slice(0, 10),
+    recentExtensions: resolvedExtensions.slice(0, 8),
+  }
+}
+
+export function loadOntologyControlSummary(): OntologyControlDashboardSummary {
+  return {
+    governance: getActiveGovernanceSummary(),
+    kernel: loadOntologyKernelSnapshot(),
+    summary: getOntologyReviewSummary(),
+    adoption: getOntologyAdoptionSummary(),
+    frontier: loadResolvedOntologyFrontierConcepts(),
+    extensions: loadResolvedOntologyExtensions(),
+    recentChanges: loadOntologyChangeEvents().slice(0, 10),
+  }
+}
+
 export function loadSkillContent(slug: string): string {
   const path = join(SG_DIR, 'general', slug, 'SKILL.md')
   if (!existsSync(path)) return ''
@@ -827,9 +1217,18 @@ export function loadPressureInterventions(): PressureIntervention[] {
     .sort((a, b) => (b.completedAt ?? b.createdAt).localeCompare(a.completedAt ?? a.createdAt))
 }
 
-export function loadTransferEvents(): TransferEvent[] {
+export function loadTransferEvents(): ResolvedTransferEvent[] {
+  const concepts = activeOntologyExtensions()
   return readJsonl<TransferEvent>('transfer-events.jsonl')
     .slice()
+    .map((event) => {
+      const semanticBindings = matchTransferOntologyBindings(event, concepts)
+      return {
+        ...event,
+        semanticBindings,
+        semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
+      } satisfies ResolvedTransferEvent
+    })
     .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
 }
 
@@ -887,6 +1286,7 @@ export function loadTopologyReviewDecisions(): TopologyReviewDecision[] {
 
 export function loadResolvedTopologyReviewCandidates(): ResolvedTopologyReviewCandidate[] {
   const candidates = loadStoredTopologyReviewCandidates()
+  const concepts = activeOntologyExtensions()
   const latestDecisionByCandidate = new Map<string, TopologyReviewDecision>()
   for (const decision of loadTopologyReviewDecisions()) {
     const existing = latestDecisionByCandidate.get(decision.candidateId)
@@ -896,10 +1296,18 @@ export function loadResolvedTopologyReviewCandidates(): ResolvedTopologyReviewCa
     .map((candidate) => {
       const latestDecision = latestDecisionByCandidate.get(candidate.id)
       const status: TopologyReviewStatus = latestDecision?.decision ?? 'open'
+      const semanticBindings = matchTopologyOntologyBindings({
+        ...candidate,
+        status,
+        latestDecision,
+        lastActivityAt: maxTimestamp(candidate.lastObservedAt, latestDecision?.decidedAt),
+      }, concepts)
       return {
         ...candidate,
         status,
         latestDecision,
+        semanticBindings,
+        semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
         lastActivityAt: maxTimestamp(candidate.lastObservedAt, latestDecision?.decidedAt),
       } satisfies ResolvedTopologyReviewCandidate
     })
@@ -1165,22 +1573,356 @@ export function getActiveGovernanceSummary(): ActiveGovernanceSummary {
   return deriveGovernanceSummary()
 }
 
+function emptyOntologyBindingCounts(): Partial<Record<OntologyBindingTargetType, number>> {
+  return {}
+}
+
+function ontologyReviewKeyBody(reviewKey?: string): string {
+  return normalizePressureValue((reviewKey ?? '').split(':').slice(1).join('-'))
+}
+
+function ontologyMotifTerm(motifId: string): string {
+  return normalizePressureValue(motifId.replace(/^motif_/, ''))
+}
+
+function ontologyConceptTerms(concept: OntologyConcept): string[] {
+  return uniqueStrings([
+    normalizePressureValue(concept.name),
+    ...((concept.aliases ?? []).map((alias) => normalizePressureValue(alias))),
+    normalizePressureValue(concept.reviewKey),
+    ontologyReviewKeyBody(concept.reviewKey),
+    ...((concept.relatedMotifIds ?? []).map((id) => ontologyMotifTerm(id))),
+    ...((concept.derivedFromKinds ?? []).map((value) => normalizePressureValue(value))),
+  ].filter(Boolean))
+}
+
+function ontologyBindingId(conceptId: string, targetType: OntologyBindingTargetType, targetId: string, sourceKind: OntologyBindingSourceKind): string {
+  return `ontology_binding_${slugFragment(conceptId)}_${targetType}_${slugFragment(targetId)}_${sourceKind}`
+}
+
+function buildOntologyBinding(params: {
+  concept: OntologyConcept
+  targetType: OntologyBindingTargetType
+  targetId: string
+  sourceKind: OntologyBindingSourceKind
+  confidence: number
+  reasons: string[]
+  effectSummary?: string
+}): ResolvedOntologyBinding {
+  return {
+    id: ontologyBindingId(params.concept.id, params.targetType, params.targetId, params.sourceKind),
+    conceptId: params.concept.id,
+    conceptName: params.concept.name,
+    conceptKind: params.concept.conceptKind,
+    targetType: params.targetType,
+    targetId: params.targetId,
+    sourceKind: params.sourceKind,
+    confidence: Math.min(0.95, Math.max(0.5, params.confidence)),
+    reasons: params.reasons,
+    effectSummary: params.effectSummary,
+  }
+}
+
+function dedupeOntologyBindings(bindings: ResolvedOntologyBinding[]): ResolvedOntologyBinding[] {
+  const byKey = new Map<string, ResolvedOntologyBinding>()
+  for (const binding of bindings) {
+    const key = `${binding.conceptId}::${binding.targetType}::${binding.targetId}`
+    const existing = byKey.get(key)
+    if (!existing || binding.confidence > existing.confidence) byKey.set(key, binding)
+  }
+  return [...byKey.values()]
+    .sort((a, b) => b.confidence - a.confidence || a.conceptName.localeCompare(b.conceptName))
+    .slice(0, 4)
+}
+
+function activeOntologyExtensions(): OntologyConcept[] {
+  return loadOntologyExtensions().filter((concept) => concept.status === 'active')
+}
+
+function matchSignalOntologyBindings(signal: PressureSignal, motifIds: string[], concepts: OntologyConcept[]): ResolvedOntologyBinding[] {
+  const capability = normalizePressureValue(signal.capability)
+  const region = normalizePressureValue(signal.region)
+  const kind = normalizePressureValue(signal.kind)
+  const motifTerms = uniqueStrings(motifIds.map((id) => ontologyMotifTerm(id)).filter(Boolean))
+  const bindings: ResolvedOntologyBinding[] = []
+
+  for (const concept of concepts) {
+    const terms = ontologyConceptTerms(concept)
+    if (concept.conceptKind === 'capability') {
+      if (capability && terms.includes(capability)) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'pressure-signal',
+          targetId: signal.id,
+          sourceKind: 'capability-match',
+          confidence: 0.86,
+          reasons: [`Signal capability ${signal.capability} matches approved capability concept ${concept.name}.`],
+          effectSummary: 'Sharpens project or capability interpretation for this pressure signal.',
+        }))
+        continue
+      }
+      if (region && terms.includes(region)) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'pressure-signal',
+          targetId: signal.id,
+          sourceKind: 'pressure-region',
+          confidence: 0.74,
+          reasons: [`Signal region ${signal.region} aligns with approved capability concept ${concept.name}.`],
+          effectSummary: 'Adds semantic coverage to a recurring pressure region.',
+        }))
+      }
+      continue
+    }
+
+    if (concept.conceptKind === 'pressure-type') {
+      if ((concept.relatedMotifIds ?? []).some((id) => motifIds.includes(id))) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'pressure-signal',
+          targetId: signal.id,
+          sourceKind: 'motif-match',
+          confidence: 0.9,
+          reasons: [`Signal participates in approved motif family ${concept.name}.`],
+          effectSummary: 'Marks this signal as part of an approved recurring pressure family.',
+        }))
+        continue
+      }
+      if (motifTerms.some((term) => terms.includes(term))) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'pressure-signal',
+          targetId: signal.id,
+          sourceKind: 'motif-match',
+          confidence: 0.84,
+          reasons: [`Signal motif region aligns with approved pressure family ${concept.name}.`],
+          effectSummary: 'Carries an approved recurring pressure family into live signal interpretation.',
+        }))
+        continue
+      }
+      if (kind && terms.includes(kind)) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'pressure-signal',
+          targetId: signal.id,
+          sourceKind: 'pressure-region',
+          confidence: 0.78,
+          reasons: [`Signal kind ${signal.kind} matches approved pressure family ${concept.name}.`],
+          effectSummary: 'Adds semantic identity to recurring pressure of the same kind.',
+        }))
+      }
+    }
+  }
+
+  return dedupeOntologyBindings(bindings)
+}
+
+function matchMotifOntologyBindings(motif: Pick<ResolvedPressureMotif, 'id' | 'key' | 'kind' | 'capability'>, concepts: OntologyConcept[]): ResolvedOntologyBinding[] {
+  const capability = normalizePressureValue(motif.capability)
+  const key = normalizePressureValue(motif.key)
+  const kind = normalizePressureValue(motif.kind)
+  const bindings: ResolvedOntologyBinding[] = []
+
+  for (const concept of concepts) {
+    const terms = ontologyConceptTerms(concept)
+    if (concept.conceptKind === 'capability' && capability && terms.includes(capability)) {
+      bindings.push(buildOntologyBinding({
+        concept,
+        targetType: 'pressure-motif',
+        targetId: motif.id,
+        sourceKind: 'capability-match',
+        confidence: 0.84,
+        reasons: [`Motif capability ${motif.capability} matches approved capability concept ${concept.name}.`],
+        effectSummary: 'Makes recurring capability pressure visible as semantic adoption.',
+      }))
+      continue
+    }
+    if (concept.conceptKind === 'pressure-type') {
+      if ((concept.relatedMotifIds ?? []).includes(motif.id)) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'pressure-motif',
+          targetId: motif.id,
+          sourceKind: 'motif-match',
+          confidence: 0.92,
+          reasons: [`Motif ${motif.key} directly matches approved pressure family ${concept.name}.`],
+          effectSummary: 'Confirms this recurring motif is an approved semantic family.',
+        }))
+        continue
+      }
+      if ([key, kind].filter(Boolean).some((value) => terms.includes(value))) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'pressure-motif',
+          targetId: motif.id,
+          sourceKind: 'pressure-region',
+          confidence: 0.86,
+          reasons: [`Motif identity aligns with approved pressure family ${concept.name}.`],
+          effectSummary: 'Carries approved semantic family identity into motif-level routing.',
+        }))
+      }
+    }
+  }
+
+  return dedupeOntologyBindings(bindings)
+}
+
+function matchTransferOntologyBindings(event: TransferEvent, concepts: OntologyConcept[]): ResolvedOntologyBinding[] {
+  const capabilityTerms = uniqueStrings((event.capabilityIds ?? []).map((value) => normalizePressureValue(value)).filter(Boolean))
+  const motifTerms = uniqueStrings((event.motifIds ?? []).map((value) => ontologyMotifTerm(value)).filter(Boolean))
+  const bindings: ResolvedOntologyBinding[] = []
+
+  for (const concept of concepts) {
+    const terms = ontologyConceptTerms(concept)
+    if (concept.conceptKind === 'capability' && capabilityTerms.some((value) => terms.includes(value))) {
+      bindings.push(buildOntologyBinding({
+        concept,
+        targetType: 'transfer-event',
+        targetId: event.id,
+        sourceKind: 'capability-match',
+        confidence: 0.82,
+        reasons: [`Transfer capabilities align with approved concept ${concept.name}.`],
+        effectSummary: 'Shows semantic adoption through reusable transfer evidence.',
+      }))
+      continue
+    }
+    if (concept.conceptKind === 'pressure-type') {
+      if ((concept.relatedMotifIds ?? []).some((id) => (event.motifIds ?? []).includes(id))) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'transfer-event',
+          targetId: event.id,
+          sourceKind: 'transfer-motif',
+          confidence: 0.88,
+          reasons: [`Transfer realizes approved recurring family ${concept.name}.`],
+          effectSummary: 'Connects realized transfer evidence to an approved recurring pressure family.',
+        }))
+        continue
+      }
+      if (motifTerms.some((value) => terms.includes(value))) {
+        bindings.push(buildOntologyBinding({
+          concept,
+          targetType: 'transfer-event',
+          targetId: event.id,
+          sourceKind: 'transfer-motif',
+          confidence: 0.8,
+          reasons: [`Transfer motif linkage aligns with approved family ${concept.name}.`],
+          effectSummary: 'Carries approved semantic family identity into realized transfer outcomes.',
+        }))
+      }
+    }
+  }
+
+  return dedupeOntologyBindings(bindings)
+}
+
+function topologyMotifDescriptor(candidate: ResolvedTopologyReviewCandidate): string | null {
+  if (candidate.changeType === 'split' && candidate.title.startsWith('Split overloaded skill:')) return 'overloaded-skill-split-pressure'
+  if (candidate.changeType === 'rewire' && candidate.title.startsWith('Resolve conflicting pair:')) return 'conflict-rewire-pressure'
+  if (candidate.changeType === 'promote' && candidate.title.startsWith('Promote recurring motif:')) return 'motif-promotion-pressure'
+  if (candidate.changeType === 'merge' && candidate.title.startsWith('Merge overlap:')) return 'overlap-merge-pressure'
+  if (candidate.changeType === 'consolidate') return 'consolidation-pressure'
+  return null
+}
+
+function matchTopologyOntologyBindings(candidate: ResolvedTopologyReviewCandidate, concepts: OntologyConcept[]): ResolvedOntologyBinding[] {
+  const descriptor = normalizePressureValue(topologyMotifDescriptor(candidate) ?? candidate.changeType)
+  const bindings: ResolvedOntologyBinding[] = []
+
+  for (const concept of concepts) {
+    const terms = ontologyConceptTerms(concept)
+    if (concept.conceptKind === 'topology-motif' && descriptor && terms.includes(descriptor)) {
+      bindings.push(buildOntologyBinding({
+        concept,
+        targetType: 'topology-review',
+        targetId: candidate.id,
+        sourceKind: 'topology-descriptor',
+        confidence: 0.86,
+        reasons: [`Topology review descriptor ${descriptor} aligns with approved topology concept ${concept.name}.`],
+        effectSummary: 'Adds semantic identity to recurring structural review patterns.',
+      }))
+      continue
+    }
+    if (concept.conceptKind === 'pressure-type' && (concept.relatedMotifIds ?? []).some((id) => (candidate.relatedMotifIds ?? []).includes(id))) {
+      bindings.push(buildOntologyBinding({
+        concept,
+        targetType: 'topology-review',
+        targetId: candidate.id,
+        sourceKind: 'motif-match',
+        confidence: 0.72,
+        reasons: [`Topology candidate inherits recurring pressure motif semantics from approved family ${concept.name}.`],
+        effectSummary: 'Links structural review back to an approved recurring pressure family.',
+      }))
+    }
+  }
+
+  return dedupeOntologyBindings(bindings)
+}
+
+function applyOntologyInfluenceToRoute(params: {
+  recommendation: PressureRouteRecommendation
+  signal: PressureSignal
+  semanticBindings: ResolvedOntologyBinding[]
+  governanceProfile: GovernanceProfile
+}): PressureRouteRecommendation {
+  const { recommendation, signal, semanticBindings, governanceProfile } = params
+  if (semanticBindings.length === 0) return recommendation
+
+  const conceptIds = uniqueStrings(semanticBindings.map((binding) => binding.conceptId))
+  const conceptNames = uniqueStrings(semanticBindings.map((binding) => binding.conceptName))
+  const hasCapability = semanticBindings.some((binding) => binding.conceptKind === 'capability')
+  const hasPressureType = semanticBindings.some((binding) => binding.conceptKind === 'pressure-type')
+  const hasTopologyMotif = semanticBindings.some((binding) => binding.conceptKind === 'topology-motif')
+  const reasons = [...recommendation.reasons]
+  let confidence = recommendation.confidence
+  let semanticInfluence: OntologySemanticInfluence = 'explanatory'
+
+  if (recommendation.route === 'generalize' && hasPressureType && governanceProfile.riskTolerance >= 0.4 && governanceProfile.reviewThreshold <= 0.82) {
+    confidence = Math.min(0.95, confidence + 0.04)
+    semanticInfluence = 'weighted'
+    reasons.push(`Approved semantic family ${conceptNames.join(', ')} reinforces network-level reuse inside the current governance envelope.`)
+  } else if (recommendation.route === 'specialize' && hasCapability && signal.projectId && governanceProfile.reviewThreshold <= 0.86) {
+    confidence = Math.min(0.95, confidence + 0.03)
+    semanticInfluence = 'weighted'
+    reasons.push(`Approved capability concept ${conceptNames.join(', ')} sharpens project-bounded specialization without widening scope.`)
+  } else if (recommendation.route === 'evolve' && hasPressureType && signal.relatedFailureId) {
+    confidence = Math.min(0.95, confidence + 0.02)
+    semanticInfluence = 'weighted'
+    reasons.push(`Approved semantic family ${conceptNames.join(', ')} sharpens this failure-linked repair lane.`)
+  } else if (recommendation.route === 'manual-review' && (hasTopologyMotif || hasPressureType)) {
+    reasons.push(`Approved semantic family ${conceptNames.join(', ')} confirms the pattern is real, but governance still prefers explicit operator review.`)
+  } else {
+    reasons.push(`Approved semantic family ${conceptNames.join(', ')} is visible here, but current governance/evidence still keeps the route bounded to ${recommendation.route}.`)
+  }
+
+  return {
+    ...recommendation,
+    confidence,
+    reasons,
+    semanticInfluence,
+    semanticConceptIds: conceptIds,
+  }
+}
+
 function buildRouteRecommendation(params: {
   signal: PressureSignal
   relatedSignals: PressureSignal[]
   linkedInterventions: PressureIntervention[]
   governanceMode: GovernanceModeName
+  governanceProfile: GovernanceProfile
+  semanticBindings: ResolvedOntologyBinding[]
 }): PressureRouteRecommendation {
-  const { signal, relatedSignals, linkedInterventions, governanceMode } = params
+  const { signal, relatedSignals, linkedInterventions, governanceMode, governanceProfile, semanticBindings } = params
   const projectSpread = new Set(relatedSignals.map((entry) => entry.projectId ?? entry.projectPath).filter(Boolean)).size
   const recurrenceCount = relatedSignals.length
   const activeTypes = [...new Set(linkedInterventions.map((intervention) => intervention.interventionType))]
   const reasons: string[] = []
+  let recommendation: PressureRouteRecommendation
 
   if (activeTypes.length >= 3 && !linkedInterventions.some((intervention) => intervention.status === 'completed' && intervention.impact === 'resolving')) {
     reasons.push('Multiple intervention lanes already touch this pressure region without clear closure.')
     reasons.push('Operator review is safer than blindly piling on another automated response.')
-    return {
+    recommendation = {
       route: 'manual-review',
       scope: projectSpread >= 2 ? 'network' : signal.projectId ? 'project' : 'local',
       confidence: 0.58,
@@ -1188,27 +1930,21 @@ function buildRouteRecommendation(params: {
       triggeredBy: 'mixed-signal',
       reasons,
     }
-  }
-
-  if (projectSpread >= 2 && recurrenceCount >= 2) {
+  } else if (projectSpread >= 2 && recurrenceCount >= 2 && governanceMode !== 'project-critical') {
     reasons.push(`This pressure region repeats across ${projectSpread} projects.`)
     reasons.push('A network-level abstraction can absorb repeated local demand more efficiently than one-off fixes.')
-    if (governanceMode !== 'project-critical') {
-      return {
-        route: 'generalize',
-        scope: 'network',
-        confidence: Math.min(0.95, 0.7 + Math.min(0.15, (projectSpread - 1) * 0.08)),
-        governanceMode,
-        triggeredBy: 'recurring-cross-project-gap',
-        reasons,
-      }
+    recommendation = {
+      route: 'generalize',
+      scope: 'network',
+      confidence: Math.min(0.95, 0.7 + Math.min(0.15, (projectSpread - 1) * 0.08)),
+      governanceMode,
+      triggeredBy: 'recurring-cross-project-gap',
+      reasons,
     }
-  }
-
-  if (signal.projectId && signal.priority === 'high' && signal.suggestedAction === 'specialize') {
+  } else if (signal.projectId && signal.priority === 'high' && signal.suggestedAction === 'specialize') {
     reasons.push('The pressure is high priority and bounded to a known project context.')
     reasons.push('Project-layer adaptation is the shortest truthful path to response.')
-    return {
+    recommendation = {
       route: 'specialize',
       scope: 'project',
       confidence: 0.82,
@@ -1216,12 +1952,10 @@ function buildRouteRecommendation(params: {
       triggeredBy: 'high-priority-local-gap',
       reasons,
     }
-  }
-
-  if (signal.relatedFailureId && signal.severity >= 0.8) {
+  } else if (signal.relatedFailureId && signal.severity >= 0.8) {
     reasons.push('This pressure is tied to a concrete failure with strong corrective evidence.')
     reasons.push('An evolution proposal can test a direct skill-level response against replay and regression evidence.')
-    return {
+    recommendation = {
       route: 'evolve',
       scope: signal.projectId ? 'project' : 'local',
       confidence: 0.78,
@@ -1229,12 +1963,10 @@ function buildRouteRecommendation(params: {
       triggeredBy: 'accepted-iteration-pattern',
       reasons,
     }
-  }
-
-  if (governanceMode === 'exploration' || signal.suggestedAction === 'research' || !signal.projectId) {
+  } else if (governanceMode === 'exploration' || signal.suggestedAction === 'research' || !signal.projectId) {
     reasons.push('The pressure still looks under-specified or capability-oriented.')
     reasons.push('Research is the best way to widen evidence before committing to structural change.')
-    return {
+    recommendation = {
       route: 'research',
       scope: signal.projectId ? 'project' : 'local',
       confidence: 0.68,
@@ -1242,12 +1974,10 @@ function buildRouteRecommendation(params: {
       triggeredBy: 'insufficient-evidence',
       reasons,
     }
-  }
-
-  if (signal.projectId) {
+  } else if (signal.projectId) {
     reasons.push('The pressure is project-scoped and can likely be handled without network-wide promotion yet.')
     reasons.push('Specialization is the most direct bounded intervention available.')
-    return {
+    recommendation = {
       route: 'specialize',
       scope: 'project',
       confidence: 0.7,
@@ -1255,18 +1985,25 @@ function buildRouteRecommendation(params: {
       triggeredBy: 'project-bounded-recurrence',
       reasons,
     }
+  } else {
+    reasons.push('No single route is dominant from the current evidence.')
+    reasons.push('Research keeps the loop moving while preserving optionality.')
+    recommendation = {
+      route: 'research',
+      scope: 'local',
+      confidence: 0.6,
+      governanceMode,
+      triggeredBy: 'insufficient-evidence',
+      reasons,
+    }
   }
 
-  reasons.push('No single route is dominant from the current evidence.')
-  reasons.push('Research keeps the loop moving while preserving optionality.')
-  return {
-    route: 'research',
-    scope: 'local',
-    confidence: 0.6,
-    governanceMode,
-    triggeredBy: 'insufficient-evidence',
-    reasons,
-  }
+  return applyOntologyInfluenceToRoute({
+    recommendation,
+    signal,
+    semanticBindings,
+    governanceProfile,
+  })
 }
 
 function interventionEvidenceAccepted(
@@ -1299,6 +2036,7 @@ export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
   const history = loadHistory()
   const artifacts = loadEvolutionArtifacts()
   const governance = deriveGovernanceSummary(pressureSignals, interventions)
+  const concepts = activeOntologyExtensions()
   const acceptedProposalIds = new Set(
     history.iterations.flatMap((iteration) => iteration.proposals)
       .filter((proposal) => proposal.outcome === 'accepted')
@@ -1336,11 +2074,14 @@ export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
     const relatedSignals = signalsByRegion.get(pressureRegionKey(signal)) ?? [signal]
     const projectSpread = new Set(relatedSignals.map((entry) => entry.projectId ?? entry.projectPath).filter(Boolean)).size
     const motifIds = relatedSignals.length >= 2 || projectSpread >= 2 ? [motifIdForSignal(signal)] : []
+    const semanticBindings = matchSignalOntologyBindings(signal, motifIds, concepts)
     const routeRecommendation = buildRouteRecommendation({
       signal,
       relatedSignals,
       linkedInterventions,
       governanceMode: governance.activeMode,
+      governanceProfile: governance.profile,
+      semanticBindings,
     })
 
     const lifecycle: PressureLifecycleState = addressingInterventions.length > 0 || signal.status === 'addressed'
@@ -1354,13 +2095,15 @@ export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
     const lastActivityAt = [signal.detectedAt, latestInterventionAt].filter(Boolean).sort((a, b) => b.localeCompare(a))[0] ?? signal.detectedAt
     const interventionTypes = [...new Set(linkedInterventions.map((intervention) => intervention.interventionType))]
     const addressedAt = addressingInterventions.map((intervention) => intervention.completedAt ?? intervention.createdAt).sort((a, b) => b.localeCompare(a))[0]
+    const semanticNames = uniqueStrings(semanticBindings.map((binding) => binding.conceptName))
+    const semanticNote = semanticNames.length > 0 ? ` • semantic family ${semanticNames.join(', ')}` : ''
     const responseSummary = lifecycle === 'addressed'
-      ? `Addressed by ${interventionTypes.join(', ') || 'linked intervention'} evidence`
+      ? `Addressed by ${interventionTypes.join(', ') || 'linked intervention'} evidence${semanticNote}`
       : lifecycle === 'in-progress'
-        ? `Response underway via ${interventionTypes.join(', ')}`
+        ? `Response underway via ${interventionTypes.join(', ')}${semanticNote}`
         : lifecycle === 'stale'
           ? 'Superseded by newer pressure in the same project/capability region'
-          : `No linked response yet • recommend ${routeRecommendation.route}`
+          : `No linked response yet • recommend ${routeRecommendation.route}${semanticNote}`
 
     return {
       ...signal,
@@ -1369,6 +2112,8 @@ export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
       interventionTypes,
       motifIds,
       routeRecommendation,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
       lastActivityAt,
       addressedAt,
       responseSummary,
@@ -1387,6 +2132,7 @@ export function loadPressureMotifs(): ResolvedPressureMotif[] {
   const interventions = loadPressureInterventions()
   const transferEvents = loadTransferEvents()
   const governance = deriveGovernanceSummary()
+  const concepts = activeOntologyExtensions()
   const groups = new Map<string, ResolvedPressureSignal[]>()
 
   for (const signal of resolvedSignals) {
@@ -1443,15 +2189,23 @@ export function loadPressureMotifs(): ResolvedPressureMotif[] {
     const linkedInterventionIds = linkedInterventions.map((intervention) => intervention.id)
     const linkedTransferEventIds = linkedTransferEvents.map((event) => event.id)
     const highPriorityCount = signals.filter((signal) => signal.priority === 'high').length
+    const semanticBindings = matchMotifOntologyBindings({
+      id: motifId,
+      key: regionKey,
+      kind: signals[0]?.kind ?? regionKey,
+      capability,
+    }, concepts)
+    const semanticNames = uniqueStrings(semanticBindings.map((binding) => binding.conceptName))
+    const semanticNote = semanticNames.length > 0 ? ` • semantic family ${semanticNames.join(', ')}` : ''
     const responseSummary = lifecycle === 'addressed'
       ? realizedTransfers.length > 0
-        ? 'Promoted into reusable transfer evidence'
-        : 'All linked pressure in this recurring region is addressed'
+        ? `Promoted into reusable transfer evidence${semanticNote}`
+        : `All linked pressure in this recurring region is addressed${semanticNote}`
       : lifecycle === 'in-progress'
-        ? `Promotion or response underway via ${interventionTypes.join(', ') || 'linked intervention'}`
+        ? `Promotion or response underway via ${interventionTypes.join(', ') || 'linked intervention'}${semanticNote}`
         : lifecycle === 'stale'
           ? 'Recurring pressure has been superseded by newer equivalent signals'
-          : `Recurring demand is waiting for ${recommendation.route}`
+          : `Recurring demand is waiting for ${recommendation.route}${semanticNote}`
 
     motifs.push({
       id: motifId,
@@ -1471,6 +2225,8 @@ export function loadPressureMotifs(): ResolvedPressureMotif[] {
       suggestedRoute: recommendation,
       lifecycle,
       interventionTypes,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
       lastActivityAt,
       addressedAt,
       responseSummary,
@@ -1486,6 +2242,126 @@ export function loadPressureMotifs(): ResolvedPressureMotif[] {
   })
 }
 
+function collectOntologyAdoptionState(): { summary: OntologyAdoptionSummary, consumerMap: Map<string, OntologyConsumerSummary> } {
+  const extensions = loadOntologyExtensions()
+  const activeExtensions = extensions.filter((concept) => concept.status === 'active')
+  const byConceptKind = ontologyKindCounts()
+  const bindingsByTargetType = emptyOntologyBindingCounts()
+  const consumerMap = new Map<string, OntologyConsumerSummary>()
+  const conceptById = new Map(extensions.map((concept) => [concept.id, concept]))
+
+  function ensureConsumer(concept: OntologyConcept): OntologyConsumerSummary {
+    const existing = consumerMap.get(concept.id)
+    if (existing) return existing
+    const created: OntologyConsumerSummary = {
+      conceptId: concept.id,
+      conceptName: concept.name,
+      conceptKind: concept.conceptKind,
+      status: concept.status,
+      totalBindings: 0,
+      bindingsByTargetType: emptyOntologyBindingCounts(),
+      activeTargetIds: [],
+      lastActivityAt: concept.lastObservedAt ?? concept.createdAt,
+    }
+    consumerMap.set(concept.id, created)
+    return created
+  }
+
+  function registerBinding(binding: ResolvedOntologyBinding) {
+    const concept = conceptById.get(binding.conceptId)
+    if (!concept || concept.status !== 'active') return
+    const consumer = ensureConsumer(concept)
+    consumer.totalBindings += 1
+    consumer.bindingsByTargetType[binding.targetType] = (consumer.bindingsByTargetType[binding.targetType] ?? 0) + 1
+    if (!consumer.activeTargetIds.includes(binding.targetId) && consumer.activeTargetIds.length < 12) {
+      consumer.activeTargetIds.push(binding.targetId)
+    }
+    consumer.lastActivityAt = maxTimestamp(consumer.lastActivityAt, concept.lastObservedAt, concept.createdAt)
+    bindingsByTargetType[binding.targetType] = (bindingsByTargetType[binding.targetType] ?? 0) + 1
+    byConceptKind[concept.conceptKind] = (byConceptKind[concept.conceptKind] ?? 0) + 1
+  }
+
+  const signals = loadResolvedPressureSignals()
+  for (const signal of signals) {
+    for (const binding of signal.semanticBindings ?? []) registerBinding(binding)
+    if (signal.routeRecommendation?.semanticConceptIds?.length) {
+      for (const conceptId of signal.routeRecommendation.semanticConceptIds) {
+        const concept = conceptById.get(conceptId)
+        if (!concept || concept.status !== 'active') continue
+        registerBinding(buildOntologyBinding({
+          concept,
+          targetType: 'route-recommendation',
+          targetId: `${signal.id}:route`,
+          sourceKind: 'pressure-region',
+          confidence: signal.routeRecommendation.semanticInfluence === 'weighted' ? 0.82 : 0.72,
+          reasons: signal.routeRecommendation.reasons.slice(0, 2),
+          effectSummary: `Route recommendation ${signal.routeRecommendation.route} is semantically informed by ${concept.name}.`,
+        }))
+      }
+    }
+  }
+
+  for (const motif of loadPressureMotifs()) {
+    for (const binding of motif.semanticBindings ?? []) registerBinding(binding)
+  }
+
+  for (const event of loadTransferEvents()) {
+    for (const binding of event.semanticBindings ?? []) registerBinding(binding)
+  }
+
+  for (const candidate of loadResolvedTopologyReviewCandidates()) {
+    for (const binding of candidate.semanticBindings ?? []) registerBinding(binding)
+  }
+
+  const activeConsumers = [...consumerMap.values()]
+    .sort((a, b) => b.totalBindings - a.totalBindings || (b.lastActivityAt ?? '').localeCompare(a.lastActivityAt ?? ''))
+
+  const atRiskConcepts = activeConsumers
+    .filter((consumer) => consumer.totalBindings > 0)
+    .map((consumer) => ({
+      ...consumer,
+      warning: `${consumer.totalBindings} active consumer${consumer.totalBindings === 1 ? '' : 's'} would be affected by deprecating ${consumer.conceptName}.`,
+    }))
+
+  return {
+    summary: {
+      activeConcepts: activeConsumers.length,
+      unusedExtensions: activeExtensions.filter((concept) => !consumerMap.has(concept.id)).length,
+      totalBindings: activeConsumers.reduce((sum, consumer) => sum + consumer.totalBindings, 0),
+      routesInfluenced: signals.filter((signal) => signal.routeRecommendation?.semanticInfluence && signal.routeRecommendation.semanticInfluence !== 'none').length,
+      conceptsWithConsumers: activeConsumers.length,
+      conceptsAtDeprecationRisk: atRiskConcepts.length,
+      bindingsByTargetType,
+      usageByConceptKind: byConceptKind,
+      topActiveConcepts: activeConsumers.slice(0, 8),
+      atRiskConcepts: atRiskConcepts.slice(0, 8),
+    },
+    consumerMap: new Map(activeConsumers.map((consumer) => [consumer.conceptId, consumer])),
+  }
+}
+
+export function getOntologyAdoptionSummary(): OntologyAdoptionSummary {
+  return collectOntologyAdoptionState().summary
+}
+
+export function loadResolvedOntologyExtensions(): ResolvedOntologyExtension[] {
+  const extensions = loadOntologyExtensions()
+  const { consumerMap } = collectOntologyAdoptionState()
+  return extensions
+    .map((concept) => {
+      const consumer = consumerMap.get(concept.id)
+      return {
+        ...concept,
+        semanticBindings: [],
+        adoptionCount: consumer?.totalBindings ?? 0,
+        bindingsByTargetType: consumer?.bindingsByTargetType ?? emptyOntologyBindingCounts(),
+        lastActivityAt: maxTimestamp(concept.lastObservedAt, consumer?.lastActivityAt, concept.createdAt),
+        warning: consumer?.warning,
+      } satisfies ResolvedOntologyExtension
+    })
+    .sort((a, b) => b.adoptionCount - a.adoptionCount || b.lastActivityAt.localeCompare(a.lastActivityAt) || a.name.localeCompare(b.name))
+}
+
 export function loadCoEvolutionSummary(): CoEvolutionDashboardSummary {
   const graph = loadGraph()
   const pressureSignals = loadPressureSignals()
@@ -1783,6 +2659,7 @@ export function loadOntologySummary(): OntologyDashboardSummary {
   const governance = getActiveGovernanceSummary()
   const topologyReviews = getTopologyReviewSummary()
   const topologyExecution = getTopologyExecutionSummary()
+  const ontologyReview = getOntologyReviewSummary()
   const skillRoles = emptyCounts(['generalist', 'specialist', 'hybrid'] as const)
   const stabilityStates = emptyCounts(['stable', 'adaptive', 'experimental'] as const)
   const plasticityStates = emptyCounts(['consolidated', 'volatile', 'candidate'] as const)
@@ -1815,7 +2692,9 @@ export function loadOntologySummary(): OntologyDashboardSummary {
 
   return {
     specVersion: graph.ontologyVersion ?? DASHBOARD_ONTOLOGY_SPEC_VERSION,
-    source: graph.ontologyVersion ? 'graph' : 'compat-derived',
+    source: ontologyReview.frontier > 0 || ontologyReview.extensions > 0 || ontologyReview.changeEvents > 0
+      ? 'hybrid-native-derived'
+      : graph.ontologyVersion ? 'graph' : 'compat-derived',
     skillRoles,
     stabilityStates,
     plasticityStates,
@@ -1832,7 +2711,7 @@ export function loadOntologySummary(): OntologyDashboardSummary {
     evidenceBackedProposals,
     artifacts: {
       total: artifacts.length,
-      native: artifacts.filter((artifact) => artifact.provenance === 'native-evolution').length,
+      native: artifacts.filter((artifact) => artifact.provenance === 'native-evolution' || artifact.provenance === 'native-ontology').length,
       derived: artifacts.filter((artifact) => artifact.provenance === 'derived-history').length,
     },
     activationTraces: {
@@ -1873,6 +2752,27 @@ export function loadOntologySummary(): OntologyDashboardSummary {
       candidate: transferEvents.filter((event) => event.status === 'candidate').length,
       rejected: transferEvents.filter((event) => event.status === 'rejected').length,
     },
+    ontologyLoop: {
+      kernelConcepts: ontologyReview.kernelConcepts,
+      extensions: ontologyReview.extensions,
+      frontier: ontologyReview.frontier,
+      reviewOpen: ontologyReview.reviewOpen,
+      promoted: ontologyReview.promoted,
+      rejected: ontologyReview.rejected,
+      deferred: ontologyReview.deferred,
+      deprecated: ontologyReview.deprecated,
+      changeEvents: ontologyReview.changeEvents,
+      byConceptKind: ontologyReview.byConceptKind,
+      adoption: {
+        activeConcepts: ontologyReview.adoption.activeConcepts,
+        unusedExtensions: ontologyReview.adoption.unusedExtensions,
+        totalBindings: ontologyReview.adoption.totalBindings,
+        routesInfluenced: ontologyReview.adoption.routesInfluenced,
+        conceptsAtDeprecationRisk: ontologyReview.adoption.conceptsAtDeprecationRisk,
+        bindingsByTargetType: ontologyReview.adoption.bindingsByTargetType,
+        usageByConceptKind: ontologyReview.adoption.usageByConceptKind,
+      },
+    },
     governance: {
       activeMode: governance.activeMode,
       derivedMode: governance.derivedMode,