@equationalapplications/core-llm-wiki 5.2.0 → 5.3.0

package/dist/index.js

@@ -45,6 +45,24 @@ async function setupDatabase(db, prefix) {
     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,
@@ -149,6 +167,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"
 };
@@ -184,6 +208,31 @@ var WikiDuplicateHashError = class extends Error {
     this.entityId = params.entityId;
   }
 };
+var WikiStrictOntologyViolation = class extends Error {
+  constructor(entityId, kind, type) {
+    super(
+      `Out-of-manifest ${kind} type "${type}" for entity "${entityId}" under strict mode.`
+    );
+    this.code = "WIKI_STRICT_ONTOLOGY_VIOLATION";
+    this.entityId = entityId;
+    this.kind = kind;
+    this.type = type;
+    this.name = "WikiStrictOntologyViolation";
+  }
+};
+var WikiSourceRefHashCollision = class extends Error {
+  constructor(params) {
+    super(
+      `Source hash "${params.sourceHash}" for entity "${params.entityId}" is already mapped to sourceRef "${params.existingSourceRef}"; cannot remap to "${params.attemptedSourceRef}".`
+    );
+    this.code = "WIKI_SOURCE_REF_HASH_COLLISION";
+    this.entityId = params.entityId;
+    this.sourceHash = params.sourceHash;
+    this.existingSourceRef = params.existingSourceRef;
+    this.attemptedSourceRef = params.attemptedSourceRef;
+    this.name = "WikiSourceRefHashCollision";
+  }
+};
 var WikiTransactionError = class extends Error {
   constructor(message, options) {
     super(message, options);
@@ -377,6 +426,61 @@ var MIGRATIONS = [
         );
       }
     }
