kodelyth-ecc 1.8.5 → 1.9.0

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## 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.
+
+### Changed
+
+- All 20 runtime JS files: memory, hooks, dashboard, evolve, MCP, router, tests now point at `~/.kodelythecc/` (42 replacements total)
+- `scripts/memory/store.js` — default `MEMORY_DIR` now `~/.kodelythecc/memory/`; runs migration on `require`
+- `bin/kodelyth-ecc.js` — runs migration on every CLI invocation (no-op after first run)
+- `KODELYTH_MEMORY_DIR` and related env vars kept unchanged for backwards compat
+
+### Added
+
+- `scripts/migrate-legacy.js` — one-shot migrator: merges memories, copies sibling files (index, patterns, projects/, evolve/, safety/, mcp-clients.json), renames old dir to `~/.kodelyth.backup-YYYY-MM-DD`, drops `.migrated-from-kodelyth` marker so it never runs twice
+
+### Behavior
+
+- **New users**: get `~/.kodelythecc/` from the start
+- **Existing users** (have `~/.kodelyth/`): data migrated on next CLI run or hook fire; original preserved as backup
+
 ## v1.8.0 — Visual system overhaul + SVG polish (May 2026)
 
 Comprehensive overhaul of all 31 social assets. GitHub social preview and OG image rebuilt with two-panel stat card layout. All text overflow issues fixed across the full SVG set. Test counts updated to 373. PNG exports regenerated at 4K only.

package/bin/kodelyth-ecc.js

@@ -20,6 +20,11 @@ const fs            = require('fs');
 const os            = require('os');
 
 const ROOT    = path.join(__dirname, '..');
+
+// Auto-migrate legacy ~/.kodelyth/ → ~/.kodelythecc/ on first run for existing users.
+// Idempotent; instant no-op if legacy dir is absent or migration marker exists.
+try { require(path.join(ROOT, 'scripts', 'migrate-legacy.js')).main(); } catch { /* best-effort */ }
+
 // zsh (unlike bash) passes inline comments as literal args — strip them
 const args    = process.argv.slice(2).filter((a, i, arr) => {
   if (a.startsWith('#')) return false;          // drop # and everything after
@@ -172,6 +177,59 @@ 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') {
+      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') {
+      log(JSON.stringify(rtk.status(), null, 2));
+      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') {
@@ -863,7 +921,7 @@ if (args.includes('--help') || args.includes('-h')) {
     mcp-call <name> <tool> [--json '{"arg":"value"}']
                          Call a tool on a registered server. See docs/mcp-clients.md.
     route                Recommend trivial/standard/hard model tier for a task. Reads
-                         .kodelyth/router.json and KODELYTH_ROUTER_* env vars. Disable with
+                         .kodelythecc/router.json and KODELYTH_ROUTER_* env vars. Disable with
                          KODELYTH_ROUTER=off. Use --json for machine-readable output.
     swarm                Run N specialist agents in parallel inside isolated git worktrees +
                          a tmux session. Auto-picks agents from --task signals or accepts
@@ -1010,6 +1068,7 @@ if (isWin) {
   }
   process.exit(result.status ?? 1);
 } else {
+  try { require(path.join(ROOT, 'scripts', 'migrate-legacy.js')).main(); } catch {}
   const sh = path.join(ROOT, 'install.sh');
   if (!fs.existsSync(sh)) {
     console.error('Error: install.sh not found in package root:', ROOT);
@@ -1017,5 +1076,33 @@ 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]) {
+        process.stdout.write('\n' + '─'.repeat(60) + '\n');
+        process.stdout.write('[rtk] setting up token savings (60-90% on shell commands)\n');
+        const inst = rtk.install({ log: (m) => process.stdout.write(m + '\n') });
+        if (inst.installed || inst.reason === 'already installed') {
+          const en = rtk.enableFor(target, { log: (m) => process.stdout.write(m + '\n') });
+          if (en.enabled) {
+            process.stdout.write(`[rtk] enabled for ${target} — restart your AI tool to activate\n`);
+          } else {
+            process.stdout.write(`[rtk] enable skipped: ${en.reason}\n`);
+          }
+        } else {
+          process.stdout.write(`[rtk] install skipped: ${inst.reason}\n`);
+          process.stdout.write('[rtk] you can retry later with: kodelyth-ecc rtk enable --target ' + target + '\n');
+        }
+      }
+    } catch (e) {
+      process.stderr.write(`[rtk] setup skipped: ${e.message}\n`);
+    }
+  }
+
   process.exit(result.status ?? 1);
 }

