switchroom 0.17.0 → 0.17.1

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

@@ -0,0 +1,126 @@
+"""Switchroom follow-up to #2830 — recall-side coverage of the tool-boundary
+slice fix.
+
+#2830 fixed silent-memory-loss in ``slice_last_turns_by_user_boundary``:
+Claude Code emits tool results as ``role="user"`` messages, and the old
+boundary counter treated each one as a turn. A tool-heavy turn (>=N sequential
+tool rounds) could therefore fill a fixed-size window with tool_result
+pseudo-turns and push the real human message OUTSIDE it.
+
+That same slice function backs TWO call sites:
+  1. the RETAIN window (covered by ``test_retain_window.py``), and
+  2. the RECALL context slice, via ``compose_recall_query``.
+
+#2830 shipped a test only for the retain path. This file closes the reviewer
+nit by exercising the RECALL path end-to-end over a tool-heavy transcript:
+the composed recall query must still carry the real human turn's text and must
+not be truncated at the tool_result pseudo-boundaries.
+
+These tests FAIL if the ``_is_tool_result_only_user_message`` guard is reverted
+(the tool_result messages become boundaries again and the human turn is sliced
+off), and pass with the guard in place.
+
+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.content import compose_recall_query  # noqa: E402
+
+
+def _human_msg(text: str) -> dict:
+    return {"role": "user", "content": text}
+
+
+def _assistant_msg(text: str) -> dict:
+    return {"role": "assistant", "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}],
+    }
+
+
+class ComposeRecallQueryToolHeavyTurn(unittest.TestCase):
+    """The recall context slice must count HUMAN turns, not tool_result
+    pseudo-turns — otherwise a tool-heavy turn drops the human's text from the
+    recall query, so recall searches on the tool output instead of what the
+    human actually said.
+    """
+
+    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,
+        # then the assistant answer. The current (latest) query is separate.
+        # recall_context_turns=2 asks for the latest turn + one prior HUMAN
+        # turn. OLD boundary semantics count the 3 tool_result "user" messages
+        # as turns and never reach the human fact; NEW semantics skip them and
+        # anchor to the real human turn, so its text lands in "Prior context:".
+        prior_fact = "my prod database is called ORCHID_PRIMARY"
+        messages = [
+            _human_msg(prior_fact),
+            _assistant_msg("let me look that up"),
+            _tool_result_msg("t1", "queried schema table 1"),
+            _assistant_msg("checking more"),
+            _tool_result_msg("t2", "queried schema table 2"),
+            _assistant_msg("one more"),
+            _tool_result_msg("t3", "queried schema table 3"),
+            _assistant_msg("here is your schema"),
+        ]
+        result = compose_recall_query(
+            "what port does it listen on",
+            messages,
+            recall_context_turns=2,
+        )
+        self.assertIn("Prior context:", result)
+        self.assertIn(
+            "ORCHID_PRIMARY",
+            result,
+            "human turn text was sliced out of the recall context by the "
+            "tool_result pseudo-boundaries (recall-side silent memory loss). "
+            "Composed query was: " + repr(result),
+        )
+        # The tool_result content must NOT leak in as if it were a human turn.
+        self.assertNotIn("queried schema table", result)
+
+    def test_recall_context_anchors_to_human_turns_across_tool_volume(self):
+        # Two prior human turns, the older one carrying a fact, each turn
+        # followed by tool rounds. recall_context_turns=3 (latest + 2 prior
+        # HUMAN turns) must reach back past ALL the tool_result messages to the
+        # oldest human turn — tool volume must not consume the turn budget.
+        oldest_fact = "the deploy key is FALCON_9_KEY"
+        messages = [
+            _human_msg(oldest_fact),
+            _assistant_msg("looking"),
+            _tool_result_msg("t1", "tool output alpha"),
+            _assistant_msg("more"),
+            _tool_result_msg("t2", "tool output beta"),
+            _human_msg("and remind me of the region too"),
+            _assistant_msg("checking region"),
+            _tool_result_msg("t3", "tool output gamma"),
+            _assistant_msg("region is ap-southeast-2"),
+        ]
+        result = compose_recall_query(
+            "put those together for me",
+            messages,
+            recall_context_turns=3,
+        )
+        self.assertIn("Prior context:", result)
+        # Both prior HUMAN turns survive; the oldest human fact is reached.
+        self.assertIn("FALCON_9_KEY", result)
+        self.assertIn("and remind me of the region too", result)
+        # No tool_result payload masquerades as human context.
+        self.assertNotIn("tool output", result)
+
+
+if __name__ == "__main__":
+    unittest.main()

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/tests/test_content.py

@@ -116,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
@@ -159,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