compound-agent 1.8.0 → 2.0.0

package/dist/index.js

@@ -1,3251 +0,0 @@
-import { createHash } from 'crypto';
-import { z } from 'zod';
-import { mkdir, appendFile, readFile, readdir } from 'fs/promises';
-import { join, dirname, extname, relative } from 'path';
-import { createRequire } from 'module';
-import { existsSync, mkdirSync, unlinkSync, writeFileSync, readFileSync, statSync, readdirSync } from 'fs';
-import { homedir } from 'os';
-import { resolveModelFile, getLlama, LlamaLogLevel } from 'node-llama-cpp';
-import { spawn, execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import 'chalk';
-
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-function generateId(insight, type) {
-  const prefix = TYPE_PREFIXES[type ?? "lesson"];
-  const hash = createHash("sha256").update(insight).digest("hex");
-  return `${prefix}${hash.slice(0, 16)}`;
-}
-var SourceSchema, ContextSchema, PatternSchema, CitationSchema, SeveritySchema, CompactionLevelSchema, LessonTypeSchema, MemoryItemTypeSchema, baseFields, LessonItemSchema, SolutionItemSchema, PatternItemSchema, PreferenceItemSchema, MemoryItemSchema, LegacyLessonSchema, LessonSchema, LegacyTombstoneSchema, LessonRecordSchema, MemoryItemRecordSchema, TYPE_PREFIXES;
-var init_types = __esm({
-  "src/memory/types.ts"() {
-    SourceSchema = z.enum([
-      "user_correction",
-      "self_correction",
-      "test_failure",
-      "manual"
-    ]);
-    ContextSchema = z.object({
-      tool: z.string(),
-      intent: z.string()
-    });
-    PatternSchema = z.object({
-      bad: z.string(),
-      good: z.string()
-    });
-    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)
-    });
-    SeveritySchema = z.enum(["high", "medium", "low"]);
-    CompactionLevelSchema = z.union([
-      z.literal(0),
-      // Active
-      z.literal(1),
-      // Flagged (>90 days)
-      z.literal(2)
-      // Archived
-    ]);
-    LessonTypeSchema = z.enum(["quick", "full"]);
-    MemoryItemTypeSchema = z.enum(["lesson", "solution", "pattern", "preference"]);
-    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()
-    };
-    LessonItemSchema = z.object({
-      ...baseFields,
-      type: z.literal("lesson"),
-      pattern: PatternSchema.optional()
-    });
-    SolutionItemSchema = z.object({
-      ...baseFields,
-      type: z.literal("solution"),
-      pattern: PatternSchema.optional()
-    });
-    PatternItemSchema = z.object({
-      ...baseFields,
-      type: z.literal("pattern"),
-      pattern: PatternSchema
-    });
-    PreferenceItemSchema = z.object({
-      ...baseFields,
-      type: z.literal("preference"),
-      pattern: PatternSchema.optional()
-    });
-    MemoryItemSchema = z.discriminatedUnion("type", [
-      LessonItemSchema,
-      SolutionItemSchema,
-      PatternItemSchema,
-      PreferenceItemSchema
-    ]);
-    LegacyLessonSchema = z.object({
-      ...baseFields,
-      type: LessonTypeSchema,
-      pattern: PatternSchema.optional()
-    });
-    LessonSchema = LessonItemSchema;
-    LegacyTombstoneSchema = z.object({
-      id: z.string(),
-      deleted: z.literal(true),
-      deletedAt: z.string()
-      // ISO8601
-    });
-    LessonRecordSchema = z.union([
-      MemoryItemSchema,
-      LegacyLessonSchema,
-      LegacyTombstoneSchema
-    ]);
-    MemoryItemRecordSchema = LessonRecordSchema;
-    TYPE_PREFIXES = {
-      lesson: "L",
-      solution: "S",
-      pattern: "P",
-      preference: "R"
-    };
-  }
-});
-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: [], deletedIds: /* @__PURE__ */ new Set(), skippedCount: 0 };
-    }
-    throw err;
-  }
-  const items = /* @__PURE__ */ new Map();
-  const deletedIds = /* @__PURE__ */ new Set();
-  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);
-      deletedIds.add(record.id);
-    } else {
-      const item = toMemoryItem(record);
-      if (item) {
-        items.set(record.id, item);
-      }
-    }
-  }
-  return { items: Array.from(items.values()), deletedIds, 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 LESSONS_PATH;
-var init_jsonl = __esm({
-  "src/memory/storage/jsonl.ts"() {
-    init_types();
-    LESSONS_PATH = ".claude/lessons/index.jsonl";
-  }
-});
-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.\nFor pnpm projects:\n  1. Ensure package.json has: "pnpm": { "onlyBuiltDependencies": ["better-sqlite3"] }\n  2. Run: pnpm install && pnpm rebuild better-sqlite3\nFor npm/yarn projects:\n  Run: npm rebuild better-sqlite3\nIf the error persists, check that build tools (python3, make, g++) are installed.',
-      { cause }
-    );
-  }
-}
-function getDatabaseConstructor() {
-  ensureSqliteAvailable();
-  return DatabaseConstructor;
-}
-var require2, checked, DatabaseConstructor;
-var init_availability = __esm({
-  "src/memory/storage/sqlite/availability.ts"() {
-    require2 = createRequire(import.meta.url);
-    checked = false;
-    DatabaseConstructor = null;
-  }
-});
-
-// src/memory/storage/sqlite/schema.ts
-function createSchema(database) {
-  database.exec(SCHEMA_SQL);
-  const current = database.pragma("user_version", { simple: true });
-  if (current !== SCHEMA_VERSION) {
-    database.pragma(`user_version = ${SCHEMA_VERSION}`);
-  }
-}
-var SCHEMA_VERSION, SCHEMA_SQL;
-var init_schema = __esm({
-  "src/memory/storage/sqlite/schema.ts"() {
-    SCHEMA_VERSION = 5;
-    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,
-    embedding_insight BLOB,
-    content_hash_insight 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 OF id, trigger, insight, tags, pattern_bad, pattern_good 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 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();
-      try {
-        unlinkSync(key);
-      } catch {
-      }
-      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();
-}
-var DB_PATH, dbMap;
-var init_connection = __esm({
-  "src/memory/storage/sqlite/connection.ts"() {
-    init_availability();
-    init_schema();
-    DB_PATH = ".claude/.cache/lessons.sqlite";
-    dbMap = /* @__PURE__ */ new Map();
-  }
-});
-function contentHash(trigger, insight) {
-  return createHash("sha256").update(`${trigger} ${insight}`).digest("hex");
-}
-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 getCachedEmbeddingsBulk(repoRoot) {
-  const database = openDb(repoRoot);
-  const rows = database.prepare("SELECT id, embedding, content_hash FROM lessons WHERE embedding IS NOT NULL").all();
-  const result = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (!row.content_hash) continue;
-    const float32 = new Float32Array(
-      row.embedding.buffer,
-      row.embedding.byteOffset,
-      row.embedding.byteLength / 4
-    );
-    result.set(row.id, { vector: float32, hash: row.content_hash });
-  }
-  return result;
-}
-function getCachedInsightEmbedding(repoRoot, lessonId, expectedHash) {
-  const database = openDb(repoRoot);
-  const row = database.prepare("SELECT embedding_insight, content_hash_insight FROM lessons WHERE id = ?").get(lessonId);
-  if (!row || !row.embedding_insight || !row.content_hash_insight) {
-    return null;
-  }
-  if (expectedHash && row.content_hash_insight !== expectedHash) {
-    return null;
-  }
-  return new Float32Array(
-    row.embedding_insight.buffer,
-    row.embedding_insight.byteOffset,
-    row.embedding_insight.byteLength / 4
-  );
-}
-function setCachedInsightEmbedding(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_insight = ?, content_hash_insight = ? WHERE id = ?").run(buffer, hash, lessonId);
-}
-function collectCachedEmbeddings(database) {
-  const cache = /* @__PURE__ */ new Map();
-  const rows = database.prepare("SELECT id, embedding, content_hash, embedding_insight, content_hash_insight FROM lessons WHERE embedding IS NOT NULL OR embedding_insight 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,
-        embeddingInsight: row.embedding_insight,
-        contentHashInsight: row.content_hash_insight
-      });
-    } else if (row.embedding_insight && row.content_hash_insight) {
-      cache.set(row.id, {
-        embedding: row.embedding_insight,
-        // placeholder, won't match hash
-        contentHash: "",
-        embeddingInsight: row.embedding_insight,
-        contentHashInsight: row.content_hash_insight
-      });
-    }
-  }
-  return cache;
-}
-var init_cache = __esm({
-  "src/memory/storage/sqlite/cache.ts"() {
-    init_connection();
-  }
-});
-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 insightHash = contentHash(item.insight, "");
-      const cached = cachedEmbeddings.get(item.id);
-      const hasValidCache = cached && cached.contentHash === newHash;
-      const hasValidInsightCache = cached && cached.contentHashInsight === insightHash;
-      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,
-        embedding_insight: hasValidInsightCache ? cached.embeddingInsight : null,
-        content_hash_insight: hasValidInsightCache ? cached.contentHashInsight : 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;
-}
-var INSERT_LESSON_SQL;
-var init_sync = __esm({
-  "src/memory/storage/sqlite/sync.ts"() {
-    init_jsonl();
-    init_connection();
-    init_cache();
-    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, embedding_insight, content_hash_insight, 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, @embedding_insight, @content_hash_insight, @invalidated_at, @invalidation_reason, @citation_file, @citation_line, @citation_commit, @compaction_level, @compacted_at, @pattern_bad, @pattern_good)
-`;
-  }
-});
-
-// src/memory/search/hybrid.ts
-function normalizeBm25Rank(rank) {
-  if (!Number.isFinite(rank)) return 0;
-  const abs = Math.abs(rank);
-  return abs / (1 + abs);
-}
-function mergeHybridScores(vectorResults, keywordResults, getId, options) {
-  if (vectorResults.length === 0 && keywordResults.length === 0) return [];
-  const rawVecW = options?.vectorWeight ?? DEFAULT_VECTOR_WEIGHT;
-  const rawTxtW = options?.textWeight ?? DEFAULT_TEXT_WEIGHT;
-  const total = rawVecW + rawTxtW;
-  if (total <= 0) return [];
-  const vecW = rawVecW / total;
-  const txtW = rawTxtW / total;
-  const limit = options?.limit;
-  const minScore = options?.minScore;
-  const merged = /* @__PURE__ */ new Map();
-  for (const v of vectorResults) {
-    merged.set(getId(v.item), { item: v.item, vecScore: v.score, txtScore: 0 });
-  }
-  for (const k of keywordResults) {
-    const id = getId(k.item);
-    const existing = merged.get(id);
-    if (existing) {
-      existing.txtScore = k.score;
-    } else {
-      merged.set(id, { item: k.item, vecScore: 0, txtScore: k.score });
-    }
-  }
-  const results = [];
-  for (const entry of merged.values()) {
-    results.push({
-      item: entry.item,
-      score: vecW * entry.vecScore + txtW * entry.txtScore
-    });
-  }
-  results.sort((a, b) => b.score - a.score);
-  const filtered = minScore !== void 0 ? results.filter((r) => r.score >= minScore) : results;
-  return limit !== void 0 ? filtered.slice(0, limit) : filtered;
-}
-function mergeHybridResults(vectorResults, keywordResults, options) {
-  const genericVec = vectorResults.map((v) => ({ item: v.lesson, score: v.score }));
-  const genericKw = keywordResults.map((k) => ({ item: k.lesson, score: k.score }));
-  const merged = mergeHybridScores(genericVec, genericKw, (item) => item.id, options);
-  return merged.map((m) => ({ lesson: m.item, score: m.score }));
-}
-var DEFAULT_VECTOR_WEIGHT, DEFAULT_TEXT_WEIGHT, CANDIDATE_MULTIPLIER, MIN_HYBRID_SCORE;
-var init_hybrid = __esm({
-  "src/memory/search/hybrid.ts"() {
-    DEFAULT_VECTOR_WEIGHT = 0.7;
-    DEFAULT_TEXT_WEIGHT = 0.3;
-    CANDIDATE_MULTIPLIER = 4;
-    MIN_HYBRID_SCORE = 0.35;
-  }
-});
-
-// src/memory/storage/sqlite/search.ts
-function safeJsonParse(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-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: safeJsonParse(row.context, {}),
-    supersedes: safeJsonParse(row.supersedes, []),
-    related: safeJsonParse(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;
-}
-function readAllFromSqlite(repoRoot) {
-  const database = openDb(repoRoot);
-  const rows = database.prepare("SELECT * FROM lessons WHERE invalidated_at IS NULL").all();
-  return rows.map(rowToMemoryItem).filter((x) => x !== null);
-}
-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);
-}
-function executeFtsQuery(repoRoot, query, limit, options) {
-  const database = openDb(repoRoot);
-  const sanitized = sanitizeFtsQuery(query);
-  if (sanitized === "") return [];
-  const selectCols = options.includeRank ? "l.*, fts.rank" : "l.*";
-  const orderClause = options.includeRank ? "ORDER BY fts.rank" : "";
-  const typeClause = options.typeFilter ? "AND l.type = ?" : "";
-  const sql = `
-    SELECT ${selectCols}
-    FROM lessons l
-    JOIN lessons_fts fts ON l.rowid = fts.rowid
-    WHERE lessons_fts MATCH ?
-      AND l.invalidated_at IS NULL
-      ${typeClause}
-    ${orderClause}
-    LIMIT ?
-  `;
-  const params = options.typeFilter ? [sanitized, options.typeFilter, limit] : [sanitized, limit];
-  try {
-    return database.prepare(sql).all(...params);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Unknown FTS5 error";
-    console.error(`[compound-agent] search error: ${message}`);
-    return [];
-  }
-}
-async function searchKeyword(repoRoot, query, limit, typeFilter) {
-  const rows = executeFtsQuery(repoRoot, query, limit, { includeRank: false, typeFilter });
-  return rows.map(rowToMemoryItem).filter((x) => x !== null);
-}
-async function searchKeywordScored(repoRoot, query, limit, typeFilter) {
-  const rows = executeFtsQuery(repoRoot, query, limit, { includeRank: true, typeFilter });
-  const results = [];
-  for (const row of rows) {
-    const lesson = rowToMemoryItem(row);
-    if (lesson) {
-      results.push({ lesson, score: normalizeBm25Rank(row.rank) });
-    }
-  }
-  return results;
-}
-var FTS_OPERATORS;
-var init_search = __esm({
-  "src/memory/storage/sqlite/search.ts"() {
-    init_types();
-    init_hybrid();
-    init_connection();
-    FTS_OPERATORS = /* @__PURE__ */ new Set(["AND", "OR", "NOT", "NEAR"]);
-  }
-});
-
-// src/memory/storage/sqlite/index.ts
-var init_sqlite = __esm({
-  "src/memory/storage/sqlite/index.ts"() {
-    init_connection();
-    init_cache();
-    init_sync();
-    init_availability();
-    init_search();
-  }
-});
-var init_compact = __esm({
-  "src/memory/storage/compact.ts"() {
-    init_types();
-    init_jsonl();
-  }
-});
-
-// src/memory/storage/index.ts
-var init_storage = __esm({
-  "src/memory/storage/index.ts"() {
-    init_jsonl();
-    init_sqlite();
-    init_compact();
-  }
-});
-
-// src/memory/embeddings/model.ts
-var model_exports = {};
-__export(model_exports, {
-  MODEL_FILENAME: () => MODEL_FILENAME,
-  MODEL_URI: () => MODEL_URI,
-  clearUsabilityCache: () => clearUsabilityCache,
-  isModelAvailable: () => isModelAvailable,
-  isModelUsable: () => isModelUsable,
-  resolveModel: () => resolveModel
-});
-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({
-      build: "never",
-      // Never compile from source in a deployed tool
-      progressLogs: false,
-      // Suppress prebuilt binary fallback warnings
-      logLevel: LlamaLogLevel.error
-      // Only surface real errors from C++ backend
-      // Set NODE_LLAMA_CPP_DEBUG=true to re-enable all output for troubleshooting
-    });
-    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 {
-        await context.dispose();
-      } catch {
-      }
-    }
-    if (model) {
-      try {
-        await model.dispose();
-      } catch {
-      }
-    }
-    if (llama) {
-      try {
-        await llama.dispose();
-      } catch {
-      }
-    }
-  }
-}
-function clearUsabilityCache() {
-  cachedUsability = null;
-}
-async function resolveModel(options = {}) {
-  const { cli = true } = options;
-  return resolveModelFile(MODEL_URI, { cli });
-}
-var MODEL_URI, MODEL_FILENAME, DEFAULT_MODEL_DIR, cachedUsability;
-var init_model = __esm({
-  "src/memory/embeddings/model.ts"() {
-    MODEL_URI = "hf:ggml-org/embeddinggemma-300M-qat-q4_0-GGUF/embeddinggemma-300M-qat-Q4_0.gguf";
-    MODEL_FILENAME = "hf_ggml-org_embeddinggemma-300M-qat-Q4_0.gguf";
-    DEFAULT_MODEL_DIR = join(homedir(), ".node-llama-cpp", "models");
-    cachedUsability = null;
-  }
-});
-async function getEmbedding() {
-  if (embeddingContext) return embeddingContext;
-  if (pendingInit) return pendingInit;
-  pendingInit = (async () => {
-    try {
-      const modelPath = await resolveModel({ cli: true });
-      llamaInstance = await getLlama({
-        build: "never",
-        // Never compile from source in a deployed tool
-        progressLogs: false,
-        // Suppress prebuilt binary fallback warnings
-        logLevel: LlamaLogLevel.error
-        // Only surface real errors from C++ backend
-        // Set NODE_LLAMA_CPP_DEBUG=true to re-enable all output for troubleshooting
-      });
-      modelInstance = await llamaInstance.loadModel({ modelPath });
-      embeddingContext = await modelInstance.createEmbeddingContext();
-      return embeddingContext;
-    } catch (err) {
-      pendingInit = null;
-      throw err;
-    }
-  })();
-  return pendingInit;
-}
-async function unloadEmbeddingResources() {
-  const pending = pendingInit;
-  if (pending) {
-    try {
-      await pending;
-    } catch {
-    }
-  }
-  const context = embeddingContext;
-  const model = modelInstance;
-  const llama = llamaInstance;
-  embeddingContext = null;
-  modelInstance = null;
-  llamaInstance = null;
-  pendingInit = null;
-  const disposals = [];
-  if (context) {
-    disposals.push(context.dispose());
-  }
-  if (model) {
-    disposals.push(model.dispose());
-  }
-  if (llama) {
-    disposals.push(llama.dispose());
-  }
-  if (disposals.length > 0) {
-    await Promise.allSettled(disposals);
-  }
-}
-function unloadEmbedding() {
-  void unloadEmbeddingResources();
-}
-async function withEmbedding(fn) {
-  try {
-    return await fn();
-  } finally {
-    await unloadEmbeddingResources();
-  }
-}
-async function embedText(text) {
-  const ctx = await getEmbedding();
-  const result = await ctx.getEmbeddingFor(text);
-  return new Float32Array(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(new Float32Array(result.vector));
-  }
-  return results;
-}
-var embeddingContext, pendingInit, llamaInstance, modelInstance;
-var init_nomic = __esm({
-  "src/memory/embeddings/nomic.ts"() {
-    init_model();
-    embeddingContext = null;
-    pendingInit = null;
-    llamaInstance = null;
-    modelInstance = null;
-  }
-});
-
-// src/memory/embeddings/index.ts
-var init_embeddings = __esm({
-  "src/memory/embeddings/index.ts"() {
-    init_nomic();
-    init_model();
-  }
-});
-
-// src/compound/clustering.ts
-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 = [];
-  const noise = [];
-  for (const group of groups.values()) {
-    if (group.length === 1) {
-      noise.push(group[0]);
-    } else {
-      clusters.push(group);
-    }
-  }
-  return { clusters, noise };
-}
-var DEFAULT_THRESHOLD;
-var init_clustering = __esm({
-  "src/compound/clustering.ts"() {
-    init_search2();
-    DEFAULT_THRESHOLD = 0.75;
-  }
-});
-function generateCctId(input) {
-  const hash = createHash("sha256").update(input).digest("hex");
-  return `CCT-${hash.slice(0, 8)}`;
-}
-var CCT_PATTERNS_PATH, CctPatternSchema;
-var init_types2 = __esm({
-  "src/compound/types.ts"() {
-    CCT_PATTERNS_PATH = ".claude/lessons/cct-patterns.jsonl";
-    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
-    });
-  }
-});
-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;
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    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");
-}
-var init_io = __esm({
-  "src/compound/io.ts"() {
-    init_types2();
-  }
-});
-
-// 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()
-  };
-}
-var init_synthesis = __esm({
-  "src/compound/synthesis.ts"() {
-    init_types2();
-  }
-});
-
-// src/compound/index.ts
-var init_compound = __esm({
-  "src/compound/index.ts"() {
-    init_clustering();
-    init_io();
-    init_synthesis();
-    init_types2();
-  }
-});
-
-// 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;
-}
-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;
-  await syncIfNeeded(repoRoot);
-  const items = readAllFromSqlite(repoRoot);
-  let cctPatterns = [];
-  try {
-    cctPatterns = await readCctPatterns(repoRoot);
-  } catch {
-  }
-  if (items.length === 0 && cctPatterns.length === 0) return [];
-  const queryVector = await embedText(query);
-  const cachedEmbeddings = getCachedEmbeddingsBulk(repoRoot);
-  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);
-      const cached = cachedEmbeddings.get(item.id);
-      let itemVector;
-      if (cached && cached.hash === hash) {
-        itemVector = cached.vector;
-      } else {
-        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 hash = contentHash(pattern.name, pattern.description);
-      const cacheKey = `${pattern.id}:${hash}`;
-      let vec = cctEmbeddingCache.get(cacheKey);
-      if (!vec) {
-        vec = await embedText(text);
-        cctEmbeddingCache.set(cacheKey, vec);
-      }
-      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);
-}
-async function findSimilarLessons(repoRoot, text, options) {
-  const threshold = options?.threshold ?? DEFAULT_THRESHOLD2;
-  const excludeId = options?.excludeId;
-  if (!isModelAvailable()) return [];
-  let items;
-  if (options?.items) {
-    items = options.items;
-  } else {
-    await syncIfNeeded(repoRoot);
-    items = readAllFromSqlite(repoRoot);
-  }
-  if (items.length === 0) return [];
-  const queryVector = await embedText(text);
-  const scored = [];
-  for (const item of items) {
-    if (item.invalidatedAt) continue;
-    if (excludeId && item.id === excludeId) continue;
-    try {
-      const hash = contentHash(item.insight, "");
-      let itemVector = getCachedInsightEmbedding(repoRoot, item.id, hash);
-      if (!itemVector) {
-        itemVector = await embedText(item.insight);
-        setCachedInsightEmbedding(repoRoot, item.id, itemVector, hash);
-      }
-      const score = cosineSimilarity(queryVector, itemVector);
-      if (score >= threshold) {
-        scored.push({ item, score });
-      }
-    } catch {
-      continue;
-    }
-  }
-  scored.sort((a, b) => b.score - a.score);
-  return scored;
-}
-var cctEmbeddingCache, DEFAULT_LIMIT, DEFAULT_THRESHOLD2;
-var init_vector = __esm({
-  "src/memory/search/vector.ts"() {
-    init_compound();
-    init_embeddings();
-    init_model();
-    init_storage();
-    cctEmbeddingCache = /* @__PURE__ */ new Map();
-    DEFAULT_LIMIT = 10;
-    DEFAULT_THRESHOLD2 = 0.8;
-  }
-});
-
-// src/utils.ts
-function getLessonAgeDays(lesson) {
-  const created = new Date(lesson.created).getTime();
-  const now = Date.now();
-  return Math.floor((now - created) / MS_PER_DAY);
-}
-var MS_PER_DAY;
-var init_utils = __esm({
-  "src/utils.ts"() {
-    MS_PER_DAY = 24 * 60 * 60 * 1e3;
-  }
-});
-
-// src/memory/search/ranking.ts
-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 RECENCY_THRESHOLD_DAYS, HIGH_SEVERITY_BOOST, MEDIUM_SEVERITY_BOOST, LOW_SEVERITY_BOOST, RECENCY_BOOST, CONFIRMATION_BOOST, MAX_COMBINED_BOOST;
-var init_ranking = __esm({
-  "src/memory/search/ranking.ts"() {
-    init_utils();
-    RECENCY_THRESHOLD_DAYS = 30;
-    HIGH_SEVERITY_BOOST = 1.5;
-    MEDIUM_SEVERITY_BOOST = 1;
-    LOW_SEVERITY_BOOST = 0.8;
-    RECENCY_BOOST = 1.2;
-    CONFIRMATION_BOOST = 1.3;
-    MAX_COMBINED_BOOST = 1.8;
-  }
-});
-
-// src/memory/search/prewarm.ts
-var init_prewarm = __esm({
-  "src/memory/search/prewarm.ts"() {
-    init_model();
-    init_embeddings();
-    init_storage();
-  }
-});
-
-// src/memory/search/index.ts
-var init_search2 = __esm({
-  "src/memory/search/index.ts"() {
-    init_vector();
-    init_ranking();
-    init_prewarm();
-    init_hybrid();
-  }
-});
-
-// src/memory/storage/sqlite-knowledge/schema.ts
-function createKnowledgeSchema(database) {
-  database.exec(SCHEMA_SQL2);
-  database.pragma(`user_version = ${KNOWLEDGE_SCHEMA_VERSION}`);
-}
-var KNOWLEDGE_SCHEMA_VERSION, SCHEMA_SQL2;
-var init_schema2 = __esm({
-  "src/memory/storage/sqlite-knowledge/schema.ts"() {
-    KNOWLEDGE_SCHEMA_VERSION = 2;
-    SCHEMA_SQL2 = `
-  CREATE TABLE IF NOT EXISTS chunks (
-    id TEXT PRIMARY KEY,
-    file_path TEXT NOT NULL,
-    start_line INTEGER NOT NULL,
-    end_line INTEGER NOT NULL,
-    content_hash TEXT NOT NULL,
-    text TEXT NOT NULL,
-    embedding BLOB,
-    model TEXT,
-    updated_at TEXT NOT NULL
-  );
-
-  CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
-    text,
-    content='chunks', content_rowid='rowid'
-  );
-
-  CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
-    INSERT INTO chunks_fts(rowid, text)
-    VALUES (new.rowid, new.text);
-  END;
-
-  CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
-    INSERT INTO chunks_fts(chunks_fts, rowid, text)
-    VALUES ('delete', old.rowid, old.text);
-  END;
-
-  CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
-    INSERT INTO chunks_fts(chunks_fts, rowid, text)
-    VALUES ('delete', old.rowid, old.text);
-    INSERT INTO chunks_fts(rowid, text)
-    VALUES (new.rowid, new.text);
-  END;
-
-  CREATE INDEX IF NOT EXISTS idx_chunks_file_path ON chunks(file_path);
-
-  CREATE TABLE IF NOT EXISTS metadata (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-  );
-`;
-  }
-});
-function openKnowledgeDb(repoRoot, options = {}) {
-  const { inMemory = false } = options;
-  const key = inMemory ? `:memory:${repoRoot}` : join(repoRoot, KNOWLEDGE_DB_PATH);
-  const cached = knowledgeDbMap.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);
-    const version = database.pragma("user_version", { simple: true });
-    if (version !== 0 && version !== KNOWLEDGE_SCHEMA_VERSION) {
-      database.close();
-      try {
-        unlinkSync(key);
-      } catch {
-      }
-      database = new Database(key);
-    }
-    database.pragma("journal_mode = WAL");
-  }
-  createKnowledgeSchema(database);
-  knowledgeDbMap.set(key, database);
-  return database;
-}
-function closeKnowledgeDb() {
-  for (const database of knowledgeDbMap.values()) {
-    database.close();
-  }
-  knowledgeDbMap.clear();
-}
-var KNOWLEDGE_DB_PATH, knowledgeDbMap;
-var init_connection2 = __esm({
-  "src/memory/storage/sqlite-knowledge/connection.ts"() {
-    init_availability();
-    init_schema2();
-    KNOWLEDGE_DB_PATH = ".claude/.cache/knowledge.sqlite";
-    knowledgeDbMap = /* @__PURE__ */ new Map();
-  }
-});
-function generateChunkId(filePath, startLine, endLine) {
-  return createHash("sha256").update(`${filePath}:${startLine}:${endLine}`).digest("hex").slice(0, 16);
-}
-function chunkContentHash(text) {
-  return createHash("sha256").update(text).digest("hex");
-}
-var SUPPORTED_EXTENSIONS, CODE_EXTENSIONS;
-var init_types3 = __esm({
-  "src/memory/knowledge/types.ts"() {
-    SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".md",
-      ".txt",
-      ".rst",
-      ".ts",
-      ".py",
-      ".js",
-      ".tsx",
-      ".jsx"
-    ]);
-    CODE_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".ts",
-      ".tsx",
-      ".js",
-      ".jsx",
-      ".py"
-    ]);
-  }
-});
-
-// src/memory/storage/sqlite-knowledge/cache.ts
-function getCachedChunkEmbedding(repoRoot, chunkId, expectedHash) {
-  const database = openKnowledgeDb(repoRoot);
-  const row = database.prepare("SELECT embedding, content_hash FROM chunks WHERE id = ?").get(chunkId);
-  if (!row || !row.embedding || !row.content_hash) {
-    return null;
-  }
-  if (expectedHash && row.content_hash !== expectedHash) {
-    return null;
-  }
-  return new Float32Array(
-    row.embedding.buffer,
-    row.embedding.byteOffset,
-    row.embedding.byteLength / 4
-  );
-}
-function setCachedChunkEmbedding(repoRoot, chunkId, embedding, hash) {
-  const database = openKnowledgeDb(repoRoot);
-  const float32 = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
-  const buffer = Buffer.from(float32.buffer, float32.byteOffset, float32.byteLength);
-  database.prepare("UPDATE chunks SET embedding = ?, content_hash = ? WHERE id = ?").run(buffer, hash, chunkId);
-}
-function collectCachedChunkEmbeddings(database) {
-  const cache = /* @__PURE__ */ new Map();
-  const rows = database.prepare("SELECT id, embedding, content_hash FROM chunks 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 init_cache2 = __esm({
-  "src/memory/storage/sqlite-knowledge/cache.ts"() {
-    init_connection2();
-    init_types3();
-  }
-});
-
-// src/memory/storage/sqlite-knowledge/search.ts
-function rowToChunk(row) {
-  const chunk = {
-    id: row.id,
-    filePath: row.file_path,
-    startLine: row.start_line,
-    endLine: row.end_line,
-    contentHash: row.content_hash,
-    text: row.text,
-    updatedAt: row.updated_at
-  };
-  if (row.model !== null) {
-    chunk.model = row.model;
-  }
-  return chunk;
-}
-function searchChunksKeywordScored(repoRoot, query, limit) {
-  const database = openKnowledgeDb(repoRoot);
-  const sanitized = sanitizeFtsQuery(query);
-  if (sanitized === "") return [];
-  try {
-    const rows = database.prepare(
-      `SELECT c.*, fts.rank
-         FROM chunks c
-         JOIN chunks_fts fts ON c.rowid = fts.rowid
-         WHERE chunks_fts MATCH ?
-         ORDER BY fts.rank
-         LIMIT ?`
-    ).all(sanitized, limit);
-    return rows.map((row) => ({
-      chunk: rowToChunk(row),
-      score: normalizeBm25Rank(row.rank)
-    }));
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Unknown FTS5 error";
-    console.error(`[compound-agent] knowledge scored search error: ${message}`);
-    return [];
-  }
-}
-var init_search3 = __esm({
-  "src/memory/storage/sqlite-knowledge/search.ts"() {
-    init_connection2();
-    init_search();
-    init_hybrid();
-  }
-});
-
-// src/memory/storage/sqlite-knowledge/sync.ts
-function upsertChunks(repoRoot, chunks, embeddings) {
-  if (chunks.length === 0) return;
-  const database = openKnowledgeDb(repoRoot);
-  const insert = database.prepare(`
-    INSERT OR REPLACE INTO chunks (id, file_path, start_line, end_line, content_hash, text, embedding, model, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  const upsertMany = database.transaction((items) => {
-    for (const chunk of items) {
-      const emb = embeddings?.get(chunk.id);
-      const embBuffer = emb ? Buffer.from(emb.buffer, emb.byteOffset, emb.byteLength) : null;
-      insert.run(
-        chunk.id,
-        chunk.filePath,
-        chunk.startLine,
-        chunk.endLine,
-        chunk.contentHash,
-        chunk.text,
-        embBuffer,
-        chunk.model ?? null,
-        chunk.updatedAt
-      );
-    }
-  });
-  upsertMany(chunks);
-}
-function deleteChunksByFilePath(repoRoot, filePaths) {
-  if (filePaths.length === 0) return;
-  const database = openKnowledgeDb(repoRoot);
-  const del = database.prepare("DELETE FROM chunks WHERE file_path = ?");
-  const deleteMany = database.transaction((paths) => {
-    for (const path of paths) {
-      del.run(path);
-    }
-  });
-  deleteMany(filePaths);
-}
-function getIndexedFilePaths(repoRoot) {
-  const database = openKnowledgeDb(repoRoot);
-  const rows = database.prepare("SELECT DISTINCT file_path FROM chunks").all();
-  return rows.map((r) => r.file_path);
-}
-function getLastIndexTime(repoRoot) {
-  const database = openKnowledgeDb(repoRoot);
-  const row = database.prepare("SELECT value FROM metadata WHERE key = 'last_index_time'").get();
-  return row?.value ?? null;
-}
-function getChunkCount(repoRoot) {
-  const database = openKnowledgeDb(repoRoot);
-  const row = database.prepare("SELECT COUNT(*) as cnt FROM chunks").get();
-  return row.cnt;
-}
-function getChunkCountByFilePath(repoRoot, filePath) {
-  const database = openKnowledgeDb(repoRoot);
-  const row = database.prepare("SELECT COUNT(*) as cnt FROM chunks WHERE file_path = ?").get(filePath);
-  return row.cnt;
-}
-function setLastIndexTime(repoRoot, time) {
-  const database = openKnowledgeDb(repoRoot);
-  database.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES ('last_index_time', ?)").run(time);
-}
-var init_sync2 = __esm({
-  "src/memory/storage/sqlite-knowledge/sync.ts"() {
-    init_connection2();
-  }
-});
-
-// src/memory/storage/sqlite-knowledge/index.ts
-var sqlite_knowledge_exports = {};
-__export(sqlite_knowledge_exports, {
-  KNOWLEDGE_DB_PATH: () => KNOWLEDGE_DB_PATH,
-  KNOWLEDGE_SCHEMA_VERSION: () => KNOWLEDGE_SCHEMA_VERSION,
-  chunkContentHash: () => chunkContentHash,
-  closeKnowledgeDb: () => closeKnowledgeDb,
-  collectCachedChunkEmbeddings: () => collectCachedChunkEmbeddings,
-  deleteChunksByFilePath: () => deleteChunksByFilePath,
-  getCachedChunkEmbedding: () => getCachedChunkEmbedding,
-  getChunkCount: () => getChunkCount,
-  getChunkCountByFilePath: () => getChunkCountByFilePath,
-  getIndexedFilePaths: () => getIndexedFilePaths,
-  getLastIndexTime: () => getLastIndexTime,
-  openKnowledgeDb: () => openKnowledgeDb,
-  searchChunksKeywordScored: () => searchChunksKeywordScored,
-  setCachedChunkEmbedding: () => setCachedChunkEmbedding,
-  setLastIndexTime: () => setLastIndexTime,
-  upsertChunks: () => upsertChunks
-});
-var init_sqlite_knowledge = __esm({
-  "src/memory/storage/sqlite-knowledge/index.ts"() {
-    init_connection2();
-    init_schema2();
-    init_cache2();
-    init_search3();
-    init_sync2();
-  }
-});
-function isBinary(content) {
-  return content.includes("\0");
-}
-function splitIntoSections(fileLines, ext) {
-  if (ext === ".md") {
-    return splitMarkdown(fileLines);
-  }
-  if (ext === ".rst") {
-    return splitParagraphs(fileLines);
-  }
-  if (CODE_EXTENSIONS.has(ext)) {
-    return splitCode(fileLines);
-  }
-  return splitParagraphs(fileLines);
-}
-function splitMarkdown(fileLines) {
-  const sections = [];
-  let current = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < fileLines.length; i++) {
-    const line = fileLines[i];
-    const lineObj = { lineNumber: i + 1, text: line };
-    if (line.trimStart().startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      current.push(lineObj);
-      continue;
-    }
-    if (!inCodeBlock && /^#{2,}\s/.test(line) && current.length > 0) {
-      sections.push(current);
-      current = [lineObj];
-      continue;
-    }
-    if (!inCodeBlock && line.trim() === "" && current.length > 0 && current.some((l) => l.text.trim() !== "")) {
-      current.push(lineObj);
-      sections.push(current);
-      current = [];
-      continue;
-    }
-    current.push(lineObj);
-  }
-  if (current.length > 0) {
-    sections.push(current);
-  }
-  return sections;
-}
-function splitCode(fileLines) {
-  const sections = [];
-  let current = [];
-  for (let i = 0; i < fileLines.length; i++) {
-    const line = fileLines[i];
-    const lineObj = { lineNumber: i + 1, text: line };
-    if (line.trim() === "" && current.length > 0) {
-      let hasNextNonBlank = false;
-      for (let j = i + 1; j < fileLines.length; j++) {
-        if (fileLines[j].trim() !== "") {
-          hasNextNonBlank = true;
-          break;
-        }
-      }
-      if (hasNextNonBlank) {
-        sections.push(current);
-        current = [lineObj];
-        continue;
-      }
-    }
-    current.push(lineObj);
-  }
-  if (current.length > 0) {
-    sections.push(current);
-  }
-  return sections;
-}
-function splitParagraphs(fileLines) {
-  const sections = [];
-  let current = [];
-  for (let i = 0; i < fileLines.length; i++) {
-    const line = fileLines[i];
-    const lineObj = { lineNumber: i + 1, text: line };
-    if (line.trim() === "" && current.length > 0) {
-      sections.push(current);
-      current = [lineObj];
-      continue;
-    }
-    current.push(lineObj);
-  }
-  if (current.length > 0) {
-    sections.push(current);
-  }
-  return sections;
-}
-function sectionText(section) {
-  return section.map((l) => l.text).join("\n");
-}
-function chunkFile(filePath, content, options) {
-  if (content.trim() === "") return [];
-  if (isBinary(content)) return [];
-  const targetSize = options?.targetSize ?? DEFAULT_TARGET_SIZE;
-  const overlapSize = options?.overlapSize ?? DEFAULT_OVERLAP_SIZE;
-  const fileLines = content.split("\n");
-  const ext = extname(filePath).toLowerCase();
-  const sections = splitIntoSections(fileLines, ext);
-  const chunks = [];
-  let accumulated = [];
-  let accumulatedLength = 0;
-  function emitChunk(lines, overlapLines2) {
-    if (lines.length === 0) return [];
-    const allLines = [...overlapLines2, ...lines];
-    const text = allLines.map((l) => l.text).join("\n");
-    const startLine = allLines[0].lineNumber;
-    const endLine = allLines[allLines.length - 1].lineNumber;
-    chunks.push({
-      id: generateChunkId(filePath, startLine, endLine),
-      filePath,
-      startLine,
-      endLine,
-      text,
-      contentHash: chunkContentHash(text)
-    });
-    if (overlapSize <= 0) return [];
-    const overlapResult = [];
-    let overlapLen = 0;
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const lineLen = lines[i].text.length + 1;
-      if (overlapLen + lineLen > overlapSize && overlapResult.length > 0) break;
-      overlapResult.unshift(lines[i]);
-      overlapLen += lineLen;
-    }
-    return overlapResult;
-  }
-  let overlapLines = [];
-  for (const section of sections) {
-    const sectionLen = sectionText(section).length;
-    if (accumulatedLength > 0 && accumulatedLength + sectionLen > targetSize) {
-      overlapLines = emitChunk(accumulated, overlapLines);
-      accumulated = [];
-      accumulatedLength = 0;
-    }
-    accumulated.push(...section);
-    accumulatedLength += sectionLen;
-    if (accumulatedLength > targetSize) {
-      overlapLines = emitChunk(accumulated, overlapLines);
-      accumulated = [];
-      accumulatedLength = 0;
-    }
-  }
-  if (accumulated.length > 0) {
-    emitChunk(accumulated, overlapLines);
-  }
-  return chunks;
-}
-var DEFAULT_TARGET_SIZE, DEFAULT_OVERLAP_SIZE;
-var init_chunking = __esm({
-  "src/memory/knowledge/chunking.ts"() {
-    init_types3();
-    DEFAULT_TARGET_SIZE = 1600;
-    DEFAULT_OVERLAP_SIZE = 320;
-  }
-});
-
-// src/memory/knowledge/embed-chunks.ts
-var embed_chunks_exports = {};
-__export(embed_chunks_exports, {
-  embedChunks: () => embedChunks,
-  getUnembeddedChunkCount: () => getUnembeddedChunkCount
-});
-function getUnembeddedChunkCount(repoRoot) {
-  const db = openKnowledgeDb(repoRoot);
-  const row = db.prepare("SELECT COUNT(*) as count FROM chunks WHERE embedding IS NULL").get();
-  return row.count;
-}
-async function embedChunks(repoRoot, options) {
-  const start = Date.now();
-  const onlyMissing = options?.onlyMissing ?? true;
-  const db = openKnowledgeDb(repoRoot);
-  const query = onlyMissing ? "SELECT id, text, content_hash FROM chunks WHERE embedding IS NULL" : "SELECT id, text, content_hash FROM chunks";
-  const rows = db.prepare(query).all();
-  const totalRow = db.prepare("SELECT COUNT(*) as count FROM chunks").get();
-  const chunksSkipped = totalRow.count - rows.length;
-  let chunksEmbedded = 0;
-  const updateStmt = db.prepare(
-    "UPDATE chunks SET embedding = ?, content_hash = ? WHERE id = ?"
-  );
-  const writeBatch = db.transaction((batch) => {
-    for (const item of batch) {
-      const buffer = Buffer.from(item.vector.buffer, item.vector.byteOffset, item.vector.byteLength);
-      updateStmt.run(buffer, item.content_hash, item.id);
-    }
-  });
-  for (let i = 0; i < rows.length; i += BATCH_SIZE) {
-    const batch = rows.slice(i, i + BATCH_SIZE);
-    const texts = batch.map((r) => r.text);
-    const vectors = await embedTexts(texts);
-    if (vectors.length !== texts.length) {
-      throw new Error(`embedTexts returned ${vectors.length} vectors for ${texts.length} inputs`);
-    }
-    const enriched = batch.map((r, j) => ({ ...r, vector: vectors[j] }));
-    writeBatch(enriched);
-    chunksEmbedded += batch.length;
-  }
-  return {
-    chunksEmbedded,
-    chunksSkipped,
-    durationMs: Date.now() - start
-  };
-}
-var BATCH_SIZE;
-var init_embed_chunks = __esm({
-  "src/memory/knowledge/embed-chunks.ts"() {
-    init_nomic();
-    init_connection2();
-    BATCH_SIZE = 16;
-  }
-});
-
-// src/memory/knowledge/indexing.ts
-var indexing_exports = {};
-__export(indexing_exports, {
-  indexDocs: () => indexDocs
-});
-function fileHash(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
-function fileHashKey(relativePath) {
-  return "file_hash:" + relativePath;
-}
-function getStoredFileHash(repoRoot, relativePath) {
-  const db = openKnowledgeDb(repoRoot);
-  const row = db.prepare("SELECT value FROM metadata WHERE key = ?").get(fileHashKey(relativePath));
-  return row?.value ?? null;
-}
-function setFileHash(repoRoot, relativePath, hash) {
-  const db = openKnowledgeDb(repoRoot);
-  db.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)").run(fileHashKey(relativePath), hash);
-}
-function removeFileHash(repoRoot, relativePath) {
-  const db = openKnowledgeDb(repoRoot);
-  db.prepare("DELETE FROM metadata WHERE key = ?").run(fileHashKey(relativePath));
-}
-async function walkSupportedFiles(baseDir, repoRoot) {
-  const results = [];
-  let entries;
-  try {
-    entries = await readdir(baseDir, { recursive: true, withFileTypes: true });
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    const ext = extname(entry.name).toLowerCase();
-    if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
-    const fullPath = join(entry.parentPath ?? entry.path, entry.name);
-    const relPath = relative(repoRoot, fullPath);
-    results.push(relPath);
-  }
-  return results;
-}
-async function tryEmbedChunks(repoRoot) {
-  const { isModelUsable: isModelUsable2 } = await Promise.resolve().then(() => (init_model(), model_exports));
-  const usability = await isModelUsable2();
-  if (!usability.usable) {
-    throw new Error(`Embedding failed: ${usability.reason}. ${usability.action}`);
-  }
-  const { embedChunks: embedChunks2 } = await Promise.resolve().then(() => (init_embed_chunks(), embed_chunks_exports));
-  const embedResult = await embedChunks2(repoRoot);
-  return embedResult.chunksEmbedded;
-}
-async function indexDocs(repoRoot, options = {}) {
-  const start = Date.now();
-  const docsDir = options.docsDir ?? "docs";
-  const force = options.force ?? false;
-  const stats = {
-    filesIndexed: 0,
-    filesSkipped: 0,
-    filesErrored: 0,
-    chunksCreated: 0,
-    chunksDeleted: 0,
-    chunksEmbedded: 0,
-    durationMs: 0
-  };
-  const docsPath = join(repoRoot, docsDir);
-  const filePaths = await walkSupportedFiles(docsPath, repoRoot);
-  for (const relPath of filePaths) {
-    const fullPath = join(repoRoot, relPath);
-    let content;
-    try {
-      content = await readFile(fullPath, "utf-8");
-    } catch {
-      stats.filesErrored++;
-      continue;
-    }
-    const hash = fileHash(content);
-    const storedHash = getStoredFileHash(repoRoot, relPath);
-    if (!force && storedHash === hash) {
-      stats.filesSkipped++;
-      continue;
-    }
-    const chunks = chunkFile(relPath, content);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const knowledgeChunks = chunks.map((chunk) => ({
-      id: chunk.id,
-      filePath: chunk.filePath,
-      startLine: chunk.startLine,
-      endLine: chunk.endLine,
-      contentHash: chunk.contentHash,
-      text: chunk.text,
-      updatedAt: now
-    }));
-    const db = openKnowledgeDb(repoRoot);
-    db.transaction(() => {
-      deleteChunksByFilePath(repoRoot, [relPath]);
-      if (knowledgeChunks.length > 0) {
-        upsertChunks(repoRoot, knowledgeChunks);
-      }
-      setFileHash(repoRoot, relPath, hash);
-    })();
-    stats.filesIndexed++;
-    stats.chunksCreated += knowledgeChunks.length;
-  }
-  const indexedPaths = getIndexedFilePaths(repoRoot);
-  const currentPathSet = new Set(filePaths);
-  const stalePaths = indexedPaths.filter((p) => !currentPathSet.has(p));
-  if (stalePaths.length > 0) {
-    for (const path of stalePaths) {
-      stats.chunksDeleted += getChunkCountByFilePath(repoRoot, path);
-    }
-    deleteChunksByFilePath(repoRoot, stalePaths);
-    for (const path of stalePaths) {
-      removeFileHash(repoRoot, path);
-    }
-  }
-  setLastIndexTime(repoRoot, (/* @__PURE__ */ new Date()).toISOString());
-  if (options.embed) {
-    stats.chunksEmbedded = await tryEmbedChunks(repoRoot);
-  }
-  stats.durationMs = Date.now() - start;
-  return stats;
-}
-var init_indexing = __esm({
-  "src/memory/knowledge/indexing.ts"() {
-    init_connection2();
-    init_sync2();
-    init_chunking();
-    init_types3();
-  }
-});
-function lockPath(repoRoot) {
-  return join(repoRoot, ".claude", ".cache", "embed.lock");
-}
-function lockDir(repoRoot) {
-  return join(repoRoot, ".claude", ".cache");
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function readLock(filePath) {
-  try {
-    const raw = readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed === "object" && parsed !== null && typeof parsed.pid === "number" && typeof parsed.startedAt === "string") {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function acquireEmbedLock(repoRoot) {
-  const dir = lockDir(repoRoot);
-  const file = lockPath(repoRoot);
-  const content = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  mkdirSync(dir, { recursive: true });
-  try {
-    writeFileSync(file, JSON.stringify(content), { flag: "wx" });
-    return { acquired: true, release: () => releaseLock(file) };
-  } catch (err) {
-    if (err.code !== "EEXIST") throw err;
-    const existing = readLock(file);
-    if (existing && isProcessAlive(existing.pid)) {
-      const lockAge = Date.now() - new Date(existing.startedAt).getTime();
-      if (lockAge < LOCK_MAX_AGE_MS) {
-        return { acquired: false, holder: existing.pid };
-      }
-    }
-    try {
-      unlinkSync(file);
-    } catch {
-    }
-    try {
-      writeFileSync(file, JSON.stringify(content), { flag: "wx" });
-      return { acquired: true, release: () => releaseLock(file) };
-    } catch {
-      const winner = readLock(file);
-      return { acquired: false, holder: winner?.pid ?? -1 };
-    }
-  }
-}
-function isEmbedLocked(repoRoot) {
-  const file = lockPath(repoRoot);
-  if (!existsSync(file)) return false;
-  const content = readLock(file);
-  if (!content) return false;
-  return isProcessAlive(content.pid);
-}
-function releaseLock(file) {
-  try {
-    unlinkSync(file);
-  } catch {
-  }
-}
-var LOCK_MAX_AGE_MS;
-var init_embed_lock = __esm({
-  "src/memory/knowledge/embed-lock.ts"() {
-    LOCK_MAX_AGE_MS = 60 * 60 * 1e3;
-  }
-});
-function statusPath(repoRoot) {
-  return join(repoRoot, STATUS_FILE);
-}
-function writeEmbedStatus(repoRoot, status) {
-  const filePath = statusPath(repoRoot);
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, JSON.stringify(status, null, 2), "utf-8");
-}
-function readEmbedStatus(repoRoot) {
-  try {
-    const raw = readFileSync(statusPath(repoRoot), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || !VALID_STATES.has(parsed.state)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-var STATUS_FILE, VALID_STATES;
-var init_embed_status = __esm({
-  "src/memory/knowledge/embed-status.ts"() {
-    STATUS_FILE = ".claude/.cache/embed-status.json";
-    VALID_STATES = /* @__PURE__ */ new Set(["idle", "running", "completed", "failed"]);
-  }
-});
-function resolveCliInvocation() {
-  let dir = dirname(fileURLToPath(import.meta.url));
-  for (let i = 0; i < 10; i++) {
-    const candidate = join(dir, "dist", "cli.js");
-    if (existsSync(candidate)) {
-      return { command: process.execPath, args: [candidate] };
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return { command: "npx", args: ["ca"] };
-}
-function spawnBackgroundEmbed(repoRoot) {
-  if (isEmbedLocked(repoRoot)) {
-    return { spawned: false, reason: "Embedding already in progress" };
-  }
-  if (!isModelAvailable()) {
-    return { spawned: false, reason: "Model not available" };
-  }
-  if (getUnembeddedChunkCount(repoRoot) === 0) {
-    return { spawned: false, reason: "All chunks already embedded" };
-  }
-  const cli = resolveCliInvocation();
-  const child = spawn(cli.command, [...cli.args, "embed-worker", repoRoot], {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-  return { spawned: true, pid: child.pid };
-}
-async function runBackgroundEmbed(repoRoot) {
-  const lock = acquireEmbedLock(repoRoot);
-  if (!lock.acquired) return;
-  const { openKnowledgeDb: openKnowledgeDb2 } = await Promise.resolve().then(() => (init_sqlite_knowledge(), sqlite_knowledge_exports));
-  openKnowledgeDb2(repoRoot);
-  const start = Date.now();
-  writeEmbedStatus(repoRoot, { state: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString() });
-  try {
-    const result = await withEmbedding(async () => embedChunks(repoRoot, { onlyMissing: true }));
-    writeEmbedStatus(repoRoot, {
-      state: "completed",
-      chunksEmbedded: result.chunksEmbedded,
-      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      durationMs: result.durationMs
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : "Unknown error";
-    writeEmbedStatus(repoRoot, {
-      state: "failed",
-      error: msg,
-      durationMs: Date.now() - start
-    });
-  } finally {
-    closeKnowledgeDb();
-    lock.release();
-  }
-}
-async function indexAndSpawnEmbed(repoRoot) {
-  const docsPath = join(repoRoot, "docs");
-  if (!existsSync(docsPath)) return null;
-  const { indexDocs: indexDocs2 } = await Promise.resolve().then(() => (init_indexing(), indexing_exports));
-  await indexDocs2(repoRoot);
-  return spawnBackgroundEmbed(repoRoot);
-}
-var init_embed_background = __esm({
-  "src/memory/knowledge/embed-background.ts"() {
-    init_embeddings();
-    init_sqlite_knowledge();
-    init_embed_lock();
-    init_embed_status();
-    init_embed_chunks();
-  }
-});
-var _require = createRequire(import.meta.url);
-var _pkg = _require("../package.json");
-var VERSION = _pkg.version;
-
-// src/index.ts
-init_storage();
-init_embeddings();
-init_search2();
-
-// src/memory/capture/quality.ts
-init_model();
-init_search2();
-init_storage();
-var DUPLICATE_THRESHOLD = 0.98;
-async function isNovel(repoRoot, insight, options = {}) {
-  const threshold = options.threshold ?? DUPLICATE_THRESHOLD;
-  if (!isModelAvailable()) {
-    return { novel: true };
-  }
-  try {
-    await syncIfNeeded(repoRoot);
-    const similar = await findSimilarLessons(repoRoot, insight, { threshold });
-    const top = similar[0];
-    if (top) {
-      return {
-        novel: false,
-        reason: `Near-duplicate of existing lesson: "${top.item.insight.slice(0, 50)}..."`,
-        existingId: top.item.id
-      };
-    }
-    return { novel: true };
-  } catch (err) {
-    if (process.env["CA_DEBUG"]) {
-      process.stderr.write(`[CA_DEBUG] isNovel catch: ${err instanceof Error ? err.message : String(err)}
-`);
-    }
-    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)}`
-  };
-}
-
-// src/memory/capture/integration.ts
-init_types();
-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
-init_storage();
-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;
-}
-
-// src/memory/retrieval/plan.ts
-init_search2();
-init_storage();
-var DEFAULT_LIMIT3 = 5;
-async function retrieveForPlan(repoRoot, planText, limit = DEFAULT_LIMIT3) {
-  const candidateLimit = limit * CANDIDATE_MULTIPLIER;
-  let vectorResults = [];
-  let vectorFailed = false;
-  const keywordResultsPromise = searchKeywordScored(repoRoot, planText, candidateLimit);
-  try {
-    vectorResults = await searchVector(repoRoot, planText, { limit: candidateLimit });
-  } catch {
-    vectorFailed = true;
-    console.error("[compound-agent] Vector search unavailable, falling back to keyword-only search");
-  }
-  const keywordResults = await keywordResultsPromise;
-  let merged;
-  if (vectorFailed) {
-    merged = mergeHybridResults([], keywordResults, {
-      vectorWeight: 0,
-      textWeight: DEFAULT_TEXT_WEIGHT
-    });
-  } else {
-    merged = mergeHybridResults(vectorResults, keywordResults, { minScore: MIN_HYBRID_SCORE });
-  }
-  const ranked = rankLessons(merged);
-  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")}`;
-}
-
-// src/index.ts
-init_sqlite_knowledge();
-
-// src/memory/knowledge/index.ts
-init_chunking();
-init_types3();
-init_indexing();
-
-// src/memory/knowledge/search.ts
-init_connection2();
-init_search3();
-init_nomic();
-init_vector();
-init_hybrid();
-init_model();
-var DEFAULT_KNOWLEDGE_LIMIT = 6;
-async function searchKnowledgeVector(repoRoot, query, options) {
-  const limit = options?.limit ?? DEFAULT_KNOWLEDGE_LIMIT;
-  const database = openKnowledgeDb(repoRoot);
-  const embRows = database.prepare("SELECT id, embedding FROM chunks WHERE embedding IS NOT NULL").all();
-  if (embRows.length === 0) return [];
-  const queryVector = await embedText(query);
-  const scored = [];
-  for (const row of embRows) {
-    const embFloat = new Float32Array(
-      row.embedding.buffer,
-      row.embedding.byteOffset,
-      row.embedding.byteLength / 4
-    );
-    scored.push({ id: row.id, score: cosineSimilarity(queryVector, embFloat) });
-  }
-  scored.sort((a, b) => b.score - a.score);
-  const topK = scored.slice(0, limit);
-  if (topK.length === 0) return [];
-  const placeholders = topK.map(() => "?").join(",");
-  const sql = `SELECT id, file_path, start_line, end_line, content_hash, text, model, updated_at FROM chunks WHERE id IN (${placeholders})`;
-  const dataRows = database.prepare(sql).all(...topK.map((r) => r.id));
-  const dataMap = new Map(dataRows.map((r) => [r.id, r]));
-  const results = [];
-  for (const { id, score } of topK) {
-    const row = dataMap.get(id);
-    if (!row) continue;
-    const chunk = {
-      id: row.id,
-      filePath: row.file_path,
-      startLine: row.start_line,
-      endLine: row.end_line,
-      contentHash: row.content_hash,
-      text: row.text,
-      updatedAt: row.updated_at
-    };
-    if (row.model !== null) {
-      chunk.model = row.model;
-    }
-    results.push({ item: chunk, score });
-  }
-  return results;
-}
-async function searchKnowledge(repoRoot, query, options) {
-  const limit = options?.limit ?? DEFAULT_KNOWLEDGE_LIMIT;
-  const candidateLimit = limit * CANDIDATE_MULTIPLIER;
-  const usability = await isModelUsable();
-  if (usability.usable) {
-    const [vectorResults, keywordResults2] = await Promise.all([
-      searchKnowledgeVector(repoRoot, query, { limit: candidateLimit }),
-      Promise.resolve(searchChunksKeywordScored(repoRoot, query, candidateLimit))
-    ]);
-    if (vectorResults.length === 0) {
-      return keywordResults2.map((k) => ({ item: k.chunk, score: k.score })).slice(0, limit);
-    }
-    const genericKw = keywordResults2.map((k) => ({
-      item: k.chunk,
-      score: k.score
-    }));
-    const merged = mergeHybridScores(
-      vectorResults,
-      genericKw,
-      (item) => item.id,
-      { limit, minScore: MIN_HYBRID_SCORE }
-    );
-    return merged;
-  }
-  const keywordResults = searchChunksKeywordScored(repoRoot, query, limit);
-  return keywordResults.map((k) => ({ item: k.chunk, score: k.score }));
-}
-
-// src/memory/knowledge/index.ts
-init_embed_chunks();
-init_embed_lock();
-init_embed_status();
-init_embed_background();
-
-// src/cli-utils.ts
-function getRepoRoot() {
-  return process.env["COMPOUND_AGENT_ROOT"] || process.cwd();
-}
-
-// src/setup/all.ts
-init_embeddings();
-init_storage();
-
-// src/setup/display-utils.ts
-init_storage();
-var STATE_DIR = ".claude";
-var STATE_FILE = ".ca-phase-state.json";
-var PHASE_STATE_MAX_AGE_MS = 72 * 60 * 60 * 1e3;
-var PHASES = ["spec-dev", "plan", "work", "review", "compound"];
-var GATES = ["post-plan", "gate-3", "gate-4", "final"];
-function getStatePath(repoRoot) {
-  return join(repoRoot, STATE_DIR, STATE_FILE);
-}
-function isPhaseName(value) {
-  return typeof value === "string" && PHASES.includes(value);
-}
-function isGateName(value) {
-  return typeof value === "string" && GATES.includes(value);
-}
-function isIsoDate(value) {
-  if (typeof value !== "string") return false;
-  return !Number.isNaN(Date.parse(value));
-}
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function migrateLegacyFields(raw) {
-  if (raw.cookit_active === void 0 && typeof raw.lfg_active === "boolean") {
-    raw.cookit_active = raw.lfg_active;
-    delete raw.lfg_active;
-  }
-}
-function validatePhaseState(raw) {
-  if (typeof raw !== "object" || raw === null) return false;
-  const state = raw;
-  migrateLegacyFields(state);
-  return typeof state.cookit_active === "boolean" && typeof state.epic_id === "string" && isPhaseName(state.current_phase) && typeof state.phase_index === "number" && state.phase_index >= 1 && state.phase_index <= 5 && isStringArray(state.skills_read) && Array.isArray(state.gates_passed) && state.gates_passed.every((gate) => isGateName(gate)) && isIsoDate(state.started_at);
-}
-function getPhaseState(repoRoot) {
-  try {
-    const path = getStatePath(repoRoot);
-    if (!existsSync(path)) return null;
-    const raw = readFileSync(path, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!validatePhaseState(parsed)) return null;
-    const age = Date.now() - new Date(parsed.started_at).getTime();
-    if (age > PHASE_STATE_MAX_AGE_MS) {
-      cleanPhaseState(repoRoot);
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function cleanPhaseState(repoRoot) {
-  try {
-    const path = getStatePath(repoRoot);
-    if (existsSync(path)) unlinkSync(path);
-  } catch {
-  }
-}
-init_storage();
-init_embeddings();
-init_storage();
-
-// src/commands/management-crud.ts
-init_storage();
-
-// src/memory/index.ts
-init_types();
-init_storage();
-init_embeddings();
-init_search2();
-init_storage();
-
-// src/commands/shared.ts
-init_utils();
-init_embeddings();
-init_storage();
-init_storage();
-
-// src/commands/management-invalidation.ts
-init_storage();
-init_storage();
-init_storage();
-init_storage();
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var FETCH_TIMEOUT_MS = 3e3;
-var CACHE_FILENAME = "update-check.json";
-async function fetchLatestVersion(packageName = "compound-agent") {
-  try {
-    const res = await fetch(
-      `https://registry.npmjs.org/-/package/${packageName}/dist-tags`,
-      { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) }
-    );
-    if (!res.ok) return null;
-    const data = await res.json();
-    const latest = data["latest"];
-    return typeof latest === "string" ? latest : null;
-  } catch {
-    return null;
-  }
-}
-async function checkForUpdate(cacheDir) {
-  try {
-    const cachePath = join(cacheDir, CACHE_FILENAME);
-    const cached = readCache(cachePath);
-    if (cached) {
-      return {
-        current: VERSION,
-        latest: cached.latest,
-        updateAvailable: semverGt(cached.latest, VERSION)
-      };
-    }
-    const latest = await fetchLatestVersion();
-    if (latest === null) return null;
-    try {
-      mkdirSync(cacheDir, { recursive: true });
-      const cacheData = { latest };
-      writeFileSync(cachePath, JSON.stringify(cacheData));
-    } catch {
-    }
-    return {
-      current: VERSION,
-      latest,
-      updateAvailable: semverGt(latest, VERSION)
-    };
-  } catch {
-    return null;
-  }
-}
-function isMajorUpdate(current, latest) {
-  return parseInt(latest.split(".")[0], 10) > parseInt(current.split(".")[0], 10);
-}
-function formatUpdateNotificationMarkdown(current, latest) {
-  const urgency = isMajorUpdate(current, latest) ? " (MAJOR - may contain breaking changes)" : "";
-  return `
----
-# Update Available
-compound-agent v${latest} is available (current: v${current})${urgency}.
-Run: \`npm update -g compound-agent\` (global) or \`pnpm add -D compound-agent@latest\` (dev dependency)
-`;
-}
-function semverGt(a, b) {
-  const parse = (v) => {
-    const clean = v.split("-")[0];
-    const parts = clean.split(".").map((n) => {
-      const num = parseInt(n, 10);
-      return isNaN(num) ? 0 : num;
-    });
-    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
-  };
-  const [aMaj, aMin, aPat] = parse(a);
-  const [bMaj, bMin, bPat] = parse(b);
-  if (aMaj !== bMaj) return aMaj > bMaj;
-  if (aMin !== bMin) return aMin > bMin;
-  return aPat > bPat;
-}
-function readCache(cachePath) {
-  try {
-    const stat = statSync(cachePath);
-    if (Date.now() - stat.mtimeMs > CACHE_TTL_MS) return null;
-    const raw = readFileSync(cachePath, "utf-8");
-    const data = JSON.parse(raw);
-    if (typeof data.latest !== "string" || !data.latest) return null;
-    return data;
-  } catch {
-    return null;
-  }
-}
-
-// src/commands/management-prime.ts
-var TRUST_LANGUAGE_TEMPLATE = `# Compound Agent Active
-
-> **Context Recovery**: Run \`npx ca prime\` after compaction, clear, or new session
-
-## CLI Commands (ALWAYS USE THESE)
-
-**You MUST use CLI commands for lesson management:**
-
-| Command | Purpose |
-|---------|---------|
-| \`npx ca search "query"\` | Search lessons - MUST call before architectural decisions; use anytime you need context |
-| \`npx ca knowledge "query"\` | Semantic search over project docs - MUST call before architectural decisions; use keyword phrases, not questions |
-| \`npx ca learn "insight"\` | Capture lessons - call AFTER corrections or discoveries |
-
-## Core Constraints
-
-**Default**: Use CLI commands 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 \`npx ca search\` and \`npx ca knowledge\` BEFORE:
-- Architectural decisions or complex planning
-- Implementing patterns you've done before in this repo
-
-**NEVER skip search for complex decisions.** Past mistakes will repeat.
-
-Beyond mandatory triggers, use these commands freely \u2014 they are lightweight queries, not heavyweight operations. Uncertain about a pattern? \`ca search\`. Need a detail from the docs? \`ca knowledge\`. The cost of an unnecessary search is near-zero; the cost of a missed one can be hours.
-
-## Capture Protocol
-
-Run \`npx ca learn\` 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.
-`;
-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}`;
-}
-function formatActiveCookitSection(repoRoot) {
-  const state = getPhaseState(repoRoot);
-  if (state === null || !state.cookit_active) return null;
-  const skillsRead = state.skills_read.length === 0 ? "(none)" : state.skills_read.join(", ");
-  const gatesPassed = state.gates_passed.length === 0 ? "(none)" : state.gates_passed.join(", ");
-  return `
----
-
-# ACTIVE COOK-IT SESSION
-
-Epic: ${state.epic_id}
-Phase: ${state.current_phase} (${state.phase_index}/5)
-Skills read: ${skillsRead}
-Gates passed: ${gatesPassed}
-Started: ${state.started_at}
-
-Resume from phase ${state.current_phase}. Run: \`npx ca phase-check start ${state.current_phase}\`
-Read the skill file first: \`.claude/skills/compound/${state.current_phase}/SKILL.md\`
-`;
-}
-async function getPrimeContext(repoRoot) {
-  const root = repoRoot ?? getRepoRoot();
-  try {
-    await syncIfNeeded(root);
-  } catch {
-  }
-  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}
-`;
-  }
-  const cookitSection = formatActiveCookitSection(root);
-  if (cookitSection !== null) {
-    output += cookitSection;
-  }
-  if (!process.stdout.isTTY && !process.env["CI"] && !process.env["NO_UPDATE_NOTIFIER"]) {
-    try {
-      const updateResult = await checkForUpdate(join(root, ".claude", ".cache"));
-      if (updateResult?.updateAvailable) {
-        output += formatUpdateNotificationMarkdown(updateResult.current, updateResult.latest);
-      }
-    } catch {
-    }
-  }
-  return output;
-}
-
-// src/audit/checks/lessons.ts
-init_storage();
-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 };
-}
-
-// src/audit/checks/patterns.ts
-init_storage();
-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(),
-  timeout: z.number().int().positive().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;
-}
-var DEFAULT_SCRIPT_TIMEOUT = 3e4;
-function runScriptCheck(check, baseDir) {
-  const expectedCode = check.expectExitCode ?? 0;
-  const timeout = check.timeout ?? DEFAULT_SCRIPT_TIMEOUT;
-  try {
-    execSync(check.command, { stdio: ["pipe", "pipe", "pipe"], cwd: baseDir, timeout });
-    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/commands/knowledge.ts
-init_embeddings();
-init_sqlite_knowledge();
-
-// src/commands/knowledge-index.ts
-init_embeddings();
-init_sqlite_knowledge();
-
-// src/commands/clean-lessons.ts
-init_embeddings();
-init_search2();
-init_storage();
-init_embeddings();
-init_storage();
-init_search2();
-
-// src/index.ts
-init_compound();
-var LinterNameSchema = z.enum([
-  "eslint",
-  "ruff",
-  "clippy",
-  "golangci-lint",
-  "ast-grep",
-  "semgrep",
-  "unknown"
-]);
-var LinterInfoSchema = z.object({
-  linter: LinterNameSchema,
-  configPath: z.string().nullable()
-});
-var DETECTION_RULES = [
-  {
-    linter: "eslint",
-    configs: [
-      // Flat config (ESLint v9+)
-      "eslint.config.js",
-      "eslint.config.mjs",
-      "eslint.config.cjs",
-      "eslint.config.ts",
-      "eslint.config.mts",
-      "eslint.config.cts",
-      // Legacy config
-      ".eslintrc.js",
-      ".eslintrc.cjs",
-      ".eslintrc.json",
-      ".eslintrc.yml",
-      ".eslintrc.yaml"
-    ]
-  },
-  {
-    linter: "ruff",
-    configs: ["ruff.toml", ".ruff.toml"]
-  },
-  {
-    linter: "clippy",
-    configs: ["clippy.toml", ".clippy.toml"]
-  },
-  {
-    linter: "golangci-lint",
-    configs: [".golangci.yml", ".golangci.yaml", ".golangci.toml", ".golangci.json"]
-  },
-  {
-    linter: "ast-grep",
-    configs: ["sgconfig.yml"]
-  },
-  {
-    linter: "semgrep",
-    configs: [".semgrep.yml", ".semgrep.yaml"]
-  }
-];
-function unknown() {
-  return { linter: "unknown", configPath: null };
-}
-function isFile(filePath) {
-  try {
-    return statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function pyprojectHasRuff(repoRoot) {
-  const filePath = join(repoRoot, "pyproject.toml");
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    return /^\s*\[tool\.ruff\b/m.test(content);
-  } catch {
-    return false;
-  }
-}
-function detectLinter(repoRoot) {
-  try {
-    for (const rule of DETECTION_RULES) {
-      for (const config of rule.configs) {
-        if (isFile(join(repoRoot, config))) {
-          return { linter: rule.linter, configPath: config };
-        }
-      }
-      if (rule.linter === "ruff" && pyprojectHasRuff(repoRoot)) {
-        return { linter: "ruff", configPath: "pyproject.toml" };
-      }
-    }
-  } catch {
-    return unknown();
-  }
-  return unknown();
-}
-
-// src/index.ts
-init_types();
-
-export { AuditFindingSchema, AuditReportSchema, CANDIDATE_MULTIPLIER, CCT_PATTERNS_PATH, CctPatternSchema, DB_PATH, DEFAULT_TEXT_WEIGHT, DEFAULT_VECTOR_WEIGHT, KNOWLEDGE_DB_PATH, KNOWLEDGE_SCHEMA_VERSION, LESSONS_PATH, LessonItemSchema, LessonSchema, LinterInfoSchema, LinterNameSchema, MODEL_FILENAME, MODEL_URI, MemoryItemRecordSchema, MemoryItemSchema, MemoryItemTypeSchema, PatternItemSchema, PreferenceItemSchema, SolutionItemSchema, VERSION, acquireEmbedLock, appendLesson, appendMemoryItem, buildSimilarityMatrix, calculateScore, chunkFile, closeDb, closeKnowledgeDb, clusterBySimilarity, collectCachedChunkEmbeddings, confirmationBoost, cosineSimilarity, detectLinter, detectSelfCorrection, detectTestFailure, detectUserCorrection, embedChunks, embedText, embedTexts, formatLessonsCheck, generateId, getCachedChunkEmbedding, getEmbedding, getPrimeContext, getUnembeddedChunkCount, indexAndSpawnEmbed, indexDocs, isActionable, isEmbedLocked, isModelAvailable, isModelUsable, isNovel, isSpecific, loadSessionLessons, mergeHybridResults, normalizeBm25Rank, openKnowledgeDb, rankLessons, readCctPatterns, readEmbedStatus, readLessons, readMemoryItems, rebuildIndex, recencyBoost, resolveModel, retrieveForPlan, runAudit, runBackgroundEmbed, searchChunksKeywordScored, searchKeyword, searchKnowledge, searchKnowledgeVector, searchVector, setCachedChunkEmbedding, severityBoost, shouldPropose, spawnBackgroundEmbed, synthesizePattern, unloadEmbedding, writeCctPatterns, writeEmbedStatus };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map