compound-agent 1.5.0 → 1.6.1

package/dist/index.js

@@ -1,19 +1,244 @@
-import { createRequire } from 'module';
-import { mkdirSync, unlinkSync, existsSync, statSync, readFileSync, readdirSync } from 'fs';
-import { join, dirname, extname, relative } from 'path';
 import { createHash } from 'crypto';
-import { readFile, mkdir, appendFile, readdir } from 'fs/promises';
 import { z } from 'zod';
-import { getLlama, LlamaLogLevel, resolveModelFile } from 'node-llama-cpp';
+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 { execSync } from 'child_process';
-import 'url';
+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, 8)}`;
+}
+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: [], skippedCount: 0 };
+    }
+    throw err;
+  }
+  const items = /* @__PURE__ */ new Map();
+  let skippedCount = 0;
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+    const record = parseJsonLine(trimmed, i + 1, strict, onParseError);
+    if (!record) {
+      skippedCount++;
+      continue;
+    }
+    if (record.deleted === true) {
+      items.delete(record.id);
+    } else {
+      const item = toMemoryItem(record);
+      if (item) {
+        items.set(record.id, item);
+      }
+    }
+  }
+  return { items: Array.from(items.values()), skippedCount };
+}
+async function readLessons(repoRoot, options = {}) {
+  const result = await readMemoryItems(repoRoot, options);
+  const lessons = result.items.filter((item) => item.type === "lesson");
+  return { lessons, skippedCount: result.skippedCount };
+}
+var 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 {
@@ -43,51 +268,74 @@ var init_availability = __esm({
   }
 });
 
-// src/memory/storage/sqlite-knowledge/schema.ts
-function createKnowledgeSchema(database) {
-  database.exec(SCHEMA_SQL2);
-  database.pragma(`user_version = ${KNOWLEDGE_SCHEMA_VERSION}`);
+// src/memory/storage/sqlite/schema.ts
+function createSchema(database) {
+  database.exec(SCHEMA_SQL);
+  database.pragma(`user_version = ${SCHEMA_VERSION}`);
 }
-var KNOWLEDGE_SCHEMA_VERSION, SCHEMA_SQL2;
+var SCHEMA_VERSION, SCHEMA_SQL;
 var init_schema = __esm({
-  "src/memory/storage/sqlite-knowledge/schema.ts"() {
-    KNOWLEDGE_SCHEMA_VERSION = 2;
-    SCHEMA_SQL2 = `
-  CREATE TABLE IF NOT EXISTS chunks (
+  "src/memory/storage/sqlite/schema.ts"() {
+    SCHEMA_VERSION = 4;
+    SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS lessons (
     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,
+    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,
-    model TEXT,
-    updated_at TEXT NOT NULL
+    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 chunks_fts USING fts5(
-    text,
-    content='chunks', content_rowid='rowid'
+  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 chunks_ai AFTER INSERT ON chunks BEGIN
-    INSERT INTO chunks_fts(rowid, text)
-    VALUES (new.rowid, new.text);
+  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 chunks_ad AFTER DELETE ON chunks BEGIN
-    INSERT INTO chunks_fts(chunks_fts, rowid, text)
-    VALUES ('delete', old.rowid, old.text);
+  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 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);
+  CREATE TRIGGER IF NOT EXISTS lessons_au AFTER UPDATE ON lessons BEGIN
+    INSERT INTO lessons_fts(lessons_fts, rowid, id, trigger, insight, tags, pattern_bad, pattern_good)
+    VALUES ('delete', old.rowid, old.id, old.trigger, old.insight, old.tags, old.pattern_bad, old.pattern_good);
+    INSERT INTO lessons_fts(rowid, id, trigger, insight, tags, pattern_bad, pattern_good)
+    VALUES (new.rowid, new.id, new.trigger, new.insight, new.tags, new.pattern_bad, new.pattern_good);
   END;
 
-  CREATE INDEX IF NOT EXISTS idx_chunks_file_path ON chunks(file_path);
+  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,
@@ -96,10 +344,14 @@ var init_schema = __esm({
 `;
   }
 });
-function openKnowledgeDb(repoRoot, options = {}) {
+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, KNOWLEDGE_DB_PATH);
-  const cached = knowledgeDbMap.get(key);
+  const key = inMemory ? `:memory:${repoRoot}` : join(repoRoot, DB_PATH);
+  const cached = dbMap.get(key);
   if (cached) {
     return cached;
   }
@@ -111,8 +363,7 @@ function openKnowledgeDb(repoRoot, options = {}) {
     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) {
+    if (!hasExpectedVersion(database)) {
       database.close();
       try {
         unlinkSync(key);
@@ -122,679 +373,1004 @@ function openKnowledgeDb(repoRoot, options = {}) {
     }
     database.pragma("journal_mode = WAL");
   }
-  createKnowledgeSchema(database);
-  knowledgeDbMap.set(key, database);
+  createSchema(database);
+  dbMap.set(key, database);
   return database;
 }
-function closeKnowledgeDb() {
-  for (const database of knowledgeDbMap.values()) {
+function closeDb() {
+  for (const database of dbMap.values()) {
     database.close();
   }
-  knowledgeDbMap.clear();
+  dbMap.clear();
 }
-var KNOWLEDGE_DB_PATH, knowledgeDbMap;
+var DB_PATH, dbMap;
 var init_connection = __esm({
-  "src/memory/storage/sqlite-knowledge/connection.ts"() {
+  "src/memory/storage/sqlite/connection.ts"() {
     init_availability();
     init_schema();
-    KNOWLEDGE_DB_PATH = ".claude/.cache/knowledge.sqlite";
-    knowledgeDbMap = /* @__PURE__ */ new Map();
+    DB_PATH = ".claude/.cache/lessons.sqlite";
+    dbMap = /* @__PURE__ */ new Map();
   }
 });
-function generateChunkId(filePath, startLine, endLine) {
-  return createHash("sha256").update(`${filePath}:${startLine}:${endLine}`).digest("hex").slice(0, 16);
+function contentHash(trigger, insight) {
+  return createHash("sha256").update(`${trigger} ${insight}`).digest("hex");
 }
-function chunkContentHash(text) {
-  return createHash("sha256").update(text).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);
 }
-var SUPPORTED_EXTENSIONS, CODE_EXTENSIONS;
-var init_types = __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"
-    ]);
+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 });
   }
-});
-
-// 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 embBuffer = 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 path2 of paths) {
-      del.run(path2);
-    }
-  });
-  deleteMany(filePaths);
+  return result;
 }
-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 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 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 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 setLastIndexTime(repoRoot, time) {
-  const database = openKnowledgeDb(repoRoot);
-  database.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES ('last_index_time', ?)").run(time);
+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_sync = __esm({
-  "src/memory/storage/sqlite-knowledge/sync.ts"() {
+var init_cache = __esm({
+  "src/memory/storage/sqlite/cache.ts"() {
     init_connection();
   }
 });
-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);
+function getJsonlMtime(repoRoot) {
+  const jsonlPath = join(repoRoot, LESSONS_PATH);
+  try {
+    const stat = statSync(jsonlPath);
+    return stat.mtimeMs;
+  } catch {
+    return null;
   }
-  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 getLastSyncMtime(database) {
+  const row = database.prepare("SELECT value FROM metadata WHERE key = ?").get("last_sync_mtime");
+  return row ? parseFloat(row.value) : null;
 }
-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;
-      }
+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);
     }
-    current.push(lineObj);
+    return;
   }
-  if (current.length > 0) {
-    sections.push(current);
+  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);
   }
-  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);
+async function syncIfNeeded(repoRoot, options = {}) {
+  const { force = false } = options;
+  const jsonlMtime = getJsonlMtime(repoRoot);
+  if (jsonlMtime === null && !force) {
+    return false;
   }
-  if (current.length > 0) {
-    sections.push(current);
+  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 sections;
+  return false;
 }
-function sectionText(section) {
-  return section.map((l) => l.text).join("\n");
+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 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;
+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 });
   }
-  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;
+  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 });
     }
   }
-  if (accumulated.length > 0) {
-    emitChunk(accumulated, overlapLines);
+  const results = [];
+  for (const entry of merged.values()) {
+    results.push({
+      item: entry.item,
+      score: vecW * entry.vecScore + txtW * entry.txtScore
+    });
   }
-  return chunks;
+  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;
 }
-var DEFAULT_TARGET_SIZE, DEFAULT_OVERLAP_SIZE;
-var init_chunking = __esm({
-  "src/memory/knowledge/chunking.ts"() {
-    init_types();
-    DEFAULT_TARGET_SIZE = 1600;
-    DEFAULT_OVERLAP_SIZE = 320;
+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;
   }
 });
-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;
+
+// src/memory/storage/sqlite/search.ts
+function safeJsonParse(value, fallback) {
   try {
-    entries = await readdir(baseDir, { recursive: true, withFileTypes: true });
+    return JSON.parse(value);
   } 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 fallback;
   }
-  return results;
 }
-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,
-    durationMs: 0
+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
   };
-  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;
+  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 }
+    };
   }
-  const indexedPaths = getIndexedFilePaths(repoRoot);
-  const currentPathSet = new Set(filePaths);
-  const stalePaths = indexedPaths.filter((p) => !currentPathSet.has(p));
-  if (stalePaths.length > 0) {
-    for (const path2 of stalePaths) {
-      stats.chunksDeleted += getChunkCountByFilePath(repoRoot, path2);
-    }
-    deleteChunksByFilePath(repoRoot, stalePaths);
-    for (const path2 of stalePaths) {
-      removeFileHash(repoRoot, path2);
-    }
+  if (row.compaction_level !== null && row.compaction_level !== 0) {
+    item.compactionLevel = row.compaction_level;
   }
-  setLastIndexTime(repoRoot, (/* @__PURE__ */ new Date()).toISOString());
-  stats.durationMs = Date.now() - start;
-  return stats;
-}
-var init_indexing = __esm({
-  "src/memory/knowledge/indexing.ts"() {
-    init_connection();
-    init_sync();
-    init_chunking();
-    init_types();
+  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 };
   }
-});
-var _require = createRequire(import.meta.url);
-var _pkg = _require("../package.json");
-var VERSION = _pkg.version;
-var SourceSchema = z.enum([
-  "user_correction",
-  "self_correction",
-  "test_failure",
-  "manual"
-]);
-var ContextSchema = z.object({
-  tool: z.string(),
-  intent: z.string()
-});
-var PatternSchema = z.object({
-  bad: z.string(),
-  good: z.string()
-});
-var CitationSchema = z.object({
-  file: z.string().min(1),
-  // Source file path (required, non-empty)
-  line: z.number().int().positive().optional(),
-  // Line number (optional, must be positive)
-  commit: z.string().optional()
-  // Git commit hash (optional)
-});
-var SeveritySchema = z.enum(["high", "medium", "low"]);
-var CompactionLevelSchema = z.union([
-  z.literal(0),
-  // Active
-  z.literal(1),
-  // Flagged (>90 days)
-  z.literal(2)
-  // Archived
-]);
-var LessonTypeSchema = z.enum(["quick", "full"]);
-var MemoryItemTypeSchema = z.enum(["lesson", "solution", "pattern", "preference"]);
-var baseFields = {
-  // Core identity (required)
-  id: z.string(),
-  trigger: z.string(),
-  insight: z.string(),
-  // Metadata (required)
-  tags: z.array(z.string()),
-  source: SourceSchema,
-  context: ContextSchema,
-  created: z.string(),
-  // ISO8601
-  confirmed: z.boolean(),
-  // Relationships (required, can be empty arrays)
-  supersedes: z.array(z.string()),
-  related: z.array(z.string()),
-  // Extended fields (optional)
-  evidence: z.string().optional(),
-  severity: SeveritySchema.optional(),
-  // Lifecycle fields (optional)
-  deleted: z.boolean().optional(),
-  deletedAt: z.string().optional(),
-  retrievalCount: z.number().optional(),
-  // Provenance tracking (optional)
-  citation: CitationSchema.optional(),
-  // Age-based validity fields (optional)
-  compactionLevel: CompactionLevelSchema.optional(),
-  compactedAt: z.string().optional(),
-  lastRetrieved: z.string().optional(),
-  // Invalidation fields (optional)
-  invalidatedAt: z.string().optional(),
-  invalidationReason: z.string().optional()
-};
-var LessonItemSchema = z.object({
-  ...baseFields,
-  type: z.literal("lesson"),
-  pattern: PatternSchema.optional()
-});
-var SolutionItemSchema = z.object({
-  ...baseFields,
-  type: z.literal("solution"),
-  pattern: PatternSchema.optional()
-});
-var PatternItemSchema = z.object({
-  ...baseFields,
-  type: z.literal("pattern"),
-  pattern: PatternSchema
-});
-var PreferenceItemSchema = z.object({
-  ...baseFields,
-  type: z.literal("preference"),
-  pattern: PatternSchema.optional()
-});
-var MemoryItemSchema = z.discriminatedUnion("type", [
-  LessonItemSchema,
-  SolutionItemSchema,
-  PatternItemSchema,
-  PreferenceItemSchema
-]);
-var LegacyLessonSchema = z.object({
-  ...baseFields,
-  type: LessonTypeSchema,
-  pattern: PatternSchema.optional()
-});
-var LessonSchema = LessonItemSchema;
-var LegacyTombstoneSchema = z.object({
-  id: z.string(),
-  deleted: z.literal(true),
-  deletedAt: z.string()
-  // ISO8601
-});
-var LessonRecordSchema = z.union([
-  MemoryItemSchema,
-  LegacyLessonSchema,
-  LegacyTombstoneSchema
-]);
-var MemoryItemRecordSchema = LessonRecordSchema;
-var TYPE_PREFIXES = {
-  lesson: "L",
-  solution: "S",
-  pattern: "P",
-  preference: "R"
-};
-function generateId(insight, type) {
-  const prefix = TYPE_PREFIXES[type ?? "lesson"];
-  const hash = createHash("sha256").update(insight).digest("hex");
-  return `${prefix}${hash.slice(0, 8)}`;
+  const result = MemoryItemSchema.safeParse(item);
+  if (!result.success) return null;
+  return result.data;
 }
-
-// src/memory/storage/jsonl.ts
-var LESSONS_PATH = ".claude/lessons/index.jsonl";
-async function appendMemoryItem(repoRoot, item) {
-  const filePath = join(repoRoot, LESSONS_PATH);
-  await mkdir(dirname(filePath), { recursive: true });
-  const line = JSON.stringify(item) + "\n";
-  await appendFile(filePath, line, "utf-8");
+function 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);
 }
-async function appendLesson(repoRoot, lesson) {
-  return appendMemoryItem(repoRoot, lesson);
+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 parseJsonLine(line, lineNumber, strict, onParseError) {
-  let parsed;
+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 {
-    parsed = JSON.parse(line);
+    return database.prepare(sql).all(...params);
   } 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 message = err instanceof Error ? err.message : "Unknown FTS5 error";
+    console.error(`[compound-agent] search error: ${message}`);
+    return [];
   }
-  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}`);
+}
+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) });
     }
