kodelyth-ecc 1.3.0 → 1.4.1

package/hooks/memory/auto-recall.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Auto Chat Detection (Memory Auto-Recall)
+//
+// Triggered on UserPromptSubmit (every message the user sends).
+// Reads the prompt, searches memory in real-time, and injects relevant
+// matches as additional context BEFORE the AI sees the prompt.
+//
+// Behaviour:
+//   - Skips on prompts that are too short (< 12 chars) or trivial ("ok", "yes")
+//   - Skips on prompts that look like agent commands (`use foo`, `@bar`)
+//   - Skips when no memory exists yet
+//   - Suppresses repeats: never re-surfaces the same memory twice in a session
+//     (state file: ~/.kodelyth/memory/session-surfaced-<sessionId>.json)
+//   - Always exits 0 — never blocks the prompt because memory is unavailable
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+const MIN_PROMPT_CHARS    = 12;
+const MIN_TOKENS          = 2;
+const MAX_RECALLED        = 3;
+const MIN_SCORE           = 1.0;       // Higher than passive inject — we want strong signal
+const TRIVIAL_PROMPTS     = new Set(['ok', 'yes', 'no', 'thanks', 'thx', 'sure', 'go', 'cool', 'k']);
+const SKIP_PATTERN        = /^\s*(use\s+|@|\/|invoke\s+)/i;
+
+let payload = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { payload += chunk; });
+process.stdin.on('end', main);
+setTimeout(() => { if (!process.stdin.readableEnded) main(); }, 200);
+
+function main() {
+  try {
+    const data        = payload ? safeJson(payload) : {};
+    const userPrompt  = (data.prompt || data.user_prompt || data.text || '').trim();
+    const sessionId   = data.session_id || 'unknown';
+    const projectRoot = data.cwd || process.cwd();
+
+    if (!shouldRecall(userPrompt)) return done({});
+
+    // Lazy require so the hook doesn't crash if memory module breaks
+    const { recallForProject } = require(path.join(__dirname, '..', '..', 'scripts', 'memory', 'store'));
+
+    const matches = recallForProject(projectRoot, userPrompt, {
+      limit:    MAX_RECALLED * 2,   // grab extra so we can filter out repeats
+      minScore: MIN_SCORE,
+    });
+    if (matches.length === 0) return done({});
+
+    // Filter out memories already surfaced this session
+    const surfacedFile = surfacedStatePath(sessionId);
+    const surfaced     = loadSurfaced(surfacedFile);
+    const fresh        = matches.filter(m => !surfaced.has(m.id)).slice(0, MAX_RECALLED);
+    if (fresh.length === 0) return done({});
+
+    // Mark the freshly surfaced memories so they don't re-appear this session
+    for (const m of fresh) surfaced.add(m.id);
+    saveSurfaced(surfacedFile, surfaced);
+
+    const block = formatBlock(fresh, userPrompt);
+    done({
+      additionalContext: block,
+      meta: {
+        source:        'kodelyth-memory:auto-recall',
+        recalledCount: fresh.length,
+        surfacedTotal: surfaced.size,
+      },
+    });
+  } catch (err) {
+    process.stderr.write(`kodelyth-memory auto-recall: ${err.message}\n`);
+    done({});
+  }
+}
+
+function shouldRecall(prompt) {
+  if (!prompt || prompt.length < MIN_PROMPT_CHARS)        return false;
+  if (TRIVIAL_PROMPTS.has(prompt.toLowerCase().trim()))   return false;
+  if (SKIP_PATTERN.test(prompt))                          return false;
+  // Token gate — need at least N meaningful words
+  const meaningful = prompt
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(w => w.length >= 4);
+  return meaningful.length >= MIN_TOKENS;
+}
+
+function formatBlock(memories, userPrompt) {
+  const lines = [];
+  lines.push('## Kodelyth Memory — relevant past solutions');
+  lines.push('');
+  lines.push(`Auto-detected from your message: "${userPrompt.slice(0, 100).replace(/\n/g, ' ')}${userPrompt.length > 100 ? '...' : ''}"`);
+  lines.push('');
+  for (const m of memories) {
+    lines.push(`- **${m.problem}**`);
+    if (m.approach) lines.push(`  Approach: ${m.approach.split('\n')[0].slice(0, 240)}`);
+    if (m.gotchas?.length) lines.push(`  Gotcha: ${m.gotchas[0].slice(0, 200)}`);
+    if (m.tags?.length) lines.push(`  Tags: ${m.tags.slice(0, 5).join(', ')}`);
+    lines.push(`  (memory id: ${m.id} · captured ${m.captured_at?.slice(0, 10)})`);
+  }
+  lines.push('');
+  lines.push('> Surface these to the user before answering only if they are genuinely relevant to the current task. If not, ignore silently — do not force-fit a memory.');
+  return lines.join('\n');
+}
+
+function surfacedStatePath(sessionId) {
+  const dir = process.env.KODELYTH_MEMORY_DIR
+    || path.join(os.homedir(), '.kodelyth', 'memory');
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, `session-surfaced-${sessionId}.json`);
+}
+
+function loadSurfaced(file) {
+  try {
+    if (!fs.existsSync(file)) return new Set();
+    return new Set(JSON.parse(fs.readFileSync(file, 'utf8')));
+  } catch {
+    return new Set();
+  }
+}
+
+function saveSurfaced(file, set) {
+  try {
+    fs.writeFileSync(file, JSON.stringify(Array.from(set)));
+  } catch {
+    /* non-fatal */
+  }
+}
+
+function safeJson(s) {
+  try { return JSON.parse(s); } catch { return {}; }
+}
+
+function done(obj) {
+  if (Object.keys(obj).length > 0) process.stdout.write(JSON.stringify(obj));
+  process.exit(0);
+}

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"

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}  58 specialist agents  ·  187 skills  ·  79 commands  ·  18+ hooks  ·  god-tier intent routing${RESET}"
+echo -e "${CYAN}  59 specialist agents  ·  188 skills  ·  80 commands  ·  18+ hooks  ·  intent routing  ·  local 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.3.0",
-  "description": "Production-grade AI coding toolkit — 58 agents, 187 skills, 79 commands, god-tier intent routing. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
+  "version": "1.4.1",
+  "description": "Production-grade AI coding toolkit — 59 agents, 188 skills, 80 commands, god-tier intent routing, local self-learning memory with auto chat detection. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",
   "repository": {
@@ -19,6 +19,9 @@
     "ai-agents",
     "coding-toolkit",
     "llm",
+    "memory",
+    "self-learning",
+    "auto-recall",
     "kodelyth"
   ],
   "bin": {

package/rules/common/memory-protocol.md

@@ -0,0 +1,56 @@
+# Kodelyth Memory Protocol
+
+> Auto-loaded every session. Tells the AI when to consult and contribute to local memory.
+
+## 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.
+
+If the SessionStart hook ran, you have already received a memory block in your initial context with:
+- The user's recurring patterns (tags seen across multiple sessions)
+- Recent solutions in this project
+- Their detected stack
+
+## When to recall memory mid-session
+
+Trigger a memory recall (run the `kodelyth-memory` agent or `node scripts/memory/cli.js search "<query>"`) when **any** of these is true:
+
+1. The user describes a task in a domain that matches a tag in their memory (`payments`, `auth`, `database`, `deployment`, etc.)
+2. The user asks "have I done this before?" or "how did I solve X last time?"
+3. The user mentions a library, framework, or service by name that appears in past memories
+4. You're about to commit to an architectural decision and want to check past precedent
+
+## How to surface a recalled memory
+
+Naturally, never robotically. Pattern:
+
+> I checked your memory — you solved a similar problem in `<project>` on `<date>`. The approach that worked was `<approach>`. Want me to apply the same here, or is this case different?
+
+Always end by giving the user the option to override. Memory is a hint, not a command.
+
+## When to capture a new memory
+
+Capture when **all** are true:
+- The user signals success (`"that worked"`, `"perfect"`, `"fixed it"`, `"thanks"`, `"done"`)
+- The work involved real iteration (not a one-shot trivial fix)
+- The lesson is reusable (would help in another similar problem, not just this exact file)
+
+Show the user the draft memory before storing. Never silently capture.
+
+## What you must not do
+
+- **Never** auto-recall the same memory twice in one session (the user has seen it)
+- **Never** capture without explicit confirmation (`yes`, `store it`, `remember`)
+- **Never** treat a recalled memory as ground truth — it could be stale
+- **Never** transmit memory data anywhere — it is local-only by design
+- **Never** fabricate a memory ("you usually...") if no relevant memory exists — say nothing
+
+## Cache-aware behaviour
+
+The injected memory block is structured so its prefix is identical across calls in the same project. Do not rewrite or reorder this block during a session — that defeats the prompt cache and burns tokens. If you need to add session-specific notes, append them after the block.
+
+## Honest disclosure
+
+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."

package/scripts/memory/cli.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Memory CLI
+//
+// Usage:
+//   node scripts/memory/cli.js list
+//   node scripts/memory/cli.js search "<query>"
+//   node scripts/memory/cli.js remember "<title>" --approach "<text>" --tags tag1,tag2
+//   node scripts/memory/cli.js forget <id>
+//   node scripts/memory/cli.js stats
+//   node scripts/memory/cli.js inject [--query "<text>"]
+//   node scripts/memory/cli.js extract <session.jsonl>
+//   node scripts/memory/cli.js rebuild-index
+// =============================================================================
+
+'use strict';
+
+const path = require('path');
+const store   = require('./store');
+const { buildContextBlock } = require('./inject');
+const { extractCandidates } = require('./extract');
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const cmd  = args[0];
+  const positional = [];
+  const flags = {};
+  for (let i = 1; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      const next = args[i + 1];
+      if (!next || next.startsWith('--')) {
+        flags[key] = true;
+      } else {
+        flags[key] = next;
+        i += 1;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { cmd, positional, flags };
+}
+
+function help() {
+  console.log(`
+Kodelyth ECC — Memory CLI
+
+Commands:
+  list                              Show all stored memories
+  search "<query>"                  BM25 search across memories
+  remember "<title>"                Add a memory (use --approach, --tags, --language)
+  forget <id>                       Mark a memory deleted
+  stats                             Show memory store stats
+  inject [--query "<text>"]         Print the cache-friendly context block
+  extract <session.jsonl>           Extract memory candidates from a session log
+  rebuild-index                     Rebuild the BM25 index from memories.jsonl
+
+Storage: ${store.PATHS.dir}
+`);
+}
+
+function fmt(memory, full = false) {
+  const date = (memory.captured_at || '').slice(0, 10);
+  const tags = (memory.tags || []).join(',');
+  if (!full) {
+    return `${memory.id}  ${date}  [${memory.language || '-'}]  ${memory.problem.slice(0, 70)}  (${tags})`;
+  }
+  return [
+    `id:        ${memory.id}`,
+    `captured:  ${memory.captured_at}`,
+    `language:  ${memory.language || '-'}`,
+    `tags:      ${tags || '-'}`,
+    `project:   ${memory.project_path || '-'}`,
+    `problem:   ${memory.problem}`,
+    `approach:`,
+    ...(memory.approach || '').split('\n').map(l => `  ${l}`),
+    memory.gotchas?.length ? `gotchas:` : '',
+    ...(memory.gotchas || []).map(g => `  - ${g}`),
+  ].filter(Boolean).join('\n');
+}
+
+function main() {
+  const { cmd, positional, flags } = parseArgs(process.argv);
+
+  if (!cmd || cmd === 'help' || cmd === '-h' || cmd === '--help') {
+    help();
+    return;
+  }
+
+  switch (cmd) {
+    case 'list': {
+      const all = store.listAll();
+      if (all.length === 0) {
+        console.log('No memories yet. Add one with: memory remember "<title>" --approach "<text>"');
+        return;
+      }
+      for (const m of all) console.log(fmt(m));
+      console.log(`\n${all.length} total`);
+      return;
+    }
+
+    case 'search': {
+      const query = positional[0];
+      if (!query) { console.error('Usage: search "<query>"'); process.exit(1); }
+      const results = store.recall(query, { limit: Number(flags.limit) || 5 });
+      if (results.length === 0) { console.log('No matches.'); return; }
+      for (const m of results) {
+        console.log(`[score ${m.score.toFixed(2)}] ${fmt(m)}`);
+      }
+      return;
+    }
+
+    case 'remember': {
+      const title    = positional[0];
+      const approach = flags.approach;
+      if (!title || !approach) {
+        console.error('Usage: remember "<title>" --approach "<what worked>" [--tags a,b] [--language ts]');
+        process.exit(1);
+      }
+      const memory = store.capture({
+        problem:  title,
+        approach,
+        tags:     (flags.tags || '').split(',').filter(Boolean),
+        project:  flags.project || process.cwd(),
+        language: flags.language || null,
+        files:    (flags.files || '').split(',').filter(Boolean),
+        gotchas:  (flags.gotchas || '').split(';').filter(Boolean),
+        source:   'cli',
+      });
+      console.log(`Captured: ${memory.id}`);
+      return;
+    }
+
+    case 'forget': {
+      const id = positional[0];
+      if (!id) { console.error('Usage: forget <id>'); process.exit(1); }
+      const ok = store.forget(id);
+      console.log(ok ? `Forgotten: ${id}` : `Not found: ${id}`);
+      return;
+    }
+
+    case 'stats': {
+      const s = store.stats();
+      console.log(`Total memories:  ${s.total}`);
+      console.log(`Storage:         ${s.storageDir}`);
+      console.log(`Projects:        ${s.projects}`);
+      console.log(`By language:`);
+      for (const [lang, count] of Object.entries(s.byLanguage)) {
+        console.log(`  ${lang.padEnd(12)} ${count}`);
+      }
+      console.log(`Top tags:`);
+      for (const [tag, count] of s.topTags) {
+        console.log(`  ${tag.padEnd(20)} ${count}`);
+      }
+      return;
+    }
+
+    case 'inject': {
+      const block = buildContextBlock({
+        projectRoot: flags.project || process.cwd(),
+        query:       flags.query || null,
+      });
+      if (!block) { console.log(''); return; }
+      console.log(block.text);
+      return;
+    }
+
+    case 'extract': {
+      const sessionPath = positional[0];
+      if (!sessionPath) { console.error('Usage: extract <session.jsonl>'); process.exit(1); }
+      const candidates = extractCandidates(path.resolve(sessionPath));
+      if (candidates.length === 0) { console.log('No memory candidates found.'); return; }
+      console.log(`Found ${candidates.length} candidate memories:\n`);
+      candidates.forEach((c, i) => {
+        console.log(`[${i + 1}] (score ${c.score})  ${c.problem}`);
+        console.log(`    tags:     ${c.tags.join(', ') || '-'}`);
+        console.log(`    language: ${c.language || '-'}`);
+        console.log(`    approach: ${c.approach.slice(0, 200)}...`);
+        console.log('');
+      });
+      console.log('Review and confirm with: memory remember "<problem>" --approach "<approach>"');
+      return;
+    }
+
+    case 'rebuild-index': {
+      const r = store.rebuildIndex();
+      console.log(`Rebuilt index for ${r.count} memories.`);
+      return;
+    }
+
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      help();
+      process.exit(1);
+  }
+}
+
+main();