minimem 0.0.3 → 0.0.4

package/dist/cli/index.js

@@ -5,20 +5,21 @@ import { program } from "commander";
 
 // src/cli/commands/init.ts
 import fs2 from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 
 // src/cli/config.ts
 import fs from "fs/promises";
-import path from "path";
-import os from "os";
+import path2 from "path";
+import os2 from "os";
 import crypto from "crypto";
-var CONFIG_FILENAME = "config.json";
-var CONFIG_DIR = ".minimem";
-var GLOBAL_DIR = ".minimem";
-var XDG_CONFIG_DIR = ".config/minimem";
+
+// src/cli/shared.ts
+import * as path from "path";
+import * as os from "os";
 function resolveMemoryDir(options) {
-  if (options.dir) {
-    return path.resolve(options.dir);
+  const dir = Array.isArray(options.dir) ? options.dir[0] : options.dir;
+  if (dir) {
+    return path.resolve(dir);
   }
   const envDir = process.env.MEMORY_DIR;
   if (envDir) {
@@ -29,27 +30,81 @@ function resolveMemoryDir(options) {
   }
   return process.cwd();
 }
+function resolveMemoryDirs(options) {
+  const dirs = [];
+  if (options.dir) {
+    const dirList = Array.isArray(options.dir) ? options.dir : [options.dir];
+    dirs.push(...dirList.map((d) => path.resolve(d)));
+  }
+  if (dirs.length === 0 && process.env.MEMORY_DIR) {
+    dirs.push(path.resolve(process.env.MEMORY_DIR));
+  }
+  if (options.global) {
+    const globalDir = path.join(os.homedir(), ".minimem");
+    if (!dirs.includes(globalDir)) {
+      dirs.push(globalDir);
+    }
+  }
+  if (dirs.length === 0) {
+    dirs.push(process.cwd());
+  }
+  return [...new Set(dirs)];
+}
+function getGlobalMemoryDir() {
+  return path.join(os.homedir(), ".minimem");
+}
+function exitWithError(message, suggestion) {
+  console.error(`Error: ${message}`);
+  if (suggestion) {
+    console.error(`  Suggestion: ${suggestion}`);
+  }
+  process.exit(1);
+}
+function warn(message) {
+  console.error(`Warning: ${message}`);
+}
+function note(message) {
+  console.error(`Note: ${message}`);
+}
+function getDirName(memoryDir) {
+  const home = os.homedir();
+  if (memoryDir === path.join(home, ".minimem")) {
+    return "global";
+  }
+  const name = path.basename(memoryDir);
+  if (name.startsWith(".")) {
+    const parent = path.basename(path.dirname(memoryDir));
+    return `${parent}/${name}`;
+  }
+  return name;
+}
+
+// src/cli/config.ts
+var CONFIG_FILENAME = "config.json";
+var CONFIG_DIR = ".minimem";
+var GLOBAL_DIR = ".minimem";
+var XDG_CONFIG_DIR = ".config/minimem";
 function getGlobalDir() {
-  return path.join(os.homedir(), GLOBAL_DIR);
+  return path2.join(os2.homedir(), GLOBAL_DIR);
 }
 function getGlobalConfigPath() {
-  return path.join(getGlobalDir(), CONFIG_DIR, CONFIG_FILENAME);
+  return path2.join(getGlobalDir(), CONFIG_DIR, CONFIG_FILENAME);
 }
 function getConfigPath(memoryDir) {
-  return path.join(memoryDir, CONFIG_DIR, CONFIG_FILENAME);
+  return path2.join(memoryDir, CONFIG_DIR, CONFIG_FILENAME);
 }
 function getXdgConfigDir() {
-  return path.join(os.homedir(), XDG_CONFIG_DIR);
+  return path2.join(os2.homedir(), XDG_CONFIG_DIR);
 }
 function getXdgConfigPath() {
-  return path.join(getXdgConfigDir(), CONFIG_FILENAME);
+  return path2.join(getXdgConfigDir(), CONFIG_FILENAME);
 }
 function expandPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return path.join(os.homedir(), filePath.slice(2));
+    return path2.join(os2.homedir(), filePath.slice(2));
   }
   if (filePath === "~") {
-    return os.homedir();
+    return os2.homedir();
   }
   return filePath;
 }
