@remnic/core 10.0.38 → 10.0.40

package/src/buffer.ts

@@ -31,6 +31,9 @@ import {
 
 export type TriggerDecision = "extract_now" | "extract_batch" | "keep_buffering";
 
+export type { BufferSurpriseProbe } from "./buffer-types.js";
+import type { BufferSurpriseProbe, SurpriseTelemetryQueueEntry } from "./buffer-types.js";
+
 export interface AddTurnOutcome {
   decision: TriggerDecision;
   extractionTurns?: BufferTurn[];
@@ -46,33 +49,6 @@ export interface RetainedTurnCleanupOptions {
   codingContext?: import("./types.js").CodingContext;
 }
 
-/**
- * Optional surprise probe injected into `SmartBuffer`.
- *
- * Computes a D-MEM-style novelty score in `[0, 1]` for an incoming turn.
- * The buffer treats the probe as purely additive: if it is not provided, if
- * the feature flag is off, or if the probe throws/times out, the buffer
- * falls back to the existing signal/turn-count/time triggers unchanged.
- *
- * Callers are responsible for sampling recent memories and passing them
- * through the embedding pipeline — the buffer does not want to know about
- * storage, embeddings, or QMD.
- *
- * @param bufferKey Identifier for the active buffer (session/thread).
- * @param turn      The incoming turn whose novelty is being scored.
- * @param recentTurns Turns already buffered for this key (most recent first
- *                    is NOT guaranteed — treat as unordered corpus).
- * @returns A surprise score in `[0, 1]`, or `null` if no score could be
- *          produced (e.g. empty corpus, probe declined to embed).
- */
-export interface BufferSurpriseProbe {
-  scoreTurn(
-    bufferKey: string,
-    turn: BufferTurn,
-    recentTurns: readonly BufferTurn[],
-  ): Promise<number | null>;
-}
-
 const MAX_BUFFER_ENTRY_COUNT = 200;
 const isAcceptedTurn = (t: { acceptedCapture?: boolean; writeNamespaceOverride?: string }): boolean =>
   t.acceptedCapture === true || t.writeNamespaceOverride !== undefined;
@@ -96,41 +72,6 @@ const BUFFER_SAVE_MAX_DEFER_MULTIPLIER = 5;
  */
 const MAX_SET_TIMEOUT_MS = 2_147_483_647;
 
-/**
- * Minimal data carried on the serialized telemetry write chain
- * (issue #563 PR 3).
- *
- * We intentionally do NOT capture the full `BufferTurn` here: under
- * slow filesystem latency the chain can back up, and retaining
- * `turn.content` for every pending append causes memory pressure on
- * large conversations. Only the fields the ledger row actually needs
- * cross the chain boundary.
- */
-interface SurpriseTelemetryQueueEntry {
-  bufferKey: string;
-  turnRole: "user" | "assistant";
-  sessionKey: string | null;
-  surpriseScore: number;
-  triggered: boolean;
-  turnCountInWindow: number;
-  /**
-   * ISO timestamp captured at the moment the turn was scored, NOT when
-   * the ledger append eventually runs. Backpressure on the serialized
-   * write chain could otherwise shift event timestamps away from the
-   * real decision moment and distort the distribution report (p90
-   * inflated, current-threshold row misidentified).
-   */
-  timestamp: string;
-  /**
-   * Threshold value in force when `triggered` was computed. Must be
-   * snapshot here rather than read from `config` at emit time — a
-   * concurrent config change between queue and write would otherwise
-   * record `triggered=true` against a newer threshold the operator
-   * never set, distorting precision/recall interpretation.
-   */
-  threshold: number;
-}
-
 interface AddTurnMutationResult {
   decision: TriggerDecision;
   signalLevel: SignalLevel;
@@ -1148,6 +1089,63 @@ export class SmartBuffer {
     });
   }
 
+  /**
+   * Remove an extraction-window chunk from the buffer WITHOUT recording an
+   * extraction (trigger-drain drop path). Used when a chunk fails extraction
+   * repeatedly and must be dropped so the session can drain; the caller is
+   * responsible for the side-file copy and logging. Returns the number of
+   * live turns dropped; 0 when the turns no longer match. `allowNonPrefix`
+   * matches by identity, like `clearAfterExtraction`, for callers (native
+   * groups) whose chunk can sit behind a pinned capture.
+   */
+  async dropExtractionChunk(
+    bufferKey = "default",
+    turns: readonly BufferTurn[],
+    options?: { allowNonPrefix?: boolean },
+  ): Promise<number> {
+    return await this.enqueueMutation(async () => {
+      await this.loadUnlocked();
+      const entry = this.entryFor(bufferKey);
+      // A window's head can be deferred-retained turns (retainDeferredTurns): take those out of the chunk first.
+      const retained = [...(entry.retainedTurns ?? [])];
+      const liveTurns: BufferTurn[] = [];
+      for (const turn of turns) {
+        const at = retained.findIndex((kept) => bufferTurnsEqual(kept, turn));
+        if (at >= 0) retained.splice(at, 1);
+        else liveTurns.push(turn);
+      }
+      const retainedDropped = (entry.retainedTurns?.length ?? 0) - retained.length;
+      let remaining = entry.turns;
+      if (options?.allowNonPrefix === true) {
+        remaining = [...entry.turns];
+        for (const turn of liveTurns) {
+          const at = remaining.findIndex((live) => bufferTurnsEqual(live, turn));
+          if (at >= 0) remaining.splice(at, 1);
+        }
+      } else {
+        remaining = entry.turns.slice(matchingQueuedExtractionPrefixLength(entry.turns, liveTurns));
+      }
+      const matchedCount = entry.turns.length - remaining.length + retainedDropped;
+      if (matchedCount === 0) return 0;
+      if (this.saveTimer) {
+        clearTimeout(this.saveTimer);
+        this.saveTimer = null;
+      }
+      entry.turns = remaining;
+      if (retainedDropped > 0) {
+        if (retained.length > 0) entry.retainedTurns = retained;
+        else delete entry.retainedTurns;
+      }
+      if (bufferKey === "default") {
+        this.state.turns = entry.turns;
+      }
+      this.persistence.markDirty(bufferKey);
+      this.pruneEntries([bufferKey]);
+      await this.saveNowRetainingPendingOnFailure("dropExtractionChunk");
+      return matchedCount;
+    });
+  }
+
   getExtractionCount(bufferKey = "default"): number {
     return this.peekEntry(bufferKey)?.extractionCount ?? 0;
   }

package/src/chat/chat-executor.ts

@@ -60,7 +60,7 @@ export function createChatExecutor(bindings: ChatExecutorBindings): ChatToolExec
     },
 
     async entityGet(name: string): Promise<string> {
-      const result = await service.entityGet(name, namespace);
+      const result = await service.entityGet(name, namespace, principal);
       return JSON.stringify(result);
     },
 

