learning-agent 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import chalk from 'chalk';
 import { Command } from 'commander';
-import { statSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
+import { existsSync, statSync, chmodSync, mkdirSync } from 'fs';
 import * as fs from 'fs/promises';
-import { mkdir, appendFile, readFile, writeFile, rename } from 'fs/promises';
+import { mkdir, writeFile, readFile, rename, appendFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
 import { createHash } from 'crypto';
 import Database from 'better-sqlite3';
 import { z } from 'zod';
-import 'node-llama-cpp';
-import { homedir } from 'os';
+import { getLlama, resolveModelFile } from 'node-llama-cpp';
 
 var SourceSchema = z.enum([
   "user_correction",
@@ -216,6 +216,28 @@ function openDb(repoRoot) {
   createSchema(db);
   return db;
 }
+function getCachedEmbedding(repoRoot, lessonId, expectedHash) {
+  const database = openDb(repoRoot);
+  const row = database.prepare("SELECT embedding, content_hash FROM lessons WHERE id = ?").get(lessonId);
+  if (!row || !row.embedding || !row.content_hash) {
+    return null;
+  }
+  if (expectedHash && row.content_hash !== expectedHash) {
+    return null;
+  }
+  const float32 = new Float32Array(
+    row.embedding.buffer,
+    row.embedding.byteOffset,
+    row.embedding.byteLength / 4
+  );
+  return Array.from(float32);
+}
+function setCachedEmbedding(repoRoot, lessonId, embedding, hash) {
+  const database = openDb(repoRoot);
+  const float32 = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
+  const buffer = Buffer.from(float32.buffer, float32.byteOffset, float32.byteLength);
+  database.prepare("UPDATE lessons SET embedding = ?, content_hash = ? WHERE id = ?").run(buffer, hash, lessonId);
+}
 function rowToLesson(row) {
   const lesson = {
     id: row.id,
@@ -547,8 +569,6 @@ function detectTestFailure(testResult) {
     trigger: `Test failure in ${testResult.testFile}: ${errorLine.slice(0, 100)}`
   };
 }
-
-// src/capture/integration.ts
 async function detectAndPropose(repoRoot, input) {
   const detected = runDetector(input);
   if (!detected) {
@@ -634,7 +654,152 @@ function parseLimit(value, name) {
 function getRepoRoot() {
   return process.env["LEARNING_AGENT_ROOT"] ?? process.cwd();
 }
-join(homedir(), ".node-llama-cpp", "models");
+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);
+    }
+    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));
+  return ageDays <= RECENCY_THRESHOLD_DAYS ? RECENCY_BOOST : 1;
+}
+function confirmationBoost(lesson) {
+  return lesson.confirmed ? CONFIRMATION_BOOST : 1;
+}
+function calculateScore(lesson, vectorSimilarity) {
+  return vectorSimilarity * severityBoost(lesson) * recencyBoost(lesson) * confirmationBoost(lesson);
+}
+function rankLessons(lessons) {
+  return lessons.map((scored) => ({
+    ...scored,
+    finalScore: calculateScore(scored.lesson, scored.score)
+  })).sort((a, b) => (b.finalScore ?? 0) - (a.finalScore ?? 0));
+}
+
+// src/retrieval/session.ts
+var DEFAULT_LIMIT2 = 5;
+function isFullLesson(lesson) {
+  return lesson.type === "full" && lesson.severity !== void 0;
+}
+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
+  );
+  highSeverityLessons.sort((a, b) => {
+    const dateA = new Date(a.created).getTime();
+    const dateB = new Date(b.created).getTime();
+    return dateB - dateA;
+  });
+  return highSeverityLessons.slice(0, limit);
+}
+
+// src/retrieval/plan.ts
+var DEFAULT_LIMIT3 = 5;
+async function retrieveForPlan(repoRoot, planText, limit = DEFAULT_LIMIT3) {
+  const scored = await searchVector(repoRoot, planText, { limit: limit * 2 });
+  const ranked = rankLessons(scored);
+  const topLessons = ranked.slice(0, limit);
+  const message = formatLessonsCheck(topLessons);
+  return { lessons: topLessons, message };
+}
+function formatLessonsCheck(lessons) {
+  const header = "\u{1F4DA} Lessons Check\n" + "\u2500".repeat(40);
+  if (lessons.length === 0) {
+    return `${header}
+No relevant lessons found for this plan.`;
+  }
+  const lessonLines = lessons.map((l, i) => {
+    const bullet = `${i + 1}.`;
+    const insight = l.lesson.insight;
+    return `${bullet} ${insight}`;
+  });
+  return `${header}
+${lessonLines.join("\n")}`;
+}
 
 // src/index.ts
 var VERSION = "0.1.0";
@@ -753,6 +918,28 @@ async function compact(repoRoot) {
 }
 
 // src/cli.ts
+var PRE_COMMIT_MESSAGE = `Before committing, have you captured any valuable lessons from this session?
+Consider: corrections, mistakes, or insights worth remembering.
+
+To capture a lesson:
+  npx learning-agent capture --trigger "what happened" --insight "what to do" --yes`;
+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 out = {
   success: (msg) => console.log(chalk.green("[ok]"), msg),
   error: (msg) => console.error(chalk.red("[error]"), msg),
@@ -768,9 +955,457 @@ function getGlobalOpts(cmd) {
 }
 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;
+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: []
+  };
+}
+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 outputSessionLessonsHuman(lessons, quiet) {
+  console.log("## Session Lessons (High Severity)\n");
+  lessons.forEach((lesson, i) => {
+    const num = i + 1;
+    const date = lesson.created.slice(0, ISO_DATE_PREFIX_LENGTH);
+    console.log(`${num}. ${chalk.bold(`[${lesson.id}]`)} ${lesson.insight}`);
+    console.log(`   - Source: ${lesson.source} (${date})`);
+    if (lesson.tags.length > 0) {
+      console.log(`   - Tags: ${lesson.tags.join(", ")}`);
+    }
+    console.log();
+  });
+  const lessonWord = lessons.length === 1 ? "lesson" : "lessons";
+  if (!quiet) {
+    console.log("---");
+    console.log(`${lessons.length} high-severity ${lessonWord} loaded.`);
+  }
+}
+var LEARNING_AGENT_SECTION_HEADER = "## Learning Agent Integration";
+var AGENTS_MD_TEMPLATE = `
+## Learning Agent Integration
+
+This project uses learning-agent for session memory.
+
+### Retrieval Points
+
+- **Session start**: High-severity lessons loaded automatically
+- **Plan-time**: BEFORE implementing a plan, run check-plan to retrieve relevant lessons
+
+### Plan-Time Retrieval (Explicit Step)
+
+**BEFORE implementing any plan**, run:
+
+\`\`\`bash
+npx learning-agent check-plan --plan "your plan description" --json
+\`\`\`
+
+Display results as a **Lessons Check** section after your plan:
+
+\`\`\`
+## Lessons Check
+1. [insight from lesson 1] (relevance: 0.85)
+2. [insight from lesson 2] (relevance: 0.72)
+\`\`\`
+
+Consider each lesson while implementing.
+
+### Proposing Lessons
+
+Propose when: user correction, self-correction, test failure fix, or manual request.
+
+**Quality gate (ALL must pass):**
+
+- Novel (not already stored)
+- Specific (clear guidance)
+- Actionable (obvious what to do)
+
+**Confirmation format:**
+
+\`\`\`
+Learned: [insight]. Save? [y/n]
+\`\`\`
+
+### Session-End Protocol
+
+Before closing a session, reflect on lessons learned:
+
+1. **Review**: What mistakes or corrections happened?
+2. **Quality gate**: Is it novel, specific, actionable?
+3. **Propose**: "Learned: [insight]. Save? [y/n]"
+4. **Capture**: \`npx learning-agent capture --trigger "..." --insight "..." --yes\`
+
+### CLI Commands
+
+\`\`\`bash
+npx learning-agent load-session --json  # Session start
+npx learning-agent check-plan --plan "..." --json  # Before implementing
+npx learning-agent capture --trigger "..." --insight "..." --yes
+\`\`\`
+
+See [AGENTS.md](https://github.com/Nathandela/learning_agent/blob/main/AGENTS.md) for full documentation.
+`;
+function hasLearningAgentSection(content) {
+  return content.includes(LEARNING_AGENT_SECTION_HEADER);
+}
+async function createLessonsDirectory(repoRoot) {
+  const lessonsDir = dirname(join(repoRoot, LESSONS_PATH));
+  await mkdir(lessonsDir, { recursive: true });
+}
+async function createIndexFile(repoRoot) {
+  const indexPath = join(repoRoot, LESSONS_PATH);
+  if (!existsSync(indexPath)) {
+    await writeFile(indexPath, "", "utf-8");
+  }
+}
+async function updateAgentsMd(repoRoot) {
+  const agentsPath = join(repoRoot, "AGENTS.md");
+  let content = "";
+  let existed = false;
+  if (existsSync(agentsPath)) {
+    content = await readFile(agentsPath, "utf-8");
+    existed = true;
+    if (hasLearningAgentSection(content)) {
+      return false;
+    }
+  }
+  const newContent = existed ? content.trimEnd() + "\n" + AGENTS_MD_TEMPLATE : AGENTS_MD_TEMPLATE.trim() + "\n";
+  await writeFile(agentsPath, newContent, "utf-8");
+  return true;
+}
+var HOOK_FILE_MODE = 493;
+function hasLearningAgentHook(content) {
+  return content.includes(HOOK_MARKER);
+}
+async function getGitHooksDir(repoRoot) {
+  const gitDir = join(repoRoot, ".git");
+  if (!existsSync(gitDir)) {
+    return null;
+  }
+  const configPath = join(gitDir, "config");
+  if (existsSync(configPath)) {
+    const config = await readFile(configPath, "utf-8");
+    const match = /hooksPath\s*=\s*(.+)$/m.exec(config);
+    if (match?.[1]) {
+      const hooksPath = match[1].trim();
+      return hooksPath.startsWith("/") ? hooksPath : join(repoRoot, hooksPath);
+    }
+  }
+  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
+`;
+async function installPreCommitHook(repoRoot) {
+  const gitHooksDir = await getGitHooksDir(repoRoot);
+  if (!gitHooksDir) {
+    return false;
+  }
+  await mkdir(gitHooksDir, { recursive: true });
+  const hookPath = join(gitHooksDir, "pre-commit");
+  if (existsSync(hookPath)) {
+    const content = await readFile(hookPath, "utf-8");
+    if (hasLearningAgentHook(content)) {
+      return false;
+    }
+    const newContent = content.trimEnd() + "\n" + LEARNING_AGENT_HOOK_BLOCK;
+    await writeFile(hookPath, newContent, "utf-8");
+    chmodSync(hookPath, HOOK_FILE_MODE);
+    return true;
+  }
+  await writeFile(hookPath, PRE_COMMIT_HOOK_TEMPLATE, "utf-8");
+  chmodSync(hookPath, HOOK_FILE_MODE);
+  return true;
+}
 var program = new Command();
 program.option("-v, --verbose", "Show detailed output").option("-q, --quiet", "Suppress non-essential output");
 program.name("learning-agent").description("Repository-scoped learning system for Claude Code").version(VERSION);
+program.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);
+  await createIndexFile(repoRoot);
+  const lessonsDir = dirname(join(repoRoot, LESSONS_PATH));
+  let agentsMdUpdated = false;
+  if (!options.skipAgents) {
+    agentsMdUpdated = await updateAgentsMd(repoRoot);
+  }
+  let hooksInstalled = false;
+  if (!options.skipHooks) {
+    hooksInstalled = await installPreCommitHook(repoRoot);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      initialized: true,
+      lessonsDir,
+      agentsMd: agentsMdUpdated,
+      hooks: hooksInstalled
+    }));
+  } else if (!quiet) {
+    out.success("Learning agent initialized");
+    console.log(`  Lessons directory: ${lessonsDir}`);
+    if (agentsMdUpdated) {
+      console.log("  AGENTS.md: Updated with Learning Agent section");
+    } else if (options.skipAgents) {
+      console.log("  AGENTS.md: Skipped (--skip-agents)");
+    } else {
+      console.log("  AGENTS.md: Already has Learning Agent section");
+    }
+    if (hooksInstalled) {
+      console.log("  Git hooks: pre-commit hook installed");
+    } else if (options.skipHooks) {
+      console.log("  Git hooks: Skipped (--skip-hooks)");
+    } else {
+      console.log("  Git hooks: Already installed or not a git repo");
+    }
+  }
+});
+var hooksCommand = program.command("hooks").description("Git hooks management");
+hooksCommand.command("run <hook>").description("Run a hook script (called by git hooks)").option("--json", "Output as JSON").action((hook, options) => {
+  if (hook === "pre-commit") {
+    if (options.json) {
+      console.log(JSON.stringify({ hook: "pre-commit", message: PRE_COMMIT_MESSAGE }));
+    } else {
+      console.log(PRE_COMMIT_MESSAGE);
+    }
+  } else {
+    if (options.json) {
+      console.log(JSON.stringify({ error: `Unknown hook: ${hook}` }));
+    } else {
+      out.error(`Unknown hook: ${hook}`);
+    }
+    process.exit(1);
+  }
+});
+function getClaudeSettingsPath(project) {
+  if (project) {
+    const repoRoot = getRepoRoot();
+    return join(repoRoot, ".claude", "settings.json");
+  }
+  return join(homedir(), ".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);
+}
+var setupCommand = program.command("setup").description("Setup integrations");
+setupCommand.command("claude").description("Install Claude Code SessionStart hooks").option("--project", "Install to project .claude directory instead of global").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.project ?? false);
+  const displayPath = options.project ? ".claude/settings.json" : "~/.claude/settings.json";
+  let settings;
+  try {
+    settings = await readClaudeSettings(settingsPath);
+  } catch {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Failed to parse settings file" }));
+    } else {
+      out.error("Failed to parse settings file. Check if JSON is valid.");
+    }
+    process.exit(1);
+  }
+  const alreadyInstalled = hasClaudeHook(settings);
+  if (options.uninstall) {
+    if (options.dryRun) {
+      if (options.json) {
+        console.log(JSON.stringify({ dryRun: true, wouldRemove: alreadyInstalled, location: displayPath }));
+      } else {
+        if (alreadyInstalled) {
+          console.log(`Would remove learning-agent hooks from ${displayPath}`);
+        } else {
+          console.log("No learning-agent hooks to remove");
+        }
+      }
+      return;
+    }
+    const removed = removeLearningAgentHook(settings);
+    if (removed) {
+      await writeClaudeSettings(settingsPath, settings);
+      if (options.json) {
+        console.log(JSON.stringify({ installed: false, location: displayPath, action: "removed" }));
+      } else {
+        out.success("Learning agent hooks removed");
+        console.log(`  Location: ${displayPath}`);
+      }
+    } else {
+      if (options.json) {
+        console.log(JSON.stringify({ installed: false, location: displayPath, action: "unchanged" }));
+      } else {
+        out.info("No learning agent hooks to remove");
+      }
+    }
+    return;
+  }
+  if (options.dryRun) {
+    if (options.json) {
+      console.log(JSON.stringify({ dryRun: true, wouldInstall: !alreadyInstalled, location: displayPath }));
+    } else {
+      if (alreadyInstalled) {
+        console.log("Learning agent hooks already installed");
+      } else {
+        console.log(`Would install learning-agent hooks to ${displayPath}`);
+      }
+    }
+    return;
+  }
+  if (alreadyInstalled) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        installed: true,
+        location: displayPath,
+        hooks: ["SessionStart"],
+        action: "unchanged"
+      }));
+    } else {
+      out.info("Learning agent hooks already installed");
+      console.log(`  Location: ${displayPath}`);
+    }
+    return;
+  }
+  const fileExists = existsSync(settingsPath);
+  addLearningAgentHook(settings);
+  await writeClaudeSettings(settingsPath, settings);
+  if (options.json) {
+    console.log(JSON.stringify({
+      installed: true,
+      location: displayPath,
+      hooks: ["SessionStart"],
+      action: fileExists ? "updated" : "created"
+    }));
+  } else {
+    out.success(options.project ? "Claude Code hooks installed (project-level)" : "Claude Code hooks installed");
+    console.log(`  Location: ${displayPath}`);
+    console.log("  Hook: SessionStart (startup|resume|compact)");
+    console.log("");
+    console.log("Lessons will be loaded automatically at session start.");
+    if (options.project) {
+      console.log("");
+      console.log("Note: Project hooks override global hooks.");
+    }
+  }
+});
 program.command("learn <insight>").description("Capture a new lesson").option("-t, --trigger <text>", "What triggered this lesson").option("--tags <tags>", "Comma-separated tags", "").option("-y, --yes", "Skip confirmation").action(async function(insight, options) {
   const repoRoot = getRepoRoot();
   const { quiet } = getGlobalOpts(this);
@@ -786,7 +1421,8 @@ program.command("learn <insight>").description("Capture a new lesson").option("-
       intent: "manual learning"
     },
     created: (/* @__PURE__ */ new Date()).toISOString(),
-    confirmed: options.yes ?? false,
+    confirmed: true,
+    // learn command is explicit confirmation
     supersedes: [],
     related: []
   };
@@ -875,9 +1511,18 @@ program.command("rebuild").description("Rebuild SQLite index from JSONL").option
     }
   }
 });
-program.command("detect").description("Detect learning triggers from input").requiredOption("--input <file>", "Path to JSON input file").option("--save", "Automatically save proposed lesson").option("--json", "Output result as JSON").action(
+program.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) {
@@ -896,7 +1541,7 @@ program.command("detect").description("Detect learning triggers from input").req
     console.log(`  Trigger: ${result.trigger}`);
     console.log(`  Source: ${result.source}`);
     console.log(`  Proposed: ${result.proposedInsight}`);
-    if (options.save) {
+    if (options.save && options.yes) {
       const lesson = {
         id: generateId(result.proposedInsight),
         type: "quick",
@@ -906,7 +1551,8 @@ program.command("detect").description("Detect learning triggers from input").req
         source: result.source,
         context: { tool: "detect", intent: "auto-capture" },
         created: (/* @__PURE__ */ new Date()).toISOString(),
-        confirmed: false,
+        confirmed: true,
+        // --yes confirms the lesson
         supersedes: [],
         related: []
       };
@@ -916,6 +1562,45 @@ Saved as lesson: ${lesson.id}`);
     }
   }
 );
