minimem 0.0.6 → 0.1.0

package/dist/cli/chunk-BIYUNXYX.js

@@ -0,0 +1,2689 @@
+#!/usr/bin/env node
+
+// src/minimem.ts
+import { randomUUID } from "crypto";
+import fs2 from "fs/promises";
+import fsSync3 from "fs";
+import path3 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 logError(context, error, debug) {
+  if (!debug) return;
+  const message = error instanceof Error ? error.message : String(error);
+  debug(`[${context}] Error: ${message}`);
+}
+function ensureDir(dir, debug) {
+  try {
+    fsSync.mkdirSync(dir, { recursive: true });
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code !== "EEXIST") {
+      logError("ensureDir", error, debug);
+    }
+  }
+  return dir;
+}
+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");
+  const hasUpper = await exists(memoryFile);
+  const hasLower = await exists(altMemoryFile);
+  if (hasUpper && hasLower) {
+    let upperReal = memoryFile;
+    let lowerReal = altMemoryFile;
+    try {
+      upperReal = await fs.realpath(memoryFile);
+    } catch {
+    }
+    try {
+      lowerReal = await fs.realpath(altMemoryFile);
+    } catch {
+    }
+    if (upperReal !== lowerReal) {
+      throw new Error(
+        `Both MEMORY.md and memory.md exist in ${memoryDir}. Please remove one to avoid ambiguity.`
+      );
+    }
+    result.push(memoryFile);
+  } else if (hasUpper) {
+    result.push(memoryFile);
+  } else if (hasLower) {
+    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 stripPrivateContent(content) {
+  return content.replace(/<private>[\s\S]*?<\/private>/gi, (match) => {
+    const lineCount = match.split("\n").length;
+    return "\n".repeat(lineCount - 1);
+  });
+}
+function chunkMarkdown(content, chunking) {
+  const stripped = stripPrivateContent(content);
+  const lines = stripped.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 extractChunkMetadata(text) {
+  const typeMatch = text.match(/<!--\s*type:\s*([\w-]+)\s*-->/i);
+  return typeMatch ? { type: typeMatch[1].toLowerCase() } : {};
+}
+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);
+}
+function vectorToBlob(embedding) {
+  return Buffer.from(new Float32Array(embedding).buffer);
+}
+
+// src/search/hybrid.ts
+function buildFtsQuery(raw) {
+  const tokens = raw.match(/[A-Za-z0-9_]+/g)?.map((t) => t.trim()).filter(Boolean) ?? [];
+  if (tokens.length === 0) return null;
+  const quoted = tokens.map((t) => `"${t.replaceAll('"', "")}"`);
+  return quoted.join(" AND ");
+}
+function bm25RankToScore(rank) {
+  if (!Number.isFinite(rank)) {
+    return 0;
+  }
+  const absRank = Math.abs(rank);
+  return 1 / (1 + absRank);
+}
+function mergeHybridResults(params) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of params.vector) {
+    byId.set(r.id, {
+      id: r.id,
+      path: r.path,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      source: r.source,
+      snippet: r.snippet,
+      vectorScore: r.vectorScore,
+      textScore: 0
+    });
+  }
+  for (const r of params.keyword) {
+    const existing = byId.get(r.id);
+    if (existing) {
+      existing.textScore = r.textScore;
+      if (r.snippet && r.snippet.length > 0) existing.snippet = r.snippet;
+    } else {
+      byId.set(r.id, {
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        vectorScore: 0,
+        textScore: r.textScore
+      });
+    }
+  }
+  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 = vw * entry.vectorScore + tw * entry.textScore;
+    return {
+      path: entry.path,
+      startLine: entry.startLine,
+      endLine: entry.endLine,
+      score,
+      snippet: entry.snippet,
+      source: entry.source
+    };
+  });
+  return merged.sort((a, b) => b.score - a.score);
+}
+
+// src/search/search.ts
+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)) {
+    const rows = params.db.prepare(
+      `SELECT c.id, c.path, c.start_line, c.end_line, c.text,
+       c.source,
+       vec_distance_cosine(v.embedding, ?) AS dist
+  FROM ${params.vectorTable} v
+  JOIN chunks c ON c.id = v.id
+ WHERE c.model = ?${params.sourceFilterVec.sql}
+ ORDER BY dist ASC
+ LIMIT ?`
+    ).all(
+      vectorToBlob(params.queryVec),
+      params.providerModel,
+      ...params.sourceFilterVec.params,
+      params.limit
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      path: row.path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      score: 1 - row.dist,
+      snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
+      source: row.source
+    }));
+  }
+  const candidates = listChunks({
+    db: params.db,
+    providerModel: params.providerModel,
+    sourceFilter: params.sourceFilterChunks
+  });
+  const scored = candidates.map((chunk) => ({
+    chunk,
+    score: cosineSimilarity(params.queryVec, chunk.embedding)
+  })).filter((entry) => Number.isFinite(entry.score));
+  return scored.sort((a, b) => b.score - a.score).slice(0, params.limit).map((entry) => ({
+    id: entry.chunk.id,
+    path: entry.chunk.path,
+    startLine: entry.chunk.startLine,
+    endLine: entry.chunk.endLine,
+    score: entry.score,
+    snippet: truncateUtf16Safe(entry.chunk.text, params.snippetMaxChars),
+    source: entry.chunk.source
+  }));
+}
+function listChunks(params) {
+  const rows = params.db.prepare(
+    `SELECT id, path, start_line, end_line, text, embedding, source
+  FROM chunks
+ WHERE model = ?${params.sourceFilter.sql}`
+  ).all(params.providerModel, ...params.sourceFilter.params);
+  return rows.map((row) => ({
+    id: row.id,
+    path: row.path,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    text: row.text,
+    embedding: parseEmbedding(row.embedding),
+    source: row.source
+  }));
+}
+async function searchKeyword(params) {
+  if (params.limit <= 0) return [];
+  const ftsQuery = params.buildFtsQuery(params.query);
+  if (!ftsQuery) return [];
+  const rows = params.db.prepare(
+    `SELECT id, path, source, start_line, end_line, text,
+       bm25(${params.ftsTable}) AS rank
+  FROM ${params.ftsTable}
+ WHERE ${params.ftsTable} MATCH ? AND model = ?${params.sourceFilter.sql}
+ ORDER BY rank ASC
+ LIMIT ?`
+  ).all(ftsQuery, params.providerModel, ...params.sourceFilter.params, params.limit);
+  return rows.map((row) => {
+    const textScore = params.bm25RankToScore(row.rank);
+    return {
+      id: row.id,
+      path: row.path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      score: textScore,
+      textScore,
+      snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
+      source: row.source
+    };
+  });
+}
+
+// src/db/schema.ts
+var SCHEMA_VERSION = 4;
+function ensureMemoryIndexSchema(params) {
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  const migrated = migrateIfNeeded(params.db, params.ftsTable);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS files (
+      path TEXT PRIMARY KEY,
+      source TEXT NOT NULL DEFAULT 'memory',
+      hash TEXT NOT NULL,
+      mtime INTEGER NOT NULL,
+      size INTEGER NOT NULL
+    );
+  `);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      path TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'memory',
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      hash TEXT NOT NULL,
+      model TEXT NOT NULL,
+      text TEXT NOT NULL,
+      embedding TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS ${params.embeddingCacheTable} (
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      provider_key TEXT NOT NULL,
+      hash TEXT NOT NULL,
+      embedding TEXT NOT NULL,
+      dims INTEGER,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (provider, model, provider_key, hash)
+    );
+  `);
+  params.db.exec(
+    `CREATE INDEX IF NOT EXISTS idx_embedding_cache_updated_at ON ${params.embeddingCacheTable}(updated_at);`
+  );
+  let ftsAvailable = false;
+  let ftsError;
+  if (params.ftsEnabled) {
+    try {
+      params.db.exec(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${params.ftsTable} USING fts5(
+  text,
+  id UNINDEXED,
+  path UNINDEXED,
+  source UNINDEXED,
+  model UNINDEXED,
+  start_line UNINDEXED,
+  end_line UNINDEXED
+);`
+      );
+      ftsAvailable = true;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      ftsAvailable = false;
+      ftsError = message;
+    }
+  }
+  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);`);
+  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();
+  if (rows.some((row) => row.name === column)) return;
+  db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}
+
+// src/session.ts
+import * as os 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 lines = yaml.split("\n");
+  return parseYamlBlock(lines, 0, 0, lines.length).value;
+}
+function parseYamlBlock(lines, indent, startIdx, endIdx) {
+  const result = {};
+  let i = startIdx;
+  while (i < endIdx) {
+    const line = lines[i];
+    if (!line || !line.trim()) {
+      i++;
+      continue;
+    }
+    const lineIndent = getIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) {
+      i++;
+      continue;
+    }
+    const keyMatch = line.match(/^(\s*)([\w-]+):\s*(.*)?$/);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const [, , key, rawValue] = keyMatch;
+    const value = rawValue?.trim() ?? "";
+    if (value === "" || value === void 0) {
+      const nextNonEmpty = findNextNonEmptyLine(lines, i + 1, endIdx);
+      if (nextNonEmpty < endIdx) {
+        const nextLine = lines[nextNonEmpty];
+        const nextIndent = getIndent(nextLine);
+        if (nextIndent > indent) {
+          if (nextLine.trimStart().startsWith("- ")) {
+            const listResult = parseYamlList(lines, nextIndent, i + 1, endIdx);
+            result[key] = listResult.value;
+            i = listResult.nextIdx;
+          } else {
+            const blockResult = parseYamlBlock(lines, nextIndent, i + 1, endIdx);
+            result[key] = blockResult.value;
+            i = blockResult.nextIdx;
+          }
+          continue;
+        }
+      }
+      result[key] = null;
+      i++;
+    } else {
+      result[key] = parseYamlValue(value);
+      i++;
+    }
+  }
+  return { value: result, nextIdx: i };
+}
+function parseYamlList(lines, indent, startIdx, endIdx) {
+  const result = [];
+  let i = startIdx;
+  while (i < endIdx) {
+    const line = lines[i];
+    if (!line || !line.trim()) {
+      i++;
+      continue;
+    }
+    const lineIndent = getIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) {
+      i++;
+      continue;
+    }
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith("- ")) break;
+    const itemContent = trimmed.slice(2).trim();
+    if (itemContent === "" || itemContent === void 0) {
+      const nextNonEmpty = findNextNonEmptyLine(lines, i + 1, endIdx);
+      if (nextNonEmpty < endIdx) {
+        const nextIndent = getIndent(lines[nextNonEmpty]);
+        if (nextIndent > indent) {
+          const blockResult = parseYamlBlock(lines, nextIndent, i + 1, endIdx);
+          result.push(blockResult.value);
+          i = blockResult.nextIdx;
+          continue;
+        }
+      }
+      result.push(null);
+      i++;
+    } else {
+      const kvMatch = itemContent.match(/^([\w-]+):\s*(.*)$/);
+      if (kvMatch) {
+        const obj = {};
+        const [, firstKey, firstVal] = kvMatch;
+        obj[firstKey] = parseYamlValue(firstVal?.trim() ?? "");
+        const itemKeyIndent = indent + 2;
+        let j = i + 1;
+        while (j < endIdx) {
+          const nextLine = lines[j];
+          if (!nextLine || !nextLine.trim()) {
+            j++;
+            continue;
+          }
+          const nextLineIndent = getIndent(nextLine);
+          if (nextLineIndent < itemKeyIndent) break;
+          if (nextLineIndent === itemKeyIndent) {
+            const nextKv = nextLine.match(/^\s*([\w-]+):\s*(.*)$/);
+            if (nextKv) {
+              const [, nk, nv] = nextKv;
+              obj[nk] = parseYamlValue(nv?.trim() ?? "");
+              j++;
+              continue;
+            }
+          }
+          break;
+        }
+        result.push(obj);
+        i = j;
+      } else {
+        result.push(parseYamlValue(itemContent));
+        i++;
+      }
+    }
+  }
+  return { value: result, nextIdx: i };
+}
+function getIndent(line) {
+  const match = line.match(/^(\s*)/);
+  return match ? match[1].length : 0;
+}
+function findNextNonEmptyLine(lines, from, end) {
+  for (let i = from; i < end; i++) {
+    if (lines[i]?.trim()) return i;
+  }
+  return end;
+}
+function parseYamlValue(value) {
+  if (value === "") return null;
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "null" || value === "~") return null;
+  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);
+    if (inner.trim() === "") return [];
+    return inner.split(",").map((s) => parseYamlValue(s.trim()));
+  }
+  return value;
+}
+function serializeFrontmatter(frontmatter) {
+  const lines = ["---"];
+  if (frontmatter.id) {
+    lines.push(`id: ${frontmatter.id}`);
+  }
+  if (frontmatter.type) {
+    lines.push(`type: ${frontmatter.type}`);
+  }
+  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(", ")}]`);
+  }
+  if (frontmatter.domain && frontmatter.domain.length > 0) {
+    lines.push(`domain: [${frontmatter.domain.join(", ")}]`);
+  }
+  if (frontmatter.entities && frontmatter.entities.length > 0) {
+    lines.push(`entities: [${frontmatter.entities.join(", ")}]`);
+  }
+  if (frontmatter.confidence !== void 0) {
+    lines.push(`confidence: ${frontmatter.confidence}`);
+  }
+  if (frontmatter.source) {
+    lines.push("source:");
+    if (frontmatter.source.origin) lines.push(`  origin: ${frontmatter.source.origin}`);
+    if (frontmatter.source.trajectories && frontmatter.source.trajectories.length > 0) {
+      lines.push(`  trajectories: [${frontmatter.source.trajectories.join(", ")}]`);
+    }
+    if (frontmatter.source.agentId) lines.push(`  agentId: ${frontmatter.source.agentId}`);
+  }
+  if (frontmatter.links && frontmatter.links.length > 0) {
+    lines.push("links:");
+    for (const link of frontmatter.links) {
+      lines.push(`  - target: ${link.target}`);
+      lines.push(`    relation: ${link.relation}`);
+      if (link.layer) lines.push(`    layer: ${link.layer}`);
+    }
+  }
+  if (frontmatter.supersedes !== void 0) {
+    lines.push(`supersedes: ${frontmatter.supersedes === null ? "~" : frontmatter.supersedes}`);
+  }
+  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
+    }
+  };
+  if (!merged.created) {
+    merged.created = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  merged.updated = (/* @__PURE__ */ new Date()).toISOString();
+  return serializeFrontmatter(merged) + body;
+}
+function formatPath(filePath) {
+  const home = os.homedir();
+  if (filePath.startsWith(home)) {
+    return "~" + filePath.slice(home.length);
+  }
+  return filePath;
+}
+
+// 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 {
+    const sqliteVec = await import("sqlite-vec");
+    const resolvedPath = params.extensionPath?.trim() ? params.extensionPath.trim() : void 0;
+    const extensionPath = resolvedPath ?? sqliteVec.getLoadablePath();
+    params.db.enableLoadExtension(true);
+    if (resolvedPath) {
+      params.db.loadExtension(extensionPath);
+    } else {
+      sqliteVec.load(params.db);
+    }
+    return { ok: true, extensionPath };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+
+// src/embeddings/embeddings.ts
+import fsSync2 from "fs";
+import path2 from "path";
+import os2 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";
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
+var DEFAULT_GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+function createNoOpEmbeddingProvider() {
+  return {
+    id: "none",
+    model: "bm25-only",
+    embedQuery: async () => [],
+    embedBatch: async (texts) => texts.map(() => [])
+  };
+}
+function resolveUserPath(filePath) {
+  if (filePath.startsWith("~/")) {
+    return path2.join(os2.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+function canAutoSelectLocal(options) {
+  const modelPath = options.local?.modelPath?.trim();
+  if (!modelPath) return false;
+  if (/^(hf:|https?:)/i.test(modelPath)) return false;
+  const resolved = resolveUserPath(modelPath);
+  try {
+    return fsSync2.statSync(resolved).isFile();
+  } catch {
+    return false;
+  }
+}
+function isMissingApiKeyError(err) {
+  const message = formatError(err);
+  return message.includes("API key") || message.includes("apiKey");
+}
+async function importNodeLlamaCpp() {
+  const llama = await import("node-llama-cpp");
+  return llama;
+}
+async function createLocalEmbeddingProvider(options) {
+  const modelPath = options.local?.modelPath?.trim() || DEFAULT_LOCAL_MODEL;
+  const modelCacheDir = options.local?.modelCacheDir?.trim();
+  const { getLlama, resolveModelFile, LlamaLogLevel } = await importNodeLlamaCpp();
+  let llama = null;
+  let embeddingModel = null;
+  let embeddingContext = null;
+  const ensureContext = async () => {
+    if (!llama) {
+      llama = await getLlama({ logLevel: LlamaLogLevel.error });
+    }
+    if (!embeddingModel) {
+      const resolved = await resolveModelFile(modelPath, modelCacheDir || void 0);
+      embeddingModel = await llama.loadModel({ modelPath: resolved });
+    }
+    if (!embeddingContext) {
+      embeddingContext = await embeddingModel.createEmbeddingContext();
+    }
+    return embeddingContext;
+  };
+  return {
+    id: "local",
+    model: modelPath,
+    embedQuery: async (text) => {
+      const ctx = await ensureContext();
+      const embedding = await ctx.getEmbeddingFor(text);
+      return Array.from(embedding.vector);
+    },
+    embedBatch: async (texts) => {
+      const ctx = await ensureContext();
+      const embeddings = await Promise.all(
+        texts.map(async (text) => {
+          const embedding = await ctx.getEmbeddingFor(text);
+          return Array.from(embedding.vector);
+        })
+      );
+      return embeddings;
+    }
+  };
+}
+function normalizeOpenAiModel(model) {
+  const trimmed = model.trim();
+  if (!trimmed) return DEFAULT_OPENAI_EMBEDDING_MODEL;
+  if (trimmed.startsWith("openai/")) return trimmed.slice("openai/".length);
+  return trimmed;
+}
+function resolveOpenAiApiKey(options) {
+  const apiKey = options.openai?.apiKey?.trim();
+  if (apiKey) return apiKey;
+  const envKey = process.env.OPENAI_API_KEY?.trim();
+  if (envKey) return envKey;
+  throw new Error("OpenAI API key not found. Set OPENAI_API_KEY env var or pass openai.apiKey option.");
+}
+async function createOpenAiEmbeddingProvider(options) {
+  const apiKey = resolveOpenAiApiKey(options);
+  const baseUrl = options.openai?.baseUrl?.trim() || DEFAULT_OPENAI_BASE_URL;
+  const headerOverrides = options.openai?.headers ?? {};
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+    ...headerOverrides
+  };
+  const model = normalizeOpenAiModel(options.model || "");
+  const client = { baseUrl, headers, model };
+  const url = `${baseUrl.replace(/\/$/, "")}/embeddings`;
+  const embed = async (input) => {
+    if (input.length === 0) return [];
+    const res = await fetch(url, {
+      method: "POST",
+      headers: client.headers,
+      body: JSON.stringify({ model: client.model, input })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`openai embeddings failed: ${res.status} ${text}`);
+    }
+    const payload = await res.json();
+    const data = payload.data ?? [];
+    return data.map((entry) => entry.embedding ?? []);
+  };
+  return {
+    provider: {
+      id: "openai",
+      model: client.model,
+      embedQuery: async (text) => {
+        const [vec] = await embed([text]);
+        return vec ?? [];
+      },
+      embedBatch: embed
+    },
+    client
+  };
+}
+function normalizeGeminiModel(model) {
+  const trimmed = model.trim();
+  if (!trimmed) return DEFAULT_GEMINI_EMBEDDING_MODEL;
+  const withoutPrefix = trimmed.replace(/^models\//, "");
+  if (withoutPrefix.startsWith("gemini/")) return withoutPrefix.slice("gemini/".length);
+  if (withoutPrefix.startsWith("google/")) return withoutPrefix.slice("google/".length);
+  return withoutPrefix;
+}
+function normalizeGeminiBaseUrl(raw) {
+  const trimmed = raw.replace(/\/+$/, "");
+  const openAiIndex = trimmed.indexOf("/openai");
+  if (openAiIndex > -1) return trimmed.slice(0, openAiIndex);
+  return trimmed;
+}
+function buildGeminiModelPath(model) {
+  return model.startsWith("models/") ? model : `models/${model}`;
+}
+function resolveGeminiApiKey(options) {
+  const apiKey = options.gemini?.apiKey?.trim();
+  if (apiKey) return apiKey;
+  const googleKey = process.env.GOOGLE_API_KEY?.trim();
+  if (googleKey) return googleKey;
+  const geminiKey = process.env.GEMINI_API_KEY?.trim();
+  if (geminiKey) return geminiKey;
+  throw new Error("Gemini API key not found. Set GOOGLE_API_KEY or GEMINI_API_KEY env var or pass gemini.apiKey option.");
+}
+async function createGeminiEmbeddingProvider(options) {
+  const apiKey = resolveGeminiApiKey(options);
+  const rawBaseUrl = options.gemini?.baseUrl?.trim() || DEFAULT_GEMINI_BASE_URL;
+  const baseUrl = normalizeGeminiBaseUrl(rawBaseUrl);
+  const headerOverrides = options.gemini?.headers ?? {};
+  const headers = {
+    "Content-Type": "application/json",
+    "x-goog-api-key": apiKey,
+    ...headerOverrides
+  };
+  const model = normalizeGeminiModel(options.model || "");
+  const modelPath = buildGeminiModelPath(model);
+  const client = { baseUrl, headers, model, modelPath };
+  const embedUrl = `${baseUrl}/${modelPath}:embedContent`;
+  const batchUrl = `${baseUrl}/${modelPath}:batchEmbedContents`;
+  const embedQuery = async (text) => {
+    if (!text.trim()) return [];
+    const res = await fetch(embedUrl, {
+      method: "POST",
+      headers: client.headers,
+      body: JSON.stringify({
+        content: { parts: [{ text }] },
+        taskType: "RETRIEVAL_QUERY"
+      })
+    });
+    if (!res.ok) {
+      const payload2 = await res.text();
+      throw new Error(`gemini embeddings failed: ${res.status} ${payload2}`);
+    }
+    const payload = await res.json();
+    return payload.embedding?.values ?? [];
+  };
+  const embedBatch = async (texts) => {
+    if (texts.length === 0) return [];
+    const requests = texts.map((text) => ({
+      model: modelPath,
+      content: { parts: [{ text }] },
+      taskType: "RETRIEVAL_DOCUMENT"
+    }));
+    const res = await fetch(batchUrl, {
+      method: "POST",
+      headers: client.headers,
+      body: JSON.stringify({ requests })
+    });
+    if (!res.ok) {
+      const payload2 = await res.text();
+      throw new Error(`gemini embeddings failed: ${res.status} ${payload2}`);
+    }
+    const payload = await res.json();
+    const embeddings = Array.isArray(payload.embeddings) ? payload.embeddings : [];
+    return texts.map((_, index) => embeddings[index]?.values ?? []);
+  };
+  return {
+    provider: {
+      id: "gemini",
+      model: client.model,
+      embedQuery,
+      embedBatch
+    },
+    client
+  };
+}
+async function createEmbeddingProvider(options) {
+  const requestedProvider = options.provider;
+  const fallback = options.fallback ?? "none";
+  if (requestedProvider === "none") {
+    return {
+      provider: createNoOpEmbeddingProvider(),
+      requestedProvider: "none"
+    };
+  }
+  const createProvider = async (id) => {
+    if (id === "local") {
+      const provider2 = await createLocalEmbeddingProvider(options);
+      return { provider: provider2 };
+    }
+    if (id === "gemini") {
+      const { provider: provider2, client: client2 } = await createGeminiEmbeddingProvider(options);
+      return { provider: provider2, gemini: client2 };
+    }
+    const { provider, client } = await createOpenAiEmbeddingProvider(options);
+    return { provider, openAi: client };
+  };
+  const formatPrimaryError = (err, provider) => provider === "local" ? formatLocalSetupError(err) : formatError(err);
+  if (requestedProvider === "auto") {
+    const missingKeyErrors = [];
+    let localError = null;
+    if (canAutoSelectLocal(options)) {
+      try {
+        const local = await createProvider("local");
+        return { ...local, requestedProvider };
+      } catch (err) {
+        localError = formatLocalSetupError(err);
+      }
+    }
+    for (const provider of ["openai", "gemini"]) {
+      try {
+        const result = await createProvider(provider);
+        return { ...result, requestedProvider };
+      } catch (err) {
+        const message = formatPrimaryError(err, provider);
+        if (isMissingApiKeyError(err)) {
+          missingKeyErrors.push(message);
+          continue;
+        }
+        throw new Error(message);
+      }
+    }
+    return {
+      provider: createNoOpEmbeddingProvider(),
+      requestedProvider,
+      fallbackFrom: "auto",
+      fallbackReason: "No embedding API available. Using BM25 full-text search only."
+    };
+  }
+  try {
+    const primary = await createProvider(requestedProvider);
+    return { ...primary, requestedProvider };
+  } catch (primaryErr) {
+    const reason = formatPrimaryError(primaryErr, requestedProvider);
+    if (fallback && fallback !== "none" && fallback !== requestedProvider) {
+      try {
+        const fallbackResult = await createProvider(fallback);
+        return {
+          ...fallbackResult,
+          requestedProvider,
+          fallbackFrom: requestedProvider,
+          fallbackReason: reason
+        };
+      } catch (fallbackErr) {
+        throw new Error(`${reason}
+
+Fallback to ${fallback} failed: ${formatError(fallbackErr)}`);
+      }
+    }
+    throw new Error(reason);
+  }
+}
+function formatError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function isNodeLlamaCppMissing(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  if (code === "ERR_MODULE_NOT_FOUND") {
+    return err.message.includes("node-llama-cpp");
+  }
+  return false;
+}
+function formatLocalSetupError(err) {
+  const detail = formatError(err);
+  const missing = isNodeLlamaCppMissing(err);
+  return [
+    "Local embeddings unavailable.",
+    missing ? "Reason: optional dependency node-llama-cpp is missing (or failed to install)." : detail ? `Reason: ${detail}` : void 0,
+    missing && detail ? `Detail: ${detail}` : null,
+    "To enable local embeddings:",
+    "1) Use Node 22 LTS (recommended for installs/updates)",
+    missing ? "2) Install node-llama-cpp: npm install node-llama-cpp" : null,
+    "3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
+    'Or set provider = "openai" or "gemini" (remote).'
+  ].filter(Boolean).join("\n");
+}
+
+// src/embeddings/batch-openai.ts
+var OPENAI_BATCH_ENDPOINT = "/v1/embeddings";
+var OPENAI_BATCH_COMPLETION_WINDOW = "24h";
+var OPENAI_BATCH_MAX_REQUESTS = 5e4;
+function getOpenAiBaseUrl(openAi) {
+  return openAi.baseUrl?.replace(/\/$/, "") ?? "";
+}
+function getOpenAiHeaders(openAi, params) {
+  const headers = openAi.headers ? { ...openAi.headers } : {};
+  if (params.json) {
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+  } else {
+    delete headers["Content-Type"];
+    delete headers["content-type"];
+  }
+  return headers;
+}
+function splitOpenAiBatchRequests(requests) {
+  if (requests.length <= OPENAI_BATCH_MAX_REQUESTS) return [requests];
+  const groups = [];
+  for (let i = 0; i < requests.length; i += OPENAI_BATCH_MAX_REQUESTS) {
+    groups.push(requests.slice(i, i + OPENAI_BATCH_MAX_REQUESTS));
+  }
+  return groups;
+}
+async function retryAsync(fn, opts) {
+  let lastError;
+  for (let attempt = 0; attempt < opts.attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!opts.shouldRetry(err) || attempt === opts.attempts - 1) {
+        throw err;
+      }
+      const delay = Math.min(
+        opts.maxDelayMs,
+        opts.minDelayMs * Math.pow(2, attempt) * (1 + Math.random() * opts.jitter)
+      );
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+async function submitOpenAiBatch(params) {
+  const baseUrl = getOpenAiBaseUrl(params.openAi);
+  const jsonl = params.requests.map((request) => JSON.stringify(request)).join("\n");
+  const form = new FormData();
+  form.append("purpose", "batch");
+  form.append(
+    "file",
+    new Blob([jsonl], { type: "application/jsonl" }),
+    `memory-embeddings.${hashText(String(Date.now()))}.jsonl`
+  );
+  const fileRes = await fetch(`${baseUrl}/files`, {
+    method: "POST",
+    headers: getOpenAiHeaders(params.openAi, { json: false }),
+    body: form
+  });
+  if (!fileRes.ok) {
+    const text = await fileRes.text();
+    throw new Error(`openai batch file upload failed: ${fileRes.status} ${text}`);
+  }
+  const filePayload = await fileRes.json();
+  if (!filePayload.id) {
+    throw new Error("openai batch file upload failed: missing file id");
+  }
+  const batchRes = await retryAsync(
+    async () => {
+      const res = await fetch(`${baseUrl}/batches`, {
+        method: "POST",
+        headers: getOpenAiHeaders(params.openAi, { json: true }),
+        body: JSON.stringify({
+          input_file_id: filePayload.id,
+          endpoint: OPENAI_BATCH_ENDPOINT,
+          completion_window: OPENAI_BATCH_COMPLETION_WINDOW,
+          metadata: {
+            source: params.source
+          }
+        })
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        const err = new Error(`openai batch create failed: ${res.status} ${text}`);
+        err.status = res.status;
+        throw err;
+      }
+      return res;
+    },
+    {
+      attempts: 3,
+      minDelayMs: 300,
+      maxDelayMs: 2e3,
+      jitter: 0.2,
+      shouldRetry: (err) => {
+        const status = err.status;
+        return status === 429 || typeof status === "number" && status >= 500;
+      }
+    }
+  );
+  return await batchRes.json();
+}
+async function fetchOpenAiBatchStatus(params) {
+  const baseUrl = getOpenAiBaseUrl(params.openAi);
+  const res = await fetch(`${baseUrl}/batches/${params.batchId}`, {
+    headers: getOpenAiHeaders(params.openAi, { json: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`openai batch status failed: ${res.status} ${text}`);
+  }
+  return await res.json();
+}
+async function fetchOpenAiFileContent(params) {
+  const baseUrl = getOpenAiBaseUrl(params.openAi);
+  const res = await fetch(`${baseUrl}/files/${params.fileId}/content`, {
+    headers: getOpenAiHeaders(params.openAi, { json: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`openai batch file content failed: ${res.status} ${text}`);
+  }
+  return await res.text();
+}
+function parseOpenAiBatchOutput(text) {
+  if (!text.trim()) return [];
+  return text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function readOpenAiBatchError(params) {
+  try {
+    const content = await fetchOpenAiFileContent({
+      openAi: params.openAi,
+      fileId: params.errorFileId
+    });
+    const lines = parseOpenAiBatchOutput(content);
+    const first = lines.find((line) => line.error?.message || line.response?.body?.error);
+    const message = first?.error?.message ?? (typeof first?.response?.body?.error?.message === "string" ? first?.response?.body?.error?.message : void 0);
+    return message;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message ? `error file unavailable: ${message}` : void 0;
+  }
+}
+async function waitForOpenAiBatch(params) {
+  const start = Date.now();
+  let current = params.initial;
+  while (true) {
+    const status = current ?? await fetchOpenAiBatchStatus({
+      openAi: params.openAi,
+      batchId: params.batchId
+    });
+    const state = status.status ?? "unknown";
+    if (state === "completed") {
+      if (!status.output_file_id) {
+        throw new Error(`openai batch ${params.batchId} completed without output file`);
+      }
+      return {
+        outputFileId: status.output_file_id,
+        errorFileId: status.error_file_id ?? void 0
+      };
+    }
+    if (["failed", "expired", "cancelled", "canceled"].includes(state)) {
+      const detail = status.error_file_id ? await readOpenAiBatchError({ openAi: params.openAi, errorFileId: status.error_file_id }) : void 0;
+      const suffix = detail ? `: ${detail}` : "";
+      throw new Error(`openai batch ${params.batchId} ${state}${suffix}`);
+    }
+    if (!params.wait) {
+      throw new Error(`openai batch ${params.batchId} still ${state}; wait disabled`);
+    }
+    if (Date.now() - start > params.timeoutMs) {
+      throw new Error(`openai batch ${params.batchId} timed out after ${params.timeoutMs}ms`);
+    }
+    params.debug?.(`openai batch ${params.batchId} ${state}; waiting ${params.pollIntervalMs}ms`);
+    await new Promise((resolve) => setTimeout(resolve, params.pollIntervalMs));
+    current = void 0;
+  }
+}
+async function runWithConcurrency(tasks, limit) {
+  if (tasks.length === 0) return [];
+  const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+  const results = Array.from({ length: tasks.length });
+  let next = 0;
+  let firstError = null;
+  const workers = Array.from({ length: resolvedLimit }, async () => {
+    while (true) {
+      if (firstError) return;
+      const index = next;
+      next += 1;
+      if (index >= tasks.length) return;
+      try {
+        results[index] = await tasks[index]();
+      } catch (err) {
+        firstError = err;
+        return;
+      }
+    }
+  });
+  await Promise.allSettled(workers);
+  if (firstError) throw firstError;
+  return results;
+}
+async function runOpenAiEmbeddingBatches(params) {
+  if (params.requests.length === 0) return /* @__PURE__ */ new Map();
+  const groups = splitOpenAiBatchRequests(params.requests);
+  const byCustomId = /* @__PURE__ */ new Map();
+  const tasks = groups.map((group, groupIndex) => async () => {
+    const batchInfo = await submitOpenAiBatch({
+      openAi: params.openAi,
+      requests: group,
+      source: params.source
+    });
+    if (!batchInfo.id) {
+      throw new Error("openai batch create failed: missing batch id");
+    }
+    params.debug?.("memory embeddings: openai batch created", {
+      batchId: batchInfo.id,
+      status: batchInfo.status,
+      group: groupIndex + 1,
+      groups: groups.length,
+      requests: group.length
+    });
+    if (!params.wait && batchInfo.status !== "completed") {
+      throw new Error(
+        `openai batch ${batchInfo.id} submitted; enable batch.wait to await completion`
+      );
+    }
+    const completed = batchInfo.status === "completed" ? {
+      outputFileId: batchInfo.output_file_id ?? "",
+      errorFileId: batchInfo.error_file_id ?? void 0
+    } : await waitForOpenAiBatch({
+      openAi: params.openAi,
+      batchId: batchInfo.id,
+      wait: params.wait,
+      pollIntervalMs: params.pollIntervalMs,
+      timeoutMs: params.timeoutMs,
+      debug: params.debug,
+      initial: batchInfo
+    });
+    if (!completed.outputFileId) {
+      throw new Error(`openai batch ${batchInfo.id} completed without output file`);
+    }
+    const content = await fetchOpenAiFileContent({
+      openAi: params.openAi,
+      fileId: completed.outputFileId
+    });
+    const outputLines = parseOpenAiBatchOutput(content);
+    const errors = [];
+    const remaining = new Set(group.map((request) => request.custom_id));
+    for (const line of outputLines) {
+      const customId = line.custom_id;
+      if (!customId) continue;
+      remaining.delete(customId);
+      if (line.error?.message) {
+        errors.push(`${customId}: ${line.error.message}`);
+        continue;
+      }
+      const response = line.response;
+      const statusCode = response?.status_code ?? 0;
+      if (statusCode >= 400) {
+        const message = response?.body?.error?.message ?? (typeof response?.body === "string" ? response.body : void 0) ?? "unknown error";
+        errors.push(`${customId}: ${message}`);
+        continue;
+      }
+      const data = response?.body?.data ?? [];
+      const embedding = data[0]?.embedding ?? [];
+      if (embedding.length === 0) {
+        errors.push(`${customId}: empty embedding`);
+        continue;
+      }
+      byCustomId.set(customId, embedding);
+    }
+    if (errors.length > 0) {
+      throw new Error(`openai batch ${batchInfo.id} failed: ${errors.join("; ")}`);
+    }
+    if (remaining.size > 0) {
+      throw new Error(`openai batch ${batchInfo.id} missing ${remaining.size} embedding responses`);
+    }
+  });
+  params.debug?.("memory embeddings: openai batch submit", {
+    requests: params.requests.length,
+    groups: groups.length,
+    wait: params.wait,
+    concurrency: params.concurrency,
+    pollIntervalMs: params.pollIntervalMs,
+    timeoutMs: params.timeoutMs
+  });
+  await runWithConcurrency(tasks, params.concurrency);
+  return byCustomId;
+}
+
+// src/embeddings/batch-gemini.ts
+var GEMINI_BATCH_MAX_REQUESTS = 5e4;
+function getGeminiBaseUrl(gemini) {
+  return gemini.baseUrl?.replace(/\/$/, "") ?? "";
+}
+function getGeminiHeaders(gemini, params) {
+  const headers = gemini.headers ? { ...gemini.headers } : {};
+  if (params.json) {
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+  } else {
+    delete headers["Content-Type"];
+    delete headers["content-type"];
+  }
+  return headers;
+}
+function getGeminiUploadUrl(baseUrl) {
+  if (baseUrl.includes("/v1beta")) {
+    return baseUrl.replace(/\/v1beta\/?$/, "/upload/v1beta");
+  }
+  return `${baseUrl.replace(/\/$/, "")}/upload`;
+}
+function splitGeminiBatchRequests(requests) {
+  if (requests.length <= GEMINI_BATCH_MAX_REQUESTS) return [requests];
+  const groups = [];
+  for (let i = 0; i < requests.length; i += GEMINI_BATCH_MAX_REQUESTS) {
+    groups.push(requests.slice(i, i + GEMINI_BATCH_MAX_REQUESTS));
+  }
+  return groups;
+}
+function buildGeminiUploadBody(params) {
+  const boundary = `minimem-${hashText(params.displayName)}`;
+  const jsonPart = JSON.stringify({
+    file: {
+      displayName: params.displayName,
+      mimeType: "application/jsonl"
+    }
+  });
+  const delimiter = `--${boundary}\r
+`;
+  const closeDelimiter = `--${boundary}--\r
+`;
+  const parts = [
+    `${delimiter}Content-Type: application/json; charset=UTF-8\r
+\r
+${jsonPart}\r
+`,
+    `${delimiter}Content-Type: application/jsonl; charset=UTF-8\r
+\r
+${params.jsonl}\r
+`,
+    closeDelimiter
+  ];
+  const body = new Blob([parts.join("")], { type: "multipart/related" });
+  return {
+    body,
+    contentType: `multipart/related; boundary=${boundary}`
+  };
+}
+async function submitGeminiBatch(params) {
+  const baseUrl = getGeminiBaseUrl(params.gemini);
+  const jsonl = params.requests.map(
+    (request) => JSON.stringify({
+      key: request.custom_id,
+      request: {
+        content: request.content,
+        task_type: request.taskType
+      }
+    })
+  ).join("\n");
+  const displayName = `memory-embeddings-${hashText(String(Date.now()))}`;
+  const uploadPayload = buildGeminiUploadBody({ jsonl, displayName });
+  const uploadUrl = `${getGeminiUploadUrl(baseUrl)}/files?uploadType=multipart`;
+  const fileRes = await fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      ...getGeminiHeaders(params.gemini, { json: false }),
+      "Content-Type": uploadPayload.contentType
+    },
+    body: uploadPayload.body
+  });
+  if (!fileRes.ok) {
+    const text2 = await fileRes.text();
+    throw new Error(`gemini batch file upload failed: ${fileRes.status} ${text2}`);
+  }
+  const filePayload = await fileRes.json();
+  const fileId = filePayload.name ?? filePayload.file?.name;
+  if (!fileId) {
+    throw new Error("gemini batch file upload failed: missing file id");
+  }
+  const batchBody = {
+    batch: {
+      displayName: `memory-embeddings-${params.source}`,
+      inputConfig: {
+        file_name: fileId
+      }
+    }
+  };
+  const batchEndpoint = `${baseUrl}/${params.gemini.modelPath}:asyncBatchEmbedContent`;
+  const batchRes = await fetch(batchEndpoint, {
+    method: "POST",
+    headers: getGeminiHeaders(params.gemini, { json: true }),
+    body: JSON.stringify(batchBody)
+  });
+  if (batchRes.ok) {
+    return await batchRes.json();
+  }
+  const text = await batchRes.text();
+  if (batchRes.status === 404) {
+    throw new Error(
+      "gemini batch create failed: 404 (asyncBatchEmbedContent not available for this model/baseUrl). Disable batch.enabled or switch providers."
+    );
+  }
+  throw new Error(`gemini batch create failed: ${batchRes.status} ${text}`);
+}
+async function fetchGeminiBatchStatus(params) {
+  const baseUrl = getGeminiBaseUrl(params.gemini);
+  const name = params.batchName.startsWith("batches/") ? params.batchName : `batches/${params.batchName}`;
+  const statusUrl = `${baseUrl}/${name}`;
+  const res = await fetch(statusUrl, {
+    headers: getGeminiHeaders(params.gemini, { json: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`gemini batch status failed: ${res.status} ${text}`);
+  }
+  return await res.json();
+}
+async function fetchGeminiFileContent(params) {
+  const baseUrl = getGeminiBaseUrl(params.gemini);
+  const file = params.fileId.startsWith("files/") ? params.fileId : `files/${params.fileId}`;
+  const downloadUrl = `${baseUrl}/${file}:download`;
+  const res = await fetch(downloadUrl, {
+    headers: getGeminiHeaders(params.gemini, { json: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`gemini batch file content failed: ${res.status} ${text}`);
+  }
+  return await res.text();
+}
+function parseGeminiBatchOutput(text) {
+  if (!text.trim()) return [];
+  return text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function waitForGeminiBatch(params) {
+  const start = Date.now();
+  let current = params.initial;
+  while (true) {
+    const status = current ?? await fetchGeminiBatchStatus({
+      gemini: params.gemini,
+      batchName: params.batchName
+    });
+    const state = status.state ?? "UNKNOWN";
+    if (["SUCCEEDED", "COMPLETED", "DONE"].includes(state)) {
+      const outputFileId = status.outputConfig?.file ?? status.outputConfig?.fileId ?? status.metadata?.output?.responsesFile;
+      if (!outputFileId) {
+        throw new Error(`gemini batch ${params.batchName} completed without output file`);
+      }
+      return { outputFileId };
+    }
+    if (["FAILED", "CANCELLED", "CANCELED", "EXPIRED"].includes(state)) {
+      const message = status.error?.message ?? "unknown error";
+      throw new Error(`gemini batch ${params.batchName} ${state}: ${message}`);
+    }
+    if (!params.wait) {
+      throw new Error(`gemini batch ${params.batchName} still ${state}; wait disabled`);
+    }
+    if (Date.now() - start > params.timeoutMs) {
+      throw new Error(`gemini batch ${params.batchName} timed out after ${params.timeoutMs}ms`);
+    }
+    params.debug?.(`gemini batch ${params.batchName} ${state}; waiting ${params.pollIntervalMs}ms`);
+    await new Promise((resolve) => setTimeout(resolve, params.pollIntervalMs));
+    current = void 0;
+  }
+}
+async function runWithConcurrency2(tasks, limit) {
+  if (tasks.length === 0) return [];
+  const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+  const results = Array.from({ length: tasks.length });
+  let next = 0;
+  let firstError = null;
+  const workers = Array.from({ length: resolvedLimit }, async () => {
+    while (true) {
+      if (firstError) return;
+      const index = next;
+      next += 1;
+      if (index >= tasks.length) return;
+      try {
+        results[index] = await tasks[index]();
+      } catch (err) {
+        firstError = err;
+        return;
+      }
+    }
+  });
+  await Promise.allSettled(workers);
+  if (firstError) throw firstError;
+  return results;
+}
+async function runGeminiEmbeddingBatches(params) {
+  if (params.requests.length === 0) return /* @__PURE__ */ new Map();
+  const groups = splitGeminiBatchRequests(params.requests);
+  const byCustomId = /* @__PURE__ */ new Map();
+  const tasks = groups.map((group, groupIndex) => async () => {
+    const batchInfo = await submitGeminiBatch({
+      gemini: params.gemini,
+      requests: group,
+      source: params.source
+    });
+    const batchName = batchInfo.name ?? "";
+    if (!batchName) {
+      throw new Error("gemini batch create failed: missing batch name");
+    }
+    params.debug?.("memory embeddings: gemini batch created", {
+      batchName,
+      state: batchInfo.state,
+      group: groupIndex + 1,
+      groups: groups.length,
+      requests: group.length
+    });
+    if (!params.wait && batchInfo.state && !["SUCCEEDED", "COMPLETED", "DONE"].includes(batchInfo.state)) {
+      throw new Error(
+        `gemini batch ${batchName} submitted; enable batch.wait to await completion`
+      );
+    }
+    const completed = batchInfo.state && ["SUCCEEDED", "COMPLETED", "DONE"].includes(batchInfo.state) ? {
+      outputFileId: batchInfo.outputConfig?.file ?? batchInfo.outputConfig?.fileId ?? batchInfo.metadata?.output?.responsesFile ?? ""
+    } : await waitForGeminiBatch({
+      gemini: params.gemini,
+      batchName,
+      wait: params.wait,
+      pollIntervalMs: params.pollIntervalMs,
+      timeoutMs: params.timeoutMs,
+      debug: params.debug,
+      initial: batchInfo
+    });
+    if (!completed.outputFileId) {
+      throw new Error(`gemini batch ${batchName} completed without output file`);
+    }
+    const content = await fetchGeminiFileContent({
+      gemini: params.gemini,
+      fileId: completed.outputFileId
+    });
+    const outputLines = parseGeminiBatchOutput(content);
+    const errors = [];
+    const remaining = new Set(group.map((request) => request.custom_id));
+    for (const line of outputLines) {
+      const customId = line.key ?? line.custom_id ?? line.request_id;
+      if (!customId) continue;
+      remaining.delete(customId);
+      if (line.error?.message) {
+        errors.push(`${customId}: ${line.error.message}`);
+        continue;
+      }
+      if (line.response?.error?.message) {
+        errors.push(`${customId}: ${line.response.error.message}`);
+        continue;
+      }
+      const embedding = line.embedding?.values ?? line.response?.embedding?.values ?? [];
+      if (embedding.length === 0) {
+        errors.push(`${customId}: empty embedding`);
+        continue;
+      }
+      byCustomId.set(customId, embedding);
+    }
+    if (errors.length > 0) {
+      throw new Error(`gemini batch ${batchName} failed: ${errors.join("; ")}`);
+    }
+    if (remaining.size > 0) {
+      throw new Error(`gemini batch ${batchName} missing ${remaining.size} embedding responses`);
+    }
+  });
+  params.debug?.("memory embeddings: gemini batch submit", {
+    requests: params.requests.length,
+    groups: groups.length,
+    wait: params.wait,
+    concurrency: params.concurrency,
+    pollIntervalMs: params.pollIntervalMs,
+    timeoutMs: params.timeoutMs
+  });
+  await runWithConcurrency2(tasks, params.concurrency);
+  return byCustomId;
+}
+
+// src/minimem.ts
+function resolveMinimemSubdir(memoryDir) {
+  const envDir = process.env.MINIMEM_CONFIG_DIR;
+  if (envDir) return envDir;
+  if (fsSync3.existsSync(path3.join(memoryDir, "config.json"))) return ".";
+  const swarmDir = path3.join(memoryDir, ".swarm", "minimem");
+  if (fsSync3.existsSync(path3.join(swarmDir, "config.json"))) return path3.join(".swarm", "minimem");
+  return ".minimem";
+}
+var META_KEY = "memory_index_meta_v1";
+var SNIPPET_MAX_CHARS = 700;
+var VECTOR_TABLE = "chunks_vec";
+var FTS_TABLE = "chunks_fts";
+var EMBEDDING_CACHE_TABLE = "embedding_cache";
+var EMBEDDING_RETRY_MAX_ATTEMPTS = 3;
+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 Minimem = class _Minimem {
+  memoryDir;
+  dbPath;
+  chunking;
+  cache;
+  hybrid;
+  queryConfig;
+  watchConfig;
+  batchConfig;
+  vectorExtensionPath;
+  debug;
+  provider;
+  openAi;
+  gemini;
+  providerKey = "";
+  providerFallbackReason;
+  db;
+  vector;
+  fts;
+  vectorReady = null;
+  watcher = null;
+  watchTimer = null;
+  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, resolveMinimemSubdir(this.memoryDir), "index.db");
+    this.chunking = {
+      tokens: config.chunking?.tokens ?? 256,
+      overlap: config.chunking?.overlap ?? 32
+    };
+    this.cache = {
+      enabled: config.cache?.enabled ?? true,
+      maxEntries: config.cache?.maxEntries ?? 1e4
+    };
+    this.hybrid = {
+      enabled: config.hybrid?.enabled ?? true,
+      vectorWeight: config.hybrid?.vectorWeight ?? 0.7,
+      textWeight: config.hybrid?.textWeight ?? 0.3,
+      candidateMultiplier: config.hybrid?.candidateMultiplier ?? 2
+    };
+    this.queryConfig = {
+      maxResults: config.query?.maxResults ?? 10,
+      minScore: config.query?.minScore ?? 0.3
+    };
+    this.watchConfig = {
+      enabled: config.watch?.enabled ?? true,
+      debounceMs: config.watch?.debounceMs ?? 1e3
+    };
+    this.batchConfig = {
+      enabled: config.batch?.enabled ?? false,
+      wait: config.batch?.wait ?? true,
+      concurrency: config.batch?.concurrency ?? 2,
+      pollIntervalMs: config.batch?.pollIntervalMs ?? 2e3,
+      timeoutMs: config.batch?.timeoutMs ?? 60 * 60 * 1e3
+    };
+    this.vectorExtensionPath = config.vectorExtensionPath;
+    this.debug = config.debug;
+    this.embeddingOptions = config.embedding;
+    this.vector = {
+      enabled: true,
+      available: null,
+      extensionPath: this.vectorExtensionPath
+    };
+    this.fts = { enabled: this.hybrid.enabled, available: false };
+  }
+  static async create(config) {
+    const instance = new _Minimem(config);
+    await instance.initialize();
+    return instance;
+  }
+  async initialize() {
+    const providerResult = await createEmbeddingProvider(this.embeddingOptions);
+    this.provider = providerResult.provider;
+    this.openAi = providerResult.openAi;
+    this.gemini = providerResult.gemini;
+    this.providerKey = this.computeProviderKey();
+    this.providerFallbackReason = providerResult.fallbackReason;
+    if (this.provider.id === "none") {
+      this.debug?.("Running in BM25-only mode (no embedding API available)");
+    }
+    this.db = this.openDatabase();
+    this.ensureSchema();
+    const meta = this.readMeta();
+    if (meta?.vectorDims) {
+      this.vector.dims = meta.vectorDims;
+    }
+    if (this.watchConfig.enabled) {
+      this.ensureWatcher();
+    }
+  }
+  openDatabase() {
+    const dbDir = path3.dirname(this.dbPath);
+    ensureDir(dbDir);
+    return new DatabaseSync(this.dbPath);
+  }
+  ensureSchema() {
+    const result = ensureMemoryIndexSchema({
+      db: this.db,
+      embeddingCacheTable: EMBEDDING_CACHE_TABLE,
+      ftsTable: FTS_TABLE,
+      ftsEnabled: this.fts.enabled
+    });
+    this.fts.available = result.ftsAvailable;
+    if (result.ftsError) {
+      this.fts.loadError = result.ftsError;
+    }
+  }
+  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(":"));
+  }
+  readMeta() {
+    try {
+      const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(META_KEY);
+      if (!row?.value) return null;
+      return JSON.parse(row.value);
+    } catch {
+      return null;
+    }
+  }
+  writeMeta(meta) {
+    this.db.prepare(`INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)`).run(META_KEY, JSON.stringify(meta));
+  }
+  ensureWatcher() {
+    if (this.watcher) return;
+    const memorySubDir = path3.join(this.memoryDir, "memory");
+    const memoryFile = path3.join(this.memoryDir, "MEMORY.md");
+    this.watcher = chokidar.watch([memoryFile, memorySubDir], {
+      ignoreInitial: true,
+      persistent: true,
+      awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+    });
+    const scheduleSync = () => {
+      this.dirty = true;
+      if (this.watchTimer) clearTimeout(this.watchTimer);
+      this.watchTimer = setTimeout(() => {
+        void this.sync({ reason: "watch" }).catch((err) => {
+          this.debug?.(`memory sync failed (watch): ${String(err)}`);
+        });
+      }, this.watchConfig.debounceMs);
+    };
+    this.watcher.on("add", scheduleSync);
+    this.watcher.on("change", scheduleSync);
+    this.watcher.on("unlink", scheduleSync);
+  }
+  /**
+   * Check if the index is stale by comparing file mtimes against stored values.
+   * This is a lightweight check (stat calls only, no file reads).
+   */
+  async isStale() {
+    try {
+      const files = await listMemoryFiles(this.memoryDir);
+      const stored = this.db.prepare(`SELECT path, mtime FROM files WHERE source = ?`).all("memory");
+      if (files.length !== stored.length) {
+        this.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.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 currentMtime = Math.floor(stat.mtimeMs);
+        if (currentMtime !== storedMtime) {
+          this.debug?.(`Stale: mtime changed for ${relPath}`);
+          return true;
+        }
+      }
+      return false;
+    } catch (err) {
+      this.debug?.(`Stale check failed: ${String(err)}`);
+      return true;
+    }
+  }
+  async search(query, opts) {
+    if (this.dirty || !this.watchConfig.enabled && await this.isStale()) {
+      await this.sync({ reason: "search" });
+    }
+    const cleaned = query.trim();
+    if (!cleaned) return [];
+    const minScore = opts?.minScore ?? this.queryConfig.minScore;
+    const maxResults = opts?.maxResults ?? this.queryConfig.maxResults;
+    const candidates = Math.min(
+      200,
+      Math.max(1, Math.floor(maxResults * this.hybrid.candidateMultiplier))
+    );
+    const sourceFilter = { sql: "", params: [] };
+    const keywordResults = this.hybrid.enabled && this.fts.available ? await searchKeyword({
+      db: this.db,
+      ftsTable: FTS_TABLE,
+      providerModel: this.provider.model,
+      query: cleaned,
+      limit: candidates,
+      snippetMaxChars: SNIPPET_MAX_CHARS,
+      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_TABLE,
+      providerModel: this.provider.model,
+      queryVec,
+      limit: candidates,
+      snippetMaxChars: SNIPPET_MAX_CHARS,
+      ensureVectorReady: (dims) => this.ensureVectorReady(dims),
+      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) {
+      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,
+        score: r.score,
+        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: filteredVector.map((r) => ({
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        vectorScore: r.score
+      })),
+      keyword: filteredKeyword.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.hybrid.vectorWeight,
+      textWeight: this.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
+    }));
+  }
+  async sync(opts) {
+    if (this.syncing) {
+      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) {
+    this.debug?.(`memory sync starting`, { reason: opts?.reason });
+    await this.ensureVectorReady();
+    const meta = this.readMeta();
+    const needsFullReindex = opts?.force || !meta || meta.model !== this.provider.model || meta.provider !== this.provider.id || meta.providerKey !== this.providerKey || meta.chunkTokens !== this.chunking.tokens || meta.chunkOverlap !== this.chunking.overlap || this.vector.available && !meta?.vectorDims;
+    const files = await listMemoryFiles(this.memoryDir);
+    const activePaths = /* @__PURE__ */ new Set();
+    for (const absPath of files) {
+      const entry = await buildFileEntry(absPath, this.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;
+      }
+      await this.indexFile(entry);
+    }
+    const staleRows = this.db.prepare(`SELECT path FROM files WHERE source = ?`).all("memory");
+    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");
+      try {
+        this.db.prepare(
+          `DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
+        ).run(stale.path, "memory");
+      } 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 (err) {
+          logError("deleteStaleFtsEntries", err, this.debug);
+        }
+      }
+    }
+    this.writeMeta({
+      model: this.provider.model,
+      provider: this.provider.id,
+      providerKey: this.providerKey,
+      chunkTokens: this.chunking.tokens,
+      chunkOverlap: this.chunking.overlap,
+      vectorDims: this.vector.dims
+    });
+    this.pruneEmbeddingCacheIfNeeded();
+    this.dirty = false;
+    this.debug?.(`memory sync complete`, { files: files.length });
+  }
+  async indexFile(entry) {
+    const content = await fs2.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 (?, ?, ?, ?, ?)`
+    ).run(entry.path, "memory", entry.hash, Math.floor(entry.mtimeMs), entry.size);
+    try {
+      this.db.prepare(
+        `DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
+      ).run(entry.path, "memory");
+    } 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 (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, type, knowledge_type, knowledge_id, domains, entities, confidence)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        chunkId,
+        entry.path,
+        "memory",
+        chunk.startLine,
+        chunk.endLine,
+        chunk.hash,
+        this.provider.model,
+        chunk.text,
+        JSON.stringify(embedding),
+        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) {
+          this.vector.dims = embedding.length;
+          this.ensureVectorTable(embedding.length);
+        }
+        try {
+          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) {
+        try {
+          this.db.prepare(
+            `INSERT INTO ${FTS_TABLE} (text, id, path, source, model, start_line, end_line)
+               VALUES (?, ?, ?, ?, ?, ?, ?)`
+          ).run(
+            chunk.text,
+            chunkId,
+            entry.path,
+            "memory",
+            this.provider.model,
+            chunk.startLine,
+            chunk.endLine
+          );
+        } 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 [];
+    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) ?? []);
+  }
+  async embedBatchWithRetry(texts) {
+    if (texts.length === 0) return [];
+    if (this.batchConfig.enabled) {
+      try {
+        return await this.embedWithBatchApi(texts);
+      } catch (err) {
+        this.debug?.(`batch embedding failed, falling back to direct: ${String(err)}`);
+      }
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < EMBEDDING_RETRY_MAX_ATTEMPTS; attempt++) {
+      try {
+        return await this.provider.embedBatch(texts);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < EMBEDDING_RETRY_MAX_ATTEMPTS - 1) {
+          const delay = Math.min(
+            EMBEDDING_RETRY_MAX_DELAY_MS,
+            EMBEDDING_RETRY_BASE_DELAY_MS * Math.pow(2, attempt)
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  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.batchConfig.wait,
+        pollIntervalMs: this.batchConfig.pollIntervalMs,
+        timeoutMs: this.batchConfig.timeoutMs,
+        concurrency: this.batchConfig.concurrency,
+        debug: this.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.batchConfig.wait,
+        pollIntervalMs: this.batchConfig.pollIntervalMs,
+        timeoutMs: this.batchConfig.timeoutMs,
+        concurrency: this.batchConfig.concurrency,
+        debug: this.debug
+      });
+      return texts.map((_, i) => results.get(`chunk-${i}`) ?? []);
+    }
+    throw new Error("Batch API not available for local embeddings");
+  }
+  async embedQueryWithTimeout(text) {
+    const timeout = this.provider.id === "local" ? EMBEDDING_QUERY_TIMEOUT_LOCAL_MS : EMBEDDING_QUERY_TIMEOUT_REMOTE_MS;
+    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();
+    if (!this.cache.enabled || hashes.length === 0) return result;
+    const placeholders = hashes.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT hash, embedding FROM ${EMBEDDING_CACHE_TABLE}
+         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_TABLE} 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;
+  }
+  upsertEmbeddingCache(hash, embedding) {
+    if (!this.cache.enabled) return;
+    const now = Date.now();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO ${EMBEDDING_CACHE_TABLE}
+         (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
+    );
+  }
+  pruneEmbeddingCacheIfNeeded() {
+    if (!this.cache.enabled) return;
+    const row = this.db.prepare(`SELECT COUNT(*) as count FROM ${EMBEDDING_CACHE_TABLE}`).get();
+    if (row.count <= this.cache.maxEntries) return;
+    const excess = row.count - this.cache.maxEntries;
+    this.db.prepare(
+      `DELETE FROM ${EMBEDDING_CACHE_TABLE}
+         WHERE rowid IN (
+           SELECT rowid FROM ${EMBEDDING_CACHE_TABLE}
+           ORDER BY updated_at ASC
+           LIMIT ?
+         )`
+    ).run(excess);
+  }
+  async ensureVectorReady(dimensions) {
+    if (this.vector.available === true) return true;
+    if (this.vector.available === false) return false;
+    if (!this.vectorReady) {
+      this.vectorReady = this.loadVectorExtension();
+    }
+    const ready = await this.vectorReady;
+    if (ready && dimensions && !this.vector.dims) {
+      this.vector.dims = dimensions;
+      this.ensureVectorTable(dimensions);
+    }
+    return ready;
+  }
+  async loadVectorExtension() {
+    const result = await loadSqliteVecExtension({
+      db: this.db,
+      extensionPath: this.vectorExtensionPath
+    });
+    this.vector.available = result.ok;
+    if (result.error) {
+      this.vector.loadError = result.error;
+      this.debug?.(`sqlite-vec load failed: ${result.error}`);
+    }
+    if (result.extensionPath) {
+      this.vector.extensionPath = result.extensionPath;
+    }
+    return result.ok;
+  }
+  ensureVectorTable(dimensions) {
+    if (!this.vector.available) return;
+    try {
+      this.db.exec(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${VECTOR_TABLE} USING vec0(
+          id TEXT PRIMARY KEY,
+          embedding FLOAT[${dimensions}]
+        )`
+      );
+    } catch (err) {
+      this.debug?.(`vector table creation failed: ${String(err)}`);
+    }
+  }
+  async readFile(relativePath) {
+    const absPath = path3.join(this.memoryDir, relativePath);
+    try {
+      return await fs2.readFile(absPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Read specific lines from a memory file
+   */
+  async readLines(relativePath, opts) {
+    const content = await this.readFile(relativePath);
+    if (content === null) return null;
+    const allLines = content.split("\n");
+    const from = Math.max(1, opts?.from ?? 1);
+    const lines = opts?.lines ?? allLines.length;
+    const startIdx = from - 1;
+    const endIdx = Math.min(startIdx + lines, allLines.length);
+    const selectedLines = allLines.slice(startIdx, endIdx);
+    return {
+      content: selectedLines.join("\n"),
+      startLine: from,
+      endLine: startIdx + selectedLines.length
+    };
+  }
+  /**
+   * Write content to a memory file (creates or overwrites)
+   */
+  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");
+    this.dirty = true;
+    this.debug?.(`memory write: ${relativePath}`);
+  }
+  /**
+   * Append content to a memory file (creates if doesn't exist)
+   */
+  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 });
+    let toAppend = content;
+    try {
+      const existing = await fs2.readFile(absPath, "utf-8");
+      if (existing.length > 0 && !existing.endsWith("\n")) {
+        toAppend = "\n" + content;
+      }
+    } catch {
+    }
+    await fs2.appendFile(absPath, toAppend, "utf-8");
+    this.dirty = true;
+    this.debug?.(`memory append: ${relativePath}`);
+  }
+  /**
+   * Append content to today's daily log (memory/YYYY-MM-DD.md)
+   */
+  async appendToday(content) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const relativePath = `memory/${today}.md`;
+    await this.appendFile(relativePath, content);
+    return relativePath;
+  }
+  /**
+   * List all memory files
+   */
+  async listFiles() {
+    const files = await listMemoryFiles(this.memoryDir);
+    return files.map((f) => path3.relative(this.memoryDir, f).replace(/\\/g, "/"));
+  }
+  /**
+   * Validate that a path is within allowed memory locations
+   */
+  validateMemoryPath(relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (normalized === "MEMORY.md" || normalized === "memory.md") {
+      return;
+    }
+    if (normalized.startsWith("memory/") && normalized.endsWith(".md")) {
+      if (normalized.includes("..")) {
+        throw new Error(`Invalid memory path: ${relativePath} (path traversal not allowed)`);
+      }
+      return;
+    }
+    throw new Error(
+      `Invalid memory path: ${relativePath}. Must be MEMORY.md or memory/*.md`
+    );
+  }
+  async status() {
+    const fileRow = this.db.prepare(`SELECT COUNT(*) as count FROM files`).get();
+    const chunkRow = this.db.prepare(`SELECT COUNT(*) as count FROM chunks`).get();
+    const cacheRow = this.db.prepare(`SELECT COUNT(*) as count FROM ${EMBEDDING_CACHE_TABLE}`).get();
+    return {
+      memoryDir: this.memoryDir,
+      dbPath: this.dbPath,
+      provider: this.provider.id,
+      model: this.provider.model,
+      vectorAvailable: this.vector.available === true,
+      ftsAvailable: this.fts.available,
+      bm25Only: this.provider.id === "none",
+      fallbackReason: this.providerFallbackReason,
+      fileCount: fileRow.count,
+      chunkCount: chunkRow.count,
+      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;
+    if (this.watchTimer) {
+      clearTimeout(this.watchTimer);
+      this.watchTimer = null;
+    }
+    if (this.watcher) {
+      void this.watcher.close();
+      this.watcher = null;
+    }
+    try {
+      this.db.close();
+    } catch (err) {
+      logError("dbClose", err, this.debug);
+    }
+  }
+};
+
+export {
+  parseFrontmatter,
+  addFrontmatter,
+  Minimem
+};
+//# sourceMappingURL=chunk-BIYUNXYX.js.map