@equationalapplications/core-llm-wiki 4.6.1 → 4.8.0

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import MiniSearch from 'minisearch';
+import { __privateAdd, EmbeddingService, SearchService, JobManager, PromptService, IngestionService, MaintenanceService, ImportExportService, RetrievalService, WriteService, __privateGet, __privateSet, normalizeSourceRef, normalizeSourceHash, generateId } from './chunk-2FGDZKC2.mjs';
+export { HOOK_TIMEOUT_MARKER, PromptService, PrunePartialFailureError, WikiBusyError, parseEmbedding } from './chunk-2FGDZKC2.mjs';
 
 // src/db/schema.ts
 async function setupDatabase(db, prefix) {
@@ -62,6 +63,19 @@ async function setupDatabase(db, prefix) {
       key TEXT PRIMARY KEY,
       value TEXT NOT NULL
     );
+
+    CREATE TABLE IF NOT EXISTS ${prefix}outbox (
+      id TEXT PRIMARY KEY,
+      entity_id TEXT NOT NULL,
+      table_name TEXT NOT NULL,
+      record_id TEXT NOT NULL,
+      operation TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS ${prefix}outbox_entity_id_created_at
+      ON ${prefix}outbox (entity_id, created_at);
   `);
 }
 
@@ -77,8 +91,8 @@ var MIGRATIONS = [
     version: 2,
     description: "Remove FTS5; add embedding column for semantic retrieval",
     run: async (db, prefix) => {
-      await db.withTransactionAsync(async () => {
-        await db.execAsync(`
+      await db.withTransactionAsync(async (tx) => {
+        await tx.execAsync(`
           DROP TRIGGER IF EXISTS ${prefix}entries_ai;
           DROP TRIGGER IF EXISTS ${prefix}entries_ad;
           DROP TRIGGER IF EXISTS ${prefix}entries_au;
@@ -106,6 +120,25 @@ var MIGRATIONS = [
         );
       }
     }
+  },
+  {
+    version: 4,
+    description: "Create outbox table for change data capture",
+    run: async (db, prefix) => {
+      await db.execAsync(`
+        CREATE TABLE IF NOT EXISTS ${prefix}outbox (
+          id TEXT PRIMARY KEY,
+          entity_id TEXT NOT NULL,
+          table_name TEXT NOT NULL,
+          record_id TEXT NOT NULL,
+          operation TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          created_at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS ${prefix}outbox_entity_id_created_at
+          ON ${prefix}outbox (entity_id, created_at);
+      `);
+    }
   }
 ];
 for (let i = 1; i < MIGRATIONS.length; i++) {
@@ -117,28 +150,6 @@ for (let i = 1; i < MIGRATIONS.length; i++) {
 }
 var CURRENT_SCHEMA_VERSION = MIGRATIONS.length > 0 ? MIGRATIONS[MIGRATIONS.length - 1].version : 0;
 
-// src/types.ts
-var WikiBusyError = class extends Error {
-  constructor(operation, entityId) {
-    super(`${operation} already running for entity ${entityId}`);
-    this.name = "WikiBusyError";
-    this.operation = operation;
-    this.entityId = entityId;
-  }
-};
-var PrunePartialFailureError = class extends Error {
-  constructor(deleted, failedAt, remaining, cause, deletedTasks = 0, deletedEvents = 0) {
-    super(`Prune partially failed: deleted ${deleted}, failed at ${failedAt}, ${remaining} remaining`);
-    this.name = "PrunePartialFailureError";
-    this.deleted = deleted;
-    this.failedAt = failedAt;
-    this.remaining = remaining;
-    this.deletedTasks = deletedTasks;
-    this.deletedEvents = deletedEvents;
-    this.cause = cause;
-  }
-};
-
 // src/repositories/BaseRepository.ts
 var BaseRepository = class {
   constructor(db, prefix) {
@@ -182,9 +193,32 @@ function mapRowToFact(row) {
     access_count: Number(row.access_count ?? 0)
   };
 }
+function normalizeEmbeddingBlobValue(blob) {
+  if (blob instanceof Uint8Array) return blob;
+  if (blob !== null && blob !== void 0 && typeof blob === "object") {
+    const obj = blob;
+    if (obj["type"] === "Buffer" && Array.isArray(obj["data"])) {
+      return new Uint8Array(obj["data"]);
+    }
+    const entries = Object.keys(obj);
+    if (entries.length > 0 && entries.every((k) => /^\d+$/.test(k))) {
+      const len = entries.length;
+      const arr = new Uint8Array(len);
+      for (let i = 0; i < len; i++) arr[i] = obj[String(i)] ?? 0;
+      return arr;
+    }
+  }
+  return null;
+}
+function mapRowToFactWithBlobs(row) {
+  const base = mapRowToFact(row);
+  const embeddingBlob = normalizeEmbeddingBlobValue(row.embedding_blob);
+  return embeddingBlob ? { ...base, embedding_blob: embeddingBlob } : base;
+}
 var EntryRepository = class extends BaseRepository {
-  constructor() {
-    super(...arguments);
+  constructor(db, prefix, outbox) {
+    super(db, prefix);
+    this.outbox = outbox;
     this.chunkSize = 500;
   }
   /**
@@ -211,19 +245,19 @@ var EntryRepository = class extends BaseRepository {
   /**
    * Upsert a WikiFact. Nullable fields set to null when fact value is null.
    * Returns { changes, lastInsertRowId }.
+   * `tx` is REQUIRED to ensure atomic outbox staging.
    */
   async upsert(fact, tx) {
     const executor = this.getExecutor(tx);
     const now = Date.now();
     const tagsJson = JSON.stringify(fact.tags);
-    const embeddingBlob = fact.embedding_blob instanceof Uint8Array ? fact.embedding_blob : fact.embedding_blob && typeof fact.embedding_blob === "object" && "type" in fact.embedding_blob ? new Uint8Array(fact.embedding_blob.data) : fact.embedding_blob && typeof fact.embedding_blob === "object" ? (() => {
-      const obj = fact.embedding_blob;
-      const keys = Object.keys(obj).map(Number).sort((a, b) => a - b);
-      const arr = new Uint8Array(keys.length);
-      for (let i = 0; i < keys.length; i++) arr[i] = obj[String(keys[i])];
-      return arr;
-    })() : void 0;
-    return executor.runAsync(
+    const embeddingBlob = this.normalizeEmbeddingBlob(fact.embedding_blob);
+    const existingRow = await executor.getFirstAsync(
+      `SELECT id FROM ${this.prefix}entries WHERE id = ?`,
+      [fact.id]
+    );
+    const operation = fact.deleted_at ? "DELETE" : existingRow ? "UPDATE" : "INSERT";
+    const result = await executor.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,
@@ -256,7 +290,6 @@ var EntryRepository = class extends BaseRepository {
         fact.source_ref,
         fact.created_at,
         now,
-        // updated_at set by repo
         fact.last_accessed_at === null ? null : fact.last_accessed_at,
         fact.access_count,
         fact.deleted_at ?? null,
@@ -264,17 +297,172 @@ var EntryRepository = class extends BaseRepository {
         null
       ]
     );
+    await this.outbox.push({
+      entityId: fact.entity_id,
+      tableName: "entries",
+      recordId: fact.id,
+      operation,
+      payload: fact
+    }, tx);
+    return result;
+  }
+  /**
+   * Normalize an embedding blob value to Uint8Array or null.
+   */
+  normalizeEmbeddingBlob(blob) {
+    return normalizeEmbeddingBlobValue(blob);
+  }
+  /**
+   * Fetch existing rows by IDs and return id/entity_id/updated_at for import collision resolution.
+   */
+  async findExistingMetadataByIds(ids, tx) {
+    const executor = this.getExecutor(tx);
+    const rows = [];
+    for (let i = 0; i < ids.length; i += this.chunkSize) {
+      const chunk = ids.slice(i, i + this.chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      const chunkRows = await executor.getAllAsync(
+        `SELECT id, entity_id, updated_at FROM ${this.prefix}entries WHERE id IN (${placeholders})`,
+        chunk
+      );
+      rows.push(...chunkRows.map((row) => ({ id: row.id, entity_id: row.entity_id, updated_at: Number(row.updated_at) })));
+    }
+    return rows;
+  }
+  async findIdById(id, entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT id FROM ${this.prefix}entries WHERE id = ? AND entity_id = ?`,
+      [id, entityId]
+    );
+    return row?.id ?? null;
+  }
+  async findIdsBySource(entityId, sourceRef, sourceHash, tx, includeDeleted = false) {
+    const executor = this.getExecutor(tx);
+    let sql = `SELECT id FROM ${this.prefix}entries WHERE entity_id = ?`;
+    const args = [entityId];
+    if (sourceRef !== null) {
+      sql += ` AND source_ref = ?`;
+      args.push(sourceRef);
+    }
+    if (sourceHash !== null) {
+      sql += ` AND source_hash = ?`;
+      args.push(sourceHash);
+    }
+    if (!includeDeleted) {
+      sql += ` AND deleted_at IS NULL`;
+    }
+    const rows = await executor.getAllAsync(sql, args);
+    return rows.map((row) => row.id);
+  }
+  async upsertForImport(fact, tx) {
+    const executor = this.getExecutor(tx);
+    const tagsJson = JSON.stringify(fact.tags);
+    const embeddingBlob = this.normalizeEmbeddingBlob(fact.embedding_blob);
+    const result = await executor.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, embedding
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        entity_id = excluded.entity_id,
+        title = excluded.title,
+        body = excluded.body,
+        tags = excluded.tags,
+        confidence = excluded.confidence,
+        source_type = excluded.source_type,
+        source_hash = excluded.source_hash,
+        source_ref = excluded.source_ref,
+        created_at = excluded.created_at,
+        updated_at = excluded.updated_at,
+        last_accessed_at = excluded.last_accessed_at,
+        access_count = excluded.access_count,
+        deleted_at = excluded.deleted_at,
+        embedding_blob = excluded.embedding_blob,
+        embedding = NULL`,
+      [
+        fact.id,
+        fact.entity_id,
+        fact.title,
+        fact.body,
+        tagsJson,
+        fact.confidence,
+        fact.source_type,
+        fact.source_hash,
+        fact.source_ref,
+        fact.created_at,
+        fact.updated_at,
+        fact.last_accessed_at === null ? null : fact.last_accessed_at,
+        fact.access_count,
+        fact.deleted_at ?? null,
+        embeddingBlob ?? null,
+        null
+      ]
+    );
+    return result;
   }
   /**
    * Soft-delete a single entry by ID scoped to entityId. Sets deleted_at + updated_at.
+   * `tx` is REQUIRED to ensure atomic outbox staging.
    */
   async softDelete(entryId, entityId, tx) {
     const executor = this.getExecutor(tx);
     const now = Date.now();
-    return executor.runAsync(
+    const result = await executor.runAsync(
       `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`,
       [now, now, entryId, entityId]
     );
+    await this.outbox.push({
+      entityId,
+      tableName: "entries",
+      recordId: entryId,
+      operation: "DELETE",
+      payload: { id: entryId, entity_id: entityId, deleted_at: now }
+    }, tx);
+    return result;
+  }
+  /**
+   * Soft-delete entries by source_ref and/or source_hash within a transaction.
+   * Stages a DELETE outbox entry for each row in the same transaction.
+   * `tx` is REQUIRED.
+   * Returns the number of rows deleted.
+   */
+  async softDeleteBySource(entityId, tx, sourceRef, sourceHash) {
+    const executor = this.getExecutor(tx);
+    const now = Date.now();
+    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);
+    }
+    let selectQ = `SELECT id FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL`;
+    const selectArgs = [entityId];
+    if (sourceRef) {
+      selectQ += ` AND source_ref = ?`;
+      selectArgs.push(sourceRef);
+    }
+    if (sourceHash) {
+      selectQ += ` AND source_hash = ?`;
+      selectArgs.push(sourceHash);
+    }
+    const idsToDelete = await executor.getAllAsync(selectQ, selectArgs);
+    const result = await executor.runAsync(q, args);
+    for (const row of idsToDelete) {
+      await this.outbox.push({
+        entityId,
+        tableName: "entries",
+        recordId: row.id,
+        operation: "DELETE",
+        payload: { id: row.id, entity_id: entityId, deleted_at: now }
+      }, tx);
+    }
+    return result.changes;
   }
   /**
    * Fetch IDs + entity_ids of soft-deleted rows older than cutoff for a given entity.
@@ -288,2635 +476,1135 @@ var EntryRepository = class extends BaseRepository {
       [entityId, cutoff]
     );
   }
-};
-
-// src/prompts.ts
-var LIBRARIAN_SYSTEM_PROMPT = `You are a knowledge extraction agent. Your job is to analyze recent episodic events and extract stable facts and actionable tasks about the user or entity.
-Return ONLY a valid JSON object matching this schema:
-{
-  "facts": [{ "title": "string (max 80 chars)", "body": "string (max 800 chars)", "tags": ["string"], "confidence": "certain|inferred|tentative" }],
-  "tasks": [{ "description": "string", "priority": "number (0-10)" }]
-}
-Keep facts concise. Do not return markdown, just raw JSON.`;
-var HEAL_SYSTEM_PROMPT = `You are a memory grooming agent. Your job is to review a full dump of facts and recent events to resolve contradictions, downgrade stale claims, and flag obsolete facts for deletion.
-Return ONLY a valid JSON object matching this schema:
-{
-  "downgraded": ["string (fact IDs)"],
-  "deleted": ["string (fact IDs)"],
-  "newFacts": [{ "title": "string (max 80 chars)", "body": "string (max 800 chars)", "tags": ["string"], "confidence": "certain|inferred|tentative" }]
-}
-Do not return markdown, just raw JSON.`;
-var INGEST_SYSTEM_PROMPT = `You are a document ingestion agent. Your job is to extract factual knowledge from the provided document chunk.
-Return ONLY a valid JSON object matching this schema:
-{
-  "facts": [{ "title": "string (max 80 chars)", "body": "string (max 800 chars)", "tags": ["string"], "confidence": "certain|inferred|tentative" }]
-}
-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/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/readOptions.ts
-function normalizeEntityIds(entityId) {
-  const input = Array.isArray(entityId) ? entityId : [entityId];
-  const seen = /* @__PURE__ */ new Set();
-  const normalized = [];
-  for (const id of input) {
-    if (seen.has(id)) continue;
-    seen.add(id);
-    normalized.push(id);
-  }
-  return normalized;
-}
-function sanitizeTierWeights(entityIds, tierWeights) {
-  if (tierWeights === void 0) return void 0;
-  const sanitized = /* @__PURE__ */ Object.create(null);
-  for (const entityId of entityIds) {
-    const raw = tierWeights[entityId];
-    if (raw === void 0 || !Number.isFinite(raw)) {
-      sanitized[entityId] = 1;
-    } else {
-      sanitized[entityId] = Math.max(0, raw);
-    }
-  }
-  return sanitized;
-}
-function applyTierWeight(score, entityId, sanitizedTierWeights) {
-  const weight = sanitizedTierWeights?.[entityId] ?? 1;
-  if (weight === 0) return -Infinity;
-  return score * weight;
-}
-function shouldExposeReadMetadata(entityId) {
-  return Array.isArray(entityId);
-}
-
-// src/WikiMemory.ts
-var HOOK_TIMEOUT_MARKER = /* @__PURE__ */ Symbol("WikiMemoryHookTimeout");
-function parseJsonResponse(text) {
-  const firstBrace = text.indexOf("{");
-  const firstBracket = text.indexOf("[");
-  let start;
-  let openChar;
-  let closeChar;
-  if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
-    start = firstBrace;
-    openChar = "{";
-    closeChar = "}";
-  } else if (firstBracket !== -1) {
-    start = firstBracket;
-    openChar = "[";
-    closeChar = "]";
-  } else {
-    throw new SyntaxError("No JSON object/array found in LLM response");
-  }
-  let depth = 0;
-  let inString = false;
-  let escape = false;
-  let end = -1;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
-    if (escape) {
-      escape = false;
-      continue;
-    }
-    if (ch === "\\" && inString) {
-      escape = true;
-      continue;
-    }
-    if (ch === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (inString) continue;
-    if (ch === openChar) {
-      depth++;
-      continue;
-    }
-    if (ch === closeChar) {
-      depth--;
-      if (depth === 0) {
-        end = i;
-        break;
-      }
-    }
-  }
-  if (end === -1) throw new SyntaxError("No JSON object/array found in LLM response");
-  return JSON.parse(text.slice(start, end + 1));
-}
-function generateId(prefix = "") {
-  return prefix + Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-}
-function safeSlice(value, start, end) {
-  const length = value.length;
-  let safeStart = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
-  let safeEnd = end === void 0 ? length : end < 0 ? Math.max(length + end, 0) : Math.min(end, length);
-  if (safeStart > safeEnd) {
-    [safeStart, safeEnd] = [safeEnd, safeStart];
-  }
-  if (safeStart > 0 && safeStart < length && value.charCodeAt(safeStart) >= 56320 && value.charCodeAt(safeStart) <= 57343 && value.charCodeAt(safeStart - 1) >= 55296 && value.charCodeAt(safeStart - 1) <= 56319) {
-    safeStart--;
-  }
-  if (safeEnd > 0 && safeEnd < length && value.charCodeAt(safeEnd - 1) >= 55296 && value.charCodeAt(safeEnd - 1) <= 56319 && value.charCodeAt(safeEnd) >= 56320 && value.charCodeAt(safeEnd) <= 57343) {
-    safeEnd--;
-  }
-  return value.slice(safeStart, safeEnd);
-}
-function chunkText(input, maxChunkLength, overlap) {
-  const text = input.trim();
-  if (text.length === 0) return { chunks: [], truncated: false };
-  if (!Number.isInteger(maxChunkLength) || maxChunkLength < 2) {
-    throw new Error("maxChunkLength must be an integer >= 2");
-  }
-  if (!Number.isInteger(overlap) || overlap < 0 || overlap >= maxChunkLength) {
-    throw new Error("overlap must be a non-negative integer < maxChunkLength");
-  }
-  const chunks = [];
-  let truncated = false;
-  let cursor = 0;
-  const halfMax = Math.floor(maxChunkLength / 2);
-  while (cursor < text.length) {
-    const remaining = text.length - cursor;
-    if (remaining <= maxChunkLength) {
-      chunks.push(safeSlice(text, cursor, text.length));
-      break;
-    }
-    const windowEnd = cursor + maxChunkLength;
-    const minSplit = cursor + halfMax;
-    let splitPoint = -1;
-    const paraIdx = text.lastIndexOf("\n\n", windowEnd);
-    if (paraIdx >= minSplit && paraIdx + 2 <= windowEnd) {
-      splitPoint = paraIdx + 2;
-    }
-    if (splitPoint === -1) {
-      let lastTerm = -1;
-      for (let i = minSplit; i < windowEnd - 1; i++) {
-        const ch = text[i];
-        if ((ch === "." || ch === "!" || ch === "?") && /\s/.test(text[i + 1])) {
-          lastTerm = i + 2;
-        }
-      }
-      if (lastTerm !== -1 && lastTerm <= windowEnd) splitPoint = lastTerm;
-    }
-    if (splitPoint === -1) {
-      for (let i = windowEnd - 1; i >= minSplit; i--) {
-        if (/\s/.test(text[i])) {
-          splitPoint = i + 1;
-          break;
-        }
-      }
-    }
-    if (splitPoint === -1) {
-      truncated = true;
-      splitPoint = windowEnd;
-    }
-    chunks.push(safeSlice(text, cursor, splitPoint));
-    const next = Math.max(splitPoint - overlap, cursor + 1);
-    cursor = next;
-  }
-  return { chunks, truncated };
-}
-async function withConcurrency(tasks, limit) {
-  const results = new Array(tasks.length);
-  let index = 0;
-  let failed = false;
-  let firstError;
-  async function worker() {
-    while (index < tasks.length && !failed) {
-      const i = index++;
-      try {
-        results[i] = await tasks[i]();
-      } catch (e) {
-        if (!failed) {
-          failed = true;
-          firstError = e;
-        }
-        return;
-      }
-    }
-  }
-  const workerCount = tasks.length === 0 ? 0 : Math.min(Math.max(limit, 1), tasks.length);
-  await Promise.allSettled(Array.from({ length: workerCount }, worker));
-  if (failed) throw firstError;
-  return results;
-}
-function clip(value, max) {
-  if (typeof value !== "string") return "";
-  const s = value.trim();
-  return s.length <= max ? s : safeSlice(s, 0, max).trimEnd();
-}
-function validateTags(tags) {
-  if (!Array.isArray(tags)) return [];
-  return tags.filter((t) => typeof t === "string").map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0 && t.length <= 40).slice(0, 6);
-}
-function validateFact(fact) {
-  if (typeof fact?.title !== "string" || typeof fact?.body !== "string") return null;
-  const title = clip(fact.title, 80);
-  const body = clip(fact.body, 800);
-  if (!title || !body) return null;
-  let confidence = fact.confidence;
-  if (confidence !== "certain" && confidence !== "tentative") confidence = "inferred";
-  return {
-    ...fact,
-    title,
-    body,
-    confidence,
-    tags: validateTags(fact.tags)
-  };
-}
-function validateTask(task) {
-  if (typeof task?.description !== "string") return null;
-  const description = clip(task.description, 200);
-  if (!description) return null;
-  let priority = task.priority;
-  if (typeof priority !== "number" || !isFinite(priority)) priority = 0;
-  return {
-    ...task,
-    description,
-    priority
-  };
-}
-function normalizeSourceRef(value) {
-  if (typeof value !== "string") return null;
-  const cleaned = value.replace(/[^A-Za-z0-9._\- ]/g, "").trim().slice(0, 255);
-  return cleaned.length > 0 ? cleaned : null;
-}
-function normalizeSourceHash(value) {
-  if (typeof value !== "string") return null;
-  return /^[0-9a-f]{64}$/i.test(value) ? value.toLowerCase() : null;
-}
-function titleTokens(title) {
-  return new Set(title.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((t) => t.length >= 3));
-}
-function jaccardScore(a, b) {
-  if (a.size === 0 && b.size === 0) return 0;
-  const intersection = new Set([...a].filter((x) => b.has(x)));
-  const union = /* @__PURE__ */ new Set([...a, ...b]);
-  return intersection.size / union.size;
-}
-var FUZZY_THRESHOLD = 0.5;
-var MIN_TOKENS_TO_QUALIFY = 3;
-var _WikiMemory = class _WikiMemory {
-  constructor(db, options) {
-    this.activeMaintenanceJobs = /* @__PURE__ */ new Set();
-    this.activeIngestJobs = /* @__PURE__ */ new Set();
-    this.statusSubscribers = /* @__PURE__ */ new Map();
-    this.miniSearch = new MiniSearch({
-      fields: ["title", "body", "tags"],
-      storeFields: ["entity_id"],
-      searchOptions: {
-        boost: { title: 2 },
-        fuzzy: 0.2,
-        prefix: true
-      }
-    });
-    this.miniSearchEntryIdsByEntity = /* @__PURE__ */ new Map();
-    this.vectorCache = /* @__PURE__ */ new Map();
-    this.db = db;
-    this.options = options;
-    this.prefix = options.config?.tablePrefix || "llm_wiki_";
-    this.entryRepo = new EntryRepository(db, this.prefix);
+  /**
+   * Fetch all non-deleted entries for an entity, ordered by updated_at DESC.
+   * Used by _getFullBundle().
+   */
+  async findAllByEntityId(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const rows = await executor.getAllAsync(
+      `SELECT * FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL ORDER BY updated_at DESC`,
+      [entityId]
+    );
+    return rows.map(mapRowToFact);
   }
-  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;
-        }
-      })()
-    };
+  /**
+   * Fetch recent non-deleted entries for an entity (limited), ordered by updated_at DESC.
+   * Used by MaintenanceService.doRunLibrarian().
+   */
+  async findRecentByEntityId(entityId, limit, tx) {
+    const executor = this.getExecutor(tx);
+    const rows = await executor.getAllAsync(
+      `SELECT * FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL ORDER BY updated_at DESC LIMIT ?`,
+      [entityId, limit]
+    );
+    return rows.map(mapRowToFact);
   }
-  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);
-    }
+  /**
+   * Fetch all non-deleted entries for an entity with embedding blobs preserved.
+   * Used by ImportExportService for export/import round-tripping.
+   */
+  async findAllByEntityIdWithBlobs(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const rows = await executor.getAllAsync(
+      `SELECT * FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL ORDER BY updated_at DESC`,
+      [entityId]
+    );
+    return rows.map(mapRowToFactWithBlobs);
   }
