helixevo 0.3.1 → 0.4.0

package/dashboard/app/coevolution/client.tsx

@@ -0,0 +1,560 @@
+'use client'
+
+import Link from 'next/link'
+import { useRef, useState } from 'react'
+import { ConsolePanel } from '@/components/console-panel'
+import { MetricCard } from '@/components/metric-card'
+import { PageHero } from '@/components/page-hero'
+import { SectionFrame } from '@/components/section-frame'
+
+type RunState = 'idle' | 'running' | 'success' | 'error' | 'stopped'
+type CommandName = 'evolve' | 'research' | 'generalize'
+type PressureInterventionType = 'research' | 'specialize' | 'evolve' | 'generalize' | 'manual-review'
+
+type Summary = {
+  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: {
+    activeMode: 'conservative' | 'balanced' | 'exploration' | 'project-critical' | 'consolidation-focused' | 'transfer-focused'
+    derivedMode: 'conservative' | 'balanced' | 'exploration' | 'project-critical' | 'consolidation-focused' | 'transfer-focused'
+    source: 'derived' | 'operator-selected'
+    manualMode?: 'conservative' | 'balanced' | 'exploration' | 'project-critical' | 'consolidation-focused' | 'transfer-focused'
+    rationale: string[]
+    profile: { reviewThreshold: number; riskTolerance: number; plasticityBias: number; explanation: string }
+  }
+  topologyReviews: {
+    total: number
+    open: number
+    accepted: number
+    rejected: number
+    deferred: number
+    highPriorityOpen: number
+    generatedFromManualReview: number
+    byChangeType: { merge: number; split: number; promote: number; demote: number; rewire: number; prune: number; consolidate: number }
+  }
+  topologyExecution: {
+    plans: number
+    pending: number
+    prepared: number
+    applied: number
+    rolledBack: number
+    failed: number
+    safeToApply: number
+    prepareOnly: number
+    snapshots: number
+    artifacts: number
+  }
+  topProjects: { projectId: string; totalSignals: number; nativeSignals: number; derivedSignals: number; highPrioritySignals: number; topCapabilities: string[] }[]
+  responseProjects: { projectId: string; totalSignals: number; nativeSignals: number; derivedSignals: number; highPrioritySignals: number; topCapabilities: string[]; openSignals: number; inProgressSignals: number; addressedSignals: number; staleSignals: number; activeInterventions: number; recentInterventionTypes: PressureInterventionType[] }[]
+  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: {
+    id: string
+    kind: string
+    projectId?: string
+    capability?: string
+    description?: string
+    priority?: 'high' | 'medium' | 'low'
+    suggestedAction?: 'research' | 'specialize' | 'create'
+    lifecycle: 'open' | 'in-progress' | 'addressed' | 'stale'
+    responseSummary: string
+    detectedAt: string
+    lastActivityAt: string
+    interventionTypes: PressureInterventionType[]
+    routeRecommendation?: {
+      route: PressureInterventionType
+      scope: 'local' | 'project' | 'network'
+      confidence: number
+      governanceMode: Summary['governance']['activeMode']
+      triggeredBy: string
+      reasons: string[]
+    }
+  }[]
+  promoteQueue: {
+    id: string
+    key: string
+    kind: string
+    capability?: string
+    description: string
+    projectIds: string[]
+    recurrenceCount: number
+    highPriorityCount: number
+    lifecycle: 'open' | 'in-progress' | 'addressed' | 'stale'
+    responseSummary: string
+    lastActivityAt: string
+    interventionTypes: PressureInterventionType[]
+    suggestedRoute: {
+      route: PressureInterventionType
+      scope: 'local' | 'project' | 'network'
+      confidence: number
+      governanceMode: Summary['governance']['activeMode']
+      triggeredBy: string
+      reasons: string[]
+    }
+  }[]
+  recentAddressed: { id: string; kind: string; projectId?: string; capability?: string; description?: string; addressedAt?: string; responseSummary: string; interventionTypes: PressureInterventionType[] }[]
+  recentInterventions: { id: string; interventionType: PressureInterventionType; status: 'started' | 'completed' | 'failed' | 'dry-run'; impact: 'exploratory' | 'structural' | 'resolving' | 'none'; projectId?: string; capabilities?: string[]; reasonSummary: string; completedAt?: string; createdAt: string }[]
+  recentTransfers: { id: string; timestamp: string; transferType: 'specialist-to-generalist' | 'generalist-to-project' | 'cross-project' | 'domain-transfer'; targetSkillIds?: string[]; capabilityIds?: string[]; motifIds?: string[]; status?: 'candidate' | 'realized' | 'rejected'; summary?: string }[]
+}
+
+interface Props {
+  summary: Summary
+}
+
+function consoleTone(state: RunState): 'neutral' | 'green' | 'red' | 'yellow' {
+  if (state === 'success') return 'green'
+  if (state === 'error') return 'red'
+  if (state === 'stopped') return 'yellow'
+  return 'neutral'
+}
+
+function toneForLifecycle(lifecycle: 'open' | 'in-progress' | 'addressed' | 'stale') {
+  if (lifecycle === 'addressed') return 'green'
+  if (lifecycle === 'in-progress') return 'blue'
+  if (lifecycle === 'stale') return 'gray'
+  return 'yellow'
+}
+
+function toneForRoute(route: PressureInterventionType) {
+  if (route === 'generalize') return 'purple'
+  if (route === 'evolve') return 'green'
+  if (route === 'specialize') return 'blue'
+  if (route === 'manual-review') return 'yellow'
+  return 'gray'
+}
+
+function toneForMode(mode: Summary['governance']['activeMode']): 'blue' | 'green' | 'purple' | 'yellow' | 'neutral' {
+  if (mode === 'transfer-focused') return 'purple'
+  if (mode === 'project-critical') return 'yellow'
+  if (mode === 'exploration') return 'blue'
+  if (mode === 'conservative') return 'neutral'
+  if (mode === 'consolidation-focused') return 'green'
+  return 'neutral'
+}
+
+function formatDate(value: string | undefined) {
+  if (!value) return '—'
+  return new Date(value).toLocaleString()
+}
+
+function formatMode(mode: Summary['governance']['activeMode']) {
+  return mode.split('-').join(' ')
+}
+
+export default function CoEvolutionClient({ summary }: Props) {
+  const [runState, setRunState] = useState<RunState>('idle')
+  const [activeCommand, setActiveCommand] = useState<CommandName | null>(null)
+  const [output, setOutput] = useState('')
+  const abortRef = useRef<AbortController | null>(null)
+  const outputRef = useRef<HTMLPreElement | null>(null)
+
+  const handleRun = async (command: CommandName) => {
+    setActiveCommand(command)
+    setRunState('running')
+    setOutput('')
+    const controller = new AbortController()
+    abortRef.current = controller
+
+    try {
+      const res = await fetch('/api/run', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ command }),
+        signal: controller.signal,
+      })
+
+      if (!res.body) {
+        setOutput('No response body')
+        setRunState('error')
+        return
+      }
+
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let sseBuffer = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        sseBuffer += decoder.decode(value, { stream: true })
+        const events = sseBuffer.split('\n\n')
+        sseBuffer = events.pop() ?? ''
+
+        for (const event of events) {
+          const lines = event.split('\n')
+          let eventType = ''
+          let eventData = ''
+
+          for (const line of lines) {
+            if (line.startsWith('event: ')) eventType = line.slice(7)
+            if (line.startsWith('data: ')) eventData = line.slice(6)
+          }
+
+          if (eventType === 'output' && eventData) {
+            try {
+              const text = JSON.parse(eventData) as string
+              setOutput((prev) => prev + text)
+              setTimeout(() => {
+                if (outputRef.current) outputRef.current.scrollTop = outputRef.current.scrollHeight
+              }, 10)
+            } catch {}
+          }
+
+          if (eventType === 'done' && eventData) {
+            try {
+              const result = JSON.parse(JSON.parse(eventData) as string) as { success: boolean; stopped?: boolean }
+              setRunState(result.stopped ? 'stopped' : result.success ? 'success' : 'error')
+            } catch {
+              setRunState('success')
+            }
+          }
+        }
+      }
+
+      setRunState((prev) => prev === 'running' ? 'success' : prev)
+    } catch (err: unknown) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        try { await fetch('/api/run', { method: 'DELETE' }) } catch {}
+        setOutput((prev) => prev + '\n\n[Stopped by user]')
+        setRunState('stopped')
+      } else {
+        setOutput((prev) => prev || 'Network error')
+        setRunState('error')
+      }
+    } finally {
+      abortRef.current = null
+    }
+  }
+
+  const handleStop = async () => {
+    if (abortRef.current) abortRef.current.abort()
+    try { await fetch('/api/run', { method: 'DELETE' }) } catch {}
+  }
+
+  return (
+    <div style={{ display: 'grid', gap: 22 }}>
+      <PageHero
+        eyebrow="Response loop"
+        title="Co-Evolution Control"
+        description="Route adaptation under explicit governance, see which recurring motifs should be promoted, and track how local pressure turns into reusable network knowledge."
+        chips={[
+          { label: `${summary.pressureLifecycle.open} open`, tone: summary.pressureLifecycle.open > 0 ? 'yellow' : 'green' },
+          { label: `${summary.pressureMotifs.promotionReady} promotion-ready motifs`, tone: summary.pressureMotifs.promotionReady > 0 ? 'purple' : 'neutral' },
+          { label: `${summary.topologyReviews.open} topology reviews`, tone: summary.topologyReviews.open > 0 ? 'yellow' : 'green' },
+          { label: `${summary.recentTransfers.length} recent transfers`, tone: summary.recentTransfers.length > 0 ? 'green' : 'neutral' },
+          { label: formatMode(summary.governance.activeMode), tone: toneForMode(summary.governance.activeMode) },
+        ]}
+        actions={
+          <div style={{ display: 'grid', gap: 12 }}>
+            <div className="hero-note-card">
+              <div className="hero-note-label">Active governance</div>
+              <div className="hero-note-title">{formatMode(summary.governance.activeMode)}</div>
+              <div className="hero-note-copy">{summary.governance.rationale[0] ?? 'Governed routing keeps local fixes and reusable promotion in balance.'}</div>
+              <div style={{ marginTop: 8, display: 'flex', gap: 6, flexWrap: 'wrap' }}>
+                <span className="badge badge-gray">source: {summary.governance.source}</span>
+                <span className="badge badge-gray">review threshold {(summary.governance.profile.reviewThreshold * 100).toFixed(0)}%</span>
+              </div>
+            </div>
+            <div style={{ display: 'flex', gap: 10, flexWrap: 'wrap', justifyContent: 'flex-end' }}>
+              <button onClick={() => handleRun('research')} disabled={runState === 'running'} className="badge badge-blue" style={{ border: 'none', cursor: 'pointer' }}>Run research</button>
+              <button onClick={() => handleRun('evolve')} disabled={runState === 'running'} className="badge badge-green" style={{ border: 'none', cursor: 'pointer' }}>Run evolve</button>
+              <button onClick={() => handleRun('generalize')} disabled={runState === 'running'} className="badge badge-purple" style={{ border: 'none', cursor: 'pointer' }}>Run generalize</button>
+              <Link href="/topology" className="badge badge-gray">Open topology</Link>
+            </div>
+          </div>
+        }
+      />
+
+      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(180px, 1fr))', gap: 16 }}>
+        <MetricCard label="Open pressure" value={summary.pressureLifecycle.open} sublabel={`${summary.pressureLifecycle.highPriorityOpen} high-priority waiting for response`} tone={summary.pressureLifecycle.open > 0 ? 'yellow' : 'green'} icon="!" />
+        <MetricCard label="Promotion-ready motifs" value={summary.pressureMotifs.promotionReady} sublabel={`${summary.pressureMotifs.total} recurring motifs tracked`} tone="purple" icon="⇄" />
+        <MetricCard label="Topology reviews" value={summary.topologyReviews.open} sublabel={`${summary.topologyReviews.accepted} accepted • ${summary.topologyReviews.deferred} deferred`} tone={summary.topologyReviews.open > 0 ? 'yellow' : 'green'} icon="◇" />
+        <MetricCard label="Prepared topology" value={summary.topologyExecution.prepared} sublabel={`${summary.topologyExecution.applied} applied • ${summary.topologyExecution.rolledBack} rolled back`} tone={summary.topologyExecution.prepared > 0 ? 'blue' : summary.topologyExecution.applied > 0 ? 'green' : 'neutral'} icon="↑" />
+        <MetricCard label="Recorded interventions" value={summary.pressureInterventions.total} sublabel={`${summary.pressureInterventions.completed} completed • ${summary.pressureInterventions.dryRun} dry-run`} tone="blue" icon="↺" />
+        <MetricCard label="Realized transfers" value={summary.recentTransfers.filter((event) => event.status === 'realized').length} sublabel={`${summary.pressureMotifs.addressed} motifs now addressed`} tone="green" icon="↑" />
+      </div>
+
+      <SectionFrame
+        eyebrow="Topology control"
+        title="Structural review can now progress into execution"
+        description="Mixed-signal manual-review routes, graph optimize candidates, and transfer-backed promotion opportunities now persist into a dedicated topology queue and can progress into prepared or applied structural execution."
+        actions={<Link href="/topology" className="badge badge-gray">Open topology control</Link>}
+      >
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: 16 }}>
+          <div className="metric-card metric-card-blue">
+            <div className="metric-card-header">
+              <div>
+                <div className="metric-card-label">Open structural review</div>
+                <div className="metric-card-value">{summary.topologyReviews.open}</div>
+              </div>
+              <div className="metric-card-icon">⇄</div>
+            </div>
+            <div className="metric-card-sublabel">{summary.topologyReviews.highPriorityOpen} high-priority items waiting for decision</div>
+          </div>
+          <div className="metric-card metric-card-purple">
+            <div className="metric-card-header">
+              <div>
+                <div className="metric-card-label">Manual-route backlog</div>
+                <div className="metric-card-value">{summary.topologyReviews.generatedFromManualReview}</div>
+              </div>
+              <div className="metric-card-icon">!</div>
+            </div>
+            <div className="metric-card-sublabel">pressure routed into review instead of another blind automatic pass</div>
+          </div>
+          <div className="metric-card metric-card-green">
+            <div className="metric-card-header">
+              <div>
+                <div className="metric-card-label">Prepared / applied</div>
+                <div className="metric-card-value">{summary.topologyExecution.prepared + summary.topologyExecution.applied}</div>
+              </div>
+              <div className="metric-card-icon">✓</div>
+            </div>
+            <div className="metric-card-sublabel">{summary.topologyExecution.prepared} prepared • {summary.topologyExecution.applied} applied • {summary.topologyExecution.snapshots} snapshots</div>
+          </div>
+        </div>
+      </SectionFrame>
+
+      <div className="grid-2">
+        <SectionFrame
+          eyebrow="Governance"
+          title="Why the loop is routing this way"
+          description="Milestone 5 turns routing into an interpretable layer: you can see the current governance bias and which response paths dominate the backlog."
+        >
+          <div style={{ display: 'grid', gap: 14 }}>
+            <div style={{ padding: '14px 16px', borderRadius: 18, background: 'rgba(255,255,255,0.72)', border: '1px solid var(--border)' }}>
+              <div className="section-label" style={{ marginBottom: 8 }}>Mode rationale</div>
+              <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', marginBottom: 10 }}>
+                <span className={`hero-chip hero-chip-${toneForMode(summary.governance.activeMode)}`}>{formatMode(summary.governance.activeMode)}</span>
+                <span className="badge badge-gray">{summary.pressureMotifs.total} motifs</span>
+                <span className="badge badge-gray">{summary.governedRoutes.length} routed lanes visible</span>
+              </div>
+              <div style={{ display: 'grid', gap: 6 }}>
+                {summary.governance.rationale.map((reason, index) => (
+                  <div key={`${reason}-${index}`} className="signal-text">• {reason}</div>
+                ))}
+              </div>
+            </div>
+
+            <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
+              {summary.governedRoutes.length > 0 ? summary.governedRoutes.map((entry) => (
+                <span key={entry.route} className={`hero-chip hero-chip-${toneForRoute(entry.route)}`}>
+                  {entry.route} × {entry.total}
+                </span>
+              )) : <span className="badge badge-gray">No governed route counts yet</span>}
+            </div>
+          </div>
+        </SectionFrame>
+
+        <SectionFrame
+          eyebrow="Promotion queue"
+          title="Recurring motifs that should generalize"
+          description="These are the strongest current candidates for promoting repeated local pressure into reusable network knowledge."
+          actions={<Link href="/network" className="badge badge-gray">Open network</Link>}
+        >
+          <div className="summary-list">
+            {summary.promoteQueue.length > 0 ? summary.promoteQueue.map((motif) => (
+              <div key={motif.id} className="summary-row" style={{ alignItems: 'flex-start' }}>
+                <div className="summary-row-main">
+                  <div className="summary-row-title">{motif.capability ?? motif.kind}</div>
+                  <div className="summary-row-meta">{motif.projectIds.length} projects • {motif.recurrenceCount} recurring signals • {motif.responseSummary}</div>
+                  <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap', marginTop: 8 }}>
+                    <span className={`badge badge-${toneForLifecycle(motif.lifecycle)}`}>{motif.lifecycle}</span>
+                    <span className="badge badge-purple">recommend {motif.suggestedRoute.route}</span>
+                    <span className="badge badge-gray">confidence {(motif.suggestedRoute.confidence * 100).toFixed(0)}%</span>
+                    {motif.projectIds.slice(0, 3).map((projectId) => <span key={`${motif.id}-${projectId}`} className="badge badge-gray">{projectId}</span>)}
+                  </div>
+                  <div style={{ display: 'grid', gap: 4, marginTop: 10 }}>
+                    {motif.suggestedRoute.reasons.slice(0, 2).map((reason, index) => (
+                      <div key={`${motif.id}-reason-${index}`} className="signal-text">• {reason}</div>
+                    ))}
+                  </div>
+                </div>
+              </div>
+            )) : (
+              <div className="empty-state" style={{ padding: 24 }}>
+                <div className="empty-state-title">No promotion-ready motifs yet</div>
+                <div className="empty-state-desc">Recurring cross-project demand will appear here once the same pressure region repeats often enough to justify generalization.</div>
+              </div>
+            )}
+          </div>
+        </SectionFrame>
+      </div>
+
+      <SectionFrame
+        eyebrow="Response lanes"
+        title="Intervention mix"
+        description="See which response modes are carrying the loop right now, and whether they are producing exploratory versus resolving work."
+      >
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(210px, 1fr))', gap: 16 }}>
+          {summary.interventionLanes.length > 0 ? summary.interventionLanes.map((lane) => (
+            <div key={lane.type} className={`metric-card metric-card-${toneForRoute(lane.type)}`}>
+              <div className="metric-card-header">
+                <div>
+                  <div className="metric-card-label">{lane.type}</div>
+                  <div className="metric-card-value">{lane.total}</div>
+                </div>
+                <div className="metric-card-icon">⇄</div>
+              </div>
+              <div className="metric-card-sublabel">{lane.resolving} resolving • {lane.exploratory} exploratory • {lane.none} non-resolving</div>
+            </div>
+          )) : (
+            <div className="empty-state" style={{ gridColumn: '1 / -1', padding: 24 }}>
+              <div className="empty-state-title">No intervention records yet</div>
+              <div className="empty-state-desc">Run research, evolve, or generalize to start populating the governed response ledger.</div>
+            </div>
+          )}
+        </div>
+      </SectionFrame>
+
+      {runState !== 'idle' ? (
+        <ConsolePanel
+          tone={consoleTone(runState)}
+          title={<span>{runState === 'running' ? `Running ${activeCommand}…` : runState === 'success' ? `${activeCommand} completed` : runState === 'stopped' ? `${activeCommand} stopped` : `${activeCommand} failed`}</span>}
+          actions={runState === 'running' ? <button onClick={handleStop} className="badge badge-red" style={{ border: 'none', cursor: 'pointer' }}>Stop</button> : <button onClick={() => window.location.reload()} className="badge badge-gray" style={{ border: 'none', cursor: 'pointer' }}>Refresh data</button>}
+        >
+          <pre ref={outputRef} style={{ margin: 0, padding: '16px 18px', fontSize: 11.5, lineHeight: 1.62, color: 'var(--text-secondary)', whiteSpace: 'pre-wrap', wordBreak: 'break-word' }}>
+            {output || 'Waiting for command output…'}
+          </pre>
+        </ConsolePanel>
+      ) : null}
+
+      <div className="grid-2">
+        <SectionFrame
+          eyebrow="Project hotspots"
+          title="Where the loop is under the most pressure"
+          description="Projects with the heaviest open or in-progress response demand."
+          actions={<Link href="/projects" className="badge badge-gray">Open projects</Link>}
+        >
+          <div className="summary-list">
+            {summary.responseProjects.length > 0 ? summary.responseProjects.map((project) => (
+              <div key={project.projectId} className="summary-row" style={{ alignItems: 'flex-start' }}>
+                <div className="summary-row-main">
+                  <div className="summary-row-title">{project.projectId}</div>
+                  <div className="summary-row-meta">{project.totalSignals} signals • {project.highPrioritySignals} high-priority • {project.activeInterventions} active interventions</div>
+                  <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap', marginTop: 8 }}>
+                    <span className="badge badge-yellow">{project.openSignals} open</span>
+                    <span className="badge badge-blue">{project.inProgressSignals} in progress</span>
+                    <span className="badge badge-green">{project.addressedSignals} addressed</span>
+                    {project.recentInterventionTypes.map((type) => <span key={`${project.projectId}-${type}`} className={`badge badge-${toneForRoute(type)}`}>{type}</span>)}
+                  </div>
+                </div>
+              </div>
+            )) : (
+              <div className="empty-state" style={{ padding: 24 }}>
+                <div className="empty-state-title">No project response hotspots yet</div>
+                <div className="empty-state-desc">Project-linked pressure will appear here once failures and project analysis produce current demand.</div>
+              </div>
+            )}
+          </div>
+        </SectionFrame>
+
+        <SectionFrame
+          eyebrow="Recent transfers"
+          title="Reusable knowledge promotion"
+          description="When recurring pressure gets promoted into reusable network knowledge, the transfer evidence appears here."
+          actions={<Link href="/evolution" className="badge badge-gray">Open evolution</Link>}
+        >
+          <div className="summary-list">
+            {summary.recentTransfers.length > 0 ? summary.recentTransfers.map((event) => (
+              <div key={event.id} className="summary-row" style={{ alignItems: 'flex-start' }}>
+                <div className="summary-row-main">
+                  <div className="summary-row-title">{event.summary ?? event.transferType}</div>
+                  <div className="summary-row-meta">{event.transferType} • {formatDate(event.timestamp)}</div>
+                  <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap', marginTop: 8 }}>
+                    <span className={`badge badge-${event.status === 'realized' ? 'green' : event.status === 'candidate' ? 'purple' : 'gray'}`}>{event.status ?? 'candidate'}</span>
+                    {(event.targetSkillIds ?? []).slice(0, 2).map((skill) => <span key={`${event.id}-${skill}`} className="badge badge-gray">{skill}</span>)}
+                    {(event.capabilityIds ?? []).slice(0, 2).map((capability) => <span key={`${event.id}-${capability}`} className="badge badge-gray">{capability}</span>)}
+                  </div>
+                </div>
+              </div>
+            )) : (
+              <div className="empty-state" style={{ padding: 24 }}>
+                <div className="empty-state-title">No transfer evidence yet</div>
+                <div className="empty-state-desc">Once recurring pressure is promoted into reusable generalized skill knowledge, realized transfer evidence will appear here.</div>
+              </div>
+            )}
+          </div>
+        </SectionFrame>
+      </div>
+
+      <SectionFrame
+        eyebrow="Act now"
+        title="Governed pressure queue"
+        description="Open and in-progress pressure sorted by urgency, including the route recommendation and the reasons behind it."
+      >
+        <div style={{ display: 'grid', gap: 10 }}>
+          {summary.backlog.length > 0 ? summary.backlog.map((signal) => (
+            <div key={signal.id} style={{ padding: '14px 16px', borderRadius: 18, border: '1px solid var(--border)', background: 'rgba(255,255,255,0.7)' }}>
+              <div style={{ display: 'flex', justifyContent: 'space-between', gap: 12, alignItems: 'flex-start', flexWrap: 'wrap' }}>
+                <div style={{ flex: 1 }}>
+                  <div style={{ fontSize: 13, fontWeight: 700, color: 'var(--text)' }}>{signal.capability ?? signal.kind}</div>
+                  <div style={{ fontSize: 12, color: 'var(--text-dim)', marginTop: 4, lineHeight: 1.6 }}>{signal.description ?? signal.responseSummary}</div>
+                  <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap', marginTop: 10 }}>
+                    <span className={`badge badge-${toneForLifecycle(signal.lifecycle)}`}>{signal.lifecycle}</span>
+                    {signal.priority ? <span className="badge badge-gray">{signal.priority}</span> : null}
+                    {signal.projectId ? <span className="badge badge-gray">{signal.projectId}</span> : null}
+                    {signal.routeRecommendation ? <span className={`badge badge-${toneForRoute(signal.routeRecommendation.route)}`}>recommend {signal.routeRecommendation.route}</span> : null}
+                    {signal.routeRecommendation ? <span className="badge badge-gray">{signal.routeRecommendation.scope}</span> : null}
+                    {signal.interventionTypes.map((type) => <span key={`${signal.id}-${type}`} className="badge badge-gray">{type}</span>)}
+                  </div>
+                  {signal.routeRecommendation?.reasons?.length ? (
+                    <div style={{ display: 'grid', gap: 4, marginTop: 10 }}>
+                      {signal.routeRecommendation.reasons.slice(0, 2).map((reason, index) => (
+                        <div key={`${signal.id}-reason-${index}`} className="signal-text">• {reason}</div>
+                      ))}
+                    </div>
+                  ) : null}
+                </div>
+                <div style={{ minWidth: 180, textAlign: 'right', fontSize: 11.5, color: 'var(--text-dim)', lineHeight: 1.7 }}>
+                  <div>Detected {formatDate(signal.detectedAt)}</div>
+                  <div>Last activity {formatDate(signal.lastActivityAt)}</div>
+                  {signal.routeRecommendation ? <div>Confidence {(signal.routeRecommendation.confidence * 100).toFixed(0)}%</div> : null}
+                </div>
+              </div>
+            </div>
+          )) : (
+            <div className="empty-state" style={{ padding: 24 }}>
+              <div className="empty-state-title">No open pressure backlog</div>
+              <div className="empty-state-desc">Once pressure enters the system, open and in-progress items will be queued here with governed routing recommendations.</div>
+            </div>
+          )}
+        </div>
+      </SectionFrame>
+
+      <SectionFrame
+        eyebrow="Recent interventions"
+        title="Latest recorded responses"
+        description="A raw operator log of how the system has recently responded to pressure."
+        actions={<Link href="/research" className="badge badge-gray">Open research</Link>}
+      >
+        <div className="summary-list">
+          {summary.recentInterventions.length > 0 ? summary.recentInterventions.map((intervention) => (
+            <div key={intervention.id} className="summary-row" style={{ alignItems: 'flex-start' }}>
+              <div className="summary-row-main">
+                <div className="summary-row-title">{intervention.interventionType}</div>
+                <div className="summary-row-meta">{intervention.reasonSummary}</div>
+                <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap', marginTop: 8 }}>
+                  <span className="badge badge-gray">{intervention.status}</span>
+                  <span className="badge badge-gray">{intervention.impact}</span>
+                  {intervention.projectId ? <span className="badge badge-blue">{intervention.projectId}</span> : null}
+                  {(intervention.capabilities ?? []).slice(0, 3).map((capability) => <span key={`${intervention.id}-${capability}`} className="badge badge-gray">{capability}</span>)}
+                  <span className="badge badge-gray">{formatDate(intervention.completedAt ?? intervention.createdAt)}</span>
+                </div>
+              </div>
+            </div>
+          )) : (
+            <div className="empty-state" style={{ padding: 24 }}>
+              <div className="empty-state-title">No response records yet</div>
+              <div className="empty-state-desc">Command-level intervention records will appear here once the response loop starts operating.</div>
+            </div>
+          )}
+        </div>
+      </SectionFrame>
+    </div>
+  )
+}