-    onParseError?.(parseError);
-    return null;
   }
-  return result.data;
+  return results;
 }
-function toMemoryItem(record) {
-  if (record.deleted === true) {
-    return null;
+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"]);
   }
-  if (record.type === "quick" || record.type === "full") {
-    return { ...record, type: "lesson" };
+});
+
+// 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();
   }
-  return record;
+});
+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 readMemoryItems(repoRoot, options = {}) {
-  const { strict = false, onParseError } = options;
-  const filePath = join(repoRoot, LESSONS_PATH);
-  let content;
+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 {
-    content = await readFile(filePath, "utf-8");
+    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) {
-    if (err.code === "ENOENT") {
-      return { items: [], skippedCount: 0 };
+    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 {
+      }
     }
-    throw err;
-  }
-  const items = /* @__PURE__ */ new Map();
-  let skippedCount = 0;
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
-    if (!trimmed) continue;
-    const record = parseJsonLine(trimmed, i + 1, strict, onParseError);
-    if (!record) {
-      skippedCount++;
-      continue;
+    if (model) {
+      try {
+        await model.dispose();
+      } catch {
+      }
     }
-    if (record.deleted === true) {
-      items.delete(record.id);
-    } else {
-      const item = toMemoryItem(record);
-      if (item) {
-        items.set(record.id, item);
+    if (llama) {
+      try {
+        await llama.dispose();
+      } catch {
       }
     }
   }
-  return { items: Array.from(items.values()), skippedCount };
 }
-async function readLessons(repoRoot, options = {}) {
-  const result = await readMemoryItems(repoRoot, options);
-  const lessons = result.items.filter((item) => item.type === "lesson");
-  return { lessons, skippedCount: result.skippedCount };
+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;
+}
+function unloadEmbedding() {
+  if (embeddingContext) {
+    embeddingContext.dispose().catch(() => {
+    });
+    embeddingContext = null;
+  }
+  if (modelInstance) {
+    modelInstance.dispose().catch(() => {
+    });
+    modelInstance = null;
+  }
+  if (llamaInstance) {
+    llamaInstance.dispose().catch(() => {
+    });
+    llamaInstance = null;
+  }
+  pendingInit = null;
+}
+async function embedText(text) {
+  const ctx = await getEmbedding();
+  const result = await ctx.getEmbeddingFor(text);
+  return 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/storage/sqlite/connection.ts
-init_availability();
+// src/memory/embeddings/index.ts
+var init_embeddings = __esm({
+  "src/memory/embeddings/index.ts"() {
+    init_nomic();
+    init_model();
+  }
+});
 
-// src/memory/storage/sqlite/schema.ts
-var SCHEMA_VERSION = 3;
-var SCHEMA_SQL = `
-  CREATE TABLE IF NOT EXISTS lessons (
-    id TEXT PRIMARY KEY,
-    type TEXT NOT NULL,
-    trigger TEXT NOT NULL,
-    insight TEXT NOT NULL,
-    evidence TEXT,
-    severity TEXT,
-    tags TEXT NOT NULL DEFAULT '',
-    source TEXT NOT NULL,
-    context TEXT NOT NULL DEFAULT '{}',
-    supersedes TEXT NOT NULL DEFAULT '[]',
-    related TEXT NOT NULL DEFAULT '[]',
-    created TEXT NOT NULL,
-    confirmed INTEGER NOT NULL DEFAULT 0,
-    deleted INTEGER NOT NULL DEFAULT 0,
-    retrieval_count INTEGER NOT NULL DEFAULT 0,
-    last_retrieved TEXT,
+// 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 = Array.from(groups.values());
+  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;
+    const parsed = JSON.parse(trimmed);
+    const result = CctPatternSchema.safeParse(parsed);
+    if (result.success) {
+      patterns.push(result.data);
+    }
+  }
+  return patterns;
+}
+async function writeCctPatterns(repoRoot, patterns) {
+  const filePath = join(repoRoot, CCT_PATTERNS_PATH);
+  await mkdir(dirname(filePath), { recursive: true });
+  const lines = patterns.map((p) => JSON.stringify(p) + "\n").join("");
+  await appendFile(filePath, lines, "utf-8");
+}
+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,
-    content_hash TEXT,
-    invalidated_at TEXT,
-    invalidation_reason TEXT,
-    citation_file TEXT,
-    citation_line INTEGER,
-    citation_commit TEXT,
-    compaction_level INTEGER DEFAULT 0,
-    compacted_at TEXT,
-    pattern_bad TEXT,
-    pattern_good TEXT
+    model TEXT,
+    updated_at TEXT NOT NULL
   );
 
-  CREATE VIRTUAL TABLE IF NOT EXISTS lessons_fts USING fts5(
-    id, trigger, insight, tags, pattern_bad, pattern_good,
-    content='lessons', content_rowid='rowid'
+  CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+    text,
+    content='chunks', 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);
+  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 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);
+  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 lessons_au AFTER UPDATE ON lessons BEGIN
-    INSERT INTO lessons_fts(lessons_fts, rowid, id, trigger, insight, tags, pattern_bad, pattern_good)
-    VALUES ('delete', old.rowid, old.id, old.trigger, old.insight, old.tags, old.pattern_bad, old.pattern_good);
-    INSERT INTO lessons_fts(rowid, id, trigger, insight, tags, pattern_bad, pattern_good)
-    VALUES (new.rowid, new.id, new.trigger, new.insight, new.tags, new.pattern_bad, new.pattern_good);
+  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_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 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 createSchema(database) {
-  database.exec(SCHEMA_SQL);
-  database.pragma(`user_version = ${SCHEMA_VERSION}`);
-}
-
-// src/memory/storage/sqlite/connection.ts
-var DB_PATH = ".claude/.cache/lessons.sqlite";
-var dbMap = /* @__PURE__ */ new Map();
-function hasExpectedVersion(database) {
-  const row = database.pragma("user_version", { simple: true });
-  return row === SCHEMA_VERSION;
-}
-function openDb(repoRoot, options = {}) {
+  }
+});
+function openKnowledgeDb(repoRoot, options = {}) {
   const { inMemory = false } = options;
-  const key = inMemory ? `:memory:${repoRoot}` : join(repoRoot, DB_PATH);
-  const cached = dbMap.get(key);
+  const key = inMemory ? `:memory:${repoRoot}` : join(repoRoot, KNOWLEDGE_DB_PATH);
+  const cached = knowledgeDbMap.get(key);
   if (cached) {
     return cached;
   }
@@ -806,7 +1382,8 @@ function openDb(repoRoot, options = {}) {
     const dir = dirname(key);
     mkdirSync(dir, { recursive: true });
     database = new Database(key);
-    if (!hasExpectedVersion(database)) {
+    const version = database.pragma("user_version", { simple: true });
+    if (version !== 0 && version !== KNOWLEDGE_SCHEMA_VERSION) {
       database.close();
       try {
         unlinkSync(key);
@@ -814,741 +1391,794 @@ function openDb(repoRoot, options = {}) {
       }
       database = new Database(key);
     }
-    database.pragma("journal_mode = WAL");
-  }
-  createSchema(database);
-  dbMap.set(key, database);
-  return database;
-}
-function closeDb() {
-  for (const database of dbMap.values()) {
-    database.close();
-  }
-  dbMap.clear();
-}
-function contentHash(trigger, insight) {
-  return createHash("sha256").update(`${trigger} ${insight}`).digest("hex");
-}
-function getCachedEmbedding(repoRoot, lessonId, expectedHash) {
-  const database = openDb(repoRoot);
-  const row = database.prepare("SELECT embedding, content_hash FROM lessons WHERE id = ?").get(lessonId);
-  if (!row || !row.embedding || !row.content_hash) {
-    return null;
-  }
-  if (expectedHash && row.content_hash !== expectedHash) {
-    return null;
-  }
-  const float32 = new Float32Array(
-    row.embedding.buffer,
-    row.embedding.byteOffset,
-    row.embedding.byteLength / 4
-  );
-  return Array.from(float32);
-}
-function setCachedEmbedding(repoRoot, lessonId, embedding, hash) {
-  const database = openDb(repoRoot);
-  const float32 = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
-  const buffer = Buffer.from(float32.buffer, float32.byteOffset, float32.byteLength);
-  database.prepare("UPDATE lessons SET embedding = ?, content_hash = ? WHERE id = ?").run(buffer, hash, lessonId);
-}
-function collectCachedEmbeddings(database) {
-  const cache = /* @__PURE__ */ new Map();
-  const rows = database.prepare("SELECT id, embedding, content_hash FROM lessons WHERE embedding IS NOT NULL").all();
-  for (const row of rows) {
-    if (row.embedding && row.content_hash) {
-      cache.set(row.id, { embedding: row.embedding, contentHash: row.content_hash });
-    }
-  }
-  return cache;
-}
-var INSERT_LESSON_SQL = `
-  INSERT INTO lessons (id, type, trigger, insight, evidence, severity, tags, source, context, supersedes, related, created, confirmed, deleted, retrieval_count, last_retrieved, embedding, content_hash, invalidated_at, invalidation_reason, citation_file, citation_line, citation_commit, compaction_level, compacted_at, pattern_bad, pattern_good)
-  VALUES (@id, @type, @trigger, @insight, @evidence, @severity, @tags, @source, @context, @supersedes, @related, @created, @confirmed, @deleted, @retrieval_count, @last_retrieved, @embedding, @content_hash, @invalidated_at, @invalidation_reason, @citation_file, @citation_line, @citation_commit, @compaction_level, @compacted_at, @pattern_bad, @pattern_good)
-`;
-function getJsonlMtime(repoRoot) {
-  const jsonlPath = join(repoRoot, LESSONS_PATH);
-  try {
-    const stat = statSync(jsonlPath);
-    return stat.mtimeMs;
-  } catch {
-    return null;
-  }
-}
-function getLastSyncMtime(database) {
-  const row = database.prepare("SELECT value FROM metadata WHERE key = ?").get("last_sync_mtime");
-  return row ? parseFloat(row.value) : null;
-}
-function setLastSyncMtime(database, mtime) {
-  database.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)").run("last_sync_mtime", mtime.toString());
-}
-async function rebuildIndex(repoRoot) {
-  const database = openDb(repoRoot);
-  const { items } = await readMemoryItems(repoRoot);
-  const cachedEmbeddings = collectCachedEmbeddings(database);
-  database.exec("DELETE FROM lessons");
-  if (items.length === 0) {
-    const mtime2 = getJsonlMtime(repoRoot);
-    if (mtime2 !== null) {
-      setLastSyncMtime(database, mtime2);
-    }
-    return;
-  }
-  const insert = database.prepare(INSERT_LESSON_SQL);
-  const insertMany = database.transaction((memoryItems) => {
-    for (const item of memoryItems) {
-      const newHash = contentHash(item.trigger, item.insight);
-      const cached = cachedEmbeddings.get(item.id);
-      const hasValidCache = cached && cached.contentHash === newHash;
-      insert.run({
-        id: item.id,
-        type: item.type,
-        trigger: item.trigger,
-        insight: item.insight,
-        evidence: item.evidence ?? null,
-        severity: item.severity ?? null,
-        tags: item.tags.join(","),
-        source: item.source,
-        context: JSON.stringify(item.context),
-        supersedes: JSON.stringify(item.supersedes),
-        related: JSON.stringify(item.related),
-        created: item.created,
-        confirmed: item.confirmed ? 1 : 0,
-        deleted: item.deleted ? 1 : 0,
-        retrieval_count: item.retrievalCount ?? 0,
-        last_retrieved: item.lastRetrieved ?? null,
-        embedding: hasValidCache ? cached.embedding : null,
-        content_hash: hasValidCache ? cached.contentHash : null,
-        invalidated_at: item.invalidatedAt ?? null,
-        invalidation_reason: item.invalidationReason ?? null,
-        citation_file: item.citation?.file ?? null,
-        citation_line: item.citation?.line ?? null,
-        citation_commit: item.citation?.commit ?? null,
-        compaction_level: item.compactionLevel ?? 0,
-        compacted_at: item.compactedAt ?? null,
-        pattern_bad: item.pattern?.bad ?? null,
-        pattern_good: item.pattern?.good ?? null
-      });
-    }
-  });
-  insertMany(items);
-  const mtime = getJsonlMtime(repoRoot);
-  if (mtime !== null) {
-    setLastSyncMtime(database, mtime);
+    database.pragma("journal_mode = WAL");
   }
+  createKnowledgeSchema(database);
+  knowledgeDbMap.set(key, database);
+  return database;
 }
-async function syncIfNeeded(repoRoot, options = {}) {
-  const { force = false } = options;
-  const jsonlMtime = getJsonlMtime(repoRoot);
-  if (jsonlMtime === null && !force) {
-    return false;
+function closeKnowledgeDb() {
+  for (const database of knowledgeDbMap.values()) {
+    database.close();
   }
-  const database = openDb(repoRoot);
-  const lastSyncMtime = getLastSyncMtime(database);
-  const needsRebuild = force || lastSyncMtime === null || jsonlMtime !== null && jsonlMtime > lastSyncMtime;
-  if (needsRebuild) {
-    await rebuildIndex(repoRoot);
-    return true;
+  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();
   }
-  return false;
+});
+function generateChunkId(filePath, startLine, endLine) {
+  return createHash("sha256").update(`${filePath}:${startLine}:${endLine}`).digest("hex").slice(0, 16);
 }
-
-// src/memory/storage/sqlite/index.ts
-init_availability();
-
-// src/memory/search/hybrid.ts
-var DEFAULT_VECTOR_WEIGHT = 0.7;
-var DEFAULT_TEXT_WEIGHT = 0.3;
-var CANDIDATE_MULTIPLIER = 4;
-var MIN_HYBRID_SCORE = 0.35;
-function normalizeBm25Rank(rank) {
-  if (!Number.isFinite(rank)) return 0;
-  const abs = Math.abs(rank);
-  return abs / (1 + abs);
+function chunkContentHash(text) {
+  return createHash("sha256").update(text).digest("hex");
 }
-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 });
+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"
+    ]);
   }
-  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 });
-    }
+});
+
+// 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;
   }
-  const results = [];
-  for (const entry of merged.values()) {
-    results.push({
-      item: entry.item,
-      score: vecW * entry.vecScore + txtW * entry.txtScore
-    });
+  if (expectedHash && row.content_hash !== expectedHash) {
+    return null;
   }
-  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;
+  return new Float32Array(
+    row.embedding.buffer,
+    row.embedding.byteOffset,
+    row.embedding.byteLength / 4
+  );
 }
-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 }));
+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);
 }
-
-// src/memory/storage/sqlite/search.ts
-function safeJsonParse(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
+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;
 }
-function rowToMemoryItem(row) {
-  const item = {
+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,
-    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
+    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.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 };
+  if (row.model !== null) {
+    chunk.model = row.model;
   }
-  const result = MemoryItemSchema.safeParse(item);
-  if (!result.success) return null;
-  return result.data;
-}
-var FTS_OPERATORS = /* @__PURE__ */ new Set(["AND", "OR", "NOT", "NEAR"]);
-function sanitizeFtsQuery(query) {
-  const stripped = query.replace(/["*^+\-():{}]/g, "");
-  const tokens = stripped.split(/\s+/).filter((t) => t.length > 0 && !FTS_OPERATORS.has(t));
-  return tokens.join(" ");
-}
-function incrementRetrievalCount(repoRoot, lessonIds) {
-  if (lessonIds.length === 0) return;
-  const database = openDb(repoRoot);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const update = database.prepare(`
-    UPDATE lessons
-    SET retrieval_count = retrieval_count + 1,
-        last_retrieved = ?
-    WHERE id = ?
-  `);
-  const updateMany = database.transaction((ids) => {
-    for (const id of ids) {
-      update.run(now, id);
-    }
-  });
-  updateMany(lessonIds);
+  return chunk;
 }
-function executeFtsQuery(repoRoot, query, limit, options) {
-  const database = openDb(repoRoot);
+function searchChunksKeywordScored(repoRoot, query, limit) {
+  const database = openKnowledgeDb(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);
+    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] search error: ${message}`);
+    console.error(`[compound-agent] knowledge scored 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);
+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);
 }
-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) });
+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);
     }
-  }
-  return results;
+  });
+  deleteMany(filePaths);
 }
-
-// src/utils.ts
-var MS_PER_DAY = 24 * 60 * 60 * 1e3;
-function getLessonAgeDays(lesson) {
-  const created = new Date(lesson.created).getTime();
-  const now = Date.now();
-  return Math.floor((now - created) / MS_PER_DAY);
+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);
 }
-var MODEL_URI = "hf:ggml-org/embeddinggemma-300M-qat-q4_0-GGUF/embeddinggemma-300M-qat-Q4_0.gguf";
-var MODEL_FILENAME = "hf_ggml-org_embeddinggemma-300M-qat-Q4_0.gguf";
-var DEFAULT_MODEL_DIR = join(homedir(), ".node-llama-cpp", "models");
-var cachedUsability = null;
-function isModelAvailable() {
-  return existsSync(join(DEFAULT_MODEL_DIR, MODEL_FILENAME));
+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;
 }
-async function isModelUsable() {
-  if (cachedUsability !== null) {
-    return cachedUsability;
+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();
   }
-  if (!isModelAvailable()) {
-    cachedUsability = {
-      usable: false,
-      reason: "Embedding model file not found",
-      action: "Run: npx ca download-model"
-    };
-    return cachedUsability;
+});
+
+// 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();
   }
-  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 {
-      }
+});
+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 (model) {
-      try {
-        await model.dispose();
-      } catch {
-      }
+    if (!inCodeBlock && /^#{2,}\s/.test(line) && current.length > 0) {
+      sections.push(current);
+      current = [lineObj];
+      continue;
     }
-    if (llama) {
-      try {
-        await llama.dispose();
-      } catch {
-      }
+    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;
 }
-async function resolveModel(options = {}) {
-  const { cli = true } = options;
-  return resolveModelFile(MODEL_URI, { cli });
+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;
 }
-
-// src/memory/embeddings/nomic.ts
-var embeddingContext = null;
-var pendingInit = null;
-var llamaInstance = null;
-var modelInstance = null;
-async function getEmbedding() {
-  if (embeddingContext) return embeddingContext;
-  if (pendingInit) return pendingInit;
-  pendingInit = (async () => {
-    try {
-      const modelPath = await resolveModel({ cli: true });
-      llamaInstance = await getLlama({
-        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;
+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;
     }
-  })();
-  return pendingInit;
+    current.push(lineObj);
+  }
+  if (current.length > 0) {
+    sections.push(current);
+  }
+  return sections;
 }
-function unloadEmbedding() {
-  if (embeddingContext) {
-    embeddingContext.dispose().catch(() => {
+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)
     });
-    embeddingContext = null;
+    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;
   }
-  if (modelInstance) {
-    modelInstance.dispose().catch(() => {
-    });
-    modelInstance = null;
+  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 (llamaInstance) {
-    llamaInstance.dispose().catch(() => {
-    });
-    llamaInstance = null;
+  if (accumulated.length > 0) {
+    emitChunk(accumulated, overlapLines);
   }
-  pendingInit = null;
-}
-async function embedText(text) {
-  const ctx = await getEmbedding();
-  const result = await ctx.getEmbeddingFor(text);
-  return Array.from(result.vector);
+  return chunks;
 }
-async function embedTexts(texts) {
-  if (texts.length === 0) return [];
-  const ctx = await getEmbedding();
-  const results = [];
-  for (const text of texts) {
-    const result = await ctx.getEmbeddingFor(text);
-    results.push(Array.from(result.vector));
+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;
   }
-  return results;
-}
+});
 
-// src/compound/clustering.ts
-var DEFAULT_THRESHOLD = 0.75;
-function buildSimilarityMatrix(embeddings) {
-  const n = embeddings.length;
-  const matrix = Array.from({ length: n }, () => new Array(n).fill(0));
-  for (let i = 0; i < n; i++) {
-    matrix[i][i] = 1;
-    for (let j = i + 1; j < n; j++) {
-      const sim = cosineSimilarity(embeddings[i], embeddings[j]);
-      matrix[i][j] = sim;
-      matrix[j][i] = sim;
-    }
-  }
-  return matrix;
+// 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;
 }
-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);
-      }
+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);
     }
-  }
-  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);
+  });
+  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`);
     }
-    group.push(items[i]);
+    const enriched = batch.map((r, j) => ({ ...r, vector: vectors[j] }));
+    writeBatch(enriched);
+    chunksEmbedded += batch.length;
   }
