helixevo 0.3.1 → 0.4.0

package/dist/cli.js

@@ -9405,6 +9405,62 @@ var init_ontology = __esm(() => {
   init_spec();
 });
 
+// src/core/network-topology.ts
+function detectMergeCandidates(enhances, coEvolves, skills) {
+  const pairScores = {};
+  for (const edge of [...enhances, ...coEvolves]) {
+    const key = [edge.from, edge.to].sort().join("::");
+    pairScores[key] = (pairScores[key] ?? 0) + edge.strength;
+  }
+  const candidates = [];
+  for (const [key, score] of Object.entries(pairScores)) {
+    if (score < 1.5)
+      continue;
+    const [a, b] = key.split("::");
+    const skillA = skills.find((skill) => skill.slug === a);
+    const skillB = skills.find((skill) => skill.slug === b);
+    if (!skillA || !skillB)
+      continue;
+    if (skillA.meta.layer !== skillB.meta.layer)
+      continue;
+    candidates.push({
+      slugs: [a, b],
+      combinedStrength: score,
+      confidence: Math.min(0.96, 0.62 + Math.max(0, score - 1.5) * 0.22)
+    });
+  }
+  return candidates.sort((a, b) => b.combinedStrength - a.combinedStrength || a.slugs.join("::").localeCompare(b.slugs.join("::")));
+}
+function detectSplitCandidates(skills) {
+  return skills.map((skill) => {
+    const contentLength = skill.content.length;
+    const failureCount = skill.meta.failureCount ?? 0;
+    if (contentLength <= 5000 && failureCount <= 20)
+      return null;
+    const contentPressure = Math.max(0, (contentLength - 5000) / 4000);
+    const failurePressure = Math.max(0, (failureCount - 20) / 20);
+    return {
+      slug: skill.slug,
+      contentLength,
+      failureCount,
+      confidence: Math.min(0.97, 0.58 + Math.min(0.18, contentPressure * 0.12) + Math.min(0.2, failurePressure * 0.14))
+    };
+  }).filter((candidate) => candidate !== null).sort((a, b) => b.failureCount - a.failureCount || b.contentLength - a.contentLength || a.slug.localeCompare(b.slug));
+}
+function previewNetworkOptimization(graph, skills) {
+  const enhances = graph.edges.filter((edge) => edge.type === "enhances" && edge.strength >= 0.8);
+  const coEvolves = graph.edges.filter((edge) => edge.type === "co-evolves" && edge.strength >= 0.8);
+  const conflicts = graph.edges.filter((edge) => edge.type === "conflicts").map((edge) => ({
+    slugs: [edge.from, edge.to],
+    strength: edge.strength
+  })).sort((a, b) => b.strength - a.strength || a.slugs.join("::").localeCompare(b.slugs.join("::")));
+  return {
+    merged: detectMergeCandidates(enhances, coEvolves, skills),
+    split: detectSplitCandidates(skills),
+    conflicts
+  };
+}
+
 // src/utils/data.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, appendFileSync, existsSync as existsSync3, readdirSync as readdirSync2 } from "node:fs";
 import { dirname, join as join3 } from "node:path";
