helixevo 0.6.1 → 0.7.0

package/dashboard/app/proof/client.tsx

@@ -0,0 +1,295 @@
+'use client'
+
+import { useState } from 'react'
+import { ConsolePanel } from '@/components/console-panel'
+import { MetricCard } from '@/components/metric-card'
+import { NextStepEmptyState } from '@/components/next-step-empty-state'
+import { OperatorLoopTrail } from '@/components/operator-loop-trail'
+import { PageHero } from '@/components/page-hero'
+import { SectionFrame } from '@/components/section-frame'
+import { SurfaceJumpLinks } from '@/components/surface-jump-links'
+import type { ProofDashboardSummary, ProofOutcomeState, ProofReviewDecisionStatus, ProofTargetType } from '@/lib/proof'
+
+type RunState = 'idle' | 'running' | 'success' | 'error'
+
+function toneForOutcome(outcome: ProofOutcomeState): 'green' | 'yellow' | 'purple' | 'neutral' {
+  if (outcome === 'effective') return 'green'
+  if (outcome === 'regressed') return 'yellow'
+  if (outcome === 'mixed') return 'purple'
+  return 'neutral'
+}
+
+function toneForTarget(targetType: ProofTargetType): 'blue' | 'green' | 'purple' | 'yellow' | 'neutral' {
+  if (targetType === 'pressure-intervention') return 'blue'
+  if (targetType === 'transfer-event') return 'green'
+  if (targetType === 'topology-execution') return 'yellow'
+  if (targetType === 'ontology-extension') return 'purple'
+  return 'neutral'
+}
+
+function labelForTarget(targetType: ProofTargetType) {
+  if (targetType === 'pressure-intervention') return 'Intervention'
+  if (targetType === 'transfer-event') return 'Transfer'
+  if (targetType === 'topology-execution') return 'Topology'
+  if (targetType === 'ontology-extension') return 'Ontology'
+  return 'Evolution'
+}
+
+function labelForOutcome(outcome: ProofOutcomeState) {
+  return outcome.replace(/-/g, ' ')
+}
+
+function formatDate(value: string | undefined) {
+  if (!value) return '—'
+  return new Date(value).toLocaleString()
+}
+
+function consoleTone(state: RunState): 'neutral' | 'green' | 'red' | 'yellow' {
+  if (state === 'success') return 'green'
+  if (state === 'error') return 'red'
+  if (state === 'running') return 'yellow'
+  return 'neutral'
+}
+
+export default function ProofClient({ initialDashboard }: { initialDashboard: ProofDashboardSummary }) {
+  const [dashboard, setDashboard] = useState(initialDashboard)
+  const [runState, setRunState] = useState<RunState>('idle')
+  const [output, setOutput] = useState('')
+  const [pendingKey, setPendingKey] = useState<string | null>(null)
+
+  const runReview = async (recordId: string, decision: ProofReviewDecisionStatus, label: string) => {
+    setPendingKey(recordId)
+    setRunState('running')
+    setOutput('')
+    try {
+      const res = await fetch('/api/proof', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          action: 'review',
+          recordId,
+          decision,
+          rationale: `${decision} proof record from dashboard proof control.`,
+        }),
+      })
+      const data = await res.json()
+      if (!res.ok || !data.success) {
+        setRunState('error')
+        setOutput(data.error ?? `${label} failed`)
+        return
+      }
+      setDashboard(data.dashboard)
+      setRunState('success')
+      setOutput(data.output || `${label} completed`)
+    } catch (err: unknown) {
+      setRunState('error')
+      setOutput(err instanceof Error ? err.message : `${label} failed`)
+    } finally {
+      setPendingKey(null)
+    }
+  }
+
+  return (
+    <div style={{ display: 'grid', gap: 22 }}>
+      <PageHero
+        eyebrow="Outcome attribution"
+        title="Proof Control"
+        description="Review whether interventions, transfers, topology changes, semantic adoption, and evolution effects actually appear to be working. Proof stays bounded and operator-governed rather than pretending to know more than the evidence supports."
+        chips={[
+          { label: `${dashboard.summary.total} proof records`, tone: 'blue' },
+          { label: `${dashboard.summary.effective} effective`, tone: dashboard.summary.effective > 0 ? 'green' : 'neutral' },
+          { label: `${dashboard.summary.mixed} mixed`, tone: dashboard.summary.mixed > 0 ? 'purple' : 'neutral' },
+          { label: `${dashboard.summary.regressed} regressed`, tone: dashboard.summary.regressed > 0 ? 'yellow' : 'neutral' },
+          { label: `${dashboard.summary.reviewOpen} open review`, tone: dashboard.summary.reviewOpen > 0 ? 'yellow' : 'green' },
+          { label: `${dashboard.summary.verified} verified`, tone: dashboard.summary.verified > 0 ? 'green' : 'neutral' },
+        ]}
+        actions={
+          <div style={{ display: 'grid', gap: 12 }}>
+            <div className="hero-note-card">
+              <div className="hero-note-label">Bounded proof layer</div>
+              <div className="hero-note-title">Derived first, reviewed explicitly</div>
+              <div className="hero-note-copy">The proof layer unifies evolution impact, semantic adoption, transfer, interventions, and topology execution without claiming direct causality when the evidence is only partial.</div>
+            </div>
+            <SurfaceJumpLinks surface="proof" variant="compact" title="Proof handoffs" />
+          </div>
+        }
+      />
+
+      <OperatorLoopTrail surface="proof" />
+
+      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(180px, 1fr))', gap: 16 }}>
+        <MetricCard label="Effective" value={dashboard.summary.effective} sublabel={`${dashboard.summary.verified} verified • ${dashboard.summary.reviewOpen} waiting for review`} tone={dashboard.summary.effective > 0 ? 'green' : 'neutral'} icon="✓" />
+        <MetricCard label="Mixed" value={dashboard.summary.mixed} sublabel="partial or conflicting downstream evidence" tone={dashboard.summary.mixed > 0 ? 'purple' : 'neutral'} icon="⇄" />
+        <MetricCard label="Regressed" value={dashboard.summary.regressed} sublabel={`${dashboard.summary.contested} contested • explicit failed or rolled-back cases`} tone={dashboard.summary.regressed > 0 ? 'yellow' : 'neutral'} icon="!" />
+        <MetricCard label="Measuring" value={dashboard.summary.measuring} sublabel={`${dashboard.summary.insufficientEvidence} insufficient-evidence`} tone={dashboard.summary.measuring > 0 ? 'blue' : 'neutral'} icon="◎" />
+        <MetricCard label="Open review" value={dashboard.summary.reviewOpen} sublabel={`${dashboard.summary.deferred} deferred • ${dashboard.summary.verified} verified`} tone={dashboard.summary.reviewOpen > 0 ? 'yellow' : 'green'} icon="◇" />
+      </div>
+
+      <SectionFrame
+        eyebrow="Coverage"
+        title="Proof now spans the live brain loop"
+        description="Milestone 10 stops prove from being only metrics. It unifies evidence review across response, transfer, topology, semantic adoption, and existing evolution measurement."
+      >
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: 12 }}>
+          {dashboard.byTargetType.length > 0 ? dashboard.byTargetType.map((entry) => (
+            <div key={entry.targetType} className="guide-dimension-card" style={{ borderLeftColor: `var(--${toneForTarget(entry.targetType) === 'neutral' ? 'text-muted' : toneForTarget(entry.targetType)})` }}>
+              <div style={{ fontSize: 12, fontWeight: 700, color: 'var(--text)' }}>{labelForTarget(entry.targetType)}</div>
+              <div style={{ fontSize: 12, color: 'var(--text-dim)', marginTop: 8, lineHeight: 1.7 }}>
+                {entry.total} total • {entry.effective} effective • {entry.mixed} mixed • {entry.regressed} regressed • {entry.measuring} measuring
+              </div>
+            </div>
+          )) : (
+            <NextStepEmptyState
+              title="No proof targets yet"
+              description="Create live interventions, semantic adoption, or topology execution first. Proof becomes useful when HelixEvo has real actions and downstream evidence to evaluate."
+              command="helixevo proof --status"
+              pageLink={{ label: 'Open Co-Evolution', href: '/coevolution', tone: 'purple' }}
+              guideLink={{ label: 'Guide · Closed-Loop Metrics', anchor: 'metrics', tone: 'blue' }}
+            />
+          )}
+        </div>
+      </SectionFrame>
+
+      <SectionFrame
+        eyebrow="Review queue"
+        title="Open proof review"
+        description="Derived proof stays operator-governed. Verify, defer, or contest proof records explicitly instead of treating heuristics as unquestionable truth."
+      >
+        <div style={{ display: 'grid', gap: 12 }}>
+          {dashboard.reviewQueue.length > 0 ? dashboard.reviewQueue.map((record) => (
+            <div key={record.id} style={{ padding: '16px 18px', borderRadius: 18, border: '1px solid var(--border)', background: 'rgba(255,255,255,0.74)' }}>
+              <div style={{ display: 'flex', justifyContent: 'space-between', gap: 16, alignItems: 'flex-start', flexWrap: 'wrap' }}>
+                <div style={{ display: 'grid', gap: 4, flex: 1 }}>
+                  <div style={{ fontSize: 13, fontWeight: 700, color: 'var(--text)' }}>{record.title}</div>
+                  <div style={{ fontSize: 12, color: 'var(--text-dim)', lineHeight: 1.6 }}>{record.summary}</div>
+                </div>
+                <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap' }}>
+                  <span className={`badge badge-${toneForTarget(record.targetType)}`}>{labelForTarget(record.targetType)}</span>
+                  <span className={`badge badge-${toneForOutcome(record.outcomeState)}`}>{labelForOutcome(record.outcomeState)}</span>
+                  <span className="badge badge-gray">{(record.confidence * 100).toFixed(0)}% confidence</span>
+                </div>
+              </div>
+
+              <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', marginTop: 12 }}>
+                <span className="badge badge-gray">created {formatDate(record.createdAt)}</span>
+                <span className="badge badge-gray">activity {formatDate(record.lastActivityAt)}</span>
+                {(record.relatedProjectIds ?? []).slice(0, 3).map((projectId) => <span key={`${record.id}-${projectId}`} className="badge badge-gray">{projectId}</span>)}
+                {(record.semanticConceptIds ?? []).slice(0, 2).map((conceptId) => <span key={`${record.id}-${conceptId}`} className="badge badge-green">{conceptId}</span>)}
+              </div>
+
+              <div style={{ display: 'grid', gap: 6, marginTop: 12 }}>
+                {record.reasons.slice(0, 3).map((reason, idx) => (
+                  <div key={`${record.id}-${idx}`} className="signal-text">• {reason}</div>
+                ))}
+                {record.recommendedAction ? <div className="signal-text">→ {record.recommendedAction}</div> : null}
+              </div>
+
+              <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', marginTop: 14 }}>
+                <button onClick={() => runReview(record.id, 'verify', `verify ${record.title}`)} disabled={pendingKey === record.id} className="badge badge-green" style={{ border: 'none', cursor: 'pointer' }}>Verify</button>
+                <button onClick={() => runReview(record.id, 'defer', `defer ${record.title}`)} disabled={pendingKey === record.id} className="badge badge-purple" style={{ border: 'none', cursor: 'pointer' }}>Defer</button>
+                <button onClick={() => runReview(record.id, 'contest', `contest ${record.title}`)} disabled={pendingKey === record.id} className="badge badge-yellow" style={{ border: 'none', cursor: 'pointer' }}>Contest</button>
+              </div>
+            </div>
+          )) : (
+            <NextStepEmptyState
+              title="No open proof reviews"
+              description="Either the proof layer has no records yet or every current record has already been verified, deferred, or contested."
+              command="helixevo proof --status --verbose"
+              pageLink={{ label: 'Open Ontology', href: '/ontology', tone: 'green' }}
+              guideLink={{ label: 'Guide · Closed-Loop Metrics', anchor: 'metrics', tone: 'blue' }}
+            />
+          )}
+        </div>
+      </SectionFrame>
+
+      <div className="grid-2">
+        <SectionFrame
+          eyebrow="Verified"
+          title="Recent verified proof"
+          description="Operator-verified records become the most trustworthy proof layer inside the current bounded system."
+        >
+          <div style={{ display: 'grid', gap: 10 }}>
+            {dashboard.recentVerified.length > 0 ? dashboard.recentVerified.map((record) => (
+              <div key={record.id} style={{ padding: '14px 16px', borderRadius: 18, border: '1px solid var(--border)', background: 'rgba(255,255,255,0.72)' }}>
+                <div style={{ display: 'flex', justifyContent: 'space-between', gap: 12, flexWrap: 'wrap' }}>
+                  <div style={{ fontSize: 12.5, fontWeight: 700, color: 'var(--text)' }}>{record.title}</div>
+                  <span className="badge badge-green">verified</span>
+                </div>
+                <div style={{ fontSize: 12, color: 'var(--text-dim)', marginTop: 6, lineHeight: 1.6 }}>{record.summary}</div>
+                <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', marginTop: 10 }}>
+                  <span className={`badge badge-${toneForOutcome(record.outcomeState)}`}>{labelForOutcome(record.outcomeState)}</span>
+                  <span className="badge badge-gray">{labelForTarget(record.targetType)}</span>
+                  <span className="badge badge-gray">{formatDate(record.latestReview?.decidedAt)}</span>
+                </div>
+              </div>
+            )) : <div className="signal-text">No verified proof records yet.</div>}
+          </div>
+        </SectionFrame>
+
+        <SectionFrame
+          eyebrow="Contested"
+          title="Recent contested proof"
+          description="Contest records when the derived attribution is too strong, too weak, or simply not aligned with operator judgment."
+        >
+          <div style={{ display: 'grid', gap: 10 }}>
+            {dashboard.recentContested.length > 0 ? dashboard.recentContested.map((record) => (
+              <div key={record.id} style={{ padding: '14px 16px', borderRadius: 18, border: '1px solid var(--border)', background: 'rgba(255,255,255,0.72)' }}>
+                <div style={{ display: 'flex', justifyContent: 'space-between', gap: 12, flexWrap: 'wrap' }}>
+                  <div style={{ fontSize: 12.5, fontWeight: 700, color: 'var(--text)' }}>{record.title}</div>
+                  <span className="badge badge-yellow">contested</span>
+                </div>
+                <div style={{ fontSize: 12, color: 'var(--text-dim)', marginTop: 6, lineHeight: 1.6 }}>{record.summary}</div>
+                <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', marginTop: 10 }}>
+                  <span className={`badge badge-${toneForOutcome(record.outcomeState)}`}>{labelForOutcome(record.outcomeState)}</span>
+                  <span className="badge badge-gray">{labelForTarget(record.targetType)}</span>
+                  <span className="badge badge-gray">{formatDate(record.latestReview?.decidedAt)}</span>
+                </div>
+              </div>
+            )) : <div className="signal-text">No contested proof records yet.</div>}
+          </div>
+        </SectionFrame>
+      </div>
+
+      <SectionFrame
+        eyebrow="Ledger"
+        title="All proof records"
+        description="A unified view across intervention, transfer, structural, semantic, and evolution evidence."
+      >
+        <div style={{ display: 'grid', gap: 12 }}>
+          {dashboard.records.length > 0 ? dashboard.records.map((record) => (
+            <div key={record.id} style={{ padding: '14px 16px', borderRadius: 18, border: '1px solid var(--border)', background: 'rgba(255,255,255,0.72)' }}>
+              <div style={{ display: 'flex', justifyContent: 'space-between', gap: 16, alignItems: 'flex-start', flexWrap: 'wrap' }}>
+                <div style={{ display: 'grid', gap: 4, flex: 1 }}>
+                  <div style={{ fontSize: 13, fontWeight: 700, color: 'var(--text)' }}>{record.title}</div>
+                  <div style={{ fontSize: 12, color: 'var(--text-dim)', lineHeight: 1.6 }}>{record.summary}</div>
+                </div>
+                <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap' }}>
+                  <span className={`badge badge-${toneForTarget(record.targetType)}`}>{labelForTarget(record.targetType)}</span>
+                  <span className={`badge badge-${toneForOutcome(record.outcomeState)}`}>{labelForOutcome(record.outcomeState)}</span>
+                  <span className="badge badge-gray">{record.reviewStatus}</span>
+                </div>
+              </div>
+              {record.latestReview?.rationale ? <div className="signal-text" style={{ marginTop: 10 }}>review rationale · {record.latestReview.rationale}</div> : null}
+            </div>
+          )) : null}
+        </div>
+      </SectionFrame>
+
+      <ConsolePanel
+        title="Proof console"
+        tone={consoleTone(runState)}
+        actions={<span className="badge badge-gray">{runState === 'running' ? 'running' : runState === 'success' ? 'success' : runState === 'error' ? 'error' : 'idle'}</span>}
+      >
+        <pre style={{ margin: 0, whiteSpace: 'pre-wrap', fontSize: 12, lineHeight: 1.7, color: 'var(--text-dim)' }}>
+          {runState === 'running'
+            ? 'Recording proof review…\n\n' + (output || '')
+            : runState === 'success'
+              ? (output || 'Proof review completed.')
+              : runState === 'error'
+                ? (output || 'Proof review failed.')
+                : 'Use this surface to review derived proof records once HelixEvo has enough downstream evidence.'}
+        </pre>
+      </ConsolePanel>
+    </div>
+  )
+}

