helixevo 0.6.0 → 0.7.0

package/dashboard/lib/proof.ts

@@ -0,0 +1,577 @@
+import { existsSync, readFileSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import {
+  loadPressureInterventions,
+  loadResolvedPressureSignals,
+  loadPressureMotifs,
+  loadTransferEvents,
+  loadResolvedTopologyApplyPlans,
+  loadResolvedTopologyReviewCandidates,
+  loadResolvedOntologyExtensions,
+  type PressureIntervention,
+  type ResolvedPressureSignal,
+  type ResolvedPressureMotif,
+  type ResolvedTransferEvent,
+  type ResolvedTopologyApplyPlan,
+  type ResolvedTopologyReviewCandidate,
+  type ResolvedOntologyExtension,
+} from './data'
+
+const HELIX_DIR = join(homedir(), '.helix')
+const PROOF_REVIEW_FILE = join(HELIX_DIR, 'proof-reviews.jsonl')
+const METRICS_FILE = join(HELIX_DIR, 'metrics.json')
+const MEASURING_WINDOW_DAYS = 2
+
+export type ProofTargetType = 'pressure-intervention' | 'transfer-event' | 'topology-execution' | 'ontology-extension' | 'evolution-impact'
+export type ProofOutcomeState = 'measuring' | 'effective' | 'mixed' | 'regressed' | 'insufficient-evidence'
+export type ProofReviewDecisionStatus = 'verify' | 'defer' | 'contest'
+export type ProofReviewStatus = 'open' | 'verified' | 'deferred' | 'contested'
+
+export interface ProofReviewRecord {
+  id: string
+  recordId: string
+  targetType: ProofTargetType
+  targetId: string
+  decision: ProofReviewDecisionStatus
+  decidedAt: string
+  rationale: string
+  decidedBy?: 'operator' | 'system'
+}
+
+export interface ResolvedProofRecord {
+  id: string
+  targetType: ProofTargetType
+  targetId: string
+  title: string
+  summary: string
+  createdAt: string
+  lastActivityAt: string
+  outcomeState: ProofOutcomeState
+  reviewStatus: ProofReviewStatus
+  latestReview?: ProofReviewRecord
+  confidence: number
+  reasons: string[]
+  metrics?: Record<string, number>
+  relatedProjectIds?: string[]
+  relatedSignalIds?: string[]
+  relatedMotifIds?: string[]
+  relatedTransferEventIds?: string[]
+  semanticConceptIds?: string[]
+  recommendedAction?: string
+}
+
+export interface ProofSummary {
+  total: number
+  effective: number
+  mixed: number
+  regressed: number
+  measuring: number
+  insufficientEvidence: number
+  reviewOpen: number
+  verified: number
+  deferred: number
+  contested: number
+  byTargetType: Record<ProofTargetType, number>
+}
+
+export interface ProofTargetBreakdown {
+  targetType: ProofTargetType
+  total: number
+  effective: number
+  mixed: number
+  regressed: number
+  measuring: number
+  insufficientEvidence: number
+}
+
+export interface ProofDashboardSummary {
+  summary: ProofSummary
+  records: ResolvedProofRecord[]
+  reviewQueue: ResolvedProofRecord[]
+  recentVerified: ResolvedProofRecord[]
+  recentContested: ResolvedProofRecord[]
+  byTargetType: ProofTargetBreakdown[]
+}
+
+type LifecycleCarrier = {
+  lifecycle: 'open' | 'in-progress' | 'addressed' | 'stale'
+  lastActivityAt: string
+}
+
+type EvolutionImpactRecord = {
+  skillSlug: string
+  generation: number
+  evolvedAt: string
+  correctionRateBefore: number
+  correctionRateAfter: number
+  improvement: number
+  samplesBefore: number
+  samplesAfter: number
+}
+
+function uniqueStrings(values: Array<string | null | undefined>): string[] {
+  return [...new Set(values.filter((value): value is string => Boolean(value && value.trim())))]
+}
+
+function maxTimestamp(...values: Array<string | null | undefined>): string {
+  const filtered = values.filter((value): value is string => Boolean(value)).sort()
+  return filtered[filtered.length - 1] ?? new Date(0).toISOString()
+}
+
+function ageDays(value: string | undefined): number {
+  if (!value) return Number.POSITIVE_INFINITY
+  return (Date.now() - new Date(value).getTime()) / (1000 * 60 * 60 * 24)
+}
+
+function buildRecordId(targetType: ProofTargetType, targetId: string): string {
+  return `${targetType}:${targetId}`
+}
+
+function loadProofReviews(): ProofReviewRecord[] {
+  if (!existsSync(PROOF_REVIEW_FILE)) return []
+  const raw = readFileSync(PROOF_REVIEW_FILE, 'utf-8').trim()
+  if (!raw) return []
+  return raw.split('\n').filter(Boolean).map((line) => JSON.parse(line) as ProofReviewRecord).sort((a, b) => b.decidedAt.localeCompare(a.decidedAt))
+}
+
+function loadEvolutionImpact(): EvolutionImpactRecord[] {
+  if (!existsSync(METRICS_FILE)) return []
+  const raw = JSON.parse(readFileSync(METRICS_FILE, 'utf-8')) as { evolutionImpact?: EvolutionImpactRecord[] }
+  return raw.evolutionImpact ?? []
+}
+
+function reviewStatusFor(decision?: ProofReviewRecord): ProofReviewStatus {
+  if (!decision) return 'open'
+  if (decision.decision === 'verify') return 'verified'
+  if (decision.decision === 'defer') return 'deferred'
+  return 'contested'
+}
+
+function confidenceFor(outcome: ProofOutcomeState, evidenceCount: number): number {
+  const base = outcome === 'effective'
+    ? 0.76
+    : outcome === 'regressed'
+      ? 0.82
+      : outcome === 'mixed'
+        ? 0.64
+        : outcome === 'measuring'
+          ? 0.52
+          : 0.42
+  return Math.min(0.96, base + Math.min(evidenceCount, 8) * 0.035)
+}
+
+function evaluateLifecycleOutcome(items: LifecycleCarrier[], targetAt: string, explicitRegression = false): ProofOutcomeState {
+  if (explicitRegression) return 'regressed'
+  const addressed = items.filter((item) => item.lifecycle === 'addressed').length
+  const active = items.filter((item) => item.lifecycle === 'open' || item.lifecycle === 'in-progress').length
+
+  if (items.length === 0) {
+    return ageDays(targetAt) <= MEASURING_WINDOW_DAYS ? 'measuring' : 'insufficient-evidence'
+  }
+
+  if (addressed > 0 && active === 0) return 'effective'
+  if (addressed > 0 && active > 0) return 'mixed'
+  if (ageDays(targetAt) <= MEASURING_WINDOW_DAYS) return 'measuring'
+  return 'insufficient-evidence'
+}
+
+function latestReviewByRecord(): Map<string, ProofReviewRecord> {
+  const latest = new Map<string, ProofReviewRecord>()
+  for (const review of loadProofReviews()) {
+    const existing = latest.get(review.recordId)
+    if (!existing || review.decidedAt > existing.decidedAt) latest.set(review.recordId, review)
+  }
+  return latest
+}
+
+function buildInterventionProofRecords(): ResolvedProofRecord[] {
+  const signals = loadResolvedPressureSignals()
+  const motifs = loadPressureMotifs()
+
+  return loadPressureInterventions().map((intervention) => {
+    const linkedSignals = signals.filter((signal) =>
+      intervention.pressureSignalIds?.includes(signal.id)
+      || signal.linkedInterventions.some((linked) => linked.id === intervention.id),
+    )
+    const linkedMotifs = motifs.filter((motif) =>
+      intervention.motifIds?.includes(motif.id)
+      || motif.linkedInterventionIds.includes(intervention.id),
+    )
+    const targetAt = intervention.completedAt ?? intervention.createdAt
+    const lifecycleItems: LifecycleCarrier[] = [...linkedSignals, ...linkedMotifs]
+    const outcomeState = intervention.status === 'failed'
+      ? 'regressed'
+      : intervention.status === 'dry-run'
+        ? 'insufficient-evidence'
+        : evaluateLifecycleOutcome(lifecycleItems, targetAt)
+    const evidenceCount = linkedSignals.length + linkedMotifs.length
+
+    return {
+      id: buildRecordId('pressure-intervention', intervention.id),
+      targetType: 'pressure-intervention',
+      targetId: intervention.id,
+      title: `${intervention.interventionType} intervention`,
+      summary: intervention.reasonSummary,
+      createdAt: intervention.createdAt,
+      lastActivityAt: maxTimestamp(intervention.completedAt, ...linkedSignals.map((signal) => signal.lastActivityAt), ...linkedMotifs.map((motif) => motif.lastActivityAt), intervention.createdAt),
+      outcomeState,
+      reviewStatus: 'open',
+      confidence: confidenceFor(outcomeState, evidenceCount),
+      reasons: [
+        `${intervention.interventionType} recorded as ${intervention.status} with ${evidenceCount} linked pressure target${evidenceCount === 1 ? '' : 's'}.`,
+        outcomeState === 'effective'
+          ? 'All linked pressure evidence currently resolves to addressed state.'
+          : outcomeState === 'mixed'
+            ? 'Linked pressure evidence is split between addressed and still-active states.'
+            : outcomeState === 'regressed'
+              ? 'The intervention failed explicitly, so proof treats it as regressed.'
+              : outcomeState === 'measuring'
+                ? 'The intervention is still too recent or too active for a stronger proof verdict.'
+                : intervention.status === 'dry-run'
+                  ? 'Dry-run interventions do not create live effect evidence.'
+                  : 'Linked evidence is too weak to attribute a stronger effect safely.',
+      ],
+      metrics: {
+        linkedSignals: linkedSignals.length,
+        linkedMotifs: linkedMotifs.length,
+        addressed: lifecycleItems.filter((item) => item.lifecycle === 'addressed').length,
+      },
+      relatedProjectIds: uniqueStrings([intervention.projectId, ...linkedSignals.map((signal) => signal.projectId), ...linkedMotifs.flatMap((motif) => motif.projectIds)]),
+      relatedSignalIds: linkedSignals.map((signal) => signal.id),
+      relatedMotifIds: linkedMotifs.map((motif) => motif.id),
+      relatedTransferEventIds: uniqueStrings([...(intervention.relatedTransferEventIds ?? []), ...linkedMotifs.flatMap((motif) => motif.linkedTransferEventIds ?? [])]),
+      semanticConceptIds: uniqueStrings([
+        ...linkedSignals.flatMap((signal) => signal.semanticConceptIds ?? []),
+        ...linkedMotifs.flatMap((motif) => motif.semanticConceptIds ?? []),
+      ]),
+      recommendedAction: outcomeState === 'effective'
+        ? 'Verify if this resolving pattern should remain a trusted lane.'
+        : outcomeState === 'mixed'
+          ? 'Inspect Co-Evolution and compare remaining active pressure before re-routing.'
+          : outcomeState === 'regressed'
+            ? 'Inspect Co-Evolution for a different governed response or manual review.'
+            : outcomeState === 'measuring'
+              ? 'Let the intervention age or accumulate more downstream evidence before review.'
+              : 'Link stronger downstream evidence before treating this intervention as proven.',
+    }
+  })
+}
+
+function buildTransferProofRecords(): ResolvedProofRecord[] {
+  const motifs = loadPressureMotifs()
+  const signals = loadResolvedPressureSignals()
+
+  return loadTransferEvents()
+    .filter((event) => event.status === 'realized')
+    .map((event) => {
+      const linkedMotifs = motifs.filter((motif) => event.motifIds?.includes(motif.id) || motif.linkedTransferEventIds.includes(event.id))
+      const linkedSignals = signals.filter((signal) => signal.motifIds?.some((motifId) => event.motifIds?.includes(motifId)))
+      const lifecycleItems: LifecycleCarrier[] = [...linkedSignals, ...linkedMotifs]
+      const outcomeState = evaluateLifecycleOutcome(lifecycleItems, event.timestamp)
+      const evidenceCount = linkedSignals.length + linkedMotifs.length
+
+      return {
+        id: buildRecordId('transfer-event', event.id),
+        targetType: 'transfer-event',
+        targetId: event.id,
+        title: `${event.transferType} transfer`,
+        summary: event.summary ?? 'Realized transfer event',
+        createdAt: event.timestamp,
+        lastActivityAt: maxTimestamp(event.timestamp, ...linkedSignals.map((signal) => signal.lastActivityAt), ...linkedMotifs.map((motif) => motif.lastActivityAt)),
+        outcomeState,
+        reviewStatus: 'open',
+        confidence: confidenceFor(outcomeState, evidenceCount),
+        reasons: [
+          `${event.transferType} transfer is realized and linked to ${linkedMotifs.length} motifs plus ${linkedSignals.length} correlated signals.`,
+          outcomeState === 'effective'
+            ? 'Linked motif pressure currently resolves cleanly to addressed state.'
+            : outcomeState === 'mixed'
+              ? 'Some linked motif pressure is addressed, but some remains active.'
+              : outcomeState === 'measuring'
+                ? 'The realized transfer is still recent enough that proof stays in measuring mode.'
+                : 'Transfer evidence exists, but downstream relief is too weak to call it effective yet.',
+        ],
+        metrics: {
+          linkedSignals: linkedSignals.length,
+          linkedMotifs: linkedMotifs.length,
+          addressed: lifecycleItems.filter((item) => item.lifecycle === 'addressed').length,
+        },
+        relatedProjectIds: uniqueStrings([event.sourceProjectId, event.targetProjectId, ...linkedMotifs.flatMap((motif) => motif.projectIds)]),
+        relatedSignalIds: linkedSignals.map((signal) => signal.id),
+        relatedMotifIds: linkedMotifs.map((motif) => motif.id),
+        relatedTransferEventIds: [event.id],
+        semanticConceptIds: uniqueStrings([
+          ...(event.semanticConceptIds ?? []),
+          ...linkedSignals.flatMap((signal) => signal.semanticConceptIds ?? []),
+          ...linkedMotifs.flatMap((motif) => motif.semanticConceptIds ?? []),
+        ]),
+        recommendedAction: outcomeState === 'effective'
+          ? 'Verify whether this transfer pattern should be treated as proven reusable evidence.'
+          : outcomeState === 'mixed'
+            ? 'Inspect remaining active motifs before treating this transfer as fully proven.'
+            : outcomeState === 'measuring'
+              ? 'Wait for more motif pressure movement before review.'
+              : 'Accumulate more downstream motif or signal relief before verifying this transfer.',
+      }
+    })
+}
+
+function buildTopologyProofRecords(): ResolvedProofRecord[] {
+  const candidatesById = new Map(loadResolvedTopologyReviewCandidates().map((candidate) => [candidate.id, candidate]))
+  const signals = loadResolvedPressureSignals()
+  const motifs = loadPressureMotifs()
+
+  return loadResolvedTopologyApplyPlans().map((plan) => {
+    const candidate = candidatesById.get(plan.candidateId)
+    const latestStatus = plan.latestStatus
+    const linkedSignals = signals.filter((signal) => candidate?.relatedSignalIds?.includes(signal.id))
+    const linkedMotifs = motifs.filter((motif) => candidate?.relatedMotifIds?.includes(motif.id))
+    const lifecycleItems: LifecycleCarrier[] = [...linkedSignals, ...linkedMotifs]
+    const targetAt = plan.latestExecution?.executedAt ?? plan.createdAt
+    const explicitRegression = latestStatus === 'rolled-back' || latestStatus === 'failed'
+    const outcomeState = latestStatus === 'pending' || latestStatus === 'prepared'
+      ? 'measuring'
+      : evaluateLifecycleOutcome(lifecycleItems, targetAt, explicitRegression)
+    const evidenceCount = linkedSignals.length + linkedMotifs.length
+
+    return {
+      id: buildRecordId('topology-execution', plan.id),
+      targetType: 'topology-execution',
+      targetId: plan.id,
+      title: `${plan.changeType} topology execution`,
+      summary: plan.reasonSummary,
+      createdAt: plan.createdAt,
+      lastActivityAt: maxTimestamp(plan.lastActivityAt, candidate?.lastActivityAt, ...linkedSignals.map((signal) => signal.lastActivityAt), ...linkedMotifs.map((motif) => motif.lastActivityAt)),
+      outcomeState,
+      reviewStatus: 'open',
+      confidence: confidenceFor(outcomeState, evidenceCount + (latestStatus === 'applied' ? 1 : 0)),
+      reasons: [
+        `${plan.changeType} topology plan is currently ${latestStatus}.`,
+        explicitRegression
+          ? 'Rollback or failed execution is treated as explicit negative evidence.'
+          : outcomeState === 'effective'
+            ? 'Linked structural pressure currently resolves to addressed state after apply.'
+            : outcomeState === 'mixed'
+              ? 'Structural apply has some correlated relief, but not a clean closure.'
+              : outcomeState === 'measuring'
+                ? 'Prepared or recently applied topology changes remain in measuring mode until more evidence accrues.'
+                : 'There is not enough downstream structural-pressure evidence for a stronger verdict yet.',
+      ],
+      metrics: {
+        linkedSignals: linkedSignals.length,
+        linkedMotifs: linkedMotifs.length,
+        safeToApply: plan.safeToApply ? 1 : 0,
+      },
+      relatedProjectIds: uniqueStrings(candidate?.projectIds ?? []),
+      relatedSignalIds: linkedSignals.map((signal) => signal.id),
+      relatedMotifIds: linkedMotifs.map((motif) => motif.id),
+      relatedTransferEventIds: candidate?.relatedTransferEventIds ?? [],
+      semanticConceptIds: uniqueStrings([
+        ...(candidate?.semanticConceptIds ?? []),
+        ...linkedSignals.flatMap((signal) => signal.semanticConceptIds ?? []),
+        ...linkedMotifs.flatMap((motif) => motif.semanticConceptIds ?? []),
+      ]),
+      recommendedAction: outcomeState === 'effective'
+        ? 'Verify this topology change if the structural relief looks durable.'
+        : outcomeState === 'mixed'
+          ? 'Inspect Topology and Co-Evolution together before trusting this execution fully.'
+          : outcomeState === 'regressed'
+            ? 'Inspect the execution notes and rollback path before retrying.'
+            : outcomeState === 'measuring'
+              ? 'Wait for more downstream pressure movement before review.'
+              : 'Link stronger post-apply evidence before verifying this structural change.',
+    }
+  })
+}
+
+function buildOntologyProofRecords(): ResolvedProofRecord[] {
+  const signals = loadResolvedPressureSignals()
+  const motifs = loadPressureMotifs()
+  const transfers = loadTransferEvents()
+  const topologyCandidates = loadResolvedTopologyReviewCandidates()
+
+  return loadResolvedOntologyExtensions()
+    .filter((concept) => concept.status === 'active')
+    .map((concept) => {
+      const boundSignals = signals.filter((signal) => signal.semanticConceptIds?.includes(concept.id))
+      const boundMotifs = motifs.filter((motif) => motif.semanticConceptIds?.includes(concept.id))
+      const boundTransfers = transfers.filter((event) => event.semanticConceptIds?.includes(concept.id))
+      const boundTopology = topologyCandidates.filter((candidate) => candidate.semanticConceptIds?.includes(concept.id))
+      const lifecycleItems: LifecycleCarrier[] = [...boundSignals, ...boundMotifs]
+      const evidenceCount = concept.adoptionCount + boundTransfers.length + boundTopology.length
+      const outcomeState = concept.adoptionCount === 0
+        ? (ageDays(concept.createdAt) <= MEASURING_WINDOW_DAYS ? 'measuring' : 'insufficient-evidence')
+        : evaluateLifecycleOutcome(lifecycleItems, concept.lastActivityAt)
+
+      return {
+        id: buildRecordId('ontology-extension', concept.id),
+        targetType: 'ontology-extension',
+        targetId: concept.id,
+        title: `${concept.name} semantic adoption`,
+        summary: concept.description ?? concept.sourceSummary ?? 'Approved ontology extension',
+        createdAt: concept.createdAt,
+        lastActivityAt: maxTimestamp(concept.lastActivityAt, ...boundSignals.map((signal) => signal.lastActivityAt), ...boundMotifs.map((motif) => motif.lastActivityAt)),
+        outcomeState,
+        reviewStatus: 'open',
+        confidence: Math.min(0.88, confidenceFor(outcomeState, evidenceCount) - 0.04),
+        reasons: [
+          `${concept.name} currently has ${concept.adoptionCount} semantic bindings across live consumers.`,
+          outcomeState === 'effective'
+            ? 'Correlated semantic consumers now align with addressed downstream pressure evidence.'
+            : outcomeState === 'mixed'
+              ? 'Semantic adoption is active, but downstream pressure evidence remains mixed.'
+              : outcomeState === 'measuring'
+                ? 'Semantic adoption is live but still too recent or incomplete for a stronger claim.'
+                : 'This record is treated as semantic-adoption evidence, not strong direct causality proof.',
+        ],
+        metrics: {
+          adoptionCount: concept.adoptionCount,
+          boundSignals: boundSignals.length,
+          boundMotifs: boundMotifs.length,
+          boundTransfers: boundTransfers.length,
+          boundTopology: boundTopology.length,
+        },
+        relatedProjectIds: uniqueStrings([...(concept.projectIds ?? []), ...boundSignals.map((signal) => signal.projectId), ...boundMotifs.flatMap((motif) => motif.projectIds)]),
+        relatedSignalIds: boundSignals.map((signal) => signal.id),
+        relatedMotifIds: boundMotifs.map((motif) => motif.id),
+        relatedTransferEventIds: boundTransfers.map((event) => event.id),
+        semanticConceptIds: [concept.id],
+        recommendedAction: outcomeState === 'effective'
+          ? 'Verify this concept if semantic adoption looks stable enough to trust.'
+          : outcomeState === 'mixed'
+            ? 'Inspect Ontology and Co-Evolution together before treating this concept as proven.'
+            : outcomeState === 'measuring'
+              ? 'Let semantic adoption spread or age before review.'
+              : 'Treat this as bounded semantic-adoption evidence until stronger downstream relief appears.',
+      }
+    })
+}
+
+function buildEvolutionProofRecords(): ResolvedProofRecord[] {
+  return loadEvolutionImpact().map((impact) => {
+    const age = ageDays(impact.evolvedAt)
+    const outcomeState: ProofOutcomeState = impact.samplesAfter <= 0
+      ? (age <= MEASURING_WINDOW_DAYS ? 'measuring' : 'insufficient-evidence')
+      : age <= MEASURING_WINDOW_DAYS || impact.samplesAfter < 3
+        ? 'measuring'
+        : impact.improvement < -10
+          ? 'effective'
+          : impact.improvement > 10
+            ? 'regressed'
+            : 'mixed'
+    const targetId = `${impact.skillSlug}:${impact.generation}:${impact.evolvedAt}`
+
+    return {
+      id: buildRecordId('evolution-impact', targetId),
+      targetType: 'evolution-impact',
+      targetId,
+      title: `${impact.skillSlug} evolution impact`,
+      summary: `Generation ${impact.generation} evolution baseline recorded at ${impact.evolvedAt}.`,
+      createdAt: impact.evolvedAt,
+      lastActivityAt: impact.evolvedAt,
+      outcomeState,
+      reviewStatus: 'open',
+      confidence: confidenceFor(outcomeState, impact.samplesBefore + impact.samplesAfter),
+      reasons: [
+        `${impact.skillSlug} generation ${impact.generation} has ${impact.samplesBefore} baseline failures and ${impact.samplesAfter} post-evolution samples.`,
+        outcomeState === 'effective'
+          ? 'Measured failure rate dropped enough to clear the effectiveness threshold.'
+          : outcomeState === 'regressed'
+            ? 'Measured failure rate increased enough to count as regression.'
+            : outcomeState === 'mixed'
+              ? 'The run changed behavior, but not enough for a clean positive or negative verdict.'
+              : outcomeState === 'measuring'
+                ? 'The evolution record is still collecting enough post-change evidence.'
+                : 'There is not enough post-change sample depth for a stronger verdict.',
+      ],
+      metrics: {
+        improvement: impact.improvement,
+        samplesBefore: impact.samplesBefore,
+        samplesAfter: impact.samplesAfter,
+      },
+      recommendedAction: outcomeState === 'effective'
+        ? 'Verify this evolution result if the lower correction rate looks durable.'
+        : outcomeState === 'regressed'
+          ? 'Inspect evolution history and judges before trusting this mutation lane again.'
+          : outcomeState === 'measuring'
+            ? 'Wait for more post-evolution samples before review.'
+            : 'Use metrics alongside proof review before concluding anything stronger.',
+    }
+  })
+}
+
+export function loadResolvedProofRecords(): ResolvedProofRecord[] {
+  const latestReviews = latestReviewByRecord()
+  const records = [
+    ...buildInterventionProofRecords(),
+    ...buildTransferProofRecords(),
+    ...buildTopologyProofRecords(),
+    ...buildOntologyProofRecords(),
+    ...buildEvolutionProofRecords(),
+  ].map((record) => {
+    const latestReview = latestReviews.get(record.id)
+    return {
+      ...record,
+      latestReview,
+      reviewStatus: reviewStatusFor(latestReview),
+    }
+  })
+
+  const outcomeWeight = (value: ProofOutcomeState) => value === 'regressed' ? 5 : value === 'mixed' ? 4 : value === 'effective' ? 3 : value === 'measuring' ? 2 : 1
+  const reviewWeight = (value: ProofReviewStatus) => value === 'contested' ? 4 : value === 'open' ? 3 : value === 'deferred' ? 2 : 1
+
+  return records.sort((a, b) => reviewWeight(b.reviewStatus) - reviewWeight(a.reviewStatus) || outcomeWeight(b.outcomeState) - outcomeWeight(a.outcomeState) || b.lastActivityAt.localeCompare(a.lastActivityAt) || a.targetType.localeCompare(b.targetType))
+}
+
+export function getProofSummary(records = loadResolvedProofRecords()): ProofSummary {
+  const byTargetType: Record<ProofTargetType, number> = {
+    'pressure-intervention': 0,
+    'transfer-event': 0,
+    'topology-execution': 0,
+    'ontology-extension': 0,
+    'evolution-impact': 0,
+  }
+  for (const record of records) byTargetType[record.targetType] += 1
+  return {
+    total: records.length,
+    effective: records.filter((record) => record.outcomeState === 'effective').length,
+    mixed: records.filter((record) => record.outcomeState === 'mixed').length,
+    regressed: records.filter((record) => record.outcomeState === 'regressed').length,
+    measuring: records.filter((record) => record.outcomeState === 'measuring').length,
+    insufficientEvidence: records.filter((record) => record.outcomeState === 'insufficient-evidence').length,
+    reviewOpen: records.filter((record) => record.reviewStatus === 'open').length,
+    verified: records.filter((record) => record.reviewStatus === 'verified').length,
+    deferred: records.filter((record) => record.reviewStatus === 'deferred').length,
+    contested: records.filter((record) => record.reviewStatus === 'contested').length,
+    byTargetType,
+  }
+}
+
+function buildTargetBreakdown(records: ResolvedProofRecord[]): ProofTargetBreakdown[] {
+  const targetTypes: ProofTargetType[] = ['pressure-intervention', 'transfer-event', 'topology-execution', 'ontology-extension', 'evolution-impact']
+  return targetTypes.map((targetType) => {
+    const subset = records.filter((record) => record.targetType === targetType)
+    return {
+      targetType,
+      total: subset.length,
+      effective: subset.filter((record) => record.outcomeState === 'effective').length,
+      mixed: subset.filter((record) => record.outcomeState === 'mixed').length,
+      regressed: subset.filter((record) => record.outcomeState === 'regressed').length,
+      measuring: subset.filter((record) => record.outcomeState === 'measuring').length,
+      insufficientEvidence: subset.filter((record) => record.outcomeState === 'insufficient-evidence').length,
+    }
+  }).filter((entry) => entry.total > 0)
+}
+
+export function loadProofDashboardSummary(): ProofDashboardSummary {
+  const records = loadResolvedProofRecords()
+  return {
+    summary: getProofSummary(records),
+    records,
+    reviewQueue: records.filter((record) => record.reviewStatus === 'open').slice(0, 12),
+    recentVerified: records.filter((record) => record.reviewStatus === 'verified').slice(0, 8),
+    recentContested: records.filter((record) => record.reviewStatus === 'contested').slice(0, 8),
+    byTargetType: buildTargetBreakdown(records),
+  }
+}

package/dashboard/lib/release-spotlight.ts

@@ -0,0 +1,17 @@
+export const CURRENT_RELEASE_SPOTLIGHT = {
+  version: '0.7.0',
+  title: 'What changed in 0.7.0',
+  summary:
+    'This release turns Prove into a first-class operator stage: HelixEvo now unifies bounded outcome attribution across interventions, semantic adoption, topology execution, transfer, and legacy evolution impact.',
+  bullets: [
+    'HelixEvo now ships a dedicated Proof route and proof review API instead of treating metrics alone as the full prove surface.',
+    'Overview, Co-Evolution, Ontology, and Topology now expose proof visibility and direct handoffs into bounded outcome review.',
+    'The operator loop now lands Prove on /proof, keeping navigation, handoffs, Commands, and Guide aligned with the shipped product.',
+    'Proof remains deliberately bounded: measuring, mixed, regressed, and insufficient-evidence states stay visible instead of being overclaimed as certainty.',
+  ],
+  nextActions: [
+    { label: 'Open proof control', href: '/proof', tone: 'blue' as const },
+    { label: 'Inspect co-evolution', href: '/coevolution', tone: 'purple' as const },
+    { label: 'Read proof + metrics', href: '/guide#metrics', tone: 'green' as const },
+  ],
+} as const