kodelyth-ecc 1.5.0 → 1.5.1

package/CHANGELOG.md

@@ -2,6 +2,60 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v1.5.1 — Compound Learning System (May 2026)
+
+### The Self-Improvement Loop
+
+Every correction you make to Claude gets encoded permanently into your project. Next session, Claude doesn't repeat the mistake. The month after, it matches how you think. After a year, it works like a team member who has been here for years.
+
+### New: Three-Layer Compound Memory Architecture
+
+| Layer | File | Scope | How it works |
+|---|---|---|---|
+| Project Lessons | `tasks/lessons.md` | Per-project | Hard rules from your corrections. Injected at session start. |
+| Global Memory | `~/.kodelyth/memory/` | Cross-project | BM25 fuzzy recall of past solutions. Auto-fires on every prompt. |
+| Intent Routing | 61 agents | Always-on | Routes your message to the right specialist from the first word. |
+
+### Added
+
+#### `hooks/memory/capture-correction.js` (Stop hook)
+- Scans session JSONL for user correction patterns (12 signal types: "no don't", "use X instead", "stop doing Y", "we always", "wrong approach", etc.)
+- Extracts corrections as hard rules and appends to `tasks/lessons.md` in the project root
+- Runs async at session end — zero latency impact
+- Self-deduplicates: same rule never written twice
+
+#### `hooks/memory/read-lessons.js` (SessionStart hook)
+- Reads `tasks/lessons.md` at session start and injects rules as high-priority context
+- Detects project tech stack (Node.js + framework, Go, Rust, Python, Java) and injects a project DNA brief
+- Reads open items from `tasks/todo.md` and surfaces them at session start
+- Fires before all other hooks — lessons are always loaded first
+
+#### `rules/common/self-improvement-workflow.md`
+- Encodes Boris Cherny's internal Claude Code team workflow (6 patterns)
+- Extended with ECC's three-layer compound memory architecture
+- Plan Node Default, Subagent Strategy, Self-Improvement Loop, Verification Before Done, Demand Elegance, Autonomous Bug Fixing
+- Task Management Protocol: `tasks/todo.md` + `tasks/lessons.md` as first-class project artifacts
+
+### How Addiction Works
+
+```
+Session 1:  You say "use pnpm not npm"
+            → capture-correction.js writes: "- use pnpm not npm" to tasks/lessons.md
+
+Session 2:  read-lessons.js fires at start
+            → "PROJECT LESSONS — HARD RULES" injected into context
+            → Claude uses pnpm without being told
+
+Month 1:    10+ lessons stacked
+            → Claude matches your style, your conventions, your preferences
+
+Month 3:    You open another AI tool
+            → It feels like a new hire who knows nothing about your project
+            → You come back
+```
+
+---
+
 ## v1.5.0 — Incident Response + Load Testing + Complete Visual Refresh (May 2026)
 
 ### Added — 2 New Specialist Agents

package/SECURITY.md

@@ -4,8 +4,12 @@
 
 | Version | Supported |
 |---------|-----------|
-| 1.1.x   | Yes — active |
-| 1.0.x   | No — upgrade to 1.1.x |
+| 1.5.x   | Yes — current stable |
+| 1.4.x   | Yes — security fixes only |
+| 1.3.x   | Yes — security fixes only |
+| 1.2.x   | No — upgrade to 1.5.x |
+| 1.1.x   | No — upgrade to 1.5.x |
+| 1.0.x   | No — upgrade to 1.5.x |
 | < 1.0   | No |
 
 ---

package/VERSION

@@ -1 +1 @@
-1.5.0
+1.5.1

package/hooks/hooks.json

@@ -168,6 +168,19 @@
       }
     ],
     "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/memory/read-lessons.js\"",
+            "async": false,
+            "timeout": 4
+          }
+        ],
+        "description": "Kodelyth ECC: inject project lessons (tasks/lessons.md) and project DNA as hard rules at session start",
+        "id": "kodelyth:session:start:read-lessons"
+      },
       {
         "matcher": "*",
         "hooks": [
@@ -340,6 +353,19 @@
       }
     ],
     "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/memory/capture-correction.js\"",
