@equationalapplications/core-llm-wiki 2.4.0 → 2.6.0

package/dist/index.js

@@ -1,5 +1,11 @@
 'use strict';
 
+var MiniSearch = require('minisearch');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var MiniSearch__default = /*#__PURE__*/_interopDefault(MiniSearch);
+
 // src/db/schema.ts
 async function setupDatabase(db, prefix) {
   await db.execAsync(`
@@ -17,7 +23,8 @@ async function setupDatabase(db, prefix) {
       updated_at INTEGER NOT NULL,
       last_accessed_at INTEGER,
       access_count INTEGER NOT NULL DEFAULT 0,
-      deleted_at INTEGER
+      deleted_at INTEGER,
+      embedding TEXT
     );
 
     CREATE INDEX IF NOT EXISTS ${prefix}entries_entity_idx ON ${prefix}entries(entity_id);
@@ -25,34 +32,6 @@ async function setupDatabase(db, prefix) {
     CREATE INDEX IF NOT EXISTS ${prefix}entries_source_hash_idx ON ${prefix}entries(entity_id, source_hash) WHERE source_hash IS NOT NULL;
     CREATE INDEX IF NOT EXISTS ${prefix}entries_updated_idx ON ${prefix}entries(updated_at DESC);
 
-    -- FTS5 Virtual Table for full-text search
-    CREATE VIRTUAL TABLE IF NOT EXISTS ${prefix}entries_fts USING fts5(
-      title,
-      body,
-      tags,
-      content='${prefix}entries',
-      content_rowid='rowid',
-      tokenize='porter unicode61'
-    );
-
-    -- Triggers to keep FTS5 in sync with entries
-    CREATE TRIGGER IF NOT EXISTS ${prefix}entries_ai AFTER INSERT ON ${prefix}entries BEGIN
-      INSERT INTO ${prefix}entries_fts(rowid, title, body, tags) 
-      VALUES (new.rowid, new.title, new.body, new.tags);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS ${prefix}entries_ad AFTER DELETE ON ${prefix}entries BEGIN
-      INSERT INTO ${prefix}entries_fts(${prefix}entries_fts, rowid, title, body, tags) 
-      VALUES ('delete', old.rowid, old.title, old.body, old.tags);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS ${prefix}entries_au AFTER UPDATE ON ${prefix}entries BEGIN
-      INSERT INTO ${prefix}entries_fts(${prefix}entries_fts, rowid, title, body, tags) 
-      VALUES ('delete', old.rowid, old.title, old.body, old.tags);
-      INSERT INTO ${prefix}entries_fts(rowid, title, body, tags) 
-      VALUES (new.rowid, new.title, new.body, new.tags);
-    END;
-
     CREATE TABLE IF NOT EXISTS ${prefix}tasks (
       id TEXT PRIMARY KEY,
       entity_id TEXT NOT NULL,
@@ -95,7 +74,13 @@ async function setupDatabase(db, prefix) {
 var MIGRATIONS = [
   {
     version: 1,
-    description: "Rebuild FTS5 with porter unicode61 tokenizer",
+    description: "Rebuild FTS5 with porter unicode61 tokenizer (superseded by v2)",
+    run: async (_db, _prefix) => {
+    }
+  },
+  {
+    version: 2,
+    description: "Remove FTS5; add embedding column for semantic retrieval",
     run: async (db, prefix) => {
       await db.withTransactionAsync(async () => {
         await db.execAsync(`
@@ -103,32 +88,14 @@ var MIGRATIONS = [
           DROP TRIGGER IF EXISTS ${prefix}entries_ad;
           DROP TRIGGER IF EXISTS ${prefix}entries_au;
           DROP TABLE IF EXISTS ${prefix}entries_fts;
-          CREATE VIRTUAL TABLE ${prefix}entries_fts USING fts5(
-            title,
-            body,
-            tags,
-            content='${prefix}entries',
-            content_rowid='rowid',
-            tokenize='porter unicode61'
-          );
-          INSERT INTO ${prefix}entries_fts(rowid, title, body, tags)
-            SELECT rowid, title, body, tags FROM ${prefix}entries;
-          CREATE TRIGGER ${prefix}entries_ai AFTER INSERT ON ${prefix}entries BEGIN
-            INSERT INTO ${prefix}entries_fts(rowid, title, body, tags)
-            VALUES (new.rowid, new.title, new.body, new.tags);
-          END;
-          CREATE TRIGGER ${prefix}entries_ad AFTER DELETE ON ${prefix}entries BEGIN
-            INSERT INTO ${prefix}entries_fts(${prefix}entries_fts, rowid, title, body, tags)
-            VALUES ('delete', old.rowid, old.title, old.body, old.tags);
-          END;
-          CREATE TRIGGER ${prefix}entries_au AFTER UPDATE ON ${prefix}entries BEGIN
-            INSERT INTO ${prefix}entries_fts(${prefix}entries_fts, rowid, title, body, tags)
-            VALUES ('delete', old.rowid, old.title, old.body, old.tags);
-            INSERT INTO ${prefix}entries_fts(rowid, title, body, tags)
-            VALUES (new.rowid, new.title, new.body, new.tags);
-          END;
         `);
       });
+      const cols = await db.getAllAsync(
+        `PRAGMA table_info(${prefix}entries)`
+      );
+      if (!cols.some((c) => c.name === "embedding")) {
+        await db.execAsync(`ALTER TABLE ${prefix}entries ADD COLUMN embedding TEXT`);
+      }
     }
   }
 ];
@@ -174,6 +141,19 @@ Return ONLY a valid JSON object matching this schema:
 }
 Extract verbatim factual content. Do not return markdown, just raw JSON.`;
 
+// src/utils/cosine.ts
+function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
 // src/WikiMemory.ts
 function parseJsonResponse(text) {
   const firstBrace = text.indexOf("{");
@@ -382,10 +362,146 @@ var WikiMemory = class {
   constructor(db, options) {
     this.activeMaintenanceJobs = /* @__PURE__ */ new Set();
     this.activeIngestJobs = /* @__PURE__ */ new Set();
+    this.miniSearch = new MiniSearch__default.default({
+      fields: ["title", "body", "tags"],
+      storeFields: ["entity_id"],
+      searchOptions: {
+        boost: { title: 2 },
+        fuzzy: 0.2,
+        prefix: true
+      }
+    });
+    this.miniSearchEntryIdsByEntity = /* @__PURE__ */ new Map();
     this.db = db;
     this.options = options;
     this.prefix = options.config?.tablePrefix || "llm_wiki_";
   }
+  normalizeMiniSearchRow(row) {
+    return {
+      id: row.id,
+      entity_id: row.entity_id,
+      title: row.title,
+      body: row.body,
+      tags: (() => {
+        try {
+          const parsed = JSON.parse(row.tags);
+          return Array.isArray(parsed) ? parsed.join(" ") : row.tags;
+        } catch {
+          return row.tags;
+        }
+      })()
+    };
+  }
+  async rebuildMiniSearchIndex(entityId) {
+    if (entityId) {
+      const rows2 = await this.db.getAllAsync(
+        `SELECT id, entity_id, title, body, tags FROM ${this.prefix}entries WHERE deleted_at IS NULL AND entity_id = ?`,
+        [entityId]
+      );
+      const previousIds = this.miniSearchEntryIdsByEntity.get(entityId);
+      if (previousIds) {
+        for (const id of previousIds) {
+          this.miniSearch.discard(id);
+        }
+      }
+      const documents2 = rows2.map((row) => this.normalizeMiniSearchRow(row));
+      if (documents2.length > 0) {
+        this.miniSearch.addAll(documents2);
+      }
+      this.miniSearchEntryIdsByEntity.set(entityId, new Set(documents2.map((document) => document.id)));
+      return;
+    }
+    const rows = await this.db.getAllAsync(`SELECT id, entity_id, title, body, tags FROM ${this.prefix}entries WHERE deleted_at IS NULL`);
+    this.miniSearch.removeAll();
+    this.miniSearchEntryIdsByEntity.clear();
+    const documents = rows.map((row) => this.normalizeMiniSearchRow(row));
+    if (documents.length > 0) {
+      this.miniSearch.addAll(documents);
+    }
+    for (const document of documents) {
+      const ids = this.miniSearchEntryIdsByEntity.get(document.entity_id) ?? /* @__PURE__ */ new Set();
+      ids.add(document.id);
+      this.miniSearchEntryIdsByEntity.set(document.entity_id, ids);
+    }
+  }
+  async storeEmbeddingDimension(dim) {
+    const existing = await this.db.getFirstAsync(
+      `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension'`
+    );
+    if (existing) {
+      const storedDim = parseInt(existing.value, 10);
+      if (storedDim !== dim) {
+        console.warn(
+          `[WikiMemory] Embedding dimension mismatch: stored ${storedDim}, got ${dim}. Call runReembed() to rebuild embeddings with the new model.`
+        );
+        await this.db.runAsync(
+          `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(
+        `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension', ?)`,
+        [String(dim)]
+      );
+    }
+  }
+  /**
+   * After a successful runReembed(), promote the pending `embedding_dimension_mismatch`
+   * value to the canonical `embedding_dimension` key and clear the mismatch flag.
+   * This ensures future read() calls use embedding-based retrieval rather than staying
+   * stuck on the MiniSearch fallback.
+   */
+  async _reconcileEmbeddingDimension() {
+    const mismatch = await this.db.getFirstAsync(
+      `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension_mismatch'`
+    );
+    if (mismatch) {
+      await this.db.runAsync(
+        `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension', ?)`,
+        [mismatch.value]
+      );
+      await this.db.runAsync(
+        `DELETE FROM ${this.prefix}meta WHERE key = 'embedding_dimension_mismatch'`
+      );
+    }
+  }
+  async embedFact(fact) {
+    const embedFn = this.options.llmProvider.embed;
+    if (!embedFn) return false;
+    let tagsStr;
+    if (Array.isArray(fact.tags)) {
+      tagsStr = fact.tags.join(" ");
+    } else {
+      try {
+        const parsed = JSON.parse(fact.tags);
+        tagsStr = Array.isArray(parsed) ? parsed.join(" ") : fact.tags;
+      } catch {
+        tagsStr = fact.tags;
+      }
+    }
+    const text = `${fact.title} ${fact.body} ${tagsStr}`.trim();
+    try {
+      const vector = await embedFn(text);
+      if (vector.length === 0 || !vector.every((v) => typeof v === "number" && isFinite(v))) {
+        console.warn(`[WikiMemory] embedFact: embed() returned an invalid vector for ${fact.id}; skipping.`);
+        return false;
+      }
+      await this.storeEmbeddingDimension(vector.length);
+      await this.db.runAsync(
+        `UPDATE ${this.prefix}entries SET embedding = ? WHERE id = ?`,
+        [JSON.stringify(vector), fact.id]
+      );
+      return true;
+    } catch (err) {
+      console.warn(`[WikiMemory] embedFact failed for ${fact.id}:`, err);
+      return false;
+    }
+  }
   _librarianKey(entityId) {
     return `${this.prefix}:${entityId}:librarian`;
   }
@@ -467,6 +583,7 @@ var WikiMemory = class {
         }
       }
     });
+    await this.rebuildMiniSearchIndex();
   }
   async hasChanged(entityId, sourceRef, sourceHash) {
     const normalizedRef = normalizeSourceRef(sourceRef);
@@ -491,6 +608,31 @@ var WikiMemory = class {
   _pruneKey(entityId) {
     return `${this.prefix}:${entityId}:prune`;
   }
+  _reembedKey(entityId) {
+    return `${this.prefix}:${entityId}:reembed`;
+  }
+  _globalReembedKey() {
+    return `${this.prefix}:reembed`;
+  }
+  _isReembedActive(entityId) {
+    return this.activeMaintenanceJobs.has(this._reembedKey(entityId)) || this.activeMaintenanceJobs.has(this._globalReembedKey());
+  }
+  /** Returns true if any maintenance job has the given operation suffix (e.g. ':prune'). */
+  _isAnyMaintenanceActiveWithSuffix(suffix) {
+    const entityKeyPrefix = `${this.prefix}:`;
+    for (const k of this.activeMaintenanceJobs) {
+      if (k.startsWith(entityKeyPrefix) && k.endsWith(suffix)) return true;
+    }
+    return false;
+  }
+  /** Returns true if any ingest job is active for the given entity. */
+  _isIngestActiveFor(entityId) {
+    const entityKeyPrefix = `${this.prefix}:${entityId}:`;
+    for (const k of this.activeIngestJobs) {
+      if (k.startsWith(entityKeyPrefix)) return true;
+    }
+    return false;
+  }
   _validatePruneDuration(value, name) {
     if (value !== null && value !== void 0 && (typeof value !== "number" || !isFinite(value) || value < 0)) {
       throw new Error(`Invalid ${name}: must be a non-negative finite number or null`);
@@ -513,6 +655,8 @@ var WikiMemory = class {
       blockingOperation = "librarian";
     } else if (this.activeMaintenanceJobs.has(this._healKey(entityId))) {
       blockingOperation = "heal";
+    } else if (this._isReembedActive(entityId)) {
+      blockingOperation = "reembed";
     } else if (isIngestRunning) {
       blockingOperation = "ingest";
     }
@@ -558,91 +702,145 @@ var WikiMemory = class {
         await this.db.execAsync(`PRAGMA wal_checkpoint(TRUNCATE)`);
         await this.db.execAsync(`VACUUM`);
       }
+      await this.rebuildMiniSearchIndex(entityId);
       return { entries: deletedEntries, tasks: deletedTasks, events: deletedEvents };
     } finally {
       this.activeMaintenanceJobs.delete(pruneKey);
     }
   }
-  formatSearchQuery(query) {
-    const normalizeTokens = (value) => value.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((t) => t.length >= 3);
-    const baseTokens = normalizeTokens(query);
-    if (baseTokens.length === 0) return "";
-    const synonymMap = this.options.config?.synonymMap;
-    const expanded = [];
-    const seen = /* @__PURE__ */ new Set();
-    const pushNormalized = (value) => {
-      for (const token of normalizeTokens(value)) {
-        if (expanded.length >= 12) return false;
-        if (seen.has(token)) continue;
-        seen.add(token);
-        expanded.push(token);
-      }
-      return true;
-    };
-    for (const t of baseTokens) {
-      if (!pushNormalized(t)) break;
-      if (synonymMap) {
-        const synonyms = synonymMap[t];
-        if (Array.isArray(synonyms)) {
-          for (const s of synonyms) {
-            if (typeof s === "string") {
-              if (!pushNormalized(s)) break;
+  async read(entityId, query) {
+    const maxResults = this.options.config?.maxResults ?? this.options.config?.maxFtsResults ?? 10;
+    const embedFn = this.options.llmProvider.embed;
+    const trimmedQuery = query.trim();
+    let facts = [];
+    if (trimmedQuery) {
+      let usedEmbed = false;
+      if (embedFn) {
+        try {
+          const queryVec = await embedFn(trimmedQuery);
+          if (queryVec.length === 0 || !queryVec.every((v) => typeof v === "number" && isFinite(v))) {
+            throw new Error(
+              "embed() returned an empty or non-finite vector. Falling back to keyword search."
+            );
+          }
+          const storedDimRow = await this.db.getFirstAsync(
+            `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension'`
+          );
+          if (storedDimRow) {
+            const storedDim = parseInt(storedDimRow.value, 10);
+            if (storedDim !== queryVec.length) {
+              throw new Error(
+                `Embedding dimension mismatch: stored ${storedDim}, query has ${queryVec.length}. Call runReembed() to rebuild embeddings with the new model.`
+              );
             }
           }
+          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 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);
+                }
+              } catch {
+              }
+            }
+            return { row, score };
+          });
+          scored.sort((a, b) => {
+            const scoreDiff = b.score - a.score;
+            if (scoreDiff !== 0) {
+              return scoreDiff;
+            }
+            const updatedAtDiff = (b.row.updated_at ?? 0) - (a.row.updated_at ?? 0);
+            if (updatedAtDiff !== 0) {
+              return updatedAtDiff;
+            }
+            const accessCountDiff = (b.row.access_count ?? 0) - (a.row.access_count ?? 0);
+            if (accessCountDiff !== 0) {
+              return accessCountDiff;
+            }
+            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);
+          }
+          usedEmbed = true;
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          this.options.onRetrievalFallback?.(error);
         }
       }
-    }
-    return expanded.map((t) => `"${t}"*`).join(" OR ");
-  }
-  async read(entityId, query) {
-    const ftsQuery = this.formatSearchQuery(query);
-    const maxResults = this.options.config?.maxFtsResults || 10;
-    let factsPromise;
-    if (ftsQuery) {
-      factsPromise = this.db.getAllAsync(`
-        SELECT e.* FROM ${this.prefix}entries e
-        JOIN ${this.prefix}entries_fts fts ON e.rowid = fts.rowid
-        WHERE fts.${this.prefix}entries_fts MATCH ?
-          AND e.entity_id = ?
-          AND e.deleted_at IS NULL
-        ORDER BY e.confidence DESC, e.access_count DESC, e.updated_at DESC
-        LIMIT ?
-      `, [ftsQuery, entityId, maxResults]);
+      if (!usedEmbed) {
+        const results = this.miniSearch.search(trimmedQuery, {
+          filter: (r) => r.entity_id === entityId,
+          combineWith: "OR"
+        });
+        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]));
+          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]
+        );
+      }
     } else {
-      factsPromise = this.db.getAllAsync(`
-        SELECT * FROM ${this.prefix}entries
-        WHERE entity_id = ? AND deleted_at IS NULL
-        ORDER BY updated_at DESC
-        LIMIT ?
-      `, [entityId, maxResults]);
-    }
-    const tasksPromise = this.db.getAllAsync(`
-      SELECT * FROM ${this.prefix}tasks
-      WHERE entity_id = ? AND status IN ('pending', 'in_progress') AND deleted_at IS NULL
-      ORDER BY priority DESC, created_at ASC
-    `, [entityId]);
-    const eventsPromise = this.db.getAllAsync(`
-      SELECT * FROM ${this.prefix}events
-      WHERE entity_id = ?
-      ORDER BY created_at DESC
-      LIMIT 10
-    `, [entityId]);
-    const [factsRaw, tasks, events] = await Promise.all([factsPromise, tasksPromise, eventsPromise]);
-    if (ftsQuery && factsRaw.length > 0) {
-      const ids = factsRaw.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 facts = factsRaw.map((f) => ({
-      ...f,
-      tags: typeof f.tags === "string" ? JSON.parse(f.tags) : f.tags
-    }));
-    return { facts, tasks, events: events.reverse() };
+      facts = await this.db.getAllAsync(
+        `SELECT * FROM ${this.prefix}entries
+         WHERE entity_id = ? AND deleted_at IS NULL
+         ORDER BY updated_at DESC
+         LIMIT ?`,
+        [entityId, maxResults]
+      );
+    }
+    const [tasks, events] = await Promise.all([
+      this.db.getAllAsync(
+        `SELECT * FROM ${this.prefix}tasks
+         WHERE entity_id = ? AND status IN ('pending', 'in_progress') AND deleted_at IS NULL
+         ORDER BY priority DESC, created_at ASC`,
+        [entityId]
+      ),
+      this.db.getAllAsync(
+        `SELECT * FROM ${this.prefix}events
+         WHERE entity_id = ?
+         ORDER BY created_at DESC
+         LIMIT 10`,
+        [entityId]
+      )
+    ]);
+    const parsedFacts = facts.map((f) => {
+      const { embedding: _embedding, ...rest } = f;
+      return {
+        ...rest,
+        tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags
+      };
+    });
+    return { facts: parsedFacts, tasks, events: events.reverse() };
   }
   async getMemoryBundle(entityId) {
     return this._getFullBundle(entityId, { maxEvents: 10 });
@@ -715,10 +913,13 @@ var WikiMemory = class {
       ORDER BY updated_at DESC
       LIMIT 100
     `, [entityId]);
-    const currentFacts = currentFactsRows.map((f) => ({
-      ...f,
-      tags: typeof f.tags === "string" ? JSON.parse(f.tags) : f.tags
-    }));
+    const currentFacts = currentFactsRows.map((f) => {
+      const { embedding: _embedding, ...rest } = f;
+      return {
+        ...rest,
+        tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags
+      };
+    });
     const userPrompt = `Events:
 ${JSON.stringify(events.reverse(), null, 2)}
 
@@ -734,6 +935,7 @@ ${JSON.stringify(currentFacts, null, 2)}`;
     const validFacts = facts.map(validateFact).filter((f) => f !== null);
     const validTasks = tasks.map(validateTask).filter((t) => t !== null);
     const now = Date.now();
+    const insertedFacts = [];
     await this.db.withTransactionAsync(async () => {
       for (const fact of validFacts) {
         const newTokens = titleTokens(fact.title);
@@ -756,6 +958,7 @@ ${JSON.stringify(currentFacts, null, 2)}`;
           INSERT INTO ${this.prefix}entries (id, entity_id, title, body, tags, confidence, source_type, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
         `, [id, entityId, fact.title, fact.body, JSON.stringify(fact.tags), fact.confidence, "agent_inferred", now, now]);
+        insertedFacts.push({ id, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
       }
       for (const task of validTasks) {
         const id = generateId("task_");
@@ -765,6 +968,10 @@ ${JSON.stringify(currentFacts, null, 2)}`;
         `, [id, entityId, task.description, "pending", task.priority, now, now]);
       }
     });
+    for (const fact of insertedFacts) {
+      await this.embedFact(fact);
+    }
+    await this.rebuildMiniSearchIndex(entityId);
   }
   async _doRunHeal(entityId) {
     const now = Date.now();
@@ -801,7 +1008,10 @@ ${JSON.stringify(currentFacts, null, 2)}`;
     const healCandidates = allFactsRows.filter((f) => f.source_type !== "user_document");
     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) => ({ ...f, tags: typeof f.tags === "string" ? JSON.parse(f.tags) : f.tags })), null, 2)}
