compound-agent 1.3.3 → 1.4.0

package/dist/index.js

@@ -1,15 +1,501 @@
 import { createRequire } from 'module';
-import { mkdir, appendFile, readFile } from 'fs/promises';
-import { join, dirname, relative } from 'path';
+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 { existsSync, mkdirSync, unlinkSync, statSync, readFileSync, readdirSync } from 'fs';
 import { getLlama, resolveModelFile } from 'node-llama-cpp';
 import { homedir } from 'os';
 import { execSync } from 'child_process';
+import 'url';
 import 'chalk';
 
-// src/version.ts
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+function ensureSqliteAvailable() {
+  if (checked) return;
+  try {
+    const module = require2("better-sqlite3");
+    const Constructor = module.default || module;
+    const testDb = new Constructor(":memory:");
+    testDb.close();
+    DatabaseConstructor = Constructor;
+    checked = true;
+  } catch (cause) {
+    throw new Error(
+      'better-sqlite3 failed to load.\nRun: npx ca setup (auto-configures pnpm native builds)\nOr manually add to your package.json:\n  "pnpm": { "onlyBuiltDependencies": ["better-sqlite3", "node-llama-cpp"] }\nThen run: pnpm install && pnpm rebuild better-sqlite3\nFor npm/yarn, run: npm rebuild better-sqlite3',
+      { cause }
+    );
+  }
+}
+function getDatabaseConstructor() {
+  ensureSqliteAvailable();
+  return DatabaseConstructor;
+}
+var require2, checked, DatabaseConstructor;
+var init_availability = __esm({
+  "src/memory/storage/sqlite/availability.ts"() {
+    require2 = createRequire(import.meta.url);
+    checked = false;
+    DatabaseConstructor = null;
+  }
+});
+
+// src/memory/storage/sqlite-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_schema = __esm({
+  "src/memory/storage/sqlite-knowledge/schema.ts"() {
+    KNOWLEDGE_SCHEMA_VERSION = 2;
+    SCHEMA_SQL2 = `
+  CREATE TABLE IF NOT EXISTS chunks (
+    id TEXT PRIMARY KEY,
+    file_path TEXT NOT NULL,
+    start_line INTEGER NOT NULL,
+    end_line INTEGER NOT NULL,
+    content_hash TEXT NOT NULL,
+    text TEXT NOT NULL,
+    embedding BLOB,
+    model TEXT,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+    text,
+    content='chunks', content_rowid='rowid'
+  );
+
+  CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+    INSERT INTO chunks_fts(rowid, text)
+    VALUES (new.rowid, new.text);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+    INSERT INTO chunks_fts(chunks_fts, rowid, text)
+    VALUES ('delete', old.rowid, old.text);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
+    INSERT INTO chunks_fts(chunks_fts, rowid, text)
+    VALUES ('delete', old.rowid, old.text);
+    INSERT INTO chunks_fts(rowid, text)
+    VALUES (new.rowid, new.text);
+  END;
+
+  CREATE INDEX IF NOT EXISTS idx_chunks_file_path ON chunks(file_path);
+
+  CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+`;
+  }
+});
+function openKnowledgeDb(repoRoot, options = {}) {
+  const { inMemory = false } = options;
+  const key = inMemory ? `:memory:${repoRoot}` : join(repoRoot, KNOWLEDGE_DB_PATH);
+  const cached = knowledgeDbMap.get(key);
+  if (cached) {
+    return cached;
+  }
+  const Database = getDatabaseConstructor();
+  let database;
+  if (inMemory) {
+    database = new Database(":memory:");
+  } else {
+    const dir = dirname(key);
+    mkdirSync(dir, { recursive: true });
+    database = new Database(key);
+    const version = database.pragma("user_version", { simple: true });
+    if (version !== 0 && version !== KNOWLEDGE_SCHEMA_VERSION) {
+      database.close();
+      try {
+        unlinkSync(key);
+      } catch {
+      }
+      database = new Database(key);
+    }
+    database.pragma("journal_mode = WAL");
+  }
+  createKnowledgeSchema(database);
+  knowledgeDbMap.set(key, database);
+  return database;
+}
+function closeKnowledgeDb() {
+  for (const database of knowledgeDbMap.values()) {
+    database.close();
+  }
+  knowledgeDbMap.clear();
+}
+var KNOWLEDGE_DB_PATH, knowledgeDbMap;
+var init_connection = __esm({
+  "src/memory/storage/sqlite-knowledge/connection.ts"() {
+    init_availability();
+    init_schema();
+    KNOWLEDGE_DB_PATH = ".claude/.cache/knowledge.sqlite";
+    knowledgeDbMap = /* @__PURE__ */ new Map();
+  }
+});
+function generateChunkId(filePath, startLine, endLine) {
+  return createHash("sha256").update(`${filePath}:${startLine}:${endLine}`).digest("hex").slice(0, 16);
+}
+function chunkContentHash(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+var SUPPORTED_EXTENSIONS, CODE_EXTENSIONS;
+var init_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"
+    ]);
+  }
+});
+
+// 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);
+}
+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 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_sync = __esm({
+  "src/memory/storage/sqlite-knowledge/sync.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);
+  }
+  return splitParagraphs(fileLines);
+}
+function splitMarkdown(fileLines) {
+  const sections = [];
+  let current = [];
+  let inCodeBlock = false;
+  for (let i = 0; i < fileLines.length; i++) {
+    const line = fileLines[i];
+    const lineObj = { lineNumber: i + 1, text: line };
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      current.push(lineObj);
+      continue;
+    }
+    if (!inCodeBlock && /^#{2,}\s/.test(line) && current.length > 0) {
+      sections.push(current);
+      current = [lineObj];
+      continue;
+    }
+    if (!inCodeBlock && line.trim() === "" && current.length > 0 && current.some((l) => l.text.trim() !== "")) {
+      current.push(lineObj);
+      sections.push(current);
+      current = [];
+      continue;
+    }
+    current.push(lineObj);
+  }
+  if (current.length > 0) {
+    sections.push(current);
+  }
+  return sections;
+}
+function splitCode(fileLines) {
+  const sections = [];
+  let current = [];
+  for (let i = 0; i < fileLines.length; i++) {
+    const line = fileLines[i];
+    const lineObj = { lineNumber: i + 1, text: line };
+    if (line.trim() === "" && current.length > 0) {
+      let hasNextNonBlank = false;
+      for (let j = i + 1; j < fileLines.length; j++) {
+        if (fileLines[j].trim() !== "") {
+          hasNextNonBlank = true;
+          break;
+        }
+      }
+      if (hasNextNonBlank) {
+        sections.push(current);
+        current = [lineObj];
+        continue;
+      }
+    }
+    current.push(lineObj);
+  }
+  if (current.length > 0) {
+    sections.push(current);
+  }
+  return sections;
+}
+function splitParagraphs(fileLines) {
+  const sections = [];
+  let current = [];
+  for (let i = 0; i < fileLines.length; i++) {
+    const line = fileLines[i];
+    const lineObj = { lineNumber: i + 1, text: line };
+    if (line.trim() === "" && current.length > 0) {
+      sections.push(current);
+      current = [lineObj];
+      continue;
+    }
+    current.push(lineObj);
+  }
+  if (current.length > 0) {
+    sections.push(current);
+  }
+  return sections;
+}
+function sectionText(section) {
+  return section.map((l) => l.text).join("\n");
+}
+function chunkFile(filePath, content, options) {
+  if (content.trim() === "") return [];
+  if (isBinary(content)) return [];
+  const targetSize = options?.targetSize ?? DEFAULT_TARGET_SIZE;
+  const overlapSize = options?.overlapSize ?? DEFAULT_OVERLAP_SIZE;
+  const fileLines = content.split("\n");
+  const ext = extname(filePath).toLowerCase();
+  const sections = splitIntoSections(fileLines, ext);
+  const chunks = [];
+  let accumulated = [];
+  let accumulatedLength = 0;
+  function emitChunk(lines, overlapLines2) {
+    if (lines.length === 0) return [];
+    const allLines = [...overlapLines2, ...lines];
+    const text = allLines.map((l) => l.text).join("\n");
+    const startLine = allLines[0].lineNumber;
+    const endLine = allLines[allLines.length - 1].lineNumber;
+    chunks.push({
+      id: generateChunkId(filePath, startLine, endLine),
+      filePath,
+      startLine,
+      endLine,
+      text,
+      contentHash: chunkContentHash(text)
+    });
+    if (overlapSize <= 0) return [];
+    const overlapResult = [];
+    let overlapLen = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const lineLen = lines[i].text.length + 1;
+      if (overlapLen + lineLen > overlapSize && overlapResult.length > 0) break;
+      overlapResult.unshift(lines[i]);
+      overlapLen += lineLen;
+    }
+    return overlapResult;
+  }
+  let overlapLines = [];
+  for (const section of sections) {
+    const sectionLen = sectionText(section).length;
+    if (accumulatedLength > 0 && accumulatedLength + sectionLen > targetSize) {
+      overlapLines = emitChunk(accumulated, overlapLines);
+      accumulated = [];
+      accumulatedLength = 0;
+    }
+    accumulated.push(...section);
+    accumulatedLength += sectionLen;
+    if (accumulatedLength > targetSize) {
+      overlapLines = emitChunk(accumulated, overlapLines);
+      accumulated = [];
+      accumulatedLength = 0;
+    }
+  }
+  if (accumulated.length > 0) {
+    emitChunk(accumulated, overlapLines);
+  }
+  return chunks;
+}
+var DEFAULT_TARGET_SIZE, DEFAULT_OVERLAP_SIZE;
+var init_chunking = __esm({
+  "src/memory/knowledge/chunking.ts"() {
+    init_types();
+    DEFAULT_TARGET_SIZE = 1600;
+    DEFAULT_OVERLAP_SIZE = 320;
+  }
+});
+function fileHash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function fileHashKey(relativePath) {
+  return "file_hash:" + relativePath;
+}
+function getStoredFileHash(repoRoot, relativePath) {
+  const db = openKnowledgeDb(repoRoot);
+  const row = db.prepare("SELECT value FROM metadata WHERE key = ?").get(fileHashKey(relativePath));
+  return row?.value ?? null;
+}
+function setFileHash(repoRoot, relativePath, hash) {
+  const db = openKnowledgeDb(repoRoot);
+  db.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)").run(fileHashKey(relativePath), hash);
+}
+function removeFileHash(repoRoot, relativePath) {
+  const db = openKnowledgeDb(repoRoot);
+  db.prepare("DELETE FROM metadata WHERE key = ?").run(fileHashKey(relativePath));
+}
+async function walkSupportedFiles(baseDir, repoRoot) {
+  const results = [];
+  let entries;
+  try {
+    entries = await readdir(baseDir, { recursive: true, withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const ext = extname(entry.name).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+    const fullPath = join(entry.parentPath ?? entry.path, entry.name);
+    const relPath = relative(repoRoot, fullPath);
+    results.push(relPath);
+  }
+  return results;
+}
+async function 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
+  };
+  const docsPath = join(repoRoot, docsDir);
+  const filePaths = await walkSupportedFiles(docsPath, repoRoot);
+  for (const relPath of filePaths) {
+    const fullPath = join(repoRoot, relPath);
+    let content;
+    try {
+      content = await readFile(fullPath, "utf-8");
+    } catch {
+      stats.filesErrored++;
+      continue;
+    }
+    const hash = fileHash(content);
+    const storedHash = getStoredFileHash(repoRoot, relPath);
+    if (!force && storedHash === hash) {
+      stats.filesSkipped++;
+      continue;
+    }
+    const chunks = chunkFile(relPath, content);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const knowledgeChunks = chunks.map((chunk) => ({
+      id: chunk.id,
+      filePath: chunk.filePath,
+      startLine: chunk.startLine,
+      endLine: chunk.endLine,
+      contentHash: chunk.contentHash,
+      text: chunk.text,
+      updatedAt: now
+    }));
+    const db = openKnowledgeDb(repoRoot);
+    db.transaction(() => {
+      deleteChunksByFilePath(repoRoot, [relPath]);
+      if (knowledgeChunks.length > 0) {
+        upsertChunks(repoRoot, knowledgeChunks);
+      }
+      setFileHash(repoRoot, relPath, hash);
+    })();
+    stats.filesIndexed++;
+    stats.chunksCreated += knowledgeChunks.length;
+  }
+  const indexedPaths = getIndexedFilePaths(repoRoot);
+  const currentPathSet = new Set(filePaths);
+  const stalePaths = indexedPaths.filter((p) => !currentPathSet.has(p));
+  if (stalePaths.length > 0) {
+    for (const path2 of stalePaths) {
+      stats.chunksDeleted += getChunkCountByFilePath(repoRoot, path2);
+    }
+    deleteChunksByFilePath(repoRoot, stalePaths);
+    for (const path2 of stalePaths) {
+      removeFileHash(repoRoot, path2);
+    }
+  }
+  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();
+  }
+});
 var _require = createRequire(import.meta.url);
 var _pkg = _require("../package.json");
 var VERSION = _pkg.version;
