helixevo 0.5.0 → 0.6.0

package/dist/cli.js

@@ -10024,6 +10024,7 @@ function refreshTopologyReviewCandidates() {
 }
 function loadResolvedTopologyReviewCandidates() {
   const candidates = loadStoredTopologyReviewCandidates();
+  const concepts = activeOntologyExtensions();
   const latestDecisionByCandidate = new Map;
   for (const decision of loadTopologyReviewDecisions()) {
     const existing = latestDecisionByCandidate.get(decision.candidateId);
@@ -10034,10 +10035,18 @@ function loadResolvedTopologyReviewCandidates() {
   return candidates.map((candidate) => {
     const latestDecision = latestDecisionByCandidate.get(candidate.id);
     const status = 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)
     };
   }).sort((a, b) => topologyStatusRank(b.status) - topologyStatusRank(a.status) || priorityRank(b.priority) - priorityRank(a.priority) || b.confidence - a.confidence || b.lastActivityAt.localeCompare(a.lastActivityAt) || a.title.localeCompare(b.title));
@@ -10450,6 +10459,7 @@ function deprecateOntologyExtension(params) {
   if (!current)
     return null;
   const governance = getActiveGovernanceSummary();
+  const adoption = loadResolvedOntologyExtensions().find((entry) => entry.id === params.conceptId);
   const deprecated = {
     ...current,
     status: "deprecated",
@@ -10459,12 +10469,13 @@ function deprecateOntologyExtension(params) {
     deprecated,
     ...extensions.filter((entry) => entry.id !== params.conceptId)
   ]);
+  const consumerWarning = adoption && adoption.adoptionCount > 0 ? ` Warning: ${adoption.adoptionCount} active semantic consumer${adoption.adoptionCount === 1 ? "" : "s"} were visible before deprecation.` : "";
   appendOntologyChangeEvent({
     id: `ontology_change_deprecated_${slugFragment(current.id)}_${Date.now()}`,
     timestamp: new Date().toISOString(),
     changeType: "concept-deprecated",
     conceptIds: [current.id],
-    reason: params.rationale.trim() || `Deprecated ontology extension ${current.name}`,
+    reason: (params.rationale.trim() || `Deprecated ontology extension ${current.name}`) + consumerWarning,
     evidenceIds: current.evidenceIds,
     approvedBy: "operator",
     ontologyVersion: ONTOLOGY_SPEC_VERSION
@@ -10473,19 +10484,37 @@ function deprecateOntologyExtension(params) {
     concept: deprecated,
     operation: "deprecate",
     sourceId: `${current.id}:deprecate`,
-    summary: `Deprecated ontology extension ${deprecated.name} under ${governance.activeMode} governance.`,
+    summary: `Deprecated ontology extension ${deprecated.name} under ${governance.activeMode} governance.${consumerWarning}`,
     metrics: {
       observations: deprecated.observationCount ?? 0,
-      confidence: deprecated.confidence ?? 0
+      confidence: deprecated.confidence ?? 0,
+      adoptionCount: adoption?.adoptionCount ?? 0
     }
   });
-  return deprecated;
+  const resolved = loadResolvedOntologyExtensions().find((entry) => entry.id === params.conceptId);
+  if (resolved) {
+    return {
+      ...resolved,
+      warning: consumerWarning.trim() || resolved.warning,
+      adoptionCount: adoption?.adoptionCount ?? resolved.adoptionCount
+    };
+  }
+  return {
+    ...deprecated,
+    semanticBindings: [],
+    adoptionCount: adoption?.adoptionCount ?? 0,
+    bindingsByTargetType: adoption?.bindingsByTargetType ?? emptyOntologyBindingCounts(),
+    lastActivityAt: deprecated.lastObservedAt ?? deprecated.createdAt,
+    warning: consumerWarning.trim() || undefined
+  };
 }
 function getOntologyReviewSummary() {
   const kernel = loadOntologyKernelSnapshot();
   const extensions = loadOntologyExtensions();
+  const resolvedExtensions = loadResolvedOntologyExtensions();
   const frontier = loadResolvedOntologyFrontierConcepts();
   const changeEvents = loadOntologyChangeEvents();
+  const adoption = getOntologyAdoptionSummary();
   const byConceptKind = ontologyKindCounts();
   for (const concept of [...extensions, ...frontier]) {
     byConceptKind[concept.conceptKind] = (byConceptKind[concept.conceptKind] ?? 0) + 1;
@@ -10501,9 +10530,10 @@ function getOntologyReviewSummary() {
     deprecated: extensions.filter((concept) => concept.status === "deprecated").length,
     changeEvents: changeEvents.length,
     byConceptKind,
+    adoption,
     backlog: frontier.filter((concept) => concept.reviewStatus === "open" || concept.reviewStatus === "deferred").slice(0, 10),
     recentChanges: changeEvents.slice(0, 10),
-    recentExtensions: extensions.slice(0, 8)
+    recentExtensions: resolvedExtensions.slice(0, 8)
   };
 }
 function buildDerivedEvolutionArtifact(iteration, proposal) {
@@ -10629,7 +10659,15 @@ function loadPressureInterventions() {
   return loadNativePressureInterventions().slice().sort((a, b) => (b.completedAt ?? b.createdAt).localeCompare(a.completedAt ?? a.createdAt));
 }
 function loadTransferEvents() {
-  return loadNativeTransferEvents().slice().sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  const concepts = activeOntologyExtensions();
+  return loadNativeTransferEvents().slice().map((event) => {
+    const semanticBindings = matchTransferOntologyBindings(event, concepts);
+    return {
+      ...event,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId))
+    };
+  }).sort((a, b) => b.timestamp.localeCompare(a.timestamp));
 }
 function normalizePressureValue(value) {
   return (value ?? "").trim().toLowerCase().replace(/[\s_/]+/g, "-");
@@ -10764,16 +10802,301 @@ function deriveGovernanceSummary(pressureSignals = loadPressureSignals(), interv
 function getActiveGovernanceSummary() {
   return deriveGovernanceSummary();
 }
+function emptyOntologyBindingCounts() {
+  return {};
+}
+function ontologyReviewKeyBody(reviewKey) {
+  return normalizePressureValue((reviewKey ?? "").split(":").slice(1).join("-"));
+}
+function ontologyMotifTerm(motifId) {
+  return normalizePressureValue(motifId.replace(/^motif_/, ""));
+}
+function ontologyConceptTerms(concept) {
+  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, targetType, targetId, sourceKind) {
+  return `ontology_binding_${slugFragment(conceptId)}_${targetType}_${slugFragment(targetId)}_${sourceKind}`;
+}
+function buildOntologyBinding(params) {
+  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) {
+  const byKey = new Map;
+  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() {
+  return loadOntologyExtensions().filter((concept) => concept.status === "active");
+}
+function matchSignalOntologyBindings(signal, motifIds, concepts) {
+  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 = [];
+  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, concepts) {
+  const capability = normalizePressureValue(motif.capability);
+  const key = normalizePressureValue(motif.key);
+  const kind = normalizePressureValue(motif.kind);
+  const bindings = [];
+  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, concepts) {
+  const capabilityTerms = uniqueStrings((event.capabilityIds ?? []).map((value) => normalizePressureValue(value)).filter(Boolean));
+  const motifTerms = uniqueStrings((event.motifIds ?? []).map((value) => ontologyMotifTerm(value)).filter(Boolean));
+  const bindings = [];
+  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 matchTopologyOntologyBindings(candidate, concepts) {
+  const descriptor = normalizePressureValue(topologyMotifDescriptor(candidate) ?? candidate.changeType);
+  const bindings = [];
+  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) {
+  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 = "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) {
-  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 = [];
+  let recommendation;
   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,
@@ -10781,25 +11104,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
-      };
-    }
-  }
-  if (signal.projectId && signal.priority === "high" && signal.suggestedAction === "specialize") {
+    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
+    };
+  } 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,
@@ -10807,11 +11126,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,
@@ -10819,11 +11137,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,
@@ -10831,11 +11148,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,
@@ -10843,17 +11159,24 @@ 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(intervention, acceptedProposalIds, acceptedArtifactIds, realizedTransferEventIds) {
   if (intervention.status !== "completed" || intervention.impact !== "resolving")
@@ -10882,6 +11205,7 @@ function loadResolvedPressureSignals() {
   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").map((proposal) => proposal.id));
   const acceptedArtifactIds = new Set(artifacts.filter((artifact) => artifact.outcome === "accepted").map((artifact) => artifact.id));
   const realizedTransferEventIds = new Set(transferEvents.filter((event) => event.status === "realized").map((event) => event.id));
@@ -10908,17 +11232,22 @@ function loadResolvedPressureSignals() {
     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
+      governanceMode: governance.activeMode,
+      governanceProfile: governance.profile,
+      semanticBindings
     });
     const lifecycle = addressingInterventions.length > 0 || signal.status === "addressed" ? "addressed" : activeInterventions.length > 0 ? "in-progress" : hasNewerEquivalentSignal ? "stale" : "open";
     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 responseSummary = lifecycle === "addressed" ? `Addressed by ${interventionTypes.join(", ") || "linked intervention"} evidence` : lifecycle === "in-progress" ? `Response underway via ${interventionTypes.join(", ")}` : lifecycle === "stale" ? "Superseded by newer pressure in the same project/capability region" : `No linked response yet • recommend ${routeRecommendation.route}`;
+    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${semanticNote}` : lifecycle === "in-progress" ? `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}${semanticNote}`;
     return {
       ...signal,
       lifecycle,
@@ -10926,6 +11255,8 @@ function loadResolvedPressureSignals() {
       interventionTypes,
       motifIds,
       routeRecommendation,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
       lastActivityAt,
       addressedAt,
       responseSummary
@@ -10936,6 +11267,7 @@ function loadPressureMotifs() {
   const resolvedSignals = loadResolvedPressureSignals();
   const interventions = loadPressureInterventions();
   const transferEvents = loadTransferEvents();
+  const concepts = activeOntologyExtensions();
   const groups = new Map;
   for (const signal of resolvedSignals) {
     const regionKey = pressureRegionKey(signal);
@@ -10980,7 +11312,15 @@ function loadPressureMotifs() {
     const linkedInterventionIds = linkedInterventions.map((intervention) => intervention.id);
     const linkedTransferEventIds = linkedTransferEvents.map((event) => event.id);
     const highPriorityCount = signals.filter((signal) => signal.priority === "high").length;
-    const responseSummary = lifecycle === "addressed" ? realizedTransfers.length > 0 ? "Promoted into reusable transfer evidence" : "All linked pressure in this recurring region is addressed" : lifecycle === "in-progress" ? `Promotion or response underway via ${interventionTypes.join(", ") || "linked intervention"}` : lifecycle === "stale" ? "Recurring pressure has been superseded by newer equivalent signals" : `Recurring demand is waiting for ${recommendation.route}`;
+    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${semanticNote}` : `All linked pressure in this recurring region is addressed${semanticNote}` : lifecycle === "in-progress" ? `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}${semanticNote}`;
     motifs.push({
       id: motifId,
       key: regionKey,
@@ -10999,6 +11339,8 @@ function loadPressureMotifs() {
       suggestedRoute: recommendation,
       lifecycle,
       interventionTypes,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
       lastActivityAt,
       addressedAt,
       responseSummary
@@ -11009,6 +11351,116 @@ function loadPressureMotifs() {
     return lifecycleWeight(b.lifecycle) - lifecycleWeight(a.lifecycle) || b.highPriorityCount - a.highPriorityCount || b.recurrenceCount - a.recurrenceCount || b.lastActivityAt.localeCompare(a.lastActivityAt);
   });
 }
+function collectOntologyAdoptionState() {
+  const extensions = loadOntologyExtensions();
+  const activeExtensions = extensions.filter((concept) => concept.status === "active");
+  const byConceptKind = ontologyKindCounts();
+  const bindingsByTargetType = emptyOntologyBindingCounts();
+  const consumerMap = new Map;
+  const conceptById = new Map(extensions.map((concept) => [concept.id, concept]));
+  function ensureConsumer(concept) {
+    const existing = consumerMap.get(concept.id);
+    if (existing)
+      return existing;
+    const created = {
+      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) {
+    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]))
+  };
+}
+function getOntologyAdoptionSummary() {
+  return collectOntologyAdoptionState().summary;
+}
+function loadResolvedOntologyExtensions() {
+  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
+    };
+  }).sort((a, b) => b.adoptionCount - a.adoptionCount || b.lastActivityAt.localeCompare(a.lastActivityAt) || a.name.localeCompare(b.name));
+}
 function matchPressureSignals(filters) {
   const capabilities = new Set((filters.capabilities ?? []).map((value) => normalizePressureValue(value)));
   const relatedFailureIds = new Set(filters.relatedFailureIds ?? []);
@@ -16373,6 +16825,8 @@ function printStatus2() {
   console.log(`  Extensions: ${summary.extensions} active • ${summary.deprecated} deprecated`);
   console.log(`  Frontier: ${summary.frontier} total • ${summary.reviewOpen} open • ${summary.deferred} deferred • ${summary.rejected} rejected`);
   console.log(`  Change log: ${summary.changeEvents} events`);
+  console.log(`  Adoption: ${summary.adoption.activeConcepts} active concepts • ${summary.adoption.totalBindings} bindings • ${summary.adoption.routesInfluenced} routes influenced`);
+  console.log(`  Coverage: ${summary.adoption.unusedExtensions} unused extensions • ${summary.adoption.conceptsAtDeprecationRisk} deprecation-sensitive concepts`);
   if (summary.backlog.length > 0) {
     console.log(`
   Frontier concepts ready for review`);
@@ -16384,7 +16838,8 @@ function printStatus2() {
     console.log(`
   Approved extensions`);
     for (const concept of summary.recentExtensions.slice(0, 5)) {
-      console.log(`  • ${concept.id} (${concept.conceptKind}) • ${concept.status}`);
+      const warning = concept.warning ? " • deprecation risk" : "";
+      console.log(`  • ${concept.id} (${concept.conceptKind}) • ${concept.status} • ${concept.adoptionCount} bindings${warning}`);
     }
   }
   console.log();
@@ -16452,14 +16907,18 @@ async function ontologyCommand(options) {
   ✓ Deprecated ontology extension: ${concept.id}`);
     console.log(`    kind: ${concept.conceptKind}`);
     console.log(`    status: ${concept.status}`);
+    if (concept.warning) {
+      console.log(`    warning: ${concept.warning}`);
+    }
     console.log();
     return;
   }
   printStatus2();
   if (options.verbose) {
+    const summary = getOntologyReviewSummary();
     const frontier = loadResolvedOntologyFrontierConcepts().slice(0, 8);
     const changes = loadOntologyChangeEvents().slice(0, 8);
-    const extensions = loadOntologyExtensions().slice(0, 8);
+    const extensions = loadResolvedOntologyExtensions().slice(0, 8);
     if (frontier.length > 0) {
       console.log("  Recent frontier concepts");
       for (const concept of frontier) {
@@ -16470,7 +16929,26 @@ async function ontologyCommand(options) {
     if (extensions.length > 0) {
       console.log("  Recent approved extensions");
       for (const concept of extensions) {
-        console.log(`  • ${concept.id} • ${concept.conceptKind} • ${concept.status}`);
+        const warning = concept.warning ? ` • ${concept.warning}` : "";
+        console.log(`  • ${concept.id} • ${concept.conceptKind} • ${concept.status} • ${concept.adoptionCount} bindings${warning}`);
+      }
+      console.log();
+    }
+    if (summary.adoption.topActiveConcepts.length > 0) {
+      console.log("  Top active concepts");
+      for (const concept of summary.adoption.topActiveConcepts) {
+        console.log(`  • ${concept.conceptId} • ${concept.totalBindings} bindings • ${Object.entries(concept.bindingsByTargetType).map(([target, count]) => `${target}:${count}`).join(" • ")}`);
+      }
+      console.log();
+    }
+    if (summary.adoption.unusedExtensions > 0) {
+      console.log(`  Unused approved extensions: ${summary.adoption.unusedExtensions}`);
+      console.log();
+    }
+    if (summary.adoption.atRiskConcepts.length > 0) {
+      console.log("  Deprecation-sensitive concepts");
+      for (const concept of summary.adoption.atRiskConcepts) {
+        console.log(`  • ${concept.conceptId} • ${concept.warning}`);
       }
       console.log();
     }
@@ -16507,6 +16985,7 @@ Examples:
   $ helixevo topology --prepare <id>       Prepare an accepted topology candidate
   $ helixevo topology --apply <planId>     Apply a safe prepared topology plan
   $ helixevo topology --rollback <planId>  Roll back an applied topology plan
+  $ helixevo ontology --status --verbose   Show frontier, extension, adoption, and deprecation-risk visibility
   $ helixevo ontology --refresh            Derive frontier concepts from recurring evidence
   $ helixevo ontology --review <id> --decision promote
                                            Promote a reviewed frontier concept into approved extensions
@@ -16533,7 +17012,7 @@ program2.command("health").description("Assess network health: cohesion, coverag
 program2.command("metrics").description("Show correction rates, skill trends, and evolution impact").option("--verbose", "Show detailed per-skill breakdown").action(metricsCommand);
 program2.command("project-setup").description("Analyze a project folder and match it against your skill set").argument("<path>", "Path to the project folder").option("--verbose", "Show detailed analysis").option("--dry-run", "Analyze without saving project profile").action(projectSetupCommand);
 program2.command("topology").description("Reviewed topology execution control [--status] [--prepare <candidateId>] [--apply <planId>] [--rollback <planId>]").option("--status", "Show topology review and execution state").option("--prepare <candidateId>", "Prepare an accepted topology review candidate").option("--apply <planId>", "Apply a safe prepared topology plan").option("--rollback <planId>", "Roll back an applied topology plan").option("--verbose", "Show detailed topology plan state").action(topologyCommand);
-program2.command("ontology").description("Governed ontology frontier control [--status] [--refresh] [--review <conceptId>] [--decision <promote|reject|defer>] [--deprecate <conceptId>]").option("--status", "Show ontology kernel, frontier, and extension state").option("--refresh", "Derive frontier concepts from recurring runtime evidence").option("--review <conceptId>", "Review a frontier concept").option("--decision <decision>", "Decision for --review: promote, reject, or defer").option("--rationale <text>", "Optional rationale for review or deprecate actions").option("--deprecate <conceptId>", "Deprecate an approved ontology extension").option("--verbose", "Show detailed ontology frontier state").action(ontologyCommand);
+program2.command("ontology").description("Governed ontology frontier and semantic adoption control [--status] [--refresh] [--review <conceptId>] [--decision <promote|reject|defer>] [--deprecate <conceptId>]").option("--status", "Show ontology kernel, frontier, and extension state").option("--refresh", "Derive frontier concepts from recurring runtime evidence").option("--review <conceptId>", "Review a frontier concept").option("--decision <decision>", "Decision for --review: promote, reject, or defer").option("--rationale <text>", "Optional rationale for review or deprecate actions").option("--deprecate <conceptId>", "Deprecate an approved ontology extension").option("--verbose", "Show detailed ontology frontier state").action(ontologyCommand);
 program2.hook("postAction", () => {
   checkForUpdates().catch(() => {});
 });