@equationalapplications/core-llm-wiki 2.6.0 → 3.0.0

package/dist/index.js

@@ -24,7 +24,8 @@ async function setupDatabase(db, prefix) {
       last_accessed_at INTEGER,
       access_count INTEGER NOT NULL DEFAULT 0,
       deleted_at INTEGER,
-      embedding TEXT
+      embedding TEXT,
+      embedding_blob BLOB
     );
 
     CREATE INDEX IF NOT EXISTS ${prefix}entries_entity_idx ON ${prefix}entries(entity_id);
@@ -97,6 +98,20 @@ var MIGRATIONS = [
         await db.execAsync(`ALTER TABLE ${prefix}entries ADD COLUMN embedding TEXT`);
       }
     }
+  },
+  {
+    version: 3,
+    description: "Add embedding_blob BLOB column for Float32Array vector storage",
+    run: async (db, prefix) => {
+      const cols = await db.getAllAsync(
+        `PRAGMA table_info(${prefix}entries)`
+      );
+      if (!cols.some((c) => c.name === "embedding_blob")) {
+        await db.execAsync(
+          `ALTER TABLE ${prefix}entries ADD COLUMN embedding_blob BLOB`
+        );
+      }
+    }
   }
 ];
 for (let i = 1; i < MIGRATIONS.length; i++) {
@@ -154,6 +169,34 @@ function cosineSimilarity(a, b) {
   return denom === 0 ? 0 : dot / denom;
 }
 
+// src/utils/embedding.ts
+function parseEmbedding(blob, text) {
+  if (blob && blob.byteLength > 0) {
+    if (blob.byteLength % 4 !== 0) return null;
+    const copy = new ArrayBuffer(blob.byteLength);
+    new Uint8Array(copy).set(blob);
+    const vector = new Float32Array(copy);
+    for (const value of vector) {
+      if (!Number.isFinite(value)) return null;
+    }
+    return vector;
+  }
+  if (text) {
+    try {
+      const arr = JSON.parse(text);
+      if (!Array.isArray(arr) || !arr.every((v) => typeof v === "number" && isFinite(v))) return null;
+      const vector = new Float32Array(arr);
+      for (const value of vector) {
+        if (!Number.isFinite(value)) return null;
+      }
+      return vector;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
 // src/WikiMemory.ts
 function parseJsonResponse(text) {
   const firstBrace = text.indexOf("{");
@@ -358,7 +401,7 @@ function jaccardScore(a, b) {
 }
 var FUZZY_THRESHOLD = 0.5;
 var MIN_TOKENS_TO_QUALIFY = 3;
-var WikiMemory = class {
+var _WikiMemory = class _WikiMemory {
   constructor(db, options) {
     this.activeMaintenanceJobs = /* @__PURE__ */ new Set();
     this.activeIngestJobs = /* @__PURE__ */ new Set();
@@ -372,6 +415,7 @@ var WikiMemory = class {
       }
     });
     this.miniSearchEntryIdsByEntity = /* @__PURE__ */ new Map();
+    this.vectorCache = /* @__PURE__ */ new Map();
     this.db = db;
     this.options = options;
     this.prefix = options.config?.tablePrefix || "llm_wiki_";
@@ -438,10 +482,6 @@ var WikiMemory = class {
           `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension_mismatch', ?)`,
           [String(dim)]
         );
-      } else {
-        await this.db.runAsync(
-          `DELETE FROM ${this.prefix}meta WHERE key = 'embedding_dimension_mismatch'`
-        );
       }
     } else {
       await this.db.runAsync(
@@ -460,7 +500,18 @@ var WikiMemory = class {
     const mismatch = await this.db.getFirstAsync(
       `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension_mismatch'`
     );
-    if (mismatch) {
+    if (!mismatch) return;
+    const newDim = parseInt(mismatch.value, 10);
+    const residual = await this.db.getFirstAsync(
+      `SELECT COUNT(*) AS cnt FROM ${this.prefix}entries
+       WHERE deleted_at IS NULL
+         AND (
+           (embedding_blob IS NOT NULL AND (CAST(length(embedding_blob) AS INTEGER) / 4) != ?)
+           OR (embedding_blob IS NULL AND embedding IS NOT NULL)
+         )`,
+      [newDim]
+    );
+    if (!residual || residual.cnt === 0) {
       await this.db.runAsync(
         `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension', ?)`,
         [mismatch.value]
@@ -491,10 +542,23 @@ var WikiMemory = class {
         console.warn(`[WikiMemory] embedFact: embed() returned an invalid vector for ${fact.id}; skipping.`);
         return false;
       }
-      await this.storeEmbeddingDimension(vector.length);
+      const float32Vector = new Float32Array(vector);
+      let hasNonFinite = false;
+      for (let i = 0; i < float32Vector.length; i++) {
+        if (!isFinite(float32Vector[i])) {
+          hasNonFinite = true;
+          break;
+        }
+      }
+      if (hasNonFinite) {
+        console.warn(`[WikiMemory] embedFact: embed() returned values that overflow float32 for ${fact.id}; skipping.`);
+        return false;
+      }
+      await this.storeEmbeddingDimension(float32Vector.length);
+      const blob = new Uint8Array(float32Vector.buffer);
       await this.db.runAsync(
-        `UPDATE ${this.prefix}entries SET embedding = ? WHERE id = ?`,
-        [JSON.stringify(vector), fact.id]
+        `UPDATE ${this.prefix}entries SET embedding_blob = ?, embedding = NULL WHERE id = ?`,
+        [blob, fact.id]
       );
       return true;
     } catch (err) {
@@ -614,9 +678,24 @@ var WikiMemory = class {
   _globalReembedKey() {
     return `${this.prefix}:reembed`;
   }
+  _importKey(entityId) {
+    return `${this.prefix}:${entityId}:import`;
+  }
+  _globalImportKey() {
+    return `${this.prefix}:import`;
+  }
+  _forgetKey(entityId) {
+    return `${this.prefix}:${entityId}:forget`;
+  }
   _isReembedActive(entityId) {
     return this.activeMaintenanceJobs.has(this._reembedKey(entityId)) || this.activeMaintenanceJobs.has(this._globalReembedKey());
   }
+  _isImportActiveFor(entityId) {
+    return this.activeMaintenanceJobs.has(this._importKey(entityId)) || this.activeMaintenanceJobs.has(this._globalImportKey());
+  }
+  _isForgetActiveFor(entityId) {
+    return this.activeMaintenanceJobs.has(this._forgetKey(entityId));
+  }
   /** Returns true if any maintenance job has the given operation suffix (e.g. ':prune'). */
   _isAnyMaintenanceActiveWithSuffix(suffix) {
     const entityKeyPrefix = `${this.prefix}:`;
@@ -659,6 +738,10 @@ var WikiMemory = class {
       blockingOperation = "reembed";
     } else if (isIngestRunning) {
       blockingOperation = "ingest";
+    } else if (this._isImportActiveFor(entityId)) {
+      blockingOperation = "import";
+    } else if (this._isForgetActiveFor(entityId)) {
+      blockingOperation = "forget";
     }
     if (blockingOperation !== null) {
       throw new WikiBusyError(blockingOperation, entityId);
@@ -703,19 +786,27 @@ var WikiMemory = class {
         await this.db.execAsync(`VACUUM`);
       }
       await this.rebuildMiniSearchIndex(entityId);
+      this.vectorCache.delete(entityId);
       return { entries: deletedEntries, tasks: deletedTasks, events: deletedEvents };
     } finally {
       this.activeMaintenanceJobs.delete(pruneKey);
     }
   }
-  async read(entityId, query) {
-    const maxResults = this.options.config?.maxResults ?? this.options.config?.maxFtsResults ?? 10;
+  async read(entityId, query, options) {
+    const config = this.options.config;
+    const rawMaxResults = options?.maxResults ?? config?.maxResults ?? config?.maxFtsResults ?? 10;
+    const maxResults = Number.isFinite(rawMaxResults) ? Math.max(0, Math.trunc(rawMaxResults)) : 10;
+    const rawPreFilterLimit = options?.preFilterLimit === null ? void 0 : options?.preFilterLimit ?? config?.preFilterLimit;
+    const effectivePreFilterLimit = rawPreFilterLimit === void 0 ? void 0 : Number.isFinite(rawPreFilterLimit) ? Math.max(0, Math.trunc(rawPreFilterLimit)) : void 0;
+    const hybridWeight = options?.hybridWeight ?? config?.hybridWeight;
+    const weight = hybridWeight !== void 0 && !Number.isNaN(hybridWeight) ? Math.max(0, Math.min(1, hybridWeight)) : void 0;
+    const skipEmbed = weight === 0;
     const embedFn = this.options.llmProvider.embed;
     const trimmedQuery = query.trim();
     let facts = [];
-    if (trimmedQuery) {
+    if (maxResults === 0) ; else if (trimmedQuery) {
       let usedEmbed = false;
-      if (embedFn) {
+      if (!skipEmbed && embedFn) {
         try {
           const queryVec = await embedFn(trimmedQuery);
           if (queryVec.length === 0 || !queryVec.every((v) => typeof v === "number" && isFinite(v))) {
@@ -734,49 +825,138 @@ var WikiMemory = class {
               );
             }
           }
-          const scoreRows = await this.db.getAllAsync(
-            `SELECT id, embedding, updated_at, access_count FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL`,
-            [entityId]
+          const mismatchedCount = await this.db.getFirstAsync(
+            `SELECT COUNT(*) AS cnt FROM ${this.prefix}entries
+             WHERE entity_id = ? AND deleted_at IS NULL
+               AND embedding_blob IS NOT NULL
+               AND (CAST(length(embedding_blob) AS INTEGER) % 4 = 0)
+               AND (CAST(length(embedding_blob) AS INTEGER) / 4) != ?`,
+            [entityId, queryVec.length]
           );
-          const scored = scoreRows.map((row) => {
-            let score = 0;
-            if (row.embedding) {
-              try {
-                const parsed = JSON.parse(row.embedding);
-                if (Array.isArray(parsed) && parsed.length === queryVec.length && parsed.every((v) => typeof v === "number" && isFinite(v))) {
-                  score = cosineSimilarity(queryVec, parsed);
+          if (mismatchedCount && mismatchedCount.cnt > 0) {
+            throw new Error(
+              `Some facts have embeddings that do not match the current model dimension. Call runReembed() to rebuild all embeddings consistently.`
+            );
+          }
+          let candidateRows;
+          let populateCache = true;
+          let miniSearchScores;
+          if (effectivePreFilterLimit !== void 0) {
+            populateCache = false;
+            const preResults = this.miniSearch.search(trimmedQuery, {
+              filter: (r) => r.entity_id === entityId,
+              combineWith: "OR"
+            });
+            if (preResults.length === 0) {
+              candidateRows = null;
+            } else {
+              const topKResults = preResults.slice(0, effectivePreFilterLimit);
+              if (topKResults.length === 0) {
+                candidateRows = null;
+              } else {
+                const topKIds = topKResults.map((r) => r.id);
+                const inClauseChunkSize = 500;
+                candidateRows = [];
+                for (let i = 0; i < topKIds.length; i += inClauseChunkSize) {
+                  const idChunk = topKIds.slice(i, i + inClauseChunkSize);
+                  const placeholders = idChunk.map(() => "?").join(",");
+                  const chunkRows = await this.db.getAllAsync(
+                    `SELECT id, embedding_blob, embedding, updated_at, access_count FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
+                    idChunk
+                  );
+                  candidateRows.push(...chunkRows);
+                }
+                if (weight !== void 0 && weight < 1) {
+                  const maxMsScore = Math.max(1, topKResults[0]?.score ?? 1);
+                  miniSearchScores = new Map(topKResults.map((r) => [r.id, r.score / maxMsScore]));
                 }
-              } catch {
               }
             }
-            return { row, score };
-          });
-          scored.sort((a, b) => {
-            const scoreDiff = b.score - a.score;
-            if (scoreDiff !== 0) {
-              return scoreDiff;
+          } else {
+            candidateRows = await this.db.getAllAsync(
+              `SELECT id, embedding_blob, embedding, updated_at, access_count FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL`,
+              [entityId]
+            );
+            if (weight !== void 0 && weight < 1) {
+              const msResults = this.miniSearch.search(trimmedQuery, {
+                filter: (r) => r.entity_id === entityId,
+                combineWith: "OR"
+              });
+              const maxMsScore = Math.max(1, msResults[0]?.score ?? 1);
+              miniSearchScores = new Map(msResults.map((r) => [r.id, r.score / maxMsScore]));
             }
-            const updatedAtDiff = (b.row.updated_at ?? 0) - (a.row.updated_at ?? 0);
-            if (updatedAtDiff !== 0) {
-              return updatedAtDiff;
+          }
+          if (candidateRows === null) {
+            usedEmbed = true;
+          } else {
+            let entityCache = this.vectorCache.get(entityId);
+            const tooLarge = populateCache && candidateRows.length > _WikiMemory.MAX_VECTOR_CACHE_FACTS_PER_ENTITY;
+            if (tooLarge && entityCache) {
+              this.vectorCache.delete(entityId);
+              entityCache = void 0;
             }
-            const accessCountDiff = (b.row.access_count ?? 0) - (a.row.access_count ?? 0);
-            if (accessCountDiff !== 0) {
-              return accessCountDiff;
+            const canCache = populateCache && !tooLarge;
+            if (canCache && !entityCache) {
+              entityCache = /* @__PURE__ */ new Map();
             }
-            return a.row.id.localeCompare(b.row.id);
-          });
-          const topIds = scored.slice(0, maxResults).map((s) => s.row.id);
-          if (topIds.length > 0) {
-            const placeholders = topIds.map(() => "?").join(",");
-            const fullRows = await this.db.getAllAsync(
-              `SELECT * FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
-              topIds
-            );
-            const byId = new Map(fullRows.map((r) => [r.id, r]));
-            facts = topIds.map((id) => byId.get(id)).filter((f) => f !== void 0);
+            const scored = candidateRows.map((row) => {
+              let vector = entityCache?.get(row.id) ?? parseEmbedding(row.embedding_blob, row.embedding);
+              if (vector && canCache && entityCache && !entityCache.has(row.id)) {
+                entityCache.set(row.id, vector);
+              }
+              let score = 0;
+              if (vector && vector.length === queryVec.length) {
+                const cosSim = cosineSimilarity(queryVec, vector);
+                if (weight !== void 0) {
+                  const kwScore = miniSearchScores?.get(row.id) ?? 0;
+                  score = weight * Math.max(0, cosSim) + (1 - weight) * kwScore;
+                } else {
+                  score = cosSim;
+                }
+              } else if (weight !== void 0 && weight < 1) {
+                const kwScore = miniSearchScores?.get(row.id) ?? 0;
+                score = (1 - weight) * kwScore;
+              } else {
+                score = -2;
+              }
+              return { row, score };
+            });
+            if (canCache && entityCache && entityCache.size > 0) {
+              if (!this.vectorCache.has(entityId)) {
+                if (this.vectorCache.size >= _WikiMemory.MAX_VECTOR_CACHE_ENTITIES) {
+                  const oldestKey = this.vectorCache.keys().next().value;
+                  if (oldestKey !== void 0) this.vectorCache.delete(oldestKey);
+                }
+                this.vectorCache.set(entityId, entityCache);
+              }
+            }
+            scored.sort((a, b) => {
+              const scoreDiff = b.score - a.score;
+              if (scoreDiff !== 0) return scoreDiff;
+              const accessCountDiff = (b.row.access_count ?? 0) - (a.row.access_count ?? 0);
+              if (accessCountDiff !== 0) return accessCountDiff;
+              const updatedAtDiff = (b.row.updated_at ?? 0) - (a.row.updated_at ?? 0);
+              if (updatedAtDiff !== 0) return updatedAtDiff;
+              return a.row.id.localeCompare(b.row.id);
+            });
+            const topIds = scored.slice(0, maxResults).map((s) => s.row.id);
+            if (topIds.length > 0) {
+              const fullRows = [];
+              const phase2ChunkSize = 500;
+              for (let i = 0; i < topIds.length; i += phase2ChunkSize) {
+                const idChunk = topIds.slice(i, i + phase2ChunkSize);
+                const placeholders = idChunk.map(() => "?").join(",");
+                const chunkRows = await this.db.getAllAsync(
+                  `SELECT * FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
+                  idChunk
+                );
+                fullRows.push(...chunkRows);
+              }
+              const byId = new Map(fullRows.map((r) => [r.id, r]));
+              facts = topIds.map((id) => byId.get(id)).filter((f) => f !== void 0);
+            }
+            usedEmbed = true;
           }
-          usedEmbed = true;
         } catch (err) {
           const error = err instanceof Error ? err : new Error(String(err));
           this.options.onRetrievalFallback?.(error);
@@ -789,25 +969,35 @@ var WikiMemory = class {
         });
         const topIds = results.slice(0, maxResults).map((r) => r.id);
         if (topIds.length > 0) {
-          const placeholders = topIds.map(() => "?").join(",");
-          const rows = await this.db.getAllAsync(
-            `SELECT * FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
-            topIds
-          );
-          const byId = new Map(rows.map((r) => [r.id, r]));
+          const kwRows = [];
+          const kwChunkSize = 500;
+          for (let i = 0; i < topIds.length; i += kwChunkSize) {
+            const idChunk = topIds.slice(i, i + kwChunkSize);
+            const placeholders = idChunk.map(() => "?").join(",");
+            const chunkRows = await this.db.getAllAsync(
+              `SELECT * FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
+              idChunk
+            );
+            kwRows.push(...chunkRows);
+          }
+          const byId = new Map(kwRows.map((r) => [r.id, r]));
           facts = topIds.map((id) => byId.get(id)).filter((f) => f !== void 0);
         }
       }
       if (facts.length > 0) {
         const ids = facts.map((f) => f.id);
-        const placeholders = ids.map(() => "?").join(",");
         const now = Date.now();
-        await this.db.runAsync(
-          `UPDATE ${this.prefix}entries
-           SET access_count = access_count + 1, last_accessed_at = ?
-           WHERE id IN (${placeholders})`,
-          [now, ...ids]
-        );
+        const accessChunkSize = 500;
+        for (let i = 0; i < ids.length; i += accessChunkSize) {
+          const idChunk = ids.slice(i, i + accessChunkSize);
+          const placeholders = idChunk.map(() => "?").join(",");
+          await this.db.runAsync(
+            `UPDATE ${this.prefix}entries
+             SET access_count = access_count + 1, last_accessed_at = ?
+             WHERE id IN (${placeholders})`,
+            [now, ...idChunk]
+          );
+        }
       }
     } else {
       facts = await this.db.getAllAsync(
@@ -834,7 +1024,7 @@ var WikiMemory = class {
       )
     ]);
     const parsedFacts = facts.map((f) => {
-      const { embedding: _embedding, ...rest } = f;
+      const { embedding: _embedding, embedding_blob: _blob, ...rest } = f;
       return {
         ...rest,
         tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags
@@ -866,7 +1056,7 @@ var WikiMemory = class {
     if (memoryCheckpoint > count) memoryCheckpoint = 0;
     if (count - memoryCheckpoint >= threshold) {
       const jobKey = this._librarianKey(entityId);
-      if (!this.activeMaintenanceJobs.has(jobKey) && !this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
+      if (!this.activeMaintenanceJobs.has(jobKey) && !this.activeMaintenanceJobs.has(this._pruneKey(entityId)) && !this._isReembedActive(entityId) && !this._isImportActiveFor(entityId) && !this._isForgetActiveFor(entityId)) {
         this.activeMaintenanceJobs.add(jobKey);
         this.runLibrarianThenMaybeHeal(entityId, count).catch(console.error).finally(() => this.activeMaintenanceJobs.delete(jobKey));
       }
@@ -914,7 +1104,7 @@ var WikiMemory = class {
       LIMIT 100
     `, [entityId]);
     const currentFacts = currentFactsRows.map((f) => {
-      const { embedding: _embedding, ...rest } = f;
+      const { embedding: _embedding, embedding_blob: _blob, ...rest } = f;
       return {
         ...rest,
         tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags
@@ -968,10 +1158,12 @@ ${JSON.stringify(currentFacts, null, 2)}`;
         `, [id, entityId, task.description, "pending", task.priority, now, now]);
       }
     });
+    await this.rebuildMiniSearchIndex(entityId);
+    this.vectorCache.delete(entityId);
     for (const fact of insertedFacts) {
       await this.embedFact(fact);
     }
-    await this.rebuildMiniSearchIndex(entityId);
+    this.vectorCache.delete(entityId);
   }
   async _doRunHeal(entityId) {
     const now = Date.now();
@@ -1009,7 +1201,7 @@ ${JSON.stringify(currentFacts, null, 2)}`;
     const documentAnchors = allFactsRows.filter((f) => f.source_type === "user_document").map(({ id, title, source_ref }) => ({ id, title, source_ref }));
     const userPrompt = `Heal Candidates:
 ${JSON.stringify(healCandidates.map((f) => {
-      const { embedding: _embedding, ...rest } = f;
+      const { embedding: _embedding, embedding_blob: _blob, ...rest } = f;
       return { ...rest, tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags };
     }), null, 2)}
 
@@ -1052,10 +1244,12 @@ The following document anchors are provided for contradiction detection only. Do
         insertedFacts.push({ id, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
       }
     });
+    this.vectorCache.delete(entityId);
+    await this.rebuildMiniSearchIndex(entityId);
     for (const fact of insertedFacts) {
       await this.embedFact(fact);
     }
-    await this.rebuildMiniSearchIndex(entityId);
+    this.vectorCache.delete(entityId);
   }
   async runLibrarian(entityId) {
     const jobKey = this._librarianKey(entityId);
@@ -1068,6 +1262,12 @@ The following document anchors are provided for contradiction detection only. Do
     if (this._isReembedActive(entityId)) {
       throw new WikiBusyError("reembed", entityId);
     }
+    if (this._isImportActiveFor(entityId)) {
+      throw new WikiBusyError("import", entityId);
+    }
+    if (this._isForgetActiveFor(entityId)) {
+      throw new WikiBusyError("forget", entityId);
+    }
     this.activeMaintenanceJobs.add(jobKey);
     try {
       await this._doRunLibrarian(entityId);
@@ -1086,6 +1286,12 @@ The following document anchors are provided for contradiction detection only. Do
     if (this._isReembedActive(entityId)) {
       throw new WikiBusyError("reembed", entityId);
     }
+    if (this._isImportActiveFor(entityId)) {
+      throw new WikiBusyError("import", entityId);
+    }
+    if (this._isForgetActiveFor(entityId)) {
+      throw new WikiBusyError("forget", entityId);
+    }
     this.activeMaintenanceJobs.add(jobKey);
     try {
       await this._doRunHeal(entityId);
@@ -1093,9 +1299,9 @@ The following document anchors are provided for contradiction detection only. Do
       this.activeMaintenanceJobs.delete(jobKey);
     }
   }
-  async runReembed(entityId) {
+  async runReembed(entityId, opts) {
     const embedFn = this.options.llmProvider.embed;
-    if (!embedFn) return { embedded: 0, skipped: 0 };
+    if (!embedFn) return { embedded: 0, skipped: 0, failed: 0 };
     const reembedKey = entityId ? this._reembedKey(entityId) : this._globalReembedKey();
     if (this.activeMaintenanceJobs.has(reembedKey)) {
       throw new WikiBusyError("reembed", entityId ?? "*");
@@ -1116,6 +1322,12 @@ The following document anchors are provided for contradiction detection only. Do
       if (this._isIngestActiveFor(entityId)) {
         throw new WikiBusyError("ingest", entityId);
       }
+      if (this._isImportActiveFor(entityId)) {
+        throw new WikiBusyError("import", entityId);
+      }
+      if (this._isForgetActiveFor(entityId)) {
+        throw new WikiBusyError("forget", entityId);
+      }
     } else {
       if (this._isAnyMaintenanceActiveWithSuffix(":reembed")) {
         throw new WikiBusyError("reembed", "*");
@@ -1132,6 +1344,12 @@ The following document anchors are provided for contradiction detection only. Do
       if (this.activeIngestJobs.size > 0) {
         throw new WikiBusyError("ingest", "*");
       }
+      if (this._isAnyMaintenanceActiveWithSuffix(":import")) {
+        throw new WikiBusyError("import", "*");
+      }
+      if (this._isAnyMaintenanceActiveWithSuffix(":forget")) {
+        throw new WikiBusyError("forget", "*");
+      }
     }
     this.activeMaintenanceJobs.add(reembedKey);
     try {
@@ -1141,17 +1359,64 @@ The following document anchors are provided for contradiction detection only. Do
         `SELECT * FROM ${this.prefix}entries WHERE ${where}`,
         params
       );
+      if (entityId) {
+        this.vectorCache.delete(entityId);
+      } else {
+        this.vectorCache.clear();
+      }
+      const skipExisting = opts?.skipExisting ?? false;
+      let effectiveSkip = skipExisting;
+      if (skipExisting) {
+        const mismatchRow = await this.db.getFirstAsync(
+          `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension_mismatch'`
+        );
+        if (mismatchRow) {
+          if (entityId) {
+            const mismatchDim = parseInt(mismatchRow.value, 10);
+            const staleForEntity = await this.db.getFirstAsync(
+              `SELECT COUNT(*) AS cnt FROM ${this.prefix}entries
+               WHERE entity_id = ? AND deleted_at IS NULL
+                 AND (
+                   embedding_blob IS NULL
+                   OR (CAST(length(embedding_blob) AS INTEGER) / 4) != ?
+                 )`,
+              [entityId, mismatchDim]
+            );
+            if (staleForEntity && staleForEntity.cnt > 0) effectiveSkip = false;
+          } else {
+            effectiveSkip = false;
+          }
+        }
+      }
       let embedded = 0;
       let skipped = 0;
-      for (const row of rows) {
-        const success = await this.embedFact(row);
-        if (success) embedded++;
-        else skipped++;
-      }
-      if (embedded > 0) {
-        await this._reconcileEmbeddingDimension();
+      let failed = 0;
+      try {
+        for (const row of rows) {
+          const existingBlob = row.embedding_blob;
+          const blobIsValid = !!existingBlob && existingBlob.byteLength > 0 && existingBlob.byteLength % 4 === 0;
+          if (effectiveSkip && blobIsValid) {
+            const vec = parseEmbedding(existingBlob, null);
+            if (vec !== null && vec.every((v) => Number.isFinite(v))) {
+              skipped++;
+              continue;
+            }
+          }
+          const success = await this.embedFact(row);
+          if (success) embedded++;
+          else failed++;
+        }
+        if (embedded > 0) {
+          await this._reconcileEmbeddingDimension();
+        }
+      } finally {
+        if (entityId) {
+          this.vectorCache.delete(entityId);
+        } else {
+          this.vectorCache.clear();
+        }
       }
-      return { embedded, skipped };
+      return { embedded, skipped, failed };
     } finally {
       this.activeMaintenanceJobs.delete(reembedKey);
     }
@@ -1171,6 +1436,9 @@ The following document anchors are provided for contradiction detection only. Do
       heal: this.activeMaintenanceJobs.has(this._healKey(entityId))
     };
   }
+  clearVectorCache() {
+    this.vectorCache.clear();
+  }
   async _getFullBundle(entityId, opts) {
     const maxEvents = opts?.maxEvents;
     const eventsQuery = maxEvents != null ? `SELECT * FROM ${this.prefix}events WHERE entity_id = ? ORDER BY created_at DESC LIMIT ?` : `SELECT * FROM ${this.prefix}events WHERE entity_id = ? ORDER BY created_at ASC`;
@@ -1187,10 +1455,16 @@ The following document anchors are provided for contradiction detection only. Do
       this.db.getAllAsync(eventsQuery, eventsParams)
     ]);
     const facts = factsRaw.map((f) => {
-      const { embedding: _embedding, ...rest } = f;
+      const { embedding: _embedding, embedding_blob, ...rest } = f;
+      const safeBlobCopy = opts?.includeBlobs && embedding_blob ? (() => {
+        const c = new ArrayBuffer(embedding_blob.byteLength);
+        new Uint8Array(c).set(embedding_blob);
+        return new Uint8Array(c);
+      })() : void 0;
+      const factBase = safeBlobCopy ? { ...rest, embedding_blob: safeBlobCopy } : rest;
       return {
-        ...rest,
-        tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags
+        ...factBase,
+        tags: typeof factBase.tags === "string" ? JSON.parse(factBase.tags) : factBase.tags
       };
     });
     const events = maxEvents != null ? eventsRaw.slice().reverse() : eventsRaw;
@@ -1217,7 +1491,7 @@ The following document anchors are provided for contradiction detection only. Do
     for (let i = 0; i < ids.length; i += BATCH) {
       const batch = ids.slice(i, i + BATCH);
       const batchResults = await Promise.all(
-        batch.map(async (id) => [id, await this._getFullBundle(id)])
+        batch.map(async (id) => [id, await this._getFullBundle(id, { includeBlobs: true })])
       );
       for (const [id, bundle] of batchResults) {
         entities[id] = bundle;
@@ -1227,172 +1501,339 @@ The following document anchors are provided for contradiction detection only. Do
   }
   async importDump(dump, opts) {
     const merge = opts?.merge ?? false;
-    for (const [entityId, bundle] of Object.entries(dump.entities)) {
-      await this.db.withTransactionAsync(async () => {
-        if (!merge) {
-          const now = Date.now();
-          await this.db.runAsync(
-            `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`,
-            [now, now, entityId]
-          );
-          await this.db.runAsync(
-            `UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`,
-            [now, now, entityId]
-          );
-          await this.db.runAsync(
-            `DELETE FROM ${this.prefix}checkpoints WHERE entity_id = ?`,
-            [entityId]
-          );
+    const entityIds = Object.keys(dump.entities);
+    for (const entityId of entityIds) {
+      if (this.activeMaintenanceJobs.has(this._importKey(entityId))) {
+        throw new WikiBusyError("import", entityId);
+      }
+      if (this.activeMaintenanceJobs.has(this._librarianKey(entityId))) {
+        throw new WikiBusyError("librarian", entityId);
+      }
+      if (this.activeMaintenanceJobs.has(this._healKey(entityId))) {
+        throw new WikiBusyError("heal", entityId);
+      }
+      if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
+        throw new WikiBusyError("prune", entityId);
+      }
+      if (this._isReembedActive(entityId)) {
+        throw new WikiBusyError("reembed", entityId);
+      }
+      if (this._isIngestActiveFor(entityId)) {
+        throw new WikiBusyError("ingest", entityId);
+      }
+      if (this._isForgetActiveFor(entityId)) {
+        throw new WikiBusyError("forget", entityId);
+      }
+    }
+    if (this.activeMaintenanceJobs.has(this._globalImportKey())) {
+      throw new WikiBusyError("import", "*");
+    }
+    this.activeMaintenanceJobs.add(this._globalImportKey());
+    for (const entityId of entityIds) {
+      this.activeMaintenanceJobs.add(this._importKey(entityId));
+    }
+    try {
+      for (const [entityId, bundle] of Object.entries(dump.entities)) {
+        await this._doImportEntity(entityId, bundle, merge);
+      }
+    } finally {
+      this.activeMaintenanceJobs.delete(this._globalImportKey());
+      for (const entityId of entityIds) {
+        this.activeMaintenanceJobs.delete(this._importKey(entityId));
+      }
+    }
+  }
+  async _doImportEntity(entityId, bundle, merge) {
+    const upsertedFactIds = /* @__PURE__ */ new Set();
+    const factsWithPreservedBlob = /* @__PURE__ */ new Set();
+    const preservedBlobDims = /* @__PURE__ */ new Set();
+    await this.db.withTransactionAsync(async () => {
+      if (!merge) {
+        const now = Date.now();
+        await this.db.runAsync(
+          `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`,
+          [now, now, entityId]
+        );
+        await this.db.runAsync(
+          `UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`,
+          [now, now, entityId]
+        );
+        await this.db.runAsync(
+          `DELETE FROM ${this.prefix}checkpoints WHERE entity_id = ?`,
+          [entityId]
+        );
+      }
+      const factIds = bundle.facts.map((fact) => fact.id);
+      const existingFactsById = /* @__PURE__ */ new Map();
+      const factLookupChunkSize = 500;
+      for (let i = 0; i < factIds.length; i += factLookupChunkSize) {
+        const factIdChunk = factIds.slice(i, i + factLookupChunkSize);
+        if (factIdChunk.length === 0) continue;
+        const placeholders = factIdChunk.map(() => "?").join(", ");
+        const existingFacts = await this.db.getAllAsync(
+          `SELECT id, entity_id, updated_at FROM ${this.prefix}entries WHERE id IN (${placeholders})`,
+          factIdChunk
+        );
+        for (const existingFact of existingFacts) {
+          existingFactsById.set(existingFact.id, existingFact);
         }
-        const factIds = bundle.facts.map((fact) => fact.id);
-        const existingFactsById = /* @__PURE__ */ new Map();
-        const factLookupChunkSize = 500;
-        for (let i = 0; i < factIds.length; i += factLookupChunkSize) {
-          const factIdChunk = factIds.slice(i, i + factLookupChunkSize);
-          if (factIdChunk.length === 0) continue;
-          const placeholders = factIdChunk.map(() => "?").join(", ");
-          const existingFacts = await this.db.getAllAsync(
-            `SELECT id, entity_id, updated_at FROM ${this.prefix}entries WHERE id IN (${placeholders})`,
-            factIdChunk
-          );
-          for (const existingFact of existingFacts) {
-            existingFactsById.set(existingFact.id, existingFact);
+      }
+      for (const fact of bundle.facts) {
+        const tagsJson = JSON.stringify(Array.isArray(fact.tags) ? fact.tags : []);
+        const safeUpdatedAt = Number.isFinite(fact.updated_at) ? fact.updated_at : 0;
+        const existing = existingFactsById.get(fact.id);
+        const rawBlobRaw = fact.embedding_blob;
+        let rawBlob = null;
+        if (rawBlobRaw instanceof Uint8Array) {
+          rawBlob = rawBlobRaw;
+        } else if (rawBlobRaw !== null && rawBlobRaw !== void 0 && typeof rawBlobRaw === "object") {
+          const obj = rawBlobRaw;
+          if (obj["type"] === "Buffer" && Array.isArray(obj["data"])) {
+            rawBlob = new Uint8Array(obj["data"]);
+          } else if (!Array.isArray(rawBlobRaw)) {
+            const entries = Object.keys(obj);
+            if (entries.length > 0 && entries.every((k) => /^\d+$/.test(k))) {
+              const len = entries.length;
+              rawBlob = new Uint8Array(len);
+              for (let i = 0; i < len; i++) rawBlob[i] = obj[String(i)] ?? 0;
+            }
           }
         }
-        for (const fact of bundle.facts) {
-          const tagsJson = JSON.stringify(Array.isArray(fact.tags) ? fact.tags : []);
-          const safeUpdatedAt = Number.isFinite(fact.updated_at) ? fact.updated_at : 0;
-          const existing = existingFactsById.get(fact.id);
-          if (existing) {
-            if (existing.entity_id !== entityId) {
-              this._warnCrossEntityCollision("entry", fact.id, existing.entity_id, entityId);
-              continue;
-            }
-            if (merge) {
-              if (safeUpdatedAt <= existing.updated_at) continue;
+        let blobData = null;
+        if (rawBlob !== null && rawBlob.byteLength > 0 && rawBlob.byteLength % 4 === 0) {
+          const copy = new ArrayBuffer(rawBlob.byteLength);
+          new Uint8Array(copy).set(rawBlob);
+          const floats = new Float32Array(copy, 0, rawBlob.byteLength / 4);
+          let allFinite = true;
+          for (let i = 0; i < floats.length; i++) {
+            if (!isFinite(floats[i])) {
+              allFinite = false;
+              break;
             }
+          }
+          if (allFinite) {
+            blobData = rawBlob;
+          }
+        }
+        if (existing) {
+          if (existing.entity_id !== entityId) {
+            this._warnCrossEntityCollision("entry", fact.id, existing.entity_id, entityId);
+            continue;
+          }
+          if (merge) {
+            if (safeUpdatedAt <= existing.updated_at) continue;
+          }
+          if (blobData != null) {
+            await this.db.runAsync(
+              `UPDATE ${this.prefix}entries SET entity_id = ?, title = ?, body = ?, tags = ?, confidence = ?, source_type = ?, source_hash = ?, source_ref = ?, created_at = ?, updated_at = ?, last_accessed_at = ?, access_count = ?, deleted_at = ?, embedding_blob = ?, embedding = NULL WHERE id = ?`,
+              [entityId, fact.title, fact.body, tagsJson, fact.confidence, fact.source_type, fact.source_hash, fact.source_ref, fact.created_at, safeUpdatedAt, fact.last_accessed_at, fact.access_count, fact.deleted_at, blobData, fact.id]
+            );
+            factsWithPreservedBlob.add(fact.id);
+            if (!fact.deleted_at) preservedBlobDims.add(blobData.byteLength / 4);
+          } else {
             await this.db.runAsync(
-              `UPDATE ${this.prefix}entries SET entity_id = ?, title = ?, body = ?, tags = ?, confidence = ?, source_type = ?, source_hash = ?, source_ref = ?, created_at = ?, updated_at = ?, last_accessed_at = ?, access_count = ?, deleted_at = ? WHERE id = ?`,
+              `UPDATE ${this.prefix}entries SET entity_id = ?, title = ?, body = ?, tags = ?, confidence = ?, source_type = ?, source_hash = ?, source_ref = ?, created_at = ?, updated_at = ?, last_accessed_at = ?, access_count = ?, deleted_at = ?, embedding_blob = NULL, embedding = NULL WHERE id = ?`,
               [entityId, fact.title, fact.body, tagsJson, fact.confidence, fact.source_type, fact.source_hash, fact.source_ref, fact.created_at, safeUpdatedAt, fact.last_accessed_at, fact.access_count, fact.deleted_at, fact.id]
             );
-            existingFactsById.set(fact.id, { id: fact.id, entity_id: entityId, updated_at: safeUpdatedAt });
+          }
+          existingFactsById.set(fact.id, { id: fact.id, entity_id: entityId, updated_at: safeUpdatedAt });
+          upsertedFactIds.add(fact.id);
+        } else {
+          if (blobData != null) {
+            await this.db.runAsync(
+              `INSERT INTO ${this.prefix}entries (id, entity_id, title, body, tags, confidence, source_type, source_hash, source_ref, created_at, updated_at, last_accessed_at, access_count, deleted_at, embedding_blob) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+              [fact.id, entityId, fact.title, fact.body, tagsJson, fact.confidence, fact.source_type, fact.source_hash, fact.source_ref, fact.created_at, safeUpdatedAt, fact.last_accessed_at, fact.access_count, fact.deleted_at, blobData]
+            );
+            factsWithPreservedBlob.add(fact.id);
+            if (!fact.deleted_at) preservedBlobDims.add(blobData.byteLength / 4);
           } else {
             await this.db.runAsync(
               `INSERT INTO ${this.prefix}entries (id, entity_id, title, body, tags, confidence, source_type, source_hash, source_ref, created_at, updated_at, last_accessed_at, access_count, deleted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
               [fact.id, entityId, fact.title, fact.body, tagsJson, fact.confidence, fact.source_type, fact.source_hash, fact.source_ref, fact.created_at, safeUpdatedAt, fact.last_accessed_at, fact.access_count, fact.deleted_at]
             );
-            existingFactsById.set(fact.id, { id: fact.id, entity_id: entityId, updated_at: safeUpdatedAt });
           }
+          existingFactsById.set(fact.id, { id: fact.id, entity_id: entityId, updated_at: safeUpdatedAt });
+          upsertedFactIds.add(fact.id);
         }
-        const taskIds = bundle.tasks.map((task) => task.id);
-        const existingTasksById = /* @__PURE__ */ new Map();
-        const taskLookupChunkSize = 500;
-        for (let i = 0; i < taskIds.length; i += taskLookupChunkSize) {
-          const taskIdChunk = taskIds.slice(i, i + taskLookupChunkSize);
-          if (taskIdChunk.length === 0) continue;
-          const placeholders = taskIdChunk.map(() => "?").join(", ");
-          const existingTasks = await this.db.getAllAsync(
-            `SELECT id, entity_id, updated_at FROM ${this.prefix}tasks WHERE id IN (${placeholders})`,
-            taskIdChunk
-          );
-          for (const existingTask of existingTasks) {
-            existingTasksById.set(existingTask.id, existingTask);
+      }
+      const taskIds = bundle.tasks.map((task) => task.id);
+      const existingTasksById = /* @__PURE__ */ new Map();
+      const taskLookupChunkSize = 500;
+      for (let i = 0; i < taskIds.length; i += taskLookupChunkSize) {
+        const taskIdChunk = taskIds.slice(i, i + taskLookupChunkSize);
+        if (taskIdChunk.length === 0) continue;
+        const placeholders = taskIdChunk.map(() => "?").join(", ");
+        const existingTasks = await this.db.getAllAsync(
+          `SELECT id, entity_id, updated_at FROM ${this.prefix}tasks WHERE id IN (${placeholders})`,
+          taskIdChunk
+        );
+        for (const existingTask of existingTasks) {
+          existingTasksById.set(existingTask.id, existingTask);
+        }
+      }
+      for (const task of bundle.tasks) {
+        const safeUpdatedAt = Number.isFinite(task.updated_at) ? task.updated_at : 0;
+        const existing = existingTasksById.get(task.id);
+        if (existing) {
+          if (existing.entity_id !== entityId) {
+            this._warnCrossEntityCollision("task", task.id, existing.entity_id, entityId);
+            continue;
+          }
+          if (merge) {
+            if (safeUpdatedAt <= existing.updated_at) continue;
           }
+          await this.db.runAsync(
+            `UPDATE ${this.prefix}tasks SET entity_id = ?, description = ?, status = ?, priority = ?, created_at = ?, updated_at = ?, resolved_at = ?, deleted_at = ? WHERE id = ?`,
+            [entityId, task.description, task.status, task.priority, task.created_at, safeUpdatedAt, task.resolved_at, task.deleted_at, task.id]
+          );
+          existingTasksById.set(task.id, { id: task.id, entity_id: entityId, updated_at: safeUpdatedAt });
+        } else {
+          await this.db.runAsync(
+            `INSERT INTO ${this.prefix}tasks (id, entity_id, description, status, priority, created_at, updated_at, resolved_at, deleted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            [task.id, entityId, task.description, task.status, task.priority, task.created_at, safeUpdatedAt, task.resolved_at, task.deleted_at]
+          );
+          existingTasksById.set(task.id, { id: task.id, entity_id: entityId, updated_at: safeUpdatedAt });
         }
-        for (const task of bundle.tasks) {
-          const safeUpdatedAt = Number.isFinite(task.updated_at) ? task.updated_at : 0;
-          const existing = existingTasksById.get(task.id);
-          if (existing) {
-            if (existing.entity_id !== entityId) {
-              this._warnCrossEntityCollision("task", task.id, existing.entity_id, entityId);
-              continue;
-            }
-            if (merge) {
-              if (safeUpdatedAt <= existing.updated_at) continue;
-            }
-            await this.db.runAsync(
-              `UPDATE ${this.prefix}tasks SET entity_id = ?, description = ?, status = ?, priority = ?, created_at = ?, updated_at = ?, resolved_at = ?, deleted_at = ? WHERE id = ?`,
-              [entityId, task.description, task.status, task.priority, task.created_at, safeUpdatedAt, task.resolved_at, task.deleted_at, task.id]
-            );
-            existingTasksById.set(task.id, { id: task.id, entity_id: entityId, updated_at: safeUpdatedAt });
-          } else {
+      }
+      for (const event of bundle.events) {
+        await this.db.runAsync(
+          `INSERT OR IGNORE INTO ${this.prefix}events (id, entity_id, event_type, summary, related_entry_id, created_at)
+             VALUES (?, ?, ?, ?, ?, ?)`,
+          [event.id, entityId, event.event_type, event.summary, event.related_entry_id ?? null, event.created_at]
+        );
+      }
+    });
+    this.vectorCache.delete(entityId);
+    await this.rebuildMiniSearchIndex(entityId);
+    for (const fact of bundle.facts) {
+      if (!fact.deleted_at && upsertedFactIds.has(fact.id) && !factsWithPreservedBlob.has(fact.id)) {
+        await this.embedFact({
+          id: fact.id,
+          title: fact.title,
+          body: fact.body,
+          tags: Array.isArray(fact.tags) || typeof fact.tags === "string" ? fact.tags : []
+        });
+      }
+    }
+    try {
+      const canonicalRow = await this.db.getFirstAsync(
+        `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension'`
+      );
+      const canonicalDim = canonicalRow ? parseInt(canonicalRow.value, 10) : null;
+      if (preservedBlobDims.size === 1) {
+        const preservedDim = [...preservedBlobDims][0];
+        if (canonicalDim === null || canonicalDim === preservedDim) {
+          await this.storeEmbeddingDimension(preservedDim);
+          const staleMismatch = await this.db.getFirstAsync(
+            `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension_mismatch'`
+          );
+          if (staleMismatch && parseInt(staleMismatch.value, 10) !== preservedDim) {
             await this.db.runAsync(
-              `INSERT INTO ${this.prefix}tasks (id, entity_id, description, status, priority, created_at, updated_at, resolved_at, deleted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-              [task.id, entityId, task.description, task.status, task.priority, task.created_at, safeUpdatedAt, task.resolved_at, task.deleted_at]
+              `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension_mismatch', ?)`,
+              [String(preservedDim)]
             );
-            existingTasksById.set(task.id, { id: task.id, entity_id: entityId, updated_at: safeUpdatedAt });
           }
-        }
-        for (const event of bundle.events) {
+          await this._reconcileEmbeddingDimension();
+        } else {
           await this.db.runAsync(
-            `INSERT OR IGNORE INTO ${this.prefix}events (id, entity_id, event_type, summary, related_entry_id, created_at)
-             VALUES (?, ?, ?, ?, ?, ?)`,
-            [event.id, entityId, event.event_type, event.summary, event.related_entry_id ?? null, event.created_at]
+            `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension_mismatch', ?)`,
+            [String(canonicalDim)]
           );
         }
-      });
-      for (const fact of bundle.facts) {
-        if (!fact.deleted_at) {
-          await this.embedFact({
-            id: fact.id,
-            title: fact.title,
-            body: fact.body,
-            tags: Array.isArray(fact.tags) || typeof fact.tags === "string" ? fact.tags : []
-          });
+      } else if (preservedBlobDims.size > 1) {
+        if (canonicalDim === null) {
+          const sortedPreservedBlobDims = [...preservedBlobDims].sort((a, b) => a - b);
+          await this.storeEmbeddingDimension(sortedPreservedBlobDims[0]);
+          await this.db.runAsync(
+            `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension_mismatch', ?)`,
+            [String(sortedPreservedBlobDims[0])]
+          );
+        } else {
+          await this.db.runAsync(
+            `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension_mismatch', ?)`,
+            [String(canonicalDim)]
+          );
         }
       }
+    } finally {
+      this.vectorCache.delete(entityId);
     }
-    await this.rebuildMiniSearchIndex();
   }
   async forget(entityId, params) {
-    const now = Date.now();
-    let deletedEntries = 0;
-    let deletedTasks = 0;
-    if (params.clearAll) {
-      const [entriesRes, tasksRes] = await Promise.all([
-        this.db.runAsync(`UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`, [now, now, entityId]),
-        this.db.runAsync(`UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`, [now, now, entityId])
-      ]);
-      await this.db.runAsync(`UPDATE ${this.prefix}checkpoints SET memory_checkpoint = 0, heal_checkpoint = 0 WHERE entity_id = ?`, [entityId]);
-      deletedEntries = entriesRes.changes;
-      deletedTasks = tasksRes.changes;
-    } else {
-      const hasIdSelectors = params.entryId !== void 0 || params.taskId !== void 0;
-      const hasSourceSelectors = params.sourceRef !== void 0 || params.sourceHash !== void 0;
-      if (hasIdSelectors && hasSourceSelectors) {
-        throw new Error("forget() params are mutually exclusive: use entryId/taskId together, or sourceRef/sourceHash together, but not both in the same call");
-      }
-      const sourceRef = params.sourceRef !== void 0 ? normalizeSourceRef(params.sourceRef) : null;
-      if (params.sourceRef !== void 0 && !sourceRef) throw new Error("Invalid sourceRef");
-      const sourceHash = params.sourceHash !== void 0 ? normalizeSourceHash(params.sourceHash) : null;
-      if (params.sourceHash !== void 0 && !sourceHash) throw new Error("Invalid sourceHash (must be 64-char hex string)");
-      const entryPromise = params.entryId ? this.db.runAsync(`UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`, [now, now, params.entryId, entityId]) : null;
-      const taskPromise = params.taskId ? this.db.runAsync(`UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`, [now, now, params.taskId, entityId]) : null;
-      let refPromise = null;
-      if (sourceRef || sourceHash) {
-        let q = `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`;
-        const args = [now, now, entityId];
-        if (sourceRef) {
-          q += ` AND source_ref = ?`;
-          args.push(sourceRef);
+    let blockingOperation = null;
+    if (this.activeMaintenanceJobs.has(this._librarianKey(entityId))) {
+      blockingOperation = "librarian";
+    } else if (this.activeMaintenanceJobs.has(this._healKey(entityId))) {
+      blockingOperation = "heal";
+    } else if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
+      blockingOperation = "prune";
+    } else if (this._isReembedActive(entityId)) {
+      blockingOperation = "reembed";
+    } else if (this._isIngestActiveFor(entityId)) {
+      blockingOperation = "ingest";
+    } else if (this._isImportActiveFor(entityId)) {
+      blockingOperation = "import";
+    } else if (this._isForgetActiveFor(entityId)) {
+      blockingOperation = "forget";
+    }
+    if (blockingOperation !== null) {
+      throw new WikiBusyError(blockingOperation, entityId);
+    }
+    const forgetKey = this._forgetKey(entityId);
+    this.activeMaintenanceJobs.add(forgetKey);
+    try {
+      const now = Date.now();
+      let deletedEntries = 0;
+      let deletedTasks = 0;
+      if (params.clearAll) {
+        const [entriesRes, tasksRes] = await Promise.all([
+          this.db.runAsync(`UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`, [now, now, entityId]),
+          this.db.runAsync(`UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`, [now, now, entityId])
+        ]);
+        await this.db.runAsync(`UPDATE ${this.prefix}checkpoints SET memory_checkpoint = 0, heal_checkpoint = 0 WHERE entity_id = ?`, [entityId]);
+        deletedEntries = entriesRes.changes;
+        deletedTasks = tasksRes.changes;
+      } else {
+        const hasIdSelectors = params.entryId !== void 0 || params.taskId !== void 0;
+        const hasSourceSelectors = params.sourceRef !== void 0 || params.sourceHash !== void 0;
+        if (hasIdSelectors && hasSourceSelectors) {
+          throw new Error("forget() params are mutually exclusive: use entryId/taskId together, or sourceRef/sourceHash together, but not both in the same call");
         }
-        if (sourceHash) {
-          q += ` AND source_hash = ?`;
-          args.push(sourceHash);
+        const sourceRef = params.sourceRef !== void 0 ? normalizeSourceRef(params.sourceRef) : null;
+        if (params.sourceRef !== void 0 && !sourceRef) throw new Error("Invalid sourceRef");
+        const sourceHash = params.sourceHash !== void 0 ? normalizeSourceHash(params.sourceHash) : null;
+        if (params.sourceHash !== void 0 && !sourceHash) throw new Error("Invalid sourceHash (must be 64-char hex string)");
+        const entryPromise = params.entryId ? this.db.runAsync(`UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`, [now, now, params.entryId, entityId]) : null;
+        const taskPromise = params.taskId ? this.db.runAsync(`UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`, [now, now, params.taskId, entityId]) : null;
+        let refPromise = null;
+        if (sourceRef || sourceHash) {
+          let q = `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`;
+          const args = [now, now, entityId];
+          if (sourceRef) {
+            q += ` AND source_ref = ?`;
+            args.push(sourceRef);
+          }
+          if (sourceHash) {
+            q += ` AND source_hash = ?`;
+            args.push(sourceHash);
+          }
+          refPromise = this.db.runAsync(q, args);
         }
-        refPromise = this.db.runAsync(q, args);
+        const [entryResult, taskResult, refResult] = await Promise.all([
+          entryPromise ?? Promise.resolve(null),
+          taskPromise ?? Promise.resolve(null),
+          refPromise ?? Promise.resolve(null)
+        ]);
+        if (entryResult) deletedEntries += entryResult.changes;
+        if (taskResult) deletedTasks += taskResult.changes;
+        if (refResult) deletedEntries += refResult.changes;
       }
-      const [entryResult, taskResult, refResult] = await Promise.all([
-        entryPromise ?? Promise.resolve(null),
-        taskPromise ?? Promise.resolve(null),
-        refPromise ?? Promise.resolve(null)
-      ]);
-      if (entryResult) deletedEntries += entryResult.changes;
-      if (taskResult) deletedTasks += taskResult.changes;
-      if (refResult) deletedEntries += refResult.changes;
+      await this.rebuildMiniSearchIndex(entityId);
+      this.vectorCache.delete(entityId);
+      return { deleted: { entries: deletedEntries, tasks: deletedTasks } };
+    } finally {
+      this.activeMaintenanceJobs.delete(forgetKey);
     }
-    await this.rebuildMiniSearchIndex(entityId);
-    return { deleted: { entries: deletedEntries, tasks: deletedTasks } };
   }
   async ingestDocument(entityId, params) {
     const sourceRef = normalizeSourceRef(params.sourceRef);
@@ -1420,6 +1861,12 @@ The following document anchors are provided for contradiction detection only. Do
     if (this._isReembedActive(entityId)) {
       throw new WikiBusyError("reembed", entityId);
     }
+    if (this._isImportActiveFor(entityId)) {
+      throw new WikiBusyError("import", entityId);
+    }
+    if (this._isForgetActiveFor(entityId)) {
+      throw new WikiBusyError("forget", entityId);
+    }
     this.activeIngestJobs.add(jobKey);
     try {
       const { chunks, truncated } = chunkText(params.documentChunk, maxChunkLength, chunkOverlap);
@@ -1467,16 +1914,31 @@ ${chunk}`;
           insertedFacts.push({ id, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
         }
       });
+      await this.rebuildMiniSearchIndex(entityId);
+      this.vectorCache.delete(entityId);
       for (const fact of insertedFacts) {
         await this.embedFact(fact);
       }
-      await this.rebuildMiniSearchIndex(entityId);
+      this.vectorCache.delete(entityId);
       return { truncated, chunks: chunks.length };
     } finally {
       this.activeIngestJobs.delete(jobKey);
     }
   }
 };
+/**
+ * Maximum number of entities whose parsed embedding vectors are held in
+ * memory. This cap is intentionally conservative so the cache remains safe
+ * on memory-constrained runtimes (e.g., mobile/Expo).
+ */
+_WikiMemory.MAX_VECTOR_CACHE_ENTITIES = 16;
+/**
+ * Maximum number of fact vectors cached per entity. Keep this high enough to
+ * preserve the parsed-embedding reuse optimization for common mid-sized
+ * entities while still maintaining a bounded memory footprint.
+ */
+_WikiMemory.MAX_VECTOR_CACHE_FACTS_PER_ENTITY = 500;
+var WikiMemory = _WikiMemory;
 
 // src/utils/formatContext.ts
 function validateMaxOption(value, name) {
@@ -1672,8 +2134,23 @@ function formatMemoryDump(dump) {
     name: formatEntityFileName(entityId),
     content: renderEntity(entityId, bundle, dump.generatedAt)
   }));
+  const manifestDump = {
+    generatedAt: dump.generatedAt,
+    entities: Object.fromEntries(
+      Object.entries(dump.entities).map(([entityId, bundle]) => [
+        entityId,
+        {
+          ...bundle,
+          facts: bundle.facts.map((f) => {
+            const { embedding_blob: _blob, ...rest } = f;
+            return rest;
+          })
+        }
+      ])
+    )
+  };
   return {
-    manifest: JSON.stringify(dump, null, 2),
+    manifest: JSON.stringify(manifestDump, null, 2),
     files
   };
 }