switchroom 0.19.22 → 0.19.23

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

@@ -57,22 +57,24 @@ class TestDerivedLimit(unittest.TestCase):
             "HINDSIGHT_RETAIN_CHUNK_SIZE",
             "HINDSIGHT_RETAIN_CHUNK_LATENCY_S",
             "HINDSIGHT_RETAIN_CLIENT_DEADLINE_S",
+            "HINDSIGHT_RETAIN_DEADLINE_SAFETY",
         ):
             os.environ.pop(key, None)
 
     def test_limit_is_chunk_size_times_chunks_that_fit_the_deadline(self):
-        # chunk_size * floor(deadline / latency) = 3000 * floor(310/18.4) = 48000
-        self.assertEqual(retain_content_limit(), 48000)
+        # chunk_size * floor(deadline * safety / latency)
+        #   = 3000 * floor(310 * 0.7 / 18.4) = 3000 * 11 = 33000
+        self.assertEqual(retain_content_limit(), 33000)
 
     def test_limit_is_derived_from_chunk_size_not_a_constant(self):
         os.environ["HINDSIGHT_RETAIN_CHUNK_SIZE"] = "1000"
-        # 1000 * floor(310 / 18.4) = 1000 * 16
-        self.assertEqual(retain_content_limit(), 16000)
+        # 1000 * floor(310 * 0.7 / 18.4) = 1000 * 11
+        self.assertEqual(retain_content_limit(), 11000)
 
     def test_limit_tracks_the_client_deadline(self):
         os.environ["HINDSIGHT_RETAIN_CLIENT_DEADLINE_S"] = "92"
-        # floor(92 / 18.4) = 5 chunks
-        self.assertEqual(retain_content_limit(), 15000)
+        # floor(92 * 0.7 / 18.4) = floor(3.5) = 3 chunks
+        self.assertEqual(retain_content_limit(), 9000)
 
     def test_limit_never_falls_below_one_chunk(self):
         os.environ["HINDSIGHT_RETAIN_CLIENT_DEADLINE_S"] = "1"
@@ -80,7 +82,77 @@ class TestDerivedLimit(unittest.TestCase):
 
     def test_garbage_env_falls_back_to_the_derived_default(self):
         os.environ["HINDSIGHT_RETAIN_CHUNK_LATENCY_S"] = "not-a-number"
+        self.assertEqual(retain_content_limit(), 33000)
+
+
+class TestTheBoundLeavesMarginUnderTheDeadline(unittest.TestCase):
+    """The bound must NOT consume the whole deadline (#3693).
+
+    Sizing a maximally-sized part to ~100% of the client deadline is what
+    manufactured `.dead` entries on this fleet: every `.dead` marker measured
+    on 2026-07-26 held 16,076-44,568 chars, i.e. every one of them sat UNDER
+    the then-current bound and still could not finish inside the deadline the
+    bound was derived from. `latency` is a MEAN (n=752), so half the
+    extraction calls are slower than it; a part sized to the mean misses its
+    deadline about half the time, the drain bumps its attempt count, and
+    MAX_ATTEMPTS later the memory is dead.
+
+    These assert the OUTCOME — real headroom — rather than the arithmetic, so
+    they fail on the zero-margin derivation regardless of how it is spelled.
+    """
+
+    def tearDown(self):
+        for key in (
+            "HINDSIGHT_RETAIN_MAX_CONTENT_CHARS",
+            "HINDSIGHT_RETAIN_CHUNK_SIZE",
+            "HINDSIGHT_RETAIN_CHUNK_LATENCY_S",
+            "HINDSIGHT_RETAIN_CLIENT_DEADLINE_S",
+            "HINDSIGHT_RETAIN_DEADLINE_SAFETY",
+        ):
+            os.environ.pop(key, None)
+
+    @staticmethod
+    def _worst_case_seconds() -> float:
+        """Sequential extraction time of a maximally-sized part."""
+        chunks = retain_content_limit() / retain_split.DEFAULT_RETAIN_CHUNK_SIZE
+        return chunks * retain_split.DEFAULT_RETAIN_CHUNK_LATENCY_S
+
+    def test_a_maximally_sized_part_finishes_well_inside_the_deadline(self):
+        deadline = retain_split.retain_client_deadline()
+        worst = self._worst_case_seconds()
+        # The pre-#3693 derivation gave 294.4s against 310s -> 0.95 here.
+        self.assertLessEqual(
+            worst / deadline,
+            0.8,
+            f"a maximally-sized part is {worst:.1f}s of extraction against a "
+            f"{deadline:.0f}s deadline: no room for the POST, server queueing, "
+            f"or a chunk slower than the mean",
+        )
+
+    def test_the_headroom_absorbs_a_chunk_distribution_worse_than_its_mean(self):
+        deadline = retain_split.retain_client_deadline()
+        # Every chunk running 25% slower than the measured mean must still fit.
+        self.assertLessEqual(self._worst_case_seconds() * 1.25, deadline)
+
+    def test_the_margin_holds_at_every_deadline_not_just_the_default(self):
+        for seconds in ("120", "200", "310", "600", "900"):
+            os.environ["HINDSIGHT_RETAIN_CLIENT_DEADLINE_S"] = seconds
+            worst = self._worst_case_seconds()
+            deadline = float(seconds)
+            with self.subTest(deadline=seconds):
+                self.assertLessEqual(worst / deadline, 0.8)
+
+    def test_the_safety_fraction_is_operator_tunable(self):
+        os.environ["HINDSIGHT_RETAIN_DEADLINE_SAFETY"] = "0.5"
+        # floor(310 * 0.5 / 18.4) = floor(8.42) = 8 chunks
+        self.assertEqual(retain_content_limit(), 24000)
+
+    def test_a_safety_fraction_above_one_cannot_reintroduce_the_overrun(self):
+        os.environ["HINDSIGHT_RETAIN_DEADLINE_SAFETY"] = "2.0"
+        # Clamped to 1.0, so the WORST an operator can do is the old
+        # zero-margin bound -- never a part sized to overrun outright.
         self.assertEqual(retain_content_limit(), 48000)
