switchroom 0.17.6 → 0.18.3

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

@@ -0,0 +1,69 @@
+"""Switchroom #2903 Fix 6.3 — the `<channel source="...">` envelope grammar is
+extracted from directive_verify.py into lib/switchroom_envelope.py so the
+coupling between the vendored Python guard and the switchroom gateway's TS wire
+format is explicit and testable in ONE place.
+
+Pins the grammar so a TS-side format change that breaks these regexes is caught
+by a failing Python test rather than silently disabling the synthetic-inbound
+guard.
+
+Stdlib-only.
+"""
+
+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.switchroom_envelope import (  # noqa: E402
+    HUMAN_INBOUND_SOURCES,
+    envelope_source,
+    is_synthetic_inbound,
+)
+
+
+class TestEnvelopeSource(unittest.TestCase):
+    def test_extracts_open_form(self):
+        self.assertEqual(
+            envelope_source('<channel source="telegram" chat_id="1">hi</channel>'),
+            "telegram",
+        )
+
+    def test_extracts_self_closing_form(self):
+        self.assertEqual(envelope_source('<channel source="reaction"/>'), "reaction")
+
+    def test_lowercases(self):
+        self.assertEqual(envelope_source('<channel source="Cron">x</channel>'), "cron")
+
+    def test_none_when_no_envelope(self):
+        self.assertIsNone(envelope_source("From now on, use British spelling."))
+
+    def test_none_on_non_string(self):
+        for bad in (None, 123, [], {}):
+            self.assertIsNone(envelope_source(bad))
+
+
+class TestSyntheticClassification(unittest.TestCase):
+    def test_telegram_is_human(self):
+        self.assertIn("telegram", HUMAN_INBOUND_SOURCES)
+        self.assertFalse(is_synthetic_inbound('<channel source="telegram">hi</channel>'))
+
+    def test_no_envelope_is_human(self):
+        self.assertFalse(is_synthetic_inbound("hello there"))
+
+    def test_new_source_defaults_to_synthetic(self):
+        # Whitelist posture: an UNKNOWN/new source is treated as machine-authored
+        # by default, not accidentally classified human.
+        self.assertTrue(is_synthetic_inbound('<channel source="brand_new_channel">x</channel>'))
+
+    def test_known_synthetic_sources(self):
+        for src in ("cron", "reaction", "resume_interrupted", "vault_grant_approved"):
+            with self.subTest(src=src):
+                self.assertTrue(is_synthetic_inbound(f'<channel source="{src}">x</channel>'))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -274,6 +274,49 @@ class TestHindsightClientRecallTagFilters:
         assert "tag_groups" not in captured["body"]
 
 
