@remnic/core 9.3.613 → 9.3.614

package/src/compounding/preference-consolidator.test.ts

@@ -30,6 +30,298 @@ test("consolidatePreferences preserves never-use facts as negative preferences",
   );
 });
 
+test("consolidatePreferences preserves like facts as positive preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user likes React for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers React for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves like-to facts as infinitive preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user would like to use React for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers to use React for dashboards",
+  );
+});
+
+test("consolidatePreferences does not join separate like-to follow-up sentences", () => {
+  const result = consolidatePreferences([
+    memory("The user would like to use React. They moved to Svelte."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(result.preferences[0]?.statement, "The user prefers to use React");
+});
+
+test("consolidatePreferences preserves love facts as positive preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user loves Svelte for prototypes."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers Svelte for prototypes",
+  );
+});
+
+test("consolidatePreferences preserves does-not-love facts as negative preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user does not love React for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user would not prefer React for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves did-not-love facts as negative preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user did not love React for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user would not prefer React for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves would-not-love facts as negative preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user would not love React for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user would not prefer React for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves would-not-like-to facts as negative preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user would not like to use React for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user would not prefer to use React for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves no-longer-loves facts as negative preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user no longer loves React."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(result.preferences[0]?.statement, "The user would not prefer React");
+});
+
+test("consolidatePreferences preserves disliked facts as negative preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user disliked React for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user would not prefer React for dashboards",
+  );
+});
+
+test("consolidatePreferences ignores double-negated dislike facts", () => {
+  const result = consolidatePreferences([
+    memory("The user does not dislike React."),
+  ]);
+
+  assert.equal(result.preferences.length, 0);
+});
+
+test("consolidatePreferences ignores repeated double-negated dislike facts", () => {
+  const result = consolidatePreferences([
+    memory("The user does not dislike React and does not dislike Svelte."),
+  ]);
+
+  assert.equal(result.preferences.length, 0);
+});
+
+test("consolidatePreferences preserves explicit preferences after double-negated aversion", () => {
+  const result = consolidatePreferences([
+    memory("The user does not dislike React, but prefers Svelte for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers Svelte for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves replacement love clauses after withdrawn preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user did not love React but now loves Svelte for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers Svelte for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves short replacement love clauses after withdrawn preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user did not love React but now loves Go."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(result.preferences[0]?.statement, "The user prefers Go");
+});
+
+test("consolidatePreferences preserves and-now replacement clauses after withdrawn preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user did not love React, and now loves Svelte for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers Svelte for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves plain-and replacement clauses after withdrawn preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user did not love React and loves Svelte for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers Svelte for dashboards",
+  );
+});
+
+test("consolidatePreferences keeps compound negated-use clauses negative", () => {
+  const result = consolidatePreferences([
+    memory("The user does not use React and uses Svelte for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(result.preferences[0]?.statement, "The user would not prefer React");
+});
+
+test("consolidatePreferences preserves replacement like-to clauses after withdrawn preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user did not love React but like to use Svelte for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers to use Svelte for dashboards",
+  );
+});
+
+test("consolidatePreferences preserves replacement enjoying clauses after withdrawn preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user did not love React but enjoying Svelte dashboard work."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers: enjoying Svelte dashboard work",
+  );
+});
+
+test("consolidatePreferences preserves replacement use clauses after withdrawn preferences", () => {
+  const result = consolidatePreferences([
+    memory("The user did not love React but now uses Svelte for dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers to use Svelte for dashboards",
+  );
+});
+
+test("consolidatePreferences still admits preference stem variants in facts", () => {
+  const result = consolidatePreferences([
+    memory("The user is enjoying Svelte specialization work."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user is enjoying Svelte specialization work",
+  );
+});
+
+test("consolidatePreferences ignores like analogies in facts", () => {
+  const result = consolidatePreferences([
+    memory("The user said Next.js is like React."),
+  ]);
+
+  assert.equal(result.preferences.length, 0);
+});
+
+test("consolidatePreferences ignores stale past-tense liked facts", () => {
+  const result = consolidatePreferences([
+    memory("The user liked Angular before switching to React."),
+  ]);
+
+  assert.equal(result.preferences.length, 0);
+});
+
+test("consolidatePreferences preserves multiline use-for facts", () => {
+  const result = consolidatePreferences([
+    memory("The user uses React\nfor dashboards."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers to use React for dashboards",
+  );
+});
+
+test("consolidatePreferences does not join separate use and movement sentences", () => {
+  const result = consolidatePreferences([
+    memory("The user uses React.\nThey moved to Svelte."),
+  ]);
+
+  assert.equal(result.preferences.length, 0);
+});
+
+test("consolidatePreferences preserves a first use clause before later sentences", () => {
+  const result = consolidatePreferences([
+    memory("The user uses React for dashboards.\nThey moved to Svelte."),
+  ]);
+
+  assert.equal(result.preferences.length, 1);
+  assert.equal(
+    result.preferences[0]?.statement,
+    "The user prefers to use React for dashboards",
+  );
+});
+
 test("consolidatePreferences preserves does-not-use facts as negative preferences", () => {
   const result = consolidatePreferences([
     memory("The user does not use React for dashboards."),

package/src/compounding/preference-consolidator.ts

@@ -48,15 +48,24 @@ const PREFERENCE_EXTRACTORS: Array<{
 }> = [
   // "Avoids X" / negated use/work/code statements → negative preference
   {
-    pattern: /(?:avoids?|dislikes?|hates?|does\s+not\s+like|doesn'?t\s+like|never\s+uses?|does\s+not\s+uses?|doesn'?t\s+uses?|does\s+not\s+use|doesn'?t\s+use|never\s+works?\s+(?:with|in)|does\s+not\s+works?\s+(?:with|in)|doesn'?t\s+works?\s+(?:with|in)|never\s+codes?\s+(?:in|with)|does\s+not\s+codes?\s+(?:in|with)|doesn'?t\s+codes?\s+(?:in|with)|refuses\s+to\s+(?:use|work\s+(?:with|in)|code\s+(?:in|with)))\s+(.+?)$/im,
+    pattern: /(?:avoids?|avoided|dislikes?|disliked|hates?|hated|does\s+not\s+(?:prefer|like|love|enjoy|favou?r)s?|doesn'?t\s+(?:prefer|like|love|enjoy|favou?r)s?|did\s+not\s+(?:prefer|like|love|enjoy|favou?r)s?|didn'?t\s+(?:prefer|like|love|enjoy|favou?r)s?|would\s+not\s+(?:prefer|like|love|enjoy|favou?r)s?|wouldn'?t\s+(?:prefer|like|love|enjoy|favou?r)s?|won'?t\s+(?:prefer|like|love|enjoy|favou?r)s?|never\s+(?:prefers?|likes?|loves?|enjoys?|favou?rs?)|no\s+longer\s+(?:prefers?|likes?|loves?|enjoys?|favou?rs?)|never\s+uses?|does\s+not\s+uses?|doesn'?t\s+uses?|does\s+not\s+use|doesn'?t\s+use|would\s+not\s+use|wouldn'?t\s+use|won'?t\s+use|never\s+works?\s+(?:with|in)|does\s+not\s+works?\s+(?:with|in)|doesn'?t\s+works?\s+(?:with|in)|would\s+not\s+works?\s+(?:with|in)|wouldn'?t\s+works?\s+(?:with|in)|won'?t\s+works?\s+(?:with|in)|never\s+codes?\s+(?:in|with)|does\s+not\s+codes?\s+(?:in|with)|doesn'?t\s+codes?\s+(?:in|with)|would\s+not\s+codes?\s+(?:in|with)|wouldn'?t\s+codes?\s+(?:in|with)|won'?t\s+codes?\s+(?:in|with)|refuses\s+to\s+(?:use|work\s+(?:with|in)|code\s+(?:in|with)))\s+([^.!?]+?)(?=\s+(?:(?:but|however|though|although|except|instead|rather)\b|and\s+(?:(?:now|currently|instead|rather)\b|(?=(?:prefer\w*|enjoy\w*|likes|like\s+to|loves?|loving|favou?r\w*|uses?|works?\s+(?:with|in)|codes?\s+(?:in|with)|interested\s+in|passionate\s+about|focused\s+on|specializ\w*)\b)))|[.!?]|$)/im,
     transform: (match) => {
       const subject = match[1].replace(/\.$/, "").trim();
       return `The user would not prefer ${subject}`;
     },
   },
+  // "Would like to X" / "like to X" → preference for doing X
+  {
+    pattern: /\blikes?\s+to\s+([^.!?]+?)(?:\s+(?:for|when|in|over)\s+([^.!?]+?))?(?=[.!?]|$)/im,
+    transform: (match) => {
+      const action = match[1].replace(/\.$/, "").trim();
+      const context = match[2] ? ` for ${match[2].replace(/\.$/, "").trim()}` : "";
+      return `The user prefers to ${action}${context}`;
+    },
+  },
   // Direct preference statements
   {
-    pattern: /(?:prefers?|enjoys?|likes?|loves?|favou?rs?)\s+(.+?)(?:\s+(?:for|when|in|over)\s+(.+?))?$/im,
+    pattern: /\b(?:prefers?|enjoys?|likes|loves?|loving|favou?rs?)\s+(.+?)(?:\s+(?:for|when|in|over)\s+(.+?))?$/im,
     transform: (match) => {
       const subject = match[1].replace(/\.$/, "").trim();
       const context = match[2] ? ` for ${match[2].replace(/\.$/, "").trim()}` : "";
@@ -65,10 +74,12 @@ const PREFERENCE_EXTRACTORS: Array<{
   },
   // "Uses X for Y" → preference for X in Y context
   {
-    pattern: /(?:uses?|works?\s+(?:with|in)|codes?\s+(?:in|with))\s+(.+?)(?:\s+(?:for|to|when)\s+(.+?))?$/im,
+    pattern: /(?:uses?|works?\s+(?:with|in)|codes?\s+(?:in|with))\s+([^.!?]+?)(?:\s+(?:for|to|when)\s+([^.!?]+?))?(?=[.!?]|$)/i,
     transform: (match) => {
-      const tool = match[1].replace(/\.$/, "").trim();
-      const context = match[2] ? ` for ${match[2].replace(/\.$/, "").trim()}` : "";
+      const tool = match[1].replace(/\s+/g, " ").replace(/\.$/, "").trim();
+      const context = match[2]
+        ? ` for ${match[2].replace(/\s+/g, " ").replace(/\.$/, "").trim()}`
+        : "";
       return `The user prefers to use ${tool}${context}`;
     },
   },
@@ -91,6 +102,26 @@ const PREFERENCE_EXTRACTORS: Array<{
   },
 ];
 
+const FACT_PREFERENCE_LANGUAGE_PATTERN =
+  /\b(?:prefer\w*|enjoy\w*|likes|like\s+to|loves?|loving|favou?r\w*|avoid\w*|dislik\w*|hat(?:e|es|ed|ing)|interested\s+in|passionate\s+about|specializ\w*|go-to)\b/i;
+const FACT_USE_CONTEXT_PATTERN =
+  /\b(?:uses?|works?\s+(?:with|in)|codes?\s+(?:in|with))\b[^.!?]+\b(?:for|to|when)\b/i;
+const DOUBLE_NEGATED_AVERSION_PATTERN =
+  /\b(?:does\s+not|doesn'?t|did\s+not|didn'?t|never|no\s+longer)\s+(?:avoids?|avoided|dislikes?|disliked|hates?|hated)\b/i;
+const DOUBLE_NEGATED_AVERSION_GLOBAL_PATTERN =
+  /\b(?:does\s+not|doesn'?t|did\s+not|didn'?t|never|no\s+longer)\s+(?:avoids?|avoided|dislikes?|disliked|hates?|hated)\b/gi;
+const WITHDRAWN_PREFERENCE_PATTERN =
+  /\b(?:avoids?|avoided|dislikes?|disliked|hates?|hated|does\s+not\s+(?:prefer|like|love|enjoy|favou?r)s?|doesn'?t\s+(?:prefer|like|love|enjoy|favou?r)s?|did\s+not\s+(?:prefer|like|love|enjoy|favou?r)s?|didn'?t\s+(?:prefer|like|love|enjoy|favou?r)s?|would\s+not\s+(?:prefer|like|love|enjoy|favou?r)s?|wouldn'?t\s+(?:prefer|like|love|enjoy|favou?r)s?|won'?t\s+(?:prefer|like|love|enjoy|favou?r)s?|never\s+(?:prefers?|likes?|loves?|enjoys?|favou?rs?)|no\s+longer\s+(?:prefers?|likes?|loves?|enjoys?|favou?rs?))\b/i;
+const REPLACEMENT_PREFERENCE_CLAUSE_PATTERN =
+  /\b(?:(?:but|however|though|although)\s+(?:now\s+|currently\s+|instead\s+|rather\s+)?|and\s+(?:now\s+|currently\s+|instead\s+|rather\s+)?)(?=(?:prefer\w*|enjoy\w*|likes|like\s+to|loves?|loving|favou?r\w*|uses?|works?\s+(?:with|in)|codes?\s+(?:in|with)|interested\s+in|passionate\s+about|focused\s+on|specializ\w*)\b)/i;
+
+function replacementPreferenceClause(content: string): string | null {
+  const match = REPLACEMENT_PREFERENCE_CLAUSE_PATTERN.exec(content);
+  if (!match) return null;
+  const clause = content.slice(match.index + match[0].length).trim();
+  return clause.replace(/[.!?]+$/, "").trim().length > 0 ? clause : null;
+}
+
 /**
  * Fallback: convert any preference/correction memory content into a
  * "The user prefers..." statement by prepending a suitable prefix.
@@ -184,17 +215,9 @@ export function consolidatePreferences(
     if (m.frontmatter.category !== "fact") return false;
     if (m.frontmatter.status && m.frontmatter.status !== "active") return false;
     if ((m.frontmatter.confidence ?? 0) < minConfidence) return false;
-    const lower = m.content.toLowerCase();
     return (
-      lower.includes("prefer") ||
-      lower.includes("enjoy") ||
-      lower.includes("like to") ||
-      lower.includes("interested in") ||
-      lower.includes("passionate about") ||
-      lower.includes("specializ") ||
-      lower.includes("favourite") ||
-      lower.includes("favorite") ||
-      (lower.includes("use") && lower.includes("for"))
+      FACT_PREFERENCE_LANGUAGE_PATTERN.test(m.content) ||
+      FACT_USE_CONTEXT_PATTERN.test(m.content)
     );
   });
 
@@ -225,24 +248,37 @@ export function consolidatePreferences(
 
   for (const mem of deduped.slice(0, maxPreferences * 2)) {
     const content = mem.content.trim();
+    const hasDoubleNegatedAversion = DOUBLE_NEGATED_AVERSION_PATTERN.test(content);
+    const hasWithdrawnPreference = WITHDRAWN_PREFERENCE_PATTERN.test(content);
+    const strippedContent = hasDoubleNegatedAversion
+      ? content.replace(DOUBLE_NEGATED_AVERSION_GLOBAL_PATTERN, " ").trim()
+      : content;
+    const replacementContent = hasWithdrawnPreference
+      ? replacementPreferenceClause(strippedContent)
+      : null;
+    const extractionContent = replacementContent ?? strippedContent;
     let statement: string | null = null;
 
     // Try pattern-based extraction first
     for (const extractor of PREFERENCE_EXTRACTORS) {
-      const match = content.match(extractor.pattern);
+      const match = extractionContent.match(extractor.pattern);
       if (match) {
-        statement = extractor.transform(match, content);
+        statement = extractor.transform(match, extractionContent);
         break;
       }
     }
 
+    if (!statement && hasDoubleNegatedAversion) {
+      continue;
+    }
+
     // Fallback: generic prefix
     if (!statement) {
-      statement = fallbackPreferenceStatement(content, mem.frontmatter.category);
+      statement = fallbackPreferenceStatement(replacementContent ?? content, mem.frontmatter.category);
     }
 
     // Skip if statement is too short or too generic
-    if (statement.length < 20) continue;
+    if (statement.length < 20 && !replacementContent) continue;
 
     const keywords = extractKeywords(statement);
 

package/src/config.test.ts

@@ -3,6 +3,63 @@ import test from "node:test";
 
 import { parseConfig } from "./config.js";
 
+test("parseConfig emitLegacyTools defaults to true and coerces config/env (issue #1427)", () => {
+  // Default: legacy aliases on, for backward compatibility.
+  assert.equal(parseConfig({}).emitLegacyTools, true);
+  // `null` means "unset → use default", consistent with the repo convention for
+  // optional fields (e.g. taskModelChain: null → undefined). Not a hard error.
+  assert.equal(parseConfig({ emitLegacyTools: null }).emitLegacyTools, true);
+  // Boolean + boolean-like string config values.
+  assert.equal(parseConfig({ emitLegacyTools: false }).emitLegacyTools, false);
+  assert.equal(parseConfig({ emitLegacyTools: "false" }).emitLegacyTools, false);
+  assert.equal(parseConfig({ emitLegacyTools: "0" }).emitLegacyTools, false);
+  assert.equal(parseConfig({ emitLegacyTools: "true" }).emitLegacyTools, true);
+
+  // Env var fallback (REMNIC_ preferred, ENGRAM_ legacy) when config field absent.
+  const prevRemnic = process.env.REMNIC_EMIT_LEGACY_TOOLS;
+  const prevEngram = process.env.ENGRAM_EMIT_LEGACY_TOOLS;
+  try {
+    process.env.REMNIC_EMIT_LEGACY_TOOLS = "false";
+    assert.equal(parseConfig({}).emitLegacyTools, false, "REMNIC_ env disables");
+    // Explicit config field wins over env.
+    assert.equal(parseConfig({ emitLegacyTools: true }).emitLegacyTools, true, "config field wins over env");
+    delete process.env.REMNIC_EMIT_LEGACY_TOOLS;
+    process.env.ENGRAM_EMIT_LEGACY_TOOLS = "false";
+    assert.equal(parseConfig({}).emitLegacyTools, false, "ENGRAM_ env fallback disables");
+  } finally {
+    if (prevRemnic === undefined) delete process.env.REMNIC_EMIT_LEGACY_TOOLS;
+    else process.env.REMNIC_EMIT_LEGACY_TOOLS = prevRemnic;
+    if (prevEngram === undefined) delete process.env.ENGRAM_EMIT_LEGACY_TOOLS;
+    else process.env.ENGRAM_EMIT_LEGACY_TOOLS = prevEngram;
+  }
+});
+
+test("parseConfig rejects a present-but-malformed emitLegacyTools (gotcha #51, #1427)", () => {
+  // A typo must fail fast, not silently fall through to the default (true) and
+  // re-enable legacy tool advertising.
+  for (const bad of ["fales", "maybe", 2, "2", "enabled"]) {
+    assert.throws(
+      () => parseConfig({ emitLegacyTools: bad }),
+      /emitLegacyTools must be a boolean-like value/,
+      `emitLegacyTools=${JSON.stringify(bad)} should throw`,
+    );
+  }
+  // Malformed env var also fails fast (only when the config field is absent).
+  const prev = process.env.REMNIC_EMIT_LEGACY_TOOLS;
+  try {
+    process.env.REMNIC_EMIT_LEGACY_TOOLS = "maybe";
+    assert.throws(
+      () => parseConfig({}),
+      /REMNIC_EMIT_LEGACY_TOOLS must be a boolean-like value/,
+    );
+    // An explicit valid config field overrides a malformed env (field wins first).
+    assert.equal(parseConfig({ emitLegacyTools: false }).emitLegacyTools, false);
+  } finally {
+    if (prev === undefined) delete process.env.REMNIC_EMIT_LEGACY_TOOLS;
+    else process.env.REMNIC_EMIT_LEGACY_TOOLS = prev;
+  }
+});
+
 test("parseConfig expands tilde paths for core storage directories", () => {
   const previousHome = process.env.HOME;
   process.env.HOME = "/Users/remnic-test";
@@ -72,6 +129,33 @@ test("parseConfig codex missing entirely → installExtension defaults to true",
   assert.equal(result.codex.installExtension, true);
 });
 
+test("parseConfig recallPlannerLlmEnabled defaults to false and coerces boolean-like strings (opt-in, issue #1367)", () => {
+  assert.equal(parseConfig({}).recallPlannerLlmEnabled, false);
+  assert.equal(parseConfig({ recallPlannerLlmEnabled: true }).recallPlannerLlmEnabled, true);
+  // CLI/env surfaces pass strings — these must enable the gate (gotcha #36).
+  assert.equal(parseConfig({ recallPlannerLlmEnabled: "true" }).recallPlannerLlmEnabled, true);
+  assert.equal(parseConfig({ recallPlannerLlmEnabled: "1" }).recallPlannerLlmEnabled, true);
+  assert.equal(parseConfig({ recallPlannerLlmEnabled: "on" }).recallPlannerLlmEnabled, true);
+  // Boolean-like falses and junk stay off.
+  assert.equal(parseConfig({ recallPlannerLlmEnabled: "false" }).recallPlannerLlmEnabled, false);
+  assert.equal(parseConfig({ recallPlannerLlmEnabled: "0" }).recallPlannerLlmEnabled, false);
+});
+
+test("parseConfig coerces boolean-like strings for all recallPlanner gates (issue #1367, gotcha #36)", () => {
+  // Rollout switches must honor string config from CLI/env surfaces.
+  assert.equal(parseConfig({ recallPlannerShadowMode: "true" }).recallPlannerShadowMode, true);
+  assert.equal(parseConfig({ recallPlannerShadowMode: "off" }).recallPlannerShadowMode, false);
+  assert.equal(parseConfig({}).recallPlannerShadowMode, false);
+
+  assert.equal(parseConfig({ recallPlannerTelemetryEnabled: "false" }).recallPlannerTelemetryEnabled, false);
+  assert.equal(parseConfig({}).recallPlannerTelemetryEnabled, true);
+
+  // The enable gate must be disableable via string "false" (the old `!== false`
+  // check treated "false" as truthy → could not disable).
+  assert.equal(parseConfig({ recallPlannerEnabled: "false" }).recallPlannerEnabled, false);
+  assert.equal(parseConfig({}).recallPlannerEnabled, true);
+});
+
 test("parseConfig dreaming.maxEntries=0 preserves the runtime disable switch", () => {
   const result = parseConfig({ dreaming: { maxEntries: 0 } });
   assert.equal(result.dreaming.maxEntries, 0);
@@ -116,6 +200,59 @@ test("parseConfig initGateTimeoutMs defaults to OpenClaw cold-start budget", ()
   assert.equal(result.initGateTimeoutMs, 30_000);
 });
 
+test("parseConfig qmdSearchStrategy defaults to hybrid and validates the enum", () => {
+  // Default must equal the historical lex+vec+hyde behavior. Issue #1335.
+  assert.equal(parseConfig({}).qmdSearchStrategy, "hybrid");
+  assert.equal(parseConfig({ qmdSearchStrategy: "hybrid" }).qmdSearchStrategy, "hybrid");
+  assert.equal(parseConfig({ qmdSearchStrategy: "lex-vec" }).qmdSearchStrategy, "lex-vec");
+  assert.equal(parseConfig({ qmdSearchStrategy: "lex" }).qmdSearchStrategy, "lex");
+  assert.equal(parseConfig({ qmdSearchStrategy: "LEX" }).qmdSearchStrategy, "lex");
+
+  for (const value of ["hyde", "vec", "bm25", "", 42]) {
+    assert.throws(
+      () => parseConfig({ qmdSearchStrategy: value }),
+      /qmdSearchStrategy must be one of/,
+      `invalid qmdSearchStrategy ${String(value)} should throw`,
+    );
+  }
+});
+
+test("parseConfig qmdSubprocessStrategy defaults to query (honors QMD query intent)", () => {
+  // Default must remain `qmd query` (LLM expansion + rerank) per CLAUDE.md gotcha #7.
+  assert.equal(parseConfig({}).qmdSubprocessStrategy, "query");
+  assert.equal(parseConfig({ qmdSubprocessStrategy: "query" }).qmdSubprocessStrategy, "query");
+  assert.equal(parseConfig({ qmdSubprocessStrategy: "search" }).qmdSubprocessStrategy, "search");
+  assert.equal(parseConfig({ qmdSubprocessStrategy: "SEARCH" }).qmdSubprocessStrategy, "search");
+
+  for (const value of ["bm25", "vsearch", "", 7]) {
+    assert.throws(
+      () => parseConfig({ qmdSubprocessStrategy: value }),
+      /qmdSubprocessStrategy must be one of/,
+      `invalid qmdSubprocessStrategy ${String(value)} should throw`,
+    );
+  }
+});
+
+test("parseConfig qmdDaemonTimeoutMs defaults to 8000 and clamps valid integers", () => {
+  assert.equal(parseConfig({}).qmdDaemonTimeoutMs, 8_000);
+  assert.equal(parseConfig({ qmdDaemonTimeoutMs: 20_000 }).qmdDaemonTimeoutMs, 20_000);
+  assert.equal(parseConfig({ qmdDaemonTimeoutMs: "20000" }).qmdDaemonTimeoutMs, 20_000);
+  // Below floor clamps up; above ceiling clamps down.
+  assert.equal(parseConfig({ qmdDaemonTimeoutMs: 100 }).qmdDaemonTimeoutMs, 1_000);
+  assert.equal(parseConfig({ qmdDaemonTimeoutMs: 999_999 }).qmdDaemonTimeoutMs, 120_000);
+});
+
+test("parseConfig qmdDaemonTimeoutMs rejects non-numeric and non-integer input", () => {
+  // gotcha #51 + codex review on #1422: silent coercion hides config mistakes.
+  for (const value of ["abc", "", 2500.9, "2500.9", Number.NaN, Infinity, true, {}]) {
+    assert.throws(
+      () => parseConfig({ qmdDaemonTimeoutMs: value }),
+      /qmdDaemonTimeoutMs must be an integer/,
+      `invalid qmdDaemonTimeoutMs ${String(value)} should throw`,
+    );
+  }
+});
+
 test("parseConfig initGateTimeoutMs accepts CLI-style numeric strings", () => {
   const result = parseConfig({ initGateTimeoutMs: "45000" });
   assert.equal(result.initGateTimeoutMs, 45_000);
@@ -140,6 +277,82 @@ test("parseConfig modelSource=gateway does not inherit OPENAI_API_KEY from the p
   }
 });
 
+test("parseConfig normalizes taskModelChain", () => {
+  const cfg = parseConfig({
+    taskModelChain: {
+      primary: " openai/cheap-primary ",
+      fallbacks: ["openai/cheap-primary", " fireworks/accounts/fireworks/models/glm-5p1 ", ""],
+    },
+  });
+
+  assert.deepEqual(cfg.taskModelChain, {
+    primary: "openai/cheap-primary",
+    fallbacks: ["fireworks/accounts/fireworks/models/glm-5p1"],
+  });
+});
+
+test("parseConfig treats an absent taskModelChain as not configured", () => {
+  assert.equal(parseConfig({}).taskModelChain, undefined);
+  assert.equal(parseConfig({ taskModelChain: null }).taskModelChain, undefined);
+  assert.equal(parseConfig({ taskModelChain: undefined }).taskModelChain, undefined);
+});
+
+test("parseConfig rejects a present-but-malformed taskModelChain (gotcha #51)", () => {
+  // A typo'd chain must surface loudly instead of silently reverting to defaults.
+  assert.throws(() => parseConfig({ taskModelChain: [] }), /taskModelChain must be an object/);
+  assert.throws(() => parseConfig({ taskModelChain: "openai/x" }), /taskModelChain must be an object/);
+  assert.throws(() => parseConfig({ taskModelChain: { primary: " " } }), /taskModelChain\.primary is required/);
+  assert.throws(() => parseConfig({ taskModelChain: { fallbacks: ["openai/fallback-only"] } }), /taskModelChain\.primary is required/);
+  assert.throws(
+    () => parseConfig({ taskModelChain: { primary: "openai/p", fallbacks: "not-an-array" } }),
+    /taskModelChain\.fallbacks must be an array/,
+  );
+  assert.throws(
+    () => parseConfig({ taskModelChain: { primary: "openai/p", fallbacks: [123] } }),
+    /taskModelChain\.fallbacks must contain only strings/,
+  );
+});
+
+test("parseConfig rejects unqualified taskModelChain model strings (codex review #1425)", () => {
+  // A slash-less id like "gpt-4.1" parses here but FallbackLlmClient.parseModelString
+  // drops it, leaving the chain silently using a different model — reject at parse.
+  assert.throws(
+    () => parseConfig({ taskModelChain: { primary: "gpt-4.1" } }),
+    /taskModelChain\.primary must be in "provider\/model" form/,
+  );
+  assert.throws(
+    () => parseConfig({ taskModelChain: { primary: "openai/" } }),
+    /taskModelChain\.primary must be in "provider\/model" form/,
+  );
+  assert.throws(
+    () => parseConfig({ taskModelChain: { primary: "/gpt-4.1" } }),
+    /taskModelChain\.primary must be in "provider\/model" form/,
+  );
+  assert.throws(
+    () => parseConfig({ taskModelChain: { primary: "openai/gpt", fallbacks: ["bare-model"] } }),
+    /taskModelChain\.fallbacks entries must be in "provider\/model" form/,
+  );
+  // Multi-slash provider/model paths remain valid.
+  assert.deepEqual(
+    parseConfig({
+      taskModelChain: { primary: "fireworks/accounts/fireworks/models/glm-5p1" },
+    }).taskModelChain,
+    { primary: "fireworks/accounts/fireworks/models/glm-5p1" },
+  );
+});
+
+test("parseConfig rejects unknown taskModelChain keys (codex review #1425)", () => {
+  // A misspelled "fallback" must not silently drop the fallback chain.
+  assert.throws(
+    () => parseConfig({ taskModelChain: { primary: "openai/p", fallback: ["openai/q"] } }),
+    /taskModelChain has unknown property: fallback/,
+  );
+  assert.throws(
+    () => parseConfig({ taskModelChain: { primary: "openai/p", fallbackModels: ["openai/q"], extra: 1 } }),
+    /taskModelChain has unknown properties:/,
+  );
+});
+
 test("parseConfig modelSource=gateway still honors an explicit openaiApiKey override", () => {
   const original = process.env.OPENAI_API_KEY;
   process.env.OPENAI_API_KEY = "sk-env-should-not-be-used";