@@ -224,29 +710,9 @@ async function readLessons(repoRoot, options = {}) {
   const lessons = result.items.filter((item) => item.type === "lesson");
   return { lessons, skippedCount: result.skippedCount };
 }
-var require2 = createRequire(import.meta.url);
-var checked = false;
-var DatabaseConstructor = null;
-function ensureSqliteAvailable() {
-  if (checked) return;
-  try {
-    const module = require2("better-sqlite3");
-    const Constructor = module.default || module;
-    const testDb = new Constructor(":memory:");
-    testDb.close();
-    DatabaseConstructor = Constructor;
-    checked = true;
-  } catch (cause) {
-    throw new Error(
-      'better-sqlite3 failed to load.\nRun: npx ca setup (auto-configures pnpm native builds)\nOr manually add to your package.json:\n  "pnpm": { "onlyBuiltDependencies": ["better-sqlite3", "node-llama-cpp"] }\nThen run: pnpm install && pnpm rebuild better-sqlite3\nFor npm/yarn, run: npm rebuild better-sqlite3',
-      { cause }
-    );
-  }
-}
-function getDatabaseConstructor() {
-  ensureSqliteAvailable();
-  return DatabaseConstructor;
-}
+
+// src/memory/storage/sqlite/connection.ts
+init_availability();
 
 // src/memory/storage/sqlite/schema.ts
 var SCHEMA_VERSION = 3;