+            "async": true,
+            "timeout": 8
+          }
+        ],
+        "description": "Kodelyth ECC: detect user corrections in session and encode them as hard rules to tasks/lessons.md (Self-Improvement Loop)",
+        "id": "kodelyth:stop:capture-correction"
+      },
       {
         "matcher": "*",
         "hooks": [
@@ -375,7 +401,7 @@
             "timeout": 300
           }
         ],
-        "description": "Batch format (Biome/Prettier) and typecheck (tsc) all JS/TS files edited this response — runs once at Stop instead of after every Edit",
+        "description": "Batch format (Biome/Prettier) and typecheck (tsc) all JS/TS files edited this response \u2014 runs once at Stop instead of after every Edit",
         "id": "stop:format-typecheck"
       },
       {
@@ -458,4 +484,4 @@
       }
     ]
   }
-}
+}

package/hooks/memory/capture-correction.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Correction Capture Hook (Stop)
+//
+// Runs at the end of every Claude Code session. Scans the session JSONL for
+// user messages that contain corrections (e.g. "no don't", "use X instead",
+// "stop doing Y", "wrong approach"). Extracts them as hard rules and appends
+// them to tasks/lessons.md in the project root.
+//
+// This is the engine behind the Self-Improvement Loop:
+//   User corrects Claude → rule encoded → next session it doesn't repeat it
+//
+// Output contract: always pass stdin through to stdout. Never block a session.
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+// ── Correction signal patterns ─────────────────────────────────────────────
+const CORRECTION_SIGNALS = [
+  /\bno[,.]?\s+(don'?t|do not|never|stop|that'?s)/i,
+  /\bthat'?s?\s+(wrong|incorrect|not right|not what I|not how I)/i,
+  /\b(don'?t|do not|never)\s+(do that|use that|write that|add that|put that)/i,
+  /\b(stop|avoid)\s+(doing|using|writing|adding|calling)/i,
+  /\binstead[,\s]\s*(use|do|write|call|import|prefer)/i,
+  /\b(wrong approach|bad approach|hacky|not the right way|not how we do)/i,
+  /\b(I said|I told you|I asked you)\s+(not to|to not|don'?t|to use|to avoid)/i,
+  /\b(always|never)\s+(use|do|write|prefer|avoid|import|call)\b/i,
+  /\buse\s+\w[\w-]*\s+(not|instead of|rather than)\s+\w/i,
+  /\b(we use|we prefer|we don'?t use|we never|we always)\b/i,
+  /\b(please don'?t|please use|please avoid|please stop)\b/i,
+  /\bthat'?s not (what|how|the way)/i,
+];
+
+// ── Messages that look like corrections but are questions ──────────────────
+const EXCLUDE_PATTERNS = [
+  /\?$/,
+  /^(what|how|why|when|where|which|who|can you|could you|would you|should I)/i,
+];
+
+// ── Minimum message length to bother with ─────────────────────────────────
+const MIN_LEN = 8;
+
+// ── Entry point ───────────────────────────────────────────────────────────
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { raw += chunk; });
+process.stdin.on('end', run);
+setTimeout(() => { if (!process.stdin.readableEnded) run(); }, 150);
+
+function run() {
+  // Always pass stdin through — never block a session
+  if (raw) process.stdout.write(raw);
+
+  try {
+    const payload = raw ? JSON.parse(raw) : {};
+    const sessionJsonl = payload.session_path
+      || payload.transcript_path
+      || findLatestSession(payload.cwd || process.cwd());
+
+    if (!sessionJsonl || !fs.existsSync(sessionJsonl)) return;
+
+    const corrections = extractCorrections(sessionJsonl);
+    if (corrections.length === 0) return;
+
+    writeToLessons(corrections, payload.cwd || process.cwd());
+  } catch (err) {
+    process.stderr.write(`[ecc:correction-capture] ${err.message}\n`);
+  }
+}
+
+// ── Extract corrections from session JSONL ─────────────────────────────────
+function extractCorrections(sessionJsonl) {
+  const lines = fs.readFileSync(sessionJsonl, 'utf8').split('\n').filter(Boolean);
+  const corrections = [];
+
+  for (const line of lines) {
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+
+    // Only process user turns
+    if (event.type !== 'user') continue;
+
+    const text = extractText(event);
+    if (!text || text.length < MIN_LEN) continue;
+
+    // Skip if it looks like a question
+    if (EXCLUDE_PATTERNS.some(p => p.test(text.trim()))) continue;
+
+    // Check for correction signals
+    if (!CORRECTION_SIGNALS.some(p => p.test(text))) continue;
+
+    // Clean up and cap length
+    const cleaned = text.trim().replace(/\s+/g, ' ').slice(0, 300);
+    corrections.push(cleaned);
+  }
+
+  // Deduplicate
+  return [...new Set(corrections)];
+}
+
+// ── Pull plain text from an event ─────────────────────────────────────────
+function extractText(event) {
+  const content = event.message?.content ?? event.content ?? '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter(b => b.type === 'text')
+      .map(b => b.text || '')
+      .join(' ')
+      .trim();
+  }
+  return '';
+}
+
+// ── Write lessons to tasks/lessons.md ─────────────────────────────────────
+function writeToLessons(corrections, cwd) {
+  const tasksDir = path.join(cwd, 'tasks');
+  const lessonsFile = path.join(tasksDir, 'lessons.md');
+
+  try {
+    fs.mkdirSync(tasksDir, { recursive: true });
+
+    const isNew = !fs.existsSync(lessonsFile);
+    const date  = new Date().toISOString().split('T')[0];
+    const project = path.basename(cwd);
+
+    let header = '';
+    if (isNew) {
+      header = [
+        '# Claude Lessons',
+        '',
+        `Project: **${project}**`,
+        '',
+        'Auto-generated by Kodelyth ECC. Each entry is a rule Claude learned from a correction.',
+        'Edit freely — add, remove, reword. These are YOUR rules.',
+        '',
+        '---',
+        '',
+      ].join('\n');
+    }
+
+    const block = [
+      `## ${date}`,
+      '',
+      ...corrections.map(c => `- ${c}`),
+      '',
+    ].join('\n');
+
+    fs.appendFileSync(lessonsFile, header + block, 'utf8');
+
+    process.stderr.write(
+      `[ecc:correction-capture] ${corrections.length} lesson(s) written to tasks/lessons.md\n`
+    );
+  } catch (err) {
+    process.stderr.write(`[ecc:correction-capture] Could not write lessons: ${err.message}\n`);
+  }
+}
+
+// ── Find the latest session JSONL for this project ────────────────────────
+function findLatestSession(cwd) {
+  try {
+    const os = require('os');
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(projectsDir)) return null;
+
+    const encoded = cwd.replace(/\//g, '-');
+    const dirs = fs.readdirSync(projectsDir)
+      .filter(d => encoded.endsWith(d.slice(-20)) || d.endsWith(encoded.slice(-30)));
+
+    if (dirs.length === 0) return null;
+
+    const projectDir = path.join(projectsDir, dirs[0]);
+    const sessions = fs.readdirSync(projectDir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => ({ f, mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime);
+
+    return sessions[0] ? path.join(projectDir, sessions[0].f) : null;
+  } catch {
+    return null;
+  }
+}

package/hooks/memory/read-lessons.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Lessons + Project DNA Hook (SessionStart)
+//
+// Runs at the start of every Claude Code session. Does two things:
+//
+//   1. LESSONS: Reads tasks/lessons.md from the project root (if it exists)
+//      and injects the encoded rules as high-priority context. These are
+//      corrections the user made in past sessions — hard rules, not soft
+//      suggestions. Claude MUST follow them for this session.
+//
+//   2. PROJECT DNA: Detects the tech stack, package manager, and key
+//      conventions from the project root (package.json, go.mod, Cargo.toml,
+//      etc.) and injects a concise project brief so Claude doesn't need to
+//      re-discover basics each session.
+//
+// Output contract: emit { additionalContext: "..." } to stdout.
+// Never block a session — exit 0 even on any error.
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { raw += chunk; });
+process.stdin.on('end', run);
+setTimeout(() => { if (!process.stdin.readableEnded) run(); }, 150);
+
+function run() {
+  try {
+    const payload = raw ? JSON.parse(raw) : {};
+    const projectRoot = payload.cwd || payload.project_root || process.cwd();
+
+    const parts = [];
+
+    const lessons = readLessons(projectRoot);
+    if (lessons) parts.push(lessons);
+
+    const dna = buildProjectDNA(projectRoot);
+    if (dna) parts.push(dna);
+
+    if (parts.length === 0) {
+      process.exit(0);
+    }
+
+    process.stdout.write(JSON.stringify({
+      additionalContext: parts.join('\n\n---\n\n'),
+      meta: { source: 'kodelyth-ecc:read-lessons', hasLessons: !!lessons, hasDNA: !!dna },
+    }));
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`[ecc:read-lessons] ${err.message}\n`);
+    process.exit(0);
+  }
+}
+
+// ── Read tasks/lessons.md and format as hard rules ────────────────────────
+function readLessons(projectRoot) {
+  const lessonsFile = path.join(projectRoot, 'tasks', 'lessons.md');
+  if (!fs.existsSync(lessonsFile)) return null;
+
+  const content = fs.readFileSync(lessonsFile, 'utf8').trim();
+  if (!content) return null;
+
+  // Extract all bullet rules across all dated sections
+  const rules = content
+    .split('\n')
+    .filter(line => line.match(/^-\s+.{5,}/))
+    .map(line => line.trim())
+    .filter(Boolean);
+
+  if (rules.length === 0) return null;
+
+  return [
+    '## PROJECT LESSONS — HARD RULES (from past corrections)',
+    '',
+    'These rules were encoded from corrections made in previous sessions.',
+    'You MUST follow them for this entire session. They override generic defaults.',
+    '',
+    rules.join('\n'),
+  ].join('\n');
+}
+
+// ── Detect project tech stack and conventions ─────────────────────────────
+function buildProjectDNA(projectRoot) {
+  const facts = [];
+
+  // Node / JS / TS
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const name = pkg.name || path.basename(projectRoot);
+      facts.push(`Project: ${name} (Node.js / JavaScript)`);
+
+      // Package manager
+      if (fs.existsSync(path.join(projectRoot, 'pnpm-lock.yaml'))) {
+        facts.push('Package manager: pnpm');
+      } else if (fs.existsSync(path.join(projectRoot, 'bun.lockb')) || fs.existsSync(path.join(projectRoot, 'bun.lock'))) {
+        facts.push('Package manager: bun');
+      } else if (fs.existsSync(path.join(projectRoot, 'yarn.lock'))) {
+        facts.push('Package manager: yarn');
+      } else {
+        facts.push('Package manager: npm');
+      }
+
+      // Framework detection
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const frameworks = [];
+      if (deps.next) frameworks.push(`Next.js ${deps.next}`);
+      if (deps.react) frameworks.push(`React ${deps.react}`);
+      if (deps.vue) frameworks.push(`Vue ${deps.vue}`);
+      if (deps.svelte) frameworks.push(`Svelte`);
+      if (deps.express) frameworks.push(`Express ${deps.express}`);
+      if (deps.fastify) frameworks.push(`Fastify`);
+      if (deps.nestjs || deps['@nestjs/core']) frameworks.push('NestJS');
+      if (deps.typescript || deps['ts-node']) frameworks.push('TypeScript');
+      if (deps.prisma || deps['@prisma/client']) frameworks.push('Prisma');
+      if (deps.drizzle) frameworks.push('Drizzle ORM');
+      if (frameworks.length > 0) facts.push(`Stack: ${frameworks.join(', ')}`);
+
+      // Test runner
+      if (deps.jest) facts.push('Test runner: Jest');
+      else if (deps.vitest) facts.push('Test runner: Vitest');
+      else if (deps.mocha) facts.push('Test runner: Mocha');
+    } catch {}
+  }
+
+  // Go
+  const goModPath = path.join(projectRoot, 'go.mod');
+  if (fs.existsSync(goModPath)) {
+    try {
+      const goMod = fs.readFileSync(goModPath, 'utf8');
+      const moduleLine = goMod.match(/^module (.+)/m);
+      const goVersion  = goMod.match(/^go (.+)/m);
+      facts.push(`Project: ${moduleLine?.[1] || 'Go module'} (Go${goVersion ? ' ' + goVersion[1] : ''})`);
+    } catch {}
+  }
+
+  // Rust
+  const cargoPath = path.join(projectRoot, 'Cargo.toml');
+  if (fs.existsSync(cargoPath)) {
+    try {
+      const cargo = fs.readFileSync(cargoPath, 'utf8');
+      const name  = cargo.match(/^name\s*=\s*"(.+)"/m);
+      facts.push(`Project: ${name?.[1] || 'Rust crate'} (Rust / Cargo)`);
+    } catch {}
+  }
+
+  // Python
+  const reqPath   = path.join(projectRoot, 'requirements.txt');
+  const pyprojPath = path.join(projectRoot, 'pyproject.toml');
+  if (fs.existsSync(reqPath) || fs.existsSync(pyprojPath)) {
+    facts.push('Language: Python');
+    if (fs.existsSync(path.join(projectRoot, 'poetry.lock'))) facts.push('Package manager: Poetry');
+    else if (fs.existsSync(path.join(projectRoot, 'Pipfile.lock'))) facts.push('Package manager: Pipenv');
+    else facts.push('Package manager: pip');
+  }
+
+  // Java / Kotlin
+  if (fs.existsSync(path.join(projectRoot, 'build.gradle')) || fs.existsSync(path.join(projectRoot, 'build.gradle.kts'))) {
+    facts.push('Build: Gradle (Java / Kotlin)');
+  }
+  if (fs.existsSync(path.join(projectRoot, 'pom.xml'))) {
+    facts.push('Build: Maven (Java)');
+  }
+
+  // Existing tasks/todo.md
+  const todoPath = path.join(projectRoot, 'tasks', 'todo.md');
+  if (fs.existsSync(todoPath)) {
+    const todo = fs.readFileSync(todoPath, 'utf8').trim();
+    const openItems = todo.split('\n').filter(l => l.match(/^-\s*\[ \]/)).slice(0, 5);
+    if (openItems.length > 0) {
+      facts.push('');
+      facts.push('Open tasks (from tasks/todo.md):');
+      openItems.forEach(item => facts.push(item.trim()));
+    }
+  }
+
+  if (facts.length === 0) return null;
+
+  return [
+    '## PROJECT DNA (auto-detected)',
+    '',
+    facts.join('\n'),
+  ].join('\n');
+}

