helixevo 0.9.0 → 0.10.0

package/dashboard/app/proof/client.tsx

@@ -9,6 +9,7 @@ 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'
+import type { TheoryConformanceRunResult } from '@/lib/theory'
 
 type RunState = 'idle' | 'running' | 'success' | 'error'
 
@@ -46,6 +47,14 @@ function toneForSteeringTier(tier: 'trusted' | 'caution' | 'bounded' | 'candidat
   return 'neutral'
 }
 
+function toneForClosureState(state: ProofDashboardSummary['records'][number]['closureState'] | ProofDashboardSummary['steering']['routeLanes'][number]['closureState']) {
+  if (state === 'trusted-with-debt') return 'yellow'
+  if (state === 'stalled') return 'yellow'
+  if (state === 'needs-review') return 'blue'
+  if (state === 'needs-evidence') return 'neutral'
+  return 'green'
+}
+
 function labelForSteeringLane(lane: ProofDashboardSummary['steering']['routeLanes'][number] | ProofDashboardSummary['steering']['semanticLanes'][number]) {
   return lane.route ? lane.route.replace(/-/g, ' ') : lane.conceptId ?? lane.laneKey
 }
@@ -62,7 +71,64 @@ function consoleTone(state: RunState): 'neutral' | 'green' | 'red' | 'yellow' {
   return 'neutral'
 }
 
