@equationalapplications/core-llm-wiki 5.2.1 → 5.3.1

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

@@ -79,6 +79,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);
@@ -211,14 +236,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;
@@ -1266,12 +1302,14 @@ var DEFAULT_CHUNK_OVERLAP = 400;
 
 // src/services/IngestionService.ts
 var IngestionService = class {
-  constructor(db, prefix, options, entryRepo, sourceRefIndexRepo, 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;
@@ -1344,12 +1382,8 @@ var IngestionService = class {
       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);
+          const existingFacts = await this.entryRepo.findRecentByEntityId(entityId, 500, tx, sourceRef);
           for (const existing of existingFacts) {
             titleIndex.set(normalizeTitleKey(existing.title), {
               id: existing.id,
@@ -1358,6 +1392,8 @@ var IngestionService = class {
           }
           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);
@@ -1366,45 +1402,51 @@ var IngestionService = class {
             }
             for (const fact of facts) {
               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 wikiFact = {
+              hostNodes.push({
                 id,
-                entity_id: entityId,
+                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,
-                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);
+                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) {
-                pendingEdges.push({ sourceId: id, sourceType: normalized.okf_type, edges: normalized.edges });
+                rawEdgeRequests.push({ sourceId: id, sourceType: normalized.okf_type, edges: normalized.edges });
               }
             }
           }
-          for (const item of pendingEdges) {
-            await this.ontologyService?.resolveAndPersistEdges(
+          const hostEdges = [];
+          for (const req of rawEdgeRequests) {
+            const resolved = this.ontologyService?.resolveEdges(
               entityId,
-              item.sourceId,
-              item.sourceType,
-              item.edges ?? [],
+              req.sourceId,
+              req.sourceType,
+              req.edges,
               manifest,
               titleIndex,
-              tx,
               now
-            );
+            ) ?? [];
+            for (const e of resolved) {
+              hostEdges.push({ type: e.edge_type, sourceId: e.source_id, targetId: e.target_id });
+            }
           }
+          await this.upsertGraphCore(
+            entityId,
+            { sourceRef, sourceHash, nodes: hostNodes, edges: hostEdges },
+            tx,
+            { strict: false }
+          );
         });
       } catch (err) {
         const sqliteCode = err instanceof WikiTransactionError ? err.sqliteErrorCode : extractSqliteCode(err);
@@ -1434,6 +1476,126 @@ var IngestionService = class {
       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/repositories/BaseRepository.ts
@@ -1546,16 +1708,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);
   }
@@ -2045,7 +2216,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,
@@ -2430,7 +2601,8 @@ var MaintenanceService = class {
             okf_type: classification.okf_type,
             edges: classification.edges
           },
-          manifest
+          manifest,
+          { strict: false }
         );
         if (!normalized.okf_type) {
           failedValidation++;
@@ -3741,6 +3913,6 @@ 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-6HNIOKT4.mjs.map
-//# sourceMappingURL=chunk-6HNIOKT4.mjs.map
+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, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, emptyManifest, entitySummaryMetaKey, extractSqliteCode, generateId, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, parseEmbedding, resolveEdgeDefinitions, resolveNodeType, safeSlice, validateInlineEdges, validateManifest };
+//# sourceMappingURL=chunk-KIJINNYU.mjs.map
+//# sourceMappingURL=chunk-KIJINNYU.mjs.map