@remnic/core 9.3.612 → 9.3.614

package/src/qmd.ts

@@ -9,7 +9,12 @@ import {
   throwIfAborted,
 } from "./abort-error.js";
 import type { QmdSearchExplain, QmdSearchResult } from "./types.js";
-import type { SearchBackend, SearchExecutionOptions, SearchQueryOptions } from "./search/port.js";
+import {
+  resolveEnsureCollectionArgs,
+  type SearchBackend,
+  type SearchExecutionOptions,
+  type SearchQueryOptions,
+} from "./search/port.js";
 import { launchProcess, type CommandChildProcess } from "./runtime/child-process.js";
 import { mergeEnv } from "./runtime/env.js";
 
@@ -33,11 +38,32 @@ export interface QmdClientOptions {
   qmdEmbedModel?: string;
   qmdRerankModel?: string;
   qmdGenerateModel?: string;
+  /** Daemon search plan; default "hybrid" preserves lex+vec+hyde. Issue #1335. */
+  qmdSearchStrategy?: QmdSearchStrategy;
+  /** Subprocess fallback command; default "query" keeps LLM expansion. Issue #1335. */
+  qmdSubprocessStrategy?: QmdSubprocessStrategy;
+  /** Per-call daemon search timeout in ms; default 8000. Issue #1335. */
+  qmdDaemonTimeoutMs?: number;
 }
 
 export type QmdVersionTuple = [number, number, number];
 export type QmdChunkStrategy = "auto" | "regex";
 export type QmdStructuredSearchType = "lex" | "vec" | "hyde";
