helixevo 0.6.1 → 0.7.0

package/dist/cli.js

@@ -13330,6 +13330,7 @@ async function statusCommand() {
   } else {
     console.log(`  ○ Need ${5 - unresolved.length} more failures before next evolution`);
   }
+  console.log("  → Review broader outcome attribution with: helixevo proof --status");
   console.log();
 }
 
@@ -13421,6 +13422,12 @@ async function reportCommand(options) {
     report += `- **${s.slug}**${evolved}
 `;
   }
+  report += `
+## Next Operator Step
+
+`;
+  report += `- Run **helixevo proof --status** to inspect outcome attribution across interventions, topology, ontology, and evolution evidence.
+`;
   const outputPath = options.output ?? join10(getHelixDir(), "reports", `${date}.md`);
   ensureDir(join10(getHelixDir(), "reports"));
   writeFileSync6(outputPath, report);
@@ -16092,6 +16099,8 @@ async function metricsCommand(options) {
     }
     console.log();
   }
+  console.log('  → For broader intervention / topology / ontology outcome review, run "helixevo proof --status"');
+  console.log();
 }
 
 // src/commands/project-setup.ts
@@ -16962,6 +16971,493 @@ async function ontologyCommand(options) {
   }
 }
 
+// src/core/proof.ts
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "node:fs";
+import { join as join22 } from "node:path";
+init_config();
+init_data();
+var PROOF_REVIEW_FILE = "proof-reviews.jsonl";
+var MEASURING_WINDOW_DAYS = 2;
+function proofPath() {
+  return join22(getHelixDir(), PROOF_REVIEW_FILE);
+}
+function uniqueStrings3(values) {
+  return [...new Set(values.filter((value) => Boolean(value && value.trim())))];
+}
+function maxTimestamp2(...values) {
+  const filtered = values.filter((value) => Boolean(value)).sort();
+  return filtered[filtered.length - 1] ?? new Date(0).toISOString();
+}
+function ageDays(value) {
+  if (!value)
+    return Number.POSITIVE_INFINITY;
+  return (Date.now() - new Date(value).getTime()) / (1000 * 60 * 60 * 24);
+}
+function buildRecordId(targetType, targetId) {
+  return `${targetType}:${targetId}`;
+}
+function readProofReviews() {
+  const path = proofPath();
+  if (!existsSync17(path))
+    return [];
+  const raw = readFileSync14(path, "utf-8").trim();
+  if (!raw)
+    return [];
+  return raw.split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+}
+function loadProofReviews() {
+  return readProofReviews().sort((a, b) => b.decidedAt.localeCompare(a.decidedAt));
+}
+function appendProofReview(record) {
+  appendJsonl(PROOF_REVIEW_FILE, record);
+}
+function reviewStatusFor(decision) {
+  if (!decision)
+    return "open";
+  if (decision.decision === "verify")
+    return "verified";
+  if (decision.decision === "defer")
+    return "deferred";
+  return "contested";
+}
+function confidenceFor(outcome, evidenceCount) {
+  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, targetAt, explicitRegression = false) {
+  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() {
+  const latest = new Map;
+  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() {
+  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 = [...linkedSignals, ...linkedMotifs];
+    const outcomeState = intervention.status === "failed" ? "regressed" : intervention.status === "dry-run" ? "insufficient-evidence" : evaluateLifecycleOutcome(lifecycleItems, targetAt);
+    const evidenceCount = linkedSignals.length + linkedMotifs.length;
+    const 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."
+    ];
+    return {
+      id: buildRecordId("pressure-intervention", intervention.id),
+      targetType: "pressure-intervention",
+      targetId: intervention.id,
+      title: `${intervention.interventionType} intervention`,
+      summary: intervention.reasonSummary,
+      createdAt: intervention.createdAt,
+      lastActivityAt: maxTimestamp2(intervention.completedAt, ...linkedSignals.map((signal) => signal.lastActivityAt), ...linkedMotifs.map((motif) => motif.lastActivityAt), intervention.createdAt),
+      outcomeState,
+      reviewStatus: "open",
+      confidence: confidenceFor(outcomeState, evidenceCount),
+      reasons,
+      metrics: {
+        linkedSignals: linkedSignals.length,
+        linkedMotifs: linkedMotifs.length,
+        addressed: lifecycleItems.filter((item) => item.lifecycle === "addressed").length
+      },
+      relatedProjectIds: uniqueStrings3([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: uniqueStrings3([
+        ...intervention.relatedTransferEventIds ?? [],
+        ...linkedMotifs.flatMap((motif) => motif.linkedTransferEventIds ?? [])
+      ]),
+      semanticConceptIds: uniqueStrings3([
+        ...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() {
+  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 = [...linkedSignals, ...linkedMotifs];
+    const outcomeState = evaluateLifecycleOutcome(lifecycleItems, event.timestamp);
+    const evidenceCount = linkedSignals.length + linkedMotifs.length;
+    const 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."
+    ];
+    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: maxTimestamp2(event.timestamp, ...linkedSignals.map((signal) => signal.lastActivityAt), ...linkedMotifs.map((motif) => motif.lastActivityAt)),
+      outcomeState,
+      reviewStatus: "open",
+      confidence: confidenceFor(outcomeState, evidenceCount),
+      reasons,
+      metrics: {
+        linkedSignals: linkedSignals.length,
+        linkedMotifs: linkedMotifs.length,
+        addressed: lifecycleItems.filter((item) => item.lifecycle === "addressed").length
+      },
+      relatedProjectIds: uniqueStrings3([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: uniqueStrings3([
+        ...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() {
+  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 = [...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;
+    const 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."
+    ];
+    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: maxTimestamp2(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,
+      metrics: {
+        linkedSignals: linkedSignals.length,
+        linkedMotifs: linkedMotifs.length,
+        safeToApply: plan.safeToApply ? 1 : 0
+      },
+      relatedProjectIds: uniqueStrings3(candidate?.projectIds ?? []),
+      relatedSignalIds: linkedSignals.map((signal) => signal.id),
+      relatedMotifIds: linkedMotifs.map((motif) => motif.id),
+      relatedTransferEventIds: candidate?.relatedTransferEventIds ?? [],
+      semanticConceptIds: uniqueStrings3([
+        ...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() {
+  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 = [...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);
+    const 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."
+    ];
+    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: maxTimestamp2(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,
+      metrics: {
+        adoptionCount: concept.adoptionCount,
+        boundSignals: boundSignals.length,
+        boundMotifs: boundMotifs.length,
+        boundTransfers: boundTransfers.length,
+        boundTopology: boundTopology.length
+      },
+      relatedProjectIds: uniqueStrings3([
+        ...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() {
+  const impacts = getMetricsSummary().evolutionImpact;
+  return impacts.map((impact) => {
+    const age = ageDays(impact.evolvedAt);
+    const outcomeState = 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 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."
+    ];
+    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,
+      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."
+    };
+  });
+}
+function loadResolvedProofRecords() {
+  const reviewByRecord = latestReviewByRecord();
+  const records = [
+    ...buildInterventionProofRecords(),
+    ...buildTransferProofRecords(),
+    ...buildTopologyProofRecords(),
+    ...buildOntologyProofRecords(),
+    ...buildEvolutionProofRecords()
+  ].map((record) => {
+    const latestReview = reviewByRecord.get(record.id);
+    return {
+      ...record,
+      latestReview,
+      reviewStatus: reviewStatusFor(latestReview)
+    };
+  });
+  const outcomeWeight = (value) => value === "regressed" ? 5 : value === "mixed" ? 4 : value === "effective" ? 3 : value === "measuring" ? 2 : 1;
+  const reviewWeight = (value) => 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));
+}
+function getProofSummary(records = loadResolvedProofRecords()) {
+  const byTargetType = {
+    "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) {
+  const targetTypes = [
+    "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);
+}
+function loadProofDashboardSummary() {
+  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)
+  };
+}
+function reviewProofRecord(input) {
+  const current = loadResolvedProofRecords().find((record) => record.id === input.recordId);
+  if (!current) {
+    throw new Error(`Unknown proof record: ${input.recordId}`);
+  }
+  appendProofReview({
+    id: `proof_review_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    recordId: current.id,
+    targetType: current.targetType,
+    targetId: current.targetId,
+    decision: input.decision,
+    decidedAt: new Date().toISOString(),
+    rationale: input.rationale,
+    decidedBy: input.decidedBy ?? "operator"
+  });
+  const refreshed = loadResolvedProofRecords().find((record) => record.id === input.recordId);
+  if (!refreshed) {
+    throw new Error(`Unable to reload proof record: ${input.recordId}`);
+  }
+  return refreshed;
+}
+
+// src/commands/proof.ts
+function labelForTarget(targetType) {
+  if (targetType === "pressure-intervention")
+    return "interventions";
+  if (targetType === "transfer-event")
+    return "transfers";
+  if (targetType === "topology-execution")
+    return "topology";
+  if (targetType === "ontology-extension")
+    return "ontology";
+  return "evolution";
+}
+function printStatus3(verbose = false) {
+  const dashboard = loadProofDashboardSummary();
+  const summary = dashboard.summary;
+  console.log(`
+  Proof Control`);
+  console.log("  ────────────────────────────────────────");
+  console.log(`  Records: ${summary.total} total • ${summary.effective} effective • ${summary.mixed} mixed • ${summary.regressed} regressed`);
+  console.log(`  Measuring: ${summary.measuring} measuring • ${summary.insufficientEvidence} insufficient-evidence`);
+  console.log(`  Reviews: ${summary.reviewOpen} open • ${summary.verified} verified • ${summary.deferred} deferred • ${summary.contested} contested`);
+  if (dashboard.byTargetType.length > 0) {
+    console.log(`
+  Coverage by target type`);
+    for (const entry of dashboard.byTargetType) {
+      console.log(`  • ${labelForTarget(entry.targetType)}: ${entry.total} total • ${entry.effective} effective • ${entry.regressed} regressed`);
+    }
+  }
+  if (dashboard.reviewQueue.length > 0) {
+    console.log(`
+  Review queue`);
+    for (const record of dashboard.reviewQueue.slice(0, 6)) {
+      console.log(`  • ${record.id} • ${record.outcomeState} • ${record.title}`);
+    }
+  }
+  console.log();
+  if (verbose) {
+    const detailed = dashboard.records.slice(0, 12);
+    if (detailed.length > 0) {
+      console.log("  Detailed proof records");
+      for (const record of detailed) {
+        const projects = (record.relatedProjectIds?.length ?? 0) > 0 ? ` • ${record.relatedProjectIds?.length} project${record.relatedProjectIds?.length === 1 ? "" : "s"}` : "";
+        console.log(`  • ${record.id}`);
+        console.log(`    ${record.targetType} • ${record.outcomeState} • ${record.reviewStatus}${projects}`);
+        console.log(`    ${record.summary}`);
+        for (const reason of record.reasons.slice(0, 2)) {
+          console.log(`    - ${reason}`);
+        }
+        if (record.recommendedAction) {
+          console.log(`    next: ${record.recommendedAction}`);
+        }
+      }
+      console.log();
+    }
+  }
+}
+async function proofCommand(options) {
+  const actions = [options.review ? "review" : null].filter(Boolean);
+  if (actions.length > 1) {
+    throw new Error("Use only one proof action at a time");
+  }
+  if (options.review) {
+    if (!options.decision) {
+      throw new Error("--decision <verify|defer|contest> is required with --review");
+    }
+    const record = reviewProofRecord({
+      recordId: options.review,
+      decision: options.decision,
+      rationale: options.rationale ?? `${options.decision} proof record via CLI review`,
+      decidedBy: "operator"
+    });
+    console.log(`
+  ✓ Recorded proof review: ${record.id}`);
+    console.log(`    target: ${record.targetType}`);
+    console.log(`    outcome: ${record.outcomeState}`);
+    console.log(`    review: ${record.reviewStatus}`);
+    if (record.recommendedAction) {
+      console.log(`    next: ${record.recommendedAction}`);
+    }
+    console.log();
+    return;
+  }
+  printStatus3(options.verbose ?? false);
+  if (!options.verbose) {
+    const summary = getProofSummary();
+    if (summary.total === 0) {
+      console.log("  No proof records yet. Create pressure responses, semantic adoption, or topology execution first, then re-run `helixevo proof --status`.\n");
+    }
+  }
+}
+
 // src/cli.ts
 var program2 = new Command;
 program2.name("helixevo").description("Co-evolving skill and project brain for AI agents").version(VERSION).addHelpText("after", `
@@ -16989,6 +17485,9 @@ Examples:
   $ helixevo ontology --refresh            Derive frontier concepts from recurring evidence
   $ helixevo ontology --review <id> --decision promote
                                            Promote a reviewed frontier concept into approved extensions
+  $ helixevo proof --status --verbose      Review intervention, topology, ontology, and evolution proof state
+  $ helixevo proof --review <id> --decision verify
+                                           Verify a derived proof record after operator review
   $ helixevo report --days 7               Weekly evolution report
   $ helixevo capture <session.json>        Extract failures from session`);
 program2.command("init").description("Import existing skills + generate skill tests").option("--skills-paths <paths...>", "Paths to scan for existing skills").option("--skip-tests", "Skip skill test generation").action(initCommand);
@@ -17010,6 +17509,7 @@ program2.command("health").description("Assess network health: cohesion, coverag
   printHealthReport2(health);
 });
 program2.command("metrics").description("Show correction rates, skill trends, and evolution impact").option("--verbose", "Show detailed per-skill breakdown").action(metricsCommand);
+program2.command("proof").description("Outcome attribution and proof review control [--status] [--review <recordId>] [--decision <verify|defer|contest>]").option("--status", "Show proof summary and open proof review state").option("--review <recordId>", "Review a derived proof record").option("--decision <decision>", "Decision for --review: verify, defer, or contest").option("--rationale <text>", "Optional rationale for the proof review decision").option("--verbose", "Show detailed proof records and derived reasons").action(proofCommand);
 program2.command("project-setup").description("Analyze a project folder and match it against your skill set").argument("<path>", "Path to the project folder").option("--verbose", "Show detailed analysis").option("--dry-run", "Analyze without saving project profile").action(projectSetupCommand);
 program2.command("topology").description("Reviewed topology execution control [--status] [--prepare <candidateId>] [--apply <planId>] [--rollback <planId>]").option("--status", "Show topology review and execution state").option("--prepare <candidateId>", "Prepare an accepted topology review candidate").option("--apply <planId>", "Apply a safe prepared topology plan").option("--rollback <planId>", "Roll back an applied topology plan").option("--verbose", "Show detailed topology plan state").action(topologyCommand);
 program2.command("ontology").description("Governed ontology frontier and semantic adoption control [--status] [--refresh] [--review <conceptId>] [--decision <promote|reject|defer>] [--deprecate <conceptId>]").option("--status", "Show ontology kernel, frontier, and extension state").option("--refresh", "Derive frontier concepts from recurring runtime evidence").option("--review <conceptId>", "Review a frontier concept").option("--decision <decision>", "Decision for --review: promote, reject, or defer").option("--rationale <text>", "Optional rationale for review or deprecate actions").option("--deprecate <conceptId>", "Deprecate an approved ontology extension").option("--verbose", "Show detailed ontology frontier state").action(ontologyCommand);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "helixevo",
-  "version": "0.6.1",
-  "description": "Co-evolving skill and project brain for AI agents, with ontology-aware learning, governed response, rollbackable topology control, and a premium dashboard.",
+  "version": "0.7.0",
+  "description": "Co-evolving skill and project brain for AI agents, with ontology-aware learning, governed response, rollbackable topology control, bounded proof control, and a premium dashboard.",
   "type": "module",
   "bin": {
     "helixevo": "dist/cli.js"