kodelyth-ecc 2.3.0 → 2.4.1

package/CHANGELOG.md

@@ -2,6 +2,76 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v2.4.1 — Intent routing v2 (July 2026)
+
+Full design pass on `rules/common/agent-intent-routing.md` — the always-on rule that maps plain-language user intent to specialist agents. Deferred from 2.4.0.
+
+### Added — 8 new routing dimensions layered above the existing 10-tier signal tables
+
+1. **Confidence tiers** — high (route silently), medium (route + "not X? say so" tail), low (name 2 candidates, ask), none (answer directly, don't announce)
+2. **Session-state awareness** — once routed to an agent, stay in its voice for follow-ups. Do NOT re-announce the same routing. Only re-route when the user's message contains a stronger signal for a different agent
+3. **Anti-routing whitelist** — 6 situations where routing MUST be skipped (under 5 words with no code, one-line factual questions, explicit `use X`, "don't route", mid-workflow, ECC-itself bug reports)
+4. **New signal families for v2.4+** — routes for `/terse`, `/terse-compress`, `codebase-memory-mcp` queries, `kodelythecc uninstall`, `kodelythecc dashboard`, IDE install
+5. **Compound intent → parallel commands** — when 2 tables match at once, fire the parallel command instead of both agents sequentially (security+review → `/security-audit`, bug+multi-layer → `/debug-blitz`, etc.)
+6. **Announcement style adapts to terse mode** — if `/terse` is active this session, drop the tip line and use one-token announcement `→ debug-detective` instead of the full form
+7. **Cultural / multi-language cues** — read emotional markers in any language, strip filler like "bro"/"yaar"/"man", respond in the user's this-turn language, never translate code/errors/commands
+8. **Evolve integration** — routing misses feed `~/.kodelythecc/evolve/routing-misses.jsonl` so the evolve pipeline can propose new triggers later
+
+### Added — 5 new output-format examples
+
+- Default (verbose)
+- Terse mode active — one-token announcement
+- Medium-confidence single match — with "wrong?" tail
+- Low-confidence, two candidates — asks user to pick
+- Sticky routing continuation — no re-announcement
+- Compound intent → parallel command
+
+### Verified
+
+- All 21 tests pass
+- Rule file grew from 707 → 832 lines (net +125 lines of new dimensions), 69 sections total
+- The 10-tier priority signal tables (unchanged) remain the workhorse; the 8 new dimensions layer above them
+
+## 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.1

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.1",
   "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/rules/common/agent-intent-routing.md

@@ -16,6 +16,96 @@ If multiple agents match, pick the **highest priority** below (priority decrease
 
 ---
 
+## Routing v2 — The Eight Dimensions
+
+The signal tables below tell you **which agent** matches. These dimensions tell you **how confidently to route, when to stay silent, how to announce, and how to handle compound intent**. Apply them in order.
+
+### 1. Confidence tiers
+
+| Tier | Trigger | AI behaviour |
+|---|---|---|
+| **High** — 2+ signals from one table, OR 1 signal + emotion, OR explicit `use X` / `@X` | Route immediately with one-line announcement |
+| **Medium** — 1 clean signal, no counter-signals | Route with one-line announcement AND a "Not X? Say so, I'll switch" tail |
+| **Low** — 1 weak signal, or signals from 2+ tables of similar priority | **Do NOT auto-route.** Name the 2 best candidates in one line, ask which fits |
+| **None** — no signal, or explicit anti-routing | Answer directly, no routing announcement |
+
+### 2. Session-state awareness (sticky routing)
+
+Once you have routed to an agent this session, **stay in that agent's voice** for follow-ups on the same thread unless:
+
+- The user's next message contains a **stronger signal** for a different agent
+- The user says "back to normal", "stop routing", "just answer me"
+- The task has clearly concluded (test passes, PR merged, question answered)
+
+**Never re-announce the same routing.** Sticky = quiet. Only announce again when the agent actually changes.
+
+### 3. Anti-routing whitelist
+
+Route to **no one** in these cases (skip Priority 1-10 entirely):
+
+- Message is under 5 words AND has no error/code paste (e.g. "hi", "ok", "thanks", "cool", "yes")
+- Message is a factual question with a one-line answer ("what does `git stash pop` do?")
+- User already invoked with `use X`, `@X`, `run <agent>` — respect explicit choice
+- User said "don't route" / "just answer" / "stop routing" this session
+- User is in the middle of a multi-step interactive workflow the previous agent started
+- The message is a bug report about ECC itself (routing bugs, install bugs) — answer as the maintainer, not as a specialist
+
+### 4. New signal families (v2.4+)
+
+Beyond the 10 priority tiers below, watch for these newer signals — they map to features shipped in ECC 2.x:
+
+| User says | Route to |
+|---|---|
+| "compress this memory file" / "shrink CLAUDE.md" / "make my rules smaller" | `/terse-compress` |
+| "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` |
+| "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>` |
+
+### 5. Compound intent → parallel agents
+
+Some messages match **two priority tables at once**. When they do, fire the parallel command, not both agents sequentially.
+
+| User signals | Fire |
+|---|---|
+| security question + review question | `/security-audit` |
+| bug + been-stuck-for-hours + multi-layer | `/debug-blitz` |
+| architecture + security + a11y (new project) | `/project-launch` |
+| pre-release + full audit | `/pre-release` |
+| refactor + types + tests | `/refactor-sprint` |
+| attacker mindset + multi-vector | `/devil-mode` |
+| new codebase + orientation | `/onboard` |
+| general audit + multiple angles | `/team-review` |
+
+### 6. Announcement style adapts to terse mode
+
+If the user has typed `/terse` this session:
+
+- Drop the `Tip: next time you can type "use <agent>"` line
+- Use a one-token announcement: `→ debug-detective` instead of `→ Routing to debug-detective (stack trace + frustration match)`
+- No trailing decoration
+
+If terse is **off**, use the full form documented in the "Output Format" section at the bottom.
+
+### 7. Cultural + multi-language cues
+
+The user may write in a mixed register (English + native language + technical shorthand). Read the cues:
+
+- Emotional markers in any language route the same way: "arre yaar broken hai" = frustration = `debug-detective`
+- Filler like "bro", "yaar", "man", "please" is not a signal — strip it, read the substance
+- If the user's message language differs from previous turns, respond in the same language they used **this turn**, not their previous one
+- Code identifiers, commands, and error text stay in their original language (never translate `NullPointerException`)
+
+### 8. Evolve integration — routing misses become proposals
+
+When you route (or explicitly do NOT route because the signal was weak) and the outcome is unsatisfying, the ECC evolve system writes this to `~/.kodelythecc/evolve/routing-misses.jsonl` so proposals for new triggers can be surfaced later.
+
+You never write this file yourself. Just be honest in the routing announcement: if the match is weak, say "medium confidence — routing to X, not Y, because Z" so the evolve pipeline has a clean signal.
+
+---
+
 ## How to Apply This Rule — Semantic Intent, Not Keyword Matching
 
 **Read the intent behind the words, not just the words.**
@@ -696,6 +786,7 @@ When the user's request spans multiple concerns, name the parallel agents:
 
 ## Output Format When Routing
 
+**Default (verbose)**:
 ```
 → Routing to debug-detective (stack trace + frustration signals match the bug-tracking pattern)
 
@@ -704,4 +795,38 @@ When the user's request spans multiple concerns, name the parallel agents:
 Tip: next time you can type "use debug-detective" to invoke me directly.
 ```
 
-This keeps the user **informed**, **never surprised**, and **learning the toolkit** with every interaction.
+**Terse mode active (see Dimension 6)**:
+```
+→ debug-detective
+
+[response — no tip line, no explanation of why]
+```
+
+**Medium-confidence single match** (add a "wrong?" tail):
+```
+→ Routing to code-reviewer (single file paste, no other context — treating as review)
+
+[response as code-reviewer]
+
+Not what you wanted? Say "use debug-detective" or "just answer" to switch.
+```
+
+**Low-confidence, two candidates** (ask, do not pick):
+```
+Two agents fit this: debug-detective (bug + error) or silent-failure-hunter (no error thrown).
+Which one? Or should I answer directly?
+```
+
+**Sticky routing continuation** (already in an agent, no announcement):
+```
+[response continues in the same agent's voice — no re-announcement]
+```
+
+**Compound intent → parallel command**:
+```
+→ Firing /debug-blitz — 3 agents in parallel (debug-detective + silent-failure-hunter + env-debugger)
+
+[synthesised result]
+```
+
+This keeps the user **informed**, **never surprised**, and **learning the toolkit** with every interaction — while still respecting terse mode and session context.

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,
+};