@@ -342,7 +808,10 @@ function openDb(repoRoot, options = {}) {
     database = new Database(key);
     if (!hasExpectedVersion(database)) {
       database.close();
-      unlinkSync(key);
+      try {
+        unlinkSync(key);
+      } catch {
+      }
       database = new Database(key);
     }
     database.pragma("journal_mode = WAL");
@@ -483,7 +952,65 @@ async function syncIfNeeded(repoRoot, options = {}) {
   return false;
 }
 
+// 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 mergeHybridScores(vectorResults, keywordResults, getId, options) {
+  if (vectorResults.length === 0 && keywordResults.length === 0) return [];
+  const rawVecW = options?.vectorWeight ?? DEFAULT_VECTOR_WEIGHT;
+  const rawTxtW = options?.textWeight ?? DEFAULT_TEXT_WEIGHT;
+  const total = rawVecW + rawTxtW;
+  if (total <= 0) return [];
+  const vecW = rawVecW / total;
+  const txtW = rawTxtW / total;
+  const limit = options?.limit;
+  const minScore = options?.minScore;
+  const merged = /* @__PURE__ */ new Map();
+  for (const v of vectorResults) {
+    merged.set(getId(v.item), { item: v.item, vecScore: v.score, txtScore: 0 });
+  }
+  for (const k of keywordResults) {
+    const id = getId(k.item);
+    const existing = merged.get(id);
+    if (existing) {
+      existing.txtScore = k.score;
+    } else {
+      merged.set(id, { item: k.item, vecScore: 0, txtScore: k.score });
+    }
+  }
+  const results = [];
+  for (const entry of merged.values()) {
+    results.push({
+      item: entry.item,
+      score: vecW * entry.vecScore + txtW * entry.txtScore
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  const filtered = minScore !== void 0 ? results.filter((r) => r.score >= minScore) : results;
+  return limit !== void 0 ? filtered.slice(0, limit) : filtered;
+}
+function mergeHybridResults(vectorResults, keywordResults, options) {
+  const genericVec = vectorResults.map((v) => ({ item: v.lesson, score: v.score }));
+  const genericKw = keywordResults.map((k) => ({ item: k.lesson, score: k.score }));
+  const merged = mergeHybridScores(genericVec, genericKw, (item) => item.id, options);
+  return merged.map((m) => ({ lesson: m.item, score: m.score }));
+}
+
 // src/memory/storage/sqlite/search.ts
+function safeJsonParse(value, fallback) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
 function rowToMemoryItem(row) {
   const item = {
     id: row.id,
@@ -492,9 +1019,9 @@ function rowToMemoryItem(row) {
     insight: row.insight,
     tags: row.tags ? row.tags.split(",").filter(Boolean) : [],
     source: row.source,
-    context: JSON.parse(row.context),
-    supersedes: JSON.parse(row.supersedes),
-    related: JSON.parse(row.related),
+    context: safeJsonParse(row.context, {}),
+    supersedes: safeJsonParse(row.supersedes, []),
+    related: safeJsonParse(row.related, []),
     created: row.created,
     confirmed: row.confirmed === 1
   };
@@ -525,7 +1052,7 @@ function rowToMemoryItem(row) {
 }
 var FTS_OPERATORS = /* @__PURE__ */ new Set(["AND", "OR", "NOT", "NEAR"]);
 function sanitizeFtsQuery(query) {
-  const stripped = query.replace(/["*^+-]/g, "");
+  const stripped = query.replace(/["*^+\-():{}]/g, "");
   const tokens = stripped.split(/\s+/).filter((t) => t.length > 0 && !FTS_OPERATORS.has(t));
   return tokens.join(" ");
 }
@@ -546,44 +1073,47 @@ function incrementRetrievalCount(repoRoot, lessonIds) {
   });
   updateMany(lessonIds);
 }
-async function searchKeyword(repoRoot, query, limit, typeFilter) {
+function executeFtsQuery(repoRoot, query, limit, options) {
   const database = openDb(repoRoot);
-  const countResult = database.prepare("SELECT COUNT(*) as cnt FROM lessons").get();
-  if (countResult.cnt === 0) return [];
   const sanitized = sanitizeFtsQuery(query);
   if (sanitized === "") return [];
+  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 {
-    if (typeFilter) {
-      const rows2 = database.prepare(
-        `
-          SELECT l.*
-          FROM lessons l
-          JOIN lessons_fts fts ON l.rowid = fts.rowid
-          WHERE lessons_fts MATCH ?
-            AND l.invalidated_at IS NULL
-            AND l.type = ?
-          LIMIT ?
-        `
-      ).all(sanitized, typeFilter, limit);
-      return rows2.map(rowToMemoryItem).filter((x) => x !== null);
-    }
-    const rows = database.prepare(
-      `
-        SELECT l.*
-        FROM lessons l
-        JOIN lessons_fts fts ON l.rowid = fts.rowid
-        WHERE lessons_fts MATCH ?
-          AND l.invalidated_at IS NULL
-        LIMIT ?
-      `
-    ).all(sanitized, limit);
-    return rows.map(rowToMemoryItem).filter((x) => x !== null);
+    return database.prepare(sql).all(...params);
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown FTS5 error";
     console.error(`[compound-agent] search error: ${message}`);
     return [];
   }
 }
+async function searchKeyword(repoRoot, query, limit, typeFilter) {
+  const rows = executeFtsQuery(repoRoot, query, limit, { includeRank: false, typeFilter });
+  return rows.map(rowToMemoryItem).filter((x) => x !== null);
+}
+async function searchKeywordScored(repoRoot, query, limit, typeFilter) {
+  const rows = executeFtsQuery(repoRoot, query, limit, { includeRank: true, typeFilter });
+  const results = [];
+  for (const row of rows) {
+    const lesson = rowToMemoryItem(row);
+    if (lesson) {
+      results.push({ lesson, score: normalizeBm25Rank(row.rank) });
+    }
+  }
+  return results;
+}
 
 // src/utils.ts
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
@@ -1161,8 +1691,13 @@ async function loadSessionLessons(repoRoot, limit = DEFAULT_LIMIT2) {
 // src/memory/retrieval/plan.ts
 var DEFAULT_LIMIT3 = 5;
 async function retrieveForPlan(repoRoot, planText, limit = DEFAULT_LIMIT3) {
-  const scored = await searchVector(repoRoot, planText, { limit: limit * 2 });
-  const ranked = rankLessons(scored);
+  const candidateLimit = limit * CANDIDATE_MULTIPLIER;
+  const [vectorResults, keywordResults] = await Promise.all([
+    searchVector(repoRoot, planText, { limit: candidateLimit }),
+    searchKeywordScored(repoRoot, planText, candidateLimit)
+  ]);
+  const merged = mergeHybridResults(vectorResults, keywordResults, { minScore: MIN_HYBRID_SCORE });
+  const ranked = rankLessons(merged);
   const topLessons = ranked.slice(0, limit);
   if (topLessons.length > 0) {
     incrementRetrievalCount(repoRoot, topLessons.map((item) => item.lesson.id));
@@ -1185,12 +1720,173 @@ 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_chunking();
+init_indexing();
+
+// src/memory/knowledge/search.ts
+init_connection();
+var DEFAULT_KNOWLEDGE_LIMIT = 6;
+async function searchKnowledgeVector(repoRoot, query, options) {
+  const limit = options?.limit ?? DEFAULT_KNOWLEDGE_LIMIT;
+  const database = openKnowledgeDb(repoRoot);
+  const embRows = database.prepare("SELECT id, embedding FROM chunks WHERE embedding IS NOT NULL").all();
+  if (embRows.length === 0) return [];
+  const queryVector = await embedText(query);
+  const scored = [];
+  for (const row of embRows) {
+    const embFloat = new Float32Array(
+      row.embedding.buffer,
+      row.embedding.byteOffset,
+      row.embedding.byteLength / 4
+    );
+    scored.push({ id: row.id, score: cosineSimilarity(queryVector, embFloat) });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const topK = scored.slice(0, limit);
+  if (topK.length === 0) return [];
+  const placeholders = topK.map(() => "?").join(",");
+  const sql = `SELECT id, file_path, start_line, end_line, content_hash, text, model, updated_at FROM chunks WHERE id IN (${placeholders})`;
+  const dataRows = database.prepare(sql).all(...topK.map((r) => r.id));
+  const dataMap = new Map(dataRows.map((r) => [r.id, r]));
+  const results = [];
+  for (const { id, score } of topK) {
+    const row = dataMap.get(id);
+    if (!row) continue;
+    const chunk = {
+      id: row.id,
+      filePath: row.file_path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      contentHash: row.content_hash,
+      text: row.text,
+      updatedAt: row.updated_at
+    };
+    if (row.model !== null) {
+      chunk.model = row.model;
+    }
+    results.push({ item: chunk, score });
+  }
+  return results;
+}
+async function searchKnowledge(repoRoot, query, options) {
+  const limit = options?.limit ?? DEFAULT_KNOWLEDGE_LIMIT;
+  const candidateLimit = limit * CANDIDATE_MULTIPLIER;
+  const usability = await isModelUsable();
+  if (usability.usable) {
+    const [vectorResults, keywordResults2] = await Promise.all([
+      searchKnowledgeVector(repoRoot, query, { limit: candidateLimit }),
+      Promise.resolve(searchChunksKeywordScored(repoRoot, query, candidateLimit))
+    ]);
+    if (vectorResults.length === 0) {
+      return keywordResults2.map((k) => ({ item: k.chunk, score: k.score })).slice(0, limit);
+    }
+    const genericKw = keywordResults2.map((k) => ({
+      item: k.chunk,
+      score: k.score
+    }));
+    const merged = mergeHybridScores(
+      vectorResults,
+      genericKw,
+      (item) => item.id,
+      { limit, minScore: MIN_HYBRID_SCORE }
+    );
+    return merged;
+  }
+  const keywordResults = searchChunksKeywordScored(repoRoot, query, limit);
+  return keywordResults.map((k) => ({ item: k.chunk, score: k.score }));
+}
+
 // src/cli-utils.ts
 function getRepoRoot() {
-  return process.env["COMPOUND_AGENT_ROOT"] ?? process.cwd();
+  return process.env["COMPOUND_AGENT_ROOT"] || process.cwd();
 }
 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 GATES = ["post-plan", "gate-3", "gate-4", "final"];
 function getStatePath(repoRoot) {
@@ -1220,11 +1916,24 @@ function getPhaseState(repoRoot) {
     if (!existsSync(path2)) return null;
     const raw = readFileSync(path2, "utf-8");
     const parsed = JSON.parse(raw);
-    return validatePhaseState(parsed) ? parsed : null;
+    if (!validatePhaseState(parsed)) return null;
+    const age = Date.now() - new Date(parsed.started_at).getTime();
+    if (age > PHASE_STATE_MAX_AGE_MS) {
+      cleanPhaseState(repoRoot);
+      return null;
+    }
+    return parsed;
   } catch {
     return null;
   }
 }
+function cleanPhaseState(repoRoot) {
+  try {
+    const path2 = getStatePath(repoRoot);
+    if (existsSync(path2)) unlinkSync(path2);
+  } catch {
+  }
+}
 
 // src/commands/management-prime.ts
 var TRUST_LANGUAGE_TEMPLATE = `# Compound Agent Active
@@ -1238,6 +1947,7 @@ var TRUST_LANGUAGE_TEMPLATE = `# Compound Agent Active
 | Command | Purpose |
 |---------|---------|
 | \`npx ca search "query"\` | Search lessons - call BEFORE architectural decisions |
+| \`npx ca knowledge "query"\` | Search docs knowledge - use for architecture context |
 | \`npx ca learn "insight"\` | Capture lessons - call AFTER corrections or discoveries |
 
 ## Core Constraints
@@ -1250,7 +1960,7 @@ var TRUST_LANGUAGE_TEMPLATE = `# Compound Agent Active
 
 ## Retrieval Protocol
 
-You MUST call \`npx ca search\` BEFORE:
+You MUST call \`npx ca search\` and \`npx ca knowledge\` BEFORE:
 - Architectural decisions or complex planning
 - Implementing patterns you've done before in this repo
 
@@ -1629,6 +2339,11 @@ var AuditReportSchema = z.object({
   timestamp: z.string()
 });
 
-export { AuditFindingSchema, AuditReportSchema, CCT_PATTERNS_PATH, CctPatternSchema, DB_PATH, LESSONS_PATH, LessonItemSchema, LessonSchema, MODEL_FILENAME, MODEL_URI, MemoryItemRecordSchema, MemoryItemSchema, MemoryItemTypeSchema, PatternItemSchema, PreferenceItemSchema, SolutionItemSchema, VERSION, appendLesson, appendMemoryItem, buildSimilarityMatrix, calculateScore, closeDb, clusterBySimilarity, confirmationBoost, cosineSimilarity, detectSelfCorrection, detectTestFailure, detectUserCorrection, embedText, embedTexts, formatLessonsCheck, generateId, getEmbedding, getPrimeContext, isActionable, isModelAvailable, isModelUsable, isNovel, isSpecific, loadSessionLessons, rankLessons, readCctPatterns, readLessons, readMemoryItems, rebuildIndex, recencyBoost, resolveModel, retrieveForPlan, runAudit, searchKeyword, searchVector, severityBoost, shouldPropose, synthesizePattern, unloadEmbedding, writeCctPatterns };
+// src/memory/knowledge/index.ts
+init_chunking();
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map