@remnic/core 9.69.38 → 9.69.40

package/src/config.test.ts

@@ -2724,21 +2724,88 @@ test("parseConfig coerces string-typed sharedContextAllowBindingAuthority from t
     );
   }
 });
+test("parseConfig coerces string-typed sharedContextEnabled from the CLI", () => {
+  // `--config sharedContextEnabled=true` arrives as a string, so a strict
+  // `=== true` silently left the feature off for anyone who enabled it.
+  // Parity with sharedContextAllowBindingAuthority (issue #2918).
+  // The default recall-pipeline shared-context gate must use the same
+  // coerced boolean — string true with no custom pipeline enables the
+  // section; false/malformed stay off.
+  for (const enabled of ["true", "1", "yes", "on", true]) {
+    const parsed = parseConfig({ sharedContextEnabled: enabled });
+    assert.equal(
+      parsed.sharedContextEnabled,
+      true,
+      `${JSON.stringify(enabled)} must enable shared context`,
+    );
+    assert.equal(
+      parsed.recallPipeline.find((section) => section.id === "shared-context")?.enabled,
+      true,
+      `${JSON.stringify(enabled)} must enable the default shared-context section`,
+    );
+  }
+  for (const disabled of ["false", "0", "no", "off", false, undefined, "", "garbage"]) {
+    const parsed = parseConfig({ sharedContextEnabled: disabled });
+    assert.equal(
+      parsed.sharedContextEnabled,
+      false,
+      `${JSON.stringify(disabled)} must leave shared context off (malformed input never activates)`,
+    );
+    assert.equal(
+      parsed.recallPipeline.find((section) => section.id === "shared-context")?.enabled,
+      false,
+      `${JSON.stringify(disabled)} must leave the default shared-context section off`,
+    );
+  }
+});
+
+test("custom recallPipeline keeps operator shared-context enabled (#2918)", () => {
+  const customOff = parseConfig({
+    sharedContextEnabled: "true",
+    recallPipeline: [{ id: "shared-context", enabled: false, maxChars: 1000 }],
+  });
+  assert.equal(customOff.sharedContextEnabled, true);
+  assert.equal(
+    customOff.recallPipeline.find((section) => section.id === "shared-context")?.enabled,
+    false,
+    "custom pipeline must not silently activate shared-context",
+  );
+
+  const customOn = parseConfig({
+    sharedContextEnabled: "false",
+    recallPipeline: [{ id: "shared-context", enabled: true, maxChars: 1000 }],
+  });
+  assert.equal(customOn.sharedContextEnabled, false);
+  assert.equal(
+    customOn.recallPipeline.find((section) => section.id === "shared-context")?.enabled,
+    true,
+    "custom pipeline enabled stays as specified",
+  );
+});
 
-test("parseConfig consumes backgroundGeneration and leaves openaiBaseUrl untouched", () => {
+
+test("parseConfig consumes llmBridgeClientConfigPath into backgroundGeneration only", () => {
   withIsolatedConnectorsDir(false, () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "remnic-llm-bridge-client-"));
     const previousKey = process.env.OPENAI_API_KEY;
     const previousBase = process.env.OPENAI_BASE_URL;
     delete process.env.OPENAI_API_KEY;
     delete process.env.OPENAI_BASE_URL;
     try {
-      const parsed = parseConfig({
-        backgroundGeneration: {
+      const file = path.join(dir, "client.json");
+      writeFileSync(
+        file,
+        JSON.stringify({
           endpoint: "http://127.0.0.1:8765/v1/chat/completions",
+          health_endpoint: "http://127.0.0.1:8765/healthz",
+          bind: "127.0.0.1",
+          model_policy: "server-owned",
+          max_body_bytes: 524288,
+          timeout_seconds: 120,
           token: "bridge-token-fixture",
-          timeoutSeconds: 120,
-        },
-      });
+        }),
+      );
+      const parsed = parseConfig({ llmBridgeClientConfigPath: file });
       assert.equal(parsed.openaiBaseUrl, undefined);
       assert.equal(parsed.openaiApiKey, undefined);
       assert.deepEqual(parsed.backgroundGeneration, {
@@ -2748,11 +2815,7 @@ test("parseConfig consumes backgroundGeneration and leaves openaiBaseUrl untouch
       });
 
       const explicitOpenAi = parseConfig({
-        backgroundGeneration: {
-          endpoint: "http://127.0.0.1:8765/v1/chat/completions",
-          token: "bridge-token-fixture",
-          timeoutSeconds: 120,
-        },
+        llmBridgeClientConfigPath: file,
         openaiBaseUrl: "http://127.0.0.1:9999/v1",
         openaiApiKey: "keep-me",
       });
@@ -2762,65 +2825,78 @@ test("parseConfig consumes backgroundGeneration and leaves openaiBaseUrl untouch
         explicitOpenAi.backgroundGeneration?.endpoint,
         "http://127.0.0.1:8765/v1/chat/completions",
       );
+
+      const explicitBg = parseConfig({
+        backgroundGeneration: {
+          endpoint: "http://127.0.0.1:8765/v1/chat/completions",
+          token: "explicit-token",
+          timeoutSeconds: 30,
+        },
+      });
+      assert.equal(explicitBg.openaiBaseUrl, undefined);
+      assert.deepEqual(explicitBg.backgroundGeneration, {
+        endpoint: "http://127.0.0.1:8765/v1/chat/completions",
+        token: "explicit-token",
+        timeoutSeconds: 30,
+      });
     } finally {
       if (previousKey === undefined) delete process.env.OPENAI_API_KEY;
       else process.env.OPENAI_API_KEY = previousKey;
       if (previousBase === undefined) delete process.env.OPENAI_BASE_URL;
       else process.env.OPENAI_BASE_URL = previousBase;
+      rmSync(dir, { recursive: true, force: true });
     }
   });
 });
 
