@equationalapplications/core-llm-wiki 7.8.0 → 7.9.1

package/dist/index.d.mts

@@ -1,7 +1,6 @@
-import { M as MemoryBundle, F as FormatContextOptions, G as GraphNeighborhood, a as MemoryDump, b as FormattedMemoryDump, R as ReadOptions, S as SQLiteAdapter, W as WikiOptions, c as WikiMemory } from './testing-CWZaXKLj.mjs';
-export { C as ChunkFailure, d as ClassifierAnswer, e as ClassifierQuestion, f as ClassifyRequest, g as ClassifyResponse, D as DegradedRecord, h as DraftPage, E as EmbedFactResult, i as EmbedFailureKind, j as EmbeddingMarkerKind, k as EntityMaintenanceReport, l as EntityStatus, m as ExtractedFact, n as ExtractedFactEdge, o as ExtractedFactWithOntology, p as ExtractedTask, q as GraphTraversalOptions, r as GroundingConfig, H as HEAL_BATCH_SIZE, s as HEAL_RECHECK_MS, t as HOOK_TIMEOUT_MARKER, u as HealResult, I as IngestDocumentResult, L as LLMProvider, v as LibrarianConfig, w as LibrarianGateConfig, x as MaintenanceJob, y as MaintenanceStopReason, O as ONTOLOGY_BACKFILL_BATCH_SIZE, z as ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, A as ONTOLOGY_BACKFILL_RECHECK_MS, B as OntologyBackfillResult, J as OntologyConfig, K as OntologyEdgeType, N as OntologyManifest, P as OntologyMode, Q as OntologyNodeType, T as OntologyPromptContext, U as OntologyUpdates, V as PendingMaintenance, X as PendingSourceStatus, Y as PromptOverrides, Z as PromptService, _ as PrunePartialFailureError, $ as ReembedResult, a0 as RunPendingMaintenanceOptions, a1 as RunPendingMaintenanceResult, a2 as SupersedeReplacement, a3 as VectorRanker, a4 as VectorRankerFallback, a5 as VectorRankerRankArgs, a6 as VectorRankerSemanticResult, a7 as WikiBusyError, a8 as WikiBusyOperation, a9 as WikiCheckpoint, aa as WikiConfig, ab as WikiDiagnostic, ac as WikiDiagnosticCode, ad as WikiDiagnosticDetail, ae as WikiDiagnosticOperation, af as WikiDiagnosticSeverity, ag as WikiDiagnosticTrigger, ah as WikiDraftNotFound, ai as WikiDuplicateHashError, aj as WikiEdge, ak as WikiEvent, al as WikiFact, am as WikiGraphNodeOwnershipConflict, an as WikiIngestEmptyError, ao as WikiInstructions, ap as WikiInvalidReadOptions, aq as WikiLintReport, ar as WikiMemoryTestAccess, as as WikiOutboxEvent, at as WikiParseError, au as WikiSourceRefHashCollision, av as WikiStrictOntologyViolation, aw as WikiSupersedeError, ax as WikiSupersedeReason, ay as WikiTask, az as WikiTransactionError, aA as validateManifest } from './testing-CWZaXKLj.mjs';
+import { M as MemoryBundle, F as FormatContextOptions, G as GraphNeighborhood, a as MemoryDump, b as FormattedMemoryDump, R as ReadOptions, S as SQLiteAdapter, W as WikiOptions, c as WikiMemory } from './testing-Bf6etdUy.mjs';
+export { C as ChunkFailure, d as ClassifierAnswer, e as ClassifierQuestion, f as ClassifyRequest, g as ClassifyResponse, D as DegradedRecord, h as DraftPage, E as EmbedFactResult, i as EmbedFailureKind, j as EmbeddingMarkerKind, k as EntityMaintenanceReport, l as EntityStatus, m as ExtractedFact, n as ExtractedFactEdge, o as ExtractedFactWithOntology, p as ExtractedTask, q as GraphTraversalOptions, r as GroundingConfig, H as HEAL_BATCH_SIZE, s as HEAL_RECHECK_MS, t as HOOK_TIMEOUT_MARKER, u as HealResult, I as IngestDocumentResult, L as LLMProvider, v as LibrarianConfig, w as LibrarianGateConfig, x as MaintenanceJob, y as MaintenanceStopReason, O as ONTOLOGY_BACKFILL_BATCH_SIZE, z as ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, A as ONTOLOGY_BACKFILL_RECHECK_MS, B as OntologyBackfillResult, J as OntologyConfig, K as OntologyEdgeType, N as OntologyManifest, P as OntologyMode, Q as OntologyNodeType, T as OntologyPromptContext, U as OntologyUpdates, V as PendingMaintenance, X as PendingSourceStatus, Y as PromptOverrides, Z as PromptService, _ as PrunePartialFailureError, $ as ReembedResult, a0 as RunPendingMaintenanceOptions, a1 as RunPendingMaintenanceResult, a2 as SupersedeReplacement, a3 as VectorRanker, a4 as VectorRankerFallback, a5 as VectorRankerRankArgs, a6 as VectorRankerSemanticResult, a7 as WikiBusyError, a8 as WikiBusyOperation, a9 as WikiCheckpoint, aa as WikiConfig, ab as WikiDiagnostic, ac as WikiDiagnosticCode, ad as WikiDiagnosticDetail, ae as WikiDiagnosticOperation, af as WikiDiagnosticSeverity, ag as WikiDiagnosticTrigger, ah as WikiDraftNotFound, ai as WikiDuplicateHashError, aj as WikiEdge, ak as WikiEvent, al as WikiFact, am as WikiGraphNodeOwnershipConflict, an as WikiIngestEmptyError, ao as WikiInstructions, ap as WikiInvalidReadOptions, aq as WikiLintReport, ar as WikiMemoryTestAccess, as as WikiOutboxEvent, at as WikiParseError, au as WikiSourceRefHashCollision, av as WikiStrictOntologyViolation, aw as WikiSupersedeError, ax as WikiSupersedeReason, ay as WikiTask, az as WikiTransactionError, aA as validateManifest } from './testing-Bf6etdUy.mjs';
 import { OkfFile } from '@equationalapplications/core-okf';
