learning-agent 0.2.1 → 0.2.2

package/dist/cli.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import chalk from 'chalk';
+import { createHash } from 'crypto';
 import { statSync, existsSync, chmodSync, mkdirSync } from 'fs';
-import * as fs from 'fs/promises';
-import { readFile, mkdir, writeFile, rename, appendFile } from 'fs/promises';
-import { homedir } from 'os';
 import { join, dirname } from 'path';
-import { createHash } from 'crypto';
-import { z } from 'zod';
 import Database from 'better-sqlite3';
+import * as fs from 'fs/promises';
+import { readFile, mkdir, appendFile, writeFile, rename } from 'fs/promises';
+import { z } from 'zod';
+import chalk from 'chalk';
 import { resolveModelFile, getLlama } from 'node-llama-cpp';
+import { homedir } from 'os';
 
 // src/cli-utils.ts
 function formatBytes(bytes) {
@@ -30,104 +30,6 @@ function parseLimit(value, name) {
 function getRepoRoot() {
   return process.env["LEARNING_AGENT_ROOT"] ?? process.cwd();
 }
-
-// src/cli/shared.ts
-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 ISO_DATE_PREFIX_LENGTH = 10;
-var AVG_DECIMAL_PLACES = 1;
-var RELEVANCE_DECIMAL_PLACES = 2;
-var JSON_INDENT_SPACES = 2;
-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 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 lna hooks run pre-commit
-`;
-var CLAUDE_HOOK_MARKER = "lna load-session";
-var CLAUDE_HOOK_MARKER_LEGACY = "learning-agent load-session";
-var CLAUDE_HOOK_CONFIG = {
-  matcher: "startup|resume|compact",
-  hooks: [
-    {
-      type: "command",
-      command: "npx lna load-session 2>/dev/null || true"
-    }
-  ]
-};
-var HOOK_MARKER = "# Learning Agent pre-commit hook";
-function getClaudeSettingsPath(global) {
-  if (global) {
-    return join(homedir(), ".claude", "settings.json");
-  }
-  const repoRoot = getRepoRoot();
-  return join(repoRoot, ".claude", "settings.json");
-}
-async function readClaudeSettings(settingsPath) {
-  if (!existsSync(settingsPath)) {
-    return {};
-  }
-  const content = await readFile(settingsPath, "utf-8");
-  return JSON.parse(content);
-}
-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) || h.command?.includes(CLAUDE_HOOK_MARKER_LEGACY)
-    );
-  });
-}
-function addLearningAgentHook(settings) {
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  const hooks = settings.hooks;
-  if (!hooks.SessionStart) {
-    hooks.SessionStart = [];
-  }
-  hooks.SessionStart.push(CLAUDE_HOOK_CONFIG);
-}
-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) || h.command?.includes(CLAUDE_HOOK_MARKER_LEGACY)
-    );
-  });
-  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);
-}
 var SourceSchema = z.enum([
   "user_correction",
   "self_correction",
@@ -142,7 +44,23 @@ var PatternSchema = z.object({
   bad: z.string(),
   good: z.string()
 });
+var CitationSchema = z.object({
+  file: z.string().min(1),
+  // Source file path (required, non-empty)
+  line: z.number().int().positive().optional(),
+  // Line number (optional, must be positive)
+  commit: z.string().optional()
+  // Git commit hash (optional)
+});
 var SeveritySchema = z.enum(["high", "medium", "low"]);
+var CompactionLevelSchema = z.union([
+  z.literal(0),
+  // Active
+  z.literal(1),
+  // Flagged (>90 days)
+  z.literal(2)
+  // Archived
+]);
 var LessonTypeSchema = z.enum(["quick", "full"]);
 var LessonSchema = z.object({
   // Core identity (required)
@@ -166,7 +84,20 @@ var LessonSchema = z.object({
   pattern: PatternSchema.optional(),
   // Lifecycle fields (optional)
   deleted: z.boolean().optional(),
-  retrievalCount: z.number().optional()
+  retrievalCount: z.number().optional(),
+  // Provenance tracking (optional)
+  citation: CitationSchema.optional(),
+  // Age-based validity fields (optional)
+  compactionLevel: CompactionLevelSchema.optional(),
+  // 0=active, 1=flagged, 2=archived
+  compactedAt: z.string().optional(),
+  // ISO8601 when compaction happened
+  lastRetrieved: z.string().optional(),
+  // ISO8601 last retrieval time
+  // Invalidation fields (optional - for marking lessons as wrong)
+  invalidatedAt: z.string().optional(),
+  // ISO8601
+  invalidationReason: z.string().optional()
 });
 z.object({
   id: z.string(),
@@ -249,6 +180,8 @@ async function readLessons(repoRoot, options = {}) {
   }
   return { lessons: Array.from(lessons.values()), skippedCount };
 }
+
+// src/storage/sqlite.ts
 var DB_PATH = ".claude/.cache/lessons.sqlite";
 var SCHEMA_SQL = `
   -- Main lessons table
@@ -270,7 +203,15 @@ var SCHEMA_SQL = `
     retrieval_count INTEGER NOT NULL DEFAULT 0,
     last_retrieved TEXT,
     embedding BLOB,
-    content_hash TEXT
+    content_hash TEXT,
+    -- v0.2.2 fields
+    invalidated_at TEXT,
+    invalidation_reason TEXT,
+    citation_file TEXT,
+    citation_line INTEGER,
+    citation_commit TEXT,
+    compaction_level INTEGER DEFAULT 0,
+    compacted_at TEXT
   );
 
   -- FTS5 virtual table for full-text search
@@ -379,6 +320,28 @@ function rowToLesson(row) {
   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) {
@@ -392,8 +355,8 @@ function collectCachedEmbeddings(database) {
   return cache;
 }
 var INSERT_LESSON_SQL = `
-  INSERT INTO lessons (id, type, trigger, insight, evidence, severity, tags, source, context, supersedes, related, created, confirmed, deleted, retrieval_count, last_retrieved, embedding, content_hash)
-  VALUES (@id, @type, @trigger, @insight, @evidence, @severity, @tags, @source, @context, @supersedes, @related, @created, @confirmed, @deleted, @retrieval_count, @last_retrieved, @embedding, @content_hash)
+  INSERT INTO lessons (id, type, trigger, insight, evidence, severity, tags, source, context, supersedes, related, created, confirmed, deleted, retrieval_count, last_retrieved, embedding, content_hash, invalidated_at, invalidation_reason, citation_file, citation_line, citation_commit, compaction_level, compacted_at)
+  VALUES (@id, @type, @trigger, @insight, @evidence, @severity, @tags, @source, @context, @supersedes, @related, @created, @confirmed, @deleted, @retrieval_count, @last_retrieved, @embedding, @content_hash, @invalidated_at, @invalidation_reason, @citation_file, @citation_line, @citation_commit, @compaction_level, @compacted_at)
 `;
 function getJsonlMtime(repoRoot) {
   const jsonlPath = join(repoRoot, LESSONS_PATH);
@@ -445,10 +408,17 @@ async function rebuildIndex(repoRoot) {
         confirmed: lesson.confirmed ? 1 : 0,
         deleted: lesson.deleted ? 1 : 0,
         retrieval_count: lesson.retrievalCount ?? 0,
-        last_retrieved: null,
-        // Reset on rebuild since we're rebuilding from source
+        last_retrieved: lesson.lastRetrieved ?? null,
         embedding: hasValidCache ? cached.embedding : null,
-        content_hash: hasValidCache ? cached.contentHash : 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,
+        citation_line: lesson.citation?.line ?? null,
+        citation_commit: lesson.citation?.commit ?? null,
+        compaction_level: lesson.compactionLevel ?? 0,
+        compacted_at: lesson.compactedAt ?? null
       });
     }
   });
@@ -483,6 +453,7 @@ async function searchKeyword(repoRoot, query, limit) {
       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);
@@ -517,90 +488,328 @@ function getRetrievalStats(repoRoot) {
     lastRetrieved: row.last_retrieved
   }));
 }
-var ARCHIVE_DIR = ".claude/lessons/archive";
-var TOMBSTONE_THRESHOLD = 100;
-var ARCHIVE_AGE_DAYS = 90;
-var MS_PER_DAY = 1e3 * 60 * 60 * 24;
-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 [];
+
+// 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 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 });
+  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 results;
+  return { novel: true };
 }
-async function countTombstones(repoRoot) {
-  const lines = await parseRawJsonlLines(repoRoot);
-  let count = 0;
-  for (const { parsed } of lines) {
-    if (parsed && parsed["deleted"] === true) {
-      count++;
+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" };
     }
   }
-  return count;
-}
-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, now) {
-  const created = new Date(lesson.created);
-  const ageMs = now.getTime() - created.getTime();
-  const ageDays = ageMs / MS_PER_DAY;
-  return ageDays > ARCHIVE_AGE_DAYS && (lesson.retrievalCount === void 0 || lesson.retrievalCount === 0);
+  if (GENERIC_IMPERATIVE_PATTERN.test(insight)) {
+    return { specific: false, reason: "Insight matches a vague pattern" };
+  }
+  return { specific: true };
 }
-async function archiveOldLessons(repoRoot) {
-  const { lessons } = await readLessons(repoRoot);
-  const now = /* @__PURE__ */ new Date();
-  const toArchive = [];
-  const toKeep = [];
-  for (const lesson of lessons) {
-    if (shouldArchive(lesson, now)) {
-      toArchive.push(lesson);
-    } else {
-      toKeep.push(lesson);
+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) {
+    if (pattern.test(insight)) {
+      return { actionable: true };
     }
   }
-  if (toArchive.length === 0) {
-    return 0;
+  return { actionable: false, reason: "Insight lacks clear action guidance" };
+}
+async function shouldPropose(repoRoot, insight) {
+  const specificResult = isSpecific(insight);
+  if (!specificResult.specific) {
+    return { shouldPropose: false, reason: specificResult.reason };
   }
-  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);
+  const actionableResult = isActionable(insight);
+  if (!actionableResult.actionable) {
+    return { shouldPropose: false, reason: actionableResult.reason };
+  }
+  const noveltyResult = await isNovel(repoRoot, insight);
+  if (!noveltyResult.novel) {
+    return { shouldPropose: false, reason: noveltyResult.reason };
+  }
+  return { shouldPropose: true };
+}
+
+// src/capture/triggers.ts
+var USER_CORRECTION_PATTERNS = [
+  /\bno\b[,.]?\s/i,
+  // "no, ..." or "no ..."
+  /\bwrong\b/i,
+  // "wrong"
+  /\bactually\b/i,
+  // "actually..."
+  /\bnot that\b/i,
+  // "not that"
+  /\bi meant\b/i
+  // "I meant"
+];
+function detectUserCorrection(signals) {
+  const { messages, context } = signals;
+  if (messages.length < 2) {
+    return null;
+  }
+  for (let i = 1; i < messages.length; i++) {
+    const message = messages[i];
+    if (!message) continue;
+    for (const pattern of USER_CORRECTION_PATTERNS) {
+      if (pattern.test(message)) {
+        return {
+          trigger: `User correction during ${context.intent}`,
+          correctionMessage: message,
+          context
+        };
+      }
+    }
+  }
+  return null;
+}
+function detectSelfCorrection(history) {
+  const { edits } = history;
+  if (edits.length < 3) {
+    return null;
+  }
+  for (let i = 0; i <= edits.length - 3; i++) {
+    const first = edits[i];
+    const second = edits[i + 1];
+    const third = edits[i + 2];
+    if (!first || !second || !third) continue;
+    if (first.file === second.file && second.file === third.file && first.success && !second.success && third.success) {
+      return {
+        file: first.file,
+        trigger: `Self-correction on ${first.file}`
+      };
+    }
+  }
+  return null;
+}
+function detectTestFailure(testResult) {
+  if (testResult.passed) {
+    return null;
+  }
+  const lines = testResult.output.split("\n").filter((line) => line.trim().length > 0);
+  const errorLine = lines.find((line) => /error|fail|assert/i.test(line)) ?? lines[0] ?? "";
+  return {
+    testFile: testResult.testFile,
+    errorOutput: testResult.output,
+    trigger: `Test failure in ${testResult.testFile}: ${errorLine.slice(0, 100)}`
+  };
+}
+async function detectAndPropose(repoRoot, input) {
+  const detected = runDetector(input);
+  if (!detected) {
+    return null;
+  }
+  const { trigger, source, proposedInsight } = detected;
+  const quality = await shouldPropose(repoRoot, proposedInsight);
+  if (!quality.shouldPropose) {
+    return null;
+  }
+  return { trigger, source, proposedInsight };
+}
+function runDetector(input) {
+  switch (input.type) {
+    case "user":
+      return detectUserCorrectionFlow(input.data);
+    case "self":
+      return detectSelfCorrectionFlow(input.data);
+    case "test":
+      return detectTestFailureFlow(input.data);
+  }
+}
+function detectUserCorrectionFlow(data) {
+  const result = detectUserCorrection(data);
+  if (!result) {
+    return null;
+  }
+  return {
+    trigger: result.trigger,
+    source: "user_correction",
+    proposedInsight: result.correctionMessage
+  };
+}
+function detectSelfCorrectionFlow(data) {
+  const result = detectSelfCorrection(data);
+  if (!result) {
+    return null;
+  }
+  return {
+    trigger: result.trigger,
+    source: "self_correction",
+    // Self-corrections need context to form useful insights
+    proposedInsight: `Check ${result.file} for common errors before editing`
+  };
+}
+function detectTestFailureFlow(data) {
+  const result = detectTestFailure(data);
+  if (!result) {
+    return null;
+  }
+  return {
+    trigger: result.trigger,
+    source: "test_failure",
+    proposedInsight: result.errorOutput
+  };
+}
+var VALID_TYPES = /* @__PURE__ */ new Set(["user", "self", "test"]);
+async function parseInputFile(filePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  const data = JSON.parse(content);
+  if (!VALID_TYPES.has(data.type)) {
+    throw new Error(`Invalid detection type: ${data.type}. Must be one of: user, self, test`);
+  }
+  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);
+}
+
+// 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;
+}
+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;
+}
+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);
@@ -630,151 +839,393 @@ async function compact(repoRoot) {
     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/cli/commands/stats.ts
-function registerStatsCommand(program2) {
-  program2.command("stats").description("Show database health and statistics").action(async () => {
-    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 {
-    }
-    try {
-      indexSize = statSync(dbPath).size;
-    } catch {
-    }
-    const totalSize = dataSize + indexSize;
-    const deletedInfo = deletedCount > 0 ? ` (${deletedCount} deleted)` : "";
-    console.log(`Lessons: ${totalLessons} total${deletedInfo}`);
-    console.log(`Retrievals: ${totalRetrievals} total, ${avgRetrievals} avg per lesson`);
-    console.log(`Storage: ${formatBytes(totalSize)} (index: ${formatBytes(indexSize)}, data: ${formatBytes(dataSize)})`);
-  });
+// 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 createLessonFromInputFile(result, confirmed) {
+  return {
+    id: generateId(result.proposedInsight),
+    type: "quick",
+    trigger: result.trigger,
+    insight: result.proposedInsight,
+    tags: [],
+    source: result.source,
+    context: { tool: "capture", intent: "auto-capture" },
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    confirmed,
+    supersedes: [],
+    related: []
+  };
 }
-function registerListCommand(program2) {
-  program2.command("list").description("List all lessons").option("-n, --limit <number>", "Maximum results", DEFAULT_LIST_LIMIT).action(async function(options) {
+function registerCaptureCommands(program2) {
+  program2.command("learn <insight>").description("Capture a new lesson").option("-t, --trigger <text>", "What triggered this lesson").option("--tags <tags>", "Comma-separated tags", "").option("-s, --severity <level>", "Lesson severity: high, medium, low").option("-y, --yes", "Skip confirmation").option("--citation <file:line>", "Source file (optionally with :line number)").option("--citation-commit <hash>", "Git commit hash for citation").action(async function(insight, options) {
     const repoRoot = getRepoRoot();
-    const limit = parseLimit(options.limit, "limit");
-    const { verbose, quiet } = getGlobalOpts(this);
-    const { lessons, skippedCount } = await readLessons(repoRoot);
-    if (lessons.length === 0) {
-      console.log('No lessons found. Get started with: learn "Your first lesson"');
-      if (skippedCount > 0) {
-        out.warn(`${skippedCount} corrupted lesson(s) skipped.`);
+    const { quiet } = getGlobalOpts(this);
+    let severity;
+    if (options.severity !== void 0) {
+      const result = SeveritySchema.safeParse(options.severity);
+      if (!result.success) {
+        out.error(`Invalid severity value: "${options.severity}". Valid values are: high, medium, low`);
+        process.exit(1);
       }
-      return;
+      severity = result.data;
+    }
+    const lessonType = severity !== void 0 ? "full" : "quick";
+    let citation;
+    if (options.citation) {
+      const parts = options.citation.split(":");
+      const file = parts[0] ?? "";
+      const lineStr = parts[1];
+      const line = lineStr ? parseInt(lineStr, 10) : void 0;
+      citation = {
+        file,
+        ...line && !isNaN(line) && { line },
+        ...options.citationCommit && { commit: options.citationCommit }
+      };
     }
-    const toShow = lessons.slice(0, limit);
+    const lesson = {
+      id: generateId(insight),
+      type: lessonType,
+      trigger: options.trigger ?? "Manual capture",
+      insight,
+      tags: options.tags ? options.tags.split(",").map((t) => t.trim()) : [],
+      source: "manual",
+      context: {
+        tool: "cli",
+        intent: "manual learning"
+      },
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      confirmed: true,
+      // learn command is explicit confirmation
+      supersedes: [],
+      related: [],
+      ...severity !== void 0 && { severity },
+      ...citation && { citation }
+    };
+    await appendLesson(repoRoot, lesson);
+    const chalk3 = await import('chalk');
+    out.success(`Learned: ${insight}`);
     if (!quiet) {
-      out.info(`Showing ${toShow.length} of ${lessons.length} lesson(s):
-`);
+      console.log(`ID: ${chalk3.default.dim(lesson.id)}`);
+      if (citation) {
+        console.log(`Citation: ${chalk3.default.dim(citation.file)}${citation.line ? `:${citation.line}` : ""}`);
+      }
     }
-    for (const lesson of toShow) {
-      console.log(`[${chalk.cyan(lesson.id)}] ${lesson.insight}`);
-      if (verbose) {
-        console.log(`  Type: ${lesson.type} | Source: ${lesson.source}`);
-        console.log(`  Created: ${lesson.created}`);
-        if (lesson.context) {
-          console.log(`  Context: ${lesson.context.tool} - ${lesson.context.intent}`);
+  });
+  program2.command("detect").description("Detect learning triggers from input").requiredOption("--input <file>", "Path to JSON input file").option("--save", "Save proposed lesson (requires --yes)").option("-y, --yes", "Confirm save (required with --save)").option("--json", "Output result as JSON").action(
+    async (options) => {
+      const repoRoot = getRepoRoot();
+      if (options.save && !options.yes) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: "--save requires --yes flag for confirmation" }));
+        } else {
+          out.error("--save requires --yes flag for confirmation");
+          console.log("Use: detect --input <file> --save --yes");
         }
-      } else {
-        console.log(`  Type: ${lesson.type} | Source: ${lesson.source}`);
+        process.exit(1);
       }
-      if (lesson.tags.length > 0) {
-        console.log(`  Tags: ${lesson.tags.join(", ")}`);
+      const input = await parseInputFile(options.input);
+      const result = await detectAndPropose(repoRoot, input);
+      if (!result) {
+        if (options.json) {
+          console.log(JSON.stringify({ detected: false }));
+        } else {
+          console.log("No learning trigger detected.");
+        }
+        return;
       }
-      console.log();
-    }
-    if (skippedCount > 0) {
-      out.warn(`${skippedCount} corrupted lesson(s) skipped.`);
-    }
-  });
-}
-function registerSearchCommand(program2) {
-  program2.command("search <query>").description("Search lessons by keyword").option("-n, --limit <number>", "Maximum results", DEFAULT_SEARCH_LIMIT).action(async function(query, options) {
-    const repoRoot = getRepoRoot();
-    const limit = parseLimit(options.limit, "limit");
-    const { verbose, quiet } = getGlobalOpts(this);
-    await syncIfNeeded(repoRoot);
-    const results = await searchKeyword(repoRoot, query, limit);
-    if (results.length === 0) {
-      console.log('No lessons match your search. Try a different query or use "list" to see all lessons.');
-      return;
-    }
-    if (!quiet) {
-      out.info(`Found ${results.length} lesson(s):
-`);
-    }
-    for (const lesson of results) {
-      console.log(`[${chalk.cyan(lesson.id)}] ${lesson.insight}`);
-      console.log(`  Trigger: ${lesson.trigger}`);
-      if (verbose && lesson.context) {
-        console.log(`  Context: ${lesson.context.tool} - ${lesson.context.intent}`);
-        console.log(`  Created: ${lesson.created}`);
+      if (options.json) {
+        console.log(JSON.stringify({ detected: true, ...result }));
+        return;
       }
-      if (lesson.tags.length > 0) {
-        console.log(`  Tags: ${lesson.tags.join(", ")}`);
+      console.log("Learning trigger detected!");
+      console.log(`  Trigger: ${result.trigger}`);
+      console.log(`  Source: ${result.source}`);
+      console.log(`  Proposed: ${result.proposedInsight}`);
+      if (options.save && options.yes) {
+        const lesson = {
+          id: generateId(result.proposedInsight),
+          type: "quick",
+          trigger: result.trigger,
+          insight: result.proposedInsight,
+          tags: [],
+          source: result.source,
+          context: { tool: "detect", intent: "auto-capture" },
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          confirmed: true,
+          // --yes confirms the lesson
+          supersedes: [],
+          related: []
+        };
+        await appendLesson(repoRoot, lesson);
+        console.log(`
+Saved as lesson: ${lesson.id}`);
       }
-      console.log();
     }
-  });
-}
-
-// src/cli/commands/rebuild.ts
-function registerRebuildCommand(program2) {
-  program2.command("rebuild").description("Rebuild SQLite index from JSONL").option("-f, --force", "Force rebuild even if unchanged").action(async (options) => {
+  );
+  program2.command("capture").description("Capture a lesson from trigger/insight or input file").option("-t, --trigger <text>", "What triggered this lesson").option("-i, --insight <text>", "The insight or lesson learned").option("--input <file>", "Path to JSON input file (alternative to trigger/insight)").option("--json", "Output result as JSON").option("-y, --yes", "Skip confirmation and save immediately").action(async function(options) {
     const repoRoot = getRepoRoot();
-    if (options.force) {
-      console.log("Forcing index rebuild...");
-      await rebuildIndex(repoRoot);
-      console.log("Index rebuilt.");
+    const { verbose } = getGlobalOpts(this);
+    let lesson;
+    if (options.input) {
+      const input = await parseInputFile(options.input);
+      const result = await detectAndPropose(repoRoot, input);
+      if (!result) {
+        options.json ? console.log(JSON.stringify({ detected: false, saved: false })) : console.log("No learning trigger detected.");
+        return;
+      }
+      lesson = createLessonFromInputFile(result, options.yes ?? false);
+    } else if (options.trigger && options.insight) {
+      lesson = createLessonFromFlags(options.trigger, options.insight, options.yes ?? false);
     } else {
-      const rebuilt = await syncIfNeeded(repoRoot);
-      if (rebuilt) {
-        console.log("Index rebuilt (JSONL changed).");
+      const msg = "Provide either --trigger and --insight, or --input file.";
+      options.json ? console.log(JSON.stringify({ error: msg, saved: false })) : out.error(msg);
+      process.exit(1);
+    }
+    if (!options.yes && !process.stdin.isTTY) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "--yes required in non-interactive mode", saved: false }));
       } else {
-        console.log("Index is up to date.");
+        out.error("--yes required in non-interactive mode");
+        console.log('Use: capture --trigger "..." --insight "..." --yes');
       }
+      process.exit(1);
+    }
+    if (options.json) {
+      if (options.yes) await appendLesson(repoRoot, lesson);
+      outputCaptureJson(lesson, options.yes ?? false);
+    } else if (options.yes) {
+      await appendLesson(repoRoot, lesson);
+      out.success(`Lesson saved: ${lesson.id}`);
+      if (verbose) console.log(`  Type: ${lesson.type} | Trigger: ${lesson.trigger}`);
+    } else {
+      outputCapturePreview(lesson);
     }
   });
 }
-
-// src/cli/commands/export.ts
-function registerExportCommand(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) => {
+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) {
     const repoRoot = getRepoRoot();
     const { lessons } = await readLessons(repoRoot);
-    let filtered = lessons;
-    if (options.since) {
-      const sinceDate = new Date(options.since);
-      if (Number.isNaN(sinceDate.getTime())) {
-        console.error(`Invalid date format: ${options.since}. Use ISO8601 format (e.g., 2024-01-15).`);
-        process.exit(1);
-      }
-      filtered = filtered.filter((lesson) => new Date(lesson.created) >= sinceDate);
+    const lesson = lessons.find((l) => l.id === id);
+    if (!lesson) {
+      out.error(`Lesson not found: ${id}`);
+      process.exit(1);
     }
-    if (options.tags) {
-      const filterTags = options.tags.split(",").map((t) => t.trim());
-      filtered = filtered.filter((lesson) => lesson.tags.some((tag) => filterTags.includes(tag)));
+    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}`);
     }
