fix(searcher): wire i18n stop_words through BM25 fallback / union path

scoring site inside _bm25_only_via_sqlite that this PR did not cover --
the original wiring landed before MemPalace#1306 existed. Without the plumbing,
two paths silently bypass locale stop_words even when the palace has
MEMPALACE_LANG set:

- vector_disabled=True (MemPalace#1222 fallback): BM25-only scoring runs without
  filtering.
- candidate_strategy="union": BM25 candidates merged into the rerank
  pool come from a tokenizer that ignored the configured locale, so
  the merged-in entries fight the lang-aware _hybrid_rank rerank.

Resolution moves once: stop_words = _resolve_stop_words(lang) is
hoisted before the vector_disabled branch and threaded through
_apply_candidate_strategy, _merge_bm25_union_candidates, and
_bm25_only_via_sqlite into _bm25_scores.

The FTS5 candidate-selection _tokenize at the top of
_bm25_only_via_sqlite is left untouched -- chromadb's FTS5 index
is built with a trigram tokenizer that already mismatches our
\\w{2,} regex, so dropping further tokens there changes selection
semantics in ways outside this PR's scope.

Three tests pin the propagation: a sqlite-backed test for
_bm25_only_via_sqlite -> _bm25_scores, a unit spy on
_apply_candidate_strategy -> merger, and an end-to-end on
search_memories(vector_disabled=True) -> _bm25_only_via_sqlite.

Author: mvalentsev

mempalace/searcher.py

@@ -433,6 +433,7 @@ def _bm25_only_via_sqlite(
     max_candidates: int = 500,
     _include_internal: bool = False,
     collection_name: str = None,
+    stop_words: frozenset = frozenset(),
 ) -> dict:
     """BM25-only search reading drawers directly from chroma.sqlite3.
 
@@ -637,7 +638,7 @@ def _metadata_filter_sql(row_id_expr: str) -> tuple[str, list[str]]:
 
     # Local BM25 over the candidate set.
     docs = [c["text"] for c in candidates]
-    bm25_raw = _bm25_scores(query, docs)
+    bm25_raw = _bm25_scores(query, docs, stop_words=stop_words)
     max_bm25 = max(bm25_raw) if bm25_raw else 0.0
     for c, raw in zip(candidates, bm25_raw):
         c["bm25_score"] = round(raw, 3)
@@ -671,6 +672,7 @@ def _merge_bm25_union_candidates(
     room: str,
     n_results: int,
     max_distance: float = 0.0,
+    stop_words: frozenset = frozenset(),
 ) -> None:
     """Append top-K BM25-only candidates from sqlite into ``hits`` in place.
 
@@ -705,6 +707,7 @@ def _merge_bm25_union_candidates(
             room=room,
             n_results=n_results * 3,
             _include_internal=True,
+            stop_words=stop_words,
         ).get("results", [])
     except Exception:
         logger.debug("candidate_strategy=union: BM25 fetch failed", exc_info=True)
@@ -763,6 +766,7 @@ def _apply_candidate_strategy(
     room: str,
     n_results: int,
     max_distance: float = 0.0,
+    stop_words: frozenset = frozenset(),
 ) -> None:
     """Dispatch to the registered merger for ``strategy``.
 
@@ -771,7 +775,16 @@ def _apply_candidate_strategy(
     """
     merger = _CANDIDATE_MERGERS[strategy]
     if merger is not None:
-        merger(hits, query, palace_path, wing, room, n_results, max_distance=max_distance)
+        merger(
+            hits,
+            query,
+            palace_path,
+            wing,
+            room,
+            n_results,
+            max_distance=max_distance,
+            stop_words=stop_words,
+        )
 
 
 def search_memories(
@@ -834,6 +847,11 @@ def search_memories(
     # the BM25-only fallback below.
     _validate_candidate_strategy(candidate_strategy)
 
+    # Resolve stop words once up-front so every BM25 site (the vector path's
+    # `_hybrid_rank`, the `vector_disabled` fallback, and the union-merge
+    # candidate gather) tokenizes against the same locale.
+    stop_words = _resolve_stop_words(lang)
+
     if vector_disabled:
         return _bm25_only_via_sqlite(
             query,
@@ -842,10 +860,9 @@ def search_memories(
             room=room,
             n_results=n_results,
             collection_name=collection_name,
+            stop_words=stop_words,
         )
 
-    stop_words = _resolve_stop_words(lang)
-
     try:
         drawers_col = get_collection(palace_path, collection_name=collection_name, create=False)
     except Exception as e:
@@ -1036,6 +1053,7 @@ def search_memories(
         room,
         n_results,
         max_distance=max_distance,
+        stop_words=stop_words,
     )
 
     # BM25 hybrid re-rank within the final candidate set, then trim back

tests/test_searcher.py

@@ -5,6 +5,7 @@
 plus mock-based tests for error paths.
 """
 
+import sqlite3
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -522,3 +523,107 @@ class FakeCfgJa:
     assert (
         "した" in second
     ), f"cache pinned stale empty set for None after config change; got {second!r}"
+
+
+# ── stop_words propagation through BM25-only / union-merge paths (post-#1306) ──
+#
+# #1306 added a second BM25 scoring site inside `_bm25_only_via_sqlite` that
+# the original PR didn't cover (it landed on develop after this branch was
+# opened). These tests pin the propagation chain so the BM25 fallback and the
+# `candidate_strategy="union"` merge tokenize at the same locale as
+# `_hybrid_rank`.
+
+
+def test_bm25_only_via_sqlite_forwards_stop_words_to_bm25_scores(monkeypatch, tmp_path):
+    """`_bm25_only_via_sqlite` must pass `stop_words` into `_bm25_scores`.
+
+    Without this, vector-disabled (#1222) palaces silently lose stop-word
+    filtering on the BM25 fallback path.
+    """
+    from mempalace import searcher
+
+    captured = {}
+    real_bm25 = searcher._bm25_scores
+
+    def _spy(query, docs, **kwargs):
+        captured["stop_words"] = kwargs.get("stop_words")
+        return real_bm25(query, docs, **kwargs)
+
+    monkeypatch.setattr(searcher, "_bm25_scores", _spy)
+
+    # Build a minimal chroma.sqlite3 with one matching drawer so the scoring
+    # path is reached. Schema mirrors what `_bm25_only_via_sqlite` reads.
+    db = tmp_path / "chroma.sqlite3"
+    conn = sqlite3.connect(db)
+    conn.executescript(
+        """
+        CREATE VIRTUAL TABLE embedding_fulltext_search USING fts5(string_value, tokenize='trigram');
+        CREATE TABLE embedding_metadata (id INTEGER, key TEXT, string_value TEXT, int_value INTEGER);
+        INSERT INTO embedding_fulltext_search (rowid, string_value) VALUES (1, 'the cat sat');
+        INSERT INTO embedding_metadata VALUES (1, 'chroma:document', 'the cat sat', NULL);
+        INSERT INTO embedding_metadata VALUES (1, 'wing', 'general', NULL);
+        INSERT INTO embedding_metadata VALUES (1, 'room', 'inbox', NULL);
+        INSERT INTO embedding_metadata VALUES (1, 'source_file', '/x/cat.md', NULL);
+        INSERT INTO embedding_metadata VALUES (1, 'filed_at', '2026-05-03', NULL);
+        """
+    )
+    conn.commit()
+    conn.close()
+
+    searcher._bm25_only_via_sqlite(
+        "the cat",
+        str(tmp_path),
+        n_results=5,
+        stop_words=frozenset({"the"}),
+    )
+
+    assert captured["stop_words"] == frozenset({"the"})
+
+
+def test_apply_candidate_strategy_forwards_stop_words_to_merger(monkeypatch):
+    """`_apply_candidate_strategy` must forward `stop_words` to the merger."""
+    from mempalace import searcher
+
+    captured = {}
+
+    def _stub_merger(hits, query, palace, wing, room, n, **kwargs):
+        captured.update(kwargs)
+
+    monkeypatch.setitem(searcher._CANDIDATE_MERGERS, "union", _stub_merger)
+
+    searcher._apply_candidate_strategy(
+        "union",
+        [],
+        "q",
+        "/p",
+        None,
+        None,
+        n_results=5,
+        max_distance=0.0,
+        stop_words=frozenset({"a", "an"}),
+    )
+
+    assert captured["stop_words"] == frozenset({"a", "an"})
+
+
+def test_search_memories_vector_disabled_uses_resolved_stop_words(monkeypatch, tmp_path):
+    """`vector_disabled=True` must route `_resolve_stop_words(lang)` into the
+    BM25 fallback, not skip stop-word resolution as it did pre-fix."""
+    from mempalace import searcher
+
+    captured = {}
+
+    def _stub(*args, **kwargs):
+        captured["stop_words"] = kwargs.get("stop_words")
+        return {"results": [], "fallback": "bm25_only_via_sqlite"}
+
+    monkeypatch.setattr(searcher, "_bm25_only_via_sqlite", _stub)
+    monkeypatch.setattr(searcher, "_resolve_stop_words", lambda lang: frozenset({"de", "es"}))
+
+    searcher.search_memories(
+        query="q",
+        palace_path=str(tmp_path),
+        vector_disabled=True,
+    )
+
+    assert captured["stop_words"] == frozenset({"de", "es"})