ziprin-context-optimizer 8.0.0

package/src/adaptive-budget.js

@@ -0,0 +1,46 @@
+'use strict';
+
+/**
+ * Adaptive Token Budget Manager (v6 levels).
+ */
+
+const BUDGETS = {
+  simple_ui_fix: 5000,
+  backend_bug: 30000,
+  architecture_review: 100000,
+  mixed: 20000,
+};
+
+const LEVELS = {
+  simple_question: 3000,
+  bug_fix: 15000,
+  feature_development: 35000,
+  architecture_review: 100000,
+};
+
+function complexityToLevel(complexity, intent) {
+  if (complexity === 'architecture_review' || intent?.action === 'architecture') {
+    return 'architecture_review';
+  }
+  if (complexity === 'backend_bug' || intent?.action === 'fix') {
+    return 'bug_fix';
+  }
+  if (intent?.action === 'implement' || intent?.action === 'refactor' || intent?.action === 'migrate') {
+    return 'feature_development';
+  }
+  if (complexity === 'simple_ui_fix' || intent?.action === 'review') {
+    return 'simple_question';
+  }
+  return 'feature_development';
+}
+
+function budgetForComplexity(complexity, profileCap, intent) {
+  const level = complexityToLevel(complexity, intent);
+  const levelBase = LEVELS[level] || BUDGETS[complexity] || BUDGETS.mixed;
+  const legacyBase = BUDGETS[complexity] || BUDGETS.mixed;
+  const base = Math.max(levelBase, legacyBase);
+  if (!profileCap) return base;
+  return Math.max(3000, Math.min(base, profileCap));
+}
+
+module.exports = { BUDGETS, LEVELS, budgetForComplexity, complexityToLevel };

package/src/analyzer.js

