switchroom 0.21.14 → 0.21.16

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

@@ -0,0 +1,133 @@
+"""M4 P-REC test (e) — cap truncation, OUTCOME test.
+
+epic §M4 TDD plan (e): "candidate sets larger than 8/4096 are truncated at
+injection, logged truthfully." The truncation mechanism itself
+(``recallMaxMemories`` head-slice / bank-slot reservation, ``recall.py``
+~2757-2795) already exists pre-M4; this is the M4-scoped regression guard
+that asserts it on RENDERED output and the truthful log row, per the
+red-team's "assert on transport/rendered output, not a flag" rule — not
+merely that ``capped`` was set internally.
+
+Stdlib-only; drives ``recall.main()`` end to end against a fake client, no
+network. Harness mirrors ``tests/test_recall_min_score.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
+
+OWN = "test-bank"
+
+
+def _memory(text, mem_id, score):
+    return {"text": text, "type": "fact", "mentioned_at": "2026-01-01", "id": mem_id,
+            "scores": {"final": score}}
+
+
+class _Client:
+    def __init__(self, results):
+        self._results = results
+
+    def list_directives(self, bank_id, active_only=True, timeout=2):
+        return {"items": []}
+
+    def recall(self, bank_id, query, **kwargs):
+        return {"results": [dict(m) for m in self._results]}
+
+
+class CapTruncationTests(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.mkdtemp(prefix="recall-cap-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 _log_row(self):
+        path = os.path.join(self._tmpdir, "state", "recall_log.jsonl")
+        with open(path, encoding="utf-8") as fh:
+            rows = [json.loads(line) for line in fh if line.strip()]
+        self.assertTrue(rows, "no recall_log row was written")
+        return rows[-1]
+
+    def _run(self, n_candidates, max_memories):
+        # Distinct scores so ordering (and therefore which 8 survive) is
+        # deterministic: candidate 0 highest score .. candidate N-1 lowest.
+        results = [
+            _memory(f"candidate {i}", f"m{i}", score=1.0 - (i * 0.01))
+            for i in range(n_candidates)
+        ]
+        client = _Client(results)
+        hook_input = {
+            "prompt": "what do you remember about the deploy pipeline",
+            "session_id": "test-session",
+            "transcript_path": "",
+            "cwd": "/tmp",
+        }
+        config = {
+            "autoRecall": True,
+            "bankId": OWN,
+            "recallMaxTokens": 4096,
+            "recallMaxMemories": max_memories,
+            "recallBudget": "mid",
+            "recallContextTurns": 1,
+            "recallMaxQueryChars": 800,
+            "recallPromptPreamble": "",
+            "recallParallelDeadlineSeconds": 5,
+            "directivesCacheTtlSeconds": 0,
+        }
+        stdout = io.StringIO()
+        with patch("recall.load_config", return_value=config), \
+                patch("recall.get_api_url", return_value="http://fake"), \
+                patch("recall.HindsightClient", return_value=client), \
+                patch("recall.ensure_bank_mission"), \
+                patch("sys.stdin", io.StringIO(json.dumps(hook_input))), \
+                patch("sys.stdout", stdout):
+            recall.main()
+        out = stdout.getvalue()
+        ctx = None
+        if out:
+            parsed = json.loads(out)
+            ctx = parsed.get("hookSpecificOutput", {}).get("additionalContext")
+        return ctx
+
+    def test_candidate_set_above_cap_is_truncated_in_rendered_output(self):
+        ctx = self._run(n_candidates=12, max_memories=8)
+        self.assertIsNotNone(ctx)
+        injected = sum(1 for i in range(12) if f"candidate {i}" in ctx)
+        self.assertEqual(injected, 8, "rendered output must contain exactly the cap's worth of memories")
+
+    def test_log_row_reports_capped_true_with_truthful_pre_cap_count(self):
+        self._run(n_candidates=12, max_memories=8)
+        row = self._log_row()
+        self.assertTrue(row["capped"])
+        self.assertEqual(row["pre_cap_count"], 12)
+
+    def test_candidate_set_at_or_below_cap_is_not_truncated(self):
+        ctx = self._run(n_candidates=8, max_memories=8)
+        self.assertIsNotNone(ctx)
+        for i in range(8):
+            self.assertIn(f"candidate {i}", ctx)
+        row = self._log_row()
+        self.assertFalse(row["capped"])
+        self.assertEqual(row["pre_cap_count"], 8)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,168 @@
+"""M4 P-REC test (d) — junk gate for `<task-notification>` envelopes.
+
+carve-M4.md packet P-REC, test (d): a `<task-notification>`-prefixed prompt
+must not run the noisy NON-directive recall — no `client.recall`, and no
+non-directive memory in the emitted transport.
+
+#4756 F2 directive exemption: DIRECTIVES are the one memory class that must
+SURVIVE the gate — an agent's standing rules apply on every turn, synthetic or
+not. So a gated turn STILL fetches + injects the `<active_directives>` block
+(`client.list_directives`), while the `recall` result set stays suppressed.
+Asserts on TRANSPORT (what reaches stdout + which client methods are touched),
+not on an internal flag, per the red-team's "assert transport, not a flag" rule.
+
+Distinct from the gateway's `<channel source=...>` envelope (a real human
+message) — this only matches the CLI-native task-notification wrapper.
+"""
+
+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
+
+
+class _DirectiveExemptClient:
+    """Models a gated task-notification turn after the #4756 F2 fix.
+
+    `list_directives` answers with one active directive (which MUST survive the
+    gate and be injected). `recall` returns a real memory but records that it
+    was called — the gate must NEVER call it, so a hit on `recall_called` (or
+    the memory text appearing in transport) is a regression to the pre-fix
+    behavior where the gate dropped directives too.
+    """
+
+    def __init__(self):
+        self.recall_called = False
+
+    def list_directives(self, bank_id, active_only=True, timeout=2):
+        return {"items": [{
+            "id": "d1", "name": "always-sign-off", "priority": 10,
+            "content": "always end replies with a wave",
+        }]}
+
+    def recall(self, bank_id, query, **kwargs):
+        self.recall_called = True
+        return {"results": [{
+            "text": "a real memory", "type": "fact", "mentioned_at": "2026-01-01",
+            "id": "m1", "scores": {"final": 0.9},
+        }]}
+
+
+class _AnsweringClient:
+    """A normal client that DOES answer, used to prove the gate did NOT fire."""
+
+    def list_directives(self, bank_id, active_only=True, timeout=2):
+        return {"items": []}
+
+    def recall(self, bank_id, query, **kwargs):
+        return {"results": [{
+            "text": "a real memory", "type": "fact", "mentioned_at": "2026-01-01",
+            "id": "m1", "scores": {"final": 0.9},
+        }]}
+
+
+class JunkGateTests(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.mkdtemp(prefix="recall-junk-gate-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 _run(self, prompt, client):
+        hook_input = {
+            "prompt": prompt,
+            "session_id": "test-session",
+            "transcript_path": "",
+            "cwd": "/tmp",
+        }
+        config = {
+            "autoRecall": True,
+            "bankId": "test-bank",
+            "recallMaxTokens": 4096,
+            "recallBudget": "mid",
+            "recallContextTurns": 1,
+            "recallMaxQueryChars": 800,
+            "recallPromptPreamble": "",
+            "recallParallelDeadlineSeconds": 5,
+            "directivesCacheTtlSeconds": 0,
+        }
+        stdout = io.StringIO()
+        with patch("recall.load_config", return_value=config), \
+                patch("recall.get_api_url", return_value="http://fake"), \
+                patch("recall.HindsightClient", return_value=client), \
+                patch("recall.ensure_bank_mission"), \
+                patch("sys.stdin", io.StringIO(json.dumps(hook_input))), \
+                patch("sys.stdout", stdout):
+            recall.main()
+        return stdout.getvalue()
+
+    def test_task_notification_gate_injects_directives_but_suppresses_recall(self):
+        # #4756 F2: on a gated task-notification turn, DIRECTIVES must be
+        # injected while the non-directive `recall` result set is suppressed.
+        # A test that would pass under the OLD bug (gate emits nothing) is
+        # invalid — so assert the directive text is PRESENT (the bug emitted
+        # ""), the memory text is ABSENT, and `recall` was never called.
+        client = _DirectiveExemptClient()
+        out = self._run(
+            "<task-notification>a background task finished</task-notification>",
+            client,
+        )
+        self.assertTrue(out, "gated turn must still emit the directives block")
+        ctx = json.loads(out)["hookSpecificOutput"]["additionalContext"]
+        self.assertIn("<active_directives>", ctx)
+        self.assertIn("always end replies with a wave", ctx)
+        self.assertNotIn(
+            "a real memory", ctx,
+            "gate must suppress the non-directive recall result set",
+        )
+        self.assertFalse(
+            client.recall_called,
+            "gated turn must never run the memory recall HTTP call",
+        )
+
+    def test_task_notification_gate_with_no_directives_emits_nothing(self):
+        # No active directives → no empty wrapper, no recall: the gate stays a
+        # true no-op on the transport (byte-identical to pre-fix when the bank
+        # has nothing to inject).
+        client = _AnsweringClient()  # list_directives returns items: []
+        out = self._run(
+            "<task-notification>a background task finished</task-notification>",
+            client,
+        )
+        self.assertEqual(
+            out, "",
+            "gated turn with no directives must emit no transport output",
+        )
+
+    def test_ordinary_prompt_with_task_notification_substring_midstring_is_not_gated(self):
+        # Only a PREFIX match gates — a real user prompt that happens to
+        # mention the phrase must still recall normally and reach the
+        # network (proven here by using an ANSWERING client and asserting
+        # the real memory shows up in the rendered transport).
+        out = self._run(
+            "what does a <task-notification> even look like in our hooks?",
+            _AnsweringClient(),
+        )
+        self.assertTrue(out)
+        ctx = json.loads(out)["hookSpecificOutput"]["additionalContext"]
+        self.assertIn("a real memory", ctx)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,124 @@
+"""M4 P-REC test (f) — no score floor applied outside degraded mode.
+
+epic §M4 TDD plan (f): "a regression test asserting no score floor is
+applied outside degraded mode (guards against the refused recommendation
+sneaking in)." E-13 measured a real rank-1 hit scoring ~0.001 and any floor
+emptied 28% of healthy recalls (#3761) — the floor MUST stay scoped to
+degraded turns only (``recallMinScoreScope`` default ``"degraded"``).
+
+This is a regression TRIPWIRE, not new behaviour: ``recall.py`` already
+scopes the floor correctly (``2731-2735``). Per the red-team audit (Finding:
+test (f) leaned on the ``min_score_applied`` flag alone), this asserts on
+BOTH the flag AND the rendered injected content — the full candidate set
+must actually reach ``additionalContext`` on a healthy turn even when a
+floor is configured, so a future "add a real floor" PR that drops rows
+while leaving the flag mis-set still fails RED.
+
+Stdlib-only; drives ``recall.main()`` end to end. Reuses the harness shape
+from ``tests/test_recall_min_score.py`` (kept in a dedicated M4 file per the
+carve's named test-file convention).
+"""
+
+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
+
+OWN = "test-bank"
+NOISE = 0.0006  # E-13's measured rank-1-hit-that-scores-almost-zero regime
+
+
+def _memory(text, mem_id, score):
+    return {"text": text, "type": "fact", "mentioned_at": "2026-01-01", "id": mem_id,
+            "scores": {"final": score}}
+
+
+class _Client:
+    def __init__(self, results):
+        self._results = results
+
+    def list_directives(self, bank_id, active_only=True, timeout=2):
+        return {"items": []}
+
+    def recall(self, bank_id, query, **kwargs):
+        return {"results": [dict(m) for m in self._results]}
+
+
+class NoScoreFloorOutsideDegradedTests(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.mkdtemp(prefix="recall-no-floor-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 _log_row(self):
+        path = os.path.join(self._tmpdir, "state", "recall_log.jsonl")
+        with open(path, encoding="utf-8") as fh:
+            rows = [json.loads(line) for line in fh if line.strip()]
+        self.assertTrue(rows)
+        return rows[-1]
+
+    def test_healthy_turn_ignores_a_configured_floor_flag_and_rendered_output(self):
+        # 6 noise-scoring candidates, a floor set well above their score, own
+        # bank answers cleanly (no timeout/error) — a HEALTHY turn.
+        results = [_memory(f"noise fact {i}", f"m{i}", NOISE) for i in range(6)]
+        client = _Client(results)
+        hook_input = {
+            "prompt": "what did we decide about the auth flow",
+            "session_id": "test-session",
+            "transcript_path": "",
+            "cwd": "/tmp",
+        }
+        config = {
+            "autoRecall": True,
+            "bankId": OWN,
+            "recallMaxTokens": 4096,
+            "recallMinScore": 0.5,  # configured floor, well above NOISE
+            "recallBudget": "mid",
+            "recallContextTurns": 1,
+            "recallMaxQueryChars": 800,
+            "recallPromptPreamble": "",
+            "recallParallelDeadlineSeconds": 5,
+            "directivesCacheTtlSeconds": 0,
+        }
+        stdout = io.StringIO()
+        with patch("recall.load_config", return_value=config), \
+                patch("recall.get_api_url", return_value="http://fake"), \
+                patch("recall.HindsightClient", return_value=client), \
+                patch("recall.ensure_bank_mission"), \
+                patch("sys.stdin", io.StringIO(json.dumps(hook_input))), \
+                patch("sys.stdout", stdout):
+            recall.main()
+        out = stdout.getvalue()
+        self.assertTrue(out)
+        ctx = json.loads(out)["hookSpecificOutput"]["additionalContext"]
+
+        # Rendered-output assertion (the redteam-mandated strengthening): the
+        # FULL pre-floor candidate set reaches the prompt, not just a flag.
+        for i in range(6):
+            self.assertIn(f"noise fact {i}", ctx,
+                           "a score floor silently dropped a healthy-turn candidate")
+
+        row = self._log_row()
+        self.assertFalse(row["min_score_applied"])
+        self.assertEqual(row["dropped_below_min_score"], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()