@equationalapplications/core-llm-wiki 5.2.0 → 5.2.1

package/README.md

@@ -825,6 +825,20 @@ const { chunks, truncated } = chunkText(
 
 > **Note:** `ingestDocument()` clamps the resolved overlap — whether it came from `chunkOverlap`, `WikiConfig`, or `DEFAULT_CHUNK_OVERLAP` — to `maxChunkLength - 1`. The clamp is evaluated on every call and is a no-op at the shipped defaults (`400 < 12000 - 1`), but it also bites when a custom `maxChunkLength` alone leaves the resolved overlap too large (e.g. `maxChunkLength: 100` with the default overlap `400` ingests at an effective overlap of `99`). That clamp is internal: passing the unclamped pair straight to `chunkText` throws, since it requires `overlap < maxChunkLength`. Apply the same `Math.min(overlap, maxChunkLength - 1)` yourself when re-chunking under a custom config.
 
+## Schema Migrations
+
+`wikiMemory.setup()` runs pending schema migrations in order and records the applied version. Migrations are additive and safe to re-run.
+
+**Migration v9** (`add_live_hash_unique_index`) adds a partial `UNIQUE` index on `(entity_id, source_hash)` scoped to live (`deleted_at IS NULL`), non-null-hash rows. This closes a TOCTOU race where two concurrent `ingestDocument()` calls for different `sourceRef`s could both pass the duplicate-hash pre-check before either write committed, leaving two live rows with the same content hash.
+
+If your existing database already has live rows that violate this invariant (created before the app-level race fix shipped), `setup()` throws:
+
+```text
+Migration v9 (add_live_hash_unique_index) failed: existing live rows violate the new UNIQUE index. …
+```
+
+The error lists the offending `(entity_id, source_hash)` groups. `setup()` performs no destructive cleanup on this path — the index is not created and the schema version is not advanced, so it's safe to retry after remediation. To remediate, either soft-delete (or re-ingest with a corrected `sourceRef`) all but one live row per listed group, then re-run `setup()`.
+
 ## Adapter Interface
 
 Implement `SQLiteAdapter` to use your platform's SQLite driver:

package/dist/{chunk-J3N3WRK7.mjs → chunk-6HNIOKT4.mjs}

@@ -38,6 +38,12 @@ var SQLITE_RESULT_CODE_NAMES = {
   26: "SQLITE_NOTADB",
   27: "SQLITE_NOTICE",
   28: "SQLITE_WARNING",
+  // Extended result codes (https://sqlite.org/rescode.html#extended_result_code_list).
+  // 2067 = SQLITE_CONSTRAINT_UNIQUE — raised when a UNIQUE index/PRIMARY KEY
+  // rejects an INSERT/UPDATE; expo-sqlite reports this as a numeric "Error code N:"
+  // 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",
   100: "SQLITE_ROW",
   101: "SQLITE_DONE"
 };
@@ -500,6 +506,19 @@ var JobManager = class {
     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.
@@ -517,6 +536,51 @@ var JobManager = class {
       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);
+      }
+      resolveReleased();
+    };
+    this.hashLocks.set(key, released);
+    return previous.then(() => release);
+  }
   _pruneKey(entityId) {
     return `${this.prefix}:${entityId}:prune`;
   }
@@ -730,6 +794,38 @@ var JobManager = class {
     this._notifyStatusSubscribers(entityId);
     return true;
   }
