helixevo 0.4.1 → 0.6.0

package/dist/cli.js

@@ -9489,6 +9489,48 @@ function writeJson(filename, data) {
   ensureDir(dirname(path));
   writeFileSync3(path, JSON.stringify(data, null, 2));
 }
+function getOntologyPath(filename) {
+  return join3(getHelixDir(), "ontology", filename);
+}
+function readOntologyJson(filename, fallback) {
+  const path = getOntologyPath(filename);
+  if (!existsSync3(path))
+    return fallback;
+  return JSON.parse(readFileSync3(path, "utf-8"));
+}
+function writeOntologyJson(filename, data) {
+  const path = getOntologyPath(filename);
+  ensureDir(dirname(path));
+  writeFileSync3(path, JSON.stringify(data, null, 2));
+}
+function readOntologyJsonl(filename) {
+  const path = getOntologyPath(filename);
+  if (!existsSync3(path))
+    return [];
+  const raw = readFileSync3(path, "utf-8").trim();
+  if (!raw)
+    return [];
+  return raw.split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+}
+function appendOntologyJsonl(filename, record) {
+  const path = getOntologyPath(filename);
+  ensureDir(dirname(path));
+  appendFileSync(path, JSON.stringify(record) + `
+`);
+}
+function kernelSnapshot() {
+  return {
+    version: ONTOLOGY_V0_SPEC.version,
+    updatedAt: new Date().toISOString(),
+    pillars: [...ONTOLOGY_V0_SPEC.pillars],
+    layers: [...ONTOLOGY_V0_SPEC.layers],
+    entityNames: [...ONTOLOGY_V0_SPEC.entityNames],
+    relationFamilies: [...ONTOLOGY_V0_SPEC.relationFamilies],
+    mutationOperations: [...ONTOLOGY_V0_SPEC.mutationOperations],
+    invariantIds: [...ONTOLOGY_V0_SPEC.invariantIds]
+  };
+}
 function loadFailures() {
   return readJsonl("failures.jsonl");
 }
@@ -9982,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);
@@ -9992,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));
@@ -10019,6 +10070,472 @@ function getTopologyReviewSummary() {
     recentDecisions: candidates.filter((candidate) => candidate.status !== "open").slice(0, 8)
   };
 }
