helixevo 0.4.0 → 0.5.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");
 }
@@ -10019,6 +10061,451 @@ 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 deprecated = {
+    ...current,
+    status: "deprecated",
+    lastObservedAt: maxTimestamp(current.lastObservedAt, new Date().toISOString())
+  };
+  saveOntologyExtensions([
+    deprecated,
+    ...extensions.filter((entry) => entry.id !== params.conceptId)
+  ]);
+  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}`,
+    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.`,
+    metrics: {
+      observations: deprecated.observationCount ?? 0,
+      confidence: deprecated.confidence ?? 0
+    }
+  });
+  return deprecated;
+}
+function getOntologyReviewSummary() {
+  const kernel = loadOntologyKernelSnapshot();
+  const extensions = loadOntologyExtensions();
+  const frontier = loadResolvedOntologyFrontierConcepts();
+  const changeEvents = loadOntologyChangeEvents();
+  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,
+    backlog: frontier.filter((concept) => concept.reviewStatus === "open" || concept.reviewStatus === "deferred").slice(0, 10),
+    recentChanges: changeEvents.slice(0, 10),
+    recentExtensions: extensions.slice(0, 8)
+  };
+}
 function buildDerivedEvolutionArtifact(iteration, proposal) {
   return {
     id: `artifact_derived_${iteration.id}_${proposal.id}`,
@@ -15875,9 +16362,131 @@ 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`);
+  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)) {
+      console.log(`  • ${concept.id} (${concept.conceptKind}) • ${concept.status}`);
+    }
+  }
+  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}`);
+    console.log();
+    return;
+  }
+  printStatus2();
+  if (options.verbose) {
+    const frontier = loadResolvedOntologyFrontierConcepts().slice(0, 8);
+    const changes = loadOntologyChangeEvents().slice(0, 8);
+    const extensions = loadOntologyExtensions().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) {
+        console.log(`  • ${concept.id} • ${concept.conceptKind} • ${concept.status}`);
+      }
+      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 +16507,9 @@ 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 --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 +16533,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.hook("postAction", () => {
   checkForUpdates().catch(() => {});
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helixevo",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Co-evolving skill and project brain for AI agents, with ontology-aware learning, governed response, rollbackable topology control, and a premium dashboard.",
   "type": "module",
   "bin": {