switchroom 0.19.2 → 0.19.4

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

@@ -58,8 +58,12 @@ class _FakeClient:
         # One entry per recall() call — lets tests assert the tag-filter
         # kwargs (upstream 962140eef) that main() passed per bank.
         self.recall_calls = []
+        # Count list_directives calls so a test can prove the A4 cache saved a
+        # round-trip across two recall.main() runs (and did NOT when TTL=0).
+        self.list_directives_calls = 0
 
     def list_directives(self, bank_id, active_only=True, timeout=2):
+        self.list_directives_calls += 1
         if self._list_exc is not None:
             raise self._list_exc
         return {"items": list(self._directives)}
@@ -114,6 +118,12 @@ def _run_main_with(client, prompt="What is the meaning of life?", config_extra=N
         "recallContextTurns": 1,
         "recallMaxQueryChars": 800,
         "recallPromptPreamble": "",
+        # Disable the A4 directives cache for these integration tests: they all
+        # share bank "test-bank" under a real wall clock, so a live cache would
+        # leak one test's directive set into the next within the TTL window.
+        # Cache hit/miss/TTL/invalidation behaviour is covered hermetically in
+        # test_directives.py (isolated CLAUDE_PLUGIN_DATA + injected clock).
+        "directivesCacheTtlSeconds": 0,
     }
     if config_extra:
         config.update(config_extra)
@@ -702,5 +712,46 @@ class RecallTagFilterIntegrationTests(unittest.TestCase):
         self.assertEqual(extra["tags_match"], None)
 
 
