@remnic/core 9.15.1 → 9.15.3

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier,
   isRecallDisclosure
-} from "./chunk-YVKF3HEW.js";
+} from "./chunk-FJ5IQ3SI.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,

package/dist/utility-runtime.d.ts

@@ -1,5 +1,5 @@
 import { TierRoutingPolicy } from './tier-routing.js';
-import './types-D_fG2ix8.js';
+import './types-2q_MRFcM.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-continuity.js';

package/dist/verified-recall.js

@@ -1,9 +1,9 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-QLOOCKKE.js";
+} from "./chunk-6EJL2O3G.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-RWSLO24I.js";
+import "./chunk-O7ACJAHR.js";
 import "./chunk-B3ABVQ36.js";
 import "./chunk-2QMKMVHH.js";
 import "./chunk-DEBHXHJR.js";
@@ -11,7 +11,7 @@ import "./chunk-DNHVPZOD.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-V57NLO5P.js";
-import "./chunk-YVKF3HEW.js";
+import "./chunk-FJ5IQ3SI.js";
 import "./chunk-XKGPIWGI.js";
 import "./chunk-EGGE52UU.js";
 import "./chunk-GCASGYIO.js";

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { w as MemoryCategory } from './types-D_fG2ix8.js';
+import { w as MemoryCategory } from './types-2q_MRFcM.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-continuity.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.15.1",
+  "version": "9.15.3",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3045,7 +3045,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.15.1"
+    "@remnic/coding-graph": "^9.15.3"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-service.ts

@@ -281,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;

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/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;