+function slugFragment(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 72) || "concept";
+}
+function ontologyKindCounts() {
+  return {};
+}
+function ontologyStatusRank(status) {
+  return status === "open" ? 4 : status === "deferred" ? 3 : status === "rejected" ? 2 : 1;
+}
+function mergeConcept(existing, next) {
+  return {
+    ...existing,
+    ...next,
+    createdAt: existing.createdAt,
+    aliases: uniqueStrings([...existing.aliases ?? [], ...next.aliases ?? []]),
+    promotionCriteria: uniqueStrings([...existing.promotionCriteria ?? [], ...next.promotionCriteria ?? []]),
+    projectIds: uniqueStrings([...existing.projectIds ?? [], ...next.projectIds ?? []]),
+    evidenceIds: uniqueStrings([...existing.evidenceIds ?? [], ...next.evidenceIds ?? []]),
+    relatedSignalIds: uniqueStrings([...existing.relatedSignalIds ?? [], ...next.relatedSignalIds ?? []]),
+    relatedMotifIds: uniqueStrings([...existing.relatedMotifIds ?? [], ...next.relatedMotifIds ?? []]),
+    relatedReviewIds: uniqueStrings([...existing.relatedReviewIds ?? [], ...next.relatedReviewIds ?? []]),
+    relatedTransferEventIds: uniqueStrings([...existing.relatedTransferEventIds ?? [], ...next.relatedTransferEventIds ?? []]),
+    derivedFromKinds: uniqueStrings([...existing.derivedFromKinds ?? [], ...next.derivedFromKinds ?? []]),
+    observationCount: Math.max(existing.observationCount ?? 0, next.observationCount ?? 0),
+    confidence: Math.max(existing.confidence ?? 0, next.confidence ?? 0),
+    lastObservedAt: maxTimestamp(existing.lastObservedAt, next.lastObservedAt, existing.createdAt, next.createdAt),
+    sourceSummary: next.sourceSummary ?? existing.sourceSummary,
+    migrationMap: { ...existing.migrationMap ?? {}, ...next.migrationMap ?? {} }
+  };
+}
+function conceptArtifactSummary(action, concept) {
+  return `${action} ontology ${concept.conceptKind} concept ${concept.name} using ${concept.observationCount ?? 0} supporting observations.`;
+}
+function appendOntologyArtifact(params) {
+  const artifact = {
+    id: `ontology_artifact_${slugFragment(params.concept.id)}_${Date.now()}`,
+    createdAt: new Date().toISOString(),
+    artifactType: "ontology-review",
+    provenance: "native-ontology",
+    title: `${params.concept.name} · ontology ${params.operation}`,
+    summary: params.summary,
+    sourceId: params.sourceId,
+    operation: `ontology:${params.operation}`,
+    metrics: params.metrics
+  };
+  appendEvolutionArtifact(artifact);
+  return artifact.id;
+}
+function loadOntologyKernelSnapshot() {
+  return readOntologyJson("kernel.json", kernelSnapshot());
+}
+function materializeOntologyKernelSnapshot() {
+  const snapshot = { ...kernelSnapshot(), updatedAt: new Date().toISOString() };
+  writeOntologyJson("kernel.json", snapshot);
+  return snapshot;
+}
+function loadOntologyExtensions() {
+  return readOntologyJson("extensions.json", []).slice().sort((a, b) => (b.lastObservedAt ?? b.createdAt).localeCompare(a.lastObservedAt ?? a.createdAt) || a.name.localeCompare(b.name));
+}
+function saveOntologyExtensions(concepts) {
+  writeOntologyJson("extensions.json", concepts);
+}
+function loadOntologyFrontier() {
+  return readOntologyJson("frontier.json", []).slice().sort((a, b) => (b.lastObservedAt ?? b.createdAt).localeCompare(a.lastObservedAt ?? a.createdAt) || a.name.localeCompare(b.name));
+}
+function saveOntologyFrontier(concepts) {
+  writeOntologyJson("frontier.json", concepts);
+}
+function loadOntologyReviewDecisions() {
+  return readOntologyJsonl("reviews.jsonl").slice().sort((a, b) => b.decidedAt.localeCompare(a.decidedAt));
+}
+function appendOntologyReviewDecision(decision) {
+  appendOntologyJsonl("reviews.jsonl", decision);
+}
+function loadOntologyChangeEvents() {
+  return readOntologyJsonl("change-log.jsonl").slice().sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
+function appendOntologyChangeEvent(event) {
+  appendOntologyJsonl("change-log.jsonl", event);
+}
+function buildCapabilityFrontierConcept() {
+  const signalsByCapability = new Map;
+  for (const signal of loadPressureSignals()) {
+    const key = signal.capability?.trim() || signal.region?.trim();
+    if (!key)
+      continue;
+    const normalized = slugFragment(key);
+    const list = signalsByCapability.get(normalized) ?? [];
+    list.push(signal);
+    signalsByCapability.set(normalized, list);
+  }
+  return [...signalsByCapability.entries()].flatMap(([normalized, signals]) => {
+    const distinctProjects = uniqueStrings(signals.map((signal) => signal.projectId ?? signal.projectPath));
+    if (signals.length < 3 && distinctProjects.length < 2)
+      return [];
+    const first = signals[0];
+    const capabilityName = first.capability?.trim() || first.region?.trim() || normalized;
+    return [{
+      id: `ontology_capability_${normalized}`,
+      name: capabilityName.replace(/-/g, " "),
+      conceptKind: "capability",
+      layer: "frontier",
+      status: "provisional",
+      createdAt: new Date().toISOString(),
+      description: `Recurring capability pressure around ${capabilityName}.`,
+      promotionCriteria: [
+        "Recurs across time or more than one meaningful project context",
+        "Improves pressure explanation or project-gap attribution",
+        "Cannot be expressed cleanly by the current capability vocabulary alone"
+      ],
+      reviewKey: `capability:${normalized}`,
+      lastObservedAt: signals.map((signal) => signal.detectedAt).sort().at(-1),
+      sourceSummary: `Derived from ${signals.length} pressure signals across ${Math.max(1, distinctProjects.length)} contexts.`,
+      projectIds: distinctProjects,
+      evidenceIds: uniqueStrings(signals.map((signal) => signal.id)),
+      observationCount: signals.length,
+      confidence: Math.min(0.95, 0.52 + Math.min(0.28, signals.length * 0.05) + Math.min(0.12, distinctProjects.length * 0.08)),
+      relatedSignalIds: uniqueStrings(signals.map((signal) => signal.id)),
+      derivedFromKinds: ["project-analysis-pressure", "capability-gap"],
+      aliases: [capabilityName],
+      migrationMap: {}
+    }];
+  });
+}
+function buildPressureTypeFrontierConcepts() {
+  return loadPressureMotifs().flatMap((motif) => {
+    if (motif.recurrenceCount < 3 && motif.projectIds.length < 2)
+      return [];
+    const capabilityPart = motif.capability ? ` ${motif.capability}` : "";
+    const normalized = slugFragment(`${motif.kind}-${motif.capability ?? motif.key}`);
+    return [{
+      id: `ontology_pressure_${normalized}`,
+      name: `${motif.kind}${capabilityPart}`.trim().replace(/-/g, " "),
+      conceptKind: "pressure-type",
+      layer: "frontier",
+      status: "provisional",
+      createdAt: new Date().toISOString(),
+      description: motif.description,
+      promotionCriteria: [
+        "Recurs above isolated single-signal behavior",
+        "Improves route recommendation explanation",
+        "Supports at least one operational use-case in co-evolution control"
+      ],
+      reviewKey: `pressure:${normalized}`,
+      lastObservedAt: motif.lastActivityAt,
+      sourceSummary: `Derived from motif ${motif.key} with ${motif.recurrenceCount} observations across ${motif.projectIds.length} projects.`,
+      projectIds: motif.projectIds,
+      evidenceIds: uniqueStrings([...motif.pressureSignalIds, ...motif.linkedInterventionIds, ...motif.linkedTransferEventIds]),
+      observationCount: motif.recurrenceCount,
+      confidence: Math.min(0.95, 0.56 + Math.min(0.2, motif.recurrenceCount * 0.04) + Math.min(0.12, motif.projectIds.length * 0.06)),
+      relatedSignalIds: motif.pressureSignalIds,
+      relatedMotifIds: [motif.id],
+      relatedTransferEventIds: motif.linkedTransferEventIds,
+      derivedFromKinds: ["pressure-motif"],
+      aliases: [motif.kind, motif.key],
+      migrationMap: {}
+    }];
+  });
+}
+function topologyMotifDescriptor(candidate) {
+  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 buildTopologyMotifFrontierConcepts() {
+  const grouped = new Map;
+  for (const candidate of loadResolvedTopologyReviewCandidates()) {
+    const descriptor = topologyMotifDescriptor(candidate);
+    if (!descriptor)
+      continue;
+    const list = grouped.get(descriptor) ?? [];
+    list.push(candidate);
+    grouped.set(descriptor, list);
+  }
+  return [...grouped.entries()].flatMap(([descriptor, candidates]) => {
+    if (candidates.length < 2)
+      return [];
+    const first = candidates[0];
+    return [{
+      id: `ontology_topology_${slugFragment(descriptor)}`,
+      name: descriptor.replace(/-/g, " "),
+      conceptKind: "topology-motif",
+      layer: "frontier",
+      status: "provisional",
+      createdAt: new Date().toISOString(),
+      description: `Recurring structural review pattern: ${descriptor.replace(/-/g, " ")}.`,
+      promotionCriteria: [
+        "Recurs across multiple structural review candidates",
+        "Improves topology review explanation or triage",
+        "Supports a bounded operational use-case in the topology control surface"
+      ],
+      reviewKey: `topology:${slugFragment(descriptor)}`,
+      lastObservedAt: candidates.map((candidate) => candidate.lastActivityAt).sort().at(-1),
+      sourceSummary: `Derived from ${candidates.length} reviewed topology candidates of type ${first.changeType}.`,
+      projectIds: uniqueStrings(candidates.flatMap((candidate) => candidate.projectIds ?? [])),
+      evidenceIds: uniqueStrings(candidates.flatMap((candidate) => [...candidate.evidence, candidate.id])),
+      observationCount: candidates.length,
+      confidence: Math.min(0.92, 0.55 + Math.min(0.24, candidates.length * 0.08)),
+      relatedReviewIds: candidates.map((candidate) => candidate.id),
+      relatedMotifIds: uniqueStrings(candidates.flatMap((candidate) => candidate.relatedMotifIds ?? [])),
+      relatedTransferEventIds: uniqueStrings(candidates.flatMap((candidate) => candidate.relatedTransferEventIds ?? [])),
+      derivedFromKinds: ["topology-review"],
+      aliases: [first.changeType, descriptor],
+      migrationMap: {}
+    }];
+  });
+}
+function deriveOntologyFrontierConcepts() {
+  const byKey = new Map;
+  for (const concept of [
+    ...buildCapabilityFrontierConcept(),
+    ...buildPressureTypeFrontierConcepts(),
+    ...buildTopologyMotifFrontierConcepts()
+  ]) {
+    const key = concept.reviewKey ?? concept.id;
+    const current = byKey.get(key);
+    byKey.set(key, current ? mergeConcept(current, concept) : concept);
+  }
+  return [...byKey.values()].filter((concept) => (concept.evidenceIds?.length ?? 0) > 0).sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0) || (b.observationCount ?? 0) - (a.observationCount ?? 0) || (b.lastObservedAt ?? "").localeCompare(a.lastObservedAt ?? "")).slice(0, 10);
+}
+function refreshOntologyFrontier() {
+  materializeOntologyKernelSnapshot();
+  const existing = loadOntologyFrontier();
+  const extensions = loadOntologyExtensions();
+  const promotedKeys = new Set(extensions.map((concept) => concept.reviewKey ?? concept.id));
+  const existingByKey = new Map(existing.map((concept) => [concept.reviewKey ?? concept.id, concept]));
+  const derived = deriveOntologyFrontierConcepts().filter((concept) => !promotedKeys.has(concept.reviewKey ?? concept.id));
+  let created = 0;
+  let updated = 0;
+  for (const concept of derived) {
+    const key = concept.reviewKey ?? concept.id;
+    const current = existingByKey.get(key);
+    if (!current) {
+      existingByKey.set(key, concept);
+      created += 1;
+      appendOntologyChangeEvent({
+        id: `ontology_change_hypothesized_${slugFragment(concept.id)}_${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        changeType: "concept-hypothesized",
+        conceptIds: [concept.id],
+        reason: concept.sourceSummary ?? conceptArtifactSummary("Hypothesized", concept),
+        evidenceIds: concept.evidenceIds,
+        ontologyVersion: ONTOLOGY_SPEC_VERSION
+      });
+      appendOntologyArtifact({
+        concept,
+        operation: "refresh",
+        sourceId: concept.id,
+        summary: conceptArtifactSummary("Hypothesized", concept),
+        metrics: {
+          observations: concept.observationCount ?? 0,
+          confidence: concept.confidence ?? 0,
+          evidence: concept.evidenceIds?.length ?? 0
+        }
+      });
+      continue;
+    }
+    existingByKey.set(key, mergeConcept(current, concept));
+    updated += 1;
+  }
+  const frontier = [...existingByKey.values()].filter((concept) => !promotedKeys.has(concept.reviewKey ?? concept.id)).sort((a, b) => (b.lastObservedAt ?? b.createdAt).localeCompare(a.lastObservedAt ?? a.createdAt) || a.name.localeCompare(b.name));
+  saveOntologyFrontier(frontier);
+  const resolved = loadResolvedOntologyFrontierConcepts();
+  return {
+    created,
+    updated,
+    total: resolved.length,
+    open: resolved.filter((concept) => concept.reviewStatus === "open").length,
+    concepts: resolved
+  };
+}
+function loadResolvedOntologyFrontierConcepts() {
+  const concepts = loadOntologyFrontier();
+  const latestDecisionByConcept = new Map;
+  for (const decision of loadOntologyReviewDecisions()) {
+    const existing = latestDecisionByConcept.get(decision.conceptId);
+    if (!existing || decision.decidedAt > existing.decidedAt)
+      latestDecisionByConcept.set(decision.conceptId, decision);
+  }
+  return concepts.map((concept) => {
+    const latestReview = latestDecisionByConcept.get(concept.id);
+    const reviewStatus = 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 reviewOntologyConcept(params) {
+  const frontier = loadOntologyFrontier();
+  const concept = frontier.find((entry) => entry.id === params.conceptId);
+  if (!concept)
+    return { concept: null, extension: null };
+  const governance = getActiveGovernanceSummary();
+  const decision = {
+    id: `ontology_review_${params.decision}_${slugFragment(params.conceptId)}_${Date.now()}`,
+    conceptId: params.conceptId,
+    decision: params.decision,
+    decidedAt: new Date().toISOString(),
+    governanceMode: governance.activeMode,
+    rationale: params.rationale.trim() || `${params.decision} ontology concept via operator review`,
+    decidedBy: "operator"
+  };
+  appendOntologyReviewDecision(decision);
+  if (params.decision === "promote") {
+    const extensions = loadOntologyExtensions();
+    const promotedConcept = {
+      ...concept,
+      layer: "extension",
+      status: "active",
+      migrationMap: { ...concept.migrationMap ?? {}, [concept.id]: concept.id },
+      aliases: uniqueStrings([...concept.aliases ?? [], concept.name]),
+      lastObservedAt: maxTimestamp(concept.lastObservedAt, decision.decidedAt)
+    };
+    saveOntologyExtensions([
+      promotedConcept,
+      ...extensions.filter((entry) => entry.id !== concept.id)
+    ]);
+    saveOntologyFrontier(frontier.filter((entry) => entry.id !== concept.id));
+    appendOntologyChangeEvent({
+      id: `ontology_change_promoted_${slugFragment(concept.id)}_${Date.now()}`,
+      timestamp: decision.decidedAt,
+      changeType: "concept-promoted",
+      conceptIds: [concept.id],
+      reason: decision.rationale,
+      evidenceIds: concept.evidenceIds,
+      approvedBy: decision.decidedBy,
+      ontologyVersion: ONTOLOGY_SPEC_VERSION
+    });
+    appendOntologyArtifact({
+      concept: promotedConcept,
+      operation: "promote",
+      sourceId: decision.id,
+      summary: conceptArtifactSummary("Promoted", promotedConcept),
+      metrics: {
+        observations: promotedConcept.observationCount ?? 0,
+        confidence: promotedConcept.confidence ?? 0,
+        evidence: promotedConcept.evidenceIds?.length ?? 0
+      }
+    });
+    return {
+      concept: null,
+      extension: promotedConcept
+    };
+  }
+  if (params.decision === "reject") {
+    appendOntologyChangeEvent({
+      id: `ontology_change_rejected_${slugFragment(concept.id)}_${Date.now()}`,
+      timestamp: decision.decidedAt,
+      changeType: "concept-rejected",
+      conceptIds: [concept.id],
+      reason: decision.rationale,
+      evidenceIds: concept.evidenceIds,
+      approvedBy: decision.decidedBy,
+      ontologyVersion: ONTOLOGY_SPEC_VERSION
+    });
+    appendOntologyArtifact({
+      concept,
+      operation: "reject",
+      sourceId: decision.id,
+      summary: conceptArtifactSummary("Rejected", concept),
+      metrics: {
+        observations: concept.observationCount ?? 0,
+        confidence: concept.confidence ?? 0,
+        evidence: concept.evidenceIds?.length ?? 0
+      }
+    });
+  }
+  return {
+    concept: loadResolvedOntologyFrontierConcepts().find((entry) => entry.id === params.conceptId) ?? null,
+    extension: null
+  };
+}
+function deprecateOntologyExtension(params) {
+  const extensions = loadOntologyExtensions();
+  const current = extensions.find((entry) => entry.id === params.conceptId);
+  if (!current)
+    return null;
+  const governance = getActiveGovernanceSummary();
+  const adoption = loadResolvedOntologyExtensions().find((entry) => entry.id === params.conceptId);
+  const deprecated = {
+    ...current,
+    status: "deprecated",
+    lastObservedAt: maxTimestamp(current.lastObservedAt, new Date().toISOString())
+  };
+  saveOntologyExtensions([
+    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}`) + consumerWarning,
+    evidenceIds: current.evidenceIds,
+    approvedBy: "operator",
+    ontologyVersion: ONTOLOGY_SPEC_VERSION
+  });
+  appendOntologyArtifact({
+    concept: deprecated,
+    operation: "deprecate",
+    sourceId: `${current.id}:deprecate`,
+    summary: `Deprecated ontology extension ${deprecated.name} under ${governance.activeMode} governance.${consumerWarning}`,
+    metrics: {
+      observations: deprecated.observationCount ?? 0,
+      confidence: deprecated.confidence ?? 0,
+      adoptionCount: adoption?.adoptionCount ?? 0
+    }
+  });
+  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;
+  }
+  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: changeEvents.length,
+    byConceptKind,
+    adoption,
+    backlog: frontier.filter((concept) => concept.reviewStatus === "open" || concept.reviewStatus === "deferred").slice(0, 10),
+    recentChanges: changeEvents.slice(0, 10),
+    recentExtensions: resolvedExtensions.slice(0, 8)
+  };
+}
 function buildDerivedEvolutionArtifact(iteration, proposal) {
   return {
     id: `artifact_derived_${iteration.id}_${proposal.id}`,
@@ -10142,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, "-");
@@ -10277,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,
@@ -10294,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,
@@ -10320,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,
@@ -10332,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,
@@ -10344,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,
@@ -10356,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")
@@ -10395,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));
@@ -10421,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,
@@ -10439,6 +11255,8 @@ function loadResolvedPressureSignals() {
       interventionTypes,
       motifIds,
       routeRecommendation,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
       lastActivityAt,
       addressedAt,
       responseSummary
@@ -10449,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);
@@ -10493,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,
@@ -10512,6 +11339,8 @@ function loadPressureMotifs() {
       suggestedRoute: recommendation,
       lifecycle,
       interventionTypes,
+      semanticBindings,
+      semanticConceptIds: uniqueStrings(semanticBindings.map((binding) => binding.conceptId)),
       lastActivityAt,
       addressedAt,
       responseSummary
@@ -10522,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 ?? []);
@@ -15875,9 +16814,157 @@ async function topologyCommand(options) {
   }
 }
 
