switchroom 0.19.24 → 0.19.26

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

@@ -546,59 +546,6 @@ class AckShortCircuitTests(unittest.TestCase):
         self.assertIsNotNone(ctx)
 
 
-class ContainmentOverlapUnitTests(unittest.TestCase):
-    """Switchroom #475 / #3541: pure-function tests for the relevance helpers."""
-
-    def test_identical_text_is_full_overlap(self):
-        # Modulo stop-word stripping (`is`, `the`, `a`, `to` removed).
-        self.assertEqual(
-            recall.containment_overlap("deploy the staging server", "deploy the staging server"),
-            1.0,
-        )
-
-    def test_disjoint_text_is_zero(self):
-        self.assertEqual(
-            recall.containment_overlap("deploy staging server", "vegan dinner recipes"),
-            0.0,
-        )
-
-    def test_partial_overlap_is_between(self):
-        score = recall.containment_overlap(
-            "deploy staging server",
-            "deploy production server",
-        )
-        # {deploy, staging, server} vs {deploy, production, server}
-        # → intersection 2, |M| = 3 → 0.666…
-        self.assertAlmostEqual(score, 2 / 3, places=2)
-
-    def test_stopwords_dont_inflate_overlap(self):
-        # "the" / "is" / "a" present in both shouldn't count.
-        score = recall.containment_overlap("the cat is a pet", "the dog is a pet")
-        # Real tokens after stopword strip: {cat, pet} vs {dog, pet}
-        # → intersection 1, |M| = 2 → 0.5
-        self.assertAlmostEqual(score, 0.5, places=2)
-
-    def test_empty_text_yields_zero(self):
-        self.assertEqual(recall.containment_overlap("", "anything at all"), 0.0)
-        self.assertEqual(recall.containment_overlap("query", ""), 0.0)
-
-    def test_non_string_inputs_yield_zero(self):
-        self.assertEqual(recall.containment_overlap(None, "x"), 0.0)
-        self.assertEqual(recall.containment_overlap("x", None), 0.0)
-
-    def test_case_insensitive(self):
-        self.assertEqual(
-            recall.containment_overlap("DEPLOY Server", "deploy server"),
-            1.0,
-        )
-
-    def test_punctuation_stripped(self):
-        self.assertEqual(
-            recall.containment_overlap("deploy, server!", "deploy server"),
-            1.0,
-        )
-
-
 class InjectedScoreStatsUnitTests(unittest.TestCase):
     """#3541 — aggregates for the injected set. Must be total and non-fatal:
     telemetry can never take recall down."""
@@ -646,354 +593,6 @@ class InjectedScoreStatsUnitTests(unittest.TestCase):
         )
 
 
