minimem 0.0.3 → 0.0.4

package/dist/index.js

@@ -1,187 +1,33 @@
+import {
+  buildFileEntry,
+  chunkMarkdown,
+  cosineSimilarity,
+  ensureDir,
+  extractChunkMetadata,
+  hashText,
+  isMemoryPath,
+  listMemoryFiles,
+  logError,
+  parseEmbedding,
+  stripPrivateContent,
+  truncateUtf16Safe,
+  vectorToBlob
+} from "./chunk-ARZQHOJI.js";
+import {
+  addFrontmatter,
+  addSessionToContent,
+  extractSession,
+  parseFrontmatter,
+  serializeFrontmatter
+} from "./chunk-GVWPZRF7.js";
+
 // src/minimem.ts
 import { randomUUID } from "crypto";
-import fs2 from "fs/promises";
-import path3 from "path";
+import fs from "fs/promises";
+import path2 from "path";
 import { DatabaseSync } from "sqlite";
 import chokidar from "chokidar";
 
-// src/internal.ts
-import crypto from "crypto";
-import fsSync from "fs";
-import fs from "fs/promises";
-import path from "path";
-function ensureDir(dir) {
-  try {
-    fsSync.mkdirSync(dir, { recursive: true });
-  } catch {
-  }
-  return dir;
-}
-function normalizeRelPath(value) {
-  const trimmed = value.trim().replace(/^[./]+/, "");
-  return trimmed.replace(/\\/g, "/");
-}
-function isMemoryPath(relPath) {
-  const normalized = normalizeRelPath(relPath);
-  if (!normalized) return false;
-  if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
-  return normalized.startsWith("memory/");
-}
-async function exists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function walkDir(dir, files) {
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      await walkDir(full, files);
-      continue;
-    }
-    if (!entry.isFile()) continue;
-    if (!entry.name.endsWith(".md")) continue;
-    files.push(full);
-  }
-}
-async function listMemoryFiles(memoryDir) {
-  const result = [];
-  const memoryFile = path.join(memoryDir, "MEMORY.md");
-  const altMemoryFile = path.join(memoryDir, "memory.md");
-  if (await exists(memoryFile)) result.push(memoryFile);
-  if (await exists(altMemoryFile)) result.push(altMemoryFile);
-  const memorySubDir = path.join(memoryDir, "memory");
-  if (await exists(memorySubDir)) {
-    await walkDir(memorySubDir, result);
-  }
-  if (result.length <= 1) return result;
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const entry of result) {
-    let key = entry;
-    try {
-      key = await fs.realpath(entry);
-    } catch {
-    }
-    if (seen.has(key)) continue;
-    seen.add(key);
-    deduped.push(entry);
-  }
-  return deduped;
-}
-function hashText(value) {
-  return crypto.createHash("sha256").update(value).digest("hex");
-}
-async function buildFileEntry(absPath, memoryDir) {
-  const stat = await fs.stat(absPath);
-  const content = await fs.readFile(absPath, "utf-8");
-  const hash = hashText(content);
-  return {
-    path: path.relative(memoryDir, absPath).replace(/\\/g, "/"),
-    absPath,
-    mtimeMs: stat.mtimeMs,
-    size: stat.size,
-    hash
-  };
-}
-function chunkMarkdown(content, chunking) {
-  const lines = content.split("\n");
-  if (lines.length === 0) return [];
-  const maxChars = Math.max(32, chunking.tokens * 4);
-  const overlapChars = Math.max(0, chunking.overlap * 4);
-  const chunks = [];
-  let current = [];
-  let currentChars = 0;
-  const flush = () => {
-    if (current.length === 0) return;
-    const firstEntry = current[0];
-    const lastEntry = current[current.length - 1];
-    if (!firstEntry || !lastEntry) return;
-    const text = current.map((entry) => entry.line).join("\n");
-    const startLine = firstEntry.lineNo;
-    const endLine = lastEntry.lineNo;
-    chunks.push({
-      startLine,
-      endLine,
-      text,
-      hash: hashText(text)
-    });
-  };
-  const carryOverlap = () => {
-    if (overlapChars <= 0 || current.length === 0) {
-      current = [];
-      currentChars = 0;
-      return;
-    }
-    let acc = 0;
-    const kept = [];
-    for (let i = current.length - 1; i >= 0; i -= 1) {
-      const entry = current[i];
-      if (!entry) continue;
-      acc += entry.line.length + 1;
-      kept.unshift(entry);
-      if (acc >= overlapChars) break;
-    }
-    current = kept;
-    currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
-  };
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i] ?? "";
-    const lineNo = i + 1;
-    const segments = [];
-    if (line.length === 0) {
-      segments.push("");
-    } else {
-      for (let start = 0; start < line.length; start += maxChars) {
-        segments.push(line.slice(start, start + maxChars));
-      }
-    }
-    for (const segment of segments) {
-      const lineSize = segment.length + 1;
-      if (currentChars + lineSize > maxChars && current.length > 0) {
-        flush();
-        carryOverlap();
-      }
-      current.push({ line: segment, lineNo });
-      currentChars += lineSize;
-    }
-  }
-  flush();
-  return chunks;
-}
-function parseEmbedding(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-function cosineSimilarity(a, b) {
-  if (a.length === 0 || b.length === 0) return 0;
-  const len = Math.min(a.length, b.length);
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < len; i += 1) {
-    const av = a[i] ?? 0;
-    const bv = b[i] ?? 0;
-    dot += av * bv;
-    normA += av * av;
-    normB += bv * bv;
-  }
-  if (normA === 0 || normB === 0) return 0;
-  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
-}
-function truncateUtf16Safe(text, maxChars) {
-  if (text.length <= maxChars) return text;
-  return text.slice(0, maxChars);
-}
-
 // src/search/hybrid.ts
 function buildFtsQuery(raw) {
   const tokens = raw.match(/[A-Za-z0-9_]+/g)?.map((t) => t.trim()).filter(Boolean) ?? [];
@@ -190,8 +36,11 @@ function buildFtsQuery(raw) {
   return quoted.join(" AND ");
 }
 function bm25RankToScore(rank) {
-  const normalized = Number.isFinite(rank) ? Math.max(0, rank) : 999;
-  return 1 / (1 + normalized);
+  if (!Number.isFinite(rank)) {
+    return 0;
+  }
+  const absRank = Math.abs(rank);
+  return 1 / (1 + absRank);
 }
 function mergeHybridResults(params) {
   const byId = /* @__PURE__ */ new Map();
@@ -225,8 +74,17 @@ function mergeHybridResults(params) {
       });
     }
   }
