compound-agent 1.0.0

package/dist/mcp.js

@@ -0,0 +1,1025 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { mkdir, appendFile, readFile } from 'fs/promises';
+import { join, dirname } from 'path';
+import { createHash } from 'crypto';
+import { mkdirSync, unlinkSync } from 'fs';
+import { createRequire } from 'module';
+import { getLlama, resolveModelFile } from 'node-llama-cpp';
+import { homedir } from 'os';
+import 'chalk';
+import 'child_process';
+
+// src/cli-utils.ts
+function getRepoRoot() {
+  return process.env["COMPOUND_AGENT_ROOT"] ?? process.cwd();
+}
+var SourceSchema = z.enum([
+  "user_correction",
+  "self_correction",
+  "test_failure",
+  "manual"
+]);
+var ContextSchema = z.object({
+  tool: z.string(),
+  intent: z.string()
+});
+var PatternSchema = z.object({
+  bad: z.string(),
+  good: z.string()
+});
+var CitationSchema = z.object({
+  file: z.string().min(1),
+  // Source file path (required, non-empty)
+  line: z.number().int().positive().optional(),
+  // Line number (optional, must be positive)
+  commit: z.string().optional()
+  // Git commit hash (optional)
+});
+var SeveritySchema = z.enum(["high", "medium", "low"]);
+var CompactionLevelSchema = z.union([
+  z.literal(0),
+  // Active
+  z.literal(1),
+  // Flagged (>90 days)
+  z.literal(2)
+  // Archived
+]);
+var LessonTypeSchema = z.enum(["quick", "full"]);
+var MemoryItemTypeSchema = z.enum(["lesson", "solution", "pattern", "preference"]);
+var baseFields = {
+  // Core identity (required)
+  id: z.string(),
+  trigger: z.string(),
+  insight: z.string(),
+  // Metadata (required)
+  tags: z.array(z.string()),
+  source: SourceSchema,
+  context: ContextSchema,
+  created: z.string(),
+  // ISO8601
+  confirmed: z.boolean(),
+  // Relationships (required, can be empty arrays)
+  supersedes: z.array(z.string()),
+  related: z.array(z.string()),
+  // Extended fields (optional)
+  evidence: z.string().optional(),
+  severity: SeveritySchema.optional(),
+  // Lifecycle fields (optional)
+  deleted: z.boolean().optional(),
+  deletedAt: z.string().optional(),
+  retrievalCount: z.number().optional(),
+  // Provenance tracking (optional)
+  citation: CitationSchema.optional(),
+  // Age-based validity fields (optional)
+  compactionLevel: CompactionLevelSchema.optional(),
+  compactedAt: z.string().optional(),
+  lastRetrieved: z.string().optional(),
+  // Invalidation fields (optional)
+  invalidatedAt: z.string().optional(),
+  invalidationReason: z.string().optional()
+};
+var LessonItemSchema = z.object({
+  ...baseFields,
+  type: z.literal("lesson"),
+  pattern: PatternSchema.optional()
+});
+var SolutionItemSchema = z.object({
+  ...baseFields,
+  type: z.literal("solution"),
+  pattern: PatternSchema.optional()
+});
+var PatternItemSchema = z.object({
+  ...baseFields,
+  type: z.literal("pattern"),
+  pattern: PatternSchema
+});
+var PreferenceItemSchema = z.object({
+  ...baseFields,
+  type: z.literal("preference"),
+  pattern: PatternSchema.optional()
+});
+var MemoryItemSchema = z.discriminatedUnion("type", [
+  LessonItemSchema,
+  SolutionItemSchema,
+  PatternItemSchema,
+  PreferenceItemSchema
+]);
+var LegacyLessonSchema = z.object({
+  ...baseFields,
+  type: LessonTypeSchema,
+  pattern: PatternSchema.optional()
+});
+var LegacyTombstoneSchema = z.object({
+  id: z.string(),
+  deleted: z.literal(true),
+  deletedAt: z.string()
+  // ISO8601
+});
+var LessonRecordSchema = z.union([
+  MemoryItemSchema,
+  LegacyLessonSchema,
+  LegacyTombstoneSchema
+]);
+var MemoryItemRecordSchema = LessonRecordSchema;
+var TYPE_PREFIXES = {
+  lesson: "L",
+  solution: "S",
+  pattern: "P",
+  preference: "R"
+};
+function generateId(insight, type) {
+  const prefix = TYPE_PREFIXES[type ?? "lesson"];
+  const hash = createHash("sha256").update(insight).digest("hex");
+  return `${prefix}${hash.slice(0, 8)}`;
+}
+
+// src/memory/storage/jsonl.ts
+var LESSONS_PATH = ".claude/lessons/index.jsonl";
+async function appendMemoryItem(repoRoot, item) {
+  const filePath = join(repoRoot, LESSONS_PATH);
+  await mkdir(dirname(filePath), { recursive: true });
+  const line = JSON.stringify(item) + "\n";
+  await appendFile(filePath, line, "utf-8");
+}
+function parseJsonLine(line, lineNumber, strict, onParseError) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (err) {
+    const parseError = {
+      line: lineNumber,
+      message: `Invalid JSON: ${err.message}`,
+      cause: err
+    };
+    if (strict) {
+      throw new Error(`Parse error on line ${lineNumber}: ${parseError.message}`);
+    }
+    onParseError?.(parseError);
+    return null;
+  }
+  const result = MemoryItemRecordSchema.safeParse(parsed);
+  if (!result.success) {
+    const parseError = {
+      line: lineNumber,
+      message: `Schema validation failed: ${result.error.message}`,
+      cause: result.error
+    };
+    if (strict) {
+      throw new Error(`Parse error on line ${lineNumber}: ${parseError.message}`);
+    }
+    onParseError?.(parseError);
+    return null;
+  }
+  return result.data;
+}
+function toMemoryItem(record) {
+  if (record.deleted === true) {
+    return null;
+  }
+  if (record.type === "quick" || record.type === "full") {
+    return { ...record, type: "lesson" };
+  }
+  return record;
+}
+async function readMemoryItems(repoRoot, options = {}) {
+  const { strict = false, onParseError } = options;
+  const filePath = join(repoRoot, LESSONS_PATH);
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { items: [], skippedCount: 0 };
+    }
+    throw err;
+  }
+  const items = /* @__PURE__ */ new Map();
+  let skippedCount = 0;
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+    const record = parseJsonLine(trimmed, i + 1, strict, onParseError);
+    if (!record) {
+      skippedCount++;
+      continue;
+    }
+    if (record.deleted === true) {
+      items.delete(record.id);
+    } else {
+      const item = toMemoryItem(record);
+      if (item) {
+        items.set(record.id, item);
+      }
+    }
+  }
+  return { items: Array.from(items.values()), skippedCount };
+}
+var require2 = createRequire(import.meta.url);
+var checked = false;
+var DatabaseConstructor = null;
+function ensureSqliteAvailable() {
+  if (checked) return;
+  try {
+    const module = require2("better-sqlite3");
+    const Constructor = module.default || module;
+    const testDb = new Constructor(":memory:");
+    testDb.close();
+    DatabaseConstructor = Constructor;
+    checked = true;
+  } catch (cause) {
+    throw new Error(
+      `better-sqlite3 failed to load.
+If using pnpm, add to your project's package.json:
+  "pnpm": { "onlyBuiltDependencies": ["better-sqlite3"] }
+Then run: pnpm install && pnpm rebuild better-sqlite3
+For npm/yarn, run: npm rebuild better-sqlite3`,
+      { cause }
+    );
+  }
+}
+function getDatabaseConstructor() {
+  ensureSqliteAvailable();
+  return DatabaseConstructor;
+}
+
+// src/memory/storage/sqlite/schema.ts
+var SCHEMA_VERSION = 3;
+var SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS lessons (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    trigger TEXT NOT NULL,
+    insight TEXT NOT NULL,
+    evidence TEXT,
+    severity TEXT,
+    tags TEXT NOT NULL DEFAULT '',
+    source TEXT NOT NULL,
+    context TEXT NOT NULL DEFAULT '{}',
+    supersedes TEXT NOT NULL DEFAULT '[]',
+    related TEXT NOT NULL DEFAULT '[]',
+    created TEXT NOT NULL,
+    confirmed INTEGER NOT NULL DEFAULT 0,
+    deleted INTEGER NOT NULL DEFAULT 0,
+    retrieval_count INTEGER NOT NULL DEFAULT 0,
+    last_retrieved TEXT,
+    embedding BLOB,
+    content_hash TEXT,
+    invalidated_at TEXT,
+    invalidation_reason TEXT,
+    citation_file TEXT,
+    citation_line INTEGER,
+    citation_commit TEXT,
+    compaction_level INTEGER DEFAULT 0,
+    compacted_at TEXT,
+    pattern_bad TEXT,
+    pattern_good TEXT
+  );
+
+  CREATE VIRTUAL TABLE IF NOT EXISTS lessons_fts USING fts5(
+    id, trigger, insight, tags, pattern_bad, pattern_good,
+    content='lessons', content_rowid='rowid'
+  );
+
+  CREATE TRIGGER IF NOT EXISTS lessons_ai AFTER INSERT ON lessons BEGIN
+    INSERT INTO lessons_fts(rowid, id, trigger, insight, tags, pattern_bad, pattern_good)
+    VALUES (new.rowid, new.id, new.trigger, new.insight, new.tags, new.pattern_bad, new.pattern_good);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS lessons_ad AFTER DELETE ON lessons BEGIN
+    INSERT INTO lessons_fts(lessons_fts, rowid, id, trigger, insight, tags, pattern_bad, pattern_good)
+    VALUES ('delete', old.rowid, old.id, old.trigger, old.insight, old.tags, old.pattern_bad, old.pattern_good);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS lessons_au AFTER UPDATE ON lessons BEGIN
+    INSERT INTO lessons_fts(lessons_fts, rowid, id, trigger, insight, tags, pattern_bad, pattern_good)
+    VALUES ('delete', old.rowid, old.id, old.trigger, old.insight, old.tags, old.pattern_bad, old.pattern_good);
+    INSERT INTO lessons_fts(rowid, id, trigger, insight, tags, pattern_bad, pattern_good)
+    VALUES (new.rowid, new.id, new.trigger, new.insight, new.tags, new.pattern_bad, new.pattern_good);
+  END;
+
+  CREATE INDEX IF NOT EXISTS idx_lessons_created ON lessons(created);
+  CREATE INDEX IF NOT EXISTS idx_lessons_confirmed ON lessons(confirmed);
+  CREATE INDEX IF NOT EXISTS idx_lessons_severity ON lessons(severity);
+  CREATE INDEX IF NOT EXISTS idx_lessons_type ON lessons(type);
+
+  CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+`;
+function createSchema(database) {
+  database.exec(SCHEMA_SQL);
+  database.pragma(`user_version = ${SCHEMA_VERSION}`);
+}
+
+// src/memory/storage/sqlite/connection.ts
+var DB_PATH = ".claude/.cache/lessons.sqlite";
+var dbMap = /* @__PURE__ */ new Map();
+function hasExpectedVersion(database) {
+  const row = database.pragma("user_version", { simple: true });
+  return row === SCHEMA_VERSION;
+}
+function openDb(repoRoot, options = {}) {
+  const { inMemory = false } = options;
+  const key = inMemory ? `:memory:${repoRoot}` : join(repoRoot, DB_PATH);
+  const cached = dbMap.get(key);
+  if (cached) {
+    return cached;
+  }
+  const Database = getDatabaseConstructor();
+  let database;
+  if (inMemory) {
+    database = new Database(":memory:");
+  } else {
+    const dir = dirname(key);
+    mkdirSync(dir, { recursive: true });
+    database = new Database(key);
+    if (!hasExpectedVersion(database)) {
+      database.close();
+      unlinkSync(key);
+      database = new Database(key);
+    }
+    database.pragma("journal_mode = WAL");
+  }
+  createSchema(database);
+  dbMap.set(key, database);
+  return database;
+}
+function closeDb() {
+  for (const database of dbMap.values()) {
+    database.close();
+  }
+  dbMap.clear();
+}
+function contentHash(trigger, insight) {
+  return createHash("sha256").update(`${trigger} ${insight}`).digest("hex");
+}
+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);
+}
+
+// src/memory/storage/sqlite/search.ts
+function incrementRetrievalCount(repoRoot, lessonIds) {
+  if (lessonIds.length === 0) return;
+  const database = openDb(repoRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const update = database.prepare(`
+    UPDATE lessons
+    SET retrieval_count = retrieval_count + 1,
+        last_retrieved = ?
+    WHERE id = ?
+  `);
+  const updateMany = database.transaction((ids) => {
+    for (const id of ids) {
+      update.run(now, id);
+    }
+  });
+  updateMany(lessonIds);
+}
+
+// src/utils.ts
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function getLessonAgeDays(lesson) {
+  const created = new Date(lesson.created).getTime();
+  const now = Date.now();
+  return Math.floor((now - created) / MS_PER_DAY);
+}
+
+// src/memory/retrieval/session.ts
+var DEFAULT_LIMIT = 5;
+function hasSeverity(item) {
+  return item.severity !== void 0;
+}
+async function loadSessionLessons(repoRoot, limit = DEFAULT_LIMIT) {
+  const { items } = await readMemoryItems(repoRoot);
+  const highSeverityLessons = items.filter(
+    (item) => hasSeverity(item) && item.severity === "high" && item.confirmed && !item.invalidatedAt
+  );
+  highSeverityLessons.sort((a, b) => {
+    const dateA = new Date(a.created).getTime();
+    const dateB = new Date(b.created).getTime();
+    return dateB - dateA;
+  });
+  const topLessons = highSeverityLessons.slice(0, limit);
+  if (topLessons.length > 0) {
+    incrementRetrievalCount(repoRoot, topLessons.map((lesson) => lesson.id));
+  }
+  return topLessons;
+}
+var CCT_PATTERNS_PATH = ".claude/lessons/cct-patterns.jsonl";
+var CctPatternSchema = z.object({
+  id: z.string().regex(/^CCT-[a-f0-9]{8}$/),
+  name: z.string().min(1),
+  description: z.string().min(1),
+  frequency: z.number().int().positive(),
+  testable: z.boolean(),
+  testApproach: z.string().optional(),
+  sourceIds: z.array(z.string()).min(1),
+  created: z.string()
+  // ISO8601
+});
+
+// src/compound/io.ts
+async function readCctPatterns(repoRoot) {
+  const filePath = join(repoRoot, CCT_PATTERNS_PATH);
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+  const patterns = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parsed = JSON.parse(trimmed);
+    const result = CctPatternSchema.safeParse(parsed);
+    if (result.success) {
+      patterns.push(result.data);
+    }
+  }
+  return patterns;
+}
+var MODEL_URI = "hf:ggml-org/embeddinggemma-300M-qat-q4_0-GGUF/embeddinggemma-300M-qat-Q4_0.gguf";
+join(homedir(), ".node-llama-cpp", "models");
+async function resolveModel(options = {}) {
+  const { cli = true } = options;
+  return resolveModelFile(MODEL_URI, { cli });
+}
+
+// src/memory/embeddings/nomic.ts
+var embeddingContext = null;
+var pendingInit = null;
+var llamaInstance = null;
+var modelInstance = null;
+async function getEmbedding() {
+  if (embeddingContext) return embeddingContext;
+  if (pendingInit) return pendingInit;
+  pendingInit = (async () => {
+    try {
+      const modelPath = await resolveModel({ cli: true });
+      llamaInstance = await getLlama();
+      modelInstance = await llamaInstance.loadModel({ modelPath });
+      embeddingContext = await modelInstance.createEmbeddingContext();
+      return embeddingContext;
+    } catch (err) {
+      pendingInit = null;
+      throw err;
+    }
+  })();
+  return pendingInit;
+}
+async function embedText(text) {
+  const ctx = await getEmbedding();
+  const result = await ctx.getEmbeddingFor(text);
+  return Array.from(result.vector);
+}
+
+// src/memory/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_LIMIT2 = 10;
+function cctToMemoryItem(pattern) {
+  return {
+    id: pattern.id,
+    type: "lesson",
+    trigger: pattern.name,
+    insight: pattern.description,
+    tags: [],
+    source: "manual",
+    context: { tool: "compound", intent: "synthesis" },
+    created: pattern.created,
+    confirmed: true,
+    supersedes: [],
+    related: pattern.sourceIds
+  };
+}
+async function searchVector(repoRoot, query, options) {
+  const limit = options?.limit ?? DEFAULT_LIMIT2;
+  const { items } = await readMemoryItems(repoRoot);
+  let cctPatterns = [];
+  try {
+    cctPatterns = await readCctPatterns(repoRoot);
+  } catch {
+  }
+  if (items.length === 0 && cctPatterns.length === 0) return [];
+  const queryVector = await embedText(query);
+  const scored = [];
+  for (const item of items) {
+    if (item.invalidatedAt) continue;
+    try {
+      const itemText = `${item.trigger} ${item.insight}`;
+      const hash = contentHash(item.trigger, item.insight);
+      let itemVector = getCachedEmbedding(repoRoot, item.id, hash);
+      if (!itemVector) {
+        itemVector = await embedText(itemText);
+        setCachedEmbedding(repoRoot, item.id, itemVector, hash);
+      }
+      const score = cosineSimilarity(queryVector, itemVector);
+      scored.push({ lesson: item, score });
+    } catch {
+      continue;
+    }
+  }
+  for (const pattern of cctPatterns) {
+    try {
+      const text = `${pattern.name} ${pattern.description}`;
+      const vec = await embedText(text);
+      const score = cosineSimilarity(queryVector, vec);
+      scored.push({ lesson: cctToMemoryItem(pattern), score });
+    } catch {
+      continue;
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+
+// src/memory/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;
+var MAX_COMBINED_BOOST = 1.8;
+function severityBoost(item) {
+  switch (item.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(item) {
+  const ageDays = getLessonAgeDays(item);
+  return ageDays <= RECENCY_THRESHOLD_DAYS ? RECENCY_BOOST : 1;
+}
+function confirmationBoost(item) {
+  return item.confirmed ? CONFIRMATION_BOOST : 1;
+}
+function calculateScore(item, vectorSimilarity) {
+  const boost = Math.min(
+    severityBoost(item) * recencyBoost(item) * confirmationBoost(item),
+    MAX_COMBINED_BOOST
+  );
+  return vectorSimilarity * boost;
+}
+function rankLessons(lessons) {
+  return lessons.map((scored) => ({
+    ...scored,
+    finalScore: calculateScore(scored.lesson, scored.score)
+  })).sort((a, b) => (b.finalScore ?? 0) - (a.finalScore ?? 0));
+}
+
+// src/commands/management-prime.ts
+var TRUST_LANGUAGE_TEMPLATE = `# Compound Agent Active
+
+> **Context Recovery**: Run \`ca prime\` after compaction, clear, or new session
+
+## MCP Tools (ALWAYS USE THESE)
+
+**You MUST use MCP tools, NOT CLI commands:**
+
+| Tool | Purpose |
+|------|---------|
+| \`memory_search\` | Search lessons - call BEFORE architectural decisions |
+| \`memory_capture\` | Capture lessons - call AFTER corrections or discoveries |
+
+## Core Constraints
+
+**Default**: Use MCP tools for lesson management
+**Prohibited**: NEVER edit .claude/lessons/ files directly
+
+**Default**: Propose lessons freely after corrections
+**Prohibited**: NEVER propose without quality gate (novel + specific; prefer actionable)
+
+## Retrieval Protocol
+
+You MUST call \`memory_search\` BEFORE:
+- Architectural decisions or complex planning
+- Implementing patterns you've done before in this repo
+
+**NEVER skip memory_search for complex decisions.** Past mistakes will repeat.
+
+## Capture Protocol
+
+Call \`memory_capture\` AFTER:
+- User corrects you ("no", "wrong", "actually...")
+- You self-correct after iteration failures
+- Test fails then you fix it
+
+**Quality gate** (must pass before capturing):
+- Novel (not already stored)
+- Specific (clear guidance)
+- Actionable (preferred, not mandatory)
+
+**Workflow**: Search BEFORE deciding, capture AFTER learning.
+
+## CLI (fallback only)
+
+When MCP is unavailable: \`ca search "query"\`, \`ca learn "insight"\`, \`ca list\`
+`;
+function formatSource(source) {
+  switch (source) {
+    case "user_correction":
+      return "user correction";
+    case "self_correction":
+      return "self correction";
+    case "test_failure":
+      return "test failure";
+    case "manual":
+      return "manual";
+    default:
+      return source;
+  }
+}
+function formatLessonForPrime(lesson) {
+  const date = lesson.created.slice(0, 10);
+  const tags = lesson.tags.length > 0 ? ` (${lesson.tags.join(", ")})` : "";
+  const source = formatSource(lesson.source);
+  return `- **${lesson.insight}**${tags}
+  Learned: ${date} via ${source}`;
+}
+async function getPrimeContext(repoRoot) {
+  const root = repoRoot ?? getRepoRoot();
+  const lessons = await loadSessionLessons(root, 5);
+  let output = TRUST_LANGUAGE_TEMPLATE;
+  if (lessons.length > 0) {
+    const formattedLessons = lessons.map(formatLessonForPrime).join("\n\n");
+    output += `
+---
+
+# [CRITICAL] Mandatory Recall
+
+Critical lessons from past corrections:
+
+${formattedLessons}
+`;
+  }
+  return output;
+}
+
+// src/memory/capture/triggers.ts
+var PATTERN_INDICATORS = [
+  /\buse\s+.+\s+instead\s+of\b/i,
+  /\bprefer\s+.+\s+(over|to)\b/i
+];
+var SOLUTION_INDICATORS = [
+  /\bwhen\s+.+,\s/i,
+  /\bif\s+.+\bthen\b/i,
+  /\bif\s+.+,\s/i,
+  /\bto\s+fix\b/i
+];
+var PREFERENCE_INDICATORS = [
+  /\balways\s+/i,
+  /\bnever\s+/i
+];
+function inferMemoryItemType(insight) {
+  for (const pattern of PATTERN_INDICATORS) {
+    if (pattern.test(insight)) return "pattern";
+  }
+  for (const pattern of SOLUTION_INDICATORS) {
+    if (pattern.test(insight)) return "solution";
+  }
+  for (const pattern of PREFERENCE_INDICATORS) {
+    if (pattern.test(insight)) return "preference";
+  }
+  return "lesson";
+}
+var CorrectionSignalSchema = z.object({
+  messages: z.array(z.string()),
+  context: ContextSchema
+});
+var EditEntrySchema = z.object({
+  file: z.string(),
+  success: z.boolean(),
+  timestamp: z.number()
+});
+var EditHistorySchema = z.object({
+  edits: z.array(EditEntrySchema)
+});
+var TestResultSchema = z.object({
+  passed: z.boolean(),
+  output: z.string(),
+  testFile: z.string()
+});
+z.discriminatedUnion("type", [
+  z.object({ type: z.literal("user"), data: CorrectionSignalSchema }),
+  z.object({ type: z.literal("self"), data: EditHistorySchema }),
+  z.object({ type: z.literal("test"), data: TestResultSchema })
+]);
+var SeveritySchema2 = z.enum(["error", "warning", "info"]);
+var FilePatternCheckSchema = z.object({
+  type: z.literal("file-pattern"),
+  glob: z.string(),
+  pattern: z.string(),
+  mustMatch: z.boolean().optional()
+});
+var FileSizeCheckSchema = z.object({
+  type: z.literal("file-size"),
+  glob: z.string(),
+  maxLines: z.number().int().positive()
+});
+var ScriptCheckSchema = z.object({
+  type: z.literal("script"),
+  command: z.string(),
+  expectExitCode: z.number().int().optional()
+});
+var RuleCheckSchema = z.discriminatedUnion("type", [
+  FilePatternCheckSchema,
+  FileSizeCheckSchema,
+  ScriptCheckSchema
+]);
+var RuleSchema = z.object({
+  id: z.string().min(1),
+  description: z.string(),
+  severity: SeveritySchema2,
+  check: RuleCheckSchema,
+  remediation: z.string()
+});
+z.object({
+  rules: z.array(RuleSchema)
+});
+var AuditFindingSchema = z.object({
+  file: z.string(),
+  issue: z.string(),
+  severity: z.enum(["error", "warning", "info"]),
+  relatedLessonId: z.string().optional(),
+  suggestedFix: z.string().optional(),
+  source: z.enum(["rule", "pattern", "lesson"])
+});
+var AuditSummarySchema = z.object({
+  errors: z.number(),
+  warnings: z.number(),
+  infos: z.number(),
+  filesChecked: z.number()
+});
+z.object({
+  findings: z.array(AuditFindingSchema),
+  summary: AuditSummarySchema,
+  timestamp: z.string()
+});
+
+// src/index.ts
+var _require = createRequire(import.meta.url);
+var _pkg = _require("../package.json");
+var VERSION = _pkg.version;
+
+// src/mcp.ts
+var DEFAULT_MAX_RESULTS = 5;
+var MIN_INSIGHT_LENGTH = 10;
+function isSearchError(result) {
+  return "error" in result && result.error !== void 0;
+}
+async function handleSearch(repoRoot, query, maxResults, typeFilter) {
+  try {
+    const limit = maxResults ?? DEFAULT_MAX_RESULTS;
+    const searchLimit = typeFilter ? limit * 3 : limit;
+    const results = await searchVector(repoRoot, query, { limit: searchLimit });
+    const ranked = rankLessons(results);
+    let lessons = ranked.map((r) => ({
+      lesson: r.lesson,
+      score: r.score,
+      finalScore: r.finalScore
+    }));
+    if (typeFilter) {
+      lessons = lessons.filter((r) => r.lesson.type === typeFilter);
+    }
+    lessons = lessons.slice(0, limit);
+    const ids = lessons.map((r) => r.lesson.id);
+    if (ids.length > 0) {
+      incrementRetrievalCount(repoRoot, ids);
+    }
+    return { lessons };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return {
+      error: `Search failed: ${message}`,
+      action: "Run: npx ca download-model",
+      lessons: []
+    };
+  }
+}
+async function handleCapture(repoRoot, insight, trigger, tags, type, pattern, severity, confirmed, supersedes, related) {
+  let itemType = type ?? inferMemoryItemType(insight);
+  if (type === "pattern" && !pattern) {
+    throw new Error("Pattern type requires a pattern field with { bad, good }");
+  }
+  if (itemType === "pattern" && !pattern && !type) {
+    itemType = "lesson";
+  }
+  const item = {
+    type: itemType,
+    id: generateId(insight, itemType),
+    trigger: trigger ?? "Manual capture via MCP",
+    insight,
+    tags: tags ?? [],
+    source: "manual",
+    context: { tool: "mcp", intent: "memory capture" },
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    ...severity ? { severity } : {},
+    confirmed: confirmed ?? true,
+    supersedes: supersedes ?? [],
+    related: related ?? [],
+    ...pattern ? { pattern } : {}
+  };
+  await appendMemoryItem(repoRoot, item);
+  return { item, lesson: item };
+}
+var searchInputSchema = {
+  query: z.string().min(1, "Query must be non-empty"),
+  maxResults: z.number().int().positive().max(100).optional(),
+  type: MemoryItemTypeSchema.optional()
+};
+var captureInputSchema = {
+  insight: z.string().min(MIN_INSIGHT_LENGTH, `Insight must be at least ${MIN_INSIGHT_LENGTH} characters`),
+  trigger: z.string().min(1).optional(),
+  tags: z.array(z.string().min(1)).optional(),
+  type: MemoryItemTypeSchema.optional(),
+  pattern: PatternSchema.optional(),
+  severity: z.enum(["high", "medium", "low"]).optional(),
+  confirmed: z.boolean().optional(),
+  supersedes: z.array(z.string()).optional(),
+  related: z.array(z.string()).optional()
+};
+function registerSearchTool(server, repoRoot, toolHandlers) {
+  server.registerTool(
+    "memory_search",
+    {
+      title: "Search Memory",
+      description: `Mandatory recall: search memory BEFORE:
+- Architectural decisions or complex planning
+- Patterns you've implemented before in this repo
+- After corrections ("actually...", "wrong", "use X instead")
+
+Returns relevant memory items ranked by similarity and severity.`,
+      inputSchema: searchInputSchema
+    },
+    async ({ query, maxResults, type: typeFilter }) => {
+      const output = await handleSearch(repoRoot, query, maxResults, typeFilter);
+      return {
+        content: [{ type: "text", text: JSON.stringify(output) }]
+      };
+    }
+  );
+  toolHandlers["memory_search"] = async (params) => {
+    const parsed = z.object(searchInputSchema).parse(params);
+    return handleSearch(repoRoot, parsed.query, parsed.maxResults, parsed.type);
+  };
+}
+function registerCaptureTool(server, repoRoot, toolHandlers) {
+  server.registerTool(
+    "memory_capture",
+    {
+      title: "Capture Memory",
+      description: `Capture a memory item AFTER:
+- User corrects you ("no", "actually...", "use X instead")
+- Test fail -> fix -> pass cycles
+- Discovering project-specific knowledge
+
+Types: lesson (default), solution, pattern (requires pattern field), preference.
+Saves immediately and shows what was captured.`,
+      inputSchema: captureInputSchema
+    },
+    async ({ insight, trigger, tags, type, pattern, severity, confirmed, supersedes, related }) => {
+      const output = await handleCapture(repoRoot, insight, trigger, tags, type, pattern, severity, confirmed, supersedes, related);
+      return {
+        content: [{ type: "text", text: JSON.stringify(output) }]
+      };
+    }
+  );
+  toolHandlers["memory_capture"] = async (params) => {
+    const parsed = z.object(captureInputSchema).parse(params);
+    return handleCapture(repoRoot, parsed.insight, parsed.trigger, parsed.tags, parsed.type, parsed.pattern, parsed.severity, parsed.confirmed, parsed.supersedes, parsed.related);
+  };
+}
+function registerPrimeResource(server, repoRoot, resourceHandlers) {
+  server.registerResource(
+    "prime",
+    "memory://prime",
+    {
+      title: "Prime Context",
+      description: "Workflow context with high-severity memory items for session start",
+      mimeType: "text/plain"
+    },
+    async (uri) => {
+      const content = await getPrimeContext(repoRoot);
+      return {
+        contents: [{ uri: uri.href, text: content }]
+      };
+    }
+  );
+  resourceHandlers["memory://prime"] = async () => {
+    const content = await getPrimeContext(repoRoot);
+    return { content };
+  };
+}
+function createMcpServer(repoRoot) {
+  const server = new McpServer({
+    name: "compound-agent",
+    version: VERSION
+  });
+  const toolHandlers = {};
+  const resourceHandlers = {};
+  registerSearchTool(server, repoRoot, toolHandlers);
+  registerCaptureTool(server, repoRoot, toolHandlers);
+  registerPrimeResource(server, repoRoot, resourceHandlers);
+  return {
+    server,
+    repoRoot,
+    async callTool(name, params) {
+      const handler = toolHandlers[name];
+      if (!handler) {
+        throw new Error(`Unknown tool: ${name}`);
+      }
+      return handler(params);
+    },
+    async readResource(uri) {
+      const handler = resourceHandlers[uri];
+      if (!handler) {
+        throw new Error(`Unknown resource: ${uri}`);
+      }
+      return handler();
+    }
+  };
+}
+function registerMcpCleanup() {
+  const cleanup = () => {
+    try {
+      closeDb();
+    } catch {
+    }
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+async function main() {
+  registerMcpCleanup();
+  const repoRoot = process.cwd();
+  const { server } = createMcpServer(repoRoot);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+  main().catch((err) => {
+    console.error("MCP Server error:", err);
+    process.exit(1);
+  });
+}
+
+export { createMcpServer, isSearchError, registerMcpCleanup };
+//# sourceMappingURL=mcp.js.map
+//# sourceMappingURL=mcp.js.map