kodelyth-ecc 1.3.0 → 1.4.1

package/.github/workflows/ci.yml

@@ -34,13 +34,12 @@ jobs:
       - name: Run test suite
         run: node tests/run-all.js
 
-      - name: Verify dashboard server syntax
-        run: node --check dashboard/server.js
-
-      - name: Verify all readers syntax
+      - name: Verify memory module syntax
         run: |
-          node --input-type=module < dashboard/lib/aggregator.js || true
-          for f in dashboard/lib/readers/*.js; do
-            node --check "$f" && echo "OK: $f"
-          done
+          node --check scripts/memory/store.js
+          node --check scripts/memory/inject.js
+          node --check scripts/memory/extract.js
+          node --check scripts/memory/cli.js
+          node --check hooks/memory/inject-start.js
+          node --check hooks/memory/capture-stop.js
         shell: bash

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,73 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v1.4.1 — Auto Chat Detection for Memory (May 2026)
+
+### Added
+- **`UserPromptSubmit` hook: `hooks/memory/auto-recall.js`** — watches every prompt in real-time, runs BM25 search against your memory, and injects relevant matches into the AI's context **before it responds**
+- **Per-session repeat suppression** — never surfaces the same memory twice in one session (state at `~/.kodelyth/memory/session-surfaced-<id>.json`)
+- **Smart skip filters** — skips trivial prompts (`ok`, `yes`, `thanks`), agent invocations (`use foo`, `@bar`, `/help`), and prompts under 12 chars
+- **9 new tests** for the auto-recall hook (47 total passing — 26 existing + 12 memory + 9 auto-recall)
+
+### How it changes the experience
+Before v1.4.1: memory only injected once at session start, then the AI had to consciously decide to query it.
+
+After v1.4.1: every meaningful prompt the user types triggers an instant memory check. Relevant past solutions appear in the AI's context for that turn, automatically. No agent invocation needed. No `/memory recall` needed.
+
+### Example
+```
+You:  "I need to add Stripe webhooks for subscription renewals"
+       └─ Auto-recall fires → finds your March 2026 memory →
+          injects: "raw body parser, validate with constructEvent,
+                   test with stripe-cli not curl"
+AI:   "I checked your memory — you solved this exact problem in March.
+       The approach that worked was raw body parser before
+       signature validation. Want me to apply the same pattern?"
+```
+
+You never typed `/memory recall`. The AI just knew.
+
+### Honest limits
+- The hook fires on Claude Code's `UserPromptSubmit` event. Other platforms (Cursor, Codex, Windsurf, Antigravity) don't currently expose an equivalent pre-prompt hook — auto-recall there is limited to SessionStart injection.
+- Repeat suppression is per-session-id. If your platform doesn't pass a stable session_id, the same memory may surface twice across sessions (still better than none).
+
+---
+
+## 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,19 @@
 ![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.1-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)
+![Auto Recall](https://img.shields.io/badge/Auto%20Chat%20Recall-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 +153,84 @@ 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. |
+| **Session-start injection** | A SessionStart hook builds a cache-friendly context block: stable prefix (your patterns + recent project memories) → variable suffix (relevant to current task). |
+| **Auto chat detection** *(v1.4.1)* | A `UserPromptSubmit` hook watches every message you type, runs BM25 search on it, and injects relevant memories **before the AI responds**. Per-session repeat suppression. Skips trivial / agent-command prompts. |
+| **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 +343,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 +455,21 @@ 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.1 highlights:
+
+- **Added:** Auto chat detection — `UserPromptSubmit` hook watches every prompt, auto-injects relevant memories
+- **Added:** Per-session repeat suppression (no memory shown twice in same session)
+- **Added:** 9 new tests (47 total passing)
+
+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.1

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

@@ -139,6 +139,21 @@
         "id": "pre:mcp-health-check"
       }
     ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/memory/auto-recall.js\"",
+            "async": false,
+            "timeout": 3
+          }
+        ],
+        "description": "Kodelyth Memory: auto-detect topic from each user prompt and inject relevant past memories before the AI responds (suppresses repeats per session)",
+        "id": "kodelyth:user-prompt:memory-auto-recall"
+      }
+    ],
     "PreCompact": [
       {
         "matcher": "*",
@@ -163,6 +178,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 +353,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": [