learning-agent 0.2.2 → 0.2.3

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { createHash } from 'crypto';
-import { statSync, existsSync, chmodSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import Database from 'better-sqlite3';
 import * as fs from 'fs/promises';
-import { readFile, mkdir, appendFile, writeFile, rename } from 'fs/promises';
+import { mkdir, appendFile, readFile, writeFile, rename } from 'fs/promises';
+import { join, dirname } from 'path';
+import { createHash } from 'crypto';
 import { z } from 'zod';
+import { createRequire } from 'module';
+import { existsSync, statSync, mkdirSync, chmodSync } from 'fs';
 import chalk from 'chalk';
 import { resolveModelFile, getLlama } from 'node-llama-cpp';
 import { homedir } from 'os';
@@ -180,11 +180,45 @@ async function readLessons(repoRoot, options = {}) {
   }
   return { lessons: Array.from(lessons.values()), skippedCount };
 }
+var require2 = createRequire(import.meta.url);
+var sqliteAvailable = null;
+var sqliteWarningLogged = false;
+var DatabaseConstructor = null;
+function isSqliteAvailable() {
+  if (sqliteAvailable !== null) {
+    return sqliteAvailable;
+  }
+  try {
+    const module = require2("better-sqlite3");
+    const Constructor = module.default || module;
+    const testDb = new Constructor(":memory:");
+    testDb.close();
+    DatabaseConstructor = Constructor;
+    sqliteAvailable = true;
+  } catch {
+    sqliteAvailable = false;
+    if (!sqliteWarningLogged) {
+      console.warn("SQLite unavailable, running in JSONL-only mode");
+      sqliteWarningLogged = true;
+    }
+  }
+  return sqliteAvailable;
+}
+function logDegradationWarning() {
+  if (!sqliteAvailable && !sqliteWarningLogged) {
+    console.warn("SQLite unavailable, running in JSONL-only mode");
+    sqliteWarningLogged = true;
+  }
+}
+function getDatabaseConstructor() {
+  if (!isSqliteAvailable()) {
+    return null;
+  }
+  return DatabaseConstructor;
+}
 
-// src/storage/sqlite.ts
-var DB_PATH = ".claude/.cache/lessons.sqlite";
+// src/storage/sqlite/schema.ts
 var SCHEMA_SQL = `
-  -- Main lessons table
   CREATE TABLE IF NOT EXISTS lessons (
     id TEXT PRIMARY KEY,
     type TEXT NOT NULL,
@@ -204,7 +238,6 @@ var SCHEMA_SQL = `
     last_retrieved TEXT,
     embedding BLOB,
     content_hash TEXT,
-    -- v0.2.2 fields
     invalidated_at TEXT,
     invalidation_reason TEXT,
     citation_file TEXT,
@@ -214,29 +247,21 @@ var SCHEMA_SQL = `
     compacted_at TEXT
   );
 
-  -- FTS5 virtual table for full-text search
   CREATE VIRTUAL TABLE IF NOT EXISTS lessons_fts USING fts5(
-    id,
-    trigger,
-    insight,
-    tags,
-    content='lessons',
-    content_rowid='rowid'
+    id, trigger, insight, tags,
+    content='lessons', content_rowid='rowid'
   );
 
-  -- Trigger to sync FTS on INSERT
   CREATE TRIGGER IF NOT EXISTS lessons_ai AFTER INSERT ON lessons BEGIN
     INSERT INTO lessons_fts(rowid, id, trigger, insight, tags)
     VALUES (new.rowid, new.id, new.trigger, new.insight, new.tags);
   END;
 
-  -- Trigger to sync FTS on DELETE
   CREATE TRIGGER IF NOT EXISTS lessons_ad AFTER DELETE ON lessons BEGIN
     INSERT INTO lessons_fts(lessons_fts, rowid, id, trigger, insight, tags)
     VALUES ('delete', old.rowid, old.id, old.trigger, old.insight, old.tags);
   END;
 
-  -- Trigger to sync FTS on UPDATE
   CREATE TRIGGER IF NOT EXISTS lessons_au AFTER UPDATE ON lessons BEGIN
     INSERT INTO lessons_fts(lessons_fts, rowid, id, trigger, insight, tags)
     VALUES ('delete', old.rowid, old.id, old.trigger, old.insight, old.tags);
@@ -244,12 +269,10 @@ var SCHEMA_SQL = `
     VALUES (new.rowid, new.id, new.trigger, new.insight, new.tags);
   END;
 
-  -- Index for common queries
   CREATE INDEX IF NOT EXISTS idx_lessons_created ON lessons(created);
   CREATE INDEX IF NOT EXISTS idx_lessons_confirmed ON lessons(confirmed);
   CREATE INDEX IF NOT EXISTS idx_lessons_severity ON lessons(severity);
 
-  -- Metadata table for sync tracking
   CREATE TABLE IF NOT EXISTS metadata (
     key TEXT PRIMARY KEY,
     value TEXT NOT NULL
@@ -258,22 +281,54 @@ var SCHEMA_SQL = `
 function createSchema(database) {
   database.exec(SCHEMA_SQL);
 }
+
+// src/storage/sqlite/connection.ts
+var DB_PATH = ".claude/.cache/lessons.sqlite";
 var db = null;
-function contentHash(trigger, insight) {
-  return createHash("sha256").update(`${trigger} ${insight}`).digest("hex");
-}
-function openDb(repoRoot) {
-  if (db) return db;
-  const dbPath = join(repoRoot, DB_PATH);
-  const dir = dirname(dbPath);
-  mkdirSync(dir, { recursive: true });
-  db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
+var dbIsInMemory = false;
+function openDb(repoRoot, options = {}) {
+  if (!isSqliteAvailable()) {
+    return null;
+  }
+  const { inMemory = false } = options;
+  if (db) {
+    if (inMemory !== dbIsInMemory) {
+      closeDb();
+    } else {
+      return db;
+    }
+  }
+  const Database = getDatabaseConstructor();
+  if (inMemory) {
+    db = new Database(":memory:");
+    dbIsInMemory = true;
+  } else {
+    const dbPath = join(repoRoot, DB_PATH);
+    const dir = dirname(dbPath);
+    mkdirSync(dir, { recursive: true });
+    db = new Database(dbPath);
+    dbIsInMemory = false;
+    db.pragma("journal_mode = WAL");
+  }
   createSchema(db);
   return db;
 }
+function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+    dbIsInMemory = false;
+  }
+}
+function contentHash(trigger, insight) {
+  return createHash("sha256").update(`${trigger} ${insight}`).digest("hex");
+}
 function getCachedEmbedding(repoRoot, lessonId, expectedHash) {
   const database = openDb(repoRoot);
+  if (!database) {
+    logDegradationWarning();
+    return null;
+  }
   const row = database.prepare("SELECT embedding, content_hash FROM lessons WHERE id = ?").get(lessonId);
   if (!row || !row.embedding || !row.content_hash) {
     return null;
@@ -290,60 +345,14 @@ function getCachedEmbedding(repoRoot, lessonId, expectedHash) {
 }
 function setCachedEmbedding(repoRoot, lessonId, embedding, hash) {
   const database = openDb(repoRoot);
+  if (!database) {
+    logDegradationWarning();
+    return;
+  }
   const float32 = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
   const buffer = Buffer.from(float32.buffer, float32.byteOffset, float32.byteLength);
   database.prepare("UPDATE lessons SET embedding = ?, content_hash = ? WHERE id = ?").run(buffer, hash, lessonId);
 }
-function rowToLesson(row) {
-  const lesson = {
-    id: row.id,
-    type: row.type,
-    trigger: row.trigger,
-    insight: row.insight,
-    tags: row.tags ? row.tags.split(",").filter(Boolean) : [],
-    source: row.source,
-    context: JSON.parse(row.context),
-    supersedes: JSON.parse(row.supersedes),
-    related: JSON.parse(row.related),
-    created: row.created,
-    confirmed: row.confirmed === 1
-  };
-  if (row.evidence !== null) {
-    lesson.evidence = row.evidence;
-  }
-  if (row.severity !== null) {
-    lesson.severity = row.severity;
-  }
-  if (row.deleted === 1) {
-    lesson.deleted = true;
-  }
-  if (row.retrieval_count > 0) {
-    lesson.retrievalCount = row.retrieval_count;
-  }
-  if (row.invalidated_at !== null) {
-    lesson.invalidatedAt = row.invalidated_at;
-  }
-  if (row.invalidation_reason !== null) {
-    lesson.invalidationReason = row.invalidation_reason;
-  }
-  if (row.citation_file !== null) {
-    lesson.citation = {
-      file: row.citation_file,
-      ...row.citation_line !== null && { line: row.citation_line },
-      ...row.citation_commit !== null && { commit: row.citation_commit }
-    };
-  }
-  if (row.compaction_level !== null && row.compaction_level !== 0) {
-    lesson.compactionLevel = row.compaction_level;
-  }
-  if (row.compacted_at !== null) {
-    lesson.compactedAt = row.compacted_at;
-  }
-  if (row.last_retrieved !== null) {
-    lesson.lastRetrieved = row.last_retrieved;
-  }
-  return lesson;
-}
 function collectCachedEmbeddings(database) {
   const cache = /* @__PURE__ */ new Map();
   const rows = database.prepare("SELECT id, embedding, content_hash FROM lessons WHERE embedding IS NOT NULL").all();
@@ -376,6 +385,10 @@ function setLastSyncMtime(database, mtime) {
 }
 async function rebuildIndex(repoRoot) {
   const database = openDb(repoRoot);
+  if (!database) {
+    logDegradationWarning();
+    return;
+  }
   const { lessons } = await readLessons(repoRoot);
   const cachedEmbeddings = collectCachedEmbeddings(database);
   database.exec("DELETE FROM lessons");
@@ -411,7 +424,6 @@ async function rebuildIndex(repoRoot) {
         last_retrieved: lesson.lastRetrieved ?? null,
         embedding: hasValidCache ? cached.embedding : null,
         content_hash: hasValidCache ? cached.contentHash : null,
-        // v0.2.2 fields
         invalidated_at: lesson.invalidatedAt ?? null,
         invalidation_reason: lesson.invalidationReason ?? null,
         citation_file: lesson.citation?.file ?? null,
@@ -429,12 +441,17 @@ async function rebuildIndex(repoRoot) {
   }
 }
 async function syncIfNeeded(repoRoot, options = {}) {
+  if (!isSqliteAvailable()) {
+    logDegradationWarning();
+    return false;
+  }
   const { force = false } = options;
   const jsonlMtime = getJsonlMtime(repoRoot);
   if (jsonlMtime === null && !force) {
     return false;
   }
   const database = openDb(repoRoot);
+  if (!database) return false;
   const lastSyncMtime = getLastSyncMtime(database);
   const needsRebuild = force || lastSyncMtime === null || jsonlMtime !== null && jsonlMtime > lastSyncMtime;
   if (needsRebuild) {
@@ -443,28 +460,49 @@ async function syncIfNeeded(repoRoot, options = {}) {
   }
   return false;
 }
-async function searchKeyword(repoRoot, query, limit) {
-  const database = openDb(repoRoot);
-  const countResult = database.prepare("SELECT COUNT(*) as cnt FROM lessons").get();
-  if (countResult.cnt === 0) return [];
-  const rows = database.prepare(
-    `
-      SELECT l.*
-      FROM lessons l
-      JOIN lessons_fts fts ON l.rowid = fts.rowid
-      WHERE lessons_fts MATCH ?
-        AND l.invalidated_at IS NULL
-      LIMIT ?
-    `
-  ).all(query, limit);
-  if (rows.length > 0) {
-    incrementRetrievalCount(repoRoot, rows.map((r) => r.id));
+
+// src/storage/sqlite/search.ts
+function rowToLesson(row) {
+  const lesson = {
+    id: row.id,
+    type: row.type,
+    trigger: row.trigger,
+    insight: row.insight,
+    tags: row.tags ? row.tags.split(",").filter(Boolean) : [],
+    source: row.source,
+    context: JSON.parse(row.context),
+    supersedes: JSON.parse(row.supersedes),
+    related: JSON.parse(row.related),
+    created: row.created,
+    confirmed: row.confirmed === 1
+  };
+  if (row.evidence !== null) lesson.evidence = row.evidence;
+  if (row.severity !== null) lesson.severity = row.severity;
+  if (row.deleted === 1) lesson.deleted = true;
+  if (row.retrieval_count > 0) lesson.retrievalCount = row.retrieval_count;
+  if (row.invalidated_at !== null) lesson.invalidatedAt = row.invalidated_at;
+  if (row.invalidation_reason !== null) lesson.invalidationReason = row.invalidation_reason;
+  if (row.citation_file !== null) {
+    lesson.citation = {
+      file: row.citation_file,
+      ...row.citation_line !== null && { line: row.citation_line },
+      ...row.citation_commit !== null && { commit: row.citation_commit }
+    };
   }
-  return rows.map(rowToLesson);
+  if (row.compaction_level !== null && row.compaction_level !== 0) {
+    lesson.compactionLevel = row.compaction_level;
+  }
+  if (row.compacted_at !== null) lesson.compactedAt = row.compacted_at;
+  if (row.last_retrieved !== null) lesson.lastRetrieved = row.last_retrieved;
+  return lesson;
 }
 function incrementRetrievalCount(repoRoot, lessonIds) {
   if (lessonIds.length === 0) return;
   const database = openDb(repoRoot);
+  if (!database) {
+    logDegradationWarning();
+    return;
+  }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const update = database.prepare(`
     UPDATE lessons
@@ -479,8 +517,36 @@ function incrementRetrievalCount(repoRoot, lessonIds) {
   });
   updateMany(lessonIds);
 }
