kodelyth-ecc 1.3.0 → 1.4.0

package/AGENTS.md

@@ -1,6 +1,6 @@
 # AGENTS.md
 
-This file is read by AI agents (Cascade, Cursor, Codex, etc.) on every session. It tells them how to work in this repo and how to use the 58 specialist agents and 187 skills shipped with Kodelyth ECC.
+This file is read by AI agents (Cascade, Cursor, Codex, etc.) on every session. It tells them how to work in this repo and how to use the 59 specialist agents and 188 skills shipped with Kodelyth ECC.
 
 ---
 

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v1.4.0 — Local Self-Learning Memory (May 2026)
+
+### Added — Kodelyth Memory
+- **Local self-learning memory store** — captures problems and solutions from past sessions, recalls them when relevant in future sessions
+- **Zero dependencies, zero telemetry** — all memory lives at `~/.kodelyth/memory/` (override with `KODELYTH_MEMORY_DIR`)
+- **BM25 retrieval** — pure JS keyword + tag search, sub-millisecond, no embeddings, no network
+- **Cache-friendly injection** — context block is structured with stable prefix → variable suffix to maximise prompt-cache hits on Anthropic and OpenAI models
+- **Model-agnostic** — works for Claude, GPT, Gemini, Llama, any model. Prompt-cache savings apply where the provider supports it; recall quality applies everywhere
+- **Privacy-first** — never auto-stores. Stop hook extracts candidates → user reviews via `/memory review-pending` → user confirms before storing
+
+### New files
+- `agents/kodelyth-memory.md` — agent persona and protocols
+- `skills/kodelyth-memory/SKILL.md` — when and how to use the memory system
+- `commands/memory.md` — `/memory` slash command
+- `rules/common/memory-protocol.md` — mid-session recall + capture rules
+- `scripts/memory/store.js` — BM25 storage + retrieval
+- `scripts/memory/inject.js` — cache-friendly context block builder
+- `scripts/memory/extract.js` — heuristic learning extractor for session JSONL
+- `scripts/memory/cli.js` — CLI entry point
+- `hooks/memory/inject-start.js` — SessionStart hook
+- `hooks/memory/capture-stop.js` — Stop hook
+- `tests/memory/store.test.js` — 12 new tests (38 total passing)
+
+### Honest disclosure
+- "Self-learning" means **better context retrieval over time**, not model fine-tuning. The LLM is unchanged. We give it smarter context.
+- Cloud-AI platforms (Windsurf, Antigravity, partial Cursor) store sessions server-side. Auto-extract from past sessions doesn't work there. Manual `/memory remember` still does.
+
+### Counts
+- Agents: 58 → **59** (+kodelyth-memory)
+- Skills: 187 → **188** (+kodelyth-memory)
+- Commands: 79 (+`/memory`, total stays 79 — replaces no slash)
+- Rules: 15 → **16** (+memory-protocol)
+
+---
+
 ## v1.3.0 — God-Tier Intent Routing + 5 New Agents (May 2026)
 
 ### Removed

package/CLAUDE.md

@@ -6,11 +6,11 @@ Guidance for Claude Code when working with this repository.
 
 **Kodelyth ECC** — a production-grade AI coding toolkit:
 
-- **58 specialist agents** — debug-detective, code-reviewer, security-reviewer, etc.
-- **187 skills** — domain knowledge, patterns, testing, security, intent routing
-- **79 commands** — slash workflows (`/tdd`, `/plan`, `/code-review`, ...)
-- **15+ hooks** — automated quality gates and session memory
-- **15 rules** — always-on coding standards + the **god-tier intent routing rule**
+- **59 specialist agents** — debug-detective, code-reviewer, security-reviewer, kodelyth-memory, etc.
+- **188 skills** — domain knowledge, patterns, testing, security, intent routing, local memory
+- **80 commands** — slash workflows (`/tdd`, `/plan`, `/code-review`, `/memory`, ...)
+- **18+ hooks** — automated quality gates, session memory, memory inject + capture
+- **16 rules** — always-on coding standards + intent routing + memory protocol
 
 Works with Claude Code, Windsurf, Cursor, Codex CLI, Antigravity, and OpenCode.
 

