kodelyth-ecc 1.9.0 → 1.9.1

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 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.

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

@@ -200,6 +200,23 @@ if (args[0] === 'rtk') {
       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); }
@@ -214,7 +231,20 @@ if (args[0] === 'rtk') {
       process.exit(r.disabled ? 0 : 1);
     }
     if (sub === 'status') {
-      log(JSON.stringify(rtk.status(), null, 2));
+      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') {
@@ -1084,20 +1114,24 @@ if (isWin) {
       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') });
+        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: (m) => process.stdout.write(m + '\n') });
+          const en = rtk.enableFor(target, { log: () => {} });
           if (en.enabled) {
-            process.stdout.write(`[rtk] enabled for ${target} — restart your AI tool to activate\n`);
+            w(`  ✓ RTK ${(rtk.getVersion() || '').replace(/^rtk /,'')} — wired for ${target}`);
+            w(`  ✓ Restart your AI tool to activate. 60-90% token savings on shell commands.`);
           } else {
-            process.stdout.write(`[rtk] enable skipped: ${en.reason}\n`);
+            w(`  · skipped: ${en.reason}`);
+            w(`  → retry: kodelyth-ecc rtk enable --target ${target}`);
           }
         } 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');
+          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`);

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.9.0",
+  "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/rtk/index.js

@@ -31,6 +31,28 @@ const TARGET_MAP = {
   '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' });
@@ -100,7 +122,10 @@ function enableFor(target, { log = () => {} } = {}) {
   }
 
   log(`[rtk] wiring RTK into ${target} …`);
-  const r = spawnSync('rtk', [...rtkArgs, '--auto-patch'], { encoding: 'utf8' });
+  // --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 };
@@ -150,6 +175,7 @@ function savings({ days = 30 } = {}) {
 
 module.exports = {
   TARGET_MAP,
+  detectInstalledTargets,
   isInstalled,
   getVersion,
   install,

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