clawmem 0.11.0 → 0.11.2

package/AGENTS.md

@@ -546,7 +546,7 @@ User Query + optional intent hint
   → Temporal Extraction (regex date range from query: "last week", "March 2026" → WHERE modified_at BETWEEN filters)
   → BM25 Probe → Strong Signal Check (skip expansion if top hit ≥ 0.85 with gap ≥ 0.15; disabled when intent provided)
   → Query Expansion (LLM generates text variants; intent steers expansion prompt)
-  → Parallel: BM25(original) + Vector(original) + BM25(each expanded) + Vector(each expanded)
+  → Parallel (typed routing): BM25(original) + Vector(original) + BM25(lex expansions) + Vector(vec/hyde expansions)
        + Temporal Proximity (date-range filtered, if temporal constraint extracted)
        + Entity Graph (conditional 1-hop entity walk from top seeds, if entity signals present)
   → Original query lists get positional 2× weight in RRF; expanded get 1×

package/CLAUDE.md

@@ -546,7 +546,7 @@ User Query + optional intent hint
   → Temporal Extraction (regex date range from query: "last week", "March 2026" → WHERE modified_at BETWEEN filters)
   → BM25 Probe → Strong Signal Check (skip expansion if top hit ≥ 0.85 with gap ≥ 0.15; disabled when intent provided)
   → Query Expansion (LLM generates text variants; intent steers expansion prompt)