-    console.log(JSON.stringify(filtered, null, JSON_INDENT_SPACES));
   });
-}
-function registerImportCommand(program2) {
-  program2.command("import <file>").description("Import lessons from a JSONL file").action(async (file) => {
+  program2.command("validate <id>").description("Re-enable a previously invalidated lesson").action(async function(id) {
     const repoRoot = getRepoRoot();
-    let content;
-    try {
+    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 (!lesson.invalidatedAt) {
+      out.info(`Lesson ${id} is not invalidated.`);
+      return;
+    }
+    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).`);
+  });
+  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;
+    }
+    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("rebuild").description("Rebuild SQLite index from JSONL").option("-f, --force", "Force rebuild even if unchanged").action(async (options) => {
+    const repoRoot = getRepoRoot();
+    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 {
+        console.log("Index is up to date.");
+      }
+    }
+  });
+  program2.command("stats").description("Show database health and statistics").action(async () => {
+    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 {
+    }
+    try {
+      indexSize = statSync(dbPath).size;
+    } catch {
+    }
+    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 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 (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)})`);
+  });
+  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);
+    let filtered = lessons;
+    if (options.since) {
+      const sinceDate = new Date(options.since);
+      if (Number.isNaN(sinceDate.getTime())) {
+        console.error(`Invalid date format: ${options.since}. Use ISO8601 format (e.g., 2024-01-15).`);
+        process.exit(1);
+      }
+      filtered = filtered.filter((lesson) => new Date(lesson.created) >= sinceDate);
+    }
+    if (options.tags) {
+      const filterTags = options.tags.split(",").map((t) => t.trim());
+      filtered = filtered.filter((lesson) => lesson.tags.some((tag) => filterTags.includes(tag)));
+    }
+    console.log(JSON.stringify(filtered, null, JSON_INDENT_SPACES));
+  });
+  program2.command("import <file>").description("Import lessons from a JSONL file").action(async (file) => {
+    const repoRoot = getRepoRoot();
+    let content;
+    try {
       content = await readFile(file, "utf-8");
     } catch (err) {
       const code = err.code;
@@ -815,7 +1266,6 @@ function registerImportCommand(program2) {
       existingIds.add(lesson.id);
       imported++;
     }
-    await syncIfNeeded(repoRoot);
     const lessonWord = imported === 1 ? "lesson" : "lessons";
     const parts = [];
     if (skipped > 0) parts.push(`${skipped} skipped`);
@@ -826,125 +1276,304 @@ function registerImportCommand(program2) {
       console.log(`Imported ${imported} ${lessonWord}`);
     }
   });
-}
-
-// src/cli/commands/compact.ts
-function registerCompactCommand(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 SHOW_JSON_INDENT = 2;
+  program2.command("show <id>").description("Show details of a specific lesson").option("--json", "Output as JSON").action(async (id, 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 { 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);
     }
-    if (!needs && !options.force) {
-      console.log(`Compaction not needed (${tombstones} tombstones, threshold is ${TOMBSTONE_THRESHOLD}).`);
-      console.log("Use --force to compact anyway.");
-      return;
+    if (options.json) {
+      console.log(JSON.stringify(lesson, null, SHOW_JSON_INDENT));
+    } else {
+      console.log(formatLessonHuman(lesson));
     }
-    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.");
   });
-}
-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";
-var DEFAULT_MODEL_DIR = join(homedir(), ".node-llama-cpp", "models");
-function isModelAvailable() {
-  return existsSync(join(DEFAULT_MODEL_DIR, MODEL_FILENAME));
-}
-async function resolveModel(options = {}) {
-  const { cli = true } = options;
-  return resolveModelFile(MODEL_URI, { cli });
-}
-
-// src/embeddings/nomic.ts
-var embeddingContext = null;
-async function getEmbedding() {
-  if (embeddingContext) return embeddingContext;
-  const modelPath = await resolveModel({ cli: true });
-  const llama = await getLlama();
-  const model = await llama.loadModel({ modelPath });
-  embeddingContext = await model.createEmbeddingContext();
-  return embeddingContext;
-}
-async function embedText(text) {
-  const ctx = await getEmbedding();
-  const result = await ctx.getEmbeddingFor(text);
-  return Array.from(result.vector);
-}
-
-// src/search/vector.ts
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have same length");
-  }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-  if (magnitude === 0) return 0;
-  return dotProduct / magnitude;
-}
-var DEFAULT_LIMIT = 10;
-async function searchVector(repoRoot, query, options) {
-  const limit = options?.limit ?? DEFAULT_LIMIT;
-  const { lessons } = await readLessons(repoRoot);
-  if (lessons.length === 0) return [];
-  const queryVector = await embedText(query);
-  const scored = [];
-  for (const lesson of lessons) {
-    const lessonText = `${lesson.trigger} ${lesson.insight}`;
-    const hash = contentHash(lesson.trigger, lesson.insight);
-    let lessonVector = getCachedEmbedding(repoRoot, lesson.id, hash);
-    if (!lessonVector) {
-      lessonVector = await embedText(lessonText);
-      setCachedEmbedding(repoRoot, lesson.id, lessonVector, hash);
+  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 score = cosineSimilarity(queryVector, lessonVector);
-    scored.push({ lesson, score });
-  }
-  scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, limit);
-}
-
-// src/search/ranking.ts
-var RECENCY_THRESHOLD_DAYS = 30;
-var HIGH_SEVERITY_BOOST = 1.5;
-var MEDIUM_SEVERITY_BOOST = 1;
-var LOW_SEVERITY_BOOST = 0.8;
-var RECENCY_BOOST = 1.2;
-var CONFIRMATION_BOOST = 1.3;
-function severityBoost(lesson) {
-  switch (lesson.severity) {
-    case "high":
-      return HIGH_SEVERITY_BOOST;
-    case "medium":
-      return MEDIUM_SEVERITY_BOOST;
-    case "low":
-      return LOW_SEVERITY_BOOST;
-    default:
-      return MEDIUM_SEVERITY_BOOST;
-  }
-}
-function recencyBoost(lesson) {
-  const created = new Date(lesson.created);
-  const now = /* @__PURE__ */ new Date();
-  const ageMs = now.getTime() - created.getTime();
-  const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
+    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);
+    }
+    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}`);
+    }
+  });
+  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 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 {
+      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);
+      }
+    }
+  });
+}
+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;
+}
+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";
+var DEFAULT_MODEL_DIR = join(homedir(), ".node-llama-cpp", "models");
+function isModelAvailable() {
+  return existsSync(join(DEFAULT_MODEL_DIR, MODEL_FILENAME));
+}
+async function resolveModel(options = {}) {
+  const { cli = true } = options;
+  return resolveModelFile(MODEL_URI, { cli });
+}
+
+// src/embeddings/nomic.ts
+var embeddingContext = null;
+async function getEmbedding() {
+  if (embeddingContext) return embeddingContext;
+  const modelPath = await resolveModel({ cli: true });
+  const llama = await getLlama();
+  const model = await llama.loadModel({ modelPath });
+  embeddingContext = await model.createEmbeddingContext();
+  return embeddingContext;
+}
+async function embedText(text) {
+  const ctx = await getEmbedding();
+  const result = await ctx.getEmbeddingFor(text);
+  return Array.from(result.vector);
+}
+
+// src/search/vector.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have same length");
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0) return 0;
+  return dotProduct / magnitude;
+}
+var DEFAULT_LIMIT = 10;
+async function searchVector(repoRoot, query, options) {
+  const limit = options?.limit ?? DEFAULT_LIMIT;
+  const { lessons } = await readLessons(repoRoot);
+  if (lessons.length === 0) return [];
+  const queryVector = await embedText(query);
+  const scored = [];
+  for (const lesson of lessons) {
+    if (lesson.invalidatedAt) continue;
+    const lessonText = `${lesson.trigger} ${lesson.insight}`;
+    const hash = contentHash(lesson.trigger, lesson.insight);
+    let lessonVector = getCachedEmbedding(repoRoot, lesson.id, hash);
+    if (!lessonVector) {
+      lessonVector = await embedText(lessonText);
+      setCachedEmbedding(repoRoot, lesson.id, lessonVector, hash);
+    }
+    const score = cosineSimilarity(queryVector, lessonVector);
+    scored.push({ lesson, score });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+
+// src/search/ranking.ts
+var RECENCY_THRESHOLD_DAYS = 30;
+var HIGH_SEVERITY_BOOST = 1.5;
+var MEDIUM_SEVERITY_BOOST = 1;
+var LOW_SEVERITY_BOOST = 0.8;
+var RECENCY_BOOST = 1.2;
+var CONFIRMATION_BOOST = 1.3;
+function severityBoost(lesson) {
+  switch (lesson.severity) {
+    case "high":
+      return HIGH_SEVERITY_BOOST;
+    case "medium":
+      return MEDIUM_SEVERITY_BOOST;
+    case "low":
+      return LOW_SEVERITY_BOOST;
+    default:
+      return MEDIUM_SEVERITY_BOOST;
+  }
+}
+function recencyBoost(lesson) {
+  const ageDays = getLessonAgeDays(lesson);
   return ageDays <= RECENCY_THRESHOLD_DAYS ? RECENCY_BOOST : 1;
 }
 function confirmationBoost(lesson) {
@@ -960,173 +1589,6 @@ function rankLessons(lessons) {
   })).sort((a, b) => (b.finalScore ?? 0) - (a.finalScore ?? 0));
 }
 
-// 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) {
-    if (pattern.test(insight)) {
-      return { actionable: true };
-    }
-  }
-  return { actionable: false, reason: "Insight lacks clear action guidance" };
-}
-async function shouldPropose(repoRoot, insight) {
-  const specificResult = isSpecific(insight);
-  if (!specificResult.specific) {
-    return { shouldPropose: false, reason: specificResult.reason };
-  }
-  const actionableResult = isActionable(insight);
-  if (!actionableResult.actionable) {
-    return { shouldPropose: false, reason: actionableResult.reason };
-  }
-  const noveltyResult = await isNovel(repoRoot, insight);
-  if (!noveltyResult.novel) {
-    return { shouldPropose: false, reason: noveltyResult.reason };
-  }
-  return { shouldPropose: true };
-}
-
-// src/capture/triggers.ts
-var USER_CORRECTION_PATTERNS = [
-  /\bno\b[,.]?\s/i,
-  // "no, ..." or "no ..."
-  /\bwrong\b/i,
-  // "wrong"
-  /\bactually\b/i,
-  // "actually..."
-  /\bnot that\b/i,
-  // "not that"
-  /\bi meant\b/i
-  // "I meant"
-];
-function detectUserCorrection(signals) {
-  const { messages, context } = signals;
-  if (messages.length < 2) {
-    return null;
-  }
-  for (let i = 1; i < messages.length; i++) {
-    const message = messages[i];
-    if (!message) continue;
-    for (const pattern of USER_CORRECTION_PATTERNS) {
-      if (pattern.test(message)) {
-        return {
-          trigger: `User correction during ${context.intent}`,
-          correctionMessage: message,
-          context
-        };
-      }
-    }
-  }
-  return null;
-}
-function detectSelfCorrection(history) {
-  const { edits } = history;
-  if (edits.length < 3) {
-    return null;
-  }
-  for (let i = 0; i <= edits.length - 3; i++) {
-    const first = edits[i];
-    const second = edits[i + 1];
-    const third = edits[i + 2];
-    if (!first || !second || !third) continue;
-    if (first.file === second.file && second.file === third.file && first.success && !second.success && third.success) {
-      return {
-        file: first.file,
-        trigger: `Self-correction on ${first.file}`
-      };
-    }
-  }
-  return null;
-}
-function detectTestFailure(testResult) {
-  if (testResult.passed) {
-    return null;
-  }
-  const lines = testResult.output.split("\n").filter((line) => line.trim().length > 0);
-  const errorLine = lines.find((line) => /error|fail|assert/i.test(line)) ?? lines[0] ?? "";
-  return {
-    testFile: testResult.testFile,
-    errorOutput: testResult.output,
-    trigger: `Test failure in ${testResult.testFile}: ${errorLine.slice(0, 100)}`
-  };
-}
-
 // src/retrieval/session.ts
 var DEFAULT_LIMIT2 = 5;
 function isFullLesson(lesson) {
@@ -1135,7 +1597,7 @@ function isFullLesson(lesson) {
 async function loadSessionLessons(repoRoot, limit = DEFAULT_LIMIT2) {
   const { lessons: allLessons } = await readLessons(repoRoot);
   const highSeverityLessons = allLessons.filter(
-    (lesson) => isFullLesson(lesson) && lesson.severity === "high" && lesson.confirmed
+    (lesson) => isFullLesson(lesson) && lesson.severity === "high" && lesson.confirmed && !lesson.invalidatedAt
   );
   highSeverityLessons.sort((a, b) => {
     const dateA = new Date(a.created).getTime();
@@ -1172,527 +1634,238 @@ ${lessonLines.join("\n")}`;
 // src/index.ts
 var VERSION = "0.1.0";
 
