switchroom 0.16.47 → 0.17.1

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

@@ -0,0 +1,261 @@
+"""Switchroom Phase 6b — unit tests for retain.py's window selection.
+
+`select_retain_window()` decides WHAT to retain once a Stop-hook fire
+happens (the throttle, which decides WHETHER to fire, is separate and
+untouched here). Phase 6b decouples the chunked sliding-window from the
+`retainEveryNTurns > 1` gate so chunked mode works at
+`retainEveryNTurns=1` — switchroom's every-turn crash-durability setting.
+
+The load-bearing property is DURABILITY: with every-turn firing, the
+window must always include the turn that just completed, so a fact told
+in a ≤2-turn session survives a restart (the jtbd-memory-survives-restart
+UAT). Because the window always extends to the END of the transcript, the
+just-completed turn is always inside it.
+
+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 retain import select_retain_window  # noqa: E402
+
+
+def _transcript(num_turns: int) -> list:
+    """Build a transcript of `num_turns` user/assistant turns.
+
+    Each turn = one user message followed by one assistant message. The
+    text encodes the turn index so slices can be identified precisely.
+    """
+    messages = []
+    for i in range(num_turns):
+        messages.append({"role": "user", "content": f"user turn {i}"})
+        messages.append({"role": "assistant", "content": f"assistant turn {i}"})
+    return messages
+
+
+def _user_turn_indices(messages: list) -> list:
+    """Return the turn indices present in a sliced message list."""
+    return [
+        int(m["content"].split()[-1])
+        for m in messages
+        if m.get("role") == "user"
+    ]
+
+
+class SelectRetainWindowChunkedEveryTurn(unittest.TestCase):
+    """The Phase 6b behaviour: chunked slicing works at retain_every_n=1."""
+
+    def test_chunked_n1_slices_recent_window_not_full_session(self):
+        # n=1, overlap=2 -> window = max(1,1)+2 = 3 recent turns.
+        messages = _transcript(5)  # turns 0..4
+        result, full_window = select_retain_window(
+            "chunked", retain_every_n=1, overlap_turns=2, all_messages=messages
+        )
+        # Only the last 3 turns, NOT all 5 — this is the cost fix.
+        self.assertEqual(_user_turn_indices(result), [2, 3, 4])
+        self.assertLess(len(result), len(messages))
+        self.assertTrue(full_window)
+
+    def test_chunked_n1_window_always_includes_the_just_completed_turn(self):
+        # DURABILITY: the newest turn (highest index) must be in the window.
+        for total in (1, 2, 3, 4, 10, 50):
+            messages = _transcript(total)
+            result, _ = select_retain_window(
+                "chunked", retain_every_n=1, overlap_turns=2, all_messages=messages
+            )
+            newest = total - 1
+            self.assertIn(
+                newest,
+                _user_turn_indices(result),
+                f"newest turn {newest} missing from window (total={total})",
+            )
+            # Window always extends to the very end of the transcript.
+            self.assertEqual(result[-1], messages[-1])
+
+    def test_single_turn_session_retains_that_turn(self):
+        # The restart-survival case: a 1-turn session. Window (3) exceeds
+        # available turns, so the whole (1-turn) transcript is retained.
+        messages = _transcript(1)
+        result, full_window = select_retain_window(
+            "chunked", retain_every_n=1, overlap_turns=2, all_messages=messages
+        )
+        self.assertEqual(_user_turn_indices(result), [0])
+        self.assertEqual(result, messages)
+        self.assertTrue(full_window)
+
+    def test_two_turn_session_retains_both_turns(self):
+        # The exact jtbd shape: fact told in turn 0, one more turn, restart.
+        messages = _transcript(2)
+        result, _ = select_retain_window(
+            "chunked", retain_every_n=1, overlap_turns=2, all_messages=messages
+        )
+        self.assertEqual(_user_turn_indices(result), [0, 1])
+
+
+class SelectRetainWindowNoRegression(unittest.TestCase):
+    """The n>1 chunked path and the full-session path must be unchanged."""
+
+    def test_chunked_n_gt_1_window_is_n_plus_overlap(self):
+        # n=10, overlap=2 -> window = 12 turns, identical to the pre-Phase-6b
+        # `retain_every_n + overlap_turns` formula (max(10,1)==10).
+        messages = _transcript(20)  # turns 0..19
+        result, full_window = select_retain_window(
+            "chunked", retain_every_n=10, overlap_turns=2, all_messages=messages
+        )
+        self.assertEqual(_user_turn_indices(result), list(range(8, 20)))  # last 12
+        self.assertTrue(full_window)
+
+    def test_chunked_zero_overlap(self):
+        # n=1, overlap=0 -> window = 1 (just the current turn).
+        messages = _transcript(5)
+        result, _ = select_retain_window(
+            "chunked", retain_every_n=1, overlap_turns=0, all_messages=messages
+        )
+        self.assertEqual(_user_turn_indices(result), [4])
+
+    def test_full_session_retains_all_regardless_of_n(self):
+        messages = _transcript(7)
+        for n in (1, 5, 10):
+            result, full_window = select_retain_window(
+                "full-session", retain_every_n=n, overlap_turns=2, all_messages=messages
+            )
+            self.assertEqual(_user_turn_indices(result), list(range(7)))
+            self.assertEqual(len(result), len(messages))
+            self.assertTrue(full_window)
+
+    def test_unknown_mode_falls_back_to_full_session(self):
+        messages = _transcript(4)
+        result, full_window = select_retain_window(
+            "something-else", retain_every_n=1, overlap_turns=2, all_messages=messages
+        )
+        self.assertEqual(len(result), len(messages))
+        self.assertTrue(full_window)
+
+    def test_returns_a_copy_not_the_same_list_for_full_session(self):
+        # select_retain_window returns list(all_messages) for full-session,
+        # so mutating the result can't corrupt the caller's transcript.
+        messages = _transcript(2)
+        result, _ = select_retain_window(
+            "full-session", retain_every_n=1, overlap_turns=2, all_messages=messages
+        )
+        self.assertIsNot(result, messages)
+
+
+def _human_msg(text: str) -> dict:
+    return {"role": "user", "content": text}
+
+
+def _tool_result_msg(tool_use_id: str, text: str) -> dict:
+    # Claude Code emits tool results as role="user" with a content list of
+    # tool_result blocks — exactly the shape read_transcript() produces.
+    return {
+        "role": "user",
+        "content": [{"type": "tool_result", "tool_use_id": tool_use_id, "content": text}],
+    }
+
+
+def _assistant_msg(text: str) -> dict:
+    return {"role": "assistant", "content": text}
+
+
+def _contains_text(messages: list, needle: str) -> bool:
+    for m in messages:
+        c = m.get("content")
+        if isinstance(c, str) and needle in c:
+            return True
+    return False
+
+
+class SelectRetainWindowToolHeavyTurn(unittest.TestCase):
+    """Finding 1 regression: tool_result messages are role="user" but are NOT
+    human turns. A tool-heavy turn must not push the human's fact out of the
+    window. These FAIL before the content.py boundary fix and pass after.
+    """
+
+    def test_tool_heavy_single_turn_keeps_human_fact_in_window(self):
+        # One logical human turn: the fact, then 3 sequential tool rounds.
+        # OLD boundary semantics count the 3 tool_result "user" messages as
+        # 3 turns and slice them off — dropping the human fact. NEW semantics
+        # count only the 1 human turn, so the whole (1 human-turn) transcript
+        # is retained and the fact survives.
+        fact = "my deploy token is DURABILITY_TOKEN_XYZ"
+        messages = [
+            _human_msg(fact),
+            _assistant_msg("let me look that up"),
+            _tool_result_msg("t1", "file a"),
+            _assistant_msg("checking more"),
+            _tool_result_msg("t2", "file b"),
+            _assistant_msg("one more"),
+            _tool_result_msg("t3", "file c"),
+            _assistant_msg("here is your answer"),
+        ]
+        result, _ = select_retain_window(
+            "chunked", retain_every_n=1, overlap_turns=2, all_messages=messages
+        )
+        self.assertTrue(
+            _contains_text(result, "DURABILITY_TOKEN_XYZ"),
+            "human fact fell outside the retain window on a tool-heavy turn "
+            "(silent memory loss). Window was: "
+            + repr([m.get("content") for m in result]),
+        )
+
+    def test_tool_heavy_current_turn_among_prior_human_turns(self):
+        # Two prior human turns, then a tool-heavy current turn whose human
+        # message carries the fact. window=3 human turns must include the
+        # current turn's human message regardless of tool volume.
+        fact = "the current fact is CURRENT_FACT_42"
+        messages = [
+            _human_msg("older turn 0"),
+            _assistant_msg("a0"),
+            _human_msg("older turn 1"),
+            _assistant_msg("a1"),
+            _human_msg(fact),
+            _assistant_msg("looking"),
+            _tool_result_msg("t1", "r1"),
+            _assistant_msg("more"),
+            _tool_result_msg("t2", "r2"),
+            _assistant_msg("more"),
+            _tool_result_msg("t3", "r3"),
+            _assistant_msg("done"),
+        ]
+        result, _ = select_retain_window(
+            "chunked", retain_every_n=1, overlap_turns=2, all_messages=messages
+        )
+        self.assertTrue(_contains_text(result, "CURRENT_FACT_42"))
+        # And the window is anchored to 3 HUMAN turns — so the oldest human
+        # message ("older turn 0") is the window start.
+        self.assertTrue(_contains_text(result, "older turn 0"))
+
+
+class SelectRetainWindowForce(unittest.TestCase):
+    """Finding 2: SessionEnd force=True widens chunked mode to full-session."""
+
+    def test_force_retains_full_session_in_chunked_mode(self):
+        messages = _transcript(10)  # turns 0..9
+        result, full_window = select_retain_window(
+            "chunked", retain_every_n=1, overlap_turns=2,
+            all_messages=messages, force=True,
+        )
+        # Forced sweep at SessionEnd retains everything, not just the window.
+        self.assertEqual(_user_turn_indices(result), list(range(10)))
+        self.assertEqual(len(result), len(messages))
+        self.assertTrue(full_window)
+
+    def test_no_force_still_windows_in_chunked_mode(self):
+        # Guard: the force widening must not leak into normal per-turn fires.
+        messages = _transcript(10)
+        result, _ = select_retain_window(
+            "chunked", retain_every_n=1, overlap_turns=2,
+            all_messages=messages, force=False,
+        )
+        self.assertEqual(_user_turn_indices(result), [7, 8, 9])  # last 3 turns
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/hindsight-memory/settings.json

@@ -13,6 +13,10 @@
   "recallContextTurns": 1,
   "recallMaxQueryChars": 800,
   "recallRoles": ["user", "assistant"],
+  "recallTags": [],
+  "recallTagsMatch": "any",
+  "recallTagGroups": null,
+  "recallAdditionalBankFilters": {},
   "recallPromptPreamble": "Relevant memories from past conversations (prioritize recent when conflicting). Only use memories that are directly useful to continue this conversation; ignore the rest:",
   "retainRoles": ["user", "assistant"],
   "retainEveryNTurns": 10,

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

@@ -230,3 +230,133 @@ class TestHindsightClientSetBankMission:
         assert "my-bank" in captured["url"]
         assert captured["body"]["updates"]["reflect_mission"] == "I am Claude"
         assert captured["body"]["updates"]["retain_mission"] == "Extract facts"
+
+
+class TestHindsightClientRecallTagFilters:
+    """Upstream 962140eef — tag filters are forwarded in the recall body."""
+
+    def test_sends_tag_filters(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",
+                tags=["memory_type:rule"],
+                tags_match="any_strict",
+                tag_groups=[{"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}],
+            )
+
+        assert captured["body"]["tags"] == ["memory_type:rule"]
+        assert captured["body"]["tags_match"] == "any_strict"
+        assert captured["body"]["tag_groups"] == [
+            {"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}
+        ]
+
+    def test_omits_tag_filters_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 "tags" not in captured["body"]
+        assert "tags_match" not in captured["body"]
+        assert "tag_groups" 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,
+    the original per-call default is preserved."""
+
+    def test_override_replaces_recall_default(self):
+        c = HindsightClient("http://localhost:9077", request_timeout_override=60)
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert captured["timeout"] == 60
+
+    def test_override_replaces_retain_default(self):
+        c = HindsightClient("http://localhost:9077", request_timeout_override=60)
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.retain("bank", "content")
+
+        assert captured["timeout"] == 60
+
+    def test_override_replaces_explicit_recall_timeout(self):
+        # Even an explicit per-call timeout (like recall.py's 8s hook
+        # budget) is replaced when the override is set — which is exactly
+        # why recall.py does NOT construct its client with the override.
+        c = HindsightClient("http://localhost:9077", request_timeout_override=60)
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query", timeout=8)
+
+        assert captured["timeout"] == 60
+
+    def test_no_override_preserves_recall_default(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert captured["timeout"] == 10
+
+    def test_no_override_preserves_retain_default(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.retain("bank", "content")
+
+        assert captured["timeout"] == 15
+
+    def test_override_does_not_affect_health_check(self):
+        c = HindsightClient("http://localhost:9077", request_timeout_override=60)
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({}, status=200)
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            with patch("time.sleep"):
+                c.health_check()
+
+        assert captured["timeout"] == 5

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

@@ -126,3 +126,50 @@ class TestLoadConfig:
         monkeypatch.setenv("HINDSIGHT_RECALL_BUDGET", "high")
         cfg = load_config()
         assert cfg["recallBudget"] == "high"
+
+    # Upstream 962140eef — recall tag filter env overrides.
+
+    def test_recall_tags_env_override_accepts_comma_list(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_RECALL_TAGS", "memory_type:rule, tech_stack:supabase")
+        cfg = load_config()
+        assert cfg["recallTags"] == ["memory_type:rule", "tech_stack:supabase"]
+
+    def test_recall_tags_env_override_accepts_json(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_RECALL_TAGS", '["memory_type:rule"]')
+        cfg = load_config()
+        assert cfg["recallTags"] == ["memory_type:rule"]
+
+    def test_recall_tag_groups_env_override_accepts_json(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv(
+            "HINDSIGHT_RECALL_TAG_GROUPS",
+            '[{"op":"all","tags":["memory_type:rule","tech_stack:supabase"]}]',
+        )
+        cfg = load_config()
+        assert cfg["recallTagGroups"] == [{"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}]
+
+    def test_recall_additional_bank_filters_env_override_accepts_json(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv(
+            "HINDSIGHT_RECALL_ADDITIONAL_BANK_FILTERS",
+            '{"normative":{"recallTags":["memory_type:rule"],"recallTagsMatch":"all"}}',
+        )
+        cfg = load_config()
+        assert cfg["recallAdditionalBankFilters"] == {
+            "normative": {"recallTags": ["memory_type:rule"], "recallTagsMatch": "all"}
+        }
+
+    # Upstream 55ef70679 — request timeout override.
+
+    def test_request_timeout_default_none(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        cfg = load_config()
+        assert cfg["requestTimeoutSeconds"] is None
+
+    def test_request_timeout_env_override(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_REQUEST_TIMEOUT_SECONDS", "60")
+        cfg = load_config()
+        assert cfg["requestTimeoutSeconds"] == 60

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

@@ -1,11 +1,14 @@
 """Tests for lib/content.py — pure content-processing functions."""
 
+import re
+
 import pytest
 
 from lib.content import (
     _extract_text_content,
     _is_channel_message_tool,
     compose_recall_query,
+    format_current_time,
     format_memories,
     prepare_retention_transcript,
     slice_last_turns_by_user_boundary,
@@ -113,6 +116,64 @@ class TestSliceLastTurnsByUserBoundary:
     def test_non_list_returns_empty(self):
         assert slice_last_turns_by_user_boundary(None, 1) == []
 
+    # --- switchroom divergence: tool_result user-messages are NOT turns ---
+
+    @staticmethod
+    def _tool_result(tuid: str, text: str) -> dict:
+        # Claude Code emits tool results as role="user" with a content list of
+        # tool_result blocks (the shape read_transcript produces).
+        return {
+            "role": "user",
+            "content": [{"type": "tool_result", "tool_use_id": tuid, "content": text}],
+        }
+
+    def test_tool_result_messages_are_not_turn_boundaries(self):
+        # One human turn + 3 tool rounds. Requesting 1 turn must anchor to the
+        # human message, NOT the newest tool_result — otherwise a tool-heavy
+        # turn drops the human's text from the window (silent memory loss).
+        msgs = [
+            {"role": "user", "content": "human fact"},
+            {"role": "assistant", "content": "a"},
+            self._tool_result("t1", "r1"),
+            {"role": "assistant", "content": "a"},
+            self._tool_result("t2", "r2"),
+            {"role": "assistant", "content": "a"},
+            self._tool_result("t3", "r3"),
+            {"role": "assistant", "content": "a"},
+        ]
+        result = slice_last_turns_by_user_boundary(msgs, 1)
+        assert result[0]["content"] == "human fact"
+        assert result == msgs  # only 1 human turn, so the whole thing is kept
+
+    def test_counts_human_turns_only_across_tool_heavy_turns(self):
+        # 2 human turns, each followed by a tool round. Requesting 1 human turn
+        # slices to the SECOND human message, not into the first turn's tools.
+        msgs = [
+            {"role": "user", "content": "human one"},
+            {"role": "assistant", "content": "a"},
+            self._tool_result("t1", "r1"),
+            {"role": "user", "content": "human two"},
+            {"role": "assistant", "content": "a"},
+            self._tool_result("t2", "r2"),
+        ]
+        result = slice_last_turns_by_user_boundary(msgs, 1)
+        assert result[0]["content"] == "human two"
+
+    def test_mixed_text_and_tool_result_block_is_a_boundary(self):
+        # A user message with BOTH text and a tool_result block still counts as
+        # a human turn (conservative — only pure tool_result messages are skipped).
+        msgs = [
+            {"role": "user", "content": "older"},
+            {"role": "assistant", "content": "a"},
+            {"role": "user", "content": [
+                {"type": "text", "text": "human with attached result"},
+                {"type": "tool_result", "tool_use_id": "t1", "content": "r1"},
+            ]},
+            {"role": "assistant", "content": "a"},
+        ]
+        result = slice_last_turns_by_user_boundary(msgs, 1)
+        assert result[0]["content"][0]["text"] == "human with attached result"
+
 
 # ---------------------------------------------------------------------------
 # compose_recall_query
@@ -156,6 +217,53 @@ class TestComposeRecallQuery:
         assert "user msg" in result
         assert "assistant msg" not in result
 
+    # --- switchroom divergence: the recall context slice counts HUMAN turns,
+    # not tool_result pseudo-turns (follow-up to #2830, closing the reviewer nit
+    # that the retain path had a test but the recall path — the OTHER caller of
+    # slice_last_turns_by_user_boundary — did not).
+
+    def test_tool_heavy_prior_turn_keeps_human_text_in_recall_context(self):
+        # A prior human turn stating a fact, then 3 sequential tool rounds
+        # (Claude Code emits tool results as role="user"). recall_context_turns=2
+        # asks for the latest turn + one prior HUMAN turn. If the tool_result
+        # messages were counted as boundaries the human fact would be sliced
+        # out; the guard skips them so the fact lands in "Prior context:".
+        messages = [
+            {"role": "user", "content": "my prod database is called ORCHID_PRIMARY"},
+            {"role": "assistant", "content": "let me look that up"},
+            {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "t1", "content": "TOOLPAYLOAD_1"}]},
+            {"role": "assistant", "content": "checking more"},
+            {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "t2", "content": "TOOLPAYLOAD_2"}]},
+            {"role": "assistant", "content": "one more"},
+            {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "t3", "content": "TOOLPAYLOAD_3"}]},
+            {"role": "assistant", "content": "here is your schema"},
+        ]
+        result = compose_recall_query("what port does it listen on", messages, recall_context_turns=2)
+        assert "Prior context:" in result
+        assert "ORCHID_PRIMARY" in result  # human turn survived the tool-heavy turn
+        assert "TOOLPAYLOAD" not in result  # tool_result payload is not human context
+
+    def test_recall_context_anchors_to_human_turns_across_tool_volume(self):
+        # Two prior human turns, each followed by tool rounds. Asking for 3
+        # context turns (latest + 2 prior HUMAN) must reach past all the
+        # tool_result messages to the oldest human turn — tool volume must not
+        # consume the turn budget.
+        messages = [
+            {"role": "user", "content": "the deploy key is FALCON_9_KEY"},
+            {"role": "assistant", "content": "looking"},
+            {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "t1", "content": "out a"}]},
+            {"role": "assistant", "content": "more"},
+            {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "t2", "content": "out b"}]},
+            {"role": "user", "content": "and remind me of the region too"},
+            {"role": "assistant", "content": "checking region"},
+            {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "t3", "content": "out c"}]},
+            {"role": "assistant", "content": "region is ap-southeast-2"},
+        ]
+        result = compose_recall_query("put those together for me", messages, recall_context_turns=3)
+        assert "Prior context:" in result
+        assert "FALCON_9_KEY" in result
+        assert "and remind me of the region too" in result
+
 
 # ---------------------------------------------------------------------------
 # truncate_recall_query
