@equationalapplications/core-llm-wiki 5.4.0 → 5.5.1

package/dist/testing.js

@@ -110,26 +110,88 @@ var PrunePartialFailureError = class extends Error {
   }
 };
 var HOOK_TIMEOUT_MARKER = /* @__PURE__ */ Symbol("WikiMemoryHookTimeout");
+var WikiParseError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "WikiParseError";
+    this.tier = opts.tier;
+    this.position = opts.position ?? null;
+    this.slice = opts.slice ?? "";
+  }
+};
+var WikiIngestEmptyError = class extends Error {
+  constructor(params) {
+    const summary = `All ${params.chunks} chunks failed for sourceRef "${params.sourceRef}"; see parseFailures for per-chunk detail`;
+    super(summary);
+    this.name = "WikiIngestEmptyError";
+    this.parseFailures = params.parseFailures;
+    this.sourceRef = params.sourceRef;
+    this.chunks = params.chunks;
+  }
+};
 
 // src/utils/pure.ts
+var MAX_REPAIR_CANDIDATES = 5;
+function throwNoJsonFound(text, start) {
+  throw new WikiParseError(
+    "No JSON object/array found in LLM response",
+    { tier: "strict", position: start, slice: text }
+  );
+}
 function parseJsonResponse(text) {
   const firstBrace = text.indexOf("{");
   const firstBracket = text.indexOf("[");
   let start;
   let openChar;
-  let closeChar;
   const useBrace = firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket);
   if (useBrace) {
     start = firstBrace;
     openChar = "{";
-    closeChar = "}";
   } else if (firstBracket !== -1) {
     start = firstBracket;
     openChar = "[";
-    closeChar = "]";
   } else {
-    throw new SyntaxError("No JSON object/array found in LLM response");
+    throwNoJsonFound(text, null);
+  }
+  const slice = scanJsonSlice(text, start, openChar);
+  if (slice !== null) {
+    try {
+      return JSON.parse(slice);
+    } catch {
+    }
+  }
+  const repairOdd = containerAwareRepair(text, start, false);
+  if (repairOdd.success !== null && !repairOdd.ambiguous) {
+    return repairOdd.success;
   }
+  const repairEven = containerAwareRepair(text, start, true);
+  if (repairOdd.success !== null && repairEven.success !== null) {
+    const pick = repairEven.escapes < repairOdd.escapes ? repairEven : repairOdd;
+    return pick.success;
+  }
+  if (repairOdd.success !== null) {
+    return repairOdd.success;
+  }
+  if (repairEven.success !== null) {
+    return repairEven.success;
+  }
+  const repair = repairEven.failed !== null ? repairEven : repairOdd;
+  if (repair.failed !== null) {
+    throw new WikiParseError(
+      `Repair produced a candidate but JSON.parse rejected it: ${repair.failed.message}`,
+      { tier: "repair", position: repair.failed.position, slice: repair.failed.candidate }
+    );
+  }
+  if (slice === null) {
+    throwNoJsonFound(text, start);
+  }
+  throw new WikiParseError(
+    "No parsable JSON candidate found",
+    { tier: "all", position: start, slice: text }
+  );
+}
+function scanJsonSlice(text, start, openChar) {
+  const closeChar = openChar === "{" ? "}" : "]";
   let depth = 0;
   let inString = false;
   let escape = false;
@@ -161,20 +223,248 @@ function parseJsonResponse(text) {
       }
     }
   }