@@ -9466,7 +9522,7 @@ function loadSkillTests() {
 function appendSkillTest(gc) {
   appendJsonl("skill-tests.jsonl", gc);
 }
-function loadSkillGraph() {
+function loadStoredSkillGraph() {
   return readJson("skill-graph.json", {
     updated: new Date().toISOString(),
     nodes: [],
@@ -9474,21 +9530,1092 @@ function loadSkillGraph() {
     clusters: []
   });
 }
+function loadSkillGraph() {
+  return applyTopologyOverridesToGraph(loadStoredSkillGraph());
+}
 function saveSkillGraph(graph) {
   writeJson("skill-graph.json", graph);
 }
+function loadNativeEvolutionArtifacts() {
+  return readJsonl("evolution-artifacts.jsonl");
+}
 function appendEvolutionArtifact(artifact) {
   appendJsonl("evolution-artifacts.jsonl", artifact);
 }
 function appendActivationTrace(trace) {
   appendJsonl("activation-traces.jsonl", trace);
 }
+function loadNativePressureSignals() {
+  return readJsonl("pressure-signals.jsonl");
+}
 function appendPressureSignal(signal) {
   appendJsonl("pressure-signals.jsonl", signal);
 }
+function loadNativePressureInterventions() {
+  return readJsonl("pressure-interventions.jsonl");
+}
+function appendPressureIntervention(intervention) {
+  appendJsonl("pressure-interventions.jsonl", intervention);
+}
+function loadNativeTransferEvents() {
+  return readJsonl("transfer-events.jsonl");
+}
+function appendTransferEvent(event) {
+  appendJsonl("transfer-events.jsonl", event);
+}
+function topologyChangeCounts() {
+  return {
+    merge: 0,
+    split: 0,
+    promote: 0,
+    demote: 0,
+    rewire: 0,
+    prune: 0,
+    consolidate: 0
+  };
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => Boolean(value && value.trim())))];
+}
+function mergeEvidence(existing, next) {
+  return uniqueStrings([...existing ?? [], ...next ?? []]);
+}
+function maxTimestamp(...values) {
+  return values.filter(Boolean).sort((a, b) => b.localeCompare(a))[0] ?? new Date(0).toISOString();
+}
+function priorityRank(priority) {
+  return priority === "high" ? 3 : priority === "medium" ? 2 : 1;
+}
+function topologyStatusRank(status) {
+  return status === "open" ? 4 : status === "deferred" ? 3 : status === "accepted" ? 2 : 1;
+}
+function priorityFromScore(score) {
+  if (score >= 0.82)
+    return "high";
+  if (score >= 0.64)
+    return "medium";
+  return "low";
+}
+function governanceProfileForMode(mode) {
+  return GOVERNANCE_PROFILES[mode];
+}
+function loadGovernanceState() {
+  const state = readJson("governance-state.json", DEFAULT_GOVERNANCE_STATE);
+  if (state.selectionMode === "manual" && state.manualMode)
+    return state;
+  return { ...DEFAULT_GOVERNANCE_STATE, ...state, selectionMode: state.selectionMode === "manual" && state.manualMode ? "manual" : "auto" };
+}
+function loadStoredTopologyReviewCandidates() {
+  return readJson("topology-review-candidates.json", []).slice().sort((a, b) => b.lastObservedAt.localeCompare(a.lastObservedAt) || a.title.localeCompare(b.title));
+}
+function saveTopologyReviewCandidates(candidates) {
+  writeJson("topology-review-candidates.json", candidates);
+}
+function loadTopologyReviewDecisions() {
+  return readJsonl("topology-review-decisions.jsonl").slice().sort((a, b) => b.decidedAt.localeCompare(a.decidedAt));
+}
+function topologyEdgeKey(edge) {
+  return `${edge.from}::${edge.to}::${edge.type}`;
+}
+function loadTopologyOverrides() {
+  const overrides = readJson("topology-overrides.json", DEFAULT_TOPOLOGY_OVERRIDES);
+  return {
+    ...DEFAULT_TOPOLOGY_OVERRIDES,
+    ...overrides,
+    nodeOverrides: overrides.nodeOverrides ?? {},
+    suppressedEdges: overrides.suppressedEdges ?? [],
+    addedEdges: overrides.addedEdges ?? [],
+    appliedPlanIds: overrides.appliedPlanIds ?? []
+  };
+}
+function saveTopologyOverrides(overrides) {
+  writeJson("topology-overrides.json", overrides);
+}
+function applyTopologyOverridesToGraph(graph, overrides = loadTopologyOverrides()) {
+  const suppressed = new Set(overrides.suppressedEdges.map((edge) => topologyEdgeKey(edge)));
+  const edgeMap = new Map;
+  for (const edge of graph.edges) {
+    const key = topologyEdgeKey(edge);
+    if (!suppressed.has(key))
+      edgeMap.set(key, edge);
+  }
+  for (const edge of overrides.addedEdges) {
+    edgeMap.set(topologyEdgeKey(edge), edge);
+  }
+  return {
+    ...graph,
+    nodes: graph.nodes.map((node) => ({
+      ...node,
+      ...overrides.nodeOverrides[node.id] ?? {}
+    })),
+    edges: [...edgeMap.values()]
+  };
+}
+function loadTopologySnapshots() {
+  return readJson("topology-snapshots.json", []).slice().sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+function saveTopologySnapshots(snapshots) {
+  writeJson("topology-snapshots.json", snapshots);
+}
+function loadTopologyApplyPlans() {
+  return readJson("topology-apply-plans.json", []).slice().sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+function saveTopologyApplyPlans(plans) {
+  writeJson("topology-apply-plans.json", plans);
+}
+function loadTopologyExecutionRecords() {
+  return readJsonl("topology-executions.jsonl").slice().sort((a, b) => (b.executedAt ?? b.rolledBackAt ?? b.createdAt).localeCompare(a.executedAt ?? a.rolledBackAt ?? a.createdAt));
+}
+function appendTopologyExecutionRecord(record) {
+  appendJsonl("topology-executions.jsonl", record);
+}
+function loadTopologyArtifacts() {
+  return readJsonl("topology-artifacts.jsonl").slice().sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+function appendTopologyArtifact(artifact) {
+  appendJsonl("topology-artifacts.jsonl", artifact);
+}
+function loadResolvedTopologyApplyPlans() {
+  const plans = loadTopologyApplyPlans();
+  const latestByPlan = new Map;
+  for (const record of loadTopologyExecutionRecords()) {
+    const existing = latestByPlan.get(record.planId);
+    const recordAt = record.executedAt ?? record.rolledBackAt ?? record.createdAt;
+    const existingAt = existing ? existing.executedAt ?? existing.rolledBackAt ?? existing.createdAt : "";
+    if (!existing || recordAt > existingAt)
+      latestByPlan.set(record.planId, record);
+  }
+  return plans.map((plan) => {
+    const latestExecution = latestByPlan.get(plan.id);
+    return {
+      ...plan,
+      latestStatus: latestExecution?.status ?? "pending",
+      latestExecution,
+      lastActivityAt: maxTimestamp(plan.createdAt, latestExecution?.executedAt, latestExecution?.rolledBackAt, latestExecution?.createdAt)
+    };
+  }).sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt) || (b.safeToApply === a.safeToApply ? 0 : b.safeToApply ? 1 : -1));
+}
+function getTopologyExecutionSummary() {
+  const plans = loadResolvedTopologyApplyPlans();
+  const snapshots = loadTopologySnapshots();
+  const artifacts = loadTopologyArtifacts();
+  const plannedCandidateIds = new Set(plans.map((plan) => plan.candidateId));
+  const acceptedReady = loadResolvedTopologyReviewCandidates().filter((candidate) => candidate.status === "accepted" && !plannedCandidateIds.has(candidate.id)).slice(0, 8);
+  return {
+    plans: plans.length,
+    pending: plans.filter((plan) => plan.latestStatus === "pending").length,
+    prepared: plans.filter((plan) => plan.latestStatus === "prepared").length,
+    applied: plans.filter((plan) => plan.latestStatus === "applied").length,
+    rolledBack: plans.filter((plan) => plan.latestStatus === "rolled-back").length,
+    failed: plans.filter((plan) => plan.latestStatus === "failed").length,
+    safeToApply: plans.filter((plan) => plan.safeToApply).length,
+    prepareOnly: plans.filter((plan) => plan.executionMode === "prepare-only").length,
+    snapshots: snapshots.length,
+    artifacts: artifacts.length,
+    acceptedReady,
+    preparedQueue: plans.filter((plan) => plan.latestStatus === "prepared").slice(0, 8),
+    appliedHistory: plans.filter((plan) => plan.latestStatus === "applied" || plan.latestStatus === "rolled-back").slice(0, 8)
+  };
+}
+function buildMergeReviewCandidate(params) {
+  const { slugA, slugB, combinedStrength, confidence, governanceMode } = params;
+  return {
+    id: `topology_merge_${slugA}_${slugB}`.replace(/[^a-zA-Z0-9_-]/g, "-"),
+    reviewKey: `merge:${[slugA, slugB].sort().join("::")}`,
+    createdAt: new Date().toISOString(),
+    lastObservedAt: new Date().toISOString(),
+    source: "graph-optimize",
+    changeType: "merge",
+    title: `Merge overlap: ${slugA} + ${slugB}`,
+    reasonSummary: "These skills show repeated high-strength overlap and likely duplicate the same abstraction boundary.",
+    description: "Review whether the pair should collapse into one cleaner abstraction or remain separated with stronger scope boundaries.",
+    priority: priorityFromScore(Math.max(confidence, Math.min(0.94, 0.58 + Math.max(0, combinedStrength - 1.5) * 0.22))),
+    confidence,
+    riskScore: Math.min(0.82, 0.52 + Math.max(0, combinedStrength - 1.5) * 0.14),
+    governanceMode,
+    affectedNodeIds: [slugA, slugB],
+    evidence: [
+      `${slugA} and ${slugB} share strong enhance/co-evolve signals.`,
+      `Combined structural overlap score ${combinedStrength.toFixed(2)} suggests duplicate abstraction territory.`
+    ]
+  };
+}
+function buildSplitReviewCandidate(params) {
+  const { slug, contentLength, failureCount, confidence, governanceMode } = params;
+  return {
+    id: `topology_split_${slug}`.replace(/[^a-zA-Z0-9_-]/g, "-"),
+    reviewKey: `split:${slug}`,
+    createdAt: new Date().toISOString(),
+    lastObservedAt: new Date().toISOString(),
+    source: "network-health",
+    changeType: "split",
+    title: `Split overloaded skill: ${slug}`,
+    reasonSummary: "This skill is carrying too much content or too many failures to remain a clean single unit.",
+    description: "Review whether the skill should be decomposed into narrower children or layered guidance blocks.",
+    priority: priorityFromScore(Math.max(confidence, failureCount >= 28 ? 0.84 : failureCount >= 22 ? 0.72 : 0.6)),
+    confidence,
+    riskScore: Math.min(0.79, 0.48 + Math.min(0.16, Math.max(0, contentLength - 5000) / 6000) + Math.min(0.15, Math.max(0, failureCount - 20) / 30)),
+    governanceMode,
+    affectedNodeIds: [slug],
+    evidence: [
+      `${slug} has ${contentLength} characters of guidance.`,
+      `${slug} has accumulated ${failureCount} failures, suggesting multiple pressure fronts are collapsing into one node.`
+    ]
+  };
+}
+function buildConflictReviewCandidate(params) {
+  const { slugA, slugB, strength, governanceMode } = params;
+  return {
+    id: `topology_rewire_${slugA}_${slugB}`.replace(/[^a-zA-Z0-9_-]/g, "-"),
+    reviewKey: `rewire:conflict:${[slugA, slugB].sort().join("::")}`,
+    createdAt: new Date().toISOString(),
+    lastObservedAt: new Date().toISOString(),
+    source: "graph-optimize",
+    changeType: "rewire",
+    title: `Resolve conflicting pair: ${slugA} ↔ ${slugB}`,
+    reasonSummary: "The graph already marks this pair as conflicting, which suggests the current relation topology may be mis-scoped.",
+    description: "Review whether one rule should be narrowed, whether these nodes need cleaner lineage, or whether a missing bridge abstraction should absorb the conflict.",
+    priority: priorityFromScore(Math.min(0.92, 0.7 + strength * 0.18)),
+    confidence: Math.min(0.92, 0.66 + strength * 0.16),
+    riskScore: Math.min(0.9, 0.68 + strength * 0.18),
+    governanceMode,
+    affectedNodeIds: [slugA, slugB],
+    evidence: [
+      `${slugA} and ${slugB} are linked by an explicit conflict edge.`,
+      `Conflict strength ${strength.toFixed(2)} makes blind automated routing less trustworthy here.`
+    ]
+  };
+}
+function buildPromoteReviewCandidate(motif, governanceMode) {
+  return {
+    id: `topology_promote_${motif.id}`.replace(/[^a-zA-Z0-9_-]/g, "-"),
+    reviewKey: `promote:${motif.id}`,
+    createdAt: new Date().toISOString(),
+    lastObservedAt: new Date().toISOString(),
+    source: "pressure-motif",
+    changeType: "promote",
+    title: `Promote recurring motif: ${motif.capability ?? motif.kind}`,
+    reasonSummary: "Recurring multi-project pressure suggests a reusable abstraction should move upward into the shared network backbone.",
+    description: motif.responseSummary,
+    priority: priorityFromScore(Math.max(motif.suggestedRoute.confidence, motif.highPriorityCount > 0 ? 0.84 : motif.recurrenceCount >= 3 ? 0.74 : 0.66)),
+    confidence: motif.suggestedRoute.confidence,
+    riskScore: Math.max(0.28, 0.62 - Math.min(0.18, motif.recurrenceCount * 0.05)),
+    governanceMode,
+    affectedNodeIds: motif.sourceSkillIds,
+    projectIds: motif.projectIds,
+    relatedSignalIds: motif.pressureSignalIds,
+    relatedMotifIds: [motif.id],
+    relatedInterventionIds: motif.linkedInterventionIds,
+    evidence: mergeEvidence([
+      `${motif.recurrenceCount} recurring signals now map to this motif.`,
+      `${motif.projectIds.length} projects are contributing demand into the same region.`
+    ], motif.suggestedRoute.reasons)
+  };
+}
+function buildConsolidateReviewCandidate(motif, governanceMode) {
+  return {
+    id: `topology_consolidate_${motif.id}`.replace(/[^a-zA-Z0-9_-]/g, "-"),
+    reviewKey: `consolidate:${motif.id}`,
+    createdAt: new Date().toISOString(),
+    lastObservedAt: new Date().toISOString(),
+    source: "transfer-pattern",
+    changeType: "consolidate",
+    title: `Consolidate transfer-backed motif: ${motif.capability ?? motif.kind}`,
+    reasonSummary: "Realized transfer evidence suggests the network can now stabilize this motif as a cleaner long-lived abstraction cluster.",
+    description: motif.responseSummary,
+    priority: priorityFromScore(motif.linkedTransferEventIds.length >= 2 ? 0.8 : 0.7),
+    confidence: Math.min(0.9, 0.7 + Math.min(0.14, motif.linkedTransferEventIds.length * 0.06)),
+    riskScore: Math.max(0.24, 0.54 - Math.min(0.16, motif.linkedTransferEventIds.length * 0.05)),
+    governanceMode,
+    affectedNodeIds: motif.sourceSkillIds,
+    projectIds: motif.projectIds,
+    relatedSignalIds: motif.pressureSignalIds,
+    relatedMotifIds: [motif.id],
+    relatedTransferEventIds: motif.linkedTransferEventIds,
+    relatedInterventionIds: motif.linkedInterventionIds,
+    evidence: [
+      `${motif.linkedTransferEventIds.length} transfer event(s) are already linked to this motif.`,
+      `${motif.projectIds.length} project contexts now share reusable evidence in the same region.`,
+      motif.responseSummary
+    ]
+  };
+}
+function buildManualRouteReviewCandidate(signals, governanceMode) {
+  const first = signals[0];
+  const regionKey = pressureRegionKey(first);
+  const projectIds = uniqueStrings(signals.flatMap((signal) => [signal.projectId, signal.projectPath]));
+  const affectedNodeIds = uniqueStrings(signals.flatMap((signal) => signal.skillIds ?? []));
+  const relatedInterventionIds = uniqueStrings(signals.flatMap((signal) => signal.linkedInterventions.map((intervention) => intervention.id)));
+  const routeReasons = signals.flatMap((signal) => signal.routeRecommendation?.reasons ?? []);
+  const maxConfidence = signals.reduce((max, signal) => Math.max(max, signal.routeRecommendation?.confidence ?? 0), 0);
+  const hasHighPriority = signals.some((signal) => signal.priority === "high");
+  return {
+    id: `topology_manual_${regionKey}`.replace(/[^a-zA-Z0-9_-]/g, "-"),
+    reviewKey: `manual-route:${regionKey}`,
+    createdAt: new Date().toISOString(),
+    lastObservedAt: maxTimestamp(...signals.map((signal) => signal.lastActivityAt)),
+    source: "manual-route",
+    changeType: "rewire",
+    title: `Manual topology review: ${first.capability ?? first.kind}`,
+    reasonSummary: "Multiple response lanes are touching the same pressure region without trustworthy closure, so the structure itself likely needs review.",
+    description: first.responseSummary,
+    priority: hasHighPriority || projectIds.length >= 2 ? "high" : priorityFromScore(Math.max(maxConfidence, 0.66)),
+    confidence: Math.max(maxConfidence, 0.58),
+    riskScore: Math.min(0.91, 0.72 + (hasHighPriority ? 0.05 : 0) + Math.min(0.08, Math.max(0, projectIds.length - 1) * 0.04)),
+    governanceMode,
+    affectedNodeIds,
+    projectIds,
+    relatedSignalIds: signals.map((signal) => signal.id),
+    relatedMotifIds: uniqueStrings(signals.flatMap((signal) => signal.motifIds ?? [])),
+    relatedInterventionIds,
+    evidence: mergeEvidence([
+      `${signals.length} active signals are converging on manual review in this region.`,
+      `${relatedInterventionIds.length} linked intervention attempts already touched it.`
+    ], routeReasons)
+  };
+}
+function mergeTopologyCandidate(existing, next) {
+  return {
+    ...existing,
+    lastObservedAt: maxTimestamp(existing.lastObservedAt, next.lastObservedAt),
+    title: next.title,
+    reasonSummary: next.reasonSummary,
+    description: next.description ?? existing.description,
+    priority: priorityRank(next.priority) > priorityRank(existing.priority) ? next.priority : existing.priority,
+    confidence: Math.max(existing.confidence, next.confidence),
+    riskScore: Math.max(existing.riskScore, next.riskScore),
+    governanceMode: next.governanceMode,
+    affectedNodeIds: uniqueStrings([...existing.affectedNodeIds, ...next.affectedNodeIds]),
+    affectedRelationIds: uniqueStrings([...existing.affectedRelationIds ?? [], ...next.affectedRelationIds ?? []]),
+    projectIds: uniqueStrings([...existing.projectIds ?? [], ...next.projectIds ?? []]),
+    relatedSignalIds: uniqueStrings([...existing.relatedSignalIds ?? [], ...next.relatedSignalIds ?? []]),
+    relatedMotifIds: uniqueStrings([...existing.relatedMotifIds ?? [], ...next.relatedMotifIds ?? []]),
+    relatedTransferEventIds: uniqueStrings([...existing.relatedTransferEventIds ?? [], ...next.relatedTransferEventIds ?? []]),
+    relatedInterventionIds: uniqueStrings([...existing.relatedInterventionIds ?? [], ...next.relatedInterventionIds ?? []]),
+    evidence: mergeEvidence(existing.evidence, next.evidence)
+  };
+}
+function deriveTopologyReviewCandidates() {
+  const graph = loadSkillGraph();
+  const skills = loadAllGeneralSkills();
+  const preview = previewNetworkOptimization(graph, skills);
+  const governance = getActiveGovernanceSummary();
+  const pressureMotifs = loadPressureMotifs();
+  const resolvedSignals = loadResolvedPressureSignals();
+  const candidates = [];
+  for (const merge of preview.merged) {
+    candidates.push(buildMergeReviewCandidate({
+      slugA: merge.slugs[0],
+      slugB: merge.slugs[1],
+      combinedStrength: merge.combinedStrength,
+      confidence: merge.confidence,
+      governanceMode: governance.activeMode
+    }));
+  }
+  for (const split of preview.split) {
+    candidates.push(buildSplitReviewCandidate({
+      slug: split.slug,
+      contentLength: split.contentLength,
+      failureCount: split.failureCount,
+      confidence: split.confidence,
+      governanceMode: governance.activeMode
+    }));
+  }
+  for (const conflict of preview.conflicts) {
+    candidates.push(buildConflictReviewCandidate({
+      slugA: conflict.slugs[0],
+      slugB: conflict.slugs[1],
+      strength: conflict.strength,
+      governanceMode: governance.activeMode
+    }));
+  }
+  for (const motif of pressureMotifs) {
+    if (motif.lifecycle !== "addressed" && motif.suggestedRoute.route === "generalize") {
+      candidates.push(buildPromoteReviewCandidate(motif, governance.activeMode));
+    }
+    if (motif.lifecycle === "addressed" && (motif.linkedTransferEventIds?.length ?? 0) > 0 && motif.sourceSkillIds.length > 0) {
+      candidates.push(buildConsolidateReviewCandidate(motif, governance.activeMode));
+    }
+  }
+  const manualGroups = new Map;
+  for (const signal of resolvedSignals) {
+    if (signal.lifecycle === "addressed")
+      continue;
+    if (signal.routeRecommendation?.route !== "manual-review")
+      continue;
+    const regionKey = pressureRegionKey(signal);
+    const entries = manualGroups.get(regionKey) ?? [];
+    entries.push(signal);
+    manualGroups.set(regionKey, entries);
+  }
+  for (const signals of manualGroups.values()) {
+    candidates.push(buildManualRouteReviewCandidate(signals, governance.activeMode));
+  }
+  return candidates.sort((a, b) => priorityRank(b.priority) - priorityRank(a.priority) || b.confidence - a.confidence || b.lastObservedAt.localeCompare(a.lastObservedAt) || a.title.localeCompare(b.title));
+}
+function refreshTopologyReviewCandidates() {
+  const existing = loadStoredTopologyReviewCandidates();
+  const derived = deriveTopologyReviewCandidates();
+  const byKey = new Map(existing.map((candidate) => [candidate.reviewKey, candidate]));
+  let created = 0;
+  let updated = 0;
+  for (const candidate of derived) {
+    const current = byKey.get(candidate.reviewKey);
+    if (!current) {
+      byKey.set(candidate.reviewKey, candidate);
+      created += 1;
+      continue;
+    }
+    byKey.set(candidate.reviewKey, mergeTopologyCandidate(current, candidate));
+    updated += 1;
+  }
+  const merged = [...byKey.values()].sort((a, b) => b.lastObservedAt.localeCompare(a.lastObservedAt) || a.title.localeCompare(b.title));
+  saveTopologyReviewCandidates(merged);
+  const resolved = loadResolvedTopologyReviewCandidates();
+  return {
+    created,
+    updated,
+    total: resolved.length,
+    open: resolved.filter((candidate) => candidate.status === "open").length,
+    candidates: resolved
+  };
+}
+function loadResolvedTopologyReviewCandidates() {
+  const candidates = loadStoredTopologyReviewCandidates();
+  const latestDecisionByCandidate = new Map;
+  for (const decision of loadTopologyReviewDecisions()) {
+    const existing = latestDecisionByCandidate.get(decision.candidateId);
+    if (!existing || decision.decidedAt > existing.decidedAt) {
+      latestDecisionByCandidate.set(decision.candidateId, decision);
+    }
+  }
+  return candidates.map((candidate) => {
+    const latestDecision = latestDecisionByCandidate.get(candidate.id);
+    const status = latestDecision?.decision ?? "open";
+    return {
+      ...candidate,
+      status,
+      latestDecision,
+      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));
+}
+function getTopologyReviewSummary() {
+  const candidates = loadResolvedTopologyReviewCandidates();
+  const byChangeType = topologyChangeCounts();
+  for (const candidate of candidates) {
+    byChangeType[candidate.changeType] += 1;
+  }
+  return {
+    total: candidates.length,
+    open: candidates.filter((candidate) => candidate.status === "open").length,
+    accepted: candidates.filter((candidate) => candidate.status === "accepted").length,
+    rejected: candidates.filter((candidate) => candidate.status === "rejected").length,
+    deferred: candidates.filter((candidate) => candidate.status === "deferred").length,
+    highPriorityOpen: candidates.filter((candidate) => candidate.status === "open" && candidate.priority === "high").length,
+    generatedFromManualReview: candidates.filter((candidate) => candidate.source === "manual-route").length,
+    byChangeType,
+    backlog: candidates.filter((candidate) => candidate.status === "open" || candidate.status === "deferred").slice(0, 10),
+    recentDecisions: candidates.filter((candidate) => candidate.status !== "open").slice(0, 8)
+  };
+}
+function buildDerivedEvolutionArtifact(iteration, proposal) {
+  return {
+    id: `artifact_derived_${iteration.id}_${proposal.id}`,
+    createdAt: iteration.timestamp,
+    artifactType: "evolution",
+    provenance: "derived-history",
+    sourceId: iteration.id,
+    iterationId: iteration.id,
+    proposalId: proposal.id,
+    title: `${proposal.targetSkill} · ${proposal.action}`,
+    summary: proposal.description,
+    targetSkill: proposal.targetSkill,
+    operation: proposal.action,
+    outcome: proposal.outcome,
+    trigger: iteration.trigger,
+    judgeScores: {
+      taskCompletion: proposal.judges.taskCompletion.score,
+      correctionAlignment: proposal.judges.correctionAlignment.score,
+      sideEffectCheck: proposal.judges.sideEffectCheck.score
+    },
+    regression: proposal.regressionResult,
+    metrics: {
+      regressionPassRate: proposal.regressionResult.passRate,
+      proposalConsensus: proposal.consensus ? 1 : 0
+    }
+  };
+}
+function deriveEvolutionArtifactsFromHistory(history = loadHistory()) {
+  const artifacts = [];
+  for (const iteration of history.iterations) {
+    for (const proposal of iteration.proposals) {
+      artifacts.push(buildDerivedEvolutionArtifact(iteration, proposal));
+    }
+  }
+  return artifacts.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+function inferFailurePressurePriority(failure) {
+  if (failure.correctionType === "manual_edit" || failure.correctionType === "mode_switch")
+    return "high";
+  if ((failure.skillsActive.length ?? 0) === 0)
+    return "high";
+  if (failure.correctionType === "retry")
+    return "medium";
+  return "low";
+}
+function inferFailurePressureSeverity(failure) {
+  const base = failure.correctionType === "manual_edit" ? 0.95 : failure.correctionType === "mode_switch" ? 0.9 : failure.correctionType === "retry" ? 0.72 : 0.65;
+  return failure.skillsActive.length === 0 ? Math.min(1, base + 0.08) : base;
+}
+function buildDerivedPressureSignalFromFailure(failure) {
+  return {
+    id: `pressure_derived_${failure.id}`,
+    kind: `correction:${failure.correctionType}`,
+    provenance: "failure-derived",
+    sourceType: "failure",
+    sourceId: failure.id,
+    projectId: failure.project ?? undefined,
+    detectedAt: failure.timestamp,
+    severity: inferFailurePressureSeverity(failure),
+    priority: inferFailurePressurePriority(failure),
+    description: failure.correction,
+    relatedFailureId: failure.id,
+    relatedActivationTraceId: failure.activationTraceId,
+    skillIds: failure.skillsActive,
+    status: failure.resolved ? "addressed" : "open"
+  };
+}
+function loadProjectProfilesForPressure() {
+  const projectsDir = join3(getHelixDir(), "projects");
+  if (!existsSync3(projectsDir))
+    return [];
+  try {
+    return readdirSync2(projectsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => {
+      const profilePath = join3(projectsDir, entry.name, "profile.json");
+      if (!existsSync3(profilePath))
+        return null;
+      try {
+        return JSON.parse(readFileSync3(profilePath, "utf-8"));
+      } catch {
+        return null;
+      }
+    }).filter((profile) => profile !== null);
+  } catch {
+    return [];
+  }
+}
+function buildDerivedProfileGapPressureSignals(profile) {
+  return profile.gaps.map((gap, index) => ({
+    id: `pressure_profile_${profile.name}_${index}`,
+    kind: `gap:${gap.area}`,
+    provenance: "profile-gap-derived",
+    sourceType: "project-analysis",
+    sourceId: profile.path,
+    projectId: profile.name,
+    projectPath: profile.path,
+    detectedAt: profile.analyzedAt,
+    severity: gap.priority === "high" ? 0.95 : gap.priority === "medium" ? 0.75 : 0.55,
+    priority: gap.priority,
+    capability: gap.area,
+    description: gap.description,
+    suggestedAction: gap.suggestedAction,
+    skillIds: profile.matchedSkills.map((skill) => skill.slug),
+    status: "open"
+  }));
+}
+function derivePressureSignalsFromFailures(failures = loadFailures()) {
+  return failures.map(buildDerivedPressureSignalFromFailure).sort((a, b) => b.detectedAt.localeCompare(a.detectedAt));
+}
+function loadPressureSignals() {
+  const nativeSignals = loadNativePressureSignals();
+  const derivedFailureSignals = derivePressureSignalsFromFailures();
+  const derivedProfileSignals = loadProjectProfilesForPressure().flatMap(buildDerivedProfileGapPressureSignals);
+  const nativeKeys = new Set(nativeSignals.map((signal) => `${signal.sourceId}:${signal.kind}`));
+  return [
+    ...nativeSignals,
+    ...derivedFailureSignals.filter((signal) => !nativeKeys.has(`${signal.sourceId}:${signal.kind}`)),
+    ...derivedProfileSignals.filter((signal) => !nativeKeys.has(`${signal.sourceId}:${signal.kind}`))
+  ].sort((a, b) => b.detectedAt.localeCompare(a.detectedAt));
+}
+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));
+}
+function normalizePressureValue(value) {
+  return (value ?? "").trim().toLowerCase().replace(/[\s_/]+/g, "-");
+}
+function pressureRegionKey(signal) {
+  return normalizePressureValue(signal.capability ?? signal.region ?? signal.kind) || "general-pressure";
+}
+function motifIdForSignal(signal) {
+  return `motif_${pressureRegionKey(signal)}`;
+}
+function pressureComparisonKey(signal) {
+  const projectKey = normalizePressureValue(signal.projectId ?? signal.projectPath ?? "global");
+  return `${projectKey}::${pressureRegionKey(signal)}`;
+}
+function interventionComparisonKeys(intervention) {
+  const projectKey = normalizePressureValue(intervention.projectId ?? intervention.projectPath ?? "global");
+  const capabilityKeys = (intervention.capabilities?.length ?? 0) > 0 ? intervention.capabilities ?? [] : [""];
+  return capabilityKeys.map((capability) => `${projectKey}::${normalizePressureValue(capability)}`);
+}
+function signalMatchesInterventionFallback(signal, intervention) {
+  if (intervention.pressureSignalIds?.includes(signal.id))
+    return true;
+  if (intervention.scope === "network")
+    return false;
+  if (signal.relatedFailureId && intervention.relatedFailureIds?.includes(signal.relatedFailureId))
+    return true;
+  if (signal.relatedActivationTraceId && intervention.relatedActivationTraceIds?.includes(signal.relatedActivationTraceId))
+    return true;
+  const signalKey = pressureComparisonKey(signal);
+  if (interventionComparisonKeys(intervention).includes(signalKey))
+    return true;
+  if (signal.projectId && intervention.projectId && signal.projectId !== intervention.projectId)
+    return false;
+  if (signal.projectPath && intervention.projectPath && signal.projectPath !== intervention.projectPath)
+    return false;
+  if (signal.capability && (intervention.capabilities?.length ?? 0) > 0) {
+    return intervention.capabilities?.some((capability) => normalizePressureValue(capability) === normalizePressureValue(signal.capability)) ?? false;
+  }
+  return false;
+}
+function motifMatchesIntervention(motifId, signals, intervention) {
+  if (intervention.motifIds?.includes(motifId))
+    return true;
+  if (signals.some((signal) => intervention.pressureSignalIds?.includes(signal.id)))
+    return true;
+  if (intervention.scope === "network") {
+    const signalKeys = new Set(signals.map((signal) => pressureRegionKey(signal)));
+    return (intervention.capabilities ?? []).some((capability) => signalKeys.has(normalizePressureValue(capability)));
+  }
+  return false;
+}
+function transferMatchesMotif(motifId, signals, event) {
+  if (event.motifIds?.includes(motifId))
+    return true;
+  const capabilities = new Set(signals.map((signal) => normalizePressureValue(signal.capability ?? signal.kind)).filter(Boolean));
+  return (event.capabilityIds ?? []).some((capability) => capabilities.has(normalizePressureValue(capability)));
+}
+function deriveGovernanceSummary(pressureSignals = loadPressureSignals(), interventions = loadPressureInterventions()) {
+  const highPrioritySignals = pressureSignals.filter((signal) => signal.priority === "high" && signal.status !== "addressed").length;
+  const recurringCrossProjectRegions = new Map;
+  for (const signal of pressureSignals) {
+    const projectId = signal.projectId ?? signal.projectPath;
+    if (!projectId)
+      continue;
+    const projects = recurringCrossProjectRegions.get(pressureRegionKey(signal)) ?? new Set;
+    projects.add(projectId);
+    recurringCrossProjectRegions.set(pressureRegionKey(signal), projects);
+  }
+  const crossProjectMotifs = [...recurringCrossProjectRegions.values()].filter((projects) => projects.size >= 2).length;
+  const exploratoryRuns = interventions.filter((intervention) => intervention.status === "dry-run" || intervention.impact === "exploratory").length;
+  const failedRuns = interventions.filter((intervention) => intervention.status === "failed").length;
+  const resolvingRuns = interventions.filter((intervention) => intervention.status === "completed" && intervention.impact === "resolving").length;
+  let derivedMode = "balanced";
+  let derivedRationale = [
+    "Current pressure is mixed across local response and broader transfer opportunities.",
+    "Governance should keep local adaptation and cross-project learning in balance."
+  ];
+  if (crossProjectMotifs >= 2) {
+    derivedMode = "transfer-focused";
+    derivedRationale = [
+      `${crossProjectMotifs} recurring pressure motifs now span multiple projects.`,
+      "Promoting reusable abstractions has higher leverage than only local adaptation right now."
+    ];
+  } else if (highPrioritySignals >= 4) {
+    derivedMode = "project-critical";
+    derivedRationale = [
+      `${highPrioritySignals} high-priority pressure signals still need response.`,
+      "Governance should bias toward project-bounded stabilization before broader promotion work."
+    ];
+  } else if (exploratoryRuns > resolvingRuns + 1) {
+    derivedMode = "exploration";
+    derivedRationale = [
+      `${exploratoryRuns} exploratory responses outweigh resolving outcomes.`,
+      "The network is still learning where the strongest durable response should be routed."
+    ];
+  } else if (failedRuns >= 2 && resolvingRuns === 0) {
+    derivedMode = "conservative";
+    derivedRationale = [
+      `${failedRuns} recent response attempts failed without resolving evidence.`,
+      "Governance should slow promotion and prefer clearer evidence before acting broadly."
+    ];
+  } else if (resolvingRuns >= 3 && highPrioritySignals <= 2) {
+    derivedMode = "consolidation-focused";
+    derivedRationale = [
+      `${resolvingRuns} resolving responses already landed recently.`,
+      "The network is in a good position to consolidate what it has learned."
+    ];
+  }
+  const state = loadGovernanceState();
+  if (state.selectionMode === "manual" && state.manualMode) {
+    return {
+      activeMode: state.manualMode,
+      derivedMode,
+      source: "operator-selected",
+      manualMode: state.manualMode,
+      rationale: [
+        `Operator selected ${state.manualMode} governance on ${state.updatedAt}.`,
+        `Derived mode would currently be ${derivedMode}.`,
+        ...derivedRationale
+      ],
+      profile: governanceProfileForMode(state.manualMode)
+    };
+  }
+  return {
+    activeMode: derivedMode,
+    derivedMode,
+    source: "derived",
+    rationale: derivedRationale,
+    profile: governanceProfileForMode(derivedMode)
+  };
+}
+function getActiveGovernanceSummary() {
+  return deriveGovernanceSummary();
+}
+function buildRouteRecommendation(params) {
+  const { signal, relatedSignals, linkedInterventions, governanceMode } = 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 = [];
+  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 {
+      route: "manual-review",
+      scope: projectSpread >= 2 ? "network" : signal.projectId ? "project" : "local",
+      confidence: 0.58,
+      governanceMode,
+      triggeredBy: "mixed-signal",
+      reasons
+    };
+  }
+  if (projectSpread >= 2 && recurrenceCount >= 2) {
+    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") {
+    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 {
+      route: "specialize",
+      scope: "project",
+      confidence: 0.82,
+      governanceMode,
+      triggeredBy: "high-priority-local-gap",
+      reasons
+    };
+  }
+  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 {
+      route: "evolve",
+      scope: signal.projectId ? "project" : "local",
+      confidence: 0.78,
+      governanceMode,
+      triggeredBy: "accepted-iteration-pattern",
+      reasons
+    };
+  }
+  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 {
+      route: "research",
+      scope: signal.projectId ? "project" : "local",
+      confidence: 0.68,
+      governanceMode,
+      triggeredBy: "insufficient-evidence",
+      reasons
+    };
+  }
+  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 {
+      route: "specialize",
+      scope: "project",
+      confidence: 0.7,
+      governanceMode,
+      triggeredBy: "project-bounded-recurrence",
+      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
+  };
+}
+function interventionEvidenceAccepted(intervention, acceptedProposalIds, acceptedArtifactIds, realizedTransferEventIds) {
+  if (intervention.status !== "completed" || intervention.impact !== "resolving")
+    return false;
+  if (intervention.relatedTransferEventIds?.some((id) => realizedTransferEventIds.has(id)))
+    return true;
+  if (intervention.relatedProposalIds?.some((id) => acceptedProposalIds.has(id))) {
+    return !(intervention.interventionType === "generalize" && intervention.scope === "network");
+  }
+  if (intervention.relatedArtifactIds?.some((id) => acceptedArtifactIds.has(id))) {
+    return !(intervention.interventionType === "generalize" && intervention.scope === "network");
+  }
+  if (intervention.interventionType !== "generalize")
+    return Boolean(intervention.relatedSkillSlugs?.length);
+  return false;
+}
+function interventionKeepsPressureActive(impact, status) {
+  if (status === "failed" || status === "dry-run")
+    return false;
+  return impact === "exploratory" || impact === "structural" || impact === "resolving";
+}
+function loadResolvedPressureSignals() {
+  const pressureSignals = loadPressureSignals();
+  const interventions = loadPressureInterventions();
+  const transferEvents = loadTransferEvents();
+  const history = loadHistory();
+  const artifacts = loadEvolutionArtifacts();
+  const governance = deriveGovernanceSummary(pressureSignals, interventions);
+  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));
+  const latestSignalByKey = new Map;
+  const signalsByRegion = new Map;
+  for (const signal of pressureSignals) {
+    const comparisonKey = pressureComparisonKey(signal);
+    const existing = latestSignalByKey.get(comparisonKey);
+    if (!existing || signal.detectedAt > existing) {
+      latestSignalByKey.set(comparisonKey, signal.detectedAt);
+    }
+    const regionKey = pressureRegionKey(signal);
+    const regionSignals = signalsByRegion.get(regionKey) ?? [];
+    regionSignals.push(signal);
+    signalsByRegion.set(regionKey, regionSignals);
+  }
+  return pressureSignals.map((signal) => {
+    const linkedInterventions = interventions.filter((intervention) => signalMatchesInterventionFallback(signal, intervention));
+    const addressingInterventions = linkedInterventions.filter((intervention) => interventionEvidenceAccepted(intervention, acceptedProposalIds, acceptedArtifactIds, realizedTransferEventIds));
+    const activeInterventions = linkedInterventions.filter((intervention) => interventionKeepsPressureActive(intervention.impact, intervention.status));
+    const latestInterventionAt = linkedInterventions.map((intervention) => intervention.completedAt ?? intervention.createdAt).sort((a, b) => b.localeCompare(a))[0];
+    const latestSignalAt = latestSignalByKey.get(pressureComparisonKey(signal)) ?? signal.detectedAt;
+    const hasNewerEquivalentSignal = latestSignalAt > signal.detectedAt;
+    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 routeRecommendation = buildRouteRecommendation({
+      signal,
+      relatedSignals,
+      linkedInterventions,
+      governanceMode: governance.activeMode
+    });
+    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}`;
+    return {
+      ...signal,
+      lifecycle,
+      linkedInterventions,
+      interventionTypes,
+      motifIds,
+      routeRecommendation,
+      lastActivityAt,
+      addressedAt,
+      responseSummary
+    };
+  });
+}
+function loadPressureMotifs() {
+  const resolvedSignals = loadResolvedPressureSignals();
+  const interventions = loadPressureInterventions();
+  const transferEvents = loadTransferEvents();
+  const groups = new Map;
+  for (const signal of resolvedSignals) {
+    const regionKey = pressureRegionKey(signal);
+    const entries = groups.get(regionKey) ?? [];
+    entries.push(signal);
+    groups.set(regionKey, entries);
+  }
+  const motifs = [];
+  for (const [regionKey, signals] of groups.entries()) {
+    const projectIds = [...new Set(signals.map((signal) => signal.projectId ?? signal.projectPath).filter(Boolean))];
+    if (signals.length < 2 && projectIds.length < 2)
+      continue;
+    const motifId = `motif_${regionKey}`;
+    const linkedInterventions = interventions.filter((intervention) => motifMatchesIntervention(motifId, signals, intervention));
+    const linkedTransferEvents = transferEvents.filter((event) => transferMatchesMotif(motifId, signals, event));
+    const activeInterventions = linkedInterventions.filter((intervention) => interventionKeepsPressureActive(intervention.impact, intervention.status));
+    const realizedTransfers = linkedTransferEvents.filter((event) => event.status === "realized");
+    const allAddressed = signals.every((signal) => signal.lifecycle === "addressed");
+    const allStale = signals.every((signal) => signal.lifecycle === "stale");
+    const lifecycle = realizedTransfers.length > 0 || allAddressed ? "addressed" : activeInterventions.length > 0 ? "in-progress" : allStale ? "stale" : "open";
+    const interventionTypes = [...new Set(linkedInterventions.map((intervention) => intervention.interventionType))];
+    const recommendation = signals.find((signal) => signal.routeRecommendation?.route === "generalize")?.routeRecommendation ?? signals[0]?.routeRecommendation ?? {
+      route: "research",
+      scope: projectIds.length >= 2 ? "network" : "project",
+      confidence: 0.5,
+      governanceMode: deriveGovernanceSummary().activeMode,
+      triggeredBy: "insufficient-evidence",
+      reasons: ["Recurring pressure exists, but routing evidence remains coarse."]
+    };
+    const lastActivityAt = [
+      ...signals.map((signal) => signal.lastActivityAt),
+      ...linkedInterventions.map((intervention) => intervention.completedAt ?? intervention.createdAt),
+      ...linkedTransferEvents.map((event) => event.timestamp)
+    ].sort((a, b) => b.localeCompare(a))[0] ?? signals[0]?.lastActivityAt ?? new Date(0).toISOString();
+    const addressedAt = [
+      ...realizedTransfers.map((event) => event.timestamp),
+      ...signals.map((signal) => signal.addressedAt).filter(Boolean)
+    ].sort((a, b) => b.localeCompare(a))[0];
+    const capability = signals.find((signal) => Boolean(signal.capability))?.capability;
+    const description = signals.find((signal) => Boolean(signal.description))?.description ?? `Recurring pressure in ${capability ?? regionKey}`;
+    const sourceSkillIds = [...new Set(signals.flatMap((signal) => signal.skillIds ?? []))];
+    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}`;
+    motifs.push({
+      id: motifId,
+      key: regionKey,
+      kind: signals[0]?.kind ?? regionKey,
+      capability,
+      description,
+      createdAt: signals.map((signal) => signal.detectedAt).sort()[0] ?? lastActivityAt,
+      lastSeenAt: signals.map((signal) => signal.detectedAt).sort((a, b) => b.localeCompare(a))[0] ?? lastActivityAt,
+      projectIds,
+      pressureSignalIds: signals.map((signal) => signal.id),
+      sourceSkillIds,
+      recurrenceCount: signals.length,
+      highPriorityCount,
+      linkedInterventionIds,
+      linkedTransferEventIds,
+      suggestedRoute: recommendation,
+      lifecycle,
+      interventionTypes,
+      lastActivityAt,
+      addressedAt,
+      responseSummary
+    });
+  }
+  return motifs.sort((a, b) => {
+    const lifecycleWeight = (value) => value === "open" ? 4 : value === "in-progress" ? 3 : value === "addressed" ? 2 : 1;
+    return lifecycleWeight(b.lifecycle) - lifecycleWeight(a.lifecycle) || b.highPriorityCount - a.highPriorityCount || b.recurrenceCount - a.recurrenceCount || b.lastActivityAt.localeCompare(a.lastActivityAt);
+  });
+}
+function matchPressureSignals(filters) {
+  const capabilities = new Set((filters.capabilities ?? []).map((value) => normalizePressureValue(value)));
+  const relatedFailureIds = new Set(filters.relatedFailureIds ?? []);
+  const relatedActivationTraceIds = new Set(filters.relatedActivationTraceIds ?? []);
+  return loadResolvedPressureSignals().filter((signal) => filters.includeAddressed || signal.lifecycle !== "addressed").filter((signal) => !filters.projectId || signal.projectId === filters.projectId).filter((signal) => !filters.projectPath || signal.projectPath === filters.projectPath).filter((signal) => !filters.suggestedAction || signal.suggestedAction === filters.suggestedAction).filter((signal) => {
+    if (capabilities.size === 0)
+      return true;
+    const normalizedCapability = normalizePressureValue(signal.capability);
+    return normalizedCapability.length > 0 && capabilities.has(normalizedCapability);
+  }).filter((signal) => relatedFailureIds.size === 0 || Boolean(signal.relatedFailureId && relatedFailureIds.has(signal.relatedFailureId))).filter((signal) => relatedActivationTraceIds.size === 0 || Boolean(signal.relatedActivationTraceId && relatedActivationTraceIds.has(signal.relatedActivationTraceId))).sort((a, b) => {
+    const priorityScore = (value) => value === "high" ? 3 : value === "medium" ? 2 : 1;
+    return priorityScore(b.priority) - priorityScore(a.priority) || b.severity - a.severity || b.detectedAt.localeCompare(a.detectedAt);
+  });
+}
+function matchPressureMotifs(filters) {
+  const capabilities = new Set((filters.capabilities ?? []).map((value) => normalizePressureValue(value)));
+  const skillIds = new Set(filters.skillIds ?? []);
+  return loadPressureMotifs().filter((motif) => filters.includeAddressed || motif.lifecycle !== "addressed").filter((motif) => {
+    if (capabilities.size === 0)
+      return true;
+    const values = [motif.capability, motif.key, motif.kind].map((value) => normalizePressureValue(value)).filter(Boolean);
+    return values.some((value) => capabilities.has(value));
+  }).filter((motif) => skillIds.size === 0 || motif.sourceSkillIds.some((skillId) => skillIds.has(skillId))).sort((a, b) => b.highPriorityCount - a.highPriorityCount || b.recurrenceCount - a.recurrenceCount || b.lastActivityAt.localeCompare(a.lastActivityAt));
+}
+function loadEvolutionArtifacts() {
+  const nativeArtifacts = loadNativeEvolutionArtifacts();
+  const derivedArtifacts = deriveEvolutionArtifactsFromHistory();
+  const nativeProposalIds = new Set(nativeArtifacts.map((artifact) => artifact.proposalId).filter(Boolean));
+  const merged = [
+    ...nativeArtifacts,
+    ...derivedArtifacts.filter((artifact) => !artifact.proposalId || !nativeProposalIds.has(artifact.proposalId))
+  ];
+  return merged.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+var DEFAULT_GOVERNANCE_STATE, GOVERNANCE_PROFILES, DEFAULT_TOPOLOGY_OVERRIDES;
 var init_data = __esm(() => {
   init_ontology();
   init_config();
+  init_skills();
+  DEFAULT_GOVERNANCE_STATE = {
+    selectionMode: "auto",
+    updatedAt: new Date(0).toISOString()
+  };
+  GOVERNANCE_PROFILES = {
+    conservative: {
+      mode: "conservative",
+      reviewThreshold: 0.86,
+      riskTolerance: 0.28,
+      plasticityBias: 0.26,
+      explanation: "Prefer stronger evidence and slower structural change until risk falls."
+    },
+    balanced: {
+      mode: "balanced",
+      reviewThreshold: 0.74,
+      riskTolerance: 0.5,
+      plasticityBias: 0.5,
+      explanation: "Keep local stabilization and structural adaptation in balance."
+    },
+    exploration: {
+      mode: "exploration",
+      reviewThreshold: 0.62,
+      riskTolerance: 0.7,
+      plasticityBias: 0.72,
+      explanation: "Favor evidence gathering and wider structural exploration before locking in."
+    },
+    "project-critical": {
+      mode: "project-critical",
+      reviewThreshold: 0.82,
+      riskTolerance: 0.35,
+      plasticityBias: 0.34,
+      explanation: "Bias toward project-bounded stability and cautious structural change."
+    },
+    "consolidation-focused": {
+      mode: "consolidation-focused",
+      reviewThreshold: 0.78,
+      riskTolerance: 0.42,
+      plasticityBias: 0.44,
+      explanation: "Favor consolidating proven patterns into stable reusable structure."
+    },
+    "transfer-focused": {
+      mode: "transfer-focused",
+      reviewThreshold: 0.68,
+      riskTolerance: 0.6,
+      plasticityBias: 0.68,
+      explanation: "Bias toward cross-project promotion and reusable topology upgrades."
+    }
+  };
+  DEFAULT_TOPOLOGY_OVERRIDES = {
+    updatedAt: new Date(0).toISOString(),
+    nodeOverrides: {},
+    suppressedEdges: [],
+    addedEdges: [],
+    appliedPlanIds: []
+  };
 });
 
 // src/utils/llm.ts
@@ -10810,9 +11937,11 @@ async function evolveCommand(options) {
   }
   const generation = getCurrentGeneration() + 1;
   const iterationId = generateIterationId();
+  const governance = getActiveGovernanceSummary();
   const proposals = [];
   const failureClusters = [];
   const artifacts = [];
+  const interventions = [];
   let proposalCount = 0;
   for (const cluster of clusters.clusters) {
     if (proposalCount >= maxProposals)
@@ -10941,6 +12070,32 @@ async function evolveCommand(options) {
         regressionPassRate: regressionResult.passRate
       }
     });
