kodelyth-ecc 1.8.6 → 1.9.1

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v1.9.1 — Smoothness pass on RTK integration (July 2026)
+
+Follow-up polish on 1.9.0. Cleaner output, agents now say the right paths, one-shot multi-IDE RTK setup.
+
+### Fixed
+
+- `rtk init --codex/--gemini/--opencode/--agent X` rejected `--auto-patch` and silently failed. `enableFor()` now only passes `--auto-patch` to the default Claude Code hook flow, where RTK accepts it. Multi-IDE enable now succeeds 3/3 instead of 2/3
+- 24 memory-path references across 11 agent/skill/rule/command markdown files still said `~/.kodelyth/` — agents were teaching users the wrong path. Now all say `~/.kodelythecc/` (matches the 1.8.6 runtime rename)
+
+### Added
+
+- `kodelyth-ecc rtk enable --all` — auto-detects every IDE ECC has been installed for on this machine (checks `~/.claude/agents`, `~/.cursor/rules`, `~/.codeium/windsurf`, `~/.antigravity`, `~/.codex`, `~/.config/opencode`, `~/.gemini`) and wires RTK into all of them in one command
+- `scripts/rtk/index.js` — `detectInstalledTargets()` export
+
+### Changed
+
+- Post-install output: replaced the raw JSON dumps with a tight 3-line summary (RTK version, target IDE, next step)
+- `kodelyth-ecc rtk status`: human-readable by default (was JSON); use `--json` for machine output. Now also lists detected ECC-installed IDEs so you can see which ones `--all` will wire
+
+## v1.9.0 — RTK integration + revived dashboard (July 2026)
+
+ECC now auto-installs [RTK](https://github.com/rtk-ai/rtk) (Rust Token Killer) and wires its transparent command filter into whichever IDE ECC was installed for. Real token savings (60-90% on shell commands) show up in the dashboard, pulled straight from RTK's own ledger — no synthetic numbers.
+
+### Added
+
+- `scripts/rtk/index.js` — RTK integration module: `install()`, `enableFor(target)`, `disableFor(target)`, `status()`, `savings()`
+- `kodelyth-ecc rtk <install|enable|disable|status|gain>` — CLI subcommands to manage RTK from ECC
+- Post-install auto-hook: after `npx kodelyth-ecc --target <ide>` succeeds, ECC auto-installs the RTK binary (Homebrew on macOS, curl script elsewhere) and runs `rtk init` for the target IDE. Opt out with `--no-rtk`
+- Target map covers 10 install targets: `claude-code`, `cursor`, `cursor-project`, `windsurf-home`, `windsurf-project`, `antigravity`, `codex-home`, `opencode`, `cline`, `gemini-cli`
+- `/api/rtk` + `/api/rtk/status` dashboard endpoints — surface RTK's live ledger
+- New **RTK Savings** tab in the dashboard: total tokens saved, raw tokens seen, avg reduction %, active IDE integrations, 30-day daily bar chart
+
+### Changed
+
+- Dashboard nav order: `Overview → RTK Savings → Memory → Evolve → Catalog → Sessions`
+
+### Notes
+
+- Windows auto-install is skipped (RTK requires manual .zip download on native Windows); WSL follows the Linux path
+- RTK setup is best-effort — if brew/curl aren't available, install fails gracefully with a hint to run `kodelyth-ecc rtk install` later
+- Existing RTK installs are detected and reused; no double-install
+
 ## v1.8.6 — Memory path rename + auto-migration (July 2026)
 
 Renamed the on-disk memory root from `~/.kodelyth/` to `~/.kodelythecc/` across every runtime path. Existing installs auto-migrate on first CLI invocation or hook fire — idempotent, non-destructive, keeps a dated backup of the old directory.

package/agents/kodelyth-memory.md

@@ -72,7 +72,7 @@ Anthropic's prompt cache (5-min TTL, 10% cost on hits) and OpenAI's automatic ca
 ## Honest limits
 
 - Retrieval is **BM25 keyword + tag matching**, not semantic. It finds memories that share vocabulary with the query. It will miss semantic matches with no shared words.
-- Memory is **per-machine**. Sync across machines requires the user opting in (Dropbox/iCloud/git on `~/.kodelyth/memory/`).
+- Memory is **per-machine**. Sync across machines requires the user opting in (Dropbox/iCloud/git on `~/.kodelythecc/memory/`).
 - On cloud-AI platforms (Windsurf, Antigravity), session data is server-side. Memory still works for capture (manual `/memory remember`) but auto-extract from past sessions is unavailable there.
 
 ## Example interaction

package/bin/kodelyth-ecc.js

@@ -177,6 +177,89 @@ if (args[0] && args[0].startsWith('mcp-')) {
   return;
 }
 
+// ── Subcommand: rtk (Rust Token Killer integration) ──────────────────────────
+// Usage:
+//   kodelyth-ecc rtk install                install rtk binary (brew or curl)
+//   kodelyth-ecc rtk enable [--target X]    wire rtk into an IDE (default: claude-code)
+//   kodelyth-ecc rtk disable [--target X]   remove rtk hook from an IDE
+//   kodelyth-ecc rtk status                 show binary version + active integrations
+//   kodelyth-ecc rtk gain                   thin wrapper around `rtk gain`
+if (args[0] === 'rtk') {
+  const rtk = require(path.join(ROOT, 'scripts', 'rtk', 'index.js'));
+  const sub = args[1] || 'status';
+  const rest = args.slice(2);
+  function flag(name, dflt) {
+    const i = rest.indexOf(name);
+    return i >= 0 && rest[i + 1] ? rest[i + 1] : dflt;
+  }
+  const log = (m) => process.stdout.write(m + '\n');
+  try {
+    if (sub === 'install') {
+      const r = rtk.install({ log });
+      log(JSON.stringify(r, null, 2));
+      process.exit(r.installed || r.skipped ? 0 : 1);
+    }
+    if (sub === 'enable') {
+      // --all mode: wire RTK into every IDE that already has ECC installed.
+      if (rest.includes('--all')) {
+        rtk.install({ log });
+        if (!rtk.isInstalled()) { process.stderr.write('rtk install failed — cannot enable\n'); process.exit(1); }
+        const targets = rtk.detectInstalledTargets();
+        if (targets.length === 0) {
+          log('No IDE installs detected. Install ECC first: npx kodelyth-ecc --target claude-code');
+          process.exit(0);
+        }
+        let ok = 0, fail = 0;
+        for (const t of targets) {
+          const r = rtk.enableFor(t, { log: () => {} });
+          if (r.enabled) { log(`  ✓ ${t}`); ok++; } else { log(`  · ${t} — ${r.reason || 'skipped'}`); fail++; }
+        }
+        log(`\nRTK enabled on ${ok}/${targets.length} IDE${targets.length === 1 ? '' : 's'}. Restart each to activate.`);
+        process.exit(fail && !ok ? 1 : 0);
+      }
+      const target = flag('--target', 'claude-code');
+      const inst = rtk.install({ log });
+      if (!rtk.isInstalled()) { log(JSON.stringify(inst, null, 2)); process.exit(1); }
+      const r = rtk.enableFor(target, { log });
+      log(JSON.stringify(r, null, 2));
+      process.exit(r.enabled ? 0 : 1);
+    }
+    if (sub === 'disable') {
+      const target = flag('--target', 'claude-code');
+      const r = rtk.disableFor(target, { log });
+      log(JSON.stringify(r, null, 2));
+      process.exit(r.disabled ? 0 : 1);
+    }
+    if (sub === 'status') {
+      const st = rtk.status();
+      if (rest.includes('--json')) { log(JSON.stringify(st, null, 2)); process.exit(0); }
+      if (!st.installed) {
+        log('RTK: not installed');
+        log('  → install: kodelyth-ecc rtk install');
+        process.exit(0);
+      }
+      log(`RTK: ${st.version}`);
+      const ecc = rtk.detectInstalledTargets();
+      log(`ECC-installed IDEs: ${ecc.length ? ecc.join(', ') : 'none detected'}`);
+      log('RTK integrations:');
+      for (const line of st.active) log('  ' + line);
+      log('');
+      log('Commands: install | enable [--target X | --all] | disable | gain | status --json');
+      process.exit(0);
+    }
+    if (sub === 'gain') {
+      const r = spawnSync('rtk', ['gain', ...rest], { stdio: 'inherit' });
+      process.exit(r.status ?? 1);
+    }
+    process.stderr.write('unknown rtk subcommand. try: install | enable | disable | status | gain\n');
+    process.exit(2);
+  } catch (e) {
+    process.stderr.write(`[rtk] ${e.message}\n`);
+    process.exit(1);
+  }
+  return;
+}
+
 // ── Subcommand: route (cost-aware model tier recommendation) ──────────────────
 // Usage: npx kodelyth-ecc route "<task description>" [--files N] [--agent <name>] [--current <model-id>]
 if (args[0] === 'route') {
@@ -1023,5 +1106,37 @@ if (isWin) {
   }
   fs.chmodSync(sh, 0o755);
   const result = spawnSync('bash', [sh, ...args], { stdio: 'inherit', shell: false });
+
+  // Post-install: auto-install + wire RTK for the target IDE (opt-out via --no-rtk).
+  if (result.status === 0 && !args.includes('--no-rtk')) {
+    try {
+      const rtk = require(path.join(ROOT, 'scripts', 'rtk', 'index.js'));
+      const targetIdx = args.indexOf('--target');
+      const target = targetIdx >= 0 && args[targetIdx + 1] ? args[targetIdx + 1] : 'claude-code';
+      if (rtk.TARGET_MAP[target]) {
+        const w = (m) => process.stdout.write(m + '\n');
+        w('');
+        w('━ RTK token savings ' + '─'.repeat(41));
+        const inst = rtk.install({ log: () => {} });        // silent — we summarise
+        if (inst.installed || inst.reason === 'already installed') {
+          const en = rtk.enableFor(target, { log: () => {} });
+          if (en.enabled) {
+            w(`  ✓ RTK ${(rtk.getVersion() || '').replace(/^rtk /,'')} — wired for ${target}`);
+            w(`  ✓ Restart your AI tool to activate. 60-90% token savings on shell commands.`);
+          } else {
+            w(`  · skipped: ${en.reason}`);
+            w(`  → retry: kodelyth-ecc rtk enable --target ${target}`);
+          }
+        } else {
+          w(`  · install skipped: ${inst.reason}`);
+          w(`  → retry: kodelyth-ecc rtk enable --target ${target}`);
+        }
+        w('');
+      }
+    } catch (e) {
+      process.stderr.write(`[rtk] setup skipped: ${e.message}\n`);
+    }
+  }
+
   process.exit(result.status ?? 1);
 }

package/commands/memory-evolve.md

@@ -24,7 +24,7 @@ Run the self-evolving memory loop. Inspect what ECC has learned from your sessio
 1. **stats** prints the current signal snapshot:
    - reuse: how many memories are tracked, total surfaces, top reused
    - routing misses: how many substantive prompts had zero memory matches, top token clusters
-2. **analyze** applies thresholds and writes proposals to `~/.kodelyth/evolve/proposals.jsonl`. Stable IDs — re-running does NOT duplicate.
+2. **analyze** applies thresholds and writes proposals to `~/.kodelythecc/evolve/proposals.jsonl`. Stable IDs — re-running does NOT duplicate.
 3. **list** filters by state. **show** prints the full draft markdown + evidence.
 4. **accept** writes the draft to its target path under `--root` (defaults to package root). Refuses to overwrite without `--overwrite`. Marks the proposal `accepted` with the absolute path.
 5. **reject** marks a proposal rejected with optional note.
@@ -63,7 +63,7 @@ Run the self-evolving memory loop. Inspect what ECC has learned from your sessio
 
 Backed by:
 
-- `scripts/evolve/stats.js` — pure record/read of `~/.kodelyth/evolve/{reuse.json, routing-misses.jsonl}`
+- `scripts/evolve/stats.js` — pure record/read of `~/.kodelythecc/evolve/{reuse.json, routing-misses.jsonl}`
 - `scripts/evolve/analyze.js` — pure functions: signals → proposals
 - `scripts/evolve/proposals.js` — append-only proposal log with state transitions
 - `hooks/memory/auto-recall.js` — fire-and-forget signal recording on every UserPromptSubmit

package/commands/memory.md

@@ -30,7 +30,7 @@ Capture a new memory. The agent will:
 Show the queue of candidate memories extracted automatically by the Stop hook from your last session. Confirm each one to store, or skip.
 
 ### `/memory forget <id>`
-Mark a memory deleted. It's a soft-delete (the row stays in the log marked `deleted: true`) so you can recover it by editing `~/.kodelyth/memory/memories.jsonl`.
+Mark a memory deleted. It's a soft-delete (the row stays in the log marked `deleted: true`) so you can recover it by editing `~/.kodelythecc/memory/memories.jsonl`.
 
 ### `/memory list`
 Show all stored memories — id, date, language, problem, tags.
@@ -55,7 +55,7 @@ use kodelyth-memory
 
 ## Storage location
 
-`~/.kodelyth/memory/` (override with `KODELYTH_MEMORY_DIR` env var)
+`~/.kodelythecc/memory/` (override with `KODELYTH_MEMORY_DIR` env var)
 
 - `memories.jsonl` — the source of truth
 - `index.json` — BM25 inverted index

package/commands/route-model.md

@@ -5,7 +5,7 @@ argument-hint: "[task description]"
 
 # /route-model
 
-Get an immediate model-tier recommendation for the current task. Combines the `cost-aware-model-routing` rule, the project's `.kodelyth/router.json` config, and the active session's token-budget pressure.
+Get an immediate model-tier recommendation for the current task. Combines the `cost-aware-model-routing` rule, the project's `.kodelythecc/router.json` config, and the active session's token-budget pressure.
 
 ## Usage
 
@@ -33,7 +33,7 @@ If you're already on the right tier, the AI routes silently and confirms in one
 ## Behind the scenes
 
 - Pure deterministic classifier (no LLM call) at `scripts/router/classify.js`.
-- Project config: `.kodelyth/router.json` (override per team).
+- Project config: `.kodelythecc/router.json` (override per team).
 - Env-var overrides: `KODELYTH_ROUTER_{TRIVIAL,STANDARD,HARD,DEFAULT}`.
 - Disable with `KODELYTH_ROUTER=off`.
 - Pairs with the `token-budget` safety hook for spend control.

package/commands/update.md

@@ -17,7 +17,7 @@ Upgrades your ECC install to the latest version from npm. Reads your existing in
 1. Reads `kodelyth-ecc-install-state.json` from your install directory to recover the original `target` and `languages`
 2. Runs `npx kodelyth-ecc@latest` with those same flags
 3. Overwrites agents, skills, rules, and commands with the latest versions
-4. Leaves your memory store (`~/.kodelyth/memory/`) and `tasks/lessons.md` untouched — your learned context is never overwritten
+4. Leaves your memory store (`~/.kodelythecc/memory/`) and `tasks/lessons.md` untouched — your learned context is never overwritten
 
 ## Implementation
 
@@ -76,7 +76,7 @@ npx kodelyth-ecc@latest --target cursor-project      # Cursor
 
 | Path | Protected |
 |------|-----------|
-| `~/.kodelyth/memory/` | Your BM25 memory store |
+| `~/.kodelythecc/memory/` | Your BM25 memory store |
 | `tasks/lessons.md` | Project correction rules |
 | `tasks/todo.md` | Open todos |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "1.8.6",
+  "version": "1.9.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/cost-aware-model-routing.md

@@ -79,7 +79,7 @@ Emit exactly one block, then proceed normally:
 
 ## Per-team configurability
 
-Teams override the defaults via env vars or `.kodelyth/router.json`:
+Teams override the defaults via env vars or `.kodelythecc/router.json`:
 
 ### Env vars
 
@@ -91,7 +91,7 @@ Teams override the defaults via env vars or `.kodelyth/router.json`:
 | `KODELYTH_ROUTER_HARD=<model-id>` | Override hard tier. |
 | `KODELYTH_ROUTER_DEFAULT=<trivial\|standard\|hard>` | Default tier for ambiguous tasks (default `standard`). |
 
-### Project file: `.kodelyth/router.json`
+### Project file: `.kodelythecc/router.json`
 
 ```json
 {

package/rules/common/memory-protocol.md

@@ -4,7 +4,7 @@
 
 ## What is Kodelyth Memory
 
-A local file at `~/.kodelyth/memory/memories.jsonl` storing solutions, patterns, and gotchas extracted from past sessions. Retrieval is BM25 (keyword + tag matching). It is **not** a learned model — it is a retrieval store that gives you better context.
+A local file at `~/.kodelythecc/memory/memories.jsonl` storing solutions, patterns, and gotchas extracted from past sessions. Retrieval is BM25 (keyword + tag matching). It is **not** a learned model — it is a retrieval store that gives you better context.
 
 **Cross-IDE: the same file is read/written by every IDE on this machine.** A memory captured in Claude Code is recall-able from Windsurf, Cursor, Antigravity, Codex, and any other MCP-capable client. There is one shared store.
 
@@ -84,4 +84,4 @@ The injected memory block is structured so its prefix is identical across calls
 
 If the user asks "how do you know that about me?", answer plainly:
 
-> "It's in your local Kodelyth Memory at `~/.kodelyth/memory/`. You can inspect it, edit it, or delete it any time. Nothing was sent anywhere."
+> "It's in your local Kodelyth Memory at `~/.kodelythecc/memory/`. You can inspect it, edit it, or delete it any time. Nothing was sent anywhere."

package/rules/common/self-improvement-workflow.md

@@ -117,7 +117,7 @@ ECC uses three compounding memory layers — together they make Claude increasin
 - Edit freely — these are YOUR rules for this project
 - Example: "Always use pnpm. Never npm. Never yarn."
 
-### Layer 2 — Global Memory (`~/.kodelyth/memory/`)
+### Layer 2 — Global Memory (`~/.kodelythecc/memory/`)
 - Cross-project. BM25 fuzzy search. Solution patterns.
 - Captures solutions from every session
 - Auto-recalls relevant past solutions on every prompt you type

package/scripts/dashboard/server.js

@@ -279,6 +279,25 @@ function handleRequest(req, res) {
       return jsonResponse(res, 200, data.tokenBudgetSnapshot());
     }
 
+    if (p === '/api/rtk/status') {
+      const rtk = require('../rtk/index.js');
+      return jsonResponse(res, 200, rtk.status());
+    }
+
+    if (p === '/api/rtk') {
+      const rtk = require('../rtk/index.js');
+      const st  = rtk.status();
+      if (!st.installed) {
+        return jsonResponse(res, 200, {
+          ok: false,
+          installed: false,
+          install_hint: 'Run: kodelyth-ecc rtk install',
+        });
+      }
+      const s = rtk.savings({ days: Number(q.get('days')) || 30 });
+      return jsonResponse(res, 200, { ok: true, installed: true, version: st.version, active: st.active, ...s });
+    }
+
     if (p.startsWith('/api/')) return notFound(res);
 
     // ── static fallback ───────────────────────────────────────────────────

package/scripts/dashboard/static/index.html

@@ -220,6 +220,7 @@
       <button id="refreshBtn" class="btn-ghost" title="Refresh active tab  (R key)">Refresh</button>
       <nav class="tabs">
         <button data-tab="overview" class="active">Overview</button>
+        <button data-tab="rtk">RTK Savings</button>
         <button data-tab="memory">Memory</button>
         <button data-tab="evolve">Evolve</button>
         <button data-tab="catalog">Catalog</button>
@@ -245,6 +246,27 @@
       </div>
     </section>
 
+    <!-- ───────── RTK SAVINGS ───────── -->
+    <section data-panel="rtk" hidden>
+      <div class="grid" id="rtkCards"></div>
+      <hr class="sep">
+      <div class="row">
+        <div class="card">
+          <h2>Top saving commands</h2>
+          <div id="rtkTopCmds">loading…</div>
+        </div>
+        <div class="card">
+          <h2>Active integrations</h2>
+          <div id="rtkActive">loading…</div>
+        </div>
+      </div>
+      <hr class="sep">
+      <div class="card">
+        <h2>Daily savings (last 30 days)</h2>
+        <div id="rtkDaily">loading…</div>
+      </div>
+    </section>
+
     <!-- ───────── MEMORY ───────── -->
     <section data-panel="memory" hidden>
       <div class="grid" id="memoryCards"></div>
@@ -630,9 +652,76 @@
     }
   }
 
+  // ───── RTK loader ─────
+  async function loadRtk() {
+    try {
+      const r = await fetch('/api/rtk').then(r => r.json());
+      const cards = $('#rtkCards');
+      if (!r.installed) {
+        cards.innerHTML = `<div class="empty">RTK not installed. Install with:
+          <code>kodelyth-ecc rtk install</code>
+          <br><br>${escapeHtml(r.install_hint || '')}</div>`;
+        $('#rtkTopCmds').innerHTML = '';
+        $('#rtkActive').innerHTML  = '';
+        $('#rtkDaily').innerHTML   = '';
+        return;
+      }
+      if (!r.ok || !r.gain) {
+        cards.innerHTML = `<div class="empty">RTK installed (${escapeHtml(r.version || '')}) but no savings data yet. Use your AI tool with RTK enabled and refresh.</div>`;
+        $('#rtkTopCmds').innerHTML = '';
+        $('#rtkActive').innerHTML  = (r.active || []).map(a => `<div class="muted">• ${escapeHtml(a)}</div>`).join('') || '<div class="empty">none</div>';
+        $('#rtkDaily').innerHTML   = '';
+        return;
+      }
+      const g = r.gain || {};
+      const s = g.summary || {};
+      const totalSaved = s.total_saved   ?? 0;
+      const totalInput = s.total_input   ?? 0;
+      const percent    = s.avg_savings_pct != null ? Math.round(s.avg_savings_pct) : 0;
+      const cmdCount   = s.total_commands ?? 0;
+      cards.innerHTML = [
+        statCard(fmtN(totalSaved), 'Tokens saved (all-time)',  `${percent}% avg reduction`),
+        statCard(fmtN(cmdCount),   'Commands filtered',        'through RTK'),
+        statCard(fmtN(totalInput), 'Raw tokens seen',          'before RTK compression'),
+        statCard(escapeHtml((r.version || '—').replace(/^rtk\s+/,'')), 'RTK version', 'active binary'),
+      ].join('');
+      // Per-command breakdown — RTK's `gain` JSON does not expose this today.
+      $('#rtkTopCmds').innerHTML = `<div class="muted" style="font-size:12.5px;">
+        Per-command breakdown lives in <code>rtk discover</code>. Run it in your terminal for missed savings opportunities.
+      </div>`;
+      // Active integrations
+      $('#rtkActive').innerHTML = (r.active && r.active.length)
+        ? r.active.map(a => `<div class="muted" style="font-family:monospace;font-size:12px;">${escapeHtml(a)}</div>`).join('')
+        : '<div class="empty">no active IDE integrations detected</div>';
+      // Daily graph — simple ascii-style bars, RTK schema: g.daily[].saved_tokens
+      const daily = g.daily || [];
+      if (Array.isArray(daily) && daily.length) {
+        const max = Math.max(...daily.map(d => d.saved_tokens || 0));
+        $('#rtkDaily').innerHTML = daily.slice(-30).map(d => {
+          const saved = d.saved_tokens || 0;
+          const pct = max ? (saved / max) * 100 : 0;
+          return `<div style="display:flex;gap:8px;align-items:center;margin:3px 0;font-size:12px;">
+            <span class="muted" style="width:90px;font-family:monospace;">${escapeHtml(d.date || '')}</span>
+            <div style="flex:1;background:#f1f5f9;border-radius:3px;height:14px;overflow:hidden;">
+              <div style="background:#34d399;height:100%;width:${pct}%;"></div>
+            </div>
+            <span style="width:110px;text-align:right;font-family:monospace;">${fmtN(saved)}</span>
+          </div>`;
+        }).join('');
+      } else {
+        $('#rtkDaily').innerHTML = '<div class="empty">no daily data yet</div>';
+      }
+      setLastUpdated();
+    } catch (e) {
+      $('#rtkCards').innerHTML = `<div class="empty">failed: ${escapeHtml(e.message)}</div>`;
+    }
+  }
+  function fmtN(n) { return Number(n || 0).toLocaleString(); }
+
   // ───── tab dispatcher ─────
   function onTabShown(tab) {
     if (tab === 'overview') loadOverview();
+    if (tab === 'rtk')      loadRtk();
     if (tab === 'memory')   loadMemory();
     if (tab === 'evolve')   loadEvolve();
     if (tab === 'catalog')  loadCatalog();

package/scripts/rtk/index.js

@@ -0,0 +1,186 @@
+// scripts/rtk/index.js
+// RTK (Rust Token Killer) integration — auto-installs and wires RTK into the IDE
+// that ECC was installed for, so shell commands run through RTK's filter for
+// 60-90% token savings.
+//
+// Public API:
+//   isInstalled()          → boolean
+//   install({ log })       → { installed, method, version } | { skipped, reason }
+//   enableFor(target,{log})→ { enabled, target, agent, output } | { skipped, reason }
+//   status()               → { installed, version, agents: [...] }
+//   savings({ days })      → parsed `rtk gain --format json` snapshot or null
+'use strict';
+
+const { execFileSync, spawnSync } = require('child_process');
+const os   = require('os');
+const path = require('path');
+const fs   = require('fs');
+
+// ── ECC install target → RTK agent flag ──────────────────────────────────────
+// Reference: `rtk init --help` and RTK README "Supported AI Tools" table.
+const TARGET_MAP = {
+  'claude-code':      ['init', '-g'],
+  'cursor':           ['init', '-g', '--agent', 'cursor'],
+  'cursor-project':   ['init',       '--agent', 'cursor'],
+  'windsurf-home':    ['init', '-g', '--agent', 'windsurf'],
+  'windsurf-project': ['init',       '--agent', 'windsurf'],
+  'antigravity':      ['init',       '--agent', 'antigravity'],
+  'codex-home':       ['init', '-g', '--codex'],
+  'opencode':         ['init', '-g', '--opencode'],
+  'cline':            ['init',       '--agent', 'cline'],
+  'gemini-cli':       ['init', '-g', '--gemini'],
+};
+
+// ── Detect which IDEs ECC has already been installed for on this machine ─────
+// Returns list of ECC install-target strings that have visible ECC artifacts.
+function detectInstalledTargets() {
+  const home = os.homedir();
+  const targets = [];
+  const checks = [
+    { target: 'claude-code',      dir: path.join(home, '.claude', 'agents') },
+    { target: 'cursor',           dir: path.join(home, '.cursor', 'rules') },
+    { target: 'windsurf-home',    dir: path.join(home, '.codeium', 'windsurf', 'memories') },
+    { target: 'antigravity',      dir: path.join(home, '.antigravity') },
+    { target: 'codex-home',       dir: path.join(home, '.codex') },
+    { target: 'opencode',         dir: path.join(home, '.config', 'opencode') },
+    { target: 'gemini-cli',       dir: path.join(home, '.gemini') },
+  ];
+  for (const { target, dir } of checks) {
+    try {
+      if (fs.existsSync(dir) && fs.readdirSync(dir).length > 0) targets.push(target);
+    } catch { /* skip */ }
+  }
+  return targets;
+}
+
+function isInstalled() {
+  try {
+    execFileSync('rtk', ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch { return false; }
+}
+
+function getVersion() {
+  try {
+    return execFileSync('rtk', ['--version'], { encoding: 'utf8' }).trim();
+  } catch { return null; }
+}
+
+// ── Install RTK binary ───────────────────────────────────────────────────────
+// Mac: prefer `brew install rtk` if brew is on PATH (fastest, cached).
+// Otherwise: pipe the official install script through sh (installs to ~/.local/bin).
+// Windows: skipped (needs manual .zip download from releases).
+function install({ log = () => {} } = {}) {
+  if (isInstalled()) {
+    return { installed: false, skipped: true, reason: 'already installed', version: getVersion() };
+  }
+  if (os.platform() === 'win32') {
+    return { installed: false, skipped: true, reason: 'windows requires manual install: https://github.com/rtk-ai/rtk/releases' };
+  }
+
+  // Try Homebrew first on macOS.
+  if (os.platform() === 'darwin') {
+    try {
+      execFileSync('brew', ['--version'], { stdio: 'ignore' });
+      log('[rtk] installing via Homebrew…');
+      const r = spawnSync('brew', ['install', 'rtk'], { stdio: 'inherit' });
+      if (r.status === 0 && isInstalled()) {
+        return { installed: true, method: 'brew', version: getVersion() };
+      }
+      log('[rtk] brew install did not complete; falling back to curl script');
+    } catch { /* brew not present */ }
+  }
+
+  // Fall back to the official install script.
+  log('[rtk] installing via curl script (installs to ~/.local/bin)…');
+  const script = 'curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh';
+  const r = spawnSync('sh', ['-c', script], { stdio: 'inherit' });
+  if (r.status !== 0) {
+    return { installed: false, skipped: true, reason: 'install script failed — install rtk manually: https://github.com/rtk-ai/rtk#installation' };
+  }
+
+  // Make sure ~/.local/bin is on PATH for this process so isInstalled() succeeds.
+  const localBin = path.join(os.homedir(), '.local', 'bin');
+  if (fs.existsSync(path.join(localBin, 'rtk')) && !process.env.PATH.split(':').includes(localBin)) {
+    process.env.PATH = `${localBin}:${process.env.PATH}`;
+  }
+
+  if (!isInstalled()) {
+    return { installed: false, skipped: true, reason: 'installed to ~/.local/bin but not on PATH — add "export PATH=$HOME/.local/bin:$PATH" to your shell rc' };
+  }
+  return { installed: true, method: 'curl', version: getVersion() };
+}
+
+// ── Enable RTK for a specific IDE ────────────────────────────────────────────
+function enableFor(target, { log = () => {} } = {}) {
+  if (!isInstalled()) {
+    return { enabled: false, skipped: true, reason: 'rtk binary not on PATH' };
+  }
+  const rtkArgs = TARGET_MAP[target];
+  if (!rtkArgs) {
+    return { enabled: false, skipped: true, reason: `no RTK mapping for target "${target}"` };
+  }
+
+  log(`[rtk] wiring RTK into ${target} …`);
+  // --auto-patch is only accepted by the default Claude Code hook flow.
+  // Other agent flags (--codex, --gemini, --opencode, --agent X) reject it.
+  const finalArgs = target === 'claude-code' ? [...rtkArgs, '--auto-patch'] : rtkArgs;
+  const r = spawnSync('rtk', finalArgs, { encoding: 'utf8' });
+  const output = (r.stdout || '') + (r.stderr || '');
+  if (r.status !== 0) {
+    return { enabled: false, skipped: true, reason: 'rtk init failed', output };
+  }
+  return { enabled: true, target, agent: rtkArgs.join(' '), output: output.trim() };
+}
+
+// ── Disable RTK for a specific IDE (removes hook + RTK.md) ───────────────────
+function disableFor(target, { log = () => {} } = {}) {
+  if (!isInstalled()) return { disabled: false, skipped: true, reason: 'rtk not installed' };
+  const rtkArgs = TARGET_MAP[target];
+  if (!rtkArgs) return { disabled: false, skipped: true, reason: `no RTK mapping for target "${target}"` };
+  log(`[rtk] removing RTK from ${target} …`);
+  const r = spawnSync('rtk', [...rtkArgs, '--uninstall'], { encoding: 'utf8' });
+  return { disabled: r.status === 0, output: ((r.stdout || '') + (r.stderr || '')).trim() };
+}
+
+// ── Status: what's installed, what's active ──────────────────────────────────
+function status() {
+  const installed = isInstalled();
+  if (!installed) return { installed: false, version: null, active: [] };
+  const version = getVersion();
+  const active  = [];
+  try {
+    const r = execFileSync('rtk', ['init', '--show'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    // Only surface the '[ok]' status rows — skip the usage help RTK prints below.
+    for (const line of r.split('\n')) {
+      const t = line.trim();
+      if (t.startsWith('[ok]') || t.startsWith('[--]')) active.push(t);
+    }
+  } catch { /* older rtk versions may not have --show */ }
+  return { installed: true, version, active };
+}
+
+// ── Savings: read `rtk gain --format json` for dashboard ─────────────────────
+function savings({ days = 30 } = {}) {
+  if (!isInstalled()) return null;
+  try {
+    const r = execFileSync('rtk', ['gain', '--all', '--format', 'json'], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 16 * 1024 * 1024,
+    });
+    return { ok: true, days, gain: JSON.parse(r) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+module.exports = {
+  TARGET_MAP,
+  detectInstalledTargets,
+  isInstalled,
+  getVersion,
+  install,
+  enableFor,
+  disableFor,
+  status,
+  savings,
+};

package/skills/cost-aware-model-routing/SKILL.md

@@ -44,7 +44,7 @@ Weight signals together. Single signals are noisy; three or four together are re
 
 ### 2. Read the team's config
 
-Check for `.kodelyth/router.json` at the project root and these env vars:
+Check for `.kodelythecc/router.json` at the project root and these env vars:
 
 ```
 KODELYTH_ROUTER          off | (unset)

package/skills/kodelyth-memory/SKILL.md

@@ -16,7 +16,7 @@ description: Local self-learning memory for AI coding sessions. Captures what wo
 
 ```
 ┌─────────────────┐    capture    ┌─────────────────┐    inject    ┌─────────────────┐
-│  Past session   │ ─────────────→│  ~/.kodelyth/   │─────────────→│  Next session   │
+│  Past session   │ ─────────────→│  ~/.kodelythecc/   │─────────────→│  Next session   │
 │  (you solved X) │               │  memory/        │              │  (X comes up)   │
 └─────────────────┘               └─────────────────┘              └─────────────────┘
                                           │
@@ -29,7 +29,7 @@ description: Local self-learning memory for AI coding sessions. Captures what wo
 
 ## Storage layout
 
-All under `~/.kodelyth/memory/` (override with `KODELYTH_MEMORY_DIR`):
+All under `~/.kodelythecc/memory/` (override with `KODELYTH_MEMORY_DIR`):
 
 | File | Purpose |
 |---|---|
@@ -109,9 +109,9 @@ For Anthropic models the cache TTL is 5 minutes — typing back-to-back during a
 ## Honest limits
 
 - **Not "the model learns"** — the model is unchanged. We're just feeding it better context.
-- **Per-machine by default** — sync via Dropbox/iCloud/git on `~/.kodelyth/memory/` if needed.
+- **Per-machine by default** — sync via Dropbox/iCloud/git on `~/.kodelythecc/memory/` if needed.
 - **Cloud-AI platforms** (Windsurf, Antigravity, partial Cursor) — session data is server-side. Auto-extract from past sessions doesn't work there. Manual `/memory remember` still does.
-- **Privacy** — every byte stays on your disk. Verify with `ls -la ~/.kodelyth/memory/`.
+- **Privacy** — every byte stays on your disk. Verify with `ls -la ~/.kodelythecc/memory/`.
 
 ## Anti-patterns
 

package/skills/self-evolving-memory/SKILL.md

@@ -77,7 +77,7 @@ Snapshot of currently recorded signals:
 
 ### `kodelyth-ecc evolve analyze`
 
-Reads signals + your `~/.kodelyth/memory/` store, applies thresholds, and writes proposals to `~/.kodelyth/evolve/proposals.jsonl`. Idempotent — re-running with the same evidence produces the same proposal IDs and does NOT duplicate.
+Reads signals + your `~/.kodelythecc/memory/` store, applies thresholds, and writes proposals to `~/.kodelythecc/evolve/proposals.jsonl`. Idempotent — re-running with the same evidence produces the same proposal IDs and does NOT duplicate.
 
 | Flag | Default | Effect |
 |---|---|---|
@@ -111,8 +111,8 @@ Marks a proposal `rejected`. Optional `--note` is preserved for the audit trail.
 
 The auto-recall hook (`hooks/memory/auto-recall.js`) does two things in addition to its normal job:
 
-1. **On a memory surface** — calls `evolve.recordSurface({ memoryId, sessionId, projectRoot })`. This bumps the per-memory counter in `~/.kodelyth/evolve/reuse.json`. Idempotent per `(memoryId, sessionId)` — you can't game the counter by surfacing the same memory ten times in one session.
-2. **On a substantive prompt with zero memory matches** — calls `evolve.recordRoutingMiss({ prompt, sessionId, projectRoot })`. Appends one line to `~/.kodelyth/evolve/routing-misses.jsonl`. The prompt is capped to 1000 chars and stored alongside its top tokens for clustering.
+1. **On a memory surface** — calls `evolve.recordSurface({ memoryId, sessionId, projectRoot })`. This bumps the per-memory counter in `~/.kodelythecc/evolve/reuse.json`. Idempotent per `(memoryId, sessionId)` — you can't game the counter by surfacing the same memory ten times in one session.
+2. **On a substantive prompt with zero memory matches** — calls `evolve.recordRoutingMiss({ prompt, sessionId, projectRoot })`. Appends one line to `~/.kodelythecc/evolve/routing-misses.jsonl`. The prompt is capped to 1000 chars and stored alongside its top tokens for clustering.
 
 Both calls are **fire-and-forget**: any error is swallowed silently. The hook NEVER blocks recall on stats failure.
 
@@ -157,7 +157,7 @@ Proposal IDs are deterministic over their evidence — the same evidence always
 ## Storage layout
 
 ```
-~/.kodelyth/evolve/
+~/.kodelythecc/evolve/
 ├── reuse.json               # per-memory reuse counters
 ├── routing-misses.jsonl     # append-only miss log
 └── proposals.jsonl          # append-only proposal events