+  },
+  {
+    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;`
+      );
+    }
   }
 ];
 for (let i = 1; i < MIGRATIONS.length; i++) {
@@ -777,12 +881,22 @@ var EntryRepository = class extends BaseRepository {
   /**
    * Fetch recent non-deleted entries for an entity (limited), ordered by updated_at DESC.
    * Used by MaintenanceService.doRunLibrarian().
+   *
+   * When `excludeSourceRef` is supplied, the WHERE clause filters out that
+   * sourceRef BEFORE applying LIMIT. The caller in IngestionService is
+   * `findRecentByEntityId(entityId, 500, tx)` — it discards same-sourceRef
+   * rows after the read to build a cross-sourceRef title index. If those
+   * rows are filtered out in SQL, the limit applies to usable rows only
+   * and a re-ingest where the caller's sourceRef owns most recent facts
+   * still leaves cross-sourceRef entries in the index.
    */
-  async findRecentByEntityId(entityId, limit, tx) {
+  async findRecentByEntityId(entityId, limit, tx, excludeSourceRef) {
     const executor = this.getExecutor(tx);
+    const excludeClause = excludeSourceRef ? ` AND (source_ref IS NULL OR source_ref != ?)` : "";
+    const args = excludeSourceRef ? [entityId, excludeSourceRef, limit] : [entityId, limit];
     const rows = await executor.getAllAsync(
-      `SELECT * FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL ORDER BY updated_at DESC LIMIT ?`,
-      [entityId, limit]
+      `SELECT * FROM ${this.prefix}entries WHERE entity_id = ? AND deleted_at IS NULL${excludeClause} ORDER BY updated_at DESC LIMIT ?`,
+      args
     );
     return rows.map(mapRowToFact);
   }
@@ -1532,6 +1646,57 @@ var OutboxRepository = class extends BaseRepository {
   }
 };
 
+// src/repositories/SourceRefIndexRepository.ts
+var SourceRefIndexRepository = class extends BaseRepository {
+  /**
+   * Idempotent insert: the partial UNIQUE index catches concurrent inserts for
+   * the same (entity_id, source_hash). The caller (IngestionService) catches
+   * the resulting SQLITE_CONSTRAINT_UNIQUE and translates it to the per-mode
+   * duplicate-hash outcome. Runtime IDs use the `sri_` prefix to avoid
+   * collision with the deterministic `sri:<entity>:<hash>` IDs used by the v9
+   * backfill (the colon separator keeps the two ID spaces disjoint).
+   */
+  async upsert(entityId, sourceHash, sourceRef, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}source_ref_index (id, entity_id, source_hash, source_ref, created_at, deleted_at)
+       VALUES (?, ?, ?, ?, ?, NULL)`,
+      [generateId("sri_"), entityId, sourceHash, sourceRef, Date.now()]
+    );
+  }
+  /**
+   * Idempotent soft-delete of the live row for (entity_id, source_ref).
+   * Called at the start of every ingestDocument to remove the prior run's
+   * index row, so the new upsert doesn't collide with itself. No-op when the
+   * row is already soft-deleted or never existed.
+   */
+  async softDeleteByEntityAndSourceRef(entityId, sourceRef, tx) {
+    const executor = this.getExecutor(tx);
+    const now = Date.now();
+    const result = await executor.runAsync(
+      `UPDATE ${this.prefix}source_ref_index
+       SET deleted_at = ?, created_at = ?
+       WHERE entity_id = ? AND source_ref = ? AND deleted_at IS NULL`,
+      [now, now, entityId, sourceRef]
+    );
+    return result.changes;
+  }
+  /**
+   * Returns the live sourceRef holding the given hash, or null when no live
+   * row exists. Used by the IngestionService pre-check (line 82) and the
+   * catch-and-translate canonical lookup (line 212).
+   */
+  async findActiveByEntityAndHash(entityId, sourceHash, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(
+      `SELECT source_ref FROM ${this.prefix}source_ref_index
+       WHERE entity_id = ? AND source_hash = ? AND deleted_at IS NULL`,
+      [entityId, sourceHash]
+    );
+    return row?.source_ref ?? null;
+  }
+};
+
 // src/repositories/TaskRepository.ts
 function mapRowToTask(row) {
   return {
@@ -1946,6 +2111,34 @@ var EdgeRepository = class extends BaseRepository {
     const executor = this.getExecutor(tx);
     await executor.runAsync(`DELETE FROM ${this.prefix}edges WHERE entity_id = ?`, [entityId]);
   }
+  /**
+   * Hard-delete every edge whose `source_id` is in `sourceFactIds`, scoped to
+   * `entityId`. Returns the number of rows deleted. Edges have no soft-delete
+   * concept; this method is named `softDeleteBySourceFactIds` for symmetry with
+   * `EntryRepository.softDeleteBySource` (which IS a soft delete), but its
+   * semantics are immediate presence/absence removal. Use ONLY inside an open
+   * transaction — the method requires `tx` and performs no autocommit.
+   *
+   * Used by `IngestionService.upsertGraphCore` to retire the prior parse's
+   * edges whose source facts are being superseded by `softDeleteBySource`.
+   */
+  async softDeleteBySourceFactIds(entityId, sourceFactIds, tx) {
+    if (sourceFactIds.length === 0) return 0;
+    const executor = this.getExecutor(tx);
+    const chunkSize = 500;
+    let totalChanges = 0;
+    for (let i = 0; i < sourceFactIds.length; i += chunkSize) {
+      const chunk = sourceFactIds.slice(i, i + chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      const result = await executor.runAsync(
+        `DELETE FROM ${this.prefix}edges
+         WHERE entity_id = ? AND source_id IN (${placeholders})`,
+        [entityId, ...chunk]
+      );
+      totalChanges += result.changes;
+    }
+    return totalChanges;
+  }
   /**
    * Multi-hop traversal from `sourceId` via SQLite `WITH RECURSIVE`. All filtering,
    * dead-ending, cycle-guarding, capping, and ordering happens in this one query.
@@ -2132,14 +2325,25 @@ function mergeOntologyUpdates(current, updates) {
   }
   return { node_types, edge_types };
 }
-function validateInlineEdges(sourceType, _targetType, edges, manifest) {
-  if (!Array.isArray(edges)) return [];
+function validateInlineEdges(sourceType, _targetType, edges, manifest, opts) {
+  const strict = opts?.strict === true;
+  const entityId = opts?.entityId ?? "";
+  if (!Array.isArray(edges)) {
+    if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", "");
+    return [];
+  }
   const valid = [];
   for (const edge of edges) {
-    if (typeof edge?.edge_type !== "string" || typeof edge?.target_title !== "string") continue;
+    if (typeof edge?.edge_type !== "string" || typeof edge?.target_title !== "string") {
+      if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", String(edge?.edge_type ?? ""));
+      continue;
+    }
     const defs = resolveEdgeDefinitions(edge.edge_type, manifest);
     const match = defs.find((d) => d.source_type.toLowerCase() === sourceType.toLowerCase());
-    if (!match) continue;
+    if (!match) {
+      if (strict) throw new WikiStrictOntologyViolation(entityId, "edge", edge.edge_type);
+      continue;
+    }
     valid.push({ edge_type: match.type, target_title: edge.target_title });
   }
   return valid;
@@ -2240,16 +2444,25 @@ var MetadataRepository = class extends BaseRepository {
     await this.db.execAsync(`PRAGMA wal_checkpoint(TRUNCATE)`);
     await this.db.execAsync(`VACUUM`);
   }
+  /**
+   * Returns the set of distinct `entity_id` values across entries/tasks/events.
+   *
+   * Deliberately widened from a prior `WHERE deleted_at IS NULL` form: the
+   * returned set intentionally includes entities whose only rows are
+   * soft-deleted, so the host's maintenance sweep can visit such
+   * "decommissioned-scope" namespaces and reap the soft-deleted rows. Sorting
+   * is `entity_id COLLATE BINARY` for stable, locale-independent ordering.
+   */
   async getDistinctEntityIds(tx) {
     const executor = this.getExecutor(tx);
     const rows = await executor.getAllAsync(
       `SELECT DISTINCT entity_id FROM (
-         SELECT entity_id FROM ${this.prefix}entries WHERE deleted_at IS NULL
+         SELECT entity_id FROM ${this.prefix}entries
          UNION
-         SELECT entity_id FROM ${this.prefix}tasks WHERE deleted_at IS NULL
+         SELECT entity_id FROM ${this.prefix}tasks
          UNION
          SELECT entity_id FROM ${this.prefix}events
-       ) ORDER BY entity_id`
+       ) ORDER BY entity_id COLLATE BINARY`
     );
     return rows.map((r) => r.entity_id);
   }
@@ -2575,6 +2788,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.
@@ -2592,6 +2818,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`;
   }
@@ -2805,6 +3076,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).
@@ -3245,11 +3548,14 @@ 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, metadataRepo, edgeRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
     this.db = db;
     this.prefix = prefix;
     this.options = options;
     this.entryRepo = entryRepo;
+    this.sourceRefIndexRepo = sourceRefIndexRepo;
+    this.metadataRepo = metadataRepo;
+    this.edgeRepo = edgeRepo;
     this.searchService = searchService;
     this.jobManager = jobManager;
     this.embeddingService = embeddingService;
@@ -3261,18 +3567,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(
@@ -3284,8 +3578,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(
@@ -3321,68 +3625,85 @@ 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));
+          const titleIndex = /* @__PURE__ */ new Map();
+          const existingFacts = await this.entryRepo.findRecentByEntityId(entityId, 500, tx, sourceRef);
+          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;
+          const hostNodes = [];
+          const rawEdgeRequests = [];
+          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, { strict: false }) ?? { okf_type: null, edges: [] };
+              const id = generateId("fact_");
+              hostNodes.push({
+                id,
+                type: ontologyFact.okf_type ?? "",
+                title: fact.title,
+                body: fact.body,
+                // Forward the LLM-extracted tags/confidence through the
+                // extracted-shape upsertGraphCore path so the entries row
+                // stores them (search filterability, heal-candidate
+                // selection, runReembed embedding-text signal). The public
+                // WikiMemory.upsertGraph API doesn't accept tags/confidence
+                // — host-supplied deterministic nodes default to [] and
+                // 'certain' as documented.
+                tags: fact.tags,
+                confidence: fact.confidence
+              });
+              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) {
+                rawEdgeRequests.push({ sourceId: id, sourceType: normalized.okf_type, edges: normalized.edges });
+              }
+            }
           }