+    const matchedPressureSignals = matchPressureSignals({
+      relatedFailureIds: clusterFailures.map((failure) => failure.id),
+      relatedActivationTraceIds: clusterFailures.map((failure) => failure.activationTraceId).filter(Boolean)
+    });
+    interventions.push({
+      id: `intervention_evolve_${proposalId}`,
+      interventionType: "evolve",
+      status: dryRun ? "dry-run" : "completed",
+      impact: finalAccepted ? "resolving" : consensus || passedRegression ? "exploratory" : "none",
+      createdAt: artifactCreatedAt,
+      completedAt: artifactCreatedAt,
+      sourceId: `evolve:${iterationId}:${proposalId}`,
+      projectId: matchedPressureSignals[0]?.projectId ?? clusterFailures.find((failure) => Boolean(failure.project))?.project ?? undefined,
+      projectPath: matchedPressureSignals[0]?.projectPath,
+      scope: matchedPressureSignals.some((signal) => Boolean(signal.projectId ?? signal.projectPath)) ? "project" : "local",
+      governanceMode: governance.activeMode,
+      capabilities: matchedPressureSignals.map((signal) => signal.capability).filter(Boolean),
+      pressureSignalIds: matchedPressureSignals.map((signal) => signal.id),
+      relatedFailureIds: clusterFailures.map((failure) => failure.id),
+      relatedActivationTraceIds: clusterFailures.map((failure) => failure.activationTraceId).filter(Boolean),
+      relatedProposalIds: [proposalId],
+      relatedArtifactIds: dryRun ? [] : [`artifact_${proposalId}`],
+      relatedSkillSlugs: finalAccepted ? [skillSlug] : [],
+      reasonSummary: `Evolution processed cluster "${cluster.type}" across ${clusterFailures.length} failures.`,
+      notes: dryRun ? "Evolution ran in dry-run mode, so proposal evidence is exploratory only." : undefined
+    });
     if (finalAccepted && !dryRun) {
       const { meta, content } = parseSkillMd(proposalOutput.proposedSkillMd);
       const skillSlug2 = proposalOutput.targetSkill ?? proposal.targetSkill;
@@ -11006,6 +12161,9 @@ async function evolveCommand(options) {
       appendEvolutionArtifact(artifact);
     }
   }
