switchroom 0.19.2 → 0.19.3

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

@@ -25,6 +25,7 @@ Stdlib-only.
 import os
 import sys
 import unittest
+import unittest.mock
 
 SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 if SCRIPTS_DIR not in sys.path:
@@ -32,11 +33,14 @@ if SCRIPTS_DIR not in sys.path:
 
 from directive_verify import (  # noqa: E402
     _VERIFY_BLOCK_REASON,
+    _is_directive_write_tool,
     directive_recorded_after,
     evaluate,
     find_last_human_turn,
+    invalidate_cache_on_directive_write,
     is_synthetic_inbound,
     looks_like_durable_directive,
+    turn_contains_directive_write,
 )
 from recall import looks_like_standing_rule  # noqa: E402
 
@@ -512,5 +516,170 @@ class TestBlockReason(unittest.TestCase):
         self.assertIn("<directive_capture_verify>", _VERIFY_BLOCK_REASON)
 
 
+class TestDirectiveWriteDetection(unittest.TestCase):
+    """A4 — the Stop-hook detector that decides whether the just-ended turn
+    wrote a directive (and should therefore invalidate the recall cache)."""
+
+    def test_write_tool_names_recognised(self):
+        for name in (
+            "create_directive",
+            "update_directive",
+            "delete_directive",
+            "mcp__hindsight__create_directive",
+            "mcp__hindsight__update_directive",
+        ):
+            self.assertTrue(_is_directive_write_tool(name), name)
+
+    def test_read_and_unrelated_tools_ignored(self):
+        for name in ("list_directives", "recall", "retain", "reflect", "", None):
+            self.assertFalse(_is_directive_write_tool(name), name)
+
+    def _assistant_tool_use(self, tool_name):
+        return {
+            "role": "assistant",
+            "content": [{"type": "tool_use", "id": "t1", "name": tool_name, "input": {}}],
+        }
+
+    def test_turn_with_create_directive_detected(self):
+        messages = [
+            {"role": "user", "content": "From now on call me Ken."},
+            self._assistant_tool_use("mcp__hindsight__create_directive"),
+        ]
+        self.assertTrue(turn_contains_directive_write(messages, 0))
+
+    def test_turn_without_write_not_detected(self):
+        messages = [
+            {"role": "user", "content": "What did we decide?"},
+            self._assistant_tool_use("mcp__hindsight__list_directives"),
+        ]
+        self.assertFalse(turn_contains_directive_write(messages, 0))
+
+    def test_write_before_start_index_ignored(self):
+        # A directive write in a PRIOR turn (before the current human turn) does
+        # not count — only writes after start_index are this turn's.
+        messages = [
+            self._assistant_tool_use("create_directive"),  # prior turn
+            {"role": "user", "content": "Now do something else."},
+            {"role": "assistant", "content": "Sure."},
+        ]
+        self.assertFalse(turn_contains_directive_write(messages, 1))
+
+
+class TestCacheInvalidationHook(unittest.TestCase):
+    """A4 — invalidate_cache_on_directive_write end-to-end: a real transcript
+    containing a directive write deletes a seeded cache file."""
+
+    def setUp(self):
+        import tempfile
+
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self._patch = unittest.mock.patch.dict(
+            os.environ, {"CLAUDE_PLUGIN_DATA": self._tmp.name}
+        )
+        self._patch.start()
+        self.addCleanup(self._patch.stop)
+
+    def _seed_cache(self, bank_id="bank1"):
+        from lib.directives import _cache_name
+        from lib.state import read_state, write_state
+
+        write_state(_cache_name(bank_id), {"ts": 1000.0, "bank_id": bank_id, "directives": []})
+        self.assertIsNotNone(read_state(_cache_name(bank_id), None))
+
+    def _cache_present(self, bank_id="bank1"):
+        from lib.directives import _cache_name
+        from lib.state import read_state
+
+        return read_state(_cache_name(bank_id), None) is not None
+
+    def test_directive_write_invalidates_cache(self):
+        self._seed_cache()
+        messages = [
+            {"role": "user", "content": "From now on call me Ken."},
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "tool_use", "id": "t1", "name": "create_directive", "input": {}}
+                ],
+            },
+        ]
+        invalidate_cache_on_directive_write(messages, {})
+        self.assertFalse(self._cache_present())
+
+    def test_no_write_leaves_cache_intact(self):
+        self._seed_cache()
+        messages = [
+            {"role": "user", "content": "What's the weather?"},
+            {"role": "assistant", "content": "Sunny."},
+        ]
+        invalidate_cache_on_directive_write(messages, {})
+        self.assertTrue(self._cache_present())
+
+    def test_empty_messages_is_noop(self):
+        self._seed_cache()
+        invalidate_cache_on_directive_write([], {})
+        self.assertTrue(self._cache_present())
+
+
+class TestMainSingleTranscriptRead(unittest.TestCase):
+    """A4 finding 2 — main() must parse the transcript AT MOST ONCE (shared by
+    cache-invalidation + capture-verify), and not at all when nothing needs it.
+    A Stop hook on a multi-MB session cannot afford a doubled multi-second
+    parse inside its 10s budget."""
+
+    def _run_main_counting_reads(self, config, stop_hook_active=False):
+        import io
+        import json
+
+        import directive_verify as dv
+
+        calls = {"n": 0}
+
+        def _counting_read(_path):
+            calls["n"] += 1
+            return []
+
+        hook_input = {"transcript_path": "/some/transcript", "stop_hook_active": stop_hook_active}
+        with unittest.mock.patch.object(dv, "read_transcript", side_effect=_counting_read), \
+             unittest.mock.patch.object(dv, "load_config", return_value=config), \
+             unittest.mock.patch("sys.stdin", new=io.StringIO(json.dumps(hook_input))), \
+             unittest.mock.patch("sys.stdout", new=io.StringIO()):
+            dv.main()
+        return calls["n"]
+
+    def test_reads_once_when_cache_and_verify_on(self):
+        n = self._run_main_counting_reads({
+            "directivesCacheTtlSeconds": 120,
+            "directiveCaptureNudge": True,
+            "directiveCaptureVerify": True,
+        })
+        self.assertEqual(n, 1)
+
+    def test_reads_once_when_only_cache_on(self):
+        n = self._run_main_counting_reads({
+            "directivesCacheTtlSeconds": 120,
+            "directiveCaptureNudge": False,
+            "directiveCaptureVerify": False,
+        })
+        self.assertEqual(n, 1)
+
+    def test_reads_once_when_only_verify_on(self):
+        n = self._run_main_counting_reads({
+            "directivesCacheTtlSeconds": 0,
+            "directiveCaptureNudge": True,
+            "directiveCaptureVerify": True,
+        })
+        self.assertEqual(n, 1)
+
+    def test_reads_zero_when_all_disabled(self):
+        n = self._run_main_counting_reads({
+            "directivesCacheTtlSeconds": 0,
+            "directiveCaptureNudge": False,
+            "directiveCaptureVerify": False,
+        })
+        self.assertEqual(n, 0)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -10,6 +10,7 @@ Run from the repo root:
 
 import os
 import sys
