switchroom 0.17.0 → 0.17.2

package/vendor/hindsight-memory/scripts/lib/content.py

@@ -167,13 +167,48 @@ def truncate_recall_query(query: str, latest_query: str, max_chars: int) -> str:
 # ---------------------------------------------------------------------------
 
 
+def _is_tool_result_only_user_message(message: dict) -> bool:
+    """True when a ``role="user"`` message carries ONLY tool_result blocks.
+
+    SWITCHROOM DIVERGENCE (candidate to upstream to vectorize-io/hindsight):
+    Claude Code emits tool results as ``role="user"`` messages whose content
+    is a list of ``{"type": "tool_result", ...}`` blocks — they are NOT
+    human turns. A genuine human turn has text (a string, or a content list
+    with at least one non-tool_result block, e.g. ``{"type": "text"}`` or an
+    image). Treating tool_result messages as turn boundaries lets a tool-heavy
+    turn (≥N sequential tool rounds) fill a fixed-size retain window with
+    tool_result messages and push the actual human message OUTSIDE the window
+    — silently dropping the fact from that fire, and from every later fire
+    (whose window starts even further from the human message). On restart the
+    fact is gone. This helper lets the boundary counter skip those messages so
+    "window = N turns" means N *human* turns regardless of tool volume.
+    """
+    if message.get("role") != "user":
+        return False
+    content = message.get("content")
+    if isinstance(content, list):
+        blocks = [b for b in content if isinstance(b, dict)]
+        # A non-empty content list that is ENTIRELY tool_result blocks.
+        if blocks and all(b.get("type") == "tool_result" for b in blocks):
+            return True
+    return False
+
+
 def slice_last_turns_by_user_boundary(messages: list, turns: int) -> list:
     """Slice messages to the last N turns, where a turn starts at a user message.
 
     Port of: sliceLastTurnsByUserBoundary() in index.js
 
-    Walks backward counting user messages as turn boundaries. Returns
-    messages from the Nth user boundary to the end.
+    Walks backward counting GENUINE HUMAN user messages as turn boundaries.
+    Returns messages from the Nth human boundary to the end.
+
+    SWITCHROOM DIVERGENCE (candidate to upstream): tool_result messages carry
+    ``role="user"`` in the Claude Code transcript but are not human turns; they
+    are skipped as boundaries (see ``_is_tool_result_only_user_message``). This
+    keeps the fixed-size retain window anchored to human turns so a tool-heavy
+    turn can never push the human's fact outside the window (silent memory loss).
+    Affects both the retain window-slice and the recall context slice — both
+    want "N human turns", not "N transcript user-messages".
     """
     if not isinstance(messages, list) or not messages or turns <= 0:
         return []
@@ -182,7 +217,8 @@ def slice_last_turns_by_user_boundary(messages: list, turns: int) -> list:
     start_index = -1
 
     for i in range(len(messages) - 1, -1, -1):
-        if messages[i].get("role") == "user":
+        msg = messages[i]
+        if msg.get("role") == "user" and not _is_tool_result_only_user_message(msg):
             user_turns_seen += 1
             if user_turns_seen >= turns:
                 start_index = i

package/vendor/hindsight-memory/scripts/retain.py

@@ -69,6 +69,60 @@ def read_transcript(transcript_path: str) -> list:
     return messages
 
 
