@equationalapplications/core-llm-wiki 7.11.2 → 7.13.0

package/dist/{chunk-522SCN2E.mjs → chunk-PCRYIUV5.mjs}

@@ -44,6 +44,8 @@ var SQLITE_RESULT_CODE_NAMES = {
   // prefix and we normalize it back to the symbolic name so callers can branch on
   // the same string the rest of the ecosystem uses.
   2067: "SQLITE_CONSTRAINT_UNIQUE",
+  // 267 = SQLITE_CORRUPT_VTAB — a corrupt FTS5 shadow table (ftsCorruptionClass).
+  267: "SQLITE_CORRUPT_VTAB",
   100: "SQLITE_ROW",
   101: "SQLITE_DONE"
 };
@@ -184,1519 +186,1592 @@ var WikiSupersedeError = class _WikiSupersedeError extends Error {
     Object.setPrototypeOf(this, _WikiSupersedeError.prototype);
   }
 };
-
-// src/utils/ids.ts
-var _injectedGetRandomValues = null;
-function configureRandomSource(fn) {
-  _injectedGetRandomValues = fn;
-}
-function generateId(prefix = "") {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return prefix + crypto.randomUUID().replace(/-/g, "").substring(0, 24);
+var WikiMigrationRequiredError = class _WikiMigrationRequiredError extends Error {
+  constructor(message, pendingWork) {
+    super(message);
+    this.code = "WIKI_MIGRATION_REQUIRED";
+    this.name = "WikiMigrationRequiredError";
+    this.pendingWork = pendingWork;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, _WikiMigrationRequiredError);
+    }
   }
