switchroom 0.19.24 → 0.19.26

package/vendor/hindsight-memory/scripts/tests/test_recall_request_timeout.py

@@ -0,0 +1,241 @@
+"""Switchroom: the per-bank recall request timeout is a MANAGED KEY, not a literal.
+
+`recall.py` used to pass a bare `timeout=8` to every `client.recall()` call.
+That literal lived inside the vendored plugin tree, which `switchroom apply`
+rm's and re-copies — so an operator who needed a different value had to
+hand-edit the installed plugin and watch the next apply silently revert it. The
+live fleet did exactly that, three separate times, each time quietly restoring
+shipped defaults while switchroom.yaml read as though it were tuned.
+
+It is now `recallRequestTimeoutSeconds` (env:
+HINDSIGHT_RECALL_REQUEST_TIMEOUT_SECONDS), resolved from
+`memory.recall.request_timeout_seconds` and stamped/exported by switchroom.
+
+The assertions here are on the VALUE THAT REACHES THE CLIENT, because that is
+the thing the bug got wrong. Asserting only that the config key parses would
+stay green with the literal still hard-coded at the callsite.
+
+Stdlib-only (unittest); runs under ``python3 -m unittest discover tests/``
+from ``scripts/``.
+"""
+
+import io
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, SCRIPTS_DIR)
+
+import recall  # noqa: E402
+from lib.config import DEFAULTS, ENV_OVERRIDES, load_config  # noqa: E402
+
+BARE = "what did we decide about the auth flow last week"
+
+
+class _RecordingClient:
+    """Captures the `timeout` kwarg of every recall() call."""
+
+    def __init__(self):
+        self.timeouts = []
+
+    def recall(self, **kwargs):
+        self.timeouts.append(kwargs.get("timeout"))
+        return {"memories": []}
+
+    def list_directives(self, *a, **kw):
+        return []
+
+
+class _Harness(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.mkdtemp(prefix="recall-req-timeout-test-")
+        self._prev = os.environ.get("CLAUDE_PLUGIN_DATA")
+        os.environ["CLAUDE_PLUGIN_DATA"] = self._tmpdir
+
+    def tearDown(self):
+        shutil.rmtree(self._tmpdir, ignore_errors=True)
+        if self._prev is None:
+            os.environ.pop("CLAUDE_PLUGIN_DATA", None)
+        else:
+            os.environ["CLAUDE_PLUGIN_DATA"] = self._prev
+
+    def _timeouts(self, config_extra=None):
+        client = _RecordingClient()
+        hook_input = {
+            "prompt": BARE,
+            "session_id": "test-session",
+            "transcript_path": "",
+            "cwd": "/tmp",
+        }
+        config = {
+            "autoRecall": True,
+            "bankId": "own-bank",
+            "recallMaxTokens": 1024,
+            "recallBudget": "mid",
+            "recallContextTurns": 1,
+            "recallMaxQueryChars": 800,
+            "recallPromptPreamble": "",
+        }
+        if config_extra:
+            config.update(config_extra)
+        with patch.object(recall, "load_config", return_value=config), patch.object(
+            recall, "get_api_url", return_value="http://localhost:18888"
+        ), patch.object(recall, "HindsightClient", return_value=client), patch.object(
+            recall, "ensure_bank_mission", return_value=None
+        ), patch.object(recall, "write_state", return_value=None), patch(
+            "sys.stdin", new=io.StringIO(json.dumps(hook_input))
+        ), patch("sys.stdout", new=io.StringIO()), patch(
+            "sys.stderr", new=io.StringIO()
+        ):
+            recall.main()
+        return client.timeouts
+
+
+class PerBankTimeoutIsConfigured(_Harness):
+    def test_default_matches_the_shipped_default(self):
+        # Promotion to a managed key must not change what switchroom ships:
+        # with the key absent from config, the value reaching the client is
+        # exactly DEFAULTS["recallRequestTimeoutSeconds"] — not the client
+        # library's own default, and not None.
+        self.assertEqual(
+            self._timeouts(), [float(DEFAULTS["recallRequestTimeoutSeconds"])]
+        )
+
+    def test_configured_value_reaches_the_client(self):
+        self.assertEqual(
+            self._timeouts({"recallRequestTimeoutSeconds": 13}), [13.0]
+        )
+
+    def test_applies_to_every_bank_in_a_fan_out(self):
+        # One hung bank must not be able to outlive its siblings' budget, so
+        # the value has to reach EVERY bank, not just the own-bank slot.
+        got = self._timeouts(
+            {
+                "recallRequestTimeoutSeconds": 5,
+                "recallAdditionalBanks": ["shared-a", "shared-b"],
+            }
+        )
+        self.assertEqual(len(got), 3)
+        self.assertEqual(set(got), {5.0})
+
+    def test_applies_on_the_serial_rollback_path_too(self):
+        got = self._timeouts(
+            {"recallRequestTimeoutSeconds": 7, "recallParallel": False}
+        )
+        self.assertEqual(got, [7.0])
+
+    def test_unusable_values_fall_back_instead_of_breaking_recall(self):
+        # A malformed or non-positive timeout must not take the pre-turn hook
+        # down to a traceback, and must never become "fail instantly".
+        for bad in ("not-a-number", None, 0, -3):
+            with self.subTest(bad=bad):
+                self.assertEqual(
+                    self._timeouts({"recallRequestTimeoutSeconds": bad}),
+                    [float(DEFAULTS["recallRequestTimeoutSeconds"])],
+                )
+
+
+class ManagedKeyIsWired(unittest.TestCase):
+    def test_key_has_a_default_and_an_env_override(self):
+        # Both halves are required for the key to be settable declaratively:
+        # the default is the shipped value, the env override is what lets
+        # switchroom.yaml outrank a stale ~/.hindsight/claude-code.json.
+        # 12s, raised from the historical 8 by #3760 after measuring that 8s
+        # fired on 96.8% of one agent's own-bank recalls and returned nothing.
+        # Pinned as a literal on purpose: src/setup/hindsight-recall-tunables.ts
+        # carries the same number for the env export, which OUTRANKS this file,
+        # and hindsight-reranker-budget.test.ts fails CI if the two drift.
+        self.assertEqual(DEFAULTS["recallRequestTimeoutSeconds"], 12)
+        self.assertIn("HINDSIGHT_RECALL_REQUEST_TIMEOUT_SECONDS", ENV_OVERRIDES)
+        key, typ = ENV_OVERRIDES["HINDSIGHT_RECALL_REQUEST_TIMEOUT_SECONDS"]
+        self.assertEqual(key, "recallRequestTimeoutSeconds")
+        # int, matching the sibling HINDSIGHT_RECALL_PARALLEL_DEADLINE_SECONDS
+        # override and switchroom's zod schema, which declares
+        # `memory.recall.request_timeout_seconds` as `.int()`
+        # (src/config/schema.ts). A float cast here would accept a value the
+        # schema can never produce; an int cast against a float-typed schema
+        # would silently DROP the override (`_cast_env` returns None and the
+        # assignment is skipped), which is the exact silent-fallthrough this
+        # test class exists to prevent.
+        self.assertIs(typ, int)
+
+    def test_env_override_wins_over_the_built_in_default(self):
+        with patch.dict(
+            os.environ,
+            {"HINDSIGHT_RECALL_REQUEST_TIMEOUT_SECONDS": "11"},
+            clear=False,
+        ):
+            self.assertEqual(load_config()["recallRequestTimeoutSeconds"], 11)
+            self.assertNotEqual(
+                load_config()["recallRequestTimeoutSeconds"],
+                DEFAULTS["recallRequestTimeoutSeconds"],
+            )
+
+
+class EnvBeatsTheUserConfigFile(unittest.TestCase):
+    """The env export is the ONLY carrier that outranks ~/.hindsight/claude-code.json.
+
+    Load order (load_config, lib/config.py:398-455):
+
+        DEFAULTS -> plugin settings.json -> ~/.hindsight/claude-code.json -> env
+
+    Switchroom stamps the envelope into the plugin's settings.json too, but
+    claude-code.json sits ABOVE that stamp and SURVIVES `switchroom apply` — the
+    live fleet had exactly such a file pinning recallParallelDeadlineSeconds to a
+    stale 16. A settings-only stamp is therefore silently defeated, which is why
+    start.sh exports these two UNCONDITIONALLY. These tests pin that precedence
+    so a future "just make it conditional / drop the export" change fails loudly
+    instead of quietly handing authority back to a hand-edited file.
+    """
+
+    ENVELOPE = (
+        ("HINDSIGHT_RECALL_PARALLEL_DEADLINE_SECONDS", "recallParallelDeadlineSeconds", 17, 16),
+        ("HINDSIGHT_RECALL_REQUEST_TIMEOUT_SECONDS", "recallRequestTimeoutSeconds", 13, 99),
+    )
+
+    def setUp(self):
+        self._tmp_home = tempfile.mkdtemp(prefix="recall-envelope-home-")
+        os.makedirs(os.path.join(self._tmp_home, ".hindsight"), exist_ok=True)
+        # Point the plugin-root settings.json probe at an empty dir so only the
+        # two layers under test are in play.
+        self._tmp_plugin = tempfile.mkdtemp(prefix="recall-envelope-plugin-")
+        self._stale = {key: stale for _, key, _, stale in self.ENVELOPE}
+        with open(
+            os.path.join(self._tmp_home, ".hindsight", "claude-code.json"), "w"
+        ) as f:
+            json.dump(self._stale, f)
+
+    def tearDown(self):
+        shutil.rmtree(self._tmp_home, ignore_errors=True)
+        shutil.rmtree(self._tmp_plugin, ignore_errors=True)
+
+    def _patched_env(self, extra):
+        env = {"HOME": self._tmp_home, "CLAUDE_PLUGIN_ROOT": self._tmp_plugin}
+        env.update(extra)
+        return patch.dict(os.environ, env, clear=False)
+
+    def test_a_stale_user_config_wins_when_nothing_is_exported(self):
+        # Establishes that the fixture is real: without the exports the stale
+        # hand-edit IS authoritative, so the next test proves something.
+        for env_name, key, _, stale in self.ENVELOPE:
+            with self.subTest(env_name=env_name), self._patched_env({}):
+                os.environ.pop(env_name, None)
+                self.assertEqual(load_config()[key], stale)
+
+    def test_the_exported_envelope_overrides_a_stale_user_config(self):
+        exports = {env_name: str(want) for env_name, _, want, _ in self.ENVELOPE}
+        with self._patched_env(exports):
+            config = load_config()
+        for _, key, want, stale in self.ENVELOPE:
+            self.assertEqual(config[key], want)
+            self.assertNotEqual(config[key], stale)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/hindsight-memory/scripts/tests/test_recall_transcript_fallback.py

@@ -12,10 +12,16 @@ Acceptance guarantees (outcomes, not code paths):
      suppresses the fallback entirely (no fallback block, log False) — the
      fact layer is not empty.
 
-  3. **Does NOT fire when a bank hit its deadline.** deadline_hit True (a bank
-     abandoned at the shared deadline) means the empty result set may be a
-     TIMEOUT, not a genuinely empty fact layer — the #3369 sequencing
-     constraint — so the fallback is suppressed even though results are empty.
+  3. **DOES fire when a bank hit its deadline** (switchroom #3757 — inverted
+     from the original #3369 gate). The original rule suppressed the fallback
+     on ``deadline_hit`` on the theory that a timeout leaves the fact layer
+     unknown. In production a timeout was the COMMON case (96.8% of the
+     `overlord` agent's own-bank recalls over the 7 days to 2026-07-27), so the
+     rule meant a timed-out turn got neither memories NOR fallback — the agent
+     went in blind. A timeout is not an outage: the banks are healthy, we just
+     ran out of time, and a bounded transcript grep beats nothing. A hard bank
+     ERROR still suppresses it (guarantee 3b) because an unreachable store CAN
+     masquerade as an empty fact layer.
 
   4. **Byte bound holds.** With a small ``…MaxBytes``, only the transcript TAIL
      is read: a query-matching line that lives only in the (discarded) HEAD is
@@ -249,8 +255,15 @@ class DoesNotFireWhenFactLayerNotEmpty(_Harness):
         self.assertEqual(e["result_count"], 1)
 
 
-class DoesNotFireWhenDeadlineHit(_Harness):
-    def test_timed_out_bank_suppresses_fallback(self):
+class FiresWhenDeadlineHit(_Harness):
+    """Switchroom #3757 — a TIMEOUT must not cost the turn its fallback too.
+
+    This is the exact inversion of the original #3369 gate. Before the fix a
+    timed-out recall produced neither memories nor fallback, which on the
+    fleet's large banks was the majority of turns.
+    """
+
+    def test_timed_out_bank_still_fires_fallback(self):
         transcript = self._write_transcript([
             _nested_line("user", "we should redo the auth flow with PKCE"),
         ])
@@ -268,10 +281,14 @@ class DoesNotFireWhenDeadlineHit(_Harness):
                 "recallParallelDeadlineSeconds": 0.5,
             },
         )
-        self.assertIsNone(context, "fallback must not fire when a bank timed out")
+        self.assertIsNotNone(
+            context, "a timed-out recall must still get the transcript fallback"
+        )
+        self.assertIn("<hindsight_transcript_fallback>", context)
+        self.assertIn("PKCE", context)
         e = self._read_log()[0]
         self.assertTrue(e["deadline_hit"])
-        self.assertFalse(e["transcript_fallback"])
+        self.assertTrue(e["transcript_fallback"])
 
 
 class DoesNotFireWhenBankErrored(_Harness):

package/vendor/hindsight-memory/tests/test_content.py

@@ -7,13 +7,16 @@ import pytest
 from lib.content import (
     _extract_text_content,
     _is_channel_message_tool,
+    _selectivity_score,
     compose_recall_query,
     format_current_time,
     format_memories,
     prepare_retention_transcript,
+    shape_recall_query,
     slice_last_turns_by_user_boundary,
     strip_channel_envelope,
     strip_memory_tags,
+    tokenize_for_bm25,
     truncate_recall_query,
 )
 
@@ -648,3 +651,218 @@ class TestFormatCurrentTime:
         monkeypatch.delenv("TZ", raising=False)
         out = format_current_time()
         assert re.match(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2} (?:AM|PM)", out), out
+
+
+# ---------------------------------------------------------------------------
+# Switchroom #3757 — BM25 query shaping
+#
+# The bug these guard: the recall hook composed an 800-char, ~110-token query
+# and Hindsight OR-joined every token into one tsquery. On the live `overlord`
+# bank that matched 119,510 of 135,565 rows and took 14.0s for the 3-arm BM25
+# UNION — past the per-bank client timeout, so 96.8% of that agent's own-bank
+# recalls returned NOTHING. Two of those tokens were scaffolding this hook
+# added itself: `user` (67,363 rows = 50% of the bank) and `assistant`
+# (29,942 = 22%).
+# ---------------------------------------------------------------------------
+
+
+def _production_shaped_query():
+    """A composed query with the shape recall.py actually produces."""
+    msgs = _msgs(
+        ("user", "the deploy went out this morning but the rollout never reached the fleet"),
+        (
+            "assistant",
+            "I checked the manifest for v0.19.17 and the digest does not match what "
+            "the agent container is running, so the pull raced the tag",
+        ),
+    )
+    return compose_recall_query(
+        "why did recall for the v0.19.17 rollout return v0.18.15 instead",
+        msgs,
+        recall_context_turns=2,
+    )
+
+
+class TestComposedQueryHasNoRoleLabels:
+    def test_compose_does_not_prefix_role_labels(self):
+        # The regression this guards: `context_lines.append(f"{role}: {content}")`.
+        msgs = _msgs(("user", "prior question"), ("assistant", "prior answer"))
+        result = compose_recall_query("current question", msgs, recall_context_turns=2)
+        assert "prior question" in result
+        assert "prior answer" in result
+        assert "user:" not in result
+        assert "assistant:" not in result
+
+    def test_role_labels_are_not_bm25_tokens(self):
+        # The property that actually matters — not "the string is absent" but
+        # "the term never reaches the tsquery".
+        query = _production_shaped_query()
+        shaped = shape_recall_query(query, "why did recall for the v0.19.17 rollout "
+                                           "return v0.18.15 instead")
+        terms = set(tokenize_for_bm25(shaped))
+        assert "user" not in terms
+        assert "assistant" not in terms
+        assert "prior" not in terms
+        assert "context" not in terms
+
+    def test_labels_embedded_in_transcript_text_are_still_stripped(self):
+        # Defence in depth: an old composed string, or a turn that literally
+        # contains a `user:` line, must not smuggle the label back in.
+        legacy = "Prior context:\n\nuser: the deploy failed\nassistant: I checked it\n\nwhy"
+        terms = set(tokenize_for_bm25(shape_recall_query(legacy, "why")))
+        assert "user" not in terms
+        assert "assistant" not in terms
+        assert "deploy" in terms
+
+
+class TestShapeRecallQuery:
+    def test_caps_distinct_bm25_terms(self):
+        query = " ".join(f"distinctword{i}" for i in range(200))
+        shaped = shape_recall_query(query, "", max_tokens=24)
+        assert len(set(tokenize_for_bm25(shaped))) <= 24
+
+    def test_cap_counts_compound_token_expansion(self):
+        # A compound is emitted by the server ALONGSIDE its fragments
+        # (`v0.19.17` → v0.19.17, v0, 19, 17), so a naive "count the words we
+        # sent" cap would silently ship 4x the terms it promised.
+        query = " ".join(f"v0.19.{i}" for i in range(40))
+        shaped = shape_recall_query(query, "", max_tokens=24)
+        assert len(set(tokenize_for_bm25(shaped))) <= 24
+
+    def test_cap_is_configurable(self):
+        query = " ".join(f"distinctword{i}" for i in range(200))
+        assert len(set(tokenize_for_bm25(shape_recall_query(query, "", max_tokens=8)))) <= 8
+        assert len(set(tokenize_for_bm25(shape_recall_query(query, "", max_tokens=40)))) <= 40
+
+    def test_zero_disables_shaping(self):
+        query = "Prior context:\n\nsomething\n\nlatest"
+        assert shape_recall_query(query, "latest", max_tokens=0) == query
+
+    def test_prefers_latest_turn_over_prior_context(self):
+        # A chronological truncation would keep the OLDEST context and throw
+        # away the question the user actually asked, so the latest turn takes
+        # the MAJORITY of the budget. But recency is a weight plus a bounded
+        # quota, not an absolute tier (#3760 review, Blocker 2): the subject of
+        # a conversation routinely sits in the turn BEFORE the one that refers
+        # to it as "it"/"that", and an absolute tier starves it every time.
+        prior = " ".join(f"stalecontextword{i}" for i in range(60))
+        latest = "why does the reaper skip orphaned worktrees"
+        query = f"Prior context:\n\n{prior}\n\n{latest}"
+        # Every prior token here is strictly MORE selective than anything in
+        # the question (they carry digits; the question is plain English), so
+        # pure merit ordering would hand prior context all four slots and the
+        # user would search for none of what they asked.
+        assert _selectivity_score("stalecontextword0") > _selectivity_score("worktrees")
+        # The latest-turn reserve is what stops that. At a punishing cap it is
+        # only `max_tokens // 3` slots — the question is represented, not
+        # preserved whole, which is the honest tradeoff when prior context is
+        # genuinely more discriminating.
+        tight = tokenize_for_bm25(shape_recall_query(query, latest, max_tokens=4))
+        from_question = set(tight) & {"reaper", "skip", "orphaned", "worktrees"}
+        assert len(from_question) >= max(1, 4 // 3)
+        assert len(set(tight)) <= 4
+        # With slack, the latest turn is still fully present and the leftover
+        # budget goes to context (which is the point of composing at all).
+        loose = set(tokenize_for_bm25(shape_recall_query(query, latest, max_tokens=12)))
+        assert {"reaper", "skip", "orphaned", "worktrees"} <= loose
+        assert any(t.startswith("stalecontextword") for t in loose)
+        assert len(loose) <= 12
+
+    def test_drops_english_stopwords(self):
+        latest = "what did we decide about the worktree reaper"
+        terms = set(tokenize_for_bm25(shape_recall_query(latest, latest, max_tokens=24)))
+        assert "worktree" in terms
+        assert "reaper" in terms
+        assert "decide" in terms
+        for stop in ("what", "did", "we", "about", "the"):
+            assert stop not in terms
+
+    def test_operator_stop_terms_are_dropped(self):
+        # Bank-specific high-df words the generic stoplist cannot know about.
+        latest = "the switchroom agent rollout stalled on the reaper"
+        terms = set(
+            tokenize_for_bm25(
+                shape_recall_query(latest, latest, max_tokens=24,
+                                   stop_terms=["switchroom", "agent"])
+            )
+        )
+        assert "reaper" in terms
+        assert "rollout" in terms
+        assert "switchroom" not in terms
+        assert "agent" not in terms
+
+    def test_short_query_survives_intact(self):
+        # No regression for the small-bank / short-prompt case: every content
+        # word is kept, so recall quality is unchanged.
+        latest = "worktree gc reaper timings"
+        terms = set(tokenize_for_bm25(shape_recall_query(latest, latest, max_tokens=24)))
+        assert terms == {"worktree", "gc", "reaper", "timings"}
+
+    def test_all_stopword_query_is_not_emptied(self):
+        # A conversational prompt must never be shaped down to nothing — an
+        # empty query would return zero memories, the exact failure we are
+        # fixing.
+        latest = "what about that"
+        shaped = shape_recall_query(latest, latest, max_tokens=24)
+        assert tokenize_for_bm25(shaped)
+
+    def test_untokenizable_query_returns_original(self):
+        assert shape_recall_query("!!! ???", "!!! ???", max_tokens=24) == "!!! ???"
+
+    def test_preserves_original_word_order(self):
+        latest = "reaper skipped orphaned worktrees before rollout"
+        shaped = shape_recall_query(latest, latest, max_tokens=24)
+        # "before" is a stopword; the survivors keep the source order.
+        assert shaped.split() == ["reaper", "skipped", "orphaned", "worktrees", "rollout"]
+
+    def test_unparseable_cap_disables_shaping_instead_of_raising(self):
+        # max_tokens arrives from settings.json / env. A config error must
+        # degrade to "send it unshaped", never raise on the recall hot path.
+        latest = "the reaper skipped orphaned worktrees before the rollout"
+        for bad in (None, "x", "", [], {}):
+            assert shape_recall_query(latest, latest, max_tokens=bad) == latest
+
+    def test_numeric_string_cap_is_honoured(self):
+        latest = "the reaper skipped orphaned worktrees before the rollout"
+        shaped = shape_recall_query(latest, latest, max_tokens="3")
+        assert len(set(tokenize_for_bm25(shaped))) <= 3
+
+    def test_stop_terms_given_as_a_bare_string_are_split_not_iterated(self):
+        # "reaper,worktrees" iterated as characters would stop-list half the
+        # alphabet and gut the query.
+        latest = "the reaper skipped orphaned worktrees before the rollout"
+        shaped = shape_recall_query(latest, latest, 24, stop_terms="reaper, worktrees")
+        terms = set(tokenize_for_bm25(shaped))
+        assert "reaper" not in terms
+        assert "worktrees" not in terms
+        assert {"skipped", "orphaned", "rollout"} <= terms
+
+    def test_preserves_original_case(self):
+        # The shaped string feeds BOTH arms. BM25 lowercases server-side, but
+        # the embedding arm does not, so shaping must not flatten `Python` to
+        # `python` or `PR` to `pr`.
+        latest = "should the Python worker open a PR against Coolify"
+        shaped = shape_recall_query(latest, latest, max_tokens=24)
+        assert shaped.split() == ["Python", "worker", "open", "PR", "Coolify"]
+
+    def test_production_shaped_query_fits_the_budget(self):
+        query = _production_shaped_query()
+        latest = "why did recall for the v0.19.17 rollout return v0.18.15 instead"
+        shaped = shape_recall_query(query, latest, max_tokens=24)
+        terms = set(tokenize_for_bm25(shaped))
+        assert len(terms) <= 24
+        # The discriminating identifiers from the latest turn survive.
+        assert "v0.19.17" in terms
+        assert "rollout" in terms
+
+
+class TestTokenizeForBm25:
+    def test_matches_server_tokenizer_on_compounds(self):
+        # Mirrors hindsight_api/engine/search/retrieval.py::tokenize_query —
+        # fragments PLUS the intact compound.
+        tokens = tokenize_for_bm25("bumped to v0.19.17")
+        assert "v0.19.17" in tokens
+        assert {"v0", "19", "17"} <= set(tokens)
+
+    def test_empty_for_punctuation_only(self):
+        assert tokenize_for_bm25("!!! ???") == []