@@ -72,7 +127,7 @@ async function getMachineId() {
   if (globalConfig.machineId) {
     return globalConfig.machineId;
   }
-  const hostname = os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const hostname = os2.hostname().toLowerCase().replace(/[^a-z0-9-]/g, "-");
   const suffix = crypto.randomBytes(2).toString("hex");
   const machineId = `${hostname}-${suffix}`;
   await saveXdgConfig({ ...globalConfig, machineId });
@@ -91,7 +146,7 @@ async function loadGlobalConfig() {
 }
 async function loadConfig(memoryDir) {
   const globalDir = getGlobalDir();
-  const isGlobalDir = path.resolve(memoryDir) === globalDir;
+  const isGlobalDir = path2.resolve(memoryDir) === globalDir;
   const globalConfig = isGlobalDir ? {} : await loadGlobalConfig();
   const localConfig = await loadConfigFile(getConfigPath(memoryDir));
   return deepMergeConfig(globalConfig, localConfig);
@@ -119,6 +174,9 @@ function deepMergeConfig(target, source) {
   if (source.chunking) {
     result.chunking = { ...target.chunking, ...source.chunking };
   }
+  if (source.hooks) {
+    result.hooks = { ...target.hooks, ...source.hooks };
+  }
   if (source.sync) {
     result.sync = { ...target.sync, ...source.sync };
     if (source.sync.include) {
@@ -131,7 +189,7 @@ function deepMergeConfig(target, source) {
   return result;
 }
 async function saveConfig(memoryDir, config2) {
-  const configDir = path.join(memoryDir, CONFIG_DIR);
+  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");
@@ -174,7 +232,7 @@ function getDefaultGlobalSyncConfig() {
 }
 async function loadFullConfig(memoryDir) {
   const globalDir = getGlobalDir();
-  const isGlobalDir = path.resolve(memoryDir) === globalDir;
+  const isGlobalDir = path2.resolve(memoryDir) === globalDir;
   const xdgConfig = await loadXdgConfig();
   const legacyGlobalConfig = isGlobalDir ? {} : await loadGlobalConfig();
   const localConfig = await loadConfigFile(getConfigPath(memoryDir));
@@ -258,7 +316,7 @@ async function isInitialized(memoryDir) {
   }
 }
 function formatPath(filePath) {
-  const home = os.homedir();
+  const home = os2.homedir();
   if (filePath.startsWith(home)) {
     return "~" + filePath.slice(home.length);
   }
@@ -289,9 +347,9 @@ async function init(dir, options) {
   }
   console.log(`Initializing minimem in ${displayPath}...`);
   await fs2.mkdir(memoryDir, { recursive: true });
-  await fs2.mkdir(path2.join(memoryDir, "memory"), { recursive: true });
-  await fs2.mkdir(path2.join(memoryDir, ".minimem"), { recursive: true });
-  const memoryFilePath = path2.join(memoryDir, "MEMORY.md");
+  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");
@@ -302,7 +360,7 @@ async function init(dir, options) {
   const config2 = getInitConfig();
   await saveConfig(memoryDir, config2);
   console.log("  Created .minimem/config.json");
-  const gitignorePath = path2.join(memoryDir, ".minimem", ".gitignore");
+  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();
@@ -319,14 +377,10 @@ async function init(dir, options) {
   console.log(`     minimem search "your query"${dir ? ` --dir ${dir}` : ""}`);
 }
 
-// src/cli/commands/search.ts
-import * as path6 from "path";
-import * as os3 from "os";
-
 // src/minimem.ts
 import { randomUUID } from "crypto";
 import fs4 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { DatabaseSync } from "node:sqlite";
 import chokidar from "chokidar";
 
@@ -334,11 +388,20 @@ import chokidar from "chokidar";
 import crypto2 from "crypto";
 import fsSync from "fs";
 import fs3 from "fs/promises";
-import path3 from "path";
-function ensureDir(dir) {
+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 {
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code !== "EEXIST") {
+      logError2("ensureDir", error, debug);
+    }
   }
   return dir;
 }
@@ -353,7 +416,7 @@ async function exists(filePath) {
 async function walkDir(dir, files) {
   const entries = await fs3.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path3.join(dir, entry.name);
+    const full = path4.join(dir, entry.name);
     if (entry.isDirectory()) {
       await walkDir(full, files);
       continue;
@@ -365,11 +428,33 @@ async function walkDir(dir, files) {
 }
 async function listMemoryFiles(memoryDir) {
   const result = [];
-  const memoryFile = path3.join(memoryDir, "MEMORY.md");
-  const altMemoryFile = path3.join(memoryDir, "memory.md");
-  if (await exists(memoryFile)) result.push(memoryFile);
-  if (await exists(altMemoryFile)) result.push(altMemoryFile);
-  const memorySubDir = path3.join(memoryDir, "memory");
+  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);
   }
@@ -396,15 +481,22 @@ async function buildFileEntry(absPath, memoryDir) {
   const content = await fs3.readFile(absPath, "utf-8");
   const hash = hashText(content);
   return {
-    path: path3.relative(memoryDir, absPath).replace(/\\/g, "/"),
+    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 lines = content.split("\n");
+  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);
@@ -468,6 +560,10 @@ function chunkMarkdown(content, chunking) {
   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);
@@ -496,6 +592,9 @@ 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) {
@@ -505,8 +604,11 @@ function buildFtsQuery(raw) {
   return quoted.join(" AND ");
 }
 function bm25RankToScore(rank) {
-  const normalized = Number.isFinite(rank) ? Math.max(0, rank) : 999;
-  return 1 / (1 + normalized);
+  if (!Number.isFinite(rank)) {
+    return 0;
+  }
+  const absRank = Math.abs(rank);
+  return 1 / (1 + absRank);
 }
 function mergeHybridResults(params) {
   const byId = /* @__PURE__ */ new Map();
@@ -540,8 +642,17 @@ function mergeHybridResults(params) {
       });
     }
   }
+  let vw = params.vectorWeight;
+  let tw = params.textWeight;
+  if (params.vector.length === 0 && params.keyword.length > 0) {
+    vw = 0;
+    tw = 1;
+  } else if (params.keyword.length === 0 && params.vector.length > 0) {
+    vw = 1;
+    tw = 0;
+  }
   const merged = Array.from(byId.values()).map((entry) => {
-    const score = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+    const score = vw * entry.vectorScore + tw * entry.textScore;
     return {
       path: entry.path,
       startLine: entry.startLine,
@@ -555,7 +666,33 @@ function mergeHybridResults(params) {
 }
 
 // src/search/search.ts
-var vectorToBlob = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
+function buildKnowledgeFilterSql(opts) {
+  const clauses = [];
+  const params = [];
+  if (opts.knowledgeType) {
+    clauses.push(` AND c.knowledge_type = ?`);
+    params.push(opts.knowledgeType);
+  }
+  if (opts.minConfidence !== void 0) {
+    clauses.push(` AND c.confidence >= ?`);
+    params.push(opts.minConfidence);
+  }
+  if (opts.domain && opts.domain.length > 0) {
+    const domainPlaceholders = opts.domain.map(() => "?").join(", ");
+    clauses.push(
+      ` AND EXISTS (SELECT 1 FROM json_each(c.domains) AS d WHERE d.value IN (${domainPlaceholders}))`
+    );
+    params.push(...opts.domain);
+  }
+  if (opts.entities && opts.entities.length > 0) {
+    const entityPlaceholders = opts.entities.map(() => "?").join(", ");
+    clauses.push(
+      ` AND EXISTS (SELECT 1 FROM json_each(c.entities) AS e WHERE e.value IN (${entityPlaceholders}))`
+    );
+    params.push(...opts.entities);
+  }
+  return { sql: clauses.join(""), params };
+}
 async function searchVector(params) {
   if (params.queryVec.length === 0 || params.limit <= 0) return [];
   if (await params.ensureVectorReady(params.queryVec.length)) {
@@ -647,6 +784,7 @@ async function searchKeyword(params) {
 }
 
 // src/db/schema.ts
+var SCHEMA_VERSION = 4;
 function ensureMemoryIndexSchema(params) {
   params.db.exec(`
     CREATE TABLE IF NOT EXISTS meta (
@@ -654,6 +792,7 @@ function ensureMemoryIndexSchema(params) {
       value TEXT NOT NULL
     );
   `);
+  const migrated = migrateIfNeeded(params.db, params.ftsTable);
   params.db.exec(`
     CREATE TABLE IF NOT EXISTS files (
       path TEXT PRIMARY KEY,
@@ -716,9 +855,61 @@ function ensureMemoryIndexSchema(params) {
   }
   ensureColumn(params.db, "files", "source", "TEXT NOT NULL DEFAULT 'memory'");
   ensureColumn(params.db, "chunks", "source", "TEXT NOT NULL DEFAULT 'memory'");
+  ensureColumn(params.db, "chunks", "type", "TEXT");
+  ensureColumn(params.db, "chunks", "knowledge_type", "TEXT");
+  ensureColumn(params.db, "chunks", "knowledge_id", "TEXT");
+  ensureColumn(params.db, "chunks", "domains", "TEXT");
+  ensureColumn(params.db, "chunks", "entities", "TEXT");
+  ensureColumn(params.db, "chunks", "confidence", "REAL");
   params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);`);
   params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source);`);
-  return { ftsAvailable, ...ftsError ? { ftsError } : {} };
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_type ON chunks(type);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_knowledge_type ON chunks(knowledge_type);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_knowledge_id ON chunks(knowledge_id);`);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_links (
+      from_id TEXT NOT NULL,
+      to_id TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      layer TEXT,
+      weight REAL DEFAULT 0.5,
+      source_path TEXT,
+      created_at INTEGER,
+      PRIMARY KEY (from_id, to_id, relation)
+    );
+  `);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_from ON knowledge_links(from_id);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_to ON knowledge_links(to_id);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_layer ON knowledge_links(layer);`);
+  params.db.prepare(
+    `INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)`
+  ).run(String(SCHEMA_VERSION));
+  return { ftsAvailable, ...ftsError ? { ftsError } : {}, ...migrated ? { migrated } : {} };
+}
+function migrateIfNeeded(db, ftsTable) {
+  let storedVersion = 0;
+  try {
+    const row = db.prepare(
+      `SELECT value FROM meta WHERE key = 'schema_version'`
+    ).get();
+    if (row) {
+      storedVersion = parseInt(row.value, 10) || 0;
+    }
+  } catch {
+    storedVersion = 0;
+  }
+  if (storedVersion >= SCHEMA_VERSION) return false;
+  if (storedVersion > 0 && storedVersion < SCHEMA_VERSION) {
+    db.exec(`DROP TABLE IF EXISTS files`);
+    db.exec(`DROP TABLE IF EXISTS chunks`);
+    db.exec(`DROP TABLE IF EXISTS knowledge_links`);
+    db.exec(`DROP TABLE IF EXISTS ${ftsTable}`);
+    try {
+      db.exec(`DROP TABLE IF EXISTS chunks_vec`);
+    } catch {
+    }
+  }
+  return storedVersion > 0;
 }
 function ensureColumn(db, table, column, definition) {
   const rows = db.prepare(`PRAGMA table_info(${table})`).all();
@@ -726,6 +917,367 @@ function ensureColumn(db, table, column, definition) {
   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 {
@@ -747,8 +1299,8 @@ async function loadSqliteVecExtension(params) {
 
 // src/embeddings/embeddings.ts
 import fsSync2 from "fs";
-import path4 from "path";
-import os2 from "os";
+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";
@@ -764,7 +1316,7 @@ function createNoOpEmbeddingProvider() {
 }
 function resolveUserPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return path4.join(os2.homedir(), filePath.slice(2));
+    return path5.join(os4.homedir(), filePath.slice(2));
   }
   return filePath;
 }
@@ -975,7 +1527,6 @@ async function createEmbeddingProvider(options) {
     return {
       provider: createNoOpEmbeddingProvider(),
       requestedProvider: "none"
-      // Type coercion for compatibility
     };
   }
   const createProvider = async (id) => {
@@ -1019,7 +1570,6 @@ async function createEmbeddingProvider(options) {
       provider: createNoOpEmbeddingProvider(),
       requestedProvider,
       fallbackFrom: "auto",
-      // Indicate this is a fallback
       fallbackReason: "No embedding API available. Using BM25 full-text search only."
     };
   }
@@ -1114,7 +1664,7 @@ async function retryAsync(fn, opts) {
         opts.maxDelayMs,
         opts.minDelayMs * Math.pow(2, attempt) * (1 + Math.random() * opts.jitter)
       );
-      await new Promise((resolve4) => setTimeout(resolve4, delay));
+      await new Promise((resolve3) => setTimeout(resolve3, delay));
     }
   }
   throw lastError;
@@ -1248,7 +1798,7 @@ async function waitForOpenAiBatch(params) {
       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((resolve4) => setTimeout(resolve4, params.pollIntervalMs));
+    await new Promise((resolve3) => setTimeout(resolve3, params.pollIntervalMs));
     current = void 0;
   }
 }
@@ -1538,7 +2088,7 @@ async function waitForGeminiBatch(params) {
       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((resolve4) => setTimeout(resolve4, params.pollIntervalMs));
+    await new Promise((resolve3) => setTimeout(resolve3, params.pollIntervalMs));
     current = void 0;
   }
 }
@@ -1662,7 +2212,6 @@ var EMBEDDING_RETRY_BASE_DELAY_MS = 500;
 var EMBEDDING_RETRY_MAX_DELAY_MS = 8e3;
 var EMBEDDING_QUERY_TIMEOUT_REMOTE_MS = 6e4;
 var EMBEDDING_QUERY_TIMEOUT_LOCAL_MS = 5 * 6e4;
-var vectorToBlob2 = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
 var Minimem = class _Minimem {
   memoryDir;
   dbPath;
@@ -1688,10 +2237,11 @@ var Minimem = class _Minimem {
   closed = false;
   dirty = true;
   syncing = null;
+  syncLock = false;
   embeddingOptions;
   constructor(config2) {
-    this.memoryDir = path5.resolve(config2.memoryDir);
-    this.dbPath = config2.dbPath ?? path5.join(this.memoryDir, ".minimem", "index.db");
+    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
@@ -1757,7 +2307,7 @@ var Minimem = class _Minimem {
     }
   }
   openDatabase() {
-    const dbDir = path5.dirname(this.dbPath);
+    const dbDir = path6.dirname(this.dbPath);
     ensureDir(dbDir);
     return new DatabaseSync(this.dbPath);
   }
@@ -1797,8 +2347,8 @@ var Minimem = class _Minimem {
   }
   ensureWatcher() {
     if (this.watcher) return;
-    const memorySubDir = path5.join(this.memoryDir, "memory");
-    const memoryFile = path5.join(this.memoryDir, "MEMORY.md");
+    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,
@@ -1831,7 +2381,7 @@ var Minimem = class _Minimem {
       }
       const storedMap = new Map(stored.map((f) => [f.path, f.mtime]));
       for (const absPath of files) {
-        const relPath = path5.relative(this.memoryDir, absPath).replace(/\\/g, "/");
+        const relPath = path6.relative(this.memoryDir, absPath).replace(/\\/g, "/");
         const storedMtime = storedMap.get(relPath);
         if (storedMtime === void 0) {
           this.debug?.(`Stale: new file ${relPath}`);
@@ -1887,8 +2437,14 @@ var Minimem = class _Minimem {
       sourceFilterVec: sourceFilter,
       sourceFilterChunks: sourceFilter
     }).catch(() => []) : [];
+    const typeFilterFn = opts?.type ? (id) => {
+      const row = this.db.prepare(`SELECT type FROM chunks WHERE id = ?`).get(id);
+      return row?.type === opts.type;
+    } : void 0;
     if (!this.hybrid.enabled) {
-      return vectorResults.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
+      let results = vectorResults;
+      if (typeFilterFn) results = results.filter((r) => typeFilterFn(r.id));
+      return results.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
         path: r.path,
         startLine: r.startLine,
         endLine: r.endLine,
@@ -1896,8 +2452,14 @@ var Minimem = class _Minimem {
         snippet: r.snippet
       }));
     }
+    let filteredVector = vectorResults;
+    let filteredKeyword = keywordResults;
+    if (typeFilterFn) {
+      filteredVector = vectorResults.filter((r) => typeFilterFn(r.id));
+      filteredKeyword = keywordResults.filter((r) => typeFilterFn(r.id));
+    }
     const merged = mergeHybridResults({
-      vector: vectorResults.map((r) => ({
+      vector: filteredVector.map((r) => ({
         id: r.id,
         path: r.path,
         startLine: r.startLine,
@@ -1906,7 +2468,7 @@ var Minimem = class _Minimem {
         snippet: r.snippet,
         vectorScore: r.score
       })),
-      keyword: keywordResults.map((r) => ({
+      keyword: filteredKeyword.map((r) => ({
         id: r.id,
         path: r.path,
         startLine: r.startLine,
@@ -1931,11 +2493,16 @@ var Minimem = class _Minimem {
       await this.syncing;
       return;
     }
+    if (this.syncLock) {
+      return;
+    }
+    this.syncLock = true;
     this.syncing = this.runSync(opts);
     try {
       await this.syncing;
     } finally {
       this.syncing = null;
+      this.syncLock = false;
     }
   }
   async runSync(opts) {
@@ -1962,13 +2529,16 @@ var Minimem = class _Minimem {
         this.db.prepare(
           `DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
         ).run(stale.path, "memory");
-      } catch {
+      } catch (err) {
+        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 {
+        } catch (err) {
+          logError2("deleteStaleFtsEntries", err, this.debug);
         }
       }
     }
@@ -1987,6 +2557,13 @@ var Minimem = class _Minimem {
   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 (?, ?, ?, ?, ?)`
@@ -1995,23 +2572,27 @@ var Minimem = class _Minimem {
       this.db.prepare(
         `DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
       ).run(entry.path, "memory");
-    } catch {
+    } catch (err) {
+      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 {
+      } 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)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at, type, knowledge_type, knowledge_id, domains, entities, confidence)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ).run(
         chunkId,
         entry.path,
@@ -2022,7 +2603,13 @@ var Minimem = class _Minimem {
         this.provider.model,
         chunk.text,
         JSON.stringify(embedding),
-        now
+        now,
+        meta.type ?? null,
+        knowledgeType,
+        knowledgeId,
+        domains ? JSON.stringify(domains) : null,
+        entities ? JSON.stringify(entities) : null,
+        confidence
       );
       if (this.vector.available && embedding.length > 0) {
         if (!this.vector.dims) {
@@ -2030,8 +2617,9 @@ var Minimem = class _Minimem {
           this.ensureVectorTable(embedding.length);
         }
         try {
-          this.db.prepare(`INSERT INTO ${VECTOR_TABLE} (id, embedding) VALUES (?, ?)`).run(chunkId, vectorToBlob2(embedding));
-        } catch {
+          this.db.prepare(`INSERT INTO ${VECTOR_TABLE} (id, embedding) VALUES (?, ?)`).run(chunkId, vectorToBlob(embedding));
+        } catch (err) {
+          logError2("insertVectorChunk", err, this.debug);
         }
       }
       if (this.fts.enabled && this.fts.available) {
@@ -2048,10 +2636,28 @@ var Minimem = class _Minimem {
             chunk.startLine,
             chunk.endLine
           );
-        } catch {
+        } 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 [];
@@ -2095,7 +2701,7 @@ var Minimem = class _Minimem {
             EMBEDDING_RETRY_MAX_DELAY_MS,
             EMBEDDING_RETRY_BASE_DELAY_MS * Math.pow(2, attempt)
           );
-          await new Promise((resolve4) => setTimeout(resolve4, delay));
+          await new Promise((resolve3) => setTimeout(resolve3, delay));
         }
       }
     }
@@ -2143,12 +2749,22 @@ var Minimem = class _Minimem {
   }
   async embedQueryWithTimeout(text) {
     const timeout = this.provider.id === "local" ? EMBEDDING_QUERY_TIMEOUT_LOCAL_MS : EMBEDDING_QUERY_TIMEOUT_REMOTE_MS;
-    return Promise.race([
-      this.provider.embedQuery(text),
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("embedding query timeout")), timeout)
-      )
-    ]);
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeout);
+    try {
+      const result = await Promise.race([
+        this.provider.embedQuery(text),
+        new Promise((_, reject) => {
+          ac.signal.addEventListener(
+            "abort",
+            () => reject(new Error("embedding query timeout"))
+          );
+        })
+      ]);
+      return result;
+    } finally {
+      clearTimeout(timer);
+    }
   }
   loadEmbeddingCache(hashes) {
     const result = /* @__PURE__ */ new Map();
@@ -2241,7 +2857,7 @@ var Minimem = class _Minimem {
     }
   }
   async readFile(relativePath) {
-    const absPath = path5.join(this.memoryDir, relativePath);
+    const absPath = path6.join(this.memoryDir, relativePath);
     try {
       return await fs4.readFile(absPath, "utf-8");
     } catch {
@@ -2271,8 +2887,8 @@ var Minimem = class _Minimem {
    */
   async writeFile(relativePath, content) {
     this.validateMemoryPath(relativePath);
-    const absPath = path5.join(this.memoryDir, relativePath);
-    const dir = path5.dirname(absPath);
+    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;
@@ -2283,8 +2899,8 @@ var Minimem = class _Minimem {
    */
   async appendFile(relativePath, content) {
     this.validateMemoryPath(relativePath);
-    const absPath = path5.join(this.memoryDir, relativePath);
-    const dir = path5.dirname(absPath);
+    const absPath = path6.join(this.memoryDir, relativePath);
+    const dir = path6.dirname(absPath);
     await fs4.mkdir(dir, { recursive: true });
     let toAppend = content;
     try {
@@ -2312,7 +2928,7 @@ var Minimem = class _Minimem {
    */
   async listFiles() {
     const files = await listMemoryFiles(this.memoryDir);
-    return files.map((f) => path5.relative(this.memoryDir, f).replace(/\\/g, "/"));
+    return files.map((f) => path6.relative(this.memoryDir, f).replace(/\\/g, "/"));
   }
   /**
    * Validate that a path is within allowed memory locations
@@ -2350,6 +2966,70 @@ var Minimem = class _Minimem {
       cacheCount: cacheRow.count
     };
   }
+  /**
+   * Search with knowledge metadata filters (domain, entities, confidence, type).
+   * Runs a standard search then post-filters by knowledge columns.
+   */
+  async knowledgeSearch(query, opts) {
+    if (this.dirty || !this.watchConfig.enabled && await this.isStale()) {
+      await this.sync({ reason: "knowledgeSearch" });
+    }
+    const cleaned = query.trim();
+    if (!cleaned) return [];
+    const minScore = opts?.minScore ?? this.queryConfig.minScore;
+    const maxResults = opts?.maxResults ?? this.queryConfig.maxResults;
+    const { sql: knowledgeWhere, params: knowledgeParams } = buildKnowledgeFilterSql({
+      domain: opts?.domain,
+      entities: opts?.entities,
+      minConfidence: opts?.minConfidence,
+      knowledgeType: opts?.knowledgeType
+    });
+    if (!knowledgeWhere) {
+      return this.search(query, { maxResults, minScore });
+    }
+    const matchingRows = this.db.prepare(
+      `SELECT id FROM chunks c WHERE c.model = ? AND c.source = 'memory'${knowledgeWhere}`
+    ).all(this.provider.model, ...knowledgeParams);
+    const matchingIds = new Set(matchingRows.map((r) => r.id));
+    if (matchingIds.size === 0) return [];
+    const overFetch = Math.max(maxResults * 3, 30);
+    const results = await this.search(query, {
+      maxResults: overFetch,
+      minScore
+    });
+    const filtered = [];
+    for (const r of results) {
+      const row = this.db.prepare(
+        `SELECT id FROM chunks WHERE path = ? AND start_line = ? AND end_line = ? AND model = ?`
+      ).get(r.path, r.startLine, r.endLine, this.provider.model);
+      if (row && matchingIds.has(row.id)) {
+        filtered.push(r);
+        if (filtered.length >= maxResults) break;
+      }
+    }
+    return filtered;
+  }
+  /**
+   * Get knowledge graph links from or to a node.
+   */
+  getLinks(nodeId, direction = "from", opts) {
+    if (direction === "from") {
+      return getLinksFrom(this.db, nodeId, opts);
+    }
+    return getLinksTo(this.db, nodeId, opts);
+  }
+  /**
+   * Get neighbor nodes via BFS traversal.
+   */
+  getGraphNeighbors(nodeId, depth = 1, opts) {
+    return getNeighbors(this.db, nodeId, depth, opts);
+  }
+  /**
+   * Find shortest path between two knowledge nodes.
+   */
+  getGraphPath(fromId, toId, maxDepth = 3) {
+    return getPathBetween(this.db, fromId, toId, maxDepth);
+  }
   close() {
     if (this.closed) return;
     this.closed = true;
@@ -2363,30 +3043,31 @@ var Minimem = class _Minimem {
     }
     try {
       this.db.close();
-    } catch {
+    } catch (err) {
+      logError2("dbClose", err, this.debug);
     }
   }
 };
 
 // src/cli/commands/search.ts
 async function search(query, options) {
-  const directories = resolveSearchDirectories(options);
+  const directories = resolveMemoryDirs(options);
   if (directories.length === 0) {
-    console.error("Error: No memory directories specified.");
-    console.error("Use --dir <path> or --global to specify directories to search.");
-    process.exit(1);
+    exitWithError(
+      "No memory directories specified.",
+      "Use --dir <path> or --global to specify directories to search."
+    );
   }
   const validDirs = [];
   for (const dir of directories) {
     if (await isInitialized(dir)) {
       validDirs.push(dir);
     } else {
-      console.error(`Warning: ${formatPath(dir)} is not initialized, skipping.`);
+      warn(`${formatPath(dir)} is not initialized, skipping.`);
     }
   }
   if (validDirs.length === 0) {
-    console.error("Error: No valid initialized memory directories found.");
-    process.exit(1);
+    exitWithError("No valid initialized memory directories found.");
   }
   const maxResults = options.max ? parseInt(options.max, 10) : 10;
   const minScore = options.minScore ? parseFloat(options.minScore) : void 0;
@@ -2405,8 +3086,8 @@ async function search(query, options) {
       if (!warnedBm25) {
         const status2 = await minimem.status();
         if (status2.bm25Only) {
-          console.error("Note: Running in BM25-only mode (no embedding API configured).");
-          console.error("      Results are based on keyword matching only.\n");
+          note("Running in BM25-only mode (no embedding API configured).");
+          note("Results are based on keyword matching only.\n");
           warnedBm25 = true;
         }
       }
@@ -2450,24 +3131,6 @@ async function search(query, options) {
     }
   }
 }
-function resolveSearchDirectories(options) {
-  const dirs = [];
-  if (options.dir && options.dir.length > 0) {
-    for (const dir of options.dir) {
-      dirs.push(path6.resolve(dir));
-    }
-  }
-  if (options.global) {
-    const globalDir = path6.join(os3.homedir(), ".minimem");
-    if (!dirs.includes(globalDir)) {
-      dirs.push(globalDir);
-    }
-  }
-  if (dirs.length === 0) {
-    dirs.push(process.cwd());
-  }
-  return dirs;
-}
 function formatSnippet(snippet) {
   const lines = snippet.split("\n");
   const formatted = lines.map((line) => `  ${line}`).join("\n");
@@ -2481,9 +3144,10 @@ function formatSnippet(snippet) {
 async function sync(options) {
   const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    console.error(`Run: minimem init${options.dir ? ` ${options.dir}` : ""}`);
-    process.exit(1);
+    exitWithError(
+      `${formatPath(memoryDir)} is not initialized.`,
+      `Run: minimem init${options.dir ? ` ${options.dir}` : ""}`
+    );
   }
   console.log(`Syncing ${formatPath(memoryDir)}...`);
   const cliConfig = await loadConfig(memoryDir);
@@ -2519,9 +3183,10 @@ async function sync(options) {
 async function status(options) {
   const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    console.error(`Run: minimem init${options.dir ? ` ${options.dir}` : ""}`);
-    process.exit(1);
+    exitWithError(
+      `${formatPath(memoryDir)} is not initialized.`,
+      `Run: minimem init${options.dir ? ` ${options.dir}` : ""}`
+    );
   }
   const cliConfig = await loadConfig(memoryDir);
   const config2 = buildMinimemConfig(memoryDir, cliConfig, {
@@ -2575,9 +3240,10 @@ async function status(options) {
 async function append(text, options) {
   const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    console.error(`Run: minimem init${options.dir ? ` ${options.dir}` : ""}`);
-    process.exit(1);
+    exitWithError(
+      `${formatPath(memoryDir)} is not initialized.`,
+      `Run: minimem init${options.dir ? ` ${options.dir}` : ""}`
+    );
   }
   let finalText = text;
   if (options.session) {
@@ -2613,133 +3279,23 @@ ${text}`;
 // src/cli/commands/upsert.ts
 import * as fs5 from "fs/promises";
 import * as path7 from "path";
-import * as os5 from "os";
-
-// src/session.ts
-import * as os4 from "os";
-function parseFrontmatter(content) {
-  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n/;
-  const match = content.match(frontmatterRegex);
-  if (!match) {
-    return { frontmatter: void 0, body: content };
-  }
-  const yamlContent = match[1];
-  const body = content.slice(match[0].length);
-  try {
-    const frontmatter = parseSimpleYaml(yamlContent);
-    return { frontmatter, body };
-  } catch {
-    return { frontmatter: void 0, body: content };
-  }
-}
-function parseSimpleYaml(yaml) {
-  const result = {};
-  const lines = yaml.split("\n");
-  let currentKey = null;
-  let currentObject = null;
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    const indentMatch = line.match(/^(\s*)/);
-    const indent = indentMatch ? indentMatch[1].length : 0;
-    if (indent === 0) {
-      const keyMatch = line.match(/^(\w+):\s*(.*)?$/);
-      if (keyMatch) {
-        const [, key, value] = keyMatch;
-        if (value && value.trim()) {
-          result[key] = parseYamlValue(value.trim());
-          currentKey = null;
-          currentObject = null;
-        } else {
-          currentKey = key;
-          currentObject = {};
-          result[key] = currentObject;
-        }
-      }
-    } else if (currentObject && indent >= 2) {
-      const nestedMatch = line.match(/^\s+(\w+):\s*(.*)$/);
-      if (nestedMatch) {
-        const [, key, value] = nestedMatch;
-        currentObject[key] = parseYamlValue(value.trim());
-      }
-    }
-  }
-  return result;
-}
-function parseYamlValue(value) {
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  if (value === "true") return true;
-  if (value === "false") return false;
-  const num = Number(value);
-  if (!isNaN(num) && value !== "") return num;
-  if (value.startsWith("[") && value.endsWith("]")) {
-    const inner = value.slice(1, -1);
-    return inner.split(",").map((s) => parseYamlValue(s.trim()));
-  }
-  return value;
-}
-function serializeFrontmatter(frontmatter) {
-  const lines = ["---"];
-  if (frontmatter.session) {
-    lines.push("session:");
-    const session = frontmatter.session;
-    if (session.id) lines.push(`  id: ${session.id}`);
-    if (session.source) lines.push(`  source: ${session.source}`);
-    if (session.project) lines.push(`  project: ${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(", ")}]`);
-  }
-  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 = os4.homedir();
-  if (filePath.startsWith(home)) {
-    return "~" + filePath.slice(home.length);
-  }
-  return filePath;
-}
-
-// src/cli/commands/upsert.ts
 async function upsert(file, content, options) {
-  const memoryDir = resolveMemoryDir2(options);
+  const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    console.error(`Run: minimem init${options.dir ? ` ${options.dir}` : ""}`);
-    process.exit(1);
+    exitWithError(
+      `${formatPath(memoryDir)} is not initialized.`,
+      `Run: minimem init${options.dir ? ` ${options.dir}` : ""}`
+    );
   }
   let finalContent = content;
   if (options.stdin) {
     finalContent = await readStdin();
   }
   if (!finalContent) {
-    console.error("Error: No content provided. Use --stdin or provide content as argument.");
-    process.exit(1);
+    exitWithError(
+      "No content provided.",
+      "Use --stdin or provide content as argument."
+    );
   }
   const session = options.session ? {
     id: options.session,
@@ -2749,11 +3305,11 @@ async function upsert(file, content, options) {
   const filePath = resolveFilePath(file, memoryDir);
   const resolvedPath = path7.resolve(filePath);
   const resolvedMemoryDir = path7.resolve(memoryDir);
-  if (!resolvedPath.startsWith(resolvedMemoryDir)) {
-    console.error(`Error: File path must be within the memory directory.`);
-    console.error(`  Memory dir: ${formatPath(memoryDir)}`);
-    console.error(`  File path: ${formatPath(filePath)}`);
-    process.exit(1);
+  if (!resolvedPath.startsWith(resolvedMemoryDir + path7.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 });
@@ -2808,54 +3364,94 @@ async function upsert(file, content, options) {
     minimem = await Minimem.create(config2);
     await minimem.sync();
     console.log("  Index synced.");
-  } catch (error) {
-    console.log("  Note: Index not synced (run 'minimem sync' with API key to index).");
+  } catch {
+    note("Index not synced (run 'minimem sync' with API key to index).");
   } finally {
     minimem?.close();
   }
 }
-function resolveMemoryDir2(options) {
-  if (options.dir) {
-    return path7.resolve(options.dir);
-  }
-  if (options.global) {
-    return path7.join(os5.homedir(), ".minimem");
-  }
-  return process.cwd();
-}
 function resolveFilePath(file, memoryDir) {
   if (path7.isAbsolute(file)) {
     return file;
   }
-  if (file.startsWith("memory/") || file.startsWith("memory\\")) {
-    return path7.join(memoryDir, file);
+  return path7.join(memoryDir, file);
+}
+async function readStdin() {
+  const chunks = [];
+  return new Promise((resolve3, reject) => {
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve3(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", reject);
+  });
+}
+
+// src/cli/commands/mcp.ts
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
+
+// src/server/mcp.ts
+import * as readline from "readline";
+
+// src/server/tools.ts
+var MEMORY_SEARCH_TOOL = {
+  name: "memory_search",
+  description: "Semantically search through memory files (MEMORY.md and memory/*.md). Use this to recall prior decisions, facts, preferences, people, dates, or context. Returns ranked snippets with file paths and line numbers. When multiple memory directories are configured, searches all by default.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Natural language search query"
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results to return (default: 10)"
+      },
+      minScore: {
+        type: "number",
+        description: "Minimum relevance score threshold 0-1 (default: 0.3)"
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories by name/path. If omitted, searches all configured directories."
+      },
+      detail: {
+        type: "string",
+        enum: ["compact", "full"],
+        description: "Result detail level. 'compact' returns a lightweight index with short previews (~80 chars). 'full' returns complete snippets. Use 'compact' first, then memory_get_details for selected results. (default: 'compact')"
+      },
+      type: {
+        type: "string",
+        description: "Filter by observation type. Matches <!-- type: X --> comments in memory entries. Common types: decision, bugfix, feature, discovery, context, note."
+      }
+    },
+    required: ["query"]
   }
-  if (file === "MEMORY.md" || file.endsWith(".md") && !file.includes("/")) {
-    return path7.join(memoryDir, file);
+};
+var MEMORY_GET_DETAILS_TOOL = {
+  name: "memory_get_details",
+  description: "Fetch full text for specific memory chunks identified by path and line range. Use after memory_search with compact results to get details for selected items only. This two-step approach significantly reduces token usage.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      results: {
+        type: "array",
+        items: { type: "object" },
+        description: "Array of { path, startLine, endLine } objects from compact search results."
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories."
+      }
+    },
+    required: ["results"]
   }
-  return path7.join(memoryDir, "memory", file);
-}
-async function readStdin() {
-  const chunks = [];
-  return new Promise((resolve4, reject) => {
-    process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve4(Buffer.concat(chunks).toString("utf-8")));
-    process.stdin.on("error", reject);
-  });
-}
-
-// src/cli/commands/mcp.ts
-import * as fs6 from "fs/promises";
-import * as path8 from "path";
-import * as os6 from "os";
-
-// src/server/mcp.ts
-import * as readline from "readline";
-
-// src/server/tools.ts
-var MEMORY_SEARCH_TOOL = {
-  name: "memory_search",
-  description: "Semantically search through memory files (MEMORY.md and memory/*.md). Use this to recall prior decisions, facts, preferences, people, dates, or context. Returns ranked snippets with file paths and line numbers. When multiple memory directories are configured, searches all by default.",
+};
+var KNOWLEDGE_SEARCH_TOOL = {
+  name: "knowledge_search",
+  description: "Search memory with knowledge metadata filters. Filter by domain, entities, confidence level, or knowledge type (observation, entity, domain-summary). Combines semantic search with structured knowledge filtering.",
   inputSchema: {
     type: "object",
     properties: {
@@ -2863,24 +3459,108 @@ var MEMORY_SEARCH_TOOL = {
         type: "string",
         description: "Natural language search query"
       },
+      domain: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter to entries in these knowledge domains"
+      },
+      entities: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter to entries referencing these entities"
+      },
+      minConfidence: {
+        type: "number",
+        description: "Minimum confidence threshold (0-1)"
+      },
+      knowledgeType: {
+        type: "string",
+        description: "Filter by knowledge type: observation, entity, domain-summary"
+      },
       maxResults: {
         type: "number",
-        description: "Maximum number of results to return (default: 10)"
+        description: "Maximum number of results (default: 10)"
       },
       minScore: {
         type: "number",
-        description: "Minimum relevance score threshold 0-1 (default: 0.3)"
+        description: "Minimum relevance score 0-1 (default: 0.3)"
       },
       directories: {
         type: "array",
         items: { type: "string" },
-        description: "Optional: filter to specific memory directories by name/path. If omitted, searches all configured directories."
+        description: "Optional: filter to specific memory directories"
       }
     },
     required: ["query"]
   }
 };
-var MEMORY_TOOLS = [MEMORY_SEARCH_TOOL];
+var KNOWLEDGE_GRAPH_TOOL = {
+  name: "knowledge_graph",
+  description: "Traverse knowledge graph links from a note. Returns neighbor nodes connected by typed relationships (e.g., relates-to, supports, contradicts). Use depth parameter for multi-hop traversal.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      nodeId: {
+        type: "string",
+        description: "The knowledge node ID to start traversal from"
+      },
+      depth: {
+        type: "number",
+        description: "Maximum traversal depth (default: 1, max: 3)",
+        default: 1
+      },
+      relation: {
+        type: "string",
+        description: "Optional: filter to specific relation type"
+      },
+      layer: {
+        type: "string",
+        description: "Optional: filter to specific graph layer"
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories"
+      }
+    },
+    required: ["nodeId"]
+  }
+};
+var KNOWLEDGE_PATH_TOOL = {
+  name: "knowledge_path",
+  description: "Find the shortest path between two knowledge nodes in the graph. Uses BFS traversal up to a configurable max depth. Returns the sequence of links connecting the two nodes.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      fromId: {
+        type: "string",
+        description: "Starting knowledge node ID"
+      },
+      toId: {
+        type: "string",
+        description: "Target knowledge node ID"
+      },
+      maxDepth: {
+        type: "number",
+        description: "Maximum path length (default: 3)",
+        default: 3
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories"
+      }
+    },
+    required: ["fromId", "toId"]
+  }
+};
+var MEMORY_TOOLS = [
+  MEMORY_SEARCH_TOOL,
+  MEMORY_GET_DETAILS_TOOL,
+  KNOWLEDGE_SEARCH_TOOL,
+  KNOWLEDGE_GRAPH_TOOL,
+  KNOWLEDGE_PATH_TOOL
+];
 var MemoryToolExecutor = class {
   instances;
   constructor(instances) {
@@ -2906,6 +3586,14 @@ var MemoryToolExecutor = class {
       switch (toolName) {
         case "memory_search":
           return await this.memorySearch(params);
+        case "memory_get_details":
+          return await this.memoryGetDetails(params);
+        case "knowledge_search":
+          return await this.knowledgeSearch(params);
+        case "knowledge_graph":
+          return await this.knowledgeGraph(params);
+        case "knowledge_path":
+          return await this.knowledgePath(params);
         default:
           return {
             content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
@@ -2920,37 +3608,43 @@ var MemoryToolExecutor = class {
       };
     }
   }
+  /**
+   * Filter instances by directory names/paths
+   */
+  filterInstances(directories) {
+    if (!directories || directories.length === 0) return this.instances;
+    const dirFilter = new Set(directories.map((d) => d.toLowerCase()));
+    const filtered = this.instances.filter((i) => {
+      const name = (i.name ?? i.memoryDir).toLowerCase();
+      const dir = i.memoryDir.toLowerCase();
+      return dirFilter.has(name) || dirFilter.has(dir) || [...dirFilter].some((f) => dir.includes(f) || name.includes(f));
+    });
+    return filtered.length > 0 ? filtered : null;
+  }
   async memorySearch(params) {
     const maxResults = params.maxResults ?? 10;
     const minScore = params.minScore;
-    let instancesToSearch = this.instances;
-    if (params.directories && params.directories.length > 0) {
-      const dirFilter = new Set(params.directories.map((d) => d.toLowerCase()));
-      instancesToSearch = this.instances.filter((i) => {
-        const name = (i.name ?? i.memoryDir).toLowerCase();
-        const dir = i.memoryDir.toLowerCase();
-        return dirFilter.has(name) || dirFilter.has(dir) || // Also match partial paths
-        [...dirFilter].some((f) => dir.includes(f) || name.includes(f));
-      });
-      if (instancesToSearch.length === 0) {
-        const available = this.getDirectories().join(", ");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No matching directories found. Available: ${available}`
-            }
-          ],
-          isError: true
-        };
-      }
+    const detail = params.detail ?? "compact";
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No matching directories found. Available: ${available}`
+          }
+        ],
+        isError: true
+      };
     }
     const allResults = [];
     for (const instance of instancesToSearch) {
       const perDirMax = Math.ceil(maxResults * 1.5);
       const results = await instance.minimem.search(params.query, {
         maxResults: perDirMax,
-        minScore
+        minScore,
+        type: params.type
       });
       for (const result of results) {
         allResults.push({
@@ -2967,21 +3661,203 @@ var MemoryToolExecutor = class {
       };
     }
     const showSource = instancesToSearch.length > 1;
-    const formatted = topResults.map((r, i) => {
+    if (detail === "compact") {
+      return this.formatCompactResults(topResults, showSource, instancesToSearch.length);
+    }
+    return this.formatFullResults(topResults, showSource, instancesToSearch.length);
+  }
+  formatCompactResults(results, showSource, dirCount) {
+    const formatted = results.map((r, i) => {
+      const location = `${r.path}:${r.startLine}-${r.endLine}`;
+      const score = (r.score * 100).toFixed(0);
+      const source = showSource ? ` [${r.memoryDir}]` : "";
+      const preview = compactPreview(r.snippet);
+      return `[${i}] ${location}${source} (${score}%) \u2014 ${preview}`;
+    }).join("\n");
+    const hint = "\n\nUse memory_get_details to fetch full text for selected results.";
+    const dirSummary = dirCount > 1 ? `
+(Searched ${dirCount} directories)` : "";
+    return {
+      content: [{ type: "text", text: formatted + dirSummary + hint }]
+    };
+  }
+  formatFullResults(results, showSource, dirCount) {
+    const formatted = results.map((r, i) => {
       const location = `${r.path}:${r.startLine}-${r.endLine}`;
       const score = (r.score * 100).toFixed(1);
       const source = showSource ? ` [${r.memoryDir}]` : "";
       return `[${i + 1}] ${location}${source} (${score}% match)
 ${r.snippet}`;
     }).join("\n\n");
-    const dirSummary = instancesToSearch.length > 1 ? `
+    const dirSummary = dirCount > 1 ? `
 
-(Searched ${instancesToSearch.length} directories)` : "";
+(Searched ${dirCount} directories)` : "";
     return {
       content: [{ type: "text", text: formatted + dirSummary }]
     };
   }
+  async memoryGetDetails(params) {
+    if (!params.results || params.results.length === 0) {
+      return {
+        content: [{ type: "text", text: "No results specified." }],
+        isError: true
+      };
+    }
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No matching directories found. Available: ${available}`
+          }
+        ],
+        isError: true
+      };
+    }
+    const details = [];
+    for (const ref of params.results) {
+      let found = false;
+      for (const instance of instancesToSearch) {
+        const lineCount = ref.endLine - ref.startLine + 1;
+        const result = await instance.minimem.readLines(ref.path, {
+          from: ref.startLine,
+          lines: lineCount
+        });
+        if (result) {
+          const location = `${ref.path}:${result.startLine}-${result.endLine}`;
+          details.push(`--- ${location} ---
+${result.content}`);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        details.push(`--- ${ref.path}:${ref.startLine}-${ref.endLine} ---
+(not found)`);
+      }
+    }
+    return {
+      content: [{ type: "text", text: details.join("\n\n") }]
+    };
+  }
+  async knowledgeSearch(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const maxResults = params.maxResults ?? 10;
+    const allResults = [];
+    for (const instance of instancesToSearch) {
+      const results = await instance.minimem.knowledgeSearch(params.query, {
+        maxResults: Math.ceil(maxResults * 1.5),
+        minScore: params.minScore,
+        domain: params.domain,
+        entities: params.entities,
+        minConfidence: params.minConfidence,
+        knowledgeType: params.knowledgeType
+      });
+      for (const result of results) {
+        allResults.push({
+          ...result,
+          memoryDir: instance.name ?? instance.memoryDir
+        });
+      }
+    }
+    allResults.sort((a, b) => b.score - a.score);
+    const topResults = allResults.slice(0, maxResults);
+    if (topResults.length === 0) {
+      return { content: [{ type: "text", text: "No knowledge results found." }] };
+    }
+    const formatted = topResults.map((r, i) => {
+      const location = `${r.path}:${r.startLine}-${r.endLine}`;
+      const score = (r.score * 100).toFixed(0);
+      const preview = compactPreview(r.snippet);
+      return `[${i}] ${location} (${score}%) \u2014 ${preview}`;
+    }).join("\n");
+    return { content: [{ type: "text", text: formatted }] };
+  }
+  async knowledgeGraph(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const depth = Math.min(params.depth ?? 1, 3);
+    const allNeighbors = [];
+    for (const instance of instancesToSearch) {
+      const neighbors = instance.minimem.getGraphNeighbors(params.nodeId, depth, {
+        relation: params.relation,
+        layer: params.layer
+      });
+      for (const n of neighbors) {
+        allNeighbors.push({
+          id: n.id,
+          depth: n.depth,
+          relation: n.link.relation,
+          layer: n.link.layer,
+          memoryDir: instance.name ?? instance.memoryDir
+        });
+      }
+    }
+    if (allNeighbors.length === 0) {
+      return { content: [{ type: "text", text: `No neighbors found for node "${params.nodeId}".` }] };
+    }
+    const formatted = allNeighbors.map((n) => `  [depth=${n.depth}] ${n.id} \u2014(${n.relation})${n.layer ? ` [${n.layer}]` : ""}`).join("\n");
+    return {
+      content: [{ type: "text", text: `Neighbors of "${params.nodeId}":
+${formatted}` }]
+    };
+  }
+  async knowledgePath(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const maxDepth = Math.min(params.maxDepth ?? 3, 5);
+    for (const instance of instancesToSearch) {
+      const path20 = instance.minimem.getGraphPath(params.fromId, params.toId, maxDepth);
+      if (path20.length > 0) {
+        const steps = path20.map((link) => `  ${link.fromId} \u2014(${link.relation})\u2192 ${link.toId}`).join("\n");
+        return {
+          content: [{
+            type: "text",
+            text: `Path from "${params.fromId}" to "${params.toId}" (${path20.length} steps):
+${steps}`
+          }]
+        };
+      }
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `No path found from "${params.fromId}" to "${params.toId}" within depth ${maxDepth}.`
+      }]
+    };
+  }
 };
+function compactPreview(snippet) {
+  const maxLen = 80;
+  const lines = snippet.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) return "(empty)";
+  const heading = lines.find((l) => l.startsWith("#"));
+  const text = heading ?? lines[0];
+  const cleaned = text.replace(/^#+\s*/, "").trim();
+  if (cleaned.length <= maxLen) return `"${cleaned}"`;
+  return `"${cleaned.slice(0, maxLen - 3)}..."`;
+}
 
 // src/server/mcp.ts
 var PROTOCOL_VERSION = "2024-11-05";
@@ -3131,12 +4007,13 @@ async function runMcpServer(server) {
 
 // src/cli/commands/mcp.ts
 async function mcp(options) {
-  const directories = resolveDirectories(options);
-  const globalDir = path8.join(os6.homedir(), ".minimem");
+  const directories = resolveMemoryDirs(options);
+  const globalDir = getGlobalMemoryDir();
   if (directories.length === 0) {
-    console.error("Error: No memory directories specified.");
-    console.error("Use --dir <path> or --global to specify directories.");
-    process.exit(1);
+    exitWithError(
+      "No memory directories specified.",
+      "Use --dir <path> or --global to specify directories."
+    );
   }
   const includesGlobal = directories.includes(globalDir);
   if (includesGlobal && !await isInitialized(globalDir)) {
@@ -3147,7 +4024,7 @@ async function mcp(options) {
   for (const memoryDir of directories) {
     const isGlobal = memoryDir === globalDir;
     if (!await isInitialized(memoryDir)) {
-      console.error(`Warning: ${formatPath(memoryDir)} is not initialized, skipping.`);
+      warn(`${formatPath(memoryDir)} is not initialized, skipping.`);
       if (!isGlobal && !includesGlobal) {
         console.error(`  Using global (~/.minimem) as fallback.`);
         if (!await isInitialized(globalDir)) {
@@ -3168,8 +4045,8 @@ async function mcp(options) {
       minimemInstances.push(minimem);
       const status2 = await minimem.status();
       if (status2.bm25Only && instances.length === 0) {
-        console.error(`Note: Running in BM25-only mode (no embedding API configured).`);
-        console.error(`      Search results will be based on keyword matching only.`);
+        note("Running in BM25-only mode (no embedding API configured).");
+        note("Search results will be based on keyword matching only.");
       }
       const name = getDirName(memoryDir);
       instances.push({
@@ -3179,12 +4056,11 @@ async function mcp(options) {
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(`Warning: Failed to load ${formatPath(memoryDir)}: ${message}`);
+      warn(`Failed to load ${formatPath(memoryDir)}: ${message}`);
     }
   }
   if (instances.length === 0) {
-    console.error("Error: No valid memory directories found.");
-    process.exit(1);
+    exitWithError("No valid memory directories found.");
   }
   if (instances.length === 1) {
     console.error(`Serving: ${instances[0].name} (${formatPath(instances[0].memoryDir)})`);
@@ -3205,36 +4081,6 @@ async function mcp(options) {
   process.on("SIGTERM", shutdown);
   await runMcpServer(server);
 }
-function resolveDirectories(options) {
-  const dirs = [];
-  if (options.dir && options.dir.length > 0) {
-    for (const dir of options.dir) {
-      dirs.push(path8.resolve(dir));
-    }
-  }
-  if (options.global) {
-    const globalDir = path8.join(os6.homedir(), ".minimem");
-    if (!dirs.includes(globalDir)) {
-      dirs.push(globalDir);
-    }
-  }
-  if (dirs.length === 0) {
-    dirs.push(process.cwd());
-  }
-  return dirs;
-}
-function getDirName(memoryDir) {
-  const home = os6.homedir();
-  if (memoryDir === path8.join(home, ".minimem")) {
-    return "global";
-  }
-  const name = path8.basename(memoryDir);
-  if (name.startsWith(".")) {
-    const parent = path8.basename(path8.dirname(memoryDir));
-    return `${parent}/${name}`;
-  }
-  return name;
-}
 async function ensureGlobalInitialized(globalDir) {
   console.error(`Auto-initializing global memory directory (~/.minimem)...`);
   await fs6.mkdir(globalDir, { recursive: true });
@@ -3273,8 +4119,7 @@ async function config(options) {
 async function showConfig(options) {
   const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   const globalConfig = await loadGlobalConfig();
   const xdgConfig = await loadXdgConfig();
@@ -3360,16 +4205,16 @@ async function handleConfigEdit(options) {
   const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
   const configPath = getConfigPath(memoryDir);
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   const currentConfig = await loadConfigFile2(configPath);
   if (options.set) {
     const [keyPath, value] = options.set.split("=");
     if (!keyPath || value === void 0) {
-      console.error("Error: --set requires format: key.path=value");
-      console.error("Example: --set embedding.provider=openai");
-      process.exit(1);
+      exitWithError(
+        "--set requires format: key.path=value",
+        "Example: --set embedding.provider=openai"
+      );
     }
     const newConfig = setConfigValue(currentConfig, keyPath, parseValue(value));
     await saveConfig(memoryDir, newConfig);
@@ -3388,9 +4233,10 @@ async function handleXdgConfigEdit(options) {
   if (options.set) {
     const [keyPath, value] = options.set.split("=");
     if (!keyPath || value === void 0) {
-      console.error("Error: --set requires format: key.path=value");
-      console.error("Example: --set centralRepo=~/memories-repo");
-      process.exit(1);
+      exitWithError(
+        "--set requires format: key.path=value",
+        "Example: --set centralRepo=~/memories-repo"
+      );
     }
     const newConfig = setConfigValue(currentConfig, keyPath, parseValue(value));
     await saveXdgConfig(newConfig);
@@ -3463,7 +4309,7 @@ import { execSync } from "child_process";
 // src/cli/sync/registry.ts
 import fs7 from "fs/promises";
 import path9 from "path";
-import os7 from "os";
+import os5 from "os";
 import crypto3 from "crypto";
 var REGISTRY_FILENAME = ".minimem-registry.json";
 function getRegistryPath(centralRepo) {
@@ -3497,15 +4343,15 @@ async function writeRegistry(centralRepo, registry) {
 }
 function normalizePath(filePath) {
   if (filePath.startsWith("~/")) {
-    return path9.resolve(os7.homedir(), filePath.slice(2));
+    return path9.resolve(os5.homedir(), filePath.slice(2));
   }
   if (filePath === "~") {
-    return os7.homedir();
+    return os5.homedir();
   }
   return path9.resolve(filePath);
 }
 function compressPath(filePath) {
-  const home = os7.homedir();
+  const home = os5.homedir();
   const resolved = path9.resolve(filePath);
   if (resolved.startsWith(home)) {
     return "~" + resolved.slice(home.length);
@@ -3600,19 +4446,15 @@ async function hasSyncConfig(dir) {
   }
 }
 async function detectDirectoryType(dir) {
-  const [hasSync, inGit] = await Promise.all([
-    hasSyncConfig(dir),
-    isInsideGitRepo(dir)
-  ]);
-  if (hasSync && inGit) {
-    return "hybrid";
-  } else if (hasSync && !inGit) {
+  const hasSync = await hasSyncConfig(dir);
+  if (hasSync) {
     return "standalone";
-  } else if (!hasSync && inGit) {
+  }
+  const inGit = await isInsideGitRepo(dir);
+  if (inGit) {
     return "project-bound";
-  } else {
-    return "unmanaged";
   }
+  return "standalone";
 }
 
 // src/cli/sync/central.ts
@@ -3825,8 +4667,7 @@ async function syncInitCentral(repoPath, options = {}) {
   console.log(`Initializing central repository at ${formatPath(repoPath)}...`);
   const result = await initCentralRepo(repoPath);
   if (!result.success) {
-    console.error(`Error: ${result.message}`);
-    process.exit(1);
+    exitWithError(result.message);
   }
   if (result.created) {
     console.log("  Created new git repository");
@@ -3853,30 +4694,30 @@ async function syncInit(options) {
     global: options.global
   });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    console.error("Run 'minimem init' first.");
-    process.exit(1);
+    exitWithError(
+      `${formatPath(memoryDir)} is not initialized.`,
+      "Run 'minimem init' first."
+    );
   }
   if (!options.path) {
-    console.error("Error: --path is required.");
-    console.error("Example: minimem sync init --path myproject/");
-    process.exit(1);
+    exitWithError(
+      "--path is required.",
+      "Example: minimem sync init --path myproject/"
+    );
   }
   const centralPath = options.path;
   const centralRepo = await getCentralRepoPath();
   if (!centralRepo) {
-    console.error("Error: No central repository configured.");
-    console.error("First initialize a central repository:");
-    console.error("  minimem sync init-central ~/memories-repo");
-    process.exit(1);
+    exitWithError(
+      "No central repository configured.",
+      "First initialize a central repository: minimem sync init-central ~/memories-repo"
+    );
   }
   const validation = await validateCentralRepo(centralRepo);
   if (!validation.valid) {
-    console.error(`Error: Central repository is invalid:`);
-    for (const error of validation.errors) {
-      console.error(`  - ${error}`);
-    }
-    process.exit(1);
+    exitWithError(
+      `Central repository is invalid: ${validation.errors.join(", ")}`
+    );
   }
   if (validation.warnings.length > 0) {
     console.log("Warnings about central repository:");
@@ -3892,15 +4733,11 @@ async function syncInit(options) {
     const existingMapping = registry.mappings.find(
       (m) => m.path === centralPath || m.path === `${centralPath}/`
     );
-    console.error(`Error: Path '${centralPath}' is already mapped by another machine.`);
+    let details = `Path '${centralPath}' is already mapped by another machine.`;
     if (existingMapping) {
-      console.error(`  Machine: ${existingMapping.machineId}`);
-      console.error(`  Local path: ${existingMapping.localPath}`);
-      console.error(`  Last sync: ${existingMapping.lastSync}`);
+      details += ` Machine: ${existingMapping.machineId}, Local: ${existingMapping.localPath}`;
     }
-    console.error();
-    console.error("Choose a different path or remove the existing mapping.");
-    process.exit(1);
+    exitWithError(details, "Choose a different path or remove the existing mapping.");
   }
   const dirType = await detectDirectoryType(memoryDir);
   console.log(`Initializing sync for ${formatPath(memoryDir)}...`);
@@ -3979,13 +4816,11 @@ async function syncRemove(options) {
   });
   const centralRepo = await getCentralRepoPath();
   if (!centralRepo) {
-    console.error("Error: No central repository configured.");
-    process.exit(1);
+    exitWithError("No central repository configured.");
   }
   const localConfig = await loadConfig(memoryDir);
   if (!localConfig.sync?.path) {
-    console.error(`Error: ${formatPath(memoryDir)} is not configured for sync.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not configured for sync.`);
   }
   const centralPath = localConfig.sync.path;
   const machineId = await getMachineId();
@@ -4023,7 +4858,8 @@ function getSyncStatePath(dir) {
 }
 function createEmptySyncState(centralPath) {
   return {
-    version: 1,
+    version: 2,
+    // Bumped version for simplified state
     lastSync: null,
     centralPath,
     files: {}
@@ -4038,6 +4874,13 @@ async function loadSyncState(dir, centralPath) {
       return createEmptySyncState(centralPath);
     }
     state.centralPath = centralPath;
+    if (state.version === 1) {
+      for (const file of Object.keys(state.files)) {
+        const entry = state.files[file];
+        delete entry.lastSyncedHash;
+      }
+      state.version = 2;
+    }
     return state;
   } catch {
     return createEmptySyncState(centralPath);
@@ -4048,7 +4891,7 @@ async function saveSyncState(dir, state) {
   const stateDir = path13.dirname(statePath);
   const tempPath = `${statePath}.${crypto4.randomBytes(4).toString("hex")}.tmp`;
   await fs11.mkdir(stateDir, { recursive: true });
-  state.version = state.version || 1;
+  state.version = state.version || 2;
   await fs11.writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
   await fs11.rename(tempPath, statePath);
 }
@@ -4101,34 +4944,27 @@ async function getFileHashInfo(filePath) {
     return { exists: false };
   }
 }
-function getFileSyncStatus(localHash, remoteHash, lastSyncedHash) {
+function getFileSyncStatus(localHash, remoteHash) {
   if (localHash && remoteHash && localHash === remoteHash) {
     return "unchanged";
   }
-  if (!lastSyncedHash) {
-    if (localHash && !remoteHash) return "new-local";
-    if (!localHash && remoteHash) return "new-remote";
-    if (localHash && remoteHash && localHash !== remoteHash) return "conflict";
+  if (localHash && remoteHash && localHash !== remoteHash) {
+    return "local-modified";
   }
-  if (lastSyncedHash && !localHash && remoteHash === lastSyncedHash) {
-    return "deleted-local";
+  if (localHash && !remoteHash) {
+    return "local-only";
   }
-  if (lastSyncedHash && !remoteHash && localHash === lastSyncedHash) {
-    return "deleted-remote";
-  }
-  if (lastSyncedHash) {
-    const localChanged = localHash !== lastSyncedHash;
-    const remoteChanged = remoteHash !== lastSyncedHash;
-    if (localChanged && !remoteChanged) return "local-only";
-    if (!localChanged && remoteChanged) return "remote-only";
-    if (localChanged && remoteChanged) {
-      if (localHash !== remoteHash) return "conflict";
-      return "unchanged";
-    }
+  if (!localHash && remoteHash) {
+    return "remote-only";
   }
   return "unchanged";
 }
 
+// src/cli/commands/conflicts.ts
+import fs13 from "fs/promises";
+import path15 from "path";
+import { spawn } from "child_process";
+
 // src/cli/sync/conflicts.ts
 import fs12 from "fs/promises";
 import path14 from "path";
@@ -4160,7 +4996,7 @@ async function listQuarantinedConflicts(memoryDir) {
   }
   return conflicts.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
 }
-async function detectConflicts(memoryDir, centralPath) {
+async function detectChanges(memoryDir) {
   const centralRepo = await getCentralRepoPath();
   if (!centralRepo) {
     throw new Error("No central repository configured");
@@ -4170,8 +5006,6 @@ async function detectConflicts(memoryDir, centralPath) {
     throw new Error("Directory is not configured for sync");
   }
   const remotePath = path14.join(centralRepo, syncConfig.path);
-  const effectiveCentralPath = centralPath ?? syncConfig.path;
-  const state = await loadSyncState(memoryDir, effectiveCentralPath);
   const [localFiles, remoteFiles] = await Promise.all([
     listSyncableFiles(memoryDir, syncConfig.include, syncConfig.exclude),
     listSyncableFiles(remotePath, syncConfig.include, syncConfig.exclude)
@@ -4183,11 +5017,7 @@ async function detectConflicts(memoryDir, centralPath) {
     unchanged: 0,
     localOnly: 0,
     remoteOnly: 0,
-    conflicts: 0,
-    newLocal: 0,
-    newRemote: 0,
-    deletedLocal: 0,
-    deletedRemote: 0
+    localModified: 0
   };
   for (const file of allFiles) {
     const localPath = path14.join(memoryDir, file);
@@ -4196,12 +5026,9 @@ async function detectConflicts(memoryDir, centralPath) {
       getFileHashInfo(localPath),
       getFileHashInfo(remoteFilePath)
     ]);
-    const existingEntry = state.files[file];
-    const baseHash = existingEntry?.lastSyncedHash ?? null;
     const status2 = getFileSyncStatus(
       localInfo.hash ?? null,
-      remoteInfo.hash ?? null,
-      baseHash
+      remoteInfo.hash ?? null
     );
     if (status2 === "unchanged") {
       unchanged.push(file);
@@ -4211,8 +5038,7 @@ async function detectConflicts(memoryDir, centralPath) {
         file,
         status: status2,
         localHash: localInfo.hash ?? null,
-        remoteHash: remoteInfo.hash ?? null,
-        baseHash
+        remoteHash: remoteInfo.hash ?? null
       });
       switch (status2) {
         case "local-only":
@@ -4221,39 +5047,24 @@ async function detectConflicts(memoryDir, centralPath) {
         case "remote-only":
           summary.remoteOnly++;
           break;
-        case "conflict":
-          summary.conflicts++;
-          break;
-        case "new-local":
-          summary.newLocal++;
-          break;
-        case "new-remote":
-          summary.newRemote++;
-          break;
-        case "deleted-local":
-          summary.deletedLocal++;
-          break;
-        case "deleted-remote":
-          summary.deletedRemote++;
+        case "local-modified":
+          summary.localModified++;
           break;
       }
     }
   }
   return { changes, unchanged, summary };
 }
+var detectConflicts = detectChanges;
 
 // src/cli/commands/conflicts.ts
-import fs13 from "fs/promises";
-import path15 from "path";
-import { spawn } from "child_process";
 async function conflictsCommand(options) {
   const memoryDir = resolveMemoryDir({
     dir: options.dir,
     global: options.global
   });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   try {
     const conflicts = await listQuarantinedConflicts(memoryDir);
@@ -4278,8 +5089,8 @@ ${conflict.timestamp}:`);
 Total: ${conflicts.length} conflict set(s)`);
     console.log("\nUse 'minimem sync:resolve <timestamp>' to resolve a conflict.");
   } catch (error) {
-    console.error(`Error: ${error}`);
-    process.exit(1);
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
   }
 }
 async function resolveCommand(timestamp, options) {
@@ -4288,16 +5099,16 @@ async function resolveCommand(timestamp, options) {
     global: options.global
   });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   const conflictDir = path15.join(getConflictsDir(memoryDir), timestamp);
   try {
     await fs13.access(conflictDir);
   } catch {
-    console.error(`Error: Conflict '${timestamp}' not found.`);
-    console.error("Use 'minimem sync:conflicts' to list available conflicts.");
-    process.exit(1);
+    exitWithError(
+      `Conflict '${timestamp}' not found.`,
+      "Use 'minimem sync:conflicts' to list available conflicts."
+    );
   }
   try {
     const files = await fs13.readdir(conflictDir);
@@ -4314,8 +5125,7 @@ async function resolveCommand(timestamp, options) {
       }
     }
     if (fileGroups.size === 0) {
-      console.error("No conflict files found in this directory.");
-      process.exit(1);
+      exitWithError("No conflict files found in this directory.");
     }
     const mergeTool = options.tool || process.env.MERGE_TOOL || await detectMergeTool();
     if (!mergeTool) {
@@ -4338,10 +5148,10 @@ Resolving: ${fileName}`);
       if (group.local && group.remote) {
         const args = group.base ? [group.local, group.base, group.remote] : [group.local, group.remote];
         const child = spawn(mergeTool, args, { stdio: "inherit" });
-        await new Promise((resolve4, reject) => {
+        await new Promise((resolve3, reject) => {
           child.on("close", (code) => {
             if (code === 0) {
-              resolve4();
+              resolve3();
             } else {
               reject(new Error(`Merge tool exited with code ${code}`));
             }
@@ -4353,8 +5163,8 @@ Resolving: ${fileName}`);
     console.log("\nMerge complete. Remove conflict directory when satisfied:");
     console.log(`  rm -rf "${conflictDir}"`);
   } catch (error) {
-    console.error(`Error: ${error}`);
-    process.exit(1);
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
   }
 }
 async function detectMergeTool() {
@@ -4376,8 +5186,7 @@ async function cleanupCommand(options) {
     global: options.global
   });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   const maxAgeDays = options.days ?? 30;
   const cutoffDate = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3);
@@ -4420,8 +5229,8 @@ Would remove ${cleaned} conflict(s), keep ${kept}`);
 Removed ${cleaned} conflict(s), kept ${kept}`);
     }
   } catch (error) {
-    console.error(`Error: ${error}`);
-    process.exit(1);
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
   }
 }
 var SYNC_LOG_FILE = "sync.log";
@@ -4446,7 +5255,8 @@ async function appendSyncLog(memoryDir, entry) {
     const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
     await fs13.writeFile(logPath, content);
   } catch (error) {
-    console.error(`Warning: Failed to write sync log: ${error}`);
+    const message = error instanceof Error ? error.message : String(error);
+    warn(`Failed to write sync log: ${message}`);
   }
 }
 async function readSyncLog(memoryDir) {
@@ -4464,8 +5274,7 @@ async function logCommand(options) {
     global: options.global
   });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   try {
     let entries = await readSyncLog(memoryDir);
@@ -4496,8 +5305,8 @@ async function logCommand(options) {
       }
     }
   } catch (error) {
-    console.error(`Error: ${error}`);
-    process.exit(1);
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
   }
 }
 
@@ -4520,20 +5329,11 @@ async function copyFileAtomic(src, dest) {
     throw error;
   }
 }
-function keepBothMerge(localContent, remoteContent, localTimestamp, remoteTimestamp) {
-  return `<<<<<<< LOCAL (${localTimestamp})
-${localContent}
-=======
-${remoteContent}
->>>>>>> REMOTE (${remoteTimestamp})
-`;
-}
 async function push(memoryDir, options = {}) {
   const result = {
     success: true,
     pushed: [],
     pulled: [],
-    conflicts: [],
     errors: [],
     skipped: []
   };
@@ -4550,69 +5350,56 @@ async function push(memoryDir, options = {}) {
     return result;
   }
   const remotePath = path16.join(centralRepo, syncConfig.path);
-  const detection = await detectConflicts(memoryDir);
   const state = await loadSyncState(memoryDir, syncConfig.path);
-  for (const change of detection.changes) {
-    const localPath = path16.join(memoryDir, change.file);
-    const remoteFilePath = path16.join(remotePath, change.file);
+  const localFiles = await listSyncableFiles(
+    memoryDir,
+    syncConfig.include,
+    syncConfig.exclude
+  );
+  const remoteFiles = await listSyncableFiles(
+    remotePath,
+    syncConfig.include,
+    syncConfig.exclude
+  );
+  const allFiles = /* @__PURE__ */ new Set([...localFiles, ...remoteFiles]);
+  for (const file of allFiles) {
+    const localPath = path16.join(memoryDir, file);
+    const remoteFilePath = path16.join(remotePath, file);
     try {
-      switch (change.status) {
+      const [localInfo, remoteInfo] = await Promise.all([
+        getFileHashInfo(localPath),
+        getFileHashInfo(remoteFilePath)
+      ]);
+      const status2 = getFileSyncStatus(
+        localInfo.hash ?? null,
+        remoteInfo.hash ?? null
+      );
+      switch (status2) {
+        case "unchanged":
+          break;
         case "local-only":
-        case "new-local":
+        case "local-modified":
           if (!options.dryRun) {
             await copyFileAtomic(localPath, remoteFilePath);
-            const hash = await computeFileHash(localPath);
-            state.files[change.file] = {
+            const hash = localInfo.hash;
+            state.files[file] = {
               localHash: hash,
               remoteHash: hash,
-              lastSyncedHash: hash,
               lastModified: (/* @__PURE__ */ new Date()).toISOString()
             };
           }
-          result.pushed.push(change.file);
+          result.pushed.push(file);
           break;
-        case "deleted-remote":
-          result.skipped.push(change.file);
-          break;
-        case "conflict":
-          if (options.force) {
-            if (!options.dryRun) {
-              await copyFileAtomic(localPath, remoteFilePath);
-              const hash = await computeFileHash(localPath);
-              state.files[change.file] = {
-                localHash: hash,
-                remoteHash: hash,
-                lastSyncedHash: hash,
-                lastModified: (/* @__PURE__ */ new Date()).toISOString()
-              };
-            }
-            result.pushed.push(change.file);
-          } else {
-            if (!options.dryRun && syncConfig.conflictStrategy === "keep-both") {
-              const localContent = await fs14.readFile(localPath, "utf-8");
-              const remoteContent = await fs14.readFile(remoteFilePath, "utf-8");
-              const merged = keepBothMerge(
-                localContent,
-                remoteContent,
-                (/* @__PURE__ */ new Date()).toISOString(),
-                (/* @__PURE__ */ new Date()).toISOString()
-              );
-              await fs14.writeFile(localPath, merged);
-              await fs14.writeFile(remoteFilePath, merged);
-              const hash = computeFileHash(localPath);
-              result.pushed.push(change.file);
-            } else {
-              result.conflicts.push(change.file);
-              result.success = false;
-            }
-          }
+        case "remote-only":
+          result.skipped.push(file);
           break;
         default:
-          result.skipped.push(change.file);
+          result.skipped.push(file);
           break;
       }
     } catch (error) {
-      result.errors.push(`${change.file}: ${error}`);
+      const message = error instanceof Error ? error.message : String(error);
+      result.errors.push(`${file}: ${message}`);
       result.success = false;
     }
   }
@@ -4628,9 +5415,8 @@ async function push(memoryDir, options = {}) {
     const logEntry = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       operation: "push",
-      result: result.success ? result.conflicts.length > 0 ? "partial" : "success" : "failure",
+      result: result.success ? "success" : "failure",
       pushed: result.pushed.length,
-      conflicts: result.conflicts.length,
       errors: result.errors.length > 0 ? result.errors : void 0
     };
     await appendSyncLog(memoryDir, logEntry);
@@ -4642,7 +5428,6 @@ async function pull(memoryDir, options = {}) {
     success: true,
     pushed: [],
     pulled: [],
-    conflicts: [],
     errors: [],
     skipped: []
   };
@@ -4659,68 +5444,71 @@ async function pull(memoryDir, options = {}) {
     return result;
   }
   const remotePath = path16.join(centralRepo, syncConfig.path);
-  const detection = await detectConflicts(memoryDir);
   const state = await loadSyncState(memoryDir, syncConfig.path);
-  for (const change of detection.changes) {
-    const localPath = path16.join(memoryDir, change.file);
-    const remoteFilePath = path16.join(remotePath, change.file);
+  const localFiles = await listSyncableFiles(
+    memoryDir,
+    syncConfig.include,
+    syncConfig.exclude
+  );
+  const remoteFiles = await listSyncableFiles(
+    remotePath,
+    syncConfig.include,
+    syncConfig.exclude
+  );
+  const allFiles = /* @__PURE__ */ new Set([...localFiles, ...remoteFiles]);
+  for (const file of allFiles) {
+    const localPath = path16.join(memoryDir, file);
+    const remoteFilePath = path16.join(remotePath, file);
     try {
-      switch (change.status) {
+      const [localInfo, remoteInfo] = await Promise.all([
+        getFileHashInfo(localPath),
+        getFileHashInfo(remoteFilePath)
+      ]);
+      const status2 = getFileSyncStatus(
+        localInfo.hash ?? null,
+        remoteInfo.hash ?? null
+      );
+      switch (status2) {
+        case "unchanged":
+          break;
         case "remote-only":
-        case "new-remote":
           if (!options.dryRun) {
             await copyFileAtomic(remoteFilePath, localPath);
-            const hash = await computeFileHash(localPath);
-            state.files[change.file] = {
+            const hash = remoteInfo.hash;
+            state.files[file] = {
               localHash: hash,
               remoteHash: hash,
-              lastSyncedHash: hash,
               lastModified: (/* @__PURE__ */ new Date()).toISOString()
             };
           }
-          result.pulled.push(change.file);
-          break;
-        case "deleted-local":
-          result.skipped.push(change.file);
+          result.pulled.push(file);
           break;
-        case "conflict":
-          if (options.force) {
+        case "local-modified":
+          if (options.force || !localInfo.exists) {
             if (!options.dryRun) {
               await copyFileAtomic(remoteFilePath, localPath);
-              const hash = await computeFileHash(localPath);
-              state.files[change.file] = {
+              const hash = remoteInfo.hash;
+              state.files[file] = {
                 localHash: hash,
                 remoteHash: hash,
-                lastSyncedHash: hash,
                 lastModified: (/* @__PURE__ */ new Date()).toISOString()
               };
             }
-            result.pulled.push(change.file);
+            result.pulled.push(file);
           } else {
-            if (!options.dryRun && syncConfig.conflictStrategy === "keep-both") {
-              const localContent = await fs14.readFile(localPath, "utf-8");
-              const remoteContent = await fs14.readFile(remoteFilePath, "utf-8");
-              const merged = keepBothMerge(
-                localContent,
-                remoteContent,
-                (/* @__PURE__ */ new Date()).toISOString(),
-                (/* @__PURE__ */ new Date()).toISOString()
-              );
-              await fs14.writeFile(localPath, merged);
-              await fs14.writeFile(remoteFilePath, merged);
-              result.pulled.push(change.file);
-            } else {
-              result.conflicts.push(change.file);
-              result.success = false;
-            }
+            result.skipped.push(file);
           }
           break;
+        case "local-only":
+          result.skipped.push(file);
+          break;
         default:
-          result.skipped.push(change.file);
+          result.skipped.push(file);
           break;
       }
     } catch (error) {
-      result.errors.push(`${change.file}: ${error}`);
+      const message = error instanceof Error ? error.message : String(error);
+      result.errors.push(`${file}: ${message}`);
       result.success = false;
     }
   }
@@ -4736,9 +5524,8 @@ async function pull(memoryDir, options = {}) {
     const logEntry = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       operation: "pull",
-      result: result.success ? result.conflicts.length > 0 ? "partial" : "success" : "failure",
+      result: result.success ? "success" : "failure",
       pulled: result.pulled.length,
-      conflicts: result.conflicts.length,
       errors: result.errors.length > 0 ? result.errors : void 0
     };
     await appendSyncLog(memoryDir, logEntry);
@@ -4753,8 +5540,7 @@ async function pushCommand(options) {
     global: options.global
   });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   console.log(`Pushing from ${formatPath(memoryDir)}...`);
   if (options.dryRun) {
@@ -4798,8 +5584,8 @@ Errors:`);
       console.log("Nothing to push - already in sync");
     }
   } catch (error) {
-    console.error(`Error: ${error}`);
-    process.exit(1);
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
   }
 }
 async function pullCommand(options) {
@@ -4808,8 +5594,7 @@ async function pullCommand(options) {
     global: options.global
   });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   console.log(`Pulling to ${formatPath(memoryDir)}...`);
   if (options.dryRun) {
@@ -4853,8 +5638,8 @@ Errors:`);
       console.log("Nothing to pull - already in sync");
     }
   } catch (error) {
-    console.error(`Error: ${error}`);
-    process.exit(1);
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
   }
 }
 async function syncStatusCommand(options) {
@@ -4863,8 +5648,7 @@ async function syncStatusCommand(options) {
     global: options.global
   });
   if (!await isInitialized(memoryDir)) {
-    console.error(`Error: ${formatPath(memoryDir)} is not initialized.`);
-    process.exit(1);
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
   }
   try {
     const detection = await detectConflicts(memoryDir);
@@ -4906,8 +5690,8 @@ async function syncStatusCommand(options) {
       }
     }
   } catch (error) {
-    console.error(`Error: ${error}`);
-    process.exit(1);
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
   }
 }
 
@@ -4917,7 +5701,7 @@ import fs17 from "fs/promises";
 // src/cli/sync/daemon.ts
 import fs16 from "fs/promises";
 import path19 from "path";
-import os8 from "os";
+import os6 from "os";
 
 // src/cli/sync/watcher.ts
 import chokidar2 from "chokidar";
@@ -5107,7 +5891,7 @@ async function validateRegistry() {
       result.stats.activeMappings++;
     }
     if (mapping.machineId === currentMachineId) {
-      const localPath = expandPath4(mapping.localPath);
+      const localPath = expandPath3(mapping.localPath);
       try {
         await fs15.access(localPath);
       } catch {
@@ -5125,7 +5909,7 @@ async function validateRegistry() {
   }
   return result;
 }
-function expandPath4(p) {
+function expandPath3(p) {
   if (p.startsWith("~/")) {
     return path18.join(process.env.HOME || "", p.slice(2));
   }
@@ -5167,7 +5951,7 @@ var DAEMON_LOG_FILE = "daemon.log";
 var PID_FILE = "daemon.pid";
 var MAX_LOG_SIZE = 1024 * 1024;
 function getDaemonDir() {
-  return path19.join(os8.homedir(), ".minimem");
+  return path19.join(os6.homedir(), ".minimem");
 }
 function getPidFilePath() {
   return path19.join(getDaemonDir(), PID_FILE);
@@ -5414,8 +6198,8 @@ async function daemonCommand(options) {
     try {
       await startDaemon();
     } catch (error) {
-      console.error(`Daemon error: ${error}`);
-      process.exit(1);
+      const message = error instanceof Error ? error.message : String(error);
+      exitWithError(`Daemon: ${message}`);
     }
     return;
   }
@@ -5431,8 +6215,8 @@ async function daemonCommand(options) {
       console.log(`Daemon started with PID ${pid}`);
       console.log(`Log file: ${getDaemonLogPath()}`);
     } catch (error) {
-      console.error(`Failed to start daemon: ${error}`);
-      process.exit(1);
+      const message = error instanceof Error ? error.message : String(error);
+      exitWithError(`Failed to start daemon: ${message}`);
     }
   } else {
     console.log("Starting daemon in foreground...");
@@ -5441,8 +6225,8 @@ async function daemonCommand(options) {
     try {
       await startDaemon();
     } catch (error) {
-      console.error(`Daemon error: ${error}`);
-      process.exit(1);
+      const message = error instanceof Error ? error.message : String(error);
+      exitWithError(`Daemon: ${message}`);
     }
   }
 }
@@ -5457,8 +6241,7 @@ async function daemonStopCommand() {
   if (stopped) {
     console.log("Daemon stopped.");
   } else {
-    console.error("Failed to stop daemon.");
-    process.exit(1);
+    exitWithError("Failed to stop daemon.");
   }
 }
 async function daemonStatusCommand() {
@@ -5511,21 +6294,37 @@ async function daemonLogsCommand(options) {
     if (error.code === "ENOENT") {
       console.log("No daemon log found.");
     } else {
-      console.error(`Error reading log: ${error}`);
-      process.exit(1);
+      const message = error instanceof Error ? error.message : String(error);
+      exitWithError(`Error reading log: ${message}`);
     }
   }
 }
 
+// src/cli/version.ts
+import { readFileSync } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath } from "url";
+function getPackageVersion() {
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname3(__filename);
+    const packagePath = join4(__dirname, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    return packageJson.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION = getPackageVersion();
+
 // src/cli/index.ts
-var VERSION = "0.0.2";
 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("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);
-program.command("upsert <file> [content]").description("Create or update a memory file").option("-d, --dir <path>", "Memory directory").option("-g, --global", "Use ~/.minimem").option("-p, --provider <name>", "Embedding provider (openai, gemini, local, auto)").option("--stdin", "Read content from stdin").option("-s, --session <id>", "Session ID to associate with this memory").option("--session-source <name>", "Session source (claude-code, vscode, etc.)").action(upsert);
+program.command("upsert <file> [content]").description("Create or update a memory file (file path relative to memory dir)").option("-d, --dir <path>", "Memory directory").option("-g, --global", "Use ~/.minimem").option("-p, --provider <name>", "Embedding provider (openai, gemini, local, auto)").option("--stdin", "Read content from stdin").option("-s, --session <id>", "Session ID to associate with this memory").option("--session-source <name>", "Session source (claude-code, vscode, etc.)").action(upsert);
 program.command("mcp").description("Run as MCP server over stdio (for Claude Desktop, Cursor, etc.)").option("-d, --dir <path...>", "Memory directories (can specify multiple)").option("-g, --global", "Include ~/.minimem").option("-p, --provider <name>", "Embedding provider (openai, gemini, local, auto)").action(mcp);
 program.command("config").description("View or modify configuration").option("-d, --dir <path>", "Memory directory").option("-g, --global", "Use ~/.minimem").option("--xdg-global", "Modify ~/.config/minimem/config.json (for sync settings)").option("--json", "Output as JSON").option("--set <key=value>", "Set a config value (e.g., embedding.provider=openai)").option("--unset <key>", "Remove a config value").action(config);
 program.command("sync:init-central <path>").description("Initialize a central repository for syncing memories").option("-f, --force", "Force creation even if directory exists").action(syncInitCentral);
@@ -5555,8 +6354,8 @@ program.command("sync:validate").description("Validate registry for collisions a
       process.exit(1);
     }
   } catch (error) {
-    console.error(`Error: ${error}`);
-    process.exit(1);
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
   }
 });
 program.parse();