+async function searchKeyword(repoRoot, query, limit) {
+  const database = openDb(repoRoot);
+  if (!database) {
+    throw new Error(
+      "Keyword search requires SQLite (FTS5 required). Install native build tools or use vector search instead."
+    );
+  }
+  const countResult = database.prepare("SELECT COUNT(*) as cnt FROM lessons").get();
+  if (countResult.cnt === 0) return [];
+  const rows = database.prepare(
+    `
+      SELECT l.*
+      FROM lessons l
+      JOIN lessons_fts fts ON l.rowid = fts.rowid
+      WHERE lessons_fts MATCH ?
+        AND l.invalidated_at IS NULL
+      LIMIT ?
+    `
+  ).all(query, limit);
+  if (rows.length > 0) {
+    incrementRetrievalCount(repoRoot, rows.map((r) => r.id));
+  }
+  return rows.map(rowToLesson);
+}
 function getRetrievalStats(repoRoot) {
   const database = openDb(repoRoot);
+  if (!database) {
+    logDegradationWarning();
+    return [];
+  }
   const rows = database.prepare("SELECT id, retrieval_count, last_retrieved FROM lessons").all();
   return rows.map((row) => ({
     id: row.id,
@@ -489,83 +555,202 @@ function getRetrievalStats(repoRoot) {
   }));
 }
 
-// src/capture/quality.ts
-var DEFAULT_SIMILARITY_THRESHOLD = 0.8;
-async function isNovel(repoRoot, insight, options = {}) {
-  const threshold = options.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
-  await syncIfNeeded(repoRoot);
-  const words = insight.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3).slice(0, 3);
-  if (words.length === 0) {
-    return { novel: true };
-  }
-  const searchQuery = words.join(" OR ");
-  const results = await searchKeyword(repoRoot, searchQuery, 10);
-  if (results.length === 0) {
-    return { novel: true };
+// src/utils.ts
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function getLessonAgeDays(lesson) {
+  const created = new Date(lesson.created).getTime();
+  const now = Date.now();
+  return Math.floor((now - created) / MS_PER_DAY);
+}
+
+// src/storage/compact.ts
+var ARCHIVE_DIR = ".claude/lessons/archive";
+var TOMBSTONE_THRESHOLD = 100;
+var ARCHIVE_AGE_DAYS = 90;
+var MONTH_INDEX_OFFSET = 1;
+var MONTH_PAD_LENGTH = 2;
+function getArchivePath(repoRoot, date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + MONTH_INDEX_OFFSET).padStart(MONTH_PAD_LENGTH, "0");
+  return join(repoRoot, ARCHIVE_DIR, `${year}-${month}.jsonl`);
+}
+async function parseRawJsonlLines(repoRoot) {
+  const filePath = join(repoRoot, LESSONS_PATH);
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch {
+    return [];
   }
-  const insightWords = new Set(insight.toLowerCase().split(/\s+/));
-  for (const lesson of results) {
-    const lessonWords = new Set(lesson.insight.toLowerCase().split(/\s+/));
-    const intersection = [...insightWords].filter((w) => lessonWords.has(w)).length;
-    const union = (/* @__PURE__ */ new Set([...insightWords, ...lessonWords])).size;
-    const similarity = union > 0 ? intersection / union : 0;
-    if (similarity >= threshold) {
-      return {
-        novel: false,
-        reason: `Found similar existing lesson: "${lesson.insight.slice(0, 50)}..."`,
-        existingId: lesson.id
-      };
-    }
-    if (lesson.insight.toLowerCase() === insight.toLowerCase()) {
-      return {
-        novel: false,
-        reason: `Exact duplicate found`,
-        existingId: lesson.id
-      };
+  const results = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      results.push({ line: trimmed, parsed });
+    } catch {
+      results.push({ line: trimmed, parsed: null });
     }
   }
-  return { novel: true };
+  return results;
 }
-var MIN_WORD_COUNT = 4;
-var VAGUE_PATTERNS = [
-  /\bwrite better\b/i,
-  /\bbe careful\b/i,
-  /\bremember to\b/i,
-  /\bmake sure\b/i,
-  /\btry to\b/i,
-  /\bdouble check\b/i
-];
-var GENERIC_IMPERATIVE_PATTERN = /^(always|never)\s+\w+(\s+\w+){0,2}$/i;
-function isSpecific(insight) {
-  const words = insight.trim().split(/\s+/).filter((w) => w.length > 0);
-  if (words.length < MIN_WORD_COUNT) {
-    return { specific: false, reason: "Insight is too short to be actionable" };
-  }
-  for (const pattern of VAGUE_PATTERNS) {
-    if (pattern.test(insight)) {
-      return { specific: false, reason: "Insight matches a vague pattern" };
+async function countTombstones(repoRoot) {
+  const lines = await parseRawJsonlLines(repoRoot);
+  let count = 0;
+  for (const { parsed } of lines) {
+    if (parsed && parsed["deleted"] === true) {
+      count++;
     }
   }
-  if (GENERIC_IMPERATIVE_PATTERN.test(insight)) {
-    return { specific: false, reason: "Insight matches a vague pattern" };
-  }
-  return { specific: true };
+  return count;
 }
-var ACTION_PATTERNS = [
-  /\buse\s+.+\s+instead\s+of\b/i,
-  // "use X instead of Y"
-  /\bprefer\s+.+\s+(over|to)\b/i,
-  // "prefer X over Y" or "prefer X to Y"
-  /\balways\s+.+\s+when\b/i,
-  // "always X when Y"
-  /\bnever\s+.+\s+without\b/i,
-  // "never X without Y"
-  /\bavoid\s+(using\s+)?\w+/i,
-  // "avoid X" or "avoid using X"
-  /\bcheck\s+.+\s+before\b/i,
-  // "check X before Y"
-  /^(run|use|add|remove|install|update|configure|set|enable|disable)\s+/i
-  // Imperative commands at start
+async function needsCompaction(repoRoot) {
+  const count = await countTombstones(repoRoot);
+  return count >= TOMBSTONE_THRESHOLD;
+}
+async function rewriteWithoutTombstones(repoRoot) {
+  const filePath = join(repoRoot, LESSONS_PATH);
+  const tempPath = filePath + ".tmp";
+  const { lessons } = await readLessons(repoRoot);
+  const tombstoneCount = await countTombstones(repoRoot);
+  await mkdir(dirname(filePath), { recursive: true });
+  const lines = lessons.map((lesson) => JSON.stringify(lesson) + "\n");
+  await writeFile(tempPath, lines.join(""), "utf-8");
+  await rename(tempPath, filePath);
+  return tombstoneCount;
+}
+function shouldArchive(lesson) {
+  const ageDays = getLessonAgeDays(lesson);
+  return ageDays > ARCHIVE_AGE_DAYS && (lesson.retrievalCount === void 0 || lesson.retrievalCount === 0);
+}
+async function archiveOldLessons(repoRoot) {
+  const { lessons } = await readLessons(repoRoot);
+  const toArchive = [];
+  const toKeep = [];
+  for (const lesson of lessons) {
+    if (shouldArchive(lesson)) {
+      toArchive.push(lesson);
+    } else {
+      toKeep.push(lesson);
+    }
+  }
+  if (toArchive.length === 0) {
+    return 0;
+  }
+  const archiveGroups = /* @__PURE__ */ new Map();
+  for (const lesson of toArchive) {
+    const created = new Date(lesson.created);
+    const archivePath = getArchivePath(repoRoot, created);
+    const group = archiveGroups.get(archivePath) ?? [];
+    group.push(lesson);
+    archiveGroups.set(archivePath, group);
+  }
+  const archiveDir = join(repoRoot, ARCHIVE_DIR);
+  await mkdir(archiveDir, { recursive: true });
+  for (const [archivePath, archiveLessons] of archiveGroups) {
+    const lines2 = archiveLessons.map((l) => JSON.stringify(l) + "\n").join("");
+    await appendFile(archivePath, lines2, "utf-8");
+  }
+  const filePath = join(repoRoot, LESSONS_PATH);
+  const tempPath = filePath + ".tmp";
+  await mkdir(dirname(filePath), { recursive: true });
+  const lines = toKeep.map((lesson) => JSON.stringify(lesson) + "\n");
+  await writeFile(tempPath, lines.join(""), "utf-8");
+  await rename(tempPath, filePath);
+  return toArchive.length;
+}
+async function compact(repoRoot) {
+  const tombstonesBefore = await countTombstones(repoRoot);
+  const archived = await archiveOldLessons(repoRoot);
+  const tombstonesAfterArchive = await countTombstones(repoRoot);
+  await rewriteWithoutTombstones(repoRoot);
+  const tombstonesRemoved = archived > 0 ? tombstonesBefore : tombstonesAfterArchive;
+  const { lessons } = await readLessons(repoRoot);
+  return {
+    archived,
+    tombstonesRemoved,
+    lessonsRemaining: lessons.length
+  };
+}
+
+// src/capture/quality.ts
+var DEFAULT_SIMILARITY_THRESHOLD = 0.8;
+async function isNovel(repoRoot, insight, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+  await syncIfNeeded(repoRoot);
+  const words = insight.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3).slice(0, 3);
+  if (words.length === 0) {
+    return { novel: true };
+  }
+  const searchQuery = words.join(" OR ");
+  const results = await searchKeyword(repoRoot, searchQuery, 10);
+  if (results.length === 0) {
+    return { novel: true };
+  }
+  const insightWords = new Set(insight.toLowerCase().split(/\s+/));
+  for (const lesson of results) {
+    const lessonWords = new Set(lesson.insight.toLowerCase().split(/\s+/));
+    const intersection = [...insightWords].filter((w) => lessonWords.has(w)).length;
+    const union = (/* @__PURE__ */ new Set([...insightWords, ...lessonWords])).size;
+    const similarity = union > 0 ? intersection / union : 0;
+    if (similarity >= threshold) {
+      return {
+        novel: false,
+        reason: `Found similar existing lesson: "${lesson.insight.slice(0, 50)}..."`,
+        existingId: lesson.id
+      };
+    }
+    if (lesson.insight.toLowerCase() === insight.toLowerCase()) {
+      return {
+        novel: false,
+        reason: `Exact duplicate found`,
+        existingId: lesson.id
+      };
+    }
+  }
+  return { novel: true };
+}
+var MIN_WORD_COUNT = 4;
+var VAGUE_PATTERNS = [
+  /\bwrite better\b/i,
+  /\bbe careful\b/i,
+  /\bremember to\b/i,
+  /\bmake sure\b/i,
+  /\btry to\b/i,
+  /\bdouble check\b/i
+];
+var GENERIC_IMPERATIVE_PATTERN = /^(always|never)\s+\w+(\s+\w+){0,2}$/i;
+function isSpecific(insight) {
+  const words = insight.trim().split(/\s+/).filter((w) => w.length > 0);
+  if (words.length < MIN_WORD_COUNT) {
+    return { specific: false, reason: "Insight is too short to be actionable" };
+  }
+  for (const pattern of VAGUE_PATTERNS) {
+    if (pattern.test(insight)) {
+      return { specific: false, reason: "Insight matches a vague pattern" };
+    }
+  }
+  if (GENERIC_IMPERATIVE_PATTERN.test(insight)) {
+    return { specific: false, reason: "Insight matches a vague pattern" };
+  }
+  return { specific: true };
+}
+var ACTION_PATTERNS = [
+  /\buse\s+.+\s+instead\s+of\b/i,
+  // "use X instead of Y"
+  /\bprefer\s+.+\s+(over|to)\b/i,
+  // "prefer X over Y" or "prefer X to Y"
+  /\balways\s+.+\s+when\b/i,
+  // "always X when Y"
+  /\bnever\s+.+\s+without\b/i,
+  // "never X without Y"
+  /\bavoid\s+(using\s+)?\w+/i,
+  // "avoid X" or "avoid using X"
+  /\bcheck\s+.+\s+before\b/i,
+  // "check X before Y"
+  /^(run|use|add|remove|install|update|configure|set|enable|disable)\s+/i
+  // Imperative commands at start
 ];
 function isActionable(insight) {
   for (const pattern of ACTION_PATTERNS) {
@@ -720,181 +905,62 @@ async function parseInputFile(filePath) {
   }
   return data;
 }
-
-// src/utils.ts
-var MS_PER_DAY = 24 * 60 * 60 * 1e3;
-function getLessonAgeDays(lesson) {
-  const created = new Date(lesson.created).getTime();
-  const now = Date.now();
-  return Math.floor((now - created) / MS_PER_DAY);
+var out = {
+  success: (msg) => console.log(chalk.green("[ok]"), msg),
+  error: (msg) => console.error(chalk.red("[error]"), msg),
+  info: (msg) => console.log(chalk.blue("[info]"), msg),
+  warn: (msg) => console.log(chalk.yellow("[warn]"), msg)
+};
+function getGlobalOpts(cmd) {
+  const opts = cmd.optsWithGlobals();
+  return {
+    verbose: opts.verbose ?? false,
+    quiet: opts.quiet ?? false
+  };
 }
+var DEFAULT_SEARCH_LIMIT = "10";
+var DEFAULT_LIST_LIMIT = "20";
+var DEFAULT_CHECK_PLAN_LIMIT = "5";
+var LESSON_COUNT_WARNING_THRESHOLD = 20;
+var AGE_FLAG_THRESHOLD_DAYS = 90;
+var ISO_DATE_PREFIX_LENGTH = 10;
+var AVG_DECIMAL_PLACES = 1;
+var RELEVANCE_DECIMAL_PLACES = 2;
+var JSON_INDENT_SPACES = 2;
 
-// src/storage/compact.ts
-var ARCHIVE_DIR = ".claude/lessons/archive";
-var TOMBSTONE_THRESHOLD = 100;
-var ARCHIVE_AGE_DAYS = 90;
-var MONTH_INDEX_OFFSET = 1;
-var MONTH_PAD_LENGTH = 2;
-function getArchivePath(repoRoot, date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + MONTH_INDEX_OFFSET).padStart(MONTH_PAD_LENGTH, "0");
-  return join(repoRoot, ARCHIVE_DIR, `${year}-${month}.jsonl`);
-}
-async function parseRawJsonlLines(repoRoot) {
-  const filePath = join(repoRoot, LESSONS_PATH);
-  let content;
-  try {
-    content = await readFile(filePath, "utf-8");
-  } catch {
-    return [];
-  }
-  const results = [];
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      results.push({ line: trimmed, parsed });
-    } catch {
-      results.push({ line: trimmed, parsed: null });
-    }
-  }
-  return results;
+// src/commands/capture.ts
+function createLessonFromFlags(trigger, insight, confirmed) {
+  return {
+    id: generateId(insight),
+    type: "quick",
+    trigger,
+    insight,
+    tags: [],
+    source: "manual",
+    context: { tool: "capture", intent: "manual capture" },
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    confirmed,
+    supersedes: [],
+    related: []
+  };
 }
-async function countTombstones(repoRoot) {
-  const lines = await parseRawJsonlLines(repoRoot);
-  let count = 0;
-  for (const { parsed } of lines) {
-    if (parsed && parsed["deleted"] === true) {
-      count++;
-    }
-  }
-  return count;
+function outputCaptureJson(lesson, saved) {
+  console.log(JSON.stringify({
+    id: lesson.id,
+    trigger: lesson.trigger,
+    insight: lesson.insight,
+    type: lesson.type,
+    saved
+  }));
 }
-async function needsCompaction(repoRoot) {
-  const count = await countTombstones(repoRoot);
-  return count >= TOMBSTONE_THRESHOLD;
-}
-async function rewriteWithoutTombstones(repoRoot) {
-  const filePath = join(repoRoot, LESSONS_PATH);
-  const tempPath = filePath + ".tmp";
-  const { lessons } = await readLessons(repoRoot);
-  const tombstoneCount = await countTombstones(repoRoot);
-  await mkdir(dirname(filePath), { recursive: true });
-  const lines = lessons.map((lesson) => JSON.stringify(lesson) + "\n");
-  await writeFile(tempPath, lines.join(""), "utf-8");
-  await rename(tempPath, filePath);
-  return tombstoneCount;
-}
-function shouldArchive(lesson) {
-  const ageDays = getLessonAgeDays(lesson);
-  return ageDays > ARCHIVE_AGE_DAYS && (lesson.retrievalCount === void 0 || lesson.retrievalCount === 0);
-}
-async function archiveOldLessons(repoRoot) {
-  const { lessons } = await readLessons(repoRoot);
-  const toArchive = [];
-  const toKeep = [];
-  for (const lesson of lessons) {
-    if (shouldArchive(lesson)) {
-      toArchive.push(lesson);
-    } else {
-      toKeep.push(lesson);
-    }
-  }
-  if (toArchive.length === 0) {
-    return 0;
-  }
-  const archiveGroups = /* @__PURE__ */ new Map();
-  for (const lesson of toArchive) {
-    const created = new Date(lesson.created);
-    const archivePath = getArchivePath(repoRoot, created);
-    const group = archiveGroups.get(archivePath) ?? [];
-    group.push(lesson);
-    archiveGroups.set(archivePath, group);
-  }
-  const archiveDir = join(repoRoot, ARCHIVE_DIR);
-  await mkdir(archiveDir, { recursive: true });
-  for (const [archivePath, archiveLessons] of archiveGroups) {
-    const lines2 = archiveLessons.map((l) => JSON.stringify(l) + "\n").join("");
-    await appendFile(archivePath, lines2, "utf-8");
-  }
-  const filePath = join(repoRoot, LESSONS_PATH);
-  const tempPath = filePath + ".tmp";
-  await mkdir(dirname(filePath), { recursive: true });
-  const lines = toKeep.map((lesson) => JSON.stringify(lesson) + "\n");
-  await writeFile(tempPath, lines.join(""), "utf-8");
-  await rename(tempPath, filePath);
-  return toArchive.length;
-}
-async function compact(repoRoot) {
-  const tombstonesBefore = await countTombstones(repoRoot);
-  const archived = await archiveOldLessons(repoRoot);
-  const tombstonesAfterArchive = await countTombstones(repoRoot);
-  await rewriteWithoutTombstones(repoRoot);
-  const tombstonesRemoved = archived > 0 ? tombstonesBefore : tombstonesAfterArchive;
-  const { lessons } = await readLessons(repoRoot);
-  return {
-    archived,
-    tombstonesRemoved,
-    lessonsRemaining: lessons.length
-  };
-}
-var out = {
-  success: (msg) => console.log(chalk.green("[ok]"), msg),
-  error: (msg) => console.error(chalk.red("[error]"), msg),
-  info: (msg) => console.log(chalk.blue("[info]"), msg),
-  warn: (msg) => console.log(chalk.yellow("[warn]"), msg)
-};
-function getGlobalOpts(cmd) {
-  const opts = cmd.optsWithGlobals();
-  return {
-    verbose: opts.verbose ?? false,
-    quiet: opts.quiet ?? false
-  };
-}
-var DEFAULT_SEARCH_LIMIT = "10";
-var DEFAULT_LIST_LIMIT = "20";
-var DEFAULT_CHECK_PLAN_LIMIT = "5";
-var LESSON_COUNT_WARNING_THRESHOLD = 20;
-var AGE_FLAG_THRESHOLD_DAYS = 90;
-var ISO_DATE_PREFIX_LENGTH = 10;
-var AVG_DECIMAL_PLACES = 1;
-var RELEVANCE_DECIMAL_PLACES = 2;
-var JSON_INDENT_SPACES = 2;
-
-// src/commands/capture.ts
-function createLessonFromFlags(trigger, insight, confirmed) {
-  return {
-    id: generateId(insight),
-    type: "quick",
-    trigger,
-    insight,
-    tags: [],
-    source: "manual",
-    context: { tool: "capture", intent: "manual capture" },
-    created: (/* @__PURE__ */ new Date()).toISOString(),
-    confirmed,
-    supersedes: [],
-    related: []
-  };
-}
-function outputCaptureJson(lesson, saved) {
-  console.log(JSON.stringify({
-    id: lesson.id,
-    trigger: lesson.trigger,
-    insight: lesson.insight,
-    type: lesson.type,
-    saved
-  }));
-}
-function outputCapturePreview(lesson) {
-  console.log("Lesson captured:");
-  console.log(`  ID: ${lesson.id}`);
-  console.log(`  Trigger: ${lesson.trigger}`);
-  console.log(`  Insight: ${lesson.insight}`);
-  console.log(`  Type: ${lesson.type}`);
-  console.log(`  Tags: ${lesson.tags.length > 0 ? lesson.tags.join(", ") : "(none)"}`);
-  console.log("\nSave this lesson? [y/n]");
+function outputCapturePreview(lesson) {
+  console.log("Lesson captured:");
+  console.log(`  ID: ${lesson.id}`);
+  console.log(`  Trigger: ${lesson.trigger}`);
+  console.log(`  Insight: ${lesson.insight}`);
+  console.log(`  Type: ${lesson.type}`);
+  console.log(`  Tags: ${lesson.tags.length > 0 ? lesson.tags.join(", ") : "(none)"}`);
+  console.log("\nSave this lesson? [y/n]");
 }
 function createLessonFromInputFile(result, confirmed) {
   return {
@@ -1057,153 +1123,249 @@ Saved as lesson: ${lesson.id}`);
     }
   });
 }
-function registerManagementCommands(program2) {
-  program2.command("wrong <id>").description("Mark a lesson as invalid/wrong").option("-r, --reason <text>", "Reason for invalidation").action(async function(id, options) {
+function formatLessonHuman(lesson) {
+  const lines = [];
+  lines.push(`ID: ${lesson.id}`);
+  lines.push(`Type: ${lesson.type}`);
+  lines.push(`Trigger: ${lesson.trigger}`);
+  lines.push(`Insight: ${lesson.insight}`);
+  if (lesson.evidence) {
+    lines.push(`Evidence: ${lesson.evidence}`);
+  }
+  if (lesson.severity) {
+    lines.push(`Severity: ${lesson.severity}`);
+  }
+  lines.push(`Tags: ${lesson.tags.length > 0 ? lesson.tags.join(", ") : "(none)"}`);
+  lines.push(`Source: ${lesson.source}`);
+  if (lesson.context) {
+    lines.push(`Context: ${lesson.context.tool} - ${lesson.context.intent}`);
+  }
+  lines.push(`Created: ${lesson.created}`);
+  lines.push(`Confirmed: ${lesson.confirmed ? "yes" : "no"}`);
+  if (lesson.supersedes && lesson.supersedes.length > 0) {
+    lines.push(`Supersedes: ${lesson.supersedes.join(", ")}`);
+  }
+  if (lesson.related && lesson.related.length > 0) {
+    lines.push(`Related: ${lesson.related.join(", ")}`);
+  }
+  if (lesson.pattern) {
+    lines.push("Pattern:");
+    lines.push(`  Bad:  ${lesson.pattern.bad}`);
+    lines.push(`  Good: ${lesson.pattern.good}`);
+  }
+  return lines.join("\n");
+}
+async function wasLessonDeleted(repoRoot, id) {
+  const filePath = join(repoRoot, LESSONS_PATH);
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const record = JSON.parse(trimmed);
+        if (record.id === id && record.deleted === true) {
+          return true;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/commands/management/crud.ts
+var SHOW_JSON_INDENT = 2;
+function registerCrudCommands(program2) {
+  program2.command("show <id>").description("Show details of a specific lesson").option("--json", "Output as JSON").action(async (id, options) => {
     const repoRoot = getRepoRoot();
     const { lessons } = await readLessons(repoRoot);
     const lesson = lessons.find((l) => l.id === id);
     if (!lesson) {
-      out.error(`Lesson not found: ${id}`);
+      const wasDeleted = await wasLessonDeleted(repoRoot, id);
+      if (options.json) {
+        console.log(JSON.stringify({ error: wasDeleted ? `Lesson ${id} not found (deleted)` : `Lesson ${id} not found` }));
+      } else {
+        out.error(wasDeleted ? `Lesson ${id} not found (deleted)` : `Lesson ${id} not found`);
+      }
       process.exit(1);
     }
-    if (lesson.invalidatedAt) {
-      out.warn(`Lesson ${id} is already marked as invalid.`);
-      return;
-    }
-    const updatedLesson = {
-      ...lesson,
-      invalidatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...options.reason !== void 0 && { invalidationReason: options.reason }
-    };
-    await appendLesson(repoRoot, updatedLesson);
-    out.success(`Lesson ${id} marked as invalid.`);
-    if (options.reason) {
-      console.log(`  Reason: ${options.reason}`);
+    if (options.json) {
+      console.log(JSON.stringify(lesson, null, SHOW_JSON_INDENT));
+    } else {
+      console.log(formatLessonHuman(lesson));
     }
   });
-  program2.command("validate <id>").description("Re-enable a previously invalidated lesson").action(async function(id) {
+  program2.command("update <id>").description("Update a lesson").option("--insight <text>", "Update insight").option("--trigger <text>", "Update trigger").option("--evidence <text>", "Update evidence").option("--severity <level>", "Update severity (low/medium/high)").option("--tags <tags>", "Update tags (comma-separated)").option("--confirmed <bool>", "Update confirmed status (true/false)").option("--json", "Output as JSON").action(async (id, options) => {
     const repoRoot = getRepoRoot();
+    const hasUpdates = options.insight !== void 0 || options.trigger !== void 0 || options.evidence !== void 0 || options.severity !== void 0 || options.tags !== void 0 || options.confirmed !== void 0;
+    if (!hasUpdates) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "No fields to update (specify at least one: --insight, --tags, --severity, ...)" }));
+      } else {
+        out.error("No fields to update (specify at least one: --insight, --tags, --severity, ...)");
+      }
+      process.exit(1);
+    }
     const { lessons } = await readLessons(repoRoot);
     const lesson = lessons.find((l) => l.id === id);
     if (!lesson) {
-      out.error(`Lesson not found: ${id}`);
+      const wasDeleted = await wasLessonDeleted(repoRoot, id);
+      if (options.json) {
+        console.log(JSON.stringify({ error: wasDeleted ? `Lesson ${id} is deleted` : `Lesson ${id} not found` }));
+      } else {
+        out.error(wasDeleted ? `Lesson ${id} is deleted` : `Lesson ${id} not found`);
+      }
       process.exit(1);
     }
-    if (!lesson.invalidatedAt) {
-      out.info(`Lesson ${id} is not invalidated.`);
-      return;
+    if (options.severity !== void 0) {
+      const result = SeveritySchema.safeParse(options.severity);
+      if (!result.success) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: `Invalid severity '${options.severity}' (must be: high, medium, low)` }));
+        } else {
+          out.error(`Invalid severity '${options.severity}' (must be: high, medium, low)`);
+        }
+        process.exit(1);
+      }
     }
     const updatedLesson = {
-      id: lesson.id,
-      type: lesson.type,
-      trigger: lesson.trigger,
-      insight: lesson.insight,
-      tags: lesson.tags,
-      source: lesson.source,
-      context: lesson.context,
-      created: lesson.created,
-      confirmed: lesson.confirmed,
-      supersedes: lesson.supersedes,
-      related: lesson.related,
-      // Include optional fields if present (excluding invalidation)
-      ...lesson.evidence !== void 0 && { evidence: lesson.evidence },
-      ...lesson.severity !== void 0 && { severity: lesson.severity },
-      ...lesson.pattern !== void 0 && { pattern: lesson.pattern },
-      ...lesson.deleted !== void 0 && { deleted: lesson.deleted },
-      ...lesson.retrievalCount !== void 0 && { retrievalCount: lesson.retrievalCount },
-      ...lesson.citation !== void 0 && { citation: lesson.citation },
-      ...lesson.compactionLevel !== void 0 && { compactionLevel: lesson.compactionLevel },
-      ...lesson.compactedAt !== void 0 && { compactedAt: lesson.compactedAt },
-      ...lesson.lastRetrieved !== void 0 && { lastRetrieved: lesson.lastRetrieved }
+      ...lesson,
+      ...options.insight !== void 0 && { insight: options.insight },
+      ...options.trigger !== void 0 && { trigger: options.trigger },
+      ...options.evidence !== void 0 && { evidence: options.evidence },
+      ...options.severity !== void 0 && { severity: options.severity },
+      ...options.tags !== void 0 && {
+        tags: [...new Set(
+          options.tags.split(",").map((t) => t.trim()).filter((t) => t.length > 0)
+        )]
+      },
+      ...options.confirmed !== void 0 && { confirmed: options.confirmed === "true" }
     };
-    await appendLesson(repoRoot, updatedLesson);
-    out.success(`Lesson ${id} re-enabled (validated).`);
-  });
-  program2.command("compact").description("Compact lessons: archive old lessons and remove tombstones").option("-f, --force", "Run compaction even if below threshold").option("--dry-run", "Show what would be done without making changes").action(async (options) => {
-    const repoRoot = getRepoRoot();
-    const tombstones = await countTombstones(repoRoot);
-    const needs = await needsCompaction(repoRoot);
-    if (options.dryRun) {
-      console.log("Dry run - no changes will be made.\n");
-      console.log(`Tombstones found: ${tombstones}`);
-      console.log(`Compaction needed: ${needs ? "yes" : "no"}`);
-      return;
+    const validationResult = LessonSchema.safeParse(updatedLesson);
+    if (!validationResult.success) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: `Schema validation failed: ${validationResult.error.message}` }));
+      } else {
+        out.error(`Schema validation failed: ${validationResult.error.message}`);
+      }
+      process.exit(1);
     }
-    if (!needs && !options.force) {
-      console.log(`Compaction not needed (${tombstones} tombstones, threshold is ${TOMBSTONE_THRESHOLD}).`);
-      console.log("Use --force to compact anyway.");
-      return;
+    await appendLesson(repoRoot, updatedLesson);
+    await syncIfNeeded(repoRoot);
+    if (options.json) {
+      console.log(JSON.stringify(updatedLesson, null, SHOW_JSON_INDENT));
+    } else {
+      out.success(`Updated lesson ${id}`);
     }
-    console.log("Running compaction...");
-    const result = await compact(repoRoot);
-    console.log("\nCompaction complete:");
-    console.log(`  Archived: ${result.archived} lesson(s)`);
-    console.log(`  Tombstones removed: ${result.tombstonesRemoved}`);
-    console.log(`  Lessons remaining: ${result.lessonsRemaining}`);
-    await rebuildIndex(repoRoot);
-    console.log("  Index rebuilt.");
   });
-  program2.command("rebuild").description("Rebuild SQLite index from JSONL").option("-f, --force", "Force rebuild even if unchanged").action(async (options) => {
+  program2.command("delete <ids...>").description("Soft delete lessons (creates tombstone)").option("--json", "Output as JSON").action(async (ids, options) => {
     const repoRoot = getRepoRoot();
-    if (options.force) {
-      console.log("Forcing index rebuild...");
-      await rebuildIndex(repoRoot);
-      console.log("Index rebuilt.");
+    const { lessons } = await readLessons(repoRoot);
+    const lessonMap = new Map(lessons.map((l) => [l.id, l]));
+    const deleted = [];
+    const warnings = [];
+    for (const id of ids) {
+      const lesson = lessonMap.get(id);
+      if (!lesson) {
+        const wasDeleted = await wasLessonDeleted(repoRoot, id);
+        warnings.push({ id, message: wasDeleted ? "already deleted" : "not found" });
+        continue;
+      }
+      const tombstone = {
+        ...lesson,
+        deleted: true,
+        deletedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await appendLesson(repoRoot, tombstone);
+      deleted.push(id);
+    }
+    if (deleted.length > 0) {
+      await syncIfNeeded(repoRoot);
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ deleted, warnings }));
     } else {
-      const rebuilt = await syncIfNeeded(repoRoot);
-      if (rebuilt) {
-        console.log("Index rebuilt (JSONL changed).");
-      } else {
-        console.log("Index is up to date.");
+      if (deleted.length > 0) {
+        out.success(`Deleted ${deleted.length} lesson(s): ${deleted.join(", ")}`);
+      }
+      for (const warning of warnings) {
+        out.warn(`${warning.id}: ${warning.message}`);
+      }
+      if (deleted.length === 0 && warnings.length > 0) {
+        process.exit(1);
       }
     }
   });
-  program2.command("stats").description("Show database health and statistics").action(async () => {
+}
+
+// src/commands/management/invalidation.ts
+function registerInvalidationCommands(program2) {
+  program2.command("wrong <id>").description("Mark a lesson as invalid/wrong").option("-r, --reason <text>", "Reason for invalidation").action(async function(id, options) {
     const repoRoot = getRepoRoot();
-    await syncIfNeeded(repoRoot);
     const { lessons } = await readLessons(repoRoot);
-    const deletedCount = await countTombstones(repoRoot);
-    const totalLessons = lessons.length;
-    const retrievalStats = getRetrievalStats(repoRoot);
-    const totalRetrievals = retrievalStats.reduce((sum, s) => sum + s.count, 0);
-    const avgRetrievals = totalLessons > 0 ? (totalRetrievals / totalLessons).toFixed(AVG_DECIMAL_PLACES) : "0.0";
-    const jsonlPath = join(repoRoot, LESSONS_PATH);
-    const dbPath = join(repoRoot, DB_PATH);
-    let dataSize = 0;
-    let indexSize = 0;
-    try {
-      dataSize = statSync(jsonlPath).size;
-    } catch {
+    const lesson = lessons.find((l) => l.id === id);
+    if (!lesson) {
+      out.error(`Lesson not found: ${id}`);
+      process.exit(1);
     }
-    try {
-      indexSize = statSync(dbPath).size;
-    } catch {
+    if (lesson.invalidatedAt) {
+      out.warn(`Lesson ${id} is already marked as invalid.`);
+      return;
     }
-    const totalSize = dataSize + indexSize;
-    let recentCount = 0;
-    let mediumCount = 0;
-    let oldCount = 0;
-    for (const lesson of lessons) {
-      const ageDays = getLessonAgeDays(lesson);
-      if (ageDays < 30) {
-        recentCount++;
-      } else if (ageDays <= AGE_FLAG_THRESHOLD_DAYS) {
-        mediumCount++;
-      } else {
-        oldCount++;
-      }
+    const updatedLesson = {
+      ...lesson,
+      invalidatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...options.reason !== void 0 && { invalidationReason: options.reason }
+    };
+    await appendLesson(repoRoot, updatedLesson);
+    out.success(`Lesson ${id} marked as invalid.`);
+    if (options.reason) {
+      console.log(`  Reason: ${options.reason}`);
     }
-    const deletedInfo = deletedCount > 0 ? ` (${deletedCount} deleted)` : "";
-    console.log(`Lessons: ${totalLessons} total${deletedInfo}`);
-    if (totalLessons > LESSON_COUNT_WARNING_THRESHOLD) {
-      out.warn(`High lesson count may degrade retrieval quality. Consider running \`lna compact\`.`);
+  });
+  program2.command("validate <id>").description("Re-enable a previously invalidated lesson").action(async function(id) {
+    const repoRoot = getRepoRoot();
+    const { lessons } = await readLessons(repoRoot);
+    const lesson = lessons.find((l) => l.id === id);
+    if (!lesson) {
+      out.error(`Lesson not found: ${id}`);
+      process.exit(1);
     }
-    if (totalLessons > 0) {
-      console.log(`Age: ${recentCount} <30d, ${mediumCount} 30-90d, ${oldCount} >90d`);
+    if (!lesson.invalidatedAt) {
+      out.info(`Lesson ${id} is not invalidated.`);
+      return;
     }
-    console.log(`Retrievals: ${totalRetrievals} total, ${avgRetrievals} avg per lesson`);
-    console.log(`Storage: ${formatBytes(totalSize)} (index: ${formatBytes(indexSize)}, data: ${formatBytes(dataSize)})`);
+    const updatedLesson = {
+      id: lesson.id,
+      type: lesson.type,
+      trigger: lesson.trigger,
+      insight: lesson.insight,
+      tags: lesson.tags,
+      source: lesson.source,
+      context: lesson.context,
+      created: lesson.created,
+      confirmed: lesson.confirmed,
+      supersedes: lesson.supersedes,
+      related: lesson.related,
+      // Include optional fields if present (excluding invalidation)
+      ...lesson.evidence !== void 0 && { evidence: lesson.evidence },
+      ...lesson.severity !== void 0 && { severity: lesson.severity },
+      ...lesson.pattern !== void 0 && { pattern: lesson.pattern },
+      ...lesson.deleted !== void 0 && { deleted: lesson.deleted },
+      ...lesson.retrievalCount !== void 0 && { retrievalCount: lesson.retrievalCount },
+      ...lesson.citation !== void 0 && { citation: lesson.citation },
+      ...lesson.compactionLevel !== void 0 && { compactionLevel: lesson.compactionLevel },
+      ...lesson.compactedAt !== void 0 && { compactedAt: lesson.compactedAt },
+      ...lesson.lastRetrieved !== void 0 && { lastRetrieved: lesson.lastRetrieved }
+    };
+    await appendLesson(repoRoot, updatedLesson);
+    out.success(`Lesson ${id} re-enabled (validated).`);
   });
+}
+function registerIOCommands(program2) {
   program2.command("export").description("Export lessons as JSON to stdout").option("--since <date>", "Only include lessons created after this date (ISO8601)").option("--tags <tags>", "Filter by tags (comma-separated, OR logic)").action(async (options) => {
     const repoRoot = getRepoRoot();
     const { lessons } = await readLessons(repoRoot);
@@ -1276,215 +1438,132 @@ function registerManagementCommands(program2) {
       console.log(`Imported ${imported} ${lessonWord}`);
     }
   });
-  const SHOW_JSON_INDENT = 2;
-  program2.command("show <id>").description("Show details of a specific lesson").option("--json", "Output as JSON").action(async (id, options) => {
+}
+function registerMaintenanceCommands(program2) {
+  program2.command("compact").description("Compact lessons: archive old lessons and remove tombstones").option("-f, --force", "Run compaction even if below threshold").option("--dry-run", "Show what would be done without making changes").action(async (options) => {
     const repoRoot = getRepoRoot();
-    const { lessons } = await readLessons(repoRoot);
-    const lesson = lessons.find((l) => l.id === id);
-    if (!lesson) {
-      const filePath = join(repoRoot, LESSONS_PATH);
-      let wasDeleted = false;
-      try {
-        const content = await readFile(filePath, "utf-8");
-        const lines = content.split("\n");
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed) continue;
-          try {
-            const record = JSON.parse(trimmed);
-            if (record.id === id && record.deleted === true) {
-              wasDeleted = true;
-              break;
-            }
-          } catch {
-          }
-        }
-      } catch {
-      }
-      if (options.json) {
-        console.log(JSON.stringify({ error: wasDeleted ? `Lesson ${id} not found (deleted)` : `Lesson ${id} not found` }));
-      } else {
-        out.error(wasDeleted ? `Lesson ${id} not found (deleted)` : `Lesson ${id} not found`);
-      }
-      process.exit(1);
+    const tombstones = await countTombstones(repoRoot);
+    const needs = await needsCompaction(repoRoot);
+    if (options.dryRun) {
+      console.log("Dry run - no changes will be made.\n");
+      console.log(`Tombstones found: ${tombstones}`);
+      console.log(`Compaction needed: ${needs ? "yes" : "no"}`);
+      return;
     }
-    if (options.json) {
-      console.log(JSON.stringify(lesson, null, SHOW_JSON_INDENT));
-    } else {
-      console.log(formatLessonHuman(lesson));
+    if (!needs && !options.force) {
+      console.log(`Compaction not needed (${tombstones} tombstones, threshold is ${TOMBSTONE_THRESHOLD}).`);
+      console.log("Use --force to compact anyway.");
+      return;
     }
+    console.log("Running compaction...");
+    const result = await compact(repoRoot);
+    console.log("\nCompaction complete:");
+    console.log(`  Archived: ${result.archived} lesson(s)`);
+    console.log(`  Tombstones removed: ${result.tombstonesRemoved}`);
+    console.log(`  Lessons remaining: ${result.lessonsRemaining}`);
+    await rebuildIndex(repoRoot);
+    console.log("  Index rebuilt.");
   });
-  program2.command("update <id>").description("Update a lesson").option("--insight <text>", "Update insight").option("--trigger <text>", "Update trigger").option("--evidence <text>", "Update evidence").option("--severity <level>", "Update severity (low/medium/high)").option("--tags <tags>", "Update tags (comma-separated)").option("--confirmed <bool>", "Update confirmed status (true/false)").option("--json", "Output as JSON").action(async (id, options) => {
+  program2.command("rebuild").description("Rebuild SQLite index from JSONL").option("-f, --force", "Force rebuild even if unchanged").action(async (options) => {
     const repoRoot = getRepoRoot();
-    const hasUpdates = options.insight !== void 0 || options.trigger !== void 0 || options.evidence !== void 0 || options.severity !== void 0 || options.tags !== void 0 || options.confirmed !== void 0;
-    if (!hasUpdates) {
-      if (options.json) {
-        console.log(JSON.stringify({ error: "No fields to update (specify at least one: --insight, --tags, --severity, ...)" }));
+    if (options.force) {
+      console.log("Forcing index rebuild...");
+      await rebuildIndex(repoRoot);
+      console.log("Index rebuilt.");
+    } else {
+      const rebuilt = await syncIfNeeded(repoRoot);
+      if (rebuilt) {
+        console.log("Index rebuilt (JSONL changed).");
       } else {
-        out.error("No fields to update (specify at least one: --insight, --tags, --severity, ...)");
+        console.log("Index is up to date.");
       }
-      process.exit(1);
     }
+  });
+  program2.command("stats").description("Show database health and statistics").action(async () => {
+    const repoRoot = getRepoRoot();
+    await syncIfNeeded(repoRoot);
     const { lessons } = await readLessons(repoRoot);
-    const lesson = lessons.find((l) => l.id === id);
-    if (!lesson) {
-      const filePath = join(repoRoot, LESSONS_PATH);
-      let wasDeleted = false;
-      try {
-        const content = await readFile(filePath, "utf-8");
-        const lines = content.split("\n");
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed) continue;
-          try {
-            const record = JSON.parse(trimmed);
-            if (record.id === id && record.deleted === true) {
-              wasDeleted = true;
-              break;
-            }
-          } catch {
-          }
-        }
-      } catch {
-      }
-      if (options.json) {
-        console.log(JSON.stringify({ error: wasDeleted ? `Lesson ${id} is deleted` : `Lesson ${id} not found` }));
-      } else {
-        out.error(wasDeleted ? `Lesson ${id} is deleted` : `Lesson ${id} not found`);
-      }
-      process.exit(1);
-    }
-    if (options.severity !== void 0) {
-      const result = SeveritySchema.safeParse(options.severity);
-      if (!result.success) {
-        if (options.json) {
-          console.log(JSON.stringify({ error: `Invalid severity '${options.severity}' (must be: high, medium, low)` }));
-        } else {
-          out.error(`Invalid severity '${options.severity}' (must be: high, medium, low)`);
-        }
-        process.exit(1);
-      }
-    }
-    const updatedLesson = {
-      ...lesson,
-      ...options.insight !== void 0 && { insight: options.insight },
-      ...options.trigger !== void 0 && { trigger: options.trigger },
-      ...options.evidence !== void 0 && { evidence: options.evidence },
-      ...options.severity !== void 0 && { severity: options.severity },
-      ...options.tags !== void 0 && {
-        tags: [...new Set(
-          options.tags.split(",").map((t) => t.trim()).filter((t) => t.length > 0)
-        )]
-      },
-      ...options.confirmed !== void 0 && { confirmed: options.confirmed === "true" }
-    };
-    const validationResult = LessonSchema.safeParse(updatedLesson);
-    if (!validationResult.success) {
-      if (options.json) {
-        console.log(JSON.stringify({ error: `Schema validation failed: ${validationResult.error.message}` }));
-      } else {
-        out.error(`Schema validation failed: ${validationResult.error.message}`);
-      }
-      process.exit(1);
+    const deletedCount = await countTombstones(repoRoot);
+    const totalLessons = lessons.length;
+    const retrievalStats = getRetrievalStats(repoRoot);
+    const totalRetrievals = retrievalStats.reduce((sum, s) => sum + s.count, 0);
+    const avgRetrievals = totalLessons > 0 ? (totalRetrievals / totalLessons).toFixed(AVG_DECIMAL_PLACES) : "0.0";
+    const jsonlPath = join(repoRoot, LESSONS_PATH);
+    const dbPath = join(repoRoot, DB_PATH);
+    let dataSize = 0;
+    let indexSize = 0;
+    try {
+      dataSize = statSync(jsonlPath).size;
+    } catch {
     }
-    await appendLesson(repoRoot, updatedLesson);
-    await syncIfNeeded(repoRoot);
-    if (options.json) {
-      console.log(JSON.stringify(updatedLesson, null, SHOW_JSON_INDENT));
-    } else {
-      out.success(`Updated lesson ${id}`);
+    try {
+      indexSize = statSync(dbPath).size;
+    } catch {
     }
-  });
-  program2.command("delete <ids...>").description("Soft delete lessons (creates tombstone)").option("--json", "Output as JSON").action(async (ids, options) => {
-    const repoRoot = getRepoRoot();
-    const { lessons } = await readLessons(repoRoot);
-    const lessonMap = new Map(lessons.map((l) => [l.id, l]));
-    const deleted = [];
-    const warnings = [];
-    for (const id of ids) {
-      const lesson = lessonMap.get(id);
-      if (!lesson) {
-        const wasDeleted = await wasLessonDeleted(repoRoot, id);
-        warnings.push({ id, message: wasDeleted ? "already deleted" : "not found" });
-        continue;
+    const totalSize = dataSize + indexSize;
+    let recentCount = 0;
+    let mediumCount = 0;
+    let oldCount = 0;
+    for (const lesson of lessons) {
+      const ageDays = getLessonAgeDays(lesson);
+      if (ageDays < 30) {
+        recentCount++;
+      } else if (ageDays <= AGE_FLAG_THRESHOLD_DAYS) {
+        mediumCount++;
+      } else {
+        oldCount++;
       }
-      const tombstone = {
-        ...lesson,
-        deleted: true,
-        deletedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await appendLesson(repoRoot, tombstone);
-      deleted.push(id);
     }
-    if (deleted.length > 0) {
-      await syncIfNeeded(repoRoot);
+    const deletedInfo = deletedCount > 0 ? ` (${deletedCount} deleted)` : "";
+    console.log(`Lessons: ${totalLessons} total${deletedInfo}`);
+    if (totalLessons > LESSON_COUNT_WARNING_THRESHOLD) {
+      out.warn(`High lesson count may degrade retrieval quality. Consider running \`lna compact\`.`);
     }
-    if (options.json) {
-      console.log(JSON.stringify({ deleted, warnings }));
-    } else {
-      if (deleted.length > 0) {
-        out.success(`Deleted ${deleted.length} lesson(s): ${deleted.join(", ")}`);
-      }
-      for (const warning of warnings) {
-        out.warn(`${warning.id}: ${warning.message}`);
-      }
-      if (deleted.length === 0 && warnings.length > 0) {
-        process.exit(1);
-      }
+    if (totalLessons > 0) {
+      console.log(`Age: ${recentCount} <30d, ${mediumCount} 30-90d, ${oldCount} >90d`);
     }
+    console.log(`Retrievals: ${totalRetrievals} total, ${avgRetrievals} avg per lesson`);
+    console.log(`Storage: ${formatBytes(totalSize)} (index: ${formatBytes(indexSize)}, data: ${formatBytes(dataSize)})`);
   });
 }
-function formatLessonHuman(lesson) {
-  const lines = [];
-  lines.push(`ID: ${lesson.id}`);
-  lines.push(`Type: ${lesson.type}`);
-  lines.push(`Trigger: ${lesson.trigger}`);
-  lines.push(`Insight: ${lesson.insight}`);
-  if (lesson.evidence) {
-    lines.push(`Evidence: ${lesson.evidence}`);
-  }
-  if (lesson.severity) {
-    lines.push(`Severity: ${lesson.severity}`);
-  }
-  lines.push(`Tags: ${lesson.tags.length > 0 ? lesson.tags.join(", ") : "(none)"}`);
-  lines.push(`Source: ${lesson.source}`);
-  if (lesson.context) {
-    lines.push(`Context: ${lesson.context.tool} - ${lesson.context.intent}`);
-  }
-  lines.push(`Created: ${lesson.created}`);
-  lines.push(`Confirmed: ${lesson.confirmed ? "yes" : "no"}`);
-  if (lesson.supersedes && lesson.supersedes.length > 0) {
-    lines.push(`Supersedes: ${lesson.supersedes.join(", ")}`);
-  }
-  if (lesson.related && lesson.related.length > 0) {
-    lines.push(`Related: ${lesson.related.join(", ")}`);
-  }
-  if (lesson.pattern) {
-    lines.push("Pattern:");
-    lines.push(`  Bad:  ${lesson.pattern.bad}`);
-    lines.push(`  Good: ${lesson.pattern.good}`);
-  }
-  return lines.join("\n");
+
+// src/commands/management/prime.ts
+var PRIME_WORKFLOW_CONTEXT = `# Learning Agent Workflow
+
+## Core Rules
+- **NEVER** edit .claude/lessons/index.jsonl directly
+- Use CLI commands: \`lna learn\`, \`lna list\`, \`lna show\`
+- Lessons load automatically at session start
+
+## When to Capture Lessons
+- User corrects you ("no", "wrong", "actually...")
+- You self-correct after multiple attempts
+- Test fails then you fix it
+
+## Commands
+- \`lna learn "insight"\` - Capture a lesson
+- \`lna list\` - Show all lessons
+- \`lna check-plan --plan "..."\` - Get relevant lessons for plan
+- \`lna stats\` - Show database health
+
+## Quality Gate (ALL must pass before proposing)
+- Novel (not already stored)
+- Specific (clear guidance)
+- Actionable (obvious what to do)
+`;
+function registerPrimeCommand(program2) {
+  program2.command("prime").description("Output workflow context for Claude Code").action(() => {
+    console.log(PRIME_WORKFLOW_CONTEXT);
+  });
 }
-async function wasLessonDeleted(repoRoot, id) {
-  const filePath = join(repoRoot, LESSONS_PATH);
-  try {
-    const content = await readFile(filePath, "utf-8");
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const record = JSON.parse(trimmed);
-        if (record.id === id && record.deleted === true) {
-          return true;
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return false;
+
+// src/commands/management/index.ts
+function registerManagementCommands(program2) {
+  registerInvalidationCommands(program2);
+  registerMaintenanceCommands(program2);
+  registerIOCommands(program2);
+  registerPrimeCommand(program2);
+  registerCrudCommands(program2);
 }
 var MODEL_URI = "hf:ggml-org/embeddinggemma-300M-qat-q4_0-GGUF/embeddinggemma-300M-qat-Q4_0.gguf";
 var MODEL_FILENAME = "hf_ggml-org_embeddinggemma-300M-qat-Q4_0.gguf";
@@ -1617,7 +1696,7 @@ async function retrieveForPlan(repoRoot, planText, limit = DEFAULT_LIMIT3) {
   return { lessons: topLessons, message };
 }
 function formatLessonsCheck(lessons) {
-  const header = "\u{1F4DA} Lessons Check\n" + "\u2500".repeat(40);
+  const header = "Lessons Check\n" + "\u2500".repeat(40);
   if (lessons.length === 0) {
     return `${header}
 No relevant lessons found for this plan.`;
@@ -1632,7 +1711,7 @@ ${lessonLines.join("\n")}`;
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.3";
 
 // src/commands/retrieval.ts
 async function readPlanFromStdin() {
@@ -1807,12 +1886,12 @@ function registerRetrievalCommands(program2) {
       if (options.json) {
         console.log(JSON.stringify({
           error: "Embedding model not available",
-          action: "Run: npx learning-agent download-model"
+          action: "Run: npx lna download-model"
         }));
       } else {
         out.error("Embedding model not available");
         console.log("");
-        console.log("Run: npx learning-agent download-model");
+        console.log("Run: npx lna download-model");
       }
       process.exit(1);
     }
@@ -1838,34 +1917,69 @@ function registerRetrievalCommands(program2) {
     }
   });
 }
+
+// src/commands/setup/templates.ts
 var PRE_COMMIT_MESSAGE = `Before committing, have you captured any valuable lessons from this session?
 Consider: corrections, mistakes, or insights worth remembering.
 
 To capture a lesson:
-  npx learning-agent capture --trigger "what happened" --insight "what to do" --yes`;
+  npx lna capture --trigger "what happened" --insight "what to do" --yes`;
 var PRE_COMMIT_HOOK_TEMPLATE = `#!/bin/sh
 # Learning Agent pre-commit hook
 # Reminds Claude to consider capturing lessons before commits
 
-npx learning-agent hooks run pre-commit
+npx lna hooks run pre-commit
+`;
+var HOOK_MARKER = "# Learning Agent pre-commit hook";
+var LEARNING_AGENT_HOOK_BLOCK = `
+# Learning Agent pre-commit hook (appended)
+npx lna hooks run pre-commit
 `;
-var CLAUDE_HOOK_MARKER = "learning-agent load-session";
+var CLAUDE_HOOK_MARKERS = ["lna load-session", "learning-agent load-session"];
 var CLAUDE_HOOK_CONFIG = {
   matcher: "startup|resume|compact",
   hooks: [
     {
       type: "command",
-      command: "npx learning-agent load-session 2>/dev/null || true"
+      command: "npx lna load-session 2>/dev/null || true"
     }
   ]
 };
-var HOOK_MARKER = "# Learning Agent pre-commit hook";
 var LEARNING_AGENT_SECTION_HEADER = "## Learning Agent Integration";
+var CLAUDE_REF_START_MARKER = "<!-- learning-agent:claude-ref:start -->";
+var CLAUDE_REF_END_MARKER = "<!-- learning-agent:claude-ref:end -->";
+var CLAUDE_MD_REFERENCE = `
+${CLAUDE_REF_START_MARKER}
+## Learning Agent
+See AGENTS.md for lesson capture workflow.
+${CLAUDE_REF_END_MARKER}
+`;
+var AGENTS_SECTION_START_MARKER = "<!-- learning-agent:start -->";
+var AGENTS_SECTION_END_MARKER = "<!-- learning-agent:end -->";
 var AGENTS_MD_TEMPLATE = `
+${AGENTS_SECTION_START_MARKER}
 ## Learning Agent Integration
 
 This project uses learning-agent for session memory.
 
+### CRITICAL RULES
+
+#### Never Edit JSONL Directly
+
+**WARNING: NEVER edit .claude/lessons/index.jsonl directly.**
+
+The JSONL file is the source of truth and requires:
+- Proper ID generation
+- Schema validation
+- SQLite index sync
+
+Always use CLI commands:
+- \`npx lna learn "insight"\` - Add a lesson
+- \`npx lna update <id> --insight "new"\` - Modify a lesson
+- \`npx lna delete <id>\` - Remove a lesson
+
+Manual edits will break validation and corrupt the SQLite sync.
+
 ### Retrieval Points
 
 - **Session start**: High-severity lessons loaded automatically
@@ -1876,7 +1990,7 @@ This project uses learning-agent for session memory.
 **BEFORE implementing any plan**, run:
 
 \`\`\`bash
-npx learning-agent check-plan --plan "your plan description" --json
+npx lna check-plan --plan "your plan description" --json
 \`\`\`
 
 Display results as a **Lessons Check** section after your plan:
@@ -1889,6 +2003,33 @@ Display results as a **Lessons Check** section after your plan:
 
 Consider each lesson while implementing.
 
+### When to Capture Lessons (Detection Triggers)
+
+Watch for these patterns and propose \`lna learn\`:
+
+**User correction**: User says "no", "wrong", "actually..."
+- Action: Propose a lesson capturing the correct approach
+
+**Self-correction**: You fix after multiple attempts (edit -> fail -> re-edit)
+- Action: Propose a lesson about what finally worked
+
+**Test failure fix**: Test fails -> you diagnose -> fix -> passes
+- Action: Propose a lesson about the root cause and solution
+
+### Auto-Invoke Trigger Phrases
+
+**Capture triggers** (propose \`lna learn\`):
+- "that worked" - User confirms a solution worked
+- "fixed it" - Problem was resolved
+- "my mistake" - User acknowledges an error
+- "actually use X" - User specifies a preference
+
+**Retrieval triggers** (run \`lna check-plan\` or \`lna search\`):
+- "similar issue" - User recalls a past problem
+- "we had this before" - Reference to previous experience
+- "seen this" - Pattern recognition
+- "remember when" - Memory recall request
+
 ### Proposing Lessons
 
 Propose when: user correction, self-correction, test failure fix, or manual request.
@@ -1912,45 +2053,428 @@ Before closing a session, reflect on lessons learned:
 1. **Review**: What mistakes or corrections happened?
 2. **Quality gate**: Is it novel, specific, actionable?
 3. **Propose**: "Learned: [insight]. Save? [y/n]"
-4. **Capture**: \`npx learning-agent capture --trigger "..." --insight "..." --yes\`
+4. **Capture**: \`npx lna capture --trigger "..." --insight "..." --yes\`
 
 ### CLI Commands
 
 \`\`\`bash
-npx learning-agent load-session --json  # Session start
-npx learning-agent check-plan --plan "..." --json  # Before implementing
-npx learning-agent capture --trigger "..." --insight "..." --yes
+npx lna load-session --json  # Session start
+npx lna check-plan --plan "..." --json  # Before implementing
+npx lna learn "insight"  # Capture a lesson
+npx lna capture --trigger "..." --insight "..." --yes
 \`\`\`
 
 See [AGENTS.md](https://github.com/Nathandela/learning_agent/blob/main/AGENTS.md) for full documentation.
+${AGENTS_SECTION_END_MARKER}
 `;
-function hasLearningAgentSection(content) {
-  return content.includes(LEARNING_AGENT_SECTION_HEADER);
+var SLASH_COMMANDS = {
+  "learn.md": `Capture a lesson from this session.
+
+Usage: /learn <insight>
+
+Examples:
+- /learn "Always use Polars for large CSV files"
+- /learn "API requires X-Request-ID header"
+
+\`\`\`bash
+npx lna learn "$ARGUMENTS"
+\`\`\`
+`,
+  "check-plan.md": `Retrieve relevant lessons for a plan before implementing.
+
+Usage: /check-plan <plan description>
+
+\`\`\`bash
+npx lna check-plan --plan "$ARGUMENTS" --json
+\`\`\`
+`,
+  "list.md": `Show all stored lessons.
+
+\`\`\`bash
+npx lna list
+\`\`\`
+`,
+  "prime.md": `Load learning-agent workflow context after compaction or context loss.
+
+\`\`\`bash
+npx lna prime
+\`\`\`
+`,
+  "show.md": `Show details of a specific lesson.
+
+Usage: /show <lesson-id>
+
+\`\`\`bash
+npx lna show "$ARGUMENTS"
+\`\`\`
+`,
+  "wrong.md": `Mark a lesson as incorrect or invalid.
+
+Usage: /wrong <lesson-id>
+
+\`\`\`bash
+npx lna wrong "$ARGUMENTS"
+\`\`\`
+`,
+  "stats.md": `Show learning-agent database statistics and health.
+
+\`\`\`bash
+npx lna stats
+\`\`\`
+`
+};
+var PLUGIN_MANIFEST = {
+  name: "learning-agent",
+  description: "Session memory for Claude Code - capture and retrieve lessons",
+  version: "0.2.2",
+  author: {
+    name: "Nathan Delacr\xE9taz",
+    url: "https://github.com/Nathandela"
+  },
+  repository: "https://github.com/Nathandela/learning_agent",
+  license: "MIT",
+  hooks: {
+    SessionStart: [
+      {
+        matcher: "",
+        hooks: [
+          { type: "command", command: "npx lna prime 2>/dev/null || true" },
+          { type: "command", command: "npx lna load-session 2>/dev/null || true" }
+        ]
+      }
+    ],
+    PreCompact: [
+      {
+        matcher: "",
+        hooks: [{ type: "command", command: "npx lna prime 2>/dev/null || true" }]
+      }
+    ]
+  }
+};
+
+// src/commands/setup/claude-helpers.ts
+function getClaudeSettingsPath(global) {
+  if (global) {
+    return join(homedir(), ".claude", "settings.json");
+  }
+  const repoRoot = getRepoRoot();
+  return join(repoRoot, ".claude", "settings.json");
 }
-async function createLessonsDirectory(repoRoot) {
-  const lessonsDir = dirname(join(repoRoot, LESSONS_PATH));
-  await mkdir(lessonsDir, { recursive: true });
+async function readClaudeSettings(settingsPath) {
+  if (!existsSync(settingsPath)) {
+    return {};
+  }
+  const content = await readFile(settingsPath, "utf-8");
+  return JSON.parse(content);
 }
-async function createIndexFile(repoRoot) {
-  const indexPath = join(repoRoot, LESSONS_PATH);
-  if (!existsSync(indexPath)) {
-    await writeFile(indexPath, "", "utf-8");
+function hasClaudeHook(settings) {
+  const hooks = settings.hooks;
+  if (!hooks?.SessionStart) return false;
+  return hooks.SessionStart.some((entry) => {
+    const hookEntry = entry;
+    return hookEntry.hooks?.some(
+      (h) => CLAUDE_HOOK_MARKERS.some((marker) => h.command?.includes(marker))
+    );
+  });
+}
+function addLearningAgentHook(settings) {
+  if (!settings.hooks) {
+    settings.hooks = {};
   }
+  const hooks = settings.hooks;
+  if (!hooks.SessionStart) {
+    hooks.SessionStart = [];
+  }
+  hooks.SessionStart.push(CLAUDE_HOOK_CONFIG);
 }
-async function updateAgentsMd(repoRoot) {
+function removeLearningAgentHook(settings) {
+  const hooks = settings.hooks;
+  if (!hooks?.SessionStart) return false;
+  const originalLength = hooks.SessionStart.length;
+  hooks.SessionStart = hooks.SessionStart.filter((entry) => {
+    const hookEntry = entry;
+    return !hookEntry.hooks?.some(
+      (h) => CLAUDE_HOOK_MARKERS.some((marker) => h.command?.includes(marker))
+    );
+  });
+  return hooks.SessionStart.length < originalLength;
+}
+async function writeClaudeSettings(settingsPath, settings) {
+  const dir = dirname(settingsPath);
+  await mkdir(dir, { recursive: true });
+  const tempPath = settingsPath + ".tmp";
+  await writeFile(tempPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  await rename(tempPath, settingsPath);
+}
+async function installClaudeHooksForInit(repoRoot) {
+  const settingsPath = join(repoRoot, ".claude", "settings.json");
+  let settings;
+  try {
+    settings = await readClaudeSettings(settingsPath);
+  } catch {
+    return { installed: false, action: "error", error: "Failed to parse settings.json" };
+  }
+  if (hasClaudeHook(settings)) {
+    return { installed: true, action: "already_installed" };
+  }
+  try {
+    addLearningAgentHook(settings);
+    await writeClaudeSettings(settingsPath, settings);
+    return { installed: true, action: "installed" };
+  } catch (err) {
+    return { installed: false, action: "error", error: String(err) };
+  }
+}
+async function removeAgentsSection(repoRoot) {
   const agentsPath = join(repoRoot, "AGENTS.md");
-  let content = "";
-  let existed = false;
-  if (existsSync(agentsPath)) {
-    content = await readFile(agentsPath, "utf-8");
-    existed = true;
-    if (hasLearningAgentSection(content)) {
-      return false;
+  if (!existsSync(agentsPath)) {
+    return false;
+  }
+  const content = await readFile(agentsPath, "utf-8");
+  const startIdx = content.indexOf(AGENTS_SECTION_START_MARKER);
+  const endIdx = content.indexOf(AGENTS_SECTION_END_MARKER);
+  if (startIdx === -1 || endIdx === -1) {
+    return false;
+  }
+  const before = content.slice(0, startIdx);
+  const after = content.slice(endIdx + AGENTS_SECTION_END_MARKER.length);
+  const newContent = (before.trimEnd() + after).trim();
+  if (newContent.length > 0) {
+    await writeFile(agentsPath, newContent + "\n", "utf-8");
+  } else {
+    await writeFile(agentsPath, "", "utf-8");
+  }
+  return true;
+}
+async function removeClaudeMdReference(repoRoot) {
+  const claudeMdPath = join(repoRoot, ".claude", "CLAUDE.md");
+  if (!existsSync(claudeMdPath)) {
+    return false;
+  }
+  const content = await readFile(claudeMdPath, "utf-8");
+  const startIdx = content.indexOf(CLAUDE_REF_START_MARKER);
+  const endIdx = content.indexOf(CLAUDE_REF_END_MARKER);
+  if (startIdx === -1 || endIdx === -1) {
+    return false;
+  }
+  const before = content.slice(0, startIdx);
+  const after = content.slice(endIdx + CLAUDE_REF_END_MARKER.length);
+  const newContent = (before.trimEnd() + after).trim();
+  if (newContent.length > 0) {
+    await writeFile(claudeMdPath, newContent + "\n", "utf-8");
+  } else {
+    await writeFile(claudeMdPath, "", "utf-8");
+  }
+  return true;
+}
+
+// src/commands/setup/claude.ts
+function registerClaudeCommand(program2) {
+  const setupCommand = program2.command("setup").description("Setup integrations");
+  setupCommand.command("claude").description("Install Claude Code SessionStart hooks").option("--global", "Install to global ~/.claude/ instead of project").option("--uninstall", "Remove learning-agent hooks").option("--status", "Check status of Claude Code integration").option("--dry-run", "Show what would change without writing").option("--json", "Output as JSON").action(async (options) => {
+    const settingsPath = getClaudeSettingsPath(options.global ?? false);
+    const displayPath = options.global ? "~/.claude/settings.json" : ".claude/settings.json";
+    let settings;
+    try {
+      settings = await readClaudeSettings(settingsPath);
+    } catch {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "Failed to parse settings file" }));
+      } else {
+        out.error("Failed to parse settings file. Check if JSON is valid.");
+      }
+      process.exit(1);
+    }
+    const alreadyInstalled = hasClaudeHook(settings);
+    if (options.status) {
+      const repoRoot = getRepoRoot();
+      const learnMdPath = join(repoRoot, ".claude", "commands", "learn.md");
+      const checkPlanMdPath = join(repoRoot, ".claude", "commands", "check-plan.md");
+      const learnExists = existsSync(learnMdPath);
+      const checkPlanExists = existsSync(checkPlanMdPath);
+      let status;
+      if (alreadyInstalled && learnExists && checkPlanExists) {
+        status = "connected";
+      } else if (alreadyInstalled || learnExists || checkPlanExists) {
+        status = "partial";
+      } else {
+        status = "disconnected";
+      }
+      const result = {
+        settingsFile: displayPath,
+        exists: existsSync(settingsPath),
+        validJson: true,
+        // We already parsed it above
+        hookInstalled: alreadyInstalled,
+        slashCommands: {
+          learn: learnExists,
+          checkPlan: checkPlanExists
+        },
+        status
+      };
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log("Claude Code Integration Status");
+        console.log("\u2500".repeat(40));
+        console.log("");
+        console.log(`Settings file: ${displayPath}`);
+        console.log(`  ${result.exists ? "[ok]" : "[missing]"} File exists`);
+        console.log(`  ${result.validJson ? "[ok]" : "[error]"} Valid JSON`);
+        console.log(`  ${result.hookInstalled ? "[ok]" : "[warn]"} SessionStart hook installed`);
+        console.log("");
+        console.log("Slash commands:");
+        console.log(`  ${learnExists ? "[ok]" : "[warn]"} /learn command`);
+        console.log(`  ${checkPlanExists ? "[ok]" : "[warn]"} /check-plan command`);
+        console.log("");
+        if (status === "connected") {
+          out.success("All checks passed. Integration is connected.");
+        } else if (status === "partial") {
+          out.warn("Partial setup detected.");
+          console.log("");
+          console.log("Run 'npx lna init' to complete setup.");
+        } else {
+          out.error("Not connected.");
+          console.log("");
+          console.log("Run 'npx lna init' to set up Learning Agent.");
+        }
+      }
+      return;
+    }
+    if (options.uninstall) {
+      const repoRoot = getRepoRoot();
+      if (options.dryRun) {
+        if (options.json) {
+          console.log(JSON.stringify({ dryRun: true, wouldRemove: alreadyInstalled, location: displayPath }));
+        } else {
+          if (alreadyInstalled) {
+            console.log(`Would remove learning-agent hooks from ${displayPath}`);
+          } else {
+            console.log("No learning-agent hooks to remove");
+          }
+        }
+        return;
+      }
+      const removedHook = removeLearningAgentHook(settings);
+      if (removedHook) {
+        await writeClaudeSettings(settingsPath, settings);
+      }
+      const removedAgents = await removeAgentsSection(repoRoot);
+      const removedClaudeMd = await removeClaudeMdReference(repoRoot);
+      const anyRemoved = removedHook || removedAgents || removedClaudeMd;
+      if (anyRemoved) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            installed: false,
+            location: displayPath,
+            action: "removed",
+            agentsMdRemoved: removedAgents,
+            claudeMdRemoved: removedClaudeMd
+          }));
+        } else {
+          out.success("Learning agent hooks removed");
+          if (removedHook) {
+            console.log(`  Settings: ${displayPath}`);
+          }
+          if (removedAgents) {
+            console.log("  AGENTS.md: Learning Agent section removed");
+          }
+          if (removedClaudeMd) {
+            console.log("  CLAUDE.md: Learning Agent reference removed");
+          }
+        }
+      } else {
+        if (options.json) {
+          console.log(JSON.stringify({ installed: false, location: displayPath, action: "unchanged" }));
+        } else {
+          out.info("No learning agent hooks to remove");
+          if (options.global) {
+            console.log("  Hint: Try without --global to check project settings.");
+          } else {
+            console.log("  Hint: Try with --global flag to check global settings.");
+          }
+        }
+      }
+      return;
+    }
+    if (options.dryRun) {
+      if (options.json) {
+        console.log(JSON.stringify({ dryRun: true, wouldInstall: !alreadyInstalled, location: displayPath }));
+      } else {
+        if (alreadyInstalled) {
+          console.log("Learning agent hooks already installed");
+        } else {
+          console.log(`Would install learning-agent hooks to ${displayPath}`);
+        }
+      }
+      return;
+    }
+    if (alreadyInstalled) {
+      if (options.json) {
+        console.log(JSON.stringify({
+          installed: true,
+          location: displayPath,
+          hooks: ["SessionStart"],
+          action: "unchanged"
+        }));
+      } else {
+        out.info("Learning agent hooks already installed");
+        console.log(`  Location: ${displayPath}`);
+      }
+      return;
+    }
+    const fileExists = existsSync(settingsPath);
+    addLearningAgentHook(settings);
+    await writeClaudeSettings(settingsPath, settings);
+    if (options.json) {
+      console.log(JSON.stringify({
+        installed: true,
+        location: displayPath,
+        hooks: ["SessionStart"],
+        action: fileExists ? "updated" : "created"
+      }));
+    } else {
+      out.success(options.global ? "Claude Code hooks installed (global)" : "Claude Code hooks installed (project-level)");
+      console.log(`  Location: ${displayPath}`);
+      console.log("  Hook: SessionStart (startup|resume|compact)");
+      console.log("");
+      console.log("Lessons will be loaded automatically at session start.");
+      if (!options.global) {
+        console.log("");
+        console.log("Note: Project hooks override global hooks.");
+      }
+    }
+  });
+}
+function registerDownloadModelCommand(program2) {
+  program2.command("download-model").description("Download the embedding model for semantic search").option("--json", "Output as JSON").action(async (options) => {
+    const alreadyExisted = isModelAvailable();
+    if (alreadyExisted) {
+      const modelPath2 = join(homedir(), ".node-llama-cpp", "models", MODEL_FILENAME);
+      const size2 = statSync(modelPath2).size;
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, path: modelPath2, size: size2, alreadyExisted: true }));
+      } else {
+        console.log("Model already exists.");
+        console.log(`Path: ${modelPath2}`);
+        console.log(`Size: ${formatBytes(size2)}`);
+      }
+      return;
+    }
+    if (!options.json) {
+      console.log("Downloading embedding model...");
+    }
+    const modelPath = await resolveModel({ cli: !options.json });
+    const size = statSync(modelPath).size;
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, path: modelPath, size, alreadyExisted: false }));
+    } else {
+      console.log(`
+Model downloaded successfully!`);
+      console.log(`Path: ${modelPath}`);
+      console.log(`Size: ${formatBytes(size)}`);
     }
-  }
-  const newContent = existed ? content.trimEnd() + "\n" + AGENTS_MD_TEMPLATE : AGENTS_MD_TEMPLATE.trim() + "\n";
-  await writeFile(agentsPath, newContent, "utf-8");
-  return true;
+  });
 }
 var HOOK_FILE_MODE = 493;
 function hasLearningAgentHook(content) {
@@ -1973,10 +2497,6 @@ async function getGitHooksDir(repoRoot) {
   const defaultHooksDir = join(gitDir, "hooks");
   return existsSync(defaultHooksDir) ? defaultHooksDir : null;
 }
-var LEARNING_AGENT_HOOK_BLOCK = `
-# Learning Agent pre-commit hook (appended)
-npx learning-agent hooks run pre-commit
-`;
 function findFirstTopLevelExitLine(lines) {
   let insideFunction = 0;
   let heredocDelimiter = null;
@@ -2037,57 +2557,97 @@ async function installPreCommitHook(repoRoot) {
   chmodSync(hookPath, HOOK_FILE_MODE);
   return true;
 }
-function getClaudeSettingsPath(global) {
-  if (global) {
-    return join(homedir(), ".claude", "settings.json");
-  }
-  const repoRoot = getRepoRoot();
-  return join(repoRoot, ".claude", "settings.json");
+function registerHooksCommand(program2) {
+  const hooksCommand = program2.command("hooks").description("Git hooks management");
+  hooksCommand.command("run <hook>").description("Run a hook script (called by git hooks)").option("--json", "Output as JSON").action((hook, options) => {
+    if (hook === "pre-commit") {
+      if (options.json) {
+        console.log(JSON.stringify({ hook: "pre-commit", message: PRE_COMMIT_MESSAGE }));
+      } else {
+        console.log(PRE_COMMIT_MESSAGE);
+      }
+    } else {
+      if (options.json) {
+        console.log(JSON.stringify({ error: `Unknown hook: ${hook}` }));
+      } else {
+        out.error(`Unknown hook: ${hook}`);
+      }
+      process.exit(1);
+    }
+  });
 }
-async function readClaudeSettings(settingsPath) {
-  if (!existsSync(settingsPath)) {
-    return {};
+function hasLearningAgentSection(content) {
+  return content.includes(LEARNING_AGENT_SECTION_HEADER);
+}
+function hasClaudeMdReference(content) {
+  return content.includes("Learning Agent") || content.includes(CLAUDE_REF_START_MARKER);
+}
+async function ensureClaudeMdReference(repoRoot) {
+  const claudeMdPath = join(repoRoot, ".claude", "CLAUDE.md");
+  await mkdir(join(repoRoot, ".claude"), { recursive: true });
+  if (!existsSync(claudeMdPath)) {
+    const content2 = `# Project Instructions
+${CLAUDE_MD_REFERENCE}`;
+    await writeFile(claudeMdPath, content2, "utf-8");
+    return true;
   }
-  const content = await readFile(settingsPath, "utf-8");
-  return JSON.parse(content);
+  const content = await readFile(claudeMdPath, "utf-8");
+  if (hasClaudeMdReference(content)) {
+    return false;
+  }
+  const newContent = content.trimEnd() + "\n" + CLAUDE_MD_REFERENCE;
+  await writeFile(claudeMdPath, newContent, "utf-8");
+  return true;
 }
-function hasClaudeHook(settings) {
-  const hooks = settings.hooks;
-  if (!hooks?.SessionStart) return false;
-  return hooks.SessionStart.some((entry) => {
-    const hookEntry = entry;
-    return hookEntry.hooks?.some((h) => h.command?.includes(CLAUDE_HOOK_MARKER));
-  });
+async function createLessonsDirectory(repoRoot) {
+  const lessonsDir = dirname(join(repoRoot, LESSONS_PATH));
+  await mkdir(lessonsDir, { recursive: true });
 }
-function addLearningAgentHook(settings) {
-  if (!settings.hooks) {
-    settings.hooks = {};
+async function createIndexFile(repoRoot) {
+  const indexPath = join(repoRoot, LESSONS_PATH);
+  if (!existsSync(indexPath)) {
+    await writeFile(indexPath, "", "utf-8");
   }
-  const hooks = settings.hooks;
-  if (!hooks.SessionStart) {
-    hooks.SessionStart = [];
+}
+async function updateAgentsMd(repoRoot) {
+  const agentsPath = join(repoRoot, "AGENTS.md");
+  let content = "";
+  let existed = false;
+  if (existsSync(agentsPath)) {
+    content = await readFile(agentsPath, "utf-8");
+    existed = true;
+    if (hasLearningAgentSection(content)) {
+      return false;
+    }
   }
-  hooks.SessionStart.push(CLAUDE_HOOK_CONFIG);
+  const newContent = existed ? content.trimEnd() + "\n" + AGENTS_MD_TEMPLATE : AGENTS_MD_TEMPLATE.trim() + "\n";
+  await writeFile(agentsPath, newContent, "utf-8");
+  return true;
 }
-function removeLearningAgentHook(settings) {
-  const hooks = settings.hooks;
-  if (!hooks?.SessionStart) return false;
-  const originalLength = hooks.SessionStart.length;
-  hooks.SessionStart = hooks.SessionStart.filter((entry) => {
-    const hookEntry = entry;
-    return !hookEntry.hooks?.some((h) => h.command?.includes(CLAUDE_HOOK_MARKER));
-  });
-  return hooks.SessionStart.length < originalLength;
+async function createPluginManifest(repoRoot) {
+  const pluginPath = join(repoRoot, ".claude", "plugin.json");
+  await mkdir(join(repoRoot, ".claude"), { recursive: true });
+  if (existsSync(pluginPath)) {
+    return false;
+  }
+  await writeFile(pluginPath, JSON.stringify(PLUGIN_MANIFEST, null, 2) + "\n", "utf-8");
+  return true;
 }
-async function writeClaudeSettings(settingsPath, settings) {
-  const dir = dirname(settingsPath);
-  await mkdir(dir, { recursive: true });
-  const tempPath = settingsPath + ".tmp";
-  await writeFile(tempPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-  await rename(tempPath, settingsPath);
+async function createSlashCommands(repoRoot) {
+  const commandsDir = join(repoRoot, ".claude", "commands");
+  await mkdir(commandsDir, { recursive: true });
+  let created = false;
+  for (const [filename, content] of Object.entries(SLASH_COMMANDS)) {
+    const filePath = join(commandsDir, filename);
+    if (!existsSync(filePath)) {
+      await writeFile(filePath, content, "utf-8");
+      created = true;
+    }
+  }
+  return created;
 }
-function registerSetupCommands(program2) {
-  program2.command("init").description("Initialize learning-agent in this repository").option("--skip-agents", "Skip AGENTS.md modification").option("--skip-hooks", "Skip git hooks installation").option("--json", "Output result as JSON").action(async function(options) {
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize learning-agent in this repository").option("--skip-agents", "Skip AGENTS.md modification").option("--skip-hooks", "Skip git hooks installation").option("--skip-claude", "Skip Claude Code hooks installation").option("--json", "Output result as JSON").action(async function(options) {
     const repoRoot = getRepoRoot();
     const { quiet } = getGlobalOpts(this);
     await createLessonsDirectory(repoRoot);
@@ -2097,16 +2657,33 @@ function registerSetupCommands(program2) {
     if (!options.skipAgents) {
       agentsMdUpdated = await updateAgentsMd(repoRoot);
     }
+    if (!options.skipAgents) {
+      await ensureClaudeMdReference(repoRoot);
+    }
+    let slashCommandsCreated = false;
+    if (!options.skipAgents) {
+      slashCommandsCreated = await createSlashCommands(repoRoot);
+    }
+    if (!options.skipAgents) {
+      await createPluginManifest(repoRoot);
+    }
     let hooksInstalled = false;
     if (!options.skipHooks) {
       hooksInstalled = await installPreCommitHook(repoRoot);
     }
+    let claudeHooksResult = { action: "error", error: "skipped" };
+    if (!options.skipClaude) {
+      claudeHooksResult = await installClaudeHooksForInit(repoRoot);
+    }
     if (options.json) {
+      const claudeHooksInstalled = claudeHooksResult.action === "installed";
       console.log(JSON.stringify({
         initialized: true,
         lessonsDir,
         agentsMd: agentsMdUpdated,
-        hooks: hooksInstalled
+        slashCommands: slashCommandsCreated || !options.skipAgents,
+        hooks: hooksInstalled,
+        claudeHooks: claudeHooksInstalled
       }));
     } else if (!quiet) {
       out.success("Learning agent initialized");
@@ -2118,6 +2695,13 @@ function registerSetupCommands(program2) {
       } else {
         console.log("  AGENTS.md: Already has Learning Agent section");
       }
+      if (slashCommandsCreated) {
+        console.log("  Slash commands: Created (/learn, /check-plan, /list, /prime)");
+      } else if (options.skipAgents) {
+        console.log("  Slash commands: Skipped (--skip-agents)");
+      } else {
+        console.log("  Slash commands: Already exist");
+      }
       if (hooksInstalled) {
         console.log("  Git hooks: pre-commit hook installed");
       } else if (options.skipHooks) {
@@ -2125,156 +2709,42 @@ function registerSetupCommands(program2) {
       } else {
         console.log("  Git hooks: Already installed or not a git repo");
       }
-    }
-  });
-  const hooksCommand = program2.command("hooks").description("Git hooks management");
-  hooksCommand.command("run <hook>").description("Run a hook script (called by git hooks)").option("--json", "Output as JSON").action((hook, options) => {
-    if (hook === "pre-commit") {
-      if (options.json) {
-        console.log(JSON.stringify({ hook: "pre-commit", message: PRE_COMMIT_MESSAGE }));
-      } else {
-        console.log(PRE_COMMIT_MESSAGE);
-      }
-    } else {
-      if (options.json) {
-        console.log(JSON.stringify({ error: `Unknown hook: ${hook}` }));
-      } else {
-        out.error(`Unknown hook: ${hook}`);
-      }
-      process.exit(1);
-    }
-  });
-  const setupCommand = program2.command("setup").description("Setup integrations");
-  setupCommand.command("claude").description("Install Claude Code SessionStart hooks").option("--global", "Install to global ~/.claude/ instead of project").option("--uninstall", "Remove learning-agent hooks").option("--dry-run", "Show what would change without writing").option("--json", "Output as JSON").action(async (options) => {
-    const settingsPath = getClaudeSettingsPath(options.global ?? false);
-    const displayPath = options.global ? "~/.claude/settings.json" : ".claude/settings.json";
-    let settings;
-    try {
-      settings = await readClaudeSettings(settingsPath);
-    } catch {
-      if (options.json) {
-        console.log(JSON.stringify({ error: "Failed to parse settings file" }));
-      } else {
-        out.error("Failed to parse settings file. Check if JSON is valid.");
-      }
-      process.exit(1);
-    }
-    const alreadyInstalled = hasClaudeHook(settings);
-    if (options.uninstall) {
-      if (options.dryRun) {
-        if (options.json) {
-          console.log(JSON.stringify({ dryRun: true, wouldRemove: alreadyInstalled, location: displayPath }));
-        } else {
-          if (alreadyInstalled) {
-            console.log(`Would remove learning-agent hooks from ${displayPath}`);
-          } else {
-            console.log("No learning-agent hooks to remove");
-          }
-        }
-        return;
-      }
-      const removed = removeLearningAgentHook(settings);
-      if (removed) {
-        await writeClaudeSettings(settingsPath, settings);
-        if (options.json) {
-          console.log(JSON.stringify({ installed: false, location: displayPath, action: "removed" }));
-        } else {
-          out.success("Learning agent hooks removed");
-          console.log(`  Location: ${displayPath}`);
-        }
-      } else {
-        if (options.json) {
-          console.log(JSON.stringify({ installed: false, location: displayPath, action: "unchanged" }));
-        } else {
-          out.info("No learning agent hooks to remove");
-          if (options.global) {
-            console.log("  Hint: Try without --global to check project settings.");
-          } else {
-            console.log("  Hint: Try with --global flag to check global settings.");
-          }
-        }
-      }
-      return;
-    }
-    if (options.dryRun) {
-      if (options.json) {
-        console.log(JSON.stringify({ dryRun: true, wouldInstall: !alreadyInstalled, location: displayPath }));
-      } else {
-        if (alreadyInstalled) {
-          console.log("Learning agent hooks already installed");
-        } else {
-          console.log(`Would install learning-agent hooks to ${displayPath}`);
-        }
-      }
-      return;
-    }
-    if (alreadyInstalled) {
-      if (options.json) {
-        console.log(JSON.stringify({
-          installed: true,
-          location: displayPath,
-          hooks: ["SessionStart"],
-          action: "unchanged"
-        }));
-      } else {
-        out.info("Learning agent hooks already installed");
-        console.log(`  Location: ${displayPath}`);
-      }
-      return;
-    }
-    const fileExists = existsSync(settingsPath);
-    addLearningAgentHook(settings);
-    await writeClaudeSettings(settingsPath, settings);
-    if (options.json) {
-      console.log(JSON.stringify({
-        installed: true,
-        location: displayPath,
-        hooks: ["SessionStart"],
-        action: fileExists ? "updated" : "created"
-      }));
-    } else {
-      out.success(options.global ? "Claude Code hooks installed (global)" : "Claude Code hooks installed (project-level)");
-      console.log(`  Location: ${displayPath}`);
-      console.log("  Hook: SessionStart (startup|resume|compact)");
-      console.log("");
-      console.log("Lessons will be loaded automatically at session start.");
-      if (!options.global) {
-        console.log("");
-        console.log("Note: Project hooks override global hooks.");
-      }
-    }
-  });
-  program2.command("download-model").description("Download the embedding model for semantic search").option("--json", "Output as JSON").action(async (options) => {
-    const alreadyExisted = isModelAvailable();
-    if (alreadyExisted) {
-      const modelPath2 = join(homedir(), ".node-llama-cpp", "models", MODEL_FILENAME);
-      const size2 = statSync(modelPath2).size;
-      if (options.json) {
-        console.log(JSON.stringify({ success: true, path: modelPath2, size: size2, alreadyExisted: true }));
-      } else {
-        console.log("Model already exists.");
-        console.log(`Path: ${modelPath2}`);
-        console.log(`Size: ${formatBytes(size2)}`);
+      if (options.skipClaude) {
+        console.log("  Claude hooks: Skipped (--skip-claude)");
+      } else if (claudeHooksResult.action === "installed") {
+        console.log("  Claude hooks: Installed to .claude/settings.json");
+      } else if (claudeHooksResult.action === "already_installed") {
+        console.log("  Claude hooks: Already installed");
+      } else if (claudeHooksResult.error) {
+        console.log(`  Claude hooks: Error - ${claudeHooksResult.error}`);
       }
-      return;
-    }
-    if (!options.json) {
-      console.log("Downloading embedding model...");
-    }
-    const modelPath = await resolveModel({ cli: !options.json });
-    const size = statSync(modelPath).size;
-    if (options.json) {
-      console.log(JSON.stringify({ success: true, path: modelPath, size, alreadyExisted: false }));
-    } else {
-      console.log(`
-Model downloaded successfully!`);
-      console.log(`Path: ${modelPath}`);
-      console.log(`Size: ${formatBytes(size)}`);
     }
   });
 }
 
+// src/commands/setup/index.ts
+function registerSetupCommands(program2) {
+  registerInitCommand(program2);
+  registerHooksCommand(program2);
+  registerClaudeCommand(program2);
+  registerDownloadModelCommand(program2);
+}
+
 // src/cli.ts
+function cleanup() {
+  try {
+    closeDb();
+  } catch {
+  }
+}
+process.on("SIGINT", () => {
+  cleanup();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  cleanup();
+  process.exit(0);
+});
 var program = new Command();
 program.option("-v, --verbose", "Show detailed output").option("-q, --quiet", "Suppress non-essential output");
 program.name("learning-agent").description("Repository-scoped learning system for Claude Code").version(VERSION);