-  async storeEmbeddingDimension(dim) {
-    const existing = await this.db.getFirstAsync(
-      `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension'`
+  /**
+   * Count non-deleted entries for the given entities whose embedding_blob dimension
+   * doesn't match queryVecLength. Used by read() to detect model-switch mismatches.
+   */
+  async countDimensionMismatched(entityIds, queryVecLength, tx) {
+    if (entityIds.length === 0) return 0;
+    const executor = this.getExecutor(tx);
+    const placeholders = entityIds.map(() => "?").join(",");
+    const row = await executor.getFirstAsync(
+      `SELECT COUNT(*) AS cnt FROM ${this.prefix}entries
+       WHERE entity_id IN (${placeholders}) 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) != ?`,
+      [...entityIds, queryVecLength]
     );
-    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(
-        `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension', ?)`,
-        [String(dim)]
-      );
-    }
+    return row?.cnt ?? 0;
   }
   /**
-   * 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.
+   * Count non-deleted entries for entityId that are stale relative to targetDim
+   * (either no blob or wrong dimension). Used by runReembed() per-entity skip logic.
    */
-  async _reconcileEmbeddingDimension() {
-    const mismatch = await this.db.getFirstAsync(
-      `SELECT value FROM ${this.prefix}meta WHERE key = 'embedding_dimension_mismatch'`
+  async countStaleForEntity(entityId, targetDim, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.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, targetDim]
     );
-    if (!mismatch) return;
-    const newDim = parseInt(mismatch.value, 10);
-    const residual = await this.db.getFirstAsync(
+    return row?.cnt ?? 0;
+  }
+  /**
+   * Count non-deleted entries with stale or unconverted embeddings relative to `dim`.
+   * Used by _reconcileEmbeddingDimension() to decide when to promote the pending
+   * embedding_dimension value.
+   */
+  async countStaleEmbeddings(dim, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.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]
+      [dim]
     );
-    if (!residual || residual.cnt === 0) {
-      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'`
-      );
-    }
+    return row?.cnt ?? 0;
   }
-  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;
-      }
-      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_blob = ?, embedding = NULL WHERE id = ?`,
-        [blob, fact.id]
+  /**
+   * Bulk delete pruned entries (already soft-deleted) by IDs.
+   * Used by runPrune(). Returns total number of deleted rows.
+   * `tx` is REQUIRED so outbox deletion events are staged atomically.
+   */
+  async bulkDeletePruned(entityId, cutoff, ids, tx) {
+    const executor = this.getExecutor(tx);
+    let totalChanges = 0;
+    const chunkSize = 500;
+    for (let i = 0; i < ids.length; i += chunkSize) {
+      const chunk = ids.slice(i, i + chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      const result = await executor.runAsync(
+        `DELETE FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NOT NULL AND deleted_at <= ? AND id IN (${placeholders})`,
+        [entityId, cutoff, ...chunk]
       );
-      try {
-        await this._notifyEmbeddingPersisted(fact.entity_id, fact.id, float32Vector);
-      } catch (hookErr) {
-        console.warn(`[WikiMemory] onEmbeddingPersisted hook failed for ${fact.id}:`, hookErr);
+      totalChanges += result.changes;
+      if (result.changes > 0) {
+        for (const id of chunk) {
+          await this.outbox.push({
+            entityId,
+            tableName: "entries",
+            recordId: id,
+            operation: "DELETE",
+            payload: { id, entity_id: entityId, deleted_at: cutoff }
+          }, tx);
+        }
       }
-      return true;
-    } catch (err) {
-      console.warn(`[WikiMemory] embedFact failed for ${fact.id}:`, err);
-      return false;
     }
+    return totalChanges;
   }
-  _librarianKey(entityId) {
-    return `${this.prefix}:${entityId}:librarian`;
-  }
-  _healKey(entityId) {
-    return `${this.prefix}:${entityId}:heal`;
-  }
-  _warnCrossEntityCollision(type, id, existingEntityId, targetEntityId) {
-    console.warn(`[WikiMemory] importDump: ${type} id "${id}" already belongs to entity "${existingEntityId}"; skipping for entity "${targetEntityId}"`);
-  }
-  /** Maps pre-rename enum strings from older dumps to current source_type values. */
-  _normalizeImportedSourceType(raw, ctx) {
-    if (raw === "user_document") return "immutable_document";
-    if (raw === "agent_inferred") return "librarian_inferred";
-    const allowed = ["user_stated", "librarian_inferred", "user_confirmed", "immutable_document"];
-    if (allowed.includes(raw)) return raw;
-    const where = ctx !== void 0 ? ` for entity "${ctx.entityId}" fact "${ctx.factId}"` : "";
-    throw new Error(
-      `importDump: invalid source_type "${raw}"${where} (expected one of: ${allowed.join(", ")}, or legacy aliases user_document / agent_inferred)`
+  /**
+   * Mark orphaned entries (never accessed, old) as deleted.
+   * Used by MaintenanceService.doRunHeal().
+   */
+  async markOrphaned(entityId, orphanThreshold, tx) {
+    const executor = this.getExecutor(tx);
+    const now = Date.now();
+    const updatedRows = await executor.getAllAsync(
+      `UPDATE ${this.prefix}entries
+       SET deleted_at = ?, updated_at = ?
+       WHERE entity_id = ? AND access_count = 0 AND created_at <= ? AND source_type != 'immutable_document' AND deleted_at IS NULL
+       RETURNING id`,
+      [now, now, entityId, orphanThreshold]
     );
+    for (const row of updatedRows) {
+      await this.outbox.push({
+        entityId,
+        tableName: "entries",
+        recordId: row.id,
+        operation: "DELETE",
+        payload: { id: row.id, entity_id: entityId, deleted_at: now }
+      }, tx);
+    }
+    return updatedRows.map((r) => r.id);
   }
-  async assertNoLegacySourceTypes() {
-    const legacyProbe = await this.db.getFirstAsync(
-      `SELECT 1 AS one FROM ${this.prefix}entries
-       WHERE source_type IN ('user_document', 'agent_inferred')
-       LIMIT 1`,
-      []
-    );
-    if (!legacyProbe) return;
-    const legacyCount = await this.db.getFirstAsync(
-      `SELECT COUNT(*) as count FROM ${this.prefix}entries
-       WHERE source_type IN ('user_document', 'agent_inferred')`,
-      []
+  /**
+   * Downgrade stale inferred entries to 'tentative'.
+   * Used by MaintenanceService.doRunHeal().
+   */
+  async downgradeStaleInferred(entityId, staleThreshold, tx) {
+    const executor = this.getExecutor(tx);
+    const now = Date.now();
+    const eligibleRows = await executor.getAllAsync(
+      `SELECT id FROM ${this.prefix}entries
+       WHERE entity_id = ? AND confidence = 'inferred'
+         AND (last_accessed_at <= ? OR (last_accessed_at IS NULL AND created_at <= ?))
+         AND source_type != 'immutable_document' AND deleted_at IS NULL`,
+      [entityId, staleThreshold, staleThreshold]
     );
-    const count = legacyCount?.count ?? 0;
-    const migrationSQL = `
--- Migrate legacy source_type values (targets your WikiMemory prefix: ${this.prefix})
-UPDATE ${this.prefix}entries SET source_type = 'immutable_document' WHERE source_type = 'user_document';
-UPDATE ${this.prefix}entries SET source_type = 'librarian_inferred' WHERE source_type = 'agent_inferred';
-    `.trim();
-    throw new Error(
-      `Database contains ${count} entries with legacy source_type values ('user_document' or 'agent_inferred'). These enum values were renamed in this release. Running without migration would allow legacy 'user_document' facts to bypass immutability guards, causing data corruption.
-
-${migrationSQL}
-
-After running the migration SQL, restart your application.`
+    if (eligibleRows.length === 0) return 0;
+    const result = await executor.runAsync(
+      `UPDATE ${this.prefix}entries
+       SET confidence = 'tentative', updated_at = ?
+       WHERE entity_id = ? AND confidence = 'inferred' AND (last_accessed_at <= ? OR (last_accessed_at IS NULL AND created_at <= ?)) AND source_type != 'immutable_document' AND deleted_at IS NULL`,
+      [now, entityId, staleThreshold, staleThreshold]
     );
-  }
-  async _notifyEmbeddingPersisted(entityId, factId, vector) {
-    if (!this.options.vectorRanker?.onEmbeddingPersisted) return;
-    const vectorCopy = vector ? vector.slice() : null;
-    await this.options.vectorRanker.onEmbeddingPersisted({
-      entityId,
-      factId,
-      vector: vectorCopy
-    });
+    for (const row of eligibleRows) {
+      await this.outbox.push({
+        entityId,
+        tableName: "entries",
+        recordId: row.id,
+        operation: "UPDATE",
+        payload: { id: row.id, entity_id: entityId, confidence: "tentative", updated_at: now }
+      }, tx);
+    }
+    return result.changes;
   }
   /**
-   * GDPR-critical variant: awaits the hook with a timeout and rethrows failures.
-   * Use ONLY on deletion paths. forget() calls after soft-delete UPDATE; runPrune()
-   * calls before hard DELETE. For best-effort sync, use _notifyEmbeddingPersisted.
+   * Downgrade specific entries to 'tentative' by IDs.
+   * Used by MaintenanceService.doRunHeal().
    */
-  async _notifyEmbeddingPersistedOrThrow(entityId, factId, vector) {
-    if (!this.options.vectorRanker?.onEmbeddingPersisted) return;
-    if (this.options.forceDeleteIgnoreRankerHook === true) return;
-    const vectorCopy = vector ? vector.slice() : null;
-    const rawTimeout = this.options.deletionHookTimeoutMs ?? 3e4;
-    if (typeof rawTimeout !== "number" || !Number.isFinite(rawTimeout) || rawTimeout <= 0) {
-      throw new Error("Invalid deletionHookTimeoutMs: must be a positive finite number");
-    }
-    const timeoutMs = rawTimeout;
-    let timeoutHandle;
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutHandle = setTimeout(
-        () => {
-          const timeoutError = new Error(`onEmbeddingPersisted timed out after ${timeoutMs}ms`);
-          timeoutError[HOOK_TIMEOUT_MARKER] = true;
-          reject(timeoutError);
-        },
-        timeoutMs
-      );
-    });
-    const hookPromise = Promise.resolve(
-      this.options.vectorRanker.onEmbeddingPersisted({
-        entityId,
-        factId,
-        vector: vectorCopy
-      })
+  async downgradeByIds(ids, entityId, tx) {
+    if (ids.length === 0) return;
+    const executor = this.getExecutor(tx);
+    const now = Date.now();
+    const placeholders = ids.map(() => "?").join(",");
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries SET confidence = 'tentative', updated_at = ? WHERE id IN (${placeholders}) AND entity_id = ?`,
+      [now, ...ids, entityId]
     );