+class TestHindsightClientPreferObservations:
+    """Switchroom Phase-1 — prefer_observations forwarded in the recall body."""
+
+    def test_forwards_prefer_observations_true(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode())
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query", prefer_observations=True)
+
+        assert captured["body"]["prefer_observations"] is True
+
+    def test_forwards_prefer_observations_false(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode())
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query", prefer_observations=False)
+
+        assert captured["body"]["prefer_observations"] is False
+
+    def test_omits_prefer_observations_when_unset(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode())
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert "prefer_observations" not in captured["body"]
+
+
 class TestRequestTimeoutOverride:
     """Upstream 55ef70679 — the constructor override replaces the per-call
     timeout that recall/retain/_request would otherwise use. When unset,

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

@@ -37,8 +37,10 @@ executes.
 
 import json
 import os
+import shutil
 import subprocess
 import sys
+import tempfile
 import textwrap
 
 
@@ -48,6 +50,52 @@ SCRIPTS_DIR = os.path.abspath(
 RECALL_PY = os.path.join(SCRIPTS_DIR, "recall.py")
 
 
+def _dir_is_exec_capable(path):
+    """Return True iff a file created under ``path`` can be executed.
+
+    pytest's ``tmp_path`` defaults to the system temp dir, which on
+    hardened hosts / CI containers is frequently mounted ``noexec``
+    (verify with ``findmnt -T /tmp``). recall.py invokes the
+    ``switchroom`` CLI *by name* via ``subprocess.run`` — that resolves
+    to our on-PATH shim, which must therefore live on an
+    exec-capable filesystem or the call dies with PermissionError and
+    the shim never runs. Probe the real invariant rather than assuming.
+    """
+    try:
+        probe = os.path.join(path, ".exec_probe.sh")
+        with open(probe, "w") as fh:
+            fh.write("#!/usr/bin/env bash\nexit 0\n")
+        os.chmod(probe, 0o755)
+        rc = subprocess.run([probe], capture_output=True).returncode
+        os.unlink(probe)
+        return rc == 0
+    except (OSError, PermissionError):
+        return False
+
+
+def _make_exec_bindir(tmp_path):
+    """Create the shim ``bin`` directory on an exec-capable filesystem.
+
+    Prefer ``tmp_path`` itself (keeps everything colocated); fall back
+    to a self-cleaning temp dir next to this test file — which lives in
+    the repo checkout, an exec-capable ext4/overlay mount — when the
+    default temp root is ``noexec``.
+    """
+    if _dir_is_exec_capable(str(tmp_path)):
+        bindir = tmp_path / "bin"
+        bindir.mkdir(exist_ok=True)
+        return bindir
+    fallback_root = tempfile.mkdtemp(
+        prefix="sw-recall-bin-", dir=os.path.dirname(__file__)
+    )
+    import atexit
+
+    atexit.register(shutil.rmtree, fallback_root, ignore_errors=True)
+    import pathlib
+
+    return pathlib.Path(fallback_root)
+
+
 def _run_recall_with_injected_fault(
     tmp_path,
     debug=False,
@@ -105,8 +153,7 @@ def _run_recall_with_injected_fault(
     # Path manipulation for the switchroom shim. We always isolate
     # PATH so the test doesn't accidentally invoke a real `switchroom`
     # on the host — that would write to a real state dir.
-    bindir = tmp_path / "bin"
-    bindir.mkdir(exist_ok=True)
+    bindir = _make_exec_bindir(tmp_path)
     if switchroom_shim is not None:
         sw = bindir / "switchroom"
         sw.write_text(switchroom_shim)

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

@@ -0,0 +1,114 @@
+"""Retrieval-precision measurement for the Switchroom Phase-1 memory changes.
+
+Per the RFC's outcome-UAT rule (reference/rfcs/hindsight-memory-reimagined.md,
+"Measurement"), the bank-starvation fix ships behind a check that compares
+recalled-set relevance before/after the sort. These tests assert the two
+load-bearing properties of the fix:
+
+  1. The merged multi-bank result set is ordered by the engine's real
+     relevance score (`scores.final`) descending.
+  2. A high-relevance memory from an ADDITIONAL bank is not starved by the
+     count cap when the own bank supplies enough lower-relevance hits to
+     fill it — the pre-fix bug (append-then-slice) would drop it.
+
+`_sort_by_final_score` is the in-place sort applied just before the cap in
+`process_recall`; the cap itself is a plain head-slice, reproduced here so the
+before/after relevance of the capped set is directly comparable.
+"""
+
+from recall import _result_final_score, _sort_by_final_score
+
+
+def _mem(mem_id, final, bank):
+    """A recall result as the engine returns it: text + a scores object."""
+    return {
+        "id": mem_id,
+        "text": f"memory {mem_id} from {bank}",
+        "bank": bank,
+        "scores": {"final": final, "semantic": final, "keyword": final},
+    }
+
+
+def _capped_relevance(results, cap):
+    """Mirror process_recall: head-slice at the cap, return kept scores."""
+    kept = results[:cap] if cap > 0 else results
+    return [_result_final_score(m) for m in kept]
+
+
+class TestFinalScoreExtraction:
+    def test_reads_final_score(self):
+        assert _result_final_score(_mem("a", 0.9, "own")) == 0.9
+
+    def test_missing_scores_sorts_last(self):
+        assert _result_final_score({"id": "x", "text": "t"}) == float("-inf")
+
+    def test_null_scores_sorts_last(self):
+        assert _result_final_score({"id": "x", "scores": None}) == float("-inf")
+
+    def test_missing_final_sorts_last(self):
+        assert _result_final_score({"id": "x", "scores": {"semantic": 0.5}}) == float("-inf")
+
+    def test_bool_is_not_a_score(self):
+        # True is an int subclass; it must not be mistaken for a 1.0 score.
+        assert _result_final_score({"id": "x", "scores": {"final": True}}) == float("-inf")
+
+
+class TestSortByFinalScore:
+    def test_orders_descending(self):
+        results = [_mem("a", 0.2, "own"), _mem("b", 0.9, "own"), _mem("c", 0.5, "own")]
+        _sort_by_final_score(results)
+        assert [m["id"] for m in results] == ["b", "c", "a"]
+
+    def test_stable_on_ties_preserves_own_bank_first(self):
+        # Own-bank appears before additional-bank in insertion order; on a
+        # score tie the stable sort must keep own-bank ahead.
+        results = [_mem("own1", 0.5, "own"), _mem("extra1", 0.5, "profile")]
+        _sort_by_final_score(results)
+        assert [m["id"] for m in results] == ["own1", "extra1"]
+
+    def test_scoreless_entries_sink_to_the_bottom(self):
+        results = [{"id": "noscore", "text": "t"}, _mem("scored", 0.1, "own")]
+        _sort_by_final_score(results)
+        assert results[0]["id"] == "scored"
+
+
+class TestCrossBankStarvationRegression:
+    """The bug the fix targets: a relevant additional-bank memory dropped at
+    the cap because own-bank hits were appended first."""
+
+    def test_high_relevance_additional_bank_memory_survives_cap(self):
+        # Own bank fills the cap with mediocre hits; the profile bank has the
+        # single most relevant memory. Pre-fix (append own, then extra, then
+        # head-slice) the profile hit lands at index 2 and is sliced off.
+        cap = 2
+        own = [_mem("own_lo1", 0.30, "own"), _mem("own_lo2", 0.25, "own")]
+        extra = [_mem("profile_hi", 0.95, "profile")]
+        merged = own + extra  # exactly the pre-fix append order
+
+        # Before: append-then-slice starves the profile bank.
+        pre_fix_ids = [m["id"] for m in merged[:cap]]
+        assert "profile_hi" not in pre_fix_ids
+
+        # After: sort by scores.final before the slice keeps the best memory.
+        _sort_by_final_score(merged)
+        post_fix_ids = [m["id"] for m in merged[:cap]]
+        assert "profile_hi" in post_fix_ids
+        assert post_fix_ids[0] == "profile_hi"
+
+    def test_capped_set_relevance_is_no_worse_after_sort(self):
+        # Measurement: summed relevance of the capped set must not decrease.
+        cap = 3
+        merged = [
+            _mem("own1", 0.4, "own"),
+            _mem("own2", 0.35, "own"),
+            _mem("own3", 0.3, "own"),
+            _mem("profile1", 0.9, "profile"),
+            _mem("shared1", 0.8, "shared"),
+        ]
+        before = sum(_capped_relevance(list(merged), cap))
+        _sort_by_final_score(merged)
+        after = sum(_capped_relevance(merged, cap))
+        assert after >= before
+        # And concretely, the two top additional-bank hits are now retained.
+        kept_ids = [m["id"] for m in merged[:cap]]
+        assert "profile1" in kept_ids and "shared1" in kept_ids