compound-agent 1.0.0

package/dist/index.js

@@ -0,0 +1,1576 @@
+import { createRequire } from 'module';
+import { mkdir, appendFile, readFile } from 'fs/promises';
+import { join, dirname, relative } from 'path';
+import { createHash } from 'crypto';
+import { z } from 'zod';
+import { existsSync, mkdirSync, unlinkSync, statSync, readFileSync, readdirSync } from 'fs';
+import { getLlama, resolveModelFile } from 'node-llama-cpp';
+import { homedir } from 'os';
+import 'chalk';
+import { execSync } from 'child_process';
+
+// src/index.ts
+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 LessonSchema = LessonItemSchema;
+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");
+}
+async function appendLesson(repoRoot, lesson) {
+  return appendMemoryItem(repoRoot, lesson);
+}
+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 };
+}
+async function readLessons(repoRoot, options = {}) {
+  const result = await readMemoryItems(repoRoot, options);
+  const lessons = result.items.filter((item) => item.type === "lesson");
+  return { lessons, skippedCount: result.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);
+}
+function collectCachedEmbeddings(database) {
+  const cache = /* @__PURE__ */ new Map();
+  const rows = database.prepare("SELECT id, embedding, content_hash FROM lessons WHERE embedding IS NOT NULL").all();
+  for (const row of rows) {
+    if (row.embedding && row.content_hash) {
+      cache.set(row.id, { embedding: row.embedding, contentHash: row.content_hash });
+    }
+  }
+  return cache;
+}
+var INSERT_LESSON_SQL = `
+  INSERT INTO lessons (id, type, trigger, insight, evidence, severity, tags, source, context, supersedes, related, created, confirmed, deleted, retrieval_count, last_retrieved, embedding, content_hash, invalidated_at, invalidation_reason, citation_file, citation_line, citation_commit, compaction_level, compacted_at, pattern_bad, pattern_good)
+  VALUES (@id, @type, @trigger, @insight, @evidence, @severity, @tags, @source, @context, @supersedes, @related, @created, @confirmed, @deleted, @retrieval_count, @last_retrieved, @embedding, @content_hash, @invalidated_at, @invalidation_reason, @citation_file, @citation_line, @citation_commit, @compaction_level, @compacted_at, @pattern_bad, @pattern_good)
+`;
+function getJsonlMtime(repoRoot) {
+  const jsonlPath = join(repoRoot, LESSONS_PATH);
+  try {
+    const stat = statSync(jsonlPath);
+    return stat.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function getLastSyncMtime(database) {
+  const row = database.prepare("SELECT value FROM metadata WHERE key = ?").get("last_sync_mtime");
+  return row ? parseFloat(row.value) : null;
+}
+function setLastSyncMtime(database, mtime) {
+  database.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)").run("last_sync_mtime", mtime.toString());
+}
+async function rebuildIndex(repoRoot) {
+  const database = openDb(repoRoot);
+  const { items } = await readMemoryItems(repoRoot);
+  const cachedEmbeddings = collectCachedEmbeddings(database);
+  database.exec("DELETE FROM lessons");
+  if (items.length === 0) {
+    const mtime2 = getJsonlMtime(repoRoot);
+    if (mtime2 !== null) {
+      setLastSyncMtime(database, mtime2);
+    }
+    return;
+  }
+  const insert = database.prepare(INSERT_LESSON_SQL);
+  const insertMany = database.transaction((memoryItems) => {
+    for (const item of memoryItems) {
+      const newHash = contentHash(item.trigger, item.insight);
+      const cached = cachedEmbeddings.get(item.id);
+      const hasValidCache = cached && cached.contentHash === newHash;
+      insert.run({
+        id: item.id,
+        type: item.type,
+        trigger: item.trigger,
+        insight: item.insight,
+        evidence: item.evidence ?? null,
+        severity: item.severity ?? null,
+        tags: item.tags.join(","),
+        source: item.source,
+        context: JSON.stringify(item.context),
+        supersedes: JSON.stringify(item.supersedes),
+        related: JSON.stringify(item.related),
+        created: item.created,
+        confirmed: item.confirmed ? 1 : 0,
+        deleted: item.deleted ? 1 : 0,
+        retrieval_count: item.retrievalCount ?? 0,
+        last_retrieved: item.lastRetrieved ?? null,
+        embedding: hasValidCache ? cached.embedding : null,
+        content_hash: hasValidCache ? cached.contentHash : null,
+        invalidated_at: item.invalidatedAt ?? null,
+        invalidation_reason: item.invalidationReason ?? null,
+        citation_file: item.citation?.file ?? null,
+        citation_line: item.citation?.line ?? null,
+        citation_commit: item.citation?.commit ?? null,
+        compaction_level: item.compactionLevel ?? 0,
+        compacted_at: item.compactedAt ?? null,
+        pattern_bad: item.pattern?.bad ?? null,
+        pattern_good: item.pattern?.good ?? null
+      });
+    }
+  });
+  insertMany(items);
+  const mtime = getJsonlMtime(repoRoot);
+  if (mtime !== null) {
+    setLastSyncMtime(database, mtime);
+  }
+}
+async function syncIfNeeded(repoRoot, options = {}) {
+  const { force = false } = options;
+  const jsonlMtime = getJsonlMtime(repoRoot);
+  if (jsonlMtime === null && !force) {
+    return false;
+  }
+  const database = openDb(repoRoot);
+  const lastSyncMtime = getLastSyncMtime(database);
+  const needsRebuild = force || lastSyncMtime === null || jsonlMtime !== null && jsonlMtime > lastSyncMtime;
+  if (needsRebuild) {
+    await rebuildIndex(repoRoot);
+    return true;
+  }
+  return false;
+}
+
+// src/memory/storage/sqlite/search.ts
+function rowToMemoryItem(row) {
+  const item = {
+    id: row.id,
+    type: row.type,
+    trigger: row.trigger,
+    insight: row.insight,
+    tags: row.tags ? row.tags.split(",").filter(Boolean) : [],
+    source: row.source,
+    context: JSON.parse(row.context),
+    supersedes: JSON.parse(row.supersedes),
+    related: JSON.parse(row.related),
+    created: row.created,
+    confirmed: row.confirmed === 1
+  };
+  if (row.evidence !== null) item.evidence = row.evidence;
+  if (row.severity !== null) item.severity = row.severity;
+  if (row.deleted === 1) item.deleted = true;
+  if (row.retrieval_count > 0) item.retrievalCount = row.retrieval_count;
+  if (row.invalidated_at !== null) item.invalidatedAt = row.invalidated_at;
+  if (row.invalidation_reason !== null) item.invalidationReason = row.invalidation_reason;
+  if (row.citation_file !== null) {
+    item.citation = {
+      file: row.citation_file,
+      ...row.citation_line !== null && { line: row.citation_line },
+      ...row.citation_commit !== null && { commit: row.citation_commit }
+    };
+  }
+  if (row.compaction_level !== null && row.compaction_level !== 0) {
+    item.compactionLevel = row.compaction_level;
+  }
+  if (row.compacted_at !== null) item.compactedAt = row.compacted_at;
+  if (row.last_retrieved !== null) item.lastRetrieved = row.last_retrieved;
+  if (row.pattern_bad !== null && row.pattern_good !== null) {
+    item.pattern = { bad: row.pattern_bad, good: row.pattern_good };
+  }
+  const result = MemoryItemSchema.safeParse(item);
+  if (!result.success) return null;
+  return result.data;
+}
+var FTS_OPERATORS = /* @__PURE__ */ new Set(["AND", "OR", "NOT", "NEAR"]);
+function sanitizeFtsQuery(query) {
+  const stripped = query.replace(/["*^+-]/g, "");
+  const tokens = stripped.split(/\s+/).filter((t) => t.length > 0 && !FTS_OPERATORS.has(t));
+  return tokens.join(" ");
+}
+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);
+}
+async function searchKeyword(repoRoot, query, limit, typeFilter) {
+  const database = openDb(repoRoot);
+  const countResult = database.prepare("SELECT COUNT(*) as cnt FROM lessons").get();
+  if (countResult.cnt === 0) return [];
+  const sanitized = sanitizeFtsQuery(query);
+  if (sanitized === "") return [];
+  try {
+    if (typeFilter) {
+      const rows2 = database.prepare(
+        `
+          SELECT l.*
+          FROM lessons l
+          JOIN lessons_fts fts ON l.rowid = fts.rowid
+          WHERE lessons_fts MATCH ?
+            AND l.invalidated_at IS NULL
+            AND l.type = ?
+          LIMIT ?
+        `
+      ).all(sanitized, typeFilter, limit);
+      return rows2.map(rowToMemoryItem).filter((x) => x !== null);
+    }
+    const rows = database.prepare(
+      `
+        SELECT l.*
+        FROM lessons l
+        JOIN lessons_fts fts ON l.rowid = fts.rowid
+        WHERE lessons_fts MATCH ?
+          AND l.invalidated_at IS NULL
+        LIMIT ?
+      `
+    ).all(sanitized, limit);
+    return rows.map(rowToMemoryItem).filter((x) => x !== null);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown FTS5 error";
+    console.error(`[compound-agent] search error: ${message}`);
+    return [];
+  }
+}
+
+// src/utils.ts
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function getLessonAgeDays(lesson) {
+  const created = new Date(lesson.created).getTime();
+  const now = Date.now();
+  return Math.floor((now - created) / MS_PER_DAY);
+}
+var 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");
+var cachedUsability = null;
+function isModelAvailable() {
+  return existsSync(join(DEFAULT_MODEL_DIR, MODEL_FILENAME));
+}
+async function isModelUsable() {
+  if (cachedUsability !== null) {
+    return cachedUsability;
+  }
+  if (!isModelAvailable()) {
+    cachedUsability = {
+      usable: false,
+      reason: "Embedding model file not found",
+      action: "Run: npx ca download-model"
+    };
+    return cachedUsability;
+  }
+  let llama = null;
+  let model = null;
+  let context = null;
+  try {
+    const modelPath = join(DEFAULT_MODEL_DIR, MODEL_FILENAME);
+    llama = await getLlama();
+    model = await llama.loadModel({ modelPath });
+    context = await model.createEmbeddingContext();
+    cachedUsability = { usable: true };
+    return cachedUsability;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    cachedUsability = {
+      usable: false,
+      reason: `Embedding model runtime initialization failed: ${message}`,
+      action: "Check system compatibility or reinstall: npx ca download-model"
+    };
+    return cachedUsability;
+  } finally {
+    if (context) {
+      try {
+        context.dispose();
+      } catch {
+      }
+    }
+  }
+}
+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;
+}
+function unloadEmbedding() {
+  if (embeddingContext) {
+    embeddingContext.dispose();
+    embeddingContext = null;
+  }
+  if (modelInstance) {
+    modelInstance.dispose().catch(() => {
+    });
+    modelInstance = null;
+  }
+  if (llamaInstance) {
+    llamaInstance.dispose().catch(() => {
+    });
+    llamaInstance = null;
+  }
+  pendingInit = null;
+}
+async function embedText(text) {
+  const ctx = await getEmbedding();
+  const result = await ctx.getEmbeddingFor(text);
+  return Array.from(result.vector);
+}
+async function embedTexts(texts) {
+  if (texts.length === 0) return [];
+  const ctx = await getEmbedding();
+  const results = [];
+  for (const text of texts) {
+    const result = await ctx.getEmbeddingFor(text);
+    results.push(Array.from(result.vector));
+  }
+  return results;
+}
+
+// src/compound/clustering.ts
+var DEFAULT_THRESHOLD = 0.75;
+function buildSimilarityMatrix(embeddings) {
+  const n = embeddings.length;
+  const matrix = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    matrix[i][i] = 1;
+    for (let j = i + 1; j < n; j++) {
+      const sim = cosineSimilarity(embeddings[i], embeddings[j]);
+      matrix[i][j] = sim;
+      matrix[j][i] = sim;
+    }
+  }
+  return matrix;
+}
+function clusterBySimilarity(items, embeddings, threshold = DEFAULT_THRESHOLD) {
+  const n = items.length;
+  if (n === 0) return { clusters: [], noise: [] };
+  const matrix = buildSimilarityMatrix(embeddings);
+  const parent = Array.from({ length: n }, (_, i) => i);
+  function find(x) {
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  }
+  function union(a, b) {
+    const rootA = find(a);
+    const rootB = find(b);
+    if (rootA !== rootB) parent[rootA] = rootB;
+  }
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (matrix[i][j] >= threshold) {
+        union(i, j);
+      }
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const root = find(i);
+    let group = groups.get(root);
+    if (!group) {
+      group = [];
+      groups.set(root, group);
+    }
+    group.push(items[i]);
+  }
+  const clusters = Array.from(groups.values());
+  return { clusters, noise: [] };
+}
+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
+});
+function generateCctId(input) {
+  const hash = createHash("sha256").update(input).digest("hex");
+  return `CCT-${hash.slice(0, 8)}`;
+}
+
+// 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;
+}
+async function writeCctPatterns(repoRoot, patterns) {
+  const filePath = join(repoRoot, CCT_PATTERNS_PATH);
+  await mkdir(dirname(filePath), { recursive: true });
+  const lines = patterns.map((p) => JSON.stringify(p) + "\n").join("");
+  await appendFile(filePath, lines, "utf-8");
+}
+
+// src/compound/synthesis.ts
+function synthesizePattern(cluster, clusterId) {
+  const id = generateCctId(clusterId);
+  const frequency = cluster.length;
+  const sourceIds = cluster.map((item) => item.id);
+  const tagCounts = /* @__PURE__ */ new Map();
+  for (const item of cluster) {
+    for (const tag of item.tags) {
+      tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+    }
+  }
+  const sortedTags = [...tagCounts.entries()].sort((a, b) => b[1] - a[1]).map(([tag]) => tag);
+  const name = sortedTags.length > 0 ? sortedTags.slice(0, 3).join(", ") : cluster[0].insight.slice(0, 50);
+  const description = cluster.map((item) => item.insight).join("; ");
+  const hasHighSeverity = cluster.some(
+    (item) => "severity" in item && item.severity === "high"
+  );
+  const hasEvidence = cluster.some(
+    (item) => "evidence" in item && item.evidence
+  );
+  const testable = hasHighSeverity || hasEvidence;
+  const testApproach = testable ? `Verify pattern: ${name}. Check ${frequency} related lesson(s).` : void 0;
+  return {
+    id,
+    name,
+    description,
+    frequency,
+    testable,
+    ...testApproach !== void 0 && { testApproach },
+    sourceIds,
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// 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_LIMIT = 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_LIMIT;
+  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));
+}
+var rankMemoryItems = rankLessons;
+
+// src/memory/capture/quality.ts
+var DEFAULT_SIMILARITY_THRESHOLD = 0.8;
+async function isNovel(repoRoot, insight, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+  await syncIfNeeded(repoRoot);
+  const words = insight.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3).slice(0, 3);
+  if (words.length === 0) {
+    return { novel: true };
+  }
+  const searchQuery = words.join(" OR ");
+  const results = await searchKeyword(repoRoot, searchQuery, 10);
+  if (results.length === 0) {
+    return { novel: true };
+  }
+  return checkSimilarity(insight, results, threshold);
+}
+function checkSimilarity(insight, lessons, threshold) {
+  const insightWords = new Set(insight.toLowerCase().split(/\s+/));
+  for (const lesson of lessons) {
+    const lessonWords = new Set(lesson.insight.toLowerCase().split(/\s+/));
+    const intersection = [...insightWords].filter((w) => lessonWords.has(w)).length;
+    const union = (/* @__PURE__ */ new Set([...insightWords, ...lessonWords])).size;
+    const similarity = union > 0 ? intersection / union : 0;
+    if (similarity >= threshold) {
+      return {
+        novel: false,
+        reason: `Found similar existing lesson: "${lesson.insight.slice(0, 50)}..."`,
+        existingId: lesson.id
+      };
+    }
+  }
+  return { novel: true };
+}
+var MIN_WORD_COUNT = 4;
+var VAGUE_PATTERNS = [
+  /\bwrite better\b/i,
+  /\bbe careful\b/i,
+  /\bremember to\b/i,
+  /\bmake sure\b/i,
+  /\btry to\b/i,
+  /\bdouble check\b/i
+];
+var GENERIC_IMPERATIVE_PATTERN = /^(always|never)\s+\w+(\s+\w+){0,2}$/i;
+function isSpecific(insight) {
+  const words = insight.trim().split(/\s+/).filter((w) => w.length > 0);
+  if (words.length < MIN_WORD_COUNT) {
+    return { specific: false, reason: "Insight is too short to be actionable" };
+  }
+  for (const pattern of VAGUE_PATTERNS) {
+    if (pattern.test(insight)) {
+      return { specific: false, reason: "Insight matches a vague pattern" };
+    }
+  }
+  if (GENERIC_IMPERATIVE_PATTERN.test(insight)) {
+    return { specific: false, reason: "Insight matches a vague pattern" };
+  }
+  return { specific: true };
+}
+var ACTION_PATTERNS = [
+  /\buse\s+.+\s+instead\s+of\b/i,
+  // "use X instead of Y"
+  /\bprefer\s+.+\s+(over|to)\b/i,
+  // "prefer X over Y" or "prefer X to Y"
+  /\balways\s+.+\s+when\b/i,
+  // "always X when Y"
+  /\bnever\s+.+\s+without\b/i,
+  // "never X without Y"
+  /\bavoid\s+(using\s+)?\w+/i,
+  // "avoid X" or "avoid using X"
+  /\bcheck\s+.+\s+before\b/i,
+  // "check X before Y"
+  /^(run|use|add|remove|install|update|configure|set|enable|disable)\s+/i
+  // Imperative commands at start
+];
+function isActionable(insight) {
+  for (const pattern of ACTION_PATTERNS) {
+    if (pattern.test(insight)) {
+      return { actionable: true };
+    }
+  }
+  return { actionable: false, reason: "Insight lacks clear action guidance" };
+}
+async function shouldPropose(repoRoot, insight) {
+  const specificResult = isSpecific(insight);
+  if (!specificResult.specific) {
+    return { shouldPropose: false, reason: specificResult.reason };
+  }
+  const noveltyResult = await isNovel(repoRoot, insight);
+  if (!noveltyResult.novel) {
+    return { shouldPropose: false, reason: noveltyResult.reason };
+  }
+  return { shouldPropose: true };
+}
+
+// src/memory/capture/triggers.ts
+var USER_CORRECTION_PATTERNS = [
+  /\bno\b[,.]?\s/i,
+  // "no, ..." or "no ..."
+  /\bwrong\b/i,
+  // "wrong"
+  /\bactually\b/i,
+  // "actually..."
+  /\bnot that\b/i,
+  // "not that"
+  /\bi meant\b/i
+  // "I meant"
+];
+function detectUserCorrection(signals) {
+  const { messages, context } = signals;
+  if (messages.length < 2) {
+    return null;
+  }
+  for (let i = 1; i < messages.length; i++) {
+    const message = messages[i];
+    if (!message) continue;
+    for (const pattern of USER_CORRECTION_PATTERNS) {
+      if (pattern.test(message)) {
+        return {
+          trigger: `User correction during ${context.intent}`,
+          correctionMessage: message,
+          context
+        };
+      }
+    }
+  }
+  return null;
+}
+function detectSelfCorrection(history) {
+  const { edits } = history;
+  if (edits.length < 3) {
+    return null;
+  }
+  for (let i = 0; i <= edits.length - 3; i++) {
+    const first = edits[i];
+    const second = edits[i + 1];
+    const third = edits[i + 2];
+    if (!first || !second || !third) continue;
+    if (first.file === second.file && second.file === third.file && first.success && !second.success && third.success) {
+      return {
+        file: first.file,
+        trigger: `Self-correction on ${first.file}`
+      };
+    }
+  }
+  return null;
+}
+function detectTestFailure(testResult) {
+  if (testResult.passed) {
+    return null;
+  }
+  const lines = testResult.output.split("\n").filter((line) => line.trim().length > 0);
+  const errorLine = lines.find((line) => /error|fail|assert/i.test(line)) ?? lines[0] ?? "";
+  return {
+    testFile: testResult.testFile,
+    errorOutput: testResult.output,
+    trigger: `Test failure in ${testResult.testFile}: ${errorLine.slice(0, 100)}`
+  };
+}
+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 })
+]);
+
+// src/memory/retrieval/session.ts
+var DEFAULT_LIMIT2 = 5;
+function hasSeverity(item) {
+  return item.severity !== void 0;
+}
+async function loadSessionLessons(repoRoot, limit = DEFAULT_LIMIT2) {
+  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 loadSessionMemory = loadSessionLessons;
+
+// src/memory/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);
+  if (topLessons.length > 0) {
+    incrementRetrievalCount(repoRoot, topLessons.map((item) => item.lesson.id));
+  }
+  const message = formatLessonsCheck(topLessons);
+  return { lessons: topLessons, message };
+}
+function formatLessonsCheck(lessons) {
+  const header = "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")}`;
+}
+var formatMemoryCheck = formatLessonsCheck;
+
+// src/cli-utils.ts
+function getRepoRoot() {
+  return process.env["COMPOUND_AGENT_ROOT"] ?? process.cwd();
+}
+
+// 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/audit/checks/lessons.ts
+async function checkLessons(repoRoot) {
+  const { items } = await readMemoryItems(repoRoot);
+  const findings = [];
+  for (const item of items) {
+    if (item.severity === "high") {
+      findings.push({
+        file: "",
+        issue: `High-severity lesson: ${item.insight}`,
+        severity: "info",
+        relatedLessonId: item.id,
+        source: "lesson"
+      });
+    }
+  }
+  const filesChecked = items.length > 0 ? [LESSONS_PATH] : [];
+  return { findings, filesChecked };
+}
+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()
+});
+var RuleConfigSchema = z.object({
+  rules: z.array(RuleSchema)
+});
+function globToRegex(glob) {
+  const pattern = glob.replace(/\./g, "\\.").replace(/\*\*\//g, "(.+/)?").replace(/\*/g, "[^/]*");
+  return new RegExp(`^${pattern}$`);
+}
+function findFiles(baseDir, glob) {
+  const regex = globToRegex(glob);
+  const results = [];
+  function walk(dir) {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules") continue;
+      const fullPath = join(dir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else {
+        const relPath = relative(baseDir, fullPath);
+        if (regex.test(relPath)) {
+          results.push(relPath);
+        }
+      }
+    }
+  }
+  walk(baseDir);
+  return results.sort();
+}
+
+// src/rules/checks/file-pattern.ts
+function runFilePatternCheck(baseDir, check) {
+  const files = findFiles(baseDir, check.glob);
+  const regex = new RegExp(check.pattern);
+  const violations = [];
+  for (const file of files) {
+    const fullPath = join(baseDir, file);
+    const content = readFileSync(fullPath, "utf-8");
+    const lines = content.split("\n");
+    if (check.mustMatch) {
+      const found = lines.some((line) => regex.test(line));
+      if (!found) {
+        violations.push({
+          file,
+          message: `Pattern ${check.pattern} missing from file`
+        });
+      }
+    } else {
+      for (let i = 0; i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          violations.push({
+            file,
+            line: i + 1,
+            message: `Pattern ${check.pattern} matched`
+          });
+        }
+      }
+    }
+  }
+  return violations;
+}
+function runFileSizeCheck(baseDir, check) {
+  const files = findFiles(baseDir, check.glob);
+  const violations = [];
+  for (const file of files) {
+    const content = readFileSync(join(baseDir, file), "utf-8");
+    const lineCount = content === "" ? 0 : content.split("\n").filter((_, i, arr) => i < arr.length - 1 || arr[i] !== "").length;
+    if (lineCount > check.maxLines) {
+      violations.push({
+        file,
+        message: `File has ${lineCount} lines, exceeds limit of ${check.maxLines}`
+      });
+    }
+  }
+  return violations;
+}
+function runScriptCheck(check, baseDir) {
+  const expectedCode = check.expectExitCode ?? 0;
+  try {
+    execSync(check.command, { stdio: ["pipe", "pipe", "pipe"], cwd: baseDir });
+    if (expectedCode !== 0) {
+      return [{ message: `Script exited with exit code 0, expected ${expectedCode}` }];
+    }
+    return [];
+  } catch (err) {
+    const exitCode = err.status ?? 1;
+    if (exitCode === expectedCode) {
+      return [];
+    }
+    const stderr = (err.stderr ?? Buffer.alloc(0)).toString("utf-8").trim();
+    const msg = stderr ? `Script exited with exit code ${exitCode} (expected ${expectedCode}): ${stderr}` : `Script exited with exit code ${exitCode} (expected ${expectedCode})`;
+    return [{ message: msg }];
+  }
+}
+
+// src/rules/engine.ts
+function loadRuleConfig(baseDir) {
+  const configPath = join(baseDir, ".claude", "rules.json");
+  if (!existsSync(configPath)) {
+    return { rules: [] };
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const json = JSON.parse(raw);
+  return RuleConfigSchema.parse(json);
+}
+function runRules(baseDir, rules) {
+  return rules.map((rule) => {
+    try {
+      const violations = runCheck(baseDir, rule);
+      return { rule, violations, passed: violations.length === 0 };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Rule check failed";
+      return { rule, violations: [{ message: `Rule check error: ${message}` }], passed: false };
+    }
+  });
+}
+function runCheck(baseDir, rule) {
+  switch (rule.check.type) {
+    case "file-pattern":
+      return runFilePatternCheck(baseDir, rule.check);
+    case "file-size":
+      return runFileSizeCheck(baseDir, rule.check);
+    case "script":
+      return runScriptCheck(rule.check, baseDir);
+  }
+}
+
+// src/audit/checks/patterns.ts
+async function checkPatterns(repoRoot) {
+  const { items } = await readMemoryItems(repoRoot);
+  const patterned = items.filter((item) => item.pattern?.bad);
+  if (patterned.length === 0) {
+    return { findings: [], filesChecked: [] };
+  }
+  const sourceFiles = findFiles(repoRoot, "**/*.ts");
+  const findings = [];
+  for (const item of patterned) {
+    const bad = item.pattern.bad;
+    for (const relPath of sourceFiles) {
+      const content = readFileSync(join(repoRoot, relPath), "utf-8");
+      if (content.includes(bad)) {
+        findings.push({
+          file: relPath,
+          issue: `Bad pattern found: "${bad}" (${item.insight})`,
+          severity: "warning",
+          relatedLessonId: item.id,
+          suggestedFix: item.pattern.good ? `Use: ${item.pattern.good}` : void 0,
+          source: "pattern"
+        });
+      }
+    }
+  }
+  return { findings, filesChecked: sourceFiles };
+}
+
+// src/audit/checks/rules.ts
+function checkRules(repoRoot) {
+  let config;
+  try {
+    config = loadRuleConfig(repoRoot);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to load rules config";
+    return {
+      findings: [{
+        file: ".claude/rules.json",
+        issue: `Invalid rules configuration: ${message}`,
+        severity: "error",
+        source: "rule"
+      }],
+      filesChecked: []
+    };
+  }
+  if (config.rules.length === 0) {
+    return { findings: [], filesChecked: [] };
+  }
+  const results = runRules(repoRoot, config.rules);
+  const findings = [];
+  const filesCheckedSet = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    for (const violation of result.violations) {
+      if (violation.file) {
+        filesCheckedSet.add(violation.file);
+      }
+      findings.push({
+        file: violation.file ?? "",
+        issue: violation.message,
+        severity: result.rule.severity,
+        suggestedFix: result.rule.remediation,
+        source: "rule"
+      });
+    }
+  }
+  return { findings, filesChecked: [...filesCheckedSet] };
+}
+
+// src/audit/engine.ts
+async function runAudit(repoRoot, options = {}) {
+  const { includeRules = true, includePatterns = true, includeLessons = true } = options;
+  const findings = [];
+  const allCheckedFiles = /* @__PURE__ */ new Set();
+  function collect(result) {
+    findings.push(...result.findings);
+    for (const f of result.filesChecked) {
+      allCheckedFiles.add(f);
+    }
+  }
+  if (includeRules) {
+    collect(checkRules(repoRoot));
+  }
+  if (includePatterns) {
+    collect(await checkPatterns(repoRoot));
+  }
+  if (includeLessons) {
+    collect(await checkLessons(repoRoot));
+  }
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const infos = findings.filter((f) => f.severity === "info").length;
+  return {
+    findings,
+    summary: { errors, warnings, infos, filesChecked: allCheckedFiles.size },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+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()
+});
+var AuditReportSchema = 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;
+
+export { AuditFindingSchema, AuditReportSchema, CCT_PATTERNS_PATH, CctPatternSchema, DB_PATH, LESSONS_PATH, LegacyLessonSchema, LegacyTombstoneSchema, LessonItemSchema, LessonRecordSchema, LessonSchema, LessonTypeSchema, MODEL_FILENAME, MODEL_URI, MemoryItemRecordSchema, MemoryItemSchema, MemoryItemTypeSchema, PatternItemSchema, PreferenceItemSchema, SolutionItemSchema, VERSION, appendLesson, appendMemoryItem, buildSimilarityMatrix, calculateScore, closeDb, clusterBySimilarity, confirmationBoost, cosineSimilarity, detectSelfCorrection, detectTestFailure, detectUserCorrection, embedText, embedTexts, formatLessonsCheck, formatMemoryCheck, generateId, getEmbedding, getPrimeContext, isActionable, isModelAvailable, isModelUsable, isNovel, isSpecific, loadSessionLessons, loadSessionMemory, rankLessons, rankMemoryItems, readCctPatterns, readLessons, readMemoryItems, rebuildIndex, recencyBoost, resolveModel, retrieveForPlan, runAudit, searchKeyword, searchVector, severityBoost, shouldPropose, synthesizePattern, unloadEmbedding, writeCctPatterns };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map