+  /**
+   * 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();
+      }
+    };
+  }
   /**
    * Validates then acquires global + per-entity import locks atomically.
    * Validates all entities before acquiring any lock (same as current importDump semantics).
@@ -1170,11 +1266,12 @@ var DEFAULT_CHUNK_OVERLAP = 400;
 
 // src/services/IngestionService.ts
 var IngestionService = class {
-  constructor(db, prefix, options, entryRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
+  constructor(db, prefix, options, entryRepo, sourceRefIndexRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
     this.db = db;
     this.prefix = prefix;
     this.options = options;
     this.entryRepo = entryRepo;
+    this.sourceRefIndexRepo = sourceRefIndexRepo;
     this.searchService = searchService;
     this.jobManager = jobManager;
     this.embeddingService = embeddingService;
@@ -1186,18 +1283,6 @@ var IngestionService = class {
     if (!sourceRef) throw new Error("Invalid sourceRef");
     const sourceHash = normalizeSourceHash(params.sourceHash);
     if (!sourceHash) throw new Error("Invalid sourceHash (must be 64-char hex string)");
-    const onDuplicateHash = opts?.onDuplicateHash ?? "ingest";
-    if (onDuplicateHash !== "ingest") {
-      const refs = await this.entryRepo.findSourceRefsByHash(entityId, sourceHash);
-      const others = refs.filter((r) => r !== sourceRef);
-      if (others.length > 0) {
-        const canonical = others[0];
-        if (onDuplicateHash === "throw") {
-          throw new WikiDuplicateHashError({ canonical, sourceHash, entityId });
-        }
-        return { truncated: false, chunks: 0, duplicateOf: canonical };
-      }
-    }
     const maxChunkLength = params.maxChunkLength ?? this.options.config?.maxChunkLength ?? DEFAULT_MAX_CHUNK_LENGTH;
     const rawOverlap = params.chunkOverlap ?? this.options.config?.chunkOverlap ?? DEFAULT_CHUNK_OVERLAP;
     const chunkOverlap = Math.min(
@@ -1209,8 +1294,18 @@ var IngestionService = class {
     if (typeof params.documentChunk !== "string") {
       throw new Error(`documentChunk must be a string, received ${typeof params.documentChunk}`);
     }
-    this.jobManager.acquireLock("ingest", entityId, sourceRef);
+    const releaseIngestLocks = await this.jobManager.acquireIngestLocks(entityId, sourceRef, sourceHash);
     try {
+      const onDuplicateHash = opts?.onDuplicateHash ?? "ingest";
+      if (onDuplicateHash !== "ingest") {
+        const canonical = await this.sourceRefIndexRepo.findActiveByEntityAndHash(entityId, sourceHash);
+        if (canonical !== null && canonical !== sourceRef) {
+          if (onDuplicateHash === "throw") {
+            throw new WikiDuplicateHashError({ canonical, sourceHash, entityId });
+          }
+          return { truncated: false, chunks: 0, duplicateOf: canonical };
+        }
+      }
       const { chunks, truncated } = chunkText(params.documentChunk, maxChunkLength, chunkOverlap);
       if (chunks.length === 0) return { truncated: false, chunks: 0 };
       const chunkResults = await withConcurrency(
@@ -1246,68 +1341,81 @@ var IngestionService = class {
       const now = Date.now();
       const insertedFacts = [];
       const deletedSourceFactIds = [];
-      await this.db.withTransactionAsync(async (tx) => {
-        deletedSourceFactIds.push(...await this.entryRepo.findIdsBySource(entityId, sourceRef, null, tx, false));
-        await this.entryRepo.softDeleteBySource(entityId, tx, sourceRef, null);
-        const titleIndex = /* @__PURE__ */ new Map();
-        const pendingEdges = [];
-        const existingFacts = await this.entryRepo.findRecentByEntityId(entityId, 500, tx);
-        for (const existing of existingFacts) {
-          titleIndex.set(normalizeTitleKey(existing.title), {
-            id: existing.id,
-            okf_type: existing.okf_type ?? null
-          });
-        }
-        let ontologyState = await this.ontologyService?.getEffectiveState(entityId, tx) ?? { mode: "off", manifest: { node_types: [], edge_types: [] } };
-        let { mode, manifest } = ontologyState;
-        for (const { facts, ontology_updates } of orderedChunkFacts) {
-          if (mode === "emergent" && ontology_updates && this.ontologyService) {
-            manifest = await this.ontologyService.mergeEmergentUpdates(entityId, ontology_updates, tx);
-            ontologyState = await this.ontologyService.getEffectiveState(entityId, tx);
-            mode = ontologyState.mode;
+      try {
+        await this.db.withTransactionAsync(async (tx) => {
+          deletedSourceFactIds.push(...await this.entryRepo.findIdsBySource(entityId, sourceRef, null, tx, false));
+          await this.entryRepo.softDeleteBySource(entityId, tx, sourceRef, null);
+          await this.sourceRefIndexRepo.softDeleteByEntityAndSourceRef(entityId, sourceRef, tx);
+          await this.sourceRefIndexRepo.upsert(entityId, sourceHash, sourceRef, tx);
+          const titleIndex = /* @__PURE__ */ new Map();
+          const pendingEdges = [];
+          const existingFacts = await this.entryRepo.findRecentByEntityId(entityId, 500, tx);
+          for (const existing of existingFacts) {
+            titleIndex.set(normalizeTitleKey(existing.title), {
+              id: existing.id,
+              okf_type: existing.okf_type ?? null
+            });
           }
-          for (const fact of facts) {
-            const ontologyFact = fact;
-            const normalized = this.ontologyService?.validateAndNormalizeFact(ontologyFact, manifest) ?? { okf_type: null, edges: [] };
-            const id = generateId("fact_");
-            const wikiFact = {
-              id,
-              entity_id: entityId,
-              title: fact.title,
-              body: fact.body,
-              tags: fact.tags,
-              confidence: fact.confidence,
-              source_type: "immutable_document",
-              source_hash: sourceHash,
-              source_ref: sourceRef,
-              created_at: now,
-              updated_at: now,
-              last_accessed_at: null,
-              access_count: 0,
-              deleted_at: null,
-              okf_type: normalized.okf_type
-            };
-            await this.entryRepo.upsert(wikiFact, tx);
-            insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
-            titleIndex.set(normalizeTitleKey(fact.title), { id, okf_type: normalized.okf_type });
-            if (normalized.edges.length > 0) {
-              pendingEdges.push({ sourceId: id, sourceType: normalized.okf_type, edges: normalized.edges });
+          let ontologyState = await this.ontologyService?.getEffectiveState(entityId, tx) ?? { mode: "off", manifest: { node_types: [], edge_types: [] } };
+          let { mode, manifest } = ontologyState;
+          for (const { facts, ontology_updates } of orderedChunkFacts) {
+            if (mode === "emergent" && ontology_updates && this.ontologyService) {
+              manifest = await this.ontologyService.mergeEmergentUpdates(entityId, ontology_updates, tx);
+              ontologyState = await this.ontologyService.getEffectiveState(entityId, tx);
+              mode = ontologyState.mode;
+            }
+            for (const fact of facts) {
+              const ontologyFact = fact;
+              const normalized = this.ontologyService?.validateAndNormalizeFact(ontologyFact, manifest) ?? { okf_type: null, edges: [] };
+              const id = generateId("fact_");
+              const wikiFact = {
+                id,
+                entity_id: entityId,
+                title: fact.title,
+                body: fact.body,
+                tags: fact.tags,
+                confidence: fact.confidence,
+                source_type: "immutable_document",
+                source_hash: sourceHash,
+                source_ref: sourceRef,
+                created_at: now,
+                updated_at: now,
+                last_accessed_at: null,
+                access_count: 0,
+                deleted_at: null,
+                okf_type: normalized.okf_type
+              };
+              await this.entryRepo.upsert(wikiFact, tx);
+              insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
+              titleIndex.set(normalizeTitleKey(fact.title), { id, okf_type: normalized.okf_type });
+              if (normalized.edges.length > 0) {
+                pendingEdges.push({ sourceId: id, sourceType: normalized.okf_type, edges: normalized.edges });
+              }
             }
           }
+          for (const item of pendingEdges) {
+            await this.ontologyService?.resolveAndPersistEdges(
+              entityId,
+              item.sourceId,
+              item.sourceType,
+              item.edges ?? [],
+              manifest,
+              titleIndex,
+              tx,
+              now
+            );
+          }
+        });
+      } catch (err) {
+        const sqliteCode = err instanceof WikiTransactionError ? err.sqliteErrorCode : extractSqliteCode(err);
+        if (sqliteCode !== "SQLITE_CONSTRAINT_UNIQUE") throw err;
+        const canonical = await this.sourceRefIndexRepo.findActiveByEntityAndHash(entityId, sourceHash);
+        if (canonical === null) throw err;
+        if (onDuplicateHash === "throw" || onDuplicateHash === "ingest") {
+          throw new WikiDuplicateHashError({ canonical, sourceHash, entityId });
         }
-        for (const item of pendingEdges) {
-          await this.ontologyService?.resolveAndPersistEdges(
-            entityId,
-            item.sourceId,
-            item.sourceType,
-            item.edges ?? [],
-            manifest,
-            titleIndex,
-            tx,
-            now
-          );
-        }
-      });
+        return { truncated: false, chunks: 0, duplicateOf: canonical };
+      }
       await this.searchService.sync(entityId);
       const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
       for (const factId of uniqueDeletedSourceFactIds) {
@@ -1323,7 +1431,7 @@ var IngestionService = class {
       this.searchService.evictCache(entityId);
       return { truncated, chunks: chunks.length };
     } finally {
-      this.jobManager.releaseLock("ingest", entityId, sourceRef);
+      releaseIngestLocks();
     }
   }
 };
@@ -1610,11 +1718,12 @@ var HEAL_MAX_PROMPT_CHARS = 4e4;
 var HEAL_BATCH_SIZE = 25;
 var HEAL_RECHECK_MS = 7 * 24 * 60 * 60 * 1e3;
 var MaintenanceService = class {
-  constructor(db, prefix, options, entryRepo, taskRepo, eventRepo, metadataRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
+  constructor(db, prefix, options, entryRepo, sourceRefIndexRepo, taskRepo, eventRepo, metadataRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
     this.db = db;
     this.prefix = prefix;
     this.options = options;
     this.entryRepo = entryRepo;
+    this.sourceRefIndexRepo = sourceRefIndexRepo;
     this.taskRepo = taskRepo;
     this.eventRepo = eventRepo;
     this.metadataRepo = metadataRepo;
@@ -1813,10 +1922,12 @@ var MaintenanceService = class {
           const entryPromise = params.entryId ? this.entryRepo.softDelete(params.entryId, entityId, tx).then((r) => r.changes > 0) : null;
           const taskDeletedPromise = params.taskId ? this.taskRepo.softDeleteById(params.taskId, entityId, tx).then((r) => r.changes > 0) : null;
           const refPromise = sourceRef || sourceHash ? this.entryRepo.softDeleteBySource(entityId, tx, sourceRef, sourceHash) : null;
+          const sourceRefIndexPromise = sourceRef ? this.sourceRefIndexRepo.softDeleteByEntityAndSourceRef(entityId, sourceRef, tx).then(() => void 0) : null;
           const [entryResult, taskResult, refResult] = await Promise.all([
             entryPromise ?? Promise.resolve(false),
             taskDeletedPromise ?? Promise.resolve(false),
-            refPromise ?? Promise.resolve(0)
+            refPromise ?? Promise.resolve(0),
+            sourceRefIndexPromise ?? Promise.resolve(void 0)
           ]);
           if (entryResult) deletedEntries++;
           if (taskResult) deletedTasks++;
@@ -3631,5 +3742,5 @@ var WriteService = class {
 };
 
 export { BaseRepository, DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, EmbeddingService, HEAL_BATCH_SIZE, HEAL_RECHECK_MS, HOOK_TIMEOUT_MARKER, ImportExportService, IngestionService, JobManager, MaintenanceService, MetadataRepository, ONTOLOGY_BACKFILL_BATCH_SIZE, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, ONTOLOGY_BACKFILL_RECHECK_MS, ONTOLOGY_BACKFILL_SYSTEM_PROMPT, PromptService, PrunePartialFailureError, RetrievalService, SearchService, WikiBusyError, WikiDuplicateHashError, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, emptyManifest, entitySummaryMetaKey, extractSqliteCode, generateId, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, parseEmbedding, resolveEdgeDefinitions, resolveNodeType, safeSlice, validateInlineEdges, validateManifest };
-//# sourceMappingURL=chunk-J3N3WRK7.mjs.map
-//# sourceMappingURL=chunk-J3N3WRK7.mjs.map
+//# sourceMappingURL=chunk-6HNIOKT4.mjs.map
+//# sourceMappingURL=chunk-6HNIOKT4.mjs.map