-  if (end === -1) throw new SyntaxError("No JSON object/array found in LLM response");
-  return JSON.parse(text.slice(start, end + 1));
+  if (end === -1) return null;
+  return safeSlice(text, start, end + 1);
+}
+function containerAwareRepair(text, start, closeOnEvenParity) {
+  const stack = [];
+  let inString = false;
+  let stringRole = null;
+  let escape = false;
+  let i = start;
+  let out = "";
+  let bareQuoteCount = 0;
+  let bestFailed = null;
+  let escapes = 0;
+  let ambiguous = false;
+  let bestSuccess = null;
+  let attempts = 0;
+  function tryEmitCandidate(candidate) {
+    attempts++;
+    try {
+      bestSuccess = JSON.parse(candidate);
+      return true;
+    } catch (err) {
+      if (bestFailed === null) {
+        bestFailed = {
+          candidate,
+          position: extractParsePosition(err),
+          message: safeErrorToString(err)
+        };
+      }
+      return false;
+    }
+  }
+  while (i < text.length) {
+    const ch = text[i];
+    if (stack.length === 0 && !inString) {
+      if (ch === "{" || ch === "[") {
+        stack.push({ container: ch === "{" ? "object" : "array", expectKey: true });
+        out += ch;
+      }
+      i++;
+      continue;
+    }
+    if (escape) {
+      out += ch;
+      escape = false;
+      i++;
+      continue;
+    }
+    if (inString && ch === "\\") {
+      out += ch;
+      escape = true;
+      i++;
+      continue;
+    }
+    if (inString) {
+      const code = ch.charCodeAt(0);
+      if (code < 32) {
+        out += controlCharEscape(code);
+        i++;
+        continue;
+      }
+    }
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < text.length && (text[j] === " " || text[j] === "	" || text[j] === "\n" || text[j] === "\r")) {
+        j++;
+      }
+      const next = j < text.length ? text[j] : "";
+      if (!inString) {
+        if (next === "}" || next === "]") {
+          if (j > i + 1) out += text.slice(i + 1, j);
+          out += next;
+          i = j + 1;
+          stack.pop();
+          if (stack.length === 0) {
+            if (tryEmitCandidate(out)) return { success: bestSuccess, failed: bestFailed, escapes, ambiguous };
+            if (attempts >= MAX_REPAIR_CANDIDATES) break;
+            out = "";
+          }
+          continue;
+        }
+        const top = stack[stack.length - 1];
+        stringRole = top?.container === "object" && top.expectKey ? "key" : "value";
+        out += ch;
+        inString = true;
+        i++;
+        continue;
+      }
+      const commaOnly = next === ",";
+      const isKeyClose = stringRole === "key" && (next === ":" || next === '"' && j + 1 < text.length && text[j + 1] === ":");
+      const isValueClose = !commaOnly && (next === "," || next === "}" || next === "]");
+      if (commaOnly && bareQuoteCount > 0) ambiguous = true;
+      const shouldCommaClose = commaOnly && (bareQuoteCount === 0 || (closeOnEvenParity ? bareQuoteCount % 2 === 0 : bareQuoteCount % 2 === 1));
+      const isClosing = isKeyClose || isValueClose || shouldCommaClose;
+      if (isClosing) {
+        out += ch;
+        inString = false;
+        const topFrame = stack[stack.length - 1];
+        if (topFrame && topFrame.container === "object") {
+          topFrame.expectKey = stringRole === "value";
+        }
+        stringRole = null;
+        bareQuoteCount = 0;
+        i++;
+        continue;
+      }
+      out += "\\" + ch;
+      bareQuoteCount++;
+      escapes++;
+      i++;
+      continue;
+    }
+    if (!inString && (ch === "{" || ch === "[")) {
+      stack.push({ container: ch === "{" ? "object" : "array", expectKey: true });
+      out += ch;
+      i++;
+      continue;
+    }
+    if (!inString && ch === ",") {
+      const topFrame = stack[stack.length - 1];
+      if (topFrame && topFrame.container === "object") {
+        topFrame.expectKey = true;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (!inString && (ch === "}" || ch === "]")) {
+      out += ch;
+      stack.pop();
+      if (stack.length === 0) {
+        if (tryEmitCandidate(out)) return { success: bestSuccess, failed: bestFailed, escapes, ambiguous };
+        if (attempts >= MAX_REPAIR_CANDIDATES) break;
+        out = "";
+      }
+      i++;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return { success: null, failed: bestFailed, escapes, ambiguous };
+}
+function controlCharEscape(code) {
+  switch (code) {
+    case 10:
+      return "\\n";
+    case 9:
+      return "\\t";
+    case 13:
+      return "\\r";
+    case 8:
+      return "\\b";
+    case 12:
+      return "\\f";
+    default:
+      return "\\u" + code.toString(16).padStart(4, "0");
+  }
+}
+function extractParsePosition(err) {
+  const match = /position\s+(\d+)/.exec(safeErrorToString(err));
+  return match ? Number(match[1]) : null;
+}
+function safeErrorToString(e) {
+  let isErrorLike = false;
+  try {
+    isErrorLike = e instanceof Error;
+  } catch {
+  }
+  if (isErrorLike) {
+    const msg = readErrorField(e, "message");
+    if (typeof msg === "string" && msg.length > 0) return msg;
+    const name = readErrorField(e, "name");
+    if (typeof name === "string" && name.length > 0) return name;
+    return "[Error]";
+  }
+  try {
+    return String(e);
+  } catch {
+    try {
+      return Object.prototype.toString.call(e);
+    } catch {
+      return "[unstringifiable error]";
+    }
+  }
+}
+function readErrorField(e, key) {
+  try {
+    return e[key];
+  } catch {
+    return void 0;
+  }
 }
 function sanitizeRankerError(err, sanitizeRankerErrors) {
+  let isErrorLike = false;
+  try {
+    isErrorLike = err instanceof Error;
+  } catch {
+  }
   if (sanitizeRankerErrors === false) {
-    return err instanceof Error ? err : new Error(String(err));
+    return isErrorLike ? err : new Error(safeErrorToString(err));
+  }
+  let errLike = null;
+  if (isErrorLike) errLike = err;
+  let typeName;
+  try {
+    if (errLike) {
+      const rawName = errLike.constructor?.name;
+      typeName = typeof rawName === "string" ? rawName : "Error";
+    } else {
+      typeName = typeof err;
+    }
+  } catch {
+    typeName = isErrorLike ? "Error" : typeof err;
+  }
+  let innerCause;
+  if (errLike) {
+    let cause;
+    try {
+      cause = errLike.cause;
+    } catch {
+      cause = void 0;
+    }
+    if (cause !== void 0) {
+      let causeName;
+      try {
+        const rawCauseName = cause?.constructor?.name;
+        causeName = typeof rawCauseName === "string" ? rawCauseName : typeof cause;
+      } catch {
+        causeName = typeof cause;
+      }
+      innerCause = new Error(`Caused by: ${causeName}`);
+    }
   }
-  const typeName = err instanceof Error ? err.constructor?.name ?? "Error" : typeof err;
-  const innerCause = err instanceof Error && err.cause !== void 0 ? new Error(`Caused by: ${err.cause?.constructor?.name ?? typeof err.cause}`) : void 0;
   const sanitized = new Error(
     `VectorRanker ${typeName} (message scrubbed for security)`,
     innerCause ? { cause: innerCause } : void 0
   );
-  sanitized.name = typeName;
+  try {
+    sanitized.name = typeName;
+  } catch {
+  }
   return sanitized;
 }
 function safeSlice(value, start, end) {
@@ -969,7 +1259,7 @@ Return ONLY a valid JSON object matching this schema:
 {
   "facts": [{ "title": "string (max 80 chars)", "body": "string (max 800 chars)", "tags": ["string"], "confidence": "certain|inferred|tentative" }]
 }
-Extract verbatim factual content. Do not return markdown, just raw JSON.`;
+Extract verbatim factual content. JSON escaping rules: every literal " character in the source must be escaped as \\" inside any JSON string body, and every literal newline as \\n. Source prose containing quotes (e.g. a worked example with "...") must still be reproduced exactly \u2014 re-escape, do not omit. Do not return markdown, just raw JSON.`;
 var ONTOLOGY_BACKFILL_SYSTEM_PROMPT = `You are a knowledge classification agent. You will receive existing memory facts that currently have no ontology type. For each input fact { "id", "title", "body", "tags" }, assign the best matching okf_type from the ontology manifest and optionally propose edges to related facts by title.
 Return ONLY a valid JSON object matching this schema:
 {
@@ -978,7 +1268,7 @@ Return ONLY a valid JSON object matching this schema:
   ]
 }
 If no manifest type fits a fact, omit that fact from "classifications" entirely \u2014 do not guess.
-Do not return markdown, just raw JSON.`;
+When echoing an existing fact's title verbatim into "target_title", preserve every JSON escape sequence (\\", \\n, \\\\, \\/) exactly as it appeared in the input body \u2014 do not strip backslashes, do not add unescaped quotes. Do not return markdown, just raw JSON.`;
 
 // src/services/PromptService.ts
 var PromptService = class {
@@ -1091,6 +1381,16 @@ var DEFAULT_MAX_CHUNK_LENGTH = 12e3;
 var DEFAULT_CHUNK_OVERLAP = 400;
 
 // src/services/IngestionService.ts
+function zeroChunkResult(duplicateOf) {
+  const result = {
+    truncated: false,
+    chunks: 0,
+    ingestedChunks: 0,
+    failedChunks: 0
+  };
+  if (duplicateOf !== void 0) result.duplicateOf = duplicateOf;
+  return result;
+}
 var IngestionService = class {
   constructor(db, prefix, options, entryRepo, sourceRefIndexRepo, metadataRepo, edgeRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
     this.db = db;
@@ -1131,113 +1431,110 @@ var IngestionService = class {
           if (onDuplicateHash === "throw") {
             throw new WikiDuplicateHashError({ canonical, sourceHash, entityId });
           }
-          return { truncated: false, chunks: 0, duplicateOf: canonical };
+          return zeroChunkResult(canonical);
         }
       }
       const { chunks, truncated } = chunkText(params.documentChunk, maxChunkLength, chunkOverlap);
-      if (chunks.length === 0) return { truncated: false, chunks: 0 };
+      if (chunks.length === 0) return zeroChunkResult();
+      const ontologyContext = await this.ontologyService?.buildPromptContext(entityId) ?? null;
       const chunkResults = await withConcurrency(
-        chunks.map((chunk) => async () => {
-          const ontologyContext = await this.ontologyService?.buildPromptContext(entityId) ?? null;
+        chunks.map((chunk, chunkIndex) => async () => {
           const { systemPrompt, userPrompt } = this.promptService.buildIngestPrompt(
             chunk,
             params.promptOverride,
             ontologyContext
           );
-          const responseText = await this.options.llmProvider.generateText({ systemPrompt, userPrompt });
-          const result = parseJsonResponse(responseText);
-          return {
-            facts: (Array.isArray(result.facts) ? result.facts : []).map(validateFact).filter((f) => f !== null),
-            ontology_updates: result.ontology_updates
-          };
+          try {
+            const responseText = await this.options.llmProvider.generateText({ systemPrompt, userPrompt });
+            const result2 = parseJsonResponse(responseText);
+            return {
+              status: "ok",
+              facts: (Array.isArray(result2.facts) ? result2.facts : []).map(validateFact).filter((f) => f !== null),
+              ontology_updates: result2.ontology_updates
+            };
+          } catch (e) {
+            const failure = e instanceof WikiParseError ? {
+              chunkIndex,
+              sourceRef,
+              source: "parse",
+              tier: e.tier,
+              position: e.position,
+              message: e.message
+            } : {
+              chunkIndex,
+              sourceRef,
+              source: "llm",
+              // `safeErrorToString` is a non-throwing coercion: an LLM
+              // provider may reject with a non-Error value, and even
+              // `String(e)` itself can throw when `e.toString()` throws.
+              // Letting such an exception escape this catch would cause
+              // `withConcurrency` to reject, discarding every sibling
+              // chunk's results — the exact failure mode this per-chunk
+              // try/catch exists to prevent. Keeping the value in the
+              // `ChunkFailure` preserves the typed diagnostic for
+              // callers (see parseFailures) without unwinding the loop.
+              position: null,
+              message: safeErrorToString(e)
+            };
+            const total = chunks.length;
+            const tags = [];
+            if (failure.tier) tags.push(`tier=${failure.tier}`);
+            if (failure.position !== null) tags.push(`position=${failure.position}`);
+            const tagsSuffix = tags.length > 0 ? `; ${tags.join(" ")}` : "";
+            console.warn(
+              `[WikiMemory] ingest chunk ${chunkIndex + 1}/${total} ${failure.source} failed (sourceRef=${sourceRef}${tagsSuffix})`
+            );
+            return { status: "failed", error: failure };
+          }
         }),
         chunkConcurrency
       );
+      let ingestedChunks = 0;
+      let failedChunks = 0;
+      const failures = [];
       const seen = /* @__PURE__ */ new Set();
       const orderedChunkFacts = [];
-      for (const chunkResult of chunkResults) {
+      for (const slot of chunkResults) {
+        if (slot.status === "failed") {
+          failedChunks++;
+          failures.push(slot.error);
+          continue;
+        }
+        ingestedChunks++;
         const dedupedFacts = [];
-        for (const fact of chunkResult.facts) {
+        for (const fact of slot.facts) {
           const normalizedTitle = normalizeTitleKey(fact.title);
           if (!seen.has(normalizedTitle)) {
             seen.add(normalizedTitle);
             dedupedFacts.push(fact);
           }
         }
-        orderedChunkFacts.push({ facts: dedupedFacts, ontology_updates: chunkResult.ontology_updates });
+        orderedChunkFacts.push({ facts: dedupedFacts, ontology_updates: slot.ontology_updates });
+      }
+      if (failedChunks === chunks.length) {
+        throw new WikiIngestEmptyError({
+          parseFailures: failures,
+          sourceRef,
+          chunks: chunks.length
+        });
       }
-      const now = Date.now();
       const insertedFacts = [];
       const deletedSourceFactIds = [];
       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 });
-              }
-            }
-          }
-          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 });
-            }
-          }
-          await this.upsertGraphCore(
-            entityId,
-            { sourceRef, sourceHash, nodes: hostNodes, edges: hostEdges },
-            tx,
-            { strict: false }
-          );
-        });
+        if (failedChunks === 0) {
+          const fullResult = await this.db.withTransactionAsync(async (tx) => {
+            return await this.runFullUpsertGraph(entityId, sourceRef, sourceHash, orderedChunkFacts, tx);
+          });
+          deletedSourceFactIds.push(...fullResult.deletedSourceFactIds);
+          insertedFacts.push(...fullResult.insertedFacts);
+        } else {
+          const partialResult = await this.db.withTransactionAsync(async (tx) => {
+            const flat = [];
+            for (const slot of orderedChunkFacts) flat.push(...slot.facts);
+            return await this.appendPartialFacts(entityId, sourceRef, flat, tx);
+          });
+          insertedFacts.push(...partialResult.insertedDescriptors);
+        }
       } catch (err) {
         const sqliteCode = err instanceof WikiTransactionError ? err.sqliteErrorCode : extractSqliteCode(err);
         if (sqliteCode !== "SQLITE_CONSTRAINT_UNIQUE") throw err;
@@ -1246,22 +1543,31 @@ var IngestionService = class {
         if (onDuplicateHash === "throw" || onDuplicateHash === "ingest") {
           throw new WikiDuplicateHashError({ canonical, sourceHash, entityId });
         }
-        return { truncated: false, chunks: 0, duplicateOf: canonical };
+        return zeroChunkResult(canonical);
       }
       await this.searchService.sync(entityId);
-      const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
-      for (const factId of uniqueDeletedSourceFactIds) {
-        try {
-          await this.embeddingService.notifyEmbeddingPersisted(entityId, factId, null);
-        } catch (hookErr) {
-          console.warn(`[WikiMemory] onEmbeddingPersisted hook failed during ingest for ${factId}:`, hookErr);
+      if (failedChunks === 0) {
+        const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
+        for (const factId of uniqueDeletedSourceFactIds) {
+          try {
+            await this.embeddingService.notifyEmbeddingPersisted(entityId, factId, null);
+          } catch (hookErr) {
+            console.warn(`[WikiMemory] onEmbeddingPersisted hook failed during ingest for ${factId}:`, hookErr);
+          }
         }
       }
       for (const fact of insertedFacts) {
         await this.embeddingService.embedFact(fact);
       }
       this.searchService.evictCache(entityId);
-      return { truncated, chunks: chunks.length };
+      const result = {
+        truncated,
+        chunks: chunks.length,
+        ingestedChunks,
+        failedChunks
+      };
+      if (failedChunks > 0) result.parseFailures = failures;
+      return result;
     } finally {
       releaseIngestLocks();
     }
@@ -1386,6 +1692,156 @@ var IngestionService = class {
       superseded: deletedFactIds.length + deletedEdgeCount
     };
   }
+  /**
+   * Full supersession + ownership path: identical to the pre-issue-#92 behavior
+   * for the happy path. Called from the `failedChunks === 0` branch of
+   * `ingestDocument`. Runs INSIDE the caller's tx.
+   *
+   * Returns `{ deletedSourceFactIds, insertedFacts }` so the caller can fire
+   * post-commit hooks (embedding lifecycle) AFTER the transaction commits.
+   * On the partial path the caller never invokes this method; the empty
+   * arrays stay empty.
+   */
+  async runFullUpsertGraph(entityId, sourceRef, sourceHash, orderedChunkFacts, tx) {
+    const deletedSourceFactIds = [];
+    const insertedFacts = [];
+    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 = [];
+    const now = Date.now();
+    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 });
+        }
+      }
+    }
+    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 });
+      }
+    }
+    await this.upsertGraphCore(
+      entityId,
+      { sourceRef, sourceHash, nodes: hostNodes, edges: hostEdges },
+      tx,
+      { strict: false }
+    );
+    return { deletedSourceFactIds, insertedFacts };
+  }
+  /**
+   * Partial-commit path for `ingestDocument`. Inserts ONLY facts whose
+   * normalized title is not already in the live set for this (entityId,
+   * sourceRef). Does NOT call `entryRepo.softDeleteBySource` (no
+   * supersession) and does NOT call `sourceRefIndexRepo.upsert` (no
+   * ownership). Edges are NOT resolved on this path (no ontology-context
+   * build, no `resolveEdges`, no `mergeEmergentUpdates`). Stale edges from
+   * prior attempts are recovered on the next full run's supersession.
+   *
+   * Source-hash is stored as NULL on partial rows. `findLatestSourceHash`
+   * reads from the most recently updated live row for the sourceRef, so
+   * storing the incoming hash here would cause `hasChanged` to return
+   * `false` on a same-hash retry — the failed chunks would never get a
+   * second chance. With NULL, a retry sees `storedHash === null`, `hasChanged`
+   * returns `true`, and the partial commit's sibling rows remain live
+   * (deduped, not superseded) for the next attempt to extend.
+   *
+   * Runs INSIDE the caller's `tx`. Does not open a nested transaction.
+   * Returns `{ inserted, skippedDuplicate }` for observability.
+   */
+  async appendPartialFacts(entityId, sourceRef, dedupedFacts, tx) {
+    const liveIds = await this.entryRepo.findIdsBySource(entityId, sourceRef, null, tx, false);
+    const liveFacts = liveIds.length === 0 ? [] : await this.entryRepo.findByIds(liveIds, void 0, tx);
+    const liveTitles = new Set(liveFacts.map((f) => normalizeTitleKey(f.title)));
+    let inserted = 0;
+    let skippedDuplicate = 0;
+    const now = Date.now();
+    const insertedDescriptors = [];
+    for (const fact of dedupedFacts) {
+      const normalizedTitle = normalizeTitleKey(fact.title);
+      if (liveTitles.has(normalizedTitle)) {
+        skippedDuplicate++;
+        continue;
+      }
+      liveTitles.add(normalizedTitle);
+      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: null on partial rows — see method docstring. The
+        // full path stamps the actual hash; partial rows stay hash-less so
+        // `hasChanged` keeps returning true for retries.
+        source_hash: null,
+        source_ref: sourceRef,
+        created_at: now,
+        updated_at: now,
+        last_accessed_at: null,
+        access_count: 0,
+        deleted_at: null,
+        okf_type: null
+      };
+      await this.entryRepo.upsert(wikiFact, tx);
+      insertedDescriptors.push({
+        id,
+        entity_id: entityId,
+        title: fact.title,
+        body: fact.body,
+        tags: JSON.stringify(fact.tags)
+      });
+      inserted++;
+    }
+    return { inserted, skippedDuplicate, insertedDescriptors };
+  }
 };
 
 // src/utils/embedding.ts
