@remnic/core 9.69.39 → 9.69.41

package/src/deep-recall.ts

@@ -17,6 +17,7 @@ import { z } from "zod";
 import type { AbstractionNode } from "./abstraction-nodes.js";
 import type { CueAnchor } from "./cue-anchors.js";
 import { compareDeterministicStrings } from "./deterministic-order.js";
+import { abortError, isAbortError, raceAbort, throwIfAborted } from "./abort-error.js";
 import { extractJsonCandidates, stripCodeFences } from "./json-extract.js";
 import { rankDeepRecallFrontier } from "./recall-deep-frontier.js";
 import { selectExpandNodeIds } from "./recall-deep-expand-select.js";
@@ -94,8 +95,19 @@ export interface DeepRecallDeps {
   loadGraph(): Promise<DeepRecallGraphSnapshot>;
   /** Namespace-scoped memory-by-id read; null when absent from the caller's namespace (§30). */
   loadMemory(memoryId: string): Promise<DeepRecallMemoryView | null>;
-  /** Raw policy LLM output (JSON text); null when the call failed. */
+  /**
+   * Raw policy LLM output (JSON text); null when the call failed. The
+   * per-call timeout already spans both LLM legs (issue #2915).
+   */
   callPolicy(statePrompt: string, timeoutMs: number): Promise<string | null>;
+  /**
+   * Cancellation from the transport (MCP tools/call cancelled, HTTP client
+   * disconnected — issue #2915). Checked before every step and raced against
+   * every dependency call; an abort surfaces as a standard AbortError, which
+   * both transports already translate (silently end the dead socket / rethrow
+   * the cancellation) instead of a partial `ok: true` result.
+   */
+  signal?: AbortSignal;
   nowMs?(): number;
 }
 
@@ -121,28 +133,49 @@ class DeepRecallDeadlineExceeded extends Error {
 }
 
 /**
- * Race one dependency call against the SHARED whole-invocation deadline.
+ * Race one dependency call against the SHARED whole-invocation deadline AND
+ * the transport cancellation signal — one helper, never two nested races
+ * (issue #2915: an early abort return that abandons an already-started
+ * deadline timer leaves its eventual rejection unhandled).
  *
  * `deadlineMs` is an absolute instant computed once per invocation, so every
  * await subtracts elapsed time instead of restarting the budget, and a stalled
  * seed search, graph load, or memory read can no longer outlive the documented
  * `totalTimeoutMs` just because the deadline is only *checked* between steps.
- * An infinite deadline (`totalTimeoutMs: 0`, a documented disable value) passes
- * the work through untouched — no timer, no wrapper.
+ * An infinite deadline (`totalTimeoutMs: 0`, a documented disable value) races
+ * only the signal — no timer. The timer stays REFERENCED: it is the only thing
+ * keeping the loop alive when the awaited dependency never settles. Every
+ * arm is cleared in the `finally`, whichever wins.
  */