-  const clusters = Array.from(groups.values());
-  return { clusters, noise: [] };
+  return {
+    chunksEmbedded,
+    chunksSkipped,
+    durationMs: Date.now() - start
+  };
 }
-var CCT_PATTERNS_PATH = ".claude/lessons/cct-patterns.jsonl";
-var CctPatternSchema = z.object({
-  id: z.string().regex(/^CCT-[a-f0-9]{8}$/),
-  name: z.string().min(1),
-  description: z.string().min(1),
-  frequency: z.number().int().positive(),
-  testable: z.boolean(),
-  testApproach: z.string().optional(),
-  sourceIds: z.array(z.string()).min(1),
-  created: z.string()
-  // ISO8601
+var BATCH_SIZE;
+var init_embed_chunks = __esm({
+  "src/memory/knowledge/embed-chunks.ts"() {
+    init_nomic();
+    init_connection2();
+    BATCH_SIZE = 16;
+  }
 });
-function generateCctId(input) {
-  const hash = createHash("sha256").update(input).digest("hex");
-  return `CCT-${hash.slice(0, 8)}`;
-}
 
-// src/compound/io.ts
-async function readCctPatterns(repoRoot) {
-  const filePath = join(repoRoot, CCT_PATTERNS_PATH);
-  let content;
+// 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 {
-    content = await readFile(filePath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return [];
-    }
-    throw err;
+    entries = await readdir(baseDir, { recursive: true, withFileTypes: true });
+  } catch {
+    return results;
   }
-  const patterns = [];
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    const parsed = JSON.parse(trimmed);
-    const result = CctPatternSchema.safeParse(parsed);
-    if (result.success) {
-      patterns.push(result.data);
-    }
+  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 patterns;
+  return results;
 }
-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");
+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;
 }