+  for (const intervention of interventions) {
+    appendPressureIntervention(intervention);
+  }
   if (hasGraph) {
     const accepted2 = proposals.filter((p) => p.outcome === "accepted");
     if (accepted2.length > 0) {
@@ -11335,12 +12493,16 @@ async function reportCommand(options) {
 // src/commands/generalize.ts
 init_config();
 init_skills();
+init_data();
 init_llm();
 import { join as join11 } from "node:path";
 async function generalizeCommand(options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
   const skills = loadAllGeneralSkills();
+  const iterationId = generateIterationId();
+  const startedAt = new Date().toISOString();
+  const governance = getActiveGovernanceSummary();
   console.log(`\uD83D\uDD2C HelixEvo Generalization Analysis
 `);
   if (skills.length < 2) {
@@ -11356,6 +12518,9 @@ async function generalizeCommand(options) {
   console.log(`  → ${candidates.length} candidate(s) found
 `);
   const proposals = [];
+  const artifacts = [];
+  const transferEvents = [];
+  const interventions = [];
   for (const candidate of candidates) {
     console.log(`  Candidate: "${candidate.suggestedName}" (${candidate.suggestedLayer} layer)`);
     console.log(`    Skills: ${candidate.skills.join(", ")}`);
@@ -11376,6 +12541,12 @@ async function generalizeCommand(options) {
 `);
     }
     const proposalId = generateProposalId();
+    const matchedMotifs = matchPressureMotifs({ skillIds: candidate.skills });
+    const matchedCapabilities = [...new Set(matchedMotifs.map((motif) => motif.capability ?? motif.key).filter(Boolean))];
+    const sourceProjects = [...new Set(matchedMotifs.flatMap((motif) => motif.projectIds))];
+    const artifactId = `artifact_generalize_${proposalId}`;
+    const transferEventId = `transfer_generalize_${proposalId}`;
+    const completedAt = new Date().toISOString();
     const proposal = {
       id: proposalId,
       targetSkill: candidate.suggestedName,
@@ -11398,7 +12569,7 @@ async function generalizeCommand(options) {
       meta.layer = candidate.suggestedLayer;
       meta.generation = 1;
       meta.score = candidate.confidence;
-      meta.lastEvolved = new Date().toISOString();
+      meta.lastEvolved = completedAt;
       const skillDir = join11(getGeneralSkillsPath(), candidate.suggestedName);
       writeSkill(skillDir, meta, content);
       console.log(`    ✓ Created: ${candidate.suggestedName} (${candidate.suggestedLayer} layer)
@@ -11411,20 +12582,83 @@ async function generalizeCommand(options) {
             console.log(`    ↳ ${sourceSkill.slug}.parent → ${candidate.suggestedName}`);
         }
       }
+      artifacts.push({
+        id: artifactId,
+        createdAt: completedAt,
+        artifactType: "evolution",
+        provenance: "native-evolution",
+        title: `${candidate.suggestedName} generalized from recurring overlap`,
+        summary: `Promoted ${candidate.skills.join(", ")} into reusable ${candidate.suggestedLayer}-layer knowledge.`,
+        sourceId: `generalize:${iterationId}`,
+        iterationId,
+        proposalId,
+        targetSkill: candidate.suggestedName,
+        operation: "generalize",
+        outcome: "accepted",
+        trigger: "weekly_generalize",
+        metrics: {
+          motifCount: matchedMotifs.length,
+          projectSpread: new Set(sourceProjects).size,
+          sourceSkillCount: candidate.skills.length
+        }
+      });
+      transferEvents.push({
+        id: transferEventId,
+        timestamp: completedAt,
+        sourceSkillIds: candidate.skills,
+        targetSkillIds: [candidate.suggestedName],
+        capabilityIds: matchedCapabilities,
+        motifIds: matchedMotifs.map((motif) => motif.id),
+        transferType: sourceProjects.length >= 2 ? "cross-project" : "domain-transfer",
+        evidenceIds: [proposalId, artifactId],
+        benefitEstimate: Math.min(1, 0.55 + matchedMotifs.length * 0.1 + Math.max(0, sourceProjects.length - 1) * 0.08),
+        status: "realized",
+        summary: `Generalized ${candidate.skills.join(", ")} into ${candidate.suggestedName} from ${matchedMotifs.length} recurring motif(s).`
+      });
     } else {
       console.log(`    [DRY RUN] Would create: ${candidate.suggestedName}
 `);
     }
+    interventions.push({
+      id: `intervention_generalize_${proposalId}`,
+      interventionType: "generalize",
+      status: dryRun ? "dry-run" : "completed",
+      impact: matchedMotifs.length > 0 ? "resolving" : "structural",
+      createdAt: startedAt,
+      completedAt,
+      sourceId: `generalize:${iterationId}:${proposalId}`,
+      scope: "network",
+      governanceMode: governance.activeMode,
+      capabilities: matchedCapabilities.length > 0 ? matchedCapabilities : [candidate.suggestedName],
+      motifIds: matchedMotifs.map((motif) => motif.id),
+      relatedProposalIds: [proposalId],
+      relatedArtifactIds: dryRun ? [] : [artifactId],
+      relatedTransferEventIds: dryRun ? [] : [transferEventId],
+      relatedSkillSlugs: dryRun ? [] : [candidate.suggestedName],
+      reasonSummary: `Generalization promoted overlap shared by ${candidate.skills.join(", ")} into ${candidate.suggestedName}.`,
+      notes: dryRun ? "Generalization ran in dry-run mode, so promotion remained exploratory only." : matchedMotifs.length > 0 ? `Linked to ${matchedMotifs.length} recurring motif(s) under ${governance.activeMode} governance.` : `No explicit recurring motif matched, so this generalization should be treated as structural rather than motif-closing evidence.`
+    });
     proposals.push(proposal);
   }
   addIteration({
-    id: generateIterationId(),
+    id: iterationId,
     timestamp: new Date().toISOString(),
     trigger: "weekly_generalize",
     failureCount: 0,
     failureClusters: [],
     proposals
   });
+  if (!dryRun) {
+    for (const artifact of artifacts) {
+      appendEvolutionArtifact(artifact);
+    }
+    for (const event of transferEvents) {
+      appendTransferEvent(event);
+    }
+  }
+  for (const intervention of interventions) {
+    appendPressureIntervention(intervention);
+  }
   const created = proposals.filter((p) => p.outcome === "accepted").length;
   console.log(`
 ─── Generalization Summary ───`);
@@ -11512,6 +12746,8 @@ async function specializeCommand(options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
   const projectName = options.project;
+  const startedAt = new Date().toISOString();
+  const governance = getActiveGovernanceSummary();
   if (!projectName) {
     console.error("  Error: --project <name> is required");
     process.exit(1);
@@ -11525,9 +12761,41 @@ async function specializeCommand(options) {
     console.log("  Keep working on this project — failures are captured automatically.");
     return;
   }
+  const persistSpecializationIntervention = (params) => {
+    const matchedSignals = matchPressureSignals({
+      projectId: projectName,
+      relatedFailureIds: failures.map((failure) => failure.id),
+      suggestedAction: "specialize"
+    });
+    const fallbackSignals = matchedSignals.length > 0 ? matchedSignals : matchPressureSignals({
+      projectId: projectName,
+      relatedFailureIds: failures.map((failure) => failure.id)
+    });
+    appendPressureIntervention({
+      id: `intervention_specialize_${Date.now()}`,
+      interventionType: "specialize",
+      status: dryRun ? "dry-run" : "completed",
+      impact: params.createdSkills && params.createdSkills.length > 0 ? "resolving" : (params.proposals?.length ?? 0) > 0 || (params.candidatePatterns?.length ?? 0) > 0 ? "structural" : "none",
+      createdAt: startedAt,
+      completedAt: new Date().toISOString(),
+      sourceId: params.iterationId ? `specialize:${params.iterationId}` : `specialize:${projectName}`,
+      projectId: projectName,
+      scope: "project",
+      governanceMode: governance.activeMode,
+      capabilities: params.candidatePatterns ?? fallbackSignals.map((signal) => signal.capability).filter(Boolean),
+      pressureSignalIds: fallbackSignals.map((signal) => signal.id),
+      relatedFailureIds: failures.map((failure) => failure.id),
+      relatedActivationTraceIds: failures.map((failure) => failure.activationTraceId).filter(Boolean),
+      relatedProposalIds: params.proposals?.map((proposal) => proposal.id) ?? [],
+      relatedSkillSlugs: params.createdSkills ?? [],
+      reasonSummary: `Specialization reviewed ${failures.length} unresolved project failures for ${projectName}.`,
+      notes: dryRun ? "Specialization ran in dry-run mode and did not create project-layer skills." : undefined
+    });
+  };
   console.log("  Step 1: Detecting specialization opportunities...");
   const candidates = await detectSpecializationCandidates(skills, failures, projectName);
   if (candidates.length === 0) {
+    persistSpecializationIntervention({ candidatePatterns: [] });
     console.log("  No specialization candidates found.");
     return;
   }
@@ -11589,8 +12857,9 @@ async function specializeCommand(options) {
     }
     proposals.push(proposal);
   }
+  const iterationId = generateIterationId();
   addIteration({
-    id: generateIterationId(),
+    id: iterationId,
     timestamp: new Date().toISOString(),
     trigger: "manual",
     failureCount: failures.length,
@@ -11598,6 +12867,12 @@ async function specializeCommand(options) {
     proposals
   });
   const created = proposals.filter((p) => p.outcome === "accepted").length;
+  persistSpecializationIntervention({
+    proposals,
+    iterationId,
+    candidatePatterns: candidates.flatMap((candidate) => candidate.projectPatterns),
+    createdSkills: proposals.filter((proposal) => proposal.outcome === "accepted").map((proposal) => proposal.targetSkill)
+  });
   console.log(`
 ─── Specialization Summary ───`);
   console.log(`  Project:     ${projectName}`);
@@ -11769,9 +13044,10 @@ async function fullRebuild(verbose) {
     clusters
   };
   saveSkillGraph(graph);
+  const effectiveGraph = loadSkillGraph();
   if (verbose)
     console.log(`  ✓ Graph saved: ${nodes.length} nodes, ${graph.edges.length} edges, ${clusters.length} clusters`);
-  return graph;
+  return effectiveGraph;
 }
 async function inferRelationships(skills) {
   const summaries = skills.map((s) => `- ${s.slug} (${s.meta.layer ?? "domain"}): ${s.meta.description?.slice(0, 100)}`).join(`
@@ -11938,6 +13214,9 @@ function nid(slug) {
   return slug.replace(/[^a-zA-Z0-9]/g, "_");
 }
 
+// src/commands/graph.ts
+init_data();
+
 // src/core/network-opt.ts
 init_data();
 init_skills();
@@ -11945,8 +13224,13 @@ init_llm();
 async function optimizeNetwork(verbose = false) {
   const graph = loadSkillGraph();
   const skills = loadAllGeneralSkills();
-  const result = { merged: [], split: [], conflictsResolved: [] };
-  const conflicts = graph.edges.filter((e) => e.type === "conflicts");
+  const preview = previewNetworkOptimization(graph, skills);
+  const result = {
+    merged: preview.merged.map((candidate) => candidate.slugs),
+    split: preview.split.map((candidate) => candidate.slug),
+    conflictsResolved: []
+  };
+  const conflicts = graph.edges.filter((edge) => edge.type === "conflicts");
   if (conflicts.length > 0) {
     if (verbose)
       console.log(`  Resolving ${conflicts.length} conflict(s)...`);
@@ -11956,21 +13240,12 @@ async function optimizeNetwork(verbose = false) {
         result.conflictsResolved.push([conflict.from, conflict.to]);
     }
   }
-  const enhances = graph.edges.filter((e) => e.type === "enhances" && e.strength >= 0.8);
-  const coEvolves = graph.edges.filter((e) => e.type === "co-evolves" && e.strength >= 0.8);
-  const mergeCandidates = detectMergeCandidates(enhances, coEvolves, skills);
-  for (const [slugA, slugB] of mergeCandidates) {
-    if (verbose)
-      console.log(`  Merge candidate: ${slugA} + ${slugB}`);
-    result.merged.push([slugA, slugB]);
-  }
-  for (const skill of skills) {
-    const contentLength = skill.content.length;
-    const failureCount = skill.meta.failureCount ?? 0;
-    if (contentLength > 5000 || failureCount > 20) {
-      if (verbose)
-        console.log(`  Split candidate: ${skill.slug} (${contentLength} chars, ${failureCount} failures)`);
-      result.split.push(skill.slug);
+  if (verbose) {
+    for (const candidate of preview.merged) {
+      console.log(`  Merge candidate: ${candidate.slugs[0]} + ${candidate.slugs[1]} (${candidate.confidence.toFixed(2)})`);
+    }
+    for (const candidate of preview.split) {
+      console.log(`  Split candidate: ${candidate.slug} (${candidate.contentLength} chars, ${candidate.failureCount} failures, ${candidate.confidence.toFixed(2)})`);
     }
   }
   return result;
@@ -12012,25 +13287,6 @@ Return JSON:
   }
   return result.resolved;
 }
-function detectMergeCandidates(enhances, coEvolves, skills) {
-  const pairScores = {};
-  for (const edge of [...enhances, ...coEvolves]) {
-    const key = [edge.from, edge.to].sort().join("::");
-    pairScores[key] = (pairScores[key] ?? 0) + edge.strength;
-  }
-  const candidates = [];
-  for (const [key, score] of Object.entries(pairScores)) {
-    if (score >= 1.5) {
-      const [a, b] = key.split("::");
-      const skillA = skills.find((s) => s.slug === a);
-      const skillB = skills.find((s) => s.slug === b);
-      if (skillA?.meta.layer === skillB?.meta.layer) {
-        candidates.push([a, b]);
-      }
-    }
-  }
-  return candidates;
-}
 
 // src/core/obsidian.ts
 init_data();
@@ -12225,6 +13481,9 @@ ${C.bold}  Network Optimization${C.reset}`);
     if (result.merged.length === 0 && result.split.length === 0 && result.conflictsResolved.length === 0) {
       console.log(`  ${C.green}✓${C.reset} Network is healthy`);
     }
+    const topology = refreshTopologyReviewCandidates();
+    console.log(`  ${C.blue}↺${C.reset} Topology review queue refreshed: ${topology.total} total • ${topology.open} open`);
+    console.log(`  ${C.dim}    ${topology.created} created • ${topology.updated} updated${C.reset}`);
   }
   if (options.obsidian) {
     console.log(`
@@ -12482,12 +13741,16 @@ function renderScoreBar(score) {
 init_config();
 init_skills();
 init_llm();
-import { join as join15 } from "node:path";
+import { isAbsolute, join as join15, resolve } from "node:path";
 import { readFileSync as readFileSync7, existsSync as existsSync9 } from "node:fs";
+init_data();
 async function researchCommand(options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
   const maxHypotheses = parseInt(options.maxHypotheses ?? "3");
+  const startedAt = new Date().toISOString();
+  const governance = getActiveGovernanceSummary();
+  const resolvedProjectPath = options.project ? isAbsolute(options.project) ? options.project : resolve(process.cwd(), options.project) : undefined;
   console.log(`\uD83D\uDD2C HelixEvo Proactive Research
 `);
   const skills = loadAllGeneralSkills();
@@ -12499,6 +13762,32 @@ async function researchCommand(options) {
   }
   console.log(`  → ${goals.gaps.length} capability gap(s) identified
 `);
+  const persistResearchIntervention = (params) => {
+    const matchedSignals = matchPressureSignals({
+      projectPath: resolvedProjectPath,
+      capabilities: goals.gaps,
+      suggestedAction: "research"
+    });
+    appendPressureIntervention({
+      id: `intervention_research_${Date.now()}`,
+      interventionType: "research",
+      status: dryRun ? "dry-run" : "completed",
+      impact: params.createdSkills && params.createdSkills.length > 0 ? "resolving" : params.discoveriesCount > 0 || params.hypothesesCount > 0 ? "exploratory" : "none",
+      createdAt: startedAt,
+      completedAt: new Date().toISOString(),
+      sourceId: params.iterationId ? `research:${params.iterationId}` : params.proposals && params.proposals.length > 0 ? `research:${params.proposals.map((proposal) => proposal.id).join(",")}` : "research:discovery-scan",
+      projectId: matchedSignals[0]?.projectId,
+      projectPath: resolvedProjectPath,
+      scope: resolvedProjectPath ? "project" : "local",
+      governanceMode: governance.activeMode,
+      capabilities: goals.gaps,
+      pressureSignalIds: matchedSignals.map((signal) => signal.id),
+      relatedProposalIds: params.proposals?.map((proposal) => proposal.id) ?? [],
+      relatedSkillSlugs: params.createdSkills ?? [],
+      reasonSummary: `Research analyzed ${goals.gaps.length} capability gaps and produced ${params.discoveriesCount} discoveries / ${params.hypothesesCount} hypotheses.`,
+      notes: dryRun ? "Research ran in dry-run mode, so results should be treated as exploratory only." : undefined
+    });
+  };
   console.log("  Step 2: Scanning frontier (web search)...");
   const gapsToSearch = goals.gaps.slice(0, 3);
   if (verbose) {
@@ -12549,6 +13838,7 @@ Only include discoveries that are NOT already covered by current skills.`
 `);
   }
   if (discoveries.length === 0) {
+    persistResearchIntervention({ discoveriesCount: 0, hypothesesCount: 0 });
     console.log("  No new discoveries. Current skills are up to date.");
     return;
   }
@@ -12564,6 +13854,7 @@ Only include discoveries that are NOT already covered by current skills.`
   console.log(`  → ${filtered.length} high-confidence hypothesis(es)
 `);
   if (filtered.length === 0) {
+    persistResearchIntervention({ discoveriesCount: discoveries.length, hypothesesCount: 0 });
     console.log("  No high-confidence hypotheses. Discoveries may not be actionable yet.");
     return;
   }
@@ -12623,8 +13914,9 @@ Only include discoveries that are NOT already covered by current skills.`
     }
     proposals.push(proposal);
   }
+  const iterationId = generateIterationId();
   addIteration({
-    id: generateIterationId(),
+    id: iterationId,
     timestamp: new Date().toISOString(),
     trigger: "manual",
     failureCount: 0,
@@ -12632,6 +13924,13 @@ Only include discoveries that are NOT already covered by current skills.`
     proposals
   });
   const created = proposals.filter((p) => p.outcome === "accepted").length;
+  persistResearchIntervention({
+    discoveriesCount: discoveries.length,
+    hypothesesCount: filtered.length,
+    proposals,
+    iterationId,
+    createdSkills: proposals.filter((proposal) => proposal.outcome === "accepted").map((proposal) => proposal.targetSkill)
+  });
   console.log("─── Research Summary ───");
   console.log(`  Gaps analyzed:     ${goals.gaps.length}`);
   console.log(`  Discoveries:       ${discoveries.length}`);
@@ -13203,14 +14502,14 @@ function isProcessAlive(pid) {
   }
 }
 async function isPortAvailable(port) {
-  return await new Promise((resolve) => {
+  return await new Promise((resolve2) => {
     const server = createServer();
     server.unref();
     server.once("error", () => {
-      resolve(false);
+      resolve2(false);
     });
     server.listen(port, () => {
-      server.close(() => resolve(true));
+      server.close(() => resolve2(true));
     });
   });
 }
@@ -13860,7 +15159,7 @@ async function metricsCommand(options) {
 init_data();
 init_skills();
 init_llm();
-import { isAbsolute, join as join20, normalize, resolve } from "node:path";
+import { isAbsolute as isAbsolute2, join as join20, normalize, resolve as resolve2 } from "node:path";
 import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 
@@ -13940,7 +15239,7 @@ function expandHomePath(path) {
 }
 function normalizeProjectPath(projectPath) {
   const expanded = expandHomePath(projectPath.trim());
-  const resolvedPath = isAbsolute(expanded) ? normalize(expanded) : resolve(process.cwd(), expanded);
+  const resolvedPath = isAbsolute2(expanded) ? normalize(expanded) : resolve2(process.cwd(), expanded);
   return stripTrailingSeparator(resolvedPath);
 }
 function readProjectContext(projectPath) {
@@ -14155,6 +15454,427 @@ async function projectSetupCommand(projectPath, options) {
   console.log();
 }
 
+// src/commands/topology.ts
+init_data();
+
+// src/core/topology-apply.ts
+init_config();
+init_data();
+import { copyFileSync, existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join21 } from "node:path";
+function uniqueStrings2(values) {
+  return [...new Set(values.filter((value) => Boolean(value && value.trim())))];
+}
+function edgeKey(edge) {
+  return `${edge.from}::${edge.to}::${edge.type}`;
+}
+function findAcceptedCandidate(candidateId) {
+  const candidate = loadResolvedTopologyReviewCandidates().find((entry) => entry.id === candidateId);
+  if (!candidate)
+    throw new Error(`Unknown topology review candidate: ${candidateId}`);
+  if (candidate.status !== "accepted" || !candidate.latestDecision) {
+    throw new Error(`Topology candidate ${candidateId} must be accepted before preparing an apply plan`);
+  }
+  return candidate;
+}
+function findPlan(planId) {
+  const plan = loadResolvedTopologyApplyPlans().find((entry) => entry.id === planId);
+  if (!plan)
+    throw new Error(`Unknown topology apply plan: ${planId}`);
+  return plan;
+}
+function snapshotId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`.replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+function readSkillRaw(slug) {
+  const path = join21(getGeneralSkillsPath(), slug, "SKILL.md");
+  if (!existsSync16(path))
+    return null;
+  return { path, raw: readFileSync13(path, "utf-8") };
+}
+function createSnapshot(params) {
+  const id = snapshotId("topology_snapshot");
+  const snapshotDir = join21(getHelixDir(), "topology-snapshots", id);
+  mkdirSync7(snapshotDir, { recursive: true });
+  const graphPath = join21(snapshotDir, "skill-graph.json");
+  const overridesPath = join21(snapshotDir, "topology-overrides.json");
+  writeFileSync13(graphPath, JSON.stringify(loadSkillGraph(), null, 2));
+  writeFileSync13(overridesPath, JSON.stringify(loadTopologyOverrides(), null, 2));
+  const skillFileSnapshots = uniqueStrings2(params.skillSlugs ?? []).flatMap((slug) => {
+    const skill = readSkillRaw(slug);
+    if (!skill)
+      return [];
+    const snapshotPath = join21(snapshotDir, `${slug}.SKILL.md`);
+    copyFileSync(skill.path, snapshotPath);
+    return [{ slug, path: skill.path, snapshotPath }];
+  });
+  const ref = {
+    id,
+    createdAt: new Date().toISOString(),
+    label: params.label,
+    candidateId: params.candidateId,
+    planId: params.planId,
+    executionRecordId: params.executionRecordId,
+    snapshotDir,
+    graphPath,
+    overridesPath,
+    skillFileSnapshots
+  };
+  const snapshots = loadTopologySnapshots();
+  saveTopologySnapshots([ref, ...snapshots]);
+  return ref;
+}
+function buildPlan(candidate, graph, beforeSnapshotId) {
+  const targetSkillSlugs = candidate.affectedNodeIds;
+  const plannedFileChanges = [];
+  const plannedGraphChanges = [];
+  const warnings = [];
+  const plannedNodeOverrides = {};
+  const plannedEdgeSuppressions = [];
+  const plannedAddedEdges = [];
+  let safeToApply = false;
+  let executionMode = "prepare-only";
+  let rollbackStrategy = "Restore the before-apply topology snapshot and revert topology-overrides.json.";
+  if (candidate.changeType === "rewire") {
+    const relevantEdges = graph.edges.filter((edge) => edge.type === "conflicts" && candidate.affectedNodeIds.includes(edge.from) && candidate.affectedNodeIds.includes(edge.to));
+    if (relevantEdges.length > 0) {
+      safeToApply = true;
+      executionMode = "apply";
+      for (const edge of relevantEdges) {
+        plannedEdgeSuppressions.push({ from: edge.from, to: edge.to, type: edge.type });
+      }
+      plannedGraphChanges.push(`Suppress ${relevantEdges.length} conflict edge(s) covered by the reviewed rewire decision.`);
+      rollbackStrategy = "Restore the previous conflict edges by reloading the before-apply override snapshot.";
+    } else {
+      warnings.push("No active conflict edge currently matches this reviewed rewire candidate, so the plan remains prepare-only.");
+      plannedGraphChanges.push("No direct graph mutation is safe to apply until a matching conflict edge is present.");
+    }
+  } else if (candidate.changeType === "promote") {
+    const promotable = graph.nodes.find((node) => candidate.affectedNodeIds.includes(node.id) && node.layer === "project");
+    if (promotable) {
+      safeToApply = true;
+      executionMode = "apply";
+      plannedNodeOverrides[promotable.id] = {
+        layer: "domain",
+        plasticityState: "consolidated"
+      };
+      plannedGraphChanges.push(`Promote ${promotable.id} from project to domain layer via a reviewed topology override.`);
+      rollbackStrategy = "Restore the previous node layer through the before-apply topology snapshot.";
+    } else {
+      warnings.push("Safe promotion currently requires a single project-layer target; this reviewed promotion remains prepare-only.");
+      plannedGraphChanges.push("Promotion recorded as structural intent only until a project-layer target can be promoted safely.");
+    }
+  } else if (candidate.changeType === "consolidate") {
+    if ((candidate.relatedTransferEventIds?.length ?? 0) > 0 && candidate.affectedNodeIds.length > 0) {
+      safeToApply = true;
+      executionMode = "apply";
+      const lineageId = candidate.relatedMotifIds?.[0] ?? candidate.id;
+      for (const slug of candidate.affectedNodeIds) {
+        plannedNodeOverrides[slug] = {
+          plasticityState: "consolidated",
+          lineageId
+        };
+      }
+      plannedGraphChanges.push(`Mark ${candidate.affectedNodeIds.length} node(s) as consolidated under shared reviewed lineage ${lineageId}.`);
+      rollbackStrategy = "Restore the previous node consolidation metadata from the before-apply topology snapshot.";
+    } else {
+      warnings.push("Consolidation currently requires realized transfer evidence and at least one target node; this plan remains prepare-only.");
+      plannedGraphChanges.push("Consolidation intent captured without applying structural metadata yet.");
+    }
+  } else {
+    warnings.push(`Safe reviewed execution for ${candidate.changeType} is not enabled in Milestone 7.`);
+    plannedGraphChanges.push(`${candidate.changeType} remains prepare-only so the reviewed structural intent is preserved without destructive execution.`);
+  }
+  if (!safeToApply) {
+    rollbackStrategy = "No structural mutation applied; keep the plan as prepare-only until a later reviewed milestone or safer candidate form is available.";
+  }
+  return {
+    candidateId: candidate.id,
+    acceptedDecisionId: candidate.latestDecision.id,
+    changeType: candidate.changeType,
+    safeToApply,
+    executionMode,
+    targetSkillSlugs,
+    plannedFileChanges,
+    plannedGraphChanges,
+    plannedNodeOverrides: Object.keys(plannedNodeOverrides).length > 0 ? plannedNodeOverrides : undefined,
+    plannedEdgeSuppressions: plannedEdgeSuppressions.length > 0 ? plannedEdgeSuppressions : undefined,
+    plannedAddedEdges: plannedAddedEdges.length > 0 ? plannedAddedEdges : undefined,
+    warnings,
+    rollbackStrategy,
+    beforeSnapshotId,
+    reasonSummary: candidate.reasonSummary
+  };
+}
+function mergePlan(plans, nextPlan) {
+  return [
+    nextPlan,
+    ...plans.filter((plan) => !(plan.candidateId === nextPlan.candidateId && plan.acceptedDecisionId === nextPlan.acceptedDecisionId))
+  ];
+}
+function appendArtifact(params) {
+  const artifact = {
+    id: snapshotId("topology_artifact"),
+    createdAt: new Date().toISOString(),
+    artifactType: "topology-apply",
+    provenance: "native-topology",
+    title: params.title,
+    summary: params.summary,
+    sourceId: params.sourceId,
+    targetSkill: params.plan.targetSkillSlugs[0],
+    operation: params.operation,
+    metrics: params.metrics
+  };
+  appendTopologyArtifact(artifact);
+  return artifact.id;
+}
+function prepareTopologyApplyPlan(candidateId) {
+  const candidate = findAcceptedCandidate(candidateId);
+  const beforeSnapshot = createSnapshot({
+    label: `Before prepare · ${candidate.title}`,
+    candidateId: candidate.id,
+    skillSlugs: candidate.affectedNodeIds
+  });
+  const governance = getActiveGovernanceSummary();
+  const planSeed = buildPlan(candidate, loadSkillGraph(), beforeSnapshot.id);
+  const plan = {
+    id: snapshotId("topology_plan"),
+    createdAt: new Date().toISOString(),
+    governanceMode: governance.activeMode,
+    ...planSeed
+  };
+  saveTopologyApplyPlans(mergePlan(loadTopologyApplyPlans(), plan));
+  const artifactId = appendArtifact({
+    title: `Prepared topology apply · ${candidate.title}`,
+    summary: plan.safeToApply ? `Prepared reviewed ${plan.changeType} plan with ${plan.executionMode} execution mode.` : `Prepared reviewed ${plan.changeType} plan in prepare-only mode because no safe execution path is currently available.`,
+    sourceId: plan.id,
+    operation: `topology:${plan.changeType}:prepare`,
+    plan,
+    metrics: {
+      safeToApply: plan.safeToApply ? 1 : 0,
+      plannedGraphChanges: plan.plannedGraphChanges.length,
+      warnings: plan.warnings.length
+    }
+  });
+  appendTopologyExecutionRecord({
+    id: snapshotId("topology_exec_prepared"),
+    planId: plan.id,
+    candidateId: plan.candidateId,
+    changeType: plan.changeType,
+    status: "prepared",
+    createdAt: new Date().toISOString(),
+    executedAt: new Date().toISOString(),
+    governanceMode: governance.activeMode,
+    beforeSnapshotId: beforeSnapshot.id,
+    artifactIds: [artifactId],
+    notes: plan.warnings
+  });
+  return plan;
+}
+function applyPlanToOverrides(plan, overrides) {
+  const nextNodeOverrides = { ...overrides.nodeOverrides };
+  for (const [slug, override] of Object.entries(plan.plannedNodeOverrides ?? {})) {
+    nextNodeOverrides[slug] = { ...nextNodeOverrides[slug] ?? {}, ...override };
+  }
+  const suppressedMap = new Map(overrides.suppressedEdges.map((edge) => [edgeKey(edge), edge]));
+  for (const edge of plan.plannedEdgeSuppressions ?? []) {
+    suppressedMap.set(edgeKey(edge), edge);
+  }
+  const addedMap = new Map(overrides.addedEdges.map((edge) => [edgeKey(edge), edge]));
+  for (const edge of plan.plannedAddedEdges ?? []) {
+    addedMap.set(edgeKey(edge), edge);
+  }
+  return {
+    updatedAt: new Date().toISOString(),
+    nodeOverrides: nextNodeOverrides,
+    suppressedEdges: [...suppressedMap.values()],
+    addedEdges: [...addedMap.values()],
+    appliedPlanIds: uniqueStrings2([...overrides.appliedPlanIds ?? [], plan.id])
+  };
+}
+function applyPreparedTopologyPlan(planId) {
+  const plan = findPlan(planId);
+  if (plan.latestStatus !== "prepared") {
+    throw new Error(`Topology plan ${planId} must be prepared before apply`);
+  }
+  if (!plan.safeToApply || plan.executionMode !== "apply") {
+    throw new Error(`Topology plan ${planId} is prepare-only and cannot be applied safely in Milestone 7`);
+  }
+  const nextOverrides = applyPlanToOverrides(plan, loadTopologyOverrides());
+  saveTopologyOverrides(nextOverrides);
+  const executionRecordId = snapshotId("topology_exec_applied");
+  const afterSnapshot = createSnapshot({
+    label: `After apply · ${plan.id}`,
+    candidateId: plan.candidateId,
+    planId: plan.id,
+    executionRecordId,
+    skillSlugs: plan.targetSkillSlugs
+  });
+  const artifactId = appendArtifact({
+    title: `Applied topology plan · ${plan.changeType}`,
+    summary: `Applied reviewed ${plan.changeType} plan with ${plan.plannedGraphChanges.length} graph mutation step(s).`,
+    sourceId: plan.id,
+    operation: `topology:${plan.changeType}:apply`,
+    plan,
+    metrics: {
+      suppressedEdges: plan.plannedEdgeSuppressions?.length ?? 0,
+      addedEdges: plan.plannedAddedEdges?.length ?? 0,
+      nodeOverrides: Object.keys(plan.plannedNodeOverrides ?? {}).length
+    }
+  });
+  const record = {
+    id: executionRecordId,
+    planId: plan.id,
+    candidateId: plan.candidateId,
+    changeType: plan.changeType,
+    status: "applied",
+    createdAt: new Date().toISOString(),
+    executedAt: new Date().toISOString(),
+    governanceMode: getActiveGovernanceSummary().activeMode,
+    beforeSnapshotId: plan.beforeSnapshotId,
+    afterSnapshotId: afterSnapshot.id,
+    artifactIds: [artifactId],
+    notes: plan.plannedGraphChanges
+  };
+  appendTopologyExecutionRecord(record);
+  return record;
+}
+function rollbackAppliedTopologyPlan(planId) {
+  const plan = findPlan(planId);
+  if (plan.latestStatus !== "applied") {
+    throw new Error(`Topology plan ${planId} must be applied before rollback`);
+  }
+  const beforeSnapshot = loadTopologySnapshots().find((snapshot) => snapshot.id === plan.beforeSnapshotId);
+  if (!beforeSnapshot || !existsSync16(beforeSnapshot.overridesPath)) {
+    throw new Error(`Before-apply snapshot for ${planId} is missing or incomplete`);
+  }
+  const restoredOverrides = JSON.parse(readFileSync13(beforeSnapshot.overridesPath, "utf-8"));
+  saveTopologyOverrides({
+    ...restoredOverrides,
+    updatedAt: new Date().toISOString()
+  });
+  const executionRecordId = snapshotId("topology_exec_rollback");
+  const afterSnapshot = createSnapshot({
+    label: `After rollback · ${plan.id}`,
+    candidateId: plan.candidateId,
+    planId: plan.id,
+    executionRecordId,
+    skillSlugs: plan.targetSkillSlugs
+  });
+  const artifactId = appendArtifact({
+    title: `Rolled back topology plan · ${plan.changeType}`,
+    summary: `Rolled back reviewed ${plan.changeType} plan by restoring the before-apply topology snapshot.`,
+    sourceId: plan.id,
+    operation: `topology:${plan.changeType}:rollback`,
+    plan,
+    metrics: {
+      restoredSnapshot: 1,
+      targetSkills: plan.targetSkillSlugs.length
+    }
+  });
+  const record = {
+    id: executionRecordId,
+    planId: plan.id,
+    candidateId: plan.candidateId,
+    changeType: plan.changeType,
+    status: "rolled-back",
+    createdAt: new Date().toISOString(),
+    rolledBackAt: new Date().toISOString(),
+    governanceMode: getActiveGovernanceSummary().activeMode,
+    beforeSnapshotId: plan.beforeSnapshotId,
+    afterSnapshotId: afterSnapshot.id,
+    artifactIds: [artifactId],
+    notes: ["Restored topology-overrides.json from the before-apply snapshot."]
+  };
+  appendTopologyExecutionRecord(record);
+  return record;
+}
+
+// src/commands/topology.ts
+function printStatus() {
+  const review = getTopologyReviewSummary();
+  const execution = getTopologyExecutionSummary();
+  console.log(`
+  Topology Control`);
+  console.log("  ────────────────────────────────────────");
+  console.log(`  Review queue: ${review.total} total • ${review.open} open • ${review.accepted} accepted • ${review.deferred} deferred`);
+  console.log(`  Execution: ${execution.plans} plans • ${execution.prepared} prepared • ${execution.applied} applied • ${execution.rolledBack} rolled back`);
+  console.log(`  Safety: ${execution.safeToApply} safe-to-apply • ${execution.prepareOnly} prepare-only • ${execution.snapshots} snapshots • ${execution.artifacts} artifacts`);
+  const acceptedReady = execution.acceptedReady.slice(0, 5);
+  if (acceptedReady.length > 0) {
+    console.log(`
+  Accepted candidates ready for prepare/apply`);
+    for (const candidate of acceptedReady) {
+      console.log(`  • ${candidate.id} (${candidate.changeType})`);
+    }
+  }
+  const prepared = execution.preparedQueue.slice(0, 5);
+  if (prepared.length > 0) {
+    console.log(`
+  Prepared plans`);
+    for (const plan of prepared) {
+      console.log(`  • ${plan.id} (${plan.changeType}) • ${plan.executionMode}`);
+    }
+  }
+  console.log();
+}
+async function topologyCommand(options) {
+  const actions = [options.prepare, options.apply, options.rollback].filter(Boolean);
+  if (actions.length > 1) {
+    throw new Error("Use only one of --prepare, --apply, or --rollback at a time");
+  }
+  if (options.prepare) {
+    const plan = prepareTopologyApplyPlan(options.prepare);
+    console.log(`
+  ✓ Prepared topology plan: ${plan.id}`);
+    console.log(`    candidate: ${plan.candidateId}`);
+    console.log(`    change: ${plan.changeType}`);
+    console.log(`    mode: ${plan.executionMode}`);
+    console.log(`    safe-to-apply: ${plan.safeToApply ? "yes" : "no"}`);
+    if (plan.plannedGraphChanges.length > 0) {
+      for (const line of plan.plannedGraphChanges)
+        console.log(`    graph: ${line}`);
+    }
+    if (plan.warnings.length > 0) {
+      for (const line of plan.warnings)
+        console.log(`    warning: ${line}`);
+    }
+    console.log();
+    return;
+  }
+  if (options.apply) {
+    const record = applyPreparedTopologyPlan(options.apply);
+    console.log(`
+  ✓ Applied topology plan: ${record.planId}`);
+    console.log(`    candidate: ${record.candidateId}`);
+    console.log(`    change: ${record.changeType}`);
+    console.log(`    after snapshot: ${record.afterSnapshotId ?? "—"}`);
+    console.log();
+    return;
+  }
+  if (options.rollback) {
+    const record = rollbackAppliedTopologyPlan(options.rollback);
+    console.log(`
+  ✓ Rolled back topology plan: ${record.planId}`);
+    console.log(`    candidate: ${record.candidateId}`);
+    console.log(`    change: ${record.changeType}`);
+    console.log(`    after snapshot: ${record.afterSnapshotId ?? "—"}`);
+    console.log();
+    return;
+  }
+  printStatus();
+  if (options.verbose) {
+    const plans = loadResolvedTopologyApplyPlans().slice(0, 8);
+    if (plans.length > 0) {
+      console.log("  Recent topology plans");
+      for (const plan of plans) {
+        console.log(`  • ${plan.id} • ${plan.changeType} • ${plan.latestStatus} • ${plan.executionMode}`);
+      }
+      console.log();
+    }
+  }
+}
+
 // src/cli.ts
 var program2 = new Command;
 program2.name("helixevo").description("Self-evolving skill ecosystem for AI agents").version(VERSION).addHelpText("after", `
@@ -14173,7 +15893,11 @@ Examples:
   $ helixevo graph --mermaid               Open graph in browser
   $ helixevo graph --obsidian ~/vault      Sync to Obsidian vault
   $ helixevo graph --rebuild               Re-infer relationships (LLM call)
-  $ helixevo graph --optimize              Detect merge/split/conflicts
+  $ helixevo graph --optimize              Detect structural candidates + refresh topology review queue
+  $ helixevo topology --status             Show reviewed topology execution state
+  $ 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 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);
@@ -14181,7 +15905,7 @@ program2.command("capture").description("Capture failures from a Craft Agent ses
 program2.command("evolve").description("Evolve skills from failures [--dry-run] [--verbose] [--max-proposals <n>]").option("--dry-run", "Show proposals without applying").option("--verbose", "Show detailed LLM interactions").option("--max-proposals <n>", "Max proposals per run", "5").action(evolveCommand);
 program2.command("generalize").description("Promote cross-skill patterns to higher layer ↑ [--dry-run] [--verbose]").option("--dry-run", "Show candidates without applying").option("--verbose", "Show detailed analysis").action(generalizeCommand);
 program2.command("specialize").description("Create project-specific skills ↓ --project <name> [--dry-run] [--verbose]").requiredOption("--project <name>", "Project name").option("--dry-run", "Show candidates without applying").option("--verbose", "Show detailed analysis").action(specializeCommand);
-program2.command("graph").description("Skill network [--mermaid] [--obsidian <path>] [--rebuild] [--optimize]").option("--mermaid", "Render as Mermaid diagram in browser").option("--rebuild", "Force rebuild (re-infer relationships via LLM)").option("--obsidian <path>", "Sync to Obsidian vault at path").option("--optimize", "Run network optimization (merge/split/conflict detection)").option("--verbose", "Show detailed analysis").action(graphCommand);
+program2.command("graph").description("Skill network [--mermaid] [--obsidian <path>] [--rebuild] [--optimize refreshes topology review]").option("--mermaid", "Render as Mermaid diagram in browser").option("--rebuild", "Force rebuild (re-infer relationships via LLM)").option("--obsidian <path>", "Sync to Obsidian vault at path").option("--optimize", "Run network optimization (merge/split/conflict detection)").option("--verbose", "Show detailed analysis").action(graphCommand);
 program2.command("research").description("Proactive research via web [--project <path>] [--dry-run] [--verbose]").option("--project <path>", "Project path for goal extraction").option("--dry-run", "Show discoveries without creating skills").option("--verbose", "Show detailed research steps").option("--max-hypotheses <n>", "Max hypotheses to test", "3").action(researchCommand);
 program2.command("dashboard").description("Open web dashboard (default: http://localhost:3847, falls forward if occupied)").option("--background", "Run in background (detach from terminal)").option("--stop", "Stop a background dashboard").option("--port <port>", "Preferred port to try first (default: 3847)").option("--no-auto-update", "Skip automatic update check before launching the dashboard").action(async (options) => {
   await dashboardCommand(options);
@@ -14196,6 +15920,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.hook("postAction", () => {
   checkForUpdates().catch(() => {});
 });