helixevo 0.3.1 → 0.4.0

package/dashboard/lib/data.ts

@@ -78,14 +78,14 @@ export interface CanaryEntry {
   skillSlug: string; version: string; deployedAt: string; expiresAt: string
 }
 
-export type ArtifactProvenance = 'native-evolution' | 'derived-history'
+export type ArtifactProvenance = 'native-evolution' | 'native-topology' | 'derived-history'
 export type ActivationProvenance = 'capture-derived' | 'project-analysis' | 'derived-failure'
 export type PressureProvenance = 'failure-native' | 'project-analysis-native' | 'failure-derived' | 'profile-gap-derived'
 
 export interface EvidenceArtifact {
   id: string
   createdAt: string
-  artifactType: 'evolution' | 'replay' | 'regression' | 'canary' | 'project-analysis' | 'ontology-review'
+  artifactType: 'evolution' | 'replay' | 'regression' | 'canary' | 'project-analysis' | 'ontology-review' | 'topology-apply'
   provenance: ArtifactProvenance
   title: string
   summary: string
@@ -144,12 +144,262 @@ export interface PressureSignal {
   region?: string
   description?: string
   suggestedAction?: 'research' | 'specialize' | 'create'
+  confidence?: number
+  recurrenceCount?: number
   relatedFailureId?: string
   relatedActivationTraceId?: string
   skillIds?: string[]
   status?: 'open' | 'addressed'
 }
 
+export type GovernanceModeName = 'conservative' | 'balanced' | 'exploration' | 'project-critical' | 'consolidation-focused' | 'transfer-focused'
+export type GovernanceSelectionMode = 'auto' | 'manual'
+export type GovernanceSource = 'derived' | 'operator-selected'
+export type TransferType = 'specialist-to-generalist' | 'generalist-to-project' | 'cross-project' | 'domain-transfer'
+export type PressureInterventionType = 'research' | 'specialize' | 'evolve' | 'generalize' | 'manual-review'
+export type TopologyReviewSource = 'graph-optimize' | 'network-health' | 'pressure-motif' | 'transfer-pattern' | 'manual-route'
+export type TopologyReviewStatus = 'open' | 'accepted' | 'rejected' | 'deferred'
+export type TopologyReviewDecisionStatus = Exclude<TopologyReviewStatus, 'open'>
+export type TopologyReviewPriority = 'high' | 'medium' | 'low'
+export type PressureInterventionStatus = 'started' | 'completed' | 'failed' | 'dry-run'
+export type PressureInterventionImpact = 'exploratory' | 'structural' | 'resolving' | 'none'
+export type PressureLifecycleState = 'open' | 'in-progress' | 'addressed' | 'stale'
+export type PressureRouteScope = 'local' | 'project' | 'network'
+export type PressureRouteTrigger = 'high-priority-local-gap' | 'project-bounded-recurrence' | 'recurring-cross-project-gap' | 'overlapping-skills' | 'accepted-iteration-pattern' | 'insufficient-evidence' | 'mixed-signal'
+
+export interface PressureRouteRecommendation {
+  route: PressureInterventionType
+  scope: PressureRouteScope
+  confidence: number
+  governanceMode: GovernanceModeName
+  triggeredBy: PressureRouteTrigger
+  reasons: string[]
+}
+
+export interface PressureIntervention {
+  id: string
+  interventionType: PressureInterventionType
+  status: PressureInterventionStatus
+  impact: PressureInterventionImpact
+  createdAt: string
+  completedAt?: string
+  sourceId: string
+  projectId?: string
+  projectPath?: string
+  scope?: PressureRouteScope
+  governanceMode?: GovernanceModeName
+  capabilities?: string[]
+  pressureSignalIds?: string[]
+  motifIds?: string[]
+  relatedFailureIds?: string[]
+  relatedActivationTraceIds?: string[]
+  relatedProposalIds?: string[]
+  relatedArtifactIds?: string[]
+  relatedTransferEventIds?: string[]
+  relatedSkillSlugs?: string[]
+  reasonSummary: string
+  notes?: string
+}
+
+export interface PressureMotif {
+  id: string
+  key: string
+  kind: string
+  capability?: string
+  description: string
+  createdAt: string
+  lastSeenAt: string
+  projectIds: string[]
+  pressureSignalIds: string[]
+  sourceSkillIds: string[]
+  recurrenceCount: number
+  highPriorityCount: number
+  linkedInterventionIds: string[]
+  linkedTransferEventIds: string[]
+  suggestedRoute: PressureRouteRecommendation
+}
+
+export interface TransferEvent {
+  id: string
+  timestamp: string
+  sourceProjectId?: string
+  targetProjectId?: string
+  sourceSkillIds: string[]
+  targetSkillIds?: string[]
+  capabilityIds?: string[]
+  motifIds?: string[]
+  transferType: TransferType
+  evidenceIds?: string[]
+  benefitEstimate?: number
+  status?: 'candidate' | 'realized' | 'rejected'
+  summary?: string
+}
+
+export interface GovernanceProfile {
+  mode: GovernanceModeName
+  reviewThreshold: number
+  riskTolerance: number
+  plasticityBias: number
+  explanation: string
+}
+
+export interface GovernanceState {
+  selectionMode: GovernanceSelectionMode
+  manualMode?: GovernanceModeName
+  updatedAt: string
+  note?: string
+}
+
+export interface ActiveGovernanceSummary {
+  activeMode: GovernanceModeName
+  derivedMode: GovernanceModeName
+  source: GovernanceSource
+  manualMode?: GovernanceModeName
+  rationale: string[]
+  profile: GovernanceProfile
+}
+
+export interface TopologyReviewCandidate {
+  id: string
+  reviewKey: string
+  createdAt: string
+  lastObservedAt: string
+  source: TopologyReviewSource
+  changeType: 'merge' | 'split' | 'promote' | 'demote' | 'rewire' | 'prune' | 'consolidate'
+  title: string
+  reasonSummary: string
+  description?: string
+  priority: TopologyReviewPriority
+  confidence: number
+  riskScore: number
+  governanceMode: GovernanceModeName
+  affectedNodeIds: string[]
+  affectedRelationIds?: string[]
+  projectIds?: string[]
+  relatedSignalIds?: string[]
+  relatedMotifIds?: string[]
+  relatedTransferEventIds?: string[]
+  relatedInterventionIds?: string[]
+  evidence: string[]
+}
+
+export interface TopologyReviewDecision {
+  id: string
+  candidateId: string
+  decision: TopologyReviewDecisionStatus
+  decidedAt: string
+  governanceMode: GovernanceModeName
+  rationale: string
+  decidedBy?: 'operator' | 'system'
+}
+
+export interface ResolvedTopologyReviewCandidate extends TopologyReviewCandidate {
+  status: TopologyReviewStatus
+  latestDecision?: TopologyReviewDecision
+  lastActivityAt: string
+}
+
+export type TopologyExecutionMode = 'prepare-only' | 'apply'
+export type TopologyExecutionStatus = 'prepared' | 'applied' | 'rolled-back' | 'failed'
+
+export interface TopologyEdgeRef {
+  from: string
+  to: string
+  type: SkillEdge['type']
+}
+
+export interface TopologyNodeOverride {
+  layer?: SkillNode['layer']
+  cognitiveRole?: CognitiveRole
+  stabilityState?: StabilityState
+  plasticityState?: PlasticityState
+  capabilities?: string[]
+  lineageId?: string
+}
+
+export interface TopologyOverrides {
+  updatedAt: string
+  nodeOverrides: Record<string, TopologyNodeOverride>
+  suppressedEdges: TopologyEdgeRef[]
+  addedEdges: SkillEdge[]
+  appliedPlanIds: string[]
+}
+
+export interface TopologySnapshotRef {
+  id: string
+  createdAt: string
+  label: string
+  candidateId?: string
+  planId?: string
+  executionRecordId?: string
+  snapshotDir: string
+  graphPath: string
+  overridesPath: string
+  skillFileSnapshots: { slug: string; path: string; snapshotPath: string }[]
+}
+
+export interface TopologyApplyPlan {
+  id: string
+  candidateId: string
+  acceptedDecisionId: string
+  createdAt: string
+  changeType: ResolvedTopologyReviewCandidate['changeType']
+  governanceMode: GovernanceModeName
+  safeToApply: boolean
+  executionMode: TopologyExecutionMode
+  targetSkillSlugs: string[]
+  plannedFileChanges: string[]
+  plannedGraphChanges: string[]
+  plannedNodeOverrides?: Record<string, TopologyNodeOverride>
+  plannedEdgeSuppressions?: TopologyEdgeRef[]
+  plannedAddedEdges?: SkillEdge[]
+  warnings: string[]
+  rollbackStrategy: string
+  beforeSnapshotId: string
+  reasonSummary: string
+}
+
+export interface TopologyExecutionRecord {
+  id: string
+  planId: string
+  candidateId: string
+  changeType: ResolvedTopologyReviewCandidate['changeType']
+  status: TopologyExecutionStatus
+  createdAt: string
+  executedAt?: string
+  rolledBackAt?: string
+  governanceMode: GovernanceModeName
+  beforeSnapshotId: string
+  afterSnapshotId?: string
+  artifactIds?: string[]
+  notes?: string[]
+}
+
+export interface ResolvedTopologyApplyPlan extends TopologyApplyPlan {
+  latestStatus: TopologyExecutionStatus | 'pending'
+  latestExecution?: TopologyExecutionRecord
+  lastActivityAt: string
+}
+
+export interface ResolvedPressureSignal extends PressureSignal {
+  lifecycle: PressureLifecycleState
+  linkedInterventions: PressureIntervention[]
+  interventionTypes: PressureInterventionType[]
+  motifIds?: string[]
+  routeRecommendation?: PressureRouteRecommendation
+  lastActivityAt: string
+  addressedAt?: string
+  responseSummary: string
+}
+
+export interface ResolvedPressureMotif extends PressureMotif {
+  lifecycle: PressureLifecycleState
+  interventionTypes: PressureInterventionType[]
+  lastActivityAt: string
+  addressedAt?: string
+  responseSummary: string
+}
+
 export interface ProjectPressureSummary {
   projectId: string
   totalSignals: number
@@ -159,16 +409,92 @@ export interface ProjectPressureSummary {
   topCapabilities: string[]
 }
 
+export interface ProjectResponseSummary extends ProjectPressureSummary {
+  openSignals: number
+  inProgressSignals: number
+  addressedSignals: number
+  staleSignals: number
+  activeInterventions: number
+  recentInterventionTypes: PressureInterventionType[]
+}
+
 export interface CoEvolutionDashboardSummary {
   pressureSignals: {
     total: number
     native: number
     derived: number
   }
+  pressureInterventions: {
+    total: number
+    started: number
+    completed: number
+    failed: number
+    dryRun: number
+  }
+  pressureLifecycle: {
+    open: number
+    inProgress: number
+    addressed: number
+    stale: number
+    highPriorityOpen: number
+  }
+  pressureMotifs: {
+    total: number
+    open: number
+    inProgress: number
+    addressed: number
+    stale: number
+    promotionReady: number
+  }
+  governance: ActiveGovernanceSummary
+  topologyReviews: {
+    total: number
+    open: number
+    accepted: number
+    rejected: number
+    deferred: number
+    highPriorityOpen: number
+    generatedFromManualReview: number
+    byChangeType: Record<ResolvedTopologyReviewCandidate['changeType'], number>
+  }
+  topologyExecution: {
+    plans: number
+    pending: number
+    prepared: number
+    applied: number
+    rolledBack: number
+    failed: number
+    safeToApply: number
+    prepareOnly: number
+    snapshots: number
+    artifacts: number
+  }
   topProjects: ProjectPressureSummary[]
+  responseProjects: ProjectResponseSummary[]
   rolePressure: Record<CognitiveRole, number>
   crossProjectGapAreas: { area: string; projects: string[]; count: number }[]
   activeRecommendations: { action: 'research' | 'specialize' | 'create'; count: number }[]
+  governedRoutes: { route: PressureInterventionType; total: number }[]
+  interventionLanes: { type: PressureInterventionType; total: number; resolving: number; exploratory: number; none: number }[]
+  backlog: ResolvedPressureSignal[]
+  promoteQueue: ResolvedPressureMotif[]
+  recentAddressed: ResolvedPressureSignal[]
+  recentInterventions: PressureIntervention[]
+  recentTransfers: TransferEvent[]
+  topologyBacklog: ResolvedTopologyReviewCandidate[]
+  recentTopologyDecisions: ResolvedTopologyReviewCandidate[]
+}
+
+export interface TopologyDashboardSummary {
+  governance: ActiveGovernanceSummary
+  summary: CoEvolutionDashboardSummary['topologyReviews']
+  execution: CoEvolutionDashboardSummary['topologyExecution']
+  backlog: ResolvedTopologyReviewCandidate[]
+  recentDecisions: ResolvedTopologyReviewCandidate[]
+  acceptedReady: ResolvedTopologyReviewCandidate[]
+  preparedQueue: ResolvedTopologyApplyPlan[]
+  appliedHistory: ResolvedTopologyApplyPlan[]
+  candidates: ResolvedTopologyReviewCandidate[]
 }
 
 export interface OntologyDashboardSummary {
@@ -197,6 +523,66 @@ export interface OntologyDashboardSummary {
     native: number
     derived: number
   }
+  pressureInterventions: {
+    total: number
+    started: number
+    completed: number
+    failed: number
+    dryRun: number
+  }
+  pressureLifecycle: {
+    open: number
+    inProgress: number
+    addressed: number
+    stale: number
+  }
+  pressureMotifs: {
+    total: number
+    open: number
+    inProgress: number
+    addressed: number
+    stale: number
+    promotionReady: number
+  }
+  governedRoutes: Record<PressureInterventionType, number>
+  transferEvents: {
+    total: number
+    realized: number
+    candidate: number
+    rejected: number
+  }
+  governance: {
+    activeMode: GovernanceModeName
+    derivedMode: GovernanceModeName
+    source: GovernanceSource
+    manualMode?: GovernanceModeName
+    rationale: string[]
+    reviewThreshold: number
+    riskTolerance: number
+    plasticityBias: number
+  }
+  topologyReviews: {
+    total: number
+    open: number
+    accepted: number
+    rejected: number
+    deferred: number
+    highPriorityOpen: number
+    generatedFromManualReview: number
+    byChangeType: Record<ResolvedTopologyReviewCandidate['changeType'], number>
+  }
+  topologyExecution: {
+    plans: number
+    pending: number
+    prepared: number
+    applied: number
+    rolledBack: number
+    failed: number
+    safeToApply: number
+    prepareOnly: number
+    snapshots: number
+    artifacts: number
+  }
   annotatedFailures: {
     pressureSignals: number
     capabilityGaps: number
@@ -233,8 +619,38 @@ function inferPlasticityState(node: SkillNode): PlasticityState {
 
 // ─── Loaders ────────────────────────────────────────────────────
 
+function edgeKey(edge: { from: string; to: string; type: string }): string {
+  return `${edge.from}::${edge.to}::${edge.type}`
+}
+
+export function loadTopologyOverrides(): TopologyOverrides {
+  const overrides = readJson<TopologyOverrides>('topology-overrides.json', { updatedAt: '', nodeOverrides: {}, suppressedEdges: [], addedEdges: [], appliedPlanIds: [] })
+  return {
+    updatedAt: overrides.updatedAt || '',
+    nodeOverrides: overrides.nodeOverrides ?? {},
+    suppressedEdges: overrides.suppressedEdges ?? [],
+    addedEdges: overrides.addedEdges ?? [],
+    appliedPlanIds: overrides.appliedPlanIds ?? [],
+  }
+}
+
+function applyTopologyOverridesToGraph(graph: SkillGraph, overrides: TopologyOverrides = loadTopologyOverrides()): SkillGraph {
+  const suppressed = new Set(overrides.suppressedEdges.map((edge) => edgeKey(edge)))
+  const edgeMap = new Map<string, SkillEdge>()
+  for (const edge of graph.edges) {
+    const key = edgeKey(edge)
+    if (!suppressed.has(key)) edgeMap.set(key, edge)
+  }
+  for (const edge of overrides.addedEdges) edgeMap.set(edgeKey(edge), edge)
+  return {
+    ...graph,
+    nodes: graph.nodes.map((node) => ({ ...node, ...(overrides.nodeOverrides[node.id] ?? {}) })),
+    edges: [...edgeMap.values()],
+  }
+}
+
 export function loadGraph(): SkillGraph {
-  return readJson<SkillGraph>('skill-graph.json', { updated: '', nodes: [], edges: [], clusters: [] })
+  return applyTopologyOverridesToGraph(readJson<SkillGraph>('skill-graph.json', { updated: '', nodes: [], edges: [], clusters: [] }))
 }
 
 export function loadFailures(): Failure[] {
@@ -405,19 +821,688 @@ export function loadPressureSignals(): PressureSignal[] {
   ].sort((a, b) => b.detectedAt.localeCompare(a.detectedAt))
 }
 
+export function loadPressureInterventions(): PressureIntervention[] {
+  return readJsonl<PressureIntervention>('pressure-interventions.jsonl')
+    .slice()
+    .sort((a, b) => (b.completedAt ?? b.createdAt).localeCompare(a.completedAt ?? a.createdAt))
+}
+
+export function loadTransferEvents(): TransferEvent[] {
+  return readJsonl<TransferEvent>('transfer-events.jsonl')
+    .slice()
+    .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+}
+
+const DEFAULT_GOVERNANCE_STATE: GovernanceState = {
+  selectionMode: 'auto',
+  updatedAt: new Date(0).toISOString(),
+}
+
+const GOVERNANCE_PROFILES: Record<GovernanceModeName, GovernanceProfile> = {
+  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.' },
+}
+
+function topologyChangeCounts(): Record<ResolvedTopologyReviewCandidate['changeType'], number> {
+  return { merge: 0, split: 0, promote: 0, demote: 0, rewire: 0, prune: 0, consolidate: 0 }
+}
+
+function maxTimestamp(...values: Array<string | undefined>): string {
+  return values.filter(Boolean).sort((a, b) => b!.localeCompare(a!))[0] ?? new Date(0).toISOString()
+}
+
+function priorityRank(priority: TopologyReviewPriority): number {
+  return priority === 'high' ? 3 : priority === 'medium' ? 2 : 1
+}
+
+function topologyStatusRank(status: TopologyReviewStatus): number {
+  return status === 'open' ? 4 : status === 'deferred' ? 3 : status === 'accepted' ? 2 : 1
+}
+
+function governanceProfileForMode(mode: GovernanceModeName): GovernanceProfile {
+  return GOVERNANCE_PROFILES[mode]
+}
+
+export function loadGovernanceState(): GovernanceState {
+  const state = readJson<GovernanceState>('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' }
+}
+
+export function loadStoredTopologyReviewCandidates(): TopologyReviewCandidate[] {
+  return readJson<TopologyReviewCandidate[]>('topology-review-candidates.json', [])
+    .slice()
+    .sort((a, b) => b.lastObservedAt.localeCompare(a.lastObservedAt) || a.title.localeCompare(b.title))
+}
+
+export function loadTopologyReviewDecisions(): TopologyReviewDecision[] {
+  return readJsonl<TopologyReviewDecision>('topology-review-decisions.jsonl')
+    .slice()
+    .sort((a, b) => b.decidedAt.localeCompare(a.decidedAt))
+}
+
+export function loadResolvedTopologyReviewCandidates(): ResolvedTopologyReviewCandidate[] {
+  const candidates = loadStoredTopologyReviewCandidates()
+  const latestDecisionByCandidate = new Map<string, TopologyReviewDecision>()
+  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: TopologyReviewStatus = latestDecision?.decision ?? 'open'
+      return {
+        ...candidate,
+        status,
+        latestDecision,
+        lastActivityAt: maxTimestamp(candidate.lastObservedAt, latestDecision?.decidedAt),
+      } satisfies ResolvedTopologyReviewCandidate
+    })
+    .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))
+}
+
+export function loadTopologySnapshots(): TopologySnapshotRef[] {
+  return readJson<TopologySnapshotRef[]>('topology-snapshots.json', [])
+    .slice()
+    .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+}
+
+export function loadTopologyApplyPlans(): TopologyApplyPlan[] {
+  return readJson<TopologyApplyPlan[]>('topology-apply-plans.json', [])
+    .slice()
+    .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+}
+
+export function loadTopologyExecutionRecords(): TopologyExecutionRecord[] {
+  return readJsonl<TopologyExecutionRecord>('topology-executions.jsonl')
+    .slice()
+    .sort((a, b) => (b.executedAt ?? b.rolledBackAt ?? b.createdAt).localeCompare(a.executedAt ?? a.rolledBackAt ?? a.createdAt))
+}
+
+export function loadTopologyArtifacts(): EvidenceArtifact[] {
+  return readJsonl<EvidenceArtifact>('topology-artifacts.jsonl')
+    .slice()
+    .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+}
+
+export function loadResolvedTopologyApplyPlans(): ResolvedTopologyApplyPlan[] {
+  const plans = loadTopologyApplyPlans()
+  const latestByPlan = new Map<string, TopologyExecutionRecord>()
+  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),
+      } satisfies ResolvedTopologyApplyPlan
+    })
+    .sort((a, b) => (b.lastActivityAt.localeCompare(a.lastActivityAt)) || (b.safeToApply === a.safeToApply ? 0 : b.safeToApply ? 1 : -1))
+}
+
+export 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),
+  }
+}
+
+export 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),
+  }
+}
+
+export function loadTopologyDashboardSummary(): TopologyDashboardSummary {
+  const governance = getActiveGovernanceSummary()
+  const summary = getTopologyReviewSummary()
+  const execution = getTopologyExecutionSummary()
+  const candidates = loadResolvedTopologyReviewCandidates()
+  return {
+    governance,
+    summary,
+    execution,
+    backlog: summary.backlog,
+    recentDecisions: summary.recentDecisions,
+    acceptedReady: execution.acceptedReady,
+    preparedQueue: execution.preparedQueue,
+    appliedHistory: execution.appliedHistory,
+    candidates,
+  }
+}
+
+function normalizePressureValue(value: string | undefined): string {
+  return (value ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_/]+/g, '-')
+}
+
+function pressureRegionKey(signal: Pick<PressureSignal, 'capability' | 'region' | 'kind'>): string {
+  return normalizePressureValue(signal.capability ?? signal.region ?? signal.kind) || 'general-pressure'
+}
+
+function motifIdForSignal(signal: Pick<PressureSignal, 'capability' | 'region' | 'kind'>): string {
+  return `motif_${pressureRegionKey(signal)}`
+}
+
+function pressureComparisonKey(signal: PressureSignal): string {
+  const projectKey = normalizePressureValue(signal.projectId ?? signal.projectPath ?? 'global')
+  return `${projectKey}::${pressureRegionKey(signal)}`
+}
+
+function interventionComparisonKeys(intervention: PressureIntervention): string[] {
+  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: PressureSignal, intervention: PressureIntervention): boolean {
+  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: string, signals: ResolvedPressureSignal[], intervention: PressureIntervention): boolean {
+  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: string, signals: ResolvedPressureSignal[], event: TransferEvent): boolean {
+  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: PressureSignal[] = loadPressureSignals(),
+  interventions: PressureIntervention[] = loadPressureInterventions(),
+): ActiveGovernanceSummary {
+  const highPrioritySignals = pressureSignals.filter((signal) => signal.priority === 'high' && signal.status !== 'addressed').length
+  const recurringCrossProjectRegions = new Map<string, Set<string>>()
+  for (const signal of pressureSignals) {
+    const projectId = signal.projectId ?? signal.projectPath
+    if (!projectId) continue
+    const projects = recurringCrossProjectRegions.get(pressureRegionKey(signal)) ?? new Set<string>()
+    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: GovernanceModeName = 'balanced'
+  let derivedRationale: string[] = [
+    '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),
+  }
+}
+
+export function getActiveGovernanceSummary(): ActiveGovernanceSummary {
+  return deriveGovernanceSummary()
+}
+
+function buildRouteRecommendation(params: {
+  signal: PressureSignal
+  relatedSignals: PressureSignal[]
+  linkedInterventions: PressureIntervention[]
+  governanceMode: GovernanceModeName
+}): PressureRouteRecommendation {
+  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: string[] = []
+
+  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: PressureIntervention,
+  acceptedProposalIds: Set<string>,
+  acceptedArtifactIds: Set<string>,
+  realizedTransferEventIds: Set<string>,
+): boolean {
+  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: PressureInterventionImpact, status: PressureInterventionStatus): boolean {
+  if (status === 'failed' || status === 'dry-run') return false
+  return impact === 'exploratory' || impact === 'structural' || impact === 'resolving'
+}
+
+export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
+  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<string, string>()
+  const signalsByRegion = new Map<string, PressureSignal[]>()
+
+  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: PressureLifecycleState = 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 projectRoleForSkill(skillId: string, graph: SkillGraph): CognitiveRole {
   const node = graph.nodes.find((entry) => entry.id === skillId)
   if (!node) return 'hybrid'
   return inferCognitiveRole(node)
 }
 
+export function loadPressureMotifs(): ResolvedPressureMotif[] {
+  const resolvedSignals = loadResolvedPressureSignals()
+  const interventions = loadPressureInterventions()
+  const transferEvents = loadTransferEvents()
+  const governance = deriveGovernanceSummary()
+  const groups = new Map<string, ResolvedPressureSignal[]>()
+
+  for (const signal of resolvedSignals) {
+    const regionKey = pressureRegionKey(signal)
+    const entries = groups.get(regionKey) ?? []
+    entries.push(signal)
+    groups.set(regionKey, entries)
+  }
+
+  const motifs: ResolvedPressureMotif[] = []
+
+  for (const [regionKey, signals] of groups.entries()) {
+    const projectIds = [...new Set(signals.map((signal) => signal.projectId ?? signal.projectPath).filter(Boolean))] as string[]
+    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: PressureLifecycleState = 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: governance.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) as string[],
+    ].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: PressureLifecycleState) => 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)
+  })
+}
+
 export function loadCoEvolutionSummary(): CoEvolutionDashboardSummary {
   const graph = loadGraph()
   const pressureSignals = loadPressureSignals()
+  const resolvedSignals = loadResolvedPressureSignals()
+  const pressureInterventions = loadPressureInterventions()
+  const pressureMotifs = loadPressureMotifs()
+  const transferEvents = loadTransferEvents()
+  const governance = getActiveGovernanceSummary()
+  const topologyReviews = getTopologyReviewSummary()
+  const topologyExecution = getTopologyExecutionSummary()
   const rolePressure = emptyCounts(['generalist', 'specialist', 'hybrid'] as const)
   const projectBuckets = new Map<string, ProjectPressureSummary>()
+  const projectResponses = new Map<string, ProjectResponseSummary>()
   const areaProjects = new Map<string, Set<string>>()
   const recommendationCounts = new Map<'research' | 'specialize' | 'create', number>()
+  const routeCounts = new Map<PressureInterventionType, number>()
+  const interventionLaneMap = new Map<PressureInterventionType, { type: PressureInterventionType; total: number; resolving: number; exploratory: number; none: number }>()
 
   for (const signal of pressureSignals) {
     for (const skillId of signal.skillIds ?? []) {
@@ -454,10 +1539,63 @@ export function loadCoEvolutionSummary(): CoEvolutionDashboardSummary {
     }
   }
 
+  for (const signal of resolvedSignals) {
+    if (signal.routeRecommendation) {
+      routeCounts.set(signal.routeRecommendation.route, (routeCounts.get(signal.routeRecommendation.route) ?? 0) + 1)
+    }
+    if (!signal.projectId) continue
+    const existing = projectResponses.get(signal.projectId) ?? {
+      ...(projectBuckets.get(signal.projectId) ?? {
+        projectId: signal.projectId,
+        totalSignals: 0,
+        nativeSignals: 0,
+        derivedSignals: 0,
+        highPrioritySignals: 0,
+        topCapabilities: [],
+      }),
+      openSignals: 0,
+      inProgressSignals: 0,
+      addressedSignals: 0,
+      staleSignals: 0,
+      activeInterventions: 0,
+      recentInterventionTypes: [],
+    }
+    if (signal.lifecycle === 'open') existing.openSignals += 1
+    if (signal.lifecycle === 'in-progress') existing.inProgressSignals += 1
+    if (signal.lifecycle === 'addressed') existing.addressedSignals += 1
+    if (signal.lifecycle === 'stale') existing.staleSignals += 1
+    existing.activeInterventions += signal.linkedInterventions.filter((intervention) => interventionKeepsPressureActive(intervention.impact, intervention.status)).length
+    for (const type of signal.interventionTypes) {
+      if (!existing.recentInterventionTypes.includes(type) && existing.recentInterventionTypes.length < 3) {
+        existing.recentInterventionTypes.push(type)
+      }
+    }
+    projectResponses.set(signal.projectId, existing)
+  }
+
+  for (const intervention of pressureInterventions) {
+    const lane = interventionLaneMap.get(intervention.interventionType) ?? {
+      type: intervention.interventionType,
+      total: 0,
+      resolving: 0,
+      exploratory: 0,
+      none: 0,
+    }
+    lane.total += 1
+    if (intervention.impact === 'resolving') lane.resolving += 1
+    else if (intervention.impact === 'exploratory' || intervention.impact === 'structural') lane.exploratory += 1
+    else lane.none += 1
+    interventionLaneMap.set(intervention.interventionType, lane)
+  }
+
   const topProjects = [...projectBuckets.values()]
     .sort((a, b) => b.totalSignals - a.totalSignals || b.highPrioritySignals - a.highPrioritySignals)
     .slice(0, 6)
 
+  const responseProjects = [...projectResponses.values()]
+    .sort((a, b) => (b.openSignals + b.inProgressSignals) - (a.openSignals + a.inProgressSignals) || b.highPrioritySignals - a.highPrioritySignals)
+    .slice(0, 8)
+
   const crossProjectGapAreas = [...areaProjects.entries()]
     .filter(([, projects]) => projects.size >= 2)
     .map(([area, projects]) => ({ area, projects: [...projects], count: projects.size }))
@@ -468,16 +1606,98 @@ export function loadCoEvolutionSummary(): CoEvolutionDashboardSummary {
     .map(([action, count]) => ({ action, count }))
     .sort((a, b) => b.count - a.count)
 
+  const governedRoutes = [...routeCounts.entries()]
+    .map(([route, total]) => ({ route, total }))
+    .sort((a, b) => b.total - a.total || a.route.localeCompare(b.route))
+
+  const interventionLanes = [...interventionLaneMap.values()]
+    .sort((a, b) => b.total - a.total || a.type.localeCompare(b.type))
+
+  const backlog = resolvedSignals
+    .filter((signal) => signal.lifecycle === 'open' || signal.lifecycle === 'in-progress')
+    .sort((a, b) => {
+      const priorityScore = (value?: string) => value === 'high' ? 3 : value === 'medium' ? 2 : 1
+      return priorityScore(b.priority) - priorityScore(a.priority) || b.severity - a.severity || b.detectedAt.localeCompare(a.detectedAt)
+    })
+    .slice(0, 12)
+
+  const promoteQueue = pressureMotifs
+    .filter((motif) => motif.lifecycle !== 'addressed' && motif.suggestedRoute.route === 'generalize')
+    .slice(0, 8)
+
+  const recentAddressed = resolvedSignals
+    .filter((signal) => signal.lifecycle === 'addressed')
+    .sort((a, b) => (b.addressedAt ?? b.lastActivityAt).localeCompare(a.addressedAt ?? a.lastActivityAt))
+    .slice(0, 8)
+
+  const recentInterventions = pressureInterventions.slice(0, 8)
+  const recentTransfers = transferEvents.slice(0, 8)
+
   return {
     pressureSignals: {
       total: pressureSignals.length,
       native: pressureSignals.filter((signal) => signal.provenance === 'failure-native' || signal.provenance === 'project-analysis-native').length,
       derived: pressureSignals.filter((signal) => signal.provenance === 'failure-derived' || signal.provenance === 'profile-gap-derived').length,
     },
+    pressureInterventions: {
+      total: pressureInterventions.length,
+      started: pressureInterventions.filter((intervention) => intervention.status === 'started').length,
+      completed: pressureInterventions.filter((intervention) => intervention.status === 'completed').length,
+      failed: pressureInterventions.filter((intervention) => intervention.status === 'failed').length,
+      dryRun: pressureInterventions.filter((intervention) => intervention.status === 'dry-run').length,
+    },
+    pressureLifecycle: {
+      open: resolvedSignals.filter((signal) => signal.lifecycle === 'open').length,
+      inProgress: resolvedSignals.filter((signal) => signal.lifecycle === 'in-progress').length,
+      addressed: resolvedSignals.filter((signal) => signal.lifecycle === 'addressed').length,
+      stale: resolvedSignals.filter((signal) => signal.lifecycle === 'stale').length,
+      highPriorityOpen: resolvedSignals.filter((signal) => signal.lifecycle !== 'addressed' && signal.priority === 'high').length,
+    },
+    pressureMotifs: {
+      total: pressureMotifs.length,
+      open: pressureMotifs.filter((motif) => motif.lifecycle === 'open').length,
+      inProgress: pressureMotifs.filter((motif) => motif.lifecycle === 'in-progress').length,
+      addressed: pressureMotifs.filter((motif) => motif.lifecycle === 'addressed').length,
+      stale: pressureMotifs.filter((motif) => motif.lifecycle === 'stale').length,
+      promotionReady: pressureMotifs.filter((motif) => motif.lifecycle !== 'addressed' && motif.suggestedRoute.route === 'generalize').length,
+    },
+    governance,
+    topologyReviews: {
+      total: topologyReviews.total,
+      open: topologyReviews.open,
+      accepted: topologyReviews.accepted,
+      rejected: topologyReviews.rejected,
+      deferred: topologyReviews.deferred,
+      highPriorityOpen: topologyReviews.highPriorityOpen,
+      generatedFromManualReview: topologyReviews.generatedFromManualReview,
+      byChangeType: topologyReviews.byChangeType,
+    },
+    topologyExecution: {
+      plans: topologyExecution.plans,
+      pending: topologyExecution.pending,
+      prepared: topologyExecution.prepared,
+      applied: topologyExecution.applied,
+      rolledBack: topologyExecution.rolledBack,
+      failed: topologyExecution.failed,
+      safeToApply: topologyExecution.safeToApply,
+      prepareOnly: topologyExecution.prepareOnly,
+      snapshots: topologyExecution.snapshots,
+      artifacts: topologyExecution.artifacts,
+    },
     topProjects,
+    responseProjects,
     rolePressure,
     crossProjectGapAreas,
     activeRecommendations,
+    governedRoutes,
+    interventionLanes,
+    backlog,
+    promoteQueue,
+    recentAddressed,
+    recentInterventions,
+    recentTransfers,
+    topologyBacklog: topologyReviews.backlog,
+    recentTopologyDecisions: topologyReviews.recentDecisions,
   }
 }
 
@@ -556,9 +1776,23 @@ export function loadOntologySummary(): OntologyDashboardSummary {
   const artifacts = loadEvolutionArtifacts()
   const activationTraces = loadActivationTraces()
   const pressureSignals = loadPressureSignals()
+  const pressureInterventions = loadPressureInterventions()
+  const resolvedPressureSignals = loadResolvedPressureSignals()
+  const pressureMotifs = loadPressureMotifs()
+  const transferEvents = loadTransferEvents()
+  const governance = getActiveGovernanceSummary()
+  const topologyReviews = getTopologyReviewSummary()
+  const topologyExecution = getTopologyExecutionSummary()
   const skillRoles = emptyCounts(['generalist', 'specialist', 'hybrid'] as const)
   const stabilityStates = emptyCounts(['stable', 'adaptive', 'experimental'] as const)
   const plasticityStates = emptyCounts(['consolidated', 'volatile', 'candidate'] as const)
+  const governedRoutes: Record<PressureInterventionType, number> = {
+    research: 0,
+    specialize: 0,
+    evolve: 0,
+    generalize: 0,
+    'manual-review': 0,
+  }
 
   for (const node of graph.nodes) {
     skillRoles[inferCognitiveRole(node)] += 1
@@ -566,6 +1800,10 @@ export function loadOntologySummary(): OntologyDashboardSummary {
     plasticityStates[inferPlasticityState(node)] += 1
   }
 
+  for (const signal of resolvedPressureSignals) {
+    if (signal.routeRecommendation) governedRoutes[signal.routeRecommendation.route] += 1
+  }
+
   const proposals = history.iterations.flatMap((iteration) => iteration.proposals)
   const observedMutationActions = [...new Set(proposals.map((proposal) => proposal.action))].sort()
   const evidenceBackedProposals = proposals.filter((proposal) => {
@@ -607,6 +1845,66 @@ export function loadOntologySummary(): OntologyDashboardSummary {
       native: pressureSignals.filter((signal) => signal.provenance === 'failure-native' || signal.provenance === 'project-analysis-native').length,
       derived: pressureSignals.filter((signal) => signal.provenance === 'failure-derived' || signal.provenance === 'profile-gap-derived').length,
     },
+    pressureInterventions: {
+      total: pressureInterventions.length,
+      started: pressureInterventions.filter((intervention) => intervention.status === 'started').length,
+      completed: pressureInterventions.filter((intervention) => intervention.status === 'completed').length,
+      failed: pressureInterventions.filter((intervention) => intervention.status === 'failed').length,
+      dryRun: pressureInterventions.filter((intervention) => intervention.status === 'dry-run').length,
+    },
+    pressureLifecycle: {
+      open: resolvedPressureSignals.filter((signal) => signal.lifecycle === 'open').length,
+      inProgress: resolvedPressureSignals.filter((signal) => signal.lifecycle === 'in-progress').length,
+      addressed: resolvedPressureSignals.filter((signal) => signal.lifecycle === 'addressed').length,
+      stale: resolvedPressureSignals.filter((signal) => signal.lifecycle === 'stale').length,
+    },
+    pressureMotifs: {
+      total: pressureMotifs.length,
+      open: pressureMotifs.filter((motif) => motif.lifecycle === 'open').length,
+      inProgress: pressureMotifs.filter((motif) => motif.lifecycle === 'in-progress').length,
+      addressed: pressureMotifs.filter((motif) => motif.lifecycle === 'addressed').length,
+      stale: pressureMotifs.filter((motif) => motif.lifecycle === 'stale').length,
+      promotionReady: pressureMotifs.filter((motif) => motif.lifecycle !== 'addressed' && motif.suggestedRoute.route === 'generalize').length,
+    },
+    governedRoutes,
+    transferEvents: {
+      total: transferEvents.length,
+      realized: transferEvents.filter((event) => event.status === 'realized').length,
+      candidate: transferEvents.filter((event) => event.status === 'candidate').length,
+      rejected: transferEvents.filter((event) => event.status === 'rejected').length,
+    },
+    governance: {
+      activeMode: governance.activeMode,
+      derivedMode: governance.derivedMode,
+      source: governance.source,
+      manualMode: governance.manualMode,
+      rationale: governance.rationale,
+      reviewThreshold: governance.profile.reviewThreshold,
+      riskTolerance: governance.profile.riskTolerance,
+      plasticityBias: governance.profile.plasticityBias,
+    },
+    topologyReviews: {
+      total: topologyReviews.total,
+      open: topologyReviews.open,
+      accepted: topologyReviews.accepted,
+      rejected: topologyReviews.rejected,
+      deferred: topologyReviews.deferred,
+      highPriorityOpen: topologyReviews.highPriorityOpen,
+      generatedFromManualReview: topologyReviews.generatedFromManualReview,
+      byChangeType: topologyReviews.byChangeType,
+    },
+    topologyExecution: {
+      plans: topologyExecution.plans,
+      pending: topologyExecution.pending,
+      prepared: topologyExecution.prepared,
+      applied: topologyExecution.applied,
+      rolledBack: topologyExecution.rolledBack,
+      failed: topologyExecution.failed,
+      safeToApply: topologyExecution.safeToApply,
+      prepareOnly: topologyExecution.prepareOnly,
+      snapshots: topologyExecution.snapshots,
+      artifacts: topologyExecution.artifacts,
+    },
     annotatedFailures: {
       pressureSignals: failures.filter((failure) => (failure.pressureSignals?.length ?? 0) > 0).length,
       capabilityGaps: failures.filter((failure) => (failure.capabilityGaps?.length ?? 0) > 0).length,