-    try {
-      await Promise.race([hookPromise, timeoutPromise]);
-    } catch (err) {
-      hookPromise.catch(() => {
-      });
-      throw err;
-    } finally {
-      if (timeoutHandle) clearTimeout(timeoutHandle);
+    for (const id of ids) {
+      await this.outbox.push({
+        entityId,
+        tableName: "entries",
+        recordId: id,
+        operation: "UPDATE",
+        payload: { id, entity_id: entityId, confidence: "tentative", updated_at: now }
+      }, tx);
     }
   }
-  async setup() {
-    const entriesExistedBeforeSetup = await this.db.getFirstAsync(
-      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
-      [`${this.prefix}entries`]
+  /**
+   * Soft-delete specific entries by IDs.
+   * Used by MaintenanceService.doRunHeal().
+   */
+  async softDeleteByIds(ids, entityId, tx) {
+    if (ids.length === 0) return;
+    const executor = this.getExecutor(tx);
+    const now = Date.now();
+    const placeholders = ids.map(() => "?").join(",");
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE id IN (${placeholders}) AND entity_id = ?`,
+      [now, now, ...ids, entityId]
     );
-    await setupDatabase(this.db, this.prefix);
-    let currentVersion;
-    if (!entriesExistedBeforeSetup) {
-      await this.db.runAsync(
-        `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('schema_version', ?)`,
-        [String(CURRENT_SCHEMA_VERSION)]
-      );
-      currentVersion = CURRENT_SCHEMA_VERSION;
-    } else {
-      const metaRow = await this.db.getFirstAsync(
-        `SELECT value FROM ${this.prefix}meta WHERE key = 'schema_version'`
-      );
-      if (metaRow) {
-        currentVersion = parseInt(metaRow.value, 10);
-        if (!Number.isFinite(currentVersion)) currentVersion = 0;
-      } else {
-        const ftsMeta = await this.db.getFirstAsync(
-          `SELECT sql FROM sqlite_master WHERE type='table' AND name=?`,
-          [`${this.prefix}entries_fts`]
-        );
-        const hasPorter = /tokenize\s*=\s*['"]porter\s+unicode61['"]/i.test(ftsMeta?.sql ?? "");
-        currentVersion = hasPorter ? 1 : 0;
-      }
-    }
-    for (const migration of MIGRATIONS) {
-      if (migration.version > currentVersion) {
-        await migration.run(this.db, this.prefix);
-        await this.db.runAsync(
-          `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('schema_version', ?)`,
-          [String(migration.version)]
-        );
-        currentVersion = migration.version;
-      }
-    }
-    if (entriesExistedBeforeSetup) {
-      const metaCheck = await this.db.getFirstAsync(
-        `SELECT value FROM ${this.prefix}meta WHERE key = 'schema_version'`
-      );
-      if (!metaCheck) {
-        await this.db.runAsync(
-          `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('schema_version', ?)`,
-          [String(currentVersion)]
-        );
-      }
-    }
-    if (entriesExistedBeforeSetup) {
-      await this.assertNoLegacySourceTypes();
+    for (const id of ids) {
+      await this.outbox.push({
+        entityId,
+        tableName: "entries",
+        recordId: id,
+        operation: "DELETE",
+        payload: { id, entity_id: entityId, deleted_at: now }
+      }, tx);
     }
-    const rows = await this.db.getAllAsync(`
-      SELECT rowid, source_ref FROM ${this.prefix}entries
-      WHERE source_ref IS NOT NULL
-        AND (
-          TRIM(source_ref) != source_ref
-          OR INSTR(source_ref, '/') > 0
-          OR INSTR(source_ref, '\\') > 0
-          OR INSTR(source_ref, CHAR(0)) > 0
-          OR source_ref GLOB '*[^-A-Za-z0-9._ ]*'
-        )
-    `);
-    await this.db.withTransactionAsync(async () => {
-      for (const row of rows) {
-        const normalized = normalizeSourceRef(row.source_ref);
-        if (normalized !== row.source_ref) {
-          await this.db.runAsync(
-            `UPDATE ${this.prefix}entries SET source_ref = ? WHERE rowid = ?`,
-            [normalized, row.rowid]
-          );
-        }
-      }
-    });
-    await this.rebuildMiniSearchIndex();
   }
-  async hasChanged(entityId, sourceRef, sourceHash) {
-    const normalizedRef = normalizeSourceRef(sourceRef);
-    if (!normalizedRef) {
-      throw new Error(`Invalid sourceRef: "${sourceRef}"`);
+  /**
+   * Bulk soft-delete all entries for an entity.
+   * Stages DELETE outbox entries for each row in the same transaction.
+   * `tx` is REQUIRED.
+   */
+  async bulkSoftDeleteByEntityId(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const now = Date.now();
+    const idsToDelete = await executor.getAllAsync(
+      `SELECT id FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL`,
+      [entityId]
+    );
+    const result = await executor.runAsync(
+      `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`,
+      [now, now, entityId]
+    );
+    for (const row of idsToDelete) {
+      await this.outbox.push({
+        entityId,
+        tableName: "entries",
+        recordId: row.id,
+        operation: "DELETE",
+        payload: { id: row.id, entity_id: entityId, deleted_at: now }
+      }, tx);
     }
-    const normalizedHash = normalizeSourceHash(sourceHash);
-    if (!normalizedHash) {
-      throw new Error(`Invalid sourceHash: must be a 64-character hex string (normalized to lowercase)`);
+    return result.changes;
+  }
+  async findMiniSearchRows(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    if (entityId !== void 0) {
+      return executor.getAllAsync(
+        `SELECT id, entity_id, title, body, tags FROM ${this.prefix}entries WHERE deleted_at IS NULL AND entity_id = ?`,
+        [entityId]
+      );
     }
-    const row = await this.db.getFirstAsync(
-      `SELECT source_hash FROM ${this.prefix}entries
-       WHERE entity_id = ? AND source_ref = ? AND deleted_at IS NULL
-       ORDER BY updated_at DESC
-       LIMIT 1`,
-      [entityId, normalizedRef]
+    return executor.getAllAsync(
+      `SELECT id, entity_id, title, body, tags FROM ${this.prefix}entries WHERE deleted_at IS NULL`
     );
-    if (!row) return true;
-    const normalizedStoredHash = row.source_hash ? normalizeSourceHash(row.source_hash) : null;
-    return normalizedStoredHash !== normalizedHash;
-  }
-  _pruneKey(entityId) {
-    return `${this.prefix}:${entityId}:prune`;
-  }
-  _reembedKey(entityId) {
-    return `${this.prefix}:${entityId}:reembed`;
   }
-  _globalReembedKey() {
-    return `${this.prefix}:reembed`;
+  async updateEmbeddingBlob(id, blob, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries SET embedding_blob = ?, embedding = NULL WHERE id = ?`,
+      [blob, id]
+    );
   }
-  _importKey(entityId) {
-    return `${this.prefix}:${entityId}:import`;
+  async hasLegacySourceTypes(tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT 1 AS one FROM ${this.prefix}entries WHERE source_type IN ('user_document', 'agent_inferred') LIMIT 1`,
+      []
+    );
+    return row != null;
   }
-  _globalImportKey() {
-    return `${this.prefix}:import`;
+  async countLegacySourceTypes(tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT COUNT(*) as count FROM ${this.prefix}entries WHERE source_type IN ('user_document', 'agent_inferred')`,
+      []
+    );
+    return row?.count ?? 0;
   }
-  _forgetKey(entityId) {
-    return `${this.prefix}:${entityId}:forget`;
+  async findAllForReembed(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    if (entityId !== void 0) {
+      return executor.getAllAsync(
+        `SELECT * FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL`,
+        [entityId]
+      );
+    }
+    return executor.getAllAsync(
+      `SELECT * FROM ${this.prefix}entries WHERE deleted_at IS NULL`
+    );
   }
-  _isReembedActive(entityId) {
-    return this.activeMaintenanceJobs.has(this._reembedKey(entityId)) || this.activeMaintenanceJobs.has(this._globalReembedKey());
+  async findRowsForSourceRefMigration(tx) {
+    const executor = this.getExecutor(tx);
+    return executor.getAllAsync(
+      `SELECT rowid, source_ref FROM ${this.prefix}entries
+       WHERE source_ref IS NOT NULL
+         AND (
+           TRIM(source_ref) != source_ref
+           OR INSTR(source_ref, '/') > 0
+           OR INSTR(source_ref, '\\') > 0
+           OR INSTR(source_ref, CHAR(0)) > 0
+           OR source_ref GLOB '*[^-A-Za-z0-9._ ]*'
+         )`
+    );
   }
-  _isImportActiveFor(entityId) {
-    return this.activeMaintenanceJobs.has(this._importKey(entityId)) || this.activeMaintenanceJobs.has(this._globalImportKey());
+  async updateSourceRefByRowid(rowid, sourceRef, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries SET source_ref = ? WHERE rowid = ?`,
+      [sourceRef, rowid]
+    );
   }
-  _isForgetActiveFor(entityId) {
-    return this.activeMaintenanceJobs.has(this._forgetKey(entityId));
+  async findLatestSourceHash(entityId, sourceRef, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT source_hash FROM ${this.prefix}entries
+       WHERE entity_id = ? AND source_ref = ? AND deleted_at IS NULL
+       ORDER BY updated_at DESC
+       LIMIT 1`,
+      [entityId, sourceRef]
+    );
+    return row?.source_hash ?? null;
   }
-  /** 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;
+  async findMetadataByIds(ids, tx) {
+    if (ids.length === 0) return [];
+    const executor = this.getExecutor(tx);
+    const rows = [];
+    for (let i = 0; i < ids.length; i += this.chunkSize) {
+      const chunk = ids.slice(i, i + this.chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      const chunkRows = await executor.getAllAsync(
+        `SELECT id, entity_id, updated_at, access_count FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
+        chunk
+      );
+      rows.push(...chunkRows);
     }
-    return false;
+    return rows;
   }
-  /** 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;
-  }
-  _copyEntityStatus(s) {
-    return { ingesting: s.ingesting, librarian: s.librarian, heal: s.heal };
-  }
-  _notifyStatusSubscribers(entityId) {
-    const set = this.statusSubscribers.get(entityId);
-    if (!set || set.size === 0) return;
-    for (const entry of Array.from(set)) {
-      if (!set.has(entry)) continue;
-      const next = this.getEntityStatus(entityId);
-      if (entry.last.ingesting === next.ingesting && entry.last.librarian === next.librarian && entry.last.heal === next.heal) continue;
-      entry.last = this._copyEntityStatus(next);
-      try {
-        entry.callback(this._copyEntityStatus(next));
-      } catch (err) {
-        console.error(`[WikiMemory.subscribeEntityStatus] callback error for entityId="${entityId}" during transition emission`, err);
-      }
+  async findWithEmbeddingsByIds(ids, tx) {
+    if (ids.length === 0) return [];
+    const executor = this.getExecutor(tx);
+    const rows = [];
+    for (let i = 0; i < ids.length; i += this.chunkSize) {
+      const chunk = ids.slice(i, i + this.chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      const chunkRows = await executor.getAllAsync(
+        `SELECT id, entity_id, embedding_blob, embedding, updated_at, access_count FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
+        chunk
+      );
+      rows.push(...chunkRows);
     }
+    return rows;
   }
-  _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`);
-    }
+  async findMetadataByEntityIds(entityIds, tx) {
+    if (entityIds.length === 0) return [];
+    const executor = this.getExecutor(tx);
+    const placeholders = entityIds.map(() => "?").join(",");
+    return executor.getAllAsync(
+      `SELECT id, entity_id, updated_at, access_count FROM ${this.prefix}entries WHERE entity_id IN (${placeholders}) AND deleted_at IS NULL`,
+      [...entityIds]
+    );
   }
-  async runPrune(entityId, options) {
-    const pruneKey = this._pruneKey(entityId);
-    const ingestPrefix = `${this.prefix}:${entityId}:`;
-    let isIngestRunning = false;
-    for (const k of this.activeIngestJobs) {
-      if (k.startsWith(ingestPrefix)) {
-        isIngestRunning = true;
-        break;
-      }
-    }
-    let blockingOperation = null;
-    if (this.activeMaintenanceJobs.has(pruneKey)) {
-      blockingOperation = "prune";
-    } else if (this.activeMaintenanceJobs.has(this._librarianKey(entityId))) {
-      blockingOperation = "librarian";
-    } else if (this.activeMaintenanceJobs.has(this._healKey(entityId))) {
-      blockingOperation = "heal";
-    } else if (this._isReembedActive(entityId)) {
-      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);
-    }
-    this.activeMaintenanceJobs.add(pruneKey);
-    try {
-      const retainSoftDeletedFor = options?.retainSoftDeletedFor !== void 0 ? options.retainSoftDeletedFor : this.options.config?.pruneRetainSoftDeletedFor ?? 7;
-      const retainEventsFor = options?.retainEventsFor !== void 0 ? options.retainEventsFor : this.options.config?.pruneEventsAfter ?? 30;
-      const vacuum = options?.vacuum ?? false;
-      this._validatePruneDuration(retainSoftDeletedFor, "retainSoftDeletedFor");
-      this._validatePruneDuration(retainEventsFor, "retainEventsFor");
-      const now = Date.now();
-      let deletedEntries = 0;
-      let deletedTasks = 0;
-      let deletedEvents = 0;
-      if (retainSoftDeletedFor !== null) {
-        const cutoff = now - retainSoftDeletedFor * 864e5;
-        const entriesToDelete = await this.entryRepo.getPrunableMetadata(entityId, cutoff);
-        const succeeded = [];
-        let failure = null;
-        for (const row of entriesToDelete) {
-          try {
-            await this._notifyEmbeddingPersistedOrThrow(row.entity_id, row.id, null);
-            succeeded.push({ entity_id: row.entity_id, id: row.id });
-          } catch (err) {
-            failure = { factId: row.id, cause: err };
-            break;
-          }
-        }
-        if (succeeded.length > 0) {
-          const chunkSize = 500;
-          for (let i = 0; i < succeeded.length; i += chunkSize) {
-            const chunk = succeeded.slice(i, i + chunkSize);
-            const placeholders = chunk.map(() => "?").join(",");
-            const entryResult = await this.db.runAsync(
-              `DELETE FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NOT NULL AND deleted_at <= ? AND id IN (${placeholders})`,
-              [entityId, cutoff, ...chunk.map((r) => r.id)]
-            );
-            deletedEntries += entryResult.changes;
-          }
-        }
-        const taskResult = await this.db.runAsync(
-          `DELETE FROM ${this.prefix}tasks
-           WHERE entity_id = ? AND deleted_at IS NOT NULL AND deleted_at <= ?`,
-          [entityId, cutoff]
-        );
-        deletedTasks = taskResult.changes;
-        if (failure) {
-          await this.rebuildMiniSearchIndex(entityId);
-          this.vectorCache.delete(entityId);
-          const remaining = entriesToDelete.length - succeeded.length - 1;
-          const isTimeout = failure.cause?.[HOOK_TIMEOUT_MARKER] === true;
-          if (isTimeout) {
-            throw new PrunePartialFailureError(
-              succeeded.length,
-              failure.factId,
-              remaining,
-              new Error("Deletion hook timed out"),
-              deletedTasks,
-              0
-              // events not yet deleted at this point
-            );
-          }
-          const errMsg = failure.cause?.message ?? "";
-          const isValidationError = errMsg.startsWith("Invalid deletionHookTimeoutMs");
-          const sanitizedCause = isValidationError ? failure.cause : this._sanitizeRankerError(failure.cause);
-          throw new PrunePartialFailureError(
-            succeeded.length,
-            failure.factId,
-            remaining,
-            sanitizedCause,
-            deletedTasks,
-            0
-            // events not yet deleted at this point
-          );
-        }
-      }
-      if (retainEventsFor !== null) {
-        const cutoff = now - retainEventsFor * 864e5;
-        const eventResult = await this.db.runAsync(
-          `DELETE FROM ${this.prefix}events
-           WHERE entity_id = ? AND created_at <= ?`,
-          [entityId, cutoff]
-        );
-        deletedEvents = eventResult.changes;
-      }
-      if (vacuum) {
-        await this.db.execAsync(`PRAGMA wal_checkpoint(TRUNCATE)`);
-        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 findWithEmbeddingsByEntityIds(entityIds, tx) {
+    if (entityIds.length === 0) return [];
+    const executor = this.getExecutor(tx);
+    const placeholders = entityIds.map(() => "?").join(",");
+    return executor.getAllAsync(
+      `SELECT id, entity_id, embedding_blob, embedding, updated_at, access_count FROM ${this.prefix}entries WHERE entity_id IN (${placeholders}) AND deleted_at IS NULL`,
+      [...entityIds]
+    );
   }
-  async read(entityId, query, options) {
-    const config = this.options.config;
-    const entityIds = normalizeEntityIds(entityId);
-    const sanitizedTierWeights = shouldExposeReadMetadata(entityId) ? sanitizeTierWeights(entityIds, options?.tierWeights) : void 0;
-    const exposeMetadata = shouldExposeReadMetadata(entityId);
-    if (entityIds.length === 0) {
-      const empty = { facts: [], tasks: [], events: [] };
-      if (exposeMetadata) {
-        empty.metadata = { query, entityIds: [] };
-        if (sanitizedTierWeights && Object.keys(sanitizedTierWeights).length > 0) empty.metadata.tierWeights = sanitizedTierWeights;
-      }
-      return empty;
-    }
-    const MAX_ENTITY_IDS = 100;
-    if (entityIds.length > MAX_ENTITY_IDS) {
-      throw new RangeError(`read() accepts at most ${MAX_ENTITY_IDS} entity IDs; received ${entityIds.length}`);
-    }
-    const nullByteId = entityIds.find((id) => id.includes("\0"));
-    if (nullByteId !== void 0) {
-      throw new TypeError(`entity_id values must not contain the null byte (\\x00); got "${nullByteId}"`);
-    }
-    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 = [];
-    let scoreByFactId;
-    if (maxResults === 0) ; else if (trimmedQuery) {
-      let usedEmbed = false;
-      const scoredEntityIds = this._filterScoredEntities(entityIds, sanitizedTierWeights, options?.includeZeroWeightEntities);
-      if (scoredEntityIds.length === 0) {
-        usedEmbed = true;
-      } else if (!skipEmbed && embedFn) {
-        let rankerShouldRethrow = false;
-        let pendingRankerFallbackError;
-        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 mismatchScope = this._entityInClause(scoredEntityIds);
-          const mismatchedCount = await this.db.getFirstAsync(
-            `SELECT COUNT(*) AS cnt FROM ${this.prefix}entries
-             WHERE ${mismatchScope.clause} 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) != ?`,
-            [...mismatchScope.params, queryVec.length]
-          );
-          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.`
-            );
-          }
-          const useRanker = Boolean(this.options.vectorRanker);
-          let candidateRows;
-          let populateCache = entityIds.length === 1;
-          let miniSearchScores;
-          if (effectivePreFilterLimit !== void 0) {
-            populateCache = false;
-            const entityIdSet = new Set(scoredEntityIds);
-            const preResults = this.miniSearch.search(trimmedQuery, {
-              filter: (r) => entityIdSet.has(r.entity_id),
-              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;
-                if (useRanker) {
-                  const rows = [];
-                  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, entity_id, updated_at, access_count FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
-                      idChunk
-                    );
-                    rows.push(...chunkRows);
-                  }
-                  candidateRows = rows;
-                } else {
-                  const rows = [];
-                  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, entity_id, embedding_blob, embedding, updated_at, access_count FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
-                      idChunk
-                    );
-                    rows.push(...chunkRows);
-                  }
-                  candidateRows = rows;
-                }
-                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]));
-                }
-              }
-            }
-          } else {
-            if (useRanker) {
-              const entityScope = this._entityInClause(scoredEntityIds);
-              candidateRows = await this.db.getAllAsync(
-                `SELECT id, entity_id, updated_at, access_count FROM ${this.prefix}entries WHERE ${entityScope.clause} AND deleted_at IS NULL`,
-                entityScope.params
-              );
-            } else {
-              const entityScope = this._entityInClause(scoredEntityIds);
-              candidateRows = await this.db.getAllAsync(
-                `SELECT id, entity_id, embedding_blob, embedding, updated_at, access_count FROM ${this.prefix}entries WHERE ${entityScope.clause} AND deleted_at IS NULL`,
-                entityScope.params
-              );
-            }
-            if (weight !== void 0 && weight < 1) {
-              const entityIdSet = new Set(scoredEntityIds);
-              const msResults = this.miniSearch.search(trimmedQuery, {
-                filter: (r) => entityIdSet.has(r.entity_id),
-                combineWith: "OR"
-              });
-              const maxMsScore = Math.max(1, msResults[0]?.score ?? 1);
-              miniSearchScores = new Map(msResults.map((r) => [r.id, r.score / maxMsScore]));
-            }
-          }
-          if (candidateRows === null) {
-            usedEmbed = true;
-          } else {
-            const entityCacheKey = entityIds.length === 1 ? entityIds[0] : entityIds.join("\0");
-            let scored;
-            if (useRanker) {
-              const candidateRowsByEntity = /* @__PURE__ */ new Map();
-              for (const row of candidateRows) {
-                const rows = candidateRowsByEntity.get(row.entity_id) ?? [];
-                rows.push(row);
-                candidateRowsByEntity.set(row.entity_id, rows);
-              }
-              try {
-                const rankerResultsByEntity = await Promise.all(
-                  scoredEntityIds.filter((id) => (candidateRowsByEntity.get(id)?.length ?? 0) > 0).map(async (scopedEntityId) => {
-                    const rowsForEntity = candidateRowsByEntity.get(scopedEntityId) ?? [];
-                    const candidateIds = effectivePreFilterLimit !== void 0 ? rowsForEntity.map((row) => row.id) : void 0;
-                    const ranked = await this._rankWithVectorRanker({
-                      entityId: scopedEntityId,
-                      queryVec,
-                      candidateIds,
-                      candidateRows: rowsForEntity,
-                      weight,
-                      miniSearchScores,
-                      limit: Math.max(maxResults * 2, maxResults + 50)
-                    });
-                    return ranked.map((row) => ({ ...row, entity_id: scopedEntityId }));
-                  })
-                );
-                scored = rankerResultsByEntity.flat();
-                const scoredIds = new Set(scored.map((s) => s.id));
-                const metadataById = new Map(
-                  candidateRows.filter((row) => scoredIds.has(row.id)).map((row) => [row.id, row])
-                );
-                scored = scored.map((row) => {
-                  const metadata = metadataById.get(row.id);
-                  return {
-                    ...row,
-                    updated_at: metadata?.updated_at ?? null,
-                    access_count: metadata?.access_count ?? null
-                  };
-                });
-                const isHybrid = weight !== void 0 && weight < 1;
-                const maxBackfill = isHybrid ? maxResults : Math.max(0, maxResults - scored.length);
-                if (maxBackfill > 0) {
-                  if (isHybrid) {
-                    const topK = [];
-                    for (const row of candidateRows) {
-                      if (scoredIds.has(row.id)) continue;
-                      const kwScore = miniSearchScores?.get(row.id) ?? 0;
-                      const candidate = { row, kwScore };
-                      if (topK.length < maxBackfill) {
-                        let insertIdx = topK.length;
-                        for (let i = 0; i < topK.length; i++) {
-                          const cmp = this._compareScoredRows(
-                            {
-                              id: candidate.row.id,
-                              score: candidate.kwScore,
-                              updated_at: candidate.row.updated_at,
-                              access_count: candidate.row.access_count
-                            },
-                            {
-                              id: topK[i].row.id,
-                              score: topK[i].kwScore,
-                              updated_at: topK[i].row.updated_at,
-                              access_count: topK[i].row.access_count
-                            }
-                          );
-                          if (cmp < 0) {
-                            insertIdx = i;
-                            break;
-                          }
-                        }
-                        topK.splice(insertIdx, 0, candidate);
-                      } else {
-                        const cmpWorst = this._compareScoredRows(
-                          {
-                            id: candidate.row.id,
-                            score: candidate.kwScore,
-                            updated_at: candidate.row.updated_at,
-                            access_count: candidate.row.access_count
-                          },
-                          {
-                            id: topK[maxBackfill - 1].row.id,
-                            score: topK[maxBackfill - 1].kwScore,
-                            updated_at: topK[maxBackfill - 1].row.updated_at,
-                            access_count: topK[maxBackfill - 1].row.access_count
-                          }
-                        );
-                        if (cmpWorst < 0) {
-                          let insertIdx = maxBackfill - 1;
-                          for (let i = 0; i < topK.length; i++) {
-                            const cmp = this._compareScoredRows(
-                              {
-                                id: candidate.row.id,
-                                score: candidate.kwScore,
-                                updated_at: candidate.row.updated_at,
-                                access_count: candidate.row.access_count
-                              },
-                              {
-                                id: topK[i].row.id,
-                                score: topK[i].kwScore,
-                                updated_at: topK[i].row.updated_at,
-                                access_count: topK[i].row.access_count
-                              }
-                            );
-                            if (cmp < 0) {
-                              insertIdx = i;
-                              break;
-                            }
-                          }
-                          topK.splice(insertIdx, 0, candidate);
-                          topK.pop();
-                        }
-                      }
-                    }
-                    for (const { row, kwScore } of topK) {
-                      scored.push({
-                        id: row.id,
-                        entity_id: row.entity_id,
-                        score: (1 - weight) * kwScore,
-                        updated_at: row.updated_at,
-                        access_count: row.access_count
-                      });
-                    }
-                  } else {
-                    const omitted = [];
-                    for (const row of candidateRows) {
-                      if (scoredIds.has(row.id)) continue;
-                      omitted.push({ id: row.id, entity_id: row.entity_id, score: -2, updated_at: row.updated_at, access_count: row.access_count });
-                    }
-                    if (omitted.length > 0) {
-                      this._tieBreakSort(omitted);
-                      scored.push(...omitted.slice(0, maxBackfill));
-                    }
-                  }
-                }
-              } catch (rankerErr) {
-                const rankerError = rankerErr instanceof Error ? rankerErr : new Error(String(rankerErr));
-                const policy = this.options.vectorRankerFallback ?? "js-cosine";
-                this.options.onVectorRankerFallback?.({
-                  error: this._sanitizeRankerError(rankerError),
-                  policy
-                });
-                if (policy === "throw") {
-                  rankerShouldRethrow = true;
-                  throw rankerError;
-                } else if (policy === "js-cosine") {
-                  let fallbackRows = candidateRows;
-                  if (fallbackRows && fallbackRows.length > 0 && !("embedding_blob" in fallbackRows[0])) {
-                    const rowIds = fallbackRows.map((r) => r.id);
-                    const embeddingsMap = /* @__PURE__ */ new Map();
-                    const chunkSize = 500;
-                    for (let i = 0; i < rowIds.length; i += chunkSize) {
-                      const idChunk = rowIds.slice(i, i + chunkSize);
-                      const placeholders = idChunk.map(() => "?").join(",");
-                      const embeddingRows = await this.db.getAllAsync(
-                        `SELECT id, embedding_blob, embedding FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
-                        idChunk
-                      );
-                      for (const row of embeddingRows) {
-                        embeddingsMap.set(row.id, { embedding_blob: row.embedding_blob, embedding: row.embedding });
-                      }
-                    }
-                    fallbackRows = fallbackRows.map((r) => ({
-                      ...r,
-                      embedding_blob: embeddingsMap.get(r.id)?.embedding_blob ?? null,
-                      embedding: embeddingsMap.get(r.id)?.embedding ?? null
-                    }));
-                  }
-                  scored = await this._rankWithJsCosine({
-                    entityId: entityCacheKey,
-                    queryVec,
-                    candidateRows: fallbackRows,
-                    weight,
-                    miniSearchScores,
-                    populateCache,
-                    limit: fallbackRows.length,
-                    skipSort: true
-                    // read() re-sorts after applying tier weights
-                  });
-                } else if (policy === "keyword") {
-                  const scoredEntityIdSet = new Set(scoredEntityIds);
-                  const msResults = this.miniSearch.search(trimmedQuery, {
-                    filter: (r) => scoredEntityIdSet.has(r.entity_id),
-                    combineWith: "OR"
-                  });
-                  const keywordOversampledLimit = Math.max(maxResults * 2, maxResults + 50);
-                  const topResults = msResults.slice(0, keywordOversampledLimit);
-                  const topResultIds = new Set(topResults.map((r) => r.id));
-                  const candidateMap = new Map(candidateRows.filter((r) => topResultIds.has(r.id)).map((row) => [row.id, row]));
-                  scored = topResults.map((result) => {
-                    const metadata = candidateMap.get(result.id);
-                    const entityForScore = metadata?.entity_id ?? result.entity_id ?? "";
-                    return {
-                      id: result.id,
-                      entity_id: entityForScore,
-                      score: result.score ?? 0,
-                      access_count: metadata?.access_count ?? null,
-                      updated_at: metadata?.updated_at ?? null
-                    };
-                  });
-                } else {
-                  scored = [];
-                }
-                if (this.options.propagateRankerFailureToRetrievalFallback) {
-                  const mirrored = new Error("Vector ranker failed, falling back", {
-                    cause: this._sanitizeRankerError(rankerErr)
-                  });
-                  pendingRankerFallbackError = mirrored;
-                }
-              }
-            } else {
-              const jsCosineNeedsTierSort = sanitizedTierWeights !== void 0 && Object.values(sanitizedTierWeights).some((w) => w !== 1);
-              scored = await this._rankWithJsCosine({
-                entityId: entityCacheKey,
-                queryVec,
-                candidateRows,
-                weight,
-                miniSearchScores,
-                populateCache,
-                limit: jsCosineNeedsTierSort ? candidateRows.length : maxResults,
-                skipSort: jsCosineNeedsTierSort
-                // read() re-sorts after applying tier weights
-              });
-            }
-            if (scored.length > 0) {
-              scored = scored.map((row) => ({
-                ...row,
-                score: applyTierWeight(row.score, row.entity_id, sanitizedTierWeights)
-              }));
-              this._tieBreakSort(scored);
-              const selectedScored = scored.slice(0, maxResults);
-              const topIds = selectedScored.map((s) => s.id);
-              if (exposeMetadata && trimmedQuery) {
-                scoreByFactId = new Map(selectedScored.map((s) => [s.id, Number.isFinite(s.score) ? s.score : 0]));
-              }
-              if (topIds.length > 0) {
-                const facts2 = await this._hydrateFactsByIds(topIds, entityIds);
-                if (facts2.length < topIds.length) {
-                  const hydrationById = new Set(facts2.map((f) => f.id));
-                  const missingIds = topIds.filter((id) => !hydrationById.has(id));
-                  const missingCount = missingIds.length;
-                  const sample = missingIds.slice(0, 5);
-                  const sampleSuffix = sample.length > 0 ? ` Missing ID sample: ${sample.join(", ")}${missingIds.length > sample.length ? ", ..." : ""}.` : "";
-                  const error = new Error(
-                    `Phase 2 fact hydration returned ${missingCount} fewer row(s) than ranked IDs. Rows may have been concurrently soft-deleted or filtered by deleted_at during hydration, or vector ranker output may include IDs that do not exist in requested entities.` + sampleSuffix
-                  );
-                  this.options.onRetrievalFallback?.(error);
-                }
-                facts = facts2;
-              }
-              if (pendingRankerFallbackError) {
-                this.options.onRetrievalFallback?.(pendingRankerFallbackError);
-                pendingRankerFallbackError = void 0;
-              }
-              usedEmbed = true;
-            } else {
-              if (pendingRankerFallbackError) {
-                this.options.onRetrievalFallback?.(pendingRankerFallbackError);
-                pendingRankerFallbackError = void 0;
-              }
-              usedEmbed = true;
-            }
-          }
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
-          if (rankerShouldRethrow) {
-            throw error;
-          }
-          if (pendingRankerFallbackError) {
-            error.cause = pendingRankerFallbackError;
-            pendingRankerFallbackError = void 0;
-          }
-          this.options.onRetrievalFallback?.(error);
-        }
-      }
-      if (!usedEmbed && scoredEntityIds.length > 0) {
-        const fallbackEntityIdSet = new Set(scoredEntityIds);
-        const fallbackOversampledLimit = Math.max(maxResults * 2, maxResults + 50);
-        const results = this.miniSearch.search(trimmedQuery, {
-          filter: (r) => fallbackEntityIdSet.has(r.entity_id),
-          combineWith: "OR"
-        });
-        const candidates = results.slice(0, fallbackOversampledLimit).map((r) => ({
-          id: r.id,
-          entity_id: r.entity_id,
-          score: applyTierWeight(r.score ?? 0, r.entity_id, sanitizedTierWeights),
-          updated_at: null,
-          access_count: null
-        }));
-        this._tieBreakSort(candidates);
-        const topCandidates = candidates.slice(0, maxResults);
-        const topIds = topCandidates.map((c) => c.id);
-        if (topIds.length > 0) {
-          facts = await this._hydrateFactsByIds(topIds, entityIds);
-          if (exposeMetadata) {
-            scoreByFactId = new Map(topCandidates.map((c) => [c.id, Number.isFinite(c.score) ? c.score : 0]));
-          }
-        }
-      }
-      if (facts.length > 0) {
-        const ids = facts.map((f) => f.id);
-        const now = Date.now();
-        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 {
-      const entityScope = this._entityInClause(entityIds);
-      const rawFacts = await this.db.getAllAsync(
-        `SELECT * FROM ${this.prefix}entries
-         WHERE ${entityScope.clause} AND deleted_at IS NULL
-         ORDER BY updated_at DESC
-         LIMIT ?`,
-        [...entityScope.params, maxResults]
+  async findEmbeddingsByIds(ids, tx) {
+    if (ids.length === 0) return [];
+    const executor = this.getExecutor(tx);
+    const rows = [];
+    for (let i = 0; i < ids.length; i += this.chunkSize) {
+      const chunk = ids.slice(i, i + this.chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      const chunkRows = await executor.getAllAsync(
+        `SELECT id, embedding_blob, embedding FROM ${this.prefix}entries WHERE id IN (${placeholders}) AND deleted_at IS NULL`,
+        chunk
       );
-      facts = rawFacts.map((f) => {
-        const { embedding: _embedding, embedding_blob: _blob, ...rest } = f;
-        return {
-          ...rest,
-          tags: (() => {
-            if (Array.isArray(rest.tags)) return rest.tags;
-            try {
-              const p = JSON.parse(rest.tags);
-              return Array.isArray(p) ? p : [];
-            } catch {
-              return [];
-            }
-          })()
-        };
-      });
-    }
-    const [tasks, events] = await Promise.all([
-      (async () => {
-        const entityScope = this._entityInClause(entityIds);
-        const tasksLimit = entityIds.length === 1 ? void 0 : Math.min(20 * entityIds.length, 200);
-        return this.db.getAllAsync(
-          `SELECT * FROM ${this.prefix}tasks
-           WHERE ${entityScope.clause} AND status IN ('pending', 'in_progress') AND deleted_at IS NULL
-           ORDER BY priority DESC, created_at ASC${tasksLimit !== void 0 ? "\n           LIMIT ?" : ""}`,
-          tasksLimit !== void 0 ? [...entityScope.params, tasksLimit] : entityScope.params
-        );
-      })(),
-      (async () => {
-        const entityScope = this._entityInClause(entityIds);
-        const eventsLimit = Math.min(10 * entityIds.length, 100);
-        return this.db.getAllAsync(
-          `SELECT * FROM ${this.prefix}events
-           WHERE ${entityScope.clause}
-           ORDER BY created_at DESC
-           LIMIT ?`,
-          [...entityScope.params, eventsLimit]
-        );
-      })()
-    ]);
-    let factScores;
-    if (exposeMetadata && trimmedQuery && scoreByFactId) {
-      factScores = Object.fromEntries(facts.map((fact) => [fact.id, scoreByFactId.get(fact.id) ?? 0]));
+      rows.push(...chunkRows);
     }
-    const bundle = { facts, tasks, events: events.reverse() };
-    if (exposeMetadata) {
-      bundle.metadata = { query, entityIds };
-      if (sanitizedTierWeights && Object.keys(sanitizedTierWeights).length > 0) bundle.metadata.tierWeights = sanitizedTierWeights;
-      if (factScores && Object.keys(factScores).length > 0) bundle.factScores = factScores;
+    return rows;
+  }
+  async trackAccess(ids, now, tx) {
+    if (ids.length === 0) return;
+    const executor = this.getExecutor(tx);
+    for (let i = 0; i < ids.length; i += this.chunkSize) {
+      const chunk = ids.slice(i, i + this.chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      await executor.runAsync(
+        `UPDATE ${this.prefix}entries SET access_count = access_count + 1, last_accessed_at = ? WHERE id IN (${placeholders})`,
+        [now, ...chunk]
+      );
     }
-    return bundle;
   }
-  /**
-   * Returns entity IDs that will participate in scored retrieval.
-   * Excludes zero-weight entities unless includeZeroWeightEntities is true.
-   */
-  _filterScoredEntities(entityIds, sanitizedTierWeights, includeZeroWeightEntities) {
-    return entityIds.filter((id) => {
-      const w = sanitizedTierWeights?.[id] ?? 1;
-      return includeZeroWeightEntities === true || w !== 0;
-    });
+  getLegacyMigrationSQL() {
+    return [
+      `-- Migrate legacy source_type values (targets your WikiMemory prefix: ${this.prefix})`,
+      `UPDATE ${this.prefix}entries SET source_type = 'immutable_document' WHERE source_type = 'user_document';`,
+      `UPDATE ${this.prefix}entries SET source_type = 'librarian_inferred' WHERE source_type = 'agent_inferred';`
+    ].join("\n");
   }
-  /**
-   * Stable tie-break sort: score desc → access_count desc → updated_at desc → id asc.
-   */
-  _tieBreakSort(items) {
-    items.sort((a, b) => this._compareScoredRows(a, b));
+  async findRecentByEntityIds(entityIds, limit, tx) {
+    if (entityIds.length === 0) return [];
+    const executor = this.getExecutor(tx);
+    const placeholders = entityIds.map(() => "?").join(",");
+    const rows = await executor.getAllAsync(
+      `SELECT * FROM ${this.prefix}entries WHERE entity_id IN (${placeholders}) AND deleted_at IS NULL ORDER BY updated_at DESC LIMIT ?`,
+      [...entityIds, limit]
+    );
+    return rows.map(mapRowToFact);
   }
+};
+
+// src/repositories/OutboxRepository.ts
+var OutboxRepository = class extends BaseRepository {
   /**
-   * Comparator for score + deterministic tie-break fields.
-   * Negative return means "a ranks ahead of b" for descending score order.
+   * Insert a new outbox event within the provided transaction.
+   * `tx` is required — callers must always pass the active transaction
+   * so the write is atomic with the main table mutation.
    */
-  _compareScoredRows(a, b) {
-    const scoreDiff = b.score - a.score;
-    if (!Number.isNaN(scoreDiff) && scoreDiff !== 0) return scoreDiff;
-    const accessCountDiff = (b.access_count ?? 0) - (a.access_count ?? 0);
-    if (accessCountDiff !== 0) return accessCountDiff;
-    const updatedAtDiff = (b.updated_at ?? 0) - (a.updated_at ?? 0);
-    if (updatedAtDiff !== 0) return updatedAtDiff;
-    return a.id.localeCompare(b.id);
+  async push(params, tx) {
+    const executor = this.getExecutor(tx);
+    const id = generateId("out_");
+    const now = Date.now();
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}outbox (id, entity_id, table_name, record_id, operation, payload, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [id, params.entityId, params.tableName, params.recordId, params.operation, JSON.stringify(params.payload), now]
+    );
   }
   /**
-   * Build SQL IN clause with placeholders for multiple entity IDs.
+   * Fetch pending outbox rows ordered by created_at ASC.
+   * Reads directly from `this.db` (not a transaction).
    */
-  _entityInClause(entityIds) {
-    if (entityIds.length === 0) return { clause: "1=0", params: [] };
-    const placeholders = entityIds.map(() => "?").join(",");
-    return { clause: `entity_id IN (${placeholders})`, params: [...entityIds] };
+  async fetchPending(limit = 50) {
+    return this.db.getAllAsync(
+      `SELECT * FROM ${this.prefix}outbox ORDER BY created_at ASC LIMIT ?`,
+      [limit]
+    );
   }
   /**
-   * Hydrate full facts by ID. Pass scopedEntityIds to restrict to requested namespaces in SQL
-   * (defense-in-depth against a rogue VectorRanker returning cross-entity IDs).
+   * Delete acknowledged outbox rows by their IDs.
+   * No-op when `ids` is empty.
+   * Deletes directly from `this.db` (not a transaction).
    */
-  async _hydrateFactsByIds(ids, scopedEntityIds, tx) {
-    return this.entryRepo.findByIds(ids, scopedEntityIds, tx);
+  async acknowledge(ids) {
+    if (ids.length === 0) return;
+    const placeholders = ids.map(() => "?").join(", ");
+    await this.db.runAsync(
+      `DELETE FROM ${this.prefix}outbox WHERE id IN (${placeholders})`,
+      ids
+    );
+  }
+};
+
+// src/repositories/TaskRepository.ts
+function mapRowToTask(row) {
+  return {
+    id: row.id,
+    entity_id: row.entity_id,
+    description: row.description,
+    status: row.status,
+    priority: Number(row.priority),
+    created_at: Number(row.created_at),
+    updated_at: Number(row.updated_at),
+    resolved_at: row.resolved_at != null ? Number(row.resolved_at) : null,
+    deleted_at: row.deleted_at != null ? Number(row.deleted_at) : null
+  };
+}
+var TaskRepository = class extends BaseRepository {
+  constructor(db, prefix, outbox) {
+    super(db, prefix);
+    this.outbox = outbox;
   }
   /**
-   * Strip potentially sensitive data from ranker errors before exposing to host callbacks.
-   * Preserves error type for debugging but removes message/stack that may contain credentials.
-   * Recursively sanitizes one level of .cause; deeper chains collapse to type only.
+   * Fetch a single task by ID. Returns null if not found or soft-deleted.
    */
-  _sanitizeRankerError(err) {
-    if (this.options.sanitizeRankerErrors === false) {
-      return err instanceof Error ? err : new Error(String(err));
-    }
-    const typeName = err instanceof Error ? err.constructor?.name ?? "Error" : typeof err;
-    const innerCause = err instanceof Error && err.cause !== void 0 ? new Error(`Caused by: ${err.cause?.constructor?.name ?? typeof err.cause}`) : void 0;
-    const sanitized = new Error(
-      `VectorRanker ${typeName} (message scrubbed for security)`,
-      innerCause ? { cause: innerCause } : void 0
+  async findById(id) {
+    const row = await this.db.getFirstAsync(
+      `SELECT * FROM ${this.prefix}tasks WHERE id = ? AND deleted_at IS NULL`,
+      [id]
     );
-    sanitized.name = typeName;
-    return sanitized;
+    return row ? mapRowToTask(row) : null;
   }
   /**
-   * Score candidate rows using in-process JS cosine similarity.
-   * Applies hybrid blending (if weight set) and tie-break sorting before returning.
+   * Fetch all pending/in_progress tasks for the given entity IDs.
+   * Returns empty array when entityIds is empty.
    */
-  async _rankWithJsCosine(args) {
-    const queryVec = args.queryVec instanceof Float32Array ? args.queryVec.slice() : Array.from(args.queryVec);
-    const { entityId, candidateRows, weight, miniSearchScores, populateCache, limit, skipSort } = args;
-    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 canCache = populateCache && !tooLarge;
-    if (canCache && !entityCache) {
-      entityCache = /* @__PURE__ */ new Map();
-    }
-    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 {
-        id: row.id,
-        entity_id: row.entity_id,
-        score,
-        updated_at: row.updated_at,
-        access_count: row.access_count
-      };
-    });
-    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);
-      }
+  async findAllPending(entityIds, limit) {
+    if (entityIds.length === 0) return [];
+    const placeholders = entityIds.map(() => "?").join(", ");
+    const sql = `SELECT * FROM ${this.prefix}tasks WHERE entity_id IN (${placeholders}) AND status IN ('pending', 'in_progress') AND deleted_at IS NULL ORDER BY priority DESC, created_at ASC` + (limit != null ? ` LIMIT ?` : "");
+    const params = limit != null ? [...entityIds, limit] : [...entityIds];
+    const rows = await this.db.getAllAsync(sql, params);
+    return rows.map(mapRowToTask);
+  }
+  async findExistingMetadataByIds(ids, tx) {
+    const executor = this.getExecutor(tx);
+    const rows = [];
+    const chunkSize = 500;
+    for (let i = 0; i < ids.length; i += chunkSize) {
+      const chunk = ids.slice(i, i + chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      const chunkRows = await executor.getAllAsync(
+        `SELECT id, entity_id, updated_at FROM ${this.prefix}tasks WHERE id IN (${placeholders})`,
+        chunk
+      );
+      rows.push(...chunkRows.map((row) => ({ id: row.id, entity_id: row.entity_id, updated_at: Number(row.updated_at) })));
     }
-    if (!skipSort) this._tieBreakSort(scored);
-    return scored.slice(0, limit);
+    return rows;
   }
   /**
-   * Delegate semantic ranking to the injected VectorRanker.
-   * Caller should pass an oversampledLimit to preserve recall after re-ranking.
-   * Returns scored results ready for hybrid blending and tie-break sorting.
+   * Upsert a WikiTask within the provided transaction.
+   * Uses ON CONFLICT(id) DO UPDATE (not INSERT OR REPLACE).
+   * Stages an outbox entry in the same transaction.
+   * `tx` is REQUIRED.
    */
-  async _rankWithVectorRanker(args) {
-    const { entityId, candidateIds, candidateRows, weight, miniSearchScores, limit } = args;
-    const ranker = this.options.vectorRanker;
-    if (!ranker) {
-      throw new Error("vectorRanker not configured");
-    }
-    const queryVecCopy = args.queryVec instanceof Float32Array ? args.queryVec.slice() : Array.from(args.queryVec);
-    const rankerResults = await ranker.rankBySimilarity({
-      entityId,
-      queryVec: queryVecCopy,
-      candidateIds,
-      limit
-    });
-    const allowedIds = new Set(candidateRows.map((row) => row.id));
-    const seen = /* @__PURE__ */ new Set();
-    const normalized = [];
-    for (const r of rankerResults) {
-      if (normalized.length >= limit) break;
-      if (seen.has(r.id)) continue;
-      if (allowedIds && !allowedIds.has(r.id)) continue;
-      if (!Number.isFinite(r.semanticScore)) continue;
-      seen.add(r.id);
-      normalized.push(r);
-    }
-    const entityIdByCandidateId = new Map(candidateRows.map((row) => [row.id, row.entity_id]));
-    const scored = normalized.map((r) => {
-      let score = r.semanticScore;
-      if (weight !== void 0) {
-        const kwScore = miniSearchScores?.get(r.id) ?? 0;
-        score = weight * Math.max(0, r.semanticScore) + (1 - weight) * kwScore;
-      }
-      return {
-        id: r.id,
-        entity_id: entityIdByCandidateId.get(r.id),
-        // allowedIds filter above guarantees membership
-        score
-      };
-    });
-    return scored;
+  async upsert(task, tx, updatedAt) {
+    const executor = this.getExecutor(tx);
+    const now = Number.isFinite(updatedAt) ? updatedAt : Date.now();
+    const existingRow = await executor.getFirstAsync(
+      `SELECT id FROM ${this.prefix}tasks WHERE id = ?`,
+      [task.id]
+    );
+    const operation = task.deleted_at != null ? "DELETE" : existingRow ? "UPDATE" : "INSERT";
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}tasks (
+        id, entity_id, description, status, priority,
+        created_at, updated_at, resolved_at, deleted_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        entity_id = excluded.entity_id,
+        description = excluded.description,
+        status = excluded.status,
+        priority = excluded.priority,
+        updated_at = excluded.updated_at,
+        resolved_at = excluded.resolved_at,
+        deleted_at = excluded.deleted_at`,
+      [
+        task.id,
+        task.entity_id,
+        task.description,
+        task.status,
+        task.priority,
+        task.created_at,
+        now,
+        // updated_at set by repo or import override
+        task.resolved_at ?? null,
+        task.deleted_at ?? null
+      ]
+    );
+    await this.outbox.push(
+      {
+        entityId: task.entity_id,
+        tableName: "tasks",
+        recordId: task.id,
+        operation,
+        payload: task
+      },
+      tx
+    );
   }
-  async getMemoryBundle(entityId) {
-    return this._getFullBundle(entityId, { maxEvents: 10 });
+  async upsertForImport(task, tx, updatedAt) {
+    const executor = this.getExecutor(tx);
+    const now = Number.isFinite(updatedAt) ? updatedAt : Date.now();
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}tasks (
+        id, entity_id, description, status, priority,
+        created_at, updated_at, resolved_at, deleted_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        entity_id = excluded.entity_id,
+        description = excluded.description,
+        status = excluded.status,
+        priority = excluded.priority,
+        updated_at = excluded.updated_at,
+        resolved_at = excluded.resolved_at,
+        deleted_at = excluded.deleted_at`,
+      [
+        task.id,
+        task.entity_id,
+        task.description,
+        task.status,
+        task.priority,
+        task.created_at,
+        now,
+        task.resolved_at ?? null,
+        task.deleted_at ?? null
+      ]
+    );
   }
-  async write(entityId, event) {
-    const id = generateId("evt_");
+  /**
+   * Soft-delete a task by ID. Sets deleted_at and updated_at.
+   * Stages a DELETE outbox entry in the same transaction.
+   * `tx` is REQUIRED.
+   */
+  async softDelete(id, entityId, tx) {
+    const executor = this.getExecutor(tx);
     const now = Date.now();
-    let eventType = event.event_type;
-    if (!["observation", "decision", "action", "outcome"].includes(eventType)) {
-      eventType = "observation";
-    }
-    await this.db.runAsync(`
-      INSERT INTO ${this.prefix}events (id, entity_id, event_type, summary, related_entry_id, created_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `, [id, entityId, eventType, event.summary, event.related_entry_id || null, now]);
-    const threshold = this.options.config?.autoLibrarianThreshold || 20;
-    const [row, cp] = await Promise.all([
-      this.db.getFirstAsync(`SELECT COUNT(*) as count FROM ${this.prefix}events WHERE entity_id = ?`, [entityId]),
-      this.db.getFirstAsync(`SELECT * FROM ${this.prefix}checkpoints WHERE entity_id = ?`, [entityId])
-    ]);
-    const count = row?.count || 0;
-    let memoryCheckpoint = cp?.memory_checkpoint || 0;
-    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)) && !this._isReembedActive(entityId) && !this._isImportActiveFor(entityId) && !this._isForgetActiveFor(entityId)) {
-        this.activeMaintenanceJobs.add(jobKey);
-        this._notifyStatusSubscribers(entityId);
-        this.runLibrarianThenMaybeHeal(entityId, count).catch(console.error).finally(() => {
-          this.activeMaintenanceJobs.delete(jobKey);
-          this._notifyStatusSubscribers(entityId);
-        });
-      }
-    }
-  }
-  async runLibrarianThenMaybeHeal(entityId, currentEventCount) {
-    await this._doRunLibrarian(entityId);
-    await this.db.runAsync(`
-      INSERT INTO ${this.prefix}checkpoints (entity_id, memory_checkpoint) 
-      VALUES (?, ?) 
-      ON CONFLICT(entity_id) DO UPDATE SET memory_checkpoint = ?
-    `, [entityId, currentEventCount, currentEventCount]);
-    const autoHealThreshold = this.options.config?.autoHealThreshold || 100;
-    const cp = await this.db.getFirstAsync(`SELECT * FROM ${this.prefix}checkpoints WHERE entity_id = ?`, [entityId]);
-    let healCheckpoint = cp?.heal_checkpoint || 0;
-    if (healCheckpoint > currentEventCount) healCheckpoint = 0;
-    if (currentEventCount - healCheckpoint >= autoHealThreshold) {
-      const healKey = this._healKey(entityId);
-      if (!this.activeMaintenanceJobs.has(healKey)) {
-        this.activeMaintenanceJobs.add(healKey);
-        this._notifyStatusSubscribers(entityId);
-        try {
-          await this._doRunHeal(entityId);
-          await this.db.runAsync(`
-            INSERT INTO ${this.prefix}checkpoints (entity_id, heal_checkpoint) 
-            VALUES (?, ?) 
-            ON CONFLICT(entity_id) DO UPDATE SET heal_checkpoint = ?
-          `, [entityId, currentEventCount, currentEventCount]);
-        } finally {
-          this.activeMaintenanceJobs.delete(healKey);
-          this._notifyStatusSubscribers(entityId);
-        }
-      }
-    }
+    await executor.runAsync(
+      `UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`,
+      [now, now, id, entityId]
+    );
+    await this.outbox.push(
+      {
+        entityId,
+        tableName: "tasks",
+        recordId: id,
+        operation: "DELETE",
+        payload: { id, entity_id: entityId, deleted_at: now }
+      },
+      tx
+    );
   }
-  async _doRunLibrarian(entityId) {
-    const events = await this.db.getAllAsync(`
-      SELECT * FROM ${this.prefix}events
-      WHERE entity_id = ?
-      ORDER BY created_at DESC
-      LIMIT 50
-    `, [entityId]);
-    const currentFactsRows = await this.db.getAllAsync(`
-      SELECT * FROM ${this.prefix}entries
-      WHERE entity_id = ? AND deleted_at IS NULL
-      ORDER BY updated_at DESC
-      LIMIT 100
-    `, [entityId]);
-    const currentFacts = currentFactsRows.map((f) => {
-      const { embedding: _embedding, embedding_blob: _blob, ...rest } = f;
-      return {
-        ...rest,
-        tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags
-      };
-    });
-    const userPrompt = `Events:
-${JSON.stringify(events.reverse(), null, 2)}
-
-Current Facts:
-${JSON.stringify(currentFacts, null, 2)}`;
-    const responseText = await this.options.llmProvider.generateText({
-      systemPrompt: LIBRARIAN_SYSTEM_PROMPT,
-      userPrompt
-    });
-    const result = parseJsonResponse(responseText);
-    const facts = Array.isArray(result.facts) ? result.facts : [];
-    const tasks = Array.isArray(result.tasks) ? result.tasks : [];
-    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);
-        let skip = false;
-        if (newTokens.size >= MIN_TOKENS_TO_QUALIFY) {
-          for (const existing of currentFactsRows) {
-            if (existing.source_type !== "librarian_inferred") continue;
-            const existingTokens = titleTokens(existing.title);
-            if (existingTokens.size >= MIN_TOKENS_TO_QUALIFY) {
-              if (jaccardScore(newTokens, existingTokens) >= FUZZY_THRESHOLD) {
-                skip = true;
-                break;
-              }
-            }
-          }
-        }
-        if (skip) continue;
-        const id = generateId("fact_");
-        await this.db.runAsync(`
-          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, "librarian_inferred", now, now]);
-        insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
-      }
-      for (const task of validTasks) {
-        const id = generateId("task_");
-        await this.db.runAsync(`
-          INSERT INTO ${this.prefix}tasks (id, entity_id, description, status, priority, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?)
-        `, [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);
+  /**
+   * Fetch all non-deleted tasks for an entity, ordered by priority DESC, created_at ASC.
+   * Used by _getFullBundle().
+   */
+  async findAllByEntityId(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const rows = await executor.getAllAsync(
+      `SELECT * FROM ${this.prefix}tasks WHERE entity_id = ? AND deleted_at IS NULL ORDER BY priority DESC, created_at ASC`,
+      [entityId]
+    );
+    return rows.map(mapRowToTask);
+  }
+  /**
+   * Bulk delete pruned tasks (already soft-deleted) by cutoff date.
+   * Used by runPrune(). Returns number of deleted rows.
+   */
+  async bulkDeletePruned(entityId, cutoff, tx) {
+    const executor = this.getExecutor(tx);
+    const rowsToDelete = await executor.getAllAsync(
+      `SELECT id, deleted_at FROM ${this.prefix}tasks WHERE entity_id = ? AND deleted_at IS NOT NULL AND deleted_at <= ?`,
+      [entityId, cutoff]
+    );
+    if (rowsToDelete.length === 0) return 0;
+    const result = await executor.runAsync(
+      `DELETE FROM ${this.prefix}tasks WHERE entity_id = ? AND deleted_at IS NOT NULL AND deleted_at <= ?`,
+      [entityId, cutoff]
+    );
+    for (const row of rowsToDelete) {
+      await this.outbox.push(
+        {
+          entityId,
+          tableName: "tasks",
+          recordId: row.id,
+          operation: "DELETE",
+          payload: { id: row.id, entity_id: entityId, deleted_at: row.deleted_at }
+        },
+        tx
+      );
     }
-    this.vectorCache.delete(entityId);
+    return result.changes;
   }
-  async _doRunHeal(entityId) {
+  /**
+   * Soft-delete a task by ID within a transaction.
+   * Stages a DELETE outbox entry in the same transaction.
+   * `tx` is REQUIRED.
+   */
+  async softDeleteById(id, entityId, tx) {
+    const executor = this.getExecutor(tx);
     const now = Date.now();
-    const orphanAfterDays = this.options.config?.orphanAfterDays !== void 0 ? this.options.config.orphanAfterDays : 30;
-    const staleInferredAfterDays = this.options.config?.staleInferredAfterDays !== void 0 ? this.options.config.staleInferredAfterDays : 60;
-    const MS_PER_DAY = 24 * 60 * 60 * 1e3;
-    if (orphanAfterDays !== null && (typeof orphanAfterDays !== "number" || !Number.isFinite(orphanAfterDays) || orphanAfterDays < 0)) {
-      throw new Error("Invalid orphanAfterDays: must be a finite number >= 0 or null");
+    const result = await executor.runAsync(
+      `UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`,
+      [now, now, id, entityId]
+    );
+    if (result.changes > 0) {
+      await this.outbox.push(
+        {
+          entityId,
+          tableName: "tasks",
+          recordId: id,
+          operation: "DELETE",
+          payload: { id, entity_id: entityId, deleted_at: now }
+        },
+        tx
+      );
     }
-    if (staleInferredAfterDays !== null && (typeof staleInferredAfterDays !== "number" || !Number.isFinite(staleInferredAfterDays) || staleInferredAfterDays < 0)) {
-      throw new Error("Invalid staleInferredAfterDays: must be a finite number >= 0 or null");
+    return result;
+  }
+  /**
+   * Bulk soft-delete all tasks for an entity.
+   * Stages DELETE outbox entries for each row in the same transaction.
+   * `tx` is REQUIRED.
+   */
+  async bulkSoftDeleteByEntityId(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const now = Date.now();
+    const idsToDelete = await executor.getAllAsync(
+      `SELECT id FROM ${this.prefix}tasks WHERE entity_id = ? AND deleted_at IS NULL`,
+      [entityId]
+    );
+    const result = await executor.runAsync(
+      `UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`,
+      [now, now, entityId]
+    );
+    for (const row of idsToDelete) {
+      await this.outbox.push({
+        entityId,
+        tableName: "tasks",
+        recordId: row.id,
+        operation: "DELETE",
+        payload: { id: row.id, entity_id: entityId, deleted_at: now }
+      }, tx);
     }
-    await this.db.withTransactionAsync(async () => {
-      if (orphanAfterDays !== null) {
-        const orphanThreshold = now - orphanAfterDays * MS_PER_DAY;
-        await this.db.runAsync(`
-          UPDATE ${this.prefix}entries
-          SET deleted_at = ?, updated_at = ?
-          WHERE entity_id = ? AND access_count = 0 AND created_at <= ? AND source_type != 'immutable_document' AND deleted_at IS NULL
-        `, [now, now, entityId, orphanThreshold]);
-      }
-      if (staleInferredAfterDays !== null) {
-        const staleThreshold = now - staleInferredAfterDays * MS_PER_DAY;
-        await this.db.runAsync(`
-          UPDATE ${this.prefix}entries
-          SET confidence = 'tentative', updated_at = ?
-          WHERE entity_id = ? AND confidence = 'inferred' AND (last_accessed_at <= ? OR (last_accessed_at IS NULL AND created_at <= ?)) AND source_type != 'immutable_document' AND deleted_at IS NULL
-        `, [now, entityId, staleThreshold, staleThreshold]);
-      }
-    });
-    const allFactsRows = await this.db.getAllAsync(`SELECT * FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL`, [entityId]);
-    const allTasks = await this.db.getAllAsync(`SELECT * FROM ${this.prefix}tasks WHERE entity_id = ? AND status IN ('pending', 'in_progress') AND deleted_at IS NULL`, [entityId]);
-    const recentEvents = await this.db.getAllAsync(`SELECT * FROM ${this.prefix}events WHERE entity_id = ? ORDER BY created_at DESC LIMIT 20`, [entityId]);
-    const healCandidates = allFactsRows.filter((f) => f.source_type !== "immutable_document");
-    const documentAnchors = allFactsRows.filter((f) => f.source_type === "immutable_document").map(({ id, title, source_ref }) => ({ id, title, source_ref }));
-    const userPrompt = `Heal Candidates:
-${JSON.stringify(healCandidates.map((f) => {
-      const { embedding: _embedding, embedding_blob: _blob, ...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)}
-
-All Tasks:
-${JSON.stringify(allTasks, null, 2)}
-
-Recent Events:
-${JSON.stringify(recentEvents, null, 2)}
+    return result.changes;
+  }
+};
 
-The following document anchors are provided for contradiction detection only. Do not include them in \`downgraded\`, \`deleted\`, or \`newFacts\`.`;
-    const responseText = await this.options.llmProvider.generateText({
-      systemPrompt: HEAL_SYSTEM_PROMPT,
-      userPrompt
-    });
-    const result = parseJsonResponse(responseText);
-    const mutableIds = new Set(healCandidates.map((f) => f.id));
-    const downgraded = Array.isArray(result.downgraded) ? result.downgraded : [];
-    const deleted = Array.isArray(result.deleted) ? result.deleted : [];
-    const newFacts = Array.isArray(result.newFacts) ? result.newFacts : [];
-    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 = [];
-    const uniqueDeletedFactIds = Array.from(new Set(safeDeleted));
-    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]);
-      }
-      for (const id of safeDeleted) {
-        await this.db.runAsync(`UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ?`, [now, now, id, entityId]);
-      }
-      for (const fact of validNewFacts) {
-        const id = generateId("fact_");
-        await this.db.runAsync(`
-          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, "librarian_inferred", now, now]);
-        insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
-      }
-    });
-    this.vectorCache.delete(entityId);
-    await this.rebuildMiniSearchIndex(entityId);
-    for (const factId of uniqueDeletedFactIds) {
-      try {
-        await this._notifyEmbeddingPersisted(entityId, factId, null);
-      } catch (hookErr) {
-        console.warn(`[WikiMemory] onEmbeddingPersisted hook failed during heal for ${factId}:`, hookErr);
-      }
-    }
-    for (const fact of insertedFacts) {
-      await this.embedFact(fact);
-    }
-    this.vectorCache.delete(entityId);
+// src/repositories/EventRepository.ts
+var EventRepository = class extends BaseRepository {
+  /**
+   * Insert a new event row.
+   * Pass `tx` to participate in a caller-owned transaction; omit to run against the default db.
+   */
+  async add(event, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}events (id, entity_id, event_type, summary, related_entry_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [
+        event.id,
+        event.entity_id,
+        event.event_type,
+        event.summary,
+        event.related_entry_id ?? null,
+        event.created_at
+      ]
+    );
   }
-  async runLibrarian(entityId) {
-    const jobKey = this._librarianKey(entityId);
-    if (this.activeMaintenanceJobs.has(jobKey)) {
-      throw new WikiBusyError("librarian", entityId);
-    }
-    if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
-      throw new WikiBusyError("prune", entityId);
-    }
-    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);
-    this._notifyStatusSubscribers(entityId);
-    try {
-      await this._doRunLibrarian(entityId);
-    } finally {
-      this.activeMaintenanceJobs.delete(jobKey);
-      this._notifyStatusSubscribers(entityId);
-    }
+  async addIgnoreDuplicate(event, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `INSERT OR IGNORE INTO ${this.prefix}events (id, entity_id, event_type, summary, related_entry_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [
+        event.id,
+        event.entity_id,
+        event.event_type,
+        event.summary,
+        event.related_entry_id ?? null,
+        event.created_at
+      ]
+    );
   }
-  async runHeal(entityId) {
-    const jobKey = this._healKey(entityId);
-    if (this.activeMaintenanceJobs.has(jobKey)) {
-      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._isImportActiveFor(entityId)) {
-      throw new WikiBusyError("import", entityId);
-    }
-    if (this._isForgetActiveFor(entityId)) {
-      throw new WikiBusyError("forget", entityId);
-    }
-    this.activeMaintenanceJobs.add(jobKey);
-    this._notifyStatusSubscribers(entityId);
-    try {
-      await this._doRunHeal(entityId);
-    } finally {
-      this.activeMaintenanceJobs.delete(jobKey);
-      this._notifyStatusSubscribers(entityId);
-    }
+  /**
+   * Return the most recent events for an entity, newest first.
+   * Defaults to a limit of 50.
+   */
+  async getRecent(entityId, limit = 50) {
+    return this.db.getAllAsync(
+      `SELECT * FROM ${this.prefix}events WHERE entity_id = ? ORDER BY created_at DESC LIMIT ?`,
+      [entityId, limit]
+    );
   }
-  async runReembed(entityId, opts) {
-    const embedFn = this.options.llmProvider.embed;
-    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 ?? "*");
-    }
-    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);
-      }
-      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", "*");
-      }
-      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", "*");
-      }
-      if (this._isAnyMaintenanceActiveWithSuffix(":import")) {
-        throw new WikiBusyError("import", "*");
-      }
-      if (this._isAnyMaintenanceActiveWithSuffix(":forget")) {
-        throw new WikiBusyError("forget", "*");
-      }
-    }
-    this.activeMaintenanceJobs.add(reembedKey);
-    try {
-      const where = entityId ? `entity_id = ? AND deleted_at IS NULL` : `deleted_at IS NULL`;
-      const params = entityId ? [entityId] : [];
+  /**
+   * Return the most recent events for the given entity IDs, newest first.
+   * Defaults to a limit of 50.
+   */
+  async getRecentForEntities(entityIds, limit = 50) {
+    if (entityIds.length === 0) return [];
+    const placeholders = entityIds.map(() => "?").join(", ");
+    return this.db.getAllAsync(
+      `SELECT * FROM ${this.prefix}events WHERE entity_id IN (${placeholders}) ORDER BY created_at DESC LIMIT ?`,
+      [...entityIds, limit]
+    );
+  }
+  /**
+   * Delete events for an entity that were created at or before the given cutoff timestamp.
+   * Returns the number of deleted rows.
+   */
+  async prune(entityId, cutoff) {
+    return this.db.runAsync(
+      `DELETE FROM ${this.prefix}events WHERE entity_id = ? AND created_at <= ?`,
+      [entityId, cutoff]
+    );
+  }
+  /**
+   * Return the total number of events stored for an entity.
+   * `tx` is optional — pass an active transaction handle for atomic reads.
+   */
+  async count(entityId, tx) {
+    const executor = tx ?? this.db;
+    const row = await executor.getFirstAsync(
+      `SELECT COUNT(*) as count FROM ${this.prefix}events WHERE entity_id = ?`,
+      [entityId]
+    );
+    return row?.count ?? 0;
+  }
+  /**
+   * Return all events for an entity in chronological (ASC) order.
+   * When limit is provided, fetches newest-first then reverses to preserve chronological order.
+   */
+  async getByEntityId(entityId, limit) {
+    if (limit != null) {
       const rows = await this.db.getAllAsync(
-        `SELECT * FROM ${this.prefix}entries WHERE ${where}`,
-        params
+        `SELECT * FROM ${this.prefix}events WHERE entity_id = ? ORDER BY created_at DESC LIMIT ?`,
+        [entityId, limit]
       );
-      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;
-      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, failed };
-    } finally {
-      this.activeMaintenanceJobs.delete(reembedKey);
+      return rows.slice().reverse();
     }
+    return this.db.getAllAsync(
+      `SELECT * FROM ${this.prefix}events WHERE entity_id = ? ORDER BY created_at ASC`,
+      [entityId]
+    );
   }
-  getEntityStatus(entityId) {
-    const ingestPrefix = `${this.prefix}:${entityId}:`;
-    let ingesting = false;
-    for (const k of this.activeIngestJobs) {
-      if (k.startsWith(ingestPrefix)) {
-        ingesting = true;
-        break;
-      }
-    }
+};
+
+// src/repositories/MetadataRepository.ts
+var MetadataRepository = class extends BaseRepository {
+  // CHECKPOINTS TABLE METHODS
+  async getCheckpoint(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT memory_checkpoint, heal_checkpoint FROM ${this.prefix}checkpoints WHERE entity_id = ?`,
+      [entityId]
+    );
+    if (!row) return {};
     return {
-      ingesting,
-      librarian: this.activeMaintenanceJobs.has(this._librarianKey(entityId)),
-      heal: this.activeMaintenanceJobs.has(this._healKey(entityId))
+      memory: row.memory_checkpoint ?? void 0,
+      heal: row.heal_checkpoint ?? void 0
     };
   }
-  /**
-   * Subscribe to {@link EntityStatus} changes for a single entity. The callback
-   * is invoked synchronously once with the current status before this method
-   * returns, then again on every transition where any of `ingesting`,
-   * `librarian`, or `heal` flips. No polling, no duplicate snapshots.
-   *
-   * Returns an idempotent unsubscribe function.
-   *
-   * See also {@link getEntityStatus} for a synchronous point-in-time read.
-   */
-  subscribeEntityStatus(entityId, callback) {
-    const initial = this.getEntityStatus(entityId);
-    let set = this.statusSubscribers.get(entityId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.statusSubscribers.set(entityId, set);
+  async updateCheckpoint(entityId, updates, tx) {
+    const fields = [];
+    const values = [];
+    if (updates.memory !== void 0) {
+      fields.push("memory_checkpoint = ?");
+      values.push(updates.memory);
     }
-    const entry = { callback, last: this._copyEntityStatus(initial) };
-    set.add(entry);
-    try {
-      callback(this._copyEntityStatus(initial));
-    } catch (err) {
-      console.error(`[WikiMemory.subscribeEntityStatus] callback error for entityId="${entityId}" during initial emission`, err);
+    if (updates.heal !== void 0) {
+      fields.push("heal_checkpoint = ?");
+      values.push(updates.heal);
     }
-    let active = true;
-    return () => {
-      if (!active) return;
-      active = false;
-      const s = this.statusSubscribers.get(entityId);
-      if (!s) return;
-      s.delete(entry);
-      if (s.size === 0) this.statusSubscribers.delete(entityId);
-    };
+    if (fields.length === 0) return;
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}checkpoints (entity_id, memory_checkpoint, heal_checkpoint)
+       VALUES (?, ?, ?)
+       ON CONFLICT(entity_id) DO UPDATE SET ${fields.join(", ")}`,
+      [entityId, updates.memory ?? 0, updates.heal ?? 0, ...values]
+    );
   }
-  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`;
-    const eventsParams = maxEvents != null ? [entityId, maxEvents] : [entityId];
-    const [factsRaw, tasks, eventsRaw] = await Promise.all([
-      this.db.getAllAsync(
-        `SELECT * FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL ORDER BY updated_at DESC`,
-        [entityId]
-      ),
-      this.db.getAllAsync(
-        `SELECT * FROM ${this.prefix}tasks WHERE entity_id = ? AND deleted_at IS NULL ORDER BY priority DESC, created_at ASC`,
-        [entityId]
-      ),
-      this.db.getAllAsync(eventsQuery, eventsParams)
-    ]);
-    const facts = factsRaw.map((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 {
-        ...factBase,
-        tags: typeof factBase.tags === "string" ? JSON.parse(factBase.tags) : factBase.tags
-      };
-    });
-    const events = maxEvents != null ? eventsRaw.slice().reverse() : eventsRaw;
-    return { facts, tasks, events };
+  async deleteCheckpoint(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `DELETE FROM ${this.prefix}checkpoints WHERE entity_id = ?`,
+      [entityId]
+    );
   }
-  async exportDump(entityIds) {
-    let ids;
-    if (entityIds && entityIds.length > 0) {
-      ids = Array.from(new Set(entityIds));
-    } else {
-      const rows = await this.db.getAllAsync(`
-        SELECT DISTINCT entity_id FROM (
-          SELECT entity_id FROM ${this.prefix}entries WHERE deleted_at IS NULL
-          UNION
-          SELECT entity_id FROM ${this.prefix}tasks WHERE deleted_at IS NULL
-          UNION
-          SELECT entity_id FROM ${this.prefix}events
-        ) ORDER BY entity_id
-      `);
-      ids = rows.map((r) => r.entity_id);
-    }
-    const entities = {};
-    const BATCH = 3;
-    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, { includeBlobs: true })])
-      );
-      for (const [id, bundle] of batchResults) {
-        entities[id] = bundle;
-      }
+  // META TABLE METHODS
+  async getMeta(key, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT value FROM ${this.prefix}meta WHERE key = ?`,
+      [key]
+    );
+    return row ? row.value : null;
+  }
+  async setMeta(key, value, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}meta (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+      [key, value]
+    );
+  }
+  async clearDimensionMismatch(tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `DELETE FROM ${this.prefix}meta WHERE key = 'embedding_dimension_mismatch'`
+    );
+  }
+  async tableExists(tableName, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
+      [tableName]
+    );
+    return row != null;
+  }
+  async getTableDdl(tableName, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT sql FROM sqlite_master WHERE type='table' AND name=?`,
+      [tableName]
+    );
+    return row?.sql ?? null;
+  }
+  async vacuum() {
+    await this.db.execAsync(`PRAGMA wal_checkpoint(TRUNCATE)`);
+    await this.db.execAsync(`VACUUM`);
+  }
+  async getDistinctEntityIds(tx) {
+    const executor = this.getExecutor(tx);
+    const rows = await executor.getAllAsync(
+      `SELECT DISTINCT entity_id FROM (
+         SELECT entity_id FROM ${this.prefix}entries WHERE deleted_at IS NULL
+         UNION
+         SELECT entity_id FROM ${this.prefix}tasks WHERE deleted_at IS NULL
+         UNION
+         SELECT entity_id FROM ${this.prefix}events
+       ) ORDER BY entity_id`
+    );
+    return rows.map((r) => r.entity_id);
+  }
+};
+
+// src/WikiMemory.ts
+var _testAccessNonTestEnvWarned;
+var WikiMemory = class {
+  constructor(db, options) {
+    /** Emits `__testAccess` console warning at most once per instance when NODE_ENV ≠ "test". */
+    __privateAdd(this, _testAccessNonTestEnvWarned, false);
+    this.db = db;
+    this.options = options;
+    this.prefix = options.config?.tablePrefix || "llm_wiki_";
+    this.outboxRepo = new OutboxRepository(db, this.prefix);
+    this.entryRepo = new EntryRepository(db, this.prefix, this.outboxRepo);
+    this.taskRepo = new TaskRepository(db, this.prefix, this.outboxRepo);
+    this.eventRepo = new EventRepository(db, this.prefix);
+    this.metadataRepo = new MetadataRepository(db, this.prefix);
+    this.embeddingService = new EmbeddingService(this.db, this.options, this.entryRepo, this.metadataRepo);
+    this.searchService = new SearchService(this.entryRepo);
+    this.jobManager = new JobManager(this.prefix);
+    this.promptService = new PromptService(options.config?.prompts);
+    this.ingestionService = new IngestionService(
+      this.db,
+      this.prefix,
+      this.options,
+      this.entryRepo,
+      this.searchService,
+      this.jobManager,
+      this.embeddingService,
+      this.promptService
+    );
+    this.maintenanceService = new MaintenanceService(
+      this.db,
+      this.prefix,
+      this.options,
+      this.entryRepo,
+      this.taskRepo,
+      this.eventRepo,
+      this.metadataRepo,
+      this.searchService,
+      this.jobManager,
+      this.embeddingService,
+      this.promptService
+    );
+    this.importExportService = new ImportExportService(
+      this.db,
+      this.entryRepo,
+      this.taskRepo,
+      this.eventRepo,
+      this.metadataRepo,
+      this.searchService,
+      this.jobManager,
+      this.embeddingService
+    );
+    this.retrievalService = new RetrievalService(
+      this.options,
+      this.entryRepo,
+      this.taskRepo,
+      this.eventRepo,
+      this.metadataRepo,
+      this.searchService
+    );
+    this.writeService = new WriteService(
+      this.db,
+      this.options,
+      this.eventRepo,
+      this.metadataRepo,
+      this.jobManager,
+      this.maintenanceService
+    );
+  }
+  /**
+   * Explicit escape hatch for test suites: typed access to composed services for mocks/spies.
+   * If `NODE_ENV` is not `"test"`, emits a single `console.warn` per instance (skipped when `process` is undefined).
+   */
+  get __testAccess() {
+    const processEnv = typeof globalThis !== "undefined" ? globalThis.process?.env : void 0;
+    if (processEnv !== void 0 && processEnv.NODE_ENV !== "test" && !__privateGet(this, _testAccessNonTestEnvWarned)) {
+      __privateSet(this, _testAccessNonTestEnvWarned, true);
+      console.warn('Warning: WikiMemory.__testAccess is intended for tests (NODE_ENV !== "test").');
     }
-    return { generatedAt: Date.now(), entities };
+    return {
+      embeddingService: this.embeddingService,
+      importExportService: this.importExportService,
+      ingestionService: this.ingestionService,
+      maintenanceService: this.maintenanceService,
+      retrievalService: this.retrievalService,
+      searchService: this.searchService,
+      writeService: this.writeService,
+      promptService: this.promptService,
+      entryRepo: this.entryRepo,
+      metadataRepo: this.metadataRepo,
+      jobManager: this.jobManager
+    };
   }
-  async importDump(dump, opts) {
-    const merge = opts?.merge ?? false;
-    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);
+  async setup() {
+    const entriesExistedBeforeSetup = await this.metadataRepo.tableExists(`${this.prefix}entries`);
+    await setupDatabase(this.db, this.prefix);
+    let currentVersion;
+    if (!entriesExistedBeforeSetup) {
+      await this.metadataRepo.setMeta("schema_version", String(CURRENT_SCHEMA_VERSION), this.db);
+      currentVersion = CURRENT_SCHEMA_VERSION;
+    } else {
+      const schemaVersionValue = await this.metadataRepo.getMeta("schema_version");
+      if (schemaVersionValue) {
+        currentVersion = parseInt(schemaVersionValue, 10);
+        if (!Number.isFinite(currentVersion)) currentVersion = 0;
+      } else {
+        const ftsDdl = await this.metadataRepo.getTableDdl(`${this.prefix}entries_fts`);
+        const hasPorter = /tokenize\s*=\s*['"]porter\s+unicode61['"]/i.test(ftsDdl ?? "");
+        currentVersion = hasPorter ? 1 : 0;
       }
     }
-    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 {
-      await this.assertNoLegacySourceTypes();
-      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));
+    for (const migration of MIGRATIONS) {
+      if (migration.version > currentVersion) {
+        await migration.run(this.db, this.prefix);
+        await this.metadataRepo.setMeta("schema_version", String(migration.version), this.db);
+        currentVersion = migration.version;
       }
     }
-  }
-  async _doImportEntity(entityId, bundle, merge) {
-    const upsertedFactIds = /* @__PURE__ */ new Set();
-    const upsertedDeletedFactIds = /* @__PURE__ */ new Set();
-    const factsWithPreservedBlob = /* @__PURE__ */ new Map();
-    const preservedBlobDims = /* @__PURE__ */ new Set();
-    const softDeletedFactIds = [];
-    await this.db.withTransactionAsync(async () => {
-      if (!merge) {
-        const toDelete = await this.db.getAllAsync(
-          `SELECT id FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL`,
-          [entityId]
-        );
-        softDeletedFactIds.push(...toDelete.map((r) => r.id));
-        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);
-        }
-      }
-      for (const fact of bundle.facts) {
-        const sourceType = this._normalizeImportedSourceType(String(fact.source_type), {
-          entityId,
-          factId: fact.id
-        });
-        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;
-            }
-          }
-        }
-        let blobData = null;
-        if (rawBlob !== null && rawBlob.byteLength > 0 && rawBlob.byteLength % 4 === 0) {
-          const copy = new ArrayBuffer(rawBlob.byteLength);
-          const alignedBlob = new Uint8Array(copy);
-          alignedBlob.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 = alignedBlob;
-          }
-        }
-        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, sourceType, fact.source_hash, fact.source_ref, fact.created_at, safeUpdatedAt, fact.last_accessed_at, fact.access_count, fact.deleted_at, blobData, fact.id]
-            );
-            factsWithPreservedBlob.set(fact.id, blobData);
-            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 = ?, embedding_blob = NULL, embedding = NULL WHERE id = ?`,
-              [entityId, fact.title, fact.body, tagsJson, fact.confidence, sourceType, 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 });
-          upsertedFactIds.add(fact.id);
-          if (fact.deleted_at) upsertedDeletedFactIds.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, sourceType, fact.source_hash, fact.source_ref, fact.created_at, safeUpdatedAt, fact.last_accessed_at, fact.access_count, fact.deleted_at, blobData]
-            );
-            factsWithPreservedBlob.set(fact.id, blobData);
-            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, sourceType, 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 });
-          upsertedFactIds.add(fact.id);
-          if (fact.deleted_at) upsertedDeletedFactIds.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);
-        }
-      }
-      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 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,
-          entity_id: entityId,
-          // Use authoritative entityId from dump key, not fact.entity_id
-          title: fact.title,
-          body: fact.body,
-          tags: Array.isArray(fact.tags) || typeof fact.tags === "string" ? fact.tags : []
-        });
+    if (entriesExistedBeforeSetup) {
+      const schemaVersionCheck = await this.metadataRepo.getMeta("schema_version");
+      if (!schemaVersionCheck) {
+        await this.metadataRepo.setMeta("schema_version", String(currentVersion), this.db);
       }
     }
