kodelyth-ecc 2.24.11 → 2.25.0

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v2.25.0 — Foundations: honest numbers, a memory that learns, MCP beyond Claude (November 2026)
+
+The first cut of the v3.0 "Foundations" track. Almost no new surface area — this
+release makes existing systems tell the truth and wires up machinery that was
+built but never connected. Every change ships with tests (48 test files, all
+passing).
+
+**Truth-in-measurement.** Three claims did not match the code, and an enterprise
+audit would catch all three:
+
+- The Terse runtime ledger claimed "every terse-active turn is recorded" — but
+  nothing wrote it, and its per-turn savings were modeled from a fixed multiplier,
+  not measured. Rows are now flagged `estimated: true`, the docs say plainly the
+  figure is an estimate (the Terse *file* compressor stays a real measurement),
+  and the unshipped statusline badge claim is gone.
+- The RTK "5,107,394 tokens / 64.1% — all real" headline was hand-authored copy,
+  not a computed number. It is now labelled an example snapshot that points at
+  `rtk gain` for your own live figures. RTK's `gain` measurement was, and stays,
+  real.
+- The codebase-graph binary's `--version` is unreliable — builds report an old
+  number while exposing much newer tools. ECC no longer trusts it: it detects
+  what the binary can actually do and flags the inconsistency instead of showing
+  a number as fact.
+
+**The memory that learns, now actually learns.** The structured instinct engine
+recorded every correction with confidence, decay, and outcome scoring — and
+nothing ever read it, so none of it influenced a session. Session start now
+injects the high-confidence, non-stale instincts for the current project. The
+dormant loop is closed.
+
+**RTK won't wire the wrong binary.** `reachingforthejack/rtk` (Rust Type Kit)
+ships a binary also called `rtk`; ECC used to treat any `rtk` on PATH as Rust
+Token Killer and would patch hooks into the wrong tool. It now verifies the
+signature (`rtk gain`) before wiring or measuring anything.
+
+**MCP — and therefore memory — reaches beyond Claude Code.** ECC auto-registered
+its MCP server for Claude only, so the whole tool surface, memory included, was
+effectively Claude-exclusive. It now also writes the MCP config for Cursor,
+Windsurf, and Gemini CLI (the IDEs that use the same JSON config shape), reusing
+the hardened merge that never clobbers your other servers. Codex (TOML) and
+Cline/Roo (editor storage) are the next step.
+
+**Fixes found along the way.** `statusAll()` in the MCP registrar called a
+function that no longer existed (`readJson`), so `kodelythecc doctor` and the
+`mcp` status command both threw "readJson is not defined". Fixed.
+
+**Routing.** The intent router learned the newer codebase-graph capabilities:
+smart test selection (`detect_changes scope:tests`), hot-path/complexity queries,
+code-to-docs links, and ADRs.
+
 ## v2.24.11 — every docs page gets its own diagram (October 2026)
 
 Documentation and site only. No code change.

package/README.md

@@ -524,13 +524,16 @@ kodelythecc rtk gain --all             # raw rtk savings output
 kodelythecc rtk --help                 # focused help
 ```
 
-### Live proof (from this repo maintainer's Mac)
+### Example snapshot (one maintainer's Mac, one point in time)
+
+Not a guaranteed figure — RTK measures savings per command, and yours depend on
+which commands you run. Run `rtk gain` to see your own live numbers.
 
 ```
 total_commands:    1,285
 total_input:       7,964,612    (raw)
 total_output:      2,858,501    (after RTK filter)