+class DirectivesCacheIntegrationTests(unittest.TestCase):
+    """A4 finding 4 — recall.main() honours the directivesCacheTtlSeconds knob
+    end-to-end. Isolated CLAUDE_PLUGIN_DATA so the cache file lands in a temp
+    state dir and does not leak into (or out of) other tests."""
+
+    def setUp(self):
+        import tempfile
+
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self._env = patch.dict(os.environ, {"CLAUDE_PLUGIN_DATA": self._tmp.name})
+        self._env.start()
+        self.addCleanup(self._env.stop)
+
+    def test_ttl_cache_saves_second_list_directives_call(self):
+        # Two consecutive recalls (same bank, no directive write between) with a
+        # live TTL → exactly one list_directives round-trip; the second serves
+        # from cache.
+        client = _FakeClient(
+            directives=[_directive("trailer", "End every response with: [VERIFIED]", priority=10)],
+            memories=[],
+        )
+        ctx1, _ = _run_main_with(client, config_extra={"directivesCacheTtlSeconds": 60})
+        ctx2, _ = _run_main_with(client, config_extra={"directivesCacheTtlSeconds": 60})
+        self.assertEqual(client.list_directives_calls, 1)
+        # Both turns still emit the directives block (the cache serves the same
+        # content on the hit).
+        self.assertIn("<active_directives>", ctx1)
+        self.assertIn("<active_directives>", ctx2)
+
+    def test_ttl_zero_refetches_each_run(self):
+        # TTL=0 disables the cache → every recall fetches live.
+        client = _FakeClient(
+            directives=[_directive("trailer", "End every response with: [VERIFIED]", priority=10)],
+            memories=[],
+        )
+        _run_main_with(client, config_extra={"directivesCacheTtlSeconds": 0})
+        _run_main_with(client, config_extra={"directivesCacheTtlSeconds": 0})
+        self.assertEqual(client.list_directives_calls, 2)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -0,0 +1,409 @@
+"""Switchroom hindsight-leverage PR 3 (workstream A3 stage 2) — parallel
+multi-bank recall under one shared deadline.
+
+Acceptance guarantees (epic #3430 exit-criterion 1 fallback: stub-timing
+acceptance tests that prove a slow bank cannot breach the hook ceiling):
+
+  1. **A slow bank cannot breach the ceiling.** With a bank stubbed to sleep far
+     past the shared deadline, `recall.main()` returns in ~deadline (NOT
+     ~sleep), the fast banks' memories still arrive, and the straggler is
+     recorded `timed_out=True` / `deadline_hit=True` — the finalized deadline
+     semantics (a deadline-abandoned straggler counts, even though it never
+     raised a timeout error, which the PR-1 interim per-bank-only form could
+     not express).
+
+  2. **Latency is the slowest slot, not the sum.** Three banks each sleeping S
+     complete in ~S wall-clock, not ~3S — the whole point of the fan-out.
+
+  3. **The directives slot is dedicated + composes with the A4 cache.** A slow
+     directives fetch is abandoned at the deadline (empty directives, no crash)
+     while bank memories still inject; a fast directives fetch runs concurrently
+     with the banks.
+
+  4. **Env-gated rollback.** `HINDSIGHT_RECALL_PARALLEL=false` (or
+     `recallParallel: False`) restores the serial path — `recall_mode="serial"`,
+     `deadline_budget_ms=None`, results still merged.
+
+  5. **The `run_parallel` primitive** classifies completed vs deadline-abandoned
+     slots correctly and bounds total wait by the shared deadline with daemon
+     threads.
+
+Stdlib-only (unittest + threading); runs under
+``python3 -m unittest discover tests/`` from ``scripts/``.
+"""
+
+import io
+import json
+import os
+import shutil
+import socket
+import sys
+import tempfile
+import threading
+import time
+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.parallel_recall import run_parallel  # noqa: E402
+
+BARE = "what did we decide about the auth flow last week"
+
+
+def _memory(text, mem_id=None):
+    out = {"text": text, "type": "fact", "mentioned_at": "2026-01-01"}
+    if mem_id is not None:
+        out["id"] = mem_id
+    return out
+
+
+class _SleepyClient:
+    """Fake HindsightClient with per-bank sleep + result control.
+
+    ``bank_sleep``  : {bank_id: seconds} — how long recall() blocks for a bank.
+    ``bank_results``: {bank_id: [memory, ...]} — what recall() returns.
+    ``directives_sleep`` / ``directives`` — for the directives slot.
+    Sleeps are real (threading), so wall-clock timing assertions exercise the
+    genuine daemon-thread fan-out rather than a mocked clock.
+    """
+
+    def __init__(self, bank_sleep=None, bank_results=None, directives=None,
+                 directives_sleep=0.0):
+        self._bank_sleep = bank_sleep or {}
+        self._bank_results = bank_results or {}
+        self._directives = directives or []
+        self._directives_sleep = directives_sleep
+        self._lock = threading.Lock()
+        self.recall_calls = []  # bank_ids, in call order (thread-safe append)
+
+    def list_directives(self, bank_id, active_only=True, timeout=2):
+        if self._directives_sleep:
+            time.sleep(self._directives_sleep)
+        return {"items": list(self._directives)}
+
+    def recall(self, bank_id, query, **kwargs):
+        with self._lock:
+            self.recall_calls.append(bank_id)
+        sleep_s = self._bank_sleep.get(bank_id, 0.0)
+        if sleep_s:
+            time.sleep(sleep_s)
+        return {"results": list(self._bank_results.get(bank_id, []))}
+
+
+class _RaisingClient(_SleepyClient):
+    """A client whose named bank raises a supplied exception."""
+
+    def __init__(self, raise_for=None, **kw):
+        super().__init__(**kw)
+        self._raise_for = raise_for or {}
+
+    def recall(self, bank_id, query, **kwargs):
+        with self._lock:
+            self.recall_calls.append(bank_id)
+        exc = self._raise_for.get(bank_id)
+        if exc is not None:
+            raise exc
+        return super().recall(bank_id, query, **kwargs)
+
+
+class _MainHarness(unittest.TestCase):
+    """Runs recall.main() with a fake client and an isolated recall log."""
+
+    def setUp(self):
+        self._tmpdir = tempfile.mkdtemp(prefix="recall-parallel-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 _read_log(self):
+        path = os.path.join(self._tmpdir, "state", "recall_log.jsonl")
+        if not os.path.isfile(path):
+            return []
+        with open(path, encoding="utf-8") as f:
+            return [json.loads(line) for line in f if line.strip()]
+
+    def _run(self, client, config_extra=None, prompt=BARE):
+        hook_input = {
+            "prompt": prompt,
+            "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)
+        stdout = io.StringIO()
+        stderr = io.StringIO()
+        started = time.monotonic()
+        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()
+        elapsed = time.monotonic() - started
+        raw = stdout.getvalue()
+        context = None
+        if raw.strip():
+            context = json.loads(raw)["hookSpecificOutput"]["additionalContext"]
+        return context, elapsed
+
+
+class SlowBankCannotBreachCeiling(_MainHarness):
+    def test_straggler_bank_abandoned_at_deadline(self):
+        # own-bank fast, shared-bank sleeps 3s — far past the 0.6s deadline.
+        client = _SleepyClient(
+            bank_sleep={"own-bank": 0.0, "shared-bank": 3.0},
+            bank_results={"own-bank": [_memory("own hit", "m-own")]},
+        )
+        context, elapsed = self._run(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["shared-bank"],
+                "recallParallelDeadlineSeconds": 0.6,
+            },
+        )
+        # Returned in ~deadline, NOT ~3s. Generous upper bound absorbs CI jitter
+        # while still proving the straggler did not hold the hook open.
+        self.assertLess(
+            elapsed, 2.0,
+            f"recall breached its deadline (took {elapsed:.2f}s with a 3s bank)",
+        )
+        # The fast bank's memory still injected.
+        self.assertIsNotNone(context)
+        self.assertIn("own hit", context)
+        # Telemetry: parallel mode, straggler timed_out, deadline_hit True.
+        e = self._read_log()[0]
+        self.assertEqual(e["recall_mode"], "parallel")
+        self.assertEqual(e["deadline_budget_ms"], 600)
+        # Effective deadline is the configured budget minus pre-fan-out spend,
+        # so it is present, positive, and never exceeds the configured budget.
+        self.assertIsNotNone(e["deadline_effective_ms"])
+        self.assertGreater(e["deadline_effective_ms"], 0)
+        self.assertLessEqual(e["deadline_effective_ms"], e["deadline_budget_ms"])
+        timings = {bt["bank_id"]: bt for bt in e["bank_timings"]}
+        self.assertFalse(timings["own-bank"]["timed_out"])
+        self.assertTrue(timings["shared-bank"]["timed_out"])
+        self.assertTrue(e["deadline_hit"])
+
+    def test_bank_timings_own_bank_first_deterministic(self):
+        client = _SleepyClient(
+            bank_sleep={"own-bank": 0.2, "b1": 0.0, "b2": 0.0},
+            bank_results={"own-bank": [_memory("x", "m1")]},
+        )
+        self._run(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["b1", "b2"],
+                "recallParallelDeadlineSeconds": 5,
+            },
+        )
+        e = self._read_log()[0]
+        order = [bt["bank_id"] for bt in e["bank_timings"]]
+        # Own bank is slowest yet listed first — order is config order, not
+        # completion order.
+        self.assertEqual(order, ["own-bank", "b1", "b2"])
+
+
+class ParallelLatencyIsSlowestSlot(_MainHarness):
+    def test_three_banks_run_concurrently(self):
+        s = 0.4
+        client = _SleepyClient(
+            bank_sleep={"own-bank": s, "b1": s, "b2": s},
+            bank_results={"own-bank": [_memory("x", "m1")]},
+        )
+        _, elapsed = self._run(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["b1", "b2"],
+                "recallParallelDeadlineSeconds": 5,
+            },
+        )
+        # Serial would be ~3*s = 1.2s; parallel is ~s. Assert well under 2*s.
+        self.assertLess(
+            elapsed, 2 * s,
+            f"banks did not run concurrently (took {elapsed:.2f}s for 3x{s}s)",
+        )
+
+
+class DirectivesSlotDedicated(_MainHarness):
+    def test_slow_directives_abandoned_banks_still_inject(self):
+        client = _SleepyClient(
+            bank_sleep={"own-bank": 0.0},
+            bank_results={"own-bank": [_memory("bank memory", "m1")]},
+            directives=[{"id": "d1", "name": "rule", "content": "always X", "priority": 5}],
+            directives_sleep=3.0,  # far past the deadline
+        )
+        context, elapsed = self._run(
+            client,
+            config_extra={"recallParallelDeadlineSeconds": 0.6},
+        )
+        self.assertLess(elapsed, 2.0)
+        # Bank memory injected despite the directives slot dying.
+        self.assertIsNotNone(context)
+        self.assertIn("bank memory", context)
+        e = self._read_log()[0]
+        self.assertTrue(e["directives_timed_out"])
+        self.assertEqual(e["directive_count"], 0)
+        self.assertTrue(e["deadline_hit"])
+
+    def test_fast_directives_inject_alongside_banks(self):
+        client = _SleepyClient(
+            bank_sleep={"own-bank": 0.0},
+            bank_results={"own-bank": [_memory("bank memory", "m1")]},
+            directives=[{"id": "d1", "name": "rule", "content": "always X", "priority": 5}],
+            directives_sleep=0.0,
+        )
+        context, _ = self._run(client, config_extra={"recallParallelDeadlineSeconds": 5})
+        self.assertIsNotNone(context)
+        self.assertIn("always X", context)
+        e = self._read_log()[0]
+        self.assertFalse(e["directives_timed_out"])
+        self.assertEqual(e["directive_count"], 1)
+        self.assertFalse(e["deadline_hit"])
+
+
+class RaisedTimeoutStillClassified(_MainHarness):
+    def test_raised_timeout_marks_deadline_hit(self):
+        # A bank that RAISES socket.timeout (fast fail) is timed_out too — the
+        # finalized semantics keep the per-request-timeout signal as well as the
+        # abandonment signal.
+        client = _RaisingClient(
+            raise_for={"shared-bank": socket.timeout("read timed out")},
+            bank_results={"own-bank": [_memory("x", "m1")]},
+        )
+        self._run(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["shared-bank"],
+                "recallParallelDeadlineSeconds": 5,
+            },
+        )
+        e = self._read_log()[0]
+        timings = {bt["bank_id"]: bt for bt in e["bank_timings"]}
+        self.assertTrue(timings["shared-bank"]["timed_out"])
+        self.assertFalse(timings["own-bank"]["timed_out"])
+        self.assertTrue(e["deadline_hit"])
+
+    def test_non_timeout_error_is_not_deadline_hit(self):
+        client = _RaisingClient(
+            raise_for={"shared-bank": RuntimeError("HTTP 503 from x: boom")},
+            bank_results={"own-bank": [_memory("x", "m1")]},
+        )
+        self._run(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["shared-bank"],
+                "recallParallelDeadlineSeconds": 5,
+            },
+        )
+        e = self._read_log()[0]
+        timings = {bt["bank_id"]: bt for bt in e["bank_timings"]}
+        self.assertFalse(timings["shared-bank"]["timed_out"])
+        self.assertFalse(e["deadline_hit"])
+
+
+class SerialRollback(_MainHarness):
+    def test_rollback_flag_uses_serial_path(self):
+        client = _SleepyClient(
+            bank_sleep={"own-bank": 0.0, "shared-bank": 0.0},
+            bank_results={
+                "own-bank": [_memory("own", "m1")],
+                "shared-bank": [_memory("shared", "m2")],
+            },
+        )
+        context, _ = self._run(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["shared-bank"],
+                "recallParallel": False,
+            },
+        )
+        self.assertIsNotNone(context)
+        e = self._read_log()[0]
+        self.assertEqual(e["recall_mode"], "serial")
+        self.assertIsNone(e["deadline_budget_ms"])
+        self.assertIsNone(e["deadline_effective_ms"])
+        self.assertFalse(e["directives_timed_out"])
+        # Both banks were queried and merged.
+        self.assertEqual(sorted(e["memory_ids"]), ["m1", "m2"])
+        self.assertEqual(sorted(client.recall_calls), ["own-bank", "shared-bank"])
+
+
+class RunParallelPrimitive(unittest.TestCase):
+    def test_completed_vs_abandoned_classification(self):
+        results = {"v": None}
+
+        def fast():
+            return 42
+
+        def slow():
+            time.sleep(2.0)
+            return "late"
+
+        started = time.monotonic()
+        outcomes = run_parallel({"fast": fast, "slow": slow}, deadline_seconds=0.4)
+        elapsed = time.monotonic() - started
+        # Bounded by the shared deadline, not the 2s slow task.
+        self.assertLess(elapsed, 1.5)
+        self.assertTrue(outcomes["fast"].completed)
+        self.assertEqual(outcomes["fast"].value, 42)
+        self.assertIsNone(outcomes["fast"].error)
+        self.assertFalse(outcomes["slow"].completed)
+        self.assertIsNone(outcomes["slow"].value)
+        # elapsed_ms recorded for both (deadline pin for the abandoned one).
+        self.assertIsInstance(outcomes["fast"].elapsed_ms, int)
+        self.assertIsInstance(outcomes["slow"].elapsed_ms, int)
+
+    def test_raising_task_surfaces_error_not_raise(self):
+        def boom():
+            raise ValueError("nope")
+
+        outcomes = run_parallel({"boom": boom}, deadline_seconds=1.0)
+        self.assertTrue(outcomes["boom"].completed)
+        self.assertIsInstance(outcomes["boom"].error, ValueError)
+        self.assertIsNone(outcomes["boom"].value)
+
+    def test_workers_are_daemon_threads(self):
+        seen = {"daemon": None}
+
+        def check():
+            seen["daemon"] = threading.current_thread().daemon
+
+        run_parallel({"c": check}, deadline_seconds=1.0)
+        self.assertTrue(seen["daemon"])
+
+    def test_total_wait_bounded_by_deadline_with_many_slow_slots(self):
+        def slow():
+            time.sleep(2.0)
+
+        tasks = {f"s{i}": slow for i in range(4)}
+        started = time.monotonic()
+        run_parallel(tasks, deadline_seconds=0.5)
+        elapsed = time.monotonic() - started
+        # 4 slow slots cost the deadline ONCE (parallel), not 4x.
+        self.assertLess(elapsed, 1.5)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,96 @@
+"""Switchroom hindsight-leverage PR5 — unit tests for recall tag-weight demotion.
+
+`_apply_tag_weights` multiplies a result's ``scores.final`` by a per-tag weight
+BEFORE the relevance sort, so a down-weighted tag (e.g. ``sidechain: 0.8``) is
+DEMOTED (ranked lower) rather than DROPPED. The load-bearing properties:
+
+  1. A penalised memory sorts BELOW an equal-score un-penalised one.
+  2. A penalised memory STILL surfaces when it is the only relevant hit — i.e.
+     the mechanism is a re-rank, never the hard demote-tag drop filter.
+
+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 recall import _apply_tag_weights, _sort_by_final_score  # noqa: E402
+
+
+def _mem(text, final, tags=None):
+    return {"text": text, "tags": tags or [], "scores": {"final": final}}
+
+
+class ApplyTagWeights(unittest.TestCase):
+    def test_penalised_memory_sorts_below_equal_score_neutral(self):
+        neutral = _mem("neutral fact", 0.50, [])
+        sidechain = _mem("sidechain fact", 0.50, ["sidechain"])
+        results = [sidechain, neutral]  # sidechain first before weighting
+        changed = _apply_tag_weights(results, {"sidechain": 0.8})
+        _sort_by_final_score(results)
+        self.assertEqual(changed, 1)
+        # After the 0.8 penalty, the neutral memory ranks first.
+        self.assertEqual(results[0]["text"], "neutral fact")
+        self.assertEqual(results[1]["text"], "sidechain fact")
+
+    def test_sidechain_still_surfaces_when_only_hit(self):
+        # Only a sidechain memory is relevant — it must remain, just penalised.
+        only = _mem("the only relevant fact", 0.42, ["sidechain"])
+        results = [only]
+        _apply_tag_weights(results, {"sidechain": 0.8})
+        _sort_by_final_score(results)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["text"], "the only relevant fact")
+        # Score was scaled, not zeroed/removed.
+        self.assertAlmostEqual(results[0]["scores"]["final"], 0.42 * 0.8)
+
+    def test_higher_scored_sidechain_can_still_beat_weaker_neutral(self):
+        # Demotion is a multiplier, not a floor: a strong sidechain hit still
+        # outranks a much weaker neutral one.
+        strong_sidechain = _mem("strong sidechain", 0.90, ["sidechain"])
+        weak_neutral = _mem("weak neutral", 0.30, [])
+        results = [weak_neutral, strong_sidechain]
+        _apply_tag_weights(results, {"sidechain": 0.8})  # 0.90*0.8 = 0.72 > 0.30
+        _sort_by_final_score(results)
+        self.assertEqual(results[0]["text"], "strong sidechain")
+
+    def test_empty_or_missing_weights_is_noop(self):
+        m = _mem("x", 0.5, ["sidechain"])
+        self.assertEqual(_apply_tag_weights([m], {}), 0)
+        self.assertEqual(_apply_tag_weights([m], None), 0)
+        self.assertEqual(m["scores"]["final"], 0.5)
+
+    def test_untagged_memory_untouched(self):
+        m = _mem("x", 0.5, [])
+        self.assertEqual(_apply_tag_weights([m], {"sidechain": 0.8}), 0)
+        self.assertEqual(m["scores"]["final"], 0.5)
+
+    def test_compound_weight_for_multiple_matching_tags(self):
+        m = _mem("x", 1.0, ["sidechain", "anti-pattern"])
+        _apply_tag_weights([m], {"sidechain": 0.8, "anti-pattern": 0.5})
+        self.assertAlmostEqual(m["scores"]["final"], 1.0 * 0.8 * 0.5)
+
+    def test_weight_of_one_is_noop(self):
+        m = _mem("x", 0.5, ["sidechain"])
+        self.assertEqual(_apply_tag_weights([m], {"sidechain": 1.0}), 0)
+        self.assertEqual(m["scores"]["final"], 0.5)
+
+    def test_scoreless_result_left_untouched(self):
+        m = {"text": "x", "tags": ["sidechain"]}  # no scores dict
+        self.assertEqual(_apply_tag_weights([m], {"sidechain": 0.8}), 0)
+        self.assertNotIn("scores", m)
+
+    def test_non_positive_or_bad_weight_ignored(self):
+        m = _mem("x", 0.5, ["sidechain"])
+        _apply_tag_weights([m], {"sidechain": 0})       # non-positive → ignored
+        _apply_tag_weights([m], {"sidechain": "bad"})   # non-numeric → ignored
+        self.assertEqual(m["scores"]["final"], 0.5)
+
+
+if __name__ == "__main__":
+    unittest.main()