virtual-context 0.3.7__tar.gz → 0.3.8__tar.gz

{virtual_context-0.3.7 → virtual_context-0.3.8}/.github/workflows/python-publish.yml

@@ -22,6 +22,12 @@ jobs:
         with:
           python-version: "3.12"
 
+      - name: Set version from tag
+        run: |
+          VERSION=${GITHUB_REF_NAME#v}
+          sed -i "s/^version = .*/version = \"$VERSION\"/" pyproject.toml
+          sed -i "s/^__version__ = .*/__version__ = \"$VERSION\"/" virtual_context/__init__.py
+
       - name: Build
         run: |
           python -m pip install build

{virtual_context-0.3.7 → virtual_context-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual-context
-Version: 0.3.7
+Version: 0.3.8
 Summary: OS-style virtual memory for LLM session context management
 Project-URL: Homepage, https://virtual-context.com
 Project-URL: Repository, https://github.com/virtual-context/virtual-context

{virtual_context-0.3.7 → virtual_context-0.3.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "virtual-context"
-version = "0.3.7"
+version = "0.3.8"
 description = "OS-style virtual memory for LLM session context management"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_compaction_commit_prune.py

@@ -70,3 +70,18 @@ def test_compaction_skips_prune_when_committed_checkpoint_lags_expected():
     pipeline._commit_compaction_state([])
 
     store.prune_turn_messages.assert_not_called()
+
+
+def test_run_compaction_never_triggers_store_cleanup_from_tag_rules():
+    pipeline, store = _make_pipeline(save_ok=True, committed_turn=4)
+    pipeline._segmenter.segment = MagicMock(return_value=[])
+    pipeline._compact_and_store = MagicMock(return_value=[])
+    pipeline._refresh_shared_retrieval_snapshots = MagicMock()
+    pipeline._config = SimpleNamespace(
+        conversation_id="conv-1",
+        tag_rules=[SimpleNamespace(match="debug*", priority=7)],
+    )
+
+    pipeline._run_compaction([], [], generated_by_turn_id="turn-123")
+
+    store.cleanup.assert_not_called()

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_config.py

@@ -52,7 +52,8 @@ class TestLoadConfig:
         assert len(config.tag_rules) == 2
         assert config.tag_rules[0].match == "architecture*"
         assert config.tag_rules[0].priority == 10
-        assert config.tag_rules[1].ttl_days == 7
+        assert config.tag_rules[1].match == "debug*"
+        assert config.tag_rules[1].priority == 7
 
     def test_load_strategy_config(self):
         config = load_config(config_dict={

virtual_context-0.3.8/tests/test_postgres_store.py

@@ -0,0 +1,102 @@
+"""Focused unit tests for PostgresStore connection management."""
+
+from __future__ import annotations
+
+import threading
+
+
+class _FakeConn:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.closed = False
+        self.executed: list[tuple[str, tuple | None]] = []
+
+    def execute(self, sql: str, params=None):
+        self.executed.append((sql, params))
+        return self
+
+    def close(self) -> None:
+        self.closed = True
+
+
+class _FakeRowsResult:
+    def __init__(self, rows):
+        self._rows = rows
+
+    def fetchall(self):
+        return self._rows
+
+
+def test_postgres_store_uses_thread_local_connections(monkeypatch):
+    from virtual_context.storage import postgres as pg
+
+    created: list[_FakeConn] = []
+
+    def _fake_connect(*args, **kwargs):
+        conn = _FakeConn(f"conn-{len(created)}")
+        created.append(conn)
+        return conn
+
+    monkeypatch.setattr(pg.psycopg, "connect", _fake_connect)
+
+    store = pg.PostgresStore("postgresql://example")
+    main_conn = store._get_conn()
+
+    from_worker: list[_FakeConn] = []
+
+    def _worker() -> None:
+        from_worker.append(store._get_conn())
+
+    worker = threading.Thread(target=_worker)
+    worker.start()
+    worker.join()
+
+    assert store._get_conn() is main_conn
+    assert from_worker == [created[1]]
+    assert from_worker[0] is not main_conn
+    assert len(created) == 2
+
+    store.close()
+
+    assert all(conn.closed for conn in created)
+
+
+def test_postgres_store_get_all_segments_uses_batch_tag_lookup(monkeypatch):
+    from virtual_context.storage import postgres as pg
+
+    class _RowsConn(_FakeConn):
+        def execute(self, sql: str, params=None):
+            self.executed.append((sql, params))
+            if "FROM segments" in sql:
+                return _FakeRowsResult([
+                    {
+                        "ref": "seg-1",
+                        "conversation_id": "conv-1",
+                        "primary_tag": "tag-a",
+                        "summary": "summary",
+                        "summary_tokens": 3,
+                        "full_text": "full text",
+                        "full_tokens": 6,
+                        "messages_json": "[]",
+                        "metadata_json": "{\"turn_count\": 2}",
+                        "created_at": "2026-04-14T00:00:00+00:00",
+                        "start_timestamp": "2026-04-14T00:00:00+00:00",
+                        "end_timestamp": "2026-04-14T00:01:00+00:00",
+                        "compaction_model": "test-model",
+                        "compression_ratio": 0.5,
+                    }
+                ])
+            return _FakeRowsResult([])
+
+    conn = _RowsConn("conn-0")
+
+    monkeypatch.setattr(pg.psycopg, "connect", lambda *args, **kwargs: conn)
+
+    store = pg.PostgresStore("postgresql://example")
+    monkeypatch.setattr(store, "_batch_get_tags", lambda refs: {"seg-1": ["tag-a", "tag-b"]})
+
+    segments = store.get_all_segments(conversation_id="conv-1")
+
+    assert len(segments) == 1
+    assert segments[0].ref == "seg-1"
+    assert segments[0].tags == ["tag-a", "tag-b"]

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_presets.py

@@ -74,9 +74,9 @@ def test_architecture_highest_priority():
     assert arch_rule["priority"] == 10
 
 
-def test_debugging_short_ttl():
-    debug_rule = next(r for r in CODING_TAG_RULES if r["match"] == "debugging*")
-    assert debug_rule["ttl_days"] == 7
+def test_coding_rules_do_not_define_ttl():
+    for rule in CODING_TAG_RULES:
+        assert "ttl_days" not in rule
 
 
 def test_catch_all_rule_exists():

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_proxy_session.py

@@ -640,11 +640,15 @@ class TestContentFingerprintRouting:
         assert is_new is False
         assert result is state
 
-    def test_marker_prefers_live_conversation_over_stale_alias(self):
-        """Explicit session ids should not chain through stale VCATTACH aliases."""
+    def test_alias_wins_even_when_live_conversation_exists(self):
+        """VCATTACH aliases are authoritative — they redirect even when the
+        source conversation still has a live session. VCATTACH no longer
+        deletes the old conversation, so the alias table is the single
+        source of truth for routing.
+        """
         metrics = ProxyMetrics()
         store = MagicMock()
-        store.resolve_conversation_alias.return_value = "wrong-session"
+        store.resolve_conversation_alias.return_value = "redirected-target"
         registry = SessionRegistry(
             config_path=None,
             upstream="http://fake:9999",
@@ -652,17 +656,23 @@ class TestContentFingerprintRouting:
             store=store,
         )
 
-        engine = MagicMock()
-        engine.config.conversation_id = "target-session"
-        state = ProxyState(engine, metrics=metrics)
-        registry._conversations["target-session"] = state
+        live_engine = MagicMock()
+        live_engine.config.conversation_id = "original-session"
+        live_state = ProxyState(live_engine, metrics=metrics)
+        registry._conversations["original-session"] = live_state
+
+        target_engine = MagicMock()
+        target_engine.config.conversation_id = "redirected-target"
+        target_state = ProxyState(target_engine, metrics=metrics)
+        registry._conversations["redirected-target"] = target_state
 
         body = self._make_body(["hello"])
-        result, is_new = registry.get_or_create("target-session", body=body)
+        result, is_new = registry.get_or_create("original-session", body=body)
 
+        # Alias redirects to the target even though original-session is live.
         assert is_new is False
-        assert result is state
-        store.resolve_conversation_alias.assert_not_called()
+        assert result is target_state
+        store.resolve_conversation_alias.assert_called_once_with("original-session")
 
     def test_cold_start_marker_restores_persisted_session(self, tmp_path):
         """A marker referencing a persisted-but-not-loaded session should restore it, not create a new random one."""
@@ -699,8 +709,13 @@ class TestContentFingerprintRouting:
         assert result.engine.config.conversation_id == saved_id
         assert len(result.engine._turn_tag_index.entries) > 0
 
-    def test_cold_start_marker_prefers_persisted_session_over_stale_alias(self, tmp_path):
-        """Persisted sessions should not redirect through older alias rows."""
+    def test_cold_start_alias_redirects_even_when_persisted_source_exists(self, tmp_path):
+        """VCATTACH aliases persistently redirect: when a client sends the old
+        id after a VCATTACH, the alias routes to the target even though the
+        original conversation still has persisted data. VCATTACH no longer
+        deletes the old conversation, so the alias is the only signal that
+        a redirect is intended.
+        """
         from virtual_context.engine import VirtualContextEngine
 
         config_path = tmp_path / "vc.yaml"
@@ -714,7 +729,7 @@ class TestContentFingerprintRouting:
         engine1.close()
 
         from virtual_context.storage.sqlite import SQLiteStore
-        SQLiteStore(str(tmp_path / "store.db")).save_conversation_alias(saved_id, "wrong-session")
+        SQLiteStore(str(tmp_path / "store.db")).save_conversation_alias(saved_id, "target-session")
 
         metrics = ProxyMetrics()
         registry = SessionRegistry(
@@ -727,7 +742,9 @@ class TestContentFingerprintRouting:
         body = self._make_body(["new message"])
         result, is_new = registry.get_or_create(saved_id, body=body)
 
-        assert result.engine.config.conversation_id == saved_id
+        # Alias redirects saved_id -> "target-session", producing a new
+        # session for target-session (there's no persisted target yet).
+        assert result.engine.config.conversation_id == "target-session"
         assert is_new is True
 
 

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_request_captures_persistence.py

@@ -335,6 +335,34 @@ class TestProxyMetricsStoreIntegration:
         assert loaded[0]["client_payload_earliest_timestamp"] == "2026-03-15T16:10:00+00:00"
         assert loaded[0]["client_payload_latest_timestamp"] == "2026-03-16T18:12:00+00:00"
 
+    def test_capture_persists_payload_accounting(self, tmp_path):
+        from virtual_context.proxy.metrics import ProxyMetrics
+
+        store = self._make_store(tmp_path)
+        m = ProxyMetrics(store=store)
+        m.capture_request(
+            turn=1,
+            body={"model": "test", "messages": [{"role": "user", "content": "hi"}]},
+            api_format="anthropic",
+            conversation_id="c1",
+            payload_accounting={
+                "raw_payload_entry_count": 4624,
+                "normalized_payload_entry_count": 986,
+                "normalized_chat_entry_count": 986,
+                "normalized_non_chat_entry_count": 3638,
+                "extracted_history_message_count": 986,
+                "extracted_history_pair_count": 493,
+                "tool_result_user_entries_folded": 1770,
+            },
+        )
+
+        loaded = store.load_request_captures(conversation_id="c1")
+        assert len(loaded) == 1
+        assert loaded[0]["raw_payload_entry_count"] == 4624
+        assert loaded[0]["normalized_payload_entry_count"] == 986
+        assert loaded[0]["extracted_history_pair_count"] == 493
+        assert loaded[0]["payload_accounting"]["tool_result_user_entries_folded"] == 1770
+
     def test_capture_enriched_persists_to_store(self, tmp_path):
         from virtual_context.proxy.metrics import ProxyMetrics
         from unittest.mock import patch
@@ -347,7 +375,9 @@ class TestProxyMetricsStoreIntegration:
         # Verify _persist_capture is called by capture_enriched
         with patch.object(m, '_persist_capture', wraps=m._persist_capture) as mock_persist:
             m.capture_enriched(turn=1, body={"model": "test", "messages": [], "system": "ctx"})
-            mock_persist.assert_called_once_with(1)
+            mock_persist.assert_called_once()
+            assert mock_persist.call_args.args == (1,)
+            assert mock_persist.call_args.kwargs == {"turn_id": None}
         # The store should still have the capture (enriched body excluded from summary)
         loaded = store.load_request_captures()
         assert len(loaded) == 1

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_session_state.py

@@ -136,6 +136,21 @@ def test_save_rejected_after_tombstone(provider, mock_redis):
     assert blob["deleted"] is True
 
 
+def test_undelete_allows_reuse_of_same_conversation_id(provider, mock_redis):
+    provider.delete("conv-123")
+
+    provider.undelete("conv-123")
+
+    state = SessionState()
+    state.last_indexed_turn = 7
+    provider.save("conv-123", state)
+
+    loaded = provider.load("conv-123")
+    assert loaded is not None
+    assert loaded.deleted is False
+    assert loaded.last_indexed_turn == 7
+
+
 def test_turn_tag_entries_roundtrip(provider, mock_redis):
     state = SessionState()
     state.turn_tag_entries = [

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_temporal_resolver.py

@@ -369,7 +369,7 @@ def test_change_over_time_supplements_fact_backed_empty_dates() -> None:
     assert supplemented[0]["match_type"] == "summary_date_expand"
 
 
-def test_remember_when_uses_query_matched_facts_before_date_fallback():
+def test_remember_when_uses_query_matched_facts_after_date_window_scan():
     store = FakeStore()
     search = FakeSearch()
     resolver = TemporalResolver(store=store, search_engine=search, config=_make_config())
@@ -394,11 +394,88 @@ def test_remember_when_uses_query_matched_facts_before_date_fallback():
     )
 
     fact_dates = [item["when"] for item in result["facts_in_window"]]
-    assert store.fallback_called is False
+    assert store.fallback_called is True
     assert "2024-07-29" in fact_dates
     assert any("microservices" in item["what"].lower() for item in result["facts_in_window"])
 
 
+def test_remember_when_lookup_scans_window_even_for_weak_query() -> None:
+    store = FakeStore()
+    search = FakeSearch()
+    resolver = TemporalResolver(store=store, search_engine=search, config=_make_config())
+
+    store.segments["seg-day-1"] = _make_segment(
+        "seg-day-1",
+        "nginx-proxy",
+        "April-13-2026",
+        "Configured nginx reverse proxy for the internal dashboard on port 5757.",
+    )
+    store.segments["seg-day-2"] = _make_segment(
+        "seg-day-2",
+        "dashboard-auth",
+        "April-13-2026",
+        "Worked on dashboard authentication flow and access restrictions.",
+    )
+    store.segments["seg-other"] = _make_segment(
+        "seg-other",
+        "other-day",
+        "April-12-2026",
+        "Worked on an unrelated caching task.",
+    )
+
+    result = resolver.remember_when(
+        query="what did we work on on april 13th",
+        time_range={"kind": "between_dates", "start": "2026-04-13", "end": "2026-04-13"},
+        max_results=4,
+        mode="lookup",
+    )
+
+    assert result["found"] is True
+    assert {item["segment_ref"] for item in result["results"]} == {"seg-day-1", "seg-day-2"}
+    assert all(item["session_date_normalized"] == "2026-04-13" for item in result["results"])
+
+
+def test_remember_when_window_overview_allows_blank_query() -> None:
+    store = FakeStore()
+    search = FakeSearch()
+    resolver = TemporalResolver(store=store, search_engine=search, config=_make_config())
+
+    store.segments["seg-day-1"] = _make_segment(
+        "seg-day-1",
+        "nginx-proxy",
+        "April-13-2026",
+        "Configured nginx reverse proxy for the internal dashboard on port 5757.",
+    )
+    store.segments["seg-day-2"] = _make_segment(
+        "seg-day-2",
+        "dashboard-auth",
+        "April-13-2026",
+        "Worked on dashboard authentication flow and access restrictions.",
+    )
+    store.fallback_facts = [
+        _make_fact(
+            "fact-day-1",
+            "2026-04-13",
+            "Set up nginx proxy routing for the dashboard service",
+            tags=["nginx-proxy", "dashboard"],
+            segment_ref="seg-day-1",
+        ),
+    ]
+
+    result = resolver.remember_when(
+        query="",
+        time_range={"kind": "between_dates", "start": "2026-04-13", "end": "2026-04-13"},
+        max_results=4,
+        mode="window_overview",
+    )
+
+    assert result["mode"] == "window_overview"
+    assert result["found"] is True
+    assert {item["segment_ref"] for item in result["results"]} == {"seg-day-1", "seg-day-2"}
+    assert any(item["what"].startswith("Set up nginx proxy routing") for item in result["facts_in_window"])
+    assert result["date_buckets"][0]["date"] == "2026-04-13"
+
+
 def test_remember_when_change_over_time_mode_merges_broad_window_facts():
     store = FakeStore()
     search = FakeSearch()
@@ -683,6 +760,66 @@ def test_remember_when_summarize_over_time_emits_ordered_milestones():
     assert "deploy stages" in milestones[3]["point"].lower()
 
 
+def test_remember_when_change_over_time_also_emits_ordered_milestones():
+    store = FakeStore()
+    search = FakeSearch()
+    resolver = TemporalResolver(store=store, search_engine=search, config=_make_config())
+
+    store.segment_hits["architecture"] = [
+        _make_quote("seg-1", "architecture", "July-03-2024", "architecture anchor"),
+    ]
+    store.segments["seg-1"] = _make_segment("seg-1", "architecture", "July-03-2024", "July 3 summary")
+
+    store.fact_hits["architecture"] = [
+        _make_fact(
+            "fact-anchor",
+            "2024-07-03",
+            "Architecture updated to support higher throughput and availability",
+            tags=["architecture", "performance-optimization"],
+            segment_ref="seg-1",
+        ),
+    ]
+    store.fallback_facts = [
+        _make_fact(
+            "fact-health",
+            "2024-07-09",
+            "Weighted round robin load balancing with health checks for unhealthy servers",
+            tags=["load-balancing", "high-availability"],
+        ),
+        _make_fact(
+            "fact-redis",
+            "2024-07-11",
+            "Redis caching tier added for repeated query traffic",
+            tags=["distributed-caching", "performance-optimization"],
+        ),
+        _make_fact(
+            "fact-cicd",
+            "2024-07-24",
+            "GitLab CI/CD pipeline added build, test, and deploy stages for the rollout",
+            tags=["deployment", "ci-cd"],
+        ),
+    ]
+
+    result = resolver.remember_when(
+        query="system architecture performance optimization plans",
+        time_range={"kind": "between_dates", "start": "2024-07-01", "end": "2024-07-29"},
+        max_results=4,
+        mode="change_over_time",
+    )
+
+    milestones = result["ordered_milestones"]
+
+    assert [item["date"] for item in milestones] == [
+        "2024-07-03",
+        "2024-07-09",
+        "2024-07-11",
+        "2024-07-24",
+    ]
+    assert "health checks" in milestones[1]["point"].lower()
+    assert "redis caching" in milestones[2]["point"].lower()
+    assert "deploy stages" in milestones[3]["point"].lower()
+
+
 def test_ordered_milestones_prefer_segment_summary_for_shared_date():
     resolver = TemporalResolver(store=FakeStore(), search_engine=FakeSearch(), config=_make_config())
 

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_tool_loop.py

@@ -485,6 +485,22 @@ class TestToolResultVerificationHint:
                     "facts": [],
                 }
             ],
+            "ordered_milestones": [
+                {
+                    "date": "2024-11-05",
+                    "theme": "context window mismatch",
+                    "point": "Window size mismatch error handling was discussed.",
+                    "source": "segment",
+                }
+            ],
+            "phase_milestones": [
+                {
+                    "start_date": "2024-11-05",
+                    "end_date": "2024-11-05",
+                    "focus": "context window mismatch",
+                    "points": ["Window size mismatch error handling was discussed."],
+                }
+            ],
         }
 
         result = execute_vc_tool(
@@ -499,11 +515,71 @@ class TestToolResultVerificationHint:
 
         parsed = json.loads(result)
         assert parsed["mode"] == "change_over_time"
+        assert "phase_milestones" in parsed
+        assert "ordered_milestones" in parsed
         assert parsed["date_buckets"][0]["date"] == "2024-11-05"
         assert "results" not in parsed
         assert "facts_in_window" not in parsed
         assert "reader_hint" in parsed
 
+    def test_remember_when_window_overview_prefers_date_buckets_payload(self):
+        engine = _mock_engine()
+        engine.remember_when.return_value = {
+            "query": "",
+            "mode": "window_overview",
+            "found": True,
+            "range": {
+                "kind": "between_dates",
+                "start": "2026-04-13",
+                "end": "2026-04-13",
+            },
+            "results": [
+                {"excerpt": "Configured nginx reverse proxy", "topic": "nginx-proxy"}
+            ],
+            "facts_in_window": [
+                {"what": "Set up nginx proxy routing", "when": "2026-04-13"}
+            ],
+            "date_buckets": [
+                {
+                    "date": "2026-04-13",
+                    "results": [
+                        {
+                            "topic": "nginx-proxy",
+                            "excerpt": "Configured nginx reverse proxy",
+                            "matched_terms": [],
+                            "segment_ref": "seg-1",
+                            "match_type": "summary_window",
+                        }
+                    ],
+                    "facts": [
+                        {
+                            "what": "Set up nginx proxy routing",
+                            "tags": ["nginx-proxy"],
+                            "matched_terms": [],
+                            "segment_ref": "seg-1",
+                        }
+                    ],
+                }
+            ],
+        }
+
+        result = execute_vc_tool(
+            engine,
+            "vc_remember_when",
+            {
+                "query": "",
+                "time_range": {"kind": "between_dates", "start": "2026-04-13", "end": "2026-04-13"},
+                "mode": "window_overview",
+            },
+        )
+
+        parsed = json.loads(result)
+        assert parsed["mode"] == "window_overview"
+        assert parsed["date_buckets"][0]["date"] == "2026-04-13"
+        assert "results" not in parsed
+        assert "facts_in_window" not in parsed
+        assert "reader_hint" in parsed
+
     def test_unknown_tool_returns_error(self):
         engine = MagicMock()
         result = execute_vc_tool(engine, "vc_unknown", {})

{virtual_context-0.3.7 → virtual_context-0.3.8}/tests/test_tool_result_filter.py

@@ -1,7 +1,11 @@
 """Tests for tool_result filtering in extract_history_pairs — assistant responses
 after tool_result must not be skipped."""
 
-from virtual_context.proxy.formats import AnthropicFormat
+from virtual_context.proxy.formats import (
+    AnthropicFormat,
+    summarize_payload_accounting,
+    summarize_raw_payload_entries,
+)
 
 
 class TestToolResultFilterPreservesAssistantResponse:
@@ -106,3 +110,37 @@ class TestToolResultFilterPreservesAssistantResponse:
         all_content = " ".join(p.content for p in pairs)
 
         assert "48MP" in all_content, "Final assistant synthesis was dropped"
+
+    def test_payload_accounting_explains_tool_fold_and_pair_counts(self):
+        fmt = AnthropicFormat()
+        body = {
+            "messages": [
+                {"role": "user", "content": "Tell me about rare beauty ingredients"},
+                {"role": "assistant", "content": [
+                    {"type": "tool_use", "id": "t1", "name": "web_search", "input": {"q": "rare beauty"}},
+                    {"type": "tool_use", "id": "t2", "name": "web_search", "input": {"q": "revolution"}},
+                ]},
+                {"role": "user", "content": [
+                    {"type": "tool_result", "tool_use_id": "t1", "content": "Rare Beauty uses..."},
+                    {"type": "tool_result", "tool_use_id": "t2", "content": "Revolution uses..."},
+                ]},
+                {"role": "assistant", "content": [
+                    {"type": "thinking", "thinking": "Comparing the two..."},
+                    {"type": "text", "text": "Same Caprylic/Capric Triglyceride for lightweight moisture"},
+                ]},
+                {"role": "user", "content": "Why do you think I have medium skin tone?"},
+                {"role": "assistant", "content": "Based on the shade recommendations..."},
+            ]
+        }
+
+        raw = summarize_raw_payload_entries(body["messages"])
+        accounting = summarize_payload_accounting(body, fmt, raw_summary=raw)
+
+        assert accounting["raw_payload_entry_count"] == 6
+        assert accounting["raw_tool_use_blocks"] == 2
+        assert accounting["raw_tool_result_only_user_entries"] == 1
+        assert accounting["assistant_tool_only_entries_folded"] == 1
+        assert accounting["tool_result_user_entries_folded"] == 1
+        assert accounting["tool_followup_pairs"] == 1
+        assert accounting["extracted_history_message_count"] == 4
+        assert accounting["extracted_history_pair_count"] == 2