helixevo 0.5.0 → 0.6.0

package/dashboard/lib/data.ts

@@ -188,6 +188,8 @@ export interface PressureRouteRecommendation {
   governanceMode: GovernanceModeName
   triggeredBy: PressureRouteTrigger
   reasons: string[]
+  semanticInfluence?: OntologySemanticInfluence
+  semanticConceptIds?: string[]
 }
 
 export interface PressureIntervention {
@@ -310,6 +312,8 @@ export interface TopologyReviewDecision {
 export interface ResolvedTopologyReviewCandidate extends TopologyReviewCandidate {
   status: TopologyReviewStatus
   latestDecision?: TopologyReviewDecision
+  semanticBindings?: ResolvedOntologyBinding[]
+  semanticConceptIds?: string[]
   lastActivityAt: string
 }
 
@@ -401,6 +405,8 @@ export interface ResolvedPressureSignal extends PressureSignal {
   interventionTypes: PressureInterventionType[]
   motifIds?: string[]
   routeRecommendation?: PressureRouteRecommendation
+  semanticBindings?: ResolvedOntologyBinding[]
+  semanticConceptIds?: string[]
   lastActivityAt: string
   addressedAt?: string
   responseSummary: string
@@ -409,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
@@ -432,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
@@ -494,7 +507,7 @@ export interface CoEvolutionDashboardSummary {
   promoteQueue: ResolvedPressureMotif[]
   recentAddressed: ResolvedPressureSignal[]
   recentInterventions: PressureIntervention[]
-  recentTransfers: TransferEvent[]
+  recentTransfers: ResolvedTransferEvent[]
   topologyBacklog: ResolvedTopologyReviewCandidate[]
   recentTopologyDecisions: ResolvedTopologyReviewCandidate[]
 }
@@ -515,6 +528,9 @@ export type OntologyConceptKind = 'entity' | 'relation-subtype' | 'capability' |
 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
@@ -569,6 +585,52 @@ export interface ResolvedOntologyConcept extends OntologyConcept {
   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
@@ -646,6 +708,15 @@ export interface OntologyDashboardSummary {
     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
@@ -690,8 +761,9 @@ export interface OntologyControlDashboardSummary {
   governance: ActiveGovernanceSummary
   kernel: OntologyKernelSnapshot
   summary: OntologyDashboardSummary['ontologyLoop']
+  adoption: OntologyAdoptionSummary
   frontier: ResolvedOntologyConcept[]
-  extensions: OntologyConcept[]
+  extensions: ResolvedOntologyExtension[]
   recentChanges: OntologyChangeEvent[]
 }
 
@@ -701,6 +773,14 @@ 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'
@@ -952,7 +1032,9 @@ 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
@@ -968,9 +1050,10 @@ export function getOntologyReviewSummary() {
     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: extensions.slice(0, 8),
+    recentExtensions: resolvedExtensions.slice(0, 8),
   }
 }
 
@@ -979,8 +1062,9 @@ export function loadOntologyControlSummary(): OntologyControlDashboardSummary {
     governance: getActiveGovernanceSummary(),
     kernel: loadOntologyKernelSnapshot(),
     summary: getOntologyReviewSummary(),
+    adoption: getOntologyAdoptionSummary(),
     frontier: loadResolvedOntologyFrontierConcepts(),
-    extensions: loadOntologyExtensions(),
+    extensions: loadResolvedOntologyExtensions(),
     recentChanges: loadOntologyChangeEvents().slice(0, 10),
   }
 }
@@ -1133,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))
 }
 
@@ -1193,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)
@@ -1202,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
     })
@@ -1471,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,
@@ -1494,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,
@@ -1522,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,
@@ -1535,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,
@@ -1548,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,
@@ -1561,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(
@@ -1605,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')
@@ -1642,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'
@@ -1660,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,
@@ -1675,6 +2112,8 @@ export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
       interventionTypes,
       motifIds,
       routeRecommendation,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
       lastActivityAt,
       addressedAt,
       responseSummary,
@@ -1693,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) {
@@ -1749,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,
@@ -1777,6 +2225,8 @@ export function loadPressureMotifs(): ResolvedPressureMotif[] {
       suggestedRoute: recommendation,
       lifecycle,
       interventionTypes,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
       lastActivityAt,
       addressedAt,
       responseSummary,
@@ -1792,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()
@@ -2193,6 +2763,15 @@ export function loadOntologySummary(): OntologyDashboardSummary {
       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,