helixevo 0.8.1 → 0.9.0

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to HelixEvo are documented here.
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-03-25
+
+### Added
+- Proof steering summaries with explicit evidence tiers — `trusted`, `caution`, `bounded`, and `candidate` — so proved outcomes can be surfaced as route-level and semantic-control influence instead of remaining only a descriptive ledger
+- Candidate-vs-priority proof queue separation so dry-run and insufficient-evidence records stay visible without crowding higher-leverage review
+
+### Changed
+- Pressure route recommendations now consume bounded proof steering after semantic influence, allowing weak evidence to stay bounded, cautionary evidence to bias toward review, and verified/effective evidence to strengthen trust modestly
+- Overview, Proof, and Co-Evolution now expose prove-to-steer closure directly, including trusted/caution lane visibility and proof-aware route rationale
+- `status`, `proof --status --verbose`, and the public README now describe Proof as a bounded steering input into the next governed loop rather than only a post-action review surface
+
 ## [0.8.1] - 2026-03-25
 
 ### Changed

package/README.md

@@ -1,6 +1,6 @@
 # HelixEvo
 
-Co-evolving skill and project brain for AI agents. HelixEvo captures failures, traces activations, models pressure, routes governed responses, promotes cross-project transfer, reviews structural topology changes, safely executes accepted topology transitions with rollback, lets approved ontology concepts become active semantic consumers inside the live control loop, and now exposes a first-class proof layer for bounded outcome attribution across the brain loop.
+Co-evolving skill and project brain for AI agents. HelixEvo captures failures, traces activations, models pressure, routes governed responses, promotes cross-project transfer, reviews structural topology changes, safely executes accepted topology transitions with rollback, lets approved ontology concepts become active semantic consumers inside the live control loop, and now turns Proof into a bounded steering input for future control instead of a descriptive layer alone.
 
 ## How it works
 
@@ -87,7 +87,7 @@ helixevo dashboard
 |---------|-------------|
 | `helixevo watch` | Always-on learning: auto-capture + auto-evolve |
 | `helixevo metrics` | Correction rates, skill trends, evolution impact |
-| `helixevo proof` | Outcome attribution and proof review across interventions, transfer, topology, ontology, and evolution |
+| `helixevo proof` | Outcome attribution, proof review, and steering summaries across interventions, transfer, topology, ontology, and evolution |
 | `helixevo health` | Network health: cohesion, coverage, balance, transfer |
 | `helixevo init` | Import existing skills + generate skill tests |
 | `helixevo capture <session>` | Extract failures from a session file |
@@ -199,10 +199,10 @@ helixevo dashboard --port 3900
 **Tabs:**
 - **Overview** — Premium control cockpit with frontier signals, brain foundation, provider-control truth, semantic backbone, ontology adoption visibility, proof review visibility, pressure counts, topology review visibility, and prepared/applied structural state
 - **Skill Network** — Interactive graph, premium inspector, co-evolution routing signals, and topology review/execution handoff links
-- **Co-Evolution** — Operator cockpit for routed pressure response, governance mode visibility, promotion queues, transfer evidence, semantic route influence, and topology handoff
+- **Co-Evolution** — Operator cockpit for routed pressure response, governance mode visibility, promotion queues, transfer evidence, semantic route influence, proof-aware route rationale, and topology handoff
 - **Ontology** — Semantic control surface for kernel visibility, frontier concept review, approved ontology extensions, adoption coverage, deprecation risk, and native ontology change events
 - **Topology** — Governance steering plus a persistent operator pipeline for review → prepare → apply → rollback across merge / split / promote / rewire / consolidate candidates
-- **Proof** — Outcome-attribution and proof-review cockpit for bounded effectiveness review across interventions, transfer, topology execution, semantic adoption, and evolution impact
+- **Proof** — Outcome-attribution, review, and proof-steering cockpit for bounded effectiveness across interventions, transfer, topology execution, semantic adoption, and evolution impact
 - **Projects** — Project intake studio, live project analysis, gap routing, per-project pressure hotspots, and promotion feeders
 - **Evolution** — Timeline of evolution runs with judge scores, artifact provenance, and activation-aware context
 - **Research** — Knowledge buffer plus a live “why research now” handoff from current pressure, governed routing, and recurring gaps
@@ -249,7 +249,7 @@ Failures → Cluster → Propose → Replay → Multi-Judge → Regression → C
 - **Governance steering** lets the operator pin or release the active adaptation mode rather than relying only on derived routing.
 - **Topology review** persists merge / split / promote / rewire / consolidate candidates so manual review is a real workflow.
 - **Reviewed topology execution** turns accepted safe candidates into prepared plans, snapshot-backed applies, and rollbackable structural transitions.