@@ -1430,7 +1886,12 @@ var TRUNCATION_PATTERNS = [
 ];
 var EXCEEDS_LIMIT_PATTERN = /exceed[a-z]*[^.]{0,40}\b(model|context)?[ _-]?limit/i;
 function isTruncationError(err) {
-  const message = err instanceof Error ? err.message : String(err ?? "");
+  let message;
+  try {
+    message = err instanceof Error ? err.message : String(err ?? "");
+  } catch {
+    return false;
+  }
   if (EXCEEDS_LIMIT_PATTERN.test(message)) return false;
   return TRUNCATION_PATTERNS.some((pattern) => pattern.test(message));
 }
@@ -1534,6 +1995,30 @@ var HEAL_ANCHOR_SEARCH_OVERFETCH = 4;
 var HEAL_MAX_PROMPT_CHARS = 4e4;
 var HEAL_BATCH_SIZE = 25;
 var HEAL_RECHECK_MS = 7 * 24 * 60 * 60 * 1e3;
+var SKIP_ERROR_LOG_CHARS = 4096;
+var formatSkipError = (err) => {
+  let base;
+  let isErrorLike = false;
+  try {
+    isErrorLike = err instanceof Error;
+  } catch {
+  }
+  if (isErrorLike || typeof err !== "object" && typeof err !== "function") {
+    base = safeErrorToString(err);
+  } else {
+    try {
+      const json = JSON.stringify(err);
+      base = typeof json === "string" ? json : safeErrorToString(err);
+    } catch {
+      base = safeErrorToString(err);
+    }
+  }
+  if (base.length > SKIP_ERROR_LOG_CHARS) {
+    const truncated = safeSlice(base, 0, SKIP_ERROR_LOG_CHARS);
+    return `${truncated}\u2026[+${base.length - SKIP_ERROR_LOG_CHARS} chars truncated]`;
+  }
+  return base;
+};
 var MaintenanceService = class {
   constructor(db, prefix, options, entryRepo, sourceRefIndexRepo, taskRepo, eventRepo, metadataRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
     this.db = db;
@@ -2014,8 +2499,7 @@ var MaintenanceService = class {
       maxPromptChars: HEAL_MAX_PROMPT_CHARS,
       onSkip: (fact, err) => {
         console.warn(
-          `[WikiMemory] heal skipped ${entityId}/${fact.id}: response could not be bounded`,
-          err
+          `[WikiMemory] heal skipped ${entityId}/${fact.id}: response could not be bounded: ${formatSkipError(err)}`
         );
       }
     });
@@ -2153,8 +2637,7 @@ var MaintenanceService = class {
       maxPromptChars: ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS,
       onSkip: (fact, err) => {
         console.warn(
-          `[WikiMemory] ontology backfill skipped ${entityId}/${fact.id}: response could not be bounded`,
-          err
+          `[WikiMemory] ontology backfill skipped ${entityId}/${fact.id}: response could not be bounded: ${formatSkipError(err)}`
         );
       }
     });
