avorelo 0.1.0 → 0.3.0

package/scripts/lib/value-ledger.js

@@ -1,130 +0,0 @@
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-
-const LEDGER_REL = ".claude/cco/state/value-ledger.jsonl";
-const SCHEMA_VERSION = 1;
-const VALID_BUCKETS = new Set([
-  "context_avoided",
-  "large_output_referenced",
-  "reentry_reused",
-  "memory_recalled",
-  "proof_completed",
-  "proof_gap_avoided",
-  "risky_action_reduced",
-  "workflow_recommendation_used",
-  "external_context_provider_detected",
-]);
-const MAX_LABEL_LEN = 200;
-const MAX_NOTES_LEN = 500;
-const MAX_ARTIFACT_LEN = 300;
-
-function buildEvent(partial) {
-  const bucket = partial.bucket;
-  if (!VALID_BUCKETS.has(bucket)) {
-    throw new Error(`Invalid bucket: ${bucket}`);
-  }
-  return {
-    schemaVersion: SCHEMA_VERSION,
-    bucket,
-    ts: partial.ts || new Date().toISOString(),
-    sessionId: partial.sessionId || null,
-    label: String(partial.label || "").slice(0, MAX_LABEL_LEN),
-    savedBytes: Number.isFinite(partial.savedBytes) ? partial.savedBytes : 0,
-    savedTokens: Number.isFinite(partial.savedTokens) ? partial.savedTokens : 0,
-    notes: String(partial.notes || "").slice(0, MAX_NOTES_LEN),
-    artifactRef: partial.artifactRef ? String(partial.artifactRef).slice(0, MAX_ARTIFACT_LEN) : null,
-    meta: partial.meta || null,
-  };
-}
-
-class ValueLedger {
-  constructor(repoRoot) {
-    this.repoRoot = repoRoot;
-    this.filePath = path.join(repoRoot, LEDGER_REL);
-  }
-
-  append(partial) {
-    try {
-      const event = buildEvent(partial);
-      const dir = path.dirname(this.filePath);
-      fs.mkdirSync(dir, { recursive: true });
-      fs.appendFileSync(this.filePath, JSON.stringify(event) + "\n", "utf8");
-      return event;
-    } catch {
-      return null;
-    }
-  }
-
-  loadAll() {
-    try {
-      const raw = fs.readFileSync(this.filePath, "utf8");
-      return raw
-        .split("\n")
-        .filter(Boolean)
-        .map((line) => {
-          try {
-            return JSON.parse(line);
-          } catch {
-            return null;
-          }
-        })
-        .filter(Boolean);
-    } catch {
-      return [];
-    }
-  }
-}
-
-function buildValueLedgerSummary(events) {
-  const byBucket = {};
-  let totalSavedBytes = 0;
-  let totalSavedTokens = 0;
-  for (const e of events) {
-    if (!e || !e.bucket) continue;
-    if (!byBucket[e.bucket]) byBucket[e.bucket] = { count: 0, savedBytes: 0, savedTokens: 0 };
-    byBucket[e.bucket].count++;
-    byBucket[e.bucket].savedBytes += e.savedBytes || 0;
-    byBucket[e.bucket].savedTokens += e.savedTokens || 0;
-    totalSavedBytes += e.savedBytes || 0;
-    totalSavedTokens += e.savedTokens || 0;
-  }
-  return {
-    totalEvents: events.length,
-    totalSavedBytes,
-    totalSavedTokens,
-    byBucket,
-  };
-}
-
-function formatValueLedgerLine(summary) {
-  if (!summary || summary.totalEvents === 0) return null;
-  const parts = [];
-  if (summary.byBucket.large_output_referenced?.count) {
-    parts.push(`${summary.byBucket.large_output_referenced.count} MCP large outputs replaced`);
-  }
-  if (summary.byBucket.reentry_reused?.count) {
-    parts.push(`${summary.byBucket.reentry_reused.count} reentry selections bounded`);
-  }
-  if (summary.byBucket.context_avoided?.count) {
-    parts.push(`${summary.byBucket.context_avoided.count} candidate drops recorded`);
-  }
-  if (summary.totalSavedBytes > 0) {
-    parts.push(`~${Math.round(summary.totalSavedBytes / 1024)}KB saved (MCP replacements)`);
-  }
-  if (parts.length === 0) {
-    parts.push(`${summary.totalEvents} value events`);
-  }
-  return `Value ledger: ${parts.join(", ")}`;
-}
-
-module.exports = {
-  ValueLedger,
-  buildEvent,
-  buildValueLedgerSummary,
-  formatValueLedgerLine,
-  VALID_BUCKETS,
-  SCHEMA_VERSION,
-  LEDGER_REL,
-};