-          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 });
+          const hostEdges = [];
+          for (const req of rawEdgeRequests) {
+            const resolved = this.ontologyService?.resolveEdges(
+              entityId,
+              req.sourceId,
+              req.sourceType,
+              req.edges,
+              manifest,
+              titleIndex,
+              now
+            ) ?? [];
+            for (const e of resolved) {
+              hostEdges.push({ type: e.edge_type, sourceId: e.source_id, targetId: e.target_id });
             }
           }
-        }
-        for (const item of pendingEdges) {
-          await this.ontologyService?.resolveAndPersistEdges(
+          await this.upsertGraphCore(
             entityId,
-            item.sourceId,
-            item.sourceType,
-            item.edges ?? [],
-            manifest,
-            titleIndex,
+            { sourceRef, sourceHash, nodes: hostNodes, edges: hostEdges },
             tx,
-            now
+            { strict: false }
           );
+        });
+      } 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 });
         }
-      });
+        return { truncated: false, chunks: 0, duplicateOf: canonical };
+      }
       await this.searchService.sync(entityId);
       const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
       for (const factId of uniqueDeletedSourceFactIds) {
@@ -3398,9 +3719,129 @@ var IngestionService = class {
       this.searchService.evictCache(entityId);
       return { truncated, chunks: chunks.length };
     } finally {
-      this.jobManager.releaseLock("ingest", entityId, sourceRef);
+      releaseIngestLocks();
     }
   }
