avorelo 0.1.0 → 0.2.0

package/scripts/lib/context-reduction-plan.js

@@ -1,178 +0,0 @@
-"use strict";
-
-const { scanRepo, LARGE_FILE_TOKEN_THRESHOLD, LARGE_FOLDER_TOKEN_THRESHOLD } = require("./context-budget-scanner");
-
-const SCHEMA_VERSION = "context-budget-reduction-plan.v1";
-
-const VALID_MODES = ["let_wuz_reduce_context", "block_large_context", "allow_full_context"];
-
-function normalizeMode(raw) {
-  return VALID_MODES.includes(raw) ? raw : "let_wuz_reduce_context";
-}
-
-function recommendForFile(entry, mode) {
-  const { kind, reasonCodes } = entry;
-
-  if (reasonCodes.includes("sensitive_context")) return "approval_required";
-  if (kind === "binary" || reasonCodes.includes("binary_or_unknown")) return "skip";
-  if (kind === "lockfile" || reasonCodes.includes("lockfile")) return "skip";
-  if (kind === "log" || reasonCodes.includes("log_file")) return "skip";
-  if (kind === "too_large" || reasonCodes.includes("too_large_to_read")) return "skip";
-
-  if (mode === "allow_full_context") return "read";
-
-  if (reasonCodes.includes("large_file")) return "summarize";
-
-  return "read";
-}
-
-function generateReductionPlan(cwd, config = {}) {
-  const mode = normalizeMode(config.mode);
-  const profile = config.profile || "balanced";
-  const recommendedLimitTokens = Number.isFinite(Number(config.recommendedLimitTokens))
-    ? Math.max(1000, Number(config.recommendedLimitTokens)) : 32000;
-
-  const scanConfig = {
-    maxFilesScanned: config.maxFilesScanned,
-    maxFileBytes: config.maxFileBytes,
-    maxDepth: config.maxDepth,
-  };
-
-  const scanResult = scanRepo(cwd, scanConfig);
-
-  const approvalRequired = [];
-  const excludedOrReduced = [];
-  const recommendedContext = [];
-  const hotspots = [];
-
-  let estimatedTotalTokens = 0;
-  let estimatedReductionTokens = 0;
-
-  for (const entry of scanResult.fileEntries) {
-    estimatedTotalTokens += entry.estimatedTokens;
-    const recommendation = recommendForFile(entry, mode);
-
-    const planEntry = {
-      path: entry.path,
-      estimatedTokens: entry.estimatedTokens,
-      recommendation,
-      reasonCodes: entry.reasonCodes,
-    };
-
-    if (recommendation === "approval_required") {
-      approvalRequired.push(planEntry);
-      estimatedReductionTokens += entry.estimatedTokens;
-    } else if (recommendation === "skip" || recommendation === "ignore_generated") {
-      excludedOrReduced.push(planEntry);
-      estimatedReductionTokens += entry.estimatedTokens;
-    } else if (recommendation === "summarize") {
-      excludedOrReduced.push(planEntry);
-      estimatedReductionTokens += Math.floor(entry.estimatedTokens * 0.8);
-    } else {
-      recommendedContext.push(planEntry);
-    }
-
-    if (entry.estimatedTokens >= LARGE_FILE_TOKEN_THRESHOLD) {
-      hotspots.push({
-        path: entry.path,
-        type: "file",
-        estimatedTokens: entry.estimatedTokens,
-        reasonCodes: entry.reasonCodes,
-        recommendation,
-      });
-    }
-  }
-
-  for (const dir of scanResult.skippedDirs) {
-    excludedOrReduced.push({
-      path: dir.path,
-      estimatedTokens: 0,
-      recommendation: dir.recommendation,
-      reasonCodes: dir.reasonCodes,
-    });
-  }
-
-  for (const folder of scanResult.largeFolders) {
-    hotspots.push({
-      path: folder.path,
-      type: "folder",
-      estimatedTokens: folder.estimatedTokens,
-      reasonCodes: ["large_folder"],
-      recommendation: "summarize",
-    });
-  }
-
-  hotspots.sort((a, b) => b.estimatedTokens - a.estimatedTokens);
-
-  const overBudget = estimatedTotalTokens > recommendedLimitTokens;
-  const estimatedReductionPercent = estimatedTotalTokens > 0
-    ? Math.round((estimatedReductionTokens / estimatedTotalTokens) * 100)
-    : 0;
-
-  const overBudgetCodes = [];
-  if (overBudget) overBudgetCodes.push("context_over_budget");
-
-  const safeBecause = buildSafeBecause(scanResult, excludedOrReduced, recommendedContext, approvalRequired);
-
-  let nextBestAction = "No context reduction needed — estimated context is within budget";
-  if (overBudget && mode === "let_wuz_reduce_context") {
-    nextBestAction = "Let Wuz reduce context before the next agent run";
-  } else if (overBudget && mode === "block_large_context") {
-    nextBestAction = "Context exceeds budget — agent run is blocked until context is reduced";
-  } else if (overBudget) {
-    nextBestAction = "Context exceeds budget — consider applying the reduction plan";
-  }
-
-  return {
-    schemaVersion: SCHEMA_VERSION,
-    cwd,
-    generatedAt: new Date().toISOString(),
-    mode,
-    profile,
-    budget: {
-      estimatedTotalTokens,
-      recommendedLimitTokens,
-      overBudget,
-      estimatedReductionTokens,
-      estimatedReductionPercent,
-      scannedFiles: scanResult.scannedFiles,
-      skippedFiles: scanResult.skippedFiles,
-      overBudgetReasonCodes: overBudgetCodes,
-    },
-    hotspots: hotspots.slice(0, 20),
-    recommendedContext: recommendedContext.sort((a, b) => b.estimatedTokens - a.estimatedTokens).slice(0, 100),
-    excludedOrReduced: excludedOrReduced.slice(0, 100),
-    approvalRequired,
-    proof: { safeBecause },
-    nextBestAction,
-  };
-}
-
-function buildSafeBecause(scanResult, excludedOrReduced, recommendedContext, approvalRequired) {
-  const reasons = [];
-
-  const hasSkippedDeps = scanResult.skippedDirs.some((d) => d.reasonCodes.includes("dependency_folder"));
-  const hasSkippedGenerated = scanResult.skippedDirs.some((d) => d.reasonCodes.includes("generated_or_build_artifact"));
-  const hasSummarized = excludedOrReduced.some((e) => e.recommendation === "summarize");
-  const hasSkippedBinary = excludedOrReduced.some((e) => e.reasonCodes.includes("binary_or_unknown"));
-  const hasApprovalRequired = approvalRequired.length > 0;
-  const hasSmallSourceFiles = recommendedContext.some(
-    (e) => e.reasonCodes.some((c) => ["source_file", "config_file", "documentation_file"].includes(c))
-  );
-
-  if (hasSkippedDeps) reasons.push("Dependency and vendor folders were excluded");
-  if (hasSkippedGenerated) reasons.push("Generated and build artifact folders were excluded");
-  if (hasSummarized) reasons.push("Large source files were converted to summarize recommendations");
-  if (hasSkippedBinary) reasons.push("Binary and media files were excluded");
-  if (hasSmallSourceFiles) reasons.push("Small source, config, and documentation files were prioritized for full read");
-  if (hasApprovalRequired) reasons.push("Sensitive-looking files require approval before use");
-  if (reasons.length === 0) reasons.push("Scan completed — no significant context pressure detected");
-
-  return reasons;
-}
-
-module.exports = {
-  generateReductionPlan,
-  normalizeMode,
-  SCHEMA_VERSION,
-};

