minimem 0.0.6 → 0.1.0

package/dist/cli/index.js

@@ -1,21 +1,36 @@
 #!/usr/bin/env node
+import {
+  Minimem,
+  addFrontmatter,
+  parseFrontmatter
+} from "./chunk-BIYUNXYX.js";
 
 // src/cli/index.ts
 import { program } from "commander";
 
 // src/cli/commands/init.ts
-import fs2 from "fs/promises";
-import path3 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 
 // src/cli/config.ts
-import fs from "fs/promises";
+import fs2 from "fs/promises";
+import fsSync from "fs";
 import path2 from "path";
 import os2 from "os";
 import crypto from "crypto";
 
 // src/cli/shared.ts
+import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+function discoverMemoryDir(base) {
+  if (fs.existsSync(path.join(base, "MEMORY.md"))) return base;
+  const swarmDir = path.join(base, ".swarm", "minimem");
+  if (fs.existsSync(path.join(swarmDir, "config.json"))) return swarmDir;
+  const minimemDir = path.join(base, ".minimem");
+  if (fs.existsSync(path.join(minimemDir, "config.json"))) return minimemDir;
+  return base;
+}
 function resolveMemoryDir(options) {
   const dir = Array.isArray(options.dir) ? options.dir[0] : options.dir;
   if (dir) {
@@ -28,7 +43,7 @@ function resolveMemoryDir(options) {
   if (options.global) {
     return path.join(os.homedir(), ".minimem");
   }
-  return process.cwd();
+  return discoverMemoryDir(process.cwd());
 }
 function resolveMemoryDirs(options) {
   const dirs = [];
@@ -46,7 +61,7 @@ function resolveMemoryDirs(options) {
     }
   }
   if (dirs.length === 0) {
-    dirs.push(process.cwd());
+    dirs.push(discoverMemoryDir(process.cwd()));
   }
   return [...new Set(dirs)];
 }
@@ -90,8 +105,16 @@ function getGlobalDir() {
 function getGlobalConfigPath() {
   return path2.join(getGlobalDir(), CONFIG_DIR, CONFIG_FILENAME);
 }
+function resolveConfigSubdir(memoryDir) {
+  const envDir = process.env.MINIMEM_CONFIG_DIR;
+  if (envDir) return envDir;
+  if (fsSync.existsSync(path2.join(memoryDir, CONFIG_FILENAME))) return ".";
+  const swarmDir = path2.join(memoryDir, ".swarm", "minimem");
+  if (fsSync.existsSync(path2.join(swarmDir, CONFIG_FILENAME))) return path2.join(".swarm", "minimem");
+  return CONFIG_DIR;
+}
 function getConfigPath(memoryDir) {
-  return path2.join(memoryDir, CONFIG_DIR, CONFIG_FILENAME);
+  return path2.join(memoryDir, resolveConfigSubdir(memoryDir), CONFIG_FILENAME);
 }
 function getXdgConfigDir() {
   return path2.join(os2.homedir(), XDG_CONFIG_DIR);
@@ -110,7 +133,7 @@ function expandPath(filePath) {
 }
 async function loadXdgConfig() {
   try {
-    const content = await fs.readFile(getXdgConfigPath(), "utf-8");
+    const content = await fs2.readFile(getXdgConfigPath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -119,8 +142,8 @@ async function loadXdgConfig() {
 async function saveXdgConfig(config2) {
   const configDir = getXdgConfigDir();
   const configPath = getXdgConfigPath();
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  await fs2.mkdir(configDir, { recursive: true });
+  await fs2.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
 }
 async function getMachineId() {
   const globalConfig = await loadXdgConfig();
@@ -135,7 +158,7 @@ async function getMachineId() {
 }
 async function loadConfigFile(configPath) {
   try {
-    const content = await fs.readFile(configPath, "utf-8");
+    const content = await fs2.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -189,10 +212,10 @@ function deepMergeConfig(target, source) {
   return result;
 }
 async function saveConfig(memoryDir, config2) {
-  const configDir = path2.join(memoryDir, CONFIG_DIR);
   const configPath = getConfigPath(memoryDir);
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  const configDir = path2.dirname(configPath);
+  await fs2.mkdir(configDir, { recursive: true });
+  await fs2.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
 }
 function getDefaultConfig() {
   return {
@@ -309,2745 +332,290 @@ function buildMinimemConfig(memoryDir, cliConfig, options) {
 async function isInitialized(memoryDir) {
   const configPath = getConfigPath(memoryDir);
   try {
-    await fs.access(configPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function formatPath(filePath) {
-  const home = os2.homedir();
-  if (filePath.startsWith(home)) {
-    return "~" + filePath.slice(home.length);
-  }
-  return filePath;
-}
-
-// src/cli/commands/init.ts
-var MEMORY_TEMPLATE = `# Memory
-
-This is your memory file. Add notes, decisions, and context here.
-
-## Quick Start
-
-- Add daily logs in the \`memory/\` directory (e.g., \`memory/2024-01-15.md\`)
-- Use \`minimem search <query>\` to find relevant memories
-- Use \`minimem append <text>\` to quickly add to today's log
-
-## Notes
-
-`;
-async function init(dir, options) {
-  const memoryDir = resolveMemoryDir({ dir, global: options.global });
-  const displayPath = formatPath(memoryDir);
-  if (!options.force && await isInitialized(memoryDir)) {
-    console.log(`Already initialized: ${displayPath}`);
-    console.log("Use --force to reinitialize");
-    return;
-  }
-  console.log(`Initializing minimem in ${displayPath}...`);
-  await fs2.mkdir(memoryDir, { recursive: true });
-  await fs2.mkdir(path3.join(memoryDir, "memory"), { recursive: true });
-  await fs2.mkdir(path3.join(memoryDir, ".minimem"), { recursive: true });
-  const memoryFilePath = path3.join(memoryDir, "MEMORY.md");
-  try {
-    await fs2.access(memoryFilePath);
-    console.log("  MEMORY.md already exists, skipping");
-  } catch {
-    await fs2.writeFile(memoryFilePath, MEMORY_TEMPLATE, "utf-8");
-    console.log("  Created MEMORY.md");
-  }
-  const config2 = getInitConfig();
-  await saveConfig(memoryDir, config2);
-  console.log("  Created .minimem/config.json");
-  const gitignorePath = path3.join(memoryDir, ".minimem", ".gitignore");
-  await fs2.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
-  console.log("  Created .minimem/.gitignore");
-  console.log();
-  console.log("Done! Your memory directory is ready.");
-  console.log();
-  console.log("Next steps:");
-  console.log(`  1. Set your embedding API key:`);
-  console.log(`     export OPENAI_API_KEY=your-key`);
-  console.log(`     # or: export GOOGLE_API_KEY=your-key`);
-  console.log();
-  console.log(`  2. Add some memories to MEMORY.md or memory/*.md`);
-  console.log();
-  console.log(`  3. Search your memories:`);
-  console.log(`     minimem search "your query"${dir ? ` --dir ${dir}` : ""}`);
-}
-
-// src/minimem.ts
-import { randomUUID } from "crypto";
-import fs4 from "fs/promises";
-import path6 from "path";
-import { DatabaseSync } from "node:sqlite";
-import chokidar from "chokidar";
-
-// src/internal.ts
-import crypto2 from "crypto";
-import fsSync from "fs";
-import fs3 from "fs/promises";
-import path4 from "path";
-function logError2(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") {
-      logError2("ensureDir", error, debug);
-    }
-  }
-  return dir;
-}
-async function exists(filePath) {
-  try {
-    await fs3.access(filePath);
+    await fs2.access(configPath);
     return true;
   } catch {
     return false;
   }
-}
-async function walkDir(dir, files) {
-  const entries = await fs3.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = path4.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 = path4.join(memoryDir, "MEMORY.md");
-  const altMemoryFile = path4.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 fs3.realpath(memoryFile);
-    } catch {
-    }
-    try {
-      lowerReal = await fs3.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 = path4.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 fs3.realpath(entry);
-    } catch {
-    }
-    if (seen.has(key)) continue;
-    seen.add(key);
-    deduped.push(entry);
-  }
-  return deduped;
-}
-function hashText(value) {
-  return crypto2.createHash("sha256").update(value).digest("hex");
-}
-async function buildFileEntry(absPath, memoryDir) {
-  const stat = await fs3.stat(absPath);
-  const content = await fs3.readFile(absPath, "utf-8");
-  const hash = hashText(content);
-  return {
-    path: path4.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 os3 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: ${formatPath2(session.project)}`);
-    if (session.transcript) lines.push(`  transcript: ${formatPath2(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 formatPath2(filePath) {
-  const home = os3.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 path20 = [];
-  let current = toId;
-  while (current !== fromId) {
-    const link = parentLink.get(current);
-    if (!link) break;
-    path20.unshift(link);
-    current = link.toId === current ? link.fromId : link.toId;
-  }
-  return path20;
-}
-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 path5 from "path";
-import os4 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 path5.join(os4.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((resolve3) => setTimeout(resolve3, 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 status2 = err.status;
-        return status2 === 429 || typeof status2 === "number" && status2 >= 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 status2 = current ?? await fetchOpenAiBatchStatus({
-      openAi: params.openAi,
-      batchId: params.batchId
-    });
-    const state = status2.status ?? "unknown";
-    if (state === "completed") {
-      if (!status2.output_file_id) {
-        throw new Error(`openai batch ${params.batchId} completed without output file`);
-      }
-      return {
-        outputFileId: status2.output_file_id,
-        errorFileId: status2.error_file_id ?? void 0
-      };
-    }
-    if (["failed", "expired", "cancelled", "canceled"].includes(state)) {
-      const detail = status2.error_file_id ? await readOpenAiBatchError({ openAi: params.openAi, errorFileId: status2.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((resolve3) => setTimeout(resolve3, 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 status2 = current ?? await fetchGeminiBatchStatus({
-      gemini: params.gemini,
-      batchName: params.batchName
-    });
-    const state = status2.state ?? "UNKNOWN";
-    if (["SUCCEEDED", "COMPLETED", "DONE"].includes(state)) {
-      const outputFileId = status2.outputConfig?.file ?? status2.outputConfig?.fileId ?? status2.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 = status2.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((resolve3) => setTimeout(resolve3, 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
-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(config2) {
-    this.memoryDir = path6.resolve(config2.memoryDir);
-    this.dbPath = config2.dbPath ?? path6.join(this.memoryDir, ".minimem", "index.db");
-    this.chunking = {
-      tokens: config2.chunking?.tokens ?? 256,
-      overlap: config2.chunking?.overlap ?? 32
-    };
-    this.cache = {
-      enabled: config2.cache?.enabled ?? true,
-      maxEntries: config2.cache?.maxEntries ?? 1e4
-    };
-    this.hybrid = {
-      enabled: config2.hybrid?.enabled ?? true,
-      vectorWeight: config2.hybrid?.vectorWeight ?? 0.7,
-      textWeight: config2.hybrid?.textWeight ?? 0.3,
-      candidateMultiplier: config2.hybrid?.candidateMultiplier ?? 2
-    };
-    this.queryConfig = {
-      maxResults: config2.query?.maxResults ?? 10,
-      minScore: config2.query?.minScore ?? 0.3
-    };
-    this.watchConfig = {
-      enabled: config2.watch?.enabled ?? true,
-      debounceMs: config2.watch?.debounceMs ?? 1e3
-    };
-    this.batchConfig = {
-      enabled: config2.batch?.enabled ?? false,
-      wait: config2.batch?.wait ?? true,
-      concurrency: config2.batch?.concurrency ?? 2,
-      pollIntervalMs: config2.batch?.pollIntervalMs ?? 2e3,
-      timeoutMs: config2.batch?.timeoutMs ?? 60 * 60 * 1e3
-    };
-    this.vectorExtensionPath = config2.vectorExtensionPath;
-    this.debug = config2.debug;
-    this.embeddingOptions = config2.embedding;
-    this.vector = {
-      enabled: true,
-      available: null,
-      extensionPath: this.vectorExtensionPath
-    };
-    this.fts = { enabled: this.hybrid.enabled, available: false };
-  }
-  static async create(config2) {
-    const instance = new _Minimem(config2);
-    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 = path6.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 = path6.join(this.memoryDir, "memory");
-    const memoryFile = path6.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 = path6.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 fs4.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) {
-        logError2("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) {
-          logError2("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 fs4.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) {
-      logError2("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) {
-        logError2("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) {
-          logError2("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) {
-          logError2("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((resolve3) => setTimeout(resolve3, 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;
+}
+function formatPath(filePath) {
+  const home = os2.homedir();
+  if (filePath.startsWith(home)) {
+    return "~" + filePath.slice(home.length);
   }
-  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)}`);
+  return filePath;
+}
+
+// src/store/manifest.ts
+import fs3 from "fs/promises";
+import fsSync2 from "fs";
+import path3 from "path";
+import os3 from "os";
+var GLOBAL_MANIFEST_PATH = path3.join(
+  os3.homedir(),
+  ".config",
+  "minimem",
+  "stores.json"
+);
+var LINKS_FILENAME = "links.json";
+async function loadManifest(manifestPath) {
+  const filePath = manifestPath ?? GLOBAL_MANIFEST_PATH;
+  try {
+    const content = await fs3.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    for (const [name, def] of Object.entries(parsed.stores ?? {})) {
+      parsed.stores[name] = {
+        ...def,
+        path: expandHome(def.path)
+      };
     }
+    return { stores: parsed.stores ?? {} };
+  } catch {
+    return { stores: {} };
   }
-  async readFile(relativePath) {
-    const absPath = path6.join(this.memoryDir, relativePath);
+}
+async function saveManifest(manifest, manifestPath) {
+  const filePath = manifestPath ?? GLOBAL_MANIFEST_PATH;
+  await fs3.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs3.writeFile(filePath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+async function loadStoreLinks(memoryDir) {
+  const candidates = [
+    path3.join(memoryDir, ".minimem", LINKS_FILENAME),
+    path3.join(memoryDir, ".swarm", "minimem", LINKS_FILENAME),
+    path3.join(memoryDir, LINKS_FILENAME)
+  ];
+  for (const candidate of candidates) {
     try {
-      return await fs4.readFile(absPath, "utf-8");
+      const content = await fs3.readFile(candidate, "utf-8");
+      const parsed = JSON.parse(content);
+      return { links: parsed.links ?? [] };
     } catch {
-      return null;
+      continue;
     }
   }
-  /**
-   * 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 = path6.join(this.memoryDir, relativePath);
-    const dir = path6.dirname(absPath);
-    await fs4.mkdir(dir, { recursive: true });
-    await fs4.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 = path6.join(this.memoryDir, relativePath);
-    const dir = path6.dirname(absPath);
-    await fs4.mkdir(dir, { recursive: true });
-    let toAppend = content;
-    try {
-      const existing = await fs4.readFile(absPath, "utf-8");
-      if (existing.length > 0 && !existing.endsWith("\n")) {
-        toAppend = "\n" + content;
-      }
-    } catch {
+  return { links: [] };
+}
+async function saveStoreLinks(memoryDir, links) {
+  const candidates = [
+    path3.join(memoryDir, ".minimem"),
+    path3.join(memoryDir, ".swarm", "minimem"),
+    memoryDir
+    // contained layout
+  ];
+  let targetDir = candidates[0];
+  for (const candidate of candidates) {
+    if (fsSync2.existsSync(candidate)) {
+      targetDir = candidate;
+      break;
+    }
+  }
+  await fs3.mkdir(targetDir, { recursive: true });
+  await fs3.writeFile(
+    path3.join(targetDir, LINKS_FILENAME),
+    JSON.stringify(links, null, 2),
+    "utf-8"
+  );
+}
+function resolveStore(manifest, storeName) {
+  return manifest.stores[storeName] ?? null;
+}
+function resolveStoreName(manifest, dirPath) {
+  const resolved = path3.resolve(dirPath);
+  for (const [name, def] of Object.entries(manifest.stores)) {
+    if (path3.resolve(def.path) === resolved) {
+      return name;
     }
-    await fs4.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;
+  return null;
+}
+async function getLinkedStoreNames(manifest, storeName) {
+  const storeDef = manifest.stores[storeName];
+  if (!storeDef) return [];
+  const storeLinks = await loadStoreLinks(storeDef.path);
+  return [...new Set(storeLinks.links)];
+}
+function getManifestPath() {
+  return GLOBAL_MANIFEST_PATH;
+}
+function expandHome(filePath) {
+  if (filePath.startsWith("~/")) {
+    return path3.join(os3.homedir(), filePath.slice(2));
   }
-  /**
-   * List all memory files
-   */
-  async listFiles() {
-    const files = await listMemoryFiles(this.memoryDir);
-    return files.map((f) => path6.relative(this.memoryDir, f).replace(/\\/g, "/"));
+  return filePath;
+}
+
+// src/store/materialize.ts
+import fs4 from "fs/promises";
+import fsSync3 from "fs";
+import path4 from "path";
+import os4 from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var CACHE_BASE = path4.join(os4.homedir(), ".cache", "minimem", "stores");
+async function materializeStore(storeName, storeDef, opts) {
+  if (fsSync3.existsSync(storeDef.path)) {
+    return materializeLocal(storeName, storeDef.path);
   }
-  /**
-   * 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 (storeDef.remote) {
+    return materializeRemote(storeName, storeDef, opts?.refresh ?? false);
+  }
+  return null;
+}
+async function materializeLocal(storeName, storePath) {
+  const tmpBase = await fs4.mkdtemp(
+    path4.join(os4.tmpdir(), "minimem-stores-")
+  );
+  const symlinkDir = path4.join(tmpBase, storeName);
+  await fs4.symlink(storePath, symlinkDir, "dir");
+  return {
+    // The Minimem instance should use the original path for its DB,
+    // but the symlink path can be used for discovery/resolution.
+    // We return the original path since Minimem works directly with it.
+    path: storePath,
+    strategy: "symlink",
+    cleanup: async () => {
+      try {
+        await fs4.unlink(symlinkDir);
+        await fs4.rmdir(tmpBase);
+      } catch {
+      }
     }
-    if (normalized.startsWith("memory/") && normalized.endsWith(".md")) {
-      if (normalized.includes("..")) {
-        throw new Error(`Invalid memory path: ${relativePath} (path traversal not allowed)`);
+  };
+}
+async function materializeRemote(storeName, storeDef, refresh) {
+  const cacheDir = path4.join(CACHE_BASE, storeName);
+  try {
+    if (fsSync3.existsSync(path4.join(cacheDir, ".git"))) {
+      if (refresh) {
+        await gitFetch(cacheDir);
       }
-      return;
+    } else {
+      await gitClone(storeDef.remote, cacheDir);
     }
-    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
+      path: cacheDir,
+      strategy: "remote",
+      cleanup: async () => {
+      }
     };
+  } catch {
+    return null;
   }
-  /**
-   * 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;
+}
+async function gitClone(remote, targetDir) {
+  await fs4.mkdir(path4.dirname(targetDir), { recursive: true });
+  await execFileAsync("git", ["clone", "--depth", "1", remote, targetDir], {
+    timeout: 6e4
+  });
+}
+async function gitFetch(cacheDir) {
+  await execFileAsync("git", ["fetch", "--depth", "1", "origin"], {
+    cwd: cacheDir,
+    timeout: 6e4
+  });
+  await execFileAsync("git", ["reset", "--hard", "origin/HEAD"], {
+    cwd: cacheDir,
+    timeout: 3e4
+  });
+}
+
+// src/cli/commands/init.ts
+var MEMORY_TEMPLATE = `# Memory
+
+This is your memory file. Add notes, decisions, and context here.
+
+## Quick Start
+
+- Add daily logs in the \`memory/\` directory (e.g., \`memory/2024-01-15.md\`)
+- Use \`minimem search <query>\` to find relevant memories
+- Use \`minimem append <text>\` to quickly add to today's log
+
+## Notes
+
+`;
+async function init(dir, options) {
+  const memoryDir = resolveMemoryDir({ dir, global: options.global });
+  const displayPath = formatPath(memoryDir);
+  if (!options.force && await isInitialized(memoryDir)) {
+    console.log(`Already initialized: ${displayPath}`);
+    console.log("Use --force to reinitialize");
+    return;
   }
-  /**
-   * 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);
+  console.log(`Initializing minimem in ${displayPath}...`);
+  await fs5.mkdir(memoryDir, { recursive: true });
+  await fs5.mkdir(path5.join(memoryDir, "memory"), { recursive: true });
+  const memoryFilePath = path5.join(memoryDir, "MEMORY.md");
+  try {
+    await fs5.access(memoryFilePath);
+    console.log("  MEMORY.md already exists, skipping");
+  } catch {
+    await fs5.writeFile(memoryFilePath, MEMORY_TEMPLATE, "utf-8");
+    console.log("  Created MEMORY.md");
   }
-  /**
-   * Get neighbor nodes via BFS traversal.
-   */
-  getGraphNeighbors(nodeId, depth = 1, opts) {
-    return getNeighbors(this.db, nodeId, depth, opts);
+  const config2 = getInitConfig();
+  const configPath = path5.join(memoryDir, "config.json");
+  await fs5.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  console.log("  Created config.json");
+  const gitignorePath = path5.join(memoryDir, ".gitignore");
+  await fs5.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
+  console.log("  Created .gitignore");
+  await materializeLinkedStores(memoryDir);
+  if (!options.skipSync) {
+    await initialSync(memoryDir);
   }
-  /**
-   * Find shortest path between two knowledge nodes.
-   */
-  getGraphPath(fromId, toId, maxDepth = 3) {
-    return getPathBetween(this.db, fromId, toId, maxDepth);
+  console.log();
+  console.log("Done! Your memory directory is ready.");
+  console.log(`Search your memories with: minimem search "your query"${dir ? ` --dir ${dir}` : ""}`);
+}
+async function initialSync(memoryDir) {
+  console.log();
+  console.log("Indexing memory files...");
+  const cliConfig = await loadConfig(memoryDir);
+  const config2 = buildMinimemConfig(memoryDir, cliConfig, {
+    watch: false
+  });
+  const { Minimem: Minimem2 } = await import("./minimem-MQXSBGNG.js");
+  let minimem = null;
+  try {
+    minimem = await Minimem2.create(config2);
+    await minimem.sync({ force: false });
+    const status2 = await minimem.status();
+    console.log(`  Indexed ${status2.fileCount} file(s), ${status2.chunkCount} chunk(s)`);
+  } catch (err) {
+    console.log("  Skipped indexing (set an embedding API key to enable)");
+  } finally {
+    minimem?.close();
   }
-  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;
+}
+async function materializeLinkedStores(memoryDir) {
+  try {
+    const manifest = await loadManifest();
+    if (Object.keys(manifest.stores).length === 0) return;
+    const storeName = resolveStoreName(manifest, memoryDir);
+    if (!storeName) return;
+    const linkedNames = await getLinkedStoreNames(manifest, storeName);
+    if (linkedNames.length === 0) return;
+    let materialized = 0;
+    for (const linkedName of linkedNames) {
+      const linkedDef = resolveStore(manifest, linkedName);
+      if (!linkedDef) continue;
+      const result = await materializeStore(linkedName, linkedDef);
+      if (result) {
+        if (result.strategy === "remote") {
+          console.log(`  Materialized linked store "${linkedName}" from remote`);
+        }
+        await result.cleanup();
+        materialized++;
+      }
     }
-    try {
-      this.db.close();
-    } catch (err) {
-      logError2("dbClose", err, this.debug);
+    if (materialized > 0) {
+      console.log(`  ${materialized} linked store(s) ready`);
     }
+  } catch {
   }
-};
+}
 
 // src/cli/commands/search.ts
 async function search(query, options) {
@@ -3069,13 +637,14 @@ async function search(query, options) {
   if (validDirs.length === 0) {
     exitWithError("No valid initialized memory directories found.");
   }
+  const { dirs: allDirs, cleanups } = options.noLinks ? { dirs: validDirs, cleanups: [] } : await resolveLinkedDirs(validDirs);
   const maxResults = options.max ? parseInt(options.max, 10) : 10;
   const minScore = options.minScore ? parseFloat(options.minScore) : void 0;
   const allResults = [];
   const instances = [];
   let warnedBm25 = false;
   try {
-    for (const memoryDir of validDirs) {
+    for (const memoryDir of allDirs) {
       const cliConfig = await loadConfig(memoryDir);
       const config2 = buildMinimemConfig(memoryDir, cliConfig, {
         provider: options.provider,
@@ -3110,7 +679,7 @@ async function search(query, options) {
       console.log(JSON.stringify(topResults, null, 2));
       return;
     }
-    const showSource = validDirs.length > 1;
+    const showSource = allDirs.length > 1;
     for (const result of topResults) {
       const score = (result.score * 100).toFixed(1);
       const location = `${result.path}:${result.startLine}-${result.endLine}`;
@@ -3123,12 +692,46 @@ async function search(query, options) {
       console.log(formatSnippet(result.snippet));
       console.log();
     }
-    const dirSummary = validDirs.length > 1 ? ` across ${validDirs.length} directories` : "";
+    const dirSummary = allDirs.length > 1 ? ` across ${allDirs.length} directories` : "";
     console.log(`Found ${topResults.length} result${topResults.length === 1 ? "" : "s"}${dirSummary}`);
   } finally {
     for (const instance of instances) {
       instance.close();
     }
+    for (const cleanup of cleanups) {
+      await cleanup().catch(() => {
+      });
+    }
+  }
+}
+async function resolveLinkedDirs(dirs) {
+  const cleanups = [];
+  try {
+    const manifest = await loadManifest();
+    if (Object.keys(manifest.stores).length === 0) {
+      return { dirs, cleanups };
+    }
+    const allDirs = new Set(dirs);
+    for (const dir of dirs) {
+      const storeName = resolveStoreName(manifest, dir);
+      if (!storeName) continue;
+      const linkedNames = await getLinkedStoreNames(manifest, storeName);
+      for (const linkedName of linkedNames) {
+        const linkedDef = resolveStore(manifest, linkedName);
+        if (!linkedDef) continue;
+        try {
+          const result = await materializeStore(linkedName, linkedDef);
+          if (result) {
+            allDirs.add(result.path);
+            cleanups.push(result.cleanup);
+          }
+        } catch {
+        }
+      }
+    }
+    return { dirs: [...allDirs], cleanups };
+  } catch {
+    return { dirs, cleanups };
   }
 }
 function formatSnippet(snippet) {
@@ -3277,8 +880,8 @@ ${text}`;
 }
 
 // src/cli/commands/upsert.ts
-import * as fs5 from "fs/promises";
-import * as path7 from "path";
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
 async function upsert(file, content, options) {
   const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
   if (!await isInitialized(memoryDir)) {
@@ -3303,22 +906,22 @@ async function upsert(file, content, options) {
     project: process.cwd()
   } : void 0;
   const filePath = resolveFilePath(file, memoryDir);
-  const resolvedPath = path7.resolve(filePath);
-  const resolvedMemoryDir = path7.resolve(memoryDir);
-  if (!resolvedPath.startsWith(resolvedMemoryDir + path7.sep) && resolvedPath !== resolvedMemoryDir) {
+  const resolvedPath = path6.resolve(filePath);
+  const resolvedMemoryDir = path6.resolve(memoryDir);
+  if (!resolvedPath.startsWith(resolvedMemoryDir + path6.sep) && resolvedPath !== resolvedMemoryDir) {
     exitWithError(
       "File path must be within the memory directory.",
       `Memory dir: ${formatPath(memoryDir)}, File: ${formatPath(filePath)}`
     );
   }
-  const parentDir = path7.dirname(filePath);
-  await fs5.mkdir(parentDir, { recursive: true });
+  const parentDir = path6.dirname(filePath);
+  await fs6.mkdir(parentDir, { recursive: true });
   let isUpdate = false;
   let existingContent;
   try {
-    await fs5.access(filePath);
+    await fs6.access(filePath);
     isUpdate = true;
-    existingContent = await fs5.readFile(filePath, "utf-8");
+    existingContent = await fs6.readFile(filePath, "utf-8");
   } catch {
   }
   let contentToWrite = finalContent;
@@ -3346,8 +949,8 @@ async function upsert(file, content, options) {
       });
     }
   }
-  await fs5.writeFile(filePath, contentToWrite, "utf-8");
-  const relativePath = path7.relative(memoryDir, filePath);
+  await fs6.writeFile(filePath, contentToWrite, "utf-8");
+  const relativePath = path6.relative(memoryDir, filePath);
   const action = isUpdate ? "Updated" : "Created";
   console.log(`${action}: ${relativePath}`);
   console.log(`  in ${formatPath(memoryDir)}`);
@@ -3371,10 +974,10 @@ async function upsert(file, content, options) {
   }
 }
 function resolveFilePath(file, memoryDir) {
-  if (path7.isAbsolute(file)) {
+  if (path6.isAbsolute(file)) {
     return file;
   }
-  return path7.join(memoryDir, file);
+  return path6.join(memoryDir, file);
 }
 async function readStdin() {
   const chunks = [];
@@ -3386,8 +989,8 @@ async function readStdin() {
 }
 
 // src/cli/commands/mcp.ts
-import * as fs6 from "fs/promises";
-import * as path8 from "path";
+import * as fs7 from "fs/promises";
+import * as path7 from "path";
 
 // src/server/mcp.ts
 import * as readline from "readline";
@@ -4019,9 +1622,10 @@ async function mcp(options) {
   if (includesGlobal && !await isInitialized(globalDir)) {
     await ensureGlobalInitialized(globalDir);
   }
+  const expandedDirs = await resolveLinkedDirsForMcp(directories);
   const instances = [];
   const minimemInstances = [];
-  for (const memoryDir of directories) {
+  for (const memoryDir of expandedDirs) {
     const isGlobal = memoryDir === globalDir;
     if (!await isInitialized(memoryDir)) {
       warn(`${formatPath(memoryDir)} is not initialized, skipping.`);
@@ -4083,12 +1687,11 @@ async function mcp(options) {
 }
 async function ensureGlobalInitialized(globalDir) {
   console.error(`Auto-initializing global memory directory (~/.minimem)...`);
-  await fs6.mkdir(globalDir, { recursive: true });
-  await fs6.mkdir(path8.join(globalDir, "memory"), { recursive: true });
-  await fs6.mkdir(path8.join(globalDir, ".minimem"), { recursive: true });
-  const memoryFilePath = path8.join(globalDir, "MEMORY.md");
+  await fs7.mkdir(globalDir, { recursive: true });
+  await fs7.mkdir(path7.join(globalDir, "memory"), { recursive: true });
+  const memoryFilePath = path7.join(globalDir, "MEMORY.md");
   try {
-    await fs6.access(memoryFilePath);
+    await fs7.access(memoryFilePath);
   } catch {
     const template = `# Global Memory
 
@@ -4099,14 +1702,41 @@ Notes stored here are available across all projects.
 ## Notes
 
 `;
-    await fs6.writeFile(memoryFilePath, template, "utf-8");
+    await fs7.writeFile(memoryFilePath, template, "utf-8");
   }
   const config2 = getInitConfig();
-  await saveConfig(globalDir, config2);
-  const gitignorePath = path8.join(globalDir, ".minimem", ".gitignore");
-  await fs6.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
+  const configPath = path7.join(globalDir, "config.json");
+  await fs7.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  const gitignorePath = path7.join(globalDir, ".gitignore");
+  await fs7.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
   console.error(`  Created ~/.minimem with default configuration.`);
 }
+async function resolveLinkedDirsForMcp(dirs) {
+  try {
+    const manifest = await loadManifest();
+    if (Object.keys(manifest.stores).length === 0) return dirs;
+    const allDirs = new Set(dirs);
+    for (const dir of dirs) {
+      const storeName = resolveStoreName(manifest, dir);
+      if (!storeName) continue;
+      const linkedNames = await getLinkedStoreNames(manifest, storeName);
+      for (const linkedName of linkedNames) {
+        const linkedDef = resolveStore(manifest, linkedName);
+        if (!linkedDef) continue;
+        try {
+          const result = await materializeStore(linkedName, linkedDef);
+          if (result) {
+            allDirs.add(result.path);
+          }
+        } catch {
+        }
+      }
+    }
+    return [...allDirs];
+  } catch {
+    return dirs;
+  }
+}
 
 // src/cli/commands/config.ts
 async function config(options) {
@@ -4250,9 +1880,9 @@ async function handleXdgConfigEdit(options) {
   }
 }
 async function loadConfigFile2(configPath) {
-  const fs18 = await import("fs/promises");
+  const fs19 = await import("fs/promises");
   try {
-    const content = await fs18.readFile(configPath, "utf-8");
+    const content = await fs19.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -4298,22 +1928,22 @@ function unsetConfigValue(config2, keyPath) {
 }
 
 // src/cli/commands/sync-init.ts
-import fs10 from "fs/promises";
-import path12 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 
 // src/cli/sync/central.ts
-import fs9 from "fs/promises";
-import path11 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 import { execSync } from "child_process";
 
 // src/cli/sync/registry.ts
-import fs7 from "fs/promises";
-import path9 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import os5 from "os";
-import crypto3 from "crypto";
+import crypto2 from "crypto";
 var REGISTRY_FILENAME = ".minimem-registry.json";
 function getRegistryPath(centralRepo) {
-  return path9.join(centralRepo, REGISTRY_FILENAME);
+  return path8.join(centralRepo, REGISTRY_FILENAME);
 }
 function createEmptyRegistry() {
   return {
@@ -4324,7 +1954,7 @@ function createEmptyRegistry() {
 async function readRegistry(centralRepo) {
   const registryPath = getRegistryPath(centralRepo);
   try {
-    const content = await fs7.readFile(registryPath, "utf-8");
+    const content = await fs8.readFile(registryPath, "utf-8");
     const registry = JSON.parse(content);
     if (!registry.mappings || !Array.isArray(registry.mappings)) {
       return createEmptyRegistry();
@@ -4336,23 +1966,23 @@ async function readRegistry(centralRepo) {
 }
 async function writeRegistry(centralRepo, registry) {
   const registryPath = getRegistryPath(centralRepo);
-  const tempPath = `${registryPath}.${crypto3.randomBytes(4).toString("hex")}.tmp`;
+  const tempPath = `${registryPath}.${crypto2.randomBytes(4).toString("hex")}.tmp`;
   registry.version = registry.version || 1;
-  await fs7.writeFile(tempPath, JSON.stringify(registry, null, 2), "utf-8");
-  await fs7.rename(tempPath, registryPath);
+  await fs8.writeFile(tempPath, JSON.stringify(registry, null, 2), "utf-8");
+  await fs8.rename(tempPath, registryPath);
 }
 function normalizePath(filePath) {
   if (filePath.startsWith("~/")) {
-    return path9.resolve(os5.homedir(), filePath.slice(2));
+    return path8.resolve(os5.homedir(), filePath.slice(2));
   }
   if (filePath === "~") {
     return os5.homedir();
   }
-  return path9.resolve(filePath);
+  return path8.resolve(filePath);
 }
 function compressPath(filePath) {
   const home = os5.homedir();
-  const resolved = path9.resolve(filePath);
+  const resolved = path8.resolve(filePath);
   if (resolved.startsWith(home)) {
     return "~" + resolved.slice(home.length);
   }
@@ -4417,28 +2047,28 @@ function updateLastSync(registry, centralPath, machineId) {
 }
 
 // src/cli/sync/detection.ts
-import fs8 from "fs/promises";
-import path10 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 async function isInsideGitRepo(dir) {
-  let current = path10.resolve(dir);
-  const root = path10.parse(current).root;
+  let current = path9.resolve(dir);
+  const root = path9.parse(current).root;
   while (current !== root) {
     try {
-      const gitPath = path10.join(current, ".git");
-      const stat = await fs8.stat(gitPath);
+      const gitPath = path9.join(current, ".git");
+      const stat = await fs9.stat(gitPath);
       if (stat.isDirectory() || stat.isFile()) {
         return true;
       }
     } catch {
     }
-    current = path10.dirname(current);
+    current = path9.dirname(current);
   }
   return false;
 }
 async function hasSyncConfig(dir) {
   const configPath = getConfigPath(dir);
   try {
-    const content = await fs8.readFile(configPath, "utf-8");
+    const content = await fs9.readFile(configPath, "utf-8");
     const config2 = JSON.parse(content);
     return config2.sync?.enabled === true || typeof config2.sync?.path === "string";
   } catch {
@@ -4507,9 +2137,9 @@ minimem sync init --path <directory-name>/
 `;
 async function isWritable(dirPath) {
   try {
-    const testFile = path11.join(dirPath, `.minimem-write-test-${Date.now()}`);
-    await fs9.writeFile(testFile, "test");
-    await fs9.unlink(testFile);
+    const testFile = path10.join(dirPath, `.minimem-write-test-${Date.now()}`);
+    await fs10.writeFile(testFile, "test");
+    await fs10.unlink(testFile);
     return true;
   } catch {
     return false;
@@ -4528,7 +2158,7 @@ async function initGitRepo(dirPath) {
 }
 async function initCentralRepo(repoPath) {
   const expandedPath = expandPath(repoPath);
-  const resolvedPath = path11.resolve(expandedPath);
+  const resolvedPath = path10.resolve(expandedPath);
   if (!isGitAvailable()) {
     return {
       success: false,
@@ -4539,7 +2169,7 @@ async function initCentralRepo(repoPath) {
   }
   let dirExists = false;
   try {
-    const stat = await fs9.stat(resolvedPath);
+    const stat = await fs10.stat(resolvedPath);
     dirExists = stat.isDirectory();
   } catch {
     dirExists = false;
@@ -4547,7 +2177,7 @@ async function initCentralRepo(repoPath) {
   let created = false;
   if (!dirExists) {
     try {
-      await fs9.mkdir(resolvedPath, { recursive: true });
+      await fs10.mkdir(resolvedPath, { recursive: true });
       created = true;
     } catch (error) {
       return {
@@ -4579,23 +2209,23 @@ async function initCentralRepo(repoPath) {
       };
     }
   }
-  const gitignorePath = path11.join(resolvedPath, ".gitignore");
+  const gitignorePath = path10.join(resolvedPath, ".gitignore");
   try {
-    await fs9.access(gitignorePath);
+    await fs10.access(gitignorePath);
   } catch {
-    await fs9.writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
+    await fs10.writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
   }
   const registryPath = getRegistryPath(resolvedPath);
   try {
-    await fs9.access(registryPath);
+    await fs10.access(registryPath);
   } catch {
     await writeRegistry(resolvedPath, createEmptyRegistry());
   }
-  const readmePath = path11.join(resolvedPath, "README.md");
+  const readmePath = path10.join(resolvedPath, "README.md");
   try {
-    await fs9.access(readmePath);
+    await fs10.access(readmePath);
   } catch {
-    await fs9.writeFile(readmePath, README_CONTENT, "utf-8");
+    await fs10.writeFile(readmePath, README_CONTENT, "utf-8");
   }
   const globalConfig = await loadXdgConfig();
   globalConfig.centralRepo = repoPath;
@@ -4609,11 +2239,11 @@ async function initCentralRepo(repoPath) {
 }
 async function validateCentralRepo(repoPath) {
   const expandedPath = expandPath(repoPath);
-  const resolvedPath = path11.resolve(expandedPath);
+  const resolvedPath = path10.resolve(expandedPath);
   const warnings = [];
   const errors = [];
   try {
-    const stat = await fs9.stat(resolvedPath);
+    const stat = await fs10.stat(resolvedPath);
     if (!stat.isDirectory()) {
       errors.push("Path is not a directory");
       return { valid: false, warnings, errors };
@@ -4628,7 +2258,7 @@ async function validateCentralRepo(repoPath) {
   }
   const registryPath = getRegistryPath(resolvedPath);
   try {
-    await fs9.access(registryPath);
+    await fs10.access(registryPath);
     const registry = await readRegistry(resolvedPath);
     if (!registry.mappings) {
       warnings.push("Registry file is malformed");
@@ -4636,9 +2266,9 @@ async function validateCentralRepo(repoPath) {
   } catch {
     warnings.push("Registry file is missing - will be created on first sync");
   }
-  const gitignorePath = path11.join(resolvedPath, ".gitignore");
+  const gitignorePath = path10.join(resolvedPath, ".gitignore");
   try {
-    const gitignore = await fs9.readFile(gitignorePath, "utf-8");
+    const gitignore = await fs10.readFile(gitignorePath, "utf-8");
     if (!gitignore.includes("*.db")) {
       warnings.push(".gitignore does not exclude database files");
     }
@@ -4657,7 +2287,7 @@ async function validateCentralRepo(repoPath) {
 async function getCentralRepoPath() {
   const globalConfig = await loadXdgConfig();
   if (globalConfig.centralRepo) {
-    return path11.resolve(expandPath(globalConfig.centralRepo));
+    return path10.resolve(expandPath(globalConfig.centralRepo));
   }
   return void 0;
 }
@@ -4763,9 +2393,9 @@ async function syncInit(options) {
   });
   await writeRegistry(centralRepo, updatedRegistry);
   console.log("  Registered mapping in central repository");
-  const centralDir = path12.join(centralRepo, centralPath);
+  const centralDir = path11.join(centralRepo, centralPath);
   try {
-    await fs10.mkdir(centralDir, { recursive: true });
+    await fs11.mkdir(centralDir, { recursive: true });
   } catch {
   }
   console.log();
@@ -4838,23 +2468,23 @@ async function syncRemove(options) {
   console.log(`Removed mapping from central registry`);
   console.log();
   console.log("Note: Files in the central repository were NOT deleted.");
-  console.log(`They remain at: ${formatPath(path12.join(centralRepo, centralPath))}`);
+  console.log(`They remain at: ${formatPath(path11.join(centralRepo, centralPath))}`);
 }
 
 // src/cli/sync/operations.ts
-import fs14 from "fs/promises";
-import path16 from "path";
-import crypto5 from "crypto";
+import fs15 from "fs/promises";
+import path15 from "path";
+import crypto4 from "crypto";
 
 // src/cli/sync/state.ts
-import fs11 from "fs/promises";
-import path13 from "path";
-import crypto4 from "crypto";
+import fs12 from "fs/promises";
+import path12 from "path";
+import crypto3 from "crypto";
 import { minimatch } from "minimatch";
 var STATE_FILENAME = "sync-state.json";
-var STATE_DIR = ".minimem";
 function getSyncStatePath(dir) {
-  return path13.join(dir, STATE_DIR, STATE_FILENAME);
+  const subdir = resolveConfigSubdir(dir);
+  return path12.join(dir, subdir, STATE_FILENAME);
 }
 function createEmptySyncState(centralPath) {
   return {
@@ -4868,7 +2498,7 @@ function createEmptySyncState(centralPath) {
 async function loadSyncState(dir, centralPath) {
   const statePath = getSyncStatePath(dir);
   try {
-    const content = await fs11.readFile(statePath, "utf-8");
+    const content = await fs12.readFile(statePath, "utf-8");
     const state = JSON.parse(content);
     if (!state.files || typeof state.files !== "object") {
       return createEmptySyncState(centralPath);
@@ -4888,27 +2518,28 @@ async function loadSyncState(dir, centralPath) {
 }
 async function saveSyncState(dir, state) {
   const statePath = getSyncStatePath(dir);
-  const stateDir = path13.dirname(statePath);
-  const tempPath = `${statePath}.${crypto4.randomBytes(4).toString("hex")}.tmp`;
-  await fs11.mkdir(stateDir, { recursive: true });
+  const stateDir = path12.dirname(statePath);
+  const tempPath = `${statePath}.${crypto3.randomBytes(4).toString("hex")}.tmp`;
+  await fs12.mkdir(stateDir, { recursive: true });
   state.version = state.version || 2;
-  await fs11.writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
-  await fs11.rename(tempPath, statePath);
+  await fs12.writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs12.rename(tempPath, statePath);
 }
 async function computeFileHash(filePath) {
-  const content = await fs11.readFile(filePath);
-  return crypto4.createHash("sha256").update(content).digest("hex");
+  const content = await fs12.readFile(filePath);
+  return crypto3.createHash("sha256").update(content).digest("hex");
 }
 async function listSyncableFiles(dir, include, exclude) {
   const files = [];
-  async function walkDir2(currentDir, relativePath = "") {
-    const entries = await fs11.readdir(currentDir, { withFileTypes: true });
+  async function walkDir(currentDir, relativePath = "") {
+    const entries = await fs12.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path13.join(currentDir, entry.name);
+      const entryPath = path12.join(currentDir, entry.name);
       const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-      if (entry.name === ".minimem") continue;
+      if (entry.name === ".minimem" || entry.name === ".swarm") continue;
+      if (entry.name === "index.db" || entry.name.startsWith("index.db-")) continue;
       if (entry.isDirectory()) {
-        await walkDir2(entryPath, relPath);
+        await walkDir(entryPath, relPath);
       } else if (entry.isFile()) {
         const matchesInclude = include.some(
           (pattern) => minimatch(relPath, pattern)
@@ -4923,7 +2554,7 @@ async function listSyncableFiles(dir, include, exclude) {
     }
   }
   try {
-    await walkDir2(dir);
+    await walkDir(dir);
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -4933,7 +2564,7 @@ async function listSyncableFiles(dir, include, exclude) {
 }
 async function getFileHashInfo(filePath) {
   try {
-    const stat = await fs11.stat(filePath);
+    const stat = await fs12.stat(filePath);
     const hash = await computeFileHash(filePath);
     return {
       exists: true,
@@ -4961,26 +2592,27 @@ function getFileSyncStatus(localHash, remoteHash) {
 }
 
 // src/cli/commands/conflicts.ts
-import fs13 from "fs/promises";
-import path15 from "path";
+import fs14 from "fs/promises";
+import path14 from "path";
 import { spawn } from "child_process";
 
 // src/cli/sync/conflicts.ts
-import fs12 from "fs/promises";
-import path14 from "path";
+import fs13 from "fs/promises";
+import path13 from "path";
 var CONFLICTS_DIR = "conflicts";
 function getConflictsDir(memoryDir) {
-  return path14.join(memoryDir, ".minimem", CONFLICTS_DIR);
+  const subdir = resolveConfigSubdir(memoryDir);
+  return path13.join(memoryDir, subdir, CONFLICTS_DIR);
 }
 async function listQuarantinedConflicts(memoryDir) {
   const conflictsDir = getConflictsDir(memoryDir);
   const conflicts = [];
   try {
-    const entries = await fs12.readdir(conflictsDir, { withFileTypes: true });
+    const entries = await fs13.readdir(conflictsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const dirPath = path14.join(conflictsDir, entry.name);
-        const files = await fs12.readdir(dirPath);
+        const dirPath = path13.join(conflictsDir, entry.name);
+        const files = await fs13.readdir(dirPath);
         const uniqueFiles = /* @__PURE__ */ new Set();
         for (const file of files) {
           const baseName = file.replace(/\.(local|remote|base)$/, "");
@@ -5005,7 +2637,7 @@ async function detectChanges(memoryDir) {
   if (!syncConfig.path) {
     throw new Error("Directory is not configured for sync");
   }
-  const remotePath = path14.join(centralRepo, syncConfig.path);
+  const remotePath = path13.join(centralRepo, syncConfig.path);
   const [localFiles, remoteFiles] = await Promise.all([
     listSyncableFiles(memoryDir, syncConfig.include, syncConfig.exclude),
     listSyncableFiles(remotePath, syncConfig.include, syncConfig.exclude)
@@ -5020,8 +2652,8 @@ async function detectChanges(memoryDir) {
     localModified: 0
   };
   for (const file of allFiles) {
-    const localPath = path14.join(memoryDir, file);
-    const remoteFilePath = path14.join(remotePath, file);
+    const localPath = path13.join(memoryDir, file);
+    const remoteFilePath = path13.join(remotePath, file);
     const [localInfo, remoteInfo] = await Promise.all([
       getFileHashInfo(localPath),
       getFileHashInfo(remoteFilePath)
@@ -5101,9 +2733,9 @@ async function resolveCommand(timestamp, options) {
   if (!await isInitialized(memoryDir)) {
     exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
-  const conflictDir = path15.join(getConflictsDir(memoryDir), timestamp);
+  const conflictDir = path14.join(getConflictsDir(memoryDir), timestamp);
   try {
-    await fs13.access(conflictDir);
+    await fs14.access(conflictDir);
   } catch {
     exitWithError(
       `Conflict '${timestamp}' not found.`,
@@ -5111,7 +2743,7 @@ async function resolveCommand(timestamp, options) {
     );
   }
   try {
-    const files = await fs13.readdir(conflictDir);
+    const files = await fs14.readdir(conflictDir);
     const fileGroups = /* @__PURE__ */ new Map();
     for (const file of files) {
       const match = file.match(/^(.+)\.(local|remote|base)$/);
@@ -5121,7 +2753,7 @@ async function resolveCommand(timestamp, options) {
           fileGroups.set(baseName, {});
         }
         const group = fileGroups.get(baseName);
-        group[type] = path15.join(conflictDir, file);
+        group[type] = path14.join(conflictDir, file);
       }
     }
     if (fileGroups.size === 0) {
@@ -5194,7 +2826,7 @@ async function cleanupCommand(options) {
     const conflictsDir = getConflictsDir(memoryDir);
     let entries = [];
     try {
-      entries = await fs13.readdir(conflictsDir);
+      entries = await fs14.readdir(conflictsDir);
     } catch {
       console.log("No conflicts directory found.");
       return;
@@ -5208,12 +2840,12 @@ async function cleanupCommand(options) {
         console.log(`  Skipping invalid timestamp: ${entry}`);
         continue;
       }
-      const entryPath = path15.join(conflictsDir, entry);
+      const entryPath = path14.join(conflictsDir, entry);
       if (entryDate < cutoffDate) {
         if (options.dryRun) {
           console.log(`  Would remove: ${entry}`);
         } else {
-          await fs13.rm(entryPath, { recursive: true, force: true });
+          await fs14.rm(entryPath, { recursive: true, force: true });
           console.log(`  Removed: ${entry}`);
         }
         cleaned++;
@@ -5236,15 +2868,16 @@ Removed ${cleaned} conflict(s), kept ${kept}`);
 var SYNC_LOG_FILE = "sync.log";
 var MAX_LOG_ENTRIES = 1e3;
 function getSyncLogPath(memoryDir) {
-  return path15.join(memoryDir, ".minimem", SYNC_LOG_FILE);
+  const subdir = resolveConfigSubdir(memoryDir);
+  return path14.join(memoryDir, subdir, SYNC_LOG_FILE);
 }
 async function appendSyncLog(memoryDir, entry) {
   const logPath = getSyncLogPath(memoryDir);
   try {
-    await fs13.mkdir(path15.dirname(logPath), { recursive: true });
+    await fs14.mkdir(path14.dirname(logPath), { recursive: true });
     let entries = [];
     try {
-      const content2 = await fs13.readFile(logPath, "utf-8");
+      const content2 = await fs14.readFile(logPath, "utf-8");
       entries = content2.split("\n").filter(Boolean).map((line) => JSON.parse(line));
     } catch {
     }
@@ -5253,7 +2886,7 @@ async function appendSyncLog(memoryDir, entry) {
       entries = entries.slice(-MAX_LOG_ENTRIES);
     }
     const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    await fs13.writeFile(logPath, content);
+    await fs14.writeFile(logPath, content);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     warn(`Failed to write sync log: ${message}`);
@@ -5262,7 +2895,7 @@ async function appendSyncLog(memoryDir, entry) {
 async function readSyncLog(memoryDir) {
   const logPath = getSyncLogPath(memoryDir);
   try {
-    const content = await fs13.readFile(logPath, "utf-8");
+    const content = await fs14.readFile(logPath, "utf-8");
     return content.split("\n").filter(Boolean).map((line) => JSON.parse(line));
   } catch {
     return [];
@@ -5311,19 +2944,19 @@ async function logCommand(options) {
 }
 
 // src/cli/sync/operations.ts
-async function ensureDir2(dirPath) {
-  await fs14.mkdir(dirPath, { recursive: true });
+async function ensureDir(dirPath) {
+  await fs15.mkdir(dirPath, { recursive: true });
 }
 async function copyFileAtomic(src, dest) {
-  const destDir = path16.dirname(dest);
-  await ensureDir2(destDir);
-  const tempDest = `${dest}.${crypto5.randomBytes(4).toString("hex")}.tmp`;
+  const destDir = path15.dirname(dest);
+  await ensureDir(destDir);
+  const tempDest = `${dest}.${crypto4.randomBytes(4).toString("hex")}.tmp`;
   try {
-    await fs14.copyFile(src, tempDest);
-    await fs14.rename(tempDest, dest);
+    await fs15.copyFile(src, tempDest);
+    await fs15.rename(tempDest, dest);
   } catch (error) {
     try {
-      await fs14.unlink(tempDest);
+      await fs15.unlink(tempDest);
     } catch {
     }
     throw error;
@@ -5349,7 +2982,7 @@ async function push(memoryDir, options = {}) {
     result.errors.push("No central repository configured");
     return result;
   }
-  const remotePath = path16.join(centralRepo, syncConfig.path);
+  const remotePath = path15.join(centralRepo, syncConfig.path);
   const state = await loadSyncState(memoryDir, syncConfig.path);
   const localFiles = await listSyncableFiles(
     memoryDir,
@@ -5363,8 +2996,8 @@ async function push(memoryDir, options = {}) {
   );
   const allFiles = /* @__PURE__ */ new Set([...localFiles, ...remoteFiles]);
   for (const file of allFiles) {
-    const localPath = path16.join(memoryDir, file);
-    const remoteFilePath = path16.join(remotePath, file);
+    const localPath = path15.join(memoryDir, file);
+    const remoteFilePath = path15.join(remotePath, file);
     try {
       const [localInfo, remoteInfo] = await Promise.all([
         getFileHashInfo(localPath),
@@ -5443,7 +3076,7 @@ async function pull(memoryDir, options = {}) {
     result.errors.push("No central repository configured");
     return result;
   }
-  const remotePath = path16.join(centralRepo, syncConfig.path);
+  const remotePath = path15.join(centralRepo, syncConfig.path);
   const state = await loadSyncState(memoryDir, syncConfig.path);
   const localFiles = await listSyncableFiles(
     memoryDir,
@@ -5457,8 +3090,8 @@ async function pull(memoryDir, options = {}) {
   );
   const allFiles = /* @__PURE__ */ new Set([...localFiles, ...remoteFiles]);
   for (const file of allFiles) {
-    const localPath = path16.join(memoryDir, file);
-    const remoteFilePath = path16.join(remotePath, file);
+    const localPath = path15.join(memoryDir, file);
+    const remoteFilePath = path15.join(remotePath, file);
     try {
       const [localInfo, remoteInfo] = await Promise.all([
         getFileHashInfo(localPath),
@@ -5696,21 +3329,21 @@ async function syncStatusCommand(options) {
 }
 
 // src/cli/commands/daemon.ts
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 
 // src/cli/sync/daemon.ts
-import fs16 from "fs/promises";
-import path19 from "path";
+import fs17 from "fs/promises";
+import path18 from "path";
 import os6 from "os";
 
 // src/cli/sync/watcher.ts
-import chokidar2 from "chokidar";
-import path17 from "path";
+import chokidar from "chokidar";
+import path16 from "path";
 import { EventEmitter } from "events";
 var DEFAULT_DEBOUNCE_MS = 2e3;
 var DEFAULT_POLL_INTERVAL = 1e3;
 var DEFAULT_INCLUDE = ["MEMORY.md", "memory/**/*.md"];
-var DEFAULT_EXCLUDE = [".minimem/**", "node_modules/**", ".git/**"];
+var DEFAULT_EXCLUDE = [".minimem/**", "index.db", "index.db-*", "node_modules/**", ".git/**"];
 function createFileWatcher(memoryDir, options = {}) {
   const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   const include = options.include ?? DEFAULT_INCLUDE;
@@ -5735,8 +3368,11 @@ function createFileWatcher(memoryDir, options = {}) {
     debounceTimer = setTimeout(flushChanges, debounceMs);
   };
   const handleEvent = (event, filePath) => {
-    const relativePath = path17.relative(memoryDir, filePath);
-    if (relativePath.startsWith(".minimem")) {
+    const relativePath = path16.relative(memoryDir, filePath);
+    if (relativePath.startsWith(".minimem") || relativePath.startsWith(".swarm")) {
+      return;
+    }
+    if (relativePath === "index.db" || relativePath.startsWith("index.db-")) {
       return;
     }
     const isIncluded = include.some((pattern) => {
@@ -5766,9 +3402,9 @@ function createFileWatcher(memoryDir, options = {}) {
     pendingChanges.set(relativePath, { event, file: relativePath });
     scheduleFlush();
   };
-  const watchPaths = include.map((pattern) => path17.join(memoryDir, pattern));
-  watcher = chokidar2.watch(watchPaths, {
-    ignored: exclude.map((pattern) => path17.join(memoryDir, pattern)),
+  const watchPaths = include.map((pattern) => path16.join(memoryDir, pattern));
+  watcher = chokidar.watch(watchPaths, {
+    ignored: exclude.map((pattern) => path16.join(memoryDir, pattern)),
     persistent: true,
     ignoreInitial: true,
     usePolling: options.usePolling ?? false,
@@ -5808,8 +3444,8 @@ function createFileWatcher(memoryDir, options = {}) {
 }
 
 // src/cli/sync/validation.ts
-import fs15 from "fs/promises";
-import path18 from "path";
+import fs16 from "fs/promises";
+import path17 from "path";
 var STALE_THRESHOLD_DAYS = 30;
 async function validateRegistry() {
   const result = {
@@ -5893,7 +3529,7 @@ async function validateRegistry() {
     if (mapping.machineId === currentMachineId) {
       const localPath = expandPath3(mapping.localPath);
       try {
-        await fs15.access(localPath);
+        await fs16.access(localPath);
       } catch {
         result.issues.push({
           type: "missing",
@@ -5911,7 +3547,7 @@ async function validateRegistry() {
 }
 function expandPath3(p) {
   if (p.startsWith("~/")) {
-    return path18.join(process.env.HOME || "", p.slice(2));
+    return path17.join(process.env.HOME || "", p.slice(2));
   }
   return p;
 }
@@ -5951,18 +3587,18 @@ var DAEMON_LOG_FILE = "daemon.log";
 var PID_FILE = "daemon.pid";
 var MAX_LOG_SIZE = 1024 * 1024;
 function getDaemonDir() {
-  return path19.join(os6.homedir(), ".minimem");
+  return path18.join(os6.homedir(), ".minimem");
 }
 function getPidFilePath() {
-  return path19.join(getDaemonDir(), PID_FILE);
+  return path18.join(getDaemonDir(), PID_FILE);
 }
 function getDaemonLogPath() {
-  return path19.join(getDaemonDir(), DAEMON_LOG_FILE);
+  return path18.join(getDaemonDir(), DAEMON_LOG_FILE);
 }
 async function isDaemonRunning() {
   const pidFile = getPidFilePath();
   try {
-    const content = await fs16.readFile(pidFile, "utf-8");
+    const content = await fs17.readFile(pidFile, "utf-8");
     const pid = parseInt(content.trim(), 10);
     if (isNaN(pid)) {
       return false;
@@ -5971,7 +3607,7 @@ async function isDaemonRunning() {
       process.kill(pid, 0);
       return true;
     } catch {
-      await fs16.unlink(pidFile).catch(() => {
+      await fs17.unlink(pidFile).catch(() => {
       });
       return false;
     }
@@ -5985,7 +3621,7 @@ async function getDaemonStatus() {
     return { running: false };
   }
   const pidFile = getPidFilePath();
-  const content = await fs16.readFile(pidFile, "utf-8");
+  const content = await fs17.readFile(pidFile, "utf-8");
   const pid = parseInt(content.trim(), 10);
   return {
     running: true,
@@ -5998,15 +3634,15 @@ async function writeLog(message, level = "info") {
   const line = `[${timestamp}] [${level.toUpperCase()}] ${message}
 `;
   try {
-    await fs16.mkdir(path19.dirname(logPath), { recursive: true });
+    await fs17.mkdir(path18.dirname(logPath), { recursive: true });
     try {
-      const stats = await fs16.stat(logPath);
+      const stats = await fs17.stat(logPath);
       if (stats.size > MAX_LOG_SIZE) {
-        await fs16.rename(logPath, `${logPath}.old`);
+        await fs17.rename(logPath, `${logPath}.old`);
       }
     } catch {
     }
-    await fs16.appendFile(logPath, line);
+    await fs17.appendFile(logPath, line);
   } catch (error) {
     console.error(`Failed to write log: ${error}`);
   }
@@ -6041,8 +3677,8 @@ async function startDaemon(options = {}) {
     throw new Error("Daemon is already running");
   }
   const daemonDir = getDaemonDir();
-  await fs16.mkdir(daemonDir, { recursive: true });
-  await fs16.writeFile(getPidFilePath(), String(process.pid));
+  await fs17.mkdir(daemonDir, { recursive: true });
+  await fs17.writeFile(getPidFilePath(), String(process.pid));
   await writeLog("Daemon starting");
   const centralRepo = await getCentralRepoPath();
   if (!centralRepo) {
@@ -6133,7 +3769,7 @@ async function startDaemon(options = {}) {
     }
     watchedDirs.clear();
     try {
-      await fs16.unlink(getPidFilePath());
+      await fs17.unlink(getPidFilePath());
     } catch {
     }
     await writeLog("Daemon stopped");
@@ -6257,7 +3893,7 @@ async function daemonStatusCommand() {
 async function daemonLogsCommand(options) {
   const logPath = getDaemonLogPath();
   try {
-    const content = await fs17.readFile(logPath, "utf-8");
+    const content = await fs18.readFile(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const numLines = options.lines ?? 50;
     const displayLines = lines.slice(-numLines);
@@ -6266,12 +3902,12 @@ async function daemonLogsCommand(options) {
     }
     if (options.follow) {
       console.log("\n--- Following log (Ctrl+C to stop) ---\n");
-      let lastSize = (await fs17.stat(logPath)).size;
+      let lastSize = (await fs18.stat(logPath)).size;
       const poll = async () => {
         try {
-          const stats = await fs17.stat(logPath);
+          const stats = await fs18.stat(logPath);
           if (stats.size > lastSize) {
-            const fd = await fs17.open(logPath, "r");
+            const fd = await fs18.open(logPath, "r");
             const buffer = Buffer.alloc(stats.size - lastSize);
             await fd.read(buffer, 0, buffer.length, lastSize);
             await fd.close();
@@ -6300,6 +3936,129 @@ async function daemonLogsCommand(options) {
   }
 }
 
+// src/cli/commands/store.ts
+import path19 from "path";
+async function storeList(options) {
+  const manifest = await loadManifest();
+  const storeNames = Object.keys(manifest.stores);
+  if (storeNames.length === 0) {
+    console.log("No stores registered.");
+    console.log(`
+Register a store with: minimem store:add <name> <path>`);
+    return;
+  }
+  if (options.json) {
+    const result = {};
+    for (const name of storeNames) {
+      const def = manifest.stores[name];
+      const links = await getLinkedStoreNames(manifest, name);
+      result[name] = { path: def.path, remote: def.remote, links };
+    }
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Registered stores (${getManifestPath()}):
+`);
+  for (const name of storeNames) {
+    const def = manifest.stores[name];
+    const links = await getLinkedStoreNames(manifest, name);
+    console.log(`  ${name}`);
+    console.log(`    path: ${formatPath(def.path)}`);
+    if (def.remote) {
+      console.log(`    remote: ${def.remote}`);
+    }
+    if (def.description) {
+      console.log(`    description: ${def.description}`);
+    }
+    if (links.length > 0) {
+      console.log(`    links: ${links.join(", ")}`);
+    }
+    console.log();
+  }
+}
+async function storeAdd(name, storePath, options) {
+  const manifest = await loadManifest();
+  const absPath = path19.resolve(storePath);
+  if (manifest.stores[name]) {
+    exitWithError(
+      `Store "${name}" already exists.`,
+      `Use a different name or remove it first with: minimem store:remove ${name}`
+    );
+  }
+  const def = {
+    path: absPath,
+    remote: options.remote,
+    description: options.description
+  };
+  manifest.stores[name] = def;
+  await saveManifest(manifest);
+  console.log(`Registered store "${name}" at ${formatPath(absPath)}`);
+  if (options.remote) {
+    console.log(`  remote: ${options.remote}`);
+  }
+  const result = await materializeStore(name, def);
+  if (result) {
+    if (result.strategy === "remote") {
+      console.log(`  Cloned remote into ${formatPath(result.path)}`);
+    }
+    await result.cleanup();
+  } else if (options.remote) {
+    console.log(`  Warning: could not materialize store (remote clone failed)`);
+  }
+}
+async function storeRemove(name) {
+  const manifest = await loadManifest();
+  if (!manifest.stores[name]) {
+    exitWithError(`Store "${name}" not found.`);
+  }
+  delete manifest.stores[name];
+  await saveManifest(manifest);
+  console.log(`Removed store "${name}"`);
+}
+async function storeLink(storeName, targetName) {
+  const manifest = await loadManifest();
+  const storeDef = manifest.stores[storeName];
+  if (!storeDef) {
+    exitWithError(
+      `Store "${storeName}" not found.`,
+      `Register it first with: minimem store:add ${storeName} <path>`
+    );
+  }
+  if (!manifest.stores[targetName]) {
+    exitWithError(
+      `Target store "${targetName}" not found.`,
+      `Register it first with: minimem store:add ${targetName} <path>`
+    );
+  }
+  if (storeName === targetName) {
+    exitWithError("Cannot link a store to itself.");
+  }
+  const links = await loadStoreLinks(storeDef.path);
+  if (links.links.includes(targetName)) {
+    console.log(`Store "${storeName}" already links to "${targetName}"`);
+    return;
+  }
+  links.links.push(targetName);
+  await saveStoreLinks(storeDef.path, links);
+  console.log(`Linked "${storeName}" \u2192 "${targetName}"`);
+  console.log(`  When searching "${storeName}", "${targetName}" will be included automatically.`);
+}
+async function storeUnlink(storeName, targetName) {
+  const manifest = await loadManifest();
+  const storeDef = manifest.stores[storeName];
+  if (!storeDef) {
+    exitWithError(`Store "${storeName}" not found.`);
+  }
+  const links = await loadStoreLinks(storeDef.path);
+  if (!links.links.includes(targetName)) {
+    console.log(`Store "${storeName}" does not link to "${targetName}"`);
+    return;
+  }
+  links.links = links.links.filter((l) => l !== targetName);
+  await saveStoreLinks(storeDef.path, links);
+  console.log(`Unlinked "${storeName}" from "${targetName}"`);
+}
+
 // src/cli/version.ts
 import { readFileSync } from "fs";
 import { dirname as dirname3, join as join4 } from "path";
@@ -6320,7 +4079,7 @@ var VERSION = getPackageVersion();
 // src/cli/index.ts
 program.name("minimem").description("File-based memory system with vector search for AI agents").version(VERSION);
 program.command("init [dir]").description("Initialize a memory directory").option("-g, --global", "Use ~/.minimem as global memory directory").option("-f, --force", "Reinitialize even if already initialized").action(init);
-program.command("search <query>").description("Semantic search through memory files").option("-d, --dir <path...>", "Memory directories (can specify multiple)").option("-g, --global", "Include ~/.minimem in search").option("-n, --max <number>", "Maximum results (default: 10)").option("-s, --min-score <number>", "Minimum score threshold 0-1 (default: 0.3)").option("-p, --provider <name>", "Embedding provider (openai, gemini, local, auto)").option("--json", "Output results as JSON").action(search);
+program.command("search <query>").description("Semantic search through memory files").option("-d, --dir <path...>", "Memory directories (can specify multiple)").option("-g, --global", "Include ~/.minimem in search").option("-n, --max <number>", "Maximum results (default: 10)").option("-s, --min-score <number>", "Minimum score threshold 0-1 (default: 0.3)").option("-p, --provider <name>", "Embedding provider (openai, gemini, local, auto)").option("--json", "Output results as JSON").option("--no-links", "Disable linked store resolution").action(search);
 program.command("sync").description("Force re-index memory files").option("-d, --dir <path>", "Memory directory").option("-g, --global", "Use ~/.minimem").option("-f, --force", "Force full re-index").option("-p, --provider <name>", "Embedding provider (openai, gemini, local, auto)").action(sync);
 program.command("status").description("Show index stats and provider info").option("-d, --dir <path>", "Memory directory").option("-g, --global", "Use ~/.minimem").option("-p, --provider <name>", "Embedding provider (openai, gemini, local, auto)").option("--json", "Output as JSON").action(status);
 program.command("append <text>").description("Append text to today's daily log (memory/YYYY-MM-DD.md)").option("-d, --dir <path>", "Memory directory").option("-g, --global", "Use ~/.minimem").option("-f, --file <path>", "Append to specific file instead of today's log").option("-p, --provider <name>", "Embedding provider (openai, gemini, local, auto)").option("-s, --session <id>", "Session ID to associate with this memory").option("--session-source <name>", "Session source (claude-code, vscode, etc.)").action(append);
@@ -6358,5 +4117,10 @@ program.command("sync:validate").description("Validate registry for collisions a
     exitWithError(message);
   }
 });
+program.command("store:list").description("List all registered stores and their links").option("--json", "Output as JSON").action(storeList);
+program.command("store:add <name> <path>").description("Register a store in the global manifest").option("-r, --remote <url>", "Git remote URL for remote materialization").option("--description <text>", "Human-readable description").action(storeAdd);
+program.command("store:remove <name>").description("Remove a store from the global manifest").action(storeRemove);
+program.command("store:link <store> <target>").description("Link a store to another (searches include linked stores)").action(storeLink);
+program.command("store:unlink <store> <target>").description("Remove a link between stores").action(storeUnlink);
 program.parse();
 //# sourceMappingURL=index.js.map