-import 'minisearch';
 
 /**
  * Slices a string like `String.prototype.slice`, but clamps out-of-range

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import { M as MemoryBundle, F as FormatContextOptions, G as GraphNeighborhood, a as MemoryDump, b as FormattedMemoryDump, R as ReadOptions, S as SQLiteAdapter, W as WikiOptions, c as WikiMemory } from './testing-CWZaXKLj.js';
-export { C as ChunkFailure, d as ClassifierAnswer, e as ClassifierQuestion, f as ClassifyRequest, g as ClassifyResponse, D as DegradedRecord, h as DraftPage, E as EmbedFactResult, i as EmbedFailureKind, j as EmbeddingMarkerKind, k as EntityMaintenanceReport, l as EntityStatus, m as ExtractedFact, n as ExtractedFactEdge, o as ExtractedFactWithOntology, p as ExtractedTask, q as GraphTraversalOptions, r as GroundingConfig, H as HEAL_BATCH_SIZE, s as HEAL_RECHECK_MS, t as HOOK_TIMEOUT_MARKER, u as HealResult, I as IngestDocumentResult, L as LLMProvider, v as LibrarianConfig, w as LibrarianGateConfig, x as MaintenanceJob, y as MaintenanceStopReason, O as ONTOLOGY_BACKFILL_BATCH_SIZE, z as ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, A as ONTOLOGY_BACKFILL_RECHECK_MS, B as OntologyBackfillResult, J as OntologyConfig, K as OntologyEdgeType, N as OntologyManifest, P as OntologyMode, Q as OntologyNodeType, T as OntologyPromptContext, U as OntologyUpdates, V as PendingMaintenance, X as PendingSourceStatus, Y as PromptOverrides, Z as PromptService, _ as PrunePartialFailureError, $ as ReembedResult, a0 as RunPendingMaintenanceOptions, a1 as RunPendingMaintenanceResult, a2 as SupersedeReplacement, a3 as VectorRanker, a4 as VectorRankerFallback, a5 as VectorRankerRankArgs, a6 as VectorRankerSemanticResult, a7 as WikiBusyError, a8 as WikiBusyOperation, a9 as WikiCheckpoint, aa as WikiConfig, ab as WikiDiagnostic, ac as WikiDiagnosticCode, ad as WikiDiagnosticDetail, ae as WikiDiagnosticOperation, af as WikiDiagnosticSeverity, ag as WikiDiagnosticTrigger, ah as WikiDraftNotFound, ai as WikiDuplicateHashError, aj as WikiEdge, ak as WikiEvent, al as WikiFact, am as WikiGraphNodeOwnershipConflict, an as WikiIngestEmptyError, ao as WikiInstructions, ap as WikiInvalidReadOptions, aq as WikiLintReport, ar as WikiMemoryTestAccess, as as WikiOutboxEvent, at as WikiParseError, au as WikiSourceRefHashCollision, av as WikiStrictOntologyViolation, aw as WikiSupersedeError, ax as WikiSupersedeReason, ay as WikiTask, az as WikiTransactionError, aA as validateManifest } from './testing-CWZaXKLj.js';
+import { M as MemoryBundle, F as FormatContextOptions, G as GraphNeighborhood, a as MemoryDump, b as FormattedMemoryDump, R as ReadOptions, S as SQLiteAdapter, W as WikiOptions, c as WikiMemory } from './testing-Bf6etdUy.js';
+export { C as ChunkFailure, d as ClassifierAnswer, e as ClassifierQuestion, f as ClassifyRequest, g as ClassifyResponse, D as DegradedRecord, h as DraftPage, E as EmbedFactResult, i as EmbedFailureKind, j as EmbeddingMarkerKind, k as EntityMaintenanceReport, l as EntityStatus, m as ExtractedFact, n as ExtractedFactEdge, o as ExtractedFactWithOntology, p as ExtractedTask, q as GraphTraversalOptions, r as GroundingConfig, H as HEAL_BATCH_SIZE, s as HEAL_RECHECK_MS, t as HOOK_TIMEOUT_MARKER, u as HealResult, I as IngestDocumentResult, L as LLMProvider, v as LibrarianConfig, w as LibrarianGateConfig, x as MaintenanceJob, y as MaintenanceStopReason, O as ONTOLOGY_BACKFILL_BATCH_SIZE, z as ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, A as ONTOLOGY_BACKFILL_RECHECK_MS, B as OntologyBackfillResult, J as OntologyConfig, K as OntologyEdgeType, N as OntologyManifest, P as OntologyMode, Q as OntologyNodeType, T as OntologyPromptContext, U as OntologyUpdates, V as PendingMaintenance, X as PendingSourceStatus, Y as PromptOverrides, Z as PromptService, _ as PrunePartialFailureError, $ as ReembedResult, a0 as RunPendingMaintenanceOptions, a1 as RunPendingMaintenanceResult, a2 as SupersedeReplacement, a3 as VectorRanker, a4 as VectorRankerFallback, a5 as VectorRankerRankArgs, a6 as VectorRankerSemanticResult, a7 as WikiBusyError, a8 as WikiBusyOperation, a9 as WikiCheckpoint, aa as WikiConfig, ab as WikiDiagnostic, ac as WikiDiagnosticCode, ad as WikiDiagnosticDetail, ae as WikiDiagnosticOperation, af as WikiDiagnosticSeverity, ag as WikiDiagnosticTrigger, ah as WikiDraftNotFound, ai as WikiDuplicateHashError, aj as WikiEdge, ak as WikiEvent, al as WikiFact, am as WikiGraphNodeOwnershipConflict, an as WikiIngestEmptyError, ao as WikiInstructions, ap as WikiInvalidReadOptions, aq as WikiLintReport, ar as WikiMemoryTestAccess, as as WikiOutboxEvent, at as WikiParseError, au as WikiSourceRefHashCollision, av as WikiStrictOntologyViolation, aw as WikiSupersedeError, ax as WikiSupersedeReason, ay as WikiTask, az as WikiTransactionError, aA as validateManifest } from './testing-Bf6etdUy.js';
 import { OkfFile } from '@equationalapplications/core-okf';
-import 'minisearch';
 
 /**
  * Slices a string like `String.prototype.slice`, but clamps out-of-range

package/dist/index.js

@@ -3469,11 +3469,28 @@ function parseEmbedding(blob, text) {
   return null;
 }
 
+// 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;
+      }
+    })()
+  };
+}
+
 // src/services/SearchService.ts
 var _SearchService = class _SearchService {
-  constructor(entryRepo) {
+  constructor(entryRepo, indexStrategy) {
     this.entryRepo = entryRepo;
-    this.miniSearchEntryIdsByEntity = /* @__PURE__ */ new Map();
     this.vectorCache = /* @__PURE__ */ new Map();
     /**
      * Serializes rebuilds. `rebuildIndex` awaits a repository read between
@@ -3499,35 +3516,13 @@ var _SearchService = class _SearchService {
      * its flag must outlive the turn (#233 review).
      */
     this.staleEpochs = /* @__PURE__ */ new Map();