package/install.sh

@@ -47,7 +47,7 @@ echo -e "${RED}${BOLD}  ║   DANGER LEVEL: GOD TIER    ·    NOT FOR JUNIOR DEV
 echo -e "${RED}${BOLD}  ╚══════════════════════════════════════════════════════════════╝${RESET}"
 echo ""
 echo -e "${BOLD}  Kodelyth ECC — The most dangerous AI coding toolkit on the planet${RESET}"
-echo -e "${CYAN}  59 specialist agents  ·  188 skills  ·  80 commands  ·  18+ hooks  ·  intent routing  ·  local memory${RESET}"
+echo -e "${CYAN}  61 specialist agents  ·  188 skills  ·  80 commands  ·  20+ hooks  ·  intent routing  ·  compound memory${RESET}"
 echo -e "${CYAN}  Any language  ·  Any framework  ·  Any scale  ·  300B-level quality${RESET}"
 echo ""
 echo -e "  github.com/sifxprime/kodelyth-ecc"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kodelyth-ecc",
-  "version": "1.5.0",
-  "description": "Production-grade AI coding toolkit — 61 agents, 188 skills, 80 commands, god-tier intent routing, local self-learning memory with auto chat detection, incident response, load testing. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
+  "version": "1.5.1",
+  "description": "Production-grade AI coding toolkit \u2014 61 agents, 188 skills, 80 commands, god-tier intent routing, local self-learning memory with auto chat detection, incident response, load testing. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",
   "repository": {

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

@@ -0,0 +1,126 @@
+# Self-Improvement Workflow — Compound Learning System
+
+This rule encodes the workflow used by the Claude Code team internally, extended with ECC's three-layer compound memory architecture. Every session makes Claude more aligned with how YOU think and work.
+
+---
+
+## 1. Plan Node Default
+
+Enter plan mode for ANY non-trivial task (3+ steps, architectural decisions, or anything that touches more than 2 files):
+
+- Write the plan to `tasks/todo.md` with checkable items before writing a single line of code
+- If something goes sideways mid-task: STOP, re-plan, do not keep pushing
+- Use plan mode for verification steps, not just building
+- Write detailed specs upfront — ambiguity at start = bugs at end
+- Check plan with the user before executing when scope is large
+
+## 2. Subagent Strategy
+
+The 61 ECC specialist agents exist so the main context window stays clean:
+
+- Offload research, exploration, and parallel analysis to subagents
+- For complex problems: throw more compute via agents, not more tokens in main context
+- One task per subagent — focused execution beats monolithic threads
+- Intent routing picks the right specialist automatically — trust it
+
+## 3. Self-Improvement Loop (CRITICAL)
+
+**After ANY correction from the user — no matter how small — encode it permanently.**
+
+When the user says something like "no, don't do that", "use X instead", "I told you to", "wrong approach", "stop doing X":
+
+1. **Acknowledge** the correction in one line
+2. **Apply** it immediately in the current response
+3. **Encode** it: mentally append the rule to `tasks/lessons.md` in the project root
+
+The AI MUST track corrections within a session and apply them consistently from that point forward. The `capture-correction.js` hook writes them to disk automatically at session end.
+
+### How lessons compound
+
+```
+Session 1:  User corrects "use pnpm not npm" → lesson written
+Session 2:  Claude reads lesson → never uses npm again in this project
+Session 3+: New lessons stack → Claude increasingly matches YOUR style
+Month 3:    Claude works like a team member who has been here for years
+```
+
+**Review and extend lessons** at `tasks/lessons.md` — edit them freely, they are yours.
+
+## 4. Verification Before Done
+
+Never mark a task complete without proving it works:
+
+- Run the actual code, test, or command — do not assume
+- Diff behavior between baseline and your changes when relevant
+- Ask: "Would a staff engineer approve this PR?"
+- Run tests, check logs, demonstrate correctness with evidence
+- If verification fails: fix, do not close the loop
+
+## 5. Demand Elegance (Balanced)
+
+For non-trivial changes, pause before presenting:
+
+- Ask internally: "Is there a more elegant solution?"
+- If the fix feels hacky: "Knowing everything I know now, implement the elegant solution"
+- **Skip this for simple, obvious fixes** — do not over-engineer
+- Challenge your own work before presenting it
+- Three lines of clear code beat a clever one-liner every time
+
+## 6. Autonomous Bug Fixing
+
+When given a bug report: fix it. Do not ask for hand-holding:
+
+- Point at logs, errors, and failing tests — then resolve them
+- Zero context switching required from the user
+- Go fix failing CI tests without being told how
+- Use `debug-detective` for root cause analysis (never patch symptoms)
+- Use `silent-failure-hunter` when there is no error message
+
+---
+
+## Task Management Protocol
+
+When starting any non-trivial task:
+
+1. **Plan First** — write plan to `tasks/todo.md` with checkable items
+2. **Verify Plan** — check in before starting implementation on large tasks
+3. **Track Progress** — mark items complete as you go
+4. **Explain Changes** — high-level summary at each step
+5. **Document Results** — add review section to `tasks/todo.md`
+6. **Capture Lessons** — `tasks/lessons.md` is updated automatically by the correction hook
+
+---
+
+## Three-Layer Compound Memory Architecture
+
+ECC uses three compounding memory layers — together they make Claude increasingly match how you think:
+
+### Layer 1 — Project Lessons (`tasks/lessons.md`)
+- Per-project. Human-readable. Hard rules.
+- Written automatically when you correct Claude (via `capture-correction.js` Stop hook)
+- Injected at session start (via `read-lessons.js` SessionStart hook)
+- Edit freely — these are YOUR rules for this project
+- Example: "Always use pnpm. Never npm. Never yarn."
+
+### Layer 2 — Global Memory (`~/.kodelyth/memory/`)
+- Cross-project. BM25 fuzzy search. Solution patterns.
+- Captures solutions from every session
+- Auto-recalls relevant past solutions on every prompt you type
+- Example: "Last time you had a CORS issue in Express, you added this middleware..."
+
+### Layer 3 — Intent Routing (`rules/common/agent-intent-routing.md`)
+- Always-on. 61 specialists. Zero setup.
+- Routes your message to the right expert from the first word
+- No agent names needed — just describe the problem
+
+**Combined effect**: Layer 1 knows your project rules. Layer 2 knows your past solutions. Layer 3 knows your intent. Together they eliminate the ramp-up cost of every session.
+
+---
+
+## Core Principles
+
+- **Simplicity First** — make every change as simple as possible, impact minimal code
+- **No Laziness** — find root causes, no temporary fixes, senior developer standards
+- **Minimal Impact** — changes touch only what's necessary, avoid introducing bugs
+- **Immutability** — create new objects, never mutate existing ones
+- **No Guessing** — if uncertain, ask. Never fabricate facts or behavior.