-
-// 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);
+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 sortedTags = [...tagCounts.entries()].sort((a, b) => b[1] - a[1]).map(([tag]) => tag);
-  const name = sortedTags.length > 0 ? sortedTags.slice(0, 3).join(", ") : cluster[0].insight.slice(0, 50);
-  const description = cluster.map((item) => item.insight).join("; ");
-  const hasHighSeverity = cluster.some(
-    (item) => "severity" in item && item.severity === "high"
-  );
-  const hasEvidence = cluster.some(
-    (item) => "evidence" in item && item.evidence
-  );
-  const testable = hasHighSeverity || hasEvidence;
-  const testApproach = testable ? `Verify pattern: ${name}. Check ${frequency} related lesson(s).` : void 0;
-  return {
-    id,
-    name,
-    description,
-    frequency,
-    testable,
-    ...testApproach !== void 0 && { testApproach },
-    sourceIds,
-    created: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-
-// src/memory/search/vector.ts
-var cctEmbeddingCache = /* @__PURE__ */ new Map();
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have same 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);
+    }
   }
-  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];
+  setLastIndexTime(repoRoot, (/* @__PURE__ */ new Date()).toISOString());
+  if (options.embed) {
+    stats.chunksEmbedded = await tryEmbedChunks(repoRoot);
   }