@@ -0,0 +1,456 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { tokens } = require('./estimate');
+const { estimateContext } = require('./estimate');
+const { getContextProfile, budgetFor } = require('./context-profiles');
+const { collectWorkspace } = require('./collector');
+const { analyzeTask } = require('./task-analyzer');
+const { scoreCandidates, explainRemoval } = require('./relevance-scorer');
+const { getOrBuildRepoMap, symbolPathsFromMap } = require('./repo-map');
+const { buildDependencyBoost, protectDependencies } = require('./dependency-graph');
+const { compressFile } = require('./compression');
+const { budgetForComplexity } = require('./adaptive-budget');
+const { qualityCheck, applyQualityActions } = require('./quality-guard');
+const { loadMemory, effectivePathBoost, cooccurBoost } = require('./context-memory');
+const { firewallDecision } = require('./firewall');
+const { routeTask } = require('./tool-router');
+const { retrieveCandidates } = require('./retrieve');
+const { packSlice } = require('./slice-pack');
+const { emitForTask } = require('./serena');
+const { skeletonFile } = require('./skeleton');
+const { loadLedger, splitFresh, remember } = require('./session-ledger');
+const { VERSION } = require('./version');
+
+const MAX_CONTEXT_FILES = 8;
+
+function alwaysApplyTokens(root) {
+  try {
+    const est = estimateContext(root);
+    const agents = est.groups['cursor/agents']?.tokens || 0;
+    const skills = est.groups['cursor/skills']?.tokens || 0;
+    const rules = est.groups['cursor/rules']?.tokens || 0;
+    const catalogs = est.groups.catalogs?.tokens || 0;
+    return agents + skills + rules + catalogs;
+  } catch {
+    return 0;
+  }
+}
+
+function buildSnapshot(root, opts = {}) {
+  const dumpBodies = opts.dumpBodies === true;
+  const preferredProfile = opts.profileId || 'standard';
+  const prompt = String(opts.prompt || '').trim();
+  const task = String(opts.task || prompt || '').trim() || '(no prompt yet)';
+  const cpt = opts.charsPerToken || 4;
+  const sessionKey = opts.sessionId || opts.sessionKey || 'default';
+  const openFiles = opts.openFiles || [];
+
+  const memory = loadMemory(root);
+  const taskInfo = analyzeTask(task, preferredProfile, memory);
+  const profileId = opts.lockProfile ? preferredProfile : taskInfo.profileId;
+  const ctxProfile = getContextProfile(profileId);
+  const profileCap = budgetFor(profileId).maxOnDemandTokens;
+  const budget = budgetForComplexity(taskInfo.complexity, profileCap, taskInfo.intent);
+
+  const retrieved = retrieveCandidates(root, {
+    tokens: taskInfo.language?.originalTokens || taskInfo.tokens,
+    expanded: taskInfo.tokens,
+    symbols: taskInfo.symbols,
+    pathHints: taskInfo.pathHints,
+    domain: taskInfo.domain,
+  }, { openFiles });
+
+  const collected = collectWorkspace(root, profileId, cpt, {
+    domain: taskInfo.domain,
+    symbols: taskInfo.symbols || [],
+    pathHints: taskInfo.pathHints || [],
+  });
+
+  const byPath = new Map(collected.files.map((f) => [f.path, f]));
+  function ensureFile(rel) {
+    if (byPath.has(rel)) return;
+    const abs = path.join(root, rel);
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) return;
+    const bytes = fs.statSync(abs).size;
+    const rec = { path: rel, bytes, tokens: tokens(bytes, cpt), seeded: true };
+    collected.files.unshift(rec);
+    byPath.set(rel, rec);
+  }
+  for (const item of retrieved.fused) ensureFile(item.path);
+  for (const p of retrieved.dirty) ensureFile(p);
+  for (const p of openFiles) ensureFile(p);
+
+  const repoMap = getOrBuildRepoMap(root, collected.symbolFiles || []);
+  for (const sym of taskInfo.symbols || []) {
+    for (const p of symbolPathsFromMap(repoMap, sym)) ensureFile(p);
+  }
+
+  const route = routeTask(task);
+  const pathBoost = effectivePathBoost(memory);
+
+  const firewalled = [];
+  const survivors = [];
+  for (const f of collected.files) {
+    const d = firewallDecision(f.path, f.bytes);
+    if (d.action === 'block') {
+      firewalled.push({ file: f.path, reason: d.reason, tokenSaving: f.tokens, action: 'block' });
+    } else {
+      survivors.push({ ...f, firewall: d });
+    }
+  }
+  for (const ig of collected.ignored) {
+    firewalled.push({ ...ig, action: 'block' });
+  }
+
+  const tokensBefore =
+    survivors.reduce((n, f) => n + f.tokens, 0) +
+    firewalled.reduce((n, f) => n + (f.tokenSaving || 0), 0);
+
+  const scorerOpts = {
+    taskTokens: taskInfo.tokens,
+    category: taskInfo.category,
+    memoryBoost: pathBoost,
+    domain: taskInfo.domain,
+    symbols: taskInfo.symbols || [],
+    pathHints: taskInfo.pathHints || [],
+    action: taskInfo.intent?.action,
+    prompt: task,
+  };
+
+  let scored = scoreCandidates(survivors, scorerOpts);
+  if (memory.negativeBoost) {
+    scored = scored.map((s) => {
+      const n = memory.negativeBoost[s.path] || 0;
+      if (!n) return s;
+      return { ...s, final_score: s.final_score - n, keep: s.final_score - n >= 15 };
+    }).sort((a, b) => b.final_score - a.final_score);
+  }
+
+  const topSeeds = scored.filter((s) => s.final_score > 20).slice(0, 25).map((s) => s.path);
+  const { boost, edges } = buildDependencyBoost(root, topSeeds, 40);
+  scored = scoreCandidates(survivors, { ...scorerOpts, dependencyBoost: boost });
+
+  const rrfBoost = new Map(retrieved.fused.map((x, i) => [x.path, 40 - i]));
+  scored = scored.map((s) => {
+    const extra = rrfBoost.get(s.path) || 0;
+    const dirty = retrieved.dirty.includes(s.path) ? 25 : 0;
+    const open = openFiles.includes(s.path) ? 30 : 0;
+    const co = cooccurBoost(memory, s.path, topSeeds.slice(0, 6));
+    const final_score = s.final_score + extra + dirty + open + co;
+    return { ...s, final_score, keep: final_score >= 15 };
+  }).sort((a, b) => b.final_score - a.final_score);
+
+  const slice = packSlice(
+    scored.filter((s) => s.keep).map((s) => s.path),
+    survivors.map((f) => f.path),
+    { maxFiles: MAX_CONTEXT_FILES }
+  );
+  const sliceSet = new Set(slice);
+
+  const selected = [];
+  const removedItems = [...firewalled];
+  let used = 0;
+  const prefer = [
+    ...slice,
+    ...scored.map((s) => s.path).filter((p) => !sliceSet.has(p)),
+  ];
+  const seenSel = new Set();
+  for (const p of prefer) {
+    if (seenSel.has(p)) continue;
+    const s = scored.find((x) => x.path === p);
+    const file = survivors.find((f) => f.path === p);
+    if (!file) continue;
+    seenSel.add(p);
+    const fw = file.firewall || firewallDecision(file.path, file.bytes);
+    const cost = fw.action === 'summarize' ? Math.min(file.tokens, 500) : file.tokens;
+    const inSlice = sliceSet.has(p);
+    if (!inSlice && s && !s.keep && s.final_score < 15) {
+      removedItems.push({
+        file: s.path,
+        reason: explainRemoval(s.breakdown, s.final_score, `low relevance (score ${s.final_score})`),
+        tokenSaving: file.tokens,
+        action: 'prune',
+        score: s.final_score,
+      });
+      continue;
+    }
+    if (used + cost > budget && selected.length >= 3 && !inSlice) {
+      removedItems.push({
+        file: file.path,
+        reason: 'exceeded adaptive token budget',
+        tokenSaving: file.tokens,
+        action: 'budget',
+        score: s?.final_score,
+      });
+      continue;
+    }
+    if (selected.length >= MAX_CONTEXT_FILES && !inSlice) {
+      removedItems.push({
+        file: file.path,
+        reason: 'cap: max context files',
+        tokenSaving: file.tokens,
+        action: 'cap',
+        score: s?.final_score,
+      });
+      continue;
+    }
+    selected.push({ path: file.path, tokens: cost, score: s?.final_score || 0, compress: fw.action === 'summarize' });
+    used += cost;
+  }
+
+  const protectedSet = protectDependencies(
+    selected.map((s) => s.path),
+    boost,
+    scored
+  );
+  let selectedPaths = protectedSet.selected;
+
+  const quality = qualityCheck({
+    taskTokens: taskInfo.tokens,
+    selected: selectedPaths,
+    restored: protectedSet.restored,
+    scores: scored,
+    budget,
+    usedTokens: used,
+    symbols: taskInfo.symbols || [],
+    pathHints: taskInfo.pathHints || [],
+    domain: taskInfo.domain,
+  });
+  selectedPaths = applyQualityActions(selectedPaths, scored, quality).slice(0, MAX_CONTEXT_FILES + 2);
+
+  if (!quality.ok && taskInfo.domain?.priorityPaths?.length) {
+    const domainHit = selectedPaths.some((p) =>
+      taskInfo.domain.priorityPaths.some((dp) => p.toLowerCase().includes(dp.toLowerCase())),
+    );
+    if (!domainHit) {
+      for (const p of collected.symbolFiles || []) {
+        if (!selectedPaths.includes(p)) selectedPaths.unshift(p);
+      }
+      selectedPaths = selectedPaths.slice(0, MAX_CONTEXT_FILES + 2);
+    }
+  }
+
+  for (const hint of taskInfo.pathHints || []) {
+    const hintHit = selectedPaths.some((p) => p.toLowerCase().includes(hint));
+    if (!hintHit) {
+      for (const f of collected.files) {
+        if (f.path.toLowerCase().includes(hint) && !selectedPaths.includes(f.path)) {
+          selectedPaths.unshift(f.path);
+          break;
+        }
+      }
+    }
+  }
+  selectedPaths = [...new Set(selectedPaths)].slice(0, MAX_CONTEXT_FILES);
+
+  const ledger = loadLedger(root);
+  let readNow = selectedPaths.slice();
+  let alreadyInContext = [];
+  if (opts.sessionId || opts.sessionKey) {
+    const split = splitFresh(selectedPaths, ledger, sessionKey);
+    readNow = split.fresh;
+    alreadyInContext = split.alreadyInContext;
+    remember(root, sessionKey, selectedPaths);
+  }
+
+  const vsAlways = alwaysApplyTokens(root);
+  const tokensAfterPlan = selectedPaths.reduce((n, p) => {
+    const f = survivors.find((x) => x.path === p);
+    return n + (f?.tokens || 0);
+  }, 0);
+
+  const serenaEmit = emitForTask(taskInfo.symbols || [], readNow);
+  const serenaStrings = (taskInfo.symbols || []).slice(0, 8).map((s) => `find_symbol:${s}`);
+
+  const decisionReport = {
+    intent: taskInfo.intent,
+    domain: taskInfo.domain,
+    seedDirs: collected.seedDirs || [],
+    symbolFiles: collected.symbolFiles || [],
+    retrieve: {
+      dirty: retrieved.dirty.slice(0, 12),
+      fusedTop: retrieved.fused.slice(0, 12).map((x) => x.path),
+      ftsHits: (retrieved.ftsHits || []).slice(0, 8),
+      cascadeSkip: Boolean(retrieved.cascadeSkip),
+      stages: retrieved.stages || {},
+      ftsMeta: retrieved.ftsMeta || null,
+    },
+    slice,
+    topSelected: selectedPaths.slice(0, 8).map((p) => {
+      const s = scored.find((x) => x.path === p);
+      return { path: p, score: s?.final_score, why: s?.whySelected, confidence: s?.confidence };
+    }),
+    topRemoved: removedItems.slice(0, 8).map((r) => ({
+      file: r.file,
+      reason: r.reason,
+      score: r.score,
+    })),
+    quality: { ok: quality.ok, issues: quality.issues },
+  };
+
+  const selectedMeta = [];
+  const contextParts = [
+    `# Ziprin Context MCP ${VERSION}`,
+    `task: ${task}`,
+    `classification: ${taskInfo.label} (${taskInfo.category})`,
+    `profile: ${ctxProfile.id}`,
+    `budget: ${budget} (${taskInfo.complexity})`,
+    `mode: ${dumpBodies ? 'dump' : 'map'}`,
+    `prompt:`,
+    prompt || '(empty)',
+    '',
+    `# Read now`,
+    ...readNow.map((p) => `- ${p}`),
+    '',
+    `# Already in context`,
+    ...(alreadyInContext.length ? alreadyInContext.map((p) => `- ${p}`) : ['- (none)']),
+    '',
+    `# Serena first`,
+    ...serenaEmit.slice(0, 8).map((c) => `- ${c.tool} ${c.name_path_pattern || c.relative_path || ''}`),
+    '',
+    `# Do not read`,
+    '- .cursor/agents/**',
+    '- .cursor/skills/**',
+    '- tooling/project-index.json',
+  ];
+
+  let tokensAfter = 0;
+  if (dumpBodies) {
+    for (const p of selectedPaths) {
+      const file = survivors.find((f) => f.path === p) || { path: p, tokens: 0, bytes: 0 };
+      const shouldCompress =
+        (file.firewall && file.firewall.action === 'summarize') || (file.bytes || 0) > 40_000;
+      const piece = compressFile(root, p, shouldCompress ? 1800 : 3500);
+      selectedMeta.push({
+        path: p,
+        mode: piece.mode,
+        tokens: piece.tokenEstimate,
+        score: scored.find((s) => s.path === p)?.final_score,
+        signatures: (piece.signatures || []).map((s) => s.name),
+        exports: piece.exports || [],
+      });
+      tokensAfter += piece.tokenEstimate;
+      contextParts.push(`\n----- ${p} (${piece.mode}) -----\n`);
+      contextParts.push(piece.text);
+    }
+  } else {
+    for (const p of selectedPaths) {
+      const file = survivors.find((f) => f.path === p) || { path: p, tokens: 80, bytes: 0 };
+      const skel = skeletonFile(root, p);
+      const est = Math.min(120, file.tokens || skel.tokenEstimate || 80);
+      selectedMeta.push({
+        path: p,
+        mode: 'map',
+        tokens: est,
+        score: scored.find((s) => s.path === p)?.final_score,
+        signatures: (skel.signatures || []).map((s) => s.name),
+        exports: (skel.signatures || []).map((s) => s.name),
+      });
+      tokensAfter += est;
+      const sig = (skel.signatures || []).slice(0, 8).map((s) => s.name).join(', ');
+      contextParts.push(`- ${p} :: ${sig || skel.mode}`);
+    }
+  }
+
+  const reductionPct =
+    tokensBefore > 0 ? Math.round((1 - tokensAfter / tokensBefore) * 100) : 0;
+  const vsAlwaysPct = vsAlways > 0 ? Math.round((1 - tokensAfter / (tokensAfter + vsAlways)) * 100) : reductionPct;
+
+  const analysis = [
+    `Task: ${taskInfo.label} / complexity=${taskInfo.complexity}`,
+    `Tokens collected ${tokensBefore} → map ${tokensAfter} (−${reductionPct}%). vsAlwaysApply extra ${vsAlways}.`,
+    `Selected ${selectedPaths.length}; slice ${slice.length}; dirty ${retrieved.dirty.length}; cascade=${retrieved.cascadeSkip}.`,
+    quality.qualityNote,
+    route.recommendation?.why ? `Router: ${route.recommendation.why}` : '',
+    'Return paths + signatures. Call Serena find_symbol before read_file. Never @folder.',
+  ]
+    .filter(Boolean)
+    .join('\n');
+
+  return {
+    id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    timestamp: new Date().toISOString(),
+    version: VERSION,
+    task,
+    prompt: prompt || task,
+    taskClassification: taskInfo.category,
+    taskLabel: taskInfo.label,
+    intent: taskInfo.intent,
+    domainId: taskInfo.domain?.id || null,
+    profileId: ctxProfile.id,
+    filesIncluded: selectedPaths,
+    filesExcluded: removedItems.map((r) => r.file),
+    readNow,
+    alreadyInContext,
+    serena: serenaStrings,
+    serenaEmit,
+    doNotRead: ['.cursor/agents/**', '.cursor/skills/**', 'tooling/project-index.json', '**/reports/**'],
+    rulesApplied: collected.rules.map((r) => r.path + (r.alwaysApply ? ' (alwaysApply)' : '')),
+    tokensBeforePrune: tokensBefore,
+    tokensAfterPrune: tokensAfter,
+    removedItems,
+    finalContext: contextParts.join('\n'),
+    result: analysis,
+    qualityReport: quality,
+    decisionReport,
+    tokenAnalysis: {
+      before: tokensBefore,
+      after: tokensAfter,
+      budget,
+      reductionPct,
+      vsNaiveCollect: reductionPct,
+      vsAlwaysApplyTokens: vsAlways,
+      vsAlwaysApplyPct: vsAlwaysPct,
+      vsSelected: tokensAfterPlan,
+      complexity: taskInfo.complexity,
+      level: taskInfo.intent?.action,
+      dumpBodies,
+      stages: retrieved.stages || {},
+    },
+    selectedMeta,
+    dependencyEdges: edges.slice(0, 80),
+    live: {
+      truncated: collected.truncated,
+      route,
+      rules: collected.rules,
+      budget,
+      taskInfo,
+      scoredTop: scored.slice(0, 20),
+      retrieved,
+    },
+  };
+}
+
+function toSession(snapshot) {
+  return {
+    id: snapshot.id,
+    timestamp: snapshot.timestamp,
+    task: snapshot.task,
+    prompt: snapshot.prompt,
+    taskClassification: snapshot.taskClassification,
+    taskLabel: snapshot.taskLabel,
+    intent: snapshot.intent,
+    domainId: snapshot.domainId,
+    filesIncluded: snapshot.filesIncluded,
+    filesExcluded: snapshot.filesExcluded,
+    readNow: snapshot.readNow,
+    alreadyInContext: snapshot.alreadyInContext,
+    serena: snapshot.serena,
+    serenaEmit: snapshot.serenaEmit,
+    doNotRead: snapshot.doNotRead,
+    rulesApplied: snapshot.rulesApplied,
+    tokensBeforePrune: snapshot.tokensBeforePrune,
+    tokensAfterPrune: snapshot.tokensAfterPrune,
+    removedItems: snapshot.removedItems,
+    finalContext: snapshot.finalContext,
+    result: snapshot.result,
+    qualityReport: snapshot.qualityReport,
+    decisionReport: snapshot.decisionReport,
+    tokenAnalysis: snapshot.tokenAnalysis,
+    profileId: snapshot.profileId,
+  };
+}
+
+module.exports = { buildSnapshot, toSession, VERSION };

