@strvmarv/total-recall 0.1.0 → 0.2.0

package/dist/index.js

@@ -223,12 +223,23 @@ import * as ort from "onnxruntime-node";
 
 // src/embedding/model-manager.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { readFileSync as readFileSync2, statSync } from "fs";
 import { writeFile } from "fs/promises";
 import { join as join3 } from "path";
 var HF_BASE_URL = "https://huggingface.co";
-function getModelPath(modelName) {
+var HF_REVISION = "main";
+function getBundledModelPath(modelName) {
+  const distDir = new URL(".", import.meta.url).pathname;
+  return join3(distDir, "..", "models", modelName);
+}
+function getUserModelPath(modelName) {
   return join3(getDataDir(), "models", modelName);
 }
+function getModelPath(modelName) {
+  const bundled = getBundledModelPath(modelName);
+  if (isModelDownloaded(bundled)) return bundled;
+  return getUserModelPath(modelName);
+}
 function isModelDownloaded(modelPath) {
   if (!existsSync3(modelPath)) return false;
   try {
@@ -238,13 +249,36 @@ function isModelDownloaded(modelPath) {
     return false;
   }
 }
+async function validateDownload(modelPath) {
+  const modelStat = statSync(join3(modelPath, "model.onnx"));
+  if (modelStat.size < 1e6) {
+    throw new Error("model.onnx appears corrupted (< 1MB)");
+  }
+  const tokenizerText = readFileSync2(join3(modelPath, "tokenizer.json"), "utf-8");
+  try {
+    JSON.parse(tokenizerText);
+  } catch {
+    throw new Error("tokenizer.json is not valid JSON");
+  }
+}
 async function downloadModel(modelName) {
-  const modelPath = getModelPath(modelName);
+  const modelPath = getUserModelPath(modelName);
   mkdirSync2(modelPath, { recursive: true });
-  const files = ["model.onnx", "tokenizer.json", "tokenizer_config.json"];
-  const repoUrl = `${HF_BASE_URL}/${modelName}/resolve/main`;
-  for (const file of files) {
-    const url = `${repoUrl}/${file}`;
+  const fileUrls = [
+    {
+      file: "model.onnx",
+      url: `${HF_BASE_URL}/sentence-transformers/${modelName}/resolve/${HF_REVISION}/onnx/model.onnx`
+    },
+    {
+      file: "tokenizer.json",
+      url: `${HF_BASE_URL}/sentence-transformers/${modelName}/resolve/${HF_REVISION}/tokenizer.json`
+    },
+    {
+      file: "tokenizer_config.json",
+      url: `${HF_BASE_URL}/sentence-transformers/${modelName}/resolve/${HF_REVISION}/tokenizer_config.json`
+    }
+  ];
+  for (const { file, url } of fileUrls) {
     const dest = join3(modelPath, file);
     const response = await fetch(url);
     if (!response.ok) {
@@ -253,8 +287,12 @@ async function downloadModel(modelName) {
       );
     }
     const buffer = await response.arrayBuffer();
+    if (buffer.byteLength === 0) {
+      throw new Error(`Downloaded ${file} is empty`);
+    }
     await writeFile(dest, Buffer.from(buffer));
   }
+  await validateDownload(modelPath);
   return modelPath;
 }
 
@@ -263,7 +301,7 @@ var CLS_TOKEN_ID = 101;
 var SEP_TOKEN_ID = 102;
 var UNK_TOKEN_ID = 100;
 var MAX_SEQ_LEN = 512;
-var Embedder = class _Embedder {
+var Embedder = class {
   options;
   session = null;
   vocab = null;
@@ -351,39 +389,6 @@ var Embedder = class _Embedder {
     }
     return results;
   }
-  /**
-   * Returns a synchronous embed function suitable for use with ingestion APIs.
-   * Uses a hash-based deterministic embedding that does not require ONNX inference,
-   * allowing synchronous operation. Call ensureLoaded() before using this.
-   */
-  makeSyncEmbedFn() {
-    const dimensions = this.options.dimensions;
-    return (text) => {
-      return _Embedder.hashEmbed(text, dimensions);
-    };
-  }
-  /**
-   * Hash-based deterministic embedding. Does not require the ONNX model.
-   * Useful as a sync fallback for ingestion pipelines.
-   */
-  static hashEmbed(text, dimensions) {
-    const vec = new Float32Array(dimensions);
-    let hash = 0;
-    for (let i = 0; i < text.length; i++) {
-      hash = hash * 31 + text.charCodeAt(i) | 0;
-    }
-    for (let i = 0; i < dimensions; i++) {
-      hash = hash * 1103515245 + 12345 | 0;
-      vec[i] = (hash >> 16 & 32767) / 32767 - 0.5;
-    }
-    let norm = 0;
-    for (let i = 0; i < dimensions; i++) norm += vec[i] * vec[i];
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-      for (let i = 0; i < dimensions; i++) vec[i] = vec[i] / norm;
-    }
-    return vec;
-  }
   /**
    * Deterministic embedding based on tokenization only (no ONNX inference).
    * Used as fallback when async embed cannot be awaited synchronously.
@@ -513,9 +518,23 @@ function deleteEntry(db, tier, type, id) {
   const table = tableName(tier, type);
   db.prepare(`DELETE FROM ${table} WHERE id = ?`).run(id);
 }
+var ALLOWED_ORDER_COLUMNS = /* @__PURE__ */ new Set([
+  "created_at",
+  "updated_at",
+  "last_accessed_at",
+  "access_count",
+  "decay_score",
+  "content"
+]);
 function listEntries(db, tier, type, opts) {
   const table = tableName(tier, type);
-  const orderBy = opts?.orderBy ?? "created_at DESC";
+  const orderParts = (opts?.orderBy ?? "created_at DESC").split(" ");
+  const column = orderParts[0];
+  const direction = orderParts[1]?.toUpperCase() === "ASC" ? "ASC" : "DESC";
+  if (!ALLOWED_ORDER_COLUMNS.has(column)) {
+    throw new Error(`Invalid orderBy column: ${column}`);
+  }
+  const orderBy = `${column} ${direction}`;
   let sql;
   let params;
   if (opts?.project !== void 0 && opts.project !== null) {
@@ -621,7 +640,7 @@ function searchByVector(db, tier, type, queryVec, opts) {
 }
 
 // src/memory/store.ts
-function storeMemory(db, embed, opts) {
+async function storeMemory(db, embed, opts) {
   const tier = opts.tier ?? "hot";
   const contentType = opts.contentType ?? "memory";
   const id = insertEntry(db, tier, contentType, {
@@ -634,14 +653,14 @@ function storeMemory(db, embed, opts) {
     collection_id: opts.collection_id,
     metadata: opts.type ? { entry_type: opts.type } : {}
   });
-  const embedding = embed(opts.content);
+  const embedding = await embed(opts.content);
   insertEmbedding(db, tier, contentType, id, embedding);
   return id;
 }
 
 // src/memory/search.ts
-function searchMemory(db, embed, query, opts) {
-  const queryVec = embed(query);
+async function searchMemory(db, embed, query, opts) {
+  const queryVec = await embed(query);
   const merged = [];
   for (const { tier, content_type } of opts.tiers) {
     const vectorResults = searchByVector(db, tier, content_type, queryVec, {
@@ -681,14 +700,14 @@ function getMemory(db, id) {
 }
 
 // src/memory/update.ts
-function updateMemory(db, embed, id, opts) {
+async function updateMemory(db, embed, id, opts) {
   const location = getMemory(db, id);
   if (!location) return false;
   const { tier, content_type } = location;
   updateEntry(db, tier, content_type, id, opts);
-  if (opts.content !== void 0) {
+  if (opts.content !== void 0 && embed !== void 0) {
     deleteEmbedding(db, tier, content_type, id);
-    const newEmbedding = embed(opts.content);
+    const newEmbedding = await embed(opts.content);
     insertEmbedding(db, tier, content_type, id, newEmbedding);
   }
   return true;
@@ -698,23 +717,103 @@ function updateMemory(db, embed, id, opts) {
 function deleteMemory(db, id) {
   const location = getMemory(db, id);
   if (!location) return false;
+  deleteEmbedding(db, location.tier, location.content_type, id);
   deleteEntry(db, location.tier, location.content_type, id);
   return true;
 }
 
 // src/memory/promote-demote.ts
-function promoteEntry(db, embed, id, fromTier, fromType, toTier, toType) {
+async function promoteEntry(db, embed, id, fromTier, fromType, toTier, toType) {
   const entry = getEntry(db, fromTier, fromType, id);
   if (!entry) {
     throw new Error(`Entry ${id} not found in ${fromTier}/${fromType}`);
   }
   deleteEmbedding(db, fromTier, fromType, id);
   moveEntry(db, fromTier, fromType, toTier, toType, id);
-  const newEmbedding = embed(entry.content);
+  const newEmbedding = await embed(entry.content);
   insertEmbedding(db, toTier, toType, id, newEmbedding);
 }
-function demoteEntry(db, embed, id, fromTier, fromType, toTier, toType) {
-  promoteEntry(db, embed, id, fromTier, fromType, toTier, toType);
+async function demoteEntry(db, embed, id, fromTier, fromType, toTier, toType) {
+  await promoteEntry(db, embed, id, fromTier, fromType, toTier, toType);
+}
+
+// src/tools/validation.ts
+import { resolve } from "path";
+var VALID_TIERS = /* @__PURE__ */ new Set(["hot", "warm", "cold"]);
+var VALID_CONTENT_TYPES = /* @__PURE__ */ new Set(["memory", "knowledge"]);
+var VALID_ENTRY_TYPES = /* @__PURE__ */ new Set(["correction", "preference", "decision", "surfaced"]);
+var MAX_CONTENT_LENGTH = 1e5;
+function validateString(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${name} must be a non-empty string`);
+  }
+  return value;
+}
+function validateOptionalString(value, name) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new Error(`${name} must be a string`);
+  return value;
+}
+function validateTier(value) {
+  if (!VALID_TIERS.has(value)) {
+    throw new Error(`Invalid tier: ${String(value)}. Must be hot, warm, or cold`);
+  }
+  return value;
+}
+function validateContentType(value) {
+  if (!VALID_CONTENT_TYPES.has(value)) {
+    throw new Error(`Invalid content type: ${String(value)}. Must be memory or knowledge`);
+  }
+  return value;
+}
+function validateEntryType(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (!VALID_ENTRY_TYPES.has(value)) {
+    throw new Error(`Invalid entry type: ${String(value)}`);
+  }
+  return value;
+}
+function validateContent(value) {
+  const content = validateString(value, "content");
+  if (content.length > MAX_CONTENT_LENGTH) {
+    throw new Error(`Content exceeds maximum length of ${MAX_CONTENT_LENGTH} characters`);
+  }
+  return content;
+}
+function validateNumber(value, name, min, max) {
+  if (typeof value !== "number" || isNaN(value)) {
+    throw new Error(`${name} must be a number`);
+  }
+  if (min !== void 0 && value < min) throw new Error(`${name} must be >= ${min}`);
+  if (max !== void 0 && value > max) throw new Error(`${name} must be <= ${max}`);
+  return value;
+}
+function validateOptionalNumber(value, name, min, max) {
+  if (value === void 0 || value === null) return void 0;
+  return validateNumber(value, name, min, max);
+}
+function validateTags(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) throw new Error("tags must be an array");
+  return value.map((v, i) => {
+    if (typeof v !== "string") throw new Error(`tags[${i}] must be a string`);
+    return v;
+  });
+}
+function validatePath(value, name) {
+  const path = validateString(value, name);
+  const resolved = resolve(path);
+  const dangerous = ["/etc", "/proc", "/sys", "/dev", "/var/run", "/root"];
+  for (const prefix of dangerous) {
+    if (resolved.startsWith(prefix)) {
+      throw new Error(`Access denied: ${name} cannot access ${prefix}`);
+    }
+  }
+  const basename2 = resolved.split("/").pop() ?? "";
+  if (basename2 === ".env" || basename2 === ".credentials.json") {
+    throw new Error(`Access denied: ${name} cannot access sensitive files`);
+  }
+  return resolved;
 }
 
 // src/tools/memory-tools.ts
@@ -829,23 +928,31 @@ var MEMORY_TOOLS = [
 ];
 async function handleMemoryTool(name, args, ctx) {
   if (name === "memory_store") {
-    const content = args.content;
+    const content = validateContent(args.content);
+    const tier = args.tier !== void 0 ? validateTier(args.tier) : "hot";
+    const contentType = args.contentType !== void 0 ? validateContentType(args.contentType) : "memory";
+    const type = validateEntryType(args.entryType);
+    const project = validateOptionalString(args.project, "project");
+    const tags = validateTags(args.tags);
+    const source = validateOptionalString(args.source, "source");
     await ctx.embedder.ensureLoaded();
     const vec = await ctx.embedder.embed(content);
     const embedFn = () => vec;
-    const id = storeMemory(ctx.db, embedFn, {
+    const id = await storeMemory(ctx.db, embedFn, {
       content,
-      tier: args.tier ?? "hot",
-      contentType: args.contentType ?? "memory",
-      type: args.entryType,
-      project: args.project,
-      tags: args.tags,
-      source: args.source
+      tier,
+      contentType,
+      type,
+      project,
+      tags,
+      source
     });
     return { content: [{ type: "text", text: JSON.stringify({ id }) }] };
   }
   if (name === "memory_search") {
-    const query = args.query;
+    const query = validateString(args.query, "query");
+    const topK = validateOptionalNumber(args.topK, "topK", 1, 1e3) ?? 10;
+    const minScore = validateOptionalNumber(args.minScore, "minScore", 0, 1);
     await ctx.embedder.ensureLoaded();
     const vec = await ctx.embedder.embed(query);
     const embedFn = () => vec;
@@ -854,72 +961,84 @@ async function handleMemoryTool(name, args, ctx) {
     const tiers = ALL_TABLE_PAIRS.filter(
       (p) => (!tierFilter || tierFilter.includes(p.tier)) && (!typeFilter || typeFilter.includes(p.type))
     ).map((p) => ({ tier: p.tier, content_type: p.type }));
-    const results = searchMemory(ctx.db, embedFn, query, {
+    const results = await searchMemory(ctx.db, embedFn, query, {
       tiers,
-      topK: args.topK ?? 10,
-      minScore: args.minScore
+      topK,
+      minScore
     });
     return { content: [{ type: "text", text: JSON.stringify(results) }] };
   }
   if (name === "memory_get") {
-    const location = getMemory(ctx.db, args.id);
+    const id = validateString(args.id, "id");
+    const location = getMemory(ctx.db, id);
     return { content: [{ type: "text", text: JSON.stringify(location) }] };
   }
   if (name === "memory_update") {
+    const id = validateString(args.id, "id");
     await ctx.embedder.ensureLoaded();
-    const newContent = args.content;
+    const newContent = args.content !== void 0 ? validateContent(args.content) : void 0;
+    const summary = validateOptionalString(args.summary, "summary");
+    const tags = args.tags !== void 0 ? validateTags(args.tags) : void 0;
+    const project = validateOptionalString(args.project, "project");
     let embedFn;
     if (newContent !== void 0) {
       const vec = await ctx.embedder.embed(newContent);
       embedFn = () => vec;
     }
-    const updated = updateMemory(ctx.db, embedFn ?? (() => new Float32Array(0)), args.id, {
+    const updated = await updateMemory(ctx.db, embedFn, id, {
       content: newContent,
-      summary: args.summary,
-      tags: args.tags,
-      project: args.project
+      summary,
+      tags,
+      project
     });
     return { content: [{ type: "text", text: JSON.stringify({ updated }) }] };
   }
   if (name === "memory_delete") {
-    const deleted = deleteMemory(ctx.db, args.id);
+    const id = validateString(args.id, "id");
+    const deleted = deleteMemory(ctx.db, id);
     return { content: [{ type: "text", text: JSON.stringify({ deleted }) }] };
   }
   if (name === "memory_promote") {
-    const location = getMemory(ctx.db, args.id);
+    const id = validateString(args.id, "id");
+    const toTier = validateTier(args.toTier);
+    const toType = validateContentType(args.toType);
+    const location = getMemory(ctx.db, id);
     if (!location) {
       return { content: [{ type: "text", text: JSON.stringify({ error: "Entry not found" }) }] };
     }
     await ctx.embedder.ensureLoaded();
     const vec = await ctx.embedder.embed(location.entry.content);
     const embedFn = () => vec;
-    promoteEntry(
+    await promoteEntry(
       ctx.db,
       embedFn,
-      args.id,
+      id,
       location.tier,
       location.content_type,
-      args.toTier,
-      args.toType
+      toTier,
+      toType
     );
     return { content: [{ type: "text", text: JSON.stringify({ promoted: true }) }] };
   }
   if (name === "memory_demote") {
-    const location = getMemory(ctx.db, args.id);
+    const id = validateString(args.id, "id");
+    const toTier = validateTier(args.toTier);
+    const toType = validateContentType(args.toType);
+    const location = getMemory(ctx.db, id);
     if (!location) {
       return { content: [{ type: "text", text: JSON.stringify({ error: "Entry not found" }) }] };
     }
     await ctx.embedder.ensureLoaded();
     const vec = await ctx.embedder.embed(location.entry.content);
     const embedFn = () => vec;
-    demoteEntry(
+    await demoteEntry(
       ctx.db,
       embedFn,
-      args.id,
+      id,
       location.tier,
       location.content_type,
-      args.toTier,
-      args.toType
+      toTier,
+      toType
     );
     return { content: [{ type: "text", text: JSON.stringify({ demoted: true }) }] };
   }
@@ -988,10 +1107,8 @@ function handleSystemTool(name, args, ctx) {
     const parts = key.split(".");
     let value = ctx.config;
     for (const part of parts) {
-      if (value === null || typeof value !== "object") {
-        value = void 0;
-        break;
-      }
+      if (value === null || typeof value !== "object") return { content: [{ type: "text", text: JSON.stringify({ error: "key not found" }) }] };
+      if (!Object.prototype.hasOwnProperty.call(value, part)) return { content: [{ type: "text", text: JSON.stringify({ error: `key not found: ${key}` }) }] };
       value = value[part];
     }
     return { content: [{ type: "text", text: JSON.stringify({ key, value }) }] };
@@ -1016,8 +1133,11 @@ function handleSystemTool(name, args, ctx) {
   return null;
 }
 
+// src/tools/kb-tools.ts
+import { statSync as statSync3 } from "fs";
+
 // src/ingestion/ingest.ts
-import { readFileSync as readFileSync2, readdirSync as readdirSync2, statSync } from "fs";
+import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { join as join5, dirname, basename, extname } from "path";
 
 // src/ingestion/markdown-parser.ts
@@ -1420,7 +1540,26 @@ function chunkFile(content, filePath, opts) {
 }
 
 // src/ingestion/hierarchical-index.ts
-function createCollection(db, embed, opts) {
+function rowToEntry2(row) {
+  return {
+    id: row.id,
+    content: row.content,
+    summary: row.summary,
+    source: row.source,
+    source_tool: row.source_tool,
+    project: row.project,
+    tags: row.tags ? JSON.parse(row.tags) : [],
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    last_accessed_at: row.last_accessed_at,
+    access_count: row.access_count,
+    decay_score: row.decay_score,
+    parent_id: row.parent_id,
+    collection_id: row.collection_id,
+    metadata: row.metadata ? JSON.parse(row.metadata) : {}
+  };
+}
+async function createCollection(db, embed, opts) {
   const content = `Collection: ${opts.name}`;
   const id = insertEntry(db, "cold", "knowledge", {
     content,
@@ -1431,11 +1570,11 @@ function createCollection(db, embed, opts) {
       source_path: opts.sourcePath
     }
   });
-  const embedding = embed(content);
+  const embedding = await embed(content);
   insertEmbedding(db, "cold", "knowledge", id, embedding);
   return id;
 }
-function addDocumentToCollection(db, embed, opts) {
+async function addDocumentToCollection(db, embed, opts) {
   const joined = opts.chunks.map((c) => c.content).join("\n\n");
   const docContent = joined.slice(0, 500);
   const docId = insertEntry(db, "cold", "knowledge", {
@@ -1448,7 +1587,7 @@ function addDocumentToCollection(db, embed, opts) {
       chunk_count: opts.chunks.length
     }
   });
-  const docEmbedding = embed(docContent);
+  const docEmbedding = await embed(docContent);
   insertEmbedding(db, "cold", "knowledge", docId, docEmbedding);
   for (const chunk of opts.chunks) {
     const chunkId = insertEntry(db, "cold", "knowledge", {
@@ -1463,7 +1602,7 @@ function addDocumentToCollection(db, embed, opts) {
         kind: chunk.kind
       }
     });
-    const chunkEmbedding = embed(chunk.content);
+    const chunkEmbedding = await embed(chunk.content);
     insertEmbedding(db, "cold", "knowledge", chunkId, chunkEmbedding);
   }
   return docId;
@@ -1471,25 +1610,9 @@ function addDocumentToCollection(db, embed, opts) {
 function listCollections(db) {
   const rows = db.prepare(`SELECT * FROM cold_knowledge WHERE json_extract(metadata, '$.type') = 'collection'`).all();
   return rows.map((row) => {
-    const metadata = row.metadata ? JSON.parse(row.metadata) : {};
-    return {
-      id: row.id,
-      content: row.content,
-      summary: row.summary,
-      source: row.source,
-      source_tool: row.source_tool,
-      project: row.project,
-      tags: row.tags ? JSON.parse(row.tags) : [],
-      created_at: row.created_at,
-      updated_at: row.updated_at,
-      last_accessed_at: row.last_accessed_at,
-      access_count: row.access_count,
-      decay_score: row.decay_score,
-      parent_id: row.parent_id,
-      collection_id: row.collection_id,
-      metadata,
-      name: metadata["name"]
-    };
+    const entry = rowToEntry2(row);
+    const metadata = entry.metadata;
+    return { ...entry, name: metadata["name"] };
   });
 }
 
@@ -1518,19 +1641,19 @@ var INGESTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".yml",
   ".toml"
 ]);
-function ingestFile(db, embed, filePath, collectionId) {
-  const content = readFileSync2(filePath, "utf-8");
+async function ingestFile(db, embed, filePath, collectionId) {
+  const content = readFileSync3(filePath, "utf-8");
   const chunks = chunkFile(content, filePath, { maxTokens: 512, overlapTokens: 50 });
   let resolvedCollectionId = collectionId;
   if (!resolvedCollectionId) {
     const dirPath = dirname(filePath);
     const dirName = basename(dirPath);
-    resolvedCollectionId = createCollection(db, embed, {
+    resolvedCollectionId = await createCollection(db, embed, {
       name: dirName,
       sourcePath: dirPath
     });
   }
-  const documentId = addDocumentToCollection(db, embed, {
+  const documentId = await addDocumentToCollection(db, embed, {
     collectionId: resolvedCollectionId,
     sourcePath: filePath,
     chunks: chunks.map((c) => ({
@@ -1543,7 +1666,7 @@ function ingestFile(db, embed, filePath, collectionId) {
   let validationPassed = false;
   if (chunks.length > 0) {
     const firstChunk = chunks[0];
-    const queryVec = embed(firstChunk.content);
+    const queryVec = await embed(firstChunk.content);
     const results = searchByVector(db, "cold", "knowledge", queryVec, {
       topK: 5,
       minScore: 0
@@ -1556,6 +1679,13 @@ function ingestFile(db, embed, filePath, collectionId) {
     validationPassed
   };
 }
+function matchesGlob(filename, glob) {
+  if (glob.startsWith("*.")) {
+    const ext = glob.slice(1);
+    return filename.endsWith(ext);
+  }
+  return filename === glob;
+}
 function walkDirectory(dirPath) {
   const files = [];
   let entries;
@@ -1569,7 +1699,7 @@ function walkDirectory(dirPath) {
     const fullPath = join5(dirPath, entry);
     let stat;
     try {
-      stat = statSync(fullPath);
+      stat = statSync2(fullPath);
     } catch {
       continue;
     }
@@ -1584,32 +1714,34 @@ function walkDirectory(dirPath) {
   }
   return files;
 }
-function ingestDirectory(db, embed, dirPath, glob) {
+async function ingestDirectory(db, embed, dirPath, glob) {
   const dirName = basename(dirPath);
-  const collectionId = createCollection(db, embed, {
+  const collectionId = await createCollection(db, embed, {
     name: dirName,
     sourcePath: dirPath
   });
   const files = walkDirectory(dirPath);
   let documentCount = 0;
   let totalChunks = 0;
+  const errors = [];
   for (const filePath of files) {
     if (glob !== void 0) {
       const name = basename(filePath);
-      const pattern = glob.replace(/\./g, "\\.").replace(/\*/g, ".*");
-      if (!new RegExp(`^${pattern}$`).test(name)) continue;
+      if (!matchesGlob(name, glob)) continue;
     }
     try {
-      const result = ingestFile(db, embed, filePath, collectionId);
+      const result = await ingestFile(db, embed, filePath, collectionId);
       documentCount++;
       totalChunks += result.chunkCount;
-    } catch {
+    } catch (err) {
+      errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   return {
     collectionId,
     documentCount,
-    totalChunks
+    totalChunks,
+    errors
   };
 }
 
@@ -1688,28 +1820,28 @@ var KB_TOOLS = [
 ];
 async function handleKbTool(name, args, ctx) {
   if (name === "kb_ingest_file") {
-    const filePath = args.path;
-    const collectionId = args.collection;
+    const filePath = validatePath(args.path, "path");
+    const collectionId = validateOptionalString(args.collection, "collection");
     await ctx.embedder.ensureLoaded();
-    const embedFn = ctx.embedder.makeSyncEmbedFn();
-    const result = ingestFile(ctx.db, embedFn, filePath, collectionId);
+    const embedFn = (text) => ctx.embedder.embed(text);
+    const result = await ingestFile(ctx.db, embedFn, filePath, collectionId);
     return { content: [{ type: "text", text: JSON.stringify(result) }] };
   }
   if (name === "kb_ingest_dir") {
-    const dirPath = args.path;
-    const glob = args.glob;
+    const dirPath = validatePath(args.path, "path");
+    const glob = validateOptionalString(args.glob, "glob");
     await ctx.embedder.ensureLoaded();
-    const embedFn = ctx.embedder.makeSyncEmbedFn();
-    const result = ingestDirectory(ctx.db, embedFn, dirPath, glob);
+    const embedFn = (text) => ctx.embedder.embed(text);
+    const result = await ingestDirectory(ctx.db, embedFn, dirPath, glob);
     return { content: [{ type: "text", text: JSON.stringify(result) }] };
   }
   if (name === "kb_search") {
-    const query = args.query;
-    const topK = args.top_k ?? 10;
+    const query = validateString(args.query, "query");
+    const topK = validateOptionalNumber(args.top_k, "top_k", 1, 1e3) ?? 10;
     await ctx.embedder.ensureLoaded();
     const vec = await ctx.embedder.embed(query);
     const embedFn = () => vec;
-    const results = searchMemory(ctx.db, embedFn, query, {
+    const results = await searchMemory(ctx.db, embedFn, query, {
       tiers: [{ tier: "cold", content_type: "knowledge" }],
       topK
     });
@@ -1720,7 +1852,7 @@ async function handleKbTool(name, args, ctx) {
     return { content: [{ type: "text", text: JSON.stringify(collections) }] };
   }
   if (name === "kb_remove") {
-    const id = args.id;
+    const id = validateString(args.id, "id");
     const cascade = args.cascade ?? false;
     if (cascade) {
       const children = listEntries(ctx.db, "cold", "knowledge").filter(
@@ -1736,15 +1868,68 @@ async function handleKbTool(name, args, ctx) {
     return { content: [{ type: "text", text: JSON.stringify({ removed: id, cascade }) }] };
   }
   if (name === "kb_refresh") {
-    const collection = args.collection;
+    const collectionId = validateString(args.collection, "collection");
+    const collectionEntry = getEntry(ctx.db, "cold", "knowledge", collectionId);
+    if (!collectionEntry) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: `Collection not found: ${collectionId}` })
+          }
+        ]
+      };
+    }
+    const sourcePath = collectionEntry.metadata?.source_path;
+    if (!sourcePath) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Collection has no source_path in metadata; cannot refresh" })
+          }
+        ]
+      };
+    }
+    const children = listEntries(ctx.db, "cold", "knowledge").filter(
+      (e) => e.collection_id === collectionId || e.parent_id === collectionId
+    );
+    for (const child of children) {
+      deleteEmbedding(ctx.db, "cold", "knowledge", child.id);
+      deleteEntry(ctx.db, "cold", "knowledge", child.id);
+    }
+    deleteEmbedding(ctx.db, "cold", "knowledge", collectionId);
+    deleteEntry(ctx.db, "cold", "knowledge", collectionId);
+    await ctx.embedder.ensureLoaded();
+    const embedFn = (text) => ctx.embedder.embed(text);
+    let result;
+    let isDir = false;
+    try {
+      isDir = statSync3(sourcePath).isDirectory();
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: `Cannot stat source path: ${String(err)}` })
+          }
+        ]
+      };
+    }
+    if (isDir) {
+      result = await ingestDirectory(ctx.db, embedFn, sourcePath);
+    } else {
+      result = await ingestFile(ctx.db, embedFn, sourcePath);
+    }
     return {
       content: [
         {
           type: "text",
           text: JSON.stringify({
-            acknowledged: true,
-            collection,
-            note: "Refresh scheduled \u2014 re-ingest the source path to update"
+            refreshed: true,
+            source_path: sourcePath,
+            deleted_children: children.length,
+            ...result
           })
         }
       ]
@@ -1757,24 +1942,27 @@ function registerKbTools() {
 }
 
 // src/tools/eval-tools.ts
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/eval/benchmark-runner.ts
-import { readFileSync as readFileSync3 } from "fs";
-function runBenchmark(db, embed, opts) {
-  const corpusLines = readFileSync3(opts.corpusPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
-  for (const line of corpusLines) {
-    const entry = JSON.parse(line);
-    storeMemory(db, embed, {
-      content: entry.content,
-      type: entry.type,
-      tier: "warm",
-      contentType: "memory",
-      tags: entry.tags
-    });
+import { readFileSync as readFileSync4 } from "fs";
+async function runBenchmark(db, embed, opts) {
+  const corpusLines = readFileSync4(opts.corpusPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+  const existingWarmCount = countEntries(db, "warm", "memory");
+  if (existingWarmCount < corpusLines.length) {
+    for (const line of corpusLines) {
+      const entry = JSON.parse(line);
+      await storeMemory(db, embed, {
+        content: entry.content,
+        type: entry.type,
+        tier: "warm",
+        contentType: "memory",
+        tags: entry.tags
+      });
+    }
   }
-  const benchmarkLines = readFileSync3(opts.benchmarkPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+  const benchmarkLines = readFileSync4(opts.benchmarkPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
   const queries = benchmarkLines.map((line) => JSON.parse(line));
   const details = [];
   let exactMatches = 0;
@@ -1783,7 +1971,7 @@ function runBenchmark(db, embed, opts) {
   let totalLatencyMs = 0;
   for (const bq of queries) {
     const start = performance.now();
-    const results = searchMemory(db, embed, bq.query, {
+    const results = await searchMemory(db, embed, bq.query, {
       tiers: [{ tier: "warm", content_type: "memory" }],
       topK: 3
     });
@@ -1928,7 +2116,7 @@ function computeMetrics(events, similarityThreshold) {
 
 // src/tools/eval-tools.ts
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
-var PACKAGE_ROOT = resolve(__dirname, "..", "..");
+var PACKAGE_ROOT = resolve2(__dirname, "..", "..");
 var EVAL_TOOLS = [
   {
     name: "eval_benchmark",
@@ -1958,10 +2146,10 @@ var EVAL_TOOLS = [
 async function handleEvalTool(name, args, ctx) {
   if (name === "eval_benchmark") {
     await ctx.embedder.ensureLoaded();
-    const embedFn = ctx.embedder.makeSyncEmbedFn();
-    const corpusPath = resolve(PACKAGE_ROOT, "eval", "corpus", "memories.jsonl");
-    const benchmarkPath = resolve(PACKAGE_ROOT, "eval", "benchmarks", "retrieval.jsonl");
-    const result = runBenchmark(ctx.db, embedFn, {
+    const embedFn = (text) => ctx.embedder.embed(text);
+    const corpusPath = resolve2(PACKAGE_ROOT, "eval", "corpus", "memories.jsonl");
+    const benchmarkPath = resolve2(PACKAGE_ROOT, "eval", "benchmarks", "retrieval.jsonl");
+    const result = await runBenchmark(ctx.db, embedFn, {
       corpusPath,
       benchmarkPath
     });
@@ -1985,7 +2173,7 @@ function registerEvalTools() {
 }
 
 // src/importers/claude-code.ts
-import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
 import { join as join6 } from "path";
 import { homedir } from "os";
 import { createHash } from "crypto";
@@ -2053,7 +2241,7 @@ var ClaudeCodeImporter = class {
     }
     return { memoryFiles, knowledgeFiles, sessionFiles };
   }
-  importMemories(db, embed, project) {
+  async importMemories(db, embed, project) {
     const result = { imported: 0, skipped: 0, errors: [] };
     const projectsDir = join6(this.basePath, "projects");
     if (!existsSync4(projectsDir)) return result;
@@ -2066,7 +2254,7 @@ var ClaudeCodeImporter = class {
         if (!filename.endsWith(".md") || filename === "MEMORY.md") continue;
         const filePath = join6(memoryDir, filename);
         try {
-          const raw = readFileSync4(filePath, "utf8");
+          const raw = readFileSync5(filePath, "utf8");
           const hash = contentHash(raw);
           if (isAlreadyImported(db, hash)) {
             result.skipped++;
@@ -2087,7 +2275,7 @@ var ClaudeCodeImporter = class {
             project: project ?? null,
             tags: frontmatter?.name ? [frontmatter.name] : []
           });
-          insertEmbedding(db, tier, type, entryId, embed(content));
+          insertEmbedding(db, tier, type, entryId, await embed(content));
           logImport(db, "claude-code", filePath, hash, entryId, tier, type);
           result.imported++;
         } catch (err) {
@@ -2097,12 +2285,12 @@ var ClaudeCodeImporter = class {
     }
     return result;
   }
-  importKnowledge(db, embed) {
+  async importKnowledge(db, embed) {
     const result = { imported: 0, skipped: 0, errors: [] };
     const claudeMdPath = join6(this.basePath, "CLAUDE.md");
     if (!existsSync4(claudeMdPath)) return result;
     try {
-      const raw = readFileSync4(claudeMdPath, "utf8");
+      const raw = readFileSync5(claudeMdPath, "utf8");
       const hash = contentHash(raw);
       if (isAlreadyImported(db, hash)) {
         result.skipped++;
@@ -2115,7 +2303,7 @@ var ClaudeCodeImporter = class {
         source_tool: "claude-code",
         tags: ["pinned"]
       });
-      insertEmbedding(db, "warm", "knowledge", entryId, embed(content));
+      insertEmbedding(db, "warm", "knowledge", entryId, await embed(content));
       logImport(db, "claude-code", claudeMdPath, hash, entryId, "warm", "knowledge");
       result.imported++;
     } catch (err) {
@@ -2128,7 +2316,7 @@ var ClaudeCodeImporter = class {
 };
 
 // src/importers/copilot-cli.ts
-import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
 import { join as join7 } from "path";
 import { homedir as homedir2 } from "os";
 import { createHash as createHash2 } from "crypto";
@@ -2176,10 +2364,10 @@ var CopilotCliImporter = class {
     }
     return { memoryFiles: 0, knowledgeFiles, sessionFiles };
   }
-  importMemories(_db2, _embed, _project) {
+  async importMemories(_db2, _embed, _project) {
     return { imported: 0, skipped: 0, errors: [] };
   }
-  importKnowledge(db, embed) {
+  async importKnowledge(db, embed) {
     const result = { imported: 0, skipped: 0, errors: [] };
     const sessionStateDir = join7(this.basePath, "session-state");
     if (!existsSync5(sessionStateDir)) return result;
@@ -2188,7 +2376,7 @@ var CopilotCliImporter = class {
       const planPath = join7(sessionStateDir, entry.name, "plan.md");
       if (!existsSync5(planPath)) continue;
       try {
-        const raw = readFileSync5(planPath, "utf8");
+        const raw = readFileSync6(planPath, "utf8");
         const hash = contentHash2(raw);
         if (isAlreadyImported2(db, hash)) {
           result.skipped++;
@@ -2199,7 +2387,7 @@ var CopilotCliImporter = class {
           source: planPath,
           source_tool: "copilot-cli"
         });
-        insertEmbedding(db, "cold", "knowledge", entryId, embed(raw));
+        insertEmbedding(db, "cold", "knowledge", entryId, await embed(raw));
         logImport2(db, "copilot-cli", planPath, hash, entryId, "cold", "knowledge");
         result.imported++;
       } catch (err) {
@@ -2226,9 +2414,9 @@ var IMPORT_TOOLS = [
 ];
 async function handleImportTool(name, args, ctx) {
   if (name === "import_host") {
-    const source = args.source;
+    const source = validateOptionalString(args.source, "source");
     await ctx.embedder.ensureLoaded();
-    const embedFn = ctx.embedder.makeSyncEmbedFn();
+    const embedFn = (text) => ctx.embedder.embed(text);
     const importers = [
       new ClaudeCodeImporter(),
       new CopilotCliImporter()
@@ -2242,8 +2430,8 @@ async function handleImportTool(name, args, ctx) {
         continue;
       }
       const scan = importer.scan();
-      const memoriesResult = importer.importMemories(ctx.db, embedFn);
-      const knowledgeResult = importer.importKnowledge(ctx.db, embedFn);
+      const memoriesResult = await importer.importMemories(ctx.db, embedFn);
+      const knowledgeResult = await importer.importKnowledge(ctx.db, embedFn);
       results.push({
         tool: importer.name,
         detected: true,
@@ -2312,7 +2500,7 @@ function logCompactionEvent(db, opts) {
     opts.configSnapshotId
   );
 }
-function compactHotTier(db, embed, config, sessionId, configSnapshotId) {
+async function compactHotTier(db, embed, config, sessionId, configSnapshotId) {
   const snapshotId = configSnapshotId ?? "default";
   const entries = listEntries(db, "hot", "memory");
   const now = Date.now();
@@ -2334,7 +2522,7 @@ function compactHotTier(db, embed, config, sessionId, configSnapshotId) {
     if (score > config.promote_threshold) {
       carryForward.push(entry.id);
     } else if (score >= config.warm_threshold) {
-      promoteEntry(db, embed, entry.id, "hot", "memory", "warm", "memory");
+      await promoteEntry(db, embed, entry.id, "hot", "memory", "warm", "memory");
       promoted.push(entry.id);
       logCompactionEvent(db, {
         sessionId,
@@ -2398,7 +2586,7 @@ var SESSION_TOOLS = [
 async function handleSessionTool(name, args, ctx) {
   if (name === "session_start") {
     await ctx.embedder.ensureLoaded();
-    const embedFn = ctx.embedder.makeSyncEmbedFn();
+    const embedFn = (text) => ctx.embedder.embed(text);
     const importers = [
       new ClaudeCodeImporter(),
       new CopilotCliImporter()
@@ -2406,8 +2594,8 @@ async function handleSessionTool(name, args, ctx) {
     const importSummary = [];
     for (const importer of importers) {
       if (!importer.detect()) continue;
-      const memResult = importer.importMemories(ctx.db, embedFn);
-      const kbResult = importer.importKnowledge(ctx.db, embedFn);
+      const memResult = await importer.importMemories(ctx.db, embedFn);
+      const kbResult = await importer.importKnowledge(ctx.db, embedFn);
       importSummary.push({
         tool: importer.name,
         memoriesImported: memResult.imported,
@@ -2436,9 +2624,9 @@ async function handleSessionTool(name, args, ctx) {
   }
   if (name === "session_end") {
     await ctx.embedder.ensureLoaded();
-    const embedFn = ctx.embedder.makeSyncEmbedFn();
+    const embedFn = (text) => ctx.embedder.embed(text);
     const sessionId = ctx.sessionId ?? randomUUID4();
-    const result = compactHotTier(ctx.db, embedFn, ctx.config.compaction, sessionId);
+    const result = await compactHotTier(ctx.db, embedFn, ctx.config.compaction, sessionId);
     return {
       content: [
         {
@@ -2482,6 +2670,355 @@ function registerSessionTools() {
   return SESSION_TOOLS;
 }
 
+// src/tools/extra-tools.ts
+import { mkdirSync as mkdirSync3, writeFileSync, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
+function registerExtraTools() {
+  return [
+    {
+      name: "compact_now",
+      description: "Force compaction of a memory tier immediately",
+      inputSchema: {
+        type: "object",
+        properties: {
+          tier: {
+            type: "string",
+            enum: ["hot"],
+            description: "Tier to compact (currently only hot supported)"
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "memory_inspect",
+      description: "Deep dive on a single memory entry, including its compaction history",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Entry ID" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "memory_history",
+      description: "List recent tier movements from compaction log",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: { type: "number", description: "Max results (default 20)" }
+        },
+        required: []
+      }
+    },
+    {
+      name: "memory_lineage",
+      description: "Show the full compaction ancestry tree for a memory entry",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Entry ID" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "memory_export",
+      description: "Export memories to a JSON file",
+      inputSchema: {
+        type: "object",
+        properties: {
+          tiers: {
+            type: "array",
+            items: { type: "string", enum: ["hot", "warm", "cold"] },
+            description: "Tiers to export (default: all)"
+          },
+          content_types: {
+            type: "array",
+            items: { type: "string", enum: ["memory", "knowledge"] },
+            description: "Content types to export (default: all)"
+          },
+          format: {
+            type: "string",
+            enum: ["json"],
+            description: "Export format (default: json)"
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "memory_import",
+      description: "Import memories from a JSON export file",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path to export JSON file" }
+        },
+        required: ["path"]
+      }
+    }
+  ];
+}
+function getCompactionLogForEntry(db, id) {
+  const rows = db.prepare(
+    `SELECT * FROM compaction_log
+       WHERE target_entry_id = ?
+          OR source_entry_ids LIKE ?
+       ORDER BY timestamp DESC`
+  ).all(id, `%"${id}"%`);
+  return rows;
+}
+function buildLineage(db, id, depth) {
+  if (depth >= 10) {
+    return { id, sources: [] };
+  }
+  const row = db.prepare(`SELECT * FROM compaction_log WHERE target_entry_id = ? ORDER BY timestamp DESC LIMIT 1`).get(id);
+  if (!row) {
+    return { id };
+  }
+  let sourceIds = [];
+  try {
+    sourceIds = JSON.parse(row.source_entry_ids);
+  } catch {
+    sourceIds = [];
+  }
+  const sources = sourceIds.map((srcId) => buildLineage(db, srcId, depth + 1));
+  return {
+    id,
+    compaction_log_id: row.id,
+    reason: row.reason,
+    timestamp: row.timestamp,
+    source_tier: row.source_tier,
+    target_tier: row.target_tier,
+    sources
+  };
+}
+async function handleExtraTool(name, args, ctx) {
+  const { db } = ctx;
+  if (name === "compact_now") {
+    await ctx.embedder.ensureLoaded();
+    const embedFn = (text) => ctx.embedder.embed(text);
+    const result = await compactHotTier(
+      db,
+      embedFn,
+      ctx.config.compaction,
+      ctx.sessionId
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            carryForward: result.carryForward.length,
+            promoted: result.promoted.length,
+            discarded: result.discarded.length,
+            carryForwardIds: result.carryForward,
+            promotedIds: result.promoted,
+            discardedIds: result.discarded
+          })
+        }
+      ]
+    };
+  }
+  if (name === "memory_inspect") {
+    const id = validateString(args.id, "id");
+    const location = getMemory(db, id);
+    const compactionHistory = getCompactionLogForEntry(db, id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            entry: location,
+            compaction_history: compactionHistory
+          })
+        }
+      ]
+    };
+  }
+  if (name === "memory_history") {
+    const limit = validateOptionalNumber(args.limit, "limit", 1, 1e3) ?? 20;
+    const rows = db.prepare(`SELECT * FROM compaction_log ORDER BY timestamp DESC LIMIT ?`).all(limit);
+    const movements = rows.map((row) => {
+      let sourceIds = [];
+      try {
+        sourceIds = JSON.parse(row.source_entry_ids);
+      } catch {
+        sourceIds = [];
+      }
+      return {
+        id: row.id,
+        timestamp: row.timestamp,
+        session_id: row.session_id,
+        source_tier: row.source_tier,
+        target_tier: row.target_tier,
+        source_entry_ids: sourceIds,
+        target_entry_id: row.target_entry_id,
+        reason: row.reason,
+        decay_scores: (() => {
+          try {
+            return JSON.parse(row.decay_scores);
+          } catch {
+            return {};
+          }
+        })()
+      };
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ movements, count: movements.length })
+        }
+      ]
+    };
+  }
+  if (name === "memory_lineage") {
+    const id = validateString(args.id, "id");
+    const lineage = buildLineage(db, id, 0);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ lineage })
+        }
+      ]
+    };
+  }
+  if (name === "memory_export") {
+    const tierFilter = args.tiers;
+    const typeFilter = args.content_types;
+    const pairs = ALL_TABLE_PAIRS.filter(
+      (p) => (!tierFilter || tierFilter.includes(p.tier)) && (!typeFilter || typeFilter.includes(p.type))
+    );
+    const allEntries = [];
+    for (const { tier, type } of pairs) {
+      const entries = listEntries(db, tier, type);
+      for (const entry of entries) {
+        allEntries.push({
+          ...entry,
+          tier,
+          content_type: type
+        });
+      }
+    }
+    const exportsDir = join8(getDataDir(), "exports");
+    mkdirSync3(exportsDir, { recursive: true });
+    const timestamp = Date.now();
+    const exportPath = join8(exportsDir, `${timestamp}.json`);
+    const exportData = { version: 1, exported_at: timestamp, entries: allEntries };
+    const jsonStr = JSON.stringify(exportData, null, 2);
+    writeFileSync(exportPath, jsonStr, "utf-8");
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            path: exportPath,
+            entry_count: allEntries.length,
+            size_bytes: Buffer.byteLength(jsonStr, "utf-8")
+          })
+        }
+      ]
+    };
+  }
+  if (name === "memory_import") {
+    const filePath = validatePath(args.path, "path");
+    let raw;
+    try {
+      raw = readFileSync7(filePath, "utf-8");
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: `Failed to read file: ${String(err)}` })
+          }
+        ]
+      };
+    }
+    let exportData;
+    try {
+      exportData = JSON.parse(raw);
+    } catch {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Invalid JSON in export file" })
+          }
+        ]
+      };
+    }
+    const entries = exportData.entries ?? [];
+    if (!Array.isArray(entries)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Export file missing entries array" })
+          }
+        ]
+      };
+    }
+    await ctx.embedder.ensureLoaded();
+    let imported = 0;
+    let skipped = 0;
+    const existingIds = /* @__PURE__ */ new Set();
+    const existingContents = /* @__PURE__ */ new Set();
+    for (const { tier, type } of ALL_TABLE_PAIRS) {
+      const existing = listEntries(db, tier, type);
+      for (const e of existing) {
+        existingIds.add(e.id);
+        existingContents.add(e.content);
+      }
+    }
+    const seenContents = new Set(existingContents);
+    for (const entry of entries) {
+      if (typeof entry.content !== "string" || !entry.content) {
+        skipped++;
+        continue;
+      }
+      if (existingIds.has(entry.id)) {
+        skipped++;
+        continue;
+      }
+      if (seenContents.has(entry.content)) {
+        skipped++;
+        continue;
+      }
+      seenContents.add(entry.content);
+      const tier = ["hot", "warm", "cold"].includes(entry.tier) ? entry.tier : "hot";
+      const content_type = ["memory", "knowledge"].includes(entry.content_type) ? entry.content_type : "memory";
+      const newId = insertEntry(db, tier, content_type, {
+        content: entry.content,
+        summary: entry.summary ?? null,
+        source: entry.source ?? null,
+        source_tool: entry.source_tool ?? null,
+        project: entry.project ?? null,
+        tags: Array.isArray(entry.tags) ? entry.tags : [],
+        parent_id: entry.parent_id ?? null,
+        collection_id: entry.collection_id ?? null,
+        metadata: entry.metadata ?? {}
+      });
+      const vec = await ctx.embedder.embed(entry.content);
+      insertEmbedding(db, tier, content_type, newId, vec);
+      imported++;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ imported, skipped })
+        }
+      ]
+    };
+  }
+  return null;
+}
+
 // src/tools/registry.ts
 async function startServer(ctx) {
   const server = new Server(
@@ -2494,7 +3031,8 @@ async function startServer(ctx) {
     ...registerKbTools(),
     ...registerEvalTools(),
     ...registerImportTools(),
-    ...registerSessionTools()
+    ...registerSessionTools(),
+    ...registerExtraTools()
   ];
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools: allTools };
@@ -2514,6 +3052,8 @@ async function startServer(ctx) {
     if (importResult !== null) return importResult;
     const sessionResult = await handleSessionTool(name, args ?? {}, ctx);
     if (sessionResult !== null) return sessionResult;
+    const extraResult = await handleExtraTool(name, args ?? {}, ctx);
+    if (extraResult !== null) return extraResult;
     return {
       content: [
         {