@remnic/core 9.15.0 → 9.15.2

package/src/access-service.ts

@@ -6,6 +6,7 @@ import { readdirSync, unlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { ZodError } from "zod";
 import { AccessIdempotencyStore, hashAccessIdempotencyPayload } from "./access-idempotency.js";
+import { enforceNamespaceAllowList, tokenCapabilityStore } from "./access-token-capabilities.js";
 import {
   recordCitationUsage as recordCitationUsageForAccess,
   type CitationUsageRequest,
@@ -130,8 +131,11 @@ import {
 import {
   type ScopePlan,
   resolveScopePlan,
+  resolveScopedWritableNamespaceValue,
   resolveWritableNamespaceValue,
+  type WritableNamespaceResult,
 } from "./scopes/scope-plan.js";
+import { resolveNamespaceWritablePreflight, type EngramAccessNamespaceWritableRequest } from "./access-namespace-preflight.js";
 import { namespaceIdentityFromToken } from "./namespaces/identity.js";
 import { namespaceCollectionName } from "./namespaces/search.js";
 import { SecureStoreLockedError } from "./secure-store/index.js";
@@ -277,52 +281,6 @@ import { EngramAccessInputError, NamespaceNotWritableError } from "./access-erro
 // working after these classes moved to ./access-errors (issue #1888).
 export { EngramAccessInputError, NamespaceNotWritableError } from "./access-errors.js";
 
-function qmdCollectionPathParts(resultPath: string): {
-  collection: string;
-  relativePath: string;
-} | null {
-  if (!resultPath || nodePath.isAbsolute(resultPath)) return null;
-  const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
-  const slashIndex = normalized.indexOf("/");
-  if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
-  const collection = normalized.slice(0, slashIndex);
-  if (/^\d{4}-\d{2}-\d{2}$/.test(collection)) return null;
-  return {
-    collection,
-    relativePath: normalized.slice(slashIndex + 1),
-  };
-}
-
-function qmdResultPathCandidates(
-  storageDir: string,
-  resultPath: string,
-): string[] {
-  const candidates = new Set<string>();
-  const storageRoot = nodePath.resolve(storageDir);
-  const addCandidate = (candidate: string) => {
-    const resolved = nodePath.resolve(candidate);
-    if (isPathInsideStorageRoot(storageRoot, resolved)) {
-      candidates.add(resolved);
-    }
-  };
-  const addRelativeCandidates = (relativePath: string) => {
-    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
-    if (!normalized) return;
-    addCandidate(nodePath.join(storageRoot, normalized));
-    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(nodePath.join(storageRoot, "facts", normalized));
-    }
-  };
-
-  if (nodePath.isAbsolute(resultPath)) {
-    addCandidate(resultPath);
-  } else {
-    addRelativeCandidates(resultPath);
-  }
-
-  return [...candidates];
-}
-
 export type AccessProfilingReportRequest = {
   format?: string;
   limit?: number;
@@ -958,7 +916,7 @@ export interface CodingScopedWriteInput {
   cwd?: string;
   projectTag?: string;
 }
-
+export type { EngramAccessNamespaceWritableRequest } from "./access-namespace-preflight.js";
 /**
  * Internal, single-resolution plan describing the effective memory scope for a
  * write-producing access request (#1495, seed for epic #1494). One plan is
@@ -1588,6 +1546,14 @@ export class EngramAccessService {
     return { principal, codingContext, overlay, profilePlan };
   }
 
+  private assertTokenCanWriteNamespace(namespace: string): void {
+    enforceNamespaceAllowList(
+      tokenCapabilityStore.getStore(),
+      namespace,
+      this.orchestrator.config.defaultNamespace,
+    );
+  }
+
   /**
    * Resolve the write namespace for explicit-write tools (memory_store /
    * suggestion_submit), project-scoping the write the same way recall does so a
@@ -1603,49 +1569,56 @@ export class EngramAccessService {
       sessionKey?: string;
       authenticatedPrincipal?: string;
     },
+    enforceToken: boolean = true,
   ): Promise<string> {
-    const hasExplicitNamespace =
-      typeof request.namespace === "string" && request.namespace.trim().length > 0;
-    if (hasExplicitNamespace) {
-      return this.writableNamespaceFor(
-        request.namespace,
+    const requested = request.namespace?.trim();
+    if (requested) {
+      const namespace = this.writableNamespaceFor(
+        requested,
         request.sessionKey,
         request.authenticatedPrincipal,
       );
+      if (enforceToken) this.assertTokenCanWriteNamespace(namespace);
+      return namespace;
     }
+
     const { principal, overlay, profilePlan } = await this.resolveCodingScopeInputs(request);
-    if (profilePlan) {
-      const selectedLayer = profilePlan.layers.find((layer) => layer.id === profilePlan.writeLayer);
-      const writeNamespaceReadable =
-        profilePlan.writeNamespace.length > 0 &&
-        profilePlan.readNamespaces.includes(profilePlan.writeNamespace);
-      if (!selectedLayer?.writable || !writeNamespaceReadable) {
-        throw new NamespaceNotWritableError(profilePlan.writeNamespace, principal,
-          `scope profile ${profilePlan.profileId} has no writable layer for principal ${principal ?? "anonymous"}`);
-      }
-      return profilePlan.writeNamespace;
+    const result = resolveScopedWritableNamespaceValue({
+      sessionKey: request.sessionKey,
+      authenticatedPrincipal: request.authenticatedPrincipal,
+      principal,
+      codingOverlay: overlay,
+      scopeProfile: profilePlan,
+      config: this.orchestrator.config,
+    });
+    if (result.ok) {
+      if (enforceToken) this.assertTokenCanWriteNamespace(result.namespace);
+      return result.namespace;
     }
-    if (!overlay) {
-      // No coding overlay → unqualified write stays on config.defaultNamespace,
-      // exactly the pre-#1434 behavior (auth-checked, like the legacy path).
-      return this.writableNamespaceFor(
-        undefined,
-        request.sessionKey,
-        request.authenticatedPrincipal,
+    if (profilePlan && result.namespace === profilePlan.writeNamespace) {
+      throw new NamespaceNotWritableError(
+        result.namespace,
+        principal,
+        `scope profile ${profilePlan.profileId} has no writable layer for principal ${principal ?? "anonymous"}`,
       );
     }
-    // Coding overlay → overlay onto the principal self base, the SAME namespace
-    // recall/observe/buffer-flush use. The result is a principal-owned
-    // `project-*` sub-namespace derived from this authorized base, so it needs
-    // no separate write policy.
-    const base = defaultNamespaceForPrincipal(principal, this.orchestrator.config);
-    if (!canWriteNamespace(principal, base, this.orchestrator.config)) {
-      throw new NamespaceNotWritableError(base, principal);
+
+    if (result.reason === "unsupported") {
+      throw new EngramAccessInputError(`unsupported namespace: ${result.namespace}`);
     }
-    return combineNamespaces(base, overlay.namespace);
+    throw new NamespaceNotWritableError(result.namespace, principal);
+  }
+
+  async namespaceWritablePreflight(
+    request: EngramAccessNamespaceWritableRequest,
+  ): Promise<WritableNamespaceResult> {
+    return resolveNamespaceWritablePreflight(
+      request,
+      (preflightRequest) => this.resolveCodingScopedWriteNamespace(preflightRequest, false),
+    );
   }
 
-  /** Read-side mirror of {@link resolveCodingScopedWriteNamespace}. Decision
+  /**
    *  `list`/`get` use this so a record written by a project-scoped session is
    *  listable/fetchable by the SAME session without manually supplying the
    *  overlaid namespace (review P2). Derivation is IDENTICAL to the write path
@@ -1748,6 +1721,7 @@ export class EngramAccessService {
         request.sessionKey,
         request.authenticatedPrincipal,
       );
+      this.assertTokenCanWriteNamespace(writeNamespace);
       return {
         principal,
         explicitNamespace: request.namespace!.trim(),
@@ -1825,6 +1799,15 @@ export class EngramAccessService {
         this.orchestrator.setCodingContextForSession(request.sessionKey!, null);
       }
     };
+    const assertWriteNamespaceAllowed = (namespace: string): void => {
+      try {
+        this.assertTokenCanWriteNamespace(namespace);
+      } catch (error) {
+        clearSeededContext();
+        throw error;
+      }
+    };
+
 
     const overlaidBase = this.orchestrator.applyCodingNamespaceOverlay(
       request.sessionKey,
@@ -1876,6 +1859,7 @@ export class EngramAccessService {
               readNamespaces.includes(layer.namespace),
           ),
       );
+      assertWriteNamespaceAllowed(profilePlan.writeNamespace);
       return {
         principal,
         baseNamespace: profilePlan.baseNamespace,
@@ -1928,6 +1912,7 @@ export class EngramAccessService {
         clearSeededContext();
         throw new NamespaceNotWritableError(baseNamespace, principal);
       }
+      assertWriteNamespaceAllowed(writeNamespace);
       return {
         principal,
         // scopeDebug.baseNamespace must report the principal SELF base
@@ -1965,6 +1950,7 @@ export class EngramAccessService {
       const ns = combineNamespaces(baseNamespace, fallback);
       if (!readNamespaces.includes(ns)) readNamespaces.push(ns);
     }
+    assertWriteNamespaceAllowed(writeNamespace);
     return {
       principal,
       baseNamespace,

package/src/config.test.ts

@@ -1179,6 +1179,13 @@ test('parseConfig localLlmDisableThinking "0"/"no"/"off" all coerce to false', (
   assert.equal(parseConfig({ localLlmDisableThinking: "off" }).localLlmDisableThinking, false);
 });
 
+test("parseConfig localLlmThinkingThresholdChars defaults conservatively and accepts zero to disable (#1997)", () => {
+  assert.equal(parseConfig({}).localLlmThinkingThresholdChars, 3_000);
+  assert.equal(parseConfig({ localLlmThinkingThresholdChars: 0 }).localLlmThinkingThresholdChars, 0);
+  assert.equal(parseConfig({ localLlmThinkingThresholdChars: "3000" }).localLlmThinkingThresholdChars, 3_000);
+  assert.equal(parseConfig({ localLlmThinkingThresholdChars: 3_000 }).localLlmThinkingThresholdChars, 3_000);
+});
+
 test("parseConfig procedural numeric fields coerce from CLI-style strings (issue #519)", () => {
   const result = parseConfig({
     openaiApiKey: "sk-test",

package/src/config.ts

@@ -2856,6 +2856,12 @@ export function parseConfig(
       ["", "none", "low", "medium", "high", "max"].includes(cfg.localLlmReasoningEffort)
         ? cfg.localLlmReasoningEffort
         : "none",
+    localLlmThinkingThresholdChars: (() => {
+      const threshold = coerceNumber(cfg.localLlmThinkingThresholdChars);
+      return threshold !== undefined && Number.isInteger(threshold) && threshold >= 0
+        ? threshold
+        : 3_000;
+    })(),
     // Extraction retry/backoff + circuit breaker (extraction hot-loop hardening)
     extractionRetryEnabled: coerceBooleanLike(cfg.extractionRetryEnabled) ?? true,
     extractionRetryScheduleMs:

package/src/extraction-thinking.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { shouldEnableLocalExtractionThinking } from "./extraction.js";
+import type { PluginConfig } from "./types.js";
+
+function config(overrides: Partial<PluginConfig> = {}): PluginConfig {
+  return {
+    localLlmDisableThinking: true,
+    localLlmThinkingThresholdChars: 3_000,
+    ...overrides,
+  } as PluginConfig;
+}
+
+test("short local extraction enables thinking when configured (#1997)", () => {
+  assert.equal(shouldEnableLocalExtractionThinking(config(), 2_999), true);
+});
+
+test("length-aware local thinking stays disabled at the threshold and above (#1997)", () => {
+  assert.equal(shouldEnableLocalExtractionThinking(config(), 3_000), false);
+  assert.equal(shouldEnableLocalExtractionThinking(config(), 3_001), false);
+});
+
+test("disabled threshold and explicit global opt-out preserve existing behavior (#1997)", () => {
+  assert.equal(shouldEnableLocalExtractionThinking(config({ localLlmThinkingThresholdChars: 0 }), 1), false);
+  assert.equal(shouldEnableLocalExtractionThinking(config({ localLlmDisableThinking: false }), 1), false);
+});
+
+test("four-transcript selection matrix keeps short sparse cases in thinking mode (#1997)", () => {
+  const cases = [
+    { name: "sparse commitment", transcript: "A".repeat(750), thinking: true },
+    { name: "sparse correction", transcript: "B".repeat(1_600), thinking: true },
+    { name: "dense technical discussion", transcript: "C".repeat(3_000), thinking: false },
+    { name: "dense multi-turn discussion", transcript: "D".repeat(6_000), thinking: false },
+  ];
+
+  for (const scenario of cases) {
+    assert.equal(
+      shouldEnableLocalExtractionThinking(config(), scenario.transcript.length),
+      scenario.thinking,
+      scenario.name,
+    );
+  }
+});

package/src/extraction.ts

@@ -147,6 +147,15 @@ function normalizeProfileUpdateKey(update: string): string {
   return update.trim().toLowerCase();
 }
 
+export function shouldEnableLocalExtractionThinking(
+  config: Pick<PluginConfig, "localLlmDisableThinking" | "localLlmThinkingThresholdChars">,
+  conversationChars: number,
+): boolean {
+  return config.localLlmDisableThinking &&
+    config.localLlmThinkingThresholdChars > 0 &&
+    conversationChars < config.localLlmThinkingThresholdChars;
+}
+
 export class ExtractionEngine {
   private client: OpenAI | null;
   private localLlm: LocalLlmClient;
@@ -1523,6 +1532,9 @@ ${truncatedConversation}`;
         temperature: 0.1,
         maxTokens: contextSizes.maxOutputTokens,
         operation: "extraction",
+        disableThinking: shouldEnableLocalExtractionThinking(this.config, conversation.length)
+          ? false
+          : undefined,
         priority: "background",
       },
     );

package/src/local-llm-thinking.test.ts

@@ -83,7 +83,7 @@ function captureFetchBodies(): {
 async function runOneChatCompletion(
   client: LocalLlmClient,
   operation: string | null = "extraction",
-  options: { forceDisableThinking?: boolean } = {},
+  options: { forceDisableThinking?: boolean; disableThinking?: boolean } = {},
 ): Promise<void> {
   await client.chatCompletion(
     [{ role: "user", content: "hello" }],
@@ -344,3 +344,15 @@ test("disableThinking=false never injects chat_template_kwargs, regardless of ba
   }
   assert.equal("chat_template_kwargs" in (bodies[0] ?? {}), false);
 });
+
+test("request-level thinking override leaves short extraction thinking enabled (#1997)", async () => {
+  const client = new LocalLlmClient(createConfig());
+  primeClient(client, { thinking: true, detected: "ollama" });
+  const { restore, bodies } = captureFetchBodies();
+  try {
+    await runOneChatCompletion(client, "extraction", { disableThinking: false });
+  } finally {
+    restore();
+  }
+  assert.equal("reasoning_effort" in (bodies[0] ?? {}), false);
+});

package/src/local-llm.ts

@@ -220,6 +220,7 @@ interface LocalLlmChatCompletionOptions {
   timeoutMs?: number;
   operation?: string;
   forceDisableThinking?: boolean;
+  disableThinking?: boolean;
   priority?: LocalLlmRequestPriority;
 }
 
@@ -989,7 +990,7 @@ export class LocalLlmClient {
       // backend hasn't been positively identified as thinking-capable.
       const shouldSuppressThinking =
         options.forceDisableThinking === true ||
-        (this._disableThinking &&
+        ((options.disableThinking ?? this._disableThinking) &&
           THINKING_SUPPRESSED_OPERATIONS.has(operation));
       if (
         shouldSuppressThinking &&

package/src/orchestration/qmd-result-resolver.test.ts

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { parseConfig } from "../config.js";
+import { StorageManager } from "../index.js";
+import {
+  QmdResultResolver,
+  qmdResultPathCandidates,
+} from "./qmd-result-resolver.js";
+
+test("qmdResultPathCandidates probes the facts/ fallback for relative date paths", () => {
+  const root = path.join(os.tmpdir(), "remnic-resolver-rel");
+  const candidates = qmdResultPathCandidates(root, "2026-07-21/fact-x.md");
+  assert.deepEqual(
+    candidates.sort(),
+    [
+      path.join(root, "2026-07-21", "fact-x.md"),
+      path.join(root, "facts", "2026-07-21", "fact-x.md"),
+    ].sort(),
+    "relative date paths probe both the literal and the facts/ location",
+  );
+});
+
+test("qmdResultPathCandidates probes the facts/ fallback for absolute date paths inside the storage root (issue #2111)", () => {
+  const root = path.join(os.tmpdir(), "remnic-resolver-abs");
+  const absolute = path.join(root, "2026-07-21", "fact-x.md");
+  const candidates = qmdResultPathCandidates(root, absolute);
+  assert.deepEqual(
+    candidates.sort(),
+    [absolute, path.join(root, "facts", "2026-07-21", "fact-x.md")].sort(),
+    "pre-absolutized date paths must probe the facts/ location too",
+  );
+});
+
+test("qmdResultPathCandidates keeps non-date absolute paths literal", () => {
+  const root = path.join(os.tmpdir(), "remnic-resolver-abs-nondate");
+  const absolute = path.join(root, "entities", "person-x.md");
+  assert.deepEqual(
+    qmdResultPathCandidates(root, absolute),
+    [absolute],
+    "non-date absolute paths must not grow a facts/ variant",
+  );
+});
+
+test("qmdResultPathCandidates rejects absolute paths outside the storage root", () => {
+  const root = path.join(os.tmpdir(), "remnic-resolver-abs-outside");
+  const outside = path.join(os.tmpdir(), "elsewhere", "2026-07-21", "fact-x.md");
+  assert.deepEqual(
+    qmdResultPathCandidates(root, outside),
+    [],
+    "containment must drop escaping paths, including their facts/ variant",
+  );
+});
+
+test("readQmdResultMemory resolves an absolute date path whose file lives under facts/ (issue #2111)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-resolver-e2e-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const factDir = path.join(dir, "facts", "2026-07-21");
+    await mkdir(factDir, { recursive: true });
+    const factPath = path.join(factDir, "fact-cookie-note.md");
+    await writeFile(
+      factPath,
+      [
+        "---",
+        "id: fact-cookie-note",
+        "category: fact",
+        "created: 2026-07-21T00:00:00.000Z",
+        "updated: 2026-07-21T00:00:00.000Z",
+        "status: active",
+        "---",
+        "",
+        "The storefront manages a uniqueId cookie with a 90-day expiration.",
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+
+    const config = parseConfig({ memoryDir: dir });
+    const resolver = new QmdResultResolver({
+      getConfig: () => config,
+      storageFor: async () => storage,
+      storageDirNamespace: () => config.defaultNamespace,
+      qmdCollectionNamespaceFromPrefix: () => null,
+      namespaceFromPath: () => config.defaultNamespace,
+    });
+
+    // Daemon-mode shape: the result path is already absolutized against the
+    // storage root but is missing the facts/ segment because the hot-facts
+    // collection was registered at the facts/ subtree.
+    const preAbsolutized = path.join(dir, "2026-07-21", "fact-cookie-note.md");
+    const memory = await resolver.readQmdResultMemory(preAbsolutized, storage);
+    assert.ok(memory, "the memory must resolve via the facts/ fallback");
+    assert.equal(memory.frontmatter.id, "fact-cookie-note");
+    assert.equal(path.resolve(memory.path), path.resolve(factPath));
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/orchestration/qmd-result-resolver.ts

@@ -84,6 +84,17 @@ export function qmdResultPathCandidates(
 
   if (path.isAbsolute(resultPath)) {
     addCandidate(resultPath);
+    // Daemon-mode results can arrive pre-absolutized against the storage
+    // root while the file lives under facts/<date>/ (hot-facts collection
+    // registered at the facts/ subtree — issue #2111). Mirror the relative
+    // branch's facts/ fallback; addCandidate re-checks containment.
+    const relative = path.relative(storageRoot, path.resolve(resultPath));
+    if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+      const normalized = relative.split(path.sep).join("/");
+      if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
+        addCandidate(path.join(storageRoot, "facts", normalized));
+      }
+    }
   } else {
     addRelativeCandidates(resultPath);
   }

package/src/scopes/scope-plan.ts

@@ -489,6 +489,72 @@ export function resolveWritableNamespaceValue(
   return { ok: true, namespace: resolved };
 }
 
+/**
+ * Inputs already derived by the access-service's read-only coding-context
+ * resolver. Keeping context discovery outside this pure function lets writes
+ * and preflight checks apply identical namespace and ACL rules.
+ */
+export interface ScopedWritableNamespaceInput {
+  readonly namespace?: string;
+  readonly sessionKey?: string;
+  readonly authenticatedPrincipal?: string;
+  readonly principal: string | undefined;
+  readonly codingOverlay: CodingNamespaceOverlay | null;
+  readonly scopeProfile: ResolvedScopeProfilePlan | null;
+  readonly config: PluginConfig;
+}
+
+/**
+ * Resolve the namespace an explicit write or implicit coding-scoped write
+ * would use. The caller supplies the same derived coding inputs for the real
+ * write and the read-only preflight.
+ */
+export function resolveScopedWritableNamespaceValue(
+  input: ScopedWritableNamespaceInput,
+): WritableNamespaceResult {
+  const requested = input.namespace?.trim();
+  if (requested) {
+    return resolveWritableNamespaceValue(
+      requested,
+      input.sessionKey,
+      input.authenticatedPrincipal,
+      input.config,
+    );
+  }
+  if (input.scopeProfile) {
+    const selectedLayer = input.scopeProfile.layers.find(
+      (layer) => layer.id === input.scopeProfile?.writeLayer,
+    );
+    const writeNamespaceReadable =
+      input.scopeProfile.writeNamespace.length > 0 &&
+      input.scopeProfile.readNamespaces.includes(input.scopeProfile.writeNamespace);
+    if (!selectedLayer?.writable || !writeNamespaceReadable) {
+      return {
+        ok: false,
+        reason: "not_writable",
+        namespace: input.scopeProfile.writeNamespace,
+      };
+    }
+    return { ok: true, namespace: input.scopeProfile.writeNamespace };
+  }
+  if (!input.codingOverlay) {
+    return resolveWritableNamespaceValue(
+      undefined,
+      input.sessionKey,
+      input.authenticatedPrincipal,
+      input.config,
+    );
+  }
+  const baseNamespace = defaultNamespaceForPrincipal(input.principal, input.config);
+  if (!canWriteNamespace(input.principal, baseNamespace, input.config)) {
+    return { ok: false, reason: "not_writable", namespace: baseNamespace };
+  }
+  return {
+    ok: true,
+    namespace: combineNamespaces(baseNamespace, input.codingOverlay.namespace),
+  };
+}
+
 /**
  * Namespace preflight (issue #1888 part 3): would a write to `namespace` by a
  * caller carrying `caps` succeed? Combines the token's write-op scope, its

package/src/types.ts

@@ -1624,6 +1624,12 @@ export interface PluginConfig extends BoundedJsonlStateConfig {
    *  `chat_template_kwargs`, so this is the only think-off dialect it honors.
    *  Issue #1996. */
   localLlmReasoningEffort: string;
+  /**
+   * Maximum transcript length that re-enables thinking for local extraction.
+   * Set to `0` to keep thinking suppressed for every extraction. Default:
+   * `3000`. Consolidation is unaffected.
+   */
+  localLlmThinkingThresholdChars: number;
   // Extraction retry/backoff + circuit breaker (extraction hot-loop hardening)
   /** Master gate. When false, restores pre-change behavior (extractor called on every triggered observe; no gate). */
   extractionRetryEnabled: boolean;