@equationalapplications/expo-llm-wiki 2.2.0 → 2.4.0

package/dist/index.js

@@ -15,1117 +15,47 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  WikiBusyError: () => WikiBusyError,
-  WikiMemory: () => WikiMemory,
-  createWiki: () => createWiki,
-  formatMemoryDump: () => formatMemoryDump
+  createWiki: () => createWiki
 });
 module.exports = __toCommonJS(index_exports);
+var import_core_llm_wiki = require("@equationalapplications/core-llm-wiki");
 
-// src/db/schema.ts
-async function setupDatabase(db, prefix) {
-  await db.execAsync(`
-    CREATE TABLE IF NOT EXISTS ${prefix}entries (
-      id TEXT PRIMARY KEY,
-      entity_id TEXT NOT NULL,
-      title TEXT NOT NULL,
-      body TEXT NOT NULL,
-      tags TEXT NOT NULL DEFAULT '[]',
-      confidence TEXT NOT NULL DEFAULT 'inferred',
-      source_type TEXT NOT NULL DEFAULT 'agent_inferred',
-      source_hash TEXT,
-      source_ref TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      last_accessed_at INTEGER,
-      access_count INTEGER NOT NULL DEFAULT 0,
-      deleted_at INTEGER
-    );
-
-    CREATE INDEX IF NOT EXISTS ${prefix}entries_entity_idx ON ${prefix}entries(entity_id);
-    CREATE INDEX IF NOT EXISTS ${prefix}entries_source_ref_idx ON ${prefix}entries(entity_id, source_ref);
-    CREATE INDEX IF NOT EXISTS ${prefix}entries_source_hash_idx ON ${prefix}entries(entity_id, source_hash) WHERE source_hash IS NOT NULL;
-    CREATE INDEX IF NOT EXISTS ${prefix}entries_updated_idx ON ${prefix}entries(updated_at DESC);
-
-    -- FTS5 Virtual Table for full-text search
-    CREATE VIRTUAL TABLE IF NOT EXISTS ${prefix}entries_fts USING fts5(
-      title,
-      body,
-      tags,
-      content='${prefix}entries',
-      content_rowid='rowid',
-      tokenize='porter unicode61'
-    );
-
-    -- Triggers to keep FTS5 in sync with entries
-    CREATE TRIGGER IF NOT EXISTS ${prefix}entries_ai AFTER INSERT ON ${prefix}entries BEGIN
-      INSERT INTO ${prefix}entries_fts(rowid, title, body, tags) 
-      VALUES (new.rowid, new.title, new.body, new.tags);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS ${prefix}entries_ad AFTER DELETE ON ${prefix}entries BEGIN
-      INSERT INTO ${prefix}entries_fts(${prefix}entries_fts, rowid, title, body, tags) 
-      VALUES ('delete', old.rowid, old.title, old.body, old.tags);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS ${prefix}entries_au AFTER UPDATE ON ${prefix}entries BEGIN
-      INSERT INTO ${prefix}entries_fts(${prefix}entries_fts, rowid, title, body, tags) 
-      VALUES ('delete', old.rowid, old.title, old.body, old.tags);
-      INSERT INTO ${prefix}entries_fts(rowid, title, body, tags) 
-      VALUES (new.rowid, new.title, new.body, new.tags);
-    END;
-
-    CREATE TABLE IF NOT EXISTS ${prefix}tasks (
-      id TEXT PRIMARY KEY,
-      entity_id TEXT NOT NULL,
-      description TEXT NOT NULL,
-      status TEXT NOT NULL DEFAULT 'pending',
-      priority INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      resolved_at INTEGER,
-      deleted_at INTEGER
-    );
-
-    CREATE INDEX IF NOT EXISTS ${prefix}tasks_entity_idx ON ${prefix}tasks(entity_id, status);
-
-    CREATE TABLE IF NOT EXISTS ${prefix}events (
-      id TEXT PRIMARY KEY,
-      entity_id TEXT NOT NULL,
-      event_type TEXT NOT NULL,
-      summary TEXT NOT NULL,
-      related_entry_id TEXT,
-      created_at INTEGER NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS ${prefix}events_entity_idx ON ${prefix}events(entity_id, created_at DESC);
-
-    CREATE TABLE IF NOT EXISTS ${prefix}checkpoints (
-      entity_id TEXT PRIMARY KEY,
-      heal_checkpoint INTEGER NOT NULL DEFAULT 0,
-      memory_checkpoint INTEGER NOT NULL DEFAULT 0
-    );
-  `);
-}
-
-// src/types.ts
-var WikiBusyError = class extends Error {
-  operation;
-  entityId;
-  constructor(operation, entityId) {
-    super(`${operation} already running for entity ${entityId}`);
-    this.name = "WikiBusyError";
-    this.operation = operation;
-    this.entityId = entityId;
-  }
-};
-
-// 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/WikiMemory.ts
-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 {
-  db;
-  prefix;
-  options;
-  activeMaintenanceJobs = /* @__PURE__ */ new Set();
-  activeIngestJobs = /* @__PURE__ */ new Set();
-  _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}"`);
-  }
-  constructor(db, options) {
-    this.db = db;
-    this.options = options;
-    this.prefix = options.config?.tablePrefix || "llm_wiki_";
-  }
-  async setup() {
-    await setupDatabase(this.db, this.prefix);
-    const ftsMeta = await this.db.getFirstAsync(
-      `SELECT sql FROM sqlite_master WHERE type='table' AND name=?`,
-      [`${this.prefix}entries_fts`]
-    );
-    const hasPorterTokenizer = /tokenize\s*=\s*['"]porter\s+unicode61['"]/i.test(ftsMeta?.sql ?? "");
-    if (ftsMeta?.sql && !hasPorterTokenizer) {
-      await this.db.withTransactionAsync(async () => {
-        await this.db.execAsync(`
-          DROP TRIGGER IF EXISTS ${this.prefix}entries_ai;
-          DROP TRIGGER IF EXISTS ${this.prefix}entries_ad;
-          DROP TRIGGER IF EXISTS ${this.prefix}entries_au;
-          DROP TABLE IF EXISTS ${this.prefix}entries_fts;
-          CREATE VIRTUAL TABLE ${this.prefix}entries_fts USING fts5(
-            title,
-            body,
-            tags,
-            content='${this.prefix}entries',
-            content_rowid='rowid',
-            tokenize='porter unicode61'
-          );
-          INSERT INTO ${this.prefix}entries_fts(rowid, title, body, tags)
-            SELECT rowid, title, body, tags FROM ${this.prefix}entries;
-          CREATE TRIGGER ${this.prefix}entries_ai AFTER INSERT ON ${this.prefix}entries BEGIN
-            INSERT INTO ${this.prefix}entries_fts(rowid, title, body, tags)
-            VALUES (new.rowid, new.title, new.body, new.tags);
-          END;
-          CREATE TRIGGER ${this.prefix}entries_ad AFTER DELETE ON ${this.prefix}entries BEGIN
-            INSERT INTO ${this.prefix}entries_fts(${this.prefix}entries_fts, rowid, title, body, tags)
-            VALUES ('delete', old.rowid, old.title, old.body, old.tags);
-          END;
-          CREATE TRIGGER ${this.prefix}entries_au AFTER UPDATE ON ${this.prefix}entries BEGIN
-            INSERT INTO ${this.prefix}entries_fts(${this.prefix}entries_fts, rowid, title, body, tags)
-            VALUES ('delete', old.rowid, old.title, old.body, old.tags);
-            INSERT INTO ${this.prefix}entries_fts(rowid, title, body, tags)
-            VALUES (new.rowid, new.title, new.body, new.tags);
-          END;
-        `);
-      });
-    }
-    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]
-          );
-        }
-      }
-    });
-  }
-  formatSearchQuery(query) {
-    const normalizeTokens = (value) => value.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((t) => t.length >= 3);
-    const baseTokens = normalizeTokens(query);
-    if (baseTokens.length === 0) return "";
-    const synonymMap = this.options.config?.synonymMap;
-    const expanded = [];
-    const seen = /* @__PURE__ */ new Set();
-    const pushNormalized = (value) => {
-      for (const token of normalizeTokens(value)) {
-        if (expanded.length >= 12) return false;
-        if (seen.has(token)) continue;
-        seen.add(token);
-        expanded.push(token);
-      }
-      return true;
-    };
-    for (const t of baseTokens) {
-      if (!pushNormalized(t)) break;
-      if (synonymMap) {
-        const synonyms = synonymMap[t];
-        if (Array.isArray(synonyms)) {
-          for (const s of synonyms) {
-            if (typeof s === "string") {
-              if (!pushNormalized(s)) break;
-            }
-          }
-        }
-      }
-    }
-    return expanded.map((t) => `"${t}"*`).join(" OR ");
-  }
-  async read(entityId, query) {
-    const ftsQuery = this.formatSearchQuery(query);
-    const maxResults = this.options.config?.maxFtsResults || 10;
-    let factsPromise;
-    if (ftsQuery) {
-      factsPromise = this.db.getAllAsync(`
-        SELECT e.* FROM ${this.prefix}entries e
-        JOIN ${this.prefix}entries_fts fts ON e.rowid = fts.rowid
-        WHERE fts.${this.prefix}entries_fts MATCH ?
-          AND e.entity_id = ?
-          AND e.deleted_at IS NULL
-        ORDER BY e.confidence DESC, e.access_count DESC, e.updated_at DESC
-        LIMIT ?
-      `, [ftsQuery, entityId, maxResults]);
-    } else {
-      factsPromise = this.db.getAllAsync(`
-        SELECT * FROM ${this.prefix}entries
-        WHERE entity_id = ? AND deleted_at IS NULL
-        ORDER BY updated_at DESC
-        LIMIT ?
-      `, [entityId, maxResults]);
-    }
-    const tasksPromise = this.db.getAllAsync(`
-      SELECT * FROM ${this.prefix}tasks
-      WHERE entity_id = ? AND status IN ('pending', 'in_progress') AND deleted_at IS NULL
-      ORDER BY priority DESC, created_at ASC
-    `, [entityId]);
-    const eventsPromise = this.db.getAllAsync(`
-      SELECT * FROM ${this.prefix}events
-      WHERE entity_id = ?
-      ORDER BY created_at DESC
-      LIMIT 10
-    `, [entityId]);
-    const [factsRaw, tasks, events] = await Promise.all([factsPromise, tasksPromise, eventsPromise]);
-    if (ftsQuery && factsRaw.length > 0) {
-      const ids = factsRaw.map((f) => f.id);
-      const placeholders = ids.map(() => "?").join(",");
-      const now = Date.now();
-      await this.db.runAsync(`
-        UPDATE ${this.prefix}entries 
-        SET access_count = access_count + 1, last_accessed_at = ?
-        WHERE id IN (${placeholders})
-      `, [now, ...ids]);
-    }
-    const facts = factsRaw.map((f) => ({
-      ...f,
-      tags: typeof f.tags === "string" ? JSON.parse(f.tags) : f.tags
-    }));
-    return { facts, tasks, events: events.reverse() };
-  }
-  async getMemoryBundle(entityId) {
-    return this._getFullBundle(entityId, { maxEvents: 10 });
-  }
-  async write(entityId, event) {
-    const id = generateId("evt_");
-    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.add(jobKey);
-        this.runLibrarianThenMaybeHeal(entityId, count).catch(console.error).finally(() => this.activeMaintenanceJobs.delete(jobKey));
-      }
-    }
-  }
-  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);
-        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);
-        }
-      }
-    }
-  }
-  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) => ({
-      ...f,
-      tags: typeof f.tags === "string" ? JSON.parse(f.tags) : f.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();
-    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 !== "agent_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, "agent_inferred", now, now]);
-      }
-      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]);
-      }
-    });
-  }
-  async _doRunHeal(entityId) {
-    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");
-    }
-    if (staleInferredAfterDays !== null && (typeof staleInferredAfterDays !== "number" || !Number.isFinite(staleInferredAfterDays) || staleInferredAfterDays < 0)) {
-      throw new Error("Invalid staleInferredAfterDays: must be a finite number >= 0 or null");
-    }
-    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 != 'user_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 != 'user_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 !== "user_document");
-    const documentAnchors = allFactsRows.filter((f) => f.source_type === "user_document").map(({ id, title, source_ref }) => ({ id, title, source_ref }));
-    const userPrompt = `Heal Candidates:
-${JSON.stringify(healCandidates.map((f) => ({ ...f, tags: typeof f.tags === "string" ? JSON.parse(f.tags) : f.tags })), null, 2)}
-
-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)}
-
-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);
-    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, "agent_inferred", now, now]);
-      }
-    });
-  }
-  async runLibrarian(entityId) {
-    const jobKey = this._librarianKey(entityId);
-    if (this.activeMaintenanceJobs.has(jobKey)) {
-      throw new WikiBusyError("librarian", entityId);
-    }
-    this.activeMaintenanceJobs.add(jobKey);
-    try {
-      await this._doRunLibrarian(entityId);
-    } finally {
-      this.activeMaintenanceJobs.delete(jobKey);
-    }
-  }
-  async runHeal(entityId) {
-    const jobKey = this._healKey(entityId);
-    if (this.activeMaintenanceJobs.has(jobKey)) {
-      throw new WikiBusyError("heal", entityId);
-    }
-    this.activeMaintenanceJobs.add(jobKey);
-    try {
-      await this._doRunHeal(entityId);
-    } finally {
-      this.activeMaintenanceJobs.delete(jobKey);
-    }
-  }
-  getEntityStatus(entityId) {
-    const ingestPrefix = `${this.prefix}:${entityId}:`;
-    let ingesting = false;
-    for (const k of this.activeIngestJobs) {
-      if (k.startsWith(ingestPrefix)) {
-        ingesting = true;
-        break;
-      }
-    }
-    return {
-      ingesting,
-      librarian: this.activeMaintenanceJobs.has(this._librarianKey(entityId)),
-      heal: this.activeMaintenanceJobs.has(this._healKey(entityId))
-    };
-  }
-  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) => ({
-      ...f,
-      tags: typeof f.tags === "string" ? JSON.parse(f.tags) : f.tags
-    }));
-    const events = maxEvents != null ? eventsRaw.slice().reverse() : eventsRaw;
-    return { facts, tasks, events };
-  }
-  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)])
-      );
-      for (const [id, bundle] of batchResults) {
-        entities[id] = bundle;
-      }
-    }
-    return { generatedAt: Date.now(), entities };
-  }
-  async importDump(dump, opts) {
-    const merge = opts?.merge ?? false;
-    for (const [entityId, bundle] of Object.entries(dump.entities)) {
-      await this.db.withTransactionAsync(async () => {
-        if (!merge) {
-          const now = Date.now();
-          await this.db.runAsync(
-            `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`,
-            [now, now, entityId]
-          );
-          await this.db.runAsync(
-            `UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`,
-            [now, now, entityId]
-          );
-          await this.db.runAsync(
-            `DELETE FROM ${this.prefix}checkpoints WHERE entity_id = ?`,
-            [entityId]
-          );
-        }
-        const factIds = bundle.facts.map((fact) => fact.id);
-        const existingFactsById = /* @__PURE__ */ new Map();
-        const factLookupChunkSize = 500;
-        for (let i = 0; i < factIds.length; i += factLookupChunkSize) {
-          const factIdChunk = factIds.slice(i, i + factLookupChunkSize);
-          if (factIdChunk.length === 0) continue;
-          const placeholders = factIdChunk.map(() => "?").join(", ");
-          const existingFacts = await this.db.getAllAsync(
-            `SELECT id, entity_id, updated_at FROM ${this.prefix}entries WHERE id IN (${placeholders})`,
-            factIdChunk
-          );
-          for (const existingFact of existingFacts) {
-            existingFactsById.set(existingFact.id, existingFact);
-          }
-        }
-        for (const fact of bundle.facts) {
-          const tagsJson = JSON.stringify(Array.isArray(fact.tags) ? fact.tags : []);
-          const safeUpdatedAt = Number.isFinite(fact.updated_at) ? fact.updated_at : 0;
-          const existing = existingFactsById.get(fact.id);
-          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;
-            }
-            await this.db.runAsync(
-              `UPDATE ${this.prefix}entries SET entity_id = ?, title = ?, body = ?, tags = ?, confidence = ?, source_type = ?, source_hash = ?, source_ref = ?, created_at = ?, updated_at = ?, last_accessed_at = ?, access_count = ?, deleted_at = ? WHERE id = ?`,
-              [entityId, fact.title, fact.body, tagsJson, fact.confidence, fact.source_type, fact.source_hash, fact.source_ref, fact.created_at, safeUpdatedAt, fact.last_accessed_at, fact.access_count, fact.deleted_at, fact.id]
-            );
-            existingFactsById.set(fact.id, { id: fact.id, entity_id: entityId, updated_at: safeUpdatedAt });
-          } else {
-            await this.db.runAsync(
-              `INSERT INTO ${this.prefix}entries (id, entity_id, title, body, tags, confidence, source_type, source_hash, source_ref, created_at, updated_at, last_accessed_at, access_count, deleted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-              [fact.id, entityId, fact.title, fact.body, tagsJson, fact.confidence, fact.source_type, fact.source_hash, fact.source_ref, fact.created_at, safeUpdatedAt, fact.last_accessed_at, fact.access_count, fact.deleted_at]
-            );
-            existingFactsById.set(fact.id, { id: fact.id, entity_id: entityId, updated_at: safeUpdatedAt });
-          }
-        }
-        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]
-          );
-        }
-      });
-    }
-  }
-  async forget(entityId, params) {
-    const now = Date.now();
-    let deletedEntries = 0;
-    let deletedTasks = 0;
-    if (params.clearAll) {
-      const [entriesRes, tasksRes] = await Promise.all([
-        this.db.runAsync(`UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`, [now, now, entityId]),
-        this.db.runAsync(`UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`, [now, now, entityId])
-      ]);
-      await this.db.runAsync(`UPDATE ${this.prefix}checkpoints SET memory_checkpoint = 0, heal_checkpoint = 0 WHERE entity_id = ?`, [entityId]);
-      deletedEntries = entriesRes.changes;
-      deletedTasks = tasksRes.changes;
-    } else {
-      const hasIdSelectors = params.entryId !== void 0 || params.taskId !== void 0;
-      const hasSourceSelectors = params.sourceRef !== void 0 || params.sourceHash !== void 0;
-      if (hasIdSelectors && hasSourceSelectors) {
-        throw new Error("forget() params are mutually exclusive: use entryId/taskId together, or sourceRef/sourceHash together, but not both in the same call");
-      }
-      const sourceRef = params.sourceRef !== void 0 ? normalizeSourceRef(params.sourceRef) : null;
-      if (params.sourceRef !== void 0 && !sourceRef) throw new Error("Invalid sourceRef");
-      const sourceHash = params.sourceHash !== void 0 ? normalizeSourceHash(params.sourceHash) : null;
-      if (params.sourceHash !== void 0 && !sourceHash) throw new Error("Invalid sourceHash (must be 64-char hex string)");
-      const entryPromise = params.entryId ? this.db.runAsync(`UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`, [now, now, params.entryId, entityId]) : null;
-      const taskPromise = params.taskId ? this.db.runAsync(`UPDATE ${this.prefix}tasks SET deleted_at = ?, updated_at = ? WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`, [now, now, params.taskId, entityId]) : null;
-      let refPromise = null;
-      if (sourceRef || sourceHash) {
-        let q = `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE entity_id = ? AND deleted_at IS NULL`;
-        const args = [now, now, entityId];
-        if (sourceRef) {
-          q += ` AND source_ref = ?`;
-          args.push(sourceRef);
-        }
-        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;
-    }
-    return { deleted: { entries: deletedEntries, tasks: deletedTasks } };
-  }
-  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);
-    }
-    this.activeIngestJobs.add(jobKey);
-    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();
-      await this.db.withTransactionAsync(async () => {
-        await this.db.runAsync(
-          `UPDATE ${this.prefix}entries SET deleted_at = ?, updated_at = ? WHERE source_ref = ? AND entity_id = ? AND deleted_at IS NULL`,
-          [now, now, sourceRef, entityId]
-        );
-        for (const fact of allValidFacts) {
-          const id = generateId("fact_");
-          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)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-            [id, entityId, fact.title, fact.body, JSON.stringify(fact.tags), fact.confidence, "user_document", sourceHash, sourceRef, now, now]
-          );
-        }
-      });
-      return { truncated, chunks: chunks.length };
-    } finally {
-      this.activeIngestJobs.delete(jobKey);
-    }
-  }
-};
-
-// src/utils/formatMemoryDump.ts
-function renderFact(f) {
-  const tags = (f.tags || []).join(", ");
-  const source = f.source_ref ?? f.source_type;
-  return `### ${f.title}
-**Tags:** ${tags}
-**Confidence:** ${f.confidence}
-**Source:** ${source}
-
-${f.body}
-
----
-`;
-}
-function renderTask(t) {
-  const checked = t.status === "done" ? "x" : " ";
-  const note = t.status === "done" ? " (done)" : t.status === "abandoned" ? " (abandoned)" : t.status === "in_progress" ? " (in progress)" : "";
-  return `- [${checked}] ${t.description}${note}
-`;
-}
-function renderEvent(e) {
-  const ts = new Date(e.created_at).toISOString();
-  return `- [${ts}] (${e.event_type}) ${e.summary}
-`;
-}
-function renderEntity(entityId, bundle, generatedAt) {
-  const lines = [];
-  lines.push(`# Memory Dump: ${entityId}`);
-  lines.push(`Generated: ${new Date(generatedAt).toISOString()}`);
-  lines.push("");
-  lines.push("## Facts");
-  lines.push("");
-  if (bundle.facts.length === 0) {
-    lines.push("_(none)_\n");
-  } else {
-    for (const f of bundle.facts) lines.push(renderFact(f));
-  }
-  lines.push("## Tasks");
-  lines.push("");
-  if (bundle.tasks.length === 0) {
-    lines.push("_(none)_\n");
-  } else {
-    for (const t of bundle.tasks) lines.push(renderTask(t));
-  }
-  lines.push("");
-  lines.push("## Recent Events");
-  lines.push("");
-  if (bundle.events.length === 0) {
-    lines.push("_(none)_\n");
-  } else {
-    for (const e of bundle.events) lines.push(renderEvent(e));
-  }
-  return lines.join("\n");
-}
-function shortHash(value) {
-  let h1 = 5381;
-  let h2 = 52711;
-  for (let i = 0; i < value.length; i += 1) {
-    const c = value.charCodeAt(i);
-    h1 = Math.imul(h1, 33) ^ c;
-    h2 = Math.imul(h2, 31) ^ c;
-  }
-  return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
-}
-function formatEntityFileName(entityId) {
-  const normalized = entityId.normalize("NFKC");
-  const sanitized = normalized.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^\.+/, "_").replace(/_+/g, "_").replace(/^[_-]+|[_-]+$/g, "");
-  const MAX_BASE = 200;
-  const trimmed = sanitized.length > MAX_BASE ? sanitized.slice(0, MAX_BASE) : sanitized;
-  const baseName = trimmed && trimmed !== "." && trimmed !== ".." ? trimmed : "entity";
-  const needsSuffix = baseName !== entityId || sanitized.length > MAX_BASE;
-  const uniqueBaseName = needsSuffix ? `${baseName}-${shortHash(entityId)}` : baseName;
-  return `${uniqueBaseName}.md`;
-}
-function formatMemoryDump(dump) {
-  const files = Object.entries(dump.entities).map(([entityId, bundle]) => ({
-    name: formatEntityFileName(entityId),
-    content: renderEntity(entityId, bundle, dump.generatedAt)
-  }));
+// src/adapter.ts
+function createExpoAdapter(db) {
   return {
-    manifest: JSON.stringify(dump, null, 2),
-    files
+    execAsync: (sql) => db.execAsync(sql),
+    runAsync: async (sql, params = []) => {
+      const result = await db.runAsync(sql, params);
+      return { changes: result.changes, lastInsertRowId: result.lastInsertRowId };
+    },
+    getAllAsync: (sql, params = []) => db.getAllAsync(sql, params),
+    getFirstAsync: (sql, params = []) => db.getFirstAsync(sql, params),
+    withTransactionAsync: (fn) => {
+      let captured;
+      return db.withTransactionAsync(() => fn().then((v) => {
+        captured = v;
+      })).then(() => captured);
+    },
+    closeAsync: () => db.closeAsync()
   };
 }
 
 // src/index.ts
+__reExport(index_exports, require("@equationalapplications/core-llm-wiki"), module.exports);
+__reExport(index_exports, require("@equationalapplications/react-llm-wiki"), module.exports);
 function createWiki(db, options) {
-  return new WikiMemory(db, options);
+  return new import_core_llm_wiki.WikiMemory(createExpoAdapter(db), options);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  WikiBusyError,
-  WikiMemory,
   createWiki,
-  formatMemoryDump
+  ...require("@equationalapplications/core-llm-wiki"),
+  ...require("@equationalapplications/react-llm-wiki")
 });
+//# sourceMappingURL=index.js.map