+  /**
+   * Implements spec §2 data flow steps a–j with the host-facing
+   * `{sourceRef, sourceHash, nodes, edges}` parameter shape. Shared between
+   * `ingestDocument` (with `{ strict: false }` to preserve current behavior)
+   * and `WikiMemory.upsertGraph` (which lets the persisted ontology mode
+   * decide strictness).
+   *
+   * Runs ENTIRELY inside the supplied `tx`. Does not acquire locks, does not
+   * open a nested transaction, does not perform post-commit work (search
+   * sync, embedding, cache eviction). Those concerns remain in `ingestDocument`.
+   *
+   * The pre-flight validation (steps a–c) lives INSIDE this method per the
+   * spec, so the public `WikiMemory.upsertGraph` can be a thin wrapper that
+   * performs only the C2 probe before delegating.
+   *
+   * @returns Counts: nodesWritten (validated nodes persisted), edgesWritten
+   *   (manifest-valid edges persisted), superseded (prior facts soft-deleted
+   *   plus prior source-ref edges hard-deleted).
+   */
+  async upsertGraphCore(entityId, params, tx, opts) {
+    const now = Date.now();
+    const ontologyState = await this.ontologyService?.getEffectiveState(entityId, tx) ?? { mode: "off", manifest: { node_types: [], edge_types: [] } };
+    let { mode, manifest } = ontologyState;
+    const strictEffective = opts?.strict === false ? false : opts?.strict === true || mode === "strict";
+    const wikiFacts = [];
+    for (const node of params.nodes) {
+      const factLike = { okf_type: node.type, edges: [] };
+      const normalized = this.ontologyService?.validateAndNormalizeFact(factLike, manifest, {
+        strict: strictEffective,
+        entityId
+      }) ?? { okf_type: null};
+      const wikiFact = {
+        id: node.id,
+        entity_id: entityId,
+        title: node.title,
+        body: node.body ?? "",
+        // Public upsertGraph callers don't supply tags/confidence, so they
+        // default to [] / 'certain' for deterministic AST-grade facts.
+        // ingestDocument routes through this method for the LLM path and
+        // forwards the LLM-supplied tags + confidence, preserving the prior
+        // behavior (search filterability, heal-candidate selection, runReembed
+        // embedding-text signal).
+        tags: node.tags ? Array.from(node.tags) : [],
+        confidence: node.confidence ?? "certain",
+        source_type: "immutable_document",
+        source_hash: params.sourceHash,
+        source_ref: params.sourceRef,
+        created_at: now,
+        updated_at: now,
+        last_accessed_at: null,
+        access_count: 0,
+        deleted_at: null,
+        okf_type: normalized.okf_type
+      };
+      wikiFacts.push(wikiFact);
+    }
+    const sourceIdToType = /* @__PURE__ */ new Map();
+    for (const fact of wikiFacts) sourceIdToType.set(fact.id, fact.okf_type ?? null);
+    const hasConstraints = (manifest.node_types?.length ?? 0) > 0 || (manifest.edge_types?.length ?? 0) > 0;
+    const validEdges = [];
+    for (const edge of params.edges) {
+      if (!hasConstraints) {
+        validEdges.push({
+          id: edge.id ?? generateId(),
+          entity_id: entityId,
+          source_id: edge.sourceId,
+          target_id: edge.targetId,
+          edge_type: edge.type,
+          created_at: now
+        });
+        continue;
+      }
+      if (!sourceIdToType.has(edge.sourceId)) {
+        validEdges.push({
+          id: edge.id ?? generateId(),
+          entity_id: entityId,
+          source_id: edge.sourceId,
+          target_id: edge.targetId,
+          edge_type: edge.type,
+          created_at: now
+        });
+        continue;
+      }
+      const sourceType = sourceIdToType.get(edge.sourceId);
+      const candidates = (manifest.edge_types ?? []).filter(
+        (d) => d.type.toLowerCase() === edge.type.toLowerCase() && d.source_type.toLowerCase() === (sourceType ?? "").toLowerCase()
+      );
+      const match = candidates[0];
+      if (!match) {
+        if (strictEffective) throw new WikiStrictOntologyViolation(entityId, "edge", edge.type);
+        continue;
+      }
+      validEdges.push({
+        id: edge.id ?? generateId(),
+        entity_id: entityId,
+        source_id: edge.sourceId,
+        target_id: edge.targetId,
+        edge_type: match.type,
+        created_at: now
+      });
+    }
+    const deletedFactIds = await this.entryRepo.findIdsBySource(entityId, params.sourceRef, null, tx, false);
+    await this.entryRepo.softDeleteBySource(entityId, tx, params.sourceRef, null);
+    const deletedEdgeCount = await this.edgeRepo.softDeleteBySourceFactIds(entityId, deletedFactIds, tx);
+    await this.sourceRefIndexRepo.softDeleteByEntityAndSourceRef(entityId, params.sourceRef, tx);
+    await this.sourceRefIndexRepo.upsert(entityId, params.sourceHash, params.sourceRef, tx);
+    for (const wikiFact of wikiFacts) {
+      await this.entryRepo.upsert(wikiFact, tx);
+    }
+    let edgesInsertedCount = 0;
+    for (const edge of validEdges) {
+      const inserted = await this.edgeRepo.addIgnoreDuplicate(edge, tx);
+      if (inserted) edgesInsertedCount++;
+    }
+    return {
+      nodesWritten: wikiFacts.length,
+      edgesWritten: edgesInsertedCount,
+      superseded: deletedFactIds.length + deletedEdgeCount
+    };
+  }
 };
 
 // src/services/BoundedLlmCall.ts