+        self.assertLessEqual(self._worst_case_seconds(), retain_split.retain_client_deadline())
 
 
 class TestSplitBounds(unittest.TestCase):

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

@@ -15,6 +15,21 @@ if SCRIPTS_DIR not in sys.path:
     sys.path.insert(0, SCRIPTS_DIR)
 
 
+def _dead_marker(path: str) -> str:
+    """Where `mark_dead` puts the marker for the queue entry at `path`.
+
+    NOT `<path>.dead` any more: a marker is the only remaining copy of its
+    memory, so it leaves the live queue directory for the `pending-dead/`
+    sibling rather than sitting in the directory external janitors glob
+    (switchroom #3697). Asserting the old spelling made this suite red on a
+    deliberate change -- invisibly, because CI discovers only
+    `scripts/tests/`.
+    """
+    from lib.pending import dead_dir
+
+    return os.path.join(dead_dir(), os.path.basename(path) + ".dead")
+
+
 class FakeOk:
     """Minimal urlopen() context-manager stand-in for a 200 OK."""
 
@@ -229,7 +244,7 @@ class DrainPendingTest(unittest.TestCase):
             summary = drain_pending.drain({})
         self.assertEqual(summary["dead"], 1)
         self.assertFalse(os.path.exists(path))
-        self.assertTrue(os.path.exists(path + ".dead"))
+        self.assertTrue(os.path.exists(_dead_marker(path)))
 
     def test_drain_max_attempts_keeps_the_memory_on_a_transient_failure(self):
         """A dead upstream must never retire a memory, however many attempts.
@@ -251,7 +266,7 @@ class DrainPendingTest(unittest.TestCase):
         self.assertEqual(summary["dead"], 0)
         self.assertEqual(summary["retried"], 1)
         self.assertTrue(os.path.exists(path))
-        self.assertFalse(os.path.exists(path + ".dead"))
+        self.assertFalse(os.path.exists(_dead_marker(path)))
 
     def test_drain_stall_guard_stops_after_threshold(self):
         # Seed 10 entries; with a same-error-class stream, the stall

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

@@ -38,7 +38,10 @@ class PendingQueueTest(unittest.TestCase):
             "api_url": "http://fake:9077",
             "api_token": None,
             "bank_id": "test-bank",
-            "content": "user: hello\nassistant: hi",
+            # Distinct per document: the queue's dedupe key is
+            # (bank_id, part_position, sha256(content)) since switchroom
+            # #3688, so a shared body would collapse these into one entry.
+            "content": f"user: hello\nassistant: hi ({document_id})",
             "document_id": document_id,
             "context": "claude-code",
             "metadata": {"session_id": "sess-1"},
@@ -59,7 +62,7 @@ class PendingQueueTest(unittest.TestCase):
         with open(path) as f:
             entry = json.load(f)
         self.assertEqual(entry["bank_id"], "test-bank")
-        self.assertEqual(entry["content"], "user: hello\nassistant: hi")
+        self.assertEqual(entry["content"], self._sample_payload()["content"])
         self.assertEqual(entry["document_id"], "doc-1")
         self.assertEqual(entry["error_class"], "ValueError")
         self.assertEqual(entry["error_message"], "nope")
@@ -200,8 +203,13 @@ class PendingQueueTest(unittest.TestCase):
             self.assertNotIn(
                 "dead_at", e, "a live queue entry must never carry dead_at"
             )
-        # The .dead marker exists and carries dead_at.
-        dead = path + ".dead"
+        # The .dead marker exists and carries dead_at. It lives in the
+        # `pending-dead/` SIBLING, not in the live queue directory: a marker
+        # is the only remaining copy of its memory, and the queue dir is the
+        # one external janitors glob (switchroom #3697).
+        dead = os.path.join(
+            pending_mod.dead_dir(), os.path.basename(path) + ".dead"
+        )
         self.assertTrue(os.path.isfile(dead))
         with open(dead) as f:
             self.assertIn("dead_at", json.load(f))