+function toneForConformance(verdict: TheoryConformanceRunResult['verdict']) {
+  if (verdict === 'pass') return 'green'
+  if (verdict === 'bounded-pass') return 'yellow'
+  if (verdict === 'fail') return 'red'
+  return 'neutral'
+}
+
+function getConformanceHeadline(result: TheoryConformanceRunResult | null) {
+  if (!result) {
+    return {
+      label: 'Not run yet',
+      title: 'No automated brain verification recorded',
+      copy: 'Run helixevo verify-brain to generate the first contract-backed theory-conformance verdict for this installation.',
+    }
+  }
+
+  const failing = result.scenarios.find((scenario) => scenario.verdict === 'fail')
+  if (failing) {
+    return {
+      label: 'Failing scenario',
+      title: `${failing.scenarioId} · ${failing.title}`,
+      copy: failing.summary,
+    }
+  }
+
+  const bounded = result.scenarios.find((scenario) => scenario.verdict === 'bounded-pass' || scenario.verdict === 'inconclusive')
+  if (bounded) {
+    return {
+      label: 'Bounded scenario',
+      title: `${bounded.scenarioId} · ${bounded.title}`,
+      copy: bounded.summary,
+    }
+  }
+
+  return {
+    label: 'Latest run',
+    title: 'All executed theory scenarios passed',
+    copy: result.summary,
+  }
+}
+
 function getRecommendedProofMove(dashboard: ProofDashboardSummary) {
+  const stalledGroup = dashboard.closureDebtGroups.find((group) => group.closureState === 'stalled')
+  if (stalledGroup) {
+    return {
+      label: 'Resolve stalled debt',
+      title: stalledGroup.title,
+      copy: 'Some proof debt has aged long enough that it now needs explicit revisit instead of passive waiting. Clear the stalled group before treating the proof layer as healthy.',
+    }
+  }
+  const trustedWithDebt = dashboard.steering.routeLanes.find((lane) => lane.trustedWithDebt)
+  if (trustedWithDebt) {
+    return {
+      label: 'Trusted, but not closed',
+      title: labelForSteeringLane(trustedWithDebt),
+      copy: trustedWithDebt.debtSummary ?? 'A trusted lane still carries unresolved debt behind it. Review the debt before treating the lane as fully settled.',
+    }
+  }
   const cautionLane = dashboard.steering.routeLanes.find((lane) => lane.evidenceTier === 'caution')
   if (cautionLane) {
     return {
@@ -79,6 +145,14 @@ function getRecommendedProofMove(dashboard: ProofDashboardSummary) {
       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.',
     }
   }
+  const evidenceDebt = dashboard.closureDebtGroups.find((group) => group.closureState === 'needs-evidence')
+  if (evidenceDebt) {
+    return {
+      label: 'Harvest missing evidence',
+      title: evidenceDebt.title,
+      copy: evidenceDebt.summary,
+    }
+  }
   if (dashboard.summary.measuring > 0) {
     return {
       label: 'Let evidence mature',
@@ -86,13 +160,6 @@ 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',
@@ -100,12 +167,15 @@ function getRecommendedProofMove(dashboard: ProofDashboardSummary) {
   }
 }
 
-export default function ProofClient({ initialDashboard }: { initialDashboard: ProofDashboardSummary }) {
+export default function ProofClient({ initialDashboard, initialConformance }: { initialDashboard: ProofDashboardSummary; initialConformance: TheoryConformanceRunResult | null }) {
   const [dashboard, setDashboard] = useState(initialDashboard)
   const [runState, setRunState] = useState<RunState>('idle')
   const [output, setOutput] = useState('')
   const [pendingKey, setPendingKey] = useState<string | null>(null)
   const recommendedMove = getRecommendedProofMove(dashboard)
+  const conformanceHeadline = getConformanceHeadline(initialConformance)
+  const evidenceDebtGroups = dashboard.closureDebtGroups.filter((group) => group.closureState === 'needs-evidence')
+  const stalledDebtGroups = dashboard.closureDebtGroups.filter((group) => group.closureState === 'stalled')
 
   const runReview = async (recordId: string, decision: ProofReviewDecisionStatus, label: string) => {
     setPendingKey(recordId)
@@ -148,10 +218,10 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
         chips={[
           { label: `${dashboard.summary.total} proof records`, tone: 'blue' },
           { 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' },
+          { label: `${dashboard.steering.trustedWithDebtLanes} trusted with debt`, tone: dashboard.steering.trustedWithDebtLanes > 0 ? 'yellow' : 'neutral' },
+          { label: `${dashboard.summary.needsReview} need review`, tone: dashboard.summary.needsReview > 0 ? 'blue' : 'neutral' },
+          { label: `${dashboard.summary.needsEvidence} need evidence`, tone: dashboard.summary.needsEvidence > 0 ? 'neutral' : 'green' },
+          { label: `${dashboard.summary.stalled} stalled`, tone: dashboard.summary.stalled > 0 ? 'yellow' : 'neutral' },
         ]}
         actions={
           <div style={{ display: 'grid', gap: 12 }}>
@@ -169,12 +239,46 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
 
       <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(180px, 1fr))', gap: 16 }}>
         <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="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="◇" />
+        <MetricCard label="Trusted with debt" value={dashboard.steering.trustedWithDebtLanes} sublabel="lanes that look strong on top but still carry unresolved closure debt" tone={dashboard.steering.trustedWithDebtLanes > 0 ? 'yellow' : 'neutral'} icon="!" />
+        <MetricCard label="Needs review" value={dashboard.summary.needsReview} sublabel={`${dashboard.reviewQueue.length} high-leverage queue items`} tone={dashboard.summary.needsReview > 0 ? 'blue' : 'green'} icon="◇" />
+        <MetricCard label="Needs evidence" value={dashboard.summary.needsEvidence} sublabel={`${evidenceDebtGroups.length} grouped debt area${evidenceDebtGroups.length === 1 ? '' : 's'}`} tone={dashboard.summary.needsEvidence > 0 ? 'neutral' : 'green'} icon="◌" />
+        <MetricCard label="Stalled debt" value={dashboard.summary.stalled} sublabel={`${stalledDebtGroups.length} stalled group${stalledDebtGroups.length === 1 ? '' : 's'}`} tone={dashboard.summary.stalled > 0 ? 'yellow' : 'green'} icon="◎" />
       </div>
 
+      <SectionFrame
+        eyebrow="Automated brain verification"
+        title="Latest theory-conformance verdict"
+        description="The prove layer is now complemented by an explicit contract-backed verification run. This does not replace proof review; it checks whether the current brain still behaves according to the bounded theory contract."
+        tone="blue"
+      >
+        {initialConformance ? (
+          <div className="grid-2" style={{ gap: 16 }}>
+            <div className="hero-note-card">
+              <div className="hero-note-label">{conformanceHeadline.label}</div>
+              <div className="hero-note-title">{conformanceHeadline.title}</div>
+              <div className="hero-note-copy">{conformanceHeadline.copy}</div>
+              {initialConformance.reportPath ? (
+                <div className="signal-text" style={{ marginTop: 10 }}>report · {initialConformance.reportPath}</div>
+              ) : null}
+            </div>
+            <div style={{ display: 'grid', gap: 12 }}>
+              <MetricCard label="Verdict" value={initialConformance.verdict} sublabel={`${initialConformance.totals.passed} pass • ${initialConformance.totals.boundedPass} bounded • ${initialConformance.totals.failed} fail • ${initialConformance.totals.inconclusive} inconclusive`} tone={toneForConformance(initialConformance.verdict)} icon="◎" />
+              <MetricCard label="Scenarios" value={initialConformance.totals.scenarios} sublabel={`${initialConformance.totals.assertions} assertions across isolated + live suites`} tone="blue" icon="◇" />
+              <MetricCard label="Latest mode" value={initialConformance.mode} sublabel={initialConformance.releaseMode ? 'release-grade handling enabled' : 'standard operator run'} tone="purple" icon="⇄" />
+              <div className="signal-text">{initialConformance.nextActions[0] ?? 'Run helixevo verify-brain --verbose to inspect the full latest result.'}</div>
+            </div>
+          </div>
+        ) : (
+          <NextStepEmptyState
+            title="No automated verification run yet"
+            description="Run helixevo verify-brain to generate the first contract-backed theory-conformance verdict for this installation."
+            command="helixevo verify-brain --verbose"
+            pageLink={{ label: 'Open Commands', href: '/commands', tone: 'blue' }}
+            guideLink={{ label: 'Guide · Surface Map', anchor: 'surfaces', tone: 'purple' }}
+          />
+        )}
+      </SectionFrame>
+
       <SectionFrame
         eyebrow="Meaning"
         title="What these proof states mean operationally"
@@ -210,7 +314,7 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
                 <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 className="summary-row-meta" style={{ marginTop: 6 }}>{lane.debtSummary ?? lane.reasons[0] ?? 'Proof steering keeps this lane bounded.'}</div>
                 </div>
                 <span className={`hero-chip hero-chip-${toneForSteeringTier(lane.evidenceTier)}`}>{lane.evidenceTier}</span>
               </div>
@@ -219,8 +323,9 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
           </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="Evidence debt" value={dashboard.summary.needsEvidence} sublabel={`${evidenceDebtGroups.length} grouped area${evidenceDebtGroups.length === 1 ? '' : 's'} still need stronger downstream evidence`} tone={dashboard.summary.needsEvidence > 0 ? 'neutral' : '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 className="signal-text">High-priority review and evidence debt are now separate concepts: some records already deserve review, while others still need more live downstream evidence first.</div>
           </div>
         </div>
       </SectionFrame>
@@ -235,7 +340,7 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
             <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
+                {entry.total} total • {entry.effective} effective • {entry.mixed} mixed • {entry.regressed} regressed • {entry.needsEvidence} need evidence • {entry.needsReview} need review • {entry.stalled} stalled
               </div>
             </div>
           )) : (
@@ -281,6 +386,8 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
                 {record.reasons.slice(0, 3).map((reason, idx) => (
                   <div key={`${record.id}-${idx}`} className="signal-text">• {reason}</div>
                 ))}
+                <div className="signal-text">closure · {record.closureState} · {record.closureSummary}</div>
+                {record.closureNeeds[0] ? <div className="signal-text">needs · {record.closureNeeds[0]}</div> : null}
                 {record.recommendedAction ? <div className="signal-text">→ {record.recommendedAction}</div> : null}
               </div>
 
@@ -303,27 +410,55 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
       </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."
+        eyebrow="Evidence debt"
+        title="What proof still needs stronger evidence"
+        description="Repeated dry-run and low-closure records stay visible here as grouped debt areas. They should not compete with high-leverage review as if they were unrelated proof units."
       >
         <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)' }}>
+          {evidenceDebtGroups.length > 0 ? evidenceDebtGroups.map((group) => (
+            <div key={group.groupKey} 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 style={{ fontSize: 12.5, fontWeight: 700, color: 'var(--text)' }}>{group.title}</div>
+                <span className="badge badge-gray">{group.recordCount} record{group.recordCount === 1 ? '' : 's'}</span>
+              </div>
+              <div style={{ fontSize: 12, color: 'var(--text-dim)', marginTop: 6, lineHeight: 1.6 }}>{group.summary}</div>
+              <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', marginTop: 10 }}>
+                {group.route ? <span className="badge badge-purple">{group.route}</span> : null}
+                {group.relatedCapabilities.slice(0, 2).map((capability) => <span key={`${group.groupKey}-${capability}`} className="badge badge-gray">{capability}</span>)}
+                {group.relatedMotifIds.slice(0, 2).map((motifId) => <span key={`${group.groupKey}-${motifId}`} className="badge badge-gray">{motifId.replace(/^motif_/, '')}</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}
+                {group.needs.slice(0, 2).map((need, idx) => <div key={`${group.groupKey}-need-${idx}`} className="signal-text">• {need}</div>)}
+                {group.examples.length > 0 ? <div className="signal-text">examples · {group.examples.join(' • ')}</div> : null}
               </div>
             </div>
-          )) : <div className="signal-text">No candidate-only proof records right now.</div>}
+          )) : <div className="signal-text">No current evidence debt groups. The proof layer is either empty or stronger records are already moving into review/settled paths.</div>}
         </div>
       </SectionFrame>
 
+      {stalledDebtGroups.length > 0 ? (
+        <SectionFrame
+          eyebrow="Stalled debt"
+          title="Proof that is aging without closure"
+          description="These debt groups have remained open long enough that the operator should explicitly revisit them instead of assuming more time alone will improve the proof state."
+        >
+          <div style={{ display: 'grid', gap: 10 }}>
+            {stalledDebtGroups.map((group) => (
+              <div key={group.groupKey} 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)' }}>{group.title}</div>
+                  <span className="badge badge-yellow">stalled</span>
+                </div>
+                <div style={{ fontSize: 12, color: 'var(--text-dim)', marginTop: 6, lineHeight: 1.6 }}>{group.summary}</div>
+                <div style={{ display: 'grid', gap: 6, marginTop: 10 }}>
+                  {group.needs.slice(0, 2).map((need, idx) => <div key={`${group.groupKey}-stalled-${idx}`} className="signal-text">• {need}</div>)}
+                </div>
+              </div>
+            ))}
+          </div>
+        </SectionFrame>
+      ) : null}
+
       <div className="grid-2">
         <SectionFrame
           eyebrow="Verified"
@@ -389,8 +524,11 @@ export default function ProofClient({ initialDashboard }: { initialDashboard: Pr
                   <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>
+                  <span className={`badge badge-${toneForClosureState(record.closureState)}`}>{record.closureState}</span>
                 </div>
               </div>
+              <div className="signal-text" style={{ marginTop: 10 }}>closure · {record.closureSummary}</div>
+              {record.closureNeeds[0] ? <div className="signal-text" style={{ marginTop: 6 }}>needs · {record.closureNeeds[0]}</div> : null}
               {record.latestReview?.rationale ? <div className="signal-text" style={{ marginTop: 10 }}>review rationale · {record.latestReview.rationale}</div> : null}
             </div>
           )) : null}

package/dashboard/app/proof/page.tsx

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

package/dashboard/lib/data.ts

@@ -199,6 +199,8 @@ export interface PressureRouteRecommendation {
   proofSummary?: string
   proofReasons?: string[]
   proofLaneKeys?: string[]
+  proofClosureState?: import('./proof').ProofLaneClosureState
+  proofDebtSummary?: string
 }
 
 export interface PressureIntervention {
@@ -1442,7 +1444,7 @@ export function loadResolvedTopologyApplyPlans(): ResolvedTopologyApplyPlan[] {
     const existing = latestByPlan.get(record.planId)
     const recordAt = record.executedAt ?? record.rolledBackAt ?? record.createdAt
     const existingAt = existing ? (existing.executedAt ?? existing.rolledBackAt ?? existing.createdAt) : ''
-    if (!existing || recordAt > existingAt) latestByPlan.set(record.planId, record)
+    if (!existing || recordAt >= existingAt) latestByPlan.set(record.planId, record)
   }
   return plans
     .map((plan) => {
@@ -2054,6 +2056,19 @@ function strongerProofTier(current: ProofSteeringTier | undefined, next: ProofSt
   return proofTierWeight(next) > proofTierWeight(current) ? next : current
 }
 
+function proofClosureWeight(state: import('./proof').ProofLaneClosureState | undefined): number {
+  if (state === 'trusted-with-debt') return 5
+  if (state === 'stalled') return 4
+  if (state === 'needs-review') return 3
+  if (state === 'needs-evidence') return 2
+  return 1
+}
+
+function strongerProofClosureState(current: import('./proof').ProofLaneClosureState | undefined, next: import('./proof').ProofLaneClosureState): import('./proof').ProofLaneClosureState {
+  if (!current) return next
+  return proofClosureWeight(next) > proofClosureWeight(current) ? next : current
+}
+
 function applyProofInfluenceToRoute(params: {
   recommendation: PressureRouteRecommendation
   signal: PressureSignal
@@ -2071,6 +2086,8 @@ function applyProofInfluenceToRoute(params: {
   const proofLaneKeys: string[] = []
   let proofSummary: string | undefined
   let proofTier: ProofSteeringTier | undefined
+  let proofClosureState: import('./proof').ProofLaneClosureState | undefined
+  let proofDebtSummary: string | undefined
   let proofInfluence: 'none' | 'explanatory' | 'weighted' = 'none'
 
   const routeLane = proofSteering.byRoute[recommendation.route]
@@ -2079,11 +2096,14 @@ function applyProofInfluenceToRoute(params: {
     proofReasons.push(...routeLane.reasons.slice(0, 2))
     proofSummary = proofSummary ?? routeLane.summary
     proofTier = strongerProofTier(proofTier, routeLane.evidenceTier)
+    proofClosureState = strongerProofClosureState(proofClosureState, routeLane.closureState)
+    proofDebtSummary = proofDebtSummary ?? routeLane.debtSummary
 
     if (routeLane.evidenceTier === 'trusted') {
-      confidence = Math.min(0.95, confidence + (routeLane.score >= 4 ? 0.06 : 0.04))
+      confidence = Math.min(0.95, confidence + (routeLane.trustedWithDebt ? 0.04 : routeLane.score >= 4 ? 0.06 : 0.04))
       proofInfluence = 'weighted'
       reasons.push(`Proof steering: ${routeLane.summary}`)
+      if (routeLane.debtSummary) reasons.push(`Proof debt: ${routeLane.debtSummary}`)
     } else if (routeLane.evidenceTier === 'caution') {
       if (recommendation.route !== 'manual-review' && routeLane.score <= -3 && (recommendation.route === 'generalize' || recommendation.route === 'evolve')) {
         route = 'manual-review'
@@ -2091,14 +2111,17 @@ function applyProofInfluenceToRoute(params: {
         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}.`)
+        if (routeLane.debtSummary) reasons.push(`Proof debt: ${routeLane.debtSummary}`)
       } else {
         confidence = Math.max(0.4, confidence - 0.08)
         proofInfluence = 'weighted'
         reasons.push(`Proof steering: ${routeLane.summary}`)
+        if (routeLane.debtSummary) reasons.push(`Proof debt: ${routeLane.debtSummary}`)
       }
     } else {
       if (proofInfluence === 'none') proofInfluence = 'explanatory'
       reasons.push(`Proof steering: ${routeLane.summary}`)
+      if (routeLane.debtSummary) reasons.push(`Proof debt: ${routeLane.debtSummary}`)
     }
   }
 
@@ -2111,10 +2134,13 @@ function applyProofInfluenceToRoute(params: {
       proofReasons.push(...strongestConceptLane.reasons.slice(0, 2))
       proofSummary = proofSummary ?? strongestConceptLane.summary
       proofTier = strongerProofTier(proofTier, strongestConceptLane.evidenceTier)
+      proofClosureState = strongerProofClosureState(proofClosureState, strongestConceptLane.closureState)
+      proofDebtSummary = proofDebtSummary ?? strongestConceptLane.debtSummary
       if (strongestConceptLane.evidenceTier === 'trusted') {
-        confidence = Math.min(0.95, confidence + 0.02)
+        confidence = Math.min(0.95, confidence + (strongestConceptLane.trustedWithDebt ? 0.01 : 0.02))
         proofInfluence = 'weighted'
         reasons.push(`Proof steering: ${strongestConceptLane.summary}`)
+        if (strongestConceptLane.debtSummary) reasons.push(`Proof debt: ${strongestConceptLane.debtSummary}`)
       } else if (strongestConceptLane.evidenceTier === 'caution') {
         confidence = Math.max(0.4, confidence - 0.03)
         if (proofInfluence === 'none') proofInfluence = 'weighted'
@@ -2137,6 +2163,8 @@ function applyProofInfluenceToRoute(params: {
     proofSummary,
     proofReasons: [...new Set(proofReasons)].slice(0, 4),
     proofLaneKeys: [...new Set(proofLaneKeys)],
+    proofClosureState,
+    proofDebtSummary,
   }
 }