package/scripts/lib/context-safety.js

@@ -1,88 +0,0 @@
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const { redactSensitive } = require("./reentry-memory-capture");
-
-const SECRET_BASENAMES = new Set([
-  ".env", ".env.local", ".env.production", ".env.staging", ".env.development",
-  ".env.server", ".env.client", ".env.test",
-  "id_rsa", "id_ed25519", "id_ecdsa", "id_dsa",
-  "credentials", "credentials.json", "service-account.json",
-  ".netrc", ".pgpass",
-]);
-
-const SECRET_EXTENSIONS = new Set([
-  ".pem", ".key", ".p12", ".pfx", ".cer", ".crt", ".der",
-  ".gpg", ".asc",
-]);
-
-const SECRET_PATH_FRAGMENTS = [
-  /[/\\]\.aws[/\\]/,
-  /[/\\]\.ssh[/\\]/,
-  /[/\\]\.gnupg[/\\]/,
-  /[/\\]\.config[/\\]gcloud[/\\]/,
-  /[/\\]\.kube[/\\]/,
-  /[/\\]secrets[/\\]/,
-];
-
-function isSecretLikePath(filePath) {
-  if (!filePath || typeof filePath !== "string") return false;
-  const base = path.basename(filePath).toLowerCase();
-  const ext = path.extname(filePath).toLowerCase();
-
-  if (SECRET_BASENAMES.has(base)) return true;
-  if (SECRET_EXTENSIONS.has(ext)) return true;
-  if (/^\.env(\..+)?$/.test(base)) return true;
-
-  const normalized = filePath.replace(/\\/g, "/");
-  return SECRET_PATH_FRAGMENTS.some((re) => re.test(normalized));
-}
-
-function isPathSafe(filePath, rootDir) {
-  if (!filePath || !rootDir) return false;
-  const resolved = path.resolve(rootDir, filePath);
-  const root = path.resolve(rootDir);
-  return resolved.startsWith(root + path.sep) || resolved === root;
-}
-
-function scrubSensitiveValues(text) {
-  return redactSensitive(text);
-}
-
-function detectCce(cwd) {
-  try {
-    if (fs.existsSync(path.join(cwd, ".context-engine.yaml"))) return true;
-    if (fs.existsSync(path.join(cwd, ".cce"))) return true;
-    const mcpPath = path.join(cwd, ".mcp.json");
-    if (fs.existsSync(mcpPath)) {
-      try {
-        const mcp = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
-        const servers = mcp.mcpServers || mcp.servers || {};
-        if (Object.keys(servers).some((k) => k.toLowerCase().includes("context-engine") || k.toLowerCase().includes("cce"))) {
-          return true;
-        }
-      } catch {}
-    }
-  } catch {}
-  return false;
-}
-
-function buildContextSafetyStatus(cwd) {
-  const cceDetected = detectCce(cwd);
-  return {
-    cceDetected,
-    statusLine: cceDetected
-      ? "Context provider: external CCE detected — Wuz is operating alongside it"
-      : null,
-    showInStatus: cceDetected,
-  };
-}
-
-module.exports = {
-  isSecretLikePath,
-  isPathSafe,
-  scrubSensitiveValues,
-  detectCce,
-  buildContextSafetyStatus,
-};

