@remnic/core 9.15.1 → 9.15.2

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;