-    this.miniSearch = this.createMiniSearch();
-  }
-  /**
-   * A fresh index with the production options. clearAll() swaps one in because
-   * MiniSearch.removeAll() empties the index but leaves dirtCount (and its
-   * vacuum bookkeeping) at its old value, which would trip syncEntries'
-   * conditional vacuum early after a clear.
-   */
-  createMiniSearch() {
-    return new MiniSearch__default.default({
-      fields: ["title", "body", "tags"],
-      storeFields: ["entity_id"],
-      // Vacuuming is driven explicitly at the end of each serialized rebuild
-      // (see sync). Auto-vacuum fires on its own schedule, asynchronously with
-      // respect to the caller, and traversing the tree mid-rebuild is what
-      // threw the uncaught TypeError in MiniSearch.performVacuuming (#64).
-      autoVacuum: false,
-      searchOptions: {
-        boost: { title: 2 },
-        fuzzy: 0.2,
-        prefix: true
-      }
-    });
+    this.indexStrategy = indexStrategy;
   }
   /**
    * 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 MiniSearch index
+   * 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.
    */
@@ -3536,19 +3531,21 @@ var _SearchService = class _SearchService {
       try {
         try {
           const epochsBefore = new Map(this.staleEpochs);
-          await this.rebuildIndex(entityId);
-          if (entityId) {
-            if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
-              this.staleEntities.delete(entityId);
-            }
-          } else {
+          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.miniSearch.vacuum();
+          await this.indexStrategy.vacuum?.();
         } finally {
           this.evictCache(entityId);
         }
@@ -3573,27 +3570,20 @@ var _SearchService = class _SearchService {
    */
   async syncEntries(entityId, ids) {
     const uniqueIds = [...new Set(ids)];
-    if (uniqueIds.length === 0 && !this.staleEntities.has(entityId) && this.miniSearchEntryIdsByEntity.has(entityId)) {
+    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.miniSearchEntryIdsByEntity.has(entityId);
+          const needsRebuild = () => this.staleEntities.has(entityId) || this.indexStrategy.hasIndexedEntity?.(entityId) !== true;
           if (!needsRebuild()) {
             const rows = await this.entryRepo.findMiniSearchRowsByIds(entityId, uniqueIds);
-            const tracked = this.miniSearchEntryIdsByEntity.get(entityId);
-            if (tracked && !this.staleEntities.has(entityId)) {
-              for (const id of uniqueIds) {
-                if (tracked.delete(id) && this.miniSearch.has(id)) this.miniSearch.discard(id);
-              }
-              const documents = rows.map((row) => this.normalizeMiniSearchRow(row));
-              if (documents.length > 0) this.miniSearch.addAll(documents);
-              for (const document of documents) tracked.add(document.id);
-              if (this.miniSearch.dirtCount > 0) {
-                await this.miniSearch.vacuum();
-              }
+            if (!this.staleEntities.has(entityId)) {
+              await this.indexStrategy.replace(entityId, uniqueIds, rows.map(toIndexDoc));
+              await this.indexStrategy.vacuum?.();
               return;
             }
           }
@@ -3601,7 +3591,7 @@ var _SearchService = class _SearchService {
           if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
             this.staleEntities.delete(entityId);
           }
-          await this.miniSearch.vacuum();
+          await this.indexStrategy.vacuum?.();
         } finally {
           this.evictCache(entityId);
         }
@@ -3621,6 +3611,16 @@ var _SearchService = class _SearchService {
     this.staleEntities.add(entityId);
     this.staleEpochs.set(entityId, (this.staleEpochs.get(entityId) ?? 0) + 1);
   }
+  /**
+   * 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() {
+    const ids = [...this.staleEntities];
+    await Promise.all(ids.map((id) => this.syncEntries(id, [])));
+  }
   /**
    * Clears the parsed vector cache. Useful for mid-loop flush guarantees
    * or memory pressure evictions.
@@ -3635,39 +3635,28 @@ var _SearchService = class _SearchService {
   /**
    * Fully resets the search service.
    */
-  clearAll() {
+  async clearAll() {
     this.vectorCache.clear();
-    this.miniSearch = this.createMiniSearch();
-    this.miniSearchEntryIdsByEntity.clear();
+    await this.indexStrategy.replaceAll([]);
     this.staleEntities.clear();
     this.staleEpochs.clear();
   }
   /**
-   * Executes a keyword search against the active MiniSearch index.
+   * Executes a keyword search against the active index strategy.
    */
-  searchKeyword(query, entityIds, limit) {
-    const entityIdSet = new Set(entityIds);
-    const results = this.miniSearch.search(query, {
-      filter: (r) => entityIdSet.has(r.entity_id),
-      combineWith: "OR"
-    });
+  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);
   }
   /**
-   * Pre-fetches MiniSearch scores for candidate hydration, used during hybrid weighting.
+   * Pre-fetches keyword scores for candidate hydration, used during hybrid weighting.
    */
-  getMiniSearchScores(query, entityIds, preFilterLimit) {
-    const entityIdSet = new Set(entityIds);
-    let results = this.miniSearch.search(query, {
-      filter: (r) => entityIdSet.has(r.entity_id),
-      combineWith: "OR"
-    }).sort((a, b) => this._compareSearchResults(a, b));
-    if (preFilterLimit !== void 0) {
-      results = results.slice(0, preFilterLimit);
-    }
+  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 maxMsScore = Math.max(1, results[0]?.score ?? 1);
-    return new Map(results.map((r) => [r.id, r.score / maxMsScore]));
+    const maxScore = Math.max(1, results[0]?.score ?? 1);
+    return new Map(results.map((r) => [r.id, r.score / maxScore]));
   }
   /**
    * Score candidate rows using in-process JS cosine similarity.
@@ -3729,53 +3718,16 @@ var _SearchService = class _SearchService {
     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) {
-    if (entityId) {
-      const rows2 = await this.entryRepo.findMiniSearchRows(entityId);
-      const previousIds = this.miniSearchEntryIdsByEntity.get(entityId);
-      if (previousIds) {
-        for (const id of previousIds) {
-          this.miniSearch.discard(id);
-        }
-      }
-      const documents2 = rows2.map((row) => this.normalizeMiniSearchRow(row));
-      if (documents2.length > 0) {
-        this.miniSearch.addAll(documents2);
-      }
-      this.miniSearchEntryIdsByEntity.set(
-        entityId,
-        new Set(documents2.map((document) => document.id))
-      );
-      return;
-    }
-    const rows = await this.entryRepo.findMiniSearchRows();
-    this.miniSearch.removeAll();
-    this.miniSearchEntryIdsByEntity.clear();
-    const documents = rows.map((row) => this.normalizeMiniSearchRow(row));
-    if (documents.length > 0) {
-      this.miniSearch.addAll(documents);
-    }
-    for (const document of documents) {
-      const ids = this.miniSearchEntryIdsByEntity.get(document.entity_id) ?? /* @__PURE__ */ new Set();
-      ids.add(document.id);
-      this.miniSearchEntryIdsByEntity.set(document.entity_id, ids);
-    }
-  }
-  normalizeMiniSearchRow(row) {
-    return {
-      id: row.id,
-      entity_id: row.entity_id,
-      title: row.title,
-      body: row.body,
-      tags: (() => {
-        try {
-          const parsed = JSON.parse(row.tags);
-          return Array.isArray(parsed) ? parsed.join(" ") : row.tags;
-        } catch {
-          return row.tags;
-        }
-      })()
-    };
+    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));
@@ -3790,11 +3742,11 @@ var _SearchService = class _SearchService {
     return a.id.localeCompare(b.id);
   }
   /**
-   * MiniSearch 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.
+   * 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;
@@ -3815,6 +3767,198 @@ _SearchService.MAX_VECTOR_CACHE_ENTITIES = 16;
  */
 _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));