-- **Proof control** turns bounded outcome attribution into an explicit operator layer where interventions, transfer, topology execution, semantic adoption, and evolution impact can be verified, deferred, or contested.
+- **Proof control** turns bounded outcome attribution into an explicit operator layer where interventions, transfer, topology execution, semantic adoption, and evolution impact can be verified, deferred, or contested, then fed back into future control through bounded proof steering.
 - **Evolution artifacts** preserve proposal-level evidence so the dashboard can show what changed, why, and with what provenance.
 
 **Three-layer hierarchy:**

package/dashboard/app/coevolution/client.tsx

@@ -78,6 +78,11 @@ type Summary = {
       reasons: string[]
       semanticInfluence?: 'none' | 'explanatory' | 'weighted'
       semanticConceptIds?: string[]
+      proofInfluence?: 'none' | 'explanatory' | 'weighted'
+      proofTier?: 'trusted' | 'caution' | 'bounded' | 'candidate'
+      proofSummary?: string
+      proofReasons?: string[]
+      proofLaneKeys?: string[]
     }
     semanticConceptIds?: string[]
   }[]
@@ -103,6 +108,11 @@ type Summary = {
       reasons: string[]
       semanticInfluence?: 'none' | 'explanatory' | 'weighted'
       semanticConceptIds?: string[]
+      proofInfluence?: 'none' | 'explanatory' | 'weighted'
+      proofTier?: 'trusted' | 'caution' | 'bounded' | 'candidate'
+      proofSummary?: string
+      proofReasons?: string[]
+      proofLaneKeys?: string[]
     }
     semanticConceptIds?: string[]
   }[]
@@ -153,6 +163,14 @@ function toneForRoute(route: PressureInterventionType) {
   return 'gray'
 }
 