package/scripts/lib/value-proof-calibration.js

@@ -1,531 +0,0 @@
-"use strict";
-
-// ── Value Proof Calibration ───────────────────────────────────────────────────
-//
-// Normalizes every important value metric into a proof object with:
-//   basis, evidence, confidence, valueClass, overclaimRisk, policy flags.
-//
-// valueClass definitions:
-//   measured   — derived directly from observed local data or event counts
-//   estimated  — derived from observable local inputs using a clear formula
-//   heuristic  — derived from rule-of-thumb assumptions
-//   unavailable — not enough evidence
-//
-// This module is purely computational — no FS I/O, no LLM, no network.
-
-// ── Proof builder ─────────────────────────────────────────────────────────────
-
-function buildValueProof({
-  valueId,
-  label,
-  dimension,
-  value,
-  unit,
-  valueClass,
-  confidence,
-  basis,
-  method,
-  evidence = [],
-  caveats = [],
-  overclaimRisk,
-  needsMoreEvidence = false,
-  nextEvidenceToCollect = null,
-}) {
-  const userFacingAllowed = valueClass !== "unavailable" && confidence !== "unavailable";
-  const dashboardAllowed = userFacingAllowed && (valueClass === "measured" || valueClass === "estimated" || valueClass === "heuristic");
-  const websiteAllowed = valueClass === "measured" && confidence === "high";
-  const pricingAllowed = false; // never allowed without real usage/billing data
-  const caveatRequired = valueClass === "heuristic" || valueClass === "estimated" || overclaimRisk === "medium" || overclaimRisk === "high";
-
-  return {
-    valueId,
-    label,
-    dimension,
-    value,
-    unit,
-    valueClass,
-    confidence,
-    basis,
-    method,
-    evidence,
-    caveats,
-    overclaimRisk,
-    userFacingAllowed,
-    dashboardAllowed,
-    websiteAllowed,
-    pricingAllowed,
-    caveatRequired,
-    needsMoreEvidence,
-    nextEvidenceToCollect,
-  };
-}
-
-// ── Time saved proof ──────────────────────────────────────────────────────────
-
-function buildTimeSavedProof({ manualStepsAvoided, minMinutes, maxMinutes, evidence, capApplied }) {
-  const hasValue = manualStepsAvoided > 0;
-
-  if (!hasValue) {
-    return buildValueProof({
-      valueId: "timeSaved",
-      label: "Time Saved",
-      dimension: "time",
-      value: null,
-      unit: "minutes",
-      valueClass: "unavailable",
-      confidence: "unavailable",
-      basis: "No manual steps avoided detected",
-      method: "heuristic: manual steps avoided × 1–3 minutes",
-      evidence: [],
-      caveats: ["No manual steps avoided detected; cannot estimate time savings."],
-      overclaimRisk: "none",
-      needsMoreEvidence: true,
-      nextEvidenceToCollect: "Run work-control, session-context, and workspace-registry to detect manual steps avoided.",
-    });
-  }
-
-  const caveats = [
-    "Heuristic estimate — no stopwatch or measured session duration.",
-    `Based on ${manualStepsAvoided} manual steps avoided × 1–3 minutes per step.`,
-    capApplied ? `Time estimate was capped at ${maxMinutes} minutes (max heuristic cap applied).` : null,
-    "Confidence cannot be high without measured session duration evidence.",
-  ].filter(Boolean);
-
-  return buildValueProof({
-    valueId: "timeSaved",
-    label: "Time Saved",
-    dimension: "time",
-    value: { min: minMinutes, max: maxMinutes },
-    unit: "minutes",
-    valueClass: "heuristic",
-    confidence: manualStepsAvoided >= 5 ? "medium" : "low",
-    basis: `${manualStepsAvoided} manual steps avoided`,
-    method: "heuristic: manual steps avoided × 1–3 minutes, capped",
-    evidence,
-    caveats,
-    overclaimRisk: "low",
-    needsMoreEvidence: true,
-    nextEvidenceToCollect: "Session duration measurement or stopwatch evidence would upgrade confidence from heuristic to estimated.",
-  });
-}
-
-// ── Token / context proof ─────────────────────────────────────────────────────
-
-function buildTokenReductionProof({
-  rawCandidateTokens,
-  rawConfidence,
-  rawSources,
-  compactHandoffTokens,
-  compactConfidence,
-  tokenReduction,
-}) {
-  if (rawCandidateTokens === null || compactHandoffTokens === null) {
-    return buildValueProof({
-      valueId: "tokenReduction",
-      label: "Token / Context Reduction",
-      dimension: "tokens",
-      value: null,
-      unit: "tokens",
-      valueClass: "unavailable",
-      confidence: "unavailable",
-      basis: "rawCandidateTokens or compactHandoffTokens not available",
-      method: "candidate context size vs compact handoff size",
-      evidence: [],
-      caveats: ["Token reduction cannot be measured without both raw candidate context and compact handoff."],
-      overclaimRisk: "none",
-      needsMoreEvidence: true,
-      nextEvidenceToCollect: "Run workspace-registry for raw candidate size and session-context for compact handoff tokens.",
-    });
-  }
-
-  if (tokenReduction <= 0) {
-    return buildValueProof({
-      valueId: "tokenReduction",
-      label: "Token / Context Reduction",
-      dimension: "tokens",
-      value: 0,
-      unit: "tokens",
-      valueClass: "unavailable",
-      confidence: "unavailable",
-      basis: "Compact handoff is not smaller than raw candidate context",
-      method: "candidate context size vs compact handoff size",
-      evidence: rawSources,
-      caveats: ["Token reduction is zero or negative; no savings claim should be shown."],
-      overclaimRisk: "none",
-      needsMoreEvidence: true,
-      nextEvidenceToCollect: "Verify session-context compact handoff is correctly minimized.",
-    });
-  }
-
-  // Both available and positive reduction
-  const combinedConfidence = compactConfidence === "measured" && rawConfidence === "estimated" ? "medium"
-    : compactConfidence === "measured" && rawConfidence === "measured" ? "high"
-    : "low";
-
-  const caveats = [
-    "Raw candidate context is estimated from source file/receipt sizes — not a measured model context window load.",
-    "Token counts use chars/4 heuristic unless session-context provides a measured value.",
-    `Raw context labeled 'candidate': it represents what could have been loaded, not guaranteed user behavior.`,
-  ];
-  if (combinedConfidence === "low") {
-    caveats.push("Low confidence: both raw and compact estimates are heuristic.");
-  }
-
-  return buildValueProof({
-    valueId: "tokenReduction",
-    label: "Token / Context Reduction",
-    dimension: "tokens",
-    value: tokenReduction,
-    unit: "tokens",
-    valueClass: rawConfidence === "estimated" ? "estimated" : "heuristic",
-    confidence: combinedConfidence,
-    basis: `~${rawCandidateTokens.toLocaleString()} candidate tokens → ~${compactHandoffTokens.toLocaleString()} compact tokens`,
-    method: `raw estimate from: ${rawSources.join("; ")}; compact from session-context`,
-    evidence: rawSources,
-    caveats,
-    overclaimRisk: "low",
-    needsMoreEvidence: false,
-    nextEvidenceToCollect: "Local tokenizer integration would replace chars/4 heuristic with a measured value.",
-  });
-}
-
-// ── Cost proof ────────────────────────────────────────────────────────────────
-
-function buildCostProof({ hasLocalPricingSource, costEvidence = null }) {
-  if (!hasLocalPricingSource) {
-    return buildValueProof({
-      valueId: "costAvoided",
-      label: "Cost Avoided",
-      dimension: "cost",
-      value: null,
-      unit: "USD",
-      valueClass: "unavailable",
-      confidence: "unavailable",
-      basis: "No local pricing source available",
-      method: "requires local token pricing data",
-      evidence: [],
-      caveats: [
-        "Cost estimate unavailable: no local pricing source exists.",
-        "Do not derive cost savings from generic internet pricing.",
-        "Run `avorelo pricing --init` to create a local pricing config.",
-        "Token reduction is shown instead.",
-      ],
-      overclaimRisk: "high",
-      needsMoreEvidence: true,
-      nextEvidenceToCollect: "Local pricing config required. Run `avorelo pricing --init`.",
-    });
-  }
-
-  // Pricing source exists but no computed cost evidence
-  if (!costEvidence || costEvidence.valueClass === "unavailable" || costEvidence.costAvoidedEstimate === null) {
-    const caveats = ["Pricing source available but cost estimate could not be computed."];
-    if (costEvidence && costEvidence.caveats) caveats.push(...costEvidence.caveats.slice(0, 2));
-    return buildValueProof({
-      valueId: "costAvoided",
-      label: "Cost Avoided",
-      dimension: "cost",
-      value: null,
-      unit: "USD",
-      valueClass: "unavailable",
-      confidence: "unavailable",
-      basis: costEvidence ? costEvidence.formula || "insufficient token evidence" : "insufficient token evidence",
-      method: "token reduction × per-token price",
-      evidence: [],
-      caveats,
-      overclaimRisk: "medium",
-      needsMoreEvidence: true,
-      nextEvidenceToCollect: "Token evidence required. Run `avorelo token-evidence --json`.",
-    });
-  }
-
-  // Both pricing and token evidence available — produce estimated cost proof
-  const estimate = costEvidence.costAvoidedEstimate;
-  const confidence = costEvidence.confidence || "low";
-  const caveats = (costEvidence.caveats || []).slice(0, 3);
-
-  return buildValueProof({
-    valueId: "costAvoided",
-    label: "Cost Avoided",
-    dimension: "cost",
-    value: estimate,
-    unit: costEvidence.currency || "USD",
-    valueClass: "estimated",
-    confidence,
-    basis: costEvidence.formula || `estimated from avoided tokens × local pricing`,
-    method: "candidate token reduction × local pricing source",
-    evidence: [costEvidence.pricingSource || "local_pricing", "token_evidence"],
-    caveats,
-    overclaimRisk: "medium",
-    needsMoreEvidence: true,
-    nextEvidenceToCollect: "Provider usage API would replace estimated tokens with measured values.",
-  });
-}
-
-// ── Security proofs ───────────────────────────────────────────────────────────
-
-function buildSecurityProofs({
-  risksSurfaced,
-  risksRouted,
-  risksBlocked,
-  approvalsRequired,
-  reducedScopeRecommendations,
-  reviewRequiredItems,
-  highRiskAssetsInRegistry,
-  intakePresent,
-  safePathPresent,
-}) {
-  const proofs = [];
-
-  // Risks surfaced proof
-  if (risksSurfaced > 0) {
-    proofs.push(buildValueProof({
-      valueId: "risksSurfaced",
-      label: "Risks Surfaced",
-      dimension: "security",
-      value: risksSurfaced,
-      unit: "items",
-      valueClass: "measured",
-      confidence: "high",
-      basis: "install-intake receipt: high/critical-risk item counts",
-      method: "direct count from install-intake scan receipt",
-      evidence: ["install-intake"],
-      caveats: ["Surfaced means detected and flagged — not necessarily blocked or mitigated."],
-      overclaimRisk: "none",
-      needsMoreEvidence: false,
-      nextEvidenceToCollect: null,
-    }));
-  }
-
-  // Risks blocked proof (safe-path block decision)
-  if (safePathPresent) {
-    proofs.push(buildValueProof({
-      valueId: "risksBlocked",
-      label: "Risks Blocked",
-      dimension: "security",
-      value: risksBlocked,
-      unit: "actions",
-      valueClass: risksBlocked > 0 ? "measured" : "measured",
-      confidence: "high",
-      basis: "safe-path receipt: block decision count",
-      method: "direct count from safe-path receipt: safePathDecision === 'block'",
-      evidence: ["safe-path"],
-      caveats: risksBlocked === 0 ? ["Safe Path ran but no block decision was made."] : [],
-      overclaimRisk: "none",
-      needsMoreEvidence: false,
-      nextEvidenceToCollect: null,
-    }));
-  }
-
-  // Risks routed proof
-  if (safePathPresent && risksRouted > 0) {
-    proofs.push(buildValueProof({
-      valueId: "risksRouted",
-      label: "Risks Routed via Safe Path",
-      dimension: "security",
-      value: risksRouted,
-      unit: "actions",
-      valueClass: "measured",
-      confidence: "high",
-      basis: "safe-path receipt: approval_required / recommend_reduced_scope / warn_with_boundary decision",
-      method: "direct count from safe-path receipt decision field",
-      evidence: ["safe-path"],
-      caveats: [],
-      overclaimRisk: "none",
-      needsMoreEvidence: false,
-      nextEvidenceToCollect: null,
-    }));
-  }
-
-  // Registry-only high-risk assets (surfaced, not blocked)
-  if (highRiskAssetsInRegistry > 0 && !safePathPresent) {
-    proofs.push(buildValueProof({
-      valueId: "highRiskAssetsFoundInRegistry",
-      label: "High-Risk Assets in Registry",
-      dimension: "security",
-      value: highRiskAssetsInRegistry,
-      unit: "assets",
-      valueClass: "measured",
-      confidence: "medium",
-      basis: "workspace-registry: highRiskAssets count",
-      method: "direct count from workspace-registry summary",
-      evidence: ["workspace-registry"],
-      caveats: [
-        "Registry-detected high-risk assets are surfaced only — Safe Path was not run.",
-        "These assets have NOT been blocked or routed; they require manual review.",
-      ],
-      overclaimRisk: "medium",
-      needsMoreEvidence: true,
-      nextEvidenceToCollect: "Run safe-path to route/block high-risk assets.",
-    }));
-  }
-
-  return proofs;
-}
-
-// ── Clarity / seamlessness proofs ─────────────────────────────────────────────
-
-function buildClarityProofs({ nextActionPresent, doNotRepeatCount, relevantCommandsCount, targetHandoffPrepared, proofAvailable }) {
-  const score = [nextActionPresent, doNotRepeatCount > 0, relevantCommandsCount > 0, targetHandoffPrepared, proofAvailable].filter(Boolean).length;
-  const confidence = score >= 4 ? "medium" : score >= 2 ? "low" : "unavailable";
-
-  return [buildValueProof({
-    valueId: "clarityScore",
-    label: "Clarity Score",
-    dimension: "clarity",
-    value: score,
-    unit: "of 5 checks",
-    valueClass: score >= 3 ? "measured" : "estimated",
-    confidence,
-    basis: `${score}/5 clarity checks passed`,
-    method: "count of: nextAction, doNotRepeat, relevantCommands, handoff, proof",
-    evidence: [nextActionPresent ? "work-control" : null, targetHandoffPrepared ? "session-context" : null].filter(Boolean),
-    caveats: score < 3 ? ["Clarity is partial — not all surfaces are ready."] : [],
-    overclaimRisk: "none",
-    needsMoreEvidence: score < 5,
-    nextEvidenceToCollect: score < 5 ? "Run missing Avorelo surfaces to complete clarity score." : null,
-  })];
-}
-
-// ── Calibration report ────────────────────────────────────────────────────────
-
-function buildCalibrationReport(proofs) {
-  const allProofs = [].concat(...proofs.map((p) => Array.isArray(p) ? p : [p]));
-
-  const measured = allProofs.filter((p) => p.valueClass === "measured" && p.value !== null);
-  const estimated = allProofs.filter((p) => p.valueClass === "estimated" && p.value !== null);
-  const heuristic = allProofs.filter((p) => p.valueClass === "heuristic" && p.value !== null);
-  const unavailable = allProofs.filter((p) => p.valueClass === "unavailable");
-  const highOverclaim = allProofs.filter((p) => p.overclaimRisk === "high" || p.overclaimRisk === "medium");
-
-  // Determine overall verdict
-  let overallVerdict;
-  if (measured.length === 0 && estimated.length === 0 && heuristic.length === 0) {
-    overallVerdict = "insufficient_data";
-  } else if (highOverclaim.length > 0) {
-    overallVerdict = "show_with_caveats";
-  } else if (measured.length > 0 || estimated.length > 0) {
-    overallVerdict = "safe_to_show";
-  } else {
-    overallVerdict = "show_with_caveats";
-  }
-
-  const strongestClaims = [
-    ...measured.map((p) => `${p.label}: ${p.valueClass}, ${p.confidence} confidence`),
-    ...estimated.map((p) => `${p.label}: ${p.valueClass}, ${p.confidence} confidence`),
-  ].slice(0, 5);
-
-  const weakestClaims = [
-    ...heuristic.map((p) => `${p.label}: heuristic — ${p.caveats[0] || "no stopwatch evidence"}`),
-    ...unavailable.map((p) => `${p.label}: unavailable — ${p.basis}`),
-  ].slice(0, 5);
-
-  const overclaimRisks = highOverclaim.map((p) => ({
-    valueId: p.valueId,
-    risk: p.overclaimRisk,
-    reason: p.caveats[0] || "overclaim risk detected",
-  }));
-
-  const recommendedCopySafe = [];
-  if (measured.some((p) => p.valueId === "risksSurfaced")) {
-    recommendedCopySafe.push("\"Risky items surfaced before execution\" (measured from intake receipt)");
-  }
-  if (estimated.some((p) => p.valueId === "tokenReduction") || measured.some((p) => p.valueId === "tokenReduction")) {
-    recommendedCopySafe.push("\"Estimated candidate context avoided\" (with caveat about estimation method)");
-  }
-  if (heuristic.some((p) => p.valueId === "timeSaved")) {
-    recommendedCopySafe.push("\"Estimated N–M minutes saved\" (labeled as heuristic estimate with range)");
-  }
-
-  const blockedCopy = [
-    "\"Guaranteed ROI\" — no measured stopwatch or billing data",
-    "\"$X saved\" — no local pricing source available",
-    "\"N risks blocked\" — only use when safe-path block decision is present",
-    "\"Exact N minutes saved\" — only ranges supported for heuristic estimates",
-  ];
-
-  const nextEvidenceToCollect = [
-    ...new Set(
-      allProofs
-        .filter((p) => p.needsMoreEvidence && p.nextEvidenceToCollect)
-        .map((p) => p.nextEvidenceToCollect)
-    ),
-  ].slice(0, 5);
-
-  return {
-    overallVerdict,
-    measuredCount: measured.length,
-    estimatedCount: estimated.length,
-    heuristicCount: heuristic.length,
-    unavailableCount: unavailable.length,
-    strongestClaims,
-    weakestClaims,
-    overclaimRisks,
-    recommendedCopySafe,
-    blockedCopy,
-    nextEvidenceToCollect,
-  };
-}
-
-// ── Build all proofs from operating value inputs ──────────────────────────────
-
-function buildValueProofs({
-  manualStepsAvoided,
-  minMinutes,
-  maxMinutes,
-  timeSavedEvidence,
-  capApplied,
-  rawCandidateTokens,
-  rawConfidence,
-  rawSources,
-  compactHandoffTokens,
-  compactConfidence,
-  tokenReduction,
-  hasLocalPricingSource,
-  costEvidence,
-  risksSurfaced,
-  risksRouted,
-  risksBlocked,
-  approvalsRequired,
-  reducedScopeRecommendations,
-  reviewRequiredItems,
-  highRiskAssetsInRegistry,
-  intakePresent,
-  safePathPresent,
-  nextActionPresent,
-  doNotRepeatCount,
-  relevantCommandsCount,
-  targetHandoffPrepared,
-  proofAvailable,
-}) {
-  const timeSavedProof = buildTimeSavedProof({ manualStepsAvoided, minMinutes, maxMinutes, evidence: timeSavedEvidence || [], capApplied });
-  const tokenReductionProof = buildTokenReductionProof({ rawCandidateTokens, rawConfidence, rawSources, compactHandoffTokens, compactConfidence, tokenReduction });
-  const costProof = buildCostProof({ hasLocalPricingSource: hasLocalPricingSource || false, costEvidence: costEvidence || null });
-  const securityProofs = buildSecurityProofs({ risksSurfaced, risksRouted, risksBlocked, approvalsRequired, reducedScopeRecommendations, reviewRequiredItems, highRiskAssetsInRegistry, intakePresent, safePathPresent });
-  const clarityProofs = buildClarityProofs({ nextActionPresent, doNotRepeatCount, relevantCommandsCount, targetHandoffPrepared, proofAvailable });
-
-  const allProofs = [timeSavedProof, tokenReductionProof, costProof, ...securityProofs, ...clarityProofs];
-  const calibrationReport = buildCalibrationReport(allProofs);
-
-  return { proofs: allProofs, calibrationReport };
-}
-
-// ── Compact user-facing confidence label ─────────────────────────────────────
-
-function confidenceLabel(valueClass, confidence) {
-  if (valueClass === "unavailable" || confidence === "unavailable") return null;
-  return `${valueClass}, ${confidence} confidence`;
-}
-
-// ── Exports ───────────────────────────────────────────────────────────────────
-
-module.exports = {
-  buildValueProof,
-  buildTimeSavedProof,
-  buildTokenReductionProof,
-  buildCostProof,
-  buildSecurityProofs,
-  buildClarityProofs,
-  buildCalibrationReport,
-  buildValueProofs,
-  confidenceLabel,
-};