package/dashboard/app/coevolution/page.tsx

@@ -0,0 +1,9 @@
+import { loadCoEvolutionSummary } from '@/lib/data'
+import CoEvolutionClient from './client'
+
+export const dynamic = 'force-dynamic'
+
+export default function CoEvolutionPage() {
+  const summary = loadCoEvolutionSummary()
+  return <CoEvolutionClient summary={summary} />
+}

package/dashboard/app/commands/page.tsx

@@ -111,18 +111,18 @@ const COMMANDS: CommandInfo[] = [
   },
   {
     name: 'graph',
-    description: 'Visualize and manage the skill network graph. Shows relationships between skills (depends, enhances, conflicts, co-evolves). Can render as TUI, Mermaid diagram, or sync to Obsidian.',
+    description: 'Visualize and manage the skill network graph. Shows relationships between skills (depends, enhances, conflicts, co-evolves), and graph optimize now persists a topology review queue for merge, split, promote, and rewire candidates.',
     usage: 'helixevo graph [options]',
     examples: [
       { cmd: 'helixevo graph', desc: 'Show skill network in terminal (instant)' },
       { cmd: 'helixevo graph --rebuild', desc: 'Re-infer all relationships via LLM' },
-      { cmd: 'helixevo graph --optimize', desc: 'Detect merge/split/conflict opportunities' },
+      { cmd: 'helixevo graph --optimize', desc: 'Detect structural candidates and refresh the topology review queue' },
       { cmd: 'helixevo graph --mermaid', desc: 'Open interactive Mermaid diagram in browser' },
       { cmd: 'helixevo graph --obsidian ~/vault', desc: 'Sync skill graph to an Obsidian vault' },
     ],
     options: [
       { flag: '--rebuild', desc: 'Force rebuild — re-infer relationships via LLM call' },
-      { flag: '--optimize', desc: 'Run network optimization (merge/split/conflict detection)' },
+      { flag: '--optimize', desc: 'Run network optimization and persist topology review candidates' },
       { flag: '--mermaid', desc: 'Render as Mermaid diagram in browser' },
       { flag: '--obsidian <path>', desc: 'Sync to Obsidian vault at the given path' },
       { flag: '--verbose', desc: 'Show detailed analysis' },
@@ -131,6 +131,27 @@ const COMMANDS: CommandInfo[] = [
     needsLLM: true,
     runnable: { command: 'graph-rebuild', label: 'Rebuild Graph', icon: 'M13.828 10.172a4 4 0 00-5.656 0l-4 4a4 4 0 105.656 5.656l1.102-1.101m-.758-4.899a4 4 0 005.656 0l4-4a4 4 0 00-5.656-5.656l-1.1 1.1', color: 'var(--purple)' },
   },
+  {
+    name: 'topology',
+    description: 'Move reviewed topology candidates through an explicit structural execution pipeline. Prepare accepted candidates, apply only the safe subset, inspect snapshots and artifacts, and roll back applied structural overrides when needed.',
+    usage: 'helixevo topology [options]',
+    examples: [
+      { cmd: 'helixevo topology --status', desc: 'Show current review and execution state for topology control' },
+      { cmd: 'helixevo topology --prepare topology_rewire_abc', desc: 'Prepare an accepted topology review candidate' },
+      { cmd: 'helixevo topology --apply topology_plan_abc', desc: 'Apply a safe prepared topology plan' },
+      { cmd: 'helixevo topology --rollback topology_plan_abc', desc: 'Roll back an applied topology plan using the before-apply snapshot' },
+    ],
+    options: [
+      { flag: '--status', desc: 'Show topology review and execution state' },
+      { flag: '--prepare <candidateId>', desc: 'Prepare an accepted topology review candidate' },
+      { flag: '--apply <planId>', desc: 'Apply a safe prepared topology plan' },
+      { flag: '--rollback <planId>', desc: 'Roll back an applied topology plan' },
+      { flag: '--verbose', desc: 'Show detailed recent topology plans in the status view' },
+    ],
+    category: 'network',
+    needsLLM: false,
+    note: 'Only accepted review candidates can enter apply-plan generation. Milestone 7 applies the safe subset and keeps riskier changes in prepare-only mode.',
+  },
   {
     name: 'research',
     description: 'Proactive skill discovery via web research. Identifies gaps in your skill network, generates hypotheses, searches the web for solutions, and creates draft skills from discoveries.',

package/dashboard/app/guide/page.tsx

@@ -342,8 +342,8 @@ export default function GuidePage() {
           </div>
           <Callout type="tip">
             HelixEvo now exposes a visible <strong>brain foundation</strong> in the dashboard: ontology-backed summaries,
-            activation traces, evolution artifacts, and pressure signals all feed the Overview, Skill Network, Projects,
-            Research, and Evolution surfaces.
+            activation traces, evolution artifacts, pressure signals, governance steering, topology review, and reviewed topology execution all feed the Overview,
+            Skill Network, Topology, Projects, Research, and Evolution surfaces.
           </Callout>
         </Section>
 
@@ -908,6 +908,16 @@ generation: 3
 ├── failures.jsonl           # Captured failure records (append-only)
 ├── activation-traces.jsonl  # Native + derived activation traces
 ├── pressure-signals.jsonl   # Native + derived adaptation pressure
+├── pressure-interventions.jsonl # Routed intervention ledger across response lanes
+├── transfer-events.jsonl    # Promotion / transfer evidence across motifs and projects
+├── governance-state.json    # Operator-selected governance steering state
+├── topology-review-candidates.json # Persisted structural review queue
+├── topology-review-decisions.jsonl # Accept / reject / defer decision ledger
+├── topology-overrides.json   # Applied safe structural topology overrides
+├── topology-snapshots.json   # Snapshot refs for reviewed execution and rollback
+├── topology-apply-plans.json # Prepared reviewed topology plans
+├── topology-executions.jsonl # Prepared/applied/rolled-back execution ledger
+├── topology-artifacts.jsonl  # Evidence artifacts for reviewed structural execution
 ├── evolution-artifacts.jsonl # Proposal/iteration evidence artifacts
 ├── frontier.json            # Pareto frontier (top-K programs)
 ├── evolution-history.json   # All evolution iterations + proposals