+program.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();
+  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);
+    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 {
+      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);
+  }
+});
 program.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);
@@ -956,14 +1641,14 @@ program.command("export").description("Export lessons as JSON to stdout").option
     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, 2));
+  console.log(JSON.stringify(filtered, null, JSON_INDENT_SPACES));
 });
 program.command("import <file>").description("Import lessons from a JSONL file").action(async (file) => {
   const repoRoot = getRepoRoot();
   let content;
   try {
-    const { readFile: readFile4 } = await import('fs/promises');
-    content = await readFile4(file, "utf-8");
+    const { readFile: readFile5 } = await import('fs/promises');
+    content = await readFile5(file, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -1021,7 +1706,7 @@ program.command("stats").description("Show database health and statistics").acti
   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(1) : "0.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;
@@ -1040,6 +1725,63 @@ program.command("stats").description("Show database health and statistics").acti
   console.log(`Retrievals: ${totalRetrievals} total, ${avgRetrievals} avg per lesson`);
   console.log(`Storage: ${formatBytes(totalSize)} (index: ${formatBytes(indexSize)}, data: ${formatBytes(dataSize)})`);
 });
+program.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);
+});
+program.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()) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: "Embedding model not available",
+        action: "Run: npx learning-agent download-model"
+      }));
+    } else {
+      out.error("Embedding model not available");
+      console.log("");
+      console.log("Run: npx learning-agent download-model");
+    }
+    process.exit(1);
+  }
+  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);
+  }
+});
 program.parse();
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map