@occasiolabs/occasio 0.8.1

package/src/lao.js

@@ -0,0 +1,185 @@
+'use strict';
+
+/**
+ * lao.js — LAO context optimization for the Occasio proxy.
+ *
+ * Before a request goes to Anthropic, optimizeContext() scores every file
+ * already loaded into the conversation (via Read / cat tool_results) against
+ * the current task using a Python TF-IDF scorer (lao_prep.py).
+ * Tool-results for low-relevance files are replaced with a one-line
+ * placeholder, keeping conversation structure intact while saving tokens.
+ *
+ * Only activates when total context exceeds MIN_TOK (default 20 000).
+ * Scorer output is cached for 30 s to avoid repeated subprocess spawning.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const { estimateTokens } = require('./analyzer');
+
+const LAO_PY    = path.join(__dirname, 'lao_prep.py');
+const MIN_TOK   = 20_000;
+const TRIM_FRAC = 0.10;   // drop files scoring < 10 % of top score
+const CACHE_TTL = 30_000;
+const PLACEHOLDER = '[content trimmed by Occasio LAO — low relevance to current task]';
+
+let _cache = { key: '', result: [], ts: 0 };
+
+// ── Python subprocess ──────────────────────────────────────────────────────────
+
+function scorePaths(task, repoPath) {
+  const key = `${task.slice(0, 120)}|${repoPath}`;
+  if (key === _cache.key && Date.now() - _cache.ts < CACHE_TTL) {
+    return Promise.resolve(_cache.result);
+  }
+  return new Promise(resolve => {
+    const py = spawn('python', [LAO_PY, task.slice(0, 500), repoPath], {
+      windowsHide: true,
+    });
+    let out = '';
+    const timer = setTimeout(() => { py.kill(); resolve([]); }, 8_000);
+    py.stdout.on('data', d => { out += d.toString(); });
+    py.on('close', () => {
+      clearTimeout(timer);
+      try {
+        const result = JSON.parse(out);
+        _cache = { key, result, ts: Date.now() };
+        resolve(result);
+      } catch { resolve([]); }
+    });
+    py.on('error', () => { clearTimeout(timer); resolve([]); });
+  });
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function contextTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === 'string') { total += estimateTokens(m.content); continue; }
+    if (!Array.isArray(m.content)) continue;
+    for (const b of m.content) {
+      const t = b.text ?? (typeof b.content === 'string' ? b.content : '') ?? '';
+      total += estimateTokens(t);
+    }
+  }
+  return total;
+}
+
+function extractTask(messages) {
+  return [...messages]
+    .reverse()
+    .filter(m => m.role === 'user')
+    .slice(0, 3)
+    .map(m =>
+      typeof m.content === 'string' ? m.content :
+      Array.isArray(m.content)
+        ? m.content.filter(b => b.type === 'text').map(b => b.text || '').join(' ')
+        : ''
+    )
+    .join(' ');
+}
+
+/**
+ * Build a map of tool_use_id → normalised file path from all assistant messages.
+ * Handles: Claude Code Read tool (file_path / path input), MCP read_file (path),
+ * and Bash cat/head/tail calls (command input).
+ */
+function buildToolIdPathMap(messages) {
+  const map = new Map();
+  for (const msg of messages) {
+    if (msg.role !== 'assistant') continue;
+    const content = Array.isArray(msg.content) ? msg.content : [];
+    for (const block of content) {
+      if (block.type !== 'tool_use' || !block.id) continue;
+      const inp = block.input || {};
+      // Direct file path fields
+      const fp = inp.file_path || inp.path || null;
+      if (fp) { map.set(block.id, fp.replace(/\\/g, '/')); continue; }
+      // Bash: cat/head/tail/bat/type <file>
+      if (block.name === 'Bash' && inp.command) {
+        const m = inp.command.match(
+          /^(?:cat|bat|head|tail|type|Get-Content)\s+(?:-\S+\s+)*(['"]?)(.+?)\1\s*$/i
+        );
+        if (m) map.set(block.id, m[2].trim().replace(/\\/g, '/'));
+      }
+    }
+  }
+  return map;
+}
+
+function toolResultText(block) {
+  if (typeof block.content === 'string') return block.content;
+  if (Array.isArray(block.content)) {
+    return block.content.map(b => (typeof b === 'string' ? b : b.text || '')).join('\n');
+  }
+  return '';
+}
+
+// ── Main export ────────────────────────────────────────────────────────────────
+
+/**
+ * Trim low-relevance file tool_results from an Anthropic request body.
+ *
+ * Skips (returns unchanged) if:
+ *   - total context < MIN_TOK tokens
+ *   - Python scorer returns no results or scores all zero
+ *   - no file path could be matched for a tool_result
+ *
+ * @param {object} reqBody  Parsed request body (has .messages array)
+ * @param {string} cwd      Repo root for the scorer
+ * @returns {Promise<{ messages: Array, tokensSaved: number, filesDropped: string[] }>}
+ */
+async function optimizeContext(reqBody, cwd) {
+  const messages = reqBody.messages || [];
+  const noChange = { messages, tokensSaved: 0, filesDropped: [] };
+
+  if (contextTokens(messages) < MIN_TOK) return noChange;
+
+  const task = extractTask(messages).trim();
+  if (!task) return noChange;
+
+  const scored = await scorePaths(task, cwd);
+  if (!scored.length) return noChange;
+
+  const maxScore = scored[0].score;
+  if (maxScore <= 0) return noChange;
+
+  const threshold = maxScore * TRIM_FRAC;
+  const relevance = new Map(scored.map(s => [s.path, s.score]));
+  const toolIdPath = buildToolIdPathMap(messages);
+
+  let tokensSaved = 0;
+  const filesDropped = [];
+
+  const trimmed = messages.map(msg => {
+    if (msg.role !== 'user' || !Array.isArray(msg.content)) return msg;
+
+    let changed = false;
+    const newContent = msg.content.map(block => {
+      if (block.type !== 'tool_result') return block;
+
+      const filePath = toolIdPath.get(block.tool_use_id);
+      if (!filePath) return block;
+
+      const rel = filePath.replace(/\\/g, '/');
+      const score = relevance.get(rel)
+        ?? relevance.get(path.posix.basename(rel))
+        ?? maxScore;  // unknown → keep
+
+      if (score >= threshold) return block;
+
+      const text = toolResultText(block);
+      tokensSaved += estimateTokens(text);
+      filesDropped.push(path.basename(filePath));
+      changed = true;
+      return { ...block, content: PLACEHOLDER };
+    });
+
+    return changed ? { ...msg, content: newContent } : msg;
+  });
+
+  return { messages: trimmed, tokensSaved, filesDropped };
+}
+
+module.exports = { optimizeContext, contextTokens, buildToolIdPathMap, extractTask };

package/src/lao_prep.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Occasio LAO context scorer.
+Usage: python lao_prep.py <task> <repo_path>
+Output: JSON array [{path, score, est_tokens}] sorted by score desc.
+No external dependencies — stdlib only.
+"""
+from __future__ import annotations
+
+import json
+import math
+import re
+import sys
+from pathlib import Path
+
+IGNORE_DIRS: set[str] = {
+    ".git", "__pycache__", "node_modules", ".venv", "venv",
+    "dist", "build", ".next", ".nuxt", "coverage", ".cache",
+    ".mypy_cache", ".pytest_cache", ".ruff_cache", ".tox",
+}
+IGNORE_EXT: set[str] = {
+    ".lock", ".log", ".map", ".min.js", ".min.css",
+    ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico",
+    ".woff", ".woff2", ".ttf", ".eot",
+    ".pdf", ".zip", ".tar", ".gz", ".bin", ".exe", ".dll",
+    ".pyc", ".pyo", ".so", ".dylib",
+}
+MAX_FILE_BYTES = 100_000
+MAX_FILES = 300
+
+
+def tokenize(text: str) -> list[str]:
+    # Identifiers >= 3 chars only: reduces noise from short tokens
+    return re.findall(r"[a-zA-Z_]\w{2,}", text.lower())
+
+
+def scan_repo(repo_path: str) -> list[dict]:
+    root = Path(repo_path).resolve()
+    files: list[dict] = []
+    try:
+        for p in root.rglob("*"):
+            if not p.is_file():
+                continue
+            if any(part in IGNORE_DIRS for part in p.parts):
+                continue
+            if p.suffix.lower() in IGNORE_EXT:
+                continue
+            try:
+                size = p.stat().st_size
+            except OSError:
+                continue
+            if size > MAX_FILE_BYTES:
+                continue
+            try:
+                content = p.read_text(encoding="utf-8", errors="ignore")
+            except OSError:
+                continue
+            rel = str(p.relative_to(root)).replace("\\", "/")
+            path_tokens = set(tokenize(rel))
+            content_tokens = set(tokenize(content))
+            files.append({
+                "path": rel,
+                "token_set": content_tokens | path_tokens,
+                "path_tokens": path_tokens,
+                "est_tokens": max(1, size // 4),
+            })
+            if len(files) >= MAX_FILES:
+                break
+    except Exception:
+        pass
+    return files
+
+
+def score_files(task: str, files: list[dict]) -> list[dict]:
+    task_tokens = tokenize(task)
+    if not task_tokens or not files:
+        return []
+
+    N = len(files)
+    idf: dict[str, float] = {}
+    for tok in set(task_tokens):
+        df = sum(1 for f in files if tok in f["token_set"])
+        idf[tok] = math.log((N + 1) / (df + 1)) + 1.0
+
+    results: list[dict] = []
+    for f in files:
+        ts = f["token_set"]
+        pt = f["path_tokens"]
+        score = 0.0
+        for tok in task_tokens:
+            w = idf.get(tok, 0.0)
+            if tok in pt:
+                score += w * 3.0   # path match: strong signal
+            elif tok in ts:
+                score += w * 1.0   # content match
+        score /= math.sqrt(max(len(ts), 1))
+        results.append({
+            "path": f["path"],
+            "score": round(score, 5),
+            "est_tokens": f["est_tokens"],
+        })
+
+    results.sort(key=lambda x: -x["score"])
+    return results
+
+
+def main() -> None:
+    if len(sys.argv) < 3:
+        print("[]")
+        return
+    task = sys.argv[1]
+    repo_path = sys.argv[2]
+    files = scan_repo(repo_path)
+    results = score_files(task, files)
+    print(json.dumps(results))
+
+
+if __name__ == "__main__":
+    main()

package/src/ledger.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const LOG_DIR      = path.join(os.homedir(), '.occasio');
+const SESSION_FILE = path.join(LOG_DIR, 'session.json');
+
+const col = {
+  r: s => `\x1b[31m${s}\x1b[0m`, g: s => `\x1b[32m${s}\x1b[0m`,
+  y: s => `\x1b[33m${s}\x1b[0m`, c: s => `\x1b[36m${s}\x1b[0m`,
+  d: s => `\x1b[2m${s}\x1b[0m`,  b: s => `\x1b[1m${s}\x1b[0m`,
+};
+
+function todayStr() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`;
+}
+
+function readDayLog(dateStr) {
+  const logFile = path.join(LOG_DIR, 'logs', `${dateStr}.jsonl`);
+  if (!fs.existsSync(logFile)) return [];
+  const lines = fs.readFileSync(logFile, 'utf8').split('\n');
+  const result = [];
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    try { result.push(JSON.parse(line)); } catch {}
+  }
+  return result;
+}
+
+// Filter entries to those at or after sessionStart (ISO string).
+// Uses entry.iso when available; falls back to HH:MM:SS string comparison.
+function readSessionEntries(entries, sessionStart) {
+  if (!sessionStart || !entries.length) return entries;
+  const startHms = new Date(sessionStart).toTimeString().slice(0, 8);
+  const filtered = entries.filter(e => {
+    if (e.iso) return e.iso >= sessionStart;
+    return (e.ts || '') >= startHms;
+  });
+  return filtered.length > 0 ? filtered : entries;
+}
+
+// Aggregate totals from a list of log entries.
+// Handles both new entries (event_type field) and old entries (intercepted flag).
+function summarize(entries) {
+  const t = {
+    requests: 0, cloud_sent: 0, local_only: 0, blocked: 0, trimmed: 0,
+    budget_exceeded: 0,
+    input_tokens: 0, output_tokens: 0,
+    cache_read_tokens: 0, cache_write_tokens: 0,
+    cost: 0, cache_savings: 0, lao_cost_saved: 0, lao_tokens_saved: 0,
+    distill_cost_saved: 0, distill_tokens_saved: 0,
+    tools_local_count: 0,
+  };
+  for (const e of entries) {
+    t.requests++;
+    const et = e.event_type || (e.intercepted ? 'local_only' : 'cloud_sent');
+    if (et === 'cloud_sent')           t.cloud_sent++;
+    else if (et === 'local_only')      t.local_only++;
+    else if (et === 'blocked')         t.blocked++;
+    else if (et === 'trimmed')         t.trimmed++;
+    else if (et === 'budget_exceeded') t.budget_exceeded++;
+    t.input_tokens          += e.input_tokens          || 0;
+    t.output_tokens         += e.output_tokens         || 0;
+    t.cache_read_tokens     += e.cache_read_tokens     || 0;
+    t.cache_write_tokens    += e.cache_write_tokens    || 0;
+    t.cost                  += e.cost                  || 0;
+    t.cache_savings         += e.cache_savings         || 0;
+    t.lao_cost_saved        += e.lao_cost_saved        || 0;
+    t.lao_tokens_saved      += e.lao_tokens_saved      || 0;
+    t.distill_cost_saved    += e.distill_cost_saved    || 0;
+    t.distill_tokens_saved  += e.distill_tokens_saved  || 0;
+    t.tools_local_count     += e.tools_local_count     || 0;
+  }
+  return t;
+}
+
+function fmtN(n) {
+  if (n >= 1e6) return (n/1e6).toFixed(1)+'M';
+  if (n >= 1e3) return (n/1e3).toFixed(1)+'k';
+  return String(n || 0);
+}
+
+function eventCol(et) {
+  switch (et) {
+    case 'cloud_sent':      return col.c('cloud_sent ');
+    case 'local_only':      return col.g('local_only ');
+    case 'blocked':         return col.r('blocked    ');
+    case 'trimmed':         return col.y('trimmed    ');
+    case 'budget_exceeded': return col.r('budget_exc ');
+    default:                return col.d((et || 'unknown').padEnd(11));
+  }
+}
+
+function resolveEventType(e) {
+  return e.event_type || (e.intercepted ? 'local_only' : 'cloud_sent');
+}
+
+function printEntry(e, idx) {
+  const ts    = e.ts || '??:??:??';
+  const model = (e.model || '—').replace('claude-', '').replace(/-\d{8}$/, '');
+  const inp   = fmtN(e.input_tokens  || 0).padStart(7);
+  const out   = fmtN(e.output_tokens || 0).padStart(5);
+  const cost  = `$${(e.cost || 0).toFixed(4)}`;
+  const et    = resolveEventType(e);
+
+  let extra = '';
+  if ((e.tools_local_count || 0) > 0) extra += col.d(` · ${e.tools_local_count} tools local`);
+  if ((e.lao_tokens_saved  || 0) > 0) extra += col.d(` · ${fmtN(e.lao_tokens_saved)} trimmed`);
+  if (et === 'blocked' && e.secrets?.length > 0)  extra += col.r(` · 🛑 ${e.secrets[0].label || 'secret'}`);
+  if (et !== 'blocked' && e.secrets?.length > 0)  extra += col.y(` · ⚠ ${e.secrets[0].label || 'secret'}`);
+
+  const idxStr = idx !== undefined ? col.d(`${String(idx + 1).padStart(4)}. `) : '      ';
+  console.log(`${idxStr}${col.d(ts)}  ${eventCol(et)}  ${col.d(model.padEnd(16))}  ${col.y(inp)} in /${col.y(out)} out  ${col.g(cost)}${extra}`);
+}
+
+function printSummary(totals, scope, runId) {
+  const { requests, cloud_sent = 0, local_only = 0, blocked = 0, trimmed = 0,
+          budget_exceeded = 0,
+          input_tokens, output_tokens, cost,
+          cache_savings, lao_cost_saved, distill_cost_saved = 0,
+          distill_tokens_saved = 0, tools_local_count } = totals;
+  const saved = (cache_savings || 0) + (lao_cost_saved || 0) + distill_cost_saved;
+
+  console.log(col.b(`\n⚡ Occasio Ledger  —  Summary`));
+  if (runId) console.log(col.d(`   run: ${runId}`));
+  console.log(col.d(`   scope: ${scope}\n`));
+
+  console.log(`  ${col.b('Requests'.padEnd(16))}  ${requests}`);
+  console.log(`  ${col.d('  cloud_sent'.padEnd(16))}  ${cloud_sent}`);
+  if (trimmed)  console.log(`  ${col.d('  trimmed'.padEnd(16))}  ${trimmed}`);
+  console.log(`  ${col.d('  local_only'.padEnd(16))}  ${local_only}`);
+  if (blocked)          console.log(`  ${col.d('  blocked'.padEnd(16))}  ${blocked}`);
+  if (totals.budget_exceeded) console.log(`  ${col.r('  budget_exc'.padEnd(16))}  ${totals.budget_exceeded}`);
+
+  console.log(`\n  ${col.b('Tokens in'.padEnd(16))}  ${fmtN(input_tokens || 0)}`);
+  console.log(`  ${col.b('Tokens out'.padEnd(16))}  ${fmtN(output_tokens || 0)}`);
+  console.log(col.y(`  ${'Cost'.padEnd(18)}  $${(cost || 0).toFixed(4)}`));
+
+  if (saved > 0.00001) {
+    const parts = [];
+    if ((cache_savings       || 0) > 0.00001) parts.push(`cache $${cache_savings.toFixed(4)}`);
+    if ((lao_cost_saved      || 0) > 0.00001) parts.push(`LAO $${lao_cost_saved.toFixed(4)}`);
+    if (distill_cost_saved        > 0.00001)  parts.push(`distill $${distill_cost_saved.toFixed(4)}`);
+    console.log(col.g(`  ${'Saved'.padEnd(18)}  $${saved.toFixed(4)}`) + col.d(` (${parts.join(' + ')})`));
+  }
+
+  if ((tools_local_count || 0) > 0) console.log(col.g(`  ${'Tools local'.padEnd(18)}  ${tools_local_count}`));
+  if (distill_tokens_saved > 0) console.log(col.c(`  ${'Distilled'.padEnd(18)}  ${fmtN(distill_tokens_saved)} tokens saved across tool outputs`));
+  console.log('');
+}
+
+function runLedgerCli(args) {
+  let scope       = 'session';
+  let limit       = 10;
+  let showSummary = false;
+
+  const scopeIdx = args.indexOf('--scope');
+  if (scopeIdx >= 0) scope = args[scopeIdx + 1] || 'session';
+
+  const lastIdx = args.indexOf('--last');
+  if (lastIdx >= 0) limit = parseInt(args[lastIdx + 1], 10) || 10;
+
+  if (args.includes('--summary')) showSummary = true;
+
+  let session = null;
+  try { session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8')); } catch {}
+
+  const todayEntries = readDayLog(todayStr());
+  const entries = scope === 'session'
+    ? readSessionEntries(todayEntries, session?.start)
+    : todayEntries;
+
+  const runId = session?.run_id || null;
+
+  if (showSummary) {
+    printSummary(summarize(entries), scope, runId);
+    return;
+  }
+
+  // List view
+  console.log(col.b(`\n⚡ Occasio Ledger`));
+  let headerLine = '';
+  if (runId) headerLine += col.d(`run: ${runId}`);
+  if (session?.start) headerLine += col.d(`${runId ? '  ·  ' : ''}started ${new Date(session.start).toTimeString().slice(0, 8)}`);
+  if (headerLine) console.log(`   ${headerLine}`);
+  console.log(col.d(`   scope: ${scope}  ·  ${entries.length} entr${entries.length === 1 ? 'y' : 'ies'} total\n`));
+
+  if (!entries.length) {
+    console.log(col.d('   No entries yet. Run: occasio claude\n'));
+    return;
+  }
+
+  const slice  = entries.slice(-limit);
+  const offset = entries.length - slice.length;
+  slice.forEach((e, i) => printEntry(e, offset + i));
+  console.log('');
+
+  if (entries.length > limit) {
+    console.log(col.d(`   Showing last ${limit} of ${entries.length}  ·  --last ${entries.length} for all  ·  --summary for totals\n`));
+  } else {
+    console.log(col.d(`   ${entries.length} entr${entries.length === 1 ? 'y' : 'ies'}  ·  --summary for totals  ·  --scope today for full day\n`));
+  }
+}
+
+module.exports = { readDayLog, readSessionEntries, summarize, runLedgerCli };

package/src/mcp-experiment.js

@@ -0,0 +1,140 @@
+'use strict';
+
+/**
+ * mcp-experiment.js — Reads both log streams and reports MCP vs. built-in adoption.
+ *
+ * Usage:
+ *   node src/mcp-experiment.js              — stats for today's session
+ *   node src/mcp-experiment.js --clear      — wipe mcp-experiment.jsonl and restart count
+ *   node src/mcp-experiment.js --raw        — dump raw MCP log entries
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const col = {
+  r: s => `\x1b[31m${s}\x1b[0m`,
+  g: s => `\x1b[32m${s}\x1b[0m`,
+  y: s => `\x1b[33m${s}\x1b[0m`,
+  c: s => `\x1b[36m${s}\x1b[0m`,
+  d: s => `\x1b[2m${s}\x1b[0m`,
+  b: s => `\x1b[1m${s}\x1b[0m`,
+};
+
+const LOG_DIR     = path.join(os.homedir(), '.occasio');
+const MCP_LOG     = path.join(LOG_DIR, 'mcp-experiment.jsonl');
+const TODAY       = new Date().toISOString().slice(0, 10);
+const SESSION_LOG = path.join(LOG_DIR, 'logs', `${TODAY}.jsonl`);
+
+function runStats() {
+  // ── MCP path: read mcp-experiment.jsonl ──────────────────────────────────────
+  let mcpEntries = [];
+  try {
+    mcpEntries = fs.readFileSync(MCP_LOG, 'utf8').trim().split('\n')
+      .filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  } catch {}
+
+  // ── Built-in path: read today's session log, count intercepted Read/Glob/Grep ─
+  let builtinTools = [];
+  try {
+    const lines = fs.readFileSync(SESSION_LOG, 'utf8').trim().split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        const tools = (entry.tools || []).filter(t => ['Read', 'Glob', 'Grep'].includes(t.tool));
+        builtinTools.push(...tools);
+      } catch {}
+    }
+  } catch {}
+
+  const mcpTotal     = mcpEntries.length;
+  const builtinTotal = builtinTools.length;
+  const total        = mcpTotal + builtinTotal;
+  const mcpPct       = total > 0 ? (mcpTotal / total * 100).toFixed(1) : '—';
+
+  // Aggregate hardening metrics (added in Slice 2)
+  const mcpDistilled   = mcpEntries.filter(e => e.distillSaved > 0).length;
+  const mcpDistillSaved = mcpEntries.reduce((s, e) => s + (e.distillSaved || 0), 0);
+  const mcpSecretsFound = mcpEntries.reduce((s, e) => s + (e.secretsFound || 0), 0);
+
+  console.log(col.b('\n⚡ Occasio MCP Experiment\n'));
+
+  if (total === 0) {
+    console.log(col.d('  No tool calls recorded yet. Run a Claude session first.\n'));
+    console.log(col.d('  Tip: ask Claude to read a file, search code, or list files.\n'));
+    return;
+  }
+
+  console.log(`  MCP path    (mcp__lf__*)          ${col.g(String(mcpTotal).padStart(4))} calls`);
+  console.log(`  Built-in    (Read / Glob / Grep)   ${col.c(String(builtinTotal).padStart(4))} calls`);
+  console.log(`  Total                              ${String(total).padStart(4)} calls`);
+  console.log('');
+  console.log(`  MCP adoption rate: ${col.b(mcpPct + '%')}`);
+
+  // MCP hardening metrics (distillation + secret scanning)
+  if (mcpTotal > 0) {
+    if (mcpDistilled > 0) {
+      console.log(col.d(`  MCP distilled: ${mcpDistilled} calls, ${mcpDistillSaved} tokens saved`));
+    }
+    if (mcpSecretsFound > 0) {
+      console.log(col.r(`  MCP secrets:   ${mcpSecretsFound} credential pattern(s) detected`));
+    }
+  }
+
+  // Breakdown by tool
+  if (mcpTotal > 0) {
+    console.log(col.d('\n  MCP breakdown:'));
+    const byTool = {};
+    for (const e of mcpEntries) byTool[e.tool] = (byTool[e.tool] || 0) + 1;
+    for (const [t, n] of Object.entries(byTool)) {
+      console.log(col.d(`    ${t.padEnd(14)} ${n}`));
+    }
+  }
+  if (builtinTotal > 0) {
+    console.log(col.d('\n  Built-in breakdown:'));
+    const byTool = {};
+    for (const e of builtinTools) byTool[e.tool] = (byTool[e.tool] || 0) + 1;
+    for (const [t, n] of Object.entries(byTool)) {
+      console.log(col.d(`    ${t.padEnd(14)} ${n}`));
+    }
+  }
+
+  // Verdict
+  console.log('');
+  const pct = parseFloat(mcpPct);
+  if (isNaN(pct)) {
+    console.log(col.d('  Not enough data.'));
+  } else if (pct >= 70) {
+    console.log(col.g('  ✓ MCP adoption is strong — MCP-primary architecture is viable.'));
+  } else if (pct >= 30) {
+    console.log(col.y('  ~ Mixed adoption — MCP usable as supplement, interceptor still needed.'));
+  } else {
+    console.log(col.r('  ✗ MCP adoption too low — interceptor must remain primary path.'));
+  }
+  console.log('');
+}
+
+function runClear() {
+  try { fs.unlinkSync(MCP_LOG); console.log(col.g('✓ mcp-experiment.jsonl cleared')); } catch {}
+}
+
+function runRaw() {
+  try {
+    const entries = fs.readFileSync(MCP_LOG, 'utf8').trim().split('\n').filter(Boolean);
+    if (entries.length === 0) { console.log('No MCP calls recorded.'); return; }
+    console.log(col.b(`\n${entries.length} MCP calls:\n`));
+    entries.forEach((l, i) => {
+      try {
+        const e = JSON.parse(l);
+        console.log(`  [${i}] ${e.ts}  ${col.c(e.tool)}  ${col.d(JSON.stringify(e).slice(0, 120))}`);
+      } catch { console.log(`  [${i}] ${l.slice(0, 120)}`); }
+    });
+    console.log('');
+  } catch { console.log('No MCP log found.'); }
+}
+
+const args = process.argv.slice(2);
+if (args.includes('--clear')) runClear();
+else if (args.includes('--raw')) runRaw();
+else runStats();