-async function withDeadline<T>(work: Promise<T>, deadlineMs: number, now: () => number): Promise<T> {
-  if (!Number.isFinite(deadlineMs)) return await work;
+async function guardCall<T>(
+  work: Promise<T>,
+  deadlineMs: number,
+  signal: AbortSignal | undefined,
+  now: () => number,
+): Promise<T> {
+  if (signal?.aborted) throw abortError("deep recall aborted");
+  if (!Number.isFinite(deadlineMs)) {
+    return await raceAbort(work, signal, "deep recall aborted");
+  }
   const remaining = deadlineMs - now();
   if (remaining <= 0) throw new DeepRecallDeadlineExceeded();
-  // The timer stays REFERENCED: it is the only thing keeping the loop alive
-  // when the awaited dependency never settles, which is precisely the case the
-  // deadline exists for. It is always cleared in the `finally`.
   const expiry = Promise.withResolvers<never>();
   const timer = setTimeout(() => expiry.reject(new DeepRecallDeadlineExceeded()), remaining);
+  let onAbort: (() => void) | undefined;
   try {
-    return await Promise.race([work, expiry.promise]);
+    const racers: Promise<T | never>[] = [work, expiry.promise];
+    if (signal) {
+      racers.push(
+        new Promise<never>((_resolve, reject) => {
+          onAbort = () => reject(abortError("deep recall aborted"));
+          signal.addEventListener("abort", onAbort, { once: true });
+        }),
+      );
+    }
+    return await Promise.race(racers);
   } finally {
     clearTimeout(timer);
+    if (signal && onAbort) signal.removeEventListener("abort", onAbort);
   }
 }
 
@@ -234,8 +267,11 @@ function nodeAddsNothing(node: AbstractionNode, workingSet: ReadonlyMap<string,
 /**
  * Frontier refresh (after every working-set change): for each working-set
  * memory, anchors whose nodeRefs include a node listing that memory make
- * every OTHER referenced node a frontier candidate. Ranked by the shared
- * pure helper (shared-anchor count desc, nodeId asc — total comparator).
+ * every OTHER referenced node a frontier candidate. `sharedAnchorCount`
+ * counts DISTINCT anchors (issue #2915): one anchor adds one no matter how
+ * many working-set memories or nodes reach the candidate through it. Ranked
+ * by the shared pure helper (shared-anchor count desc, nodeId asc — total
+ * comparator).
  *
  * Nodes in `expandedNodeIds` are dropped: a node EXPAND already followed is
  * not an unretrieved candidate, even when some of its source memories never
@@ -251,7 +287,10 @@ function refreshFrontier(
   const index = graph.index;
   interface Candidate {
     nodeId: string;
-    sharedAnchorCount: number;
+    // Distinct shared anchors ONLY (issue #2915): one anchor counts once no
+    // matter how many working-set memories reach the candidate through it,
+    // so a candidate sharing one anchor can never outrank one sharing two.
+    sharedAnchorIds: Set<string>;
     parentMemoryId: string;
     parentScore: number;
     anchorValue: string;
@@ -268,22 +307,32 @@ function refreshFrontier(
           const otherNode = index.nodeIdToNode.get(otherNodeRef);
           if (!otherNode || nodeAddsNothing(otherNode, workingSet)) continue;
           const current = byNodeId.get(otherNodeRef);
-          if (current === undefined || entry.score > current.parentScore) {
+          if (current === undefined) {
             byNodeId.set(otherNodeRef, {
               nodeId: otherNodeRef,
-              sharedAnchorCount: (current?.sharedAnchorCount ?? 0) + 1,
+              sharedAnchorIds: new Set([anchorId]),
               parentMemoryId: memoryId,
               parentScore: entry.score,
               anchorValue: anchor.anchorValue,
             });
           } else {
-            current.sharedAnchorCount += 1;
+            current.sharedAnchorIds.add(anchorId);
+            if (entry.score > current.parentScore) {
+              current.parentMemoryId = memoryId;
+              current.parentScore = entry.score;
+              current.anchorValue = anchor.anchorValue;
+            }
           }
         }
       }
     }
   }
-  const ranked = rankDeepRecallFrontier([...byNodeId.values()]);
+  const ranked = rankDeepRecallFrontier(
+    [...byNodeId.values()].map((candidate) => ({
+      nodeId: candidate.nodeId,
+      sharedAnchorCount: candidate.sharedAnchorIds.size,
+    })),
+  );
   return ranked.flatMap((rankedCandidate) => {
     const candidate = byNodeId.get(rankedCandidate.nodeId);
     const node = index.nodeIdToNode.get(rankedCandidate.nodeId);
@@ -363,6 +412,14 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
   const now = deps.nowMs ?? Date.now;
   const startedMs = now();
   const deadlineMs = cfg.totalTimeoutMs > 0 ? startedMs + cfg.totalTimeoutMs : Number.POSITIVE_INFINITY;
+  // Every dependency await races BOTH bounds: the shared whole-invocation
+  // deadline and the transport cancellation signal (issue #2915). An abort
+  // propagates as a standard AbortError — never as ok:false backend failure
+  // and never as a partial result — so each transport applies its own
+  // cancelled-response semantics.
+  const guarded = <T>(work: Promise<T>): Promise<T> =>
+    guardCall(work, deadlineMs, deps.signal, now);
+
 
   const trace: DeepRecallTraceStep[] = [];
   const contentCache = new Map<string, string>();
@@ -378,7 +435,7 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
    * would surface content the active-set check excluded.
    */
   const hydrateOrDrop = async (memoryId: string): Promise<void> => {
-    const memory = await withDeadline(deps.loadMemory(memoryId), deadlineMs, now);
+    const memory = await guarded(deps.loadMemory(memoryId));
     if (!memory || !memory.active) {
       workingSet.delete(memoryId);
       contentCache.delete(memoryId);
@@ -393,9 +450,11 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
   // working set rather than blocking the later check from ever running.
   let exhaustedDetail: string | null = null;
   try {
-    const seedHits = await withDeadline(deps.searchSeed(query, cfg.maxResults), deadlineMs, now);
+    throwIfAborted(deps.signal, "deep recall aborted");
+    const seedHits = await guarded(deps.searchSeed(query, cfg.maxResults));
     mergeIntoWorkingSet(workingSet, seedHits, "seed", contentFor);
   } catch (err) {
+    if (isAbortError(err)) throw err;
     if (!(err instanceof DeepRecallDeadlineExceeded)) {
       // Seed backend failure is the only ok:false path (§22: an empty index
       // proceeds; a thrown search does not).
@@ -405,13 +464,14 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
   }
   if (exhaustedDetail === null) {
     try {
-      graph = { index: buildFrontierIndex(await withDeadline(deps.loadGraph(), deadlineMs, now)) };
+      graph = { index: buildFrontierIndex(await guarded(deps.loadGraph())) };
       // Seed hydration also enforces the active set: a stale or non-active
       // QMD hit leaves the working set instead of being hydrated in place.
       for (const memoryId of [...workingSet.keys()]) {
         await hydrateOrDrop(memoryId);
       }
     } catch (err) {
+      if (isAbortError(err)) throw err;
       if (!(err instanceof DeepRecallDeadlineExceeded)) throw err;
       exhaustedDetail = "total timeout reached loading the graph or hydrating seeds";
     }
@@ -447,6 +507,7 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
   try {
     while (exhaustedDetail === null && cfg.maxSteps > 0 && step < cfg.maxSteps) {
       const stepStartMs = now();
+      throwIfAborted(deps.signal, "deep recall aborted");
       if (now() >= deadlineMs) {
         pushStep(step, "BUDGET_EXHAUSTED", "total timeout reached before policy call", stepStartMs);
         break;
@@ -459,13 +520,11 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
       const stepBudgetMs = cfg.stepTimeoutMs > 0 ? cfg.stepTimeoutMs : Number.POSITIVE_INFINITY;
       const effectiveBudgetMs = Math.min(stepBudgetMs, deadlineMs - now());
       const timeoutMs = Number.isFinite(effectiveBudgetMs) ? Math.max(1, effectiveBudgetMs) : 0;
-      const raw = await withDeadline(
+      const raw = await guarded(
         deps.callPolicy(
           renderStatePrompt({ query: currentQuery, workingSet, frontier, stepsRemaining: cfg.maxSteps - step }),
           timeoutMs
-        ),
-        deadlineMs,
-        now
+        )
       );
       const parsed = parsePolicyOutput(raw);
       if (parsed === null) {
@@ -489,7 +548,7 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
         currentQuery = rewrite.refinedQuery;
         refinesUsed += 1;
         try {
-          const refinedHits = await withDeadline(deps.searchSeed(currentQuery, cfg.maxResults), deadlineMs, now);
+          const refinedHits = await guarded(deps.searchSeed(currentQuery, cfg.maxResults));
           mergeIntoWorkingSet(workingSet, refinedHits, "refine", contentFor);
           for (const hit of refinedHits) {
             if (workingSet.has(hit.memoryId) && !contentCache.has(hit.memoryId)) {
@@ -499,8 +558,9 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
         } catch (err) {
           // Re-search failure mid-loop is partial, not fatal (§22): the loop
           // keeps what it has and the policy decides the next move. Deadline
-          // expiry is NOT a partial failure — it ends the invocation.
-          if (err instanceof DeepRecallDeadlineExceeded) throw err;
+          // expiry and cancellation are NOT partial failures — they end the
+          // invocation.
+          if (err instanceof DeepRecallDeadlineExceeded || isAbortError(err)) throw err;
         }
         frontier = refreshFrontier(workingSet, graph, expandedNodeIds);
         pushStep(step, "REFINE", currentQuery, stepStartMs);
@@ -528,7 +588,7 @@ export async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string)
         if (!item || !node) continue;
         for (const memoryId of (node.sourceMemoryIds ?? []).slice(0, MAX_SOURCE_MEMORY_IDS_PER_NODE)) {
           if (workingSet.has(memoryId)) continue;
-          const memory = await withDeadline(deps.loadMemory(memoryId), deadlineMs, now);
+          const memory = await guarded(deps.loadMemory(memoryId));
           // Only active memories enter the working set (§41); a null read
           // (foreign namespace, §30) skips the same way.
           if (!memory || !memory.active) continue;

package/src/extraction-error-classification.ts

@@ -39,14 +39,49 @@ export function classifyExtractionThrownError(err: unknown): ExtractionFailureCl
  * genuine empty-parse.
  */
 export function classifyFallbackParseFailure(
-  reason: "no_models" | "empty" | "http_error",
+  reason: "no_models" | "empty" | "http_error" | "schema_rejection" | "timeout",
 ): ExtractionFailureClass {
   switch (reason) {
     case "no_models":
       return "auth_config";
     case "http_error":
+    case "timeout":
       return "provider_retryable";
     case "empty":
+    case "schema_rejection":
       return "parse_empty";
   }
 }
+
+/**
+ * Operator-visible extraction parse-failure line. Keeps the historical
+ * greppable prefix and appends the fields that used to live only at debug.
+ */
+export function formatExtractionParseFailureLog(input: {
+  failureReason: string;
+  attemptedModel?: string;
+  httpStatus?: number;
+  errorClass?: string;
+  traceId: string;
+}): string {
+  const modelUsed =
+    typeof input.attemptedModel === "string" && input.attemptedModel.length > 0
+      ? input.attemptedModel
+      : "unknown";
+  const errorClass =
+    typeof input.errorClass === "string" && input.errorClass.length > 0
+      ? input.errorClass
+      : "none";
+  const httpStatus =
+    typeof input.httpStatus === "number" && Number.isFinite(input.httpStatus)
+      ? String(input.httpStatus)
+      : "none";
+  return [
+    "extraction fallback returned no parsed output",
+    `failureReason=${input.failureReason}`,
+    `modelUsed=${modelUsed}`,
+    `errorClass=${errorClass}`,
+    `httpStatus=${httpStatus}`,
+    `traceId=${input.traceId}`,
+  ].join(" ");
+}

package/src/extraction-timeout.test.ts

@@ -3,7 +3,9 @@ import test from "node:test";
 
 import { parseConfig } from "./config.js";
 import { ExtractionEngine } from "./extraction.js";
-import type { BufferTurn } from "./types.js";
+import { initLogger, resetLogger } from "./logger.js";
+import type { BufferTurn, ExtractionFailureClass, LlmTraceEvent } from "./types.js";
+import type { StructuredParseFailure } from "./fallback-llm.js";
 
 test("gateway extraction fallback honors configured timeout and output budget", async () => {
   const config = parseConfig({
@@ -320,3 +322,110 @@ test("gateway extraction forwards caller cancellation to the provider", async ()
   controller.abort(new Error("deadline"));
   await assert.rejects(extraction, /deadline/);
 });
+
+function gatewayConfig() {
+  return {
+    modelSource: "gateway" as const,
+    gatewayConfig: {
+      agents: {
+        defaults: { model: { primary: "bench-internal/gpt-5.5" } },
+        list: [],
+      },
+      models: {
+        providers: {
+          "bench-internal": {
+            api: "codex-cli" as const,
+            baseUrl: "codex-cli://local",
+            models: [{ id: "gpt-5.5", name: "gpt-5.5" }],
+          },
+        },
+      },
+    },
+  };
+}
+
+const RETRYABLE: ReadonlySet<ExtractionFailureClass> = new Set([
+  "provider_retryable",
+  "parse_empty",
+  "auth_config",
+]);
+
+test("extraction warn and llm_error keep failure classes distinct and fingerprints retryable", async () => {
+  const cases: Array<{
+    failure: StructuredParseFailure;
+    expectedClass: ExtractionFailureClass;
+  }> = [
+    {
+      failure: { result: null, failureReason: "empty", attemptedModel: "bench-internal/gpt-5.5", errorClass: "empty" },
+      expectedClass: "parse_empty",
+    },
+    {
+      failure: {
+        result: null,
+        failureReason: "schema_rejection",
+        attemptedModel: "bench-internal/gpt-5.5",
+        errorClass: "schema_rejection",
+      },
+      expectedClass: "parse_empty",
+    },
+    {
+      failure: {
+        result: null,
+        failureReason: "http_error",
+        attemptedModel: "bench-internal/gpt-5.5",
+        httpStatus: 502,
+        errorClass: "http_5xx",
+      },
+      expectedClass: "provider_retryable",
+    },
+    {
+      failure: { result: null, failureReason: "timeout", errorClass: "timeout" },
+      expectedClass: "provider_retryable",
+    },
+  ];
+
+  for (const { failure, expectedClass } of cases) {
+    const warns: string[] = [];
+    const events: LlmTraceEvent[] = [];
+    initLogger({ info() {}, warn(msg) { warns.push(msg); }, error() {} }, false, { timestamps: false });
+    (globalThis as { __openclawEngramTrace?: (event: LlmTraceEvent) => void }).__openclawEngramTrace = (event) => {
+      events.push(event);
+    };
+    try {
+      const engine = new ExtractionEngine(parseConfig(gatewayConfig()));
+      (engine as unknown as {
+        fallbackLlm: {
+          parseWithSchemaDetailed(): Promise<StructuredParseFailure>;
+        };
+      }).fallbackLlm = {
+        async parseWithSchemaDetailed() {
+          return failure;
+        },
+      };
+      const result = await engine.extract([
+        { role: "user", content: "Remember that the depot is cedar hall.", timestamp: "2026-05-08T00:00:00.000Z" },
+      ]);
+      assert.equal(result.extractionFailure, "fallback_no_parsed_output");
+      assert.equal(result.extractionFailureClass, expectedClass);
+      assert.equal(RETRYABLE.has(result.extractionFailureClass ?? "provider_retryable"), true);
+      const warn = warns.find((line) => line.includes("extraction fallback returned no parsed output"));
+      assert.ok(warn, `missing warn for ${failure.failureReason}`);
+      assert.match(warn, new RegExp(`failureReason=${failure.failureReason}`));
+      assert.match(warn, /modelUsed=/);
+      assert.match(warn, /errorClass=/);
+      assert.match(warn, /httpStatus=/);
+      assert.match(warn, /traceId=/);
+      if (failure.httpStatus !== undefined) {
+        assert.match(warn, new RegExp(`httpStatus=${failure.httpStatus}`));
+      }
+      const errorEvent = events.find((event) => event.kind === "llm_error");
+      assert.ok(errorEvent, `missing llm_error for ${failure.failureReason}`);
+      assert.match(errorEvent.error ?? "", new RegExp(`failureReason=${failure.failureReason}`));
+      assert.match(errorEvent.error ?? "", /traceId=/);
+      assert.equal(errorEvent.traceId.length > 0, true);
+    } finally {
+      resetLogger();
+      delete (globalThis as { __openclawEngramTrace?: unknown }).__openclawEngramTrace;
+    }
+  }
+});

package/src/extraction.test.ts

@@ -10,7 +10,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { classifyExtractionThrownError, classifyFallbackParseFailure } from "./extraction.js";
+import { classifyExtractionThrownError, classifyFallbackParseFailure, formatExtractionParseFailureLog } from "./extraction.js";
 
 test("classifyExtractionThrownError: 401/403 → auth_config", () => {
   assert.equal(classifyExtractionThrownError({ status: 401 }), "auth_config");
@@ -36,4 +36,22 @@ test("classifyFallbackParseFailure: maps the gateway parse-failure reasons", ()
   assert.equal(classifyFallbackParseFailure("no_models"), "auth_config");
   assert.equal(classifyFallbackParseFailure("http_error"), "provider_retryable");
   assert.equal(classifyFallbackParseFailure("empty"), "parse_empty");
+  assert.equal(classifyFallbackParseFailure("schema_rejection"), "parse_empty");
+  assert.equal(classifyFallbackParseFailure("timeout"), "provider_retryable");
+});
+
+test("formatExtractionParseFailureLog keeps the greppable prefix and distinct fields", () => {
+  const line = formatExtractionParseFailureLog({
+    failureReason: "http_error",
+    attemptedModel: "openai/test-model",
+    httpStatus: 502,
+    errorClass: "http_5xx",
+    traceId: "trace-1",
+  });
+  assert.match(line, /^extraction fallback returned no parsed output /);
+  assert.match(line, /failureReason=http_error/);
+  assert.match(line, /modelUsed=openai\/test-model/);
+  assert.match(line, /errorClass=http_5xx/);
+  assert.match(line, /httpStatus=502/);
+  assert.match(line, /traceId=trace-1/);
 });

package/src/extraction.ts

@@ -38,7 +38,8 @@ import {
 } from "./extraction-source-grounding.js";
 import { applyGroundingWithConnector, headerConnector, renderExtractionConversation, resolveSourceConnector, type ExtractionGroundingContext } from "./source-agent-qualifier.js";
 import { isMemoryCategory } from "./write-envelope.js";
-import { classifyExtractionThrownError, classifyFallbackParseFailure } from "./extraction-error-classification.js";
+export { classifyExtractionThrownError, classifyFallbackParseFailure, formatExtractionParseFailureLog } from "./extraction-error-classification.js";
+import { classifyExtractionThrownError, classifyFallbackParseFailure, formatExtractionParseFailureLog } from "./extraction-error-classification.js";
 import { AMBIENT_CAPTURE_PROMPT_SECTION_COMPACT, clampAmbientCaptureConfidence } from "./ambient-provenance.js";
 import {
   CONSOLIDATION_RESPONSE_SCHEMA,
@@ -53,22 +54,8 @@ import {
   spanModePromptSection,
 } from "./extraction-prompt.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import {
-  containsExtractionPlaceholder,
-  extractionAttributes,
-  extractionCueAnchors,
-  extractionText,
-  isPlainRecord,
-} from "./extraction-normalization.js";
-export { classifyExtractionThrownError, classifyFallbackParseFailure } from "./extraction-error-classification.js";
-import {
-  applyExtractionSpanMaterialization,
-  bindLocalExtractionPrompt,
-  buildSpanMaterializeTurns,
-  stripUntrustedFactSpans,
-  truncateLocalExtractionConversation,
-  type SpanMaterializeTurn,
-} from "./extraction-span-materialize.js";
+import { containsExtractionPlaceholder, extractionAttributes, extractionCueAnchors, extractionText, isPlainRecord } from "./extraction-normalization.js";
+import { applyExtractionSpanMaterialization, bindLocalExtractionPrompt, buildSpanMaterializeTurns, stripUntrustedFactSpans, truncateLocalExtractionConversation, type SpanMaterializeTurn } from "./extraction-span-materialize.js";
 import { resolveLocalLlmCapabilities, resolveMemoryLifecycleCapabilities, resolvePipelineProcessingCapabilities, resolveRecallAuxiliaryCapabilities } from "./capabilities.js";
 type ExtractionQuestion = ExtractionResult["questions"][number];
 type ExtractedFactResult = ExtractionResult["facts"][number];
@@ -1363,7 +1350,7 @@ export class ExtractionEngine {
         this.withGatewayAgent({
           temperature: 0.3,
           maxTokens: this.config.extractionMaxOutputTokens,
-          timeoutMs: this.config.localLlmTimeoutMs,
+          timeoutMs: this.config.taskLlmTimeoutMs ?? this.config.localLlmTimeoutMs,
           jsonSchema: {
             name: "extraction_result",
             schema: EXTRACTION_PROVIDER_JSON_SCHEMA,
@@ -1391,11 +1378,26 @@ export class ExtractionEngine {
         return this.finalizeExtractionResult(finalResult, boundedTurns, resolvedConnector, ambientCapture);
       }
 
+      const parseFailure =
+        detailed.result === null
+          ? detailed
+          : { failureReason: "empty" as const, attemptedModel: undefined, httpStatus: undefined, errorClass: "empty" };
+      const failureLog = formatExtractionParseFailureLog({
+        failureReason: parseFailure.failureReason,
+        attemptedModel: parseFailure.attemptedModel,
+        httpStatus: parseFailure.httpStatus,
+        errorClass: parseFailure.errorClass,
+        traceId: fallbackTraceId,
+      });
       this.emit({
-        kind: "llm_error", traceId: fallbackTraceId, model: "fallback", operation: "extraction",
-        durationMs: fallbackDurationMs, error: "fallback returned no parsed output",
+        kind: "llm_error",
+        traceId: fallbackTraceId,
+        model: parseFailure.attemptedModel ?? "fallback",
+        operation: "extraction",
+        durationMs: fallbackDurationMs,
+        error: failureLog,
       });
-      log.warn("extraction fallback returned no parsed output");
+      log.warn(failureLog);
       const fallbackParseFailureClass: ExtractionFailureClass =
         detailed.result === null
           ? detailed.failureReason === "no_models" && primaryExtractorAttempted