package/src/config.ts

@@ -2868,6 +2868,14 @@ export function parseConfig(
     extractionBreakerAuthCooldownMs:
       typeof cfg.extractionBreakerAuthCooldownMs === "number" && cfg.extractionBreakerAuthCooldownMs >= 0
         ? cfg.extractionBreakerAuthCooldownMs : 1_800_000,
+    // Trigger-drain drop threshold: consecutive failed extraction attempts
+    // before the failing buffer chunk is dropped (side-file copied first).
+    extractionChunkDropAfterFailures: parseIntegerAtLeast(
+      cfg.extractionChunkDropAfterFailures,
+      5,
+      1,
+      "extractionChunkDropAfterFailures",
+    ),
     // Local LLM fast tier (v9.1)
     localLlmFastEnabled: cfg.localLlmFastEnabled === true,
     localLlmFastModel:

package/src/extraction-error-classification.ts

@@ -85,3 +85,26 @@ export function formatExtractionParseFailureLog(input: {
     `traceId=${input.traceId}`,
   ].join(" ");
 }
+
+/**
+ * The local endpoint answered, and what it said rejects this input (unusable content, or a client error that is not
+ * auth, timeout or rate limiting): the chunk's problem, not an outage. Retried like an empty parse, and a trigger-drain
+ * chunk that keeps drawing it is dropped after its recovery copy is saved.
+ */
+export class LocalLlmRejectedError extends Error {
+  constructor(readonly httpStatus?: number) {
+    super(httpStatus === undefined ? "local LLM answered with unusable content" : `local LLM rejected the input (HTTP ${httpStatus})`);
+    this.name = "LocalLlmRejectedError";
+  }
+}
+
+/** What the local client recorded about a failed call (`failureDiag`). */
+export interface LocalFailureDiag {
+  lastError?: unknown;
+}
+
+/** The HTTP status when the local endpoint answered and refuses this input (400, 413, 422); else undefined. A wrong model name or route (404, 405, 410), auth, timeout and rate limiting are the setup's problem, not the chunk's. */
+export function localRejectionStatus(diag: LocalFailureDiag): number | undefined {
+  const status = httpStatusFromError(diag.lastError);
+  return status !== undefined && [400, 413, 422].includes(status) ? status : undefined;
+}

package/src/extraction-local-failure-class.test.ts

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import { ExtractionEngine } from "./extraction.js";
+import type { BufferTurn } from "./types.js";
+
+// Follow-up to #3266: the trigger drain drops a chunk after N failures, but not for an outage. Whether a local-model failure
+// is the chunk's fault is decided here, by what the local endpoint did.
+const TURNS: BufferTurn[] = [
+  { role: "user", content: "I keep my backups on the NAS in the garage.", timestamp: "2026-10-30T01:00:00.000Z" },
+  { role: "assistant", content: "Noted.", timestamp: "2026-10-30T01:00:05.000Z" },
+];
+
+type LocalMessages = Array<{ role: string; content: string }>;
+type LocalStub = (messages: LocalMessages, options: { failureDiag?: { lastError?: Error } }) => Promise<{ content: string } | null>;
+
+async function extractWith(local: LocalStub) {
+  const engine = new ExtractionEngine(parseConfig({ localLlmEnabled: true, localLlmModel: "fixture-local", localLlmFallback: false }));
+  const modelRegistry = { calculateContextSizes: () => ({ maxInputChars: 8_000, maxOutputTokens: 1_000, description: "fixture" }) };
+  assert.equal(Reflect.set(engine, "localLlm", { chatCompletion: local }), true);
+  assert.equal(Reflect.set(engine, "modelRegistry", modelRegistry), true);
+  return await engine.extract(TURNS);
+}
+
+const withStatus = (status: number) => Object.assign(new Error("local LLM http failure"), { status });
+
+test("a local endpoint that answers with something unusable rejects the chunk: parse_empty", async () => {
+  const result = await extractWith(async () => ({ content: "I cannot help with that request." }));
+  assert.equal(result.extractionFailure, "local_llm_error");
+  assert.equal(result.extractionFailureClass, "parse_empty");
+});
+
+test("a local endpoint that answers with a client error rejects the chunk: parse_empty", async () => {
+  for (const status of [400, 413, 422]) {
+    const result = await extractWith(async (_messages, options) => {
+      if (options.failureDiag) options.failureDiag.lastError = withStatus(status);
+      return null;
+    });
+    assert.equal(result.extractionFailureClass, "parse_empty", `HTTP ${status}`);
+  }
+});
+
+test("not the chunk's fault: unreachable, timeout, 5xx, 429, auth and a wrong model or route (404) stay provider_retryable", async () => {
+  const outage = await extractWith(async () => null);
+  assert.equal(outage.extractionFailure, "local_llm_unavailable");
+  assert.equal(outage.extractionFailureClass, "provider_retryable");
+  for (const status of [401, 403, 404, 405, 408, 410, 429, 500, 503]) {
+    const result = await extractWith(async (_messages, options) => {
+      if (options.failureDiag) options.failureDiag.lastError = withStatus(status);
+      return null;
+    });
+    assert.equal(result.extractionFailureClass, "provider_retryable", `HTTP ${status}`);
+  }
+});

package/src/extraction-window-drain.test.ts

@@ -0,0 +1,123 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  chunkExtractionWindow,
+  classifyDrainResult,
+  extractionWindowBudgetChars,
+  mergeDrainResults,
+} from "./extraction-window-drain.js";
+import type { ExtractionRunResult } from "./orchestration/extraction-run.js";
+import type { BufferTurn } from "./types.js";
+
+function makeTurn(content: string, sessionKey = "s1"): BufferTurn {
+  return { role: "user", content, timestamp: "2026-10-29T00:00:00.000Z", sessionKey };
+}
+
+function skippedResult(reason: string): ExtractionRunResult {
+  return { status: "skipped", reason, persistedCount: 0, durableOutputCount: 0 };
+}
+
+test("chunkExtractionWindow returns a single chunk when the window fits the budget", () => {
+  const turns = [makeTurn("a".repeat(10)), makeTurn("b".repeat(10))];
+  const chunks = chunkExtractionWindow(turns, 100);
+  assert.equal(chunks.length, 1);
+  assert.deepEqual(chunks[0], turns);
+});
+
+test("chunkExtractionWindow splits an oversized window into budget-fitting chunks in order", () => {
+  const turns = [
+    makeTurn("a".repeat(60)),
+    makeTurn("b".repeat(60)),
+    makeTurn("c".repeat(60)),
+    makeTurn("d".repeat(60)),
+  ];
+  const chunks = chunkExtractionWindow(turns, 100);
+  assert.equal(chunks.length, 4);
+  for (const chunk of chunks) {
+    assert.ok(chunk.every((turn) => turn.content.length <= 100));
+  }
+  assert.deepEqual(
+    chunks.flat().map((turn) => turn.content[0]),
+    ["a", "b", "c", "d"],
+  );
+  assert.deepEqual(chunks.flat(), turns);
+});
+
+test("chunkExtractionWindow gives a single oversized turn its own chunk", () => {
+  const turns = [makeTurn("x".repeat(250)), makeTurn("y".repeat(10))];
+  const chunks = chunkExtractionWindow(turns, 100);
+  assert.equal(chunks.length, 2);
+  assert.equal(chunks[0]?.length, 1);
+  assert.equal(chunks[1]?.length, 1);
+});
+
+test("chunkExtractionWindow treats a non-positive budget as no chunking", () => {
+  const turns = [makeTurn("a".repeat(500)), makeTurn("b".repeat(500))];
+  assert.equal(chunkExtractionWindow(turns, 0).length, 1);
+  assert.equal(chunkExtractionWindow(turns, Number.POSITIVE_INFINITY).length, 1);
+});
+
+test("chunkExtractionWindow returns no chunks for an empty window", () => {
+  assert.deepEqual(chunkExtractionWindow([], 100), []);
+});
+
+test("classifyDrainResult treats completed runs and benign skips as drained", () => {
+  assert.equal(classifyDrainResult({ status: "completed", persistedCount: 1, durableOutputCount: 2 }), "drained");
+  assert.equal(classifyDrainResult(skippedResult("below_threshold")), "drained");
+  assert.equal(classifyDrainResult(skippedResult("cron_session")), "drained");
+  assert.equal(classifyDrainResult(skippedResult("empty_normalized_turns")), "drained");
+  assert.equal(classifyDrainResult(skippedResult("processed_fingerprint")), "drained");
+});
+
+test("classifyDrainResult reports breaker/backoff skips as deferred", () => {
+  assert.equal(classifyDrainResult(skippedResult("provider_circuit_open")), "deferred");
+  assert.equal(classifyDrainResult(skippedResult("extraction_backoff")), "deferred");
+});
+
+test("classifyDrainResult reports empty extraction results as failed", () => {
+  assert.equal(
+    classifyDrainResult({ ...skippedResult("empty_extraction_result"), retainedBuffer: true }),
+    "failed",
+    "an empty result that kept the window for retry is a chunk failure",
+  );
+  assert.equal(
+    classifyDrainResult(skippedResult("empty_extraction_result")),
+    "drained",
+    "an empty result that cleared its turns extracted fine and found nothing durable",
+  );
+});
+
+test("mergeDrainResults sums counts, completes when any chunk completes, keeps the last skip reason", () => {
+  const first = skippedResult("empty_extraction_result");
+  const second: ExtractionRunResult = { status: "completed", persistedCount: 3, durableOutputCount: 4 };
+  // A completed chunk means the drain made durable progress.
+  const merged = mergeDrainResults(mergeDrainResults(null, first), second);
+  assert.equal(merged.status, "completed");
+  assert.equal(merged.persistedCount, 3);
+  assert.equal(merged.durableOutputCount, 4);
+  // All chunks skipped: the aggregate stays skipped with the last reason.
+  const mergedFailed = mergeDrainResults(
+    mergeDrainResults(null, skippedResult("provider_circuit_open")),
+    first,
+  );
+  assert.equal(mergedFailed.status, "skipped");
+  assert.equal(mergedFailed.reason, "empty_extraction_result");
+  assert.equal(mergedFailed.persistedCount, 0);
+});
+
+test("extractionWindowBudgetChars applies the learned local window only when the local model extracts", () => {
+  const registry = { calculateContextSizes: () => ({ maxInputChars: 12_000 }) };
+  const base = { registry, model: "local-model", maxContext: undefined };
+
+  assert.equal(extractionWindowBudgetChars({ ...base, localExtractionActive: true }), 12_000);
+  assert.equal(
+    extractionWindowBudgetChars({ ...base, localExtractionActive: false }),
+    Number.POSITIVE_INFINITY,
+    "gateway or disabled local LLM: the local window does not describe the extractor",
+  );
+  assert.equal(
+    extractionWindowBudgetChars({ ...base, registry: undefined, localExtractionActive: true }),
+    Number.POSITIVE_INFINITY,
+    "no registry (legacy host or test double): no budget",
+  );
+});

