@equationalapplications/core-llm-wiki 7.7.5 → 7.7.6

package/dist/{testing-CH_Kk34-.d.mts → testing-BIFNLUva.d.mts}

@@ -1171,6 +1171,14 @@ type ReembedCandidateRow = WikiFact & {
 };
 declare class EntryRepository extends BaseRepository {
     private outbox;
+    /**
+     * Column list and liveness predicate shared by findMiniSearchRows and
+     * findMiniSearchRowsByIds, so the full rebuild and the incremental read
+     * can never drift apart (spec 2026-09-28 §4.4: both must produce
+     * identical documents).
+     */
+    private static readonly MINI_SEARCH_COLUMNS;
+    private static readonly MINI_SEARCH_LIVE_WHERE;
     private chunkSize;
     constructor(db: SQLiteAdapter, prefix: string, outbox: OutboxRepository);
     /**
@@ -1375,6 +1383,19 @@ declare class EntryRepository extends BaseRepository {
         body: string;
         tags: string;
     }>>;
+    /**
+     * Keyword-index rows for specific ids — the incremental counterpart of
+     * {@link findMiniSearchRows}, with identical columns. Soft-deleted rows and
+     * rows of other entities are omitted, so a caller can pass every id a write
+     * touched and get back exactly what should be indexed. Spec 2026-09-28 §4.4.
+     */
+    findMiniSearchRowsByIds(entityId: string, ids: readonly string[], tx?: SQLiteAdapter): Promise<Array<{
+        id: string;
+        entity_id: string;
+        title: string;
+        body: string;
+        tags: string;
+    }>>;
     updateEmbeddingBlob(id: string, blob: Uint8Array, tx?: SQLiteAdapter): Promise<void>;
     /**
      * Record a failed embedding attempt. Deliberately does NOT touch updated_at
@@ -1702,7 +1723,29 @@ declare class SearchService {
      * auto-vacuum debt behind the TypeError in #64.
      */
     private syncChain;
+    /**
+     * 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.
+     */
+    private staleEntities;
+    /**
+     * 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).
+     */
+    private staleEpochs;
     constructor(entryRepo: EntryRepository);
+    /**
+     * 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.
+     */
+    private createMiniSearch;
     /**
      * Rebuilds the search index and clears the vector cache for a given entity.
      * A direct replacement for manually syncing state after a DB transaction.
@@ -1712,6 +1755,24 @@ declare class SearchService {
      * correct failure mode and killing the host process is not.
      */
     sync(entityId?: string): Promise<void>;
+    /**
+     * 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.
+     */
+    syncEntries(entityId: string, ids: Iterable<string>): Promise<void>;
+    /**
+     * 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: string): void;
     /**
      * Clears the parsed vector cache. Useful for mid-loop flush guarantees
      * or memory pressure evictions.
@@ -1738,6 +1799,14 @@ declare class SearchService {
     private normalizeMiniSearchRow;
     private _tieBreakSort;
     private _compareScoredRows;
+    /**
+     * 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.
+     */
+    private _compareSearchResults;
 }
 
 type OperationType = 'prune' | 'librarian' | 'heal' | 'ingest' | 'reembed' | 'global_reembed' | 'import' | 'global_import' | 'forget' | 'ontologyBackfill';

package/dist/{testing-CH_Kk34-.d.ts → testing-BIFNLUva.d.ts}