-  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-  if (magnitude === 0) return 0;
-  return dotProduct / magnitude;
+  stats.durationMs = Date.now() - start;
+  return stats;
 }
-var DEFAULT_LIMIT = 10;
-function cctToMemoryItem(pattern) {
-  return {
-    id: pattern.id,
-    type: "lesson",
-    trigger: pattern.name,
-    insight: pattern.description,
-    tags: [],
-    source: "manual",
-    context: { tool: "compound", intent: "synthesis" },
-    created: pattern.created,
-    confirmed: true,
-    supersedes: [],
-    related: pattern.sourceIds
-  };
+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");
 }
-async function searchVector(repoRoot, query, options) {
-  const limit = options?.limit ?? DEFAULT_LIMIT;
-  const { items } = await readMemoryItems(repoRoot);
-  let cctPatterns = [];
+function lockDir(repoRoot) {
+  return join(repoRoot, ".claude", ".cache");
+}
+function isProcessAlive(pid) {
   try {
-    cctPatterns = await readCctPatterns(repoRoot);
+    process.kill(pid, 0);
+    return true;
   } catch {
+    return false;
   }
-  if (items.length === 0 && cctPatterns.length === 0) return [];
-  const queryVector = await embedText(query);
-  const scored = [];
-  for (const item of items) {
-    if (item.invalidatedAt) continue;
-    try {
-      const itemText = `${item.trigger} ${item.insight}`;
-      const hash = contentHash(item.trigger, item.insight);
-      let itemVector = getCachedEmbedding(repoRoot, item.id, hash);
-      if (!itemVector) {
-        itemVector = await embedText(itemText);
-        setCachedEmbedding(repoRoot, item.id, itemVector, hash);
+}
+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 };
       }
-      const score = cosineSimilarity(queryVector, itemVector);
-      scored.push({ lesson: item, score });
+    }
+    try {
+      unlinkSync(file);
     } 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 });
