Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/agent/test_idle_compaction.py

@@ -0,0 +1,104 @@
+"""Tests for the opt-in idle-triggered compaction policy.
+
+Covers ``agent.turn_context._should_idle_compact`` — the pure predicate that
+decides whether a session resuming after an idle gap should compact up front.
+The predicate is intentionally side-effect-free so the policy can be verified
+without constructing a live agent or DB.
+"""
+
+from agent.turn_context import _should_idle_compact
+
+
+def _decide(**overrides):
+    """Call the predicate with sensible defaults (idle + large context => fire)."""
+    kwargs = dict(
+        enabled=True,
+        idle_after_seconds=1800,
+        idle_gap_seconds=3600.0,
+        tokens=100_000,
+        floor_tokens=40_000,
+        cooldown_active=False,
+    )
+    kwargs.update(overrides)
+    return _should_idle_compact(**kwargs)
+
+
+class TestShouldIdleCompact:
+
+    def test_disabled_when_idle_after_zero(self):
+        # 0 is the documented "off" value — must never fire regardless of gap.
+        assert _decide(idle_after_seconds=0, idle_gap_seconds=10_000.0) is False
+
+
+    def test_disabled_when_compression_off(self):
+        assert _decide(enabled=False) is False
+
+
+
+
+    def test_fires_just_above_floor(self):
+        assert _decide(tokens=40_001, floor_tokens=40_000) is True
+
+
+class TestPostCompactionFloor:
+    """The floor also honours what the previous pass actually produced (#97239).
+
+    ``floor_tokens`` is the theoretical target (threshold × target_ratio); a
+    real pass lands well above it because the system prompt, the tool schemas
+    and the protected head/tail are incompressible. Without this, an already
+    compacted session re-summarises itself on every idle resume forever.
+    """
+
+    def test_unrecorded_last_compaction_keeps_original_floor(self):
+        # 0 = nothing compacted yet (or state reset) — original semantics.
+        assert _decide(tokens=40_001, floor_tokens=40_000,
+                       last_compaction_tokens=0) is True
+
+    def test_skips_when_transcript_has_not_grown_since_last_compaction(self):
+        # Previous pass produced 44,000; the transcript is still ~that size.
+        assert _decide(tokens=44_100, floor_tokens=40_000,
+                       last_compaction_tokens=44_000) is False
+
+    def test_fires_once_a_full_floor_of_new_content_accumulated(self):
+        assert _decide(tokens=84_001, floor_tokens=40_000,
+                       last_compaction_tokens=44_000) is True
+
+    def test_does_not_fire_at_exactly_the_raised_floor(self):
+        assert _decide(tokens=84_000, floor_tokens=40_000,
+                       last_compaction_tokens=44_000) is False
+
+    def test_reported_session_stops_recompacting_itself(self):
+        """Exact numbers from issue #97239.
+
+        The 17:01 pass reduced 64,105 -> 44,579 tokens; the 17:36 resume
+        re-fired on that same transcript because 44,579 > the 25,502
+        theoretical floor, blocking the prompt for another 256 s.
+        """
+        common = dict(idle_after_seconds=1, idle_gap_seconds=747.0,
+                      floor_tokens=25_502)
+        # Before the fix the second resume fired: 44,579 > 25,502.
+        assert _decide(tokens=44_579, last_compaction_tokens=0, **common) is True
+        # With the previous pass's real output known, it sits the round out.
+        assert _decide(tokens=44_579, last_compaction_tokens=44_579,
+                       **common) is False
+
+    def test_an_effective_pass_still_raises_the_floor(self):
+        # 100K -> 10K is a good pass; another one is worth it only once about
+        # a floor's worth of new content has landed on top of the 10K.
+        assert _decide(tokens=30_000, floor_tokens=25_000,
+                       last_compaction_tokens=10_000) is False
+        assert _decide(tokens=35_001, floor_tokens=25_000,
+                       last_compaction_tokens=10_000) is True
+
+    def test_other_gates_still_win_over_the_raised_floor(self):
+        # Growth alone must not defeat the cooldown / opt-out gates.
+        assert _decide(tokens=200_000, floor_tokens=40_000,
+                       last_compaction_tokens=44_000,
+                       cooldown_active=True) is False
+        assert _decide(tokens=200_000, floor_tokens=40_000,
+                       last_compaction_tokens=44_000,
+                       idle_after_seconds=0) is False
+        assert _decide(tokens=200_000, floor_tokens=40_000,
+                       last_compaction_tokens=44_000,
+                       idle_gap_seconds=0.5) is False
+