package/src/extraction-window-drain.ts

@@ -0,0 +1,110 @@
+/**
+ * Trigger-drain helpers (extraction trigger stall fix).
+ *
+ * A session whose buffered window outgrows the extraction model's context
+ * never drains: the trigger fires `extract_batch` on every observe, the
+ * oversized request fails, nothing is cleared, and the window only grows.
+ * These helpers split such a window into budget-fitting chunks and classify
+ * each extraction run so the caller can drain successes, defer on breaker/
+ * backoff retention, and drop repeatedly failing chunks.
+ */
+
+import type { ExtractionRunResult } from "./orchestration/extraction-run.js";
+
+/**
+ * Split `turns` into chunks whose summed content length stays within
+ * `maxChars`. Chunks keep turn order and never split a turn; a single turn
+ * longer than the budget becomes its own chunk (the extraction prompt still
+ * clamps per-turn content). A non-positive or non-finite budget, or an empty
+ * window, yields at most one chunk (no chunking).
+ */
+export function chunkExtractionWindow<T extends { content: string }>(
+  turns: readonly T[],
+  maxChars: number,
+): T[][] {
+  if (turns.length === 0) return [];
+  const budget =
+    Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : Number.POSITIVE_INFINITY;
+  const chunks: T[][] = [];
+  let current: T[] = [];
+  let currentChars = 0;
+  for (const turn of turns) {
+    const turnChars = turn.content.length;
+    if (current.length > 0 && currentChars + turnChars > budget) {
+      chunks.push(current);
+      current = [];
+      currentChars = 0;
+    }
+    current.push(turn);
+    currentChars += turnChars;
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+}
+
+export type DrainVerdict = "drained" | "deferred" | "failed";
+
+/**
+ * Run results that deliberately RETAIN the buffer (provider breaker open,
+ * per-fingerprint backoff) are deferrals, not chunk failures — counting them
+ * would drop good content during a provider outage.
+ */
+const DRAIN_DEFERRAL_REASONS = {
+  provider_circuit_open: true,
+  extraction_backoff: true,
+};
+
+export function classifyDrainResult(result: ExtractionRunResult): DrainVerdict {
+  if (result.status !== "skipped") return "drained";
+  // An empty result is a failure only when the run kept the window for retry;
+  // otherwise it extracted fine, found nothing durable, and cleared its turns.
+  if (result.reason === "empty_extraction_result") {
+    return result.retainedBuffer === true ? "failed" : "drained";
+  }
+  if (result.reason !== undefined && result.reason in DRAIN_DEFERRAL_REASONS) return "deferred";
+  return "drained";
+}
+
+/**
+ * Combine chunk results into the single `ExtractionRunResult` the queue
+ * contract settles with: counts sum, any completed chunk completes the drain,
+ * and the last non-completed reason wins.
+ */
+export function mergeDrainResults(
+  previous: ExtractionRunResult | null,
+  next: ExtractionRunResult,
+): ExtractionRunResult {
+  if (previous === null) return next;
+  const completed = previous.status === "completed" || next.status === "completed";
+  const merged: ExtractionRunResult = {
+    status: completed ? "completed" : "skipped",
+    persistedCount: previous.persistedCount + next.persistedCount,
+    durableOutputCount: previous.durableOutputCount + next.durableOutputCount,
+  };
+  if (!completed) merged.reason = next.reason ?? previous.reason;
+  if (previous.postPersistMetadataFailed === true || next.postPersistMetadataFailed === true) {
+    merged.postPersistMetadataFailed = true;
+  }
+  return merged;
+}
+
+/** The slice of ModelRegistry the drain budget needs. */
+export interface WindowBudgetRegistry {
+  calculateContextSizes(modelId: string, maxContextOverride?: number): { maxInputChars: number };
+}
+
+/**
+ * Character budget for one extraction request. The learned local-model window
+ * only describes the extractor when the local LLM does the extracting; with a
+ * gateway extractor, a disabled local LLM, or no registry (legacy hosts, test
+ * doubles) there is no budget and the window runs in one request as before.
+ */
+export function extractionWindowBudgetChars(input: {
+  registry: WindowBudgetRegistry | undefined;
+  localExtractionActive: boolean;
+  model: string;
+  maxContext: number | undefined;
+}): number {
+  if (!input.registry || !input.localExtractionActive) return Number.POSITIVE_INFINITY;
+  return input.registry.calculateContextSizes(input.model, input.maxContext).maxInputChars;
+}

package/src/extraction.ts

@@ -38,7 +38,7 @@ import {
 import { applyGroundingWithConnector, headerConnector, renderExtractionConversation, resolveSourceConnector, type ExtractionGroundingContext } from "./source-agent-qualifier.js";
 import { isMemoryCategory } from "./write-envelope.js";
 export { classifyExtractionThrownError, classifyFallbackParseFailure, formatExtractionParseFailureLog } from "./extraction-error-classification.js";
-import { classifyExtractionThrownError, classifyFallbackParseFailure, formatExtractionParseFailureLog } from "./extraction-error-classification.js";
+import { LocalLlmRejectedError, classifyExtractionThrownError, classifyFallbackParseFailure, formatExtractionParseFailureLog, localRejectionStatus, type LocalFailureDiag } from "./extraction-error-classification.js";
 import { AMBIENT_CAPTURE_PROMPT_SECTION_COMPACT, clampAmbientCaptureConfidence } from "./ambient-provenance.js";
 import {
   CONSOLIDATION_RESPONSE_SCHEMA,
@@ -1244,7 +1244,7 @@ export class ExtractionEngine {
             entities: [],
             questions: [],
             extractionFailure: "local_llm_error",
-            extractionFailureClass: "provider_retryable",
+            extractionFailureClass: err instanceof LocalLlmRejectedError ? "parse_empty" : classifyExtractionThrownError(err),
           };
         }
         log.info("extraction: local LLM error, falling back to gateway default AI:", err);
@@ -1494,9 +1494,8 @@ ${extractionResponseShape(this.config.extraction?.spanMode ?? "off")}
 Conversation:
 ${truncatedConversation}`;
 
-    log.debug(
-      `extractWithLocalLlm: calling localLlm.chatCompletion with prompt length ${localPrompt.length}...`,
-    );
+    log.debug(`extractWithLocalLlm: calling localLlm.chatCompletion with prompt length ${localPrompt.length}...`);
+    const failureDiag: LocalFailureDiag = {};
     const response = await this.localLlm.chatCompletion(
       [
         { role: "system", content: "You are a memory extraction system. Output valid JSON only." },
@@ -1512,9 +1511,12 @@ ${truncatedConversation}`;
           : undefined,
         priority: "background",
         signal,
+        failureDiag,
       },
     );
     if (!response?.content) {
+      const rejected = localRejectionStatus(failureDiag);
+      if (rejected !== undefined) throw new LocalLlmRejectedError(rejected); // the endpoint is up and refuses this input
       log.debug("extractWithLocalLlm: chatCompletion returned null or empty content");
       return null;
     }
@@ -1547,12 +1549,10 @@ ${truncatedConversation}`;
     log.debug("extractWithLocalLlm: JSON parse failed, attempting partial extraction...");
     const partial = this.extractPartialFacts(content);
     if (partial.facts.length > 0 || partial.entities.length > 0) {
-      log.debug(
-        `extractWithLocalLlm: extracted ${partial.facts.length} partial facts from truncated JSON`,
-      );
+      log.debug(`extractWithLocalLlm: extracted ${partial.facts.length} partial facts from truncated JSON`);
       return partial;
     }
-    return null;
+    throw new LocalLlmRejectedError(); // the endpoint answered and nothing in the answer is usable
   }
 
   /**

package/src/namespaces/search.ts

@@ -700,7 +700,7 @@ export function normalizeQmdResultPath(resultPath: string, collection: string):
   }
   return value;
 }
-function resolveNamespaceResultPath(
+export function resolveNamespaceResultPath(
   memoryDir: string,
   collection: string,
   resultPath: string,