-  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
-    const bytes = new Uint8Array(16);
-    crypto.getRandomValues(bytes);
-    return prefix + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("").substring(0, 24);
+};
+var WikiSearchUnavailableError = class extends Error {
+  constructor(message = "Keyword search is temporarily unavailable", cause) {
+    super(message, cause !== void 0 ? { cause } : void 0);
+    this.name = "WikiSearchUnavailableError";
   }
-  if (_injectedGetRandomValues) {
-    const bytes = new Uint8Array(16);
-    _injectedGetRandomValues(bytes);
-    return prefix + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("").substring(0, 24);
+};
+function isWikiSearchUnavailableError(err) {
+  try {
+    return err instanceof WikiSearchUnavailableError;
+  } catch {
+    return false;
   }
-  throw new Error(
-    "generateId: no cryptographically secure random source available (crypto.randomUUID and crypto.getRandomValues are both missing, and no configureRandomSource() injection was provided)."
-  );
 }
 
-// src/utils/ontology.ts
-function emptyManifest() {
-  return { node_types: [], edge_types: [] };
-}
-function normalizeTitleKey(title) {
-  return title.trim().toLowerCase().replace(/\s+/g, " ");
-}
-function resolveNodeType(raw, manifest) {
-  const slug = raw.trim();
-  if (!slug) return null;
-  const hit = manifest.node_types.find((n) => n.type.toLowerCase() === slug.toLowerCase());
-  return hit?.type ?? null;
-}
-function resolveEdgeDefinitions(rawEdgeType, manifest) {
-  const slug = rawEdgeType.trim();
-  if (!slug) return [];
-  return manifest.edge_types.filter((e) => e.type.toLowerCase() === slug.toLowerCase());
-}
-function edgeTripleKey(type, sourceType, targetType) {
-  return `${type.trim().toLowerCase()}|${sourceType.trim().toLowerCase()}|${targetType.trim().toLowerCase()}`;
-}
-function typeSatisfies(declaredType, concreteType, manifest) {
-  const concrete = concreteType.trim().toLowerCase();
-  const declared = declaredType.trim().toLowerCase();
-  if (!concrete || !declared) return false;
-  if (declared === concrete) return true;
-  const def = (manifest.node_types ?? []).find(
-    (n) => typeof n?.type === "string" && n.type.trim().toLowerCase() === concrete
+// src/utils/pure.ts
+var MAX_REPAIR_CANDIDATES = 5;
+function throwNoJsonFound(text, start) {
+  throw new WikiParseError(
+    "No JSON object/array found in LLM response",
+    { tier: "strict", position: start, slice: text }
   );
-  const parent = typeof def?.parent_type === "string" ? def.parent_type.trim().toLowerCase() : "";
-  return parent !== "" && parent === declared;
-}
-function edgeTripleAllowed(manifest, edgeType, sourceType, targetType) {
-  const wanted = edgeType.trim().toLowerCase();
-  return (manifest.edge_types ?? []).some((d) => typeof d?.type === "string" && d.type.trim().toLowerCase() === wanted && typeof d.source_type === "string" && typeSatisfies(d.source_type, sourceType, manifest) && typeof d.target_type === "string" && typeSatisfies(d.target_type, targetType, manifest));
 }
-function validateManifest(manifest) {
-  const nodeSlugs = /* @__PURE__ */ new Set();
-  for (const node of manifest.node_types ?? []) {
-    const type = node.type?.trim();
-    if (!type) throw new Error("Ontology node type slug must be non-empty");
-    const key = type.toLowerCase();
-    if (nodeSlugs.has(key)) throw new Error(`Duplicate node type: ${type}`);
-    nodeSlugs.add(key);
-  }
-  const parentOf = /* @__PURE__ */ new Map();
-  for (const node of manifest.node_types ?? []) {
-    const parent = typeof node.parent_type === "string" ? node.parent_type.trim().toLowerCase() : void 0;
-    parentOf.set(node.type.trim().toLowerCase(), parent);
+function parseJsonResponse(text) {
+  const firstBrace = text.indexOf("{");
+  const firstBracket = text.indexOf("[");
+  let start;
+  let openChar;
+  const useBrace = firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket);
+  if (useBrace) {
+    start = firstBrace;
+    openChar = "{";
+  } else if (firstBracket !== -1) {
+    start = firstBracket;
+    openChar = "[";
+  } else {
+    throwNoJsonFound(text, null);
   }
-  for (const node of manifest.node_types ?? []) {
-    if (node.parent_type === void 0) continue;
-    if (typeof node.parent_type !== "string" || !node.parent_type.trim()) {
-      throw new Error(`Ontology parent_type must be a non-empty string when present: ${node.type}`);
-    }
-    const parentSlug = node.parent_type.trim().toLowerCase();
-    if (parentSlug === node.type.trim().toLowerCase()) {
-      throw new Error(`Self-parent: ${node.type}`);
-    }
-    if (!nodeSlugs.has(parentSlug)) {
-      throw new Error(`Parent type not found: ${node.parent_type}`);
-    }
-    const grandparent = parentOf.get(parentSlug);
-    if (grandparent) {
-      throw new Error(`Parent chain too deep: ${node.type} \u2192 ${node.parent_type} \u2192 ${grandparent}`);
+  const slice = scanJsonSlice(text, start, openChar);
+  if (slice !== null) {
+    try {
+      return JSON.parse(slice);
+    } catch {
     }
   }
-  const edgeKeys = /* @__PURE__ */ new Set();
-  const edgeNames = /* @__PURE__ */ new Map();
-  for (const edge of manifest.edge_types ?? []) {
-    const edgeType = edge.type?.trim();
-    const sourceType = edge.source_type?.trim();
-    const targetType = edge.target_type?.trim();
-    if (!edgeType) throw new Error("Ontology edge type slug must be non-empty");
-    if (!sourceType || !targetType || !nodeSlugs.has(sourceType.toLowerCase()) || !nodeSlugs.has(targetType.toLowerCase())) {
-      throw new Error(`Edge type ${edgeType} references unknown node type`);
-    }
-    const edgeKey = edgeTripleKey(edgeType, sourceType, targetType);
-    if (edgeKeys.has(edgeKey)) {
-      throw new Error(`Duplicate edge definition: ${edgeType} (${sourceType} \u2192 ${targetType})`);
-    }
-    edgeKeys.add(edgeKey);
-    const canonical = edgeNames.get(edgeType.toLowerCase());
-    if (canonical === void 0) {
-      edgeNames.set(edgeType.toLowerCase(), edgeType);
-    } else if (canonical !== edgeType) {
-      throw new Error(`Inconsistent casing for edge type: ${edgeType} conflicts with ${canonical}`);
-    }
+  const repairOdd = containerAwareRepair(text, start, false);
+  if (repairOdd.success !== null && !repairOdd.ambiguous) {
+    return repairOdd.success;
   }
-}
-function buildDeclaresParentIndex(nodes) {
-  const declaresParent = /* @__PURE__ */ new Map();
-  for (const n of nodes) {
-    const slug = typeof n?.type === "string" ? n.type.trim().toLowerCase() : "";
-    if (!slug || declaresParent.has(slug)) continue;
-    declaresParent.set(slug, n?.parent_type !== void 0);
+  const repairEven = containerAwareRepair(text, start, true);
+  if (repairOdd.success !== null && repairEven.success !== null) {
+    const pick = repairEven.escapes < repairOdd.escapes ? repairEven : repairOdd;
+    return pick.success;
   }
-  return declaresParent;
-}
-function mergeOntologyUpdates(current, updates) {
-  const node_types = [...current.node_types];
-  const edge_types = [...current.edge_types];
-  const nodeSlugs = new Set(node_types.map((n) => n.type.trim().toLowerCase()));
-  const edgeKeys = new Set(edge_types.map((e) => edgeTripleKey(e.type, e.source_type, e.target_type)));
-  const edgeNames = new Map(edge_types.map((e) => [e.type.trim().toLowerCase(), e.type.trim()]));
-  const declaresParent = buildDeclaresParentIndex([
-    ...current.node_types,
-    ...updates.node_types ?? []
-  ]);
-  for (const node of updates.node_types ?? []) {
-    const type = node?.type?.trim();
-    if (!type) continue;
-    const key = type.toLowerCase();
-    if (nodeSlugs.has(key)) continue;
-    const rawParent = typeof node?.parent_type === "string" ? node.parent_type.trim() : "";
-    const parentSlug = rawParent.toLowerCase();
-    const keepParent = parentSlug !== "" && parentSlug !== key && declaresParent.get(parentSlug) === false;
-    node_types.push({
-      type,
-      description: String(node.description ?? ""),
-      ...keepParent ? { parent_type: rawParent } : {}
-    });
-    nodeSlugs.add(key);
+  if (repairOdd.success !== null) {
+    return repairOdd.success;
   }
-  for (const edge of updates.edge_types ?? []) {
-    const rawEdgeType = edge?.type?.trim();
-    const sourceType = edge?.source_type?.trim();
-    const targetType = edge?.target_type?.trim();
-    if (!rawEdgeType || !sourceType || !targetType) continue;
-    const edgeType = edgeNames.get(rawEdgeType.toLowerCase()) ?? rawEdgeType;
-    const edgeKey = edgeTripleKey(edgeType, sourceType, targetType);
-    if (edgeKeys.has(edgeKey)) continue;
-    if (!nodeSlugs.has(sourceType.toLowerCase()) || !nodeSlugs.has(targetType.toLowerCase())) continue;
-    edgeNames.set(edgeType.toLowerCase(), edgeType);
-    edge_types.push({
-      type: edgeType,
-      source_type: sourceType,
-      target_type: targetType,
-      description: String(edge.description ?? "")
-    });
-    edgeKeys.add(edgeKey);
+  if (repairEven.success !== null) {
+    return repairEven.success;
   }
-  return { node_types, edge_types };
-}
-function validateInlineEdges(sourceType, _targetType, edges, manifest, opts) {
-  const strict = opts?.strict === true;
-  const entityId = opts?.entityId ?? "";
-  const drops = opts?.drops;
-  const drop = (reason, edgeType) => {
-    drops?.push({ reason, sourceId: null, edgeType, sourceNodeType: sourceType, targetNodeType: null });
-  };
-  if (!Array.isArray(edges)) {
-    if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", "");
-    drop("invalid_shape", null);
-    return [];
+  const repair = repairEven.failed !== null ? repairEven : repairOdd;
+  if (repair.failed !== null) {
+    throw new WikiParseError(
+      `Repair produced a candidate but JSON.parse rejected it: ${repair.failed.message}`,
+      { tier: "repair", position: repair.failed.position, slice: repair.failed.candidate }
+    );
   }
-  const valid = [];
-  for (const edge of edges) {
-    if (typeof edge?.edge_type !== "string" || typeof edge?.target_title !== "string") {
-      if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", String(edge?.edge_type ?? ""));
-      drop("invalid_shape", typeof edge?.edge_type === "string" ? edge.edge_type : null);
+  if (slice === null) {
+    throwNoJsonFound(text, start);
+  }
+  throw new WikiParseError(
+    "No parsable JSON candidate found",
+    { tier: "all", position: start, slice: text }
+  );
+}
+function scanJsonSlice(text, start, openChar) {
+  const closeChar = openChar === "{" ? "}" : "]";
+  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;
     }
-    const defs = resolveEdgeDefinitions(edge.edge_type, manifest);
-    const match = defs.find((d) => typeSatisfies(d.source_type, sourceType, manifest));
-    if (!match) {
-      if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", edge.edge_type);
-      drop("type_not_in_manifest", edge.edge_type);
+    if (ch === "\\" && inString) {
+      escape = true;
       continue;
     }
-    valid.push({ edge_type: match.type, target_title: edge.target_title });
-  }
-  return valid;
-}
-
-// 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;
+    if (ch === '"') {
+      inString = !inString;
+      continue;
     }
-    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;
+    if (inString) continue;
+    if (ch === openChar) {
+      depth++;
+      continue;
+    }
+    if (ch === closeChar) {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
       }
-      return vector;
-    } catch {
-      return null;
     }
   }
-  return null;
-}
-
-// 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;
+  if (end === -1) return null;
+  return safeSlice(text, start, end + 1);
 }
-
-// src/utils/indexDoc.ts
-function toIndexDoc(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;
+function containerAwareRepair(text, start, closeOnEvenParity) {
+  const stack = [];
+  let inString = false;
+  let stringRole = null;
+  let escape = false;
+  let i = start;
+  let out = "";
+  let bareQuoteCount = 0;
+  let bestFailed = null;
+  let escapes = 0;
+  let ambiguous = false;
+  let bestSuccess = null;
+  let attempts = 0;
+  function tryEmitCandidate(candidate) {
+    attempts++;
+    try {
+      bestSuccess = JSON.parse(candidate);
+      return true;
+    } catch (err) {
+      if (bestFailed === null) {
+        bestFailed = {
+          candidate,
+          position: extractParsePosition(err),
+          message: safeErrorToString(err)
+        };
       }
-    })()
-  };
-}
-
-// src/services/SearchService.ts
-var _SearchService = class _SearchService {
-  constructor(entryRepo, indexStrategy) {
-    this.entryRepo = entryRepo;
-    this.vectorCache = /* @__PURE__ */ new Map();
-    /**
-     * Serializes rebuilds. `rebuildIndex` awaits a repository read between
-     * snapshotting the previous id set and discarding it, so two concurrent
-     * sync() calls for one entity can interleave: a slow, stale read lands last
-     * and discards documents the fresh read just added. Chaining also keeps
-     * discard()/addAll() out of each other's way, which is what accrued the
-     * auto-vacuum debt behind the TypeError in #64.
-     */
-    this.syncChain = Promise.resolve();
-    /**
-     * Entities whose index may have drifted from SQLite: an incremental update
-     * failed part-way, or core wrote rows it could not index (upsertGraph runs in
-     * the host's transaction). Their next syncEntries rebuilds the entity in full.
-     * See spec 2026-09-28 §5.
-     */
-    this.staleEntities = /* @__PURE__ */ new Set();
-    /**
-     * Per-entity count of markStale() calls. A rebuild clears an entity's stale
-     * flag only when the count it snapshotted before its read still holds
-     * afterwards: markStale() runs inside the host's still-open transaction, so
-     * a call landing mid-read belongs to rows the read cannot have seen, and
-     * its flag must outlive the turn (#233 review).
-     */
-    this.staleEpochs = /* @__PURE__ */ new Map();
-    this.indexStrategy = indexStrategy;
-  }
-  /**
-   * Install the strategy resolved by `WikiMemory.setup()`. Before setup, the
-   * service runs on an empty MiniSearch placeholder, as it always has.
-   */
-  setIndexStrategy(strategy) {
-    this.indexStrategy = strategy;
+      return false;
+    }
   }
-  /**
-   * One serialized drain turn for strategies with a durable ledger. Like
-   * sync(), it never rejects: the keyword index is rebuildable, and a failed
-   * drain leaves the ledger rows in place for the next turn.
-   */
-  drainTurn(entityId) {
-    const work = this.syncChain.then(async () => {
-      try {
-        try {
-          await this.indexStrategy.drain();
-        } finally {
-          this.evictCache(entityId);
-        }
-      } catch (err) {
-        console.warn(`[WikiMemory] search index drain failed for ${entityId ?? "*"}:`, err);
+  while (i < text.length) {
+    const ch = text[i];
+    if (stack.length === 0 && !inString) {
+      if (ch === "{" || ch === "[") {
+        stack.push({ container: ch === "{" ? "object" : "array", expectKey: true });
+        out += ch;
       }
-    });
-    this.syncChain = work;
-    return work;
-  }
-  /**
-   * Rebuilds the search index and clears the vector cache for a given entity.
-   * A direct replacement for manually syncing state after a DB transaction.
-   *
-   * Rebuilds are serialized per instance and never reject: the keyword index
-   * is a rebuildable cache over SQLite, so degraded keyword search is the
-   * correct failure mode and killing the host process is not.
-   */
-  async sync(entityId) {
-    if (this.indexStrategy.drain) return this.drainTurn(entityId);
-    const work = this.syncChain.then(async () => {
-      try {
-        try {
-          const epochsBefore = new Map(this.staleEpochs);
-          if (entityId === void 0) {
-            const rows = await this.entryRepo.findMiniSearchRows();
-            await this.indexStrategy.replaceAll(rows.map(toIndexDoc));
-            for (const id of [...this.staleEntities]) {
-              if ((this.staleEpochs.get(id) ?? 0) === (epochsBefore.get(id) ?? 0)) {
-                this.staleEntities.delete(id);
-              }
-            }
-          } else {
-            await this.rebuildIndex(entityId);
-            if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
-              this.staleEntities.delete(entityId);
-            }
-          }
-          await this.indexStrategy.vacuum?.();
-        } finally {
-          this.evictCache(entityId);
-        }
-      } catch (err) {
-        console.warn(`[WikiMemory] search index rebuild failed for ${entityId ?? "*"}:`, err);
+      i++;
+      continue;
+    }
+    if (escape) {
+      out += ch;
+      escape = false;
+      i++;
+      continue;
+    }
+    if (inString && ch === "\\") {
+      out += ch;
+      escape = true;
+      i++;
+      continue;
+    }
+    if (inString) {
+      const code = ch.charCodeAt(0);
+      if (code < 32) {
+        out += controlCharEscape(code);
+        i++;
+        continue;
       }
-    });
-    this.syncChain = work;
-    return work;
-  }
-  /**
-   * Re-indexes only `ids` for `entityId`: drops each from the index, then
-   * re-adds the ones still live in SQLite, so soft-deleted or missing ids end
-   * up absent. Costs O(ids), where sync(entityId) costs O(entity) — callers that
-   * know what a write touched use this so chunked imports stay linear (#232).
-   *
-   * Serialized with sync() on the same chain and, like it, never rejects. An
-   * entity that is stale or has never been indexed gets a full rebuild instead
-   * — including on an empty `ids` list, which is a no-op only for an entity
-   * the index already tracks, and even then one that waits for rebuilds
-   * already queued on the chain.
-   */
-  async syncEntries(entityId, ids) {
-    if (this.indexStrategy.drain) return this.drainTurn(entityId);
-    const uniqueIds = [...new Set(ids)];
-    const indexed = this.indexStrategy.hasIndexedEntity?.(entityId);
-    if (uniqueIds.length === 0 && !this.staleEntities.has(entityId) && indexed === true) {
-      return this.syncChain;
     }
-    const work = this.syncChain.then(async () => {
-      try {
-        try {
-          const epochsBefore = new Map(this.staleEpochs);
-          const needsRebuild = () => this.staleEntities.has(entityId) || this.indexStrategy.hasIndexedEntity?.(entityId) !== true;
-          if (!needsRebuild()) {
-            const rows = await this.entryRepo.findMiniSearchRowsByIds(entityId, uniqueIds);
-            if (!this.staleEntities.has(entityId)) {
-              await this.indexStrategy.replace(entityId, uniqueIds, rows.map(toIndexDoc));
-              await this.indexStrategy.vacuum?.();
-              return;
-            }
-          }
-          await this.rebuildIndex(entityId);
-          if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
-            this.staleEntities.delete(entityId);
-          }
-          await this.indexStrategy.vacuum?.();
-        } finally {
-          this.evictCache(entityId);
-        }
-      } catch (err) {
-        this.staleEntities.add(entityId);
-        console.warn(`[WikiMemory] search index incremental sync failed for ${entityId}:`, err);
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < text.length && (text[j] === " " || text[j] === "	" || text[j] === "\n" || text[j] === "\r")) {
+        j++;
       }
-    });
-    this.syncChain = work;
-    return work;
-  }
-  /**
-   * Forces the entity's next syncEntries to rebuild it in full. For writes core
-   * cannot index itself, such as upsertGraph inside a host transaction.
-   */
-  markStale(entityId) {
-    if (this.indexStrategy.drain) return;
-    this.staleEntities.add(entityId);
-    this.staleEpochs.set(entityId, (this.staleEpochs.get(entityId) ?? 0) + 1);
+      const next = j < text.length ? text[j] : "";
+      if (!inString) {
+        if (next === "}" || next === "]") {
+          if (j > i + 1) out += text.slice(i + 1, j);
+          out += next;
+          i = j + 1;
+          stack.pop();
+          if (stack.length === 0) {
+            if (tryEmitCandidate(out)) return { success: bestSuccess, failed: bestFailed, escapes, ambiguous };
+            if (attempts >= MAX_REPAIR_CANDIDATES) break;
+            out = "";
+          }
+          continue;
+        }
+        const top = stack[stack.length - 1];
+        stringRole = top?.container === "object" && top.expectKey ? "key" : "value";
+        out += ch;
+        inString = true;
+        i++;
+        continue;
+      }
+      const commaOnly = next === ",";
+      const isKeyClose = stringRole === "key" && (next === ":" || next === '"' && j + 1 < text.length && text[j + 1] === ":");
+      const isValueClose = !commaOnly && (next === "," || next === "}" || next === "]");
+      if (commaOnly && bareQuoteCount > 0) ambiguous = true;
+      const shouldCommaClose = commaOnly && (bareQuoteCount === 0 || (closeOnEvenParity ? bareQuoteCount % 2 === 0 : bareQuoteCount % 2 === 1));
+      const isClosing = isKeyClose || isValueClose || shouldCommaClose;
+      if (isClosing) {
+        out += ch;
+        inString = false;
+        const topFrame = stack[stack.length - 1];
+        if (topFrame && topFrame.container === "object") {
+          topFrame.expectKey = stringRole === "value";
+        }
+        stringRole = null;
+        bareQuoteCount = 0;
+        i++;
+        continue;
+      }
+      out += "\\" + ch;
+      bareQuoteCount++;
+      escapes++;
+      i++;
+      continue;
+    }
+    if (!inString && (ch === "{" || ch === "[")) {
+      stack.push({ container: ch === "{" ? "object" : "array", expectKey: true });
+      out += ch;
+      i++;
+      continue;
+    }
+    if (!inString && ch === ",") {
+      const topFrame = stack[stack.length - 1];
+      if (topFrame && topFrame.container === "object") {
+        topFrame.expectKey = true;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (!inString && (ch === "}" || ch === "]")) {
+      out += ch;
+      stack.pop();
+      if (stack.length === 0) {
+        if (tryEmitCandidate(out)) return { success: bestSuccess, failed: bestFailed, escapes, ambiguous };
+        if (attempts >= MAX_REPAIR_CANDIDATES) break;
+        out = "";
+      }
+      i++;
+      continue;
+    }
+    out += ch;
+    i++;
   }
-  /**
-   * Runs syncEntries(id, []) for each entity marked stale when this is called,
-   * so only those entities are rebuilt. Each rebuild still takes its own turn
-   * on the sync chain, and like syncEntries this never rejects. With nothing
-   * stale it resolves at once, without waiting on work already on the chain.
-   */
-  async syncStale() {
-    if (this.indexStrategy.drain) return this.drainTurn();
-    const ids = [...this.staleEntities];
-    await Promise.all(ids.map((id) => this.syncEntries(id, [])));
+  return { success: null, failed: bestFailed, escapes, ambiguous };
+}
+function controlCharEscape(code) {
+  switch (code) {
+    case 10:
+      return "\\n";
+    case 9:
+      return "\\t";
+    case 13:
+      return "\\r";
+    case 8:
+      return "\\b";
+    case 12:
+      return "\\f";
+    default:
+      return "\\u" + code.toString(16).padStart(4, "0");
   }
-  /**
-   * Clears the parsed vector cache. Useful for mid-loop flush guarantees
-   * or memory pressure evictions.
-   */
-  evictCache(entityId) {
-    if (entityId) {
-      this.vectorCache.delete(entityId);
-    } else {
-      this.vectorCache.clear();
+}
+function extractParsePosition(err) {
+  const match = /position\s+(\d+)/.exec(safeErrorToString(err));
+  return match ? Number(match[1]) : null;
+}
+function safeErrorToString(e) {
+  let isErrorLike = false;
+  try {
+    isErrorLike = e instanceof Error;
+  } catch {
+  }
+  if (isErrorLike) {
+    const msg = readErrorField(e, "message");
+    if (typeof msg === "string" && msg.length > 0) return msg;
+    const name = readErrorField(e, "name");
+    if (typeof name === "string" && name.length > 0) return name;
+    return "[Error]";
+  }
+  try {
+    return String(e);
+  } catch {
+    try {
+      return Object.prototype.toString.call(e);
+    } catch {
+      return "[unstringifiable error]";
     }
   }
-  /**
-   * Fully resets the search service.
-   */
-  async clearAll() {
-    this.vectorCache.clear();
-    await this.indexStrategy.replaceAll([]);
-    this.staleEntities.clear();
-    this.staleEpochs.clear();
+}
+function readErrorField(e, key) {
+  try {
+    return e[key];
+  } catch {
+    return void 0;
   }
-  /**
-   * Executes a keyword search against the active index strategy.
-   */
-  async searchKeyword(query, entityIds, limit) {
-    const results = finiteResults(await this.indexStrategy.search(query, { entityIds, limit }));
-    return results.sort((a, b) => this._compareSearchResults(a, b)).slice(0, limit);
+}
+function sanitizeRankerError(err, sanitizeRankerErrors) {
+  let isErrorLike = false;
+  try {
+    isErrorLike = err instanceof Error;
+  } catch {
   }
-  /**
-   * Pre-fetches keyword scores for candidate hydration, used during hybrid weighting.
-   */
-  async getKeywordScores(query, entityIds, preFilterLimit) {
-    const opts = preFilterLimit !== void 0 ? { entityIds, limit: preFilterLimit, preFilterLimit } : { entityIds, limit: Number.MAX_SAFE_INTEGER };
-    const results = finiteResults(await this.indexStrategy.search(query, opts));
-    if (results.length === 0) return /* @__PURE__ */ new Map();
-    const maxScore = Math.max(1, results[0]?.score ?? 1);
-    return new Map(results.map((r) => [r.id, r.score / maxScore]));
+  if (sanitizeRankerErrors === false) {
+    return isErrorLike ? err : new Error(safeErrorToString(err));
   }
-  /**
-   * Score candidate rows using in-process JS cosine similarity.
-   * Applies hybrid blending (if weight set) and tie-break sorting before returning.
-   */
-  async rankSemantic(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 > _SearchService.MAX_VECTOR_CACHE_FACTS_PER_ENTITY;
-    if (tooLarge && entityCache) {
-      this.vectorCache.delete(entityId);
-      entityCache = void 0;
+  let errLike = null;
+  if (isErrorLike) errLike = err;
+  let typeName;
+  try {
+    if (errLike) {
+      const rawName = errLike.constructor?.name;
+      typeName = typeof rawName === "string" ? rawName : "Error";
+    } else {
+      typeName = typeof err;
     }
-    const canCache = populateCache && !tooLarge;
-    if (canCache && !entityCache) {
-      entityCache = /* @__PURE__ */ new Map();
+  } catch {
+    typeName = isErrorLike ? "Error" : typeof err;
+  }
+  let innerCause;
+  if (errLike) {
+    let cause;
+    try {
+      cause = errLike.cause;
+    } catch {
+      cause = void 0;
     }
-    const scored = candidateRows.map((row) => {
-      let vector = entityCache?.get(row.id) ?? parseEmbedding(row.embedding_blob, row.embedding);
-      if (vector && canCache && entityCache && !entityCache.has(row.id)) {
-        entityCache.set(row.id, vector);
-      }
-      let score = 0;
-      if (vector && vector.length === queryVec.length) {
-        const cosSim = cosineSimilarity(queryVec, vector);
-        if (weight !== void 0) {
-          const kwScore = miniSearchScores?.get(row.id) ?? 0;
-          score = weight * Math.max(0, cosSim) + (1 - weight) * kwScore;
-        } else {
-          score = cosSim;
-        }
-      } else if (weight !== void 0 && weight < 1) {
-        const kwScore = miniSearchScores?.get(row.id) ?? 0;
-        score = (1 - weight) * kwScore;
-      } else {
-        score = -2;
-      }
-      return {
-        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 >= _SearchService.MAX_VECTOR_CACHE_ENTITIES) {
-          const oldestKey = this.vectorCache.keys().next().value;
-          if (oldestKey !== void 0) this.vectorCache.delete(oldestKey);
-        }
-        this.vectorCache.set(entityId, entityCache);
+    if (cause !== void 0) {
+      let causeName;
+      try {
+        const rawCauseName = cause?.constructor?.name;
+        causeName = typeof rawCauseName === "string" ? rawCauseName : typeof cause;
+      } catch {
+        causeName = typeof cause;
       }
+      innerCause = new Error(`Caused by: ${causeName}`);
     }
-    if (!skipSort) {
-      this._tieBreakSort(scored);
-    }
-    return scored.slice(0, limit);
   }
-  // --- Internal Index Management ---
-  /**
-   * Rebuild a single entity's index from scratch. Reads every row for
-   * `entityId` from the repository (already filtered by `deleted_at IS NULL`)
-   * and hands the lot to `indexStrategy.replaceEntity`, which owns the
-   * drop-then-add bookkeeping so callers don't need to know the strategy's
-   * id-tracking shape.
-   */
-  async rebuildIndex(entityId) {
-    const rows = await this.entryRepo.findMiniSearchRows(entityId);
-    await this.indexStrategy.replaceEntity(entityId, rows.map(toIndexDoc));
+  const sanitized = new Error(
+    `VectorRanker ${typeName} (message scrubbed for security)`,
+    innerCause ? { cause: innerCause } : void 0
+  );
+  try {
+    sanitized.name = typeName;
+  } catch {
   }
-  _tieBreakSort(items) {
-    items.sort((a, b) => this._compareScoredRows(a, b));
+  return sanitized;
+}
+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];
   }
-  _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);
+  if (safeStart > 0 && safeStart < length && value.charCodeAt(safeStart) >= 56320 && value.charCodeAt(safeStart) <= 57343 && value.charCodeAt(safeStart - 1) >= 55296 && value.charCodeAt(safeStart - 1) <= 56319) {
+    safeStart--;
   }
-  /**
-   * The keyword index breaks equal-score ties by internal insertion order,
-   * which syncEntries changes: a discarded-and-re-added id moves to the end.
-   * Every caller truncates these results to a limit, so which ids survive a
-   * tie at the boundary must not depend on write history. Re-sort exact
-   * score ties by id — the same final tie-break _compareScoredRows applies.
-   */
-  _compareSearchResults(a, b) {
-    const scoreDiff = b.score - a.score;
-    if (!Number.isNaN(scoreDiff) && scoreDiff !== 0) return scoreDiff;
-    return a.id.localeCompare(b.id);
+  if (safeEnd > 0 && safeEnd < length && value.charCodeAt(safeEnd - 1) >= 55296 && value.charCodeAt(safeEnd - 1) <= 56319 && value.charCodeAt(safeEnd) >= 56320 && value.charCodeAt(safeEnd) <= 57343) {
+    safeEnd--;
   }
-};
-/**
- * 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).
- */
-_SearchService.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.
- */
-_SearchService.MAX_VECTOR_CACHE_FACTS_PER_ENTITY = 500;
-var SearchService = _SearchService;
-function finiteResults(results) {
-  return results.every((r) => Number.isFinite(r.score)) ? results : results.filter((r) => Number.isFinite(r.score));
+  return value.slice(safeStart, safeEnd);
 }
-
-// src/services/JobManager.ts
-var JobManager = class {
-  constructor(prefix) {
-    this.prefix = prefix;
-    this.activeMaintenanceJobs = /* @__PURE__ */ new Set();
-    this.activeIngestJobs = /* @__PURE__ */ new Map();
-    /**
-     * Per-(entityId, sourceHash) promise-chain lock. Serializes ingest races
-     * at the application level (the v9 partial UNIQUE index enforces it at
-     * the DB level as defense-in-depth). Two callers holding the same hash
-     * see FIFO order; different hashes never block one another.
-     *
-     * Keyed `${entityId}\0${sourceHash}` so distinct (entityId, sourceHash)
-     * pairs can never share a lock. A raw concatenation would let
-     * ("ab", "c…") collide with ("a", "bc…"); the NUL separator makes that
-     * impossible because neither component can contain NUL (entityIds are
-     * user-supplied identifiers; sourceHashes are hex digests).
-     */
-    this.hashLocks = /* @__PURE__ */ new Map();
-    this.statusSubscribers = /* @__PURE__ */ new Map();
-    /**
-     * Lookup table for acquireLock/releaseLock's dynamic-dispatch branch.
-     * Excludes 'ingest' | 'global_reembed' | 'global_import', which those
-     * methods already handle via explicit if/else branches before reaching
-     * this table.
-     */
-    this.lockKeyFns = {
-      prune: (id) => this._pruneKey(id),
-      librarian: (id) => this._librarianKey(id),
-      heal: (id) => this._healKey(id),
-      reembed: (id) => this._reembedKey(id),
-      import: (id) => this._importKey(id),
-      forget: (id) => this._forgetKey(id),
-      ontologyBackfill: (id) => this._ontologyBackfillKey(id)
-    };
+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");
   }
-  _hashLockKey(entityId, sourceHash) {
-    return `${entityId}\0${sourceHash}`;
+  if (!Number.isInteger(overlap) || overlap < 0 || overlap >= maxChunkLength) {
+    throw new Error("overlap must be a non-negative integer < maxChunkLength");
   }
-  /**
-   * Acquire a promise-chain lock scoped to one `(entityId, sourceHash)` pair.
-   * Returns a zero-argument release closure that removes the current tail
-   * from the chain. Releasing is idempotent so a holder that double-fires
-   * (e.g. on a finally that races an explicit release) cannot unblock
-   * the next holder prematurely.
-   *
-   * Documented ordering: ingest acquires the hash lock FIRST, then the
-   * synchronous sourceRef ingest lock, and the release closure unwinds in
-   * the opposite order (sourceRef first, hash second). Hash-then-sourceRef
-   * is required because the v9 partial UNIQUE index conflicts on the
-   * (entity_id, source_hash) pair regardless of source_ref, so two callers
-   * with DIFFERENT source_refs racing the same hash are the exact case the
-   * TOCTOU race fix needs to serialize.
-   *
-   * Mechanics: each holder owns a private `released` promise that resolves
-   * only when THIS holder calls release(). The map stores the holder's
-   * `released` promise as the "tail" — the NEXT caller awaits that tail
-   * via `previous = this.hashLocks.get(key)`. The current caller gets
-   * their unique release function once `previous` (the prior holder's
-   * release signal) settles, so each holder is guaranteed a UNIQUE release
-   * closure bound to their own `released` promise.
-   */
-  acquireHashLock(entityId, sourceHash) {
-    const key = this._hashLockKey(entityId, sourceHash);
-    const previous = this.hashLocks.get(key) ?? Promise.resolve();
-    let resolveReleased;
-    const released = new Promise((resolve) => {
-      resolveReleased = resolve;
-    });
-    let fired = false;
-    const release = () => {
-      if (fired) return;
-      fired = true;
-      if (this.hashLocks.get(key) === released) {
-        this.hashLocks.delete(key);
+  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;
+        }
       }
-      resolveReleased();
-    };
-    this.hashLocks.set(key, released);
-    return previous.then(() => release);
-  }
-  _pruneKey(entityId) {
-    return `${this.prefix}:${entityId}:prune`;
-  }
-  _reembedKey(entityId) {
-    return `${this.prefix}:${entityId}:reembed`;
-  }
-  _globalReembedKey() {
-    return `${this.prefix}:reembed`;
-  }
-  _importKey(entityId) {
-    return `${this.prefix}:${entityId}:import`;
-  }
-  _globalImportKey() {
-    return `${this.prefix}:import`;
+      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;
   }
-  _forgetKey(entityId) {
-    return `${this.prefix}:${entityId}:forget`;
+  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;
+      }
+    }
   }
-  _librarianKey(entityId) {
-    return `${this.prefix}:${entityId}:librarian`;
+  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);
+}
+var MAX_EVIDENCE_QUOTES = 10;
+function normalizeEvidence(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry !== "string") continue;
+    const trimmed = entry.trim();
+    if (!trimmed) continue;
+    out.push(trimmed);
+    if (out.length > MAX_EVIDENCE_QUOTES) break;
   }
-  _healKey(entityId) {
-    return `${this.prefix}:${entityId}:heal`;
-  }
-  _ontologyBackfillKey(entityId) {
-    return `${this.prefix}:${entityId}:ontologyBackfill`;
+  return out;
+}
+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";
+  const valid = {
+    ...fact,
+    title,
+    body,
+    confidence,
+    tags: validateTags(fact.tags)
+  };
+  const evidence = normalizeEvidence(fact.evidence);
+  if (evidence) valid.evidence = evidence;
+  else delete valid.evidence;
+  return valid;
+}
+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;
+  priority = Math.max(0, Math.min(10, Math.round(priority)));
+  return {
+    ...task,
+    description,
+    priority
+  };
+}
+function factRejectionReason(raw) {
+  const fact = raw;
+  if (typeof fact?.title !== "string" || typeof fact?.body !== "string") return "invalid_shape";
+  if (!clip(fact.title, 80)) return "missing_title";
+  return "missing_body";
+}
+function taskRejectionReason(raw) {
+  const task = raw;
+  if (typeof task?.description !== "string") return "invalid_shape";
+  return "missing_description";
+}
+function normalizeSourceRef(value) {
+  if (typeof value !== "string") return null;
+  const cleaned = value.replace(/[^A-Za-z0-9._\- ]/g, "").trim().slice(0, 255).trimEnd();
+  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;
+}
+
+// src/utils/ids.ts
+var _injectedGetRandomValues = null;
+function configureRandomSource(fn) {
+  _injectedGetRandomValues = fn;
+}
+function generateId(prefix = "") {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return prefix + crypto.randomUUID().replace(/-/g, "").substring(0, 24);
   }
-  _isReembedActive(entityId) {
-    return this.activeMaintenanceJobs.has(this._reembedKey(entityId)) || this.activeMaintenanceJobs.has(this._globalReembedKey());
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return prefix + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("").substring(0, 24);
   }
-  /**
-   * True while any reembed sweep is in flight — per-entity or global.
-   *
-   * Read-only; acquires nothing. Callers that mutate embedding failure
-   * markers across ALL entities (the dimension-promotion clear) must gate on
-   * this and defer, rather than resurrect rows an in-flight sweep already
-   * classified. See spec 2026-09-05-reembed-lock-scope-design.md §2.
-   *
-   * The global key `${prefix}:reembed` also ends in ':reembed', so the suffix
-   * scan alone would already match it. The explicit check is kept because it
-   * documents the intent and survives any future change to the global key's
-   * format.
-   */
-  isAnyReembedActive() {
-    return this.activeMaintenanceJobs.has(this._globalReembedKey()) || this._isAnyMaintenanceActiveWithSuffix(":reembed");
+  if (_injectedGetRandomValues) {
+    const bytes = new Uint8Array(16);
+    _injectedGetRandomValues(bytes);
+    return prefix + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("").substring(0, 24);
   }
-  _isImportActiveFor(entityId) {
-    return this.activeMaintenanceJobs.has(this._importKey(entityId)) || this.activeMaintenanceJobs.has(this._globalImportKey());
+  throw new Error(
+    "generateId: no cryptographically secure random source available (crypto.randomUUID and crypto.getRandomValues are both missing, and no configureRandomSource() injection was provided)."
+  );
+}
+
+// src/utils/ontology.ts
+function emptyManifest() {
+  return { node_types: [], edge_types: [] };
+}
+function normalizeTitleKey(title) {
+  return title.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function resolveNodeType(raw, manifest) {
+  const slug = raw.trim();
+  if (!slug) return null;
+  const hit = manifest.node_types.find((n) => n.type.toLowerCase() === slug.toLowerCase());
+  return hit?.type ?? null;
+}
+function resolveEdgeDefinitions(rawEdgeType, manifest) {
+  const slug = rawEdgeType.trim();
+  if (!slug) return [];
+  return manifest.edge_types.filter((e) => e.type.toLowerCase() === slug.toLowerCase());
+}
+function edgeTripleKey(type, sourceType, targetType) {
+  return `${type.trim().toLowerCase()}|${sourceType.trim().toLowerCase()}|${targetType.trim().toLowerCase()}`;
+}
+function typeSatisfies(declaredType, concreteType, manifest) {
+  const concrete = concreteType.trim().toLowerCase();
+  const declared = declaredType.trim().toLowerCase();
+  if (!concrete || !declared) return false;
+  if (declared === concrete) return true;
+  const def = (manifest.node_types ?? []).find(
+    (n) => typeof n?.type === "string" && n.type.trim().toLowerCase() === concrete
+  );
+  const parent = typeof def?.parent_type === "string" ? def.parent_type.trim().toLowerCase() : "";
+  return parent !== "" && parent === declared;
+}
+function edgeTripleAllowed(manifest, edgeType, sourceType, targetType) {
+  const wanted = edgeType.trim().toLowerCase();
+  return (manifest.edge_types ?? []).some((d) => typeof d?.type === "string" && d.type.trim().toLowerCase() === wanted && typeof d.source_type === "string" && typeSatisfies(d.source_type, sourceType, manifest) && typeof d.target_type === "string" && typeSatisfies(d.target_type, targetType, manifest));
+}
+function validateManifest(manifest) {
+  const nodeSlugs = /* @__PURE__ */ new Set();
+  for (const node of manifest.node_types ?? []) {
+    const type = node.type?.trim();
+    if (!type) throw new Error("Ontology node type slug must be non-empty");
+    const key = type.toLowerCase();
+    if (nodeSlugs.has(key)) throw new Error(`Duplicate node type: ${type}`);
+    nodeSlugs.add(key);
   }
-  _isForgetActiveFor(entityId) {
-    return this.activeMaintenanceJobs.has(this._forgetKey(entityId));
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const node of manifest.node_types ?? []) {
+    const parent = typeof node.parent_type === "string" ? node.parent_type.trim().toLowerCase() : void 0;
+    parentOf.set(node.type.trim().toLowerCase(), parent);
   }
-  _isAnyMaintenanceActiveWithSuffix(suffix) {
-    const entityKeyPrefix = `${this.prefix}:`;
-    for (const k of this.activeMaintenanceJobs) {
-      if (k.startsWith(entityKeyPrefix) && k.endsWith(suffix)) return true;
+  for (const node of manifest.node_types ?? []) {
+    if (node.parent_type === void 0) continue;
+    if (typeof node.parent_type !== "string" || !node.parent_type.trim()) {
+      throw new Error(`Ontology parent_type must be a non-empty string when present: ${node.type}`);
     }
-    return false;
-  }
-  _hasIngestJob(entityId, sourceRef) {
-    return this.activeIngestJobs.get(entityId)?.has(sourceRef ?? "") ?? false;
-  }
-  _addIngestJob(entityId, sourceRef) {
-    const sourceKey = sourceRef ?? "";
-    let refs = this.activeIngestJobs.get(entityId);
-    if (!refs) {
-      refs = /* @__PURE__ */ new Set();
-      this.activeIngestJobs.set(entityId, refs);
+    const parentSlug = node.parent_type.trim().toLowerCase();
+    if (parentSlug === node.type.trim().toLowerCase()) {
+      throw new Error(`Self-parent: ${node.type}`);
+    }
+    if (!nodeSlugs.has(parentSlug)) {
+      throw new Error(`Parent type not found: ${node.parent_type}`);
+    }
+    const grandparent = parentOf.get(parentSlug);
+    if (grandparent) {
+      throw new Error(`Parent chain too deep: ${node.type} \u2192 ${node.parent_type} \u2192 ${grandparent}`);
     }
-    refs.add(sourceKey);
   }
-  _removeIngestJob(entityId, sourceRef) {
-    const sourceKey = sourceRef ?? "";
-    const refs = this.activeIngestJobs.get(entityId);
-    if (!refs) return;
-    refs.delete(sourceKey);
-    if (refs.size === 0) {
-      this.activeIngestJobs.delete(entityId);
+  const edgeKeys = /* @__PURE__ */ new Set();
+  const edgeNames = /* @__PURE__ */ new Map();
+  for (const edge of manifest.edge_types ?? []) {
+    const edgeType = edge.type?.trim();
+    const sourceType = edge.source_type?.trim();
+    const targetType = edge.target_type?.trim();
+    if (!edgeType) throw new Error("Ontology edge type slug must be non-empty");
+    if (!sourceType || !targetType || !nodeSlugs.has(sourceType.toLowerCase()) || !nodeSlugs.has(targetType.toLowerCase())) {
+      throw new Error(`Edge type ${edgeType} references unknown node type`);
+    }
+    const edgeKey = edgeTripleKey(edgeType, sourceType, targetType);
+    if (edgeKeys.has(edgeKey)) {
+      throw new Error(`Duplicate edge definition: ${edgeType} (${sourceType} \u2192 ${targetType})`);
+    }
+    edgeKeys.add(edgeKey);
+    const canonical = edgeNames.get(edgeType.toLowerCase());
+    if (canonical === void 0) {
+      edgeNames.set(edgeType.toLowerCase(), edgeType);
+    } else if (canonical !== edgeType) {
+      throw new Error(`Inconsistent casing for edge type: ${edgeType} conflicts with ${canonical}`);
     }
   }
-  _isIngestActiveFor(entityId) {
-    return this.activeIngestJobs.has(entityId);
+}
+function buildDeclaresParentIndex(nodes) {
+  const declaresParent = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const slug = typeof n?.type === "string" ? n.type.trim().toLowerCase() : "";
+    if (!slug || declaresParent.has(slug)) continue;
+    declaresParent.set(slug, n?.parent_type !== void 0);
   }
-  acquireLock(operation, entityId, sourceRef) {
-    let blockingOperation = null;
-    if (operation !== "global_import" && this.activeMaintenanceJobs.has(this._globalImportKey())) {
-      throw new WikiBusyError("import", "*");
-    }
-    switch (operation) {
-      case "prune":
-        if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) 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.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId))) blockingOperation = "ontologyBackfill";
-        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";
-        break;
-      case "librarian":
-      case "heal":
-      case "ontologyBackfill": {
-        const opKey = this.lockKeyFns[operation](entityId);
-        if (this.activeMaintenanceJobs.has(opKey)) blockingOperation = operation;
-        else if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) blockingOperation = "prune";
-        else if (this._isReembedActive(entityId)) blockingOperation = "reembed";
-        else if (this._isImportActiveFor(entityId)) blockingOperation = "import";
-        else if (this._isForgetActiveFor(entityId)) blockingOperation = "forget";
-        break;
-      }
-      case "reembed":
-        if (this.activeMaintenanceJobs.has(this._reembedKey(entityId))) blockingOperation = "reembed";
-        else if (this.activeMaintenanceJobs.has(this._globalReembedKey())) blockingOperation = "reembed";
-        else if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) 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.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId))) blockingOperation = "ontologyBackfill";
-        else if (this._isIngestActiveFor(entityId)) blockingOperation = "ingest";
-        else if (this._isImportActiveFor(entityId)) blockingOperation = "import";
-        else if (this._isForgetActiveFor(entityId)) blockingOperation = "forget";
-        break;
-      case "global_reembed":
-        if (this.activeMaintenanceJobs.has(this._globalReembedKey())) blockingOperation = "reembed";
-        else if (this._isAnyMaintenanceActiveWithSuffix(":reembed")) blockingOperation = "reembed";
-        else if (this._isAnyMaintenanceActiveWithSuffix(":prune")) blockingOperation = "prune";
-        else if (this._isAnyMaintenanceActiveWithSuffix(":librarian")) blockingOperation = "librarian";
-        else if (this._isAnyMaintenanceActiveWithSuffix(":heal")) blockingOperation = "heal";
-        else if (this._isAnyMaintenanceActiveWithSuffix(":ontologyBackfill")) blockingOperation = "ontologyBackfill";
-        else if (this.activeIngestJobs.size > 0) blockingOperation = "ingest";
-        else if (this._isAnyMaintenanceActiveWithSuffix(":import")) blockingOperation = "import";
-        else if (this._isAnyMaintenanceActiveWithSuffix(":forget")) blockingOperation = "forget";
-        break;
-      case "import":
-      case "forget": {
-        const selfKey = operation === "import" ? this._importKey(entityId) : this._forgetKey(entityId);
-        if (this.activeMaintenanceJobs.has(selfKey)) blockingOperation = operation;
-        else 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._ontologyBackfillKey(entityId))) blockingOperation = "ontologyBackfill";
-        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";
-        break;
-      }
-      case "global_import":
-        if (this.activeMaintenanceJobs.has(this._globalImportKey())) blockingOperation = "import";
-        break;
-      case "ingest": {
-        const sourceKey = sourceRef ?? "";
-        if (this._hasIngestJob(entityId, sourceKey)) blockingOperation = "ingest";
-        else if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) blockingOperation = "prune";
-        else if (this._isReembedActive(entityId)) blockingOperation = "reembed";
-        else if (this._isImportActiveFor(entityId)) blockingOperation = "import";
-        else if (this._isForgetActiveFor(entityId)) blockingOperation = "forget";
-        break;
-      }
-    }
-    if (blockingOperation) {
-      throw new WikiBusyError(
-        blockingOperation,
-        operation === "global_reembed" || operation === "global_import" ? "*" : entityId
-      );
+  return declaresParent;
+}
+function mergeOntologyUpdates(current, updates) {
+  const node_types = [...current.node_types];
+  const edge_types = [...current.edge_types];
+  const nodeSlugs = new Set(node_types.map((n) => n.type.trim().toLowerCase()));
+  const edgeKeys = new Set(edge_types.map((e) => edgeTripleKey(e.type, e.source_type, e.target_type)));
+  const edgeNames = new Map(edge_types.map((e) => [e.type.trim().toLowerCase(), e.type.trim()]));
+  const declaresParent = buildDeclaresParentIndex([
+    ...current.node_types,
+    ...updates.node_types ?? []
+  ]);
+  for (const node of updates.node_types ?? []) {
+    const type = node?.type?.trim();
+    if (!type) continue;
+    const key = type.toLowerCase();
+    if (nodeSlugs.has(key)) continue;
+    const rawParent = typeof node?.parent_type === "string" ? node.parent_type.trim() : "";
+    const parentSlug = rawParent.toLowerCase();
+    const keepParent = parentSlug !== "" && parentSlug !== key && declaresParent.get(parentSlug) === false;
+    node_types.push({
+      type,
+      description: String(node.description ?? ""),
+      ...keepParent ? { parent_type: rawParent } : {}
+    });
+    nodeSlugs.add(key);
+  }
+  for (const edge of updates.edge_types ?? []) {
+    const rawEdgeType = edge?.type?.trim();
+    const sourceType = edge?.source_type?.trim();
+    const targetType = edge?.target_type?.trim();
+    if (!rawEdgeType || !sourceType || !targetType) continue;
+    const edgeType = edgeNames.get(rawEdgeType.toLowerCase()) ?? rawEdgeType;
+    const edgeKey = edgeTripleKey(edgeType, sourceType, targetType);
+    if (edgeKeys.has(edgeKey)) continue;
+    if (!nodeSlugs.has(sourceType.toLowerCase()) || !nodeSlugs.has(targetType.toLowerCase())) continue;
+    edgeNames.set(edgeType.toLowerCase(), edgeType);
+    edge_types.push({
+      type: edgeType,
+      source_type: sourceType,
+      target_type: targetType,
+      description: String(edge.description ?? "")
+    });
+    edgeKeys.add(edgeKey);
+  }
+  return { node_types, edge_types };
+}
+function validateInlineEdges(sourceType, _targetType, edges, manifest, opts) {
+  const strict = opts?.strict === true;
+  const entityId = opts?.entityId ?? "";
+  const drops = opts?.drops;
+  const drop = (reason, edgeType) => {
+    drops?.push({ reason, sourceId: null, edgeType, sourceNodeType: sourceType, targetNodeType: null });
+  };
+  if (!Array.isArray(edges)) {
+    if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", "");
+    drop("invalid_shape", null);
+    return [];
+  }
+  const valid = [];
+  for (const edge of edges) {
+    if (typeof edge?.edge_type !== "string" || typeof edge?.target_title !== "string") {
+      if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", String(edge?.edge_type ?? ""));
+      drop("invalid_shape", typeof edge?.edge_type === "string" ? edge.edge_type : null);
+      continue;
     }
-    if (operation === "ingest") {
-      this._addIngestJob(entityId, sourceRef);
-    } else if (operation === "global_reembed") {
-      this.activeMaintenanceJobs.add(this._globalReembedKey());
-    } else if (operation === "global_import") {
-      this.activeMaintenanceJobs.add(this._globalImportKey());
-    } else {
-      this.activeMaintenanceJobs.add(this.lockKeyFns[operation](entityId));
+    const defs = resolveEdgeDefinitions(edge.edge_type, manifest);
+    const match = defs.find((d) => typeSatisfies(d.source_type, sourceType, manifest));
+    if (!match) {
+      if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", edge.edge_type);
+      drop("type_not_in_manifest", edge.edge_type);
+      continue;
     }
-    this._notifyStatusSubscribers(entityId);
+    valid.push({ edge_type: match.type, target_title: edge.target_title });
   }
-  releaseLock(operation, entityId, sourceRef) {
-    if (operation === "ingest") {
-      this._removeIngestJob(entityId, sourceRef);
-    } else if (operation === "global_reembed") {
-      this.activeMaintenanceJobs.delete(this._globalReembedKey());
-    } else if (operation === "global_import") {
-      this.activeMaintenanceJobs.delete(this._globalImportKey());
-    } else {
-      this.activeMaintenanceJobs.delete(this.lockKeyFns[operation](entityId));
+  return valid;
+}
+
+// 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;
     }
-    this._notifyStatusSubscribers(entityId);
+    return vector;
   }
-  /**
-   * Returns true if acquireLock(operation, entityId) would throw WikiBusyError.
-   * Use for non-throwing conflict checks (e.g. auto-trigger gating in write()).
-   */
-  isBlocked(operation, entityId) {
-    if (operation !== "global_import" && this.activeMaintenanceJobs.has(this._globalImportKey())) return true;
-    switch (operation) {
-      case "librarian":
-      case "heal":
-      case "ontologyBackfill":
-        return this.activeMaintenanceJobs.has(this.lockKeyFns[operation](entityId)) || this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this._isReembedActive(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
-      case "prune":
-        return this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this.activeMaintenanceJobs.has(this._librarianKey(entityId)) || this.activeMaintenanceJobs.has(this._healKey(entityId)) || this.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId)) || this._isReembedActive(entityId) || this._isIngestActiveFor(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
-      case "reembed":
-        return this.activeMaintenanceJobs.has(this._reembedKey(entityId)) || this.activeMaintenanceJobs.has(this._globalReembedKey()) || this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this.activeMaintenanceJobs.has(this._librarianKey(entityId)) || this.activeMaintenanceJobs.has(this._healKey(entityId)) || this.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId)) || this._isIngestActiveFor(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
-      case "global_reembed":
-        return this.activeMaintenanceJobs.has(this._globalReembedKey()) || this._isAnyMaintenanceActiveWithSuffix(":reembed") || this._isAnyMaintenanceActiveWithSuffix(":prune") || this._isAnyMaintenanceActiveWithSuffix(":librarian") || this._isAnyMaintenanceActiveWithSuffix(":heal") || this._isAnyMaintenanceActiveWithSuffix(":ontologyBackfill") || this.activeIngestJobs.size > 0 || this._isAnyMaintenanceActiveWithSuffix(":import") || this._isAnyMaintenanceActiveWithSuffix(":forget");
-      case "import":
-      case "forget": {
-        const selfKey = operation === "import" ? this._importKey(entityId) : this._forgetKey(entityId);
-        return this.activeMaintenanceJobs.has(selfKey) || this.activeMaintenanceJobs.has(this._librarianKey(entityId)) || this.activeMaintenanceJobs.has(this._healKey(entityId)) || this.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId)) || this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this._isReembedActive(entityId) || this._isIngestActiveFor(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
+  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;
       }
-      case "global_import":
-        return this.activeMaintenanceJobs.has(this._globalImportKey());
-      case "ingest":
-        return this._hasIngestJob(entityId) || this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this._isReembedActive(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
-      default:
-        return false;
+      return vector;
+    } catch {
+      return null;
     }
   }
-  /**
-   * Auto-heal historically only gated on the heal self-key. Keep that
-   * permissiveness for write() auto-trigger paths — stricter checks stay in
-   * acquireLock() — with one exception: reembed sweeps, which are excluded
-   * structurally rather than by accident (see below).
-   */
-  tryAcquireAutoHealLock(entityId) {
-    if (this.isAnyReembedActive()) return false;
-    const healKey = this._healKey(entityId);
-    if (this.activeMaintenanceJobs.has(healKey)) return false;
-    this.activeMaintenanceJobs.add(healKey);
-    this._notifyStatusSubscribers(entityId);
-    return true;
+  return null;
+}
+
+// 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];
   }
-  /**
-   * Centralized ingest lock acquisition. Acquires the hash lock FIRST
-   * (FIFO across callers racing the same hash), then the synchronous
-   * sourceRef ingest lock (rejects cross-entity conflicts and busy
-   * operations). Returns a single zero-argument release closure that
-   * unwinds in the opposite order — sourceRef first, hash second — so
-   * the sourceRef lock is freed the instant its work is done and only
-   * the hash lock keeps serializing the duplicate-content race window.
-   *
-   * On a sourceRef conflict (WikiBusyError thrown synchronously by the
-   * underlying acquireLock) the hash lock is released BEFORE the error
-   * propagates, so the next caller in the hash chain is not held up by
-   * a request that never reached the DB.
-   */
-  async acquireIngestLocks(entityId, sourceRef, sourceHash) {
-    const releaseHash = await this.acquireHashLock(entityId, sourceHash);
-    let sourceLockAcquired = false;
-    try {
-      this.acquireLock("ingest", entityId, sourceRef);
-      sourceLockAcquired = true;
-    } catch (err) {
-      releaseHash();
-      throw err;
-    }
-    return () => {
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+// src/utils/indexDoc.ts
+function toIndexDoc(row) {
+  return {
+    id: row.id,
+    entity_id: row.entity_id,
+    title: row.title,
+    body: row.body,
+    tags: (() => {
       try {
-        if (sourceLockAcquired) this.releaseLock("ingest", entityId, sourceRef);
-      } finally {
-        releaseHash();
+        const parsed = JSON.parse(row.tags);
+        return Array.isArray(parsed) ? parsed.join(" ") : row.tags;
+      } catch {
+        return row.tags;
       }
-    };
+    })()
+  };
+}
+
+// src/services/search/UnavailableIndexStrategy.ts
+var UnavailableIndexStrategy = class {
+  constructor(cause) {
+    this.cause = cause;
   }
-  /**
-   * Validates then acquires global + per-entity import locks atomically.
-   * Validates all entities before acquiring any lock (same as current importDump semantics).
-   */
-  acquireImportLocks(entityIds) {
-    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._ontologyBackfillKey(entityId))) throw new WikiBusyError("ontologyBackfill", entityId);
-      if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) throw new WikiBusyError("prune", entityId);
-      if (this._isReembedActive(entityId)) throw new WikiBusyError("reembed", entityId);
-      if (this._isIngestActiveFor(entityId)) throw new WikiBusyError("ingest", entityId);
-      if (this._isForgetActiveFor(entityId)) throw new WikiBusyError("forget", entityId);
-    }
-    if (this.activeMaintenanceJobs.has(this._globalImportKey())) throw new WikiBusyError("import", "*");
-    this.activeMaintenanceJobs.add(this._globalImportKey());
-    for (const entityId of entityIds) {
-      this.activeMaintenanceJobs.add(this._importKey(entityId));
-    }
+  async search(_query, options) {
+    if (options.entityIds.length === 0) return [];
+    throw new WikiSearchUnavailableError(void 0, this.cause);
   }
-  releaseImportLocks(entityIds) {
-    this.activeMaintenanceJobs.delete(this._globalImportKey());
-    for (const entityId of entityIds) {
-      this.activeMaintenanceJobs.delete(this._importKey(entityId));
-    }
+  async replace(_entityId, _ids, _documents) {
   }
-  getEntityStatus(entityId) {
-    return {
-      ingesting: this._isIngestActiveFor(entityId),
-      librarian: this.activeMaintenanceJobs.has(this._librarianKey(entityId)),
-      heal: this.activeMaintenanceJobs.has(this._healKey(entityId))
-    };
+  async replaceEntity(_entityId, _documents) {
   }
-  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);
-    }
-    const entry = { callback, last: this._copyEntityStatus(initial) };
-    set.add(entry);
-    try {
-      callback(this._copyEntityStatus(initial));
-    } catch (err) {
-      console.error(`[JobManager] callback error for entityId="${entityId}" during initial emission`, err);
-    }
-    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);
-    };
+  async replaceAll(_documents) {
   }
-  _copyEntityStatus(s) {
-    return { ingesting: s.ingesting, librarian: s.librarian, heal: s.heal };
+  hasIndexedEntity(_entityId) {
+    return false;
   }
-  _notifyStatusSubscribers(entityId) {
-    if (entityId === "*") return;
-    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);
+  async drain(_opts) {
+  }
+};
+
+// src/services/SearchService.ts
+var _SearchService = class _SearchService {
+  constructor(entryRepo, indexStrategy) {
+    this.entryRepo = entryRepo;
+    this.vectorCache = /* @__PURE__ */ new Map();
+    /**
+     * Serializes rebuilds. `rebuildIndex` awaits a repository read between
+     * snapshotting the previous id set and discarding it, so two concurrent
+     * sync() calls for one entity can interleave: a slow, stale read lands last
+     * and discards documents the fresh read just added. Chaining also keeps
+     * discard()/addAll() out of each other's way, which is what accrued the
+     * auto-vacuum debt behind the TypeError in #64.
+     */
+    this.syncChain = Promise.resolve();
+    /**
+     * Entities whose index may have drifted from SQLite: an incremental update
+     * failed part-way, or core wrote rows it could not index (upsertGraph runs in
+     * the host's transaction). Their next syncEntries rebuilds the entity in full.
+     * See spec 2026-09-28 §5.
+     */
+    this.staleEntities = /* @__PURE__ */ new Set();
+    /**
+     * Per-entity count of markStale() calls. A rebuild clears an entity's stale
+     * flag only when the count it snapshotted before its read still holds
+     * afterwards: markStale() runs inside the host's still-open transaction, so
+     * a call landing mid-read belongs to rows the read cannot have seen, and
+     * its flag must outlive the turn (#233 review).
+     */
+    this.staleEpochs = /* @__PURE__ */ new Map();
+    this.indexStrategy = indexStrategy;
+  }
+  /**
+   * Install the strategy resolved by `WikiMemory.setup()`. Before setup, the
+   * service runs on an empty MiniSearch placeholder, as it always has.
+   */
+  setIndexStrategy(strategy) {
+    this.indexStrategy = strategy;
+  }
+  /** False while the installed strategy is the degraded UnavailableIndexStrategy (spec #280 Change 4). */
+  isKeywordAvailable() {
+    return !(this.indexStrategy instanceof UnavailableIndexStrategy);
+  }
+  /** True when the installed strategy drains a durable ledger (FTS5, or the degraded stand-in). */
+  hasLedger() {
+    return this.indexStrategy.drain !== void 0;
+  }
+  /**
+   * One serialized drain turn for strategies with a durable ledger. Like
+   * sync(), it never rejects: the keyword index is rebuildable, and a failed
+   * drain leaves the ledger rows in place for the next turn. Resolves false
+   * when the drain failed.
+   */
+  drainTurn(entityId, opts) {
+    const work = this.syncChain.then(async () => {
       try {
-        entry.callback(this._copyEntityStatus(next));
+        try {
+          await this.indexStrategy.drain(opts);
+        } finally {
+          this.evictCache(entityId);
+        }
+        return true;
       } catch (err) {
-        console.error(`[JobManager] callback error for entityId="${entityId}" during transition emission`, err);
+        console.warn(`[WikiMemory] search index drain failed for ${entityId ?? "*"}:`, err);
+        return false;
       }
-    }
-  }
-};
-
-// src/utils/pure.ts
-var MAX_REPAIR_CANDIDATES = 5;
-function throwNoJsonFound(text, start) {
-  throw new WikiParseError(
-    "No JSON object/array found in LLM response",
-    { tier: "strict", position: start, slice: text }
-  );
-}
-function parseJsonResponse(text) {
-  const firstBrace = text.indexOf("{");
-  const firstBracket = text.indexOf("[");
-  let start;
-  let openChar;
-  const useBrace = firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket);
-  if (useBrace) {
-    start = firstBrace;
-    openChar = "{";
-  } else if (firstBracket !== -1) {
-    start = firstBracket;
-    openChar = "[";
-  } else {
-    throwNoJsonFound(text, null);
+    });
+    this.syncChain = work.then(() => void 0);
+    return work;
   }
-  const slice = scanJsonSlice(text, start, openChar);
-  if (slice !== null) {
-    try {
-      return JSON.parse(slice);
-    } catch {
+  /**
+   * Rebuilds the search index and clears the vector cache for a given entity.
+   * A direct replacement for manually syncing state after a DB transaction.
+   *
+   * Rebuilds are serialized per instance and never reject: the keyword index
+   * is a rebuildable cache over SQLite, so degraded keyword search is the
+   * correct failure mode and killing the host process is not.
+   *
+   * With a ledger strategy, `sync()` runs one full quantum bounded by
+   * `opts.deadline`; `sync(entityId)` is a write turn (ledger only).
+   * `opts.ids` are the caller's touched ids: a ledger strategy drains them
+   * first, to completion; MiniSearch ignores them and rebuilds the entity in
+   * one scan.
+   */
+  async sync(entityId, opts) {
+    if (this.indexStrategy.drain) {
+      await this.drainTurn(entityId, entityId === void 0 ? { mode: "full", deadline: opts?.deadline, ids: opts?.ids } : { mode: "ledger", entityId, ids: opts?.ids });
+      return;
     }
+    const work = this.syncChain.then(async () => {
+      try {
+        try {
+          const epochsBefore = new Map(this.staleEpochs);
+          if (entityId === void 0) {
+            const rows = await this.entryRepo.findMiniSearchRows();
+            await this.indexStrategy.replaceAll(rows.map(toIndexDoc));
+            for (const id of [...this.staleEntities]) {
+              if ((this.staleEpochs.get(id) ?? 0) === (epochsBefore.get(id) ?? 0)) {
+                this.staleEntities.delete(id);
+              }
+            }
+          } else {
+            await this.rebuildIndex(entityId);
+            if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
+              this.staleEntities.delete(entityId);
+            }
+          }
+          await this.indexStrategy.vacuum?.();
+        } finally {
+          this.evictCache(entityId);
+        }
+      } catch (err) {
+        console.warn(`[WikiMemory] search index rebuild failed for ${entityId ?? "*"}:`, err);
+      }
+    });
+    this.syncChain = work;
+    return work;
   }
-  const repairOdd = containerAwareRepair(text, start, false);
-  if (repairOdd.success !== null && !repairOdd.ambiguous) {
-    return repairOdd.success;
-  }
-  const repairEven = containerAwareRepair(text, start, true);
-  if (repairOdd.success !== null && repairEven.success !== null) {
-    const pick = repairEven.escapes < repairOdd.escapes ? repairEven : repairOdd;
-    return pick.success;
+  /**
+   * Re-indexes only `ids` for `entityId`: drops each from the index, then
+   * re-adds the ones still live in SQLite, so soft-deleted or missing ids end
+   * up absent. Costs O(ids), where sync(entityId) costs O(entity) — callers that
+   * know what a write touched use this so chunked imports stay linear (#232).
+   *
+   * Serialized with sync() on the same chain and, like it, never rejects. An
+   * entity that is stale or has never been indexed gets a full rebuild instead
+   * — including on an empty `ids` list, which is a no-op only for an entity
+   * the index already tracks, and even then one that waits for rebuilds
+   * already queued on the chain.
+   *
+   * Resolves false only when a ledger drain failed: the caller's ids were not
+   * applied (their ledger rows remain), so a caller holding them retries.
+   */
+  async syncEntries(entityId, ids) {
+    if (this.indexStrategy.drain) return this.drainTurn(entityId, { mode: "ledger", entityId, ids: [...new Set(ids)] });
+    const uniqueIds = [...new Set(ids)];
+    const indexed = this.indexStrategy.hasIndexedEntity?.(entityId);
+    if (uniqueIds.length === 0 && !this.staleEntities.has(entityId) && indexed === true) {
+      await this.syncChain;
+      return true;
+    }
+    const work = this.syncChain.then(async () => {
+      try {
+        try {
+          const epochsBefore = new Map(this.staleEpochs);
+          const needsRebuild = () => this.staleEntities.has(entityId) || this.indexStrategy.hasIndexedEntity?.(entityId) !== true;
+          if (!needsRebuild()) {
+            const rows = await this.entryRepo.findMiniSearchRowsByIds(entityId, uniqueIds);
+            if (!this.staleEntities.has(entityId)) {
+              await this.indexStrategy.replace(entityId, uniqueIds, rows.map(toIndexDoc));
+              await this.indexStrategy.vacuum?.();
+              return;
+            }
+          }
+          await this.rebuildIndex(entityId);
+          if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
+            this.staleEntities.delete(entityId);
+          }
+          await this.indexStrategy.vacuum?.();
+        } finally {
+          this.evictCache(entityId);
+        }
+      } catch (err) {
+        this.staleEntities.add(entityId);
+        console.warn(`[WikiMemory] search index incremental sync failed for ${entityId}:`, err);
+      }
+    });
+    this.syncChain = work;
+    await work;
+    return true;
   }
-  if (repairOdd.success !== null) {
-    return repairOdd.success;
+  /**
+   * Forces the entity's next syncEntries to rebuild it in full. For writes core
+   * cannot index itself, such as upsertGraph inside a host transaction.
+   */
+  markStale(entityId) {
+    if (this.indexStrategy.drain) return;
+    this.staleEntities.add(entityId);
+    this.staleEpochs.set(entityId, (this.staleEpochs.get(entityId) ?? 0) + 1);
   }
-  if (repairEven.success !== null) {
-    return repairEven.success;
+  /**
+   * Runs syncEntries(id, []) for each entity marked stale when this is called,
+   * so only those entities are rebuilt. Each rebuild still takes its own turn
+   * on the sync chain, and like syncEntries this never rejects. With nothing
+   * stale it resolves at once, without waiting on work already on the chain.
+   * Resolves false only when a ledger drain failed (see syncEntries).
+   */
+  async syncStale(opts) {
+    if (this.indexStrategy.drain) return this.drainTurn(void 0, { mode: "full", ids: opts?.ids });
+    const ids = [...this.staleEntities];
+    await Promise.all(ids.map((id) => this.syncEntries(id, [])));
+    return true;
   }
-  const repair = repairEven.failed !== null ? repairEven : repairOdd;
-  if (repair.failed !== null) {
-    throw new WikiParseError(
-      `Repair produced a candidate but JSON.parse rejected it: ${repair.failed.message}`,
-      { tier: "repair", position: repair.failed.position, slice: repair.failed.candidate }
-    );
+  /**
+   * Clears the parsed vector cache. Useful for mid-loop flush guarantees
+   * or memory pressure evictions.
+   */
+  evictCache(entityId) {
+    if (entityId) {
+      this.vectorCache.delete(entityId);
+    } else {
+      this.vectorCache.clear();
+    }
   }
-  if (slice === null) {
-    throwNoJsonFound(text, start);
+  /**
+   * Fully resets the search service.
+   */
+  async clearAll() {
+    this.vectorCache.clear();
+    await this.indexStrategy.replaceAll([]);
+    this.staleEntities.clear();
+    this.staleEpochs.clear();
   }
-  throw new WikiParseError(
-    "No parsable JSON candidate found",
-    { tier: "all", position: start, slice: text }
-  );
-}
-function scanJsonSlice(text, start, openChar) {
-  const closeChar = openChar === "{" ? "}" : "]";
-  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;
-      }
-    }
+  /**
+   * Executes a keyword search against the active index strategy.
+   */
+  async searchKeyword(query, entityIds, limit) {
+    const results = finiteResults(await this.indexStrategy.search(query, { entityIds, limit }));
+    return results.sort((a, b) => this._compareSearchResults(a, b)).slice(0, limit);
   }
-  if (end === -1) return null;
-  return safeSlice(text, start, end + 1);
-}
-function containerAwareRepair(text, start, closeOnEvenParity) {
-  const stack = [];
-  let inString = false;
-  let stringRole = null;
-  let escape = false;
-  let i = start;
-  let out = "";
-  let bareQuoteCount = 0;
-  let bestFailed = null;
-  let escapes = 0;
-  let ambiguous = false;
-  let bestSuccess = null;
-  let attempts = 0;
-  function tryEmitCandidate(candidate) {
-    attempts++;
-    try {
-      bestSuccess = JSON.parse(candidate);
-      return true;
-    } catch (err) {
-      if (bestFailed === null) {
-        bestFailed = {
-          candidate,
-          position: extractParsePosition(err),
-          message: safeErrorToString(err)
-        };
-      }
-      return false;
-    }
+  /**
+   * Pre-fetches keyword scores for candidate hydration, used during hybrid weighting.
+   */
+  async getKeywordScores(query, entityIds, preFilterLimit) {
+    const opts = preFilterLimit !== void 0 ? { entityIds, limit: preFilterLimit, preFilterLimit } : { entityIds, limit: Number.MAX_SAFE_INTEGER };
+    const results = finiteResults(await this.indexStrategy.search(query, opts));
+    if (results.length === 0) return /* @__PURE__ */ new Map();
+    const maxScore = Math.max(1, results[0]?.score ?? 1);
+    return new Map(results.map((r) => [r.id, r.score / maxScore]));
   }
-  while (i < text.length) {
-    const ch = text[i];
-    if (stack.length === 0 && !inString) {
-      if (ch === "{" || ch === "[") {
-        stack.push({ container: ch === "{" ? "object" : "array", expectKey: true });
-        out += ch;
-      }
-      i++;
-      continue;
-    }
-    if (escape) {
-      out += ch;
-      escape = false;
-      i++;
-      continue;
-    }
-    if (inString && ch === "\\") {
-      out += ch;
-      escape = true;
-      i++;
-      continue;
+  /**
+   * Score candidate rows using in-process JS cosine similarity.
+   * Applies hybrid blending (if weight set) and tie-break sorting before returning.
+   */
+  async rankSemantic(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 > _SearchService.MAX_VECTOR_CACHE_FACTS_PER_ENTITY;
+    if (tooLarge && entityCache) {
+      this.vectorCache.delete(entityId);
+      entityCache = void 0;
     }
-    if (inString) {
-      const code = ch.charCodeAt(0);
-      if (code < 32) {
-        out += controlCharEscape(code);
-        i++;
-        continue;
-      }
+    const canCache = populateCache && !tooLarge;
+    if (canCache && !entityCache) {
+      entityCache = /* @__PURE__ */ new Map();
     }
-    if (ch === '"') {
-      let j = i + 1;
-      while (j < text.length && (text[j] === " " || text[j] === "	" || text[j] === "\n" || text[j] === "\r")) {
-        j++;
+    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);
       }
-      const next = j < text.length ? text[j] : "";
-      if (!inString) {
-        if (next === "}" || next === "]") {
-          if (j > i + 1) out += text.slice(i + 1, j);
-          out += next;
-          i = j + 1;
-          stack.pop();
-          if (stack.length === 0) {
-            if (tryEmitCandidate(out)) return { success: bestSuccess, failed: bestFailed, escapes, ambiguous };
-            if (attempts >= MAX_REPAIR_CANDIDATES) break;
-            out = "";
-          }
-          continue;
+      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;
         }
-        const top = stack[stack.length - 1];
-        stringRole = top?.container === "object" && top.expectKey ? "key" : "value";
-        out += ch;
-        inString = true;
-        i++;
-        continue;
+      } else if (weight !== void 0 && weight < 1) {
+        const kwScore = miniSearchScores?.get(row.id) ?? 0;
+        score = (1 - weight) * kwScore;
+      } else {
+        score = -2;
       }
-      const commaOnly = next === ",";
-      const isKeyClose = stringRole === "key" && (next === ":" || next === '"' && j + 1 < text.length && text[j + 1] === ":");
-      const isValueClose = !commaOnly && (next === "," || next === "}" || next === "]");
-      if (commaOnly && bareQuoteCount > 0) ambiguous = true;
-      const shouldCommaClose = commaOnly && (bareQuoteCount === 0 || (closeOnEvenParity ? bareQuoteCount % 2 === 0 : bareQuoteCount % 2 === 1));
-      const isClosing = isKeyClose || isValueClose || shouldCommaClose;
-      if (isClosing) {
-        out += ch;
-        inString = false;
-        const topFrame = stack[stack.length - 1];
-        if (topFrame && topFrame.container === "object") {
-          topFrame.expectKey = stringRole === "value";
+      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 >= _SearchService.MAX_VECTOR_CACHE_ENTITIES) {
+          const oldestKey = this.vectorCache.keys().next().value;
+          if (oldestKey !== void 0) this.vectorCache.delete(oldestKey);
         }
-        stringRole = null;
-        bareQuoteCount = 0;
-        i++;
-        continue;
+        this.vectorCache.set(entityId, entityCache);
       }
-      out += "\\" + ch;
-      bareQuoteCount++;
-      escapes++;
-      i++;
-      continue;
-    }
-    if (!inString && (ch === "{" || ch === "[")) {
-      stack.push({ container: ch === "{" ? "object" : "array", expectKey: true });
-      out += ch;
-      i++;
-      continue;
     }
-    if (!inString && ch === ",") {
-      const topFrame = stack[stack.length - 1];
-      if (topFrame && topFrame.container === "object") {
-        topFrame.expectKey = true;
-      }
-      out += ch;
-      i++;
-      continue;
+    if (!skipSort) {
+      this._tieBreakSort(scored);
     }
-    if (!inString && (ch === "}" || ch === "]")) {
-      out += ch;
-      stack.pop();
-      if (stack.length === 0) {
-        if (tryEmitCandidate(out)) return { success: bestSuccess, failed: bestFailed, escapes, ambiguous };
-        if (attempts >= MAX_REPAIR_CANDIDATES) break;
-        out = "";
+    return scored.slice(0, limit);
+  }
+  // --- Internal Index Management ---
+  /**
+   * Rebuild a single entity's index from scratch. Reads every row for
+   * `entityId` from the repository (already filtered by `deleted_at IS NULL`)
+   * and hands the lot to `indexStrategy.replaceEntity`, which owns the
+   * drop-then-add bookkeeping so callers don't need to know the strategy's
+   * id-tracking shape.
+   */
+  async rebuildIndex(entityId) {
+    const rows = await this.entryRepo.findMiniSearchRows(entityId);
+    await this.indexStrategy.replaceEntity(entityId, rows.map(toIndexDoc));
+  }
+  _tieBreakSort(items) {
+    items.sort((a, b) => this._compareScoredRows(a, b));
+  }
+  _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);
+  }
+  /**
+   * The keyword index breaks equal-score ties by internal insertion order,
+   * which syncEntries changes: a discarded-and-re-added id moves to the end.
+   * Every caller truncates these results to a limit, so which ids survive a
+   * tie at the boundary must not depend on write history. Re-sort exact
+   * score ties by id — the same final tie-break _compareScoredRows applies.
+   */
+  _compareSearchResults(a, b) {
+    const scoreDiff = b.score - a.score;
+    if (!Number.isNaN(scoreDiff) && scoreDiff !== 0) return scoreDiff;
+    return a.id.localeCompare(b.id);
+  }
+};
+/**
+ * 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).
+ */
+_SearchService.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.
+ */
+_SearchService.MAX_VECTOR_CACHE_FACTS_PER_ENTITY = 500;
+var SearchService = _SearchService;
+function finiteResults(results) {
+  return results.every((r) => Number.isFinite(r.score)) ? results : results.filter((r) => Number.isFinite(r.score));
+}
+
+// src/services/JobManager.ts
+var JobManager = class {
+  constructor(prefix) {
+    this.prefix = prefix;
+    this.activeMaintenanceJobs = /* @__PURE__ */ new Set();
+    this.activeIngestJobs = /* @__PURE__ */ new Map();
+    /**
+     * Per-(entityId, sourceHash) promise-chain lock. Serializes ingest races
+     * at the application level (the v9 partial UNIQUE index enforces it at
+     * the DB level as defense-in-depth). Two callers holding the same hash
+     * see FIFO order; different hashes never block one another.
+     *
+     * Keyed `${entityId}\0${sourceHash}` so distinct (entityId, sourceHash)
+     * pairs can never share a lock. A raw concatenation would let
+     * ("ab", "c…") collide with ("a", "bc…"); the NUL separator makes that
+     * impossible because neither component can contain NUL (entityIds are
+     * user-supplied identifiers; sourceHashes are hex digests).
+     */
+    this.hashLocks = /* @__PURE__ */ new Map();
+    this.statusSubscribers = /* @__PURE__ */ new Map();
+    /**
+     * Lookup table for acquireLock/releaseLock's dynamic-dispatch branch.
+     * Excludes 'ingest' | 'global_reembed' | 'global_import', which those
+     * methods already handle via explicit if/else branches before reaching
+     * this table.
+     */
+    this.lockKeyFns = {
+      prune: (id) => this._pruneKey(id),
+      librarian: (id) => this._librarianKey(id),
+      heal: (id) => this._healKey(id),
+      reembed: (id) => this._reembedKey(id),
+      import: (id) => this._importKey(id),
+      forget: (id) => this._forgetKey(id),
+      ontologyBackfill: (id) => this._ontologyBackfillKey(id)
+    };
+  }
+  _hashLockKey(entityId, sourceHash) {
+    return `${entityId}\0${sourceHash}`;
+  }
+  /**
+   * Acquire a promise-chain lock scoped to one `(entityId, sourceHash)` pair.
+   * Returns a zero-argument release closure that removes the current tail
+   * from the chain. Releasing is idempotent so a holder that double-fires
+   * (e.g. on a finally that races an explicit release) cannot unblock
+   * the next holder prematurely.
+   *
+   * Documented ordering: ingest acquires the hash lock FIRST, then the
+   * synchronous sourceRef ingest lock, and the release closure unwinds in
+   * the opposite order (sourceRef first, hash second). Hash-then-sourceRef
+   * is required because the v9 partial UNIQUE index conflicts on the
+   * (entity_id, source_hash) pair regardless of source_ref, so two callers
+   * with DIFFERENT source_refs racing the same hash are the exact case the
+   * TOCTOU race fix needs to serialize.
+   *
+   * Mechanics: each holder owns a private `released` promise that resolves
+   * only when THIS holder calls release(). The map stores the holder's
+   * `released` promise as the "tail" — the NEXT caller awaits that tail
+   * via `previous = this.hashLocks.get(key)`. The current caller gets
+   * their unique release function once `previous` (the prior holder's
+   * release signal) settles, so each holder is guaranteed a UNIQUE release
+   * closure bound to their own `released` promise.
+   */
+  acquireHashLock(entityId, sourceHash) {
+    const key = this._hashLockKey(entityId, sourceHash);
+    const previous = this.hashLocks.get(key) ?? Promise.resolve();
+    let resolveReleased;
+    const released = new Promise((resolve) => {
+      resolveReleased = resolve;
+    });
+    let fired = false;
+    const release = () => {
+      if (fired) return;
+      fired = true;
+      if (this.hashLocks.get(key) === released) {
+        this.hashLocks.delete(key);
       }
-      i++;
-      continue;
-    }
-    out += ch;
-    i++;
+      resolveReleased();
+    };
+    this.hashLocks.set(key, released);
+    return previous.then(() => release);
   }
-  return { success: null, failed: bestFailed, escapes, ambiguous };
-}
-function controlCharEscape(code) {
-  switch (code) {
-    case 10:
-      return "\\n";
-    case 9:
-      return "\\t";
-    case 13:
-      return "\\r";
-    case 8:
-      return "\\b";
-    case 12:
-      return "\\f";
-    default:
-      return "\\u" + code.toString(16).padStart(4, "0");
+  _pruneKey(entityId) {
+    return `${this.prefix}:${entityId}:prune`;
   }
-}
-function extractParsePosition(err) {
-  const match = /position\s+(\d+)/.exec(safeErrorToString(err));
-  return match ? Number(match[1]) : null;
-}
-function safeErrorToString(e) {
-  let isErrorLike = false;
-  try {
-    isErrorLike = e instanceof Error;
-  } catch {
+  _reembedKey(entityId) {
+    return `${this.prefix}:${entityId}:reembed`;
   }
-  if (isErrorLike) {
-    const msg = readErrorField(e, "message");
-    if (typeof msg === "string" && msg.length > 0) return msg;
-    const name = readErrorField(e, "name");
-    if (typeof name === "string" && name.length > 0) return name;
-    return "[Error]";
+  _globalReembedKey() {
+    return `${this.prefix}:reembed`;
   }
-  try {
-    return String(e);
-  } catch {
-    try {
-      return Object.prototype.toString.call(e);
-    } catch {
-      return "[unstringifiable error]";
+  _importKey(entityId) {
+    return `${this.prefix}:${entityId}:import`;
+  }
+  _globalImportKey() {
+    return `${this.prefix}:import`;
+  }
+  _forgetKey(entityId) {
+    return `${this.prefix}:${entityId}:forget`;
+  }
+  _librarianKey(entityId) {
+    return `${this.prefix}:${entityId}:librarian`;
+  }
+  _healKey(entityId) {
+    return `${this.prefix}:${entityId}:heal`;
+  }
+  _ontologyBackfillKey(entityId) {
+    return `${this.prefix}:${entityId}:ontologyBackfill`;
+  }
+  _isReembedActive(entityId) {
+    return this.activeMaintenanceJobs.has(this._reembedKey(entityId)) || this.activeMaintenanceJobs.has(this._globalReembedKey());
+  }
+  /**
+   * True while any reembed sweep is in flight — per-entity or global.
+   *
+   * Read-only; acquires nothing. Callers that mutate embedding failure
+   * markers across ALL entities (the dimension-promotion clear) must gate on
+   * this and defer, rather than resurrect rows an in-flight sweep already
+   * classified. See spec 2026-09-05-reembed-lock-scope-design.md §2.
+   *
+   * The global key `${prefix}:reembed` also ends in ':reembed', so the suffix
+   * scan alone would already match it. The explicit check is kept because it
+   * documents the intent and survives any future change to the global key's
+   * format.
+   */
+  isAnyReembedActive() {
+    return this.activeMaintenanceJobs.has(this._globalReembedKey()) || this._isAnyMaintenanceActiveWithSuffix(":reembed");
+  }
+  _isImportActiveFor(entityId) {
+    return this.activeMaintenanceJobs.has(this._importKey(entityId)) || this.activeMaintenanceJobs.has(this._globalImportKey());
+  }
+  _isForgetActiveFor(entityId) {
+    return this.activeMaintenanceJobs.has(this._forgetKey(entityId));
+  }
+  _isAnyMaintenanceActiveWithSuffix(suffix) {
+    const entityKeyPrefix = `${this.prefix}:`;
+    for (const k of this.activeMaintenanceJobs) {
+      if (k.startsWith(entityKeyPrefix) && k.endsWith(suffix)) return true;
     }
+    return false;
   }
-}
-function readErrorField(e, key) {
-  try {
-    return e[key];
-  } catch {
-    return void 0;
+  _hasIngestJob(entityId, sourceRef) {
+    return this.activeIngestJobs.get(entityId)?.has(sourceRef ?? "") ?? false;
   }
-}
-function sanitizeRankerError(err, sanitizeRankerErrors) {
-  let isErrorLike = false;
-  try {
-    isErrorLike = err instanceof Error;
-  } catch {
+  _addIngestJob(entityId, sourceRef) {
+    const sourceKey = sourceRef ?? "";
+    let refs = this.activeIngestJobs.get(entityId);
+    if (!refs) {
+      refs = /* @__PURE__ */ new Set();
+      this.activeIngestJobs.set(entityId, refs);
+    }
+    refs.add(sourceKey);
   }
-  if (sanitizeRankerErrors === false) {
-    return isErrorLike ? err : new Error(safeErrorToString(err));
+  _removeIngestJob(entityId, sourceRef) {
+    const sourceKey = sourceRef ?? "";
+    const refs = this.activeIngestJobs.get(entityId);
+    if (!refs) return;
+    refs.delete(sourceKey);
+    if (refs.size === 0) {
+      this.activeIngestJobs.delete(entityId);
+    }
   }
-  let errLike = null;
-  if (isErrorLike) errLike = err;
-  let typeName;
-  try {
-    if (errLike) {
-      const rawName = errLike.constructor?.name;
-      typeName = typeof rawName === "string" ? rawName : "Error";
+  _isIngestActiveFor(entityId) {
+    return this.activeIngestJobs.has(entityId);
+  }
+  acquireLock(operation, entityId, sourceRef) {
+    let blockingOperation = null;
+    if (operation !== "global_import" && this.activeMaintenanceJobs.has(this._globalImportKey())) {
+      throw new WikiBusyError("import", "*");
+    }
+    switch (operation) {
+      case "prune":
+        if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) 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.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId))) blockingOperation = "ontologyBackfill";
+        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";
+        break;
+      case "librarian":
+      case "heal":
+      case "ontologyBackfill": {
+        const opKey = this.lockKeyFns[operation](entityId);
+        if (this.activeMaintenanceJobs.has(opKey)) blockingOperation = operation;
+        else if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) blockingOperation = "prune";
+        else if (this._isReembedActive(entityId)) blockingOperation = "reembed";
+        else if (this._isImportActiveFor(entityId)) blockingOperation = "import";
+        else if (this._isForgetActiveFor(entityId)) blockingOperation = "forget";
+        break;
+      }
+      case "reembed":
+        if (this.activeMaintenanceJobs.has(this._reembedKey(entityId))) blockingOperation = "reembed";
+        else if (this.activeMaintenanceJobs.has(this._globalReembedKey())) blockingOperation = "reembed";
+        else if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) 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.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId))) blockingOperation = "ontologyBackfill";
+        else if (this._isIngestActiveFor(entityId)) blockingOperation = "ingest";
+        else if (this._isImportActiveFor(entityId)) blockingOperation = "import";
+        else if (this._isForgetActiveFor(entityId)) blockingOperation = "forget";
+        break;
+      case "global_reembed":
+        if (this.activeMaintenanceJobs.has(this._globalReembedKey())) blockingOperation = "reembed";
+        else if (this._isAnyMaintenanceActiveWithSuffix(":reembed")) blockingOperation = "reembed";
+        else if (this._isAnyMaintenanceActiveWithSuffix(":prune")) blockingOperation = "prune";
+        else if (this._isAnyMaintenanceActiveWithSuffix(":librarian")) blockingOperation = "librarian";
+        else if (this._isAnyMaintenanceActiveWithSuffix(":heal")) blockingOperation = "heal";
+        else if (this._isAnyMaintenanceActiveWithSuffix(":ontologyBackfill")) blockingOperation = "ontologyBackfill";
+        else if (this.activeIngestJobs.size > 0) blockingOperation = "ingest";
+        else if (this._isAnyMaintenanceActiveWithSuffix(":import")) blockingOperation = "import";
+        else if (this._isAnyMaintenanceActiveWithSuffix(":forget")) blockingOperation = "forget";
+        break;
+      case "import":
+      case "forget": {
+        const selfKey = operation === "import" ? this._importKey(entityId) : this._forgetKey(entityId);
+        if (this.activeMaintenanceJobs.has(selfKey)) blockingOperation = operation;
+        else 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._ontologyBackfillKey(entityId))) blockingOperation = "ontologyBackfill";
+        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";
+        break;
+      }
+      case "global_import":
+        if (this.activeMaintenanceJobs.has(this._globalImportKey())) blockingOperation = "import";
+        break;
+      case "ingest": {
+        const sourceKey = sourceRef ?? "";
+        if (this._hasIngestJob(entityId, sourceKey)) blockingOperation = "ingest";
+        else if (this.activeMaintenanceJobs.has(this._pruneKey(entityId))) blockingOperation = "prune";
+        else if (this._isReembedActive(entityId)) blockingOperation = "reembed";
+        else if (this._isImportActiveFor(entityId)) blockingOperation = "import";
+        else if (this._isForgetActiveFor(entityId)) blockingOperation = "forget";
+        break;
+      }
+    }
+    if (blockingOperation) {
+      throw new WikiBusyError(
+        blockingOperation,
+        operation === "global_reembed" || operation === "global_import" ? "*" : entityId
+      );
+    }
+    if (operation === "ingest") {
+      this._addIngestJob(entityId, sourceRef);
+    } else if (operation === "global_reembed") {
+      this.activeMaintenanceJobs.add(this._globalReembedKey());
+    } else if (operation === "global_import") {
+      this.activeMaintenanceJobs.add(this._globalImportKey());
     } else {
-      typeName = typeof err;
+      this.activeMaintenanceJobs.add(this.lockKeyFns[operation](entityId));
     }
-  } catch {
-    typeName = isErrorLike ? "Error" : typeof err;
+    this._notifyStatusSubscribers(entityId);
   }
-  let innerCause;
-  if (errLike) {
-    let cause;
-    try {
-      cause = errLike.cause;
-    } catch {
-      cause = void 0;
+  releaseLock(operation, entityId, sourceRef) {
+    if (operation === "ingest") {
+      this._removeIngestJob(entityId, sourceRef);
+    } else if (operation === "global_reembed") {
+      this.activeMaintenanceJobs.delete(this._globalReembedKey());
+    } else if (operation === "global_import") {
+      this.activeMaintenanceJobs.delete(this._globalImportKey());
+    } else {
+      this.activeMaintenanceJobs.delete(this.lockKeyFns[operation](entityId));
     }
-    if (cause !== void 0) {
-      let causeName;
-      try {
-        const rawCauseName = cause?.constructor?.name;
-        causeName = typeof rawCauseName === "string" ? rawCauseName : typeof cause;
-      } catch {
-        causeName = typeof cause;
+    this._notifyStatusSubscribers(entityId);
+  }
+  /**
+   * Returns true if acquireLock(operation, entityId) would throw WikiBusyError.
+   * Use for non-throwing conflict checks (e.g. auto-trigger gating in write()).
+   */
+  isBlocked(operation, entityId) {
+    if (operation !== "global_import" && this.activeMaintenanceJobs.has(this._globalImportKey())) return true;
+    switch (operation) {
+      case "librarian":
+      case "heal":
+      case "ontologyBackfill":
+        return this.activeMaintenanceJobs.has(this.lockKeyFns[operation](entityId)) || this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this._isReembedActive(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
+      case "prune":
+        return this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this.activeMaintenanceJobs.has(this._librarianKey(entityId)) || this.activeMaintenanceJobs.has(this._healKey(entityId)) || this.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId)) || this._isReembedActive(entityId) || this._isIngestActiveFor(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
+      case "reembed":
+        return this.activeMaintenanceJobs.has(this._reembedKey(entityId)) || this.activeMaintenanceJobs.has(this._globalReembedKey()) || this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this.activeMaintenanceJobs.has(this._librarianKey(entityId)) || this.activeMaintenanceJobs.has(this._healKey(entityId)) || this.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId)) || this._isIngestActiveFor(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
+      case "global_reembed":
+        return this.activeMaintenanceJobs.has(this._globalReembedKey()) || this._isAnyMaintenanceActiveWithSuffix(":reembed") || this._isAnyMaintenanceActiveWithSuffix(":prune") || this._isAnyMaintenanceActiveWithSuffix(":librarian") || this._isAnyMaintenanceActiveWithSuffix(":heal") || this._isAnyMaintenanceActiveWithSuffix(":ontologyBackfill") || this.activeIngestJobs.size > 0 || this._isAnyMaintenanceActiveWithSuffix(":import") || this._isAnyMaintenanceActiveWithSuffix(":forget");
+      case "import":
+      case "forget": {
+        const selfKey = operation === "import" ? this._importKey(entityId) : this._forgetKey(entityId);
+        return this.activeMaintenanceJobs.has(selfKey) || this.activeMaintenanceJobs.has(this._librarianKey(entityId)) || this.activeMaintenanceJobs.has(this._healKey(entityId)) || this.activeMaintenanceJobs.has(this._ontologyBackfillKey(entityId)) || this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this._isReembedActive(entityId) || this._isIngestActiveFor(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
       }
-      innerCause = new Error(`Caused by: ${causeName}`);
+      case "global_import":
+        return this.activeMaintenanceJobs.has(this._globalImportKey());
+      case "ingest":
+        return this._hasIngestJob(entityId) || this.activeMaintenanceJobs.has(this._pruneKey(entityId)) || this._isReembedActive(entityId) || this._isImportActiveFor(entityId) || this._isForgetActiveFor(entityId);
+      default:
+        return false;
     }
   }
-  const sanitized = new Error(
-    `VectorRanker ${typeName} (message scrubbed for security)`,
-    innerCause ? { cause: innerCause } : void 0
-  );
-  try {
-    sanitized.name = typeName;
-  } catch {
-  }
-  return sanitized;
-}
-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");
+  /**
+   * Auto-heal historically only gated on the heal self-key. Keep that
+   * permissiveness for write() auto-trigger paths — stricter checks stay in
+   * acquireLock() — with one exception: reembed sweeps, which are excluded
+   * structurally rather than by accident (see below).
+   */
+  tryAcquireAutoHealLock(entityId) {
+    if (this.isAnyReembedActive()) return false;
+    const healKey = this._healKey(entityId);
+    if (this.activeMaintenanceJobs.has(healKey)) return false;
+    this.activeMaintenanceJobs.add(healKey);
+    this._notifyStatusSubscribers(entityId);
+    return true;
   }
-  if (!Number.isInteger(overlap) || overlap < 0 || overlap >= maxChunkLength) {
-    throw new Error("overlap must be a non-negative integer < maxChunkLength");
+  /**
+   * Centralized ingest lock acquisition. Acquires the hash lock FIRST
+   * (FIFO across callers racing the same hash), then the synchronous
+   * sourceRef ingest lock (rejects cross-entity conflicts and busy
+   * operations). Returns a single zero-argument release closure that
+   * unwinds in the opposite order — sourceRef first, hash second — so
+   * the sourceRef lock is freed the instant its work is done and only
+   * the hash lock keeps serializing the duplicate-content race window.
+   *
+   * On a sourceRef conflict (WikiBusyError thrown synchronously by the
+   * underlying acquireLock) the hash lock is released BEFORE the error
+   * propagates, so the next caller in the hash chain is not held up by
+   * a request that never reached the DB.
+   */
+  async acquireIngestLocks(entityId, sourceRef, sourceHash) {
+    const releaseHash = await this.acquireHashLock(entityId, sourceHash);
+    let sourceLockAcquired = false;
+    try {
+      this.acquireLock("ingest", entityId, sourceRef);
+      sourceLockAcquired = true;
+    } catch (err) {
+      releaseHash();
+      throw err;
+    }
+    return () => {
+      try {
+        if (sourceLockAcquired) this.releaseLock("ingest", entityId, sourceRef);
+      } finally {
+        releaseHash();
+      }
+    };
   }
-  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;
+  /**
+   * Validates then acquires global + per-entity import locks atomically.
+   * Validates all entities before acquiring any lock (same as current importDump semantics).
+   */
+  acquireImportLocks(entityIds) {
+    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._ontologyBackfillKey(entityId))) throw new WikiBusyError("ontologyBackfill", 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);
     }
-    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 (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));
     }
-    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;
+  }
+  releaseImportLocks(entityIds) {
+    this.activeMaintenanceJobs.delete(this._globalImportKey());
+    for (const entityId of entityIds) {
+      this.activeMaintenanceJobs.delete(this._importKey(entityId));
     }
-    if (splitPoint === -1) {
-      for (let i = windowEnd - 1; i >= minSplit; i--) {
-        if (/\s/.test(text[i])) {
-          splitPoint = i + 1;
-          break;
-        }
-      }
+  }
+  getEntityStatus(entityId) {
+    return {
+      ingesting: this._isIngestActiveFor(entityId),
+      librarian: this.activeMaintenanceJobs.has(this._librarianKey(entityId)),
+      heal: this.activeMaintenanceJobs.has(this._healKey(entityId))
+    };
+  }
+  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);
     }
-    if (splitPoint === -1) {
-      truncated = true;
-      splitPoint = windowEnd;
+    const entry = { callback, last: this._copyEntityStatus(initial) };
+    set.add(entry);
+    try {
+      callback(this._copyEntityStatus(initial));
+    } catch (err) {
+      console.error(`[JobManager] callback error for entityId="${entityId}" during initial emission`, err);
     }
-    chunks.push(safeSlice(text, cursor, splitPoint));
-    const next = Math.max(splitPoint - overlap, cursor + 1);
-    cursor = next;
+    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);
+    };
   }
-  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;
+  _copyEntityStatus(s) {
+    return { ingesting: s.ingesting, librarian: s.librarian, heal: s.heal };
+  }
+  _notifyStatusSubscribers(entityId) {
+    if (entityId === "*") return;
+    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(`[JobManager] callback error for entityId="${entityId}" during transition emission`, err);
       }
     }
   }
-  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);
-}
-var MAX_EVIDENCE_QUOTES = 10;
-function normalizeEvidence(raw) {
-  if (!Array.isArray(raw)) return void 0;
-  const out = [];
-  for (const entry of raw) {
-    if (typeof entry !== "string") continue;
-    const trimmed = entry.trim();
-    if (!trimmed) continue;
-    out.push(trimmed);
-    if (out.length > MAX_EVIDENCE_QUOTES) break;
-  }
-  return out;
-}
-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";
-  const valid = {
-    ...fact,
-    title,
-    body,
-    confidence,
-    tags: validateTags(fact.tags)
-  };
-  const evidence = normalizeEvidence(fact.evidence);
-  if (evidence) valid.evidence = evidence;
-  else delete valid.evidence;
-  return valid;
-}
-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;
-  priority = Math.max(0, Math.min(10, Math.round(priority)));
-  return {
-    ...task,
-    description,
-    priority
-  };
-}
-function factRejectionReason(raw) {
-  const fact = raw;
-  if (typeof fact?.title !== "string" || typeof fact?.body !== "string") return "invalid_shape";
-  if (!clip(fact.title, 80)) return "missing_title";
-  return "missing_body";
-}
-function taskRejectionReason(raw) {
-  const task = raw;
-  if (typeof task?.description !== "string") return "invalid_shape";
-  return "missing_description";
-}
-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;
-}
+};
 
 // 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.
