kodelyth-ecc 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v2.4.0 — MCP auto-register + full uninstall (July 2026)
+
+Real bugs surfaced by live user testing on a fresh Mac install.
+
+### Fixed
+
+- **ECC's own MCP server was never registered anywhere** on install. Result: Claude Desktop showed "1 setup issue: MCP", the Codebase / MCP status views showed nothing, and no tool got to talk to our own MCP. `scripts/mcp/register-self.js` now writes `kodelyth-ecc` under `mcpServers` in both `~/.claude.json` (Claude Code) and `~/Library/Application Support/Claude/claude_desktop_config.json` (Claude Desktop). Idempotent — no duplicates on re-run.
+- **Codebase Architecture snapshot was empty** on the dashboard when no active session graph existed. Dashboard now falls back to a per-project list (project name + nodes + edges) via `list_projects`, so users can see the 8 projects codebase-memory-mcp has indexed even before opening one in-session.
+- **`mcp-register` subcommand was swallowed** by the `mcp-*` catch-all (like `mcp-status` was earlier). Excluded properly.
+
+### Added
+
+**MCP self-registration**
+- `kodelythecc mcp-register` — write ECC's MCP entry into Claude Code + Desktop configs
+- `kodelythecc mcp-register --status` — show which configs already have it
+- `kodelythecc mcp-register --unregister` — remove ECC's entry
+- **Auto-runs in post-install** — after `--target claude-code` succeeds, ECC registers itself in both configs and prints a summary. Opt out with `--no-mcp-register`
+
+**Full uninstall** (`scripts/cli/uninstall.js`)
+- New menu row: **Uninstall ECC completely**
+- CLI: `kodelythecc uninstall --dry-run | --yes | --yes --keep-memory`
+- Removes only files that were shipped by ECC (checks against the package's own `agents/skills/commands/hooks/rules/scripts/` — safe for user-authored siblings)
+- Unwires RTK (`rtk init -g --uninstall`)
+- Removes codebase-memory-mcp agent configs (`codebase-memory-mcp uninstall`)
+- Removes ECC's MCP entry from Claude Code + Desktop
+- Removes `~/.kodelythecc/` (memory + ledgers + cache)
+- Removes legacy `.kodelyth.backup-*` dirs
+- Dry-run mode identifies **759 ECC files** across 6 subdirs on a fresh install
+
+### Verified live end-to-end on this Mac
+
+- `mcp-register --status` (before): both configs empty
+- `mcp-register` writes both:
+  ```json
+  "kodelyth-ecc": { "command": "kodelythecc", "args": ["mcp"], "env": {} }
+  ```
+- `~/.claude.json` now has `mcpServers.kodelyth-ecc` + existing `mcpServers.codebase-memory-mcp` (co-existing, no clobber)
+- `uninstall --dry-run` correctly counts 70 agents + 301 skills + 99 commands + 12 hooks + 104 rules + 173 scripts = 759 files, plus 1 backup dir
+- Nothing removed on dry-run — verified
+
 ## v2.3.0 — Interactive arrow-key CLI menu (July 2026)
 
 Run `kodelythecc` (or `kodelyth-ecc`) with no args in a real terminal and an arrow-key menu opens.

package/README.md

@@ -19,11 +19,22 @@
 ![Auto Recall](https://img.shields.io/badge/Auto%20Chat%20Recall-on-blueviolet)
 ![Parallel Agents](https://img.shields.io/badge/Parallel%20Agents-new-red)
 ![Image Generation](https://img.shields.io/badge/AI%20Image%20Gen-new-yellow)
+![RTK](https://img.shields.io/badge/RTK-input%20savings-orange)
+![Terse Mode](https://img.shields.io/badge/Terse%20Mode-output%20savings-orange)
+![Codebase Graph](https://img.shields.io/badge/Codebase%20Graph-158%20languages-green)
+![Interactive CLI](https://img.shields.io/badge/CLI-interactive%20menu-blue)
 
 </div>
 
 **Kodelyth ECC** is a production-grade AI coding toolkit — **70 specialist agents (incl. an 8-agent devil-mode adversarial crew), 194 skills, 97 commands**, a god-tier **semantic intent-routing system**, local self-learning memory, MCP server, swarm orchestrator, and an observability dashboard — all local, zero telemetry.
 
+Now bundled with:
+
+- **RTK** (Rust Token Killer, Apache-2.0) — auto-compresses shell command output for **60-90% input token savings**
+- **Terse mode** (ECC-native, inspired by Caveman) — 4-level output-token compression dial for **40-70% output savings**
+- **Codebase graph** (via [codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp), MIT) — AST-parsed knowledge graph across 158 languages; structural queries at **99% fewer tokens** than file-by-file grep
+- **Interactive CLI** — type `kodelythecc` alone in a terminal for an arrow-key menu with live update check, dashboard, background daemon
+
 Works with **Claude Code**, **Windsurf**, **Cursor**, **Codex CLI**, **Google Antigravity**, **OpenCode**, **Cline**, **Roo Code**, **Aider**, **Kimi**, and **Gemini CLI**.
 
 > No telemetry. No cloud. Just rules, agents, skills, MCP server, and your own private memory store — all on your disk. The local dashboard gives you full visibility without sending anything anywhere.
@@ -88,6 +99,25 @@ You never typed `use debug-detective`. You didn't have to. The toolkit read the
 <img src="social/section-install.svg" alt="Install — One command, 11 platforms, any OS" width="900"/>
 </div>
 
+### The lazy install (one command, everything wired up)
+
+```bash
+npm i -g kodelyth-ecc
+kodelythecc --target claude-code --codebase-graph
+# then restart your AI tool
+```
+
+That's it. This single flow:
+
+1. Installs both binaries (`kodelyth-ecc` and short-form `kodelythecc`) to your PATH
+2. Copies 70 agents + 194 skills + 97 commands + 22 hooks + 14 rules into your AI tool's config dir
+3. Auto-installs **RTK** binary and wires its PreToolUse hook (input compression starts on next AI restart)
+4. Installs **Terse mode** skill + `/terse` and `/terse-compress` slash commands (dormant — user types `/terse` to activate)
+5. Auto-installs **codebase-memory-mcp** and registers its MCP entries in your AI tool (with `--codebase-graph`)
+6. Runs legacy-memory migration if you had `~/.kodelyth/` from an older install → `~/.kodelythecc/`
+
+After it finishes, run `kodelythecc` alone to open the interactive menu.
+
 ### Option 1 — npx from npm (recommended, any platform)
 
 ```bash
@@ -398,6 +428,169 @@ Full reference: [`docs/dashboard.md`](docs/dashboard.md).
 
 ---
 
+## RTK — Input Token Savings (60-90%)
+
+[RTK (Rust Token Killer)](https://github.com/rtk-ai/rtk) — Apache-2.0, single Rust binary — intercepts shell commands before they run and filters the output. Common commands like `git status`, `ls`, `cargo test`, `docker ps` return ~80% less text with zero information loss for the LLM.
+
+ECC bundles RTK end-to-end:
+
+- Auto-installs the binary via Homebrew (macOS) or curl script (Linux / WSL)
+- Auto-configures the PreToolUse hook in your AI tool's settings
+- Live ledger surfaced in the dashboard's **Token Savings** tab
+
+### Manage from the CLI
+
+```bash
+kodelythecc rtk install                # install rtk binary
+kodelythecc rtk enable --target X      # wire into one IDE
+kodelythecc rtk enable --all           # wire into every ECC-installed IDE at once
+kodelythecc rtk status                 # version + active integrations
+kodelythecc rtk gain --all             # raw rtk savings output
+kodelythecc rtk --help                 # focused help
+```
+
+### Live proof (from this repo maintainer's Mac)
+
+```
+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
+```
+
+---
+
+## Terse Mode — Output Token Savings (40-70%)
+
+RTK compresses input. **Terse mode** compresses output. Together they stack — savings on both sides of every turn.
+
+ECC's own implementation, inspired by [Caveman](https://github.com/JuliusBrussee/caveman) (MIT), independently written. Ships as a skill + two slash commands + a deterministic zero-dep memory-file compressor.
+
+### Four levels
+
+Type `/terse` in your AI tool. Level sticks until you switch or session ends.
+
+| Level | Style |
+|---|---|
+| `/terse off` | Normal AI voice |
+| `/terse lite` | Light trim, drop filler ("basically", "essentially") |
+| `/terse full` | Telegram-style fragments (default) |
+| `/terse ultra` | Maximum compression, symbols over words |
+
+**Byte-preserved always**: fenced code blocks, inline code, shell commands, error text, URLs, file paths, identifiers, numbers, versions.
+
+### Compress memory files permanently
+
+`/terse-compress` (or `kodelythecc terse compress <file>`) rewrites `CLAUDE.md`-style memory files into terse form so they cost fewer tokens **every session forever**. ~30% average byte reduction on real prose, 100% code/URL/path integrity.
+
+### CLI
+
+```bash
+kodelythecc terse status                # skill install state
+kodelythecc terse stats                 # tokens saved from ledger
+kodelythecc terse compress <file>       # rewrite a file, byte-preserves code
+kodelythecc terse enable --all          # install skill + commands into every ECC IDE
+kodelythecc terse --help
+```
+
+---
+
+## Codebase Graph — 158 Languages, Structural Queries
+
+Powered by [DeusData/codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp) (MIT). AST-parsed knowledge graph via tree-sitter across **158 languages**, Hybrid LSP semantic type resolution for 11 major languages, cross-service HTTP/gRPC/GraphQL linking, 14 MCP tools for structural queries.
+
+**Why this matters**: "Who calls `ProcessOrder`?" via file-by-file grep = ~412k tokens. Same question via the graph = ~3.4k tokens. That's a **99% reduction** on structural questions.
+
+### Auto-install path
+
+Pass `--codebase-graph` on ECC install and it auto-runs their official curl script + auto-configures the MCP server entry in every installed AI-coding agent.
+
+```bash
+kodelythecc --target claude-code --codebase-graph
+# ↑ installs ECC + RTK + Terse + codebase-memory-mcp, all wired up
+```
+
+Then in your AI tool, say **"Index this project"**. Done.
+
+### CLI
+
+```bash
+kodelythecc codebase install                              # install + auto-register
+kodelythecc codebase status                               # version + indexed projects
+kodelythecc codebase query search_graph '{"name_pattern": ".*Handler.*"}'
+kodelythecc codebase query trace_path '{"function_name": "main"}'
+kodelythecc codebase query get_architecture '{}'
+kodelythecc codebase --help
+```
+
+---
+
+## Interactive CLI Menu
+
+Type `kodelythecc` alone in a real terminal → arrow-key menu opens.
+
+```
+⚙ Kodelyth ECC  v2.3.0  ·  Elite Code Crew   up to date
+
+ ▸ Open Dashboard                     localhost — RTK, Terse, Codebase, Memory
+   Install ECC for another IDE        13-target picker
+   RTK status                         Version + wired IDEs + savings
+   Terse status                       Skill install state, ledger totals
+   Codebase graph status              158 languages, structural queries
+   Memory stats                       BM25 recall — captures, projects, tags
+   Run in background                  Detached dashboard daemon
+   Exit
+
+↑/↓ navigate  ·  ⏎ select  ·  q / esc / Ctrl+C to quit
+```
+
+### Behaviour rules
+
+| Situation | Menu opens? |
+|---|---|
+| `kodelythecc` in Terminal / iTerm | **Yes** |
+| `kodelythecc rtk status` (any subcommand) | No — runs subcommand |
+| `echo hi \| kodelythecc` (piped) | No — runs installer |
+| CI environment (`$CI` set) | No |
+| `KODELYTH_NO_MENU=1 kodelythecc` | No |
+
+### Uninstall
+
+The menu's **Uninstall ECC completely** row runs an interactive full cleanup: removes the 759 ECC-installed files from `~/.claude/`, unwires RTK from your AI tool, removes codebase-memory-mcp agent configs, removes ECC's MCP entry from Claude Code + Claude Desktop, and deletes `~/.kodelythecc/` (memory + ledgers). Prompts confirm before anything is deleted; a dry-run mode previews what would be removed without touching anything.
+
+You can also run it non-interactively:
+
+```bash
+kodelythecc uninstall --dry-run           # preview what would be removed
+kodelythecc uninstall --yes                # full cleanup
+kodelythecc uninstall --yes --keep-memory  # remove files but keep ~/.kodelythecc/
+npm uninstall -g kodelyth-ecc              # finally remove the npm package itself
+```
+
+### Update check
+
+The menu polls `https://registry.npmjs.org/kodelyth-ecc/latest` on open. Cached 24h in `~/.kodelythecc/update-check.json`. When a newer version exists, an extra menu row appears at the top:
+
+```
+ ▸ Update to v2.3.1 [NEW]              npm i -g kodelyth-ecc
+```
+
+### Background daemon
+
+Selecting "Run in background" forks the dashboard as a detached process:
+
+```
+✓ Dashboard daemon started (pid 12345)
+  URL:    http://127.0.0.1:5747
+  Log:    /Users/you/.kodelythecc/dashboard-daemon.log
+  Pid:    /Users/you/.kodelythecc/dashboard-daemon.pid
+  Stop:   kill $(cat ~/.kodelythecc/dashboard-daemon.pid)
+```
+
+Survives shell exit. Real daemon.
+
+---
+
 ## Kodelyth Memory — Local Self-Learning
 
 <div align="center">

package/VERSION

@@ -1 +1 @@
-2.3.0
+2.4.0

package/bin/kodelyth-ecc.js

@@ -135,7 +135,7 @@ if (args[0] === 'mcp') {
 //   kodelyth-ecc mcp-remove <name>
 //   kodelyth-ecc mcp-tools <name>
 //   kodelyth-ecc mcp-call <name> <tool> [--json '{"arg":"value"}']
-if (args[0] && args[0].startsWith('mcp-')) {
+if (args[0] && args[0].startsWith('mcp-') && !['mcp-register'].includes(args[0])) {
   (async () => {
     const sub = args[0].slice(4);
     const client = require(path.join(ROOT, 'scripts', 'mcp', 'client.js'));
@@ -339,6 +339,40 @@ if (args[0] === 'rtk') {
   return;
 }
 
+// ── Subcommand: uninstall (full ECC removal) ────────────────────────────────
+if (args[0] === 'uninstall') {
+  const un = require(path.join(ROOT, 'scripts', 'cli', 'uninstall.js'));
+  const dryRun = args.includes('--dry-run');
+  const keepMemory = args.includes('--keep-memory');
+  const yes = args.includes('--yes') || args.includes('-y');
+  if (!yes && !dryRun) {
+    process.stderr.write('This removes ECC files, RTK hooks, codebase-memory-mcp configs, and (unless --keep-memory) ~/.kodelythecc/. Add --yes to confirm or --dry-run to preview.\n');
+    process.exit(1);
+  }
+  const r = un.run({ log: (m) => process.stdout.write(m + '\n'), dryRun, keepMemory });
+  process.stdout.write(`\nRemoved ${r.removed_files} files across ${r.subsystems_uninstalled.length} subsystems.\n`);
+  if (r.errors.length) process.stdout.write(`Errors: ${r.errors.length}\n${r.errors.map(e => '  ' + e).join('\n')}\n`);
+  process.stdout.write(dryRun ? '(dry-run — no changes made)\n' : 'ECC removed. Uninstall the npm package: npm uninstall -g kodelyth-ecc\n');
+  process.exit(0);
+}
+
+// ── Subcommand: mcp-register (self-register ECC MCP in Claude Code + Desktop)
+if (args[0] === 'mcp-register') {
+  const reg = require(path.join(ROOT, 'scripts', 'mcp', 'register-self.js'));
+  if (args.includes('--status')) {
+    const s = reg.statusAll();
+    for (const row of s) process.stdout.write(`${row.present ? '✓' : '·'} ${row.file}${row.exists ? '' : ' (file missing)'}\n`);
+    process.exit(0);
+  }
+  if (args.includes('--unregister')) {
+    reg.unregisterAll({ log: (m) => process.stdout.write(m + '\n') });
+    process.exit(0);
+  }
+  reg.registerAll({ log: (m) => process.stdout.write(m + '\n') });
+  process.stdout.write('\nRestart Claude Code / Claude Desktop to pick up the new MCP server.\n');
+  process.exit(0);
+}
+
 // ── Subcommand: codebase (DeusData code-graph MCP integration) ───────────────
 // Usage:
 //   kodelyth-ecc codebase install                install the codebase-memory-mcp binary
@@ -1451,6 +1485,22 @@ if (isWin) {
   fs.chmodSync(sh, 0o755);
   const result = spawnSync('bash', [sh, ...args], { stdio: 'inherit', shell: false });
 
+  // Post-install: auto-register ECC's own MCP server in Claude Code + Desktop.
+  if (result.status === 0 && !args.includes('--no-mcp-register')) {
+    try {
+      const reg = require(path.join(ROOT, 'scripts', 'mcp', 'register-self.js'));
+      process.stdout.write('\n━ ECC MCP server registration ' + '─'.repeat(31) + '\n');
+      const rows = reg.registerAll({ log: () => {} });
+      for (const r of rows) {
+        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`);
+    } catch (e) {
+      process.stderr.write(`[mcp] self-register skipped: ${e.message}\n`);
+    }
+  }
+
   // Post-install: auto-install + wire RTK for the target IDE (opt-out via --no-rtk).
   if (result.status === 0 && !args.includes('--no-rtk')) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Production-grade AI coding toolkit — 70 agents (incl. devil-mode adversarial crew), 194 skills, 97 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 with Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, RooCode, Aider, Kimi, and Gemini CLI.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",

package/scripts/cli/menu.js

@@ -89,6 +89,11 @@ async function buildOptions({ ROOT }) {
     hint:  'Detach dashboard as a daemon so /api routes stay reachable',
     run:   () => runBackground(),
   });
+  opts.push({
+    label: 'Uninstall ECC completely',
+    hint:  'Remove agents/skills/commands/hooks, RTK hook, codebase-mcp, and ~/.kodelythecc/',
+    run:   () => runUninstall(ROOT),
+  });
   opts.push({
     label: 'Exit',
     hint:  '',
@@ -149,6 +154,42 @@ async function pickIdeAndInstall(ROOT) {
   waitForEnter().then(() => main().catch(() => process.exit(0)));
 }
 
+async function runUninstall(ROOT) {
+  cleanup();
+  console.log(`${C.red}${C.bold}⚠  Uninstall Kodelyth ECC${C.reset}`);
+  console.log('');
+  console.log('This will remove:');
+  console.log(`  ${C.gray}·${C.reset} All ECC agents/skills/commands/hooks/rules installed under ~/.claude/`);
+  console.log(`  ${C.gray}·${C.reset} RTK hook (rtk binary stays — remove with brew uninstall rtk)`);
+  console.log(`  ${C.gray}·${C.reset} codebase-memory-mcp agent configs (binary stays)`);
+  console.log(`  ${C.gray}·${C.reset} ECC MCP server entry from Claude Code + Claude Desktop`);
+  console.log(`  ${C.gray}·${C.reset} ~/.kodelythecc/ (memory, ledgers, cache) — unless you keep it`);
+  console.log('');
+  const choice = await pick('Confirm', [
+    'Uninstall — remove EVERYTHING including memory',
+    'Uninstall — keep ~/.kodelythecc/ memory + ledgers',
+    'Dry run — show what would be removed, change nothing',
+    'Cancel',
+  ]);
+  if (choice == null || choice === 3) return main();
+  const dryRun = choice === 2;
+  const keepMemory = choice === 1;
+  cleanup();
+  console.log('');
+  const un = require(path.join(ROOT, 'scripts', 'cli', 'uninstall.js'));
+  const r = un.run({ log: (m) => console.log(m), dryRun, keepMemory });
+  console.log('');
+  console.log(`${C.green}✓${C.reset} Removed ${C.bold}${r.removed_files}${C.reset} files across ${r.subsystems_uninstalled.length} subsystems.`);
+  if (r.errors.length) console.log(`${C.yellow}Errors: ${r.errors.length}${C.reset}`);
+  if (dryRun) {
+    console.log(`${C.dim}(dry-run — nothing was changed)${C.reset}`);
+  } else {
+    console.log('');
+    console.log(`Finish by removing the npm package: ${C.cyan}npm uninstall -g kodelyth-ecc${C.reset}`);
+  }
+  process.exit(0);
+}
+
 function runBackground() {
   cleanup();
   const logDir = path.join(os.homedir(), '.kodelythecc');

package/scripts/cli/uninstall.js

@@ -0,0 +1,148 @@
+// scripts/cli/uninstall.js
+// Full ECC cleanup — reverses everything the installer + post-install did.
+// Safe: only removes files installed BY ECC (checks for known markers).
+// Never touches user's own custom agents/skills/commands they added themselves.
+
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// ── What ECC ships — used to identify which files WE installed ─────────────
+function listShippedFiles(ROOT, subdir) {
+  const src = path.join(ROOT, subdir);
+  if (!fs.existsSync(src)) return [];
+  const out = [];
+  const walk = (dir, prefix = '') => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const rel = path.join(prefix, entry.name);
+      const abs = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(abs, rel);
+      else out.push(rel);
+    }
+  };
+  walk(src);
+  return out;
+}
+
+// Only remove files that also exist in the ECC package.
+// Preserves user-authored files in the same directory.
+function removeInstalledFiles(destDir, shipped) {
+  if (!fs.existsSync(destDir)) return { removed: 0, skipped: 0 };
+  let removed = 0, skipped = 0;
+  for (const rel of shipped) {
+    const abs = path.join(destDir, rel);
+    if (fs.existsSync(abs)) {
+      try { fs.unlinkSync(abs); removed++; } catch { skipped++; }
+    }
+  }
+  // Clean up now-empty ECC-owned directories.
+  const dirs = new Set(shipped.map(f => path.dirname(f)).filter(d => d !== '.'));
+  for (const rel of [...dirs].sort((a, b) => b.length - a.length)) {
+    const abs = path.join(destDir, rel);
+    try {
+      if (fs.existsSync(abs) && fs.readdirSync(abs).length === 0) fs.rmdirSync(abs);
+    } catch { /* keep going */ }
+  }
+  return { removed, skipped };
+}
+
+function rmrf(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); return true; }
+  catch { return false; }
+}
+
+// ── The uninstall plan (dry-run friendly) ──────────────────────────────────
+function plan(ROOT) {
+  const home = os.homedir();
+  const claudeDir = path.join(home, '.claude');
+  const shipped = {
+    agents:   listShippedFiles(ROOT, 'agents'),
+    skills:   listShippedFiles(ROOT, 'skills'),
+    commands: listShippedFiles(ROOT, 'commands'),
+    hooks:    listShippedFiles(ROOT, 'hooks'),
+    rules:    listShippedFiles(ROOT, 'rules'),
+    scripts:  listShippedFiles(ROOT, 'scripts'),
+  };
+  const dests = {
+    agents:   path.join(claudeDir, 'agents'),
+    skills:   path.join(claudeDir, 'skills'),
+    commands: path.join(claudeDir, 'commands'),
+    hooks:    path.join(claudeDir, 'hooks'),
+    rules:    path.join(claudeDir, 'rules'),
+    scripts:  path.join(claudeDir, 'scripts'),
+  };
+  return { home, claudeDir, shipped, dests };
+}
+
+// ── Run the uninstall ──────────────────────────────────────────────────────
+function run({ log = () => {}, keepMemory = false, dryRun = false } = {}) {
+  const ROOT = path.join(__dirname, '..', '..');
+  const p = plan(ROOT);
+  const results = { removed_files: 0, dirs_removed: [], subsystems_uninstalled: [], errors: [] };
+
+  log('Removing ECC-installed files from ~/.claude/ …');
+  for (const kind of Object.keys(p.shipped)) {
+    if (dryRun) {
+      log(`  [dry-run] would remove ${p.shipped[kind].length} ${kind} files from ${p.dests[kind]}`);
+      continue;
+    }
+    const r = removeInstalledFiles(p.dests[kind], p.shipped[kind]);
+    results.removed_files += r.removed;
+    log(`  ${kind}: removed ${r.removed} files (${r.skipped} skipped)`);
+  }
+
+  // Remove ECC's own MCP entries from Claude Code / Claude Desktop configs.
+  try {
+    const reg = require('../mcp/register-self.js');
+    if (!dryRun) reg.unregisterAll({ log: (m) => log('  ' + m) });
+    else         log('  [dry-run] would unregister kodelyth-ecc MCP server from Claude Code + Desktop');
+    results.subsystems_uninstalled.push('mcp-registration');
+  } catch (e) { results.errors.push('mcp-unregister: ' + e.message); }
+
+  // Remove RTK integration (uses their own uninstall flag).
+  try {
+    log('Unwiring RTK integrations …');
+    if (!dryRun) {
+      const r = spawnSync('rtk', ['init', '-g', '--uninstall'], { encoding: 'utf8' });
+      log(r.status === 0 ? '  ✓ rtk uninstalled from claude-code' : '  · rtk uninstall skipped (may not be present)');
+    }
+    results.subsystems_uninstalled.push('rtk');
+  } catch (e) { results.errors.push('rtk: ' + e.message); }
+
+  // Remove codebase-memory-mcp registration (their own uninstall).
+  try {
+    log('Uninstalling codebase-memory-mcp agent configs …');
+    if (!dryRun) {
+      const r = spawnSync('codebase-memory-mcp', ['uninstall'], { encoding: 'utf8' });
+      log(r.status === 0 ? '  ✓ codebase-memory-mcp configs removed' : '  · codebase-memory-mcp uninstall skipped (binary not present)');
+    }
+    results.subsystems_uninstalled.push('codebase-memory-mcp');
+  } catch (e) { results.errors.push('codebase-memory-mcp: ' + e.message); }
+
+  // Remove memory + ledgers.
+  if (!keepMemory) {
+    log(`${dryRun ? '[dry-run] would remove' : 'Removing'} ~/.kodelythecc/ (memory, ledgers, cache) …`);
+    const target = path.join(p.home, '.kodelythecc');
+    if (!dryRun && rmrf(target)) results.dirs_removed.push(target);
+  } else {
+    log('Keeping ~/.kodelythecc/ (memory preserved as requested)');
+  }
+
+  // Remove legacy migration backup if present.
+  try {
+    for (const name of fs.readdirSync(p.home)) {
+      if (name.startsWith('.kodelyth.backup-')) {
+        const abs = path.join(p.home, name);
+        if (dryRun) log(`  [dry-run] would remove backup ${abs}`);
+        else { rmrf(abs); results.dirs_removed.push(abs); }
+      }
+    }
+  } catch { /* home dir listing failed — skip */ }
+
+  return results;
+}
+
+module.exports = { plan, run };

package/scripts/codebase/index.js

@@ -86,6 +86,21 @@ function dashboardSnapshot() {
   const st = status();
   if (!st.installed) return { ok: false, installed: false, install_hint: 'Run: kodelyth-ecc codebase install' };
   const out = { ok: true, installed: true, version: st.version, indexed_projects: st.indexed_projects, cache_dir: st.cache_dir };
+  // Try to list projects with names — richer than just a count.
+  try {
+    const list = query('list_projects', '{}');
+    if (Array.isArray(list)) {
+      out.projects = list.slice(0, 20).map(p => ({
+        name: p.name || p.path || p.project || 'unnamed',
+        path: p.path || null,
+        nodes: p.node_count ?? p.nodes ?? null,
+        edges: p.edge_count ?? p.edges ?? null,
+      }));
+    } else if (list && Array.isArray(list.projects)) {
+      out.projects = list.projects.slice(0, 20);
+    }
+  } catch { /* older binaries may not support list_projects */ }
+  // Try architecture snapshot for whichever project is 'active'.
   try {
     const arch = query('get_architecture', '{}');
     if (arch && typeof arch === 'object') {
@@ -96,7 +111,7 @@ function dashboardSnapshot() {
         entry_points: (arch.entry_points || []).slice(0, 5),
       };
     }
-  } catch { /* no active project yet */ }
+  } catch { /* no active project yet — dashboard shows CTA */ }
   return out;
 }
 

package/scripts/dashboard/static/index.html

@@ -813,6 +813,16 @@ kodelyth-ecc codebase query detect_changes '{}'</pre>
               <td><div style="font-family:monospace;font-size:12px;line-height:1.6;">${a.entry_points.map(e => `<div>${escapeHtml(String(e.name || e))}</div>`).join('')}</div></td></tr>` : ''}
           </tbody>
         </table>`;
+      } else if ((r.projects || []).length) {
+        $('#codebaseArch').innerHTML = `<div class="muted" style="font-size:13px;">
+          ${(r.projects || []).length} project(s) indexed. Architecture snapshot is per-active-session — open a project in your AI tool and it appears here.
+        </div><table style="margin-top:10px;">
+          <thead><tr><th>Project</th><th style="text-align:right;">Nodes</th><th style="text-align:right;">Edges</th></tr></thead>
+          <tbody>${r.projects.map(p => `<tr>
+            <td><code style="font-size:11.5px;">${escapeHtml(p.name)}</code></td>
+            <td style="text-align:right;">${fmtN(p.nodes || 0)}</td>
+            <td style="text-align:right;">${fmtN(p.edges || 0)}</td>
+          </tr>`).join('')}</tbody></table>`;
       } else {
         $('#codebaseArch').innerHTML = '<div class="empty">no active project graph yet — open a repo in your AI tool and say "Index this project"</div>';
       }

package/scripts/mcp/register-self.js

@@ -0,0 +1,116 @@
+// scripts/mcp/register-self.js
+// Auto-register ECC's own MCP server in Claude Code (~/.claude.json) and
+// Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json).
+//
+// Idempotent — updates in place, never duplicates. Handles missing files.
+
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+const SERVER_NAME = 'kodelyth-ecc';
+
+function claudeCodeConfigPath() {
+  // Claude Code reads user-level MCP from ~/.claude.json
+  return path.join(os.homedir(), '.claude.json');
+}
+
+function claudeDesktopConfigPath() {
+  const home = os.homedir();
+  if (os.platform() === 'darwin') return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  if (os.platform() === 'win32')  return path.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json');
+  return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+}
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+function writeJson(file, obj) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(obj, null, 2));
+}
+
+function serverEntry() {
+  return {
+    command: 'kodelythecc',
+    args: ['mcp'],
+    env: {},
+  };
+}
+
+function registerInFile(file, opts = {}) {
+  const existing = readJson(file) || {};
+  const servers = existing.mcpServers || {};
+  const already = servers[SERVER_NAME];
+  const desired = serverEntry();
+  if (already && JSON.stringify(already) === JSON.stringify(desired)) {
+    return { file, action: 'unchanged' };
+  }
+  servers[SERVER_NAME] = desired;
+  const next = { ...existing, mcpServers: servers };
+  if (!opts.dryRun) writeJson(file, next);
+  return { file, action: already ? 'updated' : 'added' };
+}
+
+function unregisterInFile(file) {
+  const existing = readJson(file);
+  if (!existing || !existing.mcpServers || !existing.mcpServers[SERVER_NAME]) {
+    return { file, action: 'not-present' };
+  }
+  delete existing.mcpServers[SERVER_NAME];
+  writeJson(file, existing);
+  return { file, action: 'removed' };
+}
+
+function registerAll({ log = () => {} } = {}) {
+  const results = [];
+  for (const p of [claudeCodeConfigPath(), claudeDesktopConfigPath()]) {
+    try {
+      const r = registerInFile(p);
+      log(`  ${r.action}: ${r.file}`);
+      results.push(r);
+    } catch (e) {
+      log(`  skipped ${p}: ${e.message}`);
+      results.push({ file: p, action: 'error', error: e.message });
+    }
+  }
+  return results;
+}
+
+function unregisterAll({ log = () => {} } = {}) {
+  const results = [];
+  for (const p of [claudeCodeConfigPath(), claudeDesktopConfigPath()]) {
+    try {
+      const r = unregisterInFile(p);
+      log(`  ${r.action}: ${r.file}`);
+      results.push(r);
+    } catch (e) {
+      log(`  skipped ${p}: ${e.message}`);
+      results.push({ file: p, action: 'error', error: e.message });
+    }
+  }
+  return results;
+}
+
+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 });
+  }
+  return rows;
+}
+
+module.exports = {
+  SERVER_NAME,
+  serverEntry,
+  claudeCodeConfigPath,
+  claudeDesktopConfigPath,
+  registerAll,
+  unregisterAll,
+  statusAll,
+};