-test("parseConfig ignores llmBridgeClientConfigPath", () => {
-  withIsolatedConnectorsDir(false, () => {
-    const parsed = parseConfig({
-      llmBridgeClientConfigPath: "/no/such/remnic-llm-bridge-client.json",
-    });
-    assert.equal(parsed.backgroundGeneration, undefined);
-  });
-});
-
-test("parseConfig rejects backgroundGeneration without a token", () => {
+test("parseConfig rejects an unreadable llmBridgeClientConfigPath", () => {
   withIsolatedConnectorsDir(false, () => {
     assert.throws(
-      () =>
-        parseConfig({
-          backgroundGeneration: {
-            endpoint: "http://127.0.0.1:8765/v1/chat/completions",
-          },
-        }),
-      /must include a token/,
+      () => parseConfig({ llmBridgeClientConfigPath: "/no/such/remnic-llm-bridge-client.json" }),
+      /llmBridgeClientConfigPath could not be read/,
     );
   });
 });
 
-test("parseConfig ignores Hermes timeout_seconds on backgroundGeneration", () => {
+test("parseConfig rejects a bridge client file without a token", () => {
   withIsolatedConnectorsDir(false, () => {
-    const parsed = parseConfig({
-      backgroundGeneration: {
-        endpoint: "http://127.0.0.1:8765/v1/chat/completions",
-        token: "bridge-token-fixture",
-        timeout_seconds: 45,
-      },
-    });
-    assert.equal(parsed.backgroundGeneration?.timeoutSeconds, 120);
+    const dir = mkdtempSync(path.join(tmpdir(), "remnic-llm-bridge-client-"));
+    try {
+      const file = path.join(dir, "client.json");
+      writeFileSync(
+        file,
+        JSON.stringify({
+          endpoint: "http://127.0.0.1:8765/v1/chat/completions",
+        }),
+      );
+      assert.throws(
+        () => parseConfig({ llmBridgeClientConfigPath: file }),
+        /must include a token/,
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 });
 
-test("parseConfig keeps env openaiBaseUrl isolated from backgroundGeneration", () => {
+test("parseConfig keeps env openaiBaseUrl isolated from the Hermes bridge", () => {
   withIsolatedConnectorsDir(false, () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "remnic-llm-bridge-env-"));
     const previousKey = process.env.OPENAI_API_KEY;
     const previousBase = process.env.OPENAI_BASE_URL;
     process.env.OPENAI_API_KEY = "env-openai-key";
     process.env.OPENAI_BASE_URL = "http://127.0.0.1:9999/v1";
     try {
-      const parsed = parseConfig({
-        backgroundGeneration: {
+      const file = path.join(dir, "client.json");
+      writeFileSync(
+        file,
+        JSON.stringify({
           endpoint: "http://127.0.0.1:8765/v1/chat/completions",
           token: "bridge-token-fixture",
-          timeoutSeconds: 45,
-        },
-      });
+          timeout_seconds: 45,
+        }),
+      );
+      const parsed = parseConfig({ llmBridgeClientConfigPath: file });
       assert.equal(parsed.openaiBaseUrl, "http://127.0.0.1:9999/v1");
       assert.equal(parsed.openaiApiKey, "env-openai-key");
       assert.deepEqual(parsed.backgroundGeneration, {
@@ -2833,6 +2909,57 @@ test("parseConfig keeps env openaiBaseUrl isolated from backgroundGeneration", (
       else process.env.OPENAI_API_KEY = previousKey;
       if (previousBase === undefined) delete process.env.OPENAI_BASE_URL;
       else process.env.OPENAI_BASE_URL = previousBase;
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+test("parseConfig rejects nonnumeric bridge timeout values", () => {
+  withIsolatedConnectorsDir(false, () => {
+    assert.throws(
+      () =>
+        parseConfig({
+          backgroundGeneration: {
+            endpoint: "http://127.0.0.1:8765/v1/chat/completions",
+            token: "t",
+            timeoutSeconds: true,
+          },
+        }),
+      /timeoutSeconds must be a finite number/,
+    );
+    assert.throws(
+      () =>
+        parseConfig({
+          backgroundGeneration: {
+            endpoint: "http://127.0.0.1:8765/v1/chat/completions",
+            token: "t",
+            timeout_seconds: "45",
+          },
+        }),
+      /timeoutSeconds must be a finite number/,
+    );
+  });
+});
+
+test("parseConfig rejects a bridge client file with a nonnumeric timeout", () => {
+  withIsolatedConnectorsDir(false, () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "remnic-llm-bridge-badtimeout-"));
+    try {
+      const file = path.join(dir, "client.json");
+      writeFileSync(
+        file,
+        JSON.stringify({
+          endpoint: "http://127.0.0.1:8765/v1/chat/completions",
+          token: "bridge-token-fixture",
+          timeout_seconds: "45",
+        }),
+      );
+      assert.throws(
+        () => parseConfig({ llmBridgeClientConfigPath: file }),
+        /timeoutSeconds must be a finite number/,
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
     }
   });
 });

package/src/config.ts

@@ -25,6 +25,7 @@ import type {
   TriggerMode,
   TrustWeights,
 } from "./types.js";
+import { parseBackgroundGeneration } from "./background-generation-config.js";
 import { parseLocalLlmConfig } from "./local-llm-config.js";
 import { parseConvergeConfig } from "./converge-config.js";
 import { parseExternalWikiRecallGuard } from "./external-wiki-guard.js";
@@ -519,6 +520,7 @@ function normalizeOpenaiBaseUrl(value: string | undefined, source: "config" | "e
   return url;
 }
 
+
 function normalizeMemoryRelativeDir(raw: unknown, fallback: string): string {
   if (typeof raw !== "string") return fallback;
   const trimmed = raw.trim();
@@ -1482,6 +1484,7 @@ export function parseConfig(
   } else if (apiKey !== undefined) {
     baseUrl = normalizeOpenaiBaseUrl(readEnvVar("OPENAI_BASE_URL"), "env");
   }
+  const backgroundGeneration = parseBackgroundGeneration(cfg, resolveEnvVars);
 
   const sharedCrossSignalSemanticEnabled =
     cfg.sharedCrossSignalSemanticEnabled === true || cfg.crossSignalsSemanticEnabled === true;
@@ -1491,7 +1494,15 @@ export function parseConfig(
       : typeof cfg.crossSignalsSemanticTimeoutMs === "number"
         ? Math.max(1, Math.floor(cfg.crossSignalsSemanticTimeoutMs))
         : 4000;
-  const recallPipelineConfig = buildRecallPipelineConfig(cfg);
+  // Coerce once. The default recall-pipeline shared-context gate reads
+  // `cfg.sharedContextEnabled === true`, so it must see this boolean —
+  // not the raw CLI/config string. Custom `recallPipeline` is unchanged.
+  const sharedContextEnabled =
+    coerceBool(cfg.sharedContextEnabled, "sharedContextEnabled") ?? false;
+  const recallPipelineConfig = buildRecallPipelineConfig({
+    ...cfg,
+    sharedContextEnabled,
+  });
   const maintenanceNamespaceFanoutEnabled = resolveBooleanConfig(
     readFlatOrNestedConfig(
       cfg,
@@ -1560,6 +1571,7 @@ export function parseConfig(
   return {
     openaiApiKey: apiKey,
     openaiBaseUrl: baseUrl,
+    backgroundGeneration,
     model,
     reasoningEffort,
     triggerMode,
@@ -3003,10 +3015,9 @@ export function parseConfig(
         ? cfg.routingRulesStateFile.trim()
         : "state/routing-rules.json",
 
-    // v4.0 shared-context (default off)
-    sharedContextEnabled: cfg.sharedContextEnabled === true,
-    // CLI values arrive as strings (`--config sharedContextAllowBindingAuthority=true`),
-    // so a strict `=== true` silently keeps the feature off. Default stays false.
+    // Reuse the hoisted coerce above (default pipeline already saw it).
+    sharedContextEnabled,
+    // Same coercion contract for the binding-authority sibling (#2918 parity).
     sharedContextAllowBindingAuthority:
       coerceBool(cfg.sharedContextAllowBindingAuthority, "sharedContextAllowBindingAuthority") ?? false,
     sharedContextDir:
@@ -4217,6 +4228,7 @@ function buildDefaultRecallPipeline(cfg: Record<string, unknown>): RecallSection
   return [
     {
       id: "shared-context",
+      // Already coerced in parseConfig; do not coerce again.
       enabled: cfg.sharedContextEnabled === true,
       maxChars:
         typeof cfg.sharedContextMaxInjectChars === "number"

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