helixevo 0.8.0 → 0.9.0

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)