-class OverlapFilterUnitTests(unittest.TestCase):
-    """Switchroom #475: _filter_by_overlap behaviour."""
-
-    def test_threshold_zero_passthrough(self):
-        results = [_memory("totally unrelated text")]
-        kept, dropped = recall._filter_by_overlap(results, "deploy server", 0.0)
-        self.assertEqual(kept, results)
-        self.assertEqual(dropped, 0)
-
-    def test_high_threshold_drops_weak_matches(self):
-        results = [
-            _memory("deploy server staging"),  # full overlap
-            _memory("vegan dinner recipes"),    # zero overlap
-        ]
-        kept, dropped = recall._filter_by_overlap(results, "deploy server staging", 0.5)
-        self.assertEqual(len(kept), 1)
-        self.assertEqual(dropped, 1)
-        self.assertEqual(kept[0]["text"], "deploy server staging")
-
-    def test_threshold_keeps_partial_match_at_or_above(self):
-        results = [_memory("deploy production server")]
-        kept, dropped = recall._filter_by_overlap(results, "deploy staging server", 0.5)
-        # 2/|M| = 2/3 = 0.666… ≥ 0.5 → kept
-        self.assertEqual(len(kept), 1)
-        self.assertEqual(dropped, 0)
-
-    def test_threshold_drops_partial_match_below(self):
-        results = [_memory("deploy production server")]
-        # 2/|M| = 2/3 = 0.666… < 0.7 → dropped
-        kept, dropped = recall._filter_by_overlap(results, "deploy staging server", 0.7)
-        self.assertEqual(len(kept), 0)
-        self.assertEqual(dropped, 1)
-
-
-class OverlapGateQueryLengthInvarianceTests(unittest.TestCase):
-    """Switchroom #3541 regression: the gate must not be decided by prompt length.
-
-    Production telemetry (1548 recall_log.jsonl rows, ts >= 2026-07-18) showed
-    the survival rate through this gate collapsing monotonically as the prompt
-    grew — 7.3% at <200 query chars down to 0.9% at 600-750 chars — with a
-    93% zero-result rate at the long end. That is the Jaccard union term, not a
-    relevance judgement. These tests pin the containment metric that fixes it.
-    """
-
-    # A realistic recall query: the memory-bearing sentence plus the long
-    # unrelated prior-context preamble the UserPromptSubmit hook prepends.
-    CORE_QUERY = "where did we land on the postgres connection pool sizing"
-    PREAMBLE = (
-        "Prior context: the operator asked about telegram card rendering, then "
-        "about vault broker grants, then about the nightly digest schedule and "
-        "the reaction dispatch wiring, and separately about docker image "
-        "promotion, canary holdback, worktree hygiene, changelog discipline, "
-        "eval harness thresholds, skill authoring quotas and mental model "
-        "refresh cadence across the whole fleet of agents on this host. "
-    )
-    MEMORY = "Postgres connection pool sizing was settled at min 5 max 100."
-
-    @staticmethod
-    def _filler(n_words):
-        """Generate `n_words` DISTINCT unrelated content words.
-
-        Distinctness matters: the metrics operate on token *sets*, so
-        repeating the same paragraph would not grow ``|Q|`` and a
-        length-sensitivity test built on it would silently pass even under
-        the buggy Jaccard metric.
-
-        The words must also be purely alphabetic — ``_overlap_tokens``
-        splits on every non-alpha character, so a digit-suffixed word like
-        ``filler7word`` collapses to the two tokens ``filler``/``word`` no
-        matter how many are emitted.
-        """
-        letters = "abcdefghijklmnopqrstuvwxyz"
-        return " ".join(
-            "zz" + letters[i // 26 % 26] + letters[i % 26] for i in range(n_words)
-        )
-
-    def test_extra_preamble_does_not_change_the_score(self):
-        """In the production regime (query longer than the memory — always
-        true for the UserPromptSubmit preamble), piling on more unrelated
-        preamble must NOT move the score. Under Jaccard these two differ,
-        because the union term grows with the prompt; under containment the
-        denominator is the memory, so they are identical."""
-        short = recall.containment_overlap(
-            self._filler(20) + " " + self.CORE_QUERY, self.MEMORY
-        )
-        long_ = recall.containment_overlap(
-            self._filler(200) + " " + self.CORE_QUERY, self.MEMORY
-        )
-        self.assertGreater(short, 0.0, "sanity: the memory does overlap the query")
-        self.assertAlmostEqual(
-            short,
-            long_,
-            places=6,
-            msg="prompt length changed the gate score — the union-term artifact is back",
-        )
-
-    def test_relevant_memory_survives_a_production_length_prompt(self):
-        """At the fleet default threshold (0.10, scaffold.ts), a clearly
-        relevant memory must survive a production-p50-length prompt."""
-        query = self.PREAMBLE + self.CORE_QUERY
-        self.assertGreater(
-            len(query), 400, "sanity: this is a production-shaped long prompt"
-        )
-        kept, dropped = recall._filter_by_overlap([_memory(self.MEMORY)], query, 0.10)
-        self.assertEqual(
-            len(kept), 1, "relevant memory was dropped from a long prompt"
-        )
-        self.assertEqual(dropped, 0)
-
-    def test_gate_still_drops_irrelevant_memories_on_a_long_prompt(self):
-        """The floor must still bite: a length-invariant metric must not
-        become a passthrough. An unrelated memory is still dropped."""
-        query = self.PREAMBLE + self.CORE_QUERY
-        kept, dropped = recall._filter_by_overlap(
-            [_memory("Ken prefers oat milk in his flat white.")], query, 0.10
-        )
-        self.assertEqual(len(kept), 0, "gate no longer filters — floor is dead")
-        self.assertEqual(dropped, 1)
-
-    # --- switchroom #3541 review F4: what the floor does and does NOT do ---
-    #
-    # `test_gate_still_drops_irrelevant_memories_on_a_long_prompt` above uses a
-    # memory with ZERO shared terms, so it scores 0.000 and would pass at a
-    # threshold of 0.001. It proves the gate is not a total no-op; it does not
-    # characterise the floor. These two do.
-
-    IRRELEVANT_BUT_OVERLAPPING = (
-        "The nightly digest schedule and the reaction dispatch wiring "
-        "were changed."
-    )
-
-    def test_partially_overlapping_irrelevant_memory_is_KEPT_at_the_default(self):
-        """Characterisation, not aspiration: at the 0.10 fleet default the gate
-        KEEPS an off-topic memory that merely reuses words from the prompt's
-        prior-context preamble.
-
-        This memory has nothing to do with the actual question (postgres pool
-        sizing) but shares most of its content tokens with the preamble, so it
-        scores ~0.857 — HIGHER than the genuinely relevant memory (~0.571).
-        Containment is therefore NOT monotone in relevance on a preamble-heavy
-        prompt, which is precisely why the threshold is not raised to try to
-        exclude this: any threshold that drops it drops the relevant memory
-        first. Precision here is the engine reranker's job, not the gate's.
-
-        If this test ever starts failing because the memory is now dropped,
-        the gate's selectivity changed — re-measure before accepting it.
-        """
-        query = self.PREAMBLE + self.CORE_QUERY
-        off_topic = recall.containment_overlap(query, self.IRRELEVANT_BUT_OVERLAPPING)
-        relevant = recall.containment_overlap(query, self.MEMORY)
-        self.assertGreater(
-            off_topic,
-            relevant,
-            "the relevance inversion this test documents is gone — "
-            "re-derive the threshold recommendation",
-        )
-        kept, dropped = recall._filter_by_overlap(
-            [_memory(self.IRRELEVANT_BUT_OVERLAPPING)], query, 0.10
-        )
-        self.assertEqual(len(kept), 1, "gate selectivity changed — re-measure")
-        self.assertEqual(dropped, 0)
-
-    def test_floor_drops_a_long_memory_with_only_incidental_overlap(self):
-        """Where the floor DOES bite: because the denominator is the memory's
-        own token count, a long memory sharing a single incidental term with
-        the prompt scores below 0.10 and is dropped.
-
-        This is the real content of the floor after #3541 — it removes
-        candidates with near-zero lexical relationship to the prompt, and
-        (deliberately) little else.
-        """
-        query = self.PREAMBLE + self.CORE_QUERY
-        # Exactly 1 shared content token ("docker") out of 17 -> 0.059 < 0.10
-        long_incidental = (
-            "docker buildx bake emits oci manifests whose provenance "
-            "attestations confuse older registries during garbage collection "
-            "sweeps"
-        )
-        score = recall.containment_overlap(query, long_incidental)
-        self.assertLess(score, 0.10, "fixture no longer scores below the floor")
-        self.assertGreater(score, 0.0, "sanity: there IS some incidental overlap")
-        kept, dropped = recall._filter_by_overlap(
-            [_memory(long_incidental)], query, 0.10
-        )
-        self.assertEqual(len(kept), 0, "floor is dead — nothing is being dropped")
-        self.assertEqual(dropped, 1)
-
-    # --- switchroom #3541 review F5: the |Q| < |M| regime ---
-
-    def test_short_prompt_uses_the_memory_as_denominator(self):
-        """A short prompt must NOT be scored against itself.
-
-        With the textbook overlap coefficient (`min(|Q|, |M|)`) a prompt
-        shorter than the memory flips the denominator to the QUERY, and the
-        metric silently becomes "what fraction of the prompt is in the
-        memory" — a one-word prompt then scores 1.0 against any memory
-        containing that word, re-introducing the query-length dependence
-        #3541 exists to remove. Dividing by `|M|` unconditionally has no such
-        discontinuity.
-        """
-        memory = "Postgres connection pool sizing was settled at min 5 max 100."
-        n_mem = len(recall._overlap_tokens(memory))
-        query = "docker"  # 1 content token, far shorter than the memory
-        self.assertLess(
-            len(recall._overlap_tokens(query)),
-            n_mem,
-            "sanity: this is the |Q| < |M| regime",
-        )
-        # A min()-denominator would score this 1.0 (1 shared token / |Q| = 1);
-        # dividing by the memory gives 1/2.
-        self.assertEqual(recall.containment_overlap(query, "docker image"), 0.5)
-
-        # And a short prompt overlapping the memory scores by the memory:
-        q2 = "postgres pool"
-        expected = len(
-            recall._overlap_tokens(q2) & recall._overlap_tokens(memory)
-        ) / n_mem
-        self.assertAlmostEqual(
-            recall.containment_overlap(q2, memory), expected, places=6
-        )
-
-    def test_never_stricter_than_the_jaccard_gate_it_replaces(self):
-        """Safety property vs what production runs today: because
-        `|Q u M| >= |M|`, containment >= Jaccard for every pair. At a fixed
-        threshold this gate admits a SUPERSET of what the deployed Jaccard
-        gate admits, so no memory that survives today can be dropped by this
-        change. Asserted over the fixtures rather than argued in prose.
-        """
-        query = self.PREAMBLE + self.CORE_QUERY
-        cases = [
-            self.MEMORY,
-            self.IRRELEVANT_BUT_OVERLAPPING,
-            "Ken prefers oat milk in his flat white.",
-            "docker",
-            "postgres pool sizing",
-            self.PREAMBLE,
-        ]
-        for mem in cases:
-            a = recall._overlap_tokens(query)
-            b = recall._overlap_tokens(mem)
-            jac = (len(a & b) / len(a | b)) if (a and b) else 0.0
-            score = recall.containment_overlap(query, mem)
-            self.assertGreaterEqual(
-                score + 1e-12,
-                jac,
-                f"containment scored BELOW jaccard for {mem[:40]!r} — "
-                f"this change could drop a memory production keeps",
-            )
-            # Upper bound + exact value. Review finding: the lower bound
-            # alone is unfalsifiable for ANY implementation dividing by |M|
-            # (a constant `return 1.0` satisfies it), so it survived every
-            # mutation and proved nothing. These two pin the metric.
-            self.assertLessEqual(score, 1.0, f"containment exceeded 1.0 for {mem[:40]!r}")
-            expected = (len(a & b) / len(b)) if b else 0.0
-            self.assertAlmostEqual(
-                score, expected, places=9,
-                msg=f"containment is not |Q n M| / |M| for {mem[:40]!r}",
-            )
-
-    def test_strict_subset_memory_scores_strictly_below_one(self):
-        """A memory carrying a term the query does NOT have must score < 1.0.
-
-        The companion upper bound to the superset property above: it is what
-        actually falsifies a degenerate `return 1.0` implementation.
-        """
-        query = self.PREAMBLE + self.CORE_QUERY
-        # Every token of this memory except `quokka` appears in the query.
-        mem = self.CORE_QUERY + " quokka"
-        score = recall.containment_overlap(query, mem)
-        self.assertLess(score, 1.0)
-        self.assertGreater(score, 0.0)
-        # And a fully-contained memory reaches exactly 1.0, so the < 1.0
-        # above is a property of the missing term, not a ceiling artefact.
-        self.assertAlmostEqual(
-            recall.containment_overlap(query, self.CORE_QUERY), 1.0, places=9
-        )
-
-    def test_survival_does_not_degrade_as_the_prompt_grows(self):
-        """Sweep prompt length the way production does and assert the relevant
-        memory survives at every length — the monotonic collapse is the bug."""
-        for n_filler in (0, 20, 50, 100, 200, 400):
-            query = self._filler(n_filler) + " " + self.CORE_QUERY
-            kept, _ = recall._filter_by_overlap(
-                [_memory(self.MEMORY)], query, 0.10
-            )
-            self.assertEqual(
-                len(kept),
-                1,
-                f"relevant memory dropped at {n_filler} filler words "
-                f"({len(query)} query chars)",
-            )
-
-
-class OverlapGateIntegrationTests(unittest.TestCase):
-    """Switchroom #475: gate wired through main()."""
-
-    def test_default_off_passes_everything_through(self):
-        # No recallMinOverlap in config → behaves as before.
-        client = _FakeClient(
-            directives=[],
-            memories=[
-                _memory("deploy staging server"),
-                _memory("vegan dinner recipes"),
-            ],
-        )
-        ctx, _ = _run_main_with(client, prompt="how do we deploy staging?")
-        self.assertIsNotNone(ctx)
-        self.assertIn("deploy staging server", ctx)
-        self.assertIn("vegan dinner recipes", ctx)
-
-    def test_high_threshold_drops_irrelevant_memories(self):
-        client = _FakeClient(
-            directives=[],
-            memories=[
-                _memory("deploy staging server"),
-                _memory("vegan dinner recipes"),
-            ],
-        )
-        ctx, _ = _run_main_with(
-            client,
-            prompt="how do we deploy staging server",
-            config_extra={"recallMinOverlap": 0.5},
-        )
-        # Relevant survives, junk doesn't.
-        self.assertIsNotNone(ctx)
-        self.assertIn("deploy staging server", ctx)
-        self.assertNotIn("vegan", ctx)
-
-    def test_threshold_emits_no_block_when_all_dropped(self):
-        # All memories below threshold → no <hindsight_memories> block.
-        # Telemetry still records the dropped count.
-        client = _FakeClient(
-            directives=[],
-            memories=[
-                _memory("vegan dinner recipes"),
-                _memory("totally unrelated chatter"),
-            ],
-        )
-        ctx, _ = _run_main_with(
-            client,
-            prompt="how do we deploy staging server",
-            config_extra={"recallMinOverlap": 0.5},
-        )
-        # No memories survived; with no directives either, we expect no
-        # additionalContext at all.
-        self.assertIsNone(ctx)
-
-
 class RecallTagFilterIntegrationTests(unittest.TestCase):
     """Upstream 962140eef port — tag filters flow through main() to each
     per-bank recall call, composed with our additional-banks routing."""

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

@@ -0,0 +1,261 @@
+"""Switchroom — the lexical-overlap recall gate is gone, and stays gone.
+
+Between the engine's reranker and the ``recallMaxMemories`` head-slice, recall
+used to run a ``recallMinOverlap`` gate: any candidate whose containment
+overlap ``|Q n M| / |M|`` with the prompt fell under a threshold was discarded.
+It was removed outright (no replacement score floor) because measurement showed
+it was pure loss:
+
+  * On healthy production rows (non-timeout, non-error, ts >= 2026-07-20,
+    n=212 fleet-wide) it discarded 6026 of 7549 post-reranker candidates —
+    79.8% fleet-wide, 94.4% for overlord, 91.0% for klanker.
+  * Replaying 330 real logged queries against the live engine, it dropped the
+    engine's OWN top-ranked candidate on 31.2% of queries.
+  * It filtered no measurable noise: the rate at which the best injected
+    memory scored below 1e-3 was 27.0% with the gate and 28.2% with no gate.
+
+The root cause is the tokenizer: ``_overlap_tokens`` keeps only alphabetic
+tokens of length > 1, so digits, identifiers, version numbers, PR numbers and
+file paths are invisible to it. For a fleet that talks in identifiers that is
+close to worst case.
+
+So these tests assert OUTCOMES, not code paths. Each one fails if candidates
+are dropped for lexical reasons again — including via a stale
+``recallMinOverlap`` key left behind in an operator's settings.json, which is
+exactly how a removed knob comes back to life.
+
+Stdlib-only (unittest + mock); runs under ``python3 -m unittest discover
+tests/``. Harness mirrors ``test_recall_integration.py``.
+"""
+
+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
+
+BANK = "test-bank"
+
+# A production-shaped recall query: the memory-bearing sentence plus the long
+# unrelated prior-context preamble the UserPromptSubmit hook prepends. Query
+# length is what made the old gate collapse, so the fixtures keep it realistic.
+PREAMBLE = (
+    "Prior context: the operator asked about telegram card rendering, then "
+    "about vault broker grants, then about the nightly digest schedule and "
+    "the reaction dispatch wiring, and separately about docker image "
+    "promotion, canary holdback, worktree hygiene and changelog discipline. "
+)
+
+
+def _memory(text, score=0.5, mem_id=None):
+    return {
+        "text": text,
+        "type": "fact",
+        "mentioned_at": "2026-01-01",
+        "id": mem_id or text,
+        "scores": {"final": score},
+    }
+
+
+class _FakeClient:
+    def __init__(self, memories, directives=None):
+        self._memories = memories
+        self._directives = directives or []
+
+    def list_directives(self, bank_id, active_only=True, timeout=2):
+        return {"items": list(self._directives)}
+
+    def recall(self, bank_id, query, **kwargs):
+        return {"results": [dict(m) for m in self._memories]}
+
+
+def _run_main_with(client, prompt="what did we decide", config_extra=None):
+    hook_input = {
+        "prompt": prompt,
+        "session_id": "test-session",
+        "transcript_path": "",
+        "cwd": "/tmp",
+    }
+    config = {
+        "autoRecall": True,
+        "bankId": BANK,
+        "recallMaxTokens": 4096,
+        "recallBudget": "mid",
+        "recallContextTurns": 1,
+        "recallMaxQueryChars": 800,
+        "recallPromptPreamble": "",
+        "directivesCacheTtlSeconds": 0,
+    }
+    if config_extra:
+        config.update(config_extra)
+
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    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=stdout), patch("sys.stderr", new=stderr):
+        recall.main()
+
+    raw = stdout.getvalue()
+    if not raw.strip():
+        return None, raw
+    return json.loads(raw)["hookSpecificOutput"]["additionalContext"], raw
+
+
+class GateHelpersAreGoneTests(unittest.TestCase):
+    """The gate's machinery must not exist to be re-wired by accident."""
+
+    def test_gate_helpers_are_removed(self):
+        self.assertFalse(hasattr(recall, "containment_overlap"))
+        self.assertFalse(hasattr(recall, "_filter_by_overlap"))
+
+    def test_tokenizer_survives_for_the_transcript_fallback(self):
+        """`_overlap_tokens` is still load-bearing for
+        `_build_transcript_fallback`'s keyword match — deleting it with the
+        gate would silently break the #3369 fallback."""
+        self.assertEqual(
+            recall._overlap_tokens("Deploy the staging server!"),
+            {"deploy", "staging", "server"},
+        )
+
+
+class NoLexicalDroppingIntegrationTests(unittest.TestCase):
+    """Wired through main(): what the engine returns is what gets injected."""
+
+    def test_zero_word_overlap_memory_is_still_injected(self):
+        """The gate's headline behaviour, inverted. A memory sharing no
+        content word with the prompt was dropped outright; the reranker
+        ranked it, so it must now survive to the head-slice."""
+        client = _FakeClient(
+            [
+                _memory("deploy staging server", score=0.9),
+                _memory("vegan dinner recipes", score=0.8),
+            ]
+        )
+        ctx, _ = _run_main_with(client, prompt="how do we deploy staging server")
+        self.assertIsNotNone(ctx)
+        self.assertIn("deploy staging server", ctx)
+        self.assertIn("vegan dinner recipes", ctx)
+
+    def test_identifier_only_match_survives(self):
+        """The measured root cause: `_overlap_tokens` drops digits and
+        1-char tokens, so a memory whose ONLY relationship to the prompt is
+        an identifier scored 0.0 and was always discarded. Assert directly
+        that the tokenizer still cannot see the identifier, AND that the
+        memory is injected anyway."""
+        query = PREAMBLE + "did PR #3541 land, and what did v0.19.24 change"
+        mem = "#3541 shipped in 0.19.24"
+        self.assertEqual(
+            recall._overlap_tokens(query) & recall._overlap_tokens(mem),
+            set(),
+            "fixture drifted: it must share no ALPHABETIC token with the query",
+        )
+        ctx, _ = _run_main_with(_FakeClient([_memory(mem, score=0.95)]), prompt=query)
+        self.assertIsNotNone(ctx)
+        self.assertIn(mem, ctx)
+
+    def test_long_prompt_does_not_starve_recall(self):
+        """#3541's failure shape: survival collapsed as the prompt grew, to
+        93% zero-result past 600 query chars. Length must now be inert."""
+        for repeat in (1, 4, 8):
+            query = PREAMBLE * repeat + "where did the connection pool sizing land"
+            with self.subTest(query_chars=len(query)):
+                ctx, _ = _run_main_with(
+                    _FakeClient([_memory(f"m-{i}", score=0.9 - i * 0.01) for i in range(6)]),
+                    prompt=query,
+                )
+                self.assertIsNotNone(ctx)
+                for i in range(6):
+                    self.assertIn(f"m-{i}", ctx)
+
+    def test_stale_min_overlap_key_is_inert(self):
+        """A removed knob comes back to life through leftover config. An
+        operator settings.json still carrying `recallMinOverlap: 0.5` must
+        drop nothing — under the old code this emptied the block entirely."""
+        client = _FakeClient(
+            [
+                _memory("vegan dinner recipes", score=0.9),
+                _memory("totally unrelated chatter", score=0.8),
+            ]
+        )
+        ctx, _ = _run_main_with(
+            client,
+            prompt="how do we deploy staging server",
+            config_extra={"recallMinOverlap": 0.5},
+        )
+        self.assertIsNotNone(ctx)
+        self.assertIn("vegan dinner recipes", ctx)
+        self.assertIn("totally unrelated chatter", ctx)
+
+    def test_relevance_order_and_cap_still_apply(self):
+        """Removing the gate must not remove the controls that replaced it:
+        the engine's `scores.final` sort plus the head-slice ARE the
+        precision mechanism now."""
+        mems = [_memory(f"m-{i}", score=i / 10.0) for i in range(10)]
+        ctx, _ = _run_main_with(
+            _FakeClient(mems),
+            config_extra={"recallMaxMemories": 3},
+        )
+        self.assertIsNotNone(ctx)
+        for keep in ("m-9", "m-8", "m-7"):
+            self.assertIn(keep, ctx)
+        for drop in ("m-0", "m-1", "m-2"):
+            self.assertNotIn(drop, ctx)
+
+
+class RecallLogSchemaTests(unittest.TestCase):
+    """`overlap_dropped` measured a filter that no longer exists; a
+    permanently-zero field reads as "the gate is fine" on every dashboard."""
+
+    def setUp(self):
+        self._tmpdir = tempfile.mkdtemp(prefix="recall-nogate-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 test_log_row_drops_the_overlap_dropped_field(self):
+        _run_main_with(_FakeClient([_memory("a fact", score=0.9)]))
+        path = os.path.join(self._tmpdir, "state", "recall_log.jsonl")
+        self.assertTrue(os.path.isfile(path), "no recall_log.jsonl written")
+        with open(path, encoding="utf-8") as f:
+            rows = [json.loads(line) for line in f if line.strip()]
+        self.assertTrue(rows)
+        for row in rows:
+            self.assertNotIn("overlap_dropped", row)
+            # The quality fields that now carry the load must still be there.
+            self.assertIn("injected_score_median", row)
+            self.assertIn("pre_cap_count", row)
+
+    def test_every_candidate_reaches_the_cap_stage(self):
+        """Volume proof: nothing is lost between the engine response and the
+        head-slice. `pre_cap_count` == what the bank returned."""
+        mems = [_memory(f"m-{i}", score=0.9 - i * 0.01) for i in range(12)]
+        _run_main_with(_FakeClient(mems), config_extra={"recallMaxMemories": 4})
+        path = os.path.join(self._tmpdir, "state", "recall_log.jsonl")
+        with open(path, encoding="utf-8") as f:
+            rows = [json.loads(line) for line in f if line.strip()]
+        self.assertEqual(rows[-1]["pre_cap_count"], 12)
+        self.assertEqual(rows[-1]["result_count"], 4)
+
+
+if __name__ == "__main__":
+    unittest.main()