+  let vw = params.vectorWeight;
+  let tw = params.textWeight;
+  if (params.vector.length === 0 && params.keyword.length > 0) {
+    vw = 0;
+    tw = 1;
+  } else if (params.keyword.length === 0 && params.vector.length > 0) {
+    vw = 1;
+    tw = 0;
+  }
   const merged = Array.from(byId.values()).map((entry) => {
-    const score = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+    const score = vw * entry.vectorScore + tw * entry.textScore;
     return {
       path: entry.path,
       startLine: entry.startLine,
@@ -240,7 +98,33 @@ function mergeHybridResults(params) {
 }
 
 // src/search/search.ts
-var vectorToBlob = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
+function buildKnowledgeFilterSql(opts) {
+  const clauses = [];
+  const params = [];
+  if (opts.knowledgeType) {
+    clauses.push(` AND c.knowledge_type = ?`);
+    params.push(opts.knowledgeType);
+  }
+  if (opts.minConfidence !== void 0) {
+    clauses.push(` AND c.confidence >= ?`);
+    params.push(opts.minConfidence);
+  }
+  if (opts.domain && opts.domain.length > 0) {
+    const domainPlaceholders = opts.domain.map(() => "?").join(", ");
+    clauses.push(
+      ` AND EXISTS (SELECT 1 FROM json_each(c.domains) AS d WHERE d.value IN (${domainPlaceholders}))`
+    );
+    params.push(...opts.domain);
+  }
+  if (opts.entities && opts.entities.length > 0) {
+    const entityPlaceholders = opts.entities.map(() => "?").join(", ");
+    clauses.push(
+      ` AND EXISTS (SELECT 1 FROM json_each(c.entities) AS e WHERE e.value IN (${entityPlaceholders}))`
+    );
+    params.push(...opts.entities);
+  }
+  return { sql: clauses.join(""), params };
+}
 async function searchVector(params) {
   if (params.queryVec.length === 0 || params.limit <= 0) return [];
   if (await params.ensureVectorReady(params.queryVec.length)) {
@@ -332,6 +216,7 @@ async function searchKeyword(params) {
 }
 
 // src/db/schema.ts
+var SCHEMA_VERSION = 4;
 function ensureMemoryIndexSchema(params) {
   params.db.exec(`
     CREATE TABLE IF NOT EXISTS meta (
@@ -339,6 +224,7 @@ function ensureMemoryIndexSchema(params) {
       value TEXT NOT NULL
     );
   `);
+  const migrated = migrateIfNeeded(params.db, params.ftsTable);
   params.db.exec(`
     CREATE TABLE IF NOT EXISTS files (
       path TEXT PRIMARY KEY,
@@ -401,9 +287,61 @@ function ensureMemoryIndexSchema(params) {
   }
   ensureColumn(params.db, "files", "source", "TEXT NOT NULL DEFAULT 'memory'");
   ensureColumn(params.db, "chunks", "source", "TEXT NOT NULL DEFAULT 'memory'");
+  ensureColumn(params.db, "chunks", "type", "TEXT");
+  ensureColumn(params.db, "chunks", "knowledge_type", "TEXT");
+  ensureColumn(params.db, "chunks", "knowledge_id", "TEXT");
+  ensureColumn(params.db, "chunks", "domains", "TEXT");
+  ensureColumn(params.db, "chunks", "entities", "TEXT");
+  ensureColumn(params.db, "chunks", "confidence", "REAL");
   params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);`);
   params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source);`);
-  return { ftsAvailable, ...ftsError ? { ftsError } : {} };
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_type ON chunks(type);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_knowledge_type ON chunks(knowledge_type);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_knowledge_id ON chunks(knowledge_id);`);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_links (
+      from_id TEXT NOT NULL,
+      to_id TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      layer TEXT,
+      weight REAL DEFAULT 0.5,
+      source_path TEXT,
+      created_at INTEGER,
+      PRIMARY KEY (from_id, to_id, relation)
+    );
+  `);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_from ON knowledge_links(from_id);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_to ON knowledge_links(to_id);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_layer ON knowledge_links(layer);`);
+  params.db.prepare(
+    `INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)`
+  ).run(String(SCHEMA_VERSION));
+  return { ftsAvailable, ...ftsError ? { ftsError } : {}, ...migrated ? { migrated } : {} };
+}
+function migrateIfNeeded(db, ftsTable) {
+  let storedVersion = 0;
+  try {
+    const row = db.prepare(
+      `SELECT value FROM meta WHERE key = 'schema_version'`
+    ).get();
+    if (row) {
+      storedVersion = parseInt(row.value, 10) || 0;
+    }
+  } catch {
+    storedVersion = 0;
+  }
+  if (storedVersion >= SCHEMA_VERSION) return false;
+  if (storedVersion > 0 && storedVersion < SCHEMA_VERSION) {
+    db.exec(`DROP TABLE IF EXISTS files`);
+    db.exec(`DROP TABLE IF EXISTS chunks`);
+    db.exec(`DROP TABLE IF EXISTS knowledge_links`);
+    db.exec(`DROP TABLE IF EXISTS ${ftsTable}`);
+    try {
+      db.exec(`DROP TABLE IF EXISTS chunks_vec`);
+    } catch {
+    }
+  }
+  return storedVersion > 0;
 }
 function ensureColumn(db, table, column, definition) {
   const rows = db.prepare(`PRAGMA table_info(${table})`).all();
@@ -411,6 +349,122 @@ function ensureColumn(db, table, column, definition) {
   db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
 }
 
+// src/search/graph.ts
+function getLinksFrom(db, fromId, opts) {
+  let sql = `SELECT from_id, to_id, relation, layer, weight, source_path FROM knowledge_links WHERE from_id = ?`;
+  const params = [fromId];
+  if (opts?.relation) {
+    sql += ` AND relation = ?`;
+    params.push(opts.relation);
+  }
+  if (opts?.layer) {
+    sql += ` AND layer = ?`;
+    params.push(opts.layer);
+  }
+  const rows = db.prepare(sql).all(...params);
+  return rows.map(toGraphLink);
+}
+function getLinksTo(db, toId, opts) {
+  let sql = `SELECT from_id, to_id, relation, layer, weight, source_path FROM knowledge_links WHERE to_id = ?`;
+  const params = [toId];
+  if (opts?.relation) {
+    sql += ` AND relation = ?`;
+    params.push(opts.relation);
+  }
+  if (opts?.layer) {
+    sql += ` AND layer = ?`;
+    params.push(opts.layer);
+  }
+  const rows = db.prepare(sql).all(...params);
+  return rows.map(toGraphLink);
+}
+function getNeighbors(db, startId, depth = 1, opts) {
+  const visited = /* @__PURE__ */ new Set([startId]);
+  const result = [];
+  let frontier = [startId];
+  for (let d = 1; d <= depth; d++) {
+    const nextFrontier = [];
+    for (const nodeId of frontier) {
+      const outgoing = getLinksFrom(db, nodeId, opts);
+      for (const link of outgoing) {
+        if (!visited.has(link.toId)) {
+          visited.add(link.toId);
+          nextFrontier.push(link.toId);
+          result.push({ id: link.toId, depth: d, link });
+        }
+      }
+      const incoming = getLinksTo(db, nodeId, opts);
+      for (const link of incoming) {
+        if (!visited.has(link.fromId)) {
+          visited.add(link.fromId);
+          nextFrontier.push(link.fromId);
+          result.push({ id: link.fromId, depth: d, link });
+        }
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+  return result;
+}
+function getPathBetween(db, fromId, toId, maxDepth = 3) {
+  if (fromId === toId) return [];
+  const visited = /* @__PURE__ */ new Set([fromId]);
+  const parentLink = /* @__PURE__ */ new Map();
+  let frontier = [fromId];
+  for (let d = 0; d < maxDepth; d++) {
+    const nextFrontier = [];
+    for (const nodeId of frontier) {
+      const outgoing = getLinksFrom(db, nodeId);
+      for (const link of outgoing) {
+        if (!visited.has(link.toId)) {
+          visited.add(link.toId);
+          parentLink.set(link.toId, link);
+          if (link.toId === toId) {
+            return reconstructPath(parentLink, fromId, toId);
+          }
+          nextFrontier.push(link.toId);
+        }
+      }
+      const incoming = getLinksTo(db, nodeId);
+      for (const link of incoming) {
+        if (!visited.has(link.fromId)) {
+          visited.add(link.fromId);
+          parentLink.set(link.fromId, link);
+          if (link.fromId === toId) {
+            return reconstructPath(parentLink, fromId, toId);
+          }
+          nextFrontier.push(link.fromId);
+        }
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+  return [];
+}
+function reconstructPath(parentLink, fromId, toId) {
+  const path4 = [];
+  let current = toId;
+  while (current !== fromId) {
+    const link = parentLink.get(current);
+    if (!link) break;
+    path4.unshift(link);
+    current = link.toId === current ? link.fromId : link.toId;
+  }
+  return path4;
+}
+function toGraphLink(row) {
+  return {
+    fromId: row.from_id,
+    toId: row.to_id,
+    relation: row.relation,
+    layer: row.layer,
+    weight: row.weight,
+    sourcePath: row.source_path
+  };
+}
+
 // src/db/sqlite-vec.ts
 async function loadSqliteVecExtension(params) {
   try {
@@ -431,8 +485,8 @@ async function loadSqliteVecExtension(params) {
 }
 
 // src/embeddings/embeddings.ts
-import fsSync2 from "fs";
-import path2 from "path";
+import fsSync from "fs";
+import path from "path";
 import os from "os";
 var DEFAULT_LOCAL_MODEL = "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf";
 var DEFAULT_OPENAI_EMBEDDING_MODEL = "text-embedding-3-small";
@@ -449,7 +503,7 @@ function createNoOpEmbeddingProvider() {
 }
 function resolveUserPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return path2.join(os.homedir(), filePath.slice(2));
+    return path.join(os.homedir(), filePath.slice(2));
   }
   return filePath;
 }
@@ -459,7 +513,7 @@ function canAutoSelectLocal(options) {
   if (/^(hf:|https?:)/i.test(modelPath)) return false;
   const resolved = resolveUserPath(modelPath);
   try {
-    return fsSync2.statSync(resolved).isFile();
+    return fsSync.statSync(resolved).isFile();
   } catch {
     return false;
   }
@@ -660,7 +714,6 @@ async function createEmbeddingProvider(options) {
     return {
       provider: createNoOpEmbeddingProvider(),
       requestedProvider: "none"
-      // Type coercion for compatibility
     };
   }
   const createProvider = async (id) => {
@@ -704,7 +757,6 @@ async function createEmbeddingProvider(options) {
       provider: createNoOpEmbeddingProvider(),
       requestedProvider,
       fallbackFrom: "auto",
-      // Indicate this is a fallback
       fallbackReason: "No embedding API available. Using BM25 full-text search only."
     };
   }
@@ -1347,7 +1399,6 @@ var EMBEDDING_RETRY_BASE_DELAY_MS = 500;
 var EMBEDDING_RETRY_MAX_DELAY_MS = 8e3;
 var EMBEDDING_QUERY_TIMEOUT_REMOTE_MS = 6e4;
 var EMBEDDING_QUERY_TIMEOUT_LOCAL_MS = 5 * 6e4;
-var vectorToBlob2 = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
 var Minimem = class _Minimem {
   memoryDir;
   dbPath;
@@ -1373,10 +1424,11 @@ var Minimem = class _Minimem {
   closed = false;
   dirty = true;
   syncing = null;
+  syncLock = false;
   embeddingOptions;
   constructor(config) {
-    this.memoryDir = path3.resolve(config.memoryDir);
-    this.dbPath = config.dbPath ?? path3.join(this.memoryDir, ".minimem", "index.db");
+    this.memoryDir = path2.resolve(config.memoryDir);
+    this.dbPath = config.dbPath ?? path2.join(this.memoryDir, ".minimem", "index.db");
     this.chunking = {
       tokens: config.chunking?.tokens ?? 256,
       overlap: config.chunking?.overlap ?? 32
@@ -1442,7 +1494,7 @@ var Minimem = class _Minimem {
     }
   }
   openDatabase() {
-    const dbDir = path3.dirname(this.dbPath);
+    const dbDir = path2.dirname(this.dbPath);
     ensureDir(dbDir);
     return new DatabaseSync(this.dbPath);
   }
@@ -1482,8 +1534,8 @@ var Minimem = class _Minimem {
   }
   ensureWatcher() {
     if (this.watcher) return;
-    const memorySubDir = path3.join(this.memoryDir, "memory");
-    const memoryFile = path3.join(this.memoryDir, "MEMORY.md");
+    const memorySubDir = path2.join(this.memoryDir, "memory");
+    const memoryFile = path2.join(this.memoryDir, "MEMORY.md");
     this.watcher = chokidar.watch([memoryFile, memorySubDir], {
       ignoreInitial: true,
       persistent: true,
@@ -1516,13 +1568,13 @@ var Minimem = class _Minimem {
       }
       const storedMap = new Map(stored.map((f) => [f.path, f.mtime]));
       for (const absPath of files) {
-        const relPath = path3.relative(this.memoryDir, absPath).replace(/\\/g, "/");
+        const relPath = path2.relative(this.memoryDir, absPath).replace(/\\/g, "/");
         const storedMtime = storedMap.get(relPath);
         if (storedMtime === void 0) {
           this.debug?.(`Stale: new file ${relPath}`);
           return true;
         }
-        const stat = await fs2.stat(absPath);
+        const stat = await fs.stat(absPath);
         const currentMtime = Math.floor(stat.mtimeMs);
         if (currentMtime !== storedMtime) {
           this.debug?.(`Stale: mtime changed for ${relPath}`);
@@ -1572,8 +1624,14 @@ var Minimem = class _Minimem {
       sourceFilterVec: sourceFilter,
       sourceFilterChunks: sourceFilter
     }).catch(() => []) : [];
+    const typeFilterFn = opts?.type ? (id) => {
+      const row = this.db.prepare(`SELECT type FROM chunks WHERE id = ?`).get(id);
+      return row?.type === opts.type;
+    } : void 0;
     if (!this.hybrid.enabled) {
-      return vectorResults.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
+      let results = vectorResults;
+      if (typeFilterFn) results = results.filter((r) => typeFilterFn(r.id));
+      return results.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
         path: r.path,
         startLine: r.startLine,
         endLine: r.endLine,
@@ -1581,8 +1639,14 @@ var Minimem = class _Minimem {
         snippet: r.snippet
       }));
     }
+    let filteredVector = vectorResults;
+    let filteredKeyword = keywordResults;
+    if (typeFilterFn) {
+      filteredVector = vectorResults.filter((r) => typeFilterFn(r.id));
+      filteredKeyword = keywordResults.filter((r) => typeFilterFn(r.id));
+    }
     const merged = mergeHybridResults({
-      vector: vectorResults.map((r) => ({
+      vector: filteredVector.map((r) => ({
         id: r.id,
         path: r.path,
         startLine: r.startLine,
@@ -1591,7 +1655,7 @@ var Minimem = class _Minimem {
         snippet: r.snippet,
         vectorScore: r.score
       })),
-      keyword: keywordResults.map((r) => ({
+      keyword: filteredKeyword.map((r) => ({
         id: r.id,
         path: r.path,
         startLine: r.startLine,
@@ -1616,11 +1680,16 @@ var Minimem = class _Minimem {
       await this.syncing;
       return;
     }
+    if (this.syncLock) {
+      return;
+    }
+    this.syncLock = true;
     this.syncing = this.runSync(opts);
     try {
       await this.syncing;
     } finally {
       this.syncing = null;
+      this.syncLock = false;
     }
   }
   async runSync(opts) {
@@ -1647,13 +1716,16 @@ var Minimem = class _Minimem {
         this.db.prepare(
           `DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
         ).run(stale.path, "memory");
-      } catch {
+      } catch (err) {
+        logError("deleteStaleVectorEntries", err, this.debug);
       }
       this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(stale.path, "memory");
+      this.db.prepare(`DELETE FROM knowledge_links WHERE source_path = ?`).run(stale.path);
       if (this.fts.enabled && this.fts.available) {
         try {
           this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`).run(stale.path, "memory", this.provider.model);
-        } catch {
+        } catch (err) {
+          logError("deleteStaleFtsEntries", err, this.debug);
         }
       }
     }
@@ -1670,8 +1742,15 @@ var Minimem = class _Minimem {
     this.debug?.(`memory sync complete`, { files: files.length });
   }
   async indexFile(entry) {
-    const content = await fs2.readFile(entry.absPath, "utf-8");
+    const content = await fs.readFile(entry.absPath, "utf-8");
     const chunks = chunkMarkdown(content, this.chunking);
+    const { frontmatter } = parseFrontmatter(content);
+    const knowledgeType = frontmatter?.type ?? null;
+    const knowledgeId = frontmatter?.id ?? null;
+    const domains = frontmatter?.domain ?? null;
+    const entities = frontmatter?.entities ?? null;
+    const confidence = frontmatter?.confidence ?? null;
+    const links = frontmatter?.links ?? null;
     const embeddings = await this.embedChunks(chunks);
     this.db.prepare(
       `INSERT OR REPLACE INTO files (path, source, hash, mtime, size) VALUES (?, ?, ?, ?, ?)`
@@ -1680,23 +1759,27 @@ var Minimem = class _Minimem {
       this.db.prepare(
         `DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
       ).run(entry.path, "memory");
-    } catch {
+    } catch (err) {
+      logError("deleteOldVectorChunks", err, this.debug);
     }
     this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(entry.path, "memory");
     if (this.fts.enabled && this.fts.available) {
       try {
         this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`).run(entry.path, "memory", this.provider.model);
-      } catch {
+      } catch (err) {
+        logError("deleteOldFtsChunks", err, this.debug);
       }
     }
+    this.db.prepare(`DELETE FROM knowledge_links WHERE source_path = ?`).run(entry.path);
     const now = Date.now();
     for (let i = 0; i < chunks.length; i++) {
       const chunk = chunks[i];
       const embedding = embeddings[i] ?? [];
       const chunkId = randomUUID();
+      const meta = extractChunkMetadata(chunk.text);
       this.db.prepare(
-        `INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at, type, knowledge_type, knowledge_id, domains, entities, confidence)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ).run(
         chunkId,
         entry.path,
@@ -1707,7 +1790,13 @@ var Minimem = class _Minimem {
         this.provider.model,
         chunk.text,
         JSON.stringify(embedding),
-        now
+        now,
+        meta.type ?? null,
+        knowledgeType,
+        knowledgeId,
+        domains ? JSON.stringify(domains) : null,
+        entities ? JSON.stringify(entities) : null,
+        confidence
       );
       if (this.vector.available && embedding.length > 0) {
         if (!this.vector.dims) {
@@ -1715,8 +1804,9 @@ var Minimem = class _Minimem {
           this.ensureVectorTable(embedding.length);
         }
         try {
-          this.db.prepare(`INSERT INTO ${VECTOR_TABLE} (id, embedding) VALUES (?, ?)`).run(chunkId, vectorToBlob2(embedding));
-        } catch {
+          this.db.prepare(`INSERT INTO ${VECTOR_TABLE} (id, embedding) VALUES (?, ?)`).run(chunkId, vectorToBlob(embedding));
+        } catch (err) {
+          logError("insertVectorChunk", err, this.debug);
         }
       }
       if (this.fts.enabled && this.fts.available) {
@@ -1733,10 +1823,28 @@ var Minimem = class _Minimem {
             chunk.startLine,
             chunk.endLine
           );
-        } catch {
+        } catch (err) {
+          logError("insertFtsChunk", err, this.debug);
         }
       }
     }
+    if (links && knowledgeId) {
+      const upsertLink = this.db.prepare(
+        `INSERT OR REPLACE INTO knowledge_links (from_id, to_id, relation, layer, weight, source_path, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      );
+      for (const link of links) {
+        upsertLink.run(
+          knowledgeId,
+          link.target,
+          link.relation,
+          link.layer ?? null,
+          0.5,
+          entry.path,
+          now
+        );
+      }
+    }
   }
   async embedChunks(chunks) {
     if (chunks.length === 0) return [];
@@ -1828,12 +1936,22 @@ var Minimem = class _Minimem {
   }
   async embedQueryWithTimeout(text) {
     const timeout = this.provider.id === "local" ? EMBEDDING_QUERY_TIMEOUT_LOCAL_MS : EMBEDDING_QUERY_TIMEOUT_REMOTE_MS;
-    return Promise.race([
-      this.provider.embedQuery(text),
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("embedding query timeout")), timeout)
-      )
-    ]);
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeout);
+    try {
+      const result = await Promise.race([
+        this.provider.embedQuery(text),
+        new Promise((_, reject) => {
+          ac.signal.addEventListener(
+            "abort",
+            () => reject(new Error("embedding query timeout"))
+          );
+        })
+      ]);
+      return result;
+    } finally {
+      clearTimeout(timer);
+    }
   }
   loadEmbeddingCache(hashes) {
     const result = /* @__PURE__ */ new Map();
@@ -1926,9 +2044,9 @@ var Minimem = class _Minimem {
     }
   }
   async readFile(relativePath) {
-    const absPath = path3.join(this.memoryDir, relativePath);
+    const absPath = path2.join(this.memoryDir, relativePath);
     try {
-      return await fs2.readFile(absPath, "utf-8");
+      return await fs.readFile(absPath, "utf-8");
     } catch {
       return null;
     }
@@ -1956,10 +2074,10 @@ var Minimem = class _Minimem {
    */
   async writeFile(relativePath, content) {
     this.validateMemoryPath(relativePath);
-    const absPath = path3.join(this.memoryDir, relativePath);
-    const dir = path3.dirname(absPath);
-    await fs2.mkdir(dir, { recursive: true });
-    await fs2.writeFile(absPath, content, "utf-8");
+    const absPath = path2.join(this.memoryDir, relativePath);
+    const dir = path2.dirname(absPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(absPath, content, "utf-8");
     this.dirty = true;
     this.debug?.(`memory write: ${relativePath}`);
   }
@@ -1968,18 +2086,18 @@ var Minimem = class _Minimem {
    */
   async appendFile(relativePath, content) {
     this.validateMemoryPath(relativePath);
-    const absPath = path3.join(this.memoryDir, relativePath);
-    const dir = path3.dirname(absPath);
-    await fs2.mkdir(dir, { recursive: true });
+    const absPath = path2.join(this.memoryDir, relativePath);
+    const dir = path2.dirname(absPath);
+    await fs.mkdir(dir, { recursive: true });
     let toAppend = content;
     try {
-      const existing = await fs2.readFile(absPath, "utf-8");
+      const existing = await fs.readFile(absPath, "utf-8");
       if (existing.length > 0 && !existing.endsWith("\n")) {
         toAppend = "\n" + content;
       }
     } catch {
     }
-    await fs2.appendFile(absPath, toAppend, "utf-8");
+    await fs.appendFile(absPath, toAppend, "utf-8");
     this.dirty = true;
     this.debug?.(`memory append: ${relativePath}`);
   }
@@ -1997,7 +2115,7 @@ var Minimem = class _Minimem {
    */
   async listFiles() {
     const files = await listMemoryFiles(this.memoryDir);
-    return files.map((f) => path3.relative(this.memoryDir, f).replace(/\\/g, "/"));
+    return files.map((f) => path2.relative(this.memoryDir, f).replace(/\\/g, "/"));
   }
   /**
    * Validate that a path is within allowed memory locations
@@ -2035,6 +2153,70 @@ var Minimem = class _Minimem {
       cacheCount: cacheRow.count
     };
   }
+  /**
+   * Search with knowledge metadata filters (domain, entities, confidence, type).
+   * Runs a standard search then post-filters by knowledge columns.
+   */
+  async knowledgeSearch(query, opts) {
+    if (this.dirty || !this.watchConfig.enabled && await this.isStale()) {
+      await this.sync({ reason: "knowledgeSearch" });
+    }
+    const cleaned = query.trim();
+    if (!cleaned) return [];
+    const minScore = opts?.minScore ?? this.queryConfig.minScore;
+    const maxResults = opts?.maxResults ?? this.queryConfig.maxResults;
+    const { sql: knowledgeWhere, params: knowledgeParams } = buildKnowledgeFilterSql({
+      domain: opts?.domain,
+      entities: opts?.entities,
+      minConfidence: opts?.minConfidence,
+      knowledgeType: opts?.knowledgeType
+    });
+    if (!knowledgeWhere) {
+      return this.search(query, { maxResults, minScore });
+    }
+    const matchingRows = this.db.prepare(
+      `SELECT id FROM chunks c WHERE c.model = ? AND c.source = 'memory'${knowledgeWhere}`
+    ).all(this.provider.model, ...knowledgeParams);
+    const matchingIds = new Set(matchingRows.map((r) => r.id));
+    if (matchingIds.size === 0) return [];
+    const overFetch = Math.max(maxResults * 3, 30);
+    const results = await this.search(query, {
+      maxResults: overFetch,
+      minScore
+    });
+    const filtered = [];
+    for (const r of results) {
+      const row = this.db.prepare(
+        `SELECT id FROM chunks WHERE path = ? AND start_line = ? AND end_line = ? AND model = ?`
+      ).get(r.path, r.startLine, r.endLine, this.provider.model);
+      if (row && matchingIds.has(row.id)) {
+        filtered.push(r);
+        if (filtered.length >= maxResults) break;
+      }
+    }
+    return filtered;
+  }
+  /**
+   * Get knowledge graph links from or to a node.
+   */
+  getLinks(nodeId, direction = "from", opts) {
+    if (direction === "from") {
+      return getLinksFrom(this.db, nodeId, opts);
+    }
+    return getLinksTo(this.db, nodeId, opts);
+  }
+  /**
+   * Get neighbor nodes via BFS traversal.
+   */
+  getGraphNeighbors(nodeId, depth = 1, opts) {
+    return getNeighbors(this.db, nodeId, depth, opts);
+  }
+  /**
+   * Find shortest path between two knowledge nodes.
+   */
+  getGraphPath(fromId, toId, maxDepth = 3) {
+    return getPathBetween(this.db, fromId, toId, maxDepth);
+  }
   close() {
     if (this.closed) return;
     this.closed = true;
@@ -2048,7 +2230,8 @@ var Minimem = class _Minimem {
     }
     try {
       this.db.close();
-    } catch {
+    } catch (err) {
+      logError("dbClose", err, this.debug);
     }
   }
 };
@@ -2076,12 +2259,152 @@ var MEMORY_SEARCH_TOOL = {
         type: "array",
         items: { type: "string" },
         description: "Optional: filter to specific memory directories by name/path. If omitted, searches all configured directories."
+      },
+      detail: {
+        type: "string",
+        enum: ["compact", "full"],
+        description: "Result detail level. 'compact' returns a lightweight index with short previews (~80 chars). 'full' returns complete snippets. Use 'compact' first, then memory_get_details for selected results. (default: 'compact')"
+      },
+      type: {
+        type: "string",
+        description: "Filter by observation type. Matches <!-- type: X --> comments in memory entries. Common types: decision, bugfix, feature, discovery, context, note."
+      }
+    },
+    required: ["query"]
+  }
+};
+var MEMORY_GET_DETAILS_TOOL = {
+  name: "memory_get_details",
+  description: "Fetch full text for specific memory chunks identified by path and line range. Use after memory_search with compact results to get details for selected items only. This two-step approach significantly reduces token usage.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      results: {
+        type: "array",
+        items: { type: "object" },
+        description: "Array of { path, startLine, endLine } objects from compact search results."
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories."
+      }
+    },
+    required: ["results"]
+  }
+};
+var KNOWLEDGE_SEARCH_TOOL = {
+  name: "knowledge_search",
+  description: "Search memory with knowledge metadata filters. Filter by domain, entities, confidence level, or knowledge type (observation, entity, domain-summary). Combines semantic search with structured knowledge filtering.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Natural language search query"
+      },
+      domain: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter to entries in these knowledge domains"
+      },
+      entities: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter to entries referencing these entities"
+      },
+      minConfidence: {
+        type: "number",
+        description: "Minimum confidence threshold (0-1)"
+      },
+      knowledgeType: {
+        type: "string",
+        description: "Filter by knowledge type: observation, entity, domain-summary"
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results (default: 10)"
+      },
+      minScore: {
+        type: "number",
+        description: "Minimum relevance score 0-1 (default: 0.3)"
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories"
       }
     },
     required: ["query"]
   }
 };
-var MEMORY_TOOLS = [MEMORY_SEARCH_TOOL];
+var KNOWLEDGE_GRAPH_TOOL = {
+  name: "knowledge_graph",
+  description: "Traverse knowledge graph links from a note. Returns neighbor nodes connected by typed relationships (e.g., relates-to, supports, contradicts). Use depth parameter for multi-hop traversal.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      nodeId: {
+        type: "string",
+        description: "The knowledge node ID to start traversal from"
+      },
+      depth: {
+        type: "number",
+        description: "Maximum traversal depth (default: 1, max: 3)",
+        default: 1
+      },
+      relation: {
+        type: "string",
+        description: "Optional: filter to specific relation type"
+      },
+      layer: {
+        type: "string",
+        description: "Optional: filter to specific graph layer"
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories"
+      }
+    },
+    required: ["nodeId"]
+  }
+};
+var KNOWLEDGE_PATH_TOOL = {
+  name: "knowledge_path",
+  description: "Find the shortest path between two knowledge nodes in the graph. Uses BFS traversal up to a configurable max depth. Returns the sequence of links connecting the two nodes.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      fromId: {
+        type: "string",
+        description: "Starting knowledge node ID"
+      },
+      toId: {
+        type: "string",
+        description: "Target knowledge node ID"
+      },
+      maxDepth: {
+        type: "number",
+        description: "Maximum path length (default: 3)",
+        default: 3
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories"
+      }
+    },
+    required: ["fromId", "toId"]
+  }
+};
+var MEMORY_TOOLS = [
+  MEMORY_SEARCH_TOOL,
+  MEMORY_GET_DETAILS_TOOL,
+  KNOWLEDGE_SEARCH_TOOL,
+  KNOWLEDGE_GRAPH_TOOL,
+  KNOWLEDGE_PATH_TOOL
+];
 function getToolDefinitions() {
   return MEMORY_TOOLS;
 }
@@ -2110,6 +2433,14 @@ var MemoryToolExecutor = class {
       switch (toolName) {
         case "memory_search":
           return await this.memorySearch(params);
+        case "memory_get_details":
+          return await this.memoryGetDetails(params);
+        case "knowledge_search":
+          return await this.knowledgeSearch(params);
+        case "knowledge_graph":
+          return await this.knowledgeGraph(params);
+        case "knowledge_path":
+          return await this.knowledgePath(params);
         default:
           return {
             content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
@@ -2124,37 +2455,43 @@ var MemoryToolExecutor = class {
       };
     }
   }
+  /**
+   * Filter instances by directory names/paths
+   */
+  filterInstances(directories) {
+    if (!directories || directories.length === 0) return this.instances;
+    const dirFilter = new Set(directories.map((d) => d.toLowerCase()));
+    const filtered = this.instances.filter((i) => {
+      const name = (i.name ?? i.memoryDir).toLowerCase();
+      const dir = i.memoryDir.toLowerCase();
+      return dirFilter.has(name) || dirFilter.has(dir) || [...dirFilter].some((f) => dir.includes(f) || name.includes(f));
+    });
+    return filtered.length > 0 ? filtered : null;
+  }
   async memorySearch(params) {
     const maxResults = params.maxResults ?? 10;
     const minScore = params.minScore;
-    let instancesToSearch = this.instances;
-    if (params.directories && params.directories.length > 0) {
-      const dirFilter = new Set(params.directories.map((d) => d.toLowerCase()));
-      instancesToSearch = this.instances.filter((i) => {
-        const name = (i.name ?? i.memoryDir).toLowerCase();
-        const dir = i.memoryDir.toLowerCase();
-        return dirFilter.has(name) || dirFilter.has(dir) || // Also match partial paths
-        [...dirFilter].some((f) => dir.includes(f) || name.includes(f));
-      });
-      if (instancesToSearch.length === 0) {
-        const available = this.getDirectories().join(", ");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No matching directories found. Available: ${available}`
-            }
-          ],
-          isError: true
-        };
-      }
+    const detail = params.detail ?? "compact";
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No matching directories found. Available: ${available}`
+          }
+        ],
+        isError: true
+      };
     }
     const allResults = [];
     for (const instance of instancesToSearch) {
       const perDirMax = Math.ceil(maxResults * 1.5);
       const results = await instance.minimem.search(params.query, {
         maxResults: perDirMax,
-        minScore
+        minScore,
+        type: params.type
       });
       for (const result of results) {
         allResults.push({
@@ -2171,21 +2508,203 @@ var MemoryToolExecutor = class {
       };
     }
     const showSource = instancesToSearch.length > 1;
-    const formatted = topResults.map((r, i) => {
+    if (detail === "compact") {
+      return this.formatCompactResults(topResults, showSource, instancesToSearch.length);
+    }
+    return this.formatFullResults(topResults, showSource, instancesToSearch.length);
+  }
+  formatCompactResults(results, showSource, dirCount) {
+    const formatted = results.map((r, i) => {
+      const location = `${r.path}:${r.startLine}-${r.endLine}`;
+      const score = (r.score * 100).toFixed(0);
+      const source = showSource ? ` [${r.memoryDir}]` : "";
+      const preview = compactPreview(r.snippet);
+      return `[${i}] ${location}${source} (${score}%) \u2014 ${preview}`;
+    }).join("\n");
+    const hint = "\n\nUse memory_get_details to fetch full text for selected results.";
+    const dirSummary = dirCount > 1 ? `
+(Searched ${dirCount} directories)` : "";
+    return {
+      content: [{ type: "text", text: formatted + dirSummary + hint }]
+    };
+  }
+  formatFullResults(results, showSource, dirCount) {
+    const formatted = results.map((r, i) => {
       const location = `${r.path}:${r.startLine}-${r.endLine}`;
       const score = (r.score * 100).toFixed(1);
       const source = showSource ? ` [${r.memoryDir}]` : "";
       return `[${i + 1}] ${location}${source} (${score}% match)
 ${r.snippet}`;
     }).join("\n\n");
-    const dirSummary = instancesToSearch.length > 1 ? `
+    const dirSummary = dirCount > 1 ? `
 
-(Searched ${instancesToSearch.length} directories)` : "";
+(Searched ${dirCount} directories)` : "";
     return {
       content: [{ type: "text", text: formatted + dirSummary }]
     };
   }
+  async memoryGetDetails(params) {
+    if (!params.results || params.results.length === 0) {
+      return {
+        content: [{ type: "text", text: "No results specified." }],
+        isError: true
+      };
+    }
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No matching directories found. Available: ${available}`
+          }
+        ],
+        isError: true
+      };
+    }
+    const details = [];
+    for (const ref of params.results) {
+      let found = false;
+      for (const instance of instancesToSearch) {
+        const lineCount = ref.endLine - ref.startLine + 1;
+        const result = await instance.minimem.readLines(ref.path, {
+          from: ref.startLine,
+          lines: lineCount
+        });
+        if (result) {
+          const location = `${ref.path}:${result.startLine}-${result.endLine}`;
+          details.push(`--- ${location} ---
+${result.content}`);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        details.push(`--- ${ref.path}:${ref.startLine}-${ref.endLine} ---
+(not found)`);
+      }
+    }
+    return {
+      content: [{ type: "text", text: details.join("\n\n") }]
+    };
+  }
+  async knowledgeSearch(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const maxResults = params.maxResults ?? 10;
+    const allResults = [];
+    for (const instance of instancesToSearch) {
+      const results = await instance.minimem.knowledgeSearch(params.query, {
+        maxResults: Math.ceil(maxResults * 1.5),
+        minScore: params.minScore,
+        domain: params.domain,
+        entities: params.entities,
+        minConfidence: params.minConfidence,
+        knowledgeType: params.knowledgeType
+      });
+      for (const result of results) {
+        allResults.push({
+          ...result,
+          memoryDir: instance.name ?? instance.memoryDir
+        });
+      }
+    }
+    allResults.sort((a, b) => b.score - a.score);
+    const topResults = allResults.slice(0, maxResults);
+    if (topResults.length === 0) {
+      return { content: [{ type: "text", text: "No knowledge results found." }] };
+    }
+    const formatted = topResults.map((r, i) => {
+      const location = `${r.path}:${r.startLine}-${r.endLine}`;
+      const score = (r.score * 100).toFixed(0);
+      const preview = compactPreview(r.snippet);
+      return `[${i}] ${location} (${score}%) \u2014 ${preview}`;
+    }).join("\n");
+    return { content: [{ type: "text", text: formatted }] };
+  }
+  async knowledgeGraph(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const depth = Math.min(params.depth ?? 1, 3);
+    const allNeighbors = [];
+    for (const instance of instancesToSearch) {
+      const neighbors = instance.minimem.getGraphNeighbors(params.nodeId, depth, {
+        relation: params.relation,
+        layer: params.layer
+      });
+      for (const n of neighbors) {
+        allNeighbors.push({
+          id: n.id,
+          depth: n.depth,
+          relation: n.link.relation,
+          layer: n.link.layer,
+          memoryDir: instance.name ?? instance.memoryDir
+        });
+      }
+    }
+    if (allNeighbors.length === 0) {
+      return { content: [{ type: "text", text: `No neighbors found for node "${params.nodeId}".` }] };
+    }
+    const formatted = allNeighbors.map((n) => `  [depth=${n.depth}] ${n.id} \u2014(${n.relation})${n.layer ? ` [${n.layer}]` : ""}`).join("\n");
+    return {
+      content: [{ type: "text", text: `Neighbors of "${params.nodeId}":
+${formatted}` }]
+    };
+  }
+  async knowledgePath(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const maxDepth = Math.min(params.maxDepth ?? 3, 5);
+    for (const instance of instancesToSearch) {
+      const path4 = instance.minimem.getGraphPath(params.fromId, params.toId, maxDepth);
+      if (path4.length > 0) {
+        const steps = path4.map((link) => `  ${link.fromId} \u2014(${link.relation})\u2192 ${link.toId}`).join("\n");
+        return {
+          content: [{
+            type: "text",
+            text: `Path from "${params.fromId}" to "${params.toId}" (${path4.length} steps):
+${steps}`
+          }]
+        };
+      }
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `No path found from "${params.fromId}" to "${params.toId}" within depth ${maxDepth}.`
+      }]
+    };
+  }
 };
+function compactPreview(snippet) {
+  const maxLen = 80;
+  const lines = snippet.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) return "(empty)";
+  const heading = lines.find((l) => l.startsWith("#"));
+  const text = heading ?? lines[0];
+  const cleaned = text.replace(/^#+\s*/, "").trim();
+  if (cleaned.length <= maxLen) return `"${cleaned}"`;
+  return `"${cleaned.slice(0, maxLen - 3)}..."`;
+}
 function createToolExecutor(instances) {
   return new MemoryToolExecutor(instances);
 }
@@ -2347,133 +2866,570 @@ function generateMcpConfig(opts) {
   };
 }
 
-// src/session.ts
-import * as os2 from "os";
-function parseFrontmatter(content) {
-  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n/;
-  const match = content.match(frontmatterRegex);
-  if (!match) {
-    return { frontmatter: void 0, body: content };
-  }
-  const yamlContent = match[1];
-  const body = content.slice(match[0].length);
-  try {
-    const frontmatter = parseSimpleYaml(yamlContent);
-    return { frontmatter, body };
-  } catch {
-    return { frontmatter: void 0, body: content };
-  }
-}
-function parseSimpleYaml(yaml) {
-  const result = {};
-  const lines = yaml.split("\n");
-  let currentKey = null;
-  let currentObject = null;
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    const indentMatch = line.match(/^(\s*)/);
-    const indent = indentMatch ? indentMatch[1].length : 0;
-    if (indent === 0) {
-      const keyMatch = line.match(/^(\w+):\s*(.*)?$/);
-      if (keyMatch) {
-        const [, key, value] = keyMatch;
-        if (value && value.trim()) {
-          result[key] = parseYamlValue(value.trim());
-          currentKey = null;
-          currentObject = null;
-        } else {
-          currentKey = key;
-          currentObject = {};
-          result[key] = currentObject;
+// src/core/indexer.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import fs2 from "fs/promises";
+import path3 from "path";
+var META_KEY2 = "memory_index_meta_v1";
+var EMBEDDING_CACHE_TABLE2 = "embedding_cache";
+var VECTOR_TABLE2 = "chunks_vec";
+var FTS_TABLE2 = "chunks_fts";
+var EMBEDDING_RETRY_MAX_ATTEMPTS2 = 3;
+var EMBEDDING_RETRY_BASE_DELAY_MS2 = 500;
+var EMBEDDING_RETRY_MAX_DELAY_MS2 = 8e3;
+var MemoryIndexer = class {
+  config;
+  db;
+  provider;
+  providerKey;
+  openAi;
+  gemini;
+  // Vector/FTS state (shared with parent)
+  vectorState;
+  ftsAvailable;
+  constructor(db, provider, config, options) {
+    this.db = db;
+    this.provider = provider;
+    this.config = config;
+    this.openAi = options?.openAi;
+    this.gemini = options?.gemini;
+    this.vectorState = options?.vectorState ?? { available: false };
+    this.ftsAvailable = options?.ftsAvailable ?? false;
+    this.providerKey = this.computeProviderKey();
+  }
+  /**
+   * Update vector/FTS availability (called by parent when extensions load)
+   */
+  setVectorState(state) {
+    this.vectorState = state;
+  }
+  setFtsAvailable(available) {
+    this.ftsAvailable = available;
+  }
+  getVectorDims() {
+    return this.vectorState.dims;
+  }
+  /**
+   * Compute a unique key for the current provider configuration
+   */
+  computeProviderKey() {
+    const parts = [this.provider.id, this.provider.model];
+    if (this.openAi) {
+      parts.push(this.openAi.baseUrl);
+    }
+    if (this.gemini) {
+      parts.push(this.gemini.baseUrl);
+    }
+    return hashText(parts.join(":"));
+  }
+  /**
+   * Read index metadata from database
+   */
+  readMeta() {
+    try {
+      const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(META_KEY2);
+      if (!row?.value) return null;
+      return JSON.parse(row.value);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Write index metadata to database
+   */
+  writeMeta(meta) {
+    this.db.prepare(`INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)`).run(META_KEY2, JSON.stringify(meta));
+  }
+  /**
+   * Check if the index is stale by comparing file mtimes
+   */
+  async isStale() {
+    try {
+      const files = await listMemoryFiles(this.config.memoryDir);
+      const stored = this.db.prepare(`SELECT path, mtime FROM files WHERE source = ?`).all("memory");
+      if (files.length !== stored.length) {
+        this.config.debug?.(`Stale: file count changed (${stored.length} -> ${files.length})`);
+        return true;
+      }
+      const storedMap = new Map(stored.map((f) => [f.path, f.mtime]));
+      for (const absPath of files) {
+        const relPath = path3.relative(this.config.memoryDir, absPath).replace(/\\/g, "/");
+        const storedMtime = storedMap.get(relPath);
+        if (storedMtime === void 0) {
+          this.config.debug?.(`Stale: new file ${relPath}`);
+          return true;
+        }
+        const stat = await fs2.stat(absPath);
+        const currentMtime = Math.floor(stat.mtimeMs);
+        if (currentMtime !== storedMtime) {
+          this.config.debug?.(`Stale: mtime changed for ${relPath}`);
+          return true;
         }
       }
-    } else if (currentObject && indent >= 2) {
-      const nestedMatch = line.match(/^\s+(\w+):\s*(.*)$/);
-      if (nestedMatch) {
-        const [, key, value] = nestedMatch;
-        currentObject[key] = parseYamlValue(value.trim());
+      return false;
+    } catch (err) {
+      this.config.debug?.(`Stale check failed: ${String(err)}`);
+      return true;
+    }
+  }
+  /**
+   * Check if a full reindex is needed based on configuration changes
+   */
+  needsFullReindex(force) {
+    const meta = this.readMeta();
+    return force === true || !meta || meta.model !== this.provider.model || meta.provider !== this.provider.id || meta.providerKey !== this.providerKey || meta.chunkTokens !== this.config.chunking.tokens || meta.chunkOverlap !== this.config.chunking.overlap || this.vectorState.available && !meta?.vectorDims;
+  }
+  /**
+   * Index all memory files, returns stats
+   */
+  async indexAll(force) {
+    const needsFullReindex = this.needsFullReindex(force);
+    const files = await listMemoryFiles(this.config.memoryDir);
+    const activePaths = /* @__PURE__ */ new Set();
+    let filesProcessed = 0;
+    let chunksCreated = 0;
+    for (const absPath of files) {
+      const entry = await buildFileEntry(absPath, this.config.memoryDir);
+      activePaths.add(entry.path);
+      const record = this.db.prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`).get(entry.path, "memory");
+      if (!needsFullReindex && record?.hash === entry.hash) {
+        continue;
       }
+      const chunkCount = await this.indexFile(entry);
+      filesProcessed++;
+      chunksCreated += chunkCount;
     }
+    const staleRemoved = this.removeStaleEntries(activePaths);
+    this.writeMeta({
+      model: this.provider.model,
+      provider: this.provider.id,
+      providerKey: this.providerKey,
+      chunkTokens: this.config.chunking.tokens,
+      chunkOverlap: this.config.chunking.overlap,
+      vectorDims: this.vectorState.dims
+    });
+    this.pruneEmbeddingCacheIfNeeded();
+    return { filesProcessed, chunksCreated, staleRemoved };
   }
-  return result;
-}
-function parseYamlValue(value) {
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  if (value === "true") return true;
-  if (value === "false") return false;
-  const num = Number(value);
-  if (!isNaN(num) && value !== "") return num;
-  if (value.startsWith("[") && value.endsWith("]")) {
-    const inner = value.slice(1, -1);
-    return inner.split(",").map((s) => parseYamlValue(s.trim()));
-  }
-  return value;
-}
-function serializeFrontmatter(frontmatter) {
-  const lines = ["---"];
-  if (frontmatter.session) {
-    lines.push("session:");
-    const session = frontmatter.session;
-    if (session.id) lines.push(`  id: ${session.id}`);
-    if (session.source) lines.push(`  source: ${session.source}`);
-    if (session.project) lines.push(`  project: ${formatPath(session.project)}`);
-    if (session.transcript) lines.push(`  transcript: ${formatPath(session.transcript)}`);
-  }
-  if (frontmatter.created) {
-    lines.push(`created: ${frontmatter.created}`);
-  }
-  if (frontmatter.updated) {
-    lines.push(`updated: ${frontmatter.updated}`);
-  }
-  if (frontmatter.tags && frontmatter.tags.length > 0) {
-    lines.push(`tags: [${frontmatter.tags.join(", ")}]`);
-  }
-  lines.push("---");
-  return lines.join("\n") + "\n";
-}
-function addFrontmatter(content, frontmatter) {
-  const { frontmatter: existing, body } = parseFrontmatter(content);
-  const merged = {
-    ...existing,
-    ...frontmatter,
-    session: {
-      ...existing?.session,
-      ...frontmatter.session
+  /**
+   * Index a single file
+   */
+  async indexFile(entry) {
+    const content = await fs2.readFile(entry.absPath, "utf-8");
+    const chunks = chunkMarkdown(content, this.config.chunking);
+    const embeddings = await this.embedChunks(chunks);
+    this.db.prepare(
+      `INSERT OR REPLACE INTO files (path, source, hash, mtime, size) VALUES (?, ?, ?, ?, ?)`
+    ).run(entry.path, "memory", entry.hash, Math.floor(entry.mtimeMs), entry.size);
+    this.deleteChunksForFile(entry.path);
+    const now = Date.now();
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const embedding = embeddings[i] ?? [];
+      this.insertChunk(entry.path, chunk, embedding, now);
     }
-  };
-  if (!merged.created) {
-    merged.created = (/* @__PURE__ */ new Date()).toISOString();
+    return chunks.length;
   }
-  merged.updated = (/* @__PURE__ */ new Date()).toISOString();
-  return serializeFrontmatter(merged) + body;
-}
-function addSessionToContent(content, session) {
-  return addFrontmatter(content, { session });
-}
-function formatPath(filePath) {
-  const home = os2.homedir();
-  if (filePath.startsWith(home)) {
-    return "~" + filePath.slice(home.length);
+  /**
+   * Delete all chunks for a file
+   */
+  deleteChunksForFile(filePath) {
+    try {
+      this.db.prepare(
+        `DELETE FROM ${VECTOR_TABLE2} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
+      ).run(filePath, "memory");
+    } catch {
+    }
+    this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(filePath, "memory");
+    if (this.config.ftsEnabled && this.ftsAvailable) {
+      try {
+        this.db.prepare(`DELETE FROM ${FTS_TABLE2} WHERE path = ? AND source = ? AND model = ?`).run(filePath, "memory", this.provider.model);
+      } catch {
+      }
+    }
   }
-  return filePath;
-}
-function extractSession(content) {
-  const { frontmatter } = parseFrontmatter(content);
-  return frontmatter?.session;
-}
+  /**
+   * Insert a chunk into the database
+   */
+  insertChunk(filePath, chunk, embedding, timestamp) {
+    const chunkId = randomUUID2();
+    this.db.prepare(
+      `INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      chunkId,
+      filePath,
+      "memory",
+      chunk.startLine,
+      chunk.endLine,
+      chunk.hash,
+      this.provider.model,
+      chunk.text,
+      JSON.stringify(embedding),
+      timestamp
+    );
+    if (this.vectorState.available && embedding.length > 0) {
+      if (!this.vectorState.dims) {
+        this.vectorState.dims = embedding.length;
+        this.ensureVectorTable(embedding.length);
+      }
+      try {
+        this.db.prepare(`INSERT INTO ${VECTOR_TABLE2} (id, embedding) VALUES (?, ?)`).run(chunkId, vectorToBlob(embedding));
+      } catch {
+      }
+    }
+    if (this.config.ftsEnabled && this.ftsAvailable) {
+      try {
+        this.db.prepare(
+          `INSERT INTO ${FTS_TABLE2} (text, id, path, source, model, start_line, end_line)
+             VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          chunk.text,
+          chunkId,
+          filePath,
+          "memory",
+          this.provider.model,
+          chunk.startLine,
+          chunk.endLine
+        );
+      } catch {
+      }
+    }
+  }
+  /**
+   * Remove stale file entries that no longer exist
+   */
+  removeStaleEntries(activePaths) {
+    const staleRows = this.db.prepare(`SELECT path FROM files WHERE source = ?`).all("memory");
+    let removed = 0;
+    for (const stale of staleRows) {
+      if (activePaths.has(stale.path)) continue;
+      this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(stale.path, "memory");
+      this.deleteChunksForFile(stale.path);
+      removed++;
+    }
+    return removed;
+  }
+  /**
+   * Create vector table with the given dimensions
+   */
+  ensureVectorTable(dimensions) {
+    if (!this.vectorState.available) return;
+    try {
+      this.db.exec(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${VECTOR_TABLE2} USING vec0(
+          id TEXT PRIMARY KEY,
+          embedding FLOAT[${dimensions}]
+        )`
+      );
+    } catch (err) {
+      this.config.debug?.(`vector table creation failed: ${String(err)}`);
+    }
+  }
+  /**
+   * Get embeddings for chunks, using cache when available
+   */
+  async embedChunks(chunks) {
+    if (chunks.length === 0) return [];
+    const hashes = chunks.map((c) => c.hash);
+    const cached = this.loadEmbeddingCache(hashes);
+    const missing = [];
+    for (let i = 0; i < chunks.length; i++) {
+      if (!cached.has(hashes[i])) {
+        missing.push({ index: i, chunk: chunks[i] });
+      }
+    }
+    if (missing.length > 0) {
+      const texts = missing.map((m) => m.chunk.text);
+      const newEmbeddings = await this.embedBatchWithRetry(texts);
+      for (let i = 0; i < missing.length; i++) {
+        const hash = missing[i].chunk.hash;
+        const embedding = newEmbeddings[i] ?? [];
+        cached.set(hash, embedding);
+        this.upsertEmbeddingCache(hash, embedding);
+      }
+    }
+    return hashes.map((h) => cached.get(h) ?? []);
+  }
+  /**
+   * Embed texts with retry logic
+   */
+  async embedBatchWithRetry(texts) {
+    if (texts.length === 0) return [];
+    if (this.config.batch.enabled) {
+      try {
+        return await this.embedWithBatchApi(texts);
+      } catch (err) {
+        this.config.debug?.(`batch embedding failed, falling back to direct: ${String(err)}`);
+      }
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < EMBEDDING_RETRY_MAX_ATTEMPTS2; attempt++) {
+      try {
+        return await this.provider.embedBatch(texts);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < EMBEDDING_RETRY_MAX_ATTEMPTS2 - 1) {
+          const delay = Math.min(
+            EMBEDDING_RETRY_MAX_DELAY_MS2,
+            EMBEDDING_RETRY_BASE_DELAY_MS2 * Math.pow(2, attempt)
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Use batch API for large embedding jobs
+   */
+  async embedWithBatchApi(texts) {
+    if (this.openAi) {
+      const requests = texts.map((text, i) => ({
+        custom_id: `chunk-${i}`,
+        method: "POST",
+        url: OPENAI_BATCH_ENDPOINT,
+        body: { model: this.openAi.model, input: text }
+      }));
+      const results = await runOpenAiEmbeddingBatches({
+        openAi: this.openAi,
+        source: "minimem",
+        requests,
+        wait: this.config.batch.wait,
+        pollIntervalMs: this.config.batch.pollIntervalMs,
+        timeoutMs: this.config.batch.timeoutMs,
+        concurrency: this.config.batch.concurrency,
+        debug: this.config.debug
+      });
+      return texts.map((_, i) => results.get(`chunk-${i}`) ?? []);
+    }
+    if (this.gemini) {
+      const requests = texts.map((text, i) => ({
+        custom_id: `chunk-${i}`,
+        content: { parts: [{ text }] },
+        taskType: "RETRIEVAL_DOCUMENT"
+      }));
+      const results = await runGeminiEmbeddingBatches({
+        gemini: this.gemini,
+        source: "minimem",
+        requests,
+        wait: this.config.batch.wait,
+        pollIntervalMs: this.config.batch.pollIntervalMs,
+        timeoutMs: this.config.batch.timeoutMs,
+        concurrency: this.config.batch.concurrency,
+        debug: this.config.debug
+      });
+      return texts.map((_, i) => results.get(`chunk-${i}`) ?? []);
+    }
+    throw new Error("Batch API not available for local embeddings");
+  }
+  /**
+   * Load embeddings from cache
+   */
+  loadEmbeddingCache(hashes) {
+    const result = /* @__PURE__ */ new Map();
+    if (!this.config.cache.enabled || hashes.length === 0) return result;
+    const placeholders = hashes.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT hash, embedding FROM ${EMBEDDING_CACHE_TABLE2}
+         WHERE provider = ? AND model = ? AND provider_key = ? AND hash IN (${placeholders})`
+    ).all(this.provider.id, this.provider.model, this.providerKey, ...hashes);
+    const now = Date.now();
+    for (const row of rows) {
+      result.set(row.hash, parseEmbedding(row.embedding));
+      this.db.prepare(
+        `UPDATE ${EMBEDDING_CACHE_TABLE2} SET updated_at = ?
+           WHERE provider = ? AND model = ? AND provider_key = ? AND hash = ?`
+      ).run(now, this.provider.id, this.provider.model, this.providerKey, row.hash);
+    }
+    return result;
+  }
+  /**
+   * Save embedding to cache
+   */
+  upsertEmbeddingCache(hash, embedding) {
+    if (!this.config.cache.enabled) return;
+    const now = Date.now();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO ${EMBEDDING_CACHE_TABLE2}
+         (provider, model, provider_key, hash, embedding, dims, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      this.provider.id,
+      this.provider.model,
+      this.providerKey,
+      hash,
+      JSON.stringify(embedding),
+      embedding.length,
+      now
+    );
+  }
+  /**
+   * Prune old cache entries if over limit
+   */
+  pruneEmbeddingCacheIfNeeded() {
+    if (!this.config.cache.enabled) return;
+    const row = this.db.prepare(`SELECT COUNT(*) as count FROM ${EMBEDDING_CACHE_TABLE2}`).get();
+    if (row.count <= this.config.cache.maxEntries) return;
+    const excess = row.count - this.config.cache.maxEntries;
+    this.db.prepare(
+      `DELETE FROM ${EMBEDDING_CACHE_TABLE2}
+         WHERE rowid IN (
+           SELECT rowid FROM ${EMBEDDING_CACHE_TABLE2}
+           ORDER BY updated_at ASC
+           LIMIT ?
+         )`
+    ).run(excess);
+  }
+};
+
+// src/core/searcher.ts
+var SNIPPET_MAX_CHARS2 = 700;
+var VECTOR_TABLE3 = "chunks_vec";
+var FTS_TABLE3 = "chunks_fts";
+var EMBEDDING_QUERY_TIMEOUT_REMOTE_MS2 = 6e4;
+var EMBEDDING_QUERY_TIMEOUT_LOCAL_MS2 = 5 * 6e4;
+var MemorySearcher = class {
+  db;
+  provider;
+  config;
+  // State from parent
+  vectorState;
+  ftsAvailable;
+  // Callback to ensure vector is ready
+  ensureVectorReadyFn;
+  constructor(db, provider, config, options) {
+    this.db = db;
+    this.provider = provider;
+    this.config = config;
+    this.vectorState = options?.vectorState ?? { available: false };
+    this.ftsAvailable = options?.ftsAvailable ?? false;
+    this.ensureVectorReadyFn = options?.ensureVectorReady;
+  }
+  /**
+   * Update vector/FTS availability (called by parent when extensions load)
+   */
+  setVectorState(state) {
+    this.vectorState = state;
+  }
+  setFtsAvailable(available) {
+    this.ftsAvailable = available;
+  }
+  /**
+   * Execute a search query
+   */
+  async search(query, opts) {
+    const cleaned = query.trim();
+    if (!cleaned) return [];
+    const minScore = opts?.minScore ?? this.config.query.minScore;
+    const maxResults = opts?.maxResults ?? this.config.query.maxResults;
+    const candidates = Math.min(
+      200,
+      Math.max(1, Math.floor(maxResults * this.config.hybrid.candidateMultiplier))
+    );
+    const sourceFilter = { sql: "", params: [] };
+    const keywordResults = this.config.hybrid.enabled && this.ftsAvailable ? await searchKeyword({
+      db: this.db,
+      ftsTable: FTS_TABLE3,
+      providerModel: this.provider.model,
+      query: cleaned,
+      limit: candidates,
+      snippetMaxChars: SNIPPET_MAX_CHARS2,
+      sourceFilter,
+      buildFtsQuery,
+      bm25RankToScore
+    }).catch(() => []) : [];
+    const queryVec = await this.embedQueryWithTimeout(cleaned);
+    const hasVector = queryVec.some((v) => v !== 0);
+    const vectorResults = hasVector ? await searchVector({
+      db: this.db,
+      vectorTable: VECTOR_TABLE3,
+      providerModel: this.provider.model,
+      queryVec,
+      limit: candidates,
+      snippetMaxChars: SNIPPET_MAX_CHARS2,
+      ensureVectorReady: (dims) => this.ensureVectorReady(dims),
+      sourceFilterVec: sourceFilter,
+      sourceFilterChunks: sourceFilter
+    }).catch(() => []) : [];
+    if (!this.config.hybrid.enabled) {
+      return vectorResults.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        score: r.score,
+        snippet: r.snippet
+      }));
+    }
+    const merged = mergeHybridResults({
+      vector: vectorResults.map((r) => ({
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        vectorScore: r.score
+      })),
+      keyword: keywordResults.map((r) => ({
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        textScore: r.textScore
+      })),
+      vectorWeight: this.config.hybrid.vectorWeight,
+      textWeight: this.config.hybrid.textWeight
+    });
+    return merged.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
+      path: r.path,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      score: r.score,
+      snippet: r.snippet
+    }));
+  }
+  /**
+   * Embed a query string with timeout
+   */
+  async embedQueryWithTimeout(text) {
+    const timeout = this.provider.id === "local" ? EMBEDDING_QUERY_TIMEOUT_LOCAL_MS2 : EMBEDDING_QUERY_TIMEOUT_REMOTE_MS2;
+    return Promise.race([
+      this.provider.embedQuery(text),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("embedding query timeout")), timeout)
+      )
+    ]);
+  }
+  /**
+   * Ensure vector extension is ready
+   */
+  async ensureVectorReady(dims) {
+    if (this.vectorState.available) return true;
+    if (this.ensureVectorReadyFn) {
+      return this.ensureVectorReadyFn(dims);
+    }
+    return false;
+  }
+};
 export {
+  KNOWLEDGE_GRAPH_TOOL,
+  KNOWLEDGE_PATH_TOOL,
+  KNOWLEDGE_SEARCH_TOOL,
+  MEMORY_GET_DETAILS_TOOL,
   MEMORY_SEARCH_TOOL,
   MEMORY_TOOLS,
   McpServer,
+  MemoryIndexer,
+  MemorySearcher,
   MemoryToolExecutor,
   Minimem,
   addFrontmatter,
   addSessionToContent,
-  bm25RankToScore,
   buildFileEntry,
-  buildFtsQuery,
+  buildKnowledgeFilterSql,
   chunkMarkdown,
   cosineSimilarity,
   createEmbeddingProvider,
@@ -2481,18 +3437,22 @@ export {
   createMcpServer,
   createOpenAiEmbeddingProvider,
   createToolExecutor,
+  extractChunkMetadata,
   extractSession,
   generateMcpConfig,
+  getLinksFrom,
+  getLinksTo,
+  getNeighbors,
+  getPathBetween,
   getToolDefinitions,
   hashText,
   isMemoryPath,
   listMemoryFiles,
-  mergeHybridResults,
-  normalizeRelPath,
   parseFrontmatter,
   runGeminiEmbeddingBatches,
   runMcpServer,
   runOpenAiEmbeddingBatches,
-  serializeFrontmatter
+  serializeFrontmatter,
+  stripPrivateContent
 };
 //# sourceMappingURL=index.js.map