@@ -1171,6 +1171,14 @@ type ReembedCandidateRow = WikiFact & {
 };
 declare class EntryRepository extends BaseRepository {
     private outbox;
+    /**
+     * Column list and liveness predicate shared by findMiniSearchRows and
+     * findMiniSearchRowsByIds, so the full rebuild and the incremental read
+     * can never drift apart (spec 2026-09-28 §4.4: both must produce
+     * identical documents).
+     */
+    private static readonly MINI_SEARCH_COLUMNS;
+    private static readonly MINI_SEARCH_LIVE_WHERE;
     private chunkSize;
     constructor(db: SQLiteAdapter, prefix: string, outbox: OutboxRepository);
     /**
@@ -1375,6 +1383,19 @@ declare class EntryRepository extends BaseRepository {
         body: string;
         tags: string;
     }>>;
+    /**
+     * Keyword-index rows for specific ids — the incremental counterpart of
+     * {@link findMiniSearchRows}, with identical columns. Soft-deleted rows and
+     * rows of other entities are omitted, so a caller can pass every id a write
+     * touched and get back exactly what should be indexed. Spec 2026-09-28 §4.4.
+     */
+    findMiniSearchRowsByIds(entityId: string, ids: readonly string[], tx?: SQLiteAdapter): Promise<Array<{
+        id: string;
+        entity_id: string;
+        title: string;
+        body: string;
+        tags: string;
+    }>>;
     updateEmbeddingBlob(id: string, blob: Uint8Array, tx?: SQLiteAdapter): Promise<void>;
     /**
      * Record a failed embedding attempt. Deliberately does NOT touch updated_at
@@ -1702,7 +1723,29 @@ declare class SearchService {
      * auto-vacuum debt behind the TypeError in #64.
      */
     private syncChain;
+    /**
+     * 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.
+     */
+    private staleEntities;
+    /**
+     * 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).
+     */
+    private staleEpochs;
     constructor(entryRepo: EntryRepository);
+    /**
+     * 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.
+     */
+    private createMiniSearch;
     /**
      * Rebuilds the search index and clears the vector cache for a given entity.
      * A direct replacement for manually syncing state after a DB transaction.
@@ -1712,6 +1755,24 @@ declare class SearchService {
      * correct failure mode and killing the host process is not.
      */
     sync(entityId?: string): Promise<void>;
+    /**
+     * 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.
+     */
+    syncEntries(entityId: string, ids: Iterable<string>): Promise<void>;
+    /**
+     * 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: string): void;
     /**
      * Clears the parsed vector cache. Useful for mid-loop flush guarantees
      * or memory pressure evictions.
@@ -1738,6 +1799,14 @@ declare class SearchService {
     private normalizeMiniSearchRow;
     private _tieBreakSort;
     private _compareScoredRows;
+    /**
+     * 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.
+     */
+    private _compareSearchResults;
 }
 
 type OperationType = 'prune' | 'librarian' | 'heal' | 'ingest' | 'reembed' | 'global_reembed' | 'import' | 'global_import' | 'forget' | 'ontologyBackfill';

package/dist/testing.d.mts

@@ -1,3 +1,3 @@
-export { aq as EmbeddingService, ar as ImportExportService, as as IngestionService, at as JobManager, at as JobManagerType, au as MaintenanceService, av as RetrievalService, aw as SearchService, aw as SearchServiceType, ai as WikiMemoryTestAccess, ax as WriteService } from './testing-CH_Kk34-.mjs';
+export { aq as EmbeddingService, ar as ImportExportService, as as IngestionService, at as JobManager, at as JobManagerType, au as MaintenanceService, av as RetrievalService, aw as SearchService, aw as SearchServiceType, ai as WikiMemoryTestAccess, ax as WriteService } from './testing-BIFNLUva.mjs';
 import '@equationalapplications/core-okf';
 import 'minisearch';

package/dist/testing.d.ts

@@ -1,3 +1,3 @@
-export { aq as EmbeddingService, ar as ImportExportService, as as IngestionService, at as JobManager, at as JobManagerType, au as MaintenanceService, av as RetrievalService, aw as SearchService, aw as SearchServiceType, ai as WikiMemoryTestAccess, ax as WriteService } from './testing-CH_Kk34-.js';
+export { aq as EmbeddingService, ar as ImportExportService, as as IngestionService, at as JobManager, at as JobManagerType, au as MaintenanceService, av as RetrievalService, aw as SearchService, aw as SearchServiceType, ai as WikiMemoryTestAccess, ax as WriteService } from './testing-BIFNLUva.js';
 import '@equationalapplications/core-okf';
 import 'minisearch';