@@ -2613,7 +3096,12 @@ var RetrievalService = class {
                   }
                 }
               } catch (rankerErr) {
-                const rankerError = rankerErr instanceof Error ? rankerErr : new Error(String(rankerErr));
+                let isErrorLike = false;
+                try {
+                  isErrorLike = rankerErr instanceof Error;
+                } catch {
+                }
+                const rankerError = isErrorLike ? rankerErr : new Error(safeErrorToString(rankerErr));
                 const policy = this.options.vectorRankerFallback ?? "js-cosine";
                 this.options.onVectorRankerFallback?.({
                   error: this._sanitizeRankerError(rankerError),
@@ -2725,12 +3213,21 @@ var RetrievalService = class {
             }
           }
         } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
+          let isErrorLike = false;
+          try {
+            isErrorLike = err instanceof Error;
+          } catch {
+          }
+          const error = isErrorLike ? err : new Error(safeErrorToString(err));
           if (rankerShouldRethrow) {
             throw error;
           }
           if (pendingRankerFallbackError) {
-            error.cause = pendingRankerFallbackError;
+            try {
+              error.cause = pendingRankerFallbackError;
+            } catch {
+              this.options.onRetrievalFallback?.(pendingRankerFallbackError);
+            }
             pendingRankerFallbackError = void 0;
           }
           this.options.onRetrievalFallback?.(error);