superlocalmemory 3.4.63 → 3.5.0

package/src/superlocalmemory/mcp/tools_active.py

@@ -257,24 +257,88 @@ def register_active_tools(server, get_engine: Callable) -> None:
 
             # Build both return shapes from one recall. Calling recall twice
             # doubles session startup latency and can return duplicate snippets.
-            context = ""
-            if relevant:
+
+            # v3.4.65: use shared injection formatter for full-fidelity context.
+            from superlocalmemory.core.injection import (
+                InjectableMemory,
+                clamp_content,
+                is_low_quality,
+                render_context,
+            )
+
+            pid = engine.profile_id
+
+            # Merge pinned facts (Q3: Core Memory explicit pins).
+            # Pinned facts surface even if the query didn't retrieve them.
+            try:
+                pinned_facts = engine.db.get_pinned(pid)
+            except Exception:
+                pinned_facts = []
+            pinned_ids = {f.fact_id for f in pinned_facts}
+            pinned_seen = set()
+
+            cfg_inj = getattr(getattr(engine, "config", None), "injection", None)
+            # Defend against MagicMock / non-config objects in tests.
+            try:
+                from superlocalmemory.core.config import InjectionConfig
+                if not isinstance(cfg_inj, InjectionConfig):
+                    cfg_inj = None
+            except Exception:
+                cfg_inj = None
+
+            inj_mems: list[InjectableMemory] = []
+            # Pinned facts first (they always head the core block).
+            for pf in pinned_facts[:20]:  # safety cap
+                inj_mems.append(InjectableMemory(
+                    content=pf.content,
+                    score=0.0,
+                    fact_id=pf.fact_id,
+                    importance=getattr(pf, "importance", 0.0) or 0.0,
+                    access_count=getattr(pf, "access_count", 0) or 0,
+                    pinned=True,
+                ))
+                pinned_seen.add(pf.fact_id)
+
+            # Then recall results (skip duplicates of pinned).
+            for r in relevant[:max_results]:
+                if r.fact.fact_id in pinned_seen:
+                    continue
+                inj_mems.append(InjectableMemory(
+                    content=r.fact.content,
+                    score=round(r.score, 3),
+                    fact_id=r.fact.fact_id,
+                    importance=getattr(r.fact, "importance", 0.0) or 0.0,
+                    access_count=getattr(r.fact, "access_count", 0) or 0,
+                ))
+
+            mode_str = str(getattr(engine, "mode", "B")).upper()
+            try:
+                context = render_context(inj_mems, mode=mode_str, cfg=cfg_inj, wrap=False)
+            except Exception:
+                # Fall back to legacy content building on any formatter failure
                 lines = ["# Relevant Memory Context", ""]
-                for r in relevant[:max_results]:
-                    lines.append(f"- {r.fact.content[:200]}")
+                for m in inj_mems[:max_results]:
+                    lines.append(f"- {m.content[:200]}")
                 context = "\n".join(lines)
 
+            # GAP-FIX (v3.4.65 delivery-lead): the memories[] array is part of
+            # the MCP response Claude Code ingests — it MUST be bounded too, not
+            # just the rendered `context` string. Previously full unclamped
+            # content shipped here (one fact was 131K chars → ~124K-token
+            # response, defeating the whole token budget). Clamp each content
+            # to per_memory_max_tokens, drop junk, and honour max_results.
             memories = [
                 {
-                    "fact_id": r.fact.fact_id,
-                    "content": r.fact.content[:300],
-                    "score": round(r.score, 3),
+                    "fact_id": m.fact_id,
+                    "content": clamp_content(m.content, cfg_inj),
+                    "score": m.score,
+                    "is_core": m.is_core,
                 }
-                for r in relevant[:max_results]
+                for m in inj_mems[:max_results]
+                if not is_low_quality(m.content)
             ]
 
             # Get learning status
-            pid = engine.profile_id
             feedback_count = 0
             try:
                 feedback_count = engine._adaptive_learner.get_feedback_count(pid)
@@ -299,6 +363,7 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 "context": context,
                 "memories": memories[:max_results],
                 "memory_count": len(memories),