package/scripts/lib/context-savings-engine.js

@@ -1,158 +0,0 @@
-"use strict";
-
-// Context savings engine — thin helpers wired to real PRE_CONTEXT control points.
-// Only emits savings events when Wuz actually intercepts output before agent/user sees it.
-
-const crypto = require("crypto");
-const { summarizeLargeObject } = require("./tokenish");
-
-const BYTES_PER_TOKEN = 4;
-const DEFAULT_MAX_REENTRY_TOKENS = 800;
-const DEFAULT_MAX_EVIDENCE_ITEMS = 20;
-
-function bytesToTokens(bytes) {
-  return Math.round(bytes / BYTES_PER_TOKEN);
-}
-
-// Intercept large tool output — real PRE_CONTEXT for MCP tools, advisory for built-ins.
-// ledger is a ValueLedger instance or null (caller provides; engine does not instantiate).
-// Returns { summary, ledgerEvent } where summary is from tokenish or null.
-function summarizeLargeOutput(obj, ledger, opts = {}) {
-  const summary = summarizeLargeObject(obj);
-  if (!summary || !summary.isLarge) {
-    return { summary: null, ledgerEvent: null };
-  }
-
-  const savedBytes = summary.bytes - Buffer.byteLength(summary.preview || "", "utf8");
-  const savedTokens = bytesToTokens(Math.max(0, savedBytes));
-
-  let ledgerEvent = null;
-  if (ledger) {
-    ledgerEvent = ledger.append({
-      bucket: "large_output_referenced",
-      sessionId: opts.sessionId || null,
-      label: `Large output intercepted: ${summary.bytes} bytes → preview`,
-      savedBytes: Math.max(0, savedBytes),
-      savedTokens,
-      notes: opts.toolName ? `tool=${opts.toolName}` : "large output stored out-of-band",
-      artifactRef: opts.artifactRef || null,
-    });
-  }
-
-  return { summary, ledgerEvent };
-}
-
-// Check if content was recently emitted (deduplication guard).
-// recentHashes is a Set<string> maintained by the caller across tool calls in a session.
-// Pure function — no ledger side effect.
-function suppressDuplicateContext(text, recentHashes) {
-  if (!text || typeof text !== "string") return { suppressed: false, hash: null };
-  const sample = text.slice(0, 500);
-  const hash = crypto.createHash("sha1").update(sample).digest("hex");
-  if (recentHashes && recentHashes.has(hash)) {
-    return { suppressed: true, hash };
-  }
-  if (recentHashes) recentHashes.add(hash);
-  return { suppressed: false, hash };
-}
-
-// Bound reentry memory candidates to a token budget before session-start injection.
-// This is real PRE_CONTEXT — we control what gets included in the hook output.
-// ledger is a ValueLedger instance or null.
-// Returns { selected, droppedCount, savedTokens }.
-function selectCompactReentryContext(candidates, maxTokens, ledger, opts = {}) {
-  const limit = Number.isFinite(maxTokens) && maxTokens > 0 ? maxTokens : DEFAULT_MAX_REENTRY_TOKENS;
-  const all = Array.isArray(candidates) ? candidates : [];
-
-  if (all.length === 0) {
-    return { selected: [], droppedCount: 0, savedTokens: 0 };
-  }
-
-  const selected = [];
-  let accumulated = 0;
-  let droppedTokens = 0;
-  let droppedCount = 0;
-
-  for (const c of all) {
-    const tokens = Number.isFinite(c.estimatedTokens) ? c.estimatedTokens : 0;
-    if (accumulated + tokens <= limit) {
-      selected.push(c);
-      accumulated += tokens;
-    } else {
-      droppedCount++;
-      droppedTokens += tokens;
-    }
-  }
-
-  if (ledger) {
-    if (selected.length > 0) {
-      // Structural bounding event: candidates within budget were selected.
-      // savedTokens=0 because candidates are in hook JSON metadata only;
-      // they are not injected as additionalContext yet.
-      ledger.append({
-        bucket: "reentry_reused",
-        sessionId: opts.sessionId || null,
-        label: `${selected.length} reentry candidates selected (within token budget)`,
-        savedBytes: 0,
-        savedTokens: 0,
-        notes: `selected=${selected.length}, ~${accumulated} tokens, structural-bounding-only`,
-      });
-    }
-    if (droppedCount > 0) {
-      // Structural bounding event: excess candidates were dropped from hook output.
-      // savedTokens=0 because these candidates were not being injected anyway;
-      // bounding the hook JSON does not prevent token injection to Claude.
-      ledger.append({
-        bucket: "context_avoided",
-        sessionId: opts.sessionId || null,
-        label: `${droppedCount} reentry candidates dropped from hook output (over token limit)`,
-        savedBytes: 0,
-        savedTokens: 0,
-        notes: `limit=${limit}, dropped=${droppedCount}, structural-bounding-only`,
-      });
-    }
-  }
-
-  return { selected, droppedCount, savedTokens: droppedTokens };
-}
-
-// Trim evidence list to maxItems — pure, no ledger side effect.
-// Returns { items, droppedCount }.
-function compactEvidenceList(items, maxItems) {
-  const max = Number.isFinite(maxItems) && maxItems > 0 ? maxItems : DEFAULT_MAX_EVIDENCE_ITEMS;
-  const all = Array.isArray(items) ? items : [];
-  if (all.length <= max) return { items: all, droppedCount: 0 };
-  return { items: all.slice(0, max), droppedCount: all.length - max };
-}
-
-// Aggregate ledger events into a savings estimate.
-// Pure — no I/O, no throws.
-function safeEstimateSavings(events) {
-  if (!Array.isArray(events)) return { totalSavedBytes: 0, totalSavedTokens: 0, byBucket: {} };
-  let totalSavedBytes = 0;
-  let totalSavedTokens = 0;
-  const byBucket = {};
-  for (const e of events) {
-    if (!e || !e.bucket) continue;
-    if (!byBucket[e.bucket]) byBucket[e.bucket] = { count: 0, savedBytes: 0, savedTokens: 0 };
-    const eb = Number.isFinite(e.savedBytes) ? e.savedBytes : 0;
-    const et = Number.isFinite(e.savedTokens) ? e.savedTokens : 0;
-    byBucket[e.bucket].count++;
-    byBucket[e.bucket].savedBytes += eb;
-    byBucket[e.bucket].savedTokens += et;
-    totalSavedBytes += eb;
-    totalSavedTokens += et;
-  }
-  return { totalSavedBytes, totalSavedTokens, byBucket };
-}
-
-module.exports = {
-  summarizeLargeOutput,
-  suppressDuplicateContext,
-  selectCompactReentryContext,
-  compactEvidenceList,
-  safeEstimateSavings,
-  bytesToTokens,
-  DEFAULT_MAX_REENTRY_TOKENS,
-  DEFAULT_MAX_EVIDENCE_ITEMS,
-};