+function toneForProofTier(tier: 'trusted' | 'caution' | 'bounded' | 'candidate' | undefined) {
+  if (tier === 'trusted') return 'green'
+  if (tier === 'caution') return 'yellow'
+  if (tier === 'bounded') return 'blue'
+  if (tier === 'candidate') return 'gray'
+  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'
@@ -311,7 +329,7 @@ export default function CoEvolutionClient({ summary, ontology, proof }: Props) {
         <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="Active semantics" value={ontology.ontologyLoop.adoption.activeConcepts} sublabel={`${ontology.ontologyLoop.adoption.totalBindings} bindings • ${ontology.ontologyLoop.adoption.routesInfluenced} influenced routes`} tone={ontology.ontologyLoop.adoption.activeConcepts > 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="Proof review" 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="Proof steering" value={proof.steering.priorityReview} sublabel={`${proof.steering.trustedLanes} trusted • ${proof.steering.cautionLanes} caution`} tone={proof.steering.cautionLanes > 0 ? 'yellow' : proof.steering.trustedLanes > 0 ? 'green' : proof.summary.reviewOpen > 0 ? 'blue' : 'neutral'} 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>
 
@@ -402,6 +420,7 @@ export default function CoEvolutionClient({ summary, ontology, proof }: Props) {
                     <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.suggestedRoute.proofTier ? <span className={`badge badge-${toneForProofTier(motif.suggestedRoute.proofTier)}`}>proof {motif.suggestedRoute.proofTier}</span> : null}
                     {motif.suggestedRoute.semanticInfluence && motif.suggestedRoute.semanticInfluence !== 'none' ? <span className="badge badge-green">semantic {motif.suggestedRoute.semanticInfluence}</span> : null}
                     {(motif.semanticConceptIds ?? []).slice(0, 2).map((conceptId) => <span key={`${motif.id}-${conceptId}`} className="badge badge-gray">{conceptId}</span>)}
                     {motif.projectIds.slice(0, 3).map((projectId) => <span key={`${motif.id}-${projectId}`} className="badge badge-gray">{projectId}</span>)}
@@ -410,6 +429,7 @@ export default function CoEvolutionClient({ summary, ontology, proof }: Props) {
                     {motif.suggestedRoute.reasons.slice(0, 2).map((reason, index) => (
                       <div key={`${motif.id}-reason-${index}`} className="signal-text">• {reason}</div>
                     ))}
+                    {motif.suggestedRoute.proofSummary ? <div className="signal-text">→ {motif.suggestedRoute.proofSummary}</div> : null}
                   </div>
                 </div>
               </div>
@@ -551,6 +571,7 @@ export default function CoEvolutionClient({ summary, ontology, proof }: Props) {
                     {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.routeRecommendation?.proofTier ? <span className={`badge badge-${toneForProofTier(signal.routeRecommendation.proofTier)}`}>proof {signal.routeRecommendation.proofTier}</span> : null}
                     {signal.routeRecommendation?.semanticInfluence && signal.routeRecommendation.semanticInfluence !== 'none' ? <span className="badge badge-green">semantic {signal.routeRecommendation.semanticInfluence}</span> : null}
                     {(signal.semanticConceptIds ?? []).slice(0, 2).map((conceptId) => <span key={`${signal.id}-${conceptId}`} className="badge badge-gray">{conceptId}</span>)}
                     {signal.interventionTypes.map((type) => <span key={`${signal.id}-${type}`} className="badge badge-gray">{type}</span>)}
@@ -560,6 +581,7 @@ export default function CoEvolutionClient({ summary, ontology, proof }: Props) {
                       {signal.routeRecommendation.reasons.slice(0, 2).map((reason, index) => (
                         <div key={`${signal.id}-reason-${index}`} className="signal-text">• {reason}</div>
                       ))}
+                      {signal.routeRecommendation.proofSummary ? <div className="signal-text">→ {signal.routeRecommendation.proofSummary}</div> : null}
                     </div>
                   ) : null}
                 </div>

package/dashboard/app/page.tsx

@@ -31,6 +31,7 @@ function providerTone(status: 'healthy' | 'degraded' | 'unavailable' | 'unknown'
 function getPriorityActions(params: {
   unresolved: number
   proofOpen: number
+  proofCaution: number
   topologyOpen: number
   optimizeStatus: 'idle' | 'healthy' | 'partial' | 'failed'
   optimizeNextStep?: string
@@ -58,6 +59,15 @@ function getPriorityActions(params: {
     })
   }
 
+  if (params.proofCaution > 0) {
+    actions.push({
+      href: '/proof',
+      title: 'Inspect cautionary proof steering',
+      description: `${params.proofCaution} proof lane${params.proofCaution === 1 ? '' : 's'} currently reduce trust or increase review bias for the next control step.`,
+      tone: 'yellow',
+    })
+  }
+
   if (params.proofOpen > 0) {
     actions.push({
       href: '/proof',
@@ -134,6 +144,7 @@ export default function Overview() {
   const priorityActions = getPriorityActions({
     unresolved: summary.failures.unresolved,
     proofOpen: proof.summary.reviewOpen,
+    proofCaution: proof.steering.cautionLanes,
     topologyOpen: topologyControl.summary.open,
     optimizeStatus: topologyControl.optimizeStatus.status,
     optimizeNextStep: topologyControl.optimizeStatus.nextStep,
@@ -176,7 +187,7 @@ export default function Overview() {
 
       <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(180px, 1fr))', gap: 16 }}>
         <MetricCard label="Unresolved corrections" value={summary.failures.unresolved} sublabel={`out of ${summary.failures.total} captured failures`} tone={summary.failures.unresolved > 0 ? 'yellow' : 'green'} href={summary.failures.unresolved > 0 ? '#attention' : '/evolution'} icon="!" />
-        <MetricCard label="Proof review" 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'} href="/proof" icon="◇" />
+        <MetricCard label="Proof review" value={proof.summary.reviewOpen} sublabel={`${proof.steering.trustedLanes} trusted lanes • ${proof.steering.cautionLanes} caution`} tone={proof.summary.reviewOpen > 0 ? 'yellow' : proof.steering.trustedLanes > 0 ? 'green' : proof.steering.cautionLanes > 0 ? 'yellow' : 'neutral'} href="/proof" icon="◇" />
         <MetricCard
           label="Open pressure"
           value={ontology.pressureLifecycle.open}
@@ -328,6 +339,34 @@ export default function Overview() {
         </SectionFrame>
       ) : null}
 
+      <SectionFrame
+        eyebrow="Proof steering"
+        title="What proved outcomes are changing now"
+        description="Proof now separates trusted, cautionary, bounded, and candidate evidence so the next governed loop can steer more honestly instead of treating every proof record as equally strong."
+        tone="blue"
+        actions={<Link href="/proof" className="badge badge-gray">Open proof control</Link>}
+      >
+        <div className="grid-2" style={{ gap: 16 }}>
+          <div className="summary-list">
+            {proof.steering.routeLanes.slice(0, 3).map((lane) => (
+              <div key={lane.laneKey} className="summary-row">
+                <div className="summary-row-main">
+                  <div className="summary-row-title">{lane.route ? lane.route.replace(/-/g, ' ') : lane.conceptId ?? lane.laneKey}</div>
+                  <div className="summary-row-meta">{lane.summary}</div>
+                </div>
+                <span className={`hero-chip hero-chip-${lane.evidenceTier === 'trusted' ? 'green' : lane.evidenceTier === 'caution' ? 'yellow' : lane.evidenceTier === 'bounded' ? 'blue' : 'neutral'}`}>{lane.evidenceTier}</span>
+              </div>
+            ))}
+            {proof.steering.routeLanes.length === 0 ? <div className="signal-text">No route-level proof steering yet.</div> : null}
+          </div>
+          <div style={{ display: 'grid', gap: 12 }}>
+            <MetricCard label="Trusted lanes" value={proof.steering.trustedLanes} sublabel={`${proof.summary.verified} verified records reinforce future trust`} tone={proof.steering.trustedLanes > 0 ? 'green' : 'neutral'} href="/proof" icon="✓" />
+            <MetricCard label="Caution lanes" value={proof.steering.cautionLanes} sublabel={`${proof.summary.regressed} regressed • ${proof.summary.contested} contested`} tone={proof.steering.cautionLanes > 0 ? 'yellow' : 'neutral'} href="/proof" icon="!" />
+            <div className="signal-text">Candidate evidence stays visible in Proof, but no longer dominates the highest-value steering surface.</div>
+          </div>
+        </div>
+      </SectionFrame>
+
       <SectionFrame
         eyebrow="Brain summary"
         title="Semantic backbone"

package/dashboard/app/proof/client.tsx

@@ -39,6 +39,17 @@ function labelForOutcome(outcome: ProofOutcomeState) {
   return outcome.replace(/-/g, ' ')
 }
 
+function toneForSteeringTier(tier: 'trusted' | 'caution' | 'bounded' | 'candidate') {
+  if (tier === 'trusted') return 'green'
+  if (tier === 'caution') return 'yellow'
+  if (tier === 'bounded') return 'blue'
+  return 'neutral'
+}
+
+function labelForSteeringLane(lane: ProofDashboardSummary['steering']['routeLanes'][number] | ProofDashboardSummary['steering']['semanticLanes'][number]) {
+  return lane.route ? lane.route.replace(/-/g, ' ') : lane.conceptId ?? lane.laneKey
+}
+
 function formatDate(value: string | undefined) {
   if (!value) return '—'
   return new Date(value).toLocaleString()
@@ -52,19 +63,20 @@ function consoleTone(state: RunState): 'neutral' | 'green' | 'red' | 'yellow' {
 }
 
 function getRecommendedProofMove(dashboard: ProofDashboardSummary) {
+  const cautionLane = dashboard.steering.routeLanes.find((lane) => lane.evidenceTier === 'caution')
+  if (cautionLane) {
+    return {
+      label: 'Caution first',
+      title: labelForSteeringLane(cautionLane),
+      copy: 'A cautionary proof lane should usually be reviewed before you trust that route again. Regressed or contested evidence now biases the next loop toward more care.',
+    }
+  }
   const firstOpen = dashboard.reviewQueue[0]
   if (firstOpen) {
     return {
       label: 'Review queue first',
       title: firstOpen.title,
-      copy: 'Open proof records should usually be resolved before you treat the prove layer as settled. Verify, defer, or contest the most important record first.',
-    }
-  }
-  if (dashboard.summary.regressed > 0) {
-    return {
-      label: 'Investigate regressed evidence',
-      title: 'A regressed outcome needs explanation before retry',
-      copy: 'Regressed records mean HelixEvo has explicit negative evidence. Inspect the linked structural or intervention path before repeating the same move.',
+      copy: 'High-leverage proof records should usually be resolved before you treat the prove layer as settled. Verify, defer, or contest the most important record first.',
     }
   }
   if (dashboard.summary.measuring > 0) {
@@ -74,6 +86,13 @@ function getRecommendedProofMove(dashboard: ProofDashboardSummary) {
       copy: 'A measuring record is active but still too recent or incomplete for a stronger claim. Let downstream evidence accumulate before over-interpreting it.',
     }
   }
+  if (dashboard.candidateQueue.length > 0) {
+    return {
+      label: 'Candidate evidence only',
+      title: 'Dry-run and insufficient evidence stay bounded',
+      copy: 'Candidate proof records should remain visible, but they should not steer the system strongly until stronger downstream evidence appears.',
+    }
+  }
   return {
     label: 'Seed proof',
     title: 'No proof targets yet',
@@ -128,10 +147,10 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
         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.steering.trustedLanes} trusted lanes`, tone: dashboard.steering.trustedLanes > 0 ? 'green' : 'neutral' },
+          { label: `${dashboard.steering.cautionLanes} caution lanes`, tone: dashboard.steering.cautionLanes > 0 ? 'yellow' : 'neutral' },
           { label: `${dashboard.summary.reviewOpen} open review`, tone: dashboard.summary.reviewOpen > 0 ? 'yellow' : 'green' },
+          { label: `${dashboard.steering.candidateLanes} candidate lanes`, tone: dashboard.steering.candidateLanes > 0 ? 'neutral' : 'green' },
           { label: `${dashboard.summary.verified} verified`, tone: dashboard.summary.verified > 0 ? 'green' : 'neutral' },
         ]}
         actions={
@@ -149,11 +168,11 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
       <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="Trusted lanes" value={dashboard.steering.trustedLanes} sublabel={`${dashboard.summary.verified} verified records backing future trust`} tone={dashboard.steering.trustedLanes > 0 ? 'green' : 'neutral'} icon="✓" />
+        <MetricCard label="Caution lanes" value={dashboard.steering.cautionLanes} sublabel={`${dashboard.summary.regressed} regressed • ${dashboard.summary.contested} contested`} tone={dashboard.steering.cautionLanes > 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="◇" />
+        <MetricCard label="Candidate evidence" value={dashboard.steering.candidateLanes} sublabel={`${dashboard.candidateQueue.length} open low-closure records`} tone={dashboard.steering.candidateLanes > 0 ? 'neutral' : 'green'} icon="◌" />
+        <MetricCard label="Open review" value={dashboard.summary.reviewOpen} sublabel={`${dashboard.steering.priorityReview} high-leverage • ${dashboard.summary.verified} verified`} tone={dashboard.summary.reviewOpen > 0 ? 'yellow' : 'green'} icon="◇" />
       </div>
 
       <SectionFrame
@@ -178,6 +197,34 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
         </div>
       </SectionFrame>
 
+      <SectionFrame
+        eyebrow="Steering"
+        title="What proof is changing about future control"
+        description="Proof now separates trusted, cautionary, bounded, and candidate evidence so the next governed loop can steer more honestly. Trusted lanes can strengthen confidence modestly, caution lanes bias toward more review, and candidate evidence stays bounded."
+        tone="blue"
+      >
+        <div className="grid-2" style={{ gap: 16 }}>
+          <div className="summary-list">
+            {dashboard.steering.routeLanes.slice(0, 4).map((lane) => (
+              <div key={lane.laneKey} className="summary-row">
+                <div className="summary-row-main">
+                  <div className="summary-row-title">{labelForSteeringLane(lane)}</div>
+                  <div className="summary-row-meta">{lane.summary}</div>
+                  <div className="summary-row-meta" style={{ marginTop: 6 }}>{lane.reasons[0] ?? 'Proof steering keeps this lane bounded.'}</div>
+                </div>
+                <span className={`hero-chip hero-chip-${toneForSteeringTier(lane.evidenceTier)}`}>{lane.evidenceTier}</span>
+              </div>
+            ))}
+            {dashboard.steering.routeLanes.length === 0 ? <div className="signal-text">No route-level steering evidence yet.</div> : null}
+          </div>
+          <div style={{ display: 'grid', gap: 12 }}>
+            <MetricCard label="Priority review" value={dashboard.steering.priorityReview} sublabel={`${dashboard.reviewQueue.length} high-leverage queue items`} tone={dashboard.steering.priorityReview > 0 ? 'yellow' : 'green'} icon="◇" />
+            <MetricCard label="Semantic steering" value={dashboard.steering.semanticLanes.length} sublabel={`${dashboard.steering.semanticLanes.filter((lane) => lane.evidenceTier === 'trusted').length} trusted • ${dashboard.steering.semanticLanes.filter((lane) => lane.evidenceTier === 'caution').length} caution`} tone={dashboard.steering.semanticLanes.length > 0 ? 'purple' : 'neutral'} icon="◎" />
+            <div className="signal-text">Candidate evidence remains visible below, but it no longer dominates the highest-value proof review surface.</div>
+          </div>
+        </div>
+      </SectionFrame>
+
       <SectionFrame
         eyebrow="Coverage"
         title="Proof now spans the live brain loop"
@@ -255,6 +302,28 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
         </div>
       </SectionFrame>
 
+      <SectionFrame
+        eyebrow="Candidate evidence"
+        title="Dry-run and low-closure proof"
+        description="These records remain visible, but they should not steer the system strongly until stronger downstream evidence or explicit operator review exists."
+      >
+        <div style={{ display: 'grid', gap: 10 }}>
+          {dashboard.candidateQueue.length > 0 ? dashboard.candidateQueue.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-gray">candidate</span>
+              </div>
+              <div style={{ fontSize: 12, color: 'var(--text-dim)', marginTop: 6, lineHeight: 1.6 }}>{record.summary}</div>
+              <div style={{ display: 'grid', gap: 6, marginTop: 10 }}>
+                {record.reasons.slice(0, 2).map((reason, idx) => <div key={`${record.id}-candidate-${idx}`} className="signal-text">• {reason}</div>)}
+                {record.recommendedAction ? <div className="signal-text">→ {record.recommendedAction}</div> : null}
+              </div>
+            </div>
+          )) : <div className="signal-text">No candidate-only proof records right now.</div>}
+        </div>
+      </SectionFrame>
+
       <div className="grid-2">
         <SectionFrame
           eyebrow="Verified"

package/dashboard/lib/data.ts

@@ -30,6 +30,8 @@ function readOntologyJsonl<T>(filename: string): T[] {
   return raw.split('\n').filter(Boolean).map((l) => JSON.parse(l))
 }
 
+import { loadProofSteeringSummary } from './proof'
+
 // ─── Types ──────────────────────────────────────────────────────
 
 export type CognitiveRole = 'generalist' | 'specialist' | 'hybrid'
@@ -180,6 +182,8 @@ export type PressureInterventionImpact = 'exploratory' | 'structural' | 'resolvi
 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 type ProofSteeringTier = 'trusted' | 'caution' | 'bounded' | 'candidate'
+export type ProofSteeringInfluence = 'none' | 'explanatory' | 'weighted'
 
 export interface PressureRouteRecommendation {
   route: PressureInterventionType
@@ -190,6 +194,11 @@ export interface PressureRouteRecommendation {
   reasons: string[]
   semanticInfluence?: OntologySemanticInfluence
   semanticConceptIds?: string[]
+  proofInfluence?: ProofSteeringInfluence
+  proofTier?: ProofSteeringTier
+  proofSummary?: string
+  proofReasons?: string[]
+  proofLaneKeys?: string[]
 }
 
 export interface PressureIntervention {
@@ -2036,6 +2045,105 @@ function matchTopologyOntologyBindings(candidate: ResolvedTopologyReviewCandidat
   return dedupeOntologyBindings(bindings)
 }
 
+function proofTierWeight(tier: ProofSteeringTier): number {
+  return tier === 'caution' ? 4 : tier === 'trusted' ? 3 : tier === 'bounded' ? 2 : 1
+}
+
+function strongerProofTier(current: ProofSteeringTier | undefined, next: ProofSteeringTier): ProofSteeringTier {
+  if (!current) return next
+  return proofTierWeight(next) > proofTierWeight(current) ? next : current
+}
+
+function applyProofInfluenceToRoute(params: {
+  recommendation: PressureRouteRecommendation
+  signal: PressureSignal
+  semanticBindings: ResolvedOntologyBinding[]
+  proofSteering: import('./proof').ProofSteeringSummary | null
+}): PressureRouteRecommendation {
+  const { recommendation, semanticBindings, proofSteering } = params
+  if (!proofSteering) return recommendation
+
+  let route = recommendation.route
+  let confidence = recommendation.confidence
+  let triggeredBy = recommendation.triggeredBy
+  const reasons = [...recommendation.reasons]
+  const proofReasons: string[] = []
+  const proofLaneKeys: string[] = []
+  let proofSummary: string | undefined
+  let proofTier: ProofSteeringTier | undefined
+  let proofInfluence: 'none' | 'explanatory' | 'weighted' = 'none'
+
+  const routeLane = proofSteering.byRoute[recommendation.route]
+  if (routeLane) {
+    proofLaneKeys.push(routeLane.laneKey)
+    proofReasons.push(...routeLane.reasons.slice(0, 2))
+    proofSummary = proofSummary ?? routeLane.summary
+    proofTier = strongerProofTier(proofTier, routeLane.evidenceTier)
+
+    if (routeLane.evidenceTier === 'trusted') {
+      confidence = Math.min(0.95, confidence + (routeLane.score >= 4 ? 0.06 : 0.04))
+      proofInfluence = 'weighted'
+      reasons.push(`Proof steering: ${routeLane.summary}`)
+    } else if (routeLane.evidenceTier === 'caution') {
+      if (recommendation.route !== 'manual-review' && routeLane.score <= -3 && (recommendation.route === 'generalize' || recommendation.route === 'evolve')) {
+        route = 'manual-review'
+        triggeredBy = 'mixed-signal'
+        confidence = Math.max(0.66, confidence - 0.02)
+        proofInfluence = 'weighted'
+        reasons.push(`Proof steering: ${routeLane.summary} Governance now prefers explicit operator review before retrying ${recommendation.route}.`)
+      } else {
+        confidence = Math.max(0.4, confidence - 0.08)
+        proofInfluence = 'weighted'
+        reasons.push(`Proof steering: ${routeLane.summary}`)
+      }
+    } else {
+      if (proofInfluence === 'none') proofInfluence = 'explanatory'
+      reasons.push(`Proof steering: ${routeLane.summary}`)
+    }
+  }
+
+  const conceptIds = uniqueStrings([...(recommendation.semanticConceptIds ?? []), ...semanticBindings.map((binding) => binding.conceptId)])
+  const conceptLanes = conceptIds.map((conceptId) => proofSteering.byConceptId[conceptId]).filter(Boolean)
+  if (conceptLanes.length > 0) {
+    const strongestConceptLane = [...conceptLanes].sort((a, b) => proofTierWeight(b.evidenceTier) - proofTierWeight(a.evidenceTier) || Math.abs(b.score) - Math.abs(a.score))[0]
+    if (strongestConceptLane) {
+      proofLaneKeys.push(strongestConceptLane.laneKey)
+      proofReasons.push(...strongestConceptLane.reasons.slice(0, 2))
+      proofSummary = proofSummary ?? strongestConceptLane.summary
+      proofTier = strongerProofTier(proofTier, strongestConceptLane.evidenceTier)
+      if (strongestConceptLane.evidenceTier === 'trusted') {
+        confidence = Math.min(0.95, confidence + 0.02)
+        proofInfluence = 'weighted'
+        reasons.push(`Proof steering: ${strongestConceptLane.summary}`)
+      } else if (strongestConceptLane.evidenceTier === 'caution') {
+        confidence = Math.max(0.4, confidence - 0.03)
+        if (proofInfluence === 'none') proofInfluence = 'weighted'
+        reasons.push(`Proof steering: ${strongestConceptLane.summary}`)
+      } else {
+        if (proofInfluence === 'none') proofInfluence = 'explanatory'
+        reasons.push(`Proof steering: ${strongestConceptLane.summary}`)
+      }
+    }
+  }
+
+  return {
+    ...recommendation,
+    route,
+    confidence,
+    triggeredBy,
+    reasons: [...new Set(reasons)].slice(0, 8),
+    proofInfluence,
+    proofTier,
+    proofSummary,
+    proofReasons: [...new Set(proofReasons)].slice(0, 4),
+    proofLaneKeys: [...new Set(proofLaneKeys)],
+  }
+}
+
+type ProofSteeringLoadOptions = {
+  includeProofSteering?: boolean
+}
+
 function applyOntologyInfluenceToRoute(params: {
   recommendation: PressureRouteRecommendation
   signal: PressureSignal
@@ -2088,8 +2196,9 @@ function buildRouteRecommendation(params: {
   governanceMode: GovernanceModeName
   governanceProfile: GovernanceProfile
   semanticBindings: ResolvedOntologyBinding[]
+  proofSteering: import('./proof').ProofSteeringSummary | null
 }): PressureRouteRecommendation {
-  const { signal, relatedSignals, linkedInterventions, governanceMode, governanceProfile, semanticBindings } = params
+  const { signal, relatedSignals, linkedInterventions, governanceMode, governanceProfile, semanticBindings, proofSteering } = 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))]
@@ -2175,12 +2284,19 @@ function buildRouteRecommendation(params: {
     }
   }
 
-  return applyOntologyInfluenceToRoute({
+  const ontologyAware = applyOntologyInfluenceToRoute({
     recommendation,
     signal,
     semanticBindings,
     governanceProfile,
   })
+
+  return applyProofInfluenceToRoute({
+    recommendation: ontologyAware,
+    signal,
+    semanticBindings,
+    proofSteering,
+  })
 }
 
 function interventionEvidenceAccepted(
@@ -2206,7 +2322,7 @@ function interventionKeepsPressureActive(impact: PressureInterventionImpact, sta
   return impact === 'exploratory' || impact === 'structural' || impact === 'resolving'
 }
 
-export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
+export function loadResolvedPressureSignals(options: ProofSteeringLoadOptions = {}): ResolvedPressureSignal[] {
   const pressureSignals = loadPressureSignals()
   const interventions = loadPressureInterventions()
   const transferEvents = loadTransferEvents()
@@ -2214,6 +2330,7 @@ export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
   const artifacts = loadEvolutionArtifacts()
   const governance = deriveGovernanceSummary(pressureSignals, interventions)
   const concepts = activeOntologyExtensions()
+  const proofSteering = options.includeProofSteering === false ? null : loadProofSteeringSummary()
   const acceptedProposalIds = new Set(
     history.iterations.flatMap((iteration) => iteration.proposals)
       .filter((proposal) => proposal.outcome === 'accepted')
@@ -2259,6 +2376,7 @@ export function loadResolvedPressureSignals(): ResolvedPressureSignal[] {
       governanceMode: governance.activeMode,
       governanceProfile: governance.profile,
       semanticBindings,
+      proofSteering,
     })
 
     const lifecycle: PressureLifecycleState = addressingInterventions.length > 0 || signal.status === 'addressed'
@@ -2304,8 +2422,8 @@ function projectRoleForSkill(skillId: string, graph: SkillGraph): CognitiveRole
   return inferCognitiveRole(node)
 }
 
-export function loadPressureMotifs(): ResolvedPressureMotif[] {
-  const resolvedSignals = loadResolvedPressureSignals()
+export function loadPressureMotifs(options: ProofSteeringLoadOptions = {}): ResolvedPressureMotif[] {
+  const resolvedSignals = loadResolvedPressureSignals(options)
   const interventions = loadPressureInterventions()
   const transferEvents = loadTransferEvents()
   const governance = deriveGovernanceSummary()
@@ -2419,7 +2537,7 @@ export function loadPressureMotifs(): ResolvedPressureMotif[] {
   })
 }
 
-function collectOntologyAdoptionState(): { summary: OntologyAdoptionSummary, consumerMap: Map<string, OntologyConsumerSummary> } {
+function collectOntologyAdoptionState(options: ProofSteeringLoadOptions = {}): { summary: OntologyAdoptionSummary, consumerMap: Map<string, OntologyConsumerSummary> } {
   const extensions = loadOntologyExtensions()
   const activeExtensions = extensions.filter((concept) => concept.status === 'active')
   const byConceptKind = ontologyKindCounts()
@@ -2458,7 +2576,7 @@ function collectOntologyAdoptionState(): { summary: OntologyAdoptionSummary, con
     byConceptKind[concept.conceptKind] = (byConceptKind[concept.conceptKind] ?? 0) + 1
   }
 
-  const signals = loadResolvedPressureSignals()
+  const signals = loadResolvedPressureSignals(options)
   for (const signal of signals) {
     for (const binding of signal.semanticBindings ?? []) registerBinding(binding)
     if (signal.routeRecommendation?.semanticConceptIds?.length) {
@@ -2478,7 +2596,7 @@ function collectOntologyAdoptionState(): { summary: OntologyAdoptionSummary, con
     }
   }
 
-  for (const motif of loadPressureMotifs()) {
+  for (const motif of loadPressureMotifs(options)) {
     for (const binding of motif.semanticBindings ?? []) registerBinding(binding)
   }
 
@@ -2517,13 +2635,13 @@ function collectOntologyAdoptionState(): { summary: OntologyAdoptionSummary, con
   }
 }
 
-export function getOntologyAdoptionSummary(): OntologyAdoptionSummary {
-  return collectOntologyAdoptionState().summary
+export function getOntologyAdoptionSummary(options: ProofSteeringLoadOptions = {}): OntologyAdoptionSummary {
+  return collectOntologyAdoptionState(options).summary
 }
 
-export function loadResolvedOntologyExtensions(): ResolvedOntologyExtension[] {
+export function loadResolvedOntologyExtensions(options: ProofSteeringLoadOptions = {}): ResolvedOntologyExtension[] {
   const extensions = loadOntologyExtensions()
-  const { consumerMap } = collectOntologyAdoptionState()
+  const { consumerMap } = collectOntologyAdoptionState(options)
   return extensions
     .map((concept) => {
       const consumer = consumerMap.get(concept.id)