-  → Parallel: BM25(original) + Vector(original) + BM25(each expanded) + Vector(each expanded)
+  → Parallel (typed routing): BM25(original) + Vector(original) + BM25(lex expansions) + Vector(vec/hyde expansions)
        + Temporal Proximity (date-range filtered, if temporal constraint extracted)
        + Entity Graph (conditional 1-hop entity walk from top seeds, if entity signals present)
   → Original query lists get positional 2× weight in RRF; expanded get 1×

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "clawmem",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "On-device memory layer for AI agents. Claude Code, OpenClaw, and Hermes. Hooks + MCP server + hybrid RAG search.",
   "type": "module",
   "bin": {
-    "clawmem": "./bin/clawmem"
+    "clawmem": "bin/clawmem"
   },
   "files": [
     "bin/",

package/src/clawmem.ts

@@ -13,6 +13,7 @@ import {
   canonicalDocId,
   type Store,
   type SearchResult,
+  type ExpandedQuery,
   DEFAULT_EMBED_MODEL,
   DEFAULT_QUERY_MODEL,
   DEFAULT_RERANK_MODEL,
@@ -939,19 +940,13 @@ async function cmdQuery(args: string[]) {
   const secondScore = ftsResults[1]?.score ?? 0;
   const strongSignal = topScore >= 0.85 && (topScore - secondScore) >= 0.15;
 
-  // Step 2: Query expansion (skip if strong BM25 signal)
-  let expandedQueries: { type: string; text: string }[] = [];
+  // Step 2: Query expansion (skip if strong BM25 signal). expandQuery now returns
+  // typed ExpandedQuery[] (lex/vec/hyde) — no more brittle string re-parsing, and
+  // the original query is no longer echoed back as a phantom "vec" expansion.
+  let expandedQueries: ExpandedQuery[] = [];
   if (!strongSignal) {
     try {
-      const expanded = await s.expandQuery(query, DEFAULT_QUERY_MODEL);
-      expandedQueries = expanded.map(text => {
-        // Parse "type: text" format from expansion
-        const colonIdx = text.indexOf(": ");
-        if (colonIdx > 0 && colonIdx < 5) {
-          return { type: text.slice(0, colonIdx), text: text.slice(colonIdx + 2) };
-        }
-        return { type: "vec", text };
-      });
+      expandedQueries = await s.expandQuery(query, DEFAULT_QUERY_MODEL);
     } catch {
       // Fallback: no expansion
     }
@@ -959,20 +954,27 @@ async function cmdQuery(args: string[]) {
 
   // Step 3: Parallel searches
   const allRanked: { results: RankedResult[]; weight: number }[] = [];
+  // Retain the raw SearchResult from every leg (original + typed expansions) so a
+  // candidate found ONLY via an expansion leg survives Step 8's resultMap lookup.
+  const candidateResults: SearchResult[] = [];
 
   // Original query BM25 + vec (weight 2x)
   allRanked.push({ results: ftsResults.map(toRanked), weight: 2 });
+  candidateResults.push(...ftsResults);
   const vecResults = await s.searchVec(query, DEFAULT_EMBED_MODEL, 20);
   allRanked.push({ results: vecResults.map(toRanked), weight: 2 });
+  candidateResults.push(...vecResults);
 
-  // Expanded queries (weight 1x)
+  // Expanded queries (weight 1x): lex → FTS, vec/hyde → vector
   for (const eq of expandedQueries) {
     if (eq.type === "lex") {
-      const r = s.searchFTS(eq.text, 20);
+      const r = s.searchFTS(eq.query, 20);
       allRanked.push({ results: r.map(toRanked), weight: 1 });
+      candidateResults.push(...r);
     } else {
-      const r = await s.searchVec(eq.text, DEFAULT_EMBED_MODEL, 20);
+      const r = await s.searchVec(eq.query, DEFAULT_EMBED_MODEL, 20);
       allRanked.push({ results: r.map(toRanked), weight: 1 });
+      candidateResults.push(...r);
     }
   }
 
@@ -1009,9 +1011,10 @@ async function cmdQuery(args: string[]) {
   });
   blended.sort((a, b) => b.score - a.score);
 
-  // Step 8: Map back to full results and apply composite scoring
+  // Step 8: Map back to full results and apply composite scoring. Build the map from
+  // ALL legs (incl. typed expansions) so expansion-only candidates aren't dropped.
   const resultMap = new Map(
-    [...ftsResults, ...vecResults].map(r => [r.filepath, r])
+    candidateResults.map(r => [r.filepath, r])
   );
   const fullResults = blended
     .map(b => resultMap.get(b.file))

package/src/hooks/context-surfacing.ts

@@ -264,8 +264,14 @@ export async function contextSurfacing(
           const seen = new Set(results.map(r => r.filepath));
           for (const eq of expanded.slice(0, 3)) {
             if (Date.now() - startTime > 6000) break; // hard stop at 6s
-            const ftsExp = store.searchFTS(eq, 5);
-            for (const r of ftsExp) {
+            // Typed routing: lex → FTS; vec/hyde → vector (deep profile + time budget only).
+            let hits: SearchResult[] = [];
+            if (eq.type === 'lex') {
+              hits = store.searchFTS(eq.query, 5);
+            } else if (profile.useVector) {
+              try { hits = await store.searchVec(eq.query, DEFAULT_EMBED_MODEL, 5); } catch { /* vector leg non-fatal */ }
+            }
+            for (const r of hits) {
               if (!seen.has(r.filepath)) {
                 seen.add(r.filepath);
                 results.push(r);

package/src/llm.ts

@@ -141,6 +141,88 @@ export type Queryable = {
   text: string;
 };
 
+/**
+ * Template-residue / leak patterns that indicate an expansion line is NOT a real
+ * query. The qmd-query-expansion finetune, when prompted out of distribution,
+ * echoed the old verbose prompt's format hints and leaked Qwen3 thinking tags;
+ * these never belong in a search query. Kept as a defensive guard even though the
+ * terse QMD-faithful prompt (expandQueryRemote, 2026-06-23) fixed generation.
+ */
+const EXPANSION_JUNK_PATTERNS: RegExp[] = [
+  /<\/?think>/i,
+  /keyword search terms \(/i,
+  /semantic search queries \(/i,
+  /hypothetical document passage that answers the query/i,
+];
+
+/** True if an expansion text is empty or matches a known template-residue pattern. */
+export function isJunkExpansion(text: string): boolean {
+  const t = text.trim();
+  if (!t) return true;
+  return EXPANSION_JUNK_PATTERNS.some(re => re.test(t));
+}
+
+/**
+ * Strip stray Qwen3 `/no_think` / `/think` control tokens the model sometimes
+ * echoes mid-line (generateRemote appends ` /no_think`, and the finetune can copy
+ * it into a hyde passage). Only matches the token when it stands alone (start/space
+ * bounded) so real paths like `src/think.ts` are never touched. Unlike the `<think>`
+ * tag (which signals reasoning leakage → whole line rejected), a stray control token
+ * just gets cleaned out so the otherwise-good line survives.
+ */
+function stripControlTokens(text: string): string {
+  return text.replace(/(?:^|\s)\/(?:no_)?think(?=\s|$)/gi, " ").replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Shared guard for query-expansion output. Drops empty / template-residue /
+ * think-tag lines and de-duplicates by (type, text). Used by BOTH the llm.ts
+ * parsers and the store.ts wrapper (defense-in-depth across every provider).
+ * Does NOT inject a fallback — callers decide what to do with an empty result,
+ * and does NOT require the original query terms to appear (that would reject
+ * legitimate synonyms and keyword-only expansions, e.g. a future zegen lex leg).
+ */
+export function sanitizeExpandedQueries(items: Queryable[]): Queryable[] {
+  const seen = new Set<string>();
+  const out: Queryable[] = [];
+  for (const q of items) {
+    const text = stripControlTokens(q.text);
+    if (isJunkExpansion(text)) continue;
+    const key = `${q.type}:${text}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ type: q.type, text });
+  }
+  return out;
+}
+
+/**
+ * Typed fallback expansion set, used when generation fails or sanitization leaves
+ * nothing usable. lex+vec reuse the original query; hyde gets a minimal stub so the
+ * vector leg still has a hypothetical-document signal.
+ */
+export function expansionFallback(query: string, includeLexical: boolean = true): Queryable[] {
+  const out: Queryable[] = [
+    { type: 'vec', text: query },
+    { type: 'hyde', text: `Information about ${query}` },
+  ];
+  if (includeLexical) out.unshift({ type: 'lex', text: query });
+  return out;
+}
+
+/**
+ * True if `items` is exactly the typed fallback set for `query` — i.e. what every
+ * llm.expandQuery failure path returns. The store wrapper uses this to detect a
+ * leaked generation failure so it can return an expansions-only form WITHOUT
+ * caching it (a transient failure must not poison the cache). Compares against the
+ * default (lexical-included) fallback, which is what the store always requests.
+ */
+export function isFallbackExpansion(items: Queryable[], query: string): boolean {
+  const fb = expansionFallback(query);
+  return items.length === fb.length
+    && items.every((q, i) => q.type === fb[i]!.type && q.text === fb[i]!.text);
+}
+
 /**
  * Document to rerank
  */
@@ -1074,24 +1156,22 @@ export class LlamaCpp implements LLM {
   }
 
   private async expandQueryRemote(query: string, includeLexical: boolean, context?: string, intent?: string): Promise<Queryable[]> {
-    const prompt = `Rewrite this search query for better retrieval. Output lines in format "type: text" where type is lex, vec, or hyde.
-- lex: keyword search terms (1-3 lines)
-- vec: semantic search queries (1-3 lines)
-- hyde: hypothetical document passage that answers the query (1 line)
-
-Query: ${query}${intent ? `\nQuery intent: ${intent}` : ""}${context ? `\nContext: ${context}` : ""}
-
-Output:`;
+    // QMD-faithful terse prompt. The qmd-query-expansion-1.7B finetune was trained
+    // on "/no_think Expand this search query: X" (cf. QMD src/llm.ts:1467). The prior
+    // verbose prose prompt was out-of-distribution: the model echoed the template
+    // ("lex: keyword search terms (") and leaked </think> (verified live 2026-06-23).
+    let prompt = intent
+      ? `/no_think Expand this search query: ${query}\nQuery intent: ${intent}`
+      : `/no_think Expand this search query: ${query}`;
+    if (context) prompt += `\nContext: ${context}`;
 
     const result = await this.generateRemote(prompt, 500, 0.7);
     if (!result?.text) {
-      const fallback: Queryable[] = [{ type: 'vec', text: query }];
-      if (includeLexical) fallback.unshift({ type: 'lex', text: query });
-      return fallback;
+      return expansionFallback(query, includeLexical);
     }
 
     const lines = result.text.trim().split("\n");
-    const queryables: Queryable[] = lines.map(line => {
+    const parsed: Queryable[] = lines.map(line => {
       const colonIdx = line.indexOf(":");
       if (colonIdx === -1) return null;
       const type = line.slice(0, colonIdx).trim();
@@ -1101,16 +1181,11 @@ Output:`;
       return { type: type as QueryType, text };
     }).filter((q): q is Queryable => q !== null);
 
-    if (queryables.length === 0) {
-      const fallback: Queryable[] = [{ type: 'vec', text: query }];
-      if (includeLexical) fallback.unshift({ type: 'lex', text: query });
-      return fallback;
-    }
-
-    if (!includeLexical) {
-      return queryables.filter(q => q.type !== 'lex');
-    }
-    return queryables;
+    // Drop template residue / <think> leaks / dups, then scope to requested types.
+    const cleaned = sanitizeExpandedQueries(parsed);
+    const scoped = includeLexical ? cleaned : cleaned.filter(q => q.type !== 'lex');
+    if (scoped.length === 0) return expansionFallback(query, includeLexical);
+    return scoped;
   }
 
   async modelExists(modelUri: string): Promise<ModelInfo> {
@@ -1148,10 +1223,8 @@ Output:`;
     // Remote is in cooldown (pre-existing or just set) — fall through to local
     if (this.remoteLlmUrl && this.isRemoteLlmDown()) {
       if (process.env.CLAWMEM_NO_LOCAL_MODELS === "true") {
-        // Can't fall back — return passthrough
-        const fallback: Queryable[] = [{ type: 'vec', text: query }];
-        if (includeLexical) fallback.unshift({ type: 'lex', text: query });
-        return fallback;
+        // Can't fall back to local inference — return the typed passthrough set
+        return expansionFallback(query, includeLexical);
       }
       this.noteRemoteFallback(
         "llm",
@@ -1230,7 +1303,7 @@ Final Output:`;
       });
 
       const lines = result.trim().split("\n");
-      const queryables: Queryable[] = lines.map(line => {
+      const parsed: Queryable[] = lines.map(line => {
         const colonIdx = line.indexOf(":");
         if (colonIdx === -1) return null;
         const type = line.slice(0, colonIdx).trim();
@@ -1239,17 +1312,14 @@ Final Output:`;
         return { type: type as QueryType, text };
       }).filter((q): q is Queryable => q !== null);
 
-      // Filter out lex entries if not requested
-      if (!includeLexical) {
-        return queryables.filter(q => q.type !== 'lex');
-      }
-      return queryables;
+      // Same guard as the remote path — drop residue/dups, scope to requested types.
+      const cleaned = sanitizeExpandedQueries(parsed);
+      const scoped = includeLexical ? cleaned : cleaned.filter(q => q.type !== 'lex');
+      if (scoped.length === 0) return expansionFallback(query, includeLexical);
+      return scoped;
     } catch (error) {
       console.error("Structured query expansion failed:", error);
-      // Fallback to original query
-      const fallback: Queryable[] = [{ type: 'vec', text: query }];
-      if (includeLexical) fallback.unshift({ type: 'lex', text: query });
-      return fallback;
+      return expansionFallback(query, includeLexical);
     } finally {
       await genContext.dispose();
     }

package/src/mcp.ts

@@ -629,19 +629,38 @@ This is the recommended entry point for ALL memory queries.`,
       const hasStrongSignal = !intent && initialFts.length > 0
         && topScore >= 0.85 && (topScore - secondScore) >= 0.15;
 
-      // Step 2: Query expansion (skipped if strong signal)
-      const queries = hasStrongSignal
-        ? [query]
+      // Step 2: Query expansion (skipped if strong signal). Typed routing —
+      // original → BOTH FTS + vector (2× RRF anchor), lex → FTS only, vec/hyde → vector only.
+      const expanded = hasStrongSignal
+        ? []
         : await store.expandQuery(query, DEFAULT_QUERY_MODEL, intent);
 
-      for (const q of queries) {
-        const ftsResults = q === query ? initialFts : store.searchFTS(q, 20, undefined, collections, dateRange);
-        if (ftsResults.length > 0) {
-          for (const r of ftsResults) docidMap.set(r.filepath, r.docid);
-          rankedLists.push(ftsResults.map(r => ({ file: r.filepath, displayPath: r.displayPath, title: r.title, body: r.body || "", score: r.score })));
+      // Original query — both backends, pushed FIRST so the positional 2× weight
+      // below lands on exactly the original's lists.
+      if (initialFts.length > 0) {
+        for (const r of initialFts) docidMap.set(r.filepath, r.docid);
+        rankedLists.push(initialFts.map(r => ({ file: r.filepath, displayPath: r.displayPath, title: r.title, body: r.body || "", score: r.score })));
+      }
+      if (hasVectors) {
+        const vecResults = await store.searchVec(query, DEFAULT_EMBED_MODEL, 20, undefined, collections, dateRange);
+        if (vecResults.length > 0) {
+          for (const r of vecResults) docidMap.set(r.filepath, r.docid);
+          rankedLists.push(vecResults.map(r => ({ file: r.filepath, displayPath: r.displayPath, title: r.title, body: r.body || "", score: r.score })));
         }
-        if (hasVectors) {
-          const vecResults = await store.searchVec(q, DEFAULT_EMBED_MODEL, 20, undefined, collections, dateRange);
+      }
+      // Lists contributed by the original query — these get the 2× RRF weight.
+      const numOriginalLists = rankedLists.length;
+
+      // Typed expansions — route by type: lex → FTS, vec/hyde → vector.
+      for (const eq of expanded) {
+        if (eq.type === 'lex') {
+          const ftsResults = store.searchFTS(eq.query, 20, undefined, collections, dateRange);
+          if (ftsResults.length > 0) {
+            for (const r of ftsResults) docidMap.set(r.filepath, r.docid);
+            rankedLists.push(ftsResults.map(r => ({ file: r.filepath, displayPath: r.displayPath, title: r.title, body: r.body || "", score: r.score })));
+          }
+        } else if (hasVectors) {
+          const vecResults = await store.searchVec(eq.query, DEFAULT_EMBED_MODEL, 20, undefined, collections, dateRange);
           if (vecResults.length > 0) {
             for (const r of vecResults) docidMap.set(r.filepath, r.docid);
             rankedLists.push(vecResults.map(r => ({ file: r.filepath, displayPath: r.displayPath, title: r.title, body: r.body || "", score: r.score })));
@@ -705,8 +724,9 @@ This is the recommended entry point for ALL memory queries.`,
         }
       }
 
-      // Weight: original query BM25+vec get 2x, expanded queries get 1x, temporal/entity legs get 1x
-      const numOriginalLists = hasVectors ? 2 : 1; // first BM25 + first vector from original query
+      // Weight: the original query's lists (pushed first) get 2×; expansion, temporal,
+      // and entity legs get 1×. numOriginalLists (computed above) is the actual count
+      // the original contributed — robust to an empty BM25 or vector leg.
       const weights = rankedLists.map((_, i) => i < numOriginalLists ? 2.0 : 1.0);
       const fused = reciprocalRankFusion(rankedLists, weights);
       const candidates = fused.slice(0, candLimit);

package/src/store.ts

@@ -21,6 +21,9 @@ import {
   getDefaultLlamaCpp,
   formatQueryForEmbedding,
   formatDocForEmbedding,
+  sanitizeExpandedQueries,
+  expansionFallback,
+  isFallbackExpansion,
   type RerankDocument,
 } from "./llm.ts";
 import {
@@ -1139,7 +1142,7 @@ export type Store = {
   searchVec: (query: string, model: string, limit?: number, collectionId?: number, collections?: string[], dateRange?: { start: string; end: string }) => Promise<SearchResult[]>;
 
   // Query expansion & reranking
-  expandQuery: (query: string, model?: string, intent?: string) => Promise<string[]>;
+  expandQuery: (query: string, model?: string, intent?: string) => Promise<ExpandedQuery[]>;
   rerank: (query: string, documents: { file: string; text: string }[], model?: string, intent?: string) => Promise<{ file: string; score: number }[]>;
 
   // Document retrieval
@@ -3543,28 +3546,84 @@ export function insertEmbedding(
 // Query expansion
 // =============================================================================
 
-export async function expandQuery(query: string, model: string = DEFAULT_QUERY_MODEL, db: Database, intent?: string): Promise<string[]> {
-  // Check cache first (include intent in cache key)
-  const cacheKey = getCacheKey("expandQuery", { query, model, ...(intent && { intent }) });
+/**
+ * A typed query-expansion result. Decoupled from llm.ts's internal Queryable —
+ * same information, but store.ts owns its own public API type and field name.
+ *
+ * Routing contract (every consumer MUST honor it):
+ *   - lex  → FTS (BM25) only
+ *   - vec  → vector only
+ *   - hyde → vector only (hypothetical-document embedding)
+ * The original query is searched on BOTH backends and is NOT included here —
+ * callers add it explicitly with the 2× RRF anchor weight.
+ */
+export type ExpandedQuery = {
+  type: 'lex' | 'vec' | 'hyde';
+  query: string;
+};
+
+// Cache version + provider fingerprint for query expansion. Bumping the version
+// invalidates every stale entry automatically: old newline-format and pre-terse-
+// prompt garbage simply never hit again and age out of llm_cache via LRU (no manual
+// purge). The provider fingerprint will distinguish qmd from a future zegen lex
+// provider (P4) so a provider swap also invalidates the cache by construction.
+const EXPAND_CACHE_VERSION = "v3-qmd-terse-typed";
+const EXPAND_PROVIDER_FINGERPRINT = "qmd-terse";
+
+export async function expandQuery(query: string, model: string = DEFAULT_QUERY_MODEL, db: Database, intent?: string): Promise<ExpandedQuery[]> {
+  // Typed-JSON cache. Versioned key (include intent + provider fingerprint).
+  const cacheKey = getCacheKey(`expandQuery:${EXPAND_CACHE_VERSION}`, {
+    query,
+    model,
+    provider: EXPAND_PROVIDER_FINGERPRINT,
+    ...(intent && { intent }),
+  });
   const cached = getCachedResult(db, cacheKey);
   if (cached) {
-    const lines = cached.split('\n').map(l => l.trim()).filter(l => l.length > 0);
-    return [query, ...lines.slice(0, 2)];
+    try {
+      const parsed = JSON.parse(cached) as unknown;
+      // Accept ONLY a fully-valid, already-clean typed payload. A shape error on ANY
+      // element, an empty array, or anything sanitization would drop/rewrite → treat
+      // the entry as stale and re-expand (never return partial or dirty cached data).
+      if (Array.isArray(parsed) && parsed.length > 0
+        && parsed.every(r => r !== null && typeof r === "object"
+          && typeof (r as Record<string, unknown>).query === "string"
+          && ((r as Record<string, unknown>).type === "lex"
+            || (r as Record<string, unknown>).type === "vec"
+            || (r as Record<string, unknown>).type === "hyde"))) {
+        const rows = parsed as Array<{ type: ExpandedQuery["type"]; query: string }>;
+        const sanitized = sanitizeExpandedQueries(rows.map(r => ({ type: r.type, text: r.query })));
+        const clean = sanitized.length === rows.length
+          && sanitized.every((s, i) => s.type === rows[i]!.type && s.text === rows[i]!.query);
+        if (clean) return rows;
+      }
+    } catch {
+      // Malformed JSON — fall through and re-expand.
+    }
   }
 
   const llm = getDefaultLlamaCpp();
-  // Note: LlamaCpp uses hardcoded model, model parameter is ignored
-  // Pass intent to steer expansion when provided
+  // Note: LlamaCpp uses a hardcoded model; the model parameter is ignored here.
+  // Pass intent to steer expansion when provided.
   const results = await llm.expandQuery(query, { intent });
-  const queryTexts = results.map(r => r.text);
 
-  // Cache the expanded queries (excluding original)
-  const expandedOnly = queryTexts.filter(t => t !== query);
-  if (expandedOnly.length > 0) {
-    setCachedResult(db, cacheKey, expandedOnly.join('\n'));
+  // Defense-in-depth: re-run the shared guard (also covers the local GBNF path and
+  // any future provider), then drop entries that just echo the original query.
+  // llm.expandQuery substitutes its OWN typed fallback on any generation failure
+  // (remote-empty, cooldown under NO_LOCAL_MODELS, local parse-empty/error). Detect
+  // that leaked fallback AND the all-junk case, and return an expansions-only set
+  // that is NOT cached — a transient failure must not poison the cache or break the
+  // "expansions only, original excluded" contract.
+  const cleaned = sanitizeExpandedQueries(results).filter(r => r.text !== query);
+  if (cleaned.length === 0 || isFallbackExpansion(results, query)) {
+    return expansionFallback(query)
+      .filter(r => r.text !== query)   // expansions-only per the ExpandedQuery contract
+      .map(r => ({ type: r.type, query: r.text }));
   }
 
-  return Array.from(new Set([query, ...queryTexts]));
+  const expanded: ExpandedQuery[] = cleaned.map(r => ({ type: r.type, query: r.text }));
+  setCachedResult(db, cacheKey, JSON.stringify(expanded));
+  return expanded;
 }
 
 // =============================================================================