+${JSON.stringify(healCandidates.map((f) => {
+      const { embedding: _embedding, ...rest } = f;
+      return { ...rest, tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags };
+    }), null, 2)}
 
 Document Anchors (DO NOT MODIFY OR DELETE):
 ${JSON.stringify(documentAnchors, null, 2)}
@@ -825,6 +1035,7 @@ The following document anchors are provided for contradiction detection only. Do
     const safeDowngraded = downgraded.filter((id) => mutableIds.has(id));
     const safeDeleted = deleted.filter((id) => mutableIds.has(id));
     const validNewFacts = newFacts.map(validateFact).filter((f) => f !== null);
+    const insertedFacts = [];
     await this.db.withTransactionAsync(async () => {
       for (const id of safeDowngraded) {
         await this.db.runAsync(`UPDATE ${this.prefix}entries SET confidence = 'tentative', updated_at = ? WHERE id = ? AND entity_id = ?`, [now, id, entityId]);
@@ -838,8 +1049,13 @@ The following document anchors are provided for contradiction detection only. Do
           INSERT INTO ${this.prefix}entries (id, entity_id, title, body, tags, confidence, source_type, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
         `, [id, entityId, fact.title, fact.body, JSON.stringify(fact.tags), fact.confidence, "agent_inferred", now, now]);
+        insertedFacts.push({ id, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
       }
     });
+    for (const fact of insertedFacts) {
+      await this.embedFact(fact);
+    }
+    await this.rebuildMiniSearchIndex(entityId);
   }
   async runLibrarian(entityId) {
     const jobKey = this._librarianKey(entityId);
@@ -849,6 +1065,9 @@ The following document anchors are provided for contradiction detection only. Do
     if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
       throw new WikiBusyError("prune", entityId);
     }
+    if (this._isReembedActive(entityId)) {
+      throw new WikiBusyError("reembed", entityId);
+    }
     this.activeMaintenanceJobs.add(jobKey);
     try {
       await this._doRunLibrarian(entityId);
@@ -864,6 +1083,9 @@ The following document anchors are provided for contradiction detection only. Do
     if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
       throw new WikiBusyError("prune", entityId);
     }
+    if (this._isReembedActive(entityId)) {
+      throw new WikiBusyError("reembed", entityId);
+    }
     this.activeMaintenanceJobs.add(jobKey);
     try {
       await this._doRunHeal(entityId);
@@ -871,6 +1093,69 @@ The following document anchors are provided for contradiction detection only. Do
       this.activeMaintenanceJobs.delete(jobKey);
     }
   }
+  async runReembed(entityId) {
+    const embedFn = this.options.llmProvider.embed;
+    if (!embedFn) return { embedded: 0, skipped: 0 };
+    const reembedKey = entityId ? this._reembedKey(entityId) : this._globalReembedKey();
+    if (this.activeMaintenanceJobs.has(reembedKey)) {
+      throw new WikiBusyError("reembed", entityId ?? "*");
+    }
+    if (entityId) {
+      if (this.activeMaintenanceJobs.has(this._globalReembedKey())) {
+        throw new WikiBusyError("reembed", entityId);
+      }
+      if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
+        throw new WikiBusyError("prune", 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._isIngestActiveFor(entityId)) {
+        throw new WikiBusyError("ingest", entityId);
+      }
+    } else {
+      if (this._isAnyMaintenanceActiveWithSuffix(":reembed")) {
+        throw new WikiBusyError("reembed", "*");
+      }
+      if (this._isAnyMaintenanceActiveWithSuffix(":prune")) {
+        throw new WikiBusyError("prune", "*");
+      }
+      if (this._isAnyMaintenanceActiveWithSuffix(":librarian")) {
+        throw new WikiBusyError("librarian", "*");
+      }
+      if (this._isAnyMaintenanceActiveWithSuffix(":heal")) {
+        throw new WikiBusyError("heal", "*");
+      }
+      if (this.activeIngestJobs.size > 0) {
+        throw new WikiBusyError("ingest", "*");
+      }
+    }
+    this.activeMaintenanceJobs.add(reembedKey);
+    try {
+      const where = entityId ? `entity_id = ? AND deleted_at IS NULL` : `deleted_at IS NULL`;
+      const params = entityId ? [entityId] : [];
+      const rows = await this.db.getAllAsync(
+        `SELECT * FROM ${this.prefix}entries WHERE ${where}`,
+        params
+      );
+      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();
+      }
+      return { embedded, skipped };
+    } finally {
+      this.activeMaintenanceJobs.delete(reembedKey);
+    }
+  }
   getEntityStatus(entityId) {
     const ingestPrefix = `${this.prefix}:${entityId}:`;
     let ingesting = false;
@@ -901,10 +1186,13 @@ The following document anchors are provided for contradiction detection only. Do
       ),
       this.db.getAllAsync(eventsQuery, eventsParams)
     ]);
-    const facts = factsRaw.map((f) => ({
-      ...f,
-      tags: typeof f.tags === "string" ? JSON.parse(f.tags) : f.tags
-    }));
+    const facts = factsRaw.map((f) => {
+      const { embedding: _embedding, ...rest } = f;
+      return {
+        ...rest,
+        tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags
+      };
+    });
     const events = maxEvents != null ? eventsRaw.slice().reverse() : eventsRaw;
     return { facts, tasks, events };
   }
@@ -1043,7 +1331,18 @@ The following document anchors are provided for contradiction detection only. Do
           );
         }
       });
+      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 : []
+          });
+        }
+      }
     }
+    await this.rebuildMiniSearchIndex();
   }
   async forget(entityId, params) {
     const now = Date.now();
@@ -1092,6 +1391,7 @@ The following document anchors are provided for contradiction detection only. Do
       if (taskResult) deletedTasks += taskResult.changes;
       if (refResult) deletedEntries += refResult.changes;
     }
+    await this.rebuildMiniSearchIndex(entityId);
     return { deleted: { entries: deletedEntries, tasks: deletedTasks } };
   }
   async ingestDocument(entityId, params) {
@@ -1117,6 +1417,9 @@ The following document anchors are provided for contradiction detection only. Do
     if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
       throw new WikiBusyError("prune", entityId);
     }
+    if (this._isReembedActive(entityId)) {
+      throw new WikiBusyError("reembed", entityId);
+    }
     this.activeIngestJobs.add(jobKey);
     try {
       const { chunks, truncated } = chunkText(params.documentChunk, maxChunkLength, chunkOverlap);
@@ -1148,6 +1451,7 @@ ${chunk}`;
         }
       }
       const now = Date.now();
+      const insertedFacts = [];
       await this.db.withTransactionAsync(async () => {
         await this.db.runAsync(
           `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE source_ref = ? AND entity_id = ? AND deleted_at IS NULL`,
@@ -1160,8 +1464,13 @@ ${chunk}`;
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
             [id, entityId, fact.title, fact.body, JSON.stringify(fact.tags), fact.confidence, "user_document", sourceHash, sourceRef, now, now]
           );
+          insertedFacts.push({ id, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
         }
       });
+      for (const fact of insertedFacts) {
+        await this.embedFact(fact);
+      }
+      await this.rebuildMiniSearchIndex(entityId);
       return { truncated, chunks: chunks.length };
     } finally {
       this.activeIngestJobs.delete(jobKey);