-    for (const fact of bundle.facts) {
-      const blobData = factsWithPreservedBlob.get(fact.id);
-      if (blobData && !fact.deleted_at && upsertedFactIds.has(fact.id)) {
-        try {
-          const float32Vector = new Float32Array(blobData.buffer, blobData.byteOffset, blobData.byteLength / 4);
-          await this._notifyEmbeddingPersisted(entityId, fact.id, float32Vector);
-        } catch (hookErr) {
-          console.warn(`[WikiMemory] onEmbeddingPersisted hook failed for preserved-blob fact ${fact.id}:`, hookErr);
-        }
-      }
+    if (entriesExistedBeforeSetup) {
+      await this.importExportService.assertNoLegacySourceTypes();
     }
-    for (const factId of softDeletedFactIds) {
-      if (!upsertedFactIds.has(factId) || upsertedDeletedFactIds.has(factId)) {
-        try {
-          await this._notifyEmbeddingPersisted(entityId, factId, null);
-        } catch (hookErr) {
-          console.warn(`[WikiMemory] onEmbeddingPersisted(vector=null) hook failed for soft-deleted fact ${factId}:`, hookErr);
+    const rows = await this.entryRepo.findRowsForSourceRefMigration();
+    await this.db.withTransactionAsync(async (tx) => {
+      for (const row of rows) {
+        const normalized = normalizeSourceRef(row.source_ref);
+        if (normalized !== row.source_ref) {
+          await this.entryRepo.updateSourceRefByRowid(row.rowid, normalized, tx);
         }
       }
+    });
+    await this.searchService.sync();
+  }
+  async hasChanged(entityId, sourceRef, sourceHash) {
+    const normalizedRef = normalizeSourceRef(sourceRef);
+    if (!normalizedRef) {
+      throw new Error(`Invalid sourceRef: "${sourceRef}"`);
     }
-    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 OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension_mismatch', ?)`,
-              [String(preservedDim)]
-            );
-          }
-          await this._reconcileEmbeddingDimension();
-        } else {
-          await this.db.runAsync(
-            `INSERT OR REPLACE INTO ${this.prefix}meta (key, value) VALUES ('embedding_dimension_mismatch', ?)`,
-            [String(canonicalDim)]
-          );
-        }
-      } 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);
+    const normalizedHash = normalizeSourceHash(sourceHash);
+    if (!normalizedHash) {
+      throw new Error(`Invalid sourceHash: must be a 64-character hex string (normalized to lowercase)`);
     }