package/scripts/lib/cost-evidence.js

@@ -1,254 +0,0 @@
-"use strict";
-
-// Canonical cost-aware preference layer for active/near-active CJS surfaces.
-// Safe rule:
-// - Use cost-specific totals for cost displays/comparisons.
-// - Fall back to measured import summaries only for measured cost/token display.
-// - Never substitute legacy mixed-unit totals for currency comparisons.
-
-function numberOrZero(value) {
-  const number = Number(value);
-  return Number.isFinite(number) ? number : 0;
-}
-
-function numberOrNull(value) {
-  const number = Number(value);
-  return Number.isFinite(number) ? number : null;
-}
-
-function buildCostEvidenceSummary(params = {}) {
-  const aggregation = params.aggregation || {};
-  const weekly = aggregation.weeklyRepoSummary || {};
-  const measuredUsage = params.measuredUsage || null;
-
-  const aggregatedMeasuredCost = numberOrZero(weekly.measuredCostTotal);
-  const aggregatedCounterfactualCost = numberOrZero(weekly.estimatedCostCounterfactualTotal);
-  const aggregatedTokenUsage = numberOrZero(weekly.tokenUsageTotal);
-
-  const importedMeasuredCost = numberOrZero(measuredUsage?.totalCost);
-  const importedTokenUsage = numberOrZero(measuredUsage?.totalTokens);
-
-  const preferredMeasuredCost = aggregatedMeasuredCost > 0 ? aggregatedMeasuredCost : importedMeasuredCost;
-  const preferredEstimatedCostCounterfactual = aggregatedCounterfactualCost > 0 ? aggregatedCounterfactualCost : null;
-  const preferredTokenUsage = aggregatedTokenUsage > 0 ? aggregatedTokenUsage : importedTokenUsage;
-
-  const comparisonAvailable = preferredMeasuredCost > 0 && preferredEstimatedCostCounterfactual !== null;
-  const source = preferredMeasuredCost > 0 ? "measured" : "unavailable";
-  const basis = comparisonAvailable ? "cost-aware" : preferredMeasuredCost > 0 ? "measured-only" : "unavailable";
-
-  return {
-    measuredCostTotal: aggregatedMeasuredCost,
-    estimatedCostCounterfactualTotal: aggregatedCounterfactualCost,
-    tokenUsageTotal: aggregatedTokenUsage,
-    preferredMeasuredCost,
-    preferredEstimatedCostCounterfactual,
-    preferredTokenUsage,
-    source,
-    basis,
-    comparisonAvailable,
-    fallback:
-      aggregatedMeasuredCost <= 0 && importedMeasuredCost > 0
-        ? "usage-import-summary"
-        : "outcome-aggregation",
-  };
-}
-
-function buildImportedVsInternalDelta(params = {}) {
-  const summary = buildCostEvidenceSummary(params);
-  if (!summary.comparisonAvailable) return null;
-
-  const delta = Math.round((summary.preferredMeasuredCost - summary.preferredEstimatedCostCounterfactual) * 100) / 100;
-  return {
-    measuredCost: summary.preferredMeasuredCost,
-    internalCounterfactual: summary.preferredEstimatedCostCounterfactual,
-    delta,
-    unit: "currency",
-    basis: summary.basis,
-  };
-}
-
-// ── Cost Evidence v1 (avorelo.costEvidence.v1) ────────────────────────────────
-//
-// Builds a structured cost evidence object from local pricing + token evidence.
-// Rules:
-//   - No pricing source → all cost fields null
-//   - Token estimate only → confidence cannot be high
-//   - websiteAllowed / pricingAllowed always false for one-off estimated values
-//   - Never show $0 saved unless truly measured zero
-//   - No network fetch. No billing/account integration.
-
-const crypto = require("crypto");
-
-function shortId() {
-  return crypto.randomBytes(4).toString("hex");
-}
-
-function nowIso() {
-  return new Date().toISOString();
-}
-
-function buildCostEvidenceV1(params = {}) {
-  const {
-    pricingSource = null,
-    pricingEntry = null,
-    tokenEvidence = null,
-    provider = null,
-    model = null,
-  } = params;
-
-  const costEvidenceId = `ce-${Date.now()}-${shortId()}`;
-  const createdAt = nowIso();
-  const currency = (pricingEntry && pricingEntry.currency) || "USD";
-
-  const hasPricing = pricingSource && pricingSource.available && pricingEntry !== null;
-  const hasTokens = tokenEvidence && tokenEvidence.measurements &&
-    tokenEvidence.measurements.candidateTokenReduction !== null;
-
-  if (!hasPricing) {
-    return {
-      schemaVersion: 1,
-      contract: "avorelo.costEvidence.v1",
-      costEvidenceId,
-      createdAt,
-      pricingSource: pricingSource ? pricingSource.source : "unavailable",
-      usageSource: "unavailable",
-      provider,
-      model,
-      currency,
-      tokenInputs: null,
-      costEstimate: null,
-      costAvoidedEstimate: null,
-      formula: null,
-      confidence: "unavailable",
-      valueClass: "unavailable",
-      caveats: [
-        "Cost estimate unavailable: no local pricing source found.",
-        "Run `avorelo pricing --init` to create a local pricing config.",
-        "Token reduction is available without a pricing source.",
-      ],
-      pricingAllowed: false,
-      dashboardAllowed: false,
-      websiteAllowed: false,
-      redacted: true,
-    };
-  }
-
-  if (!hasTokens) {
-    return {
-      schemaVersion: 1,
-      contract: "avorelo.costEvidence.v1",
-      costEvidenceId,
-      createdAt,
-      pricingSource: pricingSource.source,
-      usageSource: "unavailable",
-      provider: pricingEntry.provider,
-      model: pricingEntry.model,
-      currency,
-      tokenInputs: null,
-      costEstimate: null,
-      costAvoidedEstimate: null,
-      formula: null,
-      confidence: "unavailable",
-      valueClass: "unavailable",
-      caveats: [
-        "Pricing source available but token evidence insufficient for cost estimate.",
-        "Run `avorelo token-evidence --json` to generate token evidence.",
-      ],
-      pricingAllowed: false,
-      dashboardAllowed: false,
-      websiteAllowed: false,
-      redacted: true,
-    };
-  }
-
-  const m = tokenEvidence.measurements;
-  const avoidedTokens = m.candidateTokenReduction;
-
-  // Cost calculation: avoided tokens × input token price (per 1M)
-  // Candidate context avoided = input tokens not sent
-  const pricePerMillion = numberOrNull(pricingEntry.inputTokenPrice);
-  if (pricePerMillion === null || avoidedTokens === null) {
-    return {
-      schemaVersion: 1,
-      contract: "avorelo.costEvidence.v1",
-      costEvidenceId,
-      createdAt,
-      pricingSource: pricingSource.source,
-      usageSource: "token_evidence",
-      provider: pricingEntry.provider,
-      model: pricingEntry.model,
-      currency,
-      tokenInputs: { avoidedCandidateTokens: avoidedTokens },
-      costEstimate: null,
-      costAvoidedEstimate: null,
-      formula: "candidate_token_reduction × input_price_per_1m_tokens",
-      confidence: "unavailable",
-      valueClass: "unavailable",
-      caveats: ["Could not compute cost: missing price or token count."],
-      pricingAllowed: false,
-      dashboardAllowed: false,
-      websiteAllowed: false,
-      redacted: true,
-    };
-  }
-
-  const costAvoidedEstimate = Math.round((avoidedTokens / 1_000_000) * pricePerMillion * 10000) / 10000;
-
-  // Confidence: depends on token method and pricing source
-  // provider_usage + local pricing → medium
-  // local_tokenizer + local pricing → medium
-  // chars_div_4 + local pricing → low (unchanged)
-  const pricingConfidence = pricingSource.confidence || "low";
-  const tokenMethod = tokenEvidence.tokenizer ? (tokenEvidence.tokenizer.method || "chars_div_4") : "chars_div_4";
-  const tokenConfidence = tokenEvidence.tokenizer ? (tokenEvidence.tokenizer.confidence || "low") : "low";
-  const tokenIsStrongerThanCharsDiv4 = tokenMethod === "provider_usage" || tokenMethod === "local_tokenizer";
-  // If token evidence is stronger than chars_div_4, cost confidence can be medium even with default_local pricing
-  const overallConfidence = tokenIsStrongerThanCharsDiv4
-    ? "medium"
-    : (pricingConfidence === "low" || tokenConfidence === "low" ? "low" : "medium");
-
-  const caveats = [
-    `Pricing source: ${pricingSource.caveat || pricingSource.source}`,
-    `Token method: ${tokenEvidence.tokenizer.method} — candidate context is estimated, not a measured model load.`,
-    "Cost estimate is based on avoided candidate context tokens, not actual API spend.",
-    "Do not use for billing reconciliation or exact cost claims.",
-    pricingEntry.caveat || null,
-  ].filter(Boolean);
-
-  return {
-    schemaVersion: 1,
-    contract: "avorelo.costEvidence.v1",
-    costEvidenceId,
-    createdAt,
-    pricingSource: pricingSource.source,
-    usageSource: "token_evidence",
-    provider: pricingEntry.provider,
-    model: pricingEntry.model,
-    currency,
-    tokenInputs: {
-      inputTokens: m.inputTokens,
-      cachedInputTokens: m.cachedInputTokens,
-      outputTokens: m.outputTokens,
-      cacheWriteTokens: m.cacheWriteTokens,
-      cacheReadTokens: m.cacheReadTokens,
-      avoidedCandidateTokens: avoidedTokens,
-    },
-    costEstimate: null, // actual session cost not measurable without provider_usage
-    costAvoidedEstimate,
-    formula: `${avoidedTokens.toLocaleString()} avoided tokens ÷ 1,000,000 × $${pricePerMillion}/M input tokens`,
-    confidence: overallConfidence,
-    valueClass: "estimated",
-    caveats,
-    pricingAllowed: false,
-    dashboardAllowed: true,
-    websiteAllowed: false,
-    redacted: true,
-  };
-}
-
-module.exports = {
-  buildCostEvidenceSummary,
-  buildImportedVsInternalDelta,
-  buildCostEvidenceV1,
-  numberOrNull,
-};