+import tempfile
 import unittest
 from io import StringIO
 from unittest.mock import patch
@@ -20,12 +21,17 @@ if SCRIPTS_DIR not in sys.path:
     sys.path.insert(0, SCRIPTS_DIR)
 
 from lib.directives import (  # noqa: E402
+    DIRECTIVES_CACHE_TTL_SECONDS,
     MAX_DIRECTIVES,
+    _cache_name,
     fetch_active_directives,
+    fetch_active_directives_cached,
     format_active_directives_block,
+    invalidate_directives_cache,
     parse_active_directives_block,
     rule_already_captured,
 )
+from lib.state import read_state, write_state  # noqa: E402
 
 
 class _StubClient:
@@ -294,5 +300,176 @@ class TestDirectiveDedup(unittest.TestCase):
         )
 
 
+class _CountingClient:
+    """List-directives stub that can vary its behaviour per call.
+
+    ``responses`` / ``excs`` are per-call sequences (last value repeats). Counts
+    total calls so a test can assert cache hits saved the HTTP round-trip.
+    """
+
+    def __init__(self, response=None, exc=None):
+        self._response = response
+        self._exc = exc
+        self.calls = 0
+
+    def list_directives(self, bank_id, active_only=True, timeout=2):
+        self.calls += 1
+        if self._exc is not None:
+            raise self._exc
+        return self._response
+
+
+class DirectivesCacheTests(unittest.TestCase):
+    """A4 — directives-list cache: hit/miss, TTL expiry, invalidation on write,
+    corrupted-cache fallback. State is isolated to a temp CLAUDE_PLUGIN_DATA."""
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self._env = patch.dict(os.environ, {"CLAUDE_PLUGIN_DATA": self._tmp.name})
+        self._env.start()
+
+    def tearDown(self):
+        self._env.stop()
+        self._tmp.cleanup()
+
+    def _resp(self, *names):
+        return {"items": [_directive(n, f"content {n}", priority=5) for n in names]}
+
+    def test_cache_hit_skips_second_http_call(self):
+        # Acceptance (a): two consecutive recalls with no write → exactly one
+        # list_directives call; both return the same content.
+        client = _CountingClient(response=self._resp("alpha"))
+        first = fetch_active_directives_cached(client, "bank1", now=1000.0)
+        second = fetch_active_directives_cached(client, "bank1", now=1000.5)
+        self.assertEqual(client.calls, 1)
+        self.assertEqual([d["name"] for d in first], ["alpha"])
+        self.assertEqual([d["name"] for d in second], ["alpha"])
+
+    def test_cache_miss_when_no_prior_entry(self):
+        client = _CountingClient(response=self._resp("alpha"))
+        result = fetch_active_directives_cached(client, "bank1", now=1000.0)
+        self.assertEqual(client.calls, 1)
+        self.assertEqual([d["name"] for d in result], ["alpha"])
+        # Cache file was written.
+        cached = read_state(_cache_name("bank1"), None)
+        self.assertIsInstance(cached, dict)
+        self.assertEqual(cached["ts"], 1000.0)
+
+    def test_ttl_expiry_refetches(self):
+        client = _CountingClient(response=self._resp("alpha"))
+        fetch_active_directives_cached(client, "bank1", ttl_seconds=120, now=1000.0)
+        # Just inside TTL → hit.
+        fetch_active_directives_cached(client, "bank1", ttl_seconds=120, now=1000.0 + 119)
+        self.assertEqual(client.calls, 1)
+        # Just past TTL → miss → refetch.
+        fetch_active_directives_cached(client, "bank1", ttl_seconds=120, now=1000.0 + 121)
+        self.assertEqual(client.calls, 2)
+
+    def test_ttl_zero_disables_cache(self):
+        # Rollback lever: TTL=0 → live fetch every time, nothing written.
+        client = _CountingClient(response=self._resp("alpha"))
+        fetch_active_directives_cached(client, "bank1", ttl_seconds=0, now=1000.0)
+        fetch_active_directives_cached(client, "bank1", ttl_seconds=0, now=1000.1)
+        self.assertEqual(client.calls, 2)
+        self.assertIsNone(read_state(_cache_name("bank1"), None))
+
+    def test_invalidation_forces_refetch(self):
+        # Acceptance (a) in-session: a directive write invalidates the cache, so
+        # the next recall re-fetches (fresh directive becomes visible).
+        client = _CountingClient(response=self._resp("alpha"))
+        fetch_active_directives_cached(client, "bank1", now=1000.0)
+        self.assertEqual(client.calls, 1)
+        invalidate_directives_cache()  # bank-agnostic sweep (Stop-hook path)
+        fetch_active_directives_cached(client, "bank1", now=1000.1)
+        self.assertEqual(client.calls, 2)
+
+    def test_invalidation_specific_bank_only(self):
+        client = _CountingClient(response=self._resp("alpha"))
+        fetch_active_directives_cached(client, "bankA", now=1000.0)
+        fetch_active_directives_cached(client, "bankB", now=1000.0)
+        self.assertEqual(client.calls, 2)
+        invalidate_directives_cache("bankA")
+        # bankA re-fetches, bankB still served from cache.
+        fetch_active_directives_cached(client, "bankA", now=1000.1)
+        self.assertEqual(client.calls, 3)
+        fetch_active_directives_cached(client, "bankB", now=1000.1)
+        self.assertEqual(client.calls, 3)
+
+    def test_corrupted_cache_falls_back_to_live(self):
+        # A non-JSON cache file → read_state returns default → live fetch.
+        from lib.state import _state_file  # noqa: PLC0415
+
+        path = _state_file(_cache_name("bank1"))
+        with open(path, "w") as f:
+            f.write("{ this is not valid json ]")
+        client = _CountingClient(response=self._resp("alpha"))
+        result = fetch_active_directives_cached(client, "bank1", now=1000.0)
+        self.assertEqual(client.calls, 1)
+        self.assertEqual([d["name"] for d in result], ["alpha"])
+
+    def test_wrong_shape_cache_falls_back_to_live(self):
+        # Valid JSON but missing the ts/directives envelope → treated as a miss.
+        write_state(_cache_name("bank1"), {"directives": [{"name": "stale"}]})
+        client = _CountingClient(response=self._resp("fresh"))
+        result = fetch_active_directives_cached(client, "bank1", now=1000.0)
+        self.assertEqual(client.calls, 1)
+        self.assertEqual([d["name"] for d in result], ["fresh"])
+
+    def test_bool_timestamp_rejected_as_corrupt(self):
+        # bool is an int subclass — guard must not accept True as a timestamp.
+        write_state(_cache_name("bank1"), {"ts": True, "directives": []})
+        client = _CountingClient(response=self._resp("fresh"))
+        fetch_active_directives_cached(client, "bank1", now=1000.0)
+        self.assertEqual(client.calls, 1)
+
+    def test_failed_fetch_not_cached(self):
+        # A transient fetch FAILURE must not poison the cache with [] — the next
+        # call must retry live rather than serving a cached empty list.
+        failing = _CountingClient(exc=RuntimeError("HTTP 503"))
+        with patch("sys.stderr", new=StringIO()):
+            first = fetch_active_directives_cached(failing, "bank1", now=1000.0)
+        self.assertEqual(first, [])
+        self.assertIsNone(read_state(_cache_name("bank1"), None))
+        # A subsequent successful fetch is served live and then cached.
+        ok = _CountingClient(response=self._resp("alpha"))
+        result = fetch_active_directives_cached(ok, "bank1", now=1000.1)
+        self.assertEqual(ok.calls, 1)
+        self.assertEqual([d["name"] for d in result], ["alpha"])
+
+    def test_empty_bank_is_cached(self):
+        # A genuinely empty bank (items: []) is a successful fetch → cacheable,
+        # so a directive-free agent also saves the round-trip.
+        client = _CountingClient(response={"items": []})
+        fetch_active_directives_cached(client, "bank1", now=1000.0)
+        fetch_active_directives_cached(client, "bank1", now=1000.1)
+        self.assertEqual(client.calls, 1)
+
+    def test_bank_id_mismatch_falls_back_to_live(self):
+        # _safe_filename can collapse two bank ids onto one cache file; an
+        # envelope whose embedded bank_id != the requested one must be rejected
+        # (a live fetch) rather than serving another bank's directives.
+        write_state(
+            _cache_name("bank1"),
+            {"ts": 1000.0, "bank_id": "a-DIFFERENT-bank", "directives": [{"name": "leaked"}]},
+        )
+        client = _CountingClient(response=self._resp("mine"))
+        result = fetch_active_directives_cached(client, "bank1", now=1000.0)
+        self.assertEqual(client.calls, 1)
+        self.assertEqual([d["name"] for d in result], ["mine"])
+
+    def test_future_timestamp_treated_as_expired(self):
+        # A stored ts in the future (wall-clock step-back) → negative age → NOT
+        # served as fresh; the cache re-fetches instead of pinning stale.
+        client = _CountingClient(response=self._resp("alpha"))
+        fetch_active_directives_cached(client, "bank1", ttl_seconds=120, now=5000.0)
+        self.assertEqual(client.calls, 1)
+        # Clock steps back well before the cached ts → age is negative.
+        fetch_active_directives_cached(client, "bank1", ttl_seconds=120, now=1000.0)
+        self.assertEqual(client.calls, 2)
+
+    def test_default_ttl_constant(self):
+        self.assertEqual(DIRECTIVES_CACHE_TTL_SECONDS, 120)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -0,0 +1,200 @@
+"""Switchroom hindsight-leverage E2 / PR9 (#398) — lesson/anti-pattern tagging
+at retain time + recall-side demotion via the PR5 score-penalty weight map.
+
+Two halves, both asserted on OUTCOMES:
+
+  * retain: ``detect_lesson_tags`` tags the intended transcript shapes (explicit
+    lesson / anti-pattern markers), stays silent on ordinary transcripts, and is
+    fully togglable via config; ``build_retain_payload`` merges the tags onto the
+    retain without clobbering configured ``retainTags``.
+  * recall: ``_effective_tag_weights`` composes the built-in lesson/anti-pattern
+    demotion weights under ``recallTagWeights`` so that, after
+    ``_apply_tag_weights`` + ``_sort_by_final_score``, a lesson-tagged memory
+    ranks BELOW an equal-score untagged one yet is NEVER hard-dropped — and the
+    operator override / rollback levers work.
+
+Stdlib-only; runs under ``python3 -m unittest discover tests/``.
+"""
+
+import os
+import sys
+import unittest
+
+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)
+
+from lib.config import DEFAULTS  # noqa: E402
+from retain import build_retain_payload, detect_lesson_tags  # noqa: E402
+from recall import (  # noqa: E402
+    _apply_tag_weights,
+    _effective_tag_weights,
+    _sort_by_final_score,
+)
+
+
+def _cfg(**over):
+    """A config dict seeded with the real lesson defaults, plus overrides."""
+    c = {
+        "lessonTagging": DEFAULTS["lessonTagging"],
+        "lessonTagMarkers": DEFAULTS["lessonTagMarkers"],
+        "lessonDemotion": DEFAULTS["lessonDemotion"],
+        "lessonDemotionWeights": DEFAULTS["lessonDemotionWeights"],
+        "recallTagWeights": {},
+    }
+    c.update(over)
+    return c
+
+
+def _mem(text, final, tags=None):
+    return {"text": text, "tags": tags or [], "scores": {"final": final}}
+
+
+class DetectLessonTags(unittest.TestCase):
+    def test_lesson_marker_tags_lesson(self):
+        t = "The lesson learned here is to always dispatch before narrating."
+        self.assertEqual(detect_lesson_tags(t, _cfg()), ["lesson"])
+
+    def test_note_to_self_tags_lesson(self):
+        t = "Note to self: run the scoped suite before pushing next time."
+        self.assertEqual(detect_lesson_tags(t, _cfg()), ["lesson"])
+
+    def test_anti_pattern_marker_tags_anti_pattern(self):
+        t = "anti-pattern: announcing a dispatch without invoking the Agent tool."
+        self.assertEqual(detect_lesson_tags(t, _cfg()), ["anti-pattern"])
+
+    def test_what_not_to_do_tags_anti_pattern(self):
+        t = "Here is what not to do: reply 'dispatching' and never dispatch."
+        self.assertEqual(detect_lesson_tags(t, _cfg()), ["anti-pattern"])
+
+    def test_both_markers_yield_both_tags_sorted(self):
+        t = "Lesson learned from this anti-pattern: verify before asserting."
+        self.assertEqual(detect_lesson_tags(t, _cfg()), ["anti-pattern", "lesson"])
+
+    def test_case_insensitive(self):
+        t = "LESSON LEARNED: read the ground truth."
+        self.assertEqual(detect_lesson_tags(t, _cfg()), ["lesson"])
+
+    def test_ordinary_transcript_untagged(self):
+        t = "User asked to refactor the auth module. Assistant edited login.ts."
+        self.assertEqual(detect_lesson_tags(t, _cfg()), [])
+
+    def test_bare_word_lesson_does_not_overtag(self):
+        # A passing mention of "lesson" without an explicit marker must NOT tag.
+        t = "The history lesson from yesterday's chat was interesting."
+        self.assertEqual(detect_lesson_tags(t, _cfg()), [])
+
+    def test_disabled_is_noop(self):
+        t = "lesson learned: always branch off fresh main."
+        self.assertEqual(detect_lesson_tags(t, _cfg(lessonTagging=False)), [])
+
+    def test_empty_or_bad_inputs(self):
+        self.assertEqual(detect_lesson_tags("", _cfg()), [])
+        self.assertEqual(detect_lesson_tags(None, _cfg()), [])
+        self.assertEqual(detect_lesson_tags("lesson learned", _cfg(lessonTagMarkers={})), [])
+
+    def test_custom_markers_override(self):
+        cfg = _cfg(lessonTagMarkers={"gotcha": ["heads up:"]})
+        self.assertEqual(detect_lesson_tags("Heads up: the port shifts.", cfg), ["gotcha"])
+
+
+class BuildRetainPayloadTagMerge(unittest.TestCase):
+    def _payload_tags(self, transcript_text, **cfg_over):
+        cfg = _cfg(
+            retainRoles=["user", "assistant"],
+            retainToolCalls=True,
+            retainContext="claude-code",
+            retainMetadata={},
+            retainTags=["{session_id}"],
+            **cfg_over,
+        )
+        msgs = [
+            {"role": "user", "content": "how do I dispatch?", "uuid": "u1"},
+            {"role": "assistant", "content": transcript_text, "uuid": "a1"},
+        ]
+        built = build_retain_payload(
+            cfg,
+            "sess-123",
+            msgs,
+            msgs,
+            bank_id="bank",
+            api_url="http://x",
+            api_token=None,
+        )
+        self.assertIsNotNone(built)
+        return built["payload"]["tags"]
+
+    def test_lesson_tag_appended_alongside_configured_tags(self):
+        tags = self._payload_tags("anti-pattern: narrate without executing")
+        self.assertIn("sess-123", tags)          # configured retainTag survives
+        self.assertIn("anti-pattern", tags)      # detected tag added
+
+    def test_no_lesson_tag_on_ordinary_transcript(self):
+        tags = self._payload_tags("Edited the login handler and ran tests.")
+        self.assertEqual(tags, ["sess-123"])
+
+    def test_tagging_disabled_leaves_only_configured(self):
+        tags = self._payload_tags("lesson learned: pull before branching",
+                                   lessonTagging=False)
+        self.assertEqual(tags, ["sess-123"])
+
+
+class EffectiveTagWeights(unittest.TestCase):
+    def test_builtins_present_by_default(self):
+        w = _effective_tag_weights(_cfg())
+        self.assertEqual(w["lesson"], 0.85)
+        self.assertEqual(w["anti-pattern"], 0.5)
+
+    def test_recall_tag_weights_compose_and_override(self):
+        # sidechain seed composes; an explicit lesson override wins over builtin.
+        w = _effective_tag_weights(
+            _cfg(recallTagWeights={"sidechain": 0.8, "lesson": 0.95})
+        )
+        self.assertEqual(w["sidechain"], 0.8)
+        self.assertEqual(w["lesson"], 0.95)          # operator override wins
+        self.assertEqual(w["anti-pattern"], 0.5)     # builtin retained
+
+    def test_rollback_drops_builtins(self):
+        w = _effective_tag_weights(
+            _cfg(lessonDemotion=False, recallTagWeights={"sidechain": 0.8})
+        )
+        self.assertEqual(w, {"sidechain": 0.8})
+        self.assertNotIn("lesson", w)
+
+
+class RecallDemotionOutcome(unittest.TestCase):
+    """End-to-end recall outcome: tag → weight → sort."""
+
+    def test_lesson_ranks_below_equal_score_untagged(self):
+        neutral = _mem("clean session fact", 0.50, [])
+        lesson = _mem("lesson transcript", 0.50, ["lesson"])
+        results = [lesson, neutral]  # lesson first pre-weight
+        w = _effective_tag_weights(_cfg())
+        _apply_tag_weights(results, w)
+        _sort_by_final_score(results)
+        self.assertEqual(results[0]["text"], "clean session fact")
+        self.assertEqual(results[1]["text"], "lesson transcript")
+
+    def test_anti_pattern_never_dropped_when_only_hit(self):
+        only = _mem("the only relevant fact", 0.42, ["anti-pattern"])
+        results = [only]
+        w = _effective_tag_weights(_cfg())
+        _apply_tag_weights(results, w)
+        _sort_by_final_score(results)
+        self.assertEqual(len(results), 1)  # re-rank, never a hard drop
+        self.assertAlmostEqual(results[0]["scores"]["final"], 0.42 * 0.5)
+
+    def test_operator_override_changes_ordering(self):
+        # With lesson override to 1.0 (no penalty), the lesson memory keeps parity.
+        a = _mem("neutral", 0.50, [])
+        b = _mem("lesson", 0.50, ["lesson"])
+        results = [b, a]
+        w = _effective_tag_weights(_cfg(recallTagWeights={"lesson": 1.0}))
+        _apply_tag_weights(results, w)
+        _sort_by_final_score(results)
+        # Stable sort keeps pre-sort order on the tie → lesson stays first.
+        self.assertEqual(results[0]["text"], "lesson")
+
+
+if __name__ == "__main__":
+    unittest.main()