package/dist/testing.js

@@ -1343,7 +1343,11 @@ var ImportExportService = class {
         );
       }
     });
-    await this.searchService.sync(entityId);
+    if (merge) {
+      await this.searchService.syncEntries(entityId, [...upsertedFactIds]);
+    } else {
+      await this.searchService.sync(entityId);
+    }
     for (const fact of bundle.facts) {
       if (!fact.deleted_at && upsertedFactIds.has(fact.id) && !factsWithPreservedBlob.has(fact.id)) {
         const clipped = clippedTextByFactId.get(fact.id);
@@ -2095,7 +2099,10 @@ var IngestionService = class {
         return zeroChunkResult(canonical);
       }
       diagBuffer.flush(this.options);
-      await this.searchService.sync(entityId);
+      await this.searchService.syncEntries(
+        entityId,
+        [...deletedSourceFactIds, ...insertedFacts.map((fact) => fact.id)]
+      );
       if (failedChunks === 0) {
         const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
         for (const factId of uniqueDeletedSourceFactIds) {
@@ -4506,7 +4513,31 @@ var _SearchService = class _SearchService {
      * auto-vacuum debt behind the TypeError in #64.
      */
     this.syncChain = Promise.resolve();
-    this.miniSearch = new MiniSearch__default.default({
+    /**
+     * 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.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
@@ -4533,7 +4564,19 @@ var _SearchService = class _SearchService {
     const work = this.syncChain.then(async () => {
       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 {
+            for (const id of [...this.staleEntities]) {
+              if ((this.staleEpochs.get(id) ?? 0) === (epochsBefore.get(id) ?? 0)) {
+                this.staleEntities.delete(id);
+              }
+            }
+          }
           await this.miniSearch.vacuum();
         } finally {
           this.evictCache(entityId);
@@ -4545,6 +4588,68 @@ var _SearchService = class _SearchService {
     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) {
+    const uniqueIds = [...new Set(ids)];
+    if (uniqueIds.length === 0 && !this.staleEntities.has(entityId) && this.miniSearchEntryIdsByEntity.has(entityId)) {
+      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);
+          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();
+              }
+              return;
+            }
+          }
+          await this.rebuildIndex(entityId);
+          if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
+            this.staleEntities.delete(entityId);
+          }
+          await this.miniSearch.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;
+    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) {
+    this.staleEntities.add(entityId);
+    this.staleEpochs.set(entityId, (this.staleEpochs.get(entityId) ?? 0) + 1);
+  }
   /**
    * Clears the parsed vector cache. Useful for mid-loop flush guarantees
    * or memory pressure evictions.
@@ -4561,8 +4666,10 @@ var _SearchService = class _SearchService {
    */
   clearAll() {
     this.vectorCache.clear();
-    this.miniSearch.removeAll();
+    this.miniSearch = this.createMiniSearch();
     this.miniSearchEntryIdsByEntity.clear();
+    this.staleEntities.clear();
+    this.staleEpochs.clear();
   }
   /**
    * Executes a keyword search against the active MiniSearch index.
@@ -4573,7 +4680,7 @@ var _SearchService = class _SearchService {
       filter: (r) => entityIdSet.has(r.entity_id),
       combineWith: "OR"
     });
-    return results.slice(0, limit);
+    return results.sort((a, b) => this._compareSearchResults(a, b)).slice(0, limit);
   }
   /**
    * Pre-fetches MiniSearch scores for candidate hydration, used during hybrid weighting.
@@ -4583,7 +4690,7 @@ var _SearchService = class _SearchService {
     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);
     }
@@ -4711,6 +4818,18 @@ var _SearchService = class _SearchService {
     if (updatedAtDiff !== 0) return updatedAtDiff;
     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.
+   */
+  _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