-total_saved:       5,107,394    ← 64.1% average reduction
+total_saved:       5,107,394    ← 64.1% on this sample
 ```
 
 ---

package/bin/kodelyth-ecc.js

@@ -1883,7 +1883,24 @@ function runPostInstall(status, args) {
         const marker = r.action === 'added' ? '✓ added' : r.action === 'updated' ? '✓ updated' : r.action === 'unchanged' ? '· unchanged' : `· ${r.action}`;
         process.stdout.write(`  ${marker}: ${r.file}\n`);
       }
-      process.stdout.write(`  · Restart Claude Code / Claude Desktop to pick up the server\n`);
+
+      // Also wire ECC's MCP server into the specific non-Claude IDE this install
+      // targeted, when that IDE uses a JSON MCP config we can safely merge
+      // (Cursor, Windsurf, Gemini CLI). This is what extends memory and the whole
+      // MCP tool surface beyond Claude Code — previously they were Claude-only.
+      const mcpTargetIdx = args.indexOf('--target');
+      const mcpRawTarget = mcpTargetIdx >= 0 && args[mcpTargetIdx + 1] ? args[mcpTargetIdx + 1] : 'claude-code';
+      if (!/^claude/.test(mcpRawTarget)) {
+        for (const r of reg.registerForTarget(mcpRawTarget, { cwd: process.cwd(), log: () => {} })) {
+          if (r.action === 'added' || r.action === 'updated') {
+            process.stdout.write(`  ✓ ${r.action}: ${r.file}\n`);
+          } else if (r.action === 'error') {
+            process.stdout.write(`  · skipped ${r.file}: ${r.error}\n`);
+          }
+          // 'unsupported' / 'unchanged' stay quiet — not every target has a JSON MCP config
+        }
+      }
+      process.stdout.write(`  · Restart your AI tool to pick up the server\n`);
     } catch (e) {
       process.stderr.write(`[mcp] self-register skipped: ${e.message}\n`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "2.24.11",
+  "version": "2.25.0",
   "description": "Production-grade AI coding toolkit — 70 agents (incl. devil-mode adversarial crew), 196 skills, 103 commands, parallel multi-agent commands, semantic intent routing, self-learning memory, and a built-in MCP server (16 tools / 6 prompts / 377 resources) that bridges to Claude Desktop, LangGraph, AutoGen, CrewAI, and OpenAI Agents SDK. Works on macOS, Linux and Windows with Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, RooCode, Aider, Kimi, and Gemini CLI.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",

package/rules/common/agent-intent-routing.md

@@ -60,6 +60,10 @@ Beyond the 10 priority tiers below, watch for these newer signals — they map t
 | "talk shorter" / "be brief" / "less verbose" / "caveman mode" | `/terse` (skill activation) |
 | "who calls X" / "where is X used" / "trace the call chain" / "impact analysis" | `codebase-memory-mcp` via `search_graph` / `trace_path` |
 | "index this project" / "build the graph" / "scan the codebase" | `codebase-memory-mcp` via `index_repository` |
+| "which tests does this change affect" / "what tests should I run" / "smart test selection" | `codebase-memory-mcp` via `detect_changes` with `scope: "tests"` (Smart CI) |
+| "find the bottleneck" / "hottest paths" / "most complex functions" / "refactor candidates" | `codebase-memory-mcp` via `query_graph` (complexity / hot-path metrics) |
+| "what docs explain X" / "where is X documented" / "link code to docs" | `codebase-memory-mcp` via `trace_path` (inbound `MENTIONS` edges) |
+| "record this decision" / "write an ADR" / "architecture decision record" | `codebase-memory-mcp` via `manage_adr` |
 | "remove ECC" / "uninstall kodelythecc" / "clean this up" | Suggest `kodelythecc uninstall --dry-run` |
 | "how much did I save" / "show my token savings" / "RTK stats" | `kodelythecc dashboard` OR `kodelythecc rtk gain` |
 | "install for another IDE" / "add to Cursor / Windsurf / Antigravity" | `kodelythecc --target <ide>` |

package/scripts/codebase/index.js

@@ -22,6 +22,52 @@ function getVersion() {
   catch { return null; }
 }
 
+// The binary's `--version` string has proven unreliable: builds have reported an
+// old number (e.g. 0.8.1) while exposing much newer tools and the `--ui` (CBM
+// Lens) flag. So detect what the binary can actually DO from its own help text
+// rather than trusting the version. Pure parser (unit-tested) + a thin probe.
+const KNOWN_CAPABILITIES = {
+  lens:       /--ui\b/,                  // CBM Lens UI (v0.12+)
+  traces:     /\bingest_traces\b/,       // runtime-trace ingestion
+  cypher:     /\bquery_graph\b/,         // Cypher + complexity/hot-path metrics
+  smart_ci:   /\bdetect_changes\b/,      // Smart CI test selection
+  adr:        /\bmanage_adr\b/,          // ADR nodes
+  cross_repo: /cross[-_]repo/,           // cross-repo intelligence
+};
+
+function parseCapabilities(helpText) {
+  const h = String(helpText || '');
+  const caps = {};
+  for (const [name, re] of Object.entries(KNOWN_CAPABILITIES)) caps[name] = re.test(h);
+  return caps;
+}
+
+// When the binary exposes clearly-newer capabilities but reports an old version,
+// the version string is not trustworthy — say so rather than displaying a number
+// ECC would otherwise treat as fact. Returns a note string, or null.
+function versionNote(reportedVersion, caps) {
+  const hasNew   = !!(caps && (caps.lens || caps.traces || caps.cross_repo));
+  const looksOld = !!(reportedVersion && /\b0\.[0-8]\./.test(reportedVersion));
+  if (hasNew && looksOld) {
+    return `binary reports "${reportedVersion}" but exposes newer capabilities — the version string is unreliable; capability detection is authoritative. Run \`kodelythecc codebase install\` to refresh.`;
+  }
+  return null;
+}
+
+// Probe the binary's help (different builds print tools under `--help` or
+// `cli --help`) and parse once. Returns the detected capability map, or all-false
+// if the binary is absent.
+function capabilities() {
+  if (!isInstalled()) return parseCapabilities('');
+  let help = '';
+  for (const argv of [['--help'], ['cli', '--help']]) {
+    try {
+      help += '\n' + execFileSync(BIN, argv, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch { /* try the next help surface */ }
+  }
+  return parseCapabilities(help);
+}
+
 function install({ log = () => {} } = {}) {
   if (isInstalled()) return { installed: false, skipped: true, reason: 'already installed', version: getVersion() };
   if (os.platform() === 'win32') {
@@ -95,7 +141,15 @@ function status() {
   const home = os.homedir();
   const c = path.join(home, '.cache', 'codebase-memory-mcp');
   if (fs.existsSync(c)) cacheDir = c;
-  return { installed: true, version, indexed_projects, cache_dir: cacheDir };
+  const caps = capabilities();
+  return {
+    installed: true,
+    version,
+    version_note: versionNote(version, caps),
+    capabilities: caps,
+    indexed_projects,
+    cache_dir: cacheDir,
+  };
 }
 
 // ── Structural query proxy (thin wrapper over `codebase-memory-mcp cli`) ────
@@ -140,4 +194,7 @@ function dashboardSnapshot() {
   return out;
 }
 
-module.exports = { isInstalled, getVersion, install, autoConfigureAgents, status, query, dashboardSnapshot };
+module.exports = {
+  isInstalled, getVersion, install, autoConfigureAgents, status, query, dashboardSnapshot,
+  capabilities, parseCapabilities, versionNote,
+};

package/scripts/hooks/session-start.js

@@ -22,6 +22,7 @@ const {
   log
 } = require('../lib/utils');
 const { resolveProjectContext, writeSessionLease, resolveSessionId } = require('../lib/observer-sessions');
+const { summarizeStructuredInstincts } = require('../memory/instinct-inject');
 const { getPackageManager, getSelectionPrompt } = require('../lib/package-manager');
 const { listAliases } = require('../lib/session-aliases');
 const { detectProjectType } = require('../lib/project-detect');
@@ -380,6 +381,17 @@ async function main() {
     additionalContextParts.push(instinctSummary);
   }
 
+  // Also inject from the structured instinct store (scripts/memory/instincts.js).
+  // It was written on every correction but never read — this activates the
+  // dormant self-learning loop. Fully fail-safe: never breaks session start.
+  const structuredInstinctSummary = summarizeStructuredInstincts(
+    (observerContext && observerContext.projectRoot) || process.cwd(),
+    { log }
+  );
+  if (structuredInstinctSummary) {
+    additionalContextParts.push(structuredInstinctSummary);
+  }
+
   // Check for recent session files (last 7 days)
   const recentSessions = dedupeRecentSessions(sessionSearchDirs);
 

package/scripts/mcp/register-self.js

@@ -25,6 +25,67 @@ function claudeDesktopConfigPath() {
   return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
 }
 
+// MCP config paths for the non-Claude IDEs ECC can auto-wire. Every target below
+// uses the SAME `{ mcpServers: { <name>: { command, args, env } } }` shape as
+// Claude Code, so the hardened readConfig + registerInFile merge works for all of
+// them unchanged — only the file location differs. That is why memory and the
+// whole MCP tool surface, previously Claude-only, reach these IDEs out of the
+// box once this runs.
+//
+// Deliberately excluded (different format or fragile location — handled manually
+// for now, tracked as a follow-up):
+//   - Codex CLI      → ~/.codex/config.toml  (TOML, not JSON)
+//   - Cline / Roo    → VS Code globalStorage (editor-version-specific path)
+function mcpPathsForTarget(target, cwd = process.cwd()) {
+  const home = os.homedir();
+  switch (target) {
+    case 'claude-code':
+    case 'claude-home':
+      return [claudeCodeConfigPath()];
+    case 'cursor':
+    case 'cursor-project':
+      return [path.join(cwd, '.cursor', 'mcp.json')];
+    case 'windsurf':
+    case 'windsurf-home':
+    case 'windsurf-project':
+      return [path.join(home, '.codeium', 'windsurf', 'mcp_config.json')];
+    case 'gemini-cli':
+    case 'gemini-home':
+    case 'gemini-project':
+      return [path.join(home, '.gemini', 'settings.json')];
+    default:
+      return [];
+  }
+}
+
+// Returns the list of targets this module can auto-wire (for help text / docs).
+function supportedMcpTargets() {
+  return ['claude-code', 'cursor', 'windsurf', 'gemini-cli'];
+}
+
+// Register ECC's MCP server for one install target. Reuses the same merge that
+// protects ~/.claude.json: absent files are created, present files are merged
+// without clobbering other servers, and an unparseable file is refused, never
+// overwritten. Never throws — a bad config for one IDE must not fail an install.
+function registerForTarget(target, { cwd = process.cwd(), log = () => {}, dryRun = false } = {}) {
+  const paths = mcpPathsForTarget(target, cwd);
+  if (paths.length === 0) {
+    return [{ target, action: 'unsupported', reason: `no known JSON MCP config path for "${target}"` }];
+  }
+  const results = [];
+  for (const p of paths) {
+    try {
+      const r = registerInFile(p, { dryRun });
+      log(`  ${r.action}: ${r.file}`);
+      results.push({ target, ...r });
+    } catch (e) {
+      log(`  skipped ${p}: ${e.message}`);
+      results.push({ target, file: p, action: 'error', error: e.message });
+    }
+  }
+  return results;
+}
+
 // Reading this file has THREE outcomes, and collapsing them is destructive.
 //
 // readJson used to return null for every failure, and the caller did
@@ -145,9 +206,19 @@ function unregisterAll({ log = () => {} } = {}) {
 function statusAll() {
   const rows = [];
   for (const p of [claudeCodeConfigPath(), claudeDesktopConfigPath()]) {
-    const cfg = readJson(p);
-    const present = !!(cfg && cfg.mcpServers && cfg.mcpServers[SERVER_NAME]);
-    rows.push({ file: p, present, exists: !!cfg });
+    // Was `readJson(p)` — a function that no longer exists after the
+    // absent/present/unreadable refactor, so statusAll() threw
+    // "readJson is not defined" and took `kodelythecc doctor` and the `mcp`
+    // status command down with it. Use the real reader and its tri-state result.
+    const cfg = readConfig(p);
+    const data = (cfg && cfg.data) || {};
+    const present = !!(data.mcpServers && data.mcpServers[SERVER_NAME]);
+    rows.push({
+      file: p,
+      present,
+      exists: cfg.state !== 'absent',
+      readable: cfg.state !== 'unreadable',
+    });
   }
   return rows;
 }
@@ -157,6 +228,9 @@ module.exports = {
   serverEntry,
   claudeCodeConfigPath,
   claudeDesktopConfigPath,
+  mcpPathsForTarget,
+  supportedMcpTargets,
+  registerForTarget,
   registerAll,
   unregisterAll,
   statusAll,

package/scripts/memory/instinct-inject.js

@@ -0,0 +1,67 @@
+// scripts/memory/instinct-inject.js
+//
+// Consume the structured instinct store (scripts/memory/instincts.js) at session
+// start. That store is written by the correction-capture hook, but until now
+// nothing ever READ it — all of its confidence / decay / outcome machinery ran
+// and never influenced a single session. This module closes that loop: it picks
+// the high-confidence, non-stale instincts relevant to the current project and
+// formats them for injection into SessionStart context.
+//
+// Kept separate from session-start.js (which executes main() at import time) so
+// the selection logic can be unit-tested without running the whole hook.
+'use strict';
+
+const DEFAULT_MAX = 6;
+const DEFAULT_THRESHOLD = 0.7;
+
+// Pure selection + formatting. Given raw instinct records, keep the ones that
+// are non-stale, confident enough, and in scope for `projectPath`; rank by
+// confidence; cap at `max`; render as injectable markdown. No I/O — this is the
+// unit the tests exercise.
+function formatStructuredInstincts(instincts, { projectPath, max = DEFAULT_MAX, threshold = DEFAULT_THRESHOLD } = {}) {
+  const candidates = (Array.isArray(instincts) ? instincts : [])
+    .filter(i => i && typeof i.rule === 'string' && i.rule.trim())
+    .filter(i => !i.stale && (i.confidence || 0) >= threshold)
+    // Global instincts always apply; project-scoped ones only in their project.
+    // A record with no project_path is treated as unscoped (applies anywhere).
+    .filter(i => i.scope === 'global' || !i.project_path || i.project_path === projectPath);
+
+  if (candidates.length === 0) return '';
+
+  const ranked = candidates
+    .slice()
+    .sort((a, b) => (b.confidence || 0) - (a.confidence || 0))
+    .slice(0, max);
+
+  const lines = ranked.map(i => {
+    const scope = i.scope === 'project' ? 'project' : 'global';
+    const confidence = `${Math.round((i.confidence || 0) * 100)}%`;
+    return `- [${scope} ${confidence}] ${i.rule.trim()}`;
+  });
+
+  return `Learned instincts (from past corrections):\n${lines.join('\n')}`;
+}
+
+// Read the store and format. Never throws: the structured store must not be able
+// to break session start, so any failure degrades to injecting nothing.
+function summarizeStructuredInstincts(projectPath, { log = () => {} } = {}) {
+  try {
+    const store = require('./instincts');
+    const summary = formatStructuredInstincts(store.list(), { projectPath });
+    if (summary) {
+      const count = summary.split('\n').length - 1;
+      log(`[SessionStart] Injecting ${count} learned instinct(s) from the structured store`);
+    }
+    return summary;
+  } catch (err) {
+    log(`[SessionStart] Structured instinct injection skipped: ${err && err.message}`);
+    return '';
+  }
+}
+
+module.exports = {
+  formatStructuredInstincts,
+  summarizeStructuredInstincts,
+  DEFAULT_MAX,
+  DEFAULT_THRESHOLD,
+};

package/scripts/rtk/index.js

@@ -64,11 +64,51 @@ function detectInstalledTargets() {
   return targets;
 }
 
+// Guard against the `rtk` name collision. reachingforthejack/rtk (Rust Type Kit)
+// also ships a binary called `rtk`; wiring or measuring it as if it were Rust
+// Token Killer would be wrong and silent — ECC would patch hooks and read a
+// `gain` ledger that does not exist. Rust Token Killer is the only `rtk` with a
+// `gain` subcommand (the token-savings ledger ECC reads), so probing it
+// distinguishes the two with no side effects and without depending on exact
+// `--version` text. `rtk gain` is the documented signature command in RTK.md.
+//
+// The decision is a pure function of two probe results so it can be unit-tested
+// without spawning a binary:
+//   gainHelpOk — did `rtk gain --help` exit 0?
+//   helpText   — stdout of `rtk --help` (or '' if it failed)
+function looksLikeRealRtk({ gainHelpOk, helpText } = {}) {
+  if (gainHelpOk) return true;
+  const h = String(helpText || '');
+  // The token killer's help lists the `gain` command and calls itself an
+  // LLM-output proxy; Rust Type Kit's help does neither.
+  return /\bgain\b/.test(h) && /(LLM|token|proxy)/i.test(h);
+}
+
+function isRealRtk() {
+  let gainHelpOk = false;
+  try {
+    execFileSync('rtk', ['gain', '--help'], { stdio: 'ignore' });
+    gainHelpOk = true;
+  } catch { /* `gain` subcommand absent, or `rtk` not runnable */ }
+
+  let helpText = '';
+  if (!gainHelpOk) {
+    try {
+      helpText = execFileSync('rtk', ['--help'], {
+        encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+      });
+    } catch { /* no help available */ }
+  }
+  return looksLikeRealRtk({ gainHelpOk, helpText });
+}
+
 function isInstalled() {
   try {
     execFileSync('rtk', ['--version'], { stdio: 'ignore' });
-    return true;
   } catch { return false; }
+  // A binary named `rtk` exists — confirm it is Rust Token Killer, not the Rust
+  // Type Kit collision, before any caller wires or measures it.
+  return isRealRtk();
 }
 
 function getVersion() {
@@ -214,6 +254,8 @@ module.exports = {
   normalizeTarget,
   detectInstalledTargets,
   isInstalled,
+  isRealRtk,
+  looksLikeRealRtk,
   getVersion,
   install,
   enableFor,

package/scripts/terse/ledger.js

@@ -1,9 +1,16 @@
 // scripts/terse/ledger.js
-// Output-token savings ledger. Stores one JSONL row per terse-active turn.
-// Zero deps. Reads only. Writes append-only.
+// Output-token savings ledger. Stores one JSONL row per recorded terse turn.
+// Zero deps. Writes append-only.
+//
+// IMPORTANT — these rows are ESTIMATES, not measured savings. There is no
+// non-terse copy of the same reply to diff against, so `saved` is modeled:
+// actual output tokens times a per-level baseline multiplier (RAW_MULT below).
+// Every figure here is an estimate and each row is flagged `estimated: true`.
+// (The Terse *file* compressor in compress.js, by contrast, reports real,
+// measured before/after bytes.)
 //
 // Row shape:
-//   { ts, level, rawEstimate, actual, saved, projectHash?, source }
+//   { ts, level, rawEstimate, actual, saved, estimated, baseline, projectHash?, source }
 //
 // Path: ~/.kodelythecc/terse/ledger.jsonl (overridable via KODELYTH_TERSE_DIR)
 
@@ -31,8 +38,10 @@ function estimateTokens(text) {
   return Math.round(Buffer.byteLength(text, 'utf8') / 4);
 }
 
-// Baseline output multiplier per level.
-// Empirically: full ≈ 0.5x normal, ultra ≈ 0.35x, lite ≈ 0.75x.
+// Per-level baseline multiplier used to MODEL what the same reply would have
+// cost without terse (full ≈ 2x the terse size, ultra ≈ 2.85x, lite ≈ 1.33x).
+// These are assumptions, not measurements — every `saved` figure derived from
+// them is an estimate, which is why each row is flagged `estimated: true`.
 const RAW_MULT = { lite: 1.33, full: 2.0, ultra: 2.85, off: 1.0 };
 
 function appendTurn({ actualText, level = 'full', source = 'unknown', projectHash = null }) {
@@ -46,6 +55,8 @@ function appendTurn({ actualText, level = 'full', source = 'unknown', projectHas
     rawEstimate,
     actual,
     saved,
+    estimated: true,                 // modeled from RAW_MULT, not a measured A/B
+    baseline: RAW_MULT[level] || 1,
     source,
     ...(projectHash ? { projectHash } : {}),
   };

package/skills/terse-mode/SKILL.md

@@ -83,7 +83,7 @@ Example — ~70% shorter:
 
 - Slash command: `/terse [lite|full|ultra|off]` — sticks for the session
 - CLI: `kodelyth-ecc terse enable [--target claude-code|--all]` — installs the skill + command into your AI tool
-- Statusline (Claude Code): shows `[TERSE ⚡ 12.4k]` — lifetime output tokens saved
+- Dashboard (Claude Code): the **Token Savings** tab shows lifetime *estimated* output savings from the terse ledger — modeled, not measured (see the ledger note in `docs/terse-mode.md`)
 
 ## Honest numbers