@@ -2116,7 +2191,7 @@ var MESSAGE = {
   embedding_failed: "A fact could not be embedded.",
   hook_failed: "A host hook threw or rejected.",
   background_job_failed: "A background maintenance job failed.",
-  heal_skipped: "Heal skipped a candidate fact.",
+  heal_skipped: "Heal skipped a candidate fact, or the whole LLM pass when keyword search is unavailable.",
   grounding_missing: "A fact carried no qualifying evidence and was stored as a draft.",
   grounding_failed: "A fact carried evidence not found in its source and was stored as a draft.",
   classification_low_confidence: "A classifier answer was below the confidence threshold and was not applied.",
@@ -2610,7 +2685,8 @@ var IngestionService = class {
    *
    * @returns Counts: nodesWritten (validated nodes persisted), edgesWritten
    *   (manifest-valid edges persisted), superseded (prior facts soft-deleted
-   *   plus prior source-ref edges hard-deleted).
+   *   plus prior source-ref edges hard-deleted), and supersededFactIds (the
+   *   ids of those soft-deleted facts, for the caller's post-commit index sync).
    *
    * Node-ownership pre-flight (spec §3, REQ-GRAPH-01): the first statement
    * is `assertGraphNodeOwnership(entityId, params.nodes, tx)`, which runs
@@ -2623,6 +2699,9 @@ var IngestionService = class {
    * ordering and counts so success counts match the pre-change contract.
    */
   async upsertGraphCore(entityId, params, tx, opts) {
+    const sourceRef = normalizeSourceRef(params.sourceRef);
+    if (!sourceRef) throw new Error("Invalid sourceRef");
+    params = { ...params, sourceRef };
     await this.assertGraphNodeOwnership(entityId, params.nodes, tx);
     const now = Date.now();
     const ontologyState = await this.ontologyService?.getEffectiveState(entityId, tx) ?? { mode: "off", manifest: { node_types: [], edge_types: [] } };
@@ -2735,7 +2814,8 @@ var IngestionService = class {
     return {
       nodesWritten: wikiFacts.length,
       edgesWritten: edgesInsertedCount,
-      superseded: deletedFactIds.length + deletedEdgeCount
+      superseded: deletedFactIds.length + deletedEdgeCount,
+      supersededFactIds: deletedFactIds
     };
   }
   /**
@@ -3322,6 +3402,784 @@ async function runBatched(args) {
   return { results, skipped, batches, unattempted, ...budgetStop ? { budgetStop } : {} };
 }
 
+// src/repositories/rowMappers.ts
+function parseJsonArray(s, fallback) {
+  if (Array.isArray(s)) return s;
+  if (typeof s === "string" && s.length > 0) {
+    try {
+      const p = JSON.parse(s);
+      if (Array.isArray(p)) return p;
+    } catch {
+    }
+  }
+  return fallback;
+}
+function parseJsonObject(s, fallback = null) {
+  if (s && typeof s === "object" && !Array.isArray(s)) return s;
+  if (typeof s === "string" && s.length > 0) {
+    try {
+      const p = JSON.parse(s);
+      if (p && typeof p === "object" && !Array.isArray(p)) return p;
+    } catch {
+    }
+  }
+  return fallback;
+}
+
+// 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 'librarian_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,
+      embedding TEXT,
+      embedding_blob BLOB,
+      okf_type TEXT,
+      ontology_checked_at INTEGER,
+      heal_checked_at INTEGER,
+      lifecycle_status TEXT NOT NULL DEFAULT 'stable',
+      stale_after INTEGER,
+      generated_by TEXT,
+      last_verified_at INTEGER,
+      last_verified_by TEXT,
+      okf_sources TEXT,
+      okf_verified TEXT,
+      okf_usage_window TEXT,
+      embedding_failed_at INTEGER,
+      embedding_failure_kind TEXT,
+      embedding_attempts INTEGER NOT NULL DEFAULT 0,
+      valid_from INTEGER,
+      valid_to INTEGER,
+      superseded_by TEXT,
+      superseded_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);
+
+    -- source_ref_index: per-(entity, source_hash) record of the canonical sourceRef
+    -- currently holding that hash. The partial UNIQUE index on (entity_id, source_hash)
+    -- WHERE deleted_at IS NULL enforces the sourceRef-level TOCTOU-race invariant;
+    -- entries-level uniqueness cannot express it because a single ingestDocument call
+    -- writes N facts that all share (entity_id, source_ref, source_hash). See
+    -- docs/superpowers/specs/2026-08-07-dependabot-concurrency-release-hygiene-design.md \xA7B1.
+    CREATE TABLE IF NOT EXISTS ${prefix}source_ref_index (
+      id TEXT PRIMARY KEY,
+      entity_id TEXT NOT NULL,
+      source_hash TEXT NOT NULL,
+      source_ref TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      deleted_at INTEGER
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS ${prefix}idx_source_ref_hash
+      ON ${prefix}source_ref_index (entity_id, source_hash)
+      WHERE deleted_at IS NULL;
+
+    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,
+      okf_type TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'stable',
+      stale_after INTEGER,
+      generated_by TEXT,
+      last_verified_at INTEGER,
+      last_verified_by TEXT,
+      okf_sources TEXT,
+      okf_verified TEXT,
+      okf_usage_window TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS ${prefix}tasks_entity_idx ON ${prefix}tasks(entity_id, status);
+
+    CREATE TABLE IF NOT EXISTS ${prefix}edges (
+      id TEXT PRIMARY KEY,
+      entity_id TEXT NOT NULL,
+      source_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      edge_type TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      UNIQUE(entity_id, source_id, target_id, edge_type)
+    );
+
+    CREATE INDEX IF NOT EXISTS ${prefix}edges_entity_id_idx ON ${prefix}edges(entity_id, id);
+
+    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,
+      occurred_at INTEGER
+    );
+
+    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,
+      librarian_watermark_at INTEGER,
+      librarian_watermark_id TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS ${prefix}entity_manifests (
+      entity_id TEXT PRIMARY KEY,
+      mode TEXT NOT NULL DEFAULT 'off',
+      manifest_json TEXT NOT NULL DEFAULT '{"node_types":[],"edge_types":[]}',
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS ${prefix}meta (
+      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);
+
+    CREATE INDEX IF NOT EXISTS ${prefix}outbox_created_at
+      ON ${prefix}outbox (created_at);
+  `);
+  await createOkfV02IndexesIfColumnsExist(db, prefix);
+  await createTemporalIndexesIfColumnsExist(db, prefix);
+}
+async function createOkfV02IndexesIfColumnsExist(db, prefix) {
+  for (const table of ["entries", "tasks"]) {
+    const cols = await db.getAllAsync(
+      `PRAGMA table_info(${prefix}${table})`
+    );
+    const colNames = new Set(cols.map((c) => c.name));
+    if (colNames.has("lifecycle_status")) {
+      await db.execAsync(`CREATE INDEX IF NOT EXISTS ${prefix}${table}_lifecycle_status_idx ON ${prefix}${table}(lifecycle_status);`);
+    }
+    if (colNames.has("stale_after")) {
+      await db.execAsync(`CREATE INDEX IF NOT EXISTS ${prefix}${table}_stale_after_idx ON ${prefix}${table}(stale_after);`);
+    }
+    if (colNames.has("last_verified_at")) {
+      await db.execAsync(`CREATE INDEX IF NOT EXISTS ${prefix}${table}_last_verified_at_idx ON ${prefix}${table}(last_verified_at);`);
+    }
+  }
+}
+async function createTemporalIndexesIfColumnsExist(db, prefix) {
+  const cols = await db.getAllAsync(`PRAGMA table_info(${prefix}entries)`);
+  const names = new Set(cols.map((c) => c.name));
+  if (names.has("superseded_by")) {
+    await db.execAsync(
+      `CREATE INDEX IF NOT EXISTS ${prefix}entries_superseded_idx ON ${prefix}entries(entity_id, superseded_by) WHERE superseded_by IS NOT NULL;`
+    );
+  }
+  if (names.has("valid_from") && names.has("valid_to")) {
+    await db.execAsync(
+      `CREATE INDEX IF NOT EXISTS ${prefix}entries_temporal_idx ON ${prefix}entries(entity_id) WHERE valid_from IS NOT NULL OR valid_to IS NOT NULL;`
+    );
+  }
+}
+
+// src/services/search/fts5Sql.ts
+var FTS5_STATE_KEY = "fts5_index_state";
+var FTS5_DRAIN_CHUNK = 500;
+var FTS5_SWEEP_CHUNK = 500;
+var FTS5_RETIRED_TABLES_KEY = "fts5_retired_tables";
+var FTS5_RETIRED_COUNTER_KEY = "fts5_retired_counter";
+var FTS5_RECLAIM_MERGE_PAGES = 500;
+function retiredTableName(p, n) {
+  return `${p}entries_fts_retired_${n}`;
+}
+function isRetiredTableName(p, name) {
+  return typeof name === "string" && name.startsWith(`${p}entries_fts_retired_`) && /^\d+$/.test(name.slice(`${p}entries_fts_retired_`.length));
+}
+var FTS5_REBUILD_WM_KEY = "fts5_rebuild_wm";
+var FTS5_REBUILD_SNAPSHOT_KEY = "fts5_rebuild_snapshot";
+var FTS5_SWEEP_CURSOR_KEY = "fts5_orphan_sweep_cursor";
+function fts5TriggerNames(prefix) {
+  return [`${prefix}entries_fts_ai`, `${prefix}entries_fts_au`, `${prefix}entries_fts_ad`];
+}
+function tagsExpr(col) {
+  return `CASE WHEN json_valid(${col}) THEN
+      CASE WHEN json_type(${col}) = 'array' THEN
+        (SELECT group_concat(CASE type WHEN 'true' THEN 'true' WHEN 'false' THEN 'false'
+                                       WHEN 'null' THEN '' ELSE value END, ' ')
+           FROM json_each(${col}))
+      ELSE ${col} END
+    ELSE ${col} END`;
+}
+function fts5TablesDdl(p) {
+  return `
+CREATE VIRTUAL TABLE IF NOT EXISTS ${p}entries_fts USING fts5(
+  id UNINDEXED, entity_id UNINDEXED, title, body, tags,
+  tokenize = 'porter unicode61'
+);
+CREATE TABLE IF NOT EXISTS ${p}fts_map (
+  fts_rowid INTEGER PRIMARY KEY,
+  id TEXT NOT NULL UNIQUE,
+  entity_id TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS ${p}fts_map_entity ON ${p}fts_map(entity_id);
+CREATE TABLE IF NOT EXISTS ${p}fts_pending (
+  seq INTEGER PRIMARY KEY,
+  entity_id TEXT NOT NULL,
+  id TEXT NOT NULL
+);`;
+}
+function fts5TriggersDdl(p) {
+  const [ai, au, ad] = fts5TriggerNames(p);
+  return `
+CREATE TRIGGER IF NOT EXISTS ${ai} AFTER INSERT ON ${p}entries BEGIN
+  INSERT INTO ${p}fts_pending (entity_id, id) VALUES (NEW.entity_id, NEW.id);
+END;
+CREATE TRIGGER IF NOT EXISTS ${au}
+AFTER UPDATE OF id, entity_id, title, body, tags, deleted_at ON ${p}entries BEGIN
+  INSERT INTO ${p}fts_pending (entity_id, id) VALUES (OLD.entity_id, OLD.id);
+  INSERT INTO ${p}fts_pending (entity_id, id)
+    SELECT NEW.entity_id, NEW.id WHERE NEW.id <> OLD.id OR NEW.entity_id <> OLD.entity_id;
+END;
+CREATE TRIGGER IF NOT EXISTS ${ad} AFTER DELETE ON ${p}entries BEGIN
+  INSERT INTO ${p}fts_pending (entity_id, id) VALUES (OLD.entity_id, OLD.id);
+END;`;
+}
+function drainHiSql(p) {
+  return `SELECT max(seq) AS hi FROM (SELECT seq FROM ${p}fts_pending ORDER BY seq LIMIT ${FTS5_DRAIN_CHUNK})`;
+}
+function ledgerChunkSql(p, chunkIds, ledgerWhere) {
+  return [
+    `DELETE FROM ${p}entries_fts WHERE rowid IN (SELECT m.fts_rowid FROM ${p}fts_map m WHERE m.id IN (${chunkIds}))`,
+    `DELETE FROM ${p}fts_map WHERE id IN (${chunkIds})`,
+    `INSERT INTO ${p}fts_map (id, entity_id)
+       SELECT e.id, e.entity_id FROM ${p}entries e WHERE e.id IN (${chunkIds}) AND e.deleted_at IS NULL`,
+    `INSERT INTO ${p}entries_fts (rowid, id, entity_id, title, body, tags)
+       SELECT m.fts_rowid, e.id, e.entity_id, e.title, e.body, ${tagsExpr("e.tags")}
+       FROM ${p}fts_map m JOIN ${p}entries e ON e.id = m.id
+       WHERE m.id IN (${chunkIds})`,
+    `DELETE FROM ${p}fts_pending WHERE ${ledgerWhere}`
+  ];
+}
+function drainChunkSql(p) {
+  return ledgerChunkSql(p, `SELECT id FROM ${p}fts_pending WHERE seq <= ?`, "seq <= ?");
+}
+function fts5PendingIndexesDdl(p) {
+  return `
+CREATE INDEX IF NOT EXISTS ${p}fts_pending_id ON ${p}fts_pending(id);
+CREATE INDEX IF NOT EXISTS ${p}fts_pending_entity ON ${p}fts_pending(entity_id);`;
+}
+function idDrainChunkSql(p) {
+  return ledgerChunkSql(
+    p,
+    `SELECT id FROM ${p}fts_pending WHERE id IN (SELECT value FROM json_each(?))`,
+    "id IN (SELECT value FROM json_each(?))"
+  );
+}
+function idReindexChunkSql(p) {
+  return ledgerChunkSql(p, "SELECT value FROM json_each(?)", "id IN (SELECT value FROM json_each(?))");
+}
+function entityDrainHiSql(p) {
+  return `SELECT max(seq) AS hi FROM (SELECT seq FROM ${p}fts_pending WHERE entity_id = ? ORDER BY seq LIMIT ${FTS5_DRAIN_CHUNK})`;
+}
+function entityDrainChunkSql(p) {
+  return ledgerChunkSql(p, `SELECT id FROM ${p}fts_pending WHERE entity_id = ? AND seq <= ?`, "entity_id = ? AND seq <= ?");
+}
+function fts5LedgerDropSql(p) {
+  return [
+    ...fts5TriggerNames(p).map((n) => `DROP TRIGGER IF EXISTS ${n};`),
+    `DROP TABLE IF EXISTS ${p}fts_pending;`,
+    `DROP TABLE IF EXISTS ${p}fts_map;`
+  ].join("\n");
+}
+function windowHiSql(p) {
+  return `SELECT max(rowid) AS hi FROM (SELECT rowid FROM ${p}entries WHERE rowid > ? AND rowid <= ? ORDER BY rowid LIMIT ${FTS5_DRAIN_CHUNK})`;
+}
+function windowChunkSql(p) {
+  const chunkIds = `SELECT id FROM ${p}entries WHERE rowid > ? AND rowid <= ?`;
+  return [
+    `DELETE FROM ${p}entries_fts WHERE rowid IN (SELECT m.fts_rowid FROM ${p}fts_map m WHERE m.id IN (${chunkIds}))`,
+    `DELETE FROM ${p}fts_map WHERE id IN (${chunkIds})`,
+    `INSERT INTO ${p}fts_map (id, entity_id)
+       SELECT e.id, e.entity_id FROM ${p}entries e WHERE e.rowid > ? AND e.rowid <= ? AND e.deleted_at IS NULL`,
+    `INSERT INTO ${p}entries_fts (rowid, id, entity_id, title, body, tags)
+       SELECT m.fts_rowid, e.id, e.entity_id, e.title, e.body, ${tagsExpr("e.tags")}
+       FROM ${p}entries e JOIN ${p}fts_map m ON m.id = e.id
+       WHERE e.rowid > ? AND e.rowid <= ?`
+  ];
+}
+function sweepHiSql(p) {
+  return `SELECT max(fts_rowid) AS hi FROM (SELECT fts_rowid FROM ${p}fts_map WHERE fts_rowid > ? AND fts_rowid <= ? ORDER BY fts_rowid LIMIT ${FTS5_SWEEP_CHUNK})`;
+}
+function sweepChunkSql(p) {
+  const orphans = `SELECT m.fts_rowid FROM ${p}fts_map m
+     WHERE m.fts_rowid > ? AND m.fts_rowid <= ? AND NOT EXISTS (SELECT 1 FROM ${p}entries e WHERE e.id = m.id)`;
+  return [
+    `DELETE FROM ${p}entries_fts WHERE rowid IN (${orphans})`,
+    `DELETE FROM ${p}fts_map WHERE fts_rowid IN (${orphans})`
+  ];
+}
+
+// src/db/migrations.ts
+var MIGRATIONS = [
+  {
+    version: 1,
+    description: "Rebuild FTS5 with porter unicode61 tokenizer (superseded by v2)",
+    run: async (_db, _prefix) => {
+    }
+  },
+  {
+    version: 2,
+    description: "Remove FTS5; add embedding column for semantic retrieval",
+    run: async (db, prefix) => {
+      await db.withTransactionAsync(async (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;
+          DROP TABLE IF EXISTS ${prefix}entries_fts;
+        `);
+      });
+      const cols = await db.getAllAsync(
+        `PRAGMA table_info(${prefix}entries)`
+      );
+      if (!cols.some((c) => c.name === "embedding")) {
+        await db.execAsync(`ALTER TABLE ${prefix}entries ADD COLUMN embedding TEXT`);
+      }
+    }
+  },
+  {
+    version: 3,
+    description: "Add embedding_blob BLOB column for Float32Array vector storage",
+    run: async (db, prefix) => {
+      const cols = await db.getAllAsync(
+        `PRAGMA table_info(${prefix}entries)`
+      );
+      if (!cols.some((c) => c.name === "embedding_blob")) {
+        await db.execAsync(
+          `ALTER TABLE ${prefix}entries ADD COLUMN embedding_blob BLOB`
+        );
+      }
+    }
+  },
+  {
+    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);
+      `);
+    }
+  },
+  {
+    version: 5,
+    description: "Add okf_type to entries/tasks for OKF type fidelity; create edges table for OKF graph import",
+    run: async (db, prefix) => {
+      for (const table of ["entries", "tasks"]) {
+        const cols = await db.getAllAsync(
+          `PRAGMA table_info(${prefix}${table})`
+        );
+        if (!cols.some((c) => c.name === "okf_type")) {
+          await db.execAsync(`ALTER TABLE ${prefix}${table} ADD COLUMN okf_type TEXT`);
+        }
+      }
+      await db.execAsync(`
+        CREATE TABLE IF NOT EXISTS ${prefix}edges (
+          id TEXT PRIMARY KEY,
+          entity_id TEXT NOT NULL,
+          source_id TEXT NOT NULL,
+          target_id TEXT NOT NULL,
+          edge_type TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          UNIQUE(entity_id, source_id, target_id, edge_type)
+        );
+        CREATE INDEX IF NOT EXISTS ${prefix}edges_entity_idx ON ${prefix}edges (entity_id);
+      `);
+    }
+  },
+  {
+    version: 6,
+    description: "Add entity_manifests table for per-entity ontology state",
+    run: async (db, prefix) => {
+      await db.execAsync(`
+        CREATE TABLE IF NOT EXISTS ${prefix}entity_manifests (
+          entity_id TEXT PRIMARY KEY,
+          mode TEXT NOT NULL DEFAULT 'off',
+          manifest_json TEXT NOT NULL DEFAULT '{"node_types":[],"edge_types":[]}',
+          updated_at INTEGER NOT NULL
+        );
+      `);
+    }
+  },
+  {
+    version: 7,
+    description: "Add ontology_checked_at to entries for ontology backfill recheck cooldown",
+    run: async (db, prefix) => {
+      const cols = await db.getAllAsync(
+        `PRAGMA table_info(${prefix}entries)`
+      );
+      if (!cols.some((c) => c.name === "ontology_checked_at")) {
+        await db.execAsync(
+          `ALTER TABLE ${prefix}entries ADD COLUMN ontology_checked_at INTEGER`
+        );
+      }
+    }
+  },
+  {
+    version: 8,
+    description: "Add heal_checked_at to entries for heal recheck cooldown",
+    run: async (db, prefix) => {
+      const cols = await db.getAllAsync(
+        `PRAGMA table_info(${prefix}entries)`
+      );
+      if (!cols.some((c) => c.name === "heal_checked_at")) {
+        await db.execAsync(
+          `ALTER TABLE ${prefix}entries ADD COLUMN heal_checked_at INTEGER`
+        );
+      }
+    }
+  },
+  {
+    version: 9,
+    description: "add_source_ref_index",
+    run: async (db, prefix) => {
+      const duplicates = await db.getAllAsync(
+        `SELECT entity_id, source_hash, COUNT(DISTINCT source_ref) AS n_refs
+         FROM ${prefix}entries
+         WHERE deleted_at IS NULL AND source_hash IS NOT NULL
+         GROUP BY entity_id, source_hash
+         HAVING COUNT(DISTINCT source_ref) > 1`
+      );
+      if (duplicates.length > 0) {
+        const sample = duplicates.slice(0, 5).map((d) => `(entity_id=${d.entity_id}, source_hash=${d.source_hash.slice(0, 12)}\u2026, n_refs=${d.n_refs})`).join(", ");
+        throw new Error(
+          `Migration v9 (add_source_ref_index) failed: existing live rows have multiple sourceRefs sharing a hash. Found ${duplicates.length} duplicate (entity_id, source_hash) groups. First ${Math.min(5, duplicates.length)}: ${sample}. Resolve each by calling forget({ sourceRef: <loser> }) for the offending sourceRef, then re-run setup.`
+        );
+      }
+      await db.execAsync(
+        `CREATE TABLE IF NOT EXISTS ${prefix}source_ref_index (
+          id TEXT PRIMARY KEY,
+          entity_id TEXT NOT NULL,
+          source_hash TEXT NOT NULL,
+          source_ref TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          deleted_at INTEGER
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS ${prefix}idx_source_ref_hash
+          ON ${prefix}source_ref_index (entity_id, source_hash)
+          WHERE deleted_at IS NULL;`
+      );
+      await db.execAsync(
+        `INSERT OR IGNORE INTO ${prefix}source_ref_index (id, entity_id, source_hash, source_ref, created_at, deleted_at)
+         SELECT
+           'sri:' || entity_id || ':' || source_hash,
+           entity_id,
+           source_hash,
+           source_ref,
+           updated_at,
+           NULL
+         FROM (
+           SELECT
+             entity_id, source_hash, source_ref, updated_at,
+             ROW_NUMBER() OVER (
+               PARTITION BY entity_id, source_hash
+               ORDER BY updated_at ASC, id ASC
+             ) AS rn
+           FROM ${prefix}entries
+           WHERE deleted_at IS NULL
+             AND source_hash IS NOT NULL
+             AND source_ref IS NOT NULL
+         ) ranked
+         WHERE rn = 1;`
+      );
+    }
+  },
+  {
+    version: 10,
+    description: "OKF v0.2: add lifecycle_status, stale_after, generated_by, last_verified_*, okf_sources, okf_verified, okf_usage_window to entries and tasks",
+    run: async (db, prefix) => {
+      for (const table of ["entries", "tasks"]) {
+        const cols = await db.getAllAsync(
+          `PRAGMA table_info(${prefix}${table})`
+        );
+        const existing = new Set(cols.map((c) => c.name));
+        const adds = [
+          ["lifecycle_status", `ALTER TABLE ${prefix}${table} ADD COLUMN lifecycle_status TEXT NOT NULL DEFAULT 'stable'`],
+          ["stale_after", `ALTER TABLE ${prefix}${table} ADD COLUMN stale_after INTEGER`],
+          ["generated_by", `ALTER TABLE ${prefix}${table} ADD COLUMN generated_by TEXT`],
+          ["last_verified_at", `ALTER TABLE ${prefix}${table} ADD COLUMN last_verified_at INTEGER`],
+          ["last_verified_by", `ALTER TABLE ${prefix}${table} ADD COLUMN last_verified_by TEXT`],
+          ["okf_sources", `ALTER TABLE ${prefix}${table} ADD COLUMN okf_sources TEXT`],
+          ["okf_verified", `ALTER TABLE ${prefix}${table} ADD COLUMN okf_verified TEXT`],
+          ["okf_usage_window", `ALTER TABLE ${prefix}${table} ADD COLUMN okf_usage_window TEXT`]
+        ];
+        for (const [name, sql] of adds) {
+          if (!existing.has(name)) await db.execAsync(sql);
+        }
+      }
+      await db.execAsync(`
+        CREATE INDEX IF NOT EXISTS ${prefix}entries_lifecycle_status_idx ON ${prefix}entries(lifecycle_status);
+        CREATE INDEX IF NOT EXISTS ${prefix}entries_stale_after_idx ON ${prefix}entries(stale_after);
+        CREATE INDEX IF NOT EXISTS ${prefix}entries_last_verified_at_idx ON ${prefix}entries(last_verified_at);
+        CREATE INDEX IF NOT EXISTS ${prefix}tasks_lifecycle_status_idx ON ${prefix}tasks(lifecycle_status);
+        CREATE INDEX IF NOT EXISTS ${prefix}tasks_stale_after_idx ON ${prefix}tasks(stale_after);
+        CREATE INDEX IF NOT EXISTS ${prefix}tasks_last_verified_at_idx ON ${prefix}tasks(last_verified_at);
+      `);
+    }
+  },
+  {
+    version: 11,
+    description: "Add embedding_failed_at, embedding_failure_kind, embedding_attempts to entries for embed retry state",
+    run: async (db, prefix) => {
+      const cols = await db.getAllAsync(
+        `PRAGMA table_info(${prefix}entries)`
+      );
+      const existing = new Set(cols.map((c) => c.name));
+      const adds = [
+        ["embedding_failed_at", `ALTER TABLE ${prefix}entries ADD COLUMN embedding_failed_at INTEGER`],
+        ["embedding_failure_kind", `ALTER TABLE ${prefix}entries ADD COLUMN embedding_failure_kind TEXT`],
+        ["embedding_attempts", `ALTER TABLE ${prefix}entries ADD COLUMN embedding_attempts INTEGER NOT NULL DEFAULT 0`]
+      ];
+      for (const [name, sql] of adds) {
+        if (!existing.has(name)) await db.execAsync(sql);
+      }
+    }
+  },
+  {
+    version: 12,
+    description: "Replace edges_entity_idx with composite edges(entity_id, id) for keyset paging",
+    run: async (db, prefix) => {
+      await db.execAsync(`
+        CREATE INDEX IF NOT EXISTS ${prefix}edges_entity_id_idx ON ${prefix}edges(entity_id, id);
+        DROP INDEX IF EXISTS ${prefix}edges_entity_idx;
+      `);
+    }
+  },
+  {
+    version: 13,
+    description: "Temporal facts: valid_from/valid_to/superseded_by/superseded_at on entries, occurred_at on events, librarian watermark on checkpoints",
+    run: async (db, prefix) => {
+      const adds = [
+        ["entries", "valid_from", "INTEGER"],
+        ["entries", "valid_to", "INTEGER"],
+        ["entries", "superseded_by", "TEXT"],
+        ["entries", "superseded_at", "INTEGER"],
+        ["events", "occurred_at", "INTEGER"],
+        ["checkpoints", "librarian_watermark_at", "INTEGER"],
+        ["checkpoints", "librarian_watermark_id", "TEXT"]
+      ];
+      const existingByTable = /* @__PURE__ */ new Map();
+      for (const [table, column, type] of adds) {
+        let existing = existingByTable.get(table);
+        if (!existing) {
+          const cols = await db.getAllAsync(`PRAGMA table_info(${prefix}${table})`);
+          existing = new Set(cols.map((c) => c.name));
+          existingByTable.set(table, existing);
+        }
+        if (!existing.has(column)) {
+          await db.execAsync(`ALTER TABLE ${prefix}${table} ADD COLUMN ${column} ${type}`);
+          existing.add(column);
+        }
+      }
+      await createTemporalIndexesIfColumnsExist(db, prefix);
+    }
+  },
+  {
+    version: 14,
+    description: "Partial index for the every-open legacy source_type probe",
+    run: async (db, prefix) => {
+      await createLegacySourceTypeIndex(db, prefix);
+    }
+  },
+  {
+    version: 15,
+    description: "fts_pending(id) and fts_pending(entity_id) indexes for the ids-first and entity-targeted drains",
+    run: async (db, prefix) => {
+      const row = await db.getFirstAsync(
+        `SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = ?`,
+        [`${prefix}fts_pending`]
+      );
+      if (row?.n) await db.execAsync(fts5PendingIndexesDdl(prefix));
+    }
+  }
+];
+async function createLegacySourceTypeIndex(db, prefix) {
+  await db.execAsync(
+    `CREATE INDEX IF NOT EXISTS ${prefix}entries_legacy_source_type_idx ON ${prefix}entries(source_type) WHERE source_type IN ('user_document', 'agent_inferred')`
+  );
+}
+for (let i = 1; i < MIGRATIONS.length; i++) {
+  if (MIGRATIONS[i].version <= MIGRATIONS[i - 1].version) {
+    throw new Error(
+      `migrations.ts: MIGRATIONS must be in strictly ascending version order. Found version ${MIGRATIONS[i].version} after ${MIGRATIONS[i - 1].version} at index ${i}.`
+    );
+  }
+}
+var CURRENT_SCHEMA_VERSION = MIGRATIONS.length > 0 ? MIGRATIONS[MIGRATIONS.length - 1].version : 0;
+
+// src/db/sourceRefNormalize.ts
+var SOURCE_REF_NORMALIZE_ALG = 1;
+var NORMALIZE_STAMP_SCHEMA_VERSION = 14;
+var NORMALIZE_STAMP_KEY = "source_ref_normalize_stamp";
+var ENTRIES_WM_KEY = "normalize_v14_entries_wm";
+var SRI_WM_KEY = "normalize_v14_sri_wm";
+var CHUNK = 500;
+function stampMatches(raw) {
+  return parseJsonObject(raw)?.normalize_alg === SOURCE_REF_NORMALIZE_ALG;
+}
+async function writeNormalizeStamp(meta, tx) {
+  await meta.setMeta(NORMALIZE_STAMP_KEY, JSON.stringify({ schema_version: NORMALIZE_STAMP_SCHEMA_VERSION, normalize_alg: SOURCE_REF_NORMALIZE_ALG }), tx);
+}
+async function resumeRowid(db, prefix, meta, table, key) {
+  const wm = parseJsonObject(await meta.getMeta(key));
+  if (typeof wm?.rowid !== "number" || typeof wm.id !== "string") return 0;
+  const row = await db.getFirstAsync(`SELECT id FROM ${prefix}${table} WHERE rowid = ?`, [wm.rowid]);
+  return row?.id === wm.id ? wm.rowid : 0;
+}
+async function resetNormalizeWatermarks(meta) {
+  await meta.deleteMeta(ENTRIES_WM_KEY);
+  await meta.deleteMeta(SRI_WM_KEY);
+}
+async function detectSchemaVersion(meta, prefix) {
+  const stored = await meta.getMeta("schema_version");
+  if (stored) {
+    const v = parseInt(stored, 10);
+    return Number.isFinite(v) ? v : 0;
+  }
+  const ftsDdl = await meta.getTableDdl(`${prefix}entries_fts`);
+  return /tokenize\s*=\s*['"]porter\s+unicode61['"]/i.test(ftsDdl ?? "") ? 1 : 0;
+}
+async function runPass(db, prefix, meta, table, key, stampOnCompletion) {
+  let cursor = await resumeRowid(db, prefix, meta, table, key);
+  while (cursor !== null) {
+    const from = cursor;
+    let next = from;
+    await db.withTransactionAsync(async (tx) => {
+      const rows = await tx.getAllAsync(
+        `SELECT rowid, id, source_ref FROM ${prefix}${table} WHERE rowid > ? ORDER BY rowid LIMIT ${CHUNK}`,
+        [from]
+      );
+      for (const r of rows) {
+        if (r.source_ref == null) continue;
+        const n = normalizeSourceRef(r.source_ref);
+        if (n === r.source_ref) continue;
+        if (table === "entries") {
+          await tx.runAsync(`UPDATE ${prefix}entries SET source_ref = ? WHERE rowid = ?`, [n, r.rowid]);
+        } else if (n === null) {
+          await tx.runAsync(`UPDATE ${prefix}source_ref_index SET deleted_at = COALESCE(deleted_at, ?) WHERE rowid = ?`, [Date.now(), r.rowid]);
+        } else {
+          await tx.runAsync(`UPDATE ${prefix}source_ref_index SET source_ref = ? WHERE rowid = ?`, [n, r.rowid]);
+        }
+      }
+      if (rows.length < CHUNK) {
+        await meta.deleteMeta(key, tx);
+        if (stampOnCompletion) await writeNormalizeStamp(meta, tx);
+        next = null;
+        return;
+      }
+      const last = rows[rows.length - 1];
+      await meta.setMeta(key, JSON.stringify({ rowid: last.rowid, id: last.id }), tx);
+      next = last.rowid;
+    });
+    cursor = next;
+  }
+}
+async function probePendingWork(db, meta, prefix) {
+  if (!await meta.tableExists(`${prefix}entries`)) return null;
+  if (!await meta.tableExists(`${prefix}meta`)) {
+    return { type: "schema_migration", fromVersion: 0, toVersion: CURRENT_SCHEMA_VERSION };
+  }
+  const version = await detectSchemaVersion(meta, prefix);
+  if (version < CURRENT_SCHEMA_VERSION) {
+    return { type: "schema_migration", fromVersion: version, toVersion: CURRENT_SCHEMA_VERSION };
+  }
+  if (!stampMatches(await meta.getMeta(NORMALIZE_STAMP_KEY))) {
+    return {
+      type: "source_ref_normalize",
+      entriesWatermark: await resumeRowid(db, prefix, meta, "entries", ENTRIES_WM_KEY),
+      sourceRefIndexWatermark: await resumeRowid(db, prefix, meta, "source_ref_index", SRI_WM_KEY)
+    };
+  }
+  return null;
+}
+async function runSourceRefNormalize(db, prefix, meta) {
+  if (stampMatches(await meta.getMeta(NORMALIZE_STAMP_KEY))) return;
+  await runPass(db, prefix, meta, "entries", ENTRIES_WM_KEY, false);
+  await runPass(db, prefix, meta, "source_ref_index", SRI_WM_KEY, true);
+}
+
+// src/services/search/fts5Progress.ts
+async function writeRebuildStart(tx, prefix, meta) {
+  const e = await tx.getFirstAsync(`SELECT coalesce(max(rowid), 0) AS hi FROM ${prefix}entries`);
+  const m = await tx.getFirstAsync(`SELECT coalesce(max(fts_rowid), 0) AS hi FROM ${prefix}fts_map`);
+  await meta.setMeta(FTS5_REBUILD_WM_KEY, JSON.stringify({ rowid: 0, id: null }), tx);
+  await meta.setMeta(FTS5_REBUILD_SNAPSHOT_KEY, JSON.stringify({ entries: e?.hi ?? 0, map: m?.hi ?? 0 }), tx);
+  await meta.setMeta(FTS5_SWEEP_CURSOR_KEY, "0", tx);
+}
+async function readRebuildProgress(meta, tx) {
+  const wm = parseJsonObject(await meta.getMeta(FTS5_REBUILD_WM_KEY, tx));
+  const snap = parseJsonObject(await meta.getMeta(FTS5_REBUILD_SNAPSHOT_KEY, tx));
+  const rawCursor = await meta.getMeta(FTS5_SWEEP_CURSOR_KEY, tx);
+  const cursor = rawCursor === null ? Number.NaN : Number(rawCursor);
+  if (typeof wm?.rowid !== "number" || !(typeof wm.id === "string" || wm.id === null)) return null;
+  if (typeof snap?.entries !== "number" || typeof snap.map !== "number" || !Number.isFinite(cursor)) return null;
+  return { wm: { rowid: wm.rowid, id: wm.id }, snapshot: { entries: snap.entries, map: snap.map }, cursor };
+}
+async function reanchorRebuildFingerprint(tx, prefix, deletedIds) {
+  if (deletedIds.length === 0) return;
+  const metaValue = async (key) => (await tx.getFirstAsync(`SELECT value FROM ${prefix}meta WHERE key = ?`, [key]))?.value ?? null;
+  if (await metaValue(FTS5_STATE_KEY) !== "rebuilding") return;
+  const wm = parseJsonObject(await metaValue(FTS5_REBUILD_WM_KEY));
+  if (typeof wm?.rowid !== "number" || typeof wm.id !== "string" || !deletedIds.includes(wm.id)) return;
+  if ((await tx.getFirstAsync(`SELECT id FROM ${prefix}entries WHERE rowid = ?`, [wm.rowid]))?.id === wm.id) return;
+  const below = await tx.getFirstAsync(
+    `SELECT rowid, id FROM ${prefix}entries WHERE rowid < ? ORDER BY rowid DESC LIMIT 1`,
+    [wm.rowid]
+  );
+  const next = below ? { rowid: below.rowid, id: below.id } : { rowid: 0, id: null };
+  await tx.runAsync(`UPDATE ${prefix}meta SET value = ? WHERE key = ?`, [JSON.stringify(next), FTS5_REBUILD_WM_KEY]);
+}
+async function restartRebuildAfterVacuum(db, prefix, meta) {
+  await db.withTransactionAsync(async (tx) => {
+    if (await meta.getMeta(FTS5_STATE_KEY, tx) !== "rebuilding") return;
+    await writeRebuildStart(tx, prefix, meta);
+  });
+}
+
 // src/services/librarian/constants.ts
 var FUZZY_THRESHOLD = 0.5;
 var MIN_TOKENS_TO_QUALIFY = 3;
@@ -3606,6 +4464,22 @@ function classifyCandidate(candidate, neighbours, cfg, mode) {
   if (score < cfg.novelThreshold) return { kind: "add" };
   return { kind: "ambiguous" };
 }
+async function loadStoredVectors(deps, entityId, nonLive) {
+  const stored = [];
+  for (const row of await deps.entryRepo.findWithEmbeddingsByEntityIds([entityId])) {
+    if (nonLive.has(row.id)) continue;
+    const vec = parseEmbedding(row.embedding_blob, row.embedding);
+    if (vec) stored.push({ id: row.id, vec });
+  }
+  return stored;
+}
+async function gateNeedsKeyword(deps, entityId) {
+  if (!await deps.entryRepo.hasLiveEntry(entityId)) return false;
+  if (typeof deps.options.llmProvider.embed !== "function") return true;
+  const nonLive = await deps.entryRepo.findNonLiveIdsByEntityIds([entityId], "current", Date.now());
+  const stored = await loadStoredVectors(deps, entityId, nonLive);
+  return stored.length === 0 || stored.some((s) => s.vec.length !== stored[0].vec.length);
+}
 async function gateCandidates(deps, ctx, candidates, cfg) {
   const { entityId, trigger } = ctx;
   const seen = /* @__PURE__ */ new Set();
@@ -3621,14 +4495,8 @@ async function gateCandidates(deps, ctx, candidates, cfg) {
   }
   const nonLive = await deps.entryRepo.findNonLiveIdsByEntityIds([entityId], "current", Date.now());
   const canEmbed = typeof deps.options.llmProvider.embed === "function";
-  const stored = [];
-  if (canEmbed && unique.length > 0) {
-    for (const row of await deps.entryRepo.findWithEmbeddingsByEntityIds([entityId])) {
-      if (nonLive.has(row.id)) continue;
-      const vec = parseEmbedding(row.embedding_blob, row.embedding);
-      if (vec) stored.push({ id: row.id, vec });
-    }
-  }
+  const stored = canEmbed && unique.length > 0 ? await loadStoredVectors(deps, entityId, nonLive) : [];
+  const hasFacts = unique.length > 0 && await deps.entryRepo.hasLiveEntry(entityId);
   const gated = [];
   for (const c of unique) {
     let ranked = null;
@@ -3649,7 +4517,7 @@ async function gateCandidates(deps, ctx, candidates, cfg) {
       }
     }
     if (!ranked) {
-      ranked = (await deps.searchService.searchKeyword(`${c.fact.title} ${c.fact.body}`, [entityId], cfg.k + nonLive.size)).filter((h) => !nonLive.has(h.id)).slice(0, cfg.k).map((h) => ({ id: h.id, score: null }));
+      ranked = hasFacts ? (await deps.searchService.searchKeyword(`${c.fact.title} ${c.fact.body}`, [entityId], cfg.k + nonLive.size)).filter((h) => !nonLive.has(h.id)).slice(0, cfg.k).map((h) => ({ id: h.id, score: null })) : [];
     }
     const facts = ranked.length > 0 ? await deps.entryRepo.findByIds(ranked.map((r) => r.id), [entityId]) : [];
     const byId = new Map(facts.map((f) => [f.id, f]));
@@ -4010,6 +4878,9 @@ var runOpsLibrarianPass = async (deps, ctx) => {
   const sel = await selectBatch(deps, entityId, wm, ctx.meter);
   if ("budgetStop" in sel) return { processedThrough: null, factsWritten: 0, budgetStop: sel.budgetStop };
   if (sel.batch.length === 0) return { processedThrough: null, factsWritten: 0 };
+  if (!deps.searchService.isKeywordAvailable() && await gateNeedsKeyword(deps, entityId)) {
+    throw new WikiSearchUnavailableError("librarian: keyword search unavailable and this pass may need it; retry the pass");
+  }
   let ex;
   try {
     ex = await runExtract(deps, ctx, sel.batch);
@@ -4239,7 +5110,9 @@ var MaintenanceService = class {
         }
       }
       if (vacuum) {
+        await resetNormalizeWatermarks(this.metadataRepo);
         await this.metadataRepo.vacuum();
+        await restartRebuildAfterVacuum(this.db, this.prefix, this.metadataRepo);
       }
       await this.searchService.syncEntries(entityId, syncedIds);
       return { entries: deletedEntries, tasks: deletedTasks, events: deletedEvents };
@@ -4538,7 +5411,8 @@ var MaintenanceService = class {
    *
    * Bounded: at most `batchSize` candidates per pass (#67). Loop on
    * `result.remaining > 0` for convergence — see {@link HealResult.remaining}
-   * for what convergence means here.
+   * for what convergence means here, and for the no-progress flags
+   * (`searchUnavailable`, `budgetStop`) a loop must also stop on.
    */
   async doRunHeal(entityId, options) {
     const promptOverride = options?.promptOverride;
@@ -4584,7 +5458,11 @@ var MaintenanceService = class {
       }
     }
     const healCandidates = await this.entryRepo.findHealCandidatesByEntityId(entityId, batchSize, recheckCutoff);
-    if (healCandidates.length === 0) {
+    const keywordUnavailable = healCandidates.length > 0 && !this.searchService.isKeywordAvailable();
+    if (healCandidates.length === 0 || keywordUnavailable) {
+      if (keywordUnavailable) {
+        emitDiagnostic(this.options, { ...diagBase, code: "heal_skipped", detail: { reason: "keyword_search_unavailable", count: healCandidates.length } });
+      }
       await this.searchService.syncEntries(entityId, Array.from(/* @__PURE__ */ new Set([...orphanedIds, ...staleDowngradedIds])));
       this.searchService.evictCache(entityId);
       const counts2 = await this.entryRepo.countHealCandidatesByEntityId(entityId, recheckCutoff);
@@ -4596,7 +5474,10 @@ var MaintenanceService = class {
         skipped: [],
         degraded: [],
         remaining: counts2.eligible,
-        deferred: counts2.deferred
+        deferred: counts2.deferred,
+        // remaining stays > 0 so maybeRunHeal holds the checkpoint back and
+        // retries after the outage; the flag lets a host loop stop instead.
+        ...keywordUnavailable ? { searchUnavailable: true } : {}
       };
     }
     const allTasks = await this.taskRepo.findAllPending([entityId], HEAL_MAX_TASKS);
@@ -5479,7 +6360,7 @@ var ImportExportService = class {
     if (merge) {
       await this.searchService.syncEntries(entityId, [...upsertedFactIds]);
     } else {
-      await this.searchService.sync(entityId);
+      await this.searchService.sync(entityId, { ids: [.../* @__PURE__ */ new Set([...upsertedFactIds, ...softDeletedFactIds])] });
     }
     for (const fact of bundle.facts) {
       if (!fact.deleted_at && upsertedFactIds.has(fact.id) && !factsWithPreservedBlob.has(fact.id)) {
@@ -6129,7 +7010,12 @@ var RetrievalService = class {
               candidateRows = this._withoutIds(await this.entryRepo.findWithEmbeddingsByEntityIds(scoredEntityIds), excludedIds);
             }
             if (weight !== void 0 && weight < 1) {
-              miniSearchScores = await this.searchService.getKeywordScores(trimmedQuery, scoredEntityIds);
+              try {
+                miniSearchScores = await this.searchService.getKeywordScores(trimmedQuery, scoredEntityIds);
+              } catch (err) {
+                if (!isWikiSearchUnavailableError(err)) throw err;
+                miniSearchScores = /* @__PURE__ */ new Map();
+              }
             }
           }
           if (candidateRows === null) {
@@ -6624,6 +7510,7 @@ var WriteService = class {
     this.jobManager = jobManager;
     this.maintenanceService = maintenanceService;
     this.inflight = /* @__PURE__ */ new Set();
+    this.warnedSearchUnavailable = false;
   }
   track(p) {
     this.inflight.add(p);
@@ -6720,8 +7607,7 @@ var WriteService = class {
         this.jobManager.acquireLock("librarian", entityId);
         const stage = { job: "librarian" };
         const job = this.runLibrarianThenMaybeHeal(entityId, librarianCount, prevMemoryCheckpoint, stage).catch((err) => {
-          console.error(err);
-          this.reportBackgroundFailure(entityId, stage.job);
+          this.reportBackgroundFailure(entityId, stage.job, err);
         }).finally(() => {
           this.jobManager.releaseLock("librarian", entityId);
         });
@@ -6732,8 +7618,7 @@ var WriteService = class {
       }
     } else if (!this.jobManager.isBlocked("librarian", entityId)) {
       const healJob = this.maybeRunHeal(entityId, eventCount).catch((err) => {
-        console.error(err);
-        this.reportBackgroundFailure(entityId, "heal");
+        this.reportBackgroundFailure(entityId, "heal", err);
       });
       this.track(healJob);
     }
@@ -6771,17 +7656,23 @@ var WriteService = class {
       }
     }
   }
-  reportBackgroundFailure(entityId, job) {
+  reportBackgroundFailure(entityId, job, err) {
+    const searchUnavailable = isWikiSearchUnavailableError(err);
+    if (!searchUnavailable) console.error(err);
+    else if (!this.warnedSearchUnavailable) {
+      this.warnedSearchUnavailable = true;
+      console.warn("[WikiMemory] Auto librarian/heal pass skipped: keyword search is unavailable. Work is held, not lost, until it recovers (a no-arg syncSearchIndex() retries the init); later skips report only via onDiagnostic.");
+    }
     emitDiagnostic(this.options, {
       code: "background_job_failed",
       operation: job,
       trigger: "auto",
       entityId,
-      detail: { reason: "unhandled_rejection" }
+      detail: { reason: searchUnavailable ? "keyword_search_unavailable" : "unhandled_rejection" }
     });
   }
 };
 
-export { BaseRepository, DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, DEFAULT_MAX_EMBED_CHARS, DiagnosticBuffer, EMBED_CHARS_CEILING, EmbeddingService, HEAL_ANCHORS_PER_CANDIDATE, HEAL_BATCH_SIZE, HEAL_MAX_FACT_BODY_CHARS_L3, HEAL_MAX_TASKS, HEAL_RECHECK_MS, HOOK_TIMEOUT_MARKER, ImportExportService, IngestionService, JobManager, MAX_EMBED_ATTEMPTS, MaintenanceService, MetadataRepository, ONTOLOGY_BACKFILL_BATCH_SIZE, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, ONTOLOGY_BACKFILL_RECHECK_MS, ONTOLOGY_BACKFILL_SYSTEM_PROMPT, PromptService, PrunePartialFailureError, RetrievalService, SearchService, TemporalService, UsageMeter, WikiBusyError, WikiDraftNotFound, WikiDuplicateHashError, WikiGraphNodeOwnershipConflict, WikiIngestEmptyError, WikiInvalidReadOptions, WikiParseError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiSupersedeError, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, edgeTripleAllowed, emptyManifest, entitySummaryMetaKey, extractSqliteCode, factTokenCost, generateId, isLiveAt, liveAtSql, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, packFactsByBudget, parseEmbedding, resolveEdgeDefinitions, resolveGrounding, resolveNodeType, safeSlice, typeSatisfies, validateInlineEdges, validateManifest };
-//# sourceMappingURL=chunk-522SCN2E.mjs.map
-//# sourceMappingURL=chunk-522SCN2E.mjs.map
+export { BaseRepository, CURRENT_SCHEMA_VERSION, DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, DEFAULT_MAX_EMBED_CHARS, DiagnosticBuffer, EMBED_CHARS_CEILING, EmbeddingService, FTS5_DRAIN_CHUNK, FTS5_REBUILD_SNAPSHOT_KEY, FTS5_REBUILD_WM_KEY, FTS5_RECLAIM_MERGE_PAGES, FTS5_RETIRED_COUNTER_KEY, FTS5_RETIRED_TABLES_KEY, FTS5_STATE_KEY, FTS5_SWEEP_CURSOR_KEY, HEAL_ANCHORS_PER_CANDIDATE, HEAL_BATCH_SIZE, HEAL_MAX_FACT_BODY_CHARS_L3, HEAL_MAX_TASKS, HEAL_RECHECK_MS, HOOK_TIMEOUT_MARKER, ImportExportService, IngestionService, JobManager, MAX_EMBED_ATTEMPTS, MIGRATIONS, MaintenanceService, MetadataRepository, ONTOLOGY_BACKFILL_BATCH_SIZE, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, ONTOLOGY_BACKFILL_RECHECK_MS, ONTOLOGY_BACKFILL_SYSTEM_PROMPT, PromptService, PrunePartialFailureError, RetrievalService, SearchService, TemporalService, UnavailableIndexStrategy, UsageMeter, WikiBusyError, WikiDraftNotFound, WikiDuplicateHashError, WikiGraphNodeOwnershipConflict, WikiIngestEmptyError, WikiInvalidReadOptions, WikiMigrationRequiredError, WikiParseError, WikiSearchUnavailableError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiSupersedeError, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, createLegacySourceTypeIndex, detectSchemaVersion, drainChunkSql, drainHiSql, edgeTripleAllowed, emptyManifest, entityDrainChunkSql, entityDrainHiSql, entitySummaryMetaKey, extractSqliteCode, factTokenCost, fts5LedgerDropSql, fts5PendingIndexesDdl, fts5TablesDdl, fts5TriggerNames, fts5TriggersDdl, generateId, idDrainChunkSql, idReindexChunkSql, isLiveAt, isRetiredTableName, isWikiSearchUnavailableError, liveAtSql, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, packFactsByBudget, parseEmbedding, parseJsonArray, parseJsonObject, probePendingWork, readRebuildProgress, reanchorRebuildFingerprint, resolveEdgeDefinitions, resolveGrounding, resolveNodeType, retiredTableName, runSourceRefNormalize, safeSlice, setupDatabase, sweepChunkSql, sweepHiSql, typeSatisfies, validateInlineEdges, validateManifest, windowChunkSql, windowHiSql, writeNormalizeStamp, writeRebuildStart };
+//# sourceMappingURL=chunk-PCRYIUV5.mjs.map
+//# sourceMappingURL=chunk-PCRYIUV5.mjs.map