package/hooks/memory/auto-recall.js

@@ -11,7 +11,7 @@
 //   - Skips on prompts that look like agent commands (`use foo`, `@bar`)
 //   - Skips when no memory exists yet
 //   - Suppresses repeats: never re-surfaces the same memory twice in a session
-//     (state file: ~/.kodelyth/memory/session-surfaced-<sessionId>.json)
+//     (state file: ~/.kodelythecc/memory/session-surfaced-<sessionId>.json)
 //   - Always exits 0 — never blocks the prompt because memory is unavailable
 // =============================================================================
 
@@ -120,7 +120,7 @@ function formatBlock(memories, userPrompt) {
 
 function surfacedStatePath(sessionId) {
   const dir = process.env.KODELYTH_MEMORY_DIR
-    || path.join(os.homedir(), '.kodelyth', 'memory');
+    || path.join(os.homedir(), '.kodelythecc', 'memory');
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   return path.join(dir, `session-surfaced-${sessionId}.json`);
 }

package/hooks/memory/capture-stop.js

@@ -4,7 +4,7 @@
 //
 // Runs at the end of a Claude Code session. Locates the session JSONL,
 // extracts memory candidates, writes them to a review queue at:
-//   ~/.kodelyth/memory/pending-review.jsonl
+//   ~/.kodelythecc/memory/pending-review.jsonl
 //
 // Candidates are NEVER auto-stored. The user reviews via:
 //   /memory review-pending
@@ -51,7 +51,7 @@ function main() {
     }
 
     const dir = process.env.KODELYTH_MEMORY_DIR
-      || path.join(os.homedir(), '.kodelyth', 'memory');
+      || path.join(os.homedir(), '.kodelythecc', 'memory');
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 
     const sessionId = data.session_id || path.basename(sessionJsonl, '.jsonl');

package/hooks/safety/token-budget.js

@@ -21,7 +21,7 @@
 //                Blocks SessionStart once usage >= budget.
 //
 // Optional knobs:
-//   KODELYTH_TOKEN_BUDGET_DIR=/custom/path   default ~/.kodelyth/safety
+//   KODELYTH_TOKEN_BUDGET_DIR=/custom/path   default ~/.kodelythecc/safety
 //   KODELYTH_TOKEN_BUDGET_WARN=0.7           warn threshold (0-1, default 0.7)
 //   KODELYTH_TOKEN_BUDGET_RESET=1            wipe usage and exit (admin op)
 //
@@ -39,7 +39,7 @@ const WARN_PCT   = Math.max(0, Math.min(1, Number(process.env.KODELYTH_TOKEN_BUD
 const RESET      = !!process.env.KODELYTH_TOKEN_BUDGET_RESET;
 
 const STATE_DIR = process.env.KODELYTH_TOKEN_BUDGET_DIR
-  || path.join(os.homedir(), '.kodelyth', 'safety');
+  || path.join(os.homedir(), '.kodelythecc', 'safety');
 
 function safeExit(code) {
   try { process.stdout.write(''); } catch {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "1.8.5",
+  "version": "1.9.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/dashboard/data.js

@@ -4,8 +4,8 @@
 //
 // All data the dashboard renders comes from:
 //   - The MCP catalog (filesystem reads of agents/, skills/, commands/, rules/, bundles/)
-//   - The BM25 memory store (~/.kodelyth/memory/)
-//   - The evolve signal streams (~/.kodelyth/evolve/)
+//   - The BM25 memory store (~/.kodelythecc/memory/)
+//   - The evolve signal streams (~/.kodelythecc/evolve/)
 //   - The token-budget hook state (${KODELYTH_TOKEN_BUDGET_DIR})
 //   - The orchestration session dirs (.orchestration/<session>/)
 //   - Live IDE session activity (Claude Code, Windsurf, Antigravity)
@@ -35,13 +35,13 @@ const evolveProposals = safeRequire('scripts/evolve/proposals.js');
 // ── helpers ──────────────────────────────────────────────────────────────────
 
 function defaultMemoryDir() {
-  return process.env.KODELYTH_MEMORY_DIR || path.join(os.homedir(), '.kodelyth', 'memory');
+  return process.env.KODELYTH_MEMORY_DIR || path.join(os.homedir(), '.kodelythecc', 'memory');
 }
 function defaultEvolveDir() {
-  return process.env.KODELYTH_EVOLVE_DIR || path.join(os.homedir(), '.kodelyth', 'evolve');
+  return process.env.KODELYTH_EVOLVE_DIR || path.join(os.homedir(), '.kodelythecc', 'evolve');
 }
 function defaultBudgetDir() {
-  return process.env.KODELYTH_TOKEN_BUDGET_DIR || path.join(os.homedir(), '.kodelyth', 'token-budget');
+  return process.env.KODELYTH_TOKEN_BUDGET_DIR || path.join(os.homedir(), '.kodelythecc', 'token-budget');
 }
 function defaultCoordRoot() {
   return process.env.KODELYTH_COORDINATION_ROOT || path.join(process.cwd(), '.orchestration');

package/scripts/dashboard/server.js

@@ -37,11 +37,11 @@ const MAX_SSE_CLIENTS = 10;
 // IMPORTANT: include both `routing-misses.jsonl` (always present once evolve sees
 // any miss) AND `proposals.jsonl` (created later, after `evolve analyze` runs).
 const WATCH_PATHS = [
-  path.join(os.homedir(), '.kodelyth', 'memory',  'memories.jsonl'),
-  path.join(os.homedir(), '.kodelyth', 'evolve',  'reuse.json'),
-  path.join(os.homedir(), '.kodelyth', 'evolve',  'routing-misses.jsonl'),
-  path.join(os.homedir(), '.kodelyth', 'evolve',  'proposals.jsonl'),
-  path.join(os.homedir(), '.kodelyth', 'token-budget'), // dir mtime — changes when budget files appear
+  path.join(os.homedir(), '.kodelythecc', 'memory',  'memories.jsonl'),
+  path.join(os.homedir(), '.kodelythecc', 'evolve',  'reuse.json'),
+  path.join(os.homedir(), '.kodelythecc', 'evolve',  'routing-misses.jsonl'),
+  path.join(os.homedir(), '.kodelythecc', 'evolve',  'proposals.jsonl'),
+  path.join(os.homedir(), '.kodelythecc', 'token-budget'), // dir mtime — changes when budget files appear
 ];
 const lastMtimes    = new Map();
 let   lastIdeMtime  = 0; // max mtime across Claude Code / Windsurf / Antigravity sessions
@@ -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/evolve/proposals.js

@@ -12,7 +12,7 @@
 // audit trail is preserved. Reads collapse to "latest state per id".
 //
 // Storage:
-//   ${KODELYTH_EVOLVE_DIR:-~/.kodelyth/evolve}/proposals.jsonl
+//   ${KODELYTH_EVOLVE_DIR:-~/.kodelythecc/evolve}/proposals.jsonl
 //
 // Pure where possible. Public functions accept dir explicitly.
 'use strict';
@@ -22,7 +22,7 @@ const path = require('path');
 const os   = require('os');
 
 const DEFAULT_DIR = process.env.KODELYTH_EVOLVE_DIR
-  || path.join(os.homedir(), '.kodelyth', 'evolve');
+  || path.join(os.homedir(), '.kodelythecc', 'evolve');
 
 const PROPOSALS_FILE = 'proposals.jsonl';
 

package/scripts/evolve/stats.js

@@ -14,7 +14,7 @@
 //                          by tokens to surface "we keep getting asked
 //                          about X but have no agent / skill / memory for it".
 //
-// Storage layout (default ${HOME}/.kodelyth/evolve/):
+// Storage layout (default ${HOME}/.kodelythecc/evolve/):
 //   reuse.json                  { byMemory: { id: { count, sessions[], lastSurfaced } } }
 //   routing-misses.jsonl        append-only — one prompt per line
 //
@@ -31,7 +31,7 @@ const path = require('path');
 const crypto = require('crypto');
 
 const DEFAULT_DIR = process.env.KODELYTH_EVOLVE_DIR
-  || path.join(os.homedir(), '.kodelyth', 'evolve');
+  || path.join(os.homedir(), '.kodelythecc', 'evolve');
 
 const REUSE_FILE = 'reuse.json';
 const MISSES_FILE = 'routing-misses.jsonl';

package/scripts/mcp/client.js

@@ -6,7 +6,7 @@
 // make ECC the MCP HUB: serve to any framework, consume from any provider.
 //
 // Storage:
-//   ~/.kodelyth/mcp-clients.json     registry of named external servers
+//   ~/.kodelythecc/mcp-clients.json     registry of named external servers
 //
 // Public API (all functions pure or local file-only):
 //   loadRegistry(), saveRegistry(reg)
@@ -32,7 +32,7 @@ const os   = require('os');
 const path = require('path');
 
 const REGISTRY_DIR = process.env.KODELYTH_MCP_CLIENT_DIR
-  || path.join(os.homedir(), '.kodelyth');
+  || path.join(os.homedir(), '.kodelythecc');
 const REGISTRY_FILE = path.join(REGISTRY_DIR, 'mcp-clients.json');
 
 // ── Registry I/O ─────────────────────────────────────────────────────────────

package/scripts/memory/instincts.js

@@ -2,7 +2,7 @@
 // Kodelyth ECC — Structured Instinct Schema  (Improvement B)
 //
 // Stores learned instincts as typed JSON records in:
-//   ~/.kodelyth/memory/instincts.jsonl
+//   ~/.kodelythecc/memory/instincts.jsonl
 //
 // Each instinct has: pattern, trigger, confidence, last_used, outcome, decay.
 // This replaces free-form markdown bullets for machine-readable learning.
@@ -33,7 +33,7 @@ const path   = require('path');
 const crypto = require('crypto');
 
 const MEMORY_DIR = process.env.KODELYTH_MEMORY_DIR
-  || path.join(os.homedir(), '.kodelyth', 'memory');
+  || path.join(os.homedir(), '.kodelythecc', 'memory');
 
 const INSTINCTS_FILE = path.join(MEMORY_DIR, 'instincts.jsonl');
 const STALE_DAYS     = 30;

package/scripts/memory/store.js

@@ -2,7 +2,7 @@
 // Kodelyth ECC — Memory Store
 // Local, zero-dependency, model-agnostic memory for AI coding sessions.
 //
-// Storage layout (all in ~/.kodelyth/memory/):
+// Storage layout (all in ~/.kodelythecc/memory/):
 //   memories.jsonl       Append-only log of every captured memory
 //   index.json           Inverted index: token -> [memory ids]
 //   patterns.json        User-level patterns (preferences, conventions)
@@ -19,8 +19,11 @@ const os   = require('os');
 const path = require('path');
 const crypto = require('crypto');
 
+// Auto-migrate legacy ~/.kodelyth/ → ~/.kodelythecc/ before we touch any path.
+try { require('../migrate-legacy').main(); } catch { /* best-effort */ }
+
 const MEMORY_DIR = process.env.KODELYTH_MEMORY_DIR
-  || path.join(os.homedir(), '.kodelyth', 'memory');
+  || path.join(os.homedir(), '.kodelythecc', 'memory');
 
 const PATHS = {
   dir:       MEMORY_DIR,

package/scripts/migrate-legacy.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+// One-shot migrator: ~/.kodelyth/ (old canonical) → ~/.kodelythecc/ (1.8.5+ canonical)
+// Idempotent — leaves a marker so it never runs twice.
+// Safe — never deletes source; renames old dir to .backup-<date>.
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const LEGACY = path.join(os.homedir(), '.kodelyth');
+const NEW    = path.join(os.homedir(), '.kodelythecc');
+const MARKER = path.join(NEW, '.migrated-from-kodelyth');
+
+function main() {
+  if (!fs.existsSync(LEGACY)) return { migrated: false, reason: 'no legacy dir' };
+  if (fs.existsSync(MARKER))  return { migrated: false, reason: 'already migrated' };
+
+  fs.mkdirSync(path.join(NEW, 'memory'), { recursive: true });
+
+  const legacyMem = path.join(LEGACY, 'memory', 'memories.jsonl');
+  const newMem    = path.join(NEW,    'memory', 'memories.jsonl');
+  let addedLines = 0;
+
+  if (fs.existsSync(legacyMem)) {
+    const existing = new Set(
+      fs.existsSync(newMem)
+        ? fs.readFileSync(newMem, 'utf8').split('\n').filter(Boolean)
+        : []
+    );
+    const legacyLines = fs.readFileSync(legacyMem, 'utf8').split('\n').filter(Boolean);
+    const toAppend = legacyLines.filter(l => !existing.has(l));
+    if (toAppend.length) {
+      fs.appendFileSync(newMem, (existing.size ? '\n' : '') + toAppend.join('\n') + '\n');
+      addedLines = toAppend.length;
+    }
+  }
+
+  // Copy any sibling files (index.json, session-surfaced-*.json) if not already present.
+  const legacyMemDir = path.join(LEGACY, 'memory');
+  let copiedFiles = 0;
+  if (fs.existsSync(legacyMemDir)) {
+    for (const f of fs.readdirSync(legacyMemDir)) {
+      if (f === 'memories.jsonl') continue;
+      const dst = path.join(NEW, 'memory', f);
+      if (!fs.existsSync(dst)) {
+        fs.copyFileSync(path.join(legacyMemDir, f), dst);
+        copiedFiles++;
+      }
+    }
+  }
+
+  // Copy other subtrees (evolve, safety, token-budget, mcp-clients.json) if missing.
+  const subtrees = ['evolve', 'safety', 'token-budget'];
+  for (const sub of subtrees) {
+    const src = path.join(LEGACY, sub);
+    const dst = path.join(NEW, sub);
+    if (fs.existsSync(src) && !fs.existsSync(dst)) {
+      copyDirSync(src, dst);
+    }
+  }
+  const legacyMcp = path.join(LEGACY, 'mcp-clients.json');
+  const newMcp    = path.join(NEW,    'mcp-clients.json');
+  if (fs.existsSync(legacyMcp) && !fs.existsSync(newMcp)) {
+    fs.copyFileSync(legacyMcp, newMcp);
+  }
+
+  // Rename legacy dir → backup (never delete).
+  const stamp = new Date().toISOString().slice(0, 10);
+  const backup = path.join(os.homedir(), `.kodelyth.backup-${stamp}`);
+  try {
+    if (!fs.existsSync(backup)) fs.renameSync(LEGACY, backup);
+  } catch { /* best-effort */ }
+
+  fs.writeFileSync(MARKER, JSON.stringify({
+    at: new Date().toISOString(),
+    addedLines,
+    copiedFiles,
+    backupPath: backup,
+  }, null, 2));
+
+  return { migrated: true, addedLines, copiedFiles, backupPath: backup };
+}
+
+function copyDirSync(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) copyDirSync(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+if (require.main === module) {
+  try {
+    const r = main();
+    if (r.migrated) {
+      process.stdout.write(
+        `[kodelyth] migrated legacy ~/.kodelyth → ~/.kodelythecc ` +
+        `(+${r.addedLines} memories, ${r.copiedFiles} files copied, backup: ${r.backupPath})\n`
+      );
+    }
+  } catch (e) {
+    process.stderr.write(`[kodelyth] migration skipped: ${e.message}\n`);
+  }
+}
+
+module.exports = { main };

package/scripts/router/classify.js

@@ -164,13 +164,13 @@ function classify(task, opts = {}) {
   return { tier: 'standard', reasons, score, explicit_tier: explicitTier || null };
 }
 
-// ── Config loader (env vars + .kodelyth/router.json) ─────────────────────────
+// ── Config loader (env vars + .kodelythecc/router.json) ─────────────────────────
 function loadConfig({ projectRoot = process.cwd() } = {}) {
   const cfg = { ...DEFAULT_MODELS, notes: '' };
 
   // 1. Project-level override.
   try {
-    const file = path.join(projectRoot, '.kodelyth', 'router.json');
+    const file = path.join(projectRoot, '.kodelythecc', 'router.json');
     if (fs.existsSync(file)) {
       const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
       for (const k of ['trivial', 'standard', 'hard', 'default', 'notes']) {

package/scripts/rtk/index.js

@@ -0,0 +1,160 @@
+// 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'],
+};
+
+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} …`);
+  const r = spawnSync('rtk', [...rtkArgs, '--auto-patch'], { 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,
+  isInstalled,
+  getVersion,
+  install,
+  enableFor,
+  disableFor,
+  status,
+  savings,
+};

package/tasks/lessons.md

@@ -0,0 +1,11 @@
+# Claude Lessons
+
+Project: **kodelyth-ecc**
+
+Auto-generated by Kodelyth ECC. Each entry is a rule Claude learned from a correction.
+Edit freely — add, remove, reword. These are YOUR rules.
+
+---
+## 2026-07-03
+
+- We need to update our kodelyth ecc ( elite code crew) we build from this - https://github.com/affaan-m/ecc but they are now more advance. So now problem is is our ECC less powerfull then them. We have bm25 memories but not works. We need grab maximum feature from them and attach into ours ( don't te