package/src/audit-history.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const AUDIT_REL = '.cursor/context-optimizer-audit.jsonl';
+
+function auditFilePath(root) {
+  return path.join(root, AUDIT_REL);
+}
+
+function readEntries(root) {
+  const file = auditFilePath(root);
+  if (!fs.existsSync(file)) return [];
+  const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/).filter(Boolean);
+  const out = [];
+  for (const line of lines) {
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      /* skip corrupt line */
+    }
+  }
+  return out;
+}
+
+function writeEntries(root, entries) {
+  const file = auditFilePath(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const text = entries.map((e) => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : '');
+  fs.writeFileSync(file, text, 'utf8');
+}
+
+function makeEntry(kind, payload) {
+  return {
+    id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    at: new Date().toISOString(),
+    kind,
+    ...payload,
+  };
+}
+
+function appendEntry(root, entry, maxEntries = 100) {
+  if (!root) return entry;
+  const entries = readEntries(root);
+  entries.push(entry);
+  const trimmed = entries.slice(-Math.max(1, maxEntries));
+  writeEntries(root, trimmed);
+  return entry;
+}
+
+function clearEntries(root) {
+  const file = auditFilePath(root);
+  if (fs.existsSync(file)) fs.unlinkSync(file);
+}
+
+function listRecent(root, limit = 15) {
+  return readEntries(root).slice(-limit).reverse();
+}
+
+function formatEntryLabel(entry) {
+  const t = entry.at ? entry.at.replace('T', ' ').slice(0, 19) : '?';
+  const task = entry.task ? ` — ${String(entry.task).slice(0, 40)}` : '';
+  return `[${t}] ${entry.kind}${task}`;
+}
+
+function buildPlanAudit(task, profileId, route, pruned, estimate) {
+  const skipSteps = (pruned.steps || []).filter((s) => s.action === 'skip');
+  const skipped = skipSteps.map((s) => s.what).filter(Boolean);
+  if (route.neverDump?.length) {
+    for (const s of route.neverDump) if (!skipped.includes(s)) skipped.push(s);
+  }
+  return makeEntry('planChat', {
+    task,
+    profile: profileId,
+    summary: {
+      totalTokens: estimate?.total?.tokens ?? null,
+      alwaysApplyCount: estimate?.alwaysApplyTrue?.length ?? null,
+      recommendedTool: route.recommendation?.tool ?? null,
+      skipped,
+      selectedPaths: (pruned.pruned?.selected || []).map((s) => s.path),
+      usedTokens: pruned.pruned?.usedTokens ?? null,
+      budget: pruned.pruned?.budget ?? null,
+    },
+    detail: { route, pruned },
+  });
+}
+
+function buildEstimateAudit(profileId, report) {
+  return makeEntry('estimate', {
+    profile: profileId,
+    summary: {
+      totalTokens: report.total.tokens,
+      alwaysApplyCount: report.alwaysApplyTrue.length,
+      groups: report.groups,
+    },
+    detail: { alwaysApplyTrue: report.alwaysApplyTrue },
+  });
+}
+
+function buildRefreshAudit(liveState) {
+  return makeEntry('refresh', {
+    task: liveState?.task,
+    profile: liveState?.profile?.id,
+    summary: {
+      totalTokens: liveState?.estimate?.total?.tokens ?? null,
+      alwaysApplyCount: liveState?.estimate?.alwaysApplyTrue?.length ?? null,
+      recommendedTool: liveState?.route?.recommendation?.tool ?? null,
+      usedTokens: liveState?.pruned?.pruned?.usedTokens ?? null,
+      budget: liveState?.pruned?.pruned?.budget ?? null,
+    },
+  });
+}
+
+function buildInstallAudit(result) {
+  return makeEntry('installTokenBudget', {
+    summary: {
+      stripped: result.stripped?.length ?? 0,
+      flipped: result.flipped?.length ?? 0,
+    },
+    detail: result,
+  });
+}
+
+module.exports = {
+  AUDIT_REL,
+  auditFilePath,
+  readEntries,
+  appendEntry,
+  clearEntries,
+  listRecent,
+  formatEntryLabel,
+  buildPlanAudit,
+  buildEstimateAudit,
+  buildRefreshAudit,
+  buildInstallAudit,
+};