+def select_retain_window(
+    retain_mode: str,
+    retain_every_n: int,
+    overlap_turns: int,
+    all_messages: list,
+    force: bool = False,
+) -> tuple:
+    """Decide which messages to retain and whether to send as a full window.
+
+    Returns ``(messages_to_retain, retain_full_window)``.
+
+    SWITCHROOM DIVERGENCE (Phase 6b — candidate to upstream to
+    vectorize-io/hindsight): the chunked sliding-window is decoupled from
+    the ``retainEveryNTurns > 1`` throttle. Upstream only sliced a window
+    when ``retain_every_n > 1``; with ``retainEveryNTurns=1`` (switchroom's
+    every-turn crash-durability setting, applied in scaffold.ts) chunked
+    mode fell through to full-session and re-consolidated the ENTIRE
+    accumulated transcript on every Stop fire — an unbounded, per-turn cost.
+
+    Decoupling is safe because window selection and the throttle answer two
+    independent questions: the throttle decides *whether* to fire this turn
+    (still owned by run_retain, unchanged); this function only decides *what*
+    to retain once a fire happens. A chunked window of
+    ``max(retain_every_n, 1) + overlap_turns`` turns is correct for any
+    ``retain_every_n >= 1``. With ``retain_every_n=1, overlap=2`` the window
+    is the 3 most-recent HUMAN turns (tool_result messages don't count as
+    turns — see slice_last_turns_by_user_boundary).
+
+    ``force=True`` (SessionEnd final retain) widens chunked mode to a
+    full-session sweep — belt-and-braces so a graceful shutdown always flushes
+    the whole session even if per-turn windowing had an edge. This costs a
+    full sweep only ONCE per session (at end), not per turn.
+
+    Durability invariant (jtbd-memory-survives-restart UAT): the window
+    always extends to the END of the transcript (``slice_last_turns_by_user_boundary``
+    returns ``messages[start:]``), so the turn that just completed — the one
+    whose Stop hook is firing — is ALWAYS included. Every turn fires (no
+    throttle at n=1), so every turn's content is retained on its own fire.
+    Boundaries are counted on human messages only, so a tool-heavy turn can't
+    push the human's fact outside the window. No fact can fall outside every
+    window.
+    """
+    if retain_mode == "chunked" and not force:
+        # Sliding window: N turns + configured overlap. max(retain_every_n, 1)
+        # keeps the window valid at n=1 (the decoupling); for n>1 this equals
+        # the previous `retain_every_n + overlap_turns` (behaviour unchanged).
+        window_turns = max(retain_every_n, 1) + overlap_turns
+        messages_to_retain = slice_last_turns_by_user_boundary(all_messages, window_turns)
+        return messages_to_retain, True
+    # Full session: vendor full-session mode, OR a forced (SessionEnd) chunked
+    # sweep. Retain all messages, always as a full window.
+    return list(all_messages), True
+
+
 def run_retain(hook_input: dict, force: bool = False) -> dict:
     """Run the auto-retain flow.
 
@@ -104,7 +158,8 @@ def run_retain(hook_input: dict, force: bool = False) -> dict:
 
     debug_log(config, f"Read {len(all_messages)} messages from transcript")
 
-    # Retention mode: full session (default) or chunked (legacy)
+    # Retention mode: full session (vendor default) or chunked. Switchroom
+    # runs chunked at retainEveryNTurns=1 (see select_retain_window / scaffold.ts).
     retain_mode = config.get("retainMode", "full-session")
     retain_every_n = max(1, config.get("retainEveryNTurns", 1))
     retain_full_window = False
@@ -118,19 +173,25 @@ def run_retain(hook_input: dict, force: bool = False) -> dict:
             debug_log(config, f"Turn {turn_count}/{retain_every_n}, skipping retain (next at turn {next_at})")
             return {"status": "skipped", "reason": "throttled"}
 
-    if retain_mode == "chunked" and retain_every_n > 1:
-        # Sliding window: N turns + configured overlap
-        overlap_turns = config.get("retainOverlapTurns", 0)
-        window_turns = retain_every_n + overlap_turns
-        messages_to_retain = slice_last_turns_by_user_boundary(all_messages, window_turns)
-        retain_full_window = True
+    # Window selection is decoupled from the throttle above — see
+    # select_retain_window() for the switchroom-divergence rationale
+    # (Phase 6b: chunked window-slicing now works at retainEveryNTurns=1).
+    overlap_turns = config.get("retainOverlapTurns", 0)
+    messages_to_retain, retain_full_window = select_retain_window(
+        retain_mode, retain_every_n, overlap_turns, all_messages, force=force
+    )
+    if retain_mode == "chunked" and not force:
+        window_turns = max(retain_every_n, 1) + overlap_turns
+        debug_log(
+            config,
+            f"Chunked retain firing (window: {window_turns} human turns, {len(messages_to_retain)} messages)",
+        )
+    elif retain_mode == "chunked" and force:
         debug_log(
             config,
-            f"Chunked retain firing (window: {window_turns} turns, {len(messages_to_retain)} messages)",
+            f"Chunked retain, forced full-session sweep (SessionEnd): {len(all_messages)} messages",
         )
     else:
-        # Full session mode: retain all messages, always as full window
-        retain_full_window = True
         debug_log(config, f"Full session retain: {len(all_messages)} messages")
 
     # Format transcript

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