+    const storedHash = await this.entryRepo.findLatestSourceHash(entityId, normalizedRef);
+    if (storedHash === null) return true;
+    const normalizedStoredHash = normalizeSourceHash(storedHash);
+    return normalizedStoredHash !== normalizedHash;
+  }
+  async runPrune(entityId, options) {
+    return this.maintenanceService.runPrune(entityId, options);
+  }
+  async read(entityId, query, options) {
+    return this.retrievalService.read(entityId, query, options);
+  }
+  async getMemoryBundle(entityId) {
+    return this.importExportService.getFullBundle(entityId, { maxEvents: 10 });
+  }
+  async write(entityId, event) {
+    return this.writeService.write(entityId, event);
+  }
+  /**
+   * @param options.promptOverride - Applies only to this manual call. Does NOT affect
+   * WriteService-triggered auto-runs. For persistent prompt customization across auto-runs,
+   * set `options.config.prompts.librarianSystemPrompt` at WikiMemory construction time.
+   */
+  async runLibrarian(entityId, options) {
+    return this.maintenanceService.runLibrarian(entityId, options);
+  }
+  /**
+   * @param options.promptOverride - Applies only to this manual call. Does NOT affect
+   * WriteService-triggered auto-runs. For persistent prompt customization across auto-runs,
+   * set `options.config.prompts.healSystemPrompt` at WikiMemory construction time.
+   */
+  async runHeal(entityId, options) {
+    return this.maintenanceService.runHeal(entityId, options);
+  }
+  async runReembed(entityId, opts) {
+    return this.maintenanceService.runReembed(entityId, opts);
+  }
+  getEntityStatus(entityId) {
+    return this.jobManager.getEntityStatus(entityId);
+  }
+  subscribeEntityStatus(entityId, callback) {
+    return this.jobManager.subscribeEntityStatus(entityId, callback);
+  }
+  clearVectorCache() {
+    this.searchService.evictCache();
+  }
+  async exportDump(entityIds) {
+    return this.importExportService.exportDump(entityIds);
+  }
+  async importDump(dump, opts) {
+    return this.importExportService.importDump(dump, opts);
   }
   async forget(entityId, params) {
-    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;
-      const deletedEntryIds = [];
-      if (params.clearAll) {
-        const newDeletions = await this.db.getAllAsync(
-          `SELECT id FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL`,
-          [entityId]
-        );
-        const alreadySoftDeleted = await this.db.getAllAsync(
-          `SELECT id FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NOT NULL`,
-          [entityId]
-        );
-        deletedEntryIds.push(...newDeletions.map((e) => e.id), ...alreadySoftDeleted.map((e) => e.id));
-        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)");
-        if (params.entryId) {
-          const entry = await this.db.getFirstAsync(
-            `SELECT id FROM ${this.prefix}entries WHERE id = ? AND entity_id = ?`,
-            [params.entryId, entityId]
-          );
-          if (entry) deletedEntryIds.push(entry.id);
-        }
-        if (sourceRef || sourceHash) {
-          let q = `SELECT id FROM ${this.prefix}entries WHERE entity_id = ?`;
-          const args = [entityId];
-          if (sourceRef) {
-            q += ` AND source_ref = ?`;
-            args.push(sourceRef);
-          }
-          if (sourceHash) {
-            q += ` AND source_hash = ?`;
-            args.push(sourceHash);
-          }
-          const entriesToDelete = await this.db.getAllAsync(q, args);
-          deletedEntryIds.push(...entriesToDelete.map((e) => e.id));
-        }
-        const entryPromise = params.entryId ? this.entryRepo.softDelete(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);
-        }
-        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);
-      const uniqueDeletedIds = Array.from(new Set(deletedEntryIds));
-      for (const factId of uniqueDeletedIds) {
-        try {
-          await this._notifyEmbeddingPersistedOrThrow(entityId, factId, null);
-        } catch (hookErr) {
-          const isTimeout = hookErr?.[HOOK_TIMEOUT_MARKER] === true;
-          if (isTimeout) {
-            throw new Error(
-              `forget(${entityId}/${factId}) failed: ${hookErr.message}`
-            );
-          }
-          const errMsg = hookErr?.message ?? "";
-          const isValidationError = errMsg.startsWith("Invalid deletionHookTimeoutMs");
-          if (isValidationError) {
-            throw new Error(
-              `forget(${entityId}/${factId}) failed: ${errMsg}`,
-              { cause: hookErr }
-            );
-          }
-          throw new Error(
-            `forget(${entityId}/${factId}) failed: ANN cleanup hook rejected`,
-            { cause: this._sanitizeRankerError(hookErr) }
-          );
-        }
-      }
-      return { deleted: { entries: deletedEntries, tasks: deletedTasks } };
-    } finally {
-      this.activeMaintenanceJobs.delete(forgetKey);
-    }
+    return this.maintenanceService.forget(entityId, params);
   }