+/**
+ * Daemon search plan. Issue #1335.
+ * - "hybrid" → lex + vec + hyde (DEFAULT — full recall; runs an embedding pass
+ *   plus a HyDE generate pass, which dominates latency on CPU-only models).
+ * - "lex-vec" → lex + vec (drops the expensive HyDE generate leg).
+ * - "lex" → lex only (BM25; fastest, no model inference).
+ */
+export type QmdSearchStrategy = "hybrid" | "lex-vec" | "lex";
+/**
+ * Subprocess fallback command (used only when the daemon is unavailable). Issue #1335.
+ * - "query" → `qmd query` (DEFAULT — LLM query expansion + rerank; see CLAUDE.md
+ *   gotcha #7, this is intentional and must remain the default).
+ * - "search" → `qmd search` (BM25-only; fast, but no expansion/rerank).
+ */
+export type QmdSubprocessStrategy = "query" | "search";
 export interface QmdStructuredSearch {
   type: QmdStructuredSearchType;
   query: string;
@@ -100,6 +126,9 @@ const QMD_TIMEOUT_MS = 30_000;
 // During the loading window, searches will timeout/return [] quickly — this is preferable to
 // blocking the full 75s on every recall request.
 // Note: keep this ≥ 5s to allow normal searches (post-load) to complete reliably.
+// This is the DEFAULT only — operators can override per-client via the
+// `qmdDaemonTimeoutMs` config knob (issue #1335), e.g. to give CPU-only HyDE
+// queries more headroom. The effective value lives in `this.daemonTimeoutMs`.
 const QMD_DAEMON_TIMEOUT_MS = 8_000;
 const QMD_PROBE_TIMEOUT_MS = 8_000;
 const QMD_UPDATE_BACKOFF_MS = 15 * 60 * 1000; // 15m
@@ -404,17 +433,32 @@ function buildSyntheticHydeQuery(query: string, intent?: string): string {
     : base;
 }
 
-function buildDefaultStructuredSearches(
+/**
+ * Build the structured sub-queries the daemon `query` tool runs in one request.
+ *
+ * The default `"hybrid"` plan (lex + vec + hyde) intentionally exercises QMD's
+ * full RRF + rerank path for best recall. On CPU-only models the `hyde` leg
+ * (1.7B generate + embed) dominates wall-clock — operators on constrained
+ * hardware can trade recall for latency via `qmdSearchStrategy` (issue #1335)
+ * without losing the default behavior. A per-call `structuredSearches` override
+ * always wins so callers with stronger query-document structure stay in control.
+ */
+export function buildDefaultStructuredSearches(
   query: string,
   options?: SearchQueryOptions,
+  strategy: QmdSearchStrategy = "hybrid",
 ): QmdStructuredSearch[] {
   const explicit = normalizeStructuredSearches(options?.structuredSearches);
   if (explicit.length > 0) return explicit;
   const trimmed = query.trim();
   if (!trimmed) return [];
+  const lex: QmdStructuredSearch = { type: "lex", query: trimmed };
+  if (strategy === "lex") return [lex];
+  const vec: QmdStructuredSearch = { type: "vec", query: trimmed };
+  if (strategy === "lex-vec") return [lex, vec];
   return [
-    { type: "lex", query: trimmed },
-    { type: "vec", query: trimmed },
+    lex,
+    vec,
     { type: "hyde", query: buildSyntheticHydeQuery(trimmed, options?.intent) },
   ];
 }
@@ -1202,6 +1246,9 @@ export class QmdClient implements SearchBackend {
   private readonly qmdCandidateLimit?: number;
   private readonly qmdQueryRerankEnabled: boolean;
   private readonly qmdIndexName?: string;
+  private readonly qmdSearchStrategy: QmdSearchStrategy;
+  private readonly qmdSubprocessStrategy: QmdSubprocessStrategy;
+  private readonly daemonTimeoutMs: number;
   private readonly qmdRuntimeEnv: QmdRuntimeEnv;
   private qmdPathSource: "auto-path" | "auto-fallback" | "configured" = "auto-path";
   private cliVersion: string | null = null;
@@ -1249,6 +1296,20 @@ export class QmdClient implements SearchBackend {
         : undefined;
     this.qmdQueryRerankEnabled = opts?.qmdQueryRerankEnabled !== false;
     this.qmdIndexName = opts?.qmdIndexName?.trim() || undefined;
+    // Default "hybrid" preserves the historical lex+vec+hyde daemon plan. Issue #1335.
+    this.qmdSearchStrategy =
+      opts?.qmdSearchStrategy === "lex" || opts?.qmdSearchStrategy === "lex-vec"
+        ? opts.qmdSearchStrategy
+        : "hybrid";
+    // Default "query" keeps `qmd query` (LLM expansion + rerank) per gotcha #7. Issue #1335.
+    this.qmdSubprocessStrategy = opts?.qmdSubprocessStrategy === "search" ? "search" : "query";
+    // Default 8000ms preserves the historical hardcoded daemon timeout. Issue #1335.
+    // Floor of 1000ms avoids absurdly small values; callers wanting CPU-only HyDE
+    // headroom can raise this (e.g. 20000) without code changes.
+    this.daemonTimeoutMs =
+      typeof opts?.qmdDaemonTimeoutMs === "number" && Number.isFinite(opts.qmdDaemonTimeoutMs)
+        ? Math.max(1_000, Math.floor(opts.qmdDaemonTimeoutMs))
+        : QMD_DAEMON_TIMEOUT_MS;
     this.qmdRuntimeEnv = this.buildRuntimeEnv(opts);
     if (this.configuredQmdPath) {
       this.qmdPath = this.configuredQmdPath;
@@ -1823,7 +1884,15 @@ export class QmdClient implements SearchBackend {
     // repeated queries within the same recall cycle (e.g., primary + hybrid
     // top-up, or conversation recall using the same collection).
     const optionsFingerprint = searchOptions ? JSON.stringify(searchOptions) : "";
-    const cacheKey = createHash("sha256").update(`${col}:${n}:${optionsFingerprint}:${trimmed}`).digest("hex");
+    // The QMD search cache is a process-global keyed map (memory-cache.ts), so the
+    // key must capture every input that changes the result — including the daemon
+    // and subprocess strategies. Otherwise two QmdClient instances (or a reloaded
+    // config) with different strategies collide within the TTL and one plan serves
+    // another plan's cached results. Issue #1335 (codex review on #1422).
+    const strategyFingerprint = `${this.qmdSearchStrategy}:${this.qmdSubprocessStrategy}`;
+    const cacheKey = createHash("sha256")
+      .update(`${strategyFingerprint}:${col}:${n}:${optionsFingerprint}:${trimmed}`)
+      .digest("hex");
     const cached = getCachedQmdSearch(cacheKey);
     if (cached) {
       log.debug(`QMD search cache hit (${cached.length} results)`);
@@ -2066,8 +2135,9 @@ export class QmdClient implements SearchBackend {
         // QMD v2: query tool expects { searches: [...], collections?: [...] }
         // The MCP tool is structured-only in 2.x; use lex+vec+hyde by default
         // to exercise QMD's RRF + rerank path and let callers override when
-        // they have stronger query-document structure.
-        const searches = buildDefaultStructuredSearches(query, options);
+        // they have stronger query-document structure. Operators on CPU-only
+        // models can downgrade the plan via qmdSearchStrategy (issue #1335).
+        const searches = buildDefaultStructuredSearches(query, options, this.qmdSearchStrategy);
         args = { searches, limit: maxResults };
         if (collection) {
           args.collections = [collection];
@@ -2082,7 +2152,7 @@ export class QmdClient implements SearchBackend {
         this.addResolvedSearchOptionsToMcpArgs(args, options);
       }
 
-      const result = await this.daemonSession.callTool("query", args, QMD_DAEMON_TIMEOUT_MS, signal);
+      const result = await this.daemonSession.callTool("query", args, this.daemonTimeoutMs, signal);
       const durationMs = Date.now() - startedAtMs;
 
       if (this.slowLog?.enabled && durationMs >= this.slowLog.thresholdMs) {
@@ -2134,7 +2204,7 @@ export class QmdClient implements SearchBackend {
             collections: [collection],
             limit: maxResults,
           },
-          QMD_DAEMON_TIMEOUT_MS,
+          this.daemonTimeoutMs,
           signal,
         );
       } else {
@@ -2142,7 +2212,7 @@ export class QmdClient implements SearchBackend {
         result = await this.daemonSession.callTool(
           "search",
           { query, limit: maxResults, collection },
-          QMD_DAEMON_TIMEOUT_MS,
+          this.daemonTimeoutMs,
           signal,
         );
       }
@@ -2187,7 +2257,7 @@ export class QmdClient implements SearchBackend {
             collections: [collection],
             limit: maxResults,
           },
-          QMD_DAEMON_TIMEOUT_MS,
+          this.daemonTimeoutMs,
           signal,
         );
       } else {
@@ -2195,7 +2265,7 @@ export class QmdClient implements SearchBackend {
         result = await this.daemonSession.callTool(
           "vsearch",
           { query, limit: maxResults, collection },
-          QMD_DAEMON_TIMEOUT_MS,
+          this.daemonTimeoutMs,
           signal,
         );
       }
@@ -2228,6 +2298,17 @@ export class QmdClient implements SearchBackend {
   ): Promise<QmdSearchResult[]> {
     if (this.available === false) return [];
 
+    // INTENTIONAL — DO NOT change the default command from `query` to `search`.
+    // `qmd query` performs LLM query expansion + reranking that Remnic depends on
+    // (Remnic's own reranking is disabled because `qmd query` handles it). This is
+    // CLAUDE.md gotcha #7. On very large collections `qmd query` can be slow/hang
+    // (issue #1335), so operators may opt into BM25-only `qmd search` by setting
+    // `qmdSubprocessStrategy: "search"` — but that trades away expansion + rerank,
+    // so it stays opt-in and the default remains `query`.
+    if (this.qmdSubprocessStrategy === "search") {
+      return this.bm25SearchViaSubprocess(query, collection, maxResults, signal);
+    }
+
     const startedAtMs = Date.now();
     try {
       const args = ["query", query, "-c", collection];
@@ -2311,15 +2392,24 @@ export class QmdClient implements SearchBackend {
 
     const startedAtMs = Date.now();
     try {
-      const args = ["query", query];
+      // Mirror searchViaSubprocess: default `qmd query` keeps LLM expansion +
+      // rerank (gotcha #7); `qmdSubprocessStrategy: "search"` opts into BM25-only
+      // `qmd search` for both scoped AND global recall so the gate stays uniform
+      // across every subprocess path (gotcha #39). Issue #1335.
+      const bm25 = this.qmdSubprocessStrategy === "search";
+      const args = bm25 ? ["search", query] : ["query", query];
       this.addQmdJsonOutputArgs(args);
       args.push("-n", String(maxResults));
-      this.addResolvedSearchOptionsToArgs(args, options);
+      // BM25 `qmd search` takes no expansion/rerank options — only forward them
+      // for the `query` command.
+      if (!bm25) {
+        this.addResolvedSearchOptionsToArgs(args, options);
+      }
       const { stdout } = await this.runQmdCommand(args, QMD_TIMEOUT_MS, signal);
       const durationMs = Date.now() - startedAtMs;
       if (this.slowLog?.enabled && durationMs >= this.slowLog.thresholdMs) {
         log.warn(
-          `SLOW QMD global query: durationMs=${durationMs} maxResults=${maxResults} queryChars=${query.length}`,
+          `SLOW QMD global ${bm25 ? "search" : "query"}: durationMs=${durationMs} maxResults=${maxResults} queryChars=${query.length}`,
         );
       }
 
@@ -2597,16 +2687,22 @@ export class QmdClient implements SearchBackend {
 
   async ensureCollection(
     memoryDir: string,
+    collectionOrExecution?: string | SearchExecutionOptions,
     execution?: SearchExecutionOptions,
   ): Promise<"present" | "missing" | "unknown" | "skipped"> {
+    const { collection, execution: effectiveExecution } = resolveEnsureCollectionArgs(
+      collectionOrExecution,
+      execution,
+    );
     if (this.available === false && !this.daemonAvailable) return "unknown";
     // If only daemon is available (no CLI), skip collection check
     if (this.available === false) return "skipped";
+    const targetCollection = collection ?? this.collection;
     try {
-      const { stdout } = await this.runQmdCommand(["collection", "list"], QMD_TIMEOUT_MS, execution?.signal);
+      const { stdout } = await this.runQmdCommand(["collection", "list"], QMD_TIMEOUT_MS, effectiveExecution?.signal);
       // Parse text output: "openclaw-engram (qmd://openclaw-engram/)"
       const collectionRegex = new RegExp(
-        `^${this.collection}\\s+\\(qmd://`,
+        `^${escapeRegExp(targetCollection)}\\s+\\(qmd://`,
         "m",
       );
       if (collectionRegex.test(stdout)) {
@@ -2616,15 +2712,19 @@ export class QmdClient implements SearchBackend {
       // Treat command/probe failures as unknown so callers do not disable features
       // permanently after a transient CLI or daemon hiccup.
       log.debug(
-        `QMD collection check unavailable for "${this.collection}" (will not disable features): ${err instanceof Error ? err.message : String(err)}`,
+        `QMD collection check unavailable for "${targetCollection}" (will not disable features): ${err instanceof Error ? err.message : String(err)}`,
       );
       return "unknown";
     }
 
     log.info(
-      `QMD collection "${this.collection}" not found. ` +
+      `QMD collection "${targetCollection}" not found. ` +
         `Add it to ~/.config/qmd/index.yml pointing at ${memoryDir}`,
     );
     return "missing";
   }
 }
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/recall-planner-llm.test.ts

@@ -0,0 +1,224 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import {
+  planRecallModeLLM,
+  resolveRecallPlannerLlmOptions,
+} from "./recall-planner-llm.js";
+import type { FallbackLlmClient } from "./fallback-llm.js";
+import type { RecallPlanMode } from "./types.js";
+
+// A stub FallbackLlmClient that records the options it was called with and
+// returns a scripted classification (or simulates a failure).
+function stubLlm(opts: {
+  available?: boolean;
+  capturedOptions?: Array<Record<string, unknown>>;
+  result?: { mode: RecallPlanMode; reason?: string | null } | null;
+  modelUsed?: string;
+  throwError?: string;
+}): FallbackLlmClient {
+  return {
+    isAvailable: () => opts.available !== false,
+    parseWithSchemaDetailed: async (
+      _messages: unknown,
+      schema: { parse: (v: unknown) => unknown },
+      options: Record<string, unknown>,
+    ) => {
+      opts.capturedOptions?.push(options);
+      if (opts.throwError) throw new Error(opts.throwError);
+      if (opts.result === null || opts.result === undefined) return null;
+      // Exercise the real schema so malformed scripted output is caught too.
+      const parsed = schema.parse(opts.result);
+      return { result: parsed, modelUsed: opts.modelUsed ?? "test/model" };
+    },
+  } as unknown as FallbackLlmClient;
+}
+
+test("returns heuristic without calling the LLM when recallPlannerLlmEnabled is false", async () => {
+  const config = parseConfig({ recallPlannerLlmEnabled: false });
+  const captured: Array<Record<string, unknown>> = [];
+  const llm = stubLlm({ capturedOptions: captured, result: { mode: "no_recall" } });
+
+  const result = await planRecallModeLLM("what did we decide about auth?", undefined, config, llm);
+
+  assert.equal(captured.length, 0, "LLM must not be contacted when disabled");
+  assert.equal(result.source, "heuristic");
+  assert.equal(result.fallbackUsed, false);
+  // Memory-seeking question → heuristic "full".
+  assert.equal(result.mode, "full");
+  assert.equal(result.heuristicMode, "full");
+});
+
+test("uses the LLM classification when enabled", async () => {
+  const config = parseConfig({ recallPlannerLlmEnabled: true });
+  const llm = stubLlm({ result: { mode: "graph_mode", reason: "asks for root cause" }, modelUsed: "anthropic/claude" });
+
+  const result = await planRecallModeLLM("restart the gateway", undefined, config, llm);
+
+  assert.equal(result.source, "llm");
+  assert.equal(result.mode, "graph_mode");
+  assert.equal(result.reason, "asks for root cause");
+  assert.equal(result.modelUsed, "anthropic/claude");
+  assert.equal(result.fallbackUsed, false);
+});
+
+test("forwards taskModelChain AND recallPlannerModel in gateway mode (provider-agnostic routing)", async () => {
+  const config = parseConfig({
+    recallPlannerLlmEnabled: true,
+    modelSource: "gateway",
+    gatewayAgentId: "persona-agent",
+    taskModelChain: { primary: "zai/glm-4.7-flash", fallbacks: ["fireworks/x/glm-5p1"] },
+    recallPlannerModel: "anthropic/claude-haiku-4-5",
+  });
+  const captured: Array<Record<string, unknown>> = [];
+  const llm = stubLlm({ capturedOptions: captured, result: { mode: "minimal" } });
+
+  await planRecallModeLLM("check status", undefined, config, llm);
+
+  assert.equal(captured.length, 1);
+  // recallPlannerModel is tried first (prepended), taskModelChain is the fallback chain.
+  assert.equal(captured[0]?.model, "anthropic/claude-haiku-4-5");
+  assert.deepEqual(captured[0]?.modelChain, {
+    primary: "zai/glm-4.7-flash",
+    fallbacks: ["fireworks/x/glm-5p1"],
+  });
+  // taskModelChain wins over the agent persona (gotcha #22).
+  assert.equal(captured[0]?.agentId, undefined);
+  assert.equal(captured[0]?.timeoutMs, config.recallPlannerTimeoutMs);
+});
+
+test("plugin mode passes only the explicit model, no gateway chain", async () => {
+  const config = parseConfig({
+    recallPlannerLlmEnabled: true,
+    modelSource: "plugin",
+    recallPlannerModel: "openai/gpt-5.5",
+  });
+  const captured: Array<Record<string, unknown>> = [];
+  const llm = stubLlm({ capturedOptions: captured, result: { mode: "full" } });
+
+  await planRecallModeLLM("summarize the project", undefined, config, llm);
+
+  assert.equal(captured.length, 1);
+  assert.equal(captured[0]?.model, "openai/gpt-5.5");
+  assert.equal(captured[0]?.modelChain, undefined);
+  assert.equal(captured[0]?.agentId, undefined);
+});
+
+test("falls back to heuristic when the LLM throws", async () => {
+  const config = parseConfig({ recallPlannerLlmEnabled: true });
+  const llm = stubLlm({ throwError: "boom" });
+
+  const result = await planRecallModeLLM("what happened during the outage?", undefined, config, llm);
+
+  assert.equal(result.source, "heuristic-fallback");
+  assert.equal(result.fallbackUsed, true);
+  assert.match(result.reason, /llm-error:boom/);
+  // "what happened" → heuristic graph_mode.
+  assert.equal(result.mode, "graph_mode");
+  assert.equal(result.mode, result.heuristicMode);
+});
+
+test("falls back to heuristic when the LLM returns no parseable result", async () => {
+  const config = parseConfig({ recallPlannerLlmEnabled: true });
+  const llm = stubLlm({ result: null });
+
+  const result = await planRecallModeLLM("how did we get here?", undefined, config, llm);
+
+  assert.equal(result.source, "heuristic-fallback");
+  assert.equal(result.fallbackUsed, true);
+  assert.equal(result.reason, "llm-empty");
+});
+
+test("falls back without a network attempt when the chain is empty and the model is bare (default gpt-5.5)", async () => {
+  // The legacy default recallPlannerModel "gpt-5.5" is bare (no provider/),
+  // which FallbackLlmClient cannot resolve — so with no gateway chain there is
+  // nothing routable and the planner must short-circuit to the heuristic
+  // (issue #1367 review on PR #1428), not log an invalid-model warning per call.
+  const config = parseConfig({ recallPlannerLlmEnabled: true });
+  const captured: Array<Record<string, unknown>> = [];
+  const llm = stubLlm({ available: false, capturedOptions: captured, result: { mode: "full" } });
+
+  const result = await planRecallModeLLM("anything", undefined, config, llm);
+
+  assert.equal(captured.length, 0, "no network attempt when nothing is routable");
+  assert.equal(result.source, "heuristic-fallback");
+  assert.equal(result.fallbackUsed, true);
+  assert.equal(result.reason, "llm-no-model");
+});
+
+test("attempts the call (and falls back) when a provider-qualified model override is set even if the chain is empty", async () => {
+  // A qualified `provider/model` override is genuinely routable, so we attempt
+  // it even when the chain probe reports unavailable, then fall back on a null
+  // response.
+  const config = parseConfig({ recallPlannerLlmEnabled: true, recallPlannerModel: "openai/gpt-5.5" });
+  const captured: Array<Record<string, unknown>> = [];
+  const llm = stubLlm({ available: false, capturedOptions: captured, result: null });
+
+  const result = await planRecallModeLLM("anything", undefined, config, llm);
+
+  assert.equal(captured.length, 1, "qualified model override → still attempt the call");
+  assert.equal(captured[0]?.model, "openai/gpt-5.5");
+  assert.equal(result.source, "heuristic-fallback");
+  assert.equal(result.reason, "llm-empty");
+});
+
+test("an already-aborted recall short-circuits to the heuristic without an LLM call", async () => {
+  const config = parseConfig({ recallPlannerLlmEnabled: true, recallPlannerModel: "openai/gpt-5.5" });
+  const captured: Array<Record<string, unknown>> = [];
+  const llm = stubLlm({ capturedOptions: captured, result: { mode: "full" } });
+  const ac = new AbortController();
+  ac.abort();
+
+  const result = await planRecallModeLLM("what did we decide?", undefined, config, llm, ac.signal);
+
+  assert.equal(captured.length, 0, "no LLM call when the recall is already aborted");
+  assert.equal(result.source, "heuristic-fallback");
+  assert.equal(result.reason, "aborted");
+  assert.equal(result.fallbackUsed, true);
+});
+
+test("forwards the abort signal into the LLM call (cancellation contract)", async () => {
+  const config = parseConfig({ recallPlannerLlmEnabled: true, recallPlannerModel: "openai/gpt-5.5" });
+  const captured: Array<Record<string, unknown>> = [];
+  const llm = stubLlm({ capturedOptions: captured, result: { mode: "minimal" } });
+  const ac = new AbortController();
+
+  await planRecallModeLLM("check status", undefined, config, llm, ac.signal);
+
+  assert.equal(captured.length, 1);
+  assert.equal(captured[0]?.signal, ac.signal, "recall abort signal must reach FallbackLlmClient");
+});
+
+test("empty prompts skip the LLM entirely", async () => {
+  const config = parseConfig({ recallPlannerLlmEnabled: true });
+  const captured: Array<Record<string, unknown>> = [];
+  const llm = stubLlm({ capturedOptions: captured, result: { mode: "full" } });
+
+  const result = await planRecallModeLLM("   ", undefined, config, llm);
+
+  assert.equal(captured.length, 0);
+  assert.equal(result.mode, "no_recall"); // heuristic returns no_recall for empty
+  assert.equal(result.source, "heuristic");
+});
+
+test("resolveRecallPlannerLlmOptions clamps timeout and sets deterministic decoding", () => {
+  const config = parseConfig({ recallPlannerLlmEnabled: true, recallPlannerTimeoutMs: 0 });
+  const options = resolveRecallPlannerLlmOptions(config);
+  assert.equal(options.temperature, 0);
+  assert.equal(options.maxTokens, 64);
+  assert.equal(options.timeoutMs, 1500, "non-positive timeout falls back to 1500");
+});
+
+test("resolveRecallPlannerLlmOptions drops bare model names but keeps provider-qualified ones", () => {
+  // Bare "gpt-5.5" is unresolvable by FallbackLlmClient → dropped (routing falls
+  // through to the chain); a qualified value is forwarded as the override.
+  const bare = resolveRecallPlannerLlmOptions(
+    parseConfig({ recallPlannerLlmEnabled: true, recallPlannerModel: "gpt-5.5" }),
+  );
+  assert.equal(bare.model, undefined);
+  const qualified = resolveRecallPlannerLlmOptions(
+    parseConfig({ recallPlannerLlmEnabled: true, recallPlannerModel: "anthropic/claude-haiku-4-5" }),
+  );
+  assert.equal(qualified.model, "anthropic/claude-haiku-4-5");
+});