@colbymchenry/cmem 0.2.37 → 0.5.2

package/dist/cli.js

@@ -1,194 +1,9 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/commands/install.ts
-var install_exports = {};
-__export(install_exports, {
-  installCommand: () => installCommand,
-  statusCommand: () => statusCommand,
-  uninstallCommand: () => uninstallCommand
-});
-import chalk9 from "chalk";
-import { writeFileSync, unlinkSync as unlinkSync2, existsSync as existsSync10, mkdirSync as mkdirSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join6, dirname as dirname6 } from "path";
-import { execSync as execSync2 } from "child_process";
-function getCmemPath() {
-  try {
-    const result = execSync2("which cmem", { encoding: "utf-8" }).trim();
-    return result;
-  } catch {
-    return "/usr/local/bin/cmem";
-  }
-}
-function getNodeBinDir() {
-  try {
-    const nodePath = execSync2("which node", { encoding: "utf-8" }).trim();
-    return dirname6(nodePath);
-  } catch {
-    return "/usr/local/bin";
-  }
-}
-function generatePlist(cmemPath) {
-  const nodeBinDir = getNodeBinDir();
-  const pathValue = `${nodeBinDir}:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin`;
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>com.cmem.watch</string>
-
-    <key>ProgramArguments</key>
-    <array>
-        <string>${cmemPath}</string>
-        <string>watch</string>
-    </array>
-
-    <key>RunAtLoad</key>
-    <true/>
-
-    <key>KeepAlive</key>
-    <true/>
-
-    <key>StandardOutPath</key>
-    <string>${homedir2()}/.cmem/watch.log</string>
-
-    <key>StandardErrorPath</key>
-    <string>${homedir2()}/.cmem/watch.error.log</string>
-
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>${pathValue}</string>
-    </dict>
-</dict>
-</plist>`;
-}
-async function installCommand() {
-  const platform = process.platform;
-  if (platform !== "darwin") {
-    console.log(chalk9.yellow("Auto-install is currently only supported on macOS."));
-    console.log(chalk9.dim("\nFor Linux, create a systemd service:"));
-    console.log(chalk9.dim("  ~/.config/systemd/user/cmem-watch.service"));
-    console.log(chalk9.dim("\nFor manual background run:"));
-    console.log(chalk9.dim("  nohup cmem watch > ~/.cmem/watch.log 2>&1 &"));
-    return;
-  }
-  console.log(chalk9.cyan("Installing cmem watch daemon...\n"));
-  if (!existsSync10(LAUNCH_AGENTS_DIR)) {
-    mkdirSync2(LAUNCH_AGENTS_DIR, { recursive: true });
-  }
-  const cmemDir = join6(homedir2(), ".cmem");
-  if (!existsSync10(cmemDir)) {
-    mkdirSync2(cmemDir, { recursive: true });
-  }
-  const cmemPath = getCmemPath();
-  console.log(chalk9.dim(`Using cmem at: ${cmemPath}`));
-  if (existsSync10(PLIST_PATH)) {
-    console.log(chalk9.yellow("LaunchAgent already exists. Unloading first..."));
-    try {
-      execSync2(`launchctl unload "${PLIST_PATH}"`, { stdio: "ignore" });
-    } catch {
-    }
-  }
-  const plistContent = generatePlist(cmemPath);
-  writeFileSync(PLIST_PATH, plistContent);
-  console.log(chalk9.green(`\u2713 Created ${PLIST_PATH}`));
-  try {
-    execSync2(`launchctl load "${PLIST_PATH}"`);
-    console.log(chalk9.green("\u2713 LaunchAgent loaded"));
-  } catch (err) {
-    console.log(chalk9.red("Failed to load LaunchAgent:"), err);
-    return;
-  }
-  console.log(chalk9.green("\n\u2713 cmem watch daemon installed and running!"));
-  console.log(chalk9.dim("\nThe daemon will:"));
-  console.log(chalk9.dim("  \u2022 Start automatically on login"));
-  console.log(chalk9.dim("  \u2022 Restart if it crashes"));
-  console.log(chalk9.dim(`  \u2022 Log to ~/.cmem/watch.log`));
-  console.log(chalk9.dim("\nCommands:"));
-  console.log(chalk9.dim("  cmem uninstall     Stop and remove the daemon"));
-  console.log(chalk9.dim("  cmem status        Check daemon status"));
-}
-async function uninstallCommand() {
-  const platform = process.platform;
-  if (platform !== "darwin") {
-    console.log(chalk9.yellow("Auto-uninstall is currently only supported on macOS."));
-    return;
-  }
-  console.log(chalk9.cyan("Uninstalling cmem watch daemon...\n"));
-  if (!existsSync10(PLIST_PATH)) {
-    console.log(chalk9.yellow("LaunchAgent not found. Nothing to uninstall."));
-    return;
-  }
-  try {
-    execSync2(`launchctl unload "${PLIST_PATH}"`);
-    console.log(chalk9.green("\u2713 LaunchAgent unloaded"));
-  } catch {
-    console.log(chalk9.yellow("LaunchAgent was not loaded"));
-  }
-  try {
-    unlinkSync2(PLIST_PATH);
-    console.log(chalk9.green(`\u2713 Removed ${PLIST_PATH}`));
-  } catch (err) {
-    console.log(chalk9.red("Failed to remove plist:"), err);
-    return;
-  }
-  console.log(chalk9.green("\n\u2713 cmem watch daemon uninstalled"));
-}
-async function statusCommand() {
-  const platform = process.platform;
-  if (platform !== "darwin") {
-    console.log(chalk9.yellow("Status check is currently only supported on macOS."));
-    return;
-  }
-  console.log(chalk9.cyan("cmem watch daemon status\n"));
-  if (!existsSync10(PLIST_PATH)) {
-    console.log(chalk9.yellow("Status: Not installed"));
-    console.log(chalk9.dim("Run: cmem install"));
-    return;
-  }
-  try {
-    const result = execSync2(`launchctl list | grep com.cmem.watch`, {
-      encoding: "utf-8"
-    });
-    const parts = result.trim().split(/\s+/);
-    const pid = parts[0];
-    const exitCode = parts[1];
-    if (pid && pid !== "-") {
-      console.log(chalk9.green(`Status: Running (PID ${pid})`));
-    } else if (exitCode === "0") {
-      console.log(chalk9.yellow("Status: Stopped (exit code 0)"));
-    } else {
-      console.log(chalk9.red(`Status: Crashed (exit code ${exitCode})`));
-      console.log(chalk9.dim("Check ~/.cmem/watch.error.log for details"));
-    }
-  } catch {
-    console.log(chalk9.yellow("Status: Not running"));
-    console.log(chalk9.dim("The daemon is installed but not currently running."));
-    console.log(chalk9.dim("It will start on next login, or run: launchctl load ~/Library/LaunchAgents/com.cmem.watch.plist"));
-  }
-  console.log(chalk9.dim(`
-Plist: ${PLIST_PATH}`));
-  console.log(chalk9.dim("Logs:  ~/.cmem/watch.log"));
-}
-var LAUNCH_AGENTS_DIR, PLIST_NAME, PLIST_PATH;
-var init_install = __esm({
-  "src/commands/install.ts"() {
-    "use strict";
-    LAUNCH_AGENTS_DIR = join6(homedir2(), "Library", "LaunchAgents");
-    PLIST_NAME = "com.cmem.watch.plist";
-    PLIST_PATH = join6(LAUNCH_AGENTS_DIR, PLIST_NAME);
-  }
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
 // src/cli.ts
@@ -197,7 +12,7 @@ import { render } from "ink";
 import React2 from "react";
 import { existsSync as existsSync12, readFileSync as readFileSync4 } from "fs";
 import { join as join8, dirname as dirname8 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { spawn as spawn2 } from "child_process";
 
 // src/ui/App.tsx
@@ -583,6 +398,88 @@ function initSchema(database) {
   database.exec(`
     CREATE INDEX IF NOT EXISTS idx_favorites_type ON favorites(type);
   `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS lessons (
+      id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      category TEXT NOT NULL CHECK (category IN (
+        'architecture_decision', 'anti_pattern', 'bug_pattern',
+        'project_convention', 'dependency_knowledge', 'domain_knowledge',
+        'workflow', 'other'
+      )),
+      title TEXT NOT NULL,
+      trigger_context TEXT NOT NULL,
+      insight TEXT NOT NULL,
+      reasoning TEXT,
+      confidence REAL DEFAULT 0.5,
+      times_applied INTEGER DEFAULT 0,
+      times_validated INTEGER DEFAULT 0,
+      times_rejected INTEGER DEFAULT 0,
+      source_session_id TEXT,
+      source_type TEXT DEFAULT 'synthesized',
+      archived INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now')),
+      last_applied_at TEXT
+    );
+  `);
+  database.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS lesson_embeddings USING vec0(
+      lesson_id TEXT PRIMARY KEY,
+      embedding FLOAT[${EMBEDDING_DIMENSIONS}]
+    );
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS lesson_feedback (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      lesson_id TEXT NOT NULL,
+      session_id TEXT,
+      feedback_type TEXT NOT NULL CHECK (feedback_type IN (
+        'validated', 'rejected', 'modified'
+      )),
+      comment TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (lesson_id) REFERENCES lessons(id) ON DELETE CASCADE
+    );
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS synthesis_queue (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL UNIQUE,
+      project_path TEXT NOT NULL,
+      queued_at TEXT DEFAULT (datetime('now')),
+      status TEXT DEFAULT 'pending',
+      processed_at TEXT,
+      lessons_created INTEGER DEFAULT 0,
+      error TEXT
+    );
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS session_injections (
+      session_id TEXT NOT NULL,
+      lesson_id TEXT NOT NULL,
+      injected_at TEXT DEFAULT (datetime('now')),
+      PRIMARY KEY (session_id, lesson_id)
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_lessons_project ON lessons(project_path);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_lessons_category ON lessons(category);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_lessons_confidence ON lessons(confidence DESC);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_lessons_archived ON lessons(archived);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_synthesis_queue_status ON synthesis_queue(status);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_session_injections_session ON session_injections(session_id);
+  `);
   runMigrations(database);
 }
 function runMigrations(database) {
@@ -3214,6 +3111,558 @@ function isClaudeCliAvailable() {
   return getClaudePath() !== null;
 }
 
+// src/db/lessons.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function mapLessonRow(row) {
+  return {
+    id: row.id,
+    projectPath: row.project_path,
+    category: row.category,
+    title: row.title,
+    triggerContext: row.trigger_context,
+    insight: row.insight,
+    reasoning: row.reasoning ?? void 0,
+    confidence: row.confidence,
+    timesApplied: row.times_applied,
+    timesValidated: row.times_validated,
+    timesRejected: row.times_rejected,
+    sourceSessionId: row.source_session_id ?? void 0,
+    sourceType: row.source_type,
+    archived: row.archived === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    lastAppliedAt: row.last_applied_at ?? void 0
+  };
+}
+function createLesson(input) {
+  const db2 = getDatabase();
+  const id = randomUUID2();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare(`
+    INSERT INTO lessons (
+      id, project_path, category, title, trigger_context, insight,
+      reasoning, confidence, source_session_id, source_type,
+      created_at, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    input.projectPath,
+    input.category,
+    input.title,
+    input.triggerContext,
+    input.insight,
+    input.reasoning ?? null,
+    input.confidence ?? 0.5,
+    input.sourceSessionId ?? null,
+    input.sourceType ?? "synthesized",
+    now,
+    now
+  );
+  return getLesson(id);
+}
+function updateLesson(id, updates) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const fields = ["updated_at = ?"];
+  const values = [now];
+  if (updates.category !== void 0) {
+    fields.push("category = ?");
+    values.push(updates.category);
+  }
+  if (updates.title !== void 0) {
+    fields.push("title = ?");
+    values.push(updates.title);
+  }
+  if (updates.triggerContext !== void 0) {
+    fields.push("trigger_context = ?");
+    values.push(updates.triggerContext);
+  }
+  if (updates.insight !== void 0) {
+    fields.push("insight = ?");
+    values.push(updates.insight);
+  }
+  if (updates.reasoning !== void 0) {
+    fields.push("reasoning = ?");
+    values.push(updates.reasoning);
+  }
+  if (updates.confidence !== void 0) {
+    fields.push("confidence = ?");
+    values.push(updates.confidence);
+  }
+  if (updates.archived !== void 0) {
+    fields.push("archived = ?");
+    values.push(updates.archived ? 1 : 0);
+  }
+  values.push(id);
+  db2.prepare(`
+    UPDATE lessons SET ${fields.join(", ")} WHERE id = ?
+  `).run(...values);
+  return getLesson(id);
+}
+function deleteLesson(id) {
+  const db2 = getDatabase();
+  const transaction = db2.transaction(() => {
+    db2.prepare("DELETE FROM lesson_embeddings WHERE lesson_id = ?").run(id);
+    db2.prepare("DELETE FROM lesson_feedback WHERE lesson_id = ?").run(id);
+    const result = db2.prepare("DELETE FROM lessons WHERE id = ?").run(id);
+    return result.changes > 0;
+  });
+  return transaction();
+}
+function archiveLesson(id) {
+  const db2 = getDatabase();
+  db2.prepare(`
+    UPDATE lessons SET archived = 1, updated_at = ? WHERE id = ?
+  `).run((/* @__PURE__ */ new Date()).toISOString(), id);
+}
+function unarchiveLesson(id) {
+  const db2 = getDatabase();
+  db2.prepare(`
+    UPDATE lessons SET archived = 0, updated_at = ? WHERE id = ?
+  `).run((/* @__PURE__ */ new Date()).toISOString(), id);
+}
+function getLesson(id) {
+  const db2 = getDatabase();
+  const row = db2.prepare(`
+    SELECT * FROM lessons WHERE id = ?
+  `).get(id);
+  return row ? mapLessonRow(row) : null;
+}
+function getLessonsByProject(projectPath, options = {}) {
+  const db2 = getDatabase();
+  let query = "SELECT * FROM lessons WHERE project_path = ?";
+  const params = [projectPath];
+  if (options.category) {
+    query += " AND category = ?";
+    params.push(options.category);
+  }
+  if (options.archived !== void 0) {
+    query += " AND archived = ?";
+    params.push(options.archived ? 1 : 0);
+  } else {
+    query += " AND archived = 0";
+  }
+  if (options.minConfidence !== void 0) {
+    query += " AND confidence >= ?";
+    params.push(options.minConfidence);
+  }
+  query += " ORDER BY confidence DESC, times_applied DESC";
+  if (options.limit) {
+    query += " LIMIT ?";
+    params.push(options.limit);
+  }
+  const rows = db2.prepare(query).all(...params);
+  return rows.map(mapLessonRow);
+}
+function getCoreLessons(projectPath, limit = 3) {
+  const db2 = getDatabase();
+  const rows = db2.prepare(`
+    SELECT * FROM lessons
+    WHERE project_path = ?
+      AND archived = 0
+      AND confidence >= 0.7
+    ORDER BY
+      times_validated DESC,
+      confidence DESC,
+      times_applied DESC
+    LIMIT ?
+  `).all(projectPath, limit);
+  return rows.map(mapLessonRow);
+}
+function getAllLessons(options = {}) {
+  const db2 = getDatabase();
+  let query = "SELECT * FROM lessons WHERE 1=1";
+  const params = [];
+  if (options.category) {
+    query += " AND category = ?";
+    params.push(options.category);
+  }
+  if (options.archived !== void 0) {
+    query += " AND archived = ?";
+    params.push(options.archived ? 1 : 0);
+  }
+  if (options.minConfidence !== void 0) {
+    query += " AND confidence >= ?";
+    params.push(options.minConfidence);
+  }
+  query += " ORDER BY updated_at DESC";
+  if (options.limit) {
+    query += " LIMIT ?";
+    params.push(options.limit);
+  }
+  const rows = db2.prepare(query).all(...params);
+  return rows.map(mapLessonRow);
+}
+function recordLessonApplication(id) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare(`
+    UPDATE lessons
+    SET times_applied = times_applied + 1,
+        last_applied_at = ?,
+        updated_at = ?
+    WHERE id = ?
+  `).run(now, now, id);
+}
+function recordLessonValidation(id, sessionId, comment) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const transaction = db2.transaction(() => {
+    db2.prepare(`
+      UPDATE lessons
+      SET times_validated = times_validated + 1, updated_at = ?
+      WHERE id = ?
+    `).run(now, id);
+    db2.prepare(`
+      INSERT INTO lesson_feedback (lesson_id, session_id, feedback_type, comment)
+      VALUES (?, ?, 'validated', ?)
+    `).run(id, sessionId ?? null, comment ?? null);
+  });
+  transaction();
+}
+function recordLessonRejection(id, sessionId, comment) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const transaction = db2.transaction(() => {
+    db2.prepare(`
+      UPDATE lessons
+      SET times_rejected = times_rejected + 1, updated_at = ?
+      WHERE id = ?
+    `).run(now, id);
+    db2.prepare(`
+      INSERT INTO lesson_feedback (lesson_id, session_id, feedback_type, comment)
+      VALUES (?, ?, 'rejected', ?)
+    `).run(id, sessionId ?? null, comment ?? null);
+  });
+  transaction();
+}
+function storeLessonEmbedding(lessonId, embedding) {
+  const db2 = getDatabase();
+  db2.prepare("DELETE FROM lesson_embeddings WHERE lesson_id = ?").run(lessonId);
+  db2.prepare(`
+    INSERT INTO lesson_embeddings (lesson_id, embedding)
+    VALUES (?, ?)
+  `).run(lessonId, JSON.stringify(embedding));
+}
+function searchLessonsByEmbedding(embedding, projectPath, limit = 5) {
+  return searchLessonsByEmbeddingWithDistance(embedding, projectPath, limit).map((r) => r.lesson);
+}
+function searchLessonsByEmbeddingWithDistance(embedding, projectPath, limit = 5) {
+  const db2 = getDatabase();
+  const rows = db2.prepare(`
+    SELECT
+      l.*,
+      le.distance
+    FROM lesson_embeddings le
+    JOIN lessons l ON l.id = le.lesson_id
+    WHERE l.project_path = ?
+      AND l.archived = 0
+      AND le.embedding MATCH ?
+    ORDER BY le.distance ASC
+    LIMIT ?
+  `).all(projectPath, JSON.stringify(embedding), limit);
+  return rows.map((row) => ({
+    lesson: mapLessonRow(row),
+    distance: row.distance
+  }));
+}
+function getPendingSynthesis(limit = 5) {
+  const db2 = getDatabase();
+  const rows = db2.prepare(`
+    SELECT
+      id,
+      session_id as sessionId,
+      project_path as projectPath,
+      queued_at as queuedAt,
+      status,
+      processed_at as processedAt,
+      lessons_created as lessonsCreated,
+      error
+    FROM synthesis_queue
+    WHERE status = 'pending'
+    ORDER BY queued_at ASC
+    LIMIT ?
+  `).all(limit);
+  return rows;
+}
+function markSynthesisProcessing(id) {
+  const db2 = getDatabase();
+  db2.prepare(`
+    UPDATE synthesis_queue SET status = 'processing' WHERE id = ?
+  `).run(id);
+}
+function markSynthesisComplete(id, lessonsCreated) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare(`
+    UPDATE synthesis_queue
+    SET status = 'completed', processed_at = ?, lessons_created = ?
+    WHERE id = ?
+  `).run(now, lessonsCreated, id);
+}
+function markSynthesisFailed(id, error) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare(`
+    UPDATE synthesis_queue
+    SET status = 'failed', processed_at = ?, error = ?
+    WHERE id = ?
+  `).run(now, error, id);
+}
+function getSynthesisStats() {
+  const db2 = getDatabase();
+  const pending = db2.prepare(`
+    SELECT COUNT(*) as count FROM synthesis_queue WHERE status = 'pending'
+  `).get().count;
+  const processing = db2.prepare(`
+    SELECT COUNT(*) as count FROM synthesis_queue WHERE status = 'processing'
+  `).get().count;
+  const completed = db2.prepare(`
+    SELECT COUNT(*) as count FROM synthesis_queue WHERE status = 'completed'
+  `).get().count;
+  const failed = db2.prepare(`
+    SELECT COUNT(*) as count FROM synthesis_queue WHERE status = 'failed'
+  `).get().count;
+  const totalLessonsCreated = db2.prepare(`
+    SELECT COALESCE(SUM(lessons_created), 0) as total FROM synthesis_queue WHERE status = 'completed'
+  `).get().total;
+  return { pending, processing, completed, failed, totalLessonsCreated };
+}
+function getLessonStats() {
+  const db2 = getDatabase();
+  const totalLessons = db2.prepare(`
+    SELECT COUNT(*) as count FROM lessons
+  `).get().count;
+  const activeLessons = db2.prepare(`
+    SELECT COUNT(*) as count FROM lessons WHERE archived = 0
+  `).get().count;
+  const archivedLessons = totalLessons - activeLessons;
+  const categoryRows = db2.prepare(`
+    SELECT category, COUNT(*) as count
+    FROM lessons
+    WHERE archived = 0
+    GROUP BY category
+  `).all();
+  const byCategory = {
+    architecture_decision: 0,
+    anti_pattern: 0,
+    bug_pattern: 0,
+    project_convention: 0,
+    dependency_knowledge: 0,
+    domain_knowledge: 0,
+    workflow: 0,
+    other: 0
+  };
+  for (const row of categoryRows) {
+    byCategory[row.category] = row.count;
+  }
+  const avgConfidence = db2.prepare(`
+    SELECT COALESCE(AVG(confidence), 0) as avg FROM lessons WHERE archived = 0
+  `).get().avg;
+  return {
+    totalLessons,
+    activeLessons,
+    archivedLessons,
+    byCategory,
+    avgConfidence
+  };
+}
+function getQueueStatus() {
+  return getSynthesisStats();
+}
+function cleanupOldInjections(daysOld = 7) {
+  const db2 = getDatabase();
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - daysOld);
+  const result = db2.prepare(`
+    DELETE FROM session_injections WHERE injected_at < ?
+  `).run(cutoff.toISOString());
+  return result.changes;
+}
+function getDistinctProjects() {
+  const db2 = getDatabase();
+  const rows = db2.prepare(`
+    SELECT DISTINCT project_path
+    FROM lessons
+    WHERE project_path IS NOT NULL AND project_path != ''
+    ORDER BY project_path ASC
+  `).all();
+  return rows.map((row) => row.project_path);
+}
+
+// src/learning/LessonManager.ts
+var VALIDATION_BOOST = 0.1;
+var REJECTION_PENALTY = 0.2;
+var MIN_CONFIDENCE = 0;
+var MAX_CONFIDENCE = 1;
+var AUTO_ARCHIVE_THRESHOLD = 0.1;
+var DECAY_RATE = 0.05;
+var LessonManager = class {
+  /**
+   * Create a new lesson and generate its embedding
+   */
+  async create(input) {
+    const lesson = createLesson(input);
+    try {
+      const embeddingText = this.buildEmbeddingText(lesson);
+      const embedding = await getEmbedding(embeddingText);
+      storeLessonEmbedding(lesson.id, embedding);
+    } catch {
+    }
+    return lesson;
+  }
+  /**
+   * Update a lesson
+   */
+  update(id, updates) {
+    return updateLesson(id, updates);
+  }
+  /**
+   * Update a lesson and regenerate its embedding
+   */
+  async updateWithEmbedding(id, updates) {
+    const lesson = updateLesson(id, updates);
+    if (lesson) {
+      if (updates.title || updates.triggerContext || updates.insight) {
+        try {
+          const embeddingText = this.buildEmbeddingText(lesson);
+          const embedding = await getEmbedding(embeddingText);
+          storeLessonEmbedding(lesson.id, embedding);
+        } catch {
+        }
+      }
+    }
+    return lesson;
+  }
+  /**
+   * Delete a lesson permanently
+   */
+  delete(id) {
+    return deleteLesson(id);
+  }
+  /**
+   * Archive a lesson (soft delete)
+   */
+  archive(id) {
+    archiveLesson(id);
+  }
+  /**
+   * Unarchive a lesson
+   */
+  unarchive(id) {
+    unarchiveLesson(id);
+  }
+  /**
+   * Get a lesson by ID
+   */
+  get(id) {
+    return getLesson(id);
+  }
+  /**
+   * Get lessons for a project
+   */
+  getByProject(projectPath, options) {
+    return getLessonsByProject(projectPath, options);
+  }
+  /**
+   * Get core lessons (high confidence, well-validated)
+   */
+  getCore(projectPath, limit) {
+    return getCoreLessons(projectPath, limit);
+  }
+  /**
+   * Get all lessons
+   */
+  getAll(options) {
+    return getAllLessons(options);
+  }
+  /**
+   * Record that a lesson was applied (shown to user)
+   */
+  recordApplication(id) {
+    recordLessonApplication(id);
+  }
+  /**
+   * Record validation feedback - boosts confidence
+   */
+  recordValidation(id, sessionId, comment) {
+    recordLessonValidation(id, sessionId, comment);
+    const lesson = getLesson(id);
+    if (lesson) {
+      const newConfidence = Math.min(MAX_CONFIDENCE, lesson.confidence + VALIDATION_BOOST);
+      updateLesson(id, { confidence: newConfidence });
+    }
+  }
+  /**
+   * Record rejection feedback - reduces confidence
+   * Auto-archives if confidence drops too low
+   */
+  recordRejection(id, sessionId, comment) {
+    recordLessonRejection(id, sessionId, comment);
+    const lesson = getLesson(id);
+    if (lesson) {
+      const newConfidence = Math.max(MIN_CONFIDENCE, lesson.confidence - REJECTION_PENALTY);
+      if (newConfidence < AUTO_ARCHIVE_THRESHOLD) {
+        archiveLesson(id);
+      } else {
+        updateLesson(id, { confidence: newConfidence });
+      }
+    }
+  }
+  /**
+   * Decay confidence of unused lessons
+   * Should be run periodically (e.g., weekly)
+   */
+  decayUnusedLessons(daysThreshold = 30) {
+    const lessons = getAllLessons({ archived: false });
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysThreshold);
+    let decayedCount = 0;
+    for (const lesson of lessons) {
+      const lastUsed = lesson.lastAppliedAt ? new Date(lesson.lastAppliedAt) : new Date(lesson.createdAt);
+      if (lastUsed < cutoffDate) {
+        const newConfidence = Math.max(MIN_CONFIDENCE, lesson.confidence - DECAY_RATE);
+        if (newConfidence < AUTO_ARCHIVE_THRESHOLD) {
+          archiveLesson(lesson.id);
+        } else {
+          updateLesson(lesson.id, { confidence: newConfidence });
+        }
+        decayedCount++;
+      }
+    }
+    return decayedCount;
+  }
+  /**
+   * Build text for embedding generation
+   */
+  buildEmbeddingText(lesson) {
+    const parts = [
+      `Title: ${lesson.title}`,
+      `Category: ${lesson.category}`,
+      `When to apply: ${lesson.triggerContext}`,
+      `Insight: ${lesson.insight}`
+    ];
+    if (lesson.reasoning) {
+      parts.push(`Reasoning: ${lesson.reasoning}`);
+    }
+    return parts.join("\n\n");
+  }
+};
+var lessonManager = new LessonManager();
+
+// src/learning/types.ts
+var VALID_CATEGORIES = [
+  "architecture_decision",
+  "anti_pattern",
+  "bug_pattern",
+  "project_convention",
+  "dependency_knowledge",
+  "domain_knowledge",
+  "workflow",
+  "other"
+];
+
 // src/mcp/server.ts
 function createMcpServer() {
   const server = new Server(
@@ -3323,29 +3772,187 @@ function createMcpServer() {
             },
             required: ["query"]
           }
-        }
-      ]
-    };
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-      switch (name) {
-        case "search_sessions":
-          return await handleSearchSessions(args);
-        case "list_sessions":
-          return await handleListSessions(args);
-        case "get_session":
-          return await handleGetSession(
-            args
-          );
-        case "get_session_context":
-          return await handleGetSessionContext(
-            args
-          );
-        case "search_and_summarize":
-          return await handleSearchAndSummarize(
-            args
+        },
+        // ==================== LESSON TOOLS ====================
+        {
+          name: "search_lessons",
+          description: "Search learned lessons for a project using semantic search. Returns lessons that match the query context.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "Search query describing what you want to find"
+              },
+              projectPath: {
+                type: "string",
+                description: "Project path to search lessons for (defaults to current directory)"
+              },
+              limit: {
+                type: "number",
+                description: "Maximum number of results (default: 5)"
+              }
+            },
+            required: ["query"]
+          }
+        },
+        {
+          name: "get_lesson",
+          description: "Get details of a specific learned lesson by ID.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              lessonId: {
+                type: "string",
+                description: "The lesson ID to retrieve"
+              }
+            },
+            required: ["lessonId"]
+          }
+        },
+        {
+          name: "save_lesson",
+          description: "Manually save a new lesson. Use this when you learn something important about a project that should be remembered.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              projectPath: {
+                type: "string",
+                description: "Project path this lesson applies to"
+              },
+              category: {
+                type: "string",
+                enum: VALID_CATEGORIES,
+                description: "Category of the lesson"
+              },
+              title: {
+                type: "string",
+                description: "Short title (max 60 chars)"
+              },
+              triggerContext: {
+                type: "string",
+                description: "When this lesson should be surfaced"
+              },
+              insight: {
+                type: "string",
+                description: "The actual knowledge (specific, actionable)"
+              },
+              reasoning: {
+                type: "string",
+                description: "Why this is true (optional)"
+              }
+            },
+            required: ["projectPath", "category", "title", "triggerContext", "insight"]
+          }
+        },
+        {
+          name: "validate_lesson",
+          description: "Mark a lesson as helpful/correct. Boosts its confidence score.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              lessonId: {
+                type: "string",
+                description: "The lesson ID to validate"
+              },
+              comment: {
+                type: "string",
+                description: "Optional comment about why it was helpful"
+              }
+            },
+            required: ["lessonId"]
+          }
+        },
+        {
+          name: "reject_lesson",
+          description: "Mark a lesson as unhelpful/incorrect. Reduces its confidence score.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              lessonId: {
+                type: "string",
+                description: "The lesson ID to reject"
+              },
+              comment: {
+                type: "string",
+                description: "Optional comment about why it was wrong"
+              }
+            },
+            required: ["lessonId"]
+          }
+        },
+        {
+          name: "list_lessons",
+          description: "List all lessons for a project.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              projectPath: {
+                type: "string",
+                description: "Project path to list lessons for"
+              },
+              category: {
+                type: "string",
+                enum: VALID_CATEGORIES,
+                description: "Filter by category"
+              },
+              includeArchived: {
+                type: "boolean",
+                description: "Include archived lessons (default: false)"
+              },
+              limit: {
+                type: "number",
+                description: "Maximum number of results (default: 20)"
+              }
+            },
+            required: ["projectPath"]
+          }
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      switch (name) {
+        case "search_sessions":
+          return await handleSearchSessions(args);
+        case "list_sessions":
+          return await handleListSessions(args);
+        case "get_session":
+          return await handleGetSession(
+            args
+          );
+        case "get_session_context":
+          return await handleGetSessionContext(
+            args
+          );
+        case "search_and_summarize":
+          return await handleSearchAndSummarize(
+            args
+          );
+        // ==================== LESSON HANDLERS ====================
+        case "search_lessons":
+          return await handleSearchLessons(
+            args
+          );
+        case "get_lesson":
+          return await handleGetLesson(args);
+        case "save_lesson":
+          return await handleSaveLesson(
+            args
+          );
+        case "validate_lesson":
+          return await handleValidateLesson(
+            args
+          );
+        case "reject_lesson":
+          return await handleRejectLesson(
+            args
+          );
+        case "list_lessons":
+          return await handleListLessons(
+            args
           );
         default:
           return {
@@ -3609,6 +4216,210 @@ No sessions found.`;
   }
   return lines.join("\n");
 }
+async function handleSearchLessons(args) {
+  const { query, projectPath = process.cwd(), limit = 5 } = args;
+  if (!isReady()) {
+    try {
+      await initializeEmbeddings();
+    } catch {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Embedding model not available. Cannot perform semantic search."
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  const queryEmbedding = await getEmbedding(query);
+  const lessons = searchLessonsByEmbedding(queryEmbedding, projectPath, limit);
+  if (lessons.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No lessons found for query: "${query}" in project: ${projectPath}`
+        }
+      ]
+    };
+  }
+  const lines = [`# Lessons matching "${query}"`, ""];
+  for (const lesson of lessons) {
+    lines.push(`### ${lesson.title}`);
+    lines.push(`- **ID:** \`${lesson.id.slice(0, 8)}\``);
+    lines.push(`- **Category:** ${lesson.category}`);
+    lines.push(`- **Confidence:** ${(lesson.confidence * 100).toFixed(0)}%`);
+    lines.push(`- **When to apply:** ${lesson.triggerContext}`);
+    lines.push("");
+    lines.push(`**Insight:** ${lesson.insight}`);
+    if (lesson.reasoning) {
+      lines.push(`**Reasoning:** ${lesson.reasoning}`);
+    }
+    lines.push("");
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+async function handleGetLesson(args) {
+  const { lessonId } = args;
+  const lesson = getLesson(lessonId);
+  if (!lesson) {
+    return {
+      content: [{ type: "text", text: `Lesson not found: ${lessonId}` }],
+      isError: true
+    };
+  }
+  const lines = [
+    `# ${lesson.title}`,
+    "",
+    `**ID:** ${lesson.id}`,
+    `**Category:** ${lesson.category}`,
+    `**Project:** ${lesson.projectPath}`,
+    `**Confidence:** ${(lesson.confidence * 100).toFixed(0)}%`,
+    `**Times Applied:** ${lesson.timesApplied}`,
+    `**Times Validated:** ${lesson.timesValidated}`,
+    `**Times Rejected:** ${lesson.timesRejected}`,
+    `**Archived:** ${lesson.archived ? "Yes" : "No"}`,
+    `**Created:** ${lesson.createdAt}`,
+    `**Updated:** ${lesson.updatedAt}`,
+    "",
+    "## When to Apply",
+    lesson.triggerContext,
+    "",
+    "## Insight",
+    lesson.insight
+  ];
+  if (lesson.reasoning) {
+    lines.push("", "## Reasoning", lesson.reasoning);
+  }
+  if (lesson.sourceSessionId) {
+    lines.push("", `**Source Session:** ${lesson.sourceSessionId}`);
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+async function handleSaveLesson(args) {
+  const input = {
+    projectPath: args.projectPath,
+    category: args.category,
+    title: args.title,
+    triggerContext: args.triggerContext,
+    insight: args.insight,
+    reasoning: args.reasoning,
+    sourceType: "manual",
+    confidence: 0.6
+    // Manual lessons start with moderate confidence
+  };
+  try {
+    const lesson = await lessonManager.create(input);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Lesson saved successfully!
+
+**ID:** ${lesson.id}
+**Title:** ${lesson.title}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to save lesson: ${String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function handleValidateLesson(args) {
+  const { lessonId, comment } = args;
+  const lesson = getLesson(lessonId);
+  if (!lesson) {
+    return {
+      content: [{ type: "text", text: `Lesson not found: ${lessonId}` }],
+      isError: true
+    };
+  }
+  lessonManager.recordValidation(lessonId, void 0, comment);
+  const updated = getLesson(lessonId);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Lesson validated: "${lesson.title}"
+New confidence: ${((updated?.confidence ?? 0) * 100).toFixed(0)}%`
+      }
+    ]
+  };
+}
+async function handleRejectLesson(args) {
+  const { lessonId, comment } = args;
+  const lesson = getLesson(lessonId);
+  if (!lesson) {
+    return {
+      content: [{ type: "text", text: `Lesson not found: ${lessonId}` }],
+      isError: true
+    };
+  }
+  lessonManager.recordRejection(lessonId, void 0, comment);
+  const updated = getLesson(lessonId);
+  let message = `Lesson rejected: "${lesson.title}"`;
+  if (updated?.archived) {
+    message += "\nLesson has been auto-archived due to low confidence.";
+  } else if (updated) {
+    message += `
+New confidence: ${(updated.confidence * 100).toFixed(0)}%`;
+  }
+  return {
+    content: [{ type: "text", text: message }]
+  };
+}
+async function handleListLessons(args) {
+  const { projectPath, category, includeArchived = false, limit = 20 } = args;
+  const lessons = getLessonsByProject(projectPath, {
+    category,
+    archived: includeArchived ? void 0 : false,
+    limit
+  });
+  if (lessons.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No lessons found for project: ${projectPath}`
+        }
+      ]
+    };
+  }
+  const stats = getLessonStats();
+  const lines = [
+    `# Lessons for ${projectPath}`,
+    "",
+    `**Total:** ${lessons.length} | **Active:** ${stats.activeLessons} | **Archived:** ${stats.archivedLessons}`,
+    ""
+  ];
+  for (const lesson of lessons) {
+    const archived = lesson.archived ? " [ARCHIVED]" : "";
+    lines.push(`### ${lesson.title}${archived}`);
+    lines.push(`- **ID:** \`${lesson.id.slice(0, 8)}\``);
+    lines.push(`- **Category:** ${lesson.category}`);
+    lines.push(`- **Confidence:** ${(lesson.confidence * 100).toFixed(0)}%`);
+    lines.push(`- **Applied:** ${lesson.timesApplied} | **Validated:** ${lesson.timesValidated} | **Rejected:** ${lesson.timesRejected}`);
+    lines.push(`- **Insight:** ${truncate(lesson.insight, 100)}`);
+    lines.push("");
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
 async function startMcpServer() {
   const server = createMcpServer();
   const transport = new StdioServerTransport();
@@ -3626,29 +4437,32 @@ async function mcpCommand() {
   }
 }
 
-// src/cli.ts
-init_install();
-
 // src/commands/setup.ts
-import chalk10 from "chalk";
-import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join7, dirname as dirname7, basename as basename7 } from "path";
+import chalk9 from "chalk";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync10, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join6, dirname as dirname6, basename as basename7 } from "path";
 import { fileURLToPath } from "url";
 import { createInterface } from "readline";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname7(__filename);
-var CLAUDE_JSON_PATH = join7(homedir3(), ".claude.json");
-var CLAUDE_SETTINGS_PATH = join7(homedir3(), ".claude", "settings.json");
-var CMEM_DIR2 = join7(homedir3(), ".cmem");
-var SETUP_MARKER = join7(CMEM_DIR2, ".setup-complete");
+var __dirname = dirname6(__filename);
+var CLAUDE_JSON_PATH = join6(homedir2(), ".claude.json");
+var CLAUDE_SETTINGS_PATH = join6(homedir2(), ".claude", "settings.json");
+var CMEM_DIR2 = join6(homedir2(), ".cmem");
+var SETUP_MARKER = join6(CMEM_DIR2, ".setup-complete");
 var CMEM_PERMISSIONS = [
   "mcp__cmem__search_sessions",
   "mcp__cmem__list_sessions",
   "mcp__cmem__get_session",
   "mcp__cmem__get_session_context",
-  "mcp__cmem__search_and_summarize"
+  "mcp__cmem__search_and_summarize",
+  "mcp__cmem__search_lessons",
+  "mcp__cmem__get_lesson",
+  "mcp__cmem__save_lesson",
+  "mcp__cmem__validate_lesson",
+  "mcp__cmem__reject_lesson",
+  "mcp__cmem__list_lessons"
 ];
 var spinnerFrames2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var Spinner3 = class {
@@ -3662,24 +4476,24 @@ var Spinner3 = class {
     process.stdout.write(`  ${spinnerFrames2[0]} ${this.message}`);
     this.interval = setInterval(() => {
       this.frameIndex = (this.frameIndex + 1) % spinnerFrames2.length;
-      process.stdout.write(`\r  ${chalk10.cyan(spinnerFrames2[this.frameIndex])} ${this.message}`);
+      process.stdout.write(`\r  ${chalk9.cyan(spinnerFrames2[this.frameIndex])} ${this.message}`);
     }, 80);
   }
   update(message) {
     this.message = message;
-    process.stdout.write(`\r  ${chalk10.cyan(spinnerFrames2[this.frameIndex])} ${this.message}                    `);
+    process.stdout.write(`\r  ${chalk9.cyan(spinnerFrames2[this.frameIndex])} ${this.message}                    `);
   }
   succeed(message) {
     this.stop();
-    console.log(`\r  ${chalk10.green("\u2713")} ${message || this.message}                    `);
+    console.log(`\r  ${chalk9.green("\u2713")} ${message || this.message}                    `);
   }
   fail(message) {
     this.stop();
-    console.log(`\r  ${chalk10.red("\u2717")} ${message || this.message}                    `);
+    console.log(`\r  ${chalk9.red("\u2717")} ${message || this.message}                    `);
   }
   warn(message) {
     this.stop();
-    console.log(`\r  ${chalk10.yellow("!")} ${message || this.message}                    `);
+    console.log(`\r  ${chalk9.yellow("!")} ${message || this.message}                    `);
   }
   stop() {
     if (this.interval) {
@@ -3689,9 +4503,9 @@ var Spinner3 = class {
   }
 };
 function printBanner(version) {
-  const magenta = chalk10.magenta;
-  const cyan = chalk10.cyan;
-  const dim = chalk10.dim;
+  const magenta = chalk9.magenta;
+  const cyan = chalk9.cyan;
+  const dim = chalk9.dim;
   console.log("");
   console.log(magenta("   \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557"));
   console.log(magenta("  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551"));
@@ -3711,11 +4525,11 @@ async function promptChoice(question, options, defaultChoice = 1) {
     output: process.stdout
   });
   options.forEach((opt, i) => {
-    console.log(chalk10.dim(`  ${i + 1}) ${opt}`));
+    console.log(chalk9.dim(`  ${i + 1}) ${opt}`));
   });
   console.log("");
   return new Promise((resolve) => {
-    rl.question(chalk10.white(`  Choice [${defaultChoice}]: `), (answer) => {
+    rl.question(chalk9.white(`  Choice [${defaultChoice}]: `), (answer) => {
       rl.close();
       const num = parseInt(answer.trim(), 10);
       if (isNaN(num) || num < 1 || num > options.length) {
@@ -3733,7 +4547,7 @@ async function promptYesNo(question, defaultYes = true) {
   });
   const hint = defaultYes ? "[Y/n]" : "[y/N]";
   return new Promise((resolve) => {
-    rl.question(chalk10.white(`  ${question} ${chalk10.dim(hint)} `), (answer) => {
+    rl.question(chalk9.white(`  ${question} ${chalk9.dim(hint)} `), (answer) => {
       rl.close();
       const normalized = answer.toLowerCase().trim();
       if (normalized === "") {
@@ -3750,7 +4564,7 @@ function isRunningViaNpx() {
 }
 function isGloballyInstalled() {
   try {
-    const result = execSync3("which cmem 2>/dev/null || where cmem 2>/dev/null", {
+    const result = execSync2("which cmem 2>/dev/null || where cmem 2>/dev/null", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -3761,8 +4575,8 @@ function isGloballyInstalled() {
 }
 function getCmemVersion() {
   try {
-    const packagePath = join7(__dirname, "..", "package.json");
-    if (existsSync11(packagePath)) {
+    const packagePath = join6(__dirname, "..", "package.json");
+    if (existsSync10(packagePath)) {
       const pkg = JSON.parse(readFileSync3(packagePath, "utf-8"));
       return pkg.version || "0.1.0";
     }
@@ -3772,7 +4586,7 @@ function getCmemVersion() {
 }
 function getInstalledVersion() {
   try {
-    const result = execSync3("cmem --version 2>/dev/null", {
+    const result = execSync2("cmem --version 2>/dev/null", {
       encoding: "utf-8"
     }).trim();
     return result;
@@ -3780,49 +4594,86 @@ function getInstalledVersion() {
     return null;
   }
 }
+function getCmemDistPath() {
+  try {
+    const globalPath = execSync2("npm root -g 2>/dev/null", {
+      encoding: "utf-8"
+    }).trim();
+    const cmemGlobalPath = join6(globalPath, "@colbymchenry", "cmem", "dist");
+    if (existsSync10(cmemGlobalPath)) {
+      return cmemGlobalPath;
+    }
+    const parentDist = dirname6(__dirname);
+    if (existsSync10(join6(parentDist, "hooks"))) {
+      return parentDist;
+    }
+    return null;
+  } catch {
+    const parentDist = dirname6(__dirname);
+    if (existsSync10(parentDist)) {
+      return parentDist;
+    }
+    return null;
+  }
+}
+function cleanupOldDaemon() {
+  const plistPath = join6(homedir2(), "Library", "LaunchAgents", "com.cmem.watch.plist");
+  if (existsSync10(plistPath)) {
+    try {
+      execSync2(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "pipe" });
+    } catch {
+    }
+    try {
+      const { unlinkSync: unlinkSync2 } = __require("fs");
+      unlinkSync2(plistPath);
+    } catch {
+    }
+  }
+}
 async function setupCommand() {
   const currentVersion = getCmemVersion();
   const installedVersion = getInstalledVersion();
   const isGlobal = isGloballyInstalled();
   const isNpx = isRunningViaNpx();
   printBanner(currentVersion);
+  cleanupOldDaemon();
   if (!isGlobal || isNpx) {
-    console.log(chalk10.yellow("  Install cmem globally?"));
-    console.log(chalk10.dim("  Makes the `cmem` command available everywhere\n"));
+    console.log(chalk9.yellow("  Install cmem globally?"));
+    console.log(chalk9.dim("  Makes the `cmem` command available everywhere\n"));
     const choice = await promptChoice("", [
       "Yes - install globally via npm",
       "No - I'll use npx each time"
     ], 1);
     if (choice === 1) {
-      console.log(chalk10.dim("\n  Installing @colbymchenry/cmem globally...\n"));
+      console.log(chalk9.dim("\n  Installing @colbymchenry/cmem globally...\n"));
       try {
-        execSync3("npm install -g @colbymchenry/cmem", { stdio: "inherit" });
-        console.log(chalk10.green("\n  \u2713 Installed globally\n"));
+        execSync2("npm install -g @colbymchenry/cmem", { stdio: "inherit" });
+        console.log(chalk9.green("\n  \u2713 Installed globally\n"));
       } catch {
-        console.log(chalk10.red("\n  \u2717 Failed to install. Try: sudo npm install -g @colbymchenry/cmem\n"));
+        console.log(chalk9.red("\n  \u2717 Failed to install. Try: sudo npm install -g @colbymchenry/cmem\n"));
       }
     } else {
-      console.log(chalk10.dim("\n  Skipped. Use `npx @colbymchenry/cmem` to run.\n"));
+      console.log(chalk9.dim("\n  Skipped. Use `npx @colbymchenry/cmem` to run.\n"));
     }
   } else if (installedVersion && installedVersion !== currentVersion) {
-    console.log(chalk10.yellow(`  Update available: ${installedVersion} \u2192 ${currentVersion}`));
+    console.log(chalk9.yellow(`  Update available: ${installedVersion} \u2192 ${currentVersion}`));
     const shouldUpdate = await promptYesNo("Update to latest version?");
     if (shouldUpdate) {
-      console.log(chalk10.dim("\n  Updating @colbymchenry/cmem...\n"));
+      console.log(chalk9.dim("\n  Updating @colbymchenry/cmem...\n"));
       try {
-        execSync3("npm install -g @colbymchenry/cmem", { stdio: "inherit" });
-        console.log(chalk10.green("\n  \u2713 Updated\n"));
+        execSync2("npm install -g @colbymchenry/cmem", { stdio: "inherit" });
+        console.log(chalk9.green("\n  \u2713 Updated\n"));
       } catch {
-        console.log(chalk10.red("\n  \u2717 Failed to update\n"));
+        console.log(chalk9.red("\n  \u2717 Failed to update\n"));
       }
     } else {
       console.log("");
     }
   } else {
-    console.log(chalk10.green("  \u2713 cmem is installed globally\n"));
+    console.log(chalk9.green("  \u2713 cmem is installed globally\n"));
   }
-  console.log(chalk10.yellow("  Semantic search setup"));
-  console.log(chalk10.dim("  Enables searching conversations by meaning\n"));
+  console.log(chalk9.yellow("  Semantic search setup"));
+  console.log(chalk9.dim("  Enables searching conversations by meaning\n"));
   const modelSpinner = new Spinner3("Checking embedding model...");
   modelSpinner.start();
   const cached = isModelCached();
@@ -3843,102 +4694,88 @@ async function setupCommand() {
       modelSpinner.succeed("Embedding model ready");
     } catch (err) {
       modelSpinner.fail("Failed to download embedding model");
-      console.log(chalk10.dim(`  Error: ${err}
+      console.log(chalk9.dim(`  Error: ${err}
 `));
     }
   }
   console.log("");
-  const daemonInstalled = existsSync11(
-    join7(homedir3(), "Library", "LaunchAgents", "com.cmem.watch.plist")
-  );
-  const isUpdating = installedVersion && installedVersion !== currentVersion;
-  if (daemonInstalled && !isUpdating) {
-    console.log(chalk10.green("  \u2713 Auto-start daemon is installed"));
-    try {
-      execSync3("launchctl load ~/Library/LaunchAgents/com.cmem.watch.plist 2>/dev/null", { stdio: "ignore" });
-    } catch {
-    }
-    console.log("");
-  } else if (daemonInstalled && isUpdating && process.platform === "darwin") {
-    console.log(chalk10.yellow("  Updating daemon..."));
-    try {
-      const { installCommand: installCommand2 } = await Promise.resolve().then(() => (init_install(), install_exports));
-      await installCommand2();
-    } catch {
-      console.log(chalk10.red("  \u2717 Failed to update daemon"));
-      console.log(chalk10.dim("  Try manually: cmem install\n"));
-    }
-  } else if (process.platform === "darwin") {
-    console.log(chalk10.yellow("  Auto-start daemon?"));
-    console.log(chalk10.dim("  Syncs Claude Code sessions in the background\n"));
+  const mcpConfigured = isMcpConfigured();
+  if (mcpConfigured) {
+    console.log(chalk9.green("  \u2713 MCP server configured in Claude Code\n"));
+  } else {
+    console.log(chalk9.yellow("  Add MCP server to Claude Code?"));
+    console.log(chalk9.dim("  Lets Claude search your past conversations\n"));
     const choice = await promptChoice("", [
-      "Yes - start on login (recommended)",
-      "No - I'll run `cmem watch` manually"
+      "Yes - configure automatically (recommended)",
+      "No - I'll configure it manually"
     ], 1);
     if (choice === 1) {
-      try {
-        const { installCommand: installCommand2 } = await Promise.resolve().then(() => (init_install(), install_exports));
-        await installCommand2();
-      } catch (err) {
-        console.log(chalk10.red("  \u2717 Failed to install daemon"));
-        console.log(chalk10.dim("  Try manually: cmem install\n"));
+      const success = configureMcpServer();
+      if (success) {
+        console.log(chalk9.green("\n  \u2713 Added MCP server to ~/.claude.json"));
+        console.log(chalk9.green("  \u2713 Added permissions to ~/.claude/settings.json"));
+        console.log(chalk9.dim("  Restart Claude Code or run /mcp to connect\n"));
+      } else {
+        console.log(chalk9.red("\n  \u2717 Failed to configure MCP server\n"));
       }
     } else {
-      console.log(chalk10.dim("\n  Skipped. Run `cmem watch` when needed.\n"));
+      console.log(chalk9.dim("\n  Skipped.\n"));
     }
   }
-  const mcpConfigured = isMcpConfigured();
-  if (mcpConfigured) {
-    console.log(chalk10.green("  \u2713 MCP server configured in Claude Code\n"));
+  const hooksConfigured = areHooksConfigured();
+  if (hooksConfigured) {
+    console.log(chalk9.green("  \u2713 Learning hooks configured\n"));
   } else {
-    console.log(chalk10.yellow("  Add MCP server to Claude Code?"));
-    console.log(chalk10.dim("  Lets Claude search your past conversations\n"));
+    console.log(chalk9.yellow("  Enable automatic learning?"));
+    console.log(chalk9.dim("  Hooks sync sessions and inject knowledge automatically\n"));
     const choice = await promptChoice("", [
-      "Yes - configure automatically (recommended)",
-      "No - I'll configure it manually"
+      "Yes - enable hooks (recommended)",
+      "No - I'll manage manually"
     ], 1);
     if (choice === 1) {
-      const success = configureMcpServer();
-      if (success) {
-        console.log(chalk10.green("\n  \u2713 Added MCP server to ~/.claude.json"));
-        console.log(chalk10.green("  \u2713 Added permissions to ~/.claude/settings.json"));
-        console.log(chalk10.dim("  Restart Claude Code or run /mcp to connect\n"));
+      const result = configureHooks();
+      if (result.success) {
+        console.log(chalk9.green("\n  \u2713 Configured hooks in ~/.claude/settings.json"));
+        console.log(chalk9.dim("  \u2022 UserPromptSubmit: Injects relevant lessons"));
+        console.log(chalk9.dim("  \u2022 Stop/PreCompact: Syncs and backs up sessions\n"));
       } else {
-        console.log(chalk10.red("\n  \u2717 Failed to configure MCP server\n"));
+        console.log(chalk9.red(`
+  \u2717 Failed to configure hooks: ${result.message}`));
+        console.log(chalk9.dim("  You can configure hooks manually in ~/.claude/settings.json\n"));
       }
     } else {
-      console.log(chalk10.dim("\n  Skipped.\n"));
+      console.log(chalk9.dim("\n  Skipped. Run `cmem watch` for manual sync.\n"));
     }
   }
-  console.log(chalk10.yellow("  Initial session indexing"));
-  console.log(chalk10.dim("  Scanning and indexing your existing Claude Code conversations\n"));
+  console.log(chalk9.yellow("  Initial session indexing"));
+  console.log(chalk9.dim("  Scanning and indexing your existing Claude Code conversations\n"));
   await indexExistingSessions();
-  if (!existsSync11(CMEM_DIR2)) {
-    mkdirSync3(CMEM_DIR2, { recursive: true });
-  }
-  writeFileSync2(SETUP_MARKER, (/* @__PURE__ */ new Date()).toISOString());
-  console.log(chalk10.magenta("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
-  console.log(chalk10.green.bold("\n  \u2713 Setup complete!\n"));
-  console.log(chalk10.white("  Commands:"));
-  console.log(chalk10.dim("    cmem              Browse sessions (TUI)"));
-  console.log(chalk10.dim('    cmem search "X"   Semantic search'));
-  console.log(chalk10.dim("    cmem watch        Start sync daemon"));
-  console.log(chalk10.dim("    cmem stats        Storage statistics"));
-  console.log(chalk10.dim("    cmem --help       All commands"));
-  console.log(chalk10.white("\n  MCP Tools (available to Claude):"));
-  console.log(chalk10.dim("    search_sessions   Find past conversations"));
-  console.log(chalk10.dim("    get_session       Retrieve full history"));
-  console.log(chalk10.dim("    list_sessions     Browse recent sessions"));
-  if (process.platform === "darwin") {
-    const plistExists = existsSync11(join7(homedir3(), "Library", "LaunchAgents", "com.cmem.watch.plist"));
-    if (plistExists) {
-      console.log(chalk10.green("\n  \u{1F680} Daemon is now syncing your sessions in the background!"));
-    }
+  if (!existsSync10(CMEM_DIR2)) {
+    mkdirSync2(CMEM_DIR2, { recursive: true });
+  }
+  writeFileSync(SETUP_MARKER, (/* @__PURE__ */ new Date()).toISOString());
+  console.log(chalk9.magenta("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  console.log(chalk9.green.bold("\n  \u2713 Setup complete!\n"));
+  console.log(chalk9.white("  Commands:"));
+  console.log(chalk9.dim("    cmem              Browse sessions (TUI)"));
+  console.log(chalk9.dim('    cmem search "X"   Semantic search'));
+  console.log(chalk9.dim("    cmem synthesize   Extract lessons from sessions"));
+  console.log(chalk9.dim("    cmem stats        Storage statistics"));
+  console.log(chalk9.dim("    cmem --help       All commands"));
+  console.log(chalk9.white("\n  MCP Tools (available to Claude):"));
+  console.log(chalk9.dim("    search_sessions   Find past conversations"));
+  console.log(chalk9.dim("    search_lessons    Find project knowledge"));
+  console.log(chalk9.dim("    save_lesson       Save important insights"));
+  if (areHooksConfigured()) {
+    console.log(chalk9.green("\n  \u{1F9E0} Learning is enabled!"));
+    console.log(chalk9.dim("    \u2022 Lessons are injected before each prompt"));
+    console.log(chalk9.dim("    \u2022 Sessions sync automatically on stop/compact"));
+    console.log(chalk9.dim("    \u2022 Run `cmem synthesize` to extract lessons"));
   }
   console.log("");
 }
 function isMcpConfigured() {
-  if (!existsSync11(CLAUDE_JSON_PATH)) {
+  if (!existsSync10(CLAUDE_JSON_PATH)) {
     return false;
   }
   try {
@@ -3951,7 +4788,7 @@ function isMcpConfigured() {
 function configureMcpServer() {
   try {
     let claudeJson = {};
-    if (existsSync11(CLAUDE_JSON_PATH)) {
+    if (existsSync10(CLAUDE_JSON_PATH)) {
       try {
         claudeJson = JSON.parse(readFileSync3(CLAUDE_JSON_PATH, "utf-8"));
       } catch {
@@ -3966,13 +4803,13 @@ function configureMcpServer() {
       command: "cmem",
       args: ["mcp"]
     };
-    writeFileSync2(CLAUDE_JSON_PATH, JSON.stringify(claudeJson, null, 2) + "\n");
-    const claudeDir = dirname7(CLAUDE_SETTINGS_PATH);
-    if (!existsSync11(claudeDir)) {
-      mkdirSync3(claudeDir, { recursive: true });
+    writeFileSync(CLAUDE_JSON_PATH, JSON.stringify(claudeJson, null, 2) + "\n");
+    const claudeDir = dirname6(CLAUDE_SETTINGS_PATH);
+    if (!existsSync10(claudeDir)) {
+      mkdirSync2(claudeDir, { recursive: true });
     }
     let settings = {};
-    if (existsSync11(CLAUDE_SETTINGS_PATH)) {
+    if (existsSync10(CLAUDE_SETTINGS_PATH)) {
       try {
         settings = JSON.parse(readFileSync3(CLAUDE_SETTINGS_PATH, "utf-8"));
       } catch {
@@ -3990,16 +4827,106 @@ function configureMcpServer() {
         settings.permissions.allow.push(perm);
       }
     }
-    writeFileSync2(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+    writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
     return true;
   } catch (err) {
-    console.error(chalk10.red("Error configuring MCP:"), err);
+    console.error(chalk9.red("Error configuring MCP:"), err);
+    return false;
+  }
+}
+function configureHooks() {
+  try {
+    const distPath = getCmemDistPath();
+    if (!distPath) {
+      return { success: false, message: "Could not find cmem installation path" };
+    }
+    const consultPath = join6(distPath, "hooks", "consult.js");
+    const syncPath = join6(distPath, "hooks", "sync.js");
+    if (!existsSync10(consultPath)) {
+      return { success: false, message: `Hook file not found: ${consultPath}` };
+    }
+    const claudeDir = dirname6(CLAUDE_SETTINGS_PATH);
+    if (!existsSync10(claudeDir)) {
+      mkdirSync2(claudeDir, { recursive: true });
+    }
+    let settings = {};
+    if (existsSync10(CLAUDE_SETTINGS_PATH)) {
+      try {
+        settings = JSON.parse(readFileSync3(CLAUDE_SETTINGS_PATH, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
+    const hasCmemHook = (hookArray) => {
+      if (!hookArray) return false;
+      return hookArray.some((h) => h.hooks?.some((hk) => hk.command?.includes("cmem")));
+    };
+    if (!hasCmemHook(settings.hooks.UserPromptSubmit)) {
+      if (!settings.hooks.UserPromptSubmit) {
+        settings.hooks.UserPromptSubmit = [];
+      }
+      settings.hooks.UserPromptSubmit.push({
+        matcher: ".*",
+        hooks: [{
+          type: "command",
+          command: `node "${consultPath}"`,
+          timeout: 5e3
+        }]
+      });
+    }
+    if (!hasCmemHook(settings.hooks.Stop)) {
+      if (!settings.hooks.Stop) {
+        settings.hooks.Stop = [];
+      }
+      settings.hooks.Stop.push({
+        matcher: ".*",
+        hooks: [{
+          type: "command",
+          command: `node "${syncPath}"`
+        }]
+      });
+    }
+    if (!hasCmemHook(settings.hooks.PreCompact)) {
+      if (!settings.hooks.PreCompact) {
+        settings.hooks.PreCompact = [];
+      }
+      settings.hooks.PreCompact.push({
+        matcher: ".*",
+        hooks: [{
+          type: "command",
+          command: `node "${syncPath}"`
+        }]
+      });
+    }
+    writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+    return { success: true, message: "Hooks configured successfully" };
+  } catch (err) {
+    return { success: false, message: String(err) };
+  }
+}
+function areHooksConfigured() {
+  if (!existsSync10(CLAUDE_SETTINGS_PATH)) {
+    return false;
+  }
+  try {
+    const settings = JSON.parse(readFileSync3(CLAUDE_SETTINGS_PATH, "utf-8"));
+    const hooks = settings.hooks;
+    if (!hooks) return false;
+    const hasCmemHook = (hookArray) => {
+      if (!hookArray) return false;
+      return hookArray.some((h) => h.hooks?.some((hk) => hk.command?.includes("cmem")));
+    };
+    return hasCmemHook(hooks.UserPromptSubmit) || hasCmemHook(hooks.Stop);
+  } catch {
     return false;
   }
 }
 function shouldRunSetup() {
   const isNpx = isRunningViaNpx();
-  const setupComplete = existsSync11(SETUP_MARKER);
+  const setupComplete = existsSync10(SETUP_MARKER);
   const isGlobal = isGloballyInstalled();
   if (isNpx) return true;
   if (!isGlobal && !setupComplete) return true;
@@ -4012,13 +4939,13 @@ function shouldRunSetup() {
 }
 function findAllSessionFiles2(dir) {
   const files = [];
-  if (!existsSync11(dir)) return files;
+  if (!existsSync10(dir)) return files;
   function scanDir(currentDir, depth = 0) {
     if (depth > 10) return;
     try {
       const entries = readdirSync4(currentDir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join7(currentDir, entry.name);
+        const fullPath = join6(currentDir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "subagents") continue;
           scanDir(fullPath, depth + 1);
@@ -4078,7 +5005,7 @@ async function indexExistingSessions() {
   const totalFiles = sessionFiles.length;
   if (totalFiles === 0) {
     spinner.succeed("No Claude Code sessions found yet");
-    console.log(chalk10.dim("  Start using Claude Code, then run cmem to see your sessions\n"));
+    console.log(chalk9.dim("  Start using Claude Code, then run cmem to see your sessions\n"));
     return;
   }
   const statsBefore = getStats();
@@ -4101,60 +5028,60 @@ async function indexExistingSessions() {
   }
   spinner.succeed(`Indexed ${totalFiles} sessions (${newlyIndexed} new)`);
   const statsAfter = getStats();
-  console.log(chalk10.dim(`  ${statsAfter.sessionCount} sessions, ${statsAfter.embeddingCount} with embeddings
+  console.log(chalk9.dim(`  ${statsAfter.sessionCount} sessions, ${statsAfter.embeddingCount} with embeddings
 `));
 }
 
 // src/commands/purge.ts
-import chalk11 from "chalk";
+import chalk10 from "chalk";
 import { createInterface as createInterface2 } from "readline";
 async function purgeCommand(options) {
   const days = options.days ? parseInt(options.days, 10) : DEFAULT_PURGE_DAYS;
   if (isNaN(days) || days < 1) {
-    console.log(chalk11.red("Invalid days value. Must be a positive number."));
+    console.log(chalk10.red("Invalid days value. Must be a positive number."));
     return;
   }
   const preview = getPurgePreview(days);
   if (preview.sessionsToDelete === 0) {
-    console.log(chalk11.green("No sessions eligible for purge."));
-    console.log(chalk11.dim("(Sessions must be older than " + days + " days and not starred)"));
+    console.log(chalk10.green("No sessions eligible for purge."));
+    console.log(chalk10.dim("(Sessions must be older than " + days + " days and not starred)"));
     return;
   }
-  console.log(chalk11.bold("\nPurge Preview:"));
-  console.log(chalk11.dim("\u2500".repeat(50)));
-  console.log(`  Database size: ${chalk11.cyan(formatBytes(getDatabaseSize()))}`);
-  console.log(`  Backups size:  ${chalk11.cyan(formatBytes(getBackupsDirSize()))}`);
-  console.log(`  Total storage: ${chalk11.cyan(formatBytes(getTotalStorageSize()))}`);
+  console.log(chalk10.bold("\nPurge Preview:"));
+  console.log(chalk10.dim("\u2500".repeat(50)));
+  console.log(`  Database size: ${chalk10.cyan(formatBytes(getDatabaseSize()))}`);
+  console.log(`  Backups size:  ${chalk10.cyan(formatBytes(getBackupsDirSize()))}`);
+  console.log(`  Total storage: ${chalk10.cyan(formatBytes(getTotalStorageSize()))}`);
   console.log();
-  console.log(`  Sessions to delete: ${chalk11.yellow(preview.sessionsToDelete.toString())}`);
-  console.log(`  Messages involved:  ${chalk11.yellow(preview.messagesInvolved.toString())}`);
+  console.log(`  Sessions to delete: ${chalk10.yellow(preview.sessionsToDelete.toString())}`);
+  console.log(`  Messages involved:  ${chalk10.yellow(preview.messagesInvolved.toString())}`);
   if (preview.backupFilesToDelete > 0) {
-    console.log(`  Backup files:       ${chalk11.yellow(preview.backupFilesToDelete.toString())} (~${formatBytes(preview.backupBytesToFree)})`);
+    console.log(`  Backup files:       ${chalk10.yellow(preview.backupFilesToDelete.toString())} (~${formatBytes(preview.backupBytesToFree)})`);
   }
-  console.log(`  Date range: ${chalk11.dim(preview.oldestSessionDate)} to ${chalk11.dim(preview.newestSessionDate)}`);
-  console.log(chalk11.dim("  (Starred sessions will be preserved)"));
-  console.log(chalk11.dim("\u2500".repeat(50)));
+  console.log(`  Date range: ${chalk10.dim(preview.oldestSessionDate)} to ${chalk10.dim(preview.newestSessionDate)}`);
+  console.log(chalk10.dim("  (Starred sessions will be preserved)"));
+  console.log(chalk10.dim("\u2500".repeat(50)));
   if (options.dryRun) {
-    console.log(chalk11.cyan("\n[Dry run] No changes made."));
+    console.log(chalk10.cyan("\n[Dry run] No changes made."));
     return;
   }
   if (!options.force) {
     const confirmed = await confirm(
-      chalk11.red(`
+      chalk10.red(`
 Delete ${preview.sessionsToDelete} sessions? This cannot be undone. [y/N] `)
     );
     if (!confirmed) {
-      console.log(chalk11.dim("Cancelled."));
+      console.log(chalk10.dim("Cancelled."));
       return;
     }
   }
   const result = purgeOldSessions(days);
-  console.log(chalk11.green(`
+  console.log(chalk10.green(`
 Purged ${result.sessionsDeleted} session${result.sessionsDeleted !== 1 ? "s" : ""}.`));
   if (result.backupsDeleted > 0) {
-    console.log(chalk11.green(`Deleted ${result.backupsDeleted} backup file${result.backupsDeleted !== 1 ? "s" : ""}.`));
+    console.log(chalk10.green(`Deleted ${result.backupsDeleted} backup file${result.backupsDeleted !== 1 ? "s" : ""}.`));
   }
-  console.log(`New storage size: ${chalk11.cyan(formatBytes(getTotalStorageSize()))}`);
+  console.log(`New storage size: ${chalk10.cyan(formatBytes(getTotalStorageSize()))}`);
 }
 function confirm(prompt) {
   const rl = createInterface2({
@@ -4169,13 +5096,582 @@ function confirm(prompt) {
   });
 }
 
+// src/commands/synthesize.ts
+import chalk11 from "chalk";
+
+// src/learning/SynthesisEngine.ts
+var SIMILARITY_THRESHOLD = 0.85;
+var MAX_MESSAGES_FOR_SYNTHESIS = 50;
+var MAX_MESSAGE_LENGTH = 2e3;
+var SynthesisEngine = class {
+  /**
+   * Synthesize lessons from a session
+   */
+  async synthesize(session, messages) {
+    const result = {
+      lessonsCreated: 0,
+      lessonsSkipped: 0,
+      errors: []
+    };
+    if (!isClaudeCliAvailable()) {
+      result.errors.push("Claude CLI not available for synthesis");
+      return result;
+    }
+    if (messages.length < 3) {
+      result.errors.push("Session too short for meaningful synthesis");
+      return result;
+    }
+    try {
+      const prompt = this.buildSynthesisPrompt(session, messages);
+      const response = await runClaudePrompt(prompt, {
+        model: "haiku",
+        // Use haiku for speed and cost
+        maxTokens: 2e3
+      });
+      if (!response.success) {
+        result.errors.push(`Claude error: ${response.error}`);
+        return result;
+      }
+      const rawLessons = this.parseResponse(response.content);
+      if (rawLessons.length === 0) {
+        return result;
+      }
+      const projectPath = session.projectPath || "";
+      for (const raw of rawLessons) {
+        try {
+          const stored = await this.dedupeAndStore(raw, session, projectPath);
+          if (stored) {
+            result.lessonsCreated++;
+          } else {
+            result.lessonsSkipped++;
+          }
+        } catch (error) {
+          result.errors.push(`Failed to store lesson: ${String(error)}`);
+        }
+      }
+      return result;
+    } catch (error) {
+      result.errors.push(`Synthesis failed: ${String(error)}`);
+      return result;
+    }
+  }
+  /**
+   * Build the synthesis prompt for Claude
+   */
+  buildSynthesisPrompt(session, messages) {
+    const formattedMessages = this.formatMessages(messages);
+    return `You are analyzing a Claude Code conversation session to extract reusable lessons.
+
+## Session Information
+- Project: ${session.projectPath || "Unknown"}
+- Title: ${session.title}
+- Messages: ${messages.length}
+
+## Conversation
+${formattedMessages}
+
+## Task
+Extract reusable lessons from this conversation. Focus on:
+
+1. **Architecture Decisions** - Design choices and their rationale
+2. **Anti-Patterns** - What NOT to do and why
+3. **Bug Patterns** - Common bugs and their root causes
+4. **Project Conventions** - Code style, naming, file organization
+5. **Dependency Knowledge** - Library quirks, version issues, APIs
+6. **Domain Knowledge** - Business logic, rules, requirements
+7. **Workflows** - Processes, commands, deployment steps
+
+## Requirements
+- Only extract genuinely reusable lessons
+- Be specific and actionable, not generic
+- Include context for when the lesson applies
+- Skip trivial or one-off fixes
+- Focus on knowledge that would help future work
+
+## Output Format
+Return a JSON array of lessons. Each lesson must have:
+\`\`\`json
+[
+  {
+    "category": "architecture_decision|anti_pattern|bug_pattern|project_convention|dependency_knowledge|domain_knowledge|workflow|other",
+    "title": "Short descriptive title (max 60 chars)",
+    "trigger_context": "When this lesson should be surfaced (what kind of prompt/task)",
+    "insight": "The actual knowledge - specific and actionable",
+    "reasoning": "Why this is true or important (optional)",
+    "confidence": 0.3-0.7
+  }
+]
+\`\`\`
+
+Confidence guidelines:
+- 0.3-0.4: Observed once, might be specific to this case
+- 0.5: Reasonable general lesson
+- 0.6-0.7: Clear pattern with strong evidence
+
+Return an empty array [] if no reusable lessons can be extracted.
+
+Output only the JSON array, no other text.`;
+  }
+  /**
+   * Format messages for the prompt
+   */
+  formatMessages(messages) {
+    const relevantMessages = messages.slice(-MAX_MESSAGES_FOR_SYNTHESIS);
+    return relevantMessages.map((m) => {
+      const role = m.role === "user" ? "User" : "Assistant";
+      const content = m.content.length > MAX_MESSAGE_LENGTH ? m.content.slice(0, MAX_MESSAGE_LENGTH) + "...[truncated]" : m.content;
+      return `### ${role}
+${content}`;
+    }).join("\n\n");
+  }
+  /**
+   * Parse Claude's response into raw lessons
+   */
+  parseResponse(content) {
+    try {
+      const jsonMatch = content.match(/\[[\s\S]*\]/);
+      if (!jsonMatch) {
+        return [];
+      }
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed)) {
+        return [];
+      }
+      return parsed.filter((item) => this.isValidRawLesson(item)).map((item) => ({
+        category: item.category,
+        title: String(item.title).slice(0, 60),
+        triggerContext: String(item.trigger_context),
+        insight: String(item.insight),
+        reasoning: item.reasoning ? String(item.reasoning) : void 0,
+        confidence: Math.min(0.7, Math.max(0.3, Number(item.confidence) || 0.5))
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Validate a raw lesson object
+   */
+  isValidRawLesson(item) {
+    if (typeof item !== "object" || item === null) {
+      return false;
+    }
+    const obj = item;
+    return typeof obj.category === "string" && VALID_CATEGORIES.includes(obj.category) && typeof obj.title === "string" && obj.title.length > 0 && typeof obj.trigger_context === "string" && obj.trigger_context.length > 0 && typeof obj.insight === "string" && obj.insight.length > 0;
+  }
+  /**
+   * Check for duplicates and store if unique
+   */
+  async dedupeAndStore(raw, session, projectPath) {
+    const embeddingText = `${raw.title} ${raw.triggerContext} ${raw.insight}`;
+    try {
+      const embedding = await getEmbedding(embeddingText);
+      const similar = searchLessonsByEmbedding(embedding, projectPath, 1);
+      if (similar.length > 0 && this.isTooSimilar(similar[0], raw)) {
+        return null;
+      }
+      const input = {
+        projectPath,
+        category: raw.category,
+        title: raw.title,
+        triggerContext: raw.triggerContext,
+        insight: raw.insight,
+        reasoning: raw.reasoning,
+        confidence: raw.confidence,
+        sourceSessionId: session.id,
+        sourceType: "synthesized"
+      };
+      const lesson = await lessonManager.create(input);
+      return lesson;
+    } catch {
+      const input = {
+        projectPath,
+        category: raw.category,
+        title: raw.title,
+        triggerContext: raw.triggerContext,
+        insight: raw.insight,
+        reasoning: raw.reasoning,
+        confidence: raw.confidence,
+        sourceSessionId: session.id,
+        sourceType: "synthesized"
+      };
+      return lessonManager.create(input);
+    }
+  }
+  /**
+   * Check if a raw lesson is too similar to an existing lesson
+   */
+  isTooSimilar(existing, raw) {
+    const existingText = `${existing.title} ${existing.insight}`.toLowerCase();
+    const rawText = `${raw.title} ${raw.insight}`.toLowerCase();
+    const existingWords = new Set(existingText.split(/\s+/));
+    const rawWords = rawText.split(/\s+/);
+    let commonCount = 0;
+    for (const word of rawWords) {
+      if (existingWords.has(word)) {
+        commonCount++;
+      }
+    }
+    const similarity = commonCount / Math.max(existingWords.size, rawWords.length);
+    return similarity > SIMILARITY_THRESHOLD;
+  }
+};
+var synthesisEngine = new SynthesisEngine();
+
+// src/learning/processQueue.ts
+async function processSynthesisQueue(limit = 5) {
+  const result = {
+    processed: 0,
+    lessonsCreated: 0,
+    failed: 0,
+    errors: []
+  };
+  const pending = getPendingSynthesis(limit);
+  if (pending.length === 0) {
+    return result;
+  }
+  for (const item of pending) {
+    try {
+      markSynthesisProcessing(item.id);
+      const session = getSession(item.sessionId);
+      if (!session) {
+        markSynthesisFailed(item.id, "Session not found");
+        result.failed++;
+        result.errors.push(`Session not found: ${item.sessionId}`);
+        continue;
+      }
+      const messages = getSessionMessages(session.id);
+      if (messages.length === 0) {
+        markSynthesisFailed(item.id, "Session has no messages");
+        result.failed++;
+        continue;
+      }
+      const synthesisResult = await synthesisEngine.synthesize(session, messages);
+      if (synthesisResult.errors.length > 0) {
+        result.errors.push(...synthesisResult.errors);
+      }
+      markSynthesisComplete(item.id, synthesisResult.lessonsCreated);
+      result.processed++;
+      result.lessonsCreated += synthesisResult.lessonsCreated;
+    } catch (error) {
+      markSynthesisFailed(item.id, String(error));
+      result.failed++;
+      result.errors.push(`Failed to process ${item.sessionId}: ${String(error)}`);
+    }
+  }
+  return result;
+}
+function getQueueStatus2() {
+  return getSynthesisStats();
+}
+
+// src/commands/synthesize.ts
+async function synthesizeCommand(options) {
+  const status = getQueueStatus2();
+  const lessonStats = getLessonStats();
+  if (options.status) {
+    console.log(chalk11.cyan("Synthesis Queue Status\n"));
+    console.log(`  Pending:    ${chalk11.yellow(status.pending)}`);
+    console.log(`  Processing: ${chalk11.blue(status.processing)}`);
+    console.log(`  Completed:  ${chalk11.green(status.completed)}`);
+    console.log(`  Failed:     ${chalk11.red(status.failed)}`);
+    console.log("");
+    console.log(chalk11.cyan("Lesson Statistics\n"));
+    console.log(`  Total:    ${lessonStats.totalLessons}`);
+    console.log(`  Active:   ${lessonStats.activeLessons}`);
+    console.log(`  Archived: ${lessonStats.archivedLessons}`);
+    console.log(`  Avg Confidence: ${(lessonStats.avgConfidence * 100).toFixed(0)}%`);
+    console.log("");
+    console.log(chalk11.dim("Categories:"));
+    for (const [category, count] of Object.entries(lessonStats.byCategory)) {
+      if (count > 0) {
+        console.log(`    ${category}: ${count}`);
+      }
+    }
+    return;
+  }
+  if (status.pending === 0) {
+    console.log(chalk11.yellow("No sessions pending synthesis."));
+    console.log(chalk11.dim(`
+Total lessons: ${lessonStats.totalLessons}`));
+    return;
+  }
+  const limit = parseInt(options.limit || "5", 10);
+  console.log(chalk11.cyan("Processing synthesis queue...\n"));
+  console.log(`  Queue: ${status.pending} pending`);
+  console.log(`  Processing up to ${limit} sessions
+`);
+  const result = await processSynthesisQueue(limit);
+  console.log(chalk11.cyan("\nResults:\n"));
+  console.log(`  Processed:       ${chalk11.green(result.processed)}`);
+  console.log(`  Lessons created: ${chalk11.green(result.lessonsCreated)}`);
+  console.log(`  Failed:          ${result.failed > 0 ? chalk11.red(result.failed) : "0"}`);
+  if (result.errors.length > 0) {
+    console.log(chalk11.yellow("\nWarnings:"));
+    for (const error of result.errors.slice(0, 5)) {
+      console.log(chalk11.dim(`  - ${error}`));
+    }
+    if (result.errors.length > 5) {
+      console.log(chalk11.dim(`  ... and ${result.errors.length - 5} more`));
+    }
+  }
+  const newStats = getLessonStats();
+  const newStatus = getQueueStatus2();
+  console.log("");
+  console.log(`Remaining in queue: ${newStatus.pending}`);
+  console.log(`Total lessons: ${newStats.totalLessons}`);
+  try {
+    const cleaned = cleanupOldInjections(7);
+    if (cleaned > 0) {
+      console.log(chalk11.dim(`
+Cleaned up ${cleaned} old injection cache records`));
+    }
+  } catch {
+  }
+}
+
+// src/commands/gui.ts
+import chalk12 from "chalk";
+
+// src/api/server.ts
+import express from "express";
+import cors from "cors";
+import { join as join7, dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync11 } from "fs";
+
+// src/api/routes.ts
+import { Router } from "express";
+var apiRouter = Router();
+apiRouter.get("/lessons", (req, res) => {
+  try {
+    const {
+      projectPath,
+      category,
+      archived,
+      minConfidence,
+      limit
+    } = req.query;
+    let lessons;
+    if (projectPath) {
+      lessons = getLessonsByProject(projectPath, {
+        category,
+        archived: archived === "true",
+        minConfidence: minConfidence ? parseFloat(minConfidence) : void 0,
+        limit: limit ? parseInt(limit, 10) : void 0
+      });
+    } else {
+      lessons = getAllLessons({
+        category,
+        archived: archived === "true",
+        minConfidence: minConfidence ? parseFloat(minConfidence) : void 0,
+        limit: limit ? parseInt(limit, 10) : void 0
+      });
+    }
+    res.json(lessons);
+  } catch (error) {
+    console.error("Error fetching lessons:", error);
+    res.status(500).json({ message: "Failed to fetch lessons" });
+  }
+});
+apiRouter.get("/lessons/:id", (req, res) => {
+  try {
+    const lesson = getLesson(req.params.id);
+    if (!lesson) {
+      res.status(404).json({ message: "Lesson not found" });
+      return;
+    }
+    res.json(lesson);
+  } catch (error) {
+    console.error("Error fetching lesson:", error);
+    res.status(500).json({ message: "Failed to fetch lesson" });
+  }
+});
+apiRouter.post("/lessons", (req, res) => {
+  try {
+    const input = req.body;
+    if (!input.projectPath || !input.category || !input.title || !input.triggerContext || !input.insight) {
+      res.status(400).json({ message: "Missing required fields" });
+      return;
+    }
+    const lesson = createLesson(input);
+    res.status(201).json(lesson);
+  } catch (error) {
+    console.error("Error creating lesson:", error);
+    res.status(500).json({ message: "Failed to create lesson" });
+  }
+});
+apiRouter.put("/lessons/:id", (req, res) => {
+  try {
+    const existing = getLesson(req.params.id);
+    if (!existing) {
+      res.status(404).json({ message: "Lesson not found" });
+      return;
+    }
+    const updates = req.body;
+    const lesson = updateLesson(req.params.id, updates);
+    res.json(lesson);
+  } catch (error) {
+    console.error("Error updating lesson:", error);
+    res.status(500).json({ message: "Failed to update lesson" });
+  }
+});
+apiRouter.delete("/lessons/:id", (req, res) => {
+  try {
+    const existing = getLesson(req.params.id);
+    if (!existing) {
+      res.status(404).json({ message: "Lesson not found" });
+      return;
+    }
+    deleteLesson(req.params.id);
+    res.status(204).send();
+  } catch (error) {
+    console.error("Error deleting lesson:", error);
+    res.status(500).json({ message: "Failed to delete lesson" });
+  }
+});
+apiRouter.post("/lessons/:id/validate", (req, res) => {
+  try {
+    const existing = getLesson(req.params.id);
+    if (!existing) {
+      res.status(404).json({ message: "Lesson not found" });
+      return;
+    }
+    const { comment } = req.body;
+    recordLessonValidation(req.params.id, comment);
+    const newConfidence = Math.min(1, existing.confidence + 0.1);
+    const lesson = updateLesson(req.params.id, { confidence: newConfidence });
+    res.json(lesson);
+  } catch (error) {
+    console.error("Error validating lesson:", error);
+    res.status(500).json({ message: "Failed to validate lesson" });
+  }
+});
+apiRouter.post("/lessons/:id/reject", (req, res) => {
+  try {
+    const existing = getLesson(req.params.id);
+    if (!existing) {
+      res.status(404).json({ message: "Lesson not found" });
+      return;
+    }
+    const { comment } = req.body;
+    recordLessonRejection(req.params.id, comment);
+    const newConfidence = Math.max(0, existing.confidence - 0.2);
+    if (newConfidence < 0.1) {
+      archiveLesson(req.params.id);
+    }
+    const lesson = updateLesson(req.params.id, { confidence: newConfidence });
+    res.json(lesson);
+  } catch (error) {
+    console.error("Error rejecting lesson:", error);
+    res.status(500).json({ message: "Failed to reject lesson" });
+  }
+});
+apiRouter.post("/lessons/:id/archive", (req, res) => {
+  try {
+    const existing = getLesson(req.params.id);
+    if (!existing) {
+      res.status(404).json({ message: "Lesson not found" });
+      return;
+    }
+    archiveLesson(req.params.id);
+    const lesson = getLesson(req.params.id);
+    res.json(lesson);
+  } catch (error) {
+    console.error("Error archiving lesson:", error);
+    res.status(500).json({ message: "Failed to archive lesson" });
+  }
+});
+apiRouter.get("/stats", (_req, res) => {
+  try {
+    const lessonStats = getLessonStats();
+    const queueStatus = getQueueStatus();
+    res.json({
+      ...lessonStats,
+      synthesisQueue: queueStatus
+    });
+  } catch (error) {
+    console.error("Error fetching stats:", error);
+    res.status(500).json({ message: "Failed to fetch stats" });
+  }
+});
+apiRouter.get("/projects", (_req, res) => {
+  try {
+    const projects = getDistinctProjects();
+    res.json(projects);
+  } catch (error) {
+    console.error("Error fetching projects:", error);
+    res.status(500).json({ message: "Failed to fetch projects" });
+  }
+});
+
+// src/api/server.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname7(__filename2);
+var DEFAULT_PORT = 3848;
+async function startServer(options = {}) {
+  const port = options.port ?? DEFAULT_PORT;
+  getDatabase();
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+  app.use("/api", (_req, res, next) => {
+    res.set("Cache-Control", "no-store, no-cache, must-revalidate, private");
+    res.set("Pragma", "no-cache");
+    res.set("Expires", "0");
+    next();
+  });
+  app.use("/api", apiRouter);
+  const guiDistPath = join7(__dirname2, "../gui/dist");
+  if (existsSync11(guiDistPath)) {
+    app.use(express.static(guiDistPath));
+    app.get("/{*path}", (_req, res) => {
+      res.sendFile(join7(guiDistPath, "index.html"));
+    });
+  } else {
+    app.get("/", (_req, res) => {
+      res.json({
+        message: "CMEM API Server",
+        note: "GUI not built. Run: cd gui && npm run build",
+        endpoints: {
+          lessons: "/api/lessons",
+          stats: "/api/stats",
+          projects: "/api/projects"
+        }
+      });
+    });
+  }
+  app.listen(port, () => {
+    console.log(`CMEM GUI server running at http://localhost:${port}`);
+    if (options.open) {
+      const url = `http://localhost:${port}`;
+      const openCommand = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+      import("child_process").then(({ exec }) => {
+        exec(openCommand);
+      });
+    }
+  });
+}
+
+// src/commands/gui.ts
+async function guiCommand(options) {
+  const port = options.port ? parseInt(options.port, 10) : 3848;
+  console.log(chalk12.cyan("Starting CMEM GUI..."));
+  console.log("");
+  await startServer({
+    port,
+    open: options.open !== false
+    // Default to opening browser
+  });
+}
+
 // src/cli.ts
 var sessionToResume = null;
 function getVersion() {
   try {
-    const __filename2 = fileURLToPath2(import.meta.url);
-    const __dirname2 = dirname8(__filename2);
-    const packagePath = join8(__dirname2, "..", "package.json");
+    const __filename3 = fileURLToPath3(import.meta.url);
+    const __dirname3 = dirname8(__filename3);
+    const packagePath = join8(__dirname3, "..", "package.json");
     if (existsSync12(packagePath)) {
       const pkg = JSON.parse(readFileSync4(packagePath, "utf-8"));
       return pkg.version || "0.1.0";
@@ -4248,14 +5744,11 @@ program.command("watch").description("Watch for Claude Code session changes and
 program.command("mcp").description("Start MCP server for Claude Code integration").action(async () => {
   await mcpCommand();
 });
-program.command("install").description("Install watch daemon to run at system startup (macOS)").action(async () => {
-  await installCommand();
-});
-program.command("uninstall").description("Remove watch daemon from system startup").action(async () => {
-  await uninstallCommand();
+program.command("synthesize").description("Extract lessons from sessions in the synthesis queue").option("-n, --limit <n>", "Maximum number of sessions to process", "5").option("-s, --status", "Show queue status only").action(async (options) => {
+  await synthesizeCommand(options);
 });
-program.command("status").description("Check watch daemon status").action(async () => {
-  await statusCommand();
+program.command("gui").description("Launch the web-based lesson management interface").option("-p, --port <port>", "Port to run server on", "3848").option("--no-open", "Do not open browser automatically").action(async (options) => {
+  await guiCommand(options);
 });
 program.parse();
 //# sourceMappingURL=cli.js.map