switchroom 0.19.41 → 0.19.42

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

@@ -0,0 +1,135 @@
+"""Characterisation of ``recall._overlap_tokens`` — the transcript-fallback tokenizer.
+
+WHY THIS FILE EXISTS
+--------------------
+``_overlap_tokens`` is the keyword tokenizer behind the #3369 transcript-grep
+recall fallback: a recent transcript turn is injected only if its token set
+intersects the query's (``recall._build_transcript_fallback``). When the
+lexical-overlap recall GATE was removed (#3761, commit e3b9d62f) the gate's
+characterisation tests went with it — but ``_overlap_tokens`` itself stayed
+load-bearing for the fallback. That left a real, shipped tokenizer with no
+direct unit coverage: a change to its rules (letters-only vs alphanumeric, the
+length floor, stopword handling) could silently move which transcript turns
+recall can surface, and nothing would fail.
+
+These tests pin the tokenizer's contract directly (#3777), including the #3578
+decision that DIGITS CARRY SIGNAL (issue numbers, ports, versions). They assert
+OUTCOMES of the tokenizer, not code paths, and each would fail on a real
+regression of the documented behaviour.
+
+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)
+
+import recall  # noqa: E402
+
+tok = recall._overlap_tokens
+
+
+class OverlapTokensCharacterisation(unittest.TestCase):
+    """Pure-function contract for ``recall._overlap_tokens`` (#3777)."""
+
+    # --- empty / non-string inputs -------------------------------------------
+
+    def test_empty_string_is_empty_set(self):
+        self.assertEqual(tok(""), set())
+
+    def test_none_is_empty_set(self):
+        self.assertEqual(tok(None), set())
+
+    def test_non_string_scalar_is_empty_set(self):
+        self.assertEqual(tok(123), set())
+
+    def test_non_string_container_is_empty_set(self):
+        self.assertEqual(tok(["deploy", "server"]), set())
+        self.assertEqual(tok({"deploy": 1}), set())
+
+    def test_whitespace_only_is_empty_set(self):
+        self.assertEqual(tok("   \t\n "), set())
+
+    # --- basic tokenisation ---------------------------------------------------
+
+    def test_simple_words_split_on_whitespace(self):
+        self.assertEqual(tok("deploy staging server"), {"deploy", "staging", "server"})
+
+    def test_lowercased(self):
+        self.assertEqual(tok("Deploy STAGING Server"), {"deploy", "staging", "server"})
+
+    def test_case_folds_to_a_single_token(self):
+        self.assertEqual(tok("DEPLOY deploy Deploy"), {"deploy"})
+
+    def test_duplicates_collapse_to_a_set(self):
+        self.assertEqual(tok("server server server"), {"server"})
+
+    def test_trailing_token_without_separator_is_flushed(self):
+        # The final run has no trailing delimiter; it must still be emitted.
+        self.assertEqual(tok("deploy server"), {"deploy", "server"})
+
+    # --- punctuation as separators -------------------------------------------
+
+    def test_punctuation_is_a_separator(self):
+        self.assertEqual(tok("deploy, the staging server!"), {"deploy", "staging", "server"})
+
+    def test_hyphen_splits_tokens(self):
+        self.assertEqual(tok("multi-word thing"), {"multi", "word", "thing"})
+
+    def test_underscore_splits_tokens(self):
+        # '_' is not alphanumeric, so it is a separator (documented behaviour).
+        self.assertEqual(tok("foo_bar baz"), {"foo", "bar", "baz"})
+
+    def test_dotted_version_splits_on_dots(self):
+        self.assertEqual(tok("v0.19.24"), {"v0", "19", "24"})
+
+    # --- length floor ---------------------------------------------------------
+
+    def test_single_alpha_char_is_dropped(self):
+        self.assertEqual(tok("x y z deploy"), {"deploy"})
+
+    def test_single_digit_char_is_dropped_as_noise(self):
+        # A lone digit is noise, not an identifier — dropped by the > 1 guard,
+        # exactly like a lone letter.
+        self.assertEqual(tok("python 9 angular"), {"python", "angular"})
+
+    def test_two_char_token_survives_the_floor(self):
+        self.assertEqual(tok("pr go"), {"pr", "go"})
+
+    # --- stopwords ------------------------------------------------------------
+
+    def test_stopwords_removed(self):
+        self.assertEqual(tok("the is a to of"), set())
+
+    def test_content_survives_with_stopwords_present(self):
+        self.assertEqual(tok("what is the deploy status"), {"deploy", "status"})
+
+    # --- #3578: digits carry signal ------------------------------------------
+
+    def test_pure_digit_issue_number_is_a_token(self):
+        self.assertEqual(tok("PR 3993"), {"pr", "3993"})
+
+    def test_hash_prefixed_issue_number_keeps_the_digits(self):
+        self.assertEqual(tok("#3541 shipped"), {"3541", "shipped"})
+
+    def test_colon_prefixed_port_keeps_the_digits(self):
+        self.assertEqual(tok(":9077 port"), {"9077", "port"})
+
+    def test_mixed_alphanumeric_run_stays_intact(self):
+        self.assertEqual(tok("abc123def"), {"abc123def"})
+
+    def test_identifier_overlap_between_query_and_transcript(self):
+        # The #3578 motivating case: a transcript turn whose only tie to the
+        # query is an issue number must now share a token (it did not before).
+        query = tok("did PR 3993 land and what did v0.19.24 change")
+        turn = tok("3993 shipped in 0.19.24 last night")
+        self.assertIn("3993", query & turn)
+        self.assertTrue(query & turn)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -115,21 +115,15 @@ def _run_main_with(client, prompt="what did we decide", config_extra=None):
     return json.loads(raw)["hookSpecificOutput"]["additionalContext"], raw
 
 
-class GateHelpersAreGoneTests(unittest.TestCase):
-    """The gate's machinery must not exist to be re-wired by accident."""
-
-    def test_gate_helpers_are_removed(self):
-        self.assertFalse(hasattr(recall, "containment_overlap"))
-        self.assertFalse(hasattr(recall, "_filter_by_overlap"))
-
-    def test_tokenizer_survives_for_the_transcript_fallback(self):
-        """`_overlap_tokens` is still load-bearing for
-        `_build_transcript_fallback`'s keyword match — deleting it with the
-        gate would silently break the #3369 fallback."""
-        self.assertEqual(
-            recall._overlap_tokens("Deploy the staging server!"),
-            {"deploy", "staging", "server"},
-        )
+#
+# NOTE (#3999): the former ``GateHelpersAreGoneTests`` hasattr guard
+# (``assertFalse(hasattr(recall, "containment_overlap"))``) was dropped as
+# redundant — a re-added-but-unwired helper does nothing, and a re-WIRED gate is
+# already caught by the outcome assertions in ``NoLexicalDroppingIntegrationTests``
+# below (which fail if any candidate is dropped for lexical reasons). Direct
+# characterisation of the surviving ``_overlap_tokens`` tokenizer now lives in
+# ``test_overlap_tokens.py`` (#3777), not in a hasattr check here.
+#
 
 
 class NoLexicalDroppingIntegrationTests(unittest.TestCase):
@@ -151,17 +145,20 @@ class NoLexicalDroppingIntegrationTests(unittest.TestCase):
         self.assertIn("vegan dinner recipes", ctx)
 
     def test_identifier_only_match_survives(self):
-        """The measured root cause: `_overlap_tokens` drops digits and
-        1-char tokens, so a memory whose ONLY relationship to the prompt is
-        an identifier scored 0.0 and was always discarded. Assert directly
-        that the tokenizer still cannot see the identifier, AND that the
-        memory is injected anyway."""
+        """A memory whose ONLY tie to the prompt is an identifier survives.
+
+        This was the measured root cause of the removed gate: `_overlap_tokens`
+        dropped digits, so an identifier-only memory scored 0.0 and was always
+        discarded. Two things now hold: (a) #3578 gave the tokenizer digit
+        vision, so query and memory now DO share the identifier token; and (b)
+        with the gate gone, the memory is injected regardless of overlap."""
         query = PREAMBLE + "did PR #3541 land, and what did v0.19.24 change"
         mem = "#3541 shipped in 0.19.24"
-        self.assertEqual(
+        # Post-#3578 the identifier is visible on both sides.
+        self.assertIn(
+            "3541",
             recall._overlap_tokens(query) & recall._overlap_tokens(mem),
-            set(),
-            "fixture drifted: it must share no ALPHABETIC token with the query",
+            "the shared identifier must now be a token on both sides (#3578)",
         )
         ctx, _ = _run_main_with(_FakeClient([_memory(mem, score=0.95)]), prompt=query)
         self.assertIsNotNone(ctx)

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

@@ -62,6 +62,7 @@ from lib.content import (  # noqa: E402
     BM25_STOPWORDS,
     _selectivity_score,
     common_english_words,
+    shape_recall_query,
     tokenize_for_bm25,
 )
 
@@ -469,5 +470,52 @@ class ShapingDoesNotMoveTheOverlapGate(_Harness):
         self.assertIn("did we decide about the", context)
 
 
+class SingleCharSubjectSurvives(unittest.TestCase):
+    """#3766 — the ``len(t) > 1`` filter used to run BEFORE the stopword
+    fallback, dropping a single-char SUBJECT ('C', 'R', a single-digit version)
+    outright and then letting the fallback pick multi-char STOPWORDS instead. The
+    length guard now lives only in the fallback, so a single-char content word
+    survives while single-char stopwords ('a', 'i') are still removed.
+
+    These call ``shape_recall_query`` directly — the shaped string is what the
+    BM25 arm searches for, and a subject that vanishes from it is a subject the
+    recall cannot match on. Each assertion fails if the length filter moves back
+    ahead of the stopword filter.
+    """
+
+    def test_single_letter_subject_survives_among_stopwords(self):
+        # 'r' is the only content word; all the rest are stopwords. Pre-fix it
+        # was dropped and the fallback kept 'still'/'faster'/'python' but never
+        # 'r'; post-fix 'r' is a first-class term.
+        out = shape_recall_query("is R still faster than python", max_tokens=24)
+        self.assertIn("r", out.lower().split())
+
+    def test_subject_is_a_lone_single_char_and_all_else_stopwords(self):
+        # "what about C for this" — every other token is a stopword. The subject
+        # 'c' MUST be what searches; pre-fix the query came back as stopwords.
+        out = shape_recall_query("what about C for this", max_tokens=24)
+        terms = out.lower().split()
+        self.assertIn("c", terms)
+        for stop in ("what", "about", "for", "this"):
+            self.assertNotIn(stop, terms, f"stopword {stop!r} reached the wire over the subject")
+
+    def test_single_digit_version_survives(self):
+        # 'single-digit versions' (#3766): "python 9 or python 3".
+        out = shape_recall_query("python 9 or python 3", max_tokens=24)
+        terms = out.lower().split()
+        self.assertIn("9", terms)
+        self.assertIn("3", terms)
+
+    def test_single_char_stopwords_are_still_removed(self):
+        # The guard must not become "keep every single char": 'a' and 'i' are
+        # stopwords and must not survive just because they are one character.
+        out = shape_recall_query("a deploy i triggered", max_tokens=24)
+        terms = out.lower().split()
+        self.assertIn("deploy", terms)
+        self.assertIn("triggered", terms)
+        self.assertNotIn("a", terms)
+        self.assertNotIn("i", terms)
+
+
 if __name__ == "__main__":  # pragma: no cover
     unittest.main()

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

@@ -7,6 +7,7 @@ failure. Stdlib-only; runs under ``python3 -m unittest discover tests/``.
 """
 
 import contextlib
+import io
 import json
 import os
 import sys
@@ -255,13 +256,105 @@ class VolumeGate(unittest.TestCase):
         msgs = []
         for i in range(20):
             msgs.append({"role": "assistant", "content": "z" * 500})
-        total = subagent_retain.non_tool_result_char_count(
+        total = subagent_retain.retained_text_char_count(
             msgs, stop_at=subagent_retain.MIN_NON_TOOL_RESULT_CHARS
         )
         self.assertGreaterEqual(total, subagent_retain.MIN_NON_TOOL_RESULT_CHARS)
         # Full sum would be 20*500=10000; short-circuit stops well before.
         self.assertLess(total, 10000)
 
+    def test_char_count_is_text_only_not_tool_use(self):
+        """#3994: the count measures only what the text-only retain path keeps.
+
+        A message with a small text block and a huge tool_use input must count
+        ONLY the text-block chars. The pre-#3994 metric added the tool_use
+        name+input serialized size; this asserts that contribution is gone, so a
+        revert goes RED.
+        """
+        msgs = [
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "text", "text": "T" * 100},
+                    {
+                        "type": "tool_use",
+                        "name": "Write",
+                        "input": {"content": "Z" * 50_000},
+                    },
+                ],
+            }
+        ]
+        self.assertEqual(subagent_retain.retained_text_char_count(msgs), 100)
+        # Alias preserves back-compat but returns the recalibrated value.
+        self.assertEqual(subagent_retain.non_tool_result_char_count(msgs), 100)
+
+    def test_tool_heavy_prose_light_fork_now_skips(self):
+        """#3994 headline: a fork that clears MIN_HUMAN_TURNS and emits a LOT of
+        tool traffic but almost no prose PASSED the old gate (tool_use chars) and
+        must now FAIL (text-only chars below the floor). The retained document
+        for such a fork was near-empty — the mismatch this recalibration closes.
+        """
+        msgs = []
+        for i in range(8):  # >= MIN_HUMAN_TURNS genuine human turns
+            msgs.append({"role": "user", "content": "go"})
+            msgs.append(
+                {
+                    "role": "assistant",
+                    "content": [
+                        # Pure tool traffic, no assistant prose. ~5 KB command
+                        # each — bulk the OLD gate counted, the payload drops.
+                        {"type": "tool_use", "name": "Bash",
+                         "input": {"command": "true " + ("x" * 5000)}},
+                    ],
+                }
+            )
+            msgs.append(
+                {"role": "user",
+                 "content": [{"type": "tool_result", "tool_use_id": "t", "content": "Z" * 5000}]}
+            )
+        passed, turns, chars = subagent_retain.passes_volume_gate(msgs, CONFIG)
+        self.assertGreaterEqual(turns, subagent_retain.MIN_HUMAN_TURNS)
+        self.assertFalse(passed, f"tool-heavy/prose-light fork must skip: chars={chars}")
+        self.assertLess(chars, subagent_retain.MIN_NON_TOOL_RESULT_CHARS)
+
+
+class EmptyWindowSkipIsVisible(unittest.TestCase):
+    """#4001: the 'formatted to empty despite clearing the gate' skip must not be
+    debug-log-only (silent with debug off in shipped settings)."""
+
+    def _run_with_empty_build(self):
+        """Drive run_subagent_retain to the build_retain_payload==None branch."""
+        with tempfile.TemporaryDirectory() as d:
+            sc = os.path.join(d, "agent-af5.jsonl")
+            _write_sidechain(sc, 8, chars_per_msg=500)  # clears the volume gate
+            hook_input = {
+                "session_id": "parentsess",
+                "agent_id": "af5",
+                "agent_type": "worker",
+                "agent_transcript_path": sc,
+                "transcript_path": os.path.join(d, "parentsess.jsonl"),
+                "cwd": d,
+            }
+            captured_err = io.StringIO()
+            with mock.patch("subagent_retain.load_config", return_value=dict(CONFIG)), \
+                    mock.patch("subagent_retain.get_api_url", return_value="http://x"), \
+                    mock.patch("subagent_retain.ensure_bank_mission"), \
+                    mock.patch("subagent_retain.derive_bank_id", return_value="agentbank"), \
+                    mock.patch("subagent_retain.HindsightClient"), \
+                    mock.patch("subagent_retain.inflight_lock", _lock_acquired), \
+                    mock.patch("subagent_retain.build_retain_payload", return_value=None), \
+                    mock.patch("sys.stderr", new=captured_err):
+                result = subagent_retain.run_subagent_retain(hook_input)
+            return result, captured_err.getvalue()
+
+    def test_empty_window_skip_emits_unconditional_stderr(self):
+        # debug is False (shipped default) — the skip must STILL be visible.
+        result, err = self._run_with_empty_build()
+        self.assertEqual(result["status"], "skipped")
+        self.assertEqual(result["reason"], "empty transcript after formatting")
+        self.assertIn("formatted to EMPTY", err)
+        self.assertIn("parentsess", err)
+
 
 class BoundedRead(unittest.TestCase):
     def test_read_transcript_max_bytes_reads_only_tail(self):

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

@@ -76,12 +76,24 @@ def _entry(role: str, content, uuid: str) -> str:
     )
 
 
+# Per-turn assistant prose. Substantive text blocks so the fixture clears the
+# RECALIBRATED (text-only) volume gate on genuine retainable prose — not on the
+# tool_use volume the payload drops (#3994). ~180 chars each * 8 turns > the
+# 2,000-char floor, all of it text the text-only path keeps.
+TURN_PROSE = (
+    "Reasoning step {i}: ruled out the consolidator dedup theory — world and "
+    "experience facts never traverse the observation dedup path, so overlap "
+    "persists as extra rows. Recording the constraint before moving on."
+)
+
+
 def _tool_heavy_sidechain(path: str, *, human_turns: int = 8) -> None:
-    """A sidechain transcript that is mostly tool traffic plus one prose finding.
+    """A sidechain transcript that is mostly tool traffic plus real prose.
 
     Shaped to clear the volume gate (>= MIN_HUMAN_TURNS human turns and
-    >= MIN_NON_TOOL_RESULT_CHARS of non-tool-result chars) so the retain
-    actually happens — the gate counts tool_use inputs, which this has in bulk.
+    >= MIN_NON_TOOL_RESULT_CHARS of RETAINED text) on the assistant PROSE — the
+    metric the recalibrated gate counts (#3994) — while the bulk of the bytes on
+    disk is the tool traffic the text-only retain path drops.
     """
     lines = []
     for i in range(human_turns):
@@ -94,6 +106,10 @@ def _tool_heavy_sidechain(path: str, *, human_turns: int = 8) -> None:
                         "type": "thinking",
                         "thinking": "internal reasoning that must never be retained",
                     },
+                    {
+                        "type": "text",
+                        "text": TURN_PROSE.format(i=i),
+                    },
                     {
                         "type": "tool_use",
                         "id": f"tu_w{i}",
@@ -142,7 +158,15 @@ def _lock_acquired(blocking=False):
 
 
 def _run_sidechain_retain(sidechain_path: str, tmpdir: str, config_extra=None):
-    """Drive run_subagent_retain with a stub client, returning (result, kwargs)."""
+    """Drive run_subagent_retain with a stub client.
+
+    Returns ``(result, captured_retain_kwargs, passed_config)`` where
+    ``passed_config`` is the EXACT dict object ``run_subagent_retain`` receives
+    from ``load_config`` — the object the production code actually holds and
+    could mutate. Tests assert on THAT object, never on the module-level
+    ``CONFIG`` template (which the code never sees; asserting on it is vacuous —
+    it passes even if the retainToolCalls-copy fix is deleted). See #3999.
+    """
     captured = {}
 
     class _Client:
@@ -153,7 +177,9 @@ def _run_sidechain_retain(sidechain_path: str, tmpdir: str, config_extra=None):
             captured.update(kwargs)
             return {"ok": True}
 
-    config = dict(CONFIG, **(config_extra or {}))
+    # A FRESH copy per run — this is the object the code receives via
+    # load_config and is expected NOT to mutate.
+    passed_config = dict(CONFIG, **(config_extra or {}))
     hook_input = {
         "session_id": "parentsess",
         "agent_id": "af5",
@@ -162,14 +188,14 @@ def _run_sidechain_retain(sidechain_path: str, tmpdir: str, config_extra=None):
         "transcript_path": os.path.join(tmpdir, "parentsess.jsonl"),
         "cwd": tmpdir,
     }
-    with mock.patch("subagent_retain.load_config", return_value=config), \
+    with mock.patch("subagent_retain.load_config", return_value=passed_config), \
             mock.patch("subagent_retain.get_api_url", return_value="http://x"), \
             mock.patch("subagent_retain.ensure_bank_mission"), \
             mock.patch("subagent_retain.derive_bank_id", return_value="agentbank"), \
             mock.patch("subagent_retain.HindsightClient", _Client), \
             mock.patch("subagent_retain.inflight_lock", _lock_acquired):
         result = subagent_retain.run_subagent_retain(hook_input)
-    return result, captured
+    return result, captured, passed_config
 
 
 class SidechainRetainsLearningsNotTools(unittest.TestCase):
@@ -180,7 +206,9 @@ class SidechainRetainsLearningsNotTools(unittest.TestCase):
         self.addCleanup(self._tmp.cleanup)
         self.sidechain = os.path.join(self._tmp.name, "agent-af5.jsonl")
         _tool_heavy_sidechain(self.sidechain)
-        self.result, self.captured = _run_sidechain_retain(self.sidechain, self._tmp.name)
+        self.result, self.captured, self.passed_config = _run_sidechain_retain(
+            self.sidechain, self._tmp.name
+        )
         self.assertEqual(self.result["status"], "ok", self.result)
         self.content = self.captured["content"]
 
@@ -227,21 +255,46 @@ class SidechainRetainsLearningsNotTools(unittest.TestCase):
         )
 
     def test_operator_config_is_not_mutated(self):
-        """The override lands on the sidechain COPY, not the parent's config."""
-        self.assertIs(CONFIG["retainToolCalls"], True)
-
-
-class ProseFreeSidechainDegradesGracefully(unittest.TestCase):
-    """The degenerate case — a worker with NO assistant prose at all.
+        """The ``retainToolCalls = False`` override lands on the sidechain COPY
+        (``sub_config = dict(config)``), never on the config the hook received.
+
+        Asserts on ``passed_config`` — the EXACT object ``run_subagent_retain``
+        got from ``load_config`` and could have mutated in place — not on the
+        module-level ``CONFIG`` template. The old assertion (`CONFIG[...] is
+        True`) was vacuous: the harness always hands the code a fresh copy, so
+        ``CONFIG`` stays True even if the production copy is deleted and the code
+        mutates its input directly. This version goes RED in exactly that case.
+        """
+        self.assertEqual(
+            self.passed_config["retainToolCalls"],
+            True,
+            "run_subagent_retain mutated its caller's config (retainToolCalls "
+            "flipped to False in place) instead of overriding on a copy",
+        )
 
-    Worth pinning because the volume gate counts ``tool_use`` inputs
-    (``non_tool_result_char_count``) while the retained content no longer
-    includes them, so gate and payload now measure different things. The
-    reassuring outcome, verified here rather than assumed: it still retains
-    cleanly, because the gate requires ``MIN_HUMAN_TURNS`` GENUINE human turns
-    and each one is a plain-string user message that survives the text path. So
-    ``build_retain_payload`` does not return None and nothing goes silently
-    empty — while the tool traffic is still excluded.
+    def test_override_is_applied_on_the_copy_the_client_sees(self):
+        """The flip must still REACH the payload: the stub client's retained
+        content is on the text-only path (no tool bodies), which only happens if
+        the sidechain copy carried ``retainToolCalls = False``. Together with
+        the test above this pins BOTH halves — copied AND applied — so deleting
+        either the copy or the override turns one of them RED."""
+        self.assertNotIn(WRITE_BODY_MARKER, self.captured["content"])
+        self.assertNotIn(BASH_COMMAND_MARKER, self.captured["content"])
+        # Positive shape check: the text-only formatter's role markers, not JSON.
+        self.assertIn("[role: assistant]", self.captured["content"])
+
+
+class ProseFreeSidechainIsSkipped(unittest.TestCase):
+    """The degenerate case — a worker with NO assistant prose, only tool traffic.
+
+    Post-#3994 the volume gate counts ONLY the chars the text-only path keeps
+    (``retained_text_char_count`` -> ``_extract_text_content``), so a fork whose
+    bulk is entirely tool_use inputs + tool_result bodies now FAILS the char
+    floor: once tools are stripped there is almost nothing to retain, and the
+    tiny "go" instruction turns fall far under ``MIN_NON_TOOL_RESULT_CHARS``.
+    That is the correct outcome — the old gate cleared on tool-command volume and
+    then retained a near-empty document (the mismatch #3994 closes). This pins
+    the SKIP so a revert to counting tool_use chars goes RED here.
     """
 
     def _prose_free_sidechain(self, path: str, human_turns: int = 8) -> None:
@@ -249,8 +302,8 @@ class ProseFreeSidechainDegradesGracefully(unittest.TestCase):
         for i in range(human_turns):
             # tool_result-only user messages don't count as human turns, so the
             # instruction turns are plain strings — but they are the USER's
-            # words. Keep them short so the retained text is dominated by
-            # nothing at all once tools are stripped.
+            # words. Keep them short so, once tools are stripped, there is almost
+            # no retainable text left.
             lines.append(_entry("user", "go", f"u{i}"))
             lines.append(
                 _entry(
@@ -269,29 +322,32 @@ class ProseFreeSidechainDegradesGracefully(unittest.TestCase):
         with open(path, "w", encoding="utf-8") as f:
             f.write("\n".join(lines) + "\n")
 
-    def test_retains_the_human_turns_and_still_drops_the_tool_traffic(self):
+    def test_prose_free_fork_fails_the_recalibrated_char_floor(self):
         with tempfile.TemporaryDirectory() as d:
             sc = os.path.join(d, "agent-af5.jsonl")
             self._prose_free_sidechain(sc)
-
-            # Precondition: the gate genuinely PASSES on tool_use chars alone,
-            # so this is the "cleared the gate with no prose" case and not just
-            # a trivial-fork skip.
             msgs = subagent_retain.read_transcript(sc)
+
+            # It clears MIN_HUMAN_TURNS (8 genuine "go" turns)...
+            self.assertGreaterEqual(
+                subagent_retain.count_human_turns(msgs), subagent_retain.MIN_HUMAN_TURNS
+            )
+            # ...but the recalibrated (text-only) char count is far below the
+            # floor, because every 4 KB Bash body is excluded from the count.
             passed, turns, chars = subagent_retain.passes_volume_gate(msgs, CONFIG)
-            self.assertTrue(passed, f"gate did not pass: turns={turns} chars={chars}")
-
-            result, captured = _run_sidechain_retain(sc, d)
-
-        # Retains, does not crash and does not enqueue a doomed pending retain.
-        self.assertEqual(result["status"], "ok", result)
-        body = captured["content"][len(subagent_retain.SIDECHAIN_MISSION_HEADER):].strip()
-        # The human instruction turns survive — nothing went silently empty.
-        self.assertIn("[role: user]", body)
-        self.assertIn("go", body)
-        # The 4 KB Bash command bodies did NOT.
-        self.assertNotIn("x" * 200, body)
-        self.assertNotIn("true ", body)
+            self.assertFalse(
+                passed,
+                f"prose-free fork should now SKIP: turns={turns} chars={chars} "
+                f"(floor {subagent_retain.MIN_NON_TOOL_RESULT_CHARS})",
+            )
+            self.assertLess(chars, subagent_retain.MIN_NON_TOOL_RESULT_CHARS)
+
+            # End to end: the retain is skipped by the volume gate; nothing POSTs.
+            result, captured, _ = _run_sidechain_retain(sc, d)
+
+        self.assertEqual(result["status"], "skipped", result)
+        self.assertEqual(result["reason"], "volume gate")
+        self.assertEqual(captured, {}, "a skipped fork must not POST a retain")
 
 
 class TextOnlyPathIsNotEmpty(unittest.TestCase):