-// src/cli/commands/download-model.ts
-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)}`);
+// src/commands/retrieval.ts
+async function readPlanFromStdin() {
+  const { stdin } = await import('process');
+  if (!stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of stdin) {
+      chunks.push(chunk);
     }
-  });
-}
-var SHOW_JSON_INDENT = JSON_INDENT_SPACES;
-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}`);
+    return Buffer.concat(chunks).toString("utf-8").trim();
   }
-  lines.push(`Created: ${lesson.created}`);
-  lines.push(`Confirmed: ${lesson.confirmed}`);
-  if (lesson.supersedes.length > 0) {
-    lines.push(`Supersedes: ${lesson.supersedes.join(", ")}`);
+  return void 0;
+}
+function outputCheckPlanJson(lessons) {
+  const jsonOutput = {
+    lessons: lessons.map((l) => ({
+      id: l.lesson.id,
+      insight: l.lesson.insight,
+      relevance: l.score,
+      source: l.lesson.source
+    })),
+    count: lessons.length
+  };
+  console.log(JSON.stringify(jsonOutput));
+}
+function outputCheckPlanHuman(lessons, quiet) {
+  console.log("## Lessons Check\n");
+  console.log("Relevant to your plan:\n");
+  lessons.forEach((item, i) => {
+    const num = i + 1;
+    console.log(`${num}. ${chalk.bold(`[${item.lesson.id}]`)} ${item.lesson.insight}`);
+    console.log(`   - Relevance: ${item.score.toFixed(RELEVANCE_DECIMAL_PLACES)}`);
+    console.log(`   - Source: ${item.lesson.source}`);
+    console.log();
+  });
+  if (!quiet) {
+    console.log("---");
+    console.log("Consider these lessons while implementing.");
   }
-  if (lesson.related.length > 0) {
-    lines.push(`Related: ${lesson.related.join(", ")}`);
+}
+function formatSource(source) {
+  return source.replace(/_/g, " ");
+}
+function outputSessionLessonsHuman(lessons, quiet) {
+  console.log("## Lessons from Past Sessions\n");
+  console.log("These lessons were captured from previous corrections and should inform your work:\n");
+  lessons.forEach((lesson, i) => {
+    const num = i + 1;
+    const date = lesson.created.slice(0, ISO_DATE_PREFIX_LENGTH);
+    const tagsDisplay = lesson.tags.length > 0 ? ` (${lesson.tags.join(", ")})` : "";
+    console.log(`${num}. **${lesson.insight}**${tagsDisplay}`);
+    console.log(`   Learned: ${date} via ${formatSource(lesson.source)}`);
+    console.log();
+  });
+  if (!quiet) {
+    console.log("Consider these lessons when planning and implementing tasks.");
   }
-  return lines.join("\n");
 }
-function registerShowCommand(program2) {
-  program2.command("show <id>").description("Show details of a specific lesson").option("--json", "Output as JSON").action(async (id, options) => {
+function registerRetrievalCommands(program2) {
+  program2.command("search <query>").description("Search lessons by keyword").option("-n, --limit <number>", "Maximum results", DEFAULT_SEARCH_LIMIT).action(async function(query, 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 {
+    const limit = parseLimit(options.limit, "limit");
+    const { verbose, quiet } = getGlobalOpts(this);
+    await syncIfNeeded(repoRoot);
+    const results = await searchKeyword(repoRoot, query, limit);
+    if (results.length === 0) {
+      console.log('No lessons match your search. Try a different query or use "list" to see all lessons.');
+      return;
+    }
+    if (!quiet) {
+      out.info(`Found ${results.length} lesson(s):
+`);
+    }
+    for (const lesson of results) {
+      console.log(`[${chalk.cyan(lesson.id)}] ${lesson.insight}`);
+      console.log(`  Trigger: ${lesson.trigger}`);
+      if (verbose && lesson.context) {
+        console.log(`  Context: ${lesson.context.tool} - ${lesson.context.intent}`);
+        console.log(`  Created: ${lesson.created}`);
       }
-      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`);
+      if (lesson.tags.length > 0) {
+        console.log(`  Tags: ${lesson.tags.join(", ")}`);
       }
-      process.exit(1);
-    }
-    if (options.json) {
-      console.log(JSON.stringify(lesson, null, SHOW_JSON_INDENT));
-    } else {
-      console.log(formatLessonHuman(lesson));
+      console.log();
     }
   });
-}
-var SHOW_JSON_INDENT2 = JSON_INDENT_SPACES;
-function registerUpdateCommand(program2) {
-  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("list").description("List all lessons").option("-n, --limit <number>", "Maximum results", DEFAULT_LIST_LIMIT).option("--invalidated", "Show only invalidated lessons").action(async function(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, ...)" }));
+    const limit = parseLimit(options.limit, "limit");
+    const { verbose, quiet } = getGlobalOpts(this);
+    const { lessons, skippedCount } = await readLessons(repoRoot);
+    const filteredLessons = options.invalidated ? lessons.filter((l) => l.invalidatedAt) : lessons;
+    if (filteredLessons.length === 0) {
+      if (options.invalidated) {
+        console.log("No invalidated lessons found.");
       } else {
-        out.error("No fields to update (specify at least one: --insight, --tags, --severity, ...)");
+        console.log('No lessons found. Get started with: learn "Your first lesson"');
       }
-      process.exit(1);
+      if (skippedCount > 0) {
+        out.warn(`${skippedCount} corrupted lesson(s) skipped.`);
+      }
+      return;
     }
-    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 {
+    const toShow = filteredLessons.slice(0, limit);
+    if (!quiet) {
+      const label = options.invalidated ? "invalidated lesson(s)" : "lesson(s)";
+      out.info(`Showing ${toShow.length} of ${filteredLessons.length} ${label}:
+`);
+    }
+    for (const lesson of toShow) {
+      const invalidMarker = lesson.invalidatedAt ? chalk.red("[INVALID] ") : "";
+      console.log(`[${chalk.cyan(lesson.id)}] ${invalidMarker}${lesson.insight}`);
+      if (verbose) {
+        console.log(`  Type: ${lesson.type} | Source: ${lesson.source}`);
+        console.log(`  Created: ${lesson.created}`);
+        if (lesson.context) {
+          console.log(`  Context: ${lesson.context.tool} - ${lesson.context.intent}`);
+        }
+        if (lesson.invalidatedAt) {
+          console.log(`  Invalidated: ${lesson.invalidatedAt}`);
+          if (lesson.invalidationReason) {
+            console.log(`  Reason: ${lesson.invalidationReason}`);
           }
         }
-      } 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);
+        console.log(`  Type: ${lesson.type} | Source: ${lesson.source}`);
       }
-    }
-    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}`);
+      if (lesson.tags.length > 0) {
+        console.log(`  Tags: ${lesson.tags.join(", ")}`);
       }
-      process.exit(1);
+      console.log();
     }
-    await appendLesson(repoRoot, updatedLesson);
-    await syncIfNeeded(repoRoot);
-    if (options.json) {
-      console.log(JSON.stringify(updatedLesson, null, SHOW_JSON_INDENT2));
-    } else {
-      out.success(`Updated lesson ${id}`);
+    if (skippedCount > 0) {
+      out.warn(`${skippedCount} corrupted lesson(s) skipped.`);
     }
   });
-}
-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;
-}
-function registerDeleteCommand(program2) {
-  program2.command("delete <ids...>").description("Soft delete lessons (creates tombstone)").option("--json", "Output as JSON").action(async (ids, options) => {
+  program2.command("load-session").description("Load high-severity lessons for session context").option("--json", "Output as JSON").action(async function(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 tombstone = {
-        ...lesson,
-        deleted: true,
-        deletedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await appendLesson(repoRoot, tombstone);
-      deleted.push(id);
-    }
-    if (deleted.length > 0) {
-      await syncIfNeeded(repoRoot);
-    }
+    const { quiet } = getGlobalOpts(this);
+    const lessons = await loadSessionLessons(repoRoot);
+    const { lessons: allLessons } = await readLessons(repoRoot);
+    const totalCount = allLessons.length;
     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);
-      }
+      console.log(JSON.stringify({ lessons, count: lessons.length, totalCount }));
+      return;
     }
-  });
-}
-function registerLearnCommand(program2) {
-  program2.command("learn <insight>").description("Capture a new lesson").option("-t, --trigger <text>", "What triggered this lesson").option("--tags <tags>", "Comma-separated tags", "").option("-s, --severity <level>", "Lesson severity: high, medium, low").option("-y, --yes", "Skip confirmation").action(async function(insight, options) {
-    const repoRoot = getRepoRoot();
-    const { quiet } = getGlobalOpts(this);
-    let severity;
-    if (options.severity !== void 0) {
-      const result = SeveritySchema.safeParse(options.severity);
-      if (!result.success) {
-        out.error(`Invalid severity value: "${options.severity}". Valid values are: high, medium, low`);
-        process.exit(1);
-      }
-      severity = result.data;
+    if (lessons.length === 0) {
+      console.log("No high-severity lessons found.");
+      return;
     }
-    const lessonType = severity !== void 0 ? "full" : "quick";
-    const lesson = {
-      id: generateId(insight),
-      type: lessonType,
-      trigger: options.trigger ?? "Manual capture",
-      insight,
-      tags: options.tags ? options.tags.split(",").map((t) => t.trim()) : [],
-      source: "manual",
-      context: {
-        tool: "cli",
-        intent: "manual learning"
-      },
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      confirmed: true,
-      // learn command is explicit confirmation
-      supersedes: [],
-      related: [],
-      ...severity !== void 0 && { severity }
-    };
-    await appendLesson(repoRoot, lesson);
-    out.success(`Learned: ${insight}`);
-    if (!quiet) {
-      console.log(`ID: ${chalk.dim(lesson.id)}`);
+    outputSessionLessonsHuman(lessons, quiet);
+    if (totalCount > LESSON_COUNT_WARNING_THRESHOLD) {
+      console.log("");
+      out.info(`${totalCount} lessons in index. Consider \`lna compact\` to reduce context pollution.`);
     }
-  });
-}
-async function detectAndPropose(repoRoot, input) {
-  const detected = runDetector(input);
-  if (!detected) {
-    return null;
-  }
-  const { trigger, source, proposedInsight } = detected;
-  const quality = await shouldPropose(repoRoot, proposedInsight);
-  if (!quality.shouldPropose) {
-    return null;
-  }
-  return { trigger, source, proposedInsight };
-}
-function runDetector(input) {
-  switch (input.type) {
-    case "user":
-      return detectUserCorrectionFlow(input.data);
-    case "self":
-      return detectSelfCorrectionFlow(input.data);
-    case "test":
-      return detectTestFailureFlow(input.data);
-  }
-}
-function detectUserCorrectionFlow(data) {
-  const result = detectUserCorrection(data);
-  if (!result) {
-    return null;
-  }
-  return {
-    trigger: result.trigger,
-    source: "user_correction",
-    proposedInsight: result.correctionMessage
-  };
-}
-function detectSelfCorrectionFlow(data) {
-  const result = detectSelfCorrection(data);
-  if (!result) {
-    return null;
-  }
-  return {
-    trigger: result.trigger,
-    source: "self_correction",
-    // Self-corrections need context to form useful insights
-    proposedInsight: `Check ${result.file} for common errors before editing`
-  };
-}
-function detectTestFailureFlow(data) {
-  const result = detectTestFailure(data);
-  if (!result) {
-    return null;
-  }
-  return {
-    trigger: result.trigger,
-    source: "test_failure",
-    proposedInsight: result.errorOutput
-  };
-}
-var VALID_TYPES = /* @__PURE__ */ new Set(["user", "self", "test"]);
-async function parseInputFile(filePath) {
-  const content = await fs.readFile(filePath, "utf-8");
-  const data = JSON.parse(content);
-  if (!VALID_TYPES.has(data.type)) {
-    throw new Error(`Invalid detection type: ${data.type}. Must be one of: user, self, test`);
-  }
-  return data;
-}
-
-// src/cli/commands/detect.ts
-function registerDetectCommand(program2) {
-  program2.command("detect").description("Detect learning triggers from input").requiredOption("--input <file>", "Path to JSON input file").option("--save", "Save proposed lesson (requires --yes)").option("-y, --yes", "Confirm save (required with --save)").option("--json", "Output result as JSON").action(
-    async (options) => {
-      const repoRoot = getRepoRoot();
-      if (options.save && !options.yes) {
-        if (options.json) {
-          console.log(JSON.stringify({ error: "--save requires --yes flag for confirmation" }));
-        } else {
-          out.error("--save requires --yes flag for confirmation");
-          console.log("Use: detect --input <file> --save --yes");
-        }
-        process.exit(1);
-      }
-      const input = await parseInputFile(options.input);
-      const result = await detectAndPropose(repoRoot, input);
-      if (!result) {
-        if (options.json) {
-          console.log(JSON.stringify({ detected: false }));
-        } else {
-          console.log("No learning trigger detected.");
-        }
-        return;
-      }
-      if (options.json) {
-        console.log(JSON.stringify({ detected: true, ...result }));
-        return;
-      }
-      console.log("Learning trigger detected!");
-      console.log(`  Trigger: ${result.trigger}`);
-      console.log(`  Source: ${result.source}`);
-      console.log(`  Proposed: ${result.proposedInsight}`);
-      if (options.save && options.yes) {
-        const lesson = {
-          id: generateId(result.proposedInsight),
-          type: "quick",
-          trigger: result.trigger,
-          insight: result.proposedInsight,
-          tags: [],
-          source: result.source,
-          context: { tool: "detect", intent: "auto-capture" },
-          created: (/* @__PURE__ */ new Date()).toISOString(),
-          confirmed: true,
-          // --yes confirms the lesson
-          supersedes: [],
-          related: []
-        };
-        await appendLesson(repoRoot, lesson);
-        console.log(`
-Saved as lesson: ${lesson.id}`);
-      }
+    const oldLessons = lessons.filter((l) => getLessonAgeDays(l) > AGE_FLAG_THRESHOLD_DAYS);
+    if (oldLessons.length > 0) {
+      console.log("");
+      out.warn(`${oldLessons.length} lesson(s) are over ${AGE_FLAG_THRESHOLD_DAYS} days old. Review for continued validity.`);
     }
-  );
-}
-
-// src/cli/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 createLessonFromInputFile(result, confirmed) {
-  return {
-    id: generateId(result.proposedInsight),
-    type: "quick",
-    trigger: result.trigger,
-    insight: result.proposedInsight,
-    tags: [],
-    source: result.source,
-    context: { tool: "capture", intent: "auto-capture" },
-    created: (/* @__PURE__ */ new Date()).toISOString(),
-    confirmed,
-    supersedes: [],
-    related: []
-  };
-}
-function registerCaptureCommand(program2) {
-  program2.command("capture").description("Capture a lesson from trigger/insight or input file").option("-t, --trigger <text>", "What triggered this lesson").option("-i, --insight <text>", "The insight or lesson learned").option("--input <file>", "Path to JSON input file (alternative to trigger/insight)").option("--json", "Output result as JSON").option("-y, --yes", "Skip confirmation and save immediately").action(async function(options) {
+  });
+  program2.command("check-plan").description("Check plan against relevant lessons").option("--plan <text>", "Plan text to check").option("--json", "Output as JSON").option("-n, --limit <number>", "Maximum results", DEFAULT_CHECK_PLAN_LIMIT).action(async function(options) {
     const repoRoot = getRepoRoot();
-    const { verbose } = getGlobalOpts(this);
-    let lesson;
-    if (options.input) {
-      const input = await parseInputFile(options.input);
-      const result = await detectAndPropose(repoRoot, input);
-      if (!result) {
-        options.json ? console.log(JSON.stringify({ detected: false, saved: false })) : console.log("No learning trigger detected.");
-        return;
-      }
-      lesson = createLessonFromInputFile(result, options.yes ?? false);
-    } else if (options.trigger && options.insight) {
-      lesson = createLessonFromFlags(options.trigger, options.insight, options.yes ?? false);
-    } else {
-      const msg = "Provide either --trigger and --insight, or --input file.";
-      options.json ? console.log(JSON.stringify({ error: msg, saved: false })) : out.error(msg);
+    const limit = parseLimit(options.limit, "limit");
+    const { quiet } = getGlobalOpts(this);
+    const planText = options.plan ?? await readPlanFromStdin();
+    if (!planText) {
+      out.error("No plan provided. Use --plan <text> or pipe text to stdin.");
       process.exit(1);
     }
-    if (!options.yes && !process.stdin.isTTY) {
+    if (!isModelAvailable()) {
       if (options.json) {
-        console.log(JSON.stringify({ error: "--yes required in non-interactive mode", saved: false }));
+        console.log(JSON.stringify({
+          error: "Embedding model not available",
+          action: "Run: npx learning-agent download-model"
+        }));
       } else {
-        out.error("--yes required in non-interactive mode");
-        console.log('Use: capture --trigger "..." --insight "..." --yes');
+        out.error("Embedding model not available");
+        console.log("");
+        console.log("Run: npx learning-agent download-model");
       }
       process.exit(1);
     }
-    if (options.json) {
-      if (options.yes) await appendLesson(repoRoot, lesson);
-      outputCaptureJson(lesson, options.yes ?? false);
-    } else if (options.yes) {
-      await appendLesson(repoRoot, lesson);
-      out.success(`Lesson saved: ${lesson.id}`);
-      if (verbose) console.log(`  Type: ${lesson.type} | Trigger: ${lesson.trigger}`);
-    } else {
-      outputCapturePreview(lesson);
+    try {
+      const result = await retrieveForPlan(repoRoot, planText, limit);
+      if (options.json) {
+        outputCheckPlanJson(result.lessons);
+        return;
+      }
+      if (result.lessons.length === 0) {
+        console.log("No relevant lessons found for this plan.");
+        return;
+      }
+      outputCheckPlanHuman(result.lessons, quiet);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      if (options.json) {
+        console.log(JSON.stringify({ error: message }));
+      } else {
+        out.error(`Failed to check plan: ${message}`);
+      }
+      process.exit(1);
     }
   });
 }
-var LEARNING_AGENT_SECTION_HEADER = "## Learning Agent Integration";
-var HOOK_FILE_MODE = 493;
-var LEARNING_AGENT_HOOK_BLOCK = `
-# Learning Agent pre-commit hook (appended)
-npx lna hooks run pre-commit
+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`;
+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
 `;
+var CLAUDE_HOOK_MARKER = "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"
+    }
+  ]
+};
+var HOOK_MARKER = "# Learning Agent pre-commit hook";
+var LEARNING_AGENT_SECTION_HEADER = "## Learning Agent Integration";
 var AGENTS_MD_TEMPLATE = `
 ## Learning Agent Integration
 
 This project uses learning-agent for session memory.
 
-### \u26A0\uFE0F IMPORTANT: Never Edit JSONL Directly
-
-**DO NOT** manually edit \`.claude/lessons/index.jsonl\`.
-
-Always use CLI commands:
-
-\`\`\`bash
-npx lna learn "insight" --severity high    # Create lesson
-npx lna update <id> --insight "new text"   # Update lesson
-npx lna delete <id>                        # Delete lesson
-npx lna list                               # List all lessons
-\`\`\`
-
-Manual edits will:
-- **Break SQLite sync** - Index becomes stale, search fails
-- **Bypass schema validation** - Invalid data corrupts the database
-- **Cause silent failures** - Lessons won't load at session start
-
 ### Retrieval Points
 
 - **Session start**: High-severity lessons loaded automatically
@@ -1703,7 +1876,7 @@ Manual edits will:
 **BEFORE implementing any plan**, run:
 
 \`\`\`bash
-npx lna check-plan --plan "your plan description" --json
+npx learning-agent check-plan --plan "your plan description" --json
 \`\`\`
 
 Display results as a **Lessons Check** section after your plan:
@@ -1739,14 +1912,14 @@ 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 lna capture --trigger "..." --insight "..." --yes\`
+4. **Capture**: \`npx learning-agent capture --trigger "..." --insight "..." --yes\`
 
 ### CLI Commands
 
 \`\`\`bash
-npx lna load-session --json  # Session start
-npx lna check-plan --plan "..." --json  # Before implementing
-npx lna capture --trigger "..." --insight "..." --yes
+npx learning-agent load-session --json  # Session start
+npx learning-agent check-plan --plan "..." --json  # Before implementing
+npx learning-agent capture --trigger "..." --insight "..." --yes
 \`\`\`
 
 See [AGENTS.md](https://github.com/Nathandela/learning_agent/blob/main/AGENTS.md) for full documentation.
@@ -1779,6 +1952,7 @@ async function updateAgentsMd(repoRoot) {
   await writeFile(agentsPath, newContent, "utf-8");
   return true;
 }
+var HOOK_FILE_MODE = 493;
 function hasLearningAgentHook(content) {
   return content.includes(HOOK_MARKER);
 }
@@ -1799,6 +1973,10 @@ 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;
@@ -1859,8 +2037,57 @@ async function installPreCommitHook(repoRoot) {
   chmodSync(hookPath, HOOK_FILE_MODE);
   return true;
 }
-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) {
+function getClaudeSettingsPath(global) {
+  if (global) {
+    return join(homedir(), ".claude", "settings.json");
+  }
+  const repoRoot = getRepoRoot();
+  return join(repoRoot, ".claude", "settings.json");
+}
+async function readClaudeSettings(settingsPath) {
+  if (!existsSync(settingsPath)) {
+    return {};
+  }
+  const content = await readFile(settingsPath, "utf-8");
+  return JSON.parse(content);
+}
+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));
+  });
+}
+function addLearningAgentHook(settings) {
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  const hooks = settings.hooks;
+  if (!hooks.SessionStart) {
+    hooks.SessionStart = [];
+  }
+  hooks.SessionStart.push(CLAUDE_HOOK_CONFIG);
+}
+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 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);
+}
+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) {
     const repoRoot = getRepoRoot();
     const { quiet } = getGlobalOpts(this);
     await createLessonsDirectory(repoRoot);
@@ -1874,28 +2101,12 @@ function registerInitCommand(program2) {
     if (!options.skipHooks) {
       hooksInstalled = await installPreCommitHook(repoRoot);
     }
-    let claudeHooksInstalled = false;
-    let claudeHooksError = null;
-    if (!options.skipClaude) {
-      try {
-        const settingsPath = getClaudeSettingsPath(false);
-        const settings = await readClaudeSettings(settingsPath);
-        if (!hasClaudeHook(settings)) {
-          addLearningAgentHook(settings);
-          await writeClaudeSettings(settingsPath, settings);
-          claudeHooksInstalled = true;
-        }
-      } catch (err) {
-        claudeHooksError = err instanceof Error ? err.message : "Unknown error";
-      }
-    }
     if (options.json) {
       console.log(JSON.stringify({
         initialized: true,
         lessonsDir,
         agentsMd: agentsMdUpdated,
-        hooks: hooksInstalled,
-        claudeHooks: claudeHooksInstalled
+        hooks: hooksInstalled
       }));
     } else if (!quiet) {
       out.success("Learning agent initialized");
@@ -1914,21 +2125,8 @@ function registerInitCommand(program2) {
       } else {
         console.log("  Git hooks: Already installed or not a git repo");
       }
-      if (claudeHooksInstalled) {
-        console.log("  Claude Code hooks: Installed to .claude/settings.json");
-      } else if (options.skipClaude) {
-        console.log("  Claude Code hooks: Skipped (--skip-claude)");
-      } else if (claudeHooksError) {
-        console.log(`  Claude Code hooks: Error - ${claudeHooksError}`);
-      } else {
-        console.log("  Claude Code hooks: Already installed");
-      }
     }
   });
-}
-
-// src/cli/commands/hooks.ts
-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") {
@@ -1946,8 +2144,6 @@ function registerHooksCommand(program2) {
       process.exit(1);
     }
   });
-}
-function registerSetupCommand(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("--dry-run", "Show what would change without writing").option("--json", "Output as JSON").action(async (options) => {
     const settingsPath = getClaudeSettingsPath(options.global ?? false);
@@ -2048,150 +2244,44 @@ function registerSetupCommand(program2) {
       }
     }
   });
-}
-
-// src/cli/commands/load-session.ts
-function formatSource(source) {
-  return source.replace(/_/g, " ");
-}
-function outputSessionLessonsHuman(lessons, quiet) {
-  console.log("## Lessons from Past Sessions\n");
-  if (!quiet) {
-    console.log("These lessons were captured from previous corrections and should inform your work:\n");
-  }
-  for (let i = 0; i < lessons.length; i++) {
-    const lesson = lessons[i];
-    const tags = lesson.tags.length > 0 ? ` (${lesson.tags.join(", ")})` : "";
-    console.log(`${i + 1}. **${lesson.insight}**${tags}`);
-    console.log(`   Learned: ${lesson.created.slice(0, ISO_DATE_PREFIX_LENGTH)} via ${formatSource(lesson.source)}`);
-    console.log();
-  }
-  if (!quiet) {
-    console.log("Consider these lessons when planning and implementing tasks.");
-  }
-}
-function registerLoadSessionCommand(program2) {
-  program2.command("load-session").description("Load high-severity lessons for session context").option("--json", "Output as JSON").action(async function(options) {
-    const repoRoot = getRepoRoot();
-    const { quiet } = getGlobalOpts(this);
-    const lessons = await loadSessionLessons(repoRoot);
-    if (options.json) {
-      console.log(JSON.stringify({ lessons, count: lessons.length }));
-      return;
-    }
-    if (lessons.length === 0) {
-      console.log("No high-severity lessons found.");
-      return;
-    }
-    outputSessionLessonsHuman(lessons, quiet);
-  });
-}
-async function readPlanFromStdin() {
-  const { stdin } = await import('process');
-  if (!stdin.isTTY) {
-    const chunks = [];
-    for await (const chunk of stdin) {
-      chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString("utf-8").trim();
-  }
-  return void 0;
-}
-function outputCheckPlanJson(lessons) {
-  const jsonOutput = {
-    lessons: lessons.map((l) => ({
-      id: l.lesson.id,
-      insight: l.lesson.insight,
-      relevance: l.score,
-      source: l.lesson.source
-    })),
-    count: lessons.length
-  };
-  console.log(JSON.stringify(jsonOutput));
-}
-function outputCheckPlanHuman(lessons, quiet) {
-  console.log("## Lessons Check\n");
-  console.log("Relevant to your plan:\n");
-  lessons.forEach((item, i) => {
-    const num = i + 1;
-    console.log(`${num}. ${chalk.bold(`[${item.lesson.id}]`)} ${item.lesson.insight}`);
-    console.log(`   - Relevance: ${item.score.toFixed(RELEVANCE_DECIMAL_PLACES)}`);
-    console.log(`   - Source: ${item.lesson.source}`);
-    console.log();
-  });
-  if (!quiet) {
-    console.log("---");
-    console.log("Consider these lessons while implementing.");
-  }
-}
-function registerCheckPlanCommand(program2) {
-  program2.command("check-plan").description("Check plan against relevant lessons").option("--plan <text>", "Plan text to check").option("--json", "Output as JSON").option("-n, --limit <number>", "Maximum results", DEFAULT_CHECK_PLAN_LIMIT).action(async function(options) {
-    const repoRoot = getRepoRoot();
-    const limit = parseLimit(options.limit, "limit");
-    const { quiet } = getGlobalOpts(this);
-    const planText = options.plan ?? await readPlanFromStdin();
-    if (!planText) {
-      out.error("No plan provided. Use --plan <text> or pipe text to stdin.");
-      process.exit(1);
-    }
-    if (!isModelAvailable()) {
+  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({
-          error: "Embedding model not available",
-          action: "Run: npx lna download-model"
-        }));
+        console.log(JSON.stringify({ success: true, path: modelPath2, size: size2, alreadyExisted: true }));
       } else {
-        out.error("Embedding model not available");
-        console.log("");
-        console.log("Run: npx lna download-model");
+        console.log("Model already exists.");
+        console.log(`Path: ${modelPath2}`);
+        console.log(`Size: ${formatBytes(size2)}`);
       }
-      process.exit(1);
+      return;
     }
-    try {
-      const result = await retrieveForPlan(repoRoot, planText, limit);
-      if (options.json) {
-        outputCheckPlanJson(result.lessons);
-        return;
-      }
-      if (result.lessons.length === 0) {
-        console.log("No relevant lessons found for this plan.");
-        return;
-      }
-      outputCheckPlanHuman(result.lessons, quiet);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Unknown error";
-      if (options.json) {
-        console.log(JSON.stringify({ error: message }));
-      } else {
-        out.error(`Failed to check plan: ${message}`);
-      }
-      process.exit(1);
+    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/cli.ts
 var program = new Command();
-program.name("learning-agent").description("Learning system for Claude Code session memory").version(VERSION).option("-v, --verbose", "Verbose output").option("-q, --quiet", "Minimal output");
-registerInitCommand(program);
-registerLearnCommand(program);
-registerCaptureCommand(program);
-registerDetectCommand(program);
-registerListCommand(program);
-registerSearchCommand(program);
-registerShowCommand(program);
-registerUpdateCommand(program);
-registerDeleteCommand(program);
-registerLoadSessionCommand(program);
-registerCheckPlanCommand(program);
-registerStatsCommand(program);
-registerRebuildCommand(program);
-registerCompactCommand(program);
-registerExportCommand(program);
-registerImportCommand(program);
-registerDownloadModelCommand(program);
-registerSetupCommand(program);
-registerHooksCommand(program);
+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);
+registerCaptureCommands(program);
+registerRetrievalCommands(program);
+registerManagementCommands(program);
+registerSetupCommands(program);
 program.parse();
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map