+                "core_memory": [m["content"] for m in memories if m.get("is_core")],
                 "degraded_mode": degraded_mode,
                 "retrieval_mode": "emergency_fts5_bm25" if degraded_mode else "full_6_channel",
                 "learning": {
@@ -471,3 +536,59 @@ def register_active_tools(server, get_engine: Callable) -> None:
         except Exception as exc:
             logger.exception("close_session failed")
             return {"success": False, "error": str(exc)}
+
+    # ------------------------------------------------------------------
+    # core_memory — v3.4.65: explicit Core Memory pin management
+    # ------------------------------------------------------------------
+
+    @server.tool()
+    async def core_memory(
+        action: str,
+        fact_id: str = "",
+        profile_id: str = "default",
+    ) -> dict:
+        """Manage the explicit Core Memory pin set (v3.4.65).
+
+        - pin:   mark a fact as always-injected
+        - unpin: clear the pin
+        - list:  return currently pinned facts
+        """
+        try:
+            engine = get_engine()
+            db = engine.db
+            pid = profile_id or engine.profile_id
+
+            if action == "pin":
+                if not fact_id:
+                    return {"success": False, "error": "fact_id required for pin"}
+                db.set_pinned(fact_id, True)
+                return {"success": True, "action": "pin", "fact_id": fact_id}
+
+            if action == "unpin":
+                if not fact_id:
+                    return {"success": False, "error": "fact_id required for unpin"}
+                db.set_pinned(fact_id, False)
+                return {"success": True, "action": "unpin", "fact_id": fact_id}
+
+            if action == "list":
+                pinned = db.get_pinned(pid)
+                cfg_inj = getattr(getattr(engine, "config", None), "injection", None)
+                max_tok = getattr(cfg_inj, "per_memory_max_tokens", 600) if cfg_inj else 600
+                return {
+                    "success": True,
+                    "pinned": [
+                        {
+                            "fact_id": f.fact_id,
+                            "content": f.content[: max_tok * 4],
+                            "importance": getattr(f, "importance", 0.0),
+                        }
+                        for f in pinned
+                    ],
+                    "count": len(pinned),
+                }
+
+            return {"success": False, "error": f"unknown action: {action}"}
+
+        except Exception as exc:
+            logger.exception("core_memory failed")
+            return {"success": False, "error": str(exc)}

package/src/superlocalmemory/mcp/tools_context.py

@@ -26,7 +26,7 @@ from superlocalmemory.core.security_primitives import redact_secrets
 logger = logging.getLogger(__name__)
 
 MAX_CALLS_PER_MINUTE = 30
-MAX_RESPONSE_BYTES = 16 * 1024  # 16 KB
+MAX_RESPONSE_BYTES = 64 * 1024  # v3.4.65: raised from 16 KB, configurable via InjectionConfig
 WINDOW_SECONDS = 60.0
 
 
@@ -72,7 +72,11 @@ def _iso_now() -> str:
 
 
 def _cap_memory(memory: dict, *, max_text_bytes: int = 2048) -> dict:
-    """Ensure each memory is bounded and redacted."""
+    """Ensure each memory is bounded and redacted.
+
+    v3.4.65: max_text_bytes default kept small for backward compat;
+    callers should pass cfg.per_memory_max_tokens * 4 for full fidelity.
+    """
     text = memory.get("text", "")
     if not isinstance(text, str):
         text = str(text)
@@ -135,7 +139,17 @@ def prestage_context(
             "truncated_count": 0,
         }
 
-    capped = [_cap_memory(m) for m in raw if isinstance(m, dict)]
+    # v3.4.65: use InjectionConfig for per-memory and response caps.
+    try:
+        from superlocalmemory.core.config import SLMConfig
+        cfg_inj = SLMConfig.load().injection
+        per_mem_bytes = cfg_inj.per_memory_max_tokens * 4
+        resp_bytes = cfg_inj.prestage_max_response_bytes
+    except Exception:
+        per_mem_bytes = 2400   # 600 tokens * 4
+        resp_bytes = 64 * 1024
+
+    capped = [_cap_memory(m, max_text_bytes=per_mem_bytes) for m in raw if isinstance(m, dict)]
     capped = capped[:limit]
 
     # Enforce total response size cap (A11/16 KB).
@@ -147,7 +161,7 @@ def prestage_context(
     }
     encoded = json.dumps(response).encode("utf-8")
     truncated = 0
-    while len(encoded) > MAX_RESPONSE_BYTES and response["memories"]:
+    while len(encoded) > resp_bytes and response["memories"]:
         response["memories"].pop()
         truncated += 1
         response["truncated_count"] = truncated

package/src/superlocalmemory/retrieval/bm25_channel.py

@@ -146,6 +146,43 @@ class BM25Channel:
         # Persist for cold start
         self._db.store_bm25_tokens(fact_id, profile_id, tokens)
 
+    def _fts5_search(
+        self, query: str, profile_id: str, top_k: int = 30,
+    ) -> list[tuple[str, float]]:
+        """v3.5.0: SQLite FTS5 keyword search (C-level indexed, scales to millions).
+
+        Uses the ``atomic_facts_fts`` external-content FTS5 table (kept in sync
+        by INSERT/DELETE/UPDATE triggers). Joins ``atomic_facts`` for profile
+        scoping (FTS table has no profile_id). ``bm25()`` returns a negative
+        score (lower = better match); we negate it to the channel's
+        "higher = better" convention. Returns [] on no matches.
+
+        Raises (OperationalError) if the FTS5 table is absent — the caller
+        then falls back to the legacy in-memory rank_bm25 path.
+        """
+        tokens = tokenize(query)
+        if not tokens:
+            return []
+        # Quote each token so query punctuation can't break FTS5 MATCH syntax;
+        # OR-join for high recall (any token may match).
+        match_expr = " OR ".join('"' + t.replace('"', "") + '"' for t in tokens)
+        sql = (
+            "SELECT af.fact_id AS fact_id, bm25(atomic_facts_fts) AS rank "
+            "FROM atomic_facts_fts "
+            "JOIN atomic_facts af ON af.rowid = atomic_facts_fts.rowid "
+            "WHERE atomic_facts_fts MATCH ? AND af.profile_id = ? "
+            "ORDER BY rank LIMIT ?"
+        )
+        rows = self._db.execute(sql, (match_expr, profile_id, int(top_k)))
+        out: list[tuple[str, float]] = []
+        for r in rows:
+            d = dict(r)
+            fid = d.get("fact_id")
+            if not fid:
+                continue
+            out.append((fid, -float(d.get("rank", 0.0))))
+        return out
+
     def search(
         self,
         query: str,
@@ -164,6 +201,19 @@ class BM25Channel:
         Returns:
             List of (fact_id, bm25_score) sorted by score descending.
         """
+        # v3.5.0: FTS5 fast path — C-level indexed, ~ms, scales to millions.
+        # The legacy in-memory rank_bm25 path rebuilt the whole index over the
+        # entire corpus on every corpus change (11s+ at 17.5k facts, does not
+        # scale). FTS5 (atomic_facts_fts, kept in sync by triggers) replaces it.
+        # Falls back to rank_bm25 ONLY if the FTS5 table is genuinely
+        # unavailable (raises) — e.g. a pre-FTS legacy DB.
+        try:
+            return self._fts5_search(query, profile_id, top_k)
+        except Exception as exc:  # pragma: no cover — legacy/missing FTS table
+            logger.debug(
+                "BM25 FTS5 path unavailable, using rank_bm25 fallback: %s", exc,
+            )
+
         self.ensure_loaded(profile_id)
 
         if not self._corpus:

package/src/superlocalmemory/retrieval/engine.py

@@ -127,8 +127,20 @@ class RetrievalEngine:
         t0 = time.monotonic()
         self._extra_disabled = set(extra_disabled_channels or ())
 
+        # v3.5.0 diagnostic: stage timing inside retrieval (SLM_RECALL_TIMING=1).
+        import os as _os_e
+        import time as _time_e
+        _et = bool(_os_e.environ.get("SLM_RECALL_TIMING"))
+        _e0 = _time_e.monotonic()
+
+        def _em(_l: str) -> None:
+            if _et:
+                logger.warning("[RECALL-TIMING]   engine.%-16s %.0f ms",
+                               _l, (_time_e.monotonic() - _e0) * 1000.0)
+
         # 1. Classify query, get adaptive weights
         strat = self._strategy.classify(query, self._base_weights)
+        _em("classify")
 
         # Profile shortcut (runs before channel search)
         if self._profile_channel is not None:
@@ -149,12 +161,14 @@ class RetrievalEngine:
 
         # 3. Run 4 channels
         ch_results = self._run_channels(query, profile_id, strat)
+        _em("run_channels")
         if profile_hits:
             ch_results["profile"] = profile_hits
         total = sum(len(v) for v in ch_results.values())
 
         # 3. Single-pass RRF fusion
         fused = weighted_rrf(ch_results, strat.weights, k=self._config.rrf_k)
+        _em("rrf_fusion")
 
         # V3.3.21: Cross-channel intersection boost for multi-hop/temporal queries.
         # Problem: channels work in ISOLATION. "When did Caroline go to X?" needs
@@ -181,18 +195,23 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("Bridge discovery: %s", exc)
 
-        # Scene expansion
-        if fused:
+        # Scene expansion (v3.5.0: batch + time-budgeted).
+        # Skip if channels already exceeded the per-recall time budget;
+        # the scene signal is nice-to-have, never worth delaying response.
+        if fused and (_time_e.monotonic() - _e0) < 0.8:
             try:
+                top_ids = [fr.fact_id for fr in fused[:20]]
+                scenes_map = self._db.get_scenes_for_facts_batch(top_ids, profile_id)
                 expanded_ids: set[str] = set()
-                for fr in fused[:20]:
-                    scenes = self._db.get_scenes_for_fact(fr.fact_id, profile_id)
-                    for scene in scenes[:2]:
+                for fid in top_ids:
+                    for scene in scenes_map.get(fid, [])[:2]:
                         for sfid in scene.fact_ids:
                             if not any(f.fact_id == sfid for f in fused) and sfid not in expanded_ids:
                                 expanded_ids.add(sfid)
                                 fused.append(FusionResult(
-                                    fact_id=sfid, fused_score=fr.fused_score * 0.8,
+                                    fact_id=sfid, fused_score=(
+                                        next((f.fused_score for f in fused if f.fact_id == fid), 0.5) * 0.8
+                                    ),
                                     channel_ranks={}, channel_scores={},
                                 ))
             except Exception as exc:
@@ -204,7 +223,8 @@ class RetrievalEngine:
         # Research: Microsoft GraphRAG DRIFT, Pistis-RAG cascaded architecture.
         if (self._entity is not None
                 and "entity_graph" not in set(self._config.disabled_channels)
-                and fused):
+                and fused
+                and (_time_e.monotonic() - _e0) < 0.9):
             try:
                 candidate_ids = [fr.fact_id for fr in fused[:100]]
                 eg_scores = self._entity.score_candidates(
@@ -229,10 +249,12 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("Entity graph signal enhancement: %s", exc)
 
+        _em("expand+entity_enh")
         # 4. Load facts for rerank pool
         pool = min(len(fused), max(effective_limit * 3, 30))
         top = fused[:pool]
         facts = self._load_facts(top, profile_id)
+        _em("load_facts")
 
         # V3.3.21: Session diversity for aggregation queries.
         if strat.query_type == "aggregation" and facts:
@@ -250,6 +272,7 @@ class RetrievalEngine:
         if reranker_ready and facts:
             ce_alpha = 0.5 if strat.query_type in ("multi_hop", "temporal") else 0.75
             top = self._apply_reranker(query, top, facts, alpha=ce_alpha)
+        _em(f"rerank(ready={reranker_ready})")
 
         # V3.4.11: Channel diversity — guarantee entity_graph results appear in
         # the final output. Applied AFTER reranker so results can't be pushed out.
@@ -462,6 +485,9 @@ class RetrievalEngine:
         3-5x speedup for the channel phase.
         """
         import concurrent.futures
+        import os as _os_e
+        import time as _time_e
+        _et = bool(_os_e.environ.get("SLM_RECALL_TIMING"))
         out: dict[str, list[tuple[str, float]]] = {}
         # Skip channels listed in disabled_channels (ablation support)
         # V3.4.40: union with per-recall extra_disabled set (e.g. --fast skip)
@@ -492,8 +518,12 @@ class RetrievalEngine:
 
         def _safe_channel(name: str, fn, *args):
             """Run a single channel, returning (name, result_or_None)."""
+            _cs = _time_e.monotonic() if _et else 0.0
             try:
                 res = fn(*args)
+                if _et:
+                    logger.warning("[RECALL-TIMING]     channel.%-16s %.0f ms",
+                                   name, (_time_e.monotonic() - _cs) * 1000.0)
                 return (name, res if res else None)
             except Exception as exc:
                 logger.warning("%s channel: %s", name, exc)
@@ -735,9 +765,13 @@ class RetrievalEngine:
             trust_weight, raw_trust = self._get_trust_weight(fact, profile_id)
 
             boosted_score = fr.fused_score * recency_boost * quality * trust_weight
-            confidence = min(1.0, boosted_score * 10.0) * fact.confidence
+            # v3.5.0 (M2): soft-normalize to [0,1]. RRF weights + scene/entity
+            # boosts push raw scores well above 1 (observed: 27.97). A sigmoid
+            # preserves rank (monotonic) while giving users a readable 0-1 range.
+            normalized_score = 1.0 / (1.0 + math.exp(-boosted_score * 0.5))
+            confidence = min(1.0, normalized_score * 10.0) * fact.confidence
             results.append(RetrievalResult(
-                fact=fact, score=boosted_score,
+                fact=fact, score=round(normalized_score, 4),
                 channel_scores=fr.channel_scores,
                 confidence=confidence, evidence_chain=evidence,
                 trust_score=raw_trust,

package/src/superlocalmemory/retrieval/hopfield_channel.py

@@ -145,18 +145,31 @@ class HopfieldChannel:
             )
             return []
 
-        # Step 4: Get memory matrix
+        # Step 4 (v3.5.0 FIX): route by the cheap total_count BEFORE building
+        # the full memory matrix. Previously _get_memory_matrix() loaded and
+        # normalized ALL embeddings (~6s at 17.5k facts) even when the prefilter
+        # path was taken — and that path builds its own ANN sub-matrix and never
+        # uses the full one. So the entire 6s build was wasted on large stores.
+        # Now the full matrix is built ONLY for small stores (<= prefilter_threshold).
+        vs_ok = bool(
+            self._vector_store
+            and getattr(self._vector_store, "available", False)
+        )
+        # v3.5.0 FIX: prefer the bounded ANN-prefilter path whenever a vector
+        # store is available and the corpus is larger than the candidate set.
+        # The full-matrix path loads & L2-normalizes EVERY embedding from SQLite
+        # (~6s at 17.5k facts), so it's only worth it for tiny stores or when no
+        # VS exists. Routing on prefilter_candidates (not prefilter_threshold)
+        # ensures the matrix is always bounded to ~prefilter_candidates rows.
+        if vs_ok and total_count > self._config.prefilter_candidates:
+            return self._search_with_prefilter(q_vec, profile_id, [], top_k)
+
+        # Tiny store (or no VS): build (cached) full matrix.
         memory_matrix, fact_ids = self._get_memory_matrix(profile_id)
-
-        # Step 5: Empty check
         if memory_matrix is None or len(fact_ids) == 0:
             return []
-
-        # Step 6/7: Route by size
-        if len(fact_ids) > self._config.prefilter_threshold:
-            return self._search_with_prefilter(
-                q_vec, profile_id, fact_ids, top_k,
-            )
+        if vs_ok and len(fact_ids) > self._config.prefilter_candidates:
+            return self._search_with_prefilter(q_vec, profile_id, fact_ids, top_k)
         return self._search_full_matrix(
             q_vec, memory_matrix, fact_ids, top_k,
         )

package/src/superlocalmemory/retrieval/temporal_channel.py

@@ -32,9 +32,18 @@ _MAX_PROXIMITY_DAYS: float = 365.0
 def _parse_iso(s: str | None) -> datetime | None:
     if not s:
         return None
+    # v3.5.0 perf: stored dates are ISO-8601, so try the C-level
+    # datetime.fromisoformat (~1µs) FIRST. dateutil.parser.parse is ~100x
+    # slower (~100µs) and the temporal channel parses up to 4 dates per event
+    # across thousands of events — that was ~2.6s of the recall. dateutil is
+    # now only the fallback for non-ISO strings.
+    try:
+        return datetime.fromisoformat(s.replace("Z", "+00:00"))
+    except (ValueError, TypeError):
+        pass
     try:
         return dateutil_parse(s)
-    except (ParserError, ValueError, OverflowError):
+    except (ParserError, ValueError, OverflowError, TypeError):
         return None
 
 

package/src/superlocalmemory/server/routes/memories.py

@@ -417,7 +417,7 @@ async def search_memories(request: Request, body: SearchRequest):
         # directly in an async route blocks the ASGI event loop — Chrome detects
         # a stalled connection and aborts with "signal is aborted without reason"
         # before the response arrives. Fix: run in a thread-pool executor so the
-        # event loop stays alive to send keepalive frames. Also fast=True skips
+        # event loop stays alive to send keepalive frames. Also fast=False skips
         # spreading_activation + Hopfield (saves ~7s on cold graph traversal).
         import asyncio
         import time as _time
@@ -427,7 +427,7 @@ async def search_memories(request: Request, body: SearchRequest):
             t0 = _time.monotonic()
             response = await loop.run_in_executor(
                 None,
-                lambda: engine.recall(body.query, limit=body.limit, fast=True),
+                lambda: engine.recall(body.query, limit=body.limit, fast=False),
             )
             elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
             results = []

package/src/superlocalmemory/server/routes/v3_api.py

@@ -514,45 +514,60 @@ async def set_provider(request: Request):
 
 @router.post("/recall/trace")
 async def recall_trace(request: Request):
-    """Recall with per-channel score breakdown."""
+    """Recall with per-channel score breakdown.
+
+    v3.4.64: Replaced WorkerPool.shared() (subprocess, blocks event loop,
+    worker crashes after ~15s) with daemon engine via run_in_executor.
+    Same fix as POST /api/search in v3.4.63.
+    """
+    import asyncio
+    import time as _time
     try:
         body = await request.json()
         query = body.get("query", "")
         limit = body.get("limit", 10)
 
-        from superlocalmemory.core.worker_pool import WorkerPool
-        pool = WorkerPool.shared()
-        result = pool.recall(query, limit=limit)
-
-        if not result.get("ok"):
-            return JSONResponse(
-                {"error": result.get("error", "Recall failed")},
-                status_code=503,
-            )
-
-        # Optional: synthesize answer from results (Mode B/C only)
-        synthesis = ""
-        if body.get("synthesize") and result.get("results"):
-            try:
-                syn_result = pool.synthesize(query, result["results"][:5])
-                synthesis = syn_result.get("synthesis", "") if syn_result.get("ok") else ""
-            except Exception:
-                pass
+        # Use daemon engine — already loaded, shares warm page cache.
+        # run_in_executor keeps event loop alive so browser doesn't abort.
+        from .helpers import get_engine_lazy
+        engine = get_engine_lazy(request.app.state)
+        if engine is None:
+            return JSONResponse({"error": "Engine not initialised"}, status_code=503)
+
+        loop = asyncio.get_event_loop()
+        t0 = _time.monotonic()
+        response = await loop.run_in_executor(
+            None,
+            lambda: engine.recall(query, limit=limit, fast=False),
+        )
+        elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
+
+        results = []
+        for r in response.results[:limit]:
+            results.append({
+                "fact_id": r.fact.fact_id,
+                "memory_id": getattr(r.fact, "memory_id", ""),
+                "content": r.fact.content[:300],
+                "score": round(r.score, 4),
+                "confidence": round(getattr(r, "confidence", 0.0), 4),
+                "channel_scores": getattr(r, "channel_scores", {}),
+                "created_at": getattr(r.fact, "created_at", ""),
+            })
 
         # Record learning signals (non-blocking, non-critical)
         try:
-            _record_learning_signals(query, result.get("results", []))
+            _record_learning_signals(query, results)
         except Exception as _sig_exc:
             import logging as _log
             _log.getLogger(__name__).warning("Learning signal error: %s", _sig_exc)
 
         return {
             "query": query,
-            "query_type": result.get("query_type", "unknown"),
-            "result_count": result.get("result_count", 0),
-            "retrieval_time_ms": result.get("retrieval_time_ms", 0),
-            "results": result.get("results", []),
-            "synthesis": synthesis,
+            "query_type": getattr(response, "query_type", "semantic"),
+            "result_count": len(results),
+            "retrieval_time_ms": elapsed_ms,
+            "results": results,
+            "synthesis": "",
         }
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)