kodelyth-ecc 1.5.10 → 1.7.0

package/scripts/evolve/analyze.js

@@ -0,0 +1,303 @@
+// scripts/evolve/analyze.js
+//
+// Phase 3.4 — Self-evolving memory: signal → proposal logic.
+//
+// Pure, deterministic functions. No I/O. Given:
+//   - reuse stats (from stats.getReuseStats)
+//   - routing-miss stats (from stats.getRoutingMissStats)
+//   - the memories themselves (from scripts/memory/store.listAll)
+//   - the current routing rule text (string)
+//
+// Produces a list of structured proposals. Two kinds:
+//
+//   1) skill-upgrade   — a memory has been surfaced ≥ N times and across
+//                        ≥ M distinct sessions → propose creating a draft
+//                        SKILL.md from it.
+//
+//   2) routing-addition — ≥ K substantive prompts cluster on the same token
+//                         set without any memory match → propose adding a
+//                         new routing entry under the most-likely tier.
+//
+// Every proposal carries:
+//   - id (deterministic given evidence — stable across re-runs)
+//   - type
+//   - evidence (the raw signal data)
+//   - proposal: { kind, target_path, diff (markdown), rationale }
+//
+// Apply step writes the diff to disk as a draft file the user reviews
+// before committing. NEVER auto-applied.
+'use strict';
+
+const crypto = require('crypto');
+
+const DEFAULT_REUSE_MIN_COUNT     = 3;
+const DEFAULT_REUSE_MIN_SESSIONS  = 2;
+const DEFAULT_MISS_MIN_COUNT      = 3;
+const DEFAULT_MISS_CLUSTER_MIN    = 2; // distinct prompt-hashes per cluster
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function deterministicId(prefix, payload) {
+  const h = crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 10);
+  return `${prefix}-${h}`;
+}
+
+function slugify(s) {
+  return String(s || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'untitled';
+}
+
+// ── skill-upgrade proposals ─────────────────────────────────────────────────
+
+function buildSkillUpgradeMarkdown(memory) {
+  const slug = slugify(memory.problem);
+  const tags = (memory.tags || []).slice(0, 8);
+  const desc = (memory.problem || '').slice(0, 180);
+  const approach = (memory.approach || '').trim();
+  const lang = memory.language || 'general';
+
+  return [
+    '---',
+    `name: ${slug}`,
+    `description: ${desc.replace(/[\r\n]+/g, ' ')} (auto-derived from memory ${memory.id} after repeated reuse)`,
+    `origin: kodelyth-evolve`,
+    `language: ${lang}`,
+    `tags:`,
+    ...tags.map(t => `  - ${t}`),
+    '---',
+    '',
+    `# Skill: ${slug}`,
+    '',
+    '> **Auto-derived draft.** Generated by `kodelyth-ecc evolve` after this memory was surfaced repeatedly across multiple sessions. Review, refine, and rename before committing.',
+    '',
+    '## Problem',
+    '',
+    memory.problem || '_(no problem statement)_',
+    '',
+    '## Approach',
+    '',
+    approach || '_(no approach text)_',
+    '',
+    memory.gotchas?.length ? '## Gotchas\n\n' + memory.gotchas.map(g => `- ${g}`).join('\n') + '\n' : '',
+    '## When to invoke',
+    '',
+    '_Replace this section with explicit trigger conditions. Examples that worked:_',
+    '',
+    '_(add 2-3 real prompts that historically benefitted from this approach)_',
+    '',
+    '## Origin',
+    '',
+    `- Memory id: \`${memory.id}\``,
+    `- Captured at: ${memory.captured_at || 'unknown'}`,
+    `- Source: ${memory.source || 'unknown'}`,
+    `- Auto-promoted by Phase 3.4 self-evolving memory.`,
+    '',
+  ].filter(Boolean).join('\n');
+}
+
+function analyzeReuseForProposals({
+  reuseStats,
+  memories,
+  thresholds: t = {},
+} = {}) {
+  if (!reuseStats || !Array.isArray(memories)) return [];
+  const minCount    = t.minCount    ?? DEFAULT_REUSE_MIN_COUNT;
+  const minSessions = t.minSessions ?? DEFAULT_REUSE_MIN_SESSIONS;
+
+  const memoriesById = new Map(memories.map(m => [m.id, m]));
+  const proposals = [];
+
+  for (const entry of reuseStats.entries || []) {
+    if (entry.count < minCount) continue;
+    if ((entry.sessions || []).length < minSessions) continue;
+    const memory = memoriesById.get(entry.id);
+    if (!memory) continue;
+
+    const targetPath = `skills/${slugify(memory.problem)}/SKILL.md`;
+    const evidence = {
+      memoryId:    entry.id,
+      reuseCount:  entry.count,
+      sessions:    entry.sessions,
+      projects:    entry.projects || [],
+      firstSurfaced: entry.firstSurfaced,
+      lastSurfaced:  entry.lastSurfaced,
+    };
+    proposals.push({
+      id:    deterministicId('skill', evidence),
+      type:  'skill-upgrade',
+      evidence,
+      proposal: {
+        kind:        'create-skill',
+        target_path: targetPath,
+        diff:        buildSkillUpgradeMarkdown(memory),
+        rationale:
+          `Memory "${memory.problem}" surfaced ${entry.count}x across ` +
+          `${(entry.sessions || []).length} sessions — promoting to a draft skill.`,
+      },
+    });
+  }
+  return proposals;
+}
+
+// ── routing-addition proposals ──────────────────────────────────────────────
+
+const STOP = new Set([
+  'the','a','an','to','of','in','on','for','and','or','but','if','is','are',
+  'was','were','be','been','have','has','had','do','does','did','this','that',
+  'it','its','i','you','we','they','my','your','our','can','will','should',
+  'how','what','why','when','where','use','using','run','make','need','want',
+]);
+
+function topTokens(tokens, k = 4) {
+  const filtered = (tokens || []).filter(t => t.length >= 3 && !STOP.has(t));
+  return filtered.slice(0, k);
+}
+
+/**
+ * Cluster routing-miss entries by their top-K tokens. Two entries are in
+ * the same cluster if their top-K token sets share at least 2 tokens.
+ * Greedy / O(n²) — fine for thousands of misses, this isn't BM25.
+ */
+function clusterMisses(missEntries) {
+  const clusters = [];
+  for (const m of missEntries) {
+    const myTokens = topTokens(m.tokens);
+    if (myTokens.length === 0) continue;
+    let placed = false;
+    for (const c of clusters) {
+      const overlap = myTokens.filter(t => c.tokens.has(t)).length;
+      if (overlap >= 2) {
+        c.entries.push(m);
+        c.count += m.count;
+        myTokens.forEach(t => c.tokens.add(t));
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      clusters.push({
+        tokens:  new Set(myTokens),
+        entries: [m],
+        count:   m.count,
+      });
+    }
+  }
+  return clusters
+    .map(c => ({
+      tokens:  [...c.tokens],
+      entries: c.entries,
+      count:   c.count,
+    }))
+    .sort((a, b) => b.count - a.count);
+}
+
+function buildRoutingProposalMarkdown(cluster) {
+  const sampleTokens = cluster.tokens.slice(0, 4).join(' / ');
+  const sampleLines = cluster.entries
+    .flatMap(e => e.samples || [])
+    .slice(0, 5)
+    .map(s => `  - "${s.replace(/\n/g, ' ').slice(0, 140)}"`)
+    .join('\n');
+  return [
+    '<!-- proposed addition to rules/common/agent-intent-routing.md -->',
+    '<!-- review by hand, decide on tier + agent, then merge -->',
+    '',
+    `### TODO-agent — covers prompts about ${sampleTokens}`,
+    '',
+    `Trigger if the user mentions ${cluster.tokens.slice(0, 6).map(t => `\`${t}\``).join(', ')}.`,
+    '',
+    '| Signal | Real human phrasing |',
+    '|---|---|',
+    `| repeated unrouted prompt cluster | ${cluster.tokens.slice(0, 5).join(', ')} |`,
+    '',
+    `**Origin:** Phase 3.4 self-evolving memory \u2014 ${cluster.count} prompts in this cluster were submitted with no memory match and (presumably) no specialist routing.`,
+    '',
+    'Recent samples:',
+    sampleLines || '  _(none)_',
+    '',
+    '_(Pick the right tier in `rules/common/agent-intent-routing.md` before merging. Do NOT commit this block as-is — replace `TODO-agent` with the real agent name and slot under the correct priority tier.)_',
+    '',
+  ].join('\n');
+}
+
+function analyzeMissesForProposals({
+  missStats,
+  thresholds: t = {},
+} = {}) {
+  if (!missStats) return [];
+  const minCount      = t.minCount      ?? DEFAULT_MISS_MIN_COUNT;
+  const minClusterDistinct = t.minClusterDistinct ?? DEFAULT_MISS_CLUSTER_MIN;
+
+  const clusters = clusterMisses(missStats.entries || []);
+  const proposals = [];
+
+  for (const c of clusters) {
+    if (c.count < minCount) continue;
+    if (c.entries.length < minClusterDistinct) continue;
+    const evidence = {
+      tokens:           c.tokens,
+      occurrences:      c.count,
+      distinct_prompts: c.entries.length,
+      sample_prompts:   c.entries.flatMap(e => e.samples || []).slice(0, 5),
+    };
+    proposals.push({
+      id:    deterministicId('route', { tokens: c.tokens.sort() }),
+      type:  'routing-addition',
+      evidence,
+      proposal: {
+        kind:        'add-routing-entry',
+        target_path: 'rules/common/agent-intent-routing.md',
+        diff:        buildRoutingProposalMarkdown(c),
+        rationale:
+          `${c.count} substantive prompts (${c.entries.length} distinct) clustered on ` +
+          `tokens [${c.tokens.slice(0, 4).join(', ')}] without any memory match. ` +
+          `Likely a routing gap.`,
+      },
+    });
+  }
+  return proposals;
+}
+
+// ── single entry point ──────────────────────────────────────────────────────
+
+function analyzeAll({
+  reuseStats,
+  missStats,
+  memories,
+  thresholds = {},
+} = {}) {
+  return [
+    ...analyzeReuseForProposals({
+      reuseStats,
+      memories: memories || [],
+      thresholds: {
+        minCount:    thresholds.reuseMinCount,
+        minSessions: thresholds.reuseMinSessions,
+      },
+    }),
+    ...analyzeMissesForProposals({
+      missStats,
+      thresholds: {
+        minCount:           thresholds.missMinCount,
+        minClusterDistinct: thresholds.missMinClusterDistinct,
+      },
+    }),
+  ];
+}
+
+module.exports = {
+  DEFAULT_REUSE_MIN_COUNT,
+  DEFAULT_REUSE_MIN_SESSIONS,
+  DEFAULT_MISS_MIN_COUNT,
+  DEFAULT_MISS_CLUSTER_MIN,
+  analyzeReuseForProposals,
+  analyzeMissesForProposals,
+  analyzeAll,
+  buildSkillUpgradeMarkdown,
+  buildRoutingProposalMarkdown,
+  clusterMisses,
+  _internals: { topTokens, slugify, deterministicId },
+};

package/scripts/evolve/proposals.js

@@ -0,0 +1,162 @@
+// scripts/evolve/proposals.js
+//
+// Phase 3.4 — Self-evolving memory: proposal log.
+//
+// Append-only JSONL store of proposals with state transitions:
+//   pending   → initial state when written
+//   accepted  → user ran `evolve accept <id>`; draft file written to disk
+//   rejected  → user ran `evolve reject <id>`
+//   applied   → user committed the accepted draft (advisory, set manually)
+//
+// State changes are append-only (a new line per state event), so the full
+// audit trail is preserved. Reads collapse to "latest state per id".
+//
+// Storage:
+//   ${KODELYTH_EVOLVE_DIR:-~/.kodelyth/evolve}/proposals.jsonl
+//
+// Pure where possible. Public functions accept dir explicitly.
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const DEFAULT_DIR = process.env.KODELYTH_EVOLVE_DIR
+  || path.join(os.homedir(), '.kodelyth', 'evolve');
+
+const PROPOSALS_FILE = 'proposals.jsonl';
+
+const VALID_STATUSES = new Set(['pending', 'accepted', 'rejected', 'applied']);
+
+function ensureDir(dir) {
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    return true;
+  } catch { return false; }
+}
+
+function readAll(dir = DEFAULT_DIR) {
+  const p = path.join(dir, PROPOSALS_FILE);
+  if (!fs.existsSync(p)) return [];
+  try {
+    return fs.readFileSync(p, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map(line => { try { return JSON.parse(line); } catch { return null; } })
+      .filter(Boolean);
+  } catch { return []; }
+}
+
+/**
+ * Reduce raw event log → latest state per proposal id.
+ * Returns an ordered array (insertion order of first event per id).
+ */
+function readLatest(dir = DEFAULT_DIR) {
+  const events = readAll(dir);
+  const byId = new Map();
+  for (const ev of events) {
+    if (!ev.id) continue;
+    if (!byId.has(ev.id)) {
+      byId.set(ev.id, { ...ev });
+    } else {
+      const cur = byId.get(ev.id);
+      // Merge: keep original proposal/evidence, update mutable fields.
+      cur.status = ev.status || cur.status;
+      cur.last_updated = ev.timestamp || cur.last_updated;
+      cur.applied_path = ev.applied_path || cur.applied_path;
+      cur.note = ev.note ?? cur.note;
+    }
+  }
+  return [...byId.values()];
+}
+
+function appendEvent(event, dir = DEFAULT_DIR) {
+  if (!ensureDir(dir)) return false;
+  try {
+    fs.appendFileSync(path.join(dir, PROPOSALS_FILE), JSON.stringify(event) + '\n');
+    return true;
+  } catch { return false; }
+}
+
+/**
+ * Append a fresh proposal with status=pending. Idempotent on `id`:
+ * if a proposal with this id already exists in the log, this is a no-op.
+ *
+ * @returns the proposal (existing or new)
+ */
+function appendProposal(proposal, dir = DEFAULT_DIR) {
+  if (!proposal || !proposal.id || !proposal.type || !proposal.proposal) {
+    throw new Error('appendProposal: proposal must include id, type, and proposal{}');
+  }
+  const existing = readLatest(dir).find(p => p.id === proposal.id);
+  if (existing) return existing;
+
+  const event = {
+    ...proposal,
+    status: 'pending',
+    created_at: new Date().toISOString(),
+    timestamp:  new Date().toISOString(),
+  };
+  appendEvent(event, dir);
+  return event;
+}
+
+function setStatus(id, status, dir = DEFAULT_DIR, extras = {}) {
+  if (!VALID_STATUSES.has(status)) {
+    throw new Error(`setStatus: invalid status "${status}" (expected one of ${[...VALID_STATUSES].join(', ')})`);
+  }
+  const current = readLatest(dir).find(p => p.id === id);
+  if (!current) return null;
+  const event = {
+    id,
+    status,
+    timestamp: new Date().toISOString(),
+    ...extras,
+  };
+  appendEvent(event, dir);
+  return { ...current, ...event };
+}
+
+function listByStatus(status = null, dir = DEFAULT_DIR) {
+  const all = readLatest(dir);
+  if (!status) return all;
+  return all.filter(p => p.status === status);
+}
+
+function findById(id, dir = DEFAULT_DIR) {
+  return readLatest(dir).find(p => p.id === id) || null;
+}
+
+/**
+ * Write the proposal's diff to its target_path (relative to repoRoot).
+ * Defensive: refuses to overwrite an existing file unless overwrite=true.
+ *
+ * @returns { written, path } on success
+ * @throws on conflict / write failure
+ */
+function applyProposalToDisk(proposal, { repoRoot, overwrite = false } = {}) {
+  if (!proposal?.proposal?.diff || !proposal.proposal.target_path) {
+    throw new Error('applyProposalToDisk: proposal lacks diff or target_path');
+  }
+  if (!repoRoot) throw new Error('applyProposalToDisk: repoRoot is required');
+  const abs = path.resolve(repoRoot, proposal.proposal.target_path);
+  if (fs.existsSync(abs) && !overwrite) {
+    throw new Error(`applyProposalToDisk: refusing to overwrite existing file at ${abs} (pass overwrite=true)`);
+  }
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, proposal.proposal.diff);
+  return { written: true, path: abs };
+}
+
+module.exports = {
+  DEFAULT_DIR,
+  PROPOSALS_FILE,
+  VALID_STATUSES,
+  appendProposal,
+  setStatus,
+  listByStatus,
+  findById,
+  readAll,
+  readLatest,
+  applyProposalToDisk,
+};

package/scripts/evolve/stats.js

@@ -0,0 +1,219 @@
+// scripts/evolve/stats.js
+//
+// Phase 3.4 — Self-evolving memory: signal recording.
+//
+// Two signal streams are tracked, both purely local, zero telemetry:
+//
+//   1) reuse signals     — memory IDs surfaced by auto-recall, counted
+//                          per memory + per session. High counts → the
+//                          memory is being repeatedly useful → candidate
+//                          for promotion to a skill.
+//
+//   2) routing misses   — substantive UserPromptSubmit prompts where
+//                          memory recall returned NOTHING. Clustered later
+//                          by tokens to surface "we keep getting asked
+//                          about X but have no agent / skill / memory for it".
+//
+// Storage layout (default ${HOME}/.kodelyth/evolve/):
+//   reuse.json                  { byMemory: { id: { count, sessions[], lastSurfaced } } }
+//   routing-misses.jsonl        append-only — one prompt per line
+//
+// Override the directory with $KODELYTH_EVOLVE_DIR.
+//
+// Pure functions — every function takes its dir explicitly. No global state.
+// Safe to call from a hook: every public function swallows internal errors
+// and returns either a sane default or `false`/`null`. Hooks must never crash.
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const DEFAULT_DIR = process.env.KODELYTH_EVOLVE_DIR
+  || path.join(os.homedir(), '.kodelyth', 'evolve');
+
+const REUSE_FILE = 'reuse.json';
+const MISSES_FILE = 'routing-misses.jsonl';
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function ensureDir(dir) {
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    return true;
+  } catch { return false; }
+}
+
+function safeReadJson(p, fallback) {
+  try {
+    if (!fs.existsSync(p)) return fallback;
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch { return fallback; }
+}
+
+function safeWriteJson(p, data) {
+  try {
+    fs.writeFileSync(p, JSON.stringify(data, null, 2));
+    return true;
+  } catch { return false; }
+}
+
+function safeAppendLine(p, line) {
+  try {
+    fs.appendFileSync(p, line.replace(/\n+$/, '') + '\n');
+    return true;
+  } catch { return false; }
+}
+
+function tokenize(text) {
+  if (!text) return [];
+  return String(text)
+    .toLowerCase()
+    .replace(/[^a-z0-9_\-/.\s]/g, ' ')
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+function hashPrompt(prompt) {
+  return crypto.createHash('sha256').update(String(prompt)).digest('hex').slice(0, 12);
+}
+
+// ── reuse signals ────────────────────────────────────────────────────────────
+
+function emptyReuse() { return { byMemory: {}, lastUpdated: null }; }
+
+function readReuse(dir = DEFAULT_DIR) {
+  return safeReadJson(path.join(dir, REUSE_FILE), emptyReuse());
+}
+
+/**
+ * Record that a memory was surfaced to the user.
+ * Idempotent per (memoryId, sessionId): if the same memory has already
+ * been counted this session, count is NOT bumped again. This matches the
+ * existing auto-recall semantics ("never re-surface the same memory twice
+ * in a session").
+ *
+ * @returns true on success, false on any error (never throws).
+ */
+function recordSurface({ memoryId, sessionId, projectRoot, timestamp } = {}, dir = DEFAULT_DIR) {
+  if (!memoryId) return false;
+  if (!ensureDir(dir)) return false;
+  const data = readReuse(dir);
+  const ts = timestamp || new Date().toISOString();
+  const sid = String(sessionId || 'unknown');
+
+  const cur = data.byMemory[memoryId] || {
+    count: 0,
+    sessions: [],
+    projects: [],
+    firstSurfaced: ts,
+    lastSurfaced: ts,
+  };
+
+  if (!cur.sessions.includes(sid)) {
+    cur.count += 1;
+    cur.sessions.push(sid);
+  }
+  if (projectRoot && !cur.projects.includes(projectRoot)) {
+    cur.projects.push(projectRoot);
+  }
+  cur.lastSurfaced = ts;
+
+  data.byMemory[memoryId] = cur;
+  data.lastUpdated = ts;
+  return safeWriteJson(path.join(dir, REUSE_FILE), data);
+}
+
+function getReuseStats(dir = DEFAULT_DIR) {
+  const data = readReuse(dir);
+  const entries = Object.entries(data.byMemory).map(([id, v]) => ({ id, ...v }));
+  entries.sort((a, b) => b.count - a.count);
+  return {
+    total_memories_tracked: entries.length,
+    total_surfaces: entries.reduce((s, e) => s + e.count, 0),
+    last_updated: data.lastUpdated,
+    entries,
+  };
+}
+
+// ── routing miss signals ─────────────────────────────────────────────────────
+
+function readMisses(dir = DEFAULT_DIR) {
+  const p = path.join(dir, MISSES_FILE);
+  if (!fs.existsSync(p)) return [];
+  try {
+    return fs.readFileSync(p, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map(line => { try { return JSON.parse(line); } catch { return null; } })
+      .filter(Boolean);
+  } catch { return []; }
+}
+
+/**
+ * Record a substantive prompt where memory recall returned nothing.
+ * Hook layer decides what counts as "substantive" — this function is dumb
+ * persistence. Stores the prompt itself (capped) plus tokens for clustering.
+ *
+ * @returns true on success, false on any error (never throws).
+ */
+function recordRoutingMiss({ prompt, sessionId, projectRoot, timestamp } = {}, dir = DEFAULT_DIR) {
+  if (!prompt || typeof prompt !== 'string') return false;
+  if (!ensureDir(dir)) return false;
+
+  // Cap stored prompt to avoid log bloat from accidental paste of huge files.
+  const trimmed = prompt.slice(0, 1000);
+  const entry = {
+    hash:        hashPrompt(trimmed),
+    prompt:      trimmed,
+    tokens:      tokenize(trimmed).slice(0, 32),
+    session_id:  String(sessionId || 'unknown'),
+    project:     projectRoot || null,
+    recorded_at: timestamp || new Date().toISOString(),
+  };
+  return safeAppendLine(path.join(dir, MISSES_FILE), JSON.stringify(entry));
+}
+
+function getRoutingMissStats(dir = DEFAULT_DIR) {
+  const all = readMisses(dir);
+  const byHash = new Map();
+  for (const m of all) {
+    const cur = byHash.get(m.hash) || { hash: m.hash, count: 0, samples: [], firstSeen: m.recorded_at, lastSeen: m.recorded_at, tokens: m.tokens };
+    cur.count += 1;
+    if (cur.samples.length < 3) cur.samples.push(m.prompt);
+    cur.lastSeen = m.recorded_at;
+    byHash.set(m.hash, cur);
+  }
+  const entries = [...byHash.values()].sort((a, b) => b.count - a.count);
+  return {
+    total_misses: all.length,
+    unique_prompts: entries.length,
+    entries,
+  };
+}
+
+// ── reset (test helper) ──────────────────────────────────────────────────────
+
+function resetAll(dir = DEFAULT_DIR) {
+  try {
+    if (fs.existsSync(path.join(dir, REUSE_FILE))) fs.unlinkSync(path.join(dir, REUSE_FILE));
+    if (fs.existsSync(path.join(dir, MISSES_FILE))) fs.unlinkSync(path.join(dir, MISSES_FILE));
+    return true;
+  } catch { return false; }
+}
+
+module.exports = {
+  DEFAULT_DIR,
+  REUSE_FILE,
+  MISSES_FILE,
+  recordSurface,
+  readReuse,
+  getReuseStats,
+  recordRoutingMiss,
+  readMisses,
+  getRoutingMissStats,
+  resetAll,
+  // exposed for tests
+  _internals: { tokenize, hashPrompt },
+};