package/dashboard/app/proof/page.tsx

@@ -0,0 +1,9 @@
+import ProofClient from './client'
+import { loadProofDashboardSummary } from '@/lib/proof'
+
+export const dynamic = 'force-dynamic'
+
+export default function ProofPage() {
+  const dashboard = loadProofDashboardSummary()
+  return <ProofClient initialDashboard={dashboard} />
+}

package/dashboard/app/topology/client.tsx

@@ -10,6 +10,7 @@ import { OperatorLoopTrail } from '@/components/operator-loop-trail'
 import { SurfaceJumpLinks } from '@/components/surface-jump-links'
 import { NextStepEmptyState } from '@/components/next-step-empty-state'
 import type { GovernanceModeName, GovernanceState, TopologyDashboardSummary, TopologyReviewDecisionStatus, TopologyReviewStatus } from '@/lib/data'
+import type { ProofDashboardSummary } from '@/lib/proof'
 
 type RunState = 'idle' | 'running' | 'success' | 'error' | 'stopped'
 
@@ -65,9 +66,11 @@ function consoleTone(state: RunState): 'neutral' | 'green' | 'red' | 'yellow' {
 export default function TopologyClient({
   initialDashboard,
   initialGovernanceState,
+  proof,
 }: {
   initialDashboard: TopologyDashboardSummary
   initialGovernanceState: GovernanceState
+  proof: ProofDashboardSummary
 }) {
   const [dashboard, setDashboard] = useState(initialDashboard)
   const [governanceState, setGovernanceState] = useState(initialGovernanceState)
@@ -244,6 +247,7 @@ export default function TopologyClient({
           { label: `${dashboard.summary.open} open reviews`, tone: dashboard.summary.open > 0 ? 'yellow' : 'green' },
           { label: `${dashboard.execution.prepared} prepared`, tone: dashboard.execution.prepared > 0 ? 'blue' : 'neutral' },
           { label: `${dashboard.execution.applied} applied`, tone: dashboard.execution.applied > 0 ? 'green' : 'neutral' },
+          { label: `${proof.summary.reviewOpen} proof review`, tone: proof.summary.reviewOpen > 0 ? 'yellow' : proof.summary.effective > 0 ? 'green' : 'neutral' },
           { label: formatMode(dashboard.governance.activeMode), tone: toneForMode(dashboard.governance.activeMode) },
           { label: dashboard.governance.source === 'operator-selected' ? 'operator-steered' : 'derived mode', tone: dashboard.governance.source === 'operator-selected' ? 'purple' : 'neutral' },
         ]}
@@ -253,6 +257,10 @@ export default function TopologyClient({
               <div className="hero-note-label">Active governance profile</div>
               <div className="hero-note-title">{formatMode(dashboard.governance.activeMode)}</div>
               <div className="hero-note-copy">{dashboard.governance.profile.explanation}</div>
+              <div style={{ marginTop: 8, display: 'flex', gap: 6, flexWrap: 'wrap' }}>
+                <span className="badge badge-gray">{proof.summary.effective} effective records</span>
+                <Link href="/proof" className="badge badge-gray" style={{ textDecoration: 'none' }}>open proof</Link>
+              </div>
             </div>
             <div style={{ display: 'grid', gap: 10 }}>
               <div style={{ display: 'flex', gap: 10, flexWrap: 'wrap', justifyContent: 'flex-end' }}>
@@ -271,6 +279,7 @@ export default function TopologyClient({
         <MetricCard label="Accepted ready" value={dashboard.acceptedReady.length} sublabel="accepted candidates not yet prepared for execution" tone={dashboard.acceptedReady.length > 0 ? 'blue' : 'neutral'} icon="✓" />
         <MetricCard label="Prepared plans" value={dashboard.execution.prepared} sublabel={`${dashboard.execution.safeToApply} safe-to-apply • ${dashboard.execution.prepareOnly} prepare-only`} tone={dashboard.execution.prepared > 0 ? 'blue' : 'neutral'} icon="◇" />
         <MetricCard label="Applied plans" value={dashboard.execution.applied} sublabel={`${dashboard.execution.rolledBack} rolled back • ${dashboard.execution.artifacts} artifacts`} tone={dashboard.execution.applied > 0 ? 'green' : 'neutral'} icon="↑" />
+        <MetricCard label="Structural proof" value={proof.summary.reviewOpen} sublabel={`${proof.summary.effective} effective • ${proof.summary.regressed} regressed`} tone={proof.summary.reviewOpen > 0 ? 'yellow' : proof.summary.effective > 0 ? 'green' : 'neutral'} icon="◇" />
         <MetricCard label="Manual-route backlog" value={dashboard.summary.generatedFromManualReview} sublabel="pressure routed into actual operator review" tone="purple" icon="!" />
         <MetricCard label="Snapshots" value={dashboard.execution.snapshots} sublabel="before/after state preserved for reviewed execution" tone="purple" icon="◎" />
       </div>

package/dashboard/app/topology/page.tsx

@@ -1,4 +1,5 @@
 import { loadGovernanceState, loadTopologyDashboardSummary } from '@/lib/data'
+import { loadProofDashboardSummary } from '@/lib/proof'
 import TopologyClient from './client'
 
 export const dynamic = 'force-dynamic'
@@ -6,5 +7,6 @@ export const dynamic = 'force-dynamic'
 export default function TopologyPage() {
   const dashboard = loadTopologyDashboardSummary()
   const governanceState = loadGovernanceState()
-  return <TopologyClient initialDashboard={dashboard} initialGovernanceState={governanceState} />
+  const proof = loadProofDashboardSummary()
+  return <TopologyClient initialDashboard={dashboard} initialGovernanceState={governanceState} proof={proof} />
 }

package/dashboard/components/sidebar-nav.tsx

@@ -14,6 +14,7 @@ const OPERATE_NAV: NavItem[] = [
   { href: '/projects', label: 'Projects', icon: 'M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-6l-2-2H5a2 2 0 00-2 2z' },
   { href: '/research', label: 'Research', icon: 'M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z' },
   { href: '/coevolution', label: 'Co-Evolution', icon: 'M4 12h4m8 0h4M12 4v4m0 8v4M7.05 7.05l2.83 2.83m4.24 4.24l2.83 2.83m0-9.9l-2.83 2.83m-4.24 4.24l-2.83 2.83' },
+  { href: '/proof', label: 'Proof', icon: 'M9 17v-2m3 2v-4m3 4v-6m2 10H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z' },
 ]
 
 const STRUCTURE_NAV: NavItem[] = [

package/dashboard/lib/loop-map.ts

@@ -1,5 +1,5 @@
 export type LoopStageId = 'observe' | 'route' | 'adopt' | 'restructure' | 'prove'
-export type SurfaceKey = 'overview' | 'projects' | 'research' | 'coevolution' | 'ontology' | 'topology'
+export type SurfaceKey = 'overview' | 'projects' | 'research' | 'coevolution' | 'ontology' | 'topology' | 'proof'
 export type SurfaceTone = 'blue' | 'green' | 'purple' | 'yellow' | 'neutral'
 export type GuideAnchorId = 'quickstart' | 'brainstack' | 'loop' | 'semanticcontrol' | 'surfaces' | 'commands' | 'maturity' | 'metrics'
 
@@ -66,9 +66,9 @@ export const LOOP_STAGES: LoopStageMeta[] = [
   {
     id: 'prove',
     label: 'Prove',
-    href: '/guide#metrics',
+    href: '/proof',
     tone: 'neutral',
-    description: 'Check evidence, metrics, and guide-backed operator understanding.',
+    description: 'Review bounded outcome attribution, proof decisions, and the live evidence ledger.',
   },
 ]
 
@@ -97,6 +97,7 @@ export const SURFACE_LOOP_CONFIG: Record<SurfaceKey, SurfaceLoopConfig> = {
       { label: 'Open Co-Evolution', href: '/coevolution', tone: 'purple', description: 'Inspect governed routing and the active response backlog.' },
       { label: 'Open Ontology', href: '/ontology', tone: 'green', description: 'Inspect semantic adoption, frontier review, and concept consumers.' },
       { label: 'Open Topology', href: '/topology', tone: 'yellow', description: 'Review structural candidates, preparation, and rollbackable execution.' },
+      { label: 'Open Proof', href: '/proof', tone: 'neutral', description: 'Review what appears to be working, regressing, or still measuring.' },
     ],
     guideLinks: [
       { label: 'Read Quick Start', anchor: 'quickstart', tone: 'blue', description: 'See the shortest operator path into the live brain loop.' },
@@ -143,6 +144,7 @@ export const SURFACE_LOOP_CONFIG: Record<SurfaceKey, SurfaceLoopConfig> = {
       { label: 'Open Ontology', href: '/ontology', tone: 'green', description: 'Inspect which approved concepts are influencing current route rationale.' },
       { label: 'Open Topology', href: '/topology', tone: 'yellow', description: 'Escalate mixed-signal structural demand into review and execution.' },
       { label: 'Open Research', href: '/research', tone: 'blue', description: 'Run or inspect the discovery lane when research is the governed response.' },
+      { label: 'Open Proof', href: '/proof', tone: 'neutral', description: 'See whether routed interventions and transfer appear effective yet.' },
     ],
     guideLinks: [
       { label: 'Guide · Semantic Control', anchor: 'semanticcontrol', tone: 'green', description: 'See how semantic adoption shapes route explanation without bypassing governance.' },
@@ -158,6 +160,7 @@ export const SURFACE_LOOP_CONFIG: Record<SurfaceKey, SurfaceLoopConfig> = {
       { label: 'Open Co-Evolution', href: '/coevolution', tone: 'purple', description: 'See where active concepts are influencing current route rationale.' },
       { label: 'Open Topology', href: '/topology', tone: 'yellow', description: 'Compare semantic adoption with structural review and execution.' },
       { label: 'Open Skill Network', href: '/network', tone: 'blue', description: 'Inspect semantic context alongside graph relationships and inspector detail.' },
+      { label: 'Open Proof', href: '/proof', tone: 'neutral', description: 'Review semantic-adoption effectiveness without overclaiming causality.' },
     ],
     guideLinks: [
       { label: 'Guide · Semantic Control', anchor: 'semanticcontrol', tone: 'green', description: 'Read the post-M8 / post-M9 ontology lifecycle and operator playbooks.' },
@@ -173,12 +176,29 @@ export const SURFACE_LOOP_CONFIG: Record<SurfaceKey, SurfaceLoopConfig> = {
       { label: 'Open Ontology', href: '/ontology', tone: 'green', description: 'Check the semantic families clustering around current structural candidates.' },
       { label: 'Open Co-Evolution', href: '/coevolution', tone: 'purple', description: 'Return to the governed response backlog feeding structural review.' },
       { label: 'Open Skill Network', href: '/network', tone: 'blue', description: 'Inspect the graph context around the candidates being reviewed or applied.' },
+      { label: 'Open Proof', href: '/proof', tone: 'neutral', description: 'Review whether structural execution appears effective, mixed, or regressed.' },
     ],
     guideLinks: [
       { label: 'Guide · Surface Map', anchor: 'surfaces', tone: 'purple', description: 'See how topology fits the rest of the dashboard operator loop.' },
       { label: 'Guide · Maturity & Safety', anchor: 'maturity', tone: 'yellow', description: 'Review the current bounded-safe-execution limits before structural action.' },
     ],
   },
+  proof: {
+    key: 'proof',
+    label: 'Proof',
+    stage: 'prove',
+    context: 'Proof is where bounded outcome attribution becomes explicit operator review across interventions, semantics, transfer, topology, and evolution.',
+    adjacentLinks: [
+      { label: 'Open Co-Evolution', href: '/coevolution', tone: 'purple', description: 'Compare proof verdicts with the active response backlog and route state.' },
+      { label: 'Open Ontology', href: '/ontology', tone: 'green', description: 'Inspect semantic-adoption evidence alongside concept review and deprecation risk.' },
+      { label: 'Open Topology', href: '/topology', tone: 'yellow', description: 'Compare structural execution outcomes with their reviewed execution history.' },
+      { label: 'Open Overview', href: '/', tone: 'blue', description: 'Return to the cockpit after reviewing what appears to be working.' },
+    ],
+    guideLinks: [
+      { label: 'Guide · Closed-Loop Metrics', anchor: 'metrics', tone: 'blue', description: 'Read how metrics and proof fit together inside the prove stage.' },
+      { label: 'Guide · Surface Map', anchor: 'surfaces', tone: 'purple', description: 'See where Proof sits in the dashboard operator loop.' },
+    ],
+  },
 }
 
 export function getSurfaceLoopConfig(surface: SurfaceKey) {