@@ -469,3 +577,18 @@ class TestPrepareRetentionTranscript:
         transcript, _ = prepare_retention_transcript(msgs, retain_full_window=True, include_tool_calls=False)
         assert "[role: user]" in transcript
         assert "[user:end]" in transcript
+
+
+# ---------------------------------------------------------------------------
+# format_current_time
+# ---------------------------------------------------------------------------
+
+
+class TestFormatCurrentTime:
+    def test_includes_utc_suffix(self):
+        # The "UTC" suffix prevents client LLMs from misreading the
+        # timestamp as local time.
+        assert format_current_time().endswith(" UTC")
+
+    def test_format_shape(self):
+        assert re.fullmatch(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2} UTC", format_current_time())

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

@@ -310,6 +310,68 @@ class TestRecallHook:
             cache_path = tmp_path / "plugin_data" / "state" / "recall_cache.json"
             assert not cache_path.exists(), f"Cache should not be written for TTL={bad!r}"
 
+    def test_passes_tag_filters_to_recall_api(self, monkeypatch, tmp_path):
+        # Upstream 962140eef.
+        captured = {}
+
+        def capture_and_respond(req, timeout=None):
+            if "/recall" in req.full_url:
+                captured["body"] = json.loads(req.data.decode())
+            return FakeHTTPResponse({"results": []})
+
+        hook_input = make_hook_input(prompt="What project rules apply here?")
+        _run_hook(
+            "recall",
+            hook_input,
+            monkeypatch,
+            tmp_path,
+            urlopen_side_effect=capture_and_respond,
+            extra_settings={
+                "recallTags": ["memory_type:rule"],
+                "recallTagsMatch": "any_strict",
+                "recallTagGroups": [{"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}],
+            },
+        )
+
+        assert captured["body"]["tags"] == ["memory_type:rule"]
+        assert captured["body"]["tags_match"] == "any_strict"
+        assert captured["body"]["tag_groups"] == [{"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}]
+
+    def test_additional_bank_filters_override_global_tags(self, monkeypatch, tmp_path):
+        # Upstream 962140eef — per-bank overrides beat the global filters.
+        captured = []
+
+        def capture_and_respond(req, timeout=None):
+            if "/recall" in req.full_url:
+                captured.append(json.loads(req.data.decode()))
+            return FakeHTTPResponse({"results": []})
+
+        hook_input = make_hook_input(prompt="What project rules apply here?")
+        _run_hook(
+            "recall",
+            hook_input,
+            monkeypatch,
+            tmp_path,
+            urlopen_side_effect=capture_and_respond,
+            extra_settings={
+                "bankId": "project-bank",
+                "recallAdditionalBanks": ["normative-bank"],
+                "recallTags": ["tech_stack:supabase"],
+                "recallTagsMatch": "any",
+                "recallAdditionalBankFilters": {
+                    "normative-bank": {
+                        "recallTags": ["memory_type:rule"],
+                        "recallTagsMatch": "all_strict",
+                    }
+                },
+            },
+        )
+
+        assert captured[0]["tags"] == ["tech_stack:supabase"]
+        assert captured[0]["tags_match"] == "any"
+        assert captured[1]["tags"] == ["memory_type:rule"]
+        assert captured[1]["tags_match"] == "all_strict"
+
     def test_disabled_auto_recall_produces_no_output(self, monkeypatch, tmp_path):
         (tmp_path / "plugin_root").mkdir(exist_ok=True)
         (tmp_path / "plugin_data").mkdir(exist_ok=True)