package/KODELYTH.md

@@ -20,7 +20,7 @@ Now the user just describes their problem in plain words and the AI:
 2. Behaves as that agent
 3. Teaches the user the explicit form (`Tip: type "use <agent>"`)
 
-No more memorizing 58 agent names.
+No more memorizing 59 agent names.
 
 ### Added: 5 New Specialist Agents
 

package/README.md

@@ -8,17 +8,18 @@
 ![Antigravity](https://img.shields.io/badge/Antigravity-Ready-00ADD8)
 ![Cursor](https://img.shields.io/badge/Cursor-Ready-3b82f6)
 ![Codex](https://img.shields.io/badge/Codex-Ready-10b981)
-![Version](https://img.shields.io/badge/version-1.3.0-orange)
-![Agents](https://img.shields.io/badge/Agents-58-brightgreen)
-![Skills](https://img.shields.io/badge/Skills-187-brightgreen)
+![Version](https://img.shields.io/badge/version-1.4.0-orange)
+![Agents](https://img.shields.io/badge/Agents-59-brightgreen)
+![Skills](https://img.shields.io/badge/Skills-188-brightgreen)
+![Memory](https://img.shields.io/badge/Local%20Memory-on-blueviolet)
 
 </div>
 
-**Kodelyth ECC** is a production-grade AI coding toolkit — **58 specialist agents, 187 skills, 79 commands**, and a god-tier **intent-routing system** that auto-detects what you need and hands you the right specialist before you finish typing.
+**Kodelyth ECC** is a production-grade AI coding toolkit — **59 specialist agents, 188 skills, 80 commands**, a god-tier **intent-routing system**, and **local self-learning memory** that gets smarter at helping *you* every session.
 
 Works with **Claude Code**, **Windsurf**, **Cursor**, **Codex CLI**, **Google Antigravity**, and **OpenCode**.
 
-> No dashboard. No telemetry. No cloud. Just rules, agents, and skills your AI loads on every session.
+> No dashboard. No telemetry. No cloud. Just rules, agents, skills, and your own private memory store — all on your disk.
 
 ---
 
@@ -151,25 +152,83 @@ See `skills/agent-handoff/SKILL.md` for the full handoff protocol and standard c
 
 ---
 
+## Kodelyth Memory — Local Self-Learning (new in v1.4.0)
+
+The first time you solve a hard problem, ECC remembers what worked. The next time you hit something similar, your AI surfaces the past solution before you ask.
+
+```
+Session 1 (March):
+  You:  "Stripe webhook signatures are failing in production"
+  AI:   [helps you debug, you discover raw body parser is required]
+  You:  "Perfect, that worked, thanks"
+  → ECC's Stop hook queues the lesson for review.
+  → You confirm with /memory review-pending → stored locally.
+
+Session 2 (August, new project):
+  You:  "I need to add Stripe webhooks to checkout"
+  AI:   I checked your memory — you solved this exact problem in March.
+        Raw body parser before signature validation, test with stripe-cli
+        not curl. Want me to apply the same pattern?
+  You:  "Yes, do it"
+  → 30 minutes of past debugging saved in 3 seconds.
+```
+
+### How it works
+
+| Layer | Mechanism |
+|---|---|
+| **Capture** | A Stop hook scans your session JSONL, extracts (problem, approach, gotchas, tags). Queues for your review — never auto-stores. |
+| **Storage** | `~/.kodelyth/memory/memories.jsonl` — append-only log on your disk only. Override with `KODELYTH_MEMORY_DIR`. |
+| **Retrieval** | BM25 keyword + tag search. Pure JS, sub-millisecond, no embeddings, no network. |
+| **Injection** | A SessionStart hook builds a cache-friendly context block: stable prefix (your patterns + recent project memories) → variable suffix (relevant to current task). |
+| **Cost win** | The stable prefix sits in the prompt cache. Anthropic charges 10% on cached tokens (5-min TTL); OpenAI auto-caches prefixes ≥1024 tokens. Long sessions become dramatically cheaper. |
+
+### Privacy
+
+Every byte stays on your machine. Verify any time with `ls -la ~/.kodelyth/memory/`. Sync across machines is opt-in (Dropbox/iCloud/git on that folder).
+
+### Slash command
+
+```
+/memory                          # Stats and recent memories
+/memory recall <query>           # BM25 search
+/memory remember "<title>"       # Capture (interactive — confirms before storing)
+/memory review-pending           # Review Stop-hook candidates
+/memory forget <id>              # Soft-delete a memory
+/memory inject [--query <text>]  # Print what your AI sees about you
+```
+
+### Honest limits
+
+- It is **not** model fine-tuning. The LLM never changes. We give it smarter context.
+- Cache savings apply to Anthropic and OpenAI. Other models (Gemini, Llama, Mistral) get the recall quality without the discount.
+- Cloud-AI platforms (Windsurf, Antigravity, partial Cursor) store sessions server-side. Auto-extract from past sessions doesn't work there. Manual `/memory remember` still does.
+
+See `skills/kodelyth-memory/SKILL.md` for the full design + CLI reference.
+
+---
+
 ## What's Inside
 
 | Component | Count | Description |
 |---|---|---|
-| Agents | **58** | Specialist subagents — reviewers, planners, debuggers, architects, doctors |
-| Skills | **187** | Domain knowledge — patterns, testing, security, DevOps, intent routing |
-| Commands | **79** | Slash command workflows (`/tdd`, `/plan`, `/code-review`, etc.) |
-| Hooks | **15+** | Quality gates, session memory, secret scanning, branch checks |
-| Rules | **15** | Always-on coding standards + the intent routing rule |
+| Agents | **59** | Specialist subagents — reviewers, planners, debuggers, architects, doctors, memory curator |
+| Skills | **188** | Domain knowledge — patterns, testing, security, DevOps, intent routing, memory |
+| Commands | **80** | Slash command workflows (`/tdd`, `/plan`, `/memory`, etc.) |
+| Hooks | **18+** | Quality gates, secret scanning, branch checks, memory inject + capture |
+| Rules | **16** | Always-on coding standards + intent routing + memory protocol |
+| Memory | **local** | BM25-indexed personal memory at `~/.kodelyth/memory/` (zero deps) |
 
 ---
 
 ## Agent Arsenal
 
-### Kodelyth Exclusives — The 11 Agents That Make ECC
+### Kodelyth Exclusives — The 13 Agents That Make ECC
 
 | Agent | One-line job |
 |---|---|
 | `kodelyth-advisor` | Master guide — picks the right tool when you don't know where to start |
+| `kodelyth-memory` | Curates your local memory — recalls past solutions, captures new ones |
 | `pair-programmer` | The engineer who sits next to you **before** you write the code |
 | `debug-detective` | Never guesses — traces every bug to root cause |
 | `silent-failure-hunter` | Finds bugs that don't throw errors |
@@ -282,8 +341,8 @@ The intent router will route you to the right one. The AI announces who's taking
 
 | Source | Destination | What it does |
 |---|---|---|
-| `agents/` | `~/.claude/agents/` | All 58 subagents available globally |
-| `skills/` | `~/.claude/skills/` | All 187 skills loadable via commands |
+| `agents/` | `~/.claude/agents/` | All 59 subagents available globally |
+| `skills/` | `~/.claude/skills/` | All 188 skills loadable via commands |
 | `hooks/hooks.json` | `~/.claude/hooks/` | Automated quality gates |
 | `rules/` | `~/.claude/rules/` | Always-on standards + intent routing |
 | `commands/` | `~/.claude/commands/` | Slash commands (`/tdd`, `/plan`, etc.) |
@@ -394,7 +453,15 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for templates, checklists, and the full K
 
 ## Changelog
 
-See [CHANGELOG.md](CHANGELOG.md). v1.3.0 highlights:
+See [CHANGELOG.md](CHANGELOG.md). v1.4.0 highlights:
+
+- **Added:** `kodelyth-memory` — local self-learning memory (BM25, zero deps, cache-friendly)
+- **Added:** SessionStart hook injects relevant past memories; Stop hook queues candidates for review
+- **Added:** `/memory` slash command + `kodelyth-memory` agent + `memory-protocol` rule
+- **Added:** 12 new tests (38 total passing)
+- **Honest disclosure:** "Self-learning" means smarter context retrieval, not model fine-tuning
+
+v1.3.0 highlights:
 
 - **Removed:** Lens dashboard (was inaccurate across cloud-AI platforms)
 - **Added:** God-tier `agent-intent-routing` rule — 10 priority tiers, 50+ patterns

package/VERSION

@@ -1 +1 @@
-1.3.0
+1.4.0

package/agents/kodelyth-memory.md

@@ -0,0 +1,87 @@
+---
+name: kodelyth-memory
+description: Manages the local Kodelyth Memory store — captures patterns and solutions from past sessions, recalls them when relevant, and shapes context for prompt-cache savings. Use PROACTIVELY at session start to recall relevant memories, and at session end to capture what worked. Model-agnostic.
+tools: Read, Write, Edit, Bash, Grep, Glob
+model: sonnet
+---
+
+# Kodelyth Memory
+
+You are **Kodelyth Memory** — the curator of the user's local AI memory. Everything you store stays on the user's machine. Nothing leaves.
+
+## Your job
+
+You do four things:
+
+1. **Recall** — at the start of work on a new task, search past memories for relevant patterns and surface them to the user before they ask.
+2. **Capture** — when the user solves a real problem, extract the lesson and store it.
+3. **Curate** — keep memory honest. Forget stale entries, dedupe duplicates, escalate contradictions to the user.
+4. **Shape context** — structure the injected memory block so it sits in the cacheable prefix of the model's context, maximising prompt-cache hits.
+
+## Recall protocol
+
+When invoked at session start (or when the user begins describing a new task):
+
+1. Run `node scripts/memory/cli.js inject --query "<task summary>"` to get the relevant memory block
+2. If `relevantCount > 0`, surface the memories naturally:
+   > "I see you solved a similar problem before — `<problem>` — using `<approach>`. Want me to apply the same pattern here, or is this case different?"
+3. If no matches, stay quiet. Don't fabricate "you usually..." patterns from nothing.
+4. Never recall a memory more than once per session — the user has already seen it.
+
+## Capture protocol
+
+When the user signals success (`"that worked"`, `"perfect"`, `"thanks"`, `"fixed it"`), or after a long iteration converges on a solution:
+
+1. Identify:
+   - **Problem** (one sentence — what the user originally asked)
+   - **Approach** (1-3 sentences — what actually worked, not what you tried)
+   - **Gotchas** (specific traps, max 2)
+   - **Tags** (auto-extract from the conversation: `api-integration`, `auth`, `database`, etc.)
+   - **Files touched**
+   - **Language**
+2. Show the proposed memory to the user **before storing** — silent capture is how memory systems become noise.
+3. On confirmation, run:
+   ```bash
+   node scripts/memory/cli.js remember "<problem>" --approach "<approach>" --tags "<tags>" --language "<lang>"
+   ```
+4. Confirm: "Stored. I'll bring this up next time you hit something similar."
+
+## Curate protocol
+
+Run `node scripts/memory/cli.js stats` weekly. Surface to user when:
+- Memory count exceeds 500 (offer to consolidate)
+- A tag appears in 20+ memories (offer to extract a pattern note)
+- Two memories contradict each other (ask which is current)
+
+## Cache-shaping rules
+
+The injected block from `cli.js inject` is structured into:
+- **Stable prefix** — patterns + recent project memories (identical across calls in same project)
+- **Variable suffix** — relevant-to-this-task memories (changes per query)
+
+Anthropic's prompt cache (5-min TTL, 10% cost on hits) and OpenAI's automatic caching both reward stable prefixes. Do not modify the stable section per session — this defeats the cache. If you need to add session-specific notes, append them after the memory block.
+
+## What you must never do
+
+- Capture without explicit user confirmation
+- Send memory data to any network endpoint (it's local-only by design)
+- Inject memories that contradict the current task without flagging the contradiction
+- Recall the same memory twice in one session
+- Auto-store every interaction as a memory (signal-to-noise dies)
+
+## 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/`).
+- 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
+
+User: "I need to add Stripe webhooks to this project"
+
+You (after running inject):
+> I checked your memory — you set up Stripe webhooks 4 months ago in `payments-api`. Key things you discovered then:
+> - Express body parser must be `raw`, not `json`, before signature validation
+> - Test with `stripe listen --forward-to`, not curl — curl can't sign requests
+>
+> Want me to apply the same pattern, or is this project's setup different?

package/bin/kodelyth-ecc.js

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 // Kodelyth ECC — npx entry point
-// Usage:
-//   npx github:sifxprime/kodelyth-ecc                           # Claude Code (default)
-//   npx github:sifxprime/kodelyth-ecc --target windsurf-project # Windsurf (project)
-//   npx github:sifxprime/kodelyth-ecc --target windsurf-home    # Windsurf (global)
-//   npx github:sifxprime/kodelyth-ecc --target antigravity      # Google Antigravity
-//   npx github:sifxprime/kodelyth-ecc --target cursor-project   # Cursor IDE
-//   npx github:sifxprime/kodelyth-ecc --target codex-home       # Codex CLI
-//   npx github:sifxprime/kodelyth-ecc --target opencode         # OpenCode
+// Usage (from npm — recommended):
+//   npx kodelyth-ecc                            # Claude Code (default)
+//   npx kodelyth-ecc --target windsurf-project  # Windsurf (project)
+//   npx kodelyth-ecc --target windsurf-home     # Windsurf (global)
+//   npx kodelyth-ecc --target antigravity       # Google Antigravity
+//   npx kodelyth-ecc --target cursor-project    # Cursor IDE
+//   npx kodelyth-ecc --target codex-home        # Codex CLI
+//   npx kodelyth-ecc --target opencode          # OpenCode
+//
+// Usage (from GitHub — latest commit):
+//   npx github:sifxprime/kodelyth-ecc
 
 'use strict';
 
@@ -26,7 +29,7 @@ if (args.includes('--help') || args.includes('-h')) {
   Kodelyth ECC — AI Coding Toolkit installer
 
   Usage:
-    npx github:sifxprime/kodelyth-ecc [--target TARGET] [--profile PROFILE] [languages...]
+    npx kodelyth-ecc [--target TARGET] [--profile PROFILE] [languages...]
 
   Targets:
     claude-home          Claude Code — global install (default)
@@ -38,10 +41,13 @@ if (args.includes('--help') || args.includes('-h')) {
     opencode             OpenCode — project install (.opencode/)
 
   Examples:
+    npx kodelyth-ecc
+    npx kodelyth-ecc --target windsurf-project
+    npx kodelyth-ecc --target antigravity --profile nextjs
+    npx kodelyth-ecc --target claude-home typescript python
+
+    # Always-latest unreleased commit:
     npx github:sifxprime/kodelyth-ecc
-    npx github:sifxprime/kodelyth-ecc --target windsurf-project
-    npx github:sifxprime/kodelyth-ecc --target antigravity --profile nextjs
-    npx github:sifxprime/kodelyth-ecc --target claude-home typescript python
 
   Flags:
     --help, -h       Show this help

package/commands/memory.md

@@ -0,0 +1,62 @@
+---
+description: Manage local Kodelyth Memory — recall, capture, review, and curate what your AI knows about you
+---
+
+# /memory
+
+Local self-learning memory. Everything stays on this machine.
+
+## Subcommands
+
+### `/memory`
+Show storage stats and the 5 most recent memories for this project.
+
+### `/memory recall <query>`
+Search memory for `<query>` using BM25 keyword + tag retrieval. Surfaces the top 5 relevant matches.
+
+Example:
+```
+/memory recall stripe webhook signature
+```
+
+### `/memory remember "<title>"`
+Capture a new memory. The agent will:
+1. Ask for the approach (what worked) and any gotchas
+2. Auto-extract tags and language from the conversation
+3. Show you the proposed memory
+4. Store only after you confirm
+
+### `/memory review-pending`
+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`.
+
+### `/memory list`
+Show all stored memories — id, date, language, problem, tags.
+
+### `/memory rebuild`
+Rebuild the BM25 index from `memories.jsonl`. Run this if search results look stale or if you've manually edited the log.
+
+### `/memory inject [--query <text>]`
+Print the cache-friendly context block that the SessionStart hook would inject. Useful for debugging what your AI sees about you.
+
+## Implementation
+
+This command delegates to:
+```bash
+node ~/.claude/scripts/memory/cli.js <subcommand> [args]
+```
+
+Or invoke the agent directly:
+```
+use kodelyth-memory
+```
+
+## Storage location
+
+`~/.kodelyth/memory/` (override with `KODELYTH_MEMORY_DIR` env var)
+
+- `memories.jsonl` — the source of truth
+- `index.json` — BM25 inverted index
+- `pending-review.jsonl` — Stop-hook candidates awaiting confirmation

package/hooks/hooks.json

@@ -163,6 +163,19 @@
         ],
         "description": "Load previous context and detect package manager on new session",
         "id": "session:start"
+      },
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/memory/inject-start.js\"",
+            "async": true,
+            "timeout": 5
+          }
+        ],
+        "description": "Kodelyth Memory: inject relevant past memories as cache-friendly context",
+        "id": "kodelyth:session:start:memory-inject"
       }
     ],
     "PostToolUse": [
@@ -325,6 +338,19 @@
         "description": "Kodelyth: Suggest the next logical agent or command after each response based on what just happened",
         "id": "kodelyth:stop:smart-suggest"
       },
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/memory/capture-stop.js\"",
+            "async": true,
+            "timeout": 10
+          }
+        ],
+        "description": "Kodelyth Memory: extract memory candidates from session and queue for review (never auto-stores)",
+        "id": "kodelyth:stop:memory-capture"
+      },
       {
         "matcher": "*",
         "hooks": [

package/hooks/memory/capture-stop.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Memory Capture Hook (Stop)
+//
+// 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
+//
+// Candidates are NEVER auto-stored. The user reviews via:
+//   /memory review-pending
+// or:
+//   node scripts/memory/cli.js list-pending
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+let payload = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { payload += chunk; });
+process.stdin.on('end', main);
+setTimeout(() => { if (!process.stdin.readableEnded) main(); }, 100);
+
+function main() {
+  try {
+    const data = payload ? JSON.parse(payload) : {};
+    const sessionJsonl = data.session_path
+      || data.transcript_path
+      || findLatestClaudeSession(data.cwd || process.cwd());
+
+    if (!sessionJsonl || !fs.existsSync(sessionJsonl)) {
+      process.exit(0);
+    }
+
+    const { extractCandidates } = require(path.join(__dirname, '..', '..', 'scripts', 'memory', 'extract'));
+    const candidates = extractCandidates(sessionJsonl);
+    if (candidates.length === 0) {
+      process.exit(0);
+    }
+
+    const dir = process.env.KODELYTH_MEMORY_DIR
+      || path.join(os.homedir(), '.kodelyth', 'memory');
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const queueFile = path.join(dir, 'pending-review.jsonl');
+    const sessionId = data.session_id || path.basename(sessionJsonl, '.jsonl');
+
+    const lines = candidates.map(c => JSON.stringify({
+      ...c,
+      session_id: sessionId,
+      project_path: data.cwd || process.cwd(),
+      queued_at: new Date().toISOString(),
+    }));
+
+    fs.appendFileSync(queueFile, lines.join('\n') + '\n');
+
+    // Emit advisory message so user sees something happened
+    process.stdout.write(JSON.stringify({
+      message: `Kodelyth Memory: ${candidates.length} candidate(s) queued for review. Run "/memory review-pending" to confirm.`,
+    }));
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`kodelyth-memory capture: ${err.message}\n`);
+    process.exit(0);
+  }
+}
+
+function findLatestClaudeSession(cwd) {
+  try {
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(projectsDir)) return null;
+    // Project dirs are encoded paths
+    const encoded = '-' + cwd.replace(/\//g, '-');
+    const matches = fs.readdirSync(projectsDir).filter(d => d.endsWith(encoded.slice(-30)));
+    if (matches.length === 0) return null;
+    const projectDir = path.join(projectsDir, matches[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/inject-start.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Memory Inject Hook (SessionStart)
+//
+// Runs at the start of every Claude Code session. Reads the project root
+// from the hook payload (or cwd fallback), builds the memory context block,
+// and emits it as additional system context.
+//
+// Hook contract: prints JSON to stdout that Claude Code will merge into
+// the session's system context. Exits 0 even on error — never block a
+// session because memory is unavailable.
+// =============================================================================
+
+'use strict';
+
+const path = require('path');
+
+let payload = {};
+try {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { raw += chunk; });
+  process.stdin.on('end', () => {
+    try { payload = raw ? JSON.parse(raw) : {}; } catch { payload = {}; }
+    main();
+  });
+  // Fallback: if stdin closes immediately (no piped input), proceed
+  setTimeout(() => { if (!process.stdin.readableEnded) main(); }, 100);
+} catch {
+  main();
+}
+
+function main() {
+  try {
+    const projectRoot = payload.cwd || payload.project_root || process.cwd();
+    const { buildContextBlock } = require(path.join(__dirname, '..', '..', 'scripts', 'memory', 'inject'));
+
+    const block = buildContextBlock({ projectRoot });
+    if (!block || !block.text) {
+      process.exit(0);
+    }
+
+    // Emit as additional context — non-blocking, advisory
+    const output = {
+      additionalContext: block.text,
+      meta: {
+        source: 'kodelyth-memory',
+        memoryCount: block.memoryCount,
+        projectMemoryCount: block.projectMemoryCount,
+        patternCount: block.patternCount,
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  } catch (err) {
+    // Never crash a session because memory hook failed — log to stderr and continue
+    process.stderr.write(`kodelyth-memory inject: ${err.message}\n`);
+    process.exit(0);
+  }
+}

package/install.ps1

@@ -21,7 +21,7 @@ $ErrorActionPreference = "Stop"
 # ── Banner ────────────────────────────────────────────────────────────────────
 Write-Host ""
 Write-Host "  Kodelyth ECC — Production-grade AI coding agent toolkit" -ForegroundColor Cyan
-Write-Host "  58 agents · 187 skills · 79 commands · 18+ hooks · god-tier intent routing" -ForegroundColor Gray
+Write-Host "  59 agents · 188 skills · 80 commands · 18+ hooks · intent routing · local memory" -ForegroundColor Gray
 Write-Host ""
 
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
@@ -219,11 +219,30 @@ switch ($Target) {
         Write-Host "  2. Type: /kodelyth-quickstart"
         Write-Host "  3. Or:   use kodelyth-advisor"
     }
+    { $_ -in "windsurf-project","windsurf-home" } {
+        Write-Host "  1. Open the project in Windsurf"
+        Write-Host "  2. Cascade auto-loads .windsurfrules on every session"
+        Write-Host "  3. Try:  use kodelyth-advisor"
+    }
+    "cursor-project" {
+        Write-Host "  1. Open the project in Cursor"
+        Write-Host "  2. Rules and skills are now active in chat"
+        Write-Host "  3. Try:  use kodelyth-advisor"
+    }
+    "codex-home" {
+        Write-Host "  1. Restart Codex CLI (codex)"
+        Write-Host "  2. All 59 agents and 188 skills are now available"
+        Write-Host "  3. Try:  use kodelyth-advisor"
+    }
     "antigravity" {
         Write-Host "  1. Open your project in Antigravity"
         Write-Host "  2. Agents are available as Skills"
         Write-Host "  3. Commands are available as Workflows"
     }
+    "opencode" {
+        Write-Host "  1. Open the project in OpenCode"
+        Write-Host "  2. Rules in .opencode/rules/ are now loaded"
+    }
     default {
         Write-Host "  1. Restart your AI coding agent"
         Write-Host "  2. Agents, skills, and rules are now active"