@@ -3522,11 +3963,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;
@@ -3725,10 +4167,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++;
@@ -3846,7 +4290,7 @@ var MaintenanceService = class {
         }
         if (skip) continue;
         const ontologyFact = fact;
-        const normalized = this.ontologyService?.validateAndNormalizeFact(ontologyFact, manifest) ?? { okf_type: null, edges: [] };
+        const normalized = this.ontologyService?.validateAndNormalizeFact(ontologyFact, manifest, { strict: false }) ?? { okf_type: null, edges: [] };
         const id = generateId("fact_");
         const factObj = {
           id,
@@ -4231,7 +4675,8 @@ var MaintenanceService = class {
             okf_type: classification.okf_type,
             edges: classification.edges
           },
-          manifest
+          manifest,
+          { strict: false }
         );
         if (!normalized.okf_type) {
           failedValidation++;
@@ -5621,16 +6066,27 @@ var OntologyService = class {
     this.invalidateCache(entityId);
     return merged;
   }
-  validateAndNormalizeFact(fact, manifest) {
+  validateAndNormalizeFact(fact, manifest, opts) {
     const rawType = typeof fact.okf_type === "string" ? fact.okf_type : "";
+    const strict = opts?.strict === true;
     const canonical = resolveNodeType(rawType, manifest);
-    if (!canonical) return { okf_type: null, edges: [] };
-    const edges = validateInlineEdges(canonical, null, fact.edges ?? [], manifest);
+    if (!canonical) {
+      if (strict) throw new WikiStrictOntologyViolation(opts?.entityId ?? "", "node", rawType);
+      return { okf_type: null, edges: [] };
+    }
+    const edges = validateInlineEdges(canonical, null, fact.edges ?? [], manifest, opts);
     return { okf_type: canonical, edges };
   }
-  async resolveAndPersistEdges(entityId, sourceId, sourceType, edges, manifest, titleIndex, tx, now) {
-    if (!sourceType || edges.length === 0) return 0;
-    let persisted = 0;
+  /**
+   * Pure resolver: given a source type, LLM-supplied edges, the manifest,
+   * and a title index, return a list of concrete `WikiEdge` objects ready
+   * for persistence. Performs no DB writes. Used by callers that batch edge
+   * writes inside their own transaction (e.g. `IngestionService.ingestDocument`
+   * when delegating to `upsertGraphCore`).
+   */
+  resolveEdges(entityId, sourceId, sourceType, edges, manifest, titleIndex, now) {
+    if (!sourceType || edges.length === 0) return [];
+    const out = [];
     for (const edge of edges) {
       const candidates = resolveEdgeDefinitions(edge.edge_type, manifest).filter((d) => d.source_type.toLowerCase() === sourceType.toLowerCase());
       if (candidates.length === 0) continue;
@@ -5641,15 +6097,29 @@ var OntologyService = class {
         (d) => d.target_type.toLowerCase() === (target.okf_type ?? "").toLowerCase()
       );
       if (!def) continue;
-      const wikiEdge = {
+      out.push({
         id: generateId(),
         entity_id: entityId,
         source_id: sourceId,
         target_id: target.id,
         edge_type: def.type,
         created_at: now
-      };
-      const inserted = await this.edgeRepo.addIgnoreDuplicate(wikiEdge, tx);
+      });
+    }
+    return out;
+  }
+  /**
+   * Backwards-compatible wrapper: resolves edges via {@link resolveEdges},
+   * then persists each via `edgeRepo.addIgnoreDuplicate` in the supplied
+   * transaction. Returns the number of edges persisted. Used by paths that
+   * want self-contained edge persistence (e.g. MaintenanceService heal /
+   * backfill callers that do not have a separate edge-write step).
+   */
+  async resolveAndPersistEdges(entityId, sourceId, sourceType, edges, manifest, titleIndex, tx, now) {
+    const resolved = this.resolveEdges(entityId, sourceId, sourceType, edges, manifest, titleIndex, now);
+    let persisted = 0;
+    for (const edge of resolved) {
+      const inserted = await this.edgeRepo.addIgnoreDuplicate(edge, tx);
       if (inserted) persisted++;
     }
     return persisted;
@@ -5705,6 +6175,7 @@ var WikiMemory = class {
     }
     this.outboxRepo = new OutboxRepository(this.db, this.prefix, !!options.config?.enableOutbox);
     this.entryRepo = new EntryRepository(this.db, this.prefix, this.outboxRepo);
+    this.sourceRefIndexRepo = new SourceRefIndexRepository(this.db, this.prefix);
     this.taskRepo = new TaskRepository(this.db, this.prefix, this.outboxRepo);
     this.eventRepo = new EventRepository(this.db, this.prefix);
     this.edgeRepo = new EdgeRepository(this.db, this.prefix);
@@ -5723,6 +6194,9 @@ var WikiMemory = class {
       this.prefix,
       this.options,
       this.entryRepo,
+      this.sourceRefIndexRepo,
+      this.metadataRepo,
+      this.edgeRepo,
       this.searchService,
       this.jobManager,
       this.embeddingService,
@@ -5734,6 +6208,7 @@ var WikiMemory = class {
       this.prefix,
       this.options,
       this.entryRepo,
+      this.sourceRefIndexRepo,
       this.taskRepo,
       this.eventRepo,
       this.metadataRepo,
@@ -5798,6 +6273,7 @@ var WikiMemory = class {
       promptService: this.promptService,
       graphTraversalService: this.graphTraversalService,
       entryRepo: this.entryRepo,
+      sourceRefIndexRepo: this.sourceRefIndexRepo,
       metadataRepo: this.metadataRepo,
       jobManager: this.jobManager
     };
@@ -5874,7 +6350,7 @@ var WikiMemory = class {
     const latestHashes = await this.entryRepo.findLatestSourceHashes(entityId, normalized.map((e) => e.sourceRef));
     const distinctHashes = Array.from(new Set(normalized.map((e) => e.sourceHash)));
     const dupRefs = await Promise.all(
-      distinctHashes.map((h) => this.entryRepo.findSourceRefsByHash(entityId, h))
+      distinctHashes.map((h) => this.sourceRefIndexRepo.findActiveByEntityAndHash(entityId, h))
     );
     const dupMap = /* @__PURE__ */ new Map();
     for (let i = 0; i < distinctHashes.length; i++) {
@@ -5883,12 +6359,10 @@ var WikiMemory = class {
     return normalized.map((e) => {
       const stored = latestHashes.get(e.sourceRef);
       const changed = stored === void 0 || stored === null || normalizeSourceHash(stored) !== e.sourceHash;
-      const allRefs = dupMap.get(e.sourceHash) ?? [];
-      const others = allRefs.filter((r) => r !== e.sourceRef);
-      if (others.length === 0) {
+      const canonical = dupMap.get(e.sourceHash) ?? null;
+      if (canonical === null || canonical === e.sourceRef) {
         return { sourceRef: e.rawSourceRef, changed };
       }
-      const canonical = others[0];
       return { sourceRef: e.rawSourceRef, changed, duplicateOf: canonical };
     });
   }
@@ -5903,13 +6377,47 @@ var WikiMemory = class {
     return this.entryRepo.listSourceRefs(entityId);
   }
   /**
-   * Returns the live source_refs for an entity that hold the given source_hash,
-   * sorted `COLLATE BINARY` ascending. The first element is the canonical ref
-   * under the code-unit-minimum rule (no locale dependency). Used by the
-   * ingestDocument guard and by hosts auditing duplicate-content collisions.
+   * Returns the live source_refs for an entity that hold the given source_hash.
+   * With v9, source_ref_index is the source of truth for the sourceRef-level
+   * TOCTOU-race invariant: at most one sourceRef can hold a given
+   * (entity_id, source_hash). The result is either a single-element array
+   * (one canonical ref) or empty (no live ref holds the hash). Returned as
+   * an array to preserve the existing public-API shape used by hosts
+   * auditing duplicate-content collisions.
    */
   async findSourceRefsByHash(entityId, sourceHash) {
-    return this.entryRepo.findSourceRefsByHash(entityId, sourceHash);
+    const canonical = await this.sourceRefIndexRepo.findActiveByEntityAndHash(entityId, sourceHash);
+    return canonical === null ? [] : [canonical];
+  }
+  /**
+   * Returns the set of `entity_id` values with at least one row in this
+   * database, INCLUDING entities whose only remaining rows are soft-deleted
+   * — sorted ascending `entity_id COLLATE BINARY`. Empty array when the
+   * database has no entities.
+   *
+   * The deliberate inclusion of soft-deleted-only entities closes the
+   * decommissioned-scope leak: a scoped namespace whose documents have all
+   * been forgotten or superseded must still appear so host maintenance
+   * sweeps (`runLibrarian`, `runHeal`, `runOntologyBackfill`, `runPrune`)
+   * can visit it and reap the soft-deleted rows.
+   *
+   * Read-only. Never acquires a lock. Never opens a transaction. Propagates
+   * underlying read errors.
+   *
+   * @param options.prefix - Optional string filter applied as
+   *   `id.startsWith(prefix)`. O(n) over distinct ids because the
+   *   `(entity_id, source_ref)` index is not seekable on `entity_id`-only
+   *   prefix. Empty-string prefix matches every id.
+   *
+   * Note: this widens the coverage of `exportDump` (which delegates to
+   * `MetadataRepository.getDistinctEntityIds`); exported dumps now include
+   * orphaned entities. This is a deliberate widening for backup/migration
+   * coverage, not a breaking change to `exportDump`'s return shape.
+   */
+  async listEntityIds(options) {
+    const ids = await this.metadataRepo.getDistinctEntityIds();
+    if (options?.prefix === void 0) return ids;
+    return ids.filter((id) => id.startsWith(options.prefix));
   }
   async runPrune(entityId, options) {
     return this.maintenanceService.runPrune(entityId, options);
@@ -6007,6 +6515,57 @@ var WikiMemory = class {
   async ingestDocument(entityId, params, opts) {
     return this.ingestionService.ingestDocument(entityId, params, opts);
   }
+  /**
+   * Deterministic write path into the graph. Accepts caller-supplied
+   * `(nodes, edges)` and writes them under `(sourceRef, sourceHash)`
+   * semantics identical to `ingestDocument`, minus the LLM extraction step.
+   *
+   * 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`,
+   * scoped via `listEntityIds`).
+   *
+   * Contract (full pre-flight validation lives inside
+   * `IngestionService.upsertGraphCore`, which this method delegates to):
+   * - C2: no-op when `(entityId, sourceHash)` is already mapped to
+   *   `params.sourceRef`; throws `WikiSourceRefHashCollision` if mapped to
+   *   a different `sourceRef`.
+   * - C3: edges with dangling `targetId` are stored verbatim (no FK, no
+   *   resolution).
+   * - C4: under persisted ontology mode `'strict'`, an out-of-manifest node
+   *   or edge `type` throws `WikiStrictOntologyViolation` (pre-flight,
+   *   all-or-nothing — NONE written on failure).
+   *
+   * @returns Counts: nodesWritten (validated nodes persisted), edgesWritten
+   *   (manifest-valid edges persisted), superseded (prior facts soft-deleted
+   *   plus prior source-ref edges hard-deleted).
+   */
+  async upsertGraph(entityId, params, adapter) {
+    const sourceRef = normalizeSourceRef(params.sourceRef);
+    if (!sourceRef) throw new Error("Invalid sourceRef");
+    const sourceHash = normalizeSourceHash(params.sourceHash);
+    if (!sourceHash) throw new Error("Invalid sourceHash (must be 64-char hex string)");
+    const canonical = await this.sourceRefIndexRepo.findActiveByEntityAndHash(entityId, sourceHash, adapter);
+    if (canonical !== null && canonical === sourceRef) {
+      return { nodesWritten: 0, edgesWritten: 0, superseded: 0 };
+    }
+    if (canonical !== null && canonical !== sourceRef) {
+      throw new WikiSourceRefHashCollision({
+        entityId,
+        sourceHash,
+        existingSourceRef: canonical,
+        attemptedSourceRef: sourceRef
+      });
+    }
+    return this.ingestionService.upsertGraphCore(
+      entityId,
+      { sourceRef, sourceHash, nodes: params.nodes, edges: params.edges },
+      adapter
+    );
+  }
   /**
    * Returns up to `limit` unprocessed outbox events, oldest first.
    * Works regardless of enableOutbox value — allows draining after disabling.
@@ -6826,6 +7385,8 @@ exports.PrunePartialFailureError = PrunePartialFailureError;
 exports.WikiBusyError = WikiBusyError;
 exports.WikiDuplicateHashError = WikiDuplicateHashError;
 exports.WikiMemory = WikiMemory;
+exports.WikiSourceRefHashCollision = WikiSourceRefHashCollision;
+exports.WikiStrictOntologyViolation = WikiStrictOntologyViolation;
 exports.WikiTransactionError = WikiTransactionError;
 exports.chunkText = chunkText;
 exports.configureRandomSource = configureRandomSource;