+}
+var MiniSearchIndexStrategy = class {
+  constructor() {
+    /**
+     * Per-entity id set. `replaceEntity()` and `hasIndexedEntity()` read it;
+     * `addDocuments()` and `discardIds()` keep it in sync. `SearchService` does
+     * not see this map; it only sees `hasIndexedEntity`. The previous
+     * `miniSearchEntryIdsByEntity` lived on `SearchService`.
+     */
+    this.entryIdsByEntity = /* @__PURE__ */ new Map();
+    /**
+     * Reverse of `entryIdsByEntity`. `replace(entityId, ids, …)` uses it to
+     * decide which ids are owned by `entityId` (the only safe membership test
+     * — a rebuild that failed between its discard pass and the set replacement
+     * can leave the forward set claiming ids the MiniSearch instance does not
+     * hold). The pre-extraction `syncEntries` deleted from one set per id, not
+     * from every entity's set.
+     */
+    this.entityIdById = /* @__PURE__ */ new Map();
+    this.index = this.createIndex();
+  }
+  /**
+   * Build a fresh MiniSearch instance with the project's index options.
+   * Called from the constructor and from `replaceAll`. We do not use
+   * `removeAll()` on an existing instance because that empties the index but
+   * leaves `dirtCount` and the vacuum bookkeeping intact, which would trip
+   * `syncEntries`' conditional vacuum early after a clear.
+   */
+  createIndex() {
+    return new MiniSearch__default.default({
+      fields: ["title", "body", "tags"],
+      storeFields: ["entity_id"],
+      // Vacuuming is driven explicitly at the end of each serialized rebuild
+      // (see SearchService.syncEntries). Auto-vacuum fires on its own
+      // schedule, asynchronously with respect to the caller, and traversing
+      // the tree mid-rebuild is what threw the uncaught TypeError in
+      // MiniSearch.performVacuuming (#64).
+      autoVacuum: false,
+      searchOptions: {
+        boost: { title: 2 },
+        fuzzy: 0.2,
+        prefix: true
+      }
+    });
+  }
+  /**
+   * Incremental sync. Removes only ids currently tracked under `entityId`
+   * (other entities' docs are untouched), then upserts `documents` by id.
+   * The same id appearing in both `ids` and `documents` is discarded first
+   * so the upsert does not throw on a duplicate id.
+   *
+   * Every document must carry `entityId` as its `entity_id`; a mismatch is
+   * rejected before the write mutates anything. A tracking-only call
+   * (`replace(entityId, [], [])`) registers the entity as indexed, matching
+   * the interface contract.
+   *
+   * Atomicity: never awaits between the discard pass and `addDocuments`, so
+   * a concurrent `search()` sees the index wholly before or wholly after,
+   * never half-updated. This is the precondition the pre-extraction
+   * `syncEntries` kept with its "no await from here to `addAll`" comment.
+   */
+  async replace(entityId, ids, documents) {
+    assertOwnedBy(entityId, documents);
+    this.discardIds(ids, entityId);
+    if (!this.entryIdsByEntity.has(entityId)) this.entryIdsByEntity.set(entityId, /* @__PURE__ */ new Set());
+    this.addDocuments(documents);
+  }
+  /**
+   * Per-entity rebuild. Removes every id tracked under `entityId` (with the
+   * `index.has(id)` guard so a stale tracking set cannot make `discard()`
+   * throw), then writes `documents`. The entity stays registered as
+   * indexed — even when `documents` is empty — so the next `syncEntries`
+   * call can take the fast path. Every document must belong to `entityId`.
+   */
+  async replaceEntity(entityId, documents) {
+    assertOwnedBy(entityId, documents);
+    const previous = this.entryIdsByEntity.get(entityId);
+    if (previous) this.discardIds([...previous]);
+    this.entryIdsByEntity.set(entityId, /* @__PURE__ */ new Set());
+    this.addDocuments(documents);
+  }
+  /**
+   * Global rebuild / clear. Replaces the MiniSearch instance and clears both
+   * id maps, so `hasIndexedEntity` returns `false` for every entity afterwards.
+   * `SearchService.clearAll()` calls `replaceAll([])`.
+   */
+  async replaceAll(documents) {
+    this.index = this.createIndex();
+    this.entryIdsByEntity.clear();
+    this.entityIdById.clear();
+    this.addDocuments(documents);
+  }
+  /**
+   * Best-match-first search over the documents whose `entity_id` is in
+   * `options.entityIds`. `preFilterLimit` overrides `limit` (hybrid retrieval
+   * uses this to over-fetch candidates before the `limit` cap). Scores are
+   * raw BM25+ — `SearchService.getKeywordScores` and `searchKeyword` apply
+   * any scaling, not the strategy.
+   */
+  async search(query, options) {
+    if (options.entityIds.length === 0) return [];
+    const entityIdSet = new Set(options.entityIds);
+    const limit = options.preFilterLimit ?? options.limit;
+    const raw = this.index.search(query, {
+      filter: (r) => entityIdSet.has(r.entity_id),
+      combineWith: "OR"
+    });
+    raw.sort((a, b) => {
+      const scoreDiff = b.score - a.score;
+      if (!Number.isNaN(scoreDiff) && scoreDiff !== 0) return scoreDiff;
+      return a.id.localeCompare(b.id);
+    });
+    return raw.slice(0, limit).map((r) => ({
+      id: r.id,
+      entity_id: r.entity_id,
+      score: r.score
+    }));
+  }
+  /**
+   * Explicit vacuum. MiniSearch 7.2.0's `dirtCount` rule: search after an
+   * un-vacuumed discard inverts the relative scores of term-sharing
+   * documents at any index size. `SearchService.syncEntries` calls this
+   * after a discard-bearing turn. No-op when `dirtCount === 0`.
+   */
+  async vacuum() {
+    if (this.index.dirtCount > 0) {
+      await this.index.vacuum();
+    }
+  }
+  /**
+   * `true` when `entityId` has been indexed at least once under the current
+   * strategy state. Backed by `entryIdsByEntity.has(entityId)`, which is
+   * kept in sync by `addDocuments`, `replaceEntity`, and `replaceAll`.
+   */
+  hasIndexedEntity(entityId) {
+    return this.entryIdsByEntity.has(entityId);
+  }
+  /**
+   * Add `documents` to the MiniSearch instance and register them in
+   * `entryIdsByEntity` and `entityIdById`. MiniSearch mutates documents
+   * during `add`, so each doc is copied first. `add` throws on an id the
+   * index already holds — `replace` and `replaceEntity` discard first for
+   * that reason.
+   *
+   * Adds and registers one document at a time: if a duplicate id throws
+   * part-way through, every document already in the index is tracked, so
+   * the next rebuild can discard it instead of failing on it again. This is
+   * the precondition the per-turn recovery path relies on (#258 review).
+   */
+  addDocuments(documents) {
+    for (const d of documents) {
+      const doc = { ...d };
+      this.index.add(doc);
+      const set = this.entryIdsByEntity.get(doc.entity_id) ?? /* @__PURE__ */ new Set();
+      set.add(doc.id);
+      this.entryIdsByEntity.set(doc.entity_id, set);
+      this.entityIdById.set(doc.id, doc.entity_id);
+    }
+  }
+  /**
+   * Discard `ids` from the MiniSearch instance and from both id maps, but
+   * only for ids currently owned by `entityId` (the second argument). When
+   * `entityId` is omitted (used by `replaceEntity` for the bulk rebuild
+   * path), every id is discarded regardless of owning entity.
+   *
+   * `index.has(id)` is the membership test of record: a rebuild that failed
+   * between its own discard pass and the set replacement can leave the
+   * tracking set claiming ids the index no longer holds — `discard()` throws
+   * on those, so we guard.
+   */
+  discardIds(ids, entityId) {
+    for (const id of ids) {
+      const owning = this.entityIdById.get(id);
+      if (owning === void 0) continue;
+      if (entityId !== void 0 && owning !== entityId) continue;
+      if (this.index.has(id)) this.index.discard(id);
+      this.entryIdsByEntity.get(owning)?.delete(id);
+      this.entityIdById.delete(id);
+    }
+  }
+};
+function assertOwnedBy(entityId, documents) {
+  for (const doc of documents) {
+    if (doc.entity_id !== entityId) {
+      throw new Error(
+        `IndexStrategy write for entity ${entityId} got document ${doc.id} under entity ${doc.entity_id}`
+      );
+    }
+  }
+}
 
 // src/services/JobManager.ts
 var JobManager = class {
@@ -6478,7 +6622,7 @@ async function gateCandidates(deps, ctx, candidates, cfg) {
       }
     }
     if (!ranked) {
-      ranked = 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 = (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]));
@@ -7921,7 +8065,7 @@ var MaintenanceService = class {
     if (!query) return [];
     const cached = cache?.get(query);
     if (cached) return cached;
-    const hits = this.searchService.searchKeyword(
+    const hits = await this.searchService.searchKeyword(
       query,
       [entityId],
       cap * HEAL_ANCHOR_SEARCH_OVERFETCH
@@ -9093,7 +9237,7 @@ var RetrievalService = class {
           let miniSearchScores;
           if (effectivePreFilterLimit !== void 0) {
             populateCache = false;
-            const preResults = this.searchService.searchKeyword(trimmedQuery, scoredEntityIds, Number.MAX_SAFE_INTEGER).filter((r) => !excludedIds.has(r.id));
+            const preResults = (await this.searchService.searchKeyword(trimmedQuery, scoredEntityIds, Number.MAX_SAFE_INTEGER)).filter((r) => !excludedIds.has(r.id));
             if (preResults.length === 0) {
               candidateRows = null;
             } else {
@@ -9120,7 +9264,7 @@ var RetrievalService = class {
               candidateRows = this._withoutIds(await this.entryRepo.findWithEmbeddingsByEntityIds(scoredEntityIds), excludedIds);
             }
             if (weight !== void 0 && weight < 1) {
-              miniSearchScores = this.searchService.getMiniSearchScores(trimmedQuery, scoredEntityIds);
+              miniSearchScores = await this.searchService.getKeywordScores(trimmedQuery, scoredEntityIds);
             }
           }
           if (candidateRows === null) {
@@ -9363,7 +9507,7 @@ var RetrievalService = class {
                   const hasActiveFloorsKeywordFallback = sanitizedTierFloors !== void 0 && Object.values(sanitizedTierFloors).some((f) => f > 0);
                   const keywordOversampledLimit = hasActiveFloorsKeywordFallback ? Number.MAX_SAFE_INTEGER : padLimit(Math.max(maxResults * 2, maxResults + 50));
                   const preFilteredIds = effectivePreFilterLimit !== void 0 ? new Set(candidateRows.map((r) => r.id)) : void 0;
-                  const keywordResults = this.searchService.searchKeyword(trimmedQuery, scoredEntityIds, keywordOversampledLimit);
+                  const keywordResults = await this.searchService.searchKeyword(trimmedQuery, scoredEntityIds, keywordOversampledLimit);
                   const topResults = preFilteredIds === void 0 ? keywordResults : keywordResults.filter((r) => preFilteredIds.has(r.id));
                   const topResultIds = new Set(topResults.map((r) => r.id));
                   const candidateMap = new Map(candidateRows.filter((r) => topResultIds.has(r.id)).map((row) => [row.id, row]));
@@ -9466,7 +9610,7 @@ var RetrievalService = class {
       if (!usedEmbed && scoredEntityIds.length > 0) {
         const hasActiveFloors = sanitizedTierFloors !== void 0 && Object.values(sanitizedTierFloors).some((f) => f > 0);
         const fallbackOversampledLimit = hasActiveFloors ? Number.MAX_SAFE_INTEGER : padLimit(Math.max(maxResults * 2, maxResults + 50));
-        const results = this.searchService.searchKeyword(trimmedQuery, scoredEntityIds, fallbackOversampledLimit).filter((r) => !excludedIds.has(r.id));
+        const results = (await this.searchService.searchKeyword(trimmedQuery, scoredEntityIds, fallbackOversampledLimit)).filter((r) => !excludedIds.has(r.id));
         const candidates = results.map((r) => ({
           id: r.id,
           entity_id: r.entity_id,
@@ -10298,7 +10442,10 @@ var WikiMemory = class {
     );
     this.lintService = new LintService(this.lintRepo, this.ontologyService);
     this.embeddingService = new EmbeddingService(this.db, this.options, this.entryRepo, this.metadataRepo);
-    this.searchService = new SearchService(this.entryRepo);
+    this.searchService = new SearchService(
+      this.entryRepo,
+      new MiniSearchIndexStrategy()
+    );
     this.temporalService = new TemporalService(this.db, this.options, this.entryRepo, this.searchService, this.embeddingService);
     this.jobManager = new JobManager(this.prefix);
     this.promptService = new PromptService(options.config?.prompts, resolveGrounding(options.config?.grounding));
@@ -10691,6 +10838,32 @@ var WikiMemory = class {
   clearVectorCache() {
     this.searchService.evictCache();
   }
+  /**
+   * Brings the keyword search index up to date with SQLite after a host
+   * transaction that used `upsertGraph` has committed. Core never sees that
+   * commit, so without this the nodes stay out of keyword, hybrid and
+   * fallback retrieval until the entity's next core write.
+   *
+   * With `entityId`, rebuilds that entity if it is stale or has never been
+   * indexed; otherwise it is a no-op that still waits for rebuilds already
+   * queued. Without an argument, rebuilds every entity currently marked
+   * stale; when none is, it resolves immediately and does not wait for rebuilds
+   * already queued.
+   *
+   * Call only after the host's transaction commits: called inside it, the
+   * rebuild may index rows that later roll back, or miss them and clear the
+   * stale flag anyway. Serialized with core's internal index syncs and takes
+   * no maintenance lock. Never rejects for a valid `entityId` — on failure the
+   * entity stays stale and the next call retries it. Does not compute
+   * embeddings; that remains the maintenance sweep's job.
+   *
+   * @throws {TypeError} when `entityId` is given but is not a non-empty string.
+   */
+  async syncSearchIndex(entityId) {
+    if (entityId === void 0) return this.searchService.syncStale();
+    assertEntityId(entityId);
+    return this.searchService.syncEntries(entityId, []);
+  }
   async exportDump(entityIds) {
     return this.importExportService.exportDump(entityIds);
   }
@@ -10737,9 +10910,11 @@ var WikiMemory = class {
    * MUST be called from inside an open `db.withTransactionAsync` callback —
    * the third argument is the caller's `tx`. The method does not open a
    * nested transaction, does not acquire any lock, and does not perform
-   * post-commit work (search sync, embedding, cache eviction). Hosts that
-   * want embeddings synced should drive the existing maintenance sweep
-   * (`runLibrarian` / `runHeal` / `runOntologyBackfill` / `runPrune`,
+   * post-commit work (search sync, embedding, cache eviction). After the
+   * transaction commits, call `syncSearchIndex(entityId)` — or
+   * `syncSearchIndex()` after writing several entities in one transaction —
+   * to make the new nodes keyword-searchable. Embeddings still come from the maintenance
+   * sweep (`runLibrarian` / `runHeal` / `runOntologyBackfill` / `runPrune`,
    * scoped via `listEntityIds`).
    *
    * Contract (full pre-flight validation lives inside