+      writeFileSync(file, JSON.stringify(content), { flag: "wx" });
+      return { acquired: true, release: () => releaseLock(file) };
     } catch {
-      continue;
+      const winner = readLock(file);
+      return { acquired: false, holder: winner?.pid ?? -1 };
     }
   }
-  scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, limit);
 }
-
-// src/memory/search/ranking.ts
-var RECENCY_THRESHOLD_DAYS = 30;
-var HIGH_SEVERITY_BOOST = 1.5;
-var MEDIUM_SEVERITY_BOOST = 1;
-var LOW_SEVERITY_BOOST = 0.8;
-var RECENCY_BOOST = 1.2;
-var CONFIRMATION_BOOST = 1.3;
-var MAX_COMBINED_BOOST = 1.8;
-function severityBoost(item) {
-  switch (item.severity) {
-    case "high":
-      return HIGH_SEVERITY_BOOST;
-    case "medium":
-      return MEDIUM_SEVERITY_BOOST;
-    case "low":
-      return LOW_SEVERITY_BOOST;
-    default:
-      return MEDIUM_SEVERITY_BOOST;
+function 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 {
   }
 }
-function recencyBoost(item) {
-  const ageDays = getLessonAgeDays(item);
-  return ageDays <= RECENCY_THRESHOLD_DAYS ? RECENCY_BOOST : 1;
+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 confirmationBoost(item) {
-  return item.confirmed ? CONFIRMATION_BOOST : 1;
+function writeEmbedStatus(repoRoot, status) {
+  const filePath = statusPath(repoRoot);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(status, null, 2), "utf-8");
 }
-function calculateScore(item, vectorSimilarity) {
-  const boost = Math.min(
-    severityBoost(item) * recencyBoost(item) * confirmationBoost(item),
-    MAX_COMBINED_BOOST
-  );
-  return vectorSimilarity * boost;
+function readEmbedStatus(repoRoot) {
+  try {
+    const raw = readFileSync(statusPath(repoRoot), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
 }
-function rankLessons(lessons) {
-  return lessons.map((scored) => ({
-    ...scored,
-    finalScore: calculateScore(scored.lesson, scored.score)
-  })).sort((a, b) => (b.finalScore ?? 0) - (a.finalScore ?? 0));
+var STATUS_FILE;
+var init_embed_status = __esm({
+  "src/memory/knowledge/embed-status.ts"() {
+    STATUS_FILE = ".claude/.cache/embed-status.json";
+  }
+});
+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 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 {
+    unloadEmbedding();
+    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
-var DEFAULT_SIMILARITY_THRESHOLD = 0.8;
+init_model();
+init_search2();
+init_storage();
+var DUPLICATE_THRESHOLD = 0.98;
 async function isNovel(repoRoot, insight, options = {}) {
-  const threshold = options.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
-  await syncIfNeeded(repoRoot);
-  const words = insight.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3).slice(0, 3);
-  if (words.length === 0) {
-    return { novel: true };
-  }
-  const searchQuery = words.join(" OR ");
-  const results = await searchKeyword(repoRoot, searchQuery, 10);
-  if (results.length === 0) {
+  const threshold = options.threshold ?? DUPLICATE_THRESHOLD;
+  if (!isModelAvailable()) {
     return { novel: true };
   }
-  return checkSimilarity(insight, results, threshold);
-}
-function checkSimilarity(insight, lessons, threshold) {
-  const insightWords = new Set(insight.toLowerCase().split(/\s+/));
-  for (const lesson of lessons) {
-    const lessonWords = new Set(lesson.insight.toLowerCase().split(/\s+/));
-    const intersection = [...insightWords].filter((w) => lessonWords.has(w)).length;
-    const union = (/* @__PURE__ */ new Set([...insightWords, ...lessonWords])).size;
-    const similarity = union > 0 ? intersection / union : 0;
-    if (similarity >= threshold) {
+  try {
+    await syncIfNeeded(repoRoot);
+    const similar = await findSimilarLessons(repoRoot, insight, { threshold });
+    const top = similar[0];
+    if (top) {
       return {
         novel: false,
-        reason: `Found similar existing lesson: "${lesson.insight.slice(0, 50)}..."`,
-        existingId: lesson.id
+        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 };
   }
-  return { novel: true };
 }
 var MIN_WORD_COUNT = 4;
 var VAGUE_PATTERNS = [
@@ -1675,6 +2305,9 @@ function detectTestFailure(testResult) {
     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
@@ -1699,6 +2332,7 @@ z.discriminatedUnion("type", [
 ]);
 
 // src/memory/retrieval/session.ts
+init_storage();
 var DEFAULT_LIMIT2 = 5;
 function hasSeverity(item) {
   return item.severity !== void 0;
@@ -1721,6 +2355,8 @@ async function loadSessionLessons(repoRoot, limit = DEFAULT_LIMIT2) {
 }
 
 // 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;
@@ -1752,95 +2388,21 @@ No relevant lessons found for this plan.`;
 ${lessonLines.join("\n")}`;
 }
 
-// src/memory/storage/sqlite-knowledge/index.ts
-init_connection();
-init_schema();
-
-// src/memory/storage/sqlite-knowledge/cache.ts
-init_connection();
-init_types();
-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;
-}
-
-// src/memory/storage/sqlite-knowledge/search.ts
-init_connection();
-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 [];
-  }
-}
-
-// src/memory/storage/sqlite-knowledge/index.ts
-init_sync();
-
 // src/index.ts
+init_sqlite_knowledge();
+
+// src/memory/knowledge/index.ts
 init_chunking();
+init_types3();
 init_indexing();
 
 // src/memory/knowledge/search.ts
-init_connection();
+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;
@@ -1912,14 +2474,27 @@ async function searchKnowledge(repoRoot, query, options) {
   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 = ["brainstorm", "plan", "work", "review", "compound"];
+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);
@@ -1937,16 +2512,23 @@ function isIsoDate(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;
-  return typeof state.lfg_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);
+  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 path2 = getStatePath(repoRoot);
-    if (!existsSync(path2)) return null;
-    const raw = readFileSync(path2, "utf-8");
+    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();
@@ -1961,13 +2543,41 @@ function getPhaseState(repoRoot) {
 }
 function cleanPhaseState(repoRoot) {
   try {
-    const path2 = getStatePath(repoRoot);
-    if (existsSync(path2)) unlinkSync(path2);
+    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();
+
+// src/commands/management-helpers.ts
+init_storage();
+init_embeddings();
+init_storage();
+init_storage();
+
+// src/commands/management-invalidation.ts
+init_storage();
+init_storage();
+init_storage();
 
 // src/commands/management-prime.ts
+init_storage();
 var TRUST_LANGUAGE_TEMPLATE = `# Compound Agent Active
 
 > **Context Recovery**: Run \`npx ca prime\` after compaction, clear, or new session
@@ -2035,15 +2645,15 @@ function formatLessonForPrime(lesson) {
   return `- **${lesson.insight}**${tags}
   Learned: ${date} via ${source}`;
 }
-function formatActiveLfgSection(repoRoot) {
+function formatActiveCookitSection(repoRoot) {
   const state = getPhaseState(repoRoot);
-  if (state === null || !state.lfg_active) return null;
+  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 LFG SESSION
+# ACTIVE COOK-IT SESSION
 
 Epic: ${state.epic_id}
 Phase: ${state.current_phase} (${state.phase_index}/5)
@@ -2075,14 +2685,15 @@ Critical lessons from past corrections:
 ${formattedLessons}
 `;
   }
-  const lfgSection = formatActiveLfgSection(root);
-  if (lfgSection !== null) {
-    output += lfgSection;
+  const cookitSection = formatActiveCookitSection(root);
+  if (cookitSection !== null) {
+    output += cookitSection;
   }
   return output;
 }
 
 // src/audit/checks/lessons.ts
+init_storage();
 async function checkLessons(repoRoot) {
   const { items } = await readMemoryItems(repoRoot);
   const findings = [];
@@ -2100,6 +2711,9 @@ async function checkLessons(repoRoot) {
   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"),
@@ -2373,11 +2987,24 @@ var AuditReportSchema = z.object({
   timestamp: z.string()
 });
 
-// src/memory/knowledge/index.ts
-init_chunking();
+// src/commands/knowledge.ts
+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_storage();
+init_search2();
+
+// src/index.ts
+init_compound();
 init_types();
-init_indexing();
 
-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, MODEL_FILENAME, MODEL_URI, MemoryItemRecordSchema, MemoryItemSchema, MemoryItemTypeSchema, PatternItemSchema, PreferenceItemSchema, SolutionItemSchema, VERSION, appendLesson, appendMemoryItem, buildSimilarityMatrix, calculateScore, chunkFile, closeDb, closeKnowledgeDb, clusterBySimilarity, collectCachedChunkEmbeddings, confirmationBoost, cosineSimilarity, detectSelfCorrection, detectTestFailure, detectUserCorrection, embedText, embedTexts, formatLessonsCheck, generateId, getCachedChunkEmbedding, getEmbedding, getPrimeContext, indexDocs, isActionable, isModelAvailable, isModelUsable, isNovel, isSpecific, loadSessionLessons, mergeHybridResults, normalizeBm25Rank, openKnowledgeDb, rankLessons, readCctPatterns, readLessons, readMemoryItems, rebuildIndex, recencyBoost, resolveModel, retrieveForPlan, runAudit, searchChunksKeywordScored, searchKeyword, searchKnowledge, searchKnowledgeVector, searchVector, setCachedChunkEmbedding, severityBoost, shouldPropose, synthesizePattern, unloadEmbedding, writeCctPatterns };
+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, MODEL_FILENAME, MODEL_URI, MemoryItemRecordSchema, MemoryItemSchema, MemoryItemTypeSchema, PatternItemSchema, PreferenceItemSchema, SolutionItemSchema, VERSION, acquireEmbedLock, appendLesson, appendMemoryItem, buildSimilarityMatrix, calculateScore, chunkFile, closeDb, closeKnowledgeDb, clusterBySimilarity, collectCachedChunkEmbeddings, confirmationBoost, cosineSimilarity, 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