+// src/commands/ontology.ts
+init_data();
+function printStatus2() {
+  const summary = getOntologyReviewSummary();
+  console.log(`
+  Ontology Frontier`);
+  console.log("  ────────────────────────────────────────");
+  console.log(`  Kernel: ${summary.kernelConcepts} canonical entities`);
+  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`);
+    for (const concept of summary.backlog.slice(0, 5)) {
+      console.log(`  • ${concept.id} (${concept.conceptKind}) • ${concept.reviewStatus}`);
+    }
+  }
+  if (summary.recentExtensions.length > 0) {
+    console.log(`
+  Approved extensions`);
+    for (const concept of summary.recentExtensions.slice(0, 5)) {
+      const warning = concept.warning ? " • deprecation risk" : "";
+      console.log(`  • ${concept.id} (${concept.conceptKind}) • ${concept.status} • ${concept.adoptionCount} bindings${warning}`);
+    }
+  }
+  console.log();
+}
+async function ontologyCommand(options) {
+  materializeOntologyKernelSnapshot();
+  const actions = [
+    options.refresh ? "refresh" : null,
+    options.review ? "review" : null,
+    options.deprecate ? "deprecate" : null
+  ].filter(Boolean);
+  if (actions.length > 1) {
+    throw new Error("Use only one of --refresh, --review, or --deprecate at a time");
+  }
+  if (options.refresh) {
+    const result = refreshOntologyFrontier();
+    console.log(`
+  ✓ Refreshed ontology frontier`);
+    console.log(`    created: ${result.created}`);
+    console.log(`    updated: ${result.updated}`);
+    console.log(`    frontier total: ${result.total}`);
+    console.log(`    open review: ${result.open}`);
+    if (options.verbose && result.concepts.length > 0) {
+      for (const concept of result.concepts.slice(0, 8)) {
+        console.log(`    • ${concept.id} (${concept.conceptKind}) • ${concept.observationCount ?? 0} obs • ${(concept.confidence ?? 0).toFixed(2)} conf`);
+      }
+    }
+    console.log();
+    return;
+  }
+  if (options.review) {
+    if (!options.decision) {
+      throw new Error("--decision <promote|reject|defer> is required with --review");
+    }
+    const result = reviewOntologyConcept({
+      conceptId: options.review,
+      decision: options.decision,
+      rationale: options.rationale ?? `${options.decision} ontology concept via CLI review`
+    });
+    if (!result.concept && !result.extension) {
+      throw new Error(`Unknown ontology frontier concept: ${options.review}`);
+    }
+    console.log(`
+  ✓ Recorded ontology review: ${options.review}`);
+    console.log(`    decision: ${options.decision}`);
+    if (result.extension) {
+      console.log(`    promoted extension: ${result.extension.id}`);
+      console.log(`    status: ${result.extension.status}`);
+    } else if (result.concept) {
+      console.log(`    review status: ${result.concept.reviewStatus}`);
+      console.log(`    concept kind: ${result.concept.conceptKind}`);
+    }
+    console.log();
+    return;
+  }
+  if (options.deprecate) {
+    const concept = deprecateOntologyExtension({
+      conceptId: options.deprecate,
+      rationale: options.rationale ?? `Deprecated ontology extension ${options.deprecate} via CLI`
+    });
+    if (!concept) {
+      throw new Error(`Unknown ontology extension: ${options.deprecate}`);
+    }
+    console.log(`
+  ✓ 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 = loadResolvedOntologyExtensions().slice(0, 8);
+    if (frontier.length > 0) {
+      console.log("  Recent frontier concepts");
+      for (const concept of frontier) {
+        console.log(`  • ${concept.id} • ${concept.conceptKind} • ${concept.reviewStatus} • ${concept.observationCount ?? 0} obs`);
+      }
+      console.log();
+    }
+    if (extensions.length > 0) {
+      console.log("  Recent approved extensions");
+      for (const concept of extensions) {
+        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();
+    }
+    if (changes.length > 0) {
+      console.log("  Recent ontology changes");
+      for (const event of changes) {
+        console.log(`  • ${event.changeType} • ${event.conceptIds.join(", ")} • ${event.timestamp}`);
+      }
+      console.log();
+    }
+  }
+}
+
 // src/cli.ts
 var program2 = new Command;
-program2.name("helixevo").description("Self-evolving skill ecosystem for AI agents").version(VERSION).addHelpText("after", `
+program2.name("helixevo").description("Co-evolving skill and project brain for AI agents").version(VERSION).addHelpText("after", `
 Examples:
   $ helixevo watch                         Always-on learning (auto-capture + auto-evolve)
   $ helixevo watch --project myapp         Watch with project context
@@ -15898,6 +16985,10 @@ 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
   $ helixevo report --days 7               Weekly evolution report
   $ helixevo capture <session.json>        Extract failures from session`);
 program2.command("init").description("Import existing skills + generate skill tests").option("--skills-paths <paths...>", "Paths to scan for existing skills").option("--skip-tests", "Skip skill test generation").action(initCommand);
@@ -15921,6 +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 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(() => {});
 });