+  /**
+   * @param params.promptOverride - Overrides the system prompt for this ingest call only.
+   * For persistent customization, set `options.config.prompts.ingestSystemPrompt` at
+   * WikiMemory construction time.
+   */
   async ingestDocument(entityId, params) {
-    const sourceRef = normalizeSourceRef(params.sourceRef);
-    if (!sourceRef) throw new Error("Invalid sourceRef");
-    const sourceHash = normalizeSourceHash(params.sourceHash);
-    if (!sourceHash) throw new Error("Invalid sourceHash (must be 64-char hex string)");
-    const maxChunkLength = params.maxChunkLength ?? this.options.config?.maxChunkLength ?? 12e3;
-    const rawOverlap = params.chunkOverlap ?? this.options.config?.chunkOverlap ?? 400;
-    const chunkOverlap = Math.min(
-      Number.isFinite(rawOverlap) && rawOverlap >= 0 ? Math.floor(rawOverlap) : 400,
-      maxChunkLength - 1
-    );
-    const rawConcurrency = params.chunkConcurrency ?? this.options.config?.chunkConcurrency ?? 1;
-    const chunkConcurrency = Number.isFinite(rawConcurrency) && rawConcurrency >= 1 ? Math.floor(rawConcurrency) : 1;
-    if (typeof params.documentChunk !== "string") {
-      throw new Error(`documentChunk must be a string, received ${typeof params.documentChunk}`);
-    }
-    const jobKey = `${this.prefix}:${entityId}:${sourceRef}`;
-    if (this.activeIngestJobs.has(jobKey)) {
-      throw new WikiBusyError("ingest", entityId);
-    }
-    if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) {
-      throw new WikiBusyError("prune", entityId);
-    }
-    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);
-    this._notifyStatusSubscribers(entityId);
-    try {
-      const { chunks, truncated } = chunkText(params.documentChunk, maxChunkLength, chunkOverlap);
-      if (chunks.length === 0) {
-        return { truncated: false, chunks: 0 };
-      }
-      const chunkResults = await withConcurrency(
-        chunks.map((chunk) => async () => {
-          const userPrompt = `Document Chunk:
-${chunk}`;
-          const responseText = await this.options.llmProvider.generateText({
-            systemPrompt: INGEST_SYSTEM_PROMPT,
-            userPrompt
-          });
-          const result = parseJsonResponse(responseText);
-          return (Array.isArray(result.facts) ? result.facts : []).map(validateFact).filter((f) => f !== null);
-        }),
-        chunkConcurrency
-      );
-      const seen = /* @__PURE__ */ new Set();
-      const allValidFacts = [];
-      for (const facts of chunkResults) {
-        for (const fact of facts) {
-          const normalized = fact.title.trim().toLowerCase().replace(/\s+/g, " ");
-          if (!seen.has(normalized)) {
-            seen.add(normalized);
-            allValidFacts.push(fact);
-          }
-        }
-      }
-      const now = Date.now();
-      const insertedFacts = [];
-      const deletedSourceFactIds = [];
-      await this.db.withTransactionAsync(async () => {
-        const existingSourceFacts = await this.db.getAllAsync(
-          `SELECT id FROM ${this.prefix}entries WHERE source_ref = ? AND entity_id = ? AND deleted_at IS NULL`,
-          [sourceRef, entityId]
-        );
-        for (const row of existingSourceFacts) {
-          deletedSourceFactIds.push(row.id);
-        }
-        await this.db.runAsync(
-          `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE source_ref = ? AND entity_id = ? AND deleted_at IS NULL`,
-          [now, now, sourceRef, entityId]
-        );
-        for (const fact of allValidFacts) {
-          const id = generateId("fact_");
-          const wikiFact = {
-            id,
-            entity_id: entityId,
-            title: fact.title,
-            body: fact.body,
-            tags: fact.tags,
-            confidence: fact.confidence,
-            source_type: "immutable_document",
-            source_hash: sourceHash,
-            source_ref: sourceRef,
-            created_at: now,
-            updated_at: now,
-            last_accessed_at: null,
-            access_count: 0,
-            deleted_at: null
-          };
-          await this.entryRepo.upsert(wikiFact);
-          insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
-        }
-      });
-      await this.rebuildMiniSearchIndex(entityId);
-      this.vectorCache.delete(entityId);
-      const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
-      for (const factId of uniqueDeletedSourceFactIds) {
-        try {
-          await this._notifyEmbeddingPersisted(entityId, factId, null);
-        } catch (hookErr) {
-          console.warn(`[WikiMemory] onEmbeddingPersisted hook failed during ingest for ${factId}:`, hookErr);
-        }
-      }
-      for (const fact of insertedFacts) {
-        await this.embedFact(fact);
-      }
-      this.vectorCache.delete(entityId);
-      return { truncated, chunks: chunks.length };
-    } finally {
-      this.activeIngestJobs.delete(jobKey);
-      this._notifyStatusSubscribers(entityId);
-    }
+    return this.ingestionService.ingestDocument(entityId, params);
   }
 };
-/**
- * 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;
+_testAccessNonTestEnvWarned = new WeakMap();
 
 // src/utils/formatContext.ts
 function validateMaxOption(value, name) {
@@ -3183,6 +1871,6 @@ function createWiki(db, options) {
   return new WikiMemory(db, options);
 }
 
-export { DEFAULT_LIBRARIAN_SYNTHESIS_PROMPT, PrunePartialFailureError, WikiBusyError, WikiMemory, createWiki, formatContext, formatMemoryDump, hydrateLibrarianPrompt, mapLibrarianOptionsToReadOptions, parseEmbedding, validateLibrarianPromptTemplate };
+export { DEFAULT_LIBRARIAN_SYNTHESIS_PROMPT, WikiMemory, createWiki, formatContext, formatMemoryDump, hydrateLibrarianPrompt, mapLibrarianOptionsToReadOptions, validateLibrarianPromptTemplate };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map