yilsem/aiturk-hermes-ide
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 4 Wiki Activity
Files
e874ce9c4cce98584bf7adbe1b577ec4817d2d71
aiturk-hermes-ide/tests/agent/test_compression_rotation_state.py
T

2072 lines
80 KiB
Python
Raw Blame History

"""Compression rotation hardening — state-loss fixes at the compaction boundary.
When auto-compression rotates ``agent.session_id`` to a continuation child,
three pieces of state used to be lost or corrupted:
* #33618 — a persistent ``/goal`` did not follow the rotation (``load_goal``
is a flat per-session lookup with no lineage walk), so it silently died.
* #33906/#33907 — if the child ``create_session`` raised, the outer handler
only warned and let the agent continue on the NEW (un-indexed) id,
producing an orphan session missing from state.db.
* #27633 — the compaction-boundary ``on_session_start`` notification omitted
the ``platform`` kwarg, so context-engine plugins saw ``source=unknown``
for every message after the boundary.
These tests drive the real ``compress_context`` path against a real SessionDB.
"""
from __future__ import annotations
import copy
import os
import time
from pathlib import Path
from typing import Any
from unittest.mock import MagicMock, patch
import pytest
from agent.context_compressor import ContextCompressor, _DB_PERSISTED_MARKER
from agent.conversation_compression import (
CompressionCommitFence,
_is_real_user_message,
)
from hermes_state import SessionDB
def _build_agent_with_db(db: SessionDB, session_id: str, platform: str = "telegram"):
with patch.dict(os.environ, {"OPENROUTER_API_KEY": "test-key"}):
from run_agent import AIAgent
agent = AIAgent(
api_key="test-key",
base_url="https://openrouter.ai/api/v1",
model="test/model",
platform=platform,
quiet_mode=True,
session_db=db,
session_id=session_id,
skip_context_files=True,
skip_memory=True,
)
compressor = MagicMock()
compressor.compress.return_value = [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "user", "content": "tail"},
]
compressor.compression_count = 1
compressor.last_prompt_tokens = 0
compressor.last_completion_tokens = 0
compressor._last_summary_error = None
compressor._last_compress_aborted = False
compressor._last_summary_auth_failure = False
compressor._last_aux_model_failure_model = None
compressor._last_aux_model_failure_error = None
agent.context_compressor = compressor
# ROTATION fallback path — pin in_place=False so these keep covering fork
# rotation regardless of the global default (flipped to True in #38763).
agent.compression_in_place = False
return agent
def _msgs(n=20):
return [{"role": "user", "content": f"m{i}"} for i in range(n)]
def _count_rows(rows, *, content: Any = None, role: str | None = None):
return sum(
1
for row in rows
if (content is None or row.get("content") == content)
and (role is None or row.get("role") == role)
)
def _bound_context_compressor(db: SessionDB, session_id: str) -> ContextCompressor:
with patch(
"agent.context_compressor.get_model_context_length",
return_value=100_000,
):
compressor = ContextCompressor(
model="test/model",
threshold_percent=0.85,
protect_first_n=2,
protect_last_n=2,
quiet_mode=True,
)
compressor.bind_session_state(db, session_id)
return compressor
@pytest.fixture
def refresh_state_db(tmp_path: Path):
db = SessionDB(db_path=tmp_path / "state.db")
try:
yield db
finally:
db.close()
class TestGoalMigratesOnRotation:
def test_goal_follows_compression_rotation(self, tmp_path: Path):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_GOAL_ROT"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent)
# Set a persistent goal on the parent via the real persistence path.
with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path / ".hermes")}):
(tmp_path / ".hermes").mkdir(exist_ok=True)
import hermes_cli.goals as goals
goals._DB_CACHE.clear()
# Point the goal DB at the same state.db the agent uses.
with patch.object(goals, "_get_session_db", return_value=db):
goals.save_goal(parent, goals.GoalState(goal="finish the migration"))
agent._compress_context(_msgs(), "sys", approx_tokens=120_000)
child = agent.session_id
assert child != parent # rotation happened
migrated = goals.load_goal(child)
assert migrated is not None
assert migrated.goal == "finish the migration"
goals._DB_CACHE.clear()
class TestOrphanRollbackOnCreateFailure:
def test_rolls_back_to_parent_when_child_create_fails(self, tmp_path: Path):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ORPHAN_ROT"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent)
# Atomic publication failure must leave the live parent and caller's
# original list untouched even when a plugin compressor mutates in place.
original = _msgs()
def _mutating_compress(live_messages, **_kwargs):
live_messages[:] = [
{"role": "user", "content": "mutated compacted snapshot"}
]
return live_messages
agent.context_compressor.compress.side_effect = _mutating_compress
def _boom(*a, **k):
raise RuntimeError("simulated atomic publication failure")
with patch.object(db, "publish_compression_child", side_effect=_boom):
returned, _system_prompt = agent._compress_context(
original, "sys", approx_tokens=120_000
)
assert agent.session_id == parent
assert [(m["role"], m["content"]) for m in returned] == [
(m["role"], m["content"]) for m in _msgs()
]
assert returned is original
parent_row = db.get_session(parent)
assert parent_row is not None
assert parent_row["ended_at"] is None
assert db.find_live_compression_child(parent) is None
class TestWorkspaceMetadataFollowsRotation:
def test_child_row_inherits_cwd_repo_and_origin_on_rotation(self, tmp_path: Path):
"""Behavioral #64709/#59527: drive the REAL compression rotation path
and assert the child session row carries the parent's workspace and
gateway-origin metadata, so the project sidebar entry and the peer
routing mapping both survive the compaction boundary."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_CWD_ROT"
db.create_session(
parent,
source="telegram",
user_id="u1",
session_key="telegram:u1:c1",
chat_id="c1",
chat_type="private",
)
db.update_session_cwd(
parent, "/work/repo", git_branch="main", git_repo_root="/work/repo"
)
agent = _build_agent_with_db(db, parent, platform="telegram")
agent._compress_context(_msgs(), "sys", approx_tokens=120_000)
child = agent.session_id
assert child != parent # rotation happened
row = db.get_session(child)
assert row is not None
assert row["parent_session_id"] == parent
# Workspace metadata (#64709): sidebar grouping keys must survive.
assert row["cwd"] == "/work/repo"
assert row["git_repo_root"] == "/work/repo"
assert row["git_branch"] == "main"
# Gateway origin metadata (#59527): routing keys must survive even if
# the gateway never gets to re-record the peer (crash window).
assert row["session_key"] == "telegram:u1:c1"
assert row["chat_id"] == "c1"
assert row["chat_type"] == "private"
assert row["user_id"] == "u1"
class TestRotationChildFlushDedup:
def test_summary_handoff_row_is_persisted_once_in_child(
self, tmp_path: Path
):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_LIVE_USER"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
messages = [*loaded, {"role": "user", "content": "live question"}]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(messages) - 1
agent.context_compressor.compress.return_value = [
{"role": "assistant", "content": "[CONTEXT COMPACTION] summary"},
]
returned, _ = agent._compress_context(messages, "sys", approx_tokens=120_000)
assert any(
isinstance(msg, dict)
and msg.get("content") == "[CONTEXT COMPACTION] summary"
and msg.get(_DB_PERSISTED_MARKER)
for msg in returned
)
assert any(
isinstance(msg, dict)
and msg.get("content") == "live question"
and msg.get(_DB_PERSISTED_MARKER)
for msg in returned
)
def test_rotation_flush_of_original_live_list_keeps_user_once_when_handoff_already_contains_user(
self, tmp_path: Path
):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_ORIGINAL_LIVE"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
live_user = {
"role": "user",
"content": "live question",
"timestamp": 1234.5,
}
messages = [*loaded, live_user]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(messages) - 1
agent.context_compressor.compress.return_value = [
{"role": "assistant", "content": "[CONTEXT COMPACTION] summary"},
copy.deepcopy(live_user),
]
real_flush = agent._flush_messages_to_session_db
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
returned, _ = agent._compress_context(
messages, "sys", approx_tokens=120_000
)
assert agent.session_id != parent
assert _DB_PERSISTED_MARKER in live_user
real_flush(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
assert _count_rows(child_rows, content="live question", role="user") == 1
assert _count_rows(
child_rows, content="[CONTEXT COMPACTION] summary", role="assistant"
) == 1
def test_failed_publish_leaves_live_user_unmarked_for_later_flush(
self, tmp_path: Path
):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_PUBLISH_FAIL"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
messages = [*loaded, {"role": "user", "content": "live question"}]
live_user = messages[-1]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(messages) - 1
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "assistant", "content": "tail"},
]
real_flush = agent._flush_messages_to_session_db
with patch.object(
db,
"publish_compression_child",
side_effect=RuntimeError("simulated publish failure"),
):
returned, _ = agent._compress_context(
messages, "sys", approx_tokens=120_000
)
assert _DB_PERSISTED_MARKER not in live_user
retry_session = "PARENT_ROT_PUBLISH_RETRY"
db.create_session(retry_session, source="cli")
agent.session_id = retry_session
real_flush([live_user])
retry_rows = db.get_messages_as_conversation(
retry_session, include_inactive=True
)
assert _count_rows(retry_rows, content="live question", role="user") == 1
def test_mid_tool_loop_rows_do_not_duplicate_after_failed_parent_flush(
self, tmp_path: Path
):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_TOOL_LOOP"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
assistant_turn = {
"role": "assistant",
"content": "",
"tool_calls": [
{
"id": "call-1",
"type": "function",
"function": {"name": "lookup", "arguments": "{}"},
}
],
}
tool_turn = {
"role": "tool",
"tool_call_id": "call-1",
"content": "tool result",
}
messages = [
*loaded,
{"role": "user", "content": "live tool question"},
assistant_turn,
tool_turn,
]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(loaded)
agent.context_compressor.compress.return_value = [
copy.deepcopy(assistant_turn),
copy.deepcopy(tool_turn),
]
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
returned, _ = agent._compress_context(
messages, "sys", approx_tokens=120_000
)
agent._flush_messages_to_session_db(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
assert _count_rows(
child_rows, content="live tool question", role="user"
) == 1
assert _count_rows(child_rows, content="tool result", role="tool") == 1
def test_mid_tool_loop_rows_do_not_duplicate_after_failed_parent_flush_direct_path(
self, tmp_path: Path
):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_TOOL_LOOP_DIRECT"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
assistant_turn = {
"role": "assistant",
"content": "",
"tool_calls": [
{
"id": "call-1",
"type": "function",
"function": {"name": "lookup", "arguments": "{}"},
}
],
}
tool_turn = {
"role": "tool",
"tool_call_id": "call-1",
"content": "tool result",
}
messages = [
*loaded,
{"role": "user", "content": "live tool question"},
assistant_turn,
tool_turn,
]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(loaded)
agent.context_compressor.compress.return_value = [
copy.deepcopy(assistant_turn),
copy.deepcopy(tool_turn),
]
real_flush = agent._flush_messages_to_session_db
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
assert agent.session_id != parent
real_flush(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
assert _count_rows(
child_rows, content="live tool question", role="user"
) == 1
assert _count_rows(child_rows, content="", role="assistant") == 1
assert _count_rows(child_rows, content="tool result", role="tool") == 1
def test_timestampless_duplicate_content_rows_are_all_stamped(
self, tmp_path: Path
):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_DUPLICATE_CONTENT"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
assistant_turn = {
"role": "assistant",
"content": "",
"tool_calls": [
{
"id": "call-1",
"type": "function",
"function": {"name": "lookup", "arguments": "{}"},
}
],
}
tool_turn = {
"role": "tool",
"tool_call_id": "call-1",
"content": "tool result",
}
messages = [
*loaded,
{"role": "user", "content": "live tool question"},
assistant_turn,
copy.deepcopy(assistant_turn),
tool_turn,
copy.deepcopy(tool_turn),
]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(loaded)
agent.context_compressor.compress.return_value = [
copy.deepcopy(assistant_turn),
copy.deepcopy(tool_turn),
]
real_flush = agent._flush_messages_to_session_db
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
real_flush(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
assert _count_rows(
child_rows, content="live tool question", role="user"
) == 1
assert _count_rows(child_rows, content="", role="assistant") == 1
assert _count_rows(child_rows, content="tool result", role="tool") == 1
def test_rotation_stamps_diverged_session_messages_entry_only_when_it_matches(
self, tmp_path: Path
):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_SESSION_MESSAGES_DIVERGE"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
messages = [*loaded, {"role": "user", "content": "live question"}]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(messages) - 1
agent._session_messages = [
*loaded,
{"role": "user", "content": "different live question"},
]
agent.context_compressor.compress.return_value = [
{"role": "assistant", "content": "[CONTEXT COMPACTION] summary"},
]
returned, _ = agent._compress_context(messages, "sys", approx_tokens=120_000)
agent._flush_messages_to_session_db(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
assert _count_rows(child_rows, content="live question", role="user") == 1
assert _DB_PERSISTED_MARKER in messages[-1]
assert _DB_PERSISTED_MARKER not in agent._session_messages[-1]
# ------------------------------------------------------------------
# Item 2 review fixes — symmetric identity validation on the primary
# stamp. The guard stamps the anchor-source row (the last real user
# message in `messages`, the row the published child actually
# represents), NEVER an index that may have drifted, and mirrors the
# twin (`_session_messages`) by scoped identity against that anchor
# source with a marker-independent exact-hit two-phase scan.
# ------------------------------------------------------------------
def test_rotation_never_stamps_drifted_user_role_neighbor(
self, tmp_path: Path
):
"""A user-role neighbor at a drifted index must not be stamped."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_DRIFTED_NEIGHBOR"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
messages = [
*loaded,
{"role": "user", "content": "live question"},
{
"role": "user",
"content": "drifted neighbor",
"_todo_snapshot_synthetic": True,
},
]
agent = _build_agent_with_db(db, parent)
# Index drifted onto the synthetic user-role neighbor (the reanchor
# fallback / stale-index failure shape the guard must not trust).
agent._persist_user_message_idx = len(messages) - 1
agent.context_compressor.compress.return_value = [
{"role": "assistant", "content": "[CONTEXT COMPACTION] summary"},
]
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
# The drifted neighbor is not the row the child represents.
assert _DB_PERSISTED_MARKER not in messages[-1]
# The anchor source (the real live question) is stamped.
assert _DB_PERSISTED_MARKER in messages[-2]
def test_rotation_drifted_index_does_not_duplicate_live_question_in_child(
self, tmp_path: Path
):
"""Merged outcome + drifted index: real flush must not re-append the
live question standalone (the duplicate the PR eliminates)."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_DRIFTED_MERGED"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
messages = [
*loaded,
{"role": "user", "content": "live question"},
{
"role": "user",
"content": "drifted neighbor",
"_todo_snapshot_synthetic": True,
},
]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(messages) - 1
agent.context_compressor.compress.return_value = [
{
"role": "user",
"content": "handoff scaffolding",
"_todo_snapshot_synthetic": True,
},
]
real_flush = agent._flush_messages_to_session_db
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
real_flush(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
# No standalone "live question" row — the merged handoff already
# represents it.
assert _count_rows(child_rows, content="live question") == 0
assert (
_count_rows(
child_rows, content="live question\n\nhandoff scaffolding"
)
== 1
)
def test_merged_outcome_still_stamps_live_question(self, tmp_path: Path):
"""Constraint: the guard must not break the legitimate merged stamp."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_MERGED_LIVE"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
messages = [*loaded, {"role": "user", "content": "live question"}]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(messages) - 1
agent.context_compressor.compress.return_value = [
{
"role": "user",
"content": "scaffolding",
"_todo_snapshot_synthetic": True,
},
]
real_flush = agent._flush_messages_to_session_db
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
assert _DB_PERSISTED_MARKER in messages[-1]
real_flush(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
assert _count_rows(
child_rows, content="live question", role="user"
) == 0
assert (
_count_rows(child_rows, content="live question\n\nscaffolding")
== 1
)
def test_adoption_divergence_merged_stamps_both_views_and_no_duplicate(
self, tmp_path: Path
):
"""REAL adoption divergence: durable parent grows under the lease,
`messages` rebinds to the adopted snapshot while
`agent._session_messages` stays on the old live list, and the merged
handoff cannot be mirrored by the wrapper's scoped sync. Both views
must carry the marker and the real post-rotation flush over the old
live view must not re-append the live question standalone."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_ADOPT_DIVERGE"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
# (b) Old live list object kept alive; divergence set so the twin is
# the SAME object the guard scans (not a fresh copy).
loaded = db.get_messages_as_conversation(parent, include_inactive=True)
old_live_list = [
*loaded,
{"role": "user", "content": "live question", "timestamp": 1234.5},
]
agent = _build_agent_with_db(db, parent)
agent._session_messages = old_live_list
assert agent._session_messages is old_live_list
# (c) The stale snapshot passed to _compress_context is a separate
# object (the production frontend-snapshot shape).
stale_snapshot = [
{"role": "user", "content": "persisted question"},
{"role": "assistant", "content": "persisted answer"},
]
assert stale_snapshot is not agent._session_messages
# (d) Pin the initial persist-index state: production "no known
# un-persisted tail" shape, so the real code takes the adopt-directly
# branch (:2994-3001) and the pre-adoption flush (:2988) is provably
# never attempted (no fixture flush can mask the divergence).
agent._persist_user_message_idx = None
assert agent._persist_user_message_idx is None
# Grow the DB AFTER the snapshot is taken so the REAL adoption
# condition (durable parent longer than the caller snapshot) fires.
db.append_message(parent, "user", "live question")
durable_check = db.get_messages_as_conversation(parent)
assert len(durable_check) == 3 > len(stale_snapshot) == 2
# Sync the twin's timestamp to the committed row so the guard's
# exact-timestamp twin scan matches the adopted anchor.
old_live_list[-1]["timestamp"] = durable_check[-1]["timestamp"]
agent.context_compressor.compress.return_value = [
{
"role": "user",
"content": "handoff scaffolding",
"_todo_snapshot_synthetic": True,
},
]
# Phase-keyed flush failure: fail ONLY the pre-publish flush (:3780);
# a blanket failure would not distinguish the phases and a masked
# pre-adoption flush would hide the divergence.
flush_attempts = []
def _fail_only_prepublish_flush(messages_arg, **kwargs):
flush_attempts.append((messages_arg, kwargs))
raise RuntimeError("simulated pre-publish flush failure")
real_flush = agent._flush_messages_to_session_db
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=_fail_only_prepublish_flush,
):
_returned, _ = agent._compress_context(
stale_snapshot,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
# The ONLY internal flush was the single pre-publish one.
assert len(flush_attempts) == 1
# (e) Identity and shape asserts BEFORE markers: adoption fired, the
# divergence is preserved, the persist index was rebound out of range.
adopted = agent.context_compressor.compress.call_args.args[0]
assert adopted is not stale_snapshot
assert adopted is not agent._session_messages
assert agent._session_messages is old_live_list
assert agent._persist_user_message_idx == len(adopted)
assert adopted[-1]["role"] == "user"
assert adopted[-1]["content"] == "live question"
assert adopted[-1].get("timestamp") is not None
assert old_live_list[-1]["content"] == "live question"
assert (
old_live_list[-1].get("timestamp") == adopted[-1].get("timestamp")
)
# (f) Markers on BOTH views. Note: the adopted view's rows are
# "born durable" (hermes_state stamps _DB_PERSISTED_MARKER on rows
# materialized from the DB), so the adopted assert holds even
# pre-fix; the DISCRIMINATING assert is the twin's — the old live
# view is a constructed list the production code only stamps via
# the guard's twin scan (pre-fix it stays unstamped → FAIL).
assert _DB_PERSISTED_MARKER in adopted[-1]
assert _DB_PERSISTED_MARKER in old_live_list[-1]
real_flush(agent._session_messages, conversation_history=loaded)
# (g) No standalone duplicate by EXACT SCOPED IDENTITY (content +
# timestamp), and exactly one merged row.
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
assert not any(
row.get("content") == "live question"
and row.get("timestamp") == adopted[-1].get("timestamp")
for row in child_rows
)
assert (
_count_rows(
child_rows, content="live question\n\nhandoff scaffolding"
)
== 1
)
def test_rotation_stamps_anchor_source_when_reanchor_fallback_rewrote_turn(
self, tmp_path: Path
):
"""REAL reanchor drift: reanchor_current_turn_user_idx's last-user
fallback lands on a trailing production-shaped todo-snapshot row
(index 2) while the anchor-source scan selects the rewritten carrier
(index 1). The stamp must land on the carrier, not the todo row."""
from agent.turn_context import reanchor_current_turn_user_idx
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_REANCHOR_DRIFT"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "old durable")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
# Pinned production-shaped fixture (plan §3.5): the trailing row is
# the todo-snapshot shape compress_context appends at :3484-3489.
# The reanchor helper's last-user-originated fallback lands on it
# (index 2) while the anchor-source scan skips it (synthetic flag)
# and selects the rewritten carrier (index 1) — the drift is real.
# Deliberately a 3-row fixture (NOT prefixed with `loaded`): the
# pinned drift values below were verified against the real
# reanchor_current_turn_user_idx on this shape.
messages = [
{"role": "user", "content": "old durable"},
{"role": "user", "content": "current ask\n\n[merged summary]"},
{
"role": "user",
"content": "Current todos:\n- [ ] leftover",
"_todo_snapshot_synthetic": True,
},
]
# Drift-first assertions: prove the reanchor index and the anchor
# source diverge BEFORE any stamp behavior is checked.
drifted = reanchor_current_turn_user_idx(messages, "current ask")
anchor_source = max(
i for i, m in enumerate(messages) if _is_real_user_message(m)
)
assert drifted == 2
assert anchor_source == 1
assert drifted != anchor_source
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = drifted
agent.context_compressor.compress.return_value = [
{
"role": "user",
"content": "handoff scaffolding",
"_todo_snapshot_synthetic": True,
},
]
real_flush = agent._flush_messages_to_session_db
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
# The carrier (anchor source) is stamped; the todo-snapshot row the
# drifted index points at is NOT.
assert _DB_PERSISTED_MARKER in messages[1]
assert _DB_PERSISTED_MARKER not in messages[2]
real_flush(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
assert (
_count_rows(
child_rows,
content="current ask\n\n[merged summary]",
role="user",
)
== 0
)
assert (
_count_rows(
child_rows,
content=(
"current ask\n\n[merged summary]\n\nhandoff scaffolding"
),
)
== 1
)
def test_no_real_user_anchor_guard_not_entered(self, tmp_path: Path):
"""Negative regression: placeholder_appended/already_present must not
enter the anchor-source guard branch — no exception, rotation happens,
no live row outside the handoff carries the marker."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_NO_REAL_ANCHOR"
db.create_session(parent, source="cli")
# All-user-synthetic transcript with NO real user. The rows carry
# enough content that compression shrinks the transcript (a single
# short synthetic row trips the would-grow gate and aborts rotation,
# which would make this a fixture failure, not a regression).
messages = [
{
"role": "user",
"content": f"synthetic scaffolding block {i} with enough "
f"content to keep the compressed transcript smaller",
"_todo_snapshot_synthetic": True,
}
for i in range(6)
]
agent = _build_agent_with_db(db, parent)
agent.context_compressor.compress.return_value = [
{"role": "assistant", "content": "[CONTEXT COMPACTION] summary"},
]
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
# Rotation happened; no live row carries the marker.
assert agent.session_id != parent
assert _DB_PERSISTED_MARKER not in messages[0]
def test_list_content_merged_outcome_still_stamps_live_question(
self, tmp_path: Path
):
"""Constraint (reviewer list-content requirement): list-content anchor
merged via the list branch (anchor_parts + target_parts) must still
stamp the live row and not duplicate it."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_LIST_MERGED"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
messages = [
*loaded,
{
"role": "user",
"content": [{"type": "text", "text": "live question"}],
},
]
agent = _build_agent_with_db(db, parent)
agent._persist_user_message_idx = len(messages) - 1
agent.context_compressor.compress.return_value = [
{
"role": "user",
"content": [{"type": "text", "text": "scaffolding"}],
"_todo_snapshot_synthetic": True,
},
]
real_flush = agent._flush_messages_to_session_db
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
assert _DB_PERSISTED_MARKER in messages[-1]
real_flush(messages, conversation_history=loaded)
child_rows = db.get_messages_as_conversation(
agent.session_id, include_inactive=True
)
# No standalone live-question row (the flush stores list content
# flattened to its text join, so match the flattened string too).
assert _count_rows(child_rows, content="live question") == 0
assert (
_count_rows(
child_rows,
content=[{"type": "text", "text": "live question"}],
)
== 0
)
# Exactly one merged row with the concatenated parts list.
assert (
_count_rows(
child_rows,
content=[
{"type": "text", "text": "live question"},
{"type": "text", "text": "scaffolding"},
],
)
== 1
)
def test_already_stamped_exact_twin_suppresses_broad_fallback(
self, tmp_path: Path
):
"""Two-phase edge (reviewer scenario): an already-stamped exact twin
must still count as an exact hit (marker-INDEPENDENT), suppressing the
broad fallback so a timestamp-less same-content historical row is NOT
stamped as the anchor's twin."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ROT_STAMPED_TWIN"
db.create_session(parent, source="cli")
db.append_message(parent, "user", "persisted question")
db.append_message(parent, "assistant", "persisted answer")
loaded = db.get_messages_as_conversation(parent)
messages = [
*loaded,
{
"role": "user",
"content": "live question",
"timestamp": "2026-01-01T00:00:00Z",
},
]
agent = _build_agent_with_db(db, parent)
# Deliberately do NOT set _persist_user_message_idx: the guard must
# not trust a persist index at all.
agent._session_messages = [
{
"role": "user",
"content": "live question",
"timestamp": "2026-01-01T00:00:00Z",
_DB_PERSISTED_MARKER: True,
},
{"role": "user", "content": "live question"},
]
agent.context_compressor.compress.return_value = [
{
"role": "user",
"content": "handoff scaffolding",
"_todo_snapshot_synthetic": True,
},
]
with patch.object(
agent,
"_flush_messages_to_session_db",
side_effect=RuntimeError("simulated parent flush failure"),
):
_returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
commit_fence=CompressionCommitFence(),
)
# The timestamp-less ambiguous row must NOT be stamped as a twin.
assert _DB_PERSISTED_MARKER not in agent._session_messages[1]
# The already-stamped exact twin keeps its marker (idempotent).
assert _DB_PERSISTED_MARKER in agent._session_messages[0]
# The primary anchor is still stamped.
assert _DB_PERSISTED_MARKER in messages[-1]
class TestPlatformForwardedAtBoundary:
def test_on_session_start_receives_platform(self, tmp_path: Path):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_PLATFORM_ROT"
db.create_session(parent, source="telegram")
agent = _build_agent_with_db(db, parent, platform="telegram")
agent._compress_context(_msgs(), "sys", approx_tokens=120_000)
# The boundary notify must forward the platform so context-engine
# plugins don't fall back to source=unknown (#27633).
calls = [c for c in agent.context_compressor.on_session_start.call_args_list]
assert calls, "on_session_start was not called at the boundary"
kwargs = calls[-1].kwargs
assert kwargs.get("platform") == "telegram"
assert kwargs.get("boundary_reason") == "compression"
class TestFallbackStreakFollowsRotation:
def test_fallback_boundary_persists_on_child_session(self, tmp_path: Path):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_FALLBACK_ROT"
db.create_session(parent, source="telegram")
with patch(
"agent.context_compressor.get_model_context_length",
return_value=100_000,
):
compressor = ContextCompressor(
model="test/model",
threshold_percent=0.85,
protect_first_n=2,
protect_last_n=2,
quiet_mode=True,
)
compressor.bind_session_state(db, parent)
# A fallback streak must survive the session-id rotation itself. The
# boundary then records the just-completed fallback on the child row.
compressor.record_completed_compaction(used_fallback=True)
assert db.get_compression_fallback_streak(parent) == 1
db.create_session(
"CHILD_FALLBACK_ROT",
source="telegram",
parent_session_id=parent,
)
compressor.on_session_start(
"CHILD_FALLBACK_ROT",
session_db=db,
boundary_reason="compression",
old_session_id=parent,
)
assert compressor._fallback_compression_streak == 1
compressor.record_completed_compaction(used_fallback=True)
assert compressor._fallback_compression_streak == 2
assert db.get_compression_fallback_streak("CHILD_FALLBACK_ROT") == 2
resumed = ContextCompressor(
model="test/model",
threshold_percent=0.85,
protect_first_n=2,
protect_last_n=2,
quiet_mode=True,
)
resumed.bind_session_state(db, "CHILD_FALLBACK_ROT")
assert resumed._fallback_compression_streak == 2
def test_real_rotation_records_fallback_after_lifecycle_rebind(self, tmp_path: Path):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_REAL_FALLBACK_ROT"
db.create_session(parent, source="telegram")
agent = _build_agent_with_db(db, parent, platform="telegram")
with patch(
"agent.context_compressor.get_model_context_length",
return_value=100_000,
):
compressor = ContextCompressor(
model="test/model",
threshold_percent=0.85,
protect_first_n=2,
protect_last_n=2,
quiet_mode=True,
)
compressor.bind_session_state(db, parent)
compressed = [
{"role": "user", "content": "[CONTEXT COMPACTION] fallback"},
{"role": "assistant", "content": "tail"},
]
def _fallback_compress(*_args, **_kwargs):
compressor._last_summary_error = "empty summary"
compressor._last_summary_fallback_used = True
compressor._last_compression_made_progress = True
return compressed
with patch.object(
compressor,
"compress",
side_effect=_fallback_compress,
):
compressor.compression_count = 1
setattr(agent, "context_compressor", compressor)
agent._compress_context(_msgs(), "sys", approx_tokens=120_000)
child = getattr(agent, "session_id")
assert child != parent
assert compressor._fallback_compression_streak == 1
assert db.get_compression_fallback_streak(child) == 1
class TestAutomaticCompressionStateRefreshAfterLock:
def test_prebound_agent_rejects_parent_rotated_before_lock_acquisition(
self,
refresh_state_db: SessionDB,
):
db = refresh_state_db
parent_id = "STALE_ROTATED_PARENT"
child_id = "CANONICAL_COMPRESSION_CHILD"
db.create_session(parent_id, source="telegram")
agent = _build_agent_with_db(db, parent_id, platform="telegram")
compressor = _bound_context_compressor(db, parent_id)
# A competing path completes rotation after this call's initial checks
# but before it acquires the parent lock.
real_acquire = db.try_acquire_compression_lock
def _acquire_after_rotation(*args, **kwargs):
db.end_session(parent_id, "compression")
db.create_session(
child_id,
source="telegram",
parent_session_id=parent_id,
)
return real_acquire(*args, **kwargs)
db.try_acquire_compression_lock = _acquire_after_rotation
agent.context_compressor = compressor
agent.compression_in_place = False
agent._compression_feasibility_checked = True
messages = _msgs()
with patch.object(
compressor,
"compress",
side_effect=AssertionError("stale parent was compressed again"),
) as compress:
returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
force=True,
)
children = db._conn.execute(
"SELECT id FROM sessions WHERE parent_session_id = ?",
(parent_id,),
).fetchall()
assert returned is messages
assert agent.session_id == parent_id
assert [row["id"] for row in children] == [child_id]
compress.assert_not_called()
assert db.get_compression_lock_holder(parent_id) is None
def test_prebound_agent_drops_stale_cooldown_before_initial_gate(
self,
refresh_state_db: SessionDB,
):
db = refresh_state_db
session_id = "CLEARED_COMPRESSION_COOLDOWN"
db.create_session(session_id, source="telegram")
db.record_compression_failure_cooldown(
session_id,
time.time() + 60,
"rate limited",
)
agent = _build_agent_with_db(db, session_id, platform="telegram")
compressor = _bound_context_compressor(db, session_id)
assert compressor.get_active_compression_failure_cooldown() is not None
# A successful forced retry on another agent clears the durable row.
# This prebound compressor must not keep honoring its stale local timer.
db.clear_compression_failure_cooldown(session_id)
agent.context_compressor = compressor
agent.compression_in_place = True
agent._compression_feasibility_checked = True
messages = _msgs()
with patch.object(compressor, "compress", return_value=messages) as compress:
returned, _ = agent._compress_context(
messages,
"sys",
approx_tokens=120_000,
)
assert returned is messages
assert compressor.get_active_compression_failure_cooldown() is None
compress.assert_called_once()
assert db.get_compression_lock_holder(session_id) is None
class TestGateLevelGuardRefresh:
"""The unblock direction must work from the should_compress() pre-gates.
compress_context refreshes durable guards internally, but the automatic
paths (preflight/turn gates) consult should_compress() first — if a stale
in-memory fallback streak (which has no expiry timer) blocks there, the
refresh inside compress_context is never reached and the agent stays
blocked forever.
"""
def test_should_compress_unblocks_after_another_agent_clears_streak(
self,
refresh_state_db: SessionDB,
):
db = refresh_state_db
session_id = "GATE_LEVEL_STREAK_CLEAR"
db.create_session(session_id, source="telegram")
db.set_compression_fallback_streak(session_id, 2)
compressor = _bound_context_compressor(db, session_id)
assert compressor._fallback_compression_streak == 2
# Another agent's healthy boundary clears the durable breaker.
db.set_compression_fallback_streak(session_id, 0)
assert compressor.should_compress(10**9) is True
assert compressor._fallback_compression_streak == 0
def test_unblocked_gate_does_not_touch_the_db(
self,
refresh_state_db: SessionDB,
):
db = refresh_state_db
session_id = "GATE_LEVEL_HOT_PATH"
db.create_session(session_id, source="telegram")
compressor = _bound_context_compressor(db, session_id)
with patch.object(
compressor,
"_refresh_durable_guards",
side_effect=AssertionError("hot path must not refresh"),
):
assert compressor._automatic_compression_blocked() is False
class TestCooldownPersistFailureIsNotAClearedRow:
def test_refresh_keeps_local_cooldown_when_persist_failed(
self,
refresh_state_db: SessionDB,
):
"""An empty durable row is not evidence of a clear when OUR write failed.
_record_compression_failure_cooldown sets the local timer first and
persists best-effort. If that persist failed, a later refresh=True
finding no DB row must keep the local cooldown (otherwise the #11529
thrash guard silently re-opens), until it expires or a successful
DB round-trip supersedes it.
"""
db = refresh_state_db
session_id = "PERSIST_FAILED_COOLDOWN"
db.create_session(session_id, source="telegram")
compressor = _bound_context_compressor(db, session_id)
with patch.object(
db,
"record_compression_failure_cooldown",
side_effect=Exception("disk full"),
):
compressor._record_compression_failure_cooldown(60, "rate limited")
assert compressor._cooldown_persist_failed is True
state = compressor.get_active_compression_failure_cooldown(refresh=True)
assert state is not None
assert compressor._summary_failure_cooldown_until > 0
assert compressor._automatic_compression_blocked() is True
# Once a durable round-trip succeeds, the DB is authoritative again.
compressor._record_compression_failure_cooldown(30, "retry later")
assert compressor._cooldown_persist_failed is False
db.clear_compression_failure_cooldown(session_id)
assert compressor.get_active_compression_failure_cooldown(refresh=True) is None
assert compressor._summary_failure_cooldown_until == 0.0
def test_ineffective_count_block_honors_durable_clear_by_another_agent(
self,
refresh_state_db: SessionDB,
):
"""The ineffective-strike counter is durable (#54923): a block owed to
it must re-read the DB so another agent's clear (a real usage reading
that dipped below the threshold) unblocks this compressor too."""
db = refresh_state_db
session_id = "INEFFECTIVE_DURABLE_BLOCK"
db.create_session(session_id, source="telegram")
db.set_compression_ineffective_count(session_id, 2)
compressor = _bound_context_compressor(db, session_id)
assert compressor._ineffective_compression_count == 2
assert compressor._automatic_compression_blocked() is True
# Another agent's real prompt reading dipped below the threshold and
# zeroed the durable counter.
db.set_compression_ineffective_count(session_id, 0)
assert compressor._automatic_compression_blocked() is False
assert compressor._ineffective_compression_count == 0
class TestTodoSnapshotMergedNotDuplicated:
"""Todo snapshots preserve tail content without duplicate user turns."""
def test_snapshot_merges_into_trailing_user(self, tmp_path: Path):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_TODO_MERGE"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent, platform="cli")
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "assistant", "content": "acknowledged"},
{"role": "user", "content": "tail"},
]
agent._todo_store._todos = [
{"id": "t1", "content": "task A", "status": "pending"}
]
agent._todo_store.format_for_injection = (
lambda: "## Current Tasks\n- [ ] task A"
)
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
assert len(compressed) == 3
tail = compressed[-1]
assert tail["role"] == "user"
assert "tail" in tail["content"]
assert "task A" in tail["content"]
assert not any(
previous.get("role") == current.get("role") == "user"
for previous, current in zip(compressed, compressed[1:])
)
def test_multimodal_snapshot_merge_is_persisted_in_place(self, tmp_path: Path):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_TODO_MULTIMODAL_INPLACE"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent, platform="cli")
agent.compression_in_place = True
original_parts = [
{"type": "text", "text": "last user msg"},
{
"type": "image_url",
"image_url": {"url": "https://example.com/context.png"},
},
]
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "assistant", "content": "ok"},
{"role": "user", "content": list(original_parts)},
]
agent._todo_store._todos = [
{"id": "t1", "content": "inspect image", "status": "in_progress"}
]
agent._todo_store.format_for_injection = (
lambda: "## Current Tasks\n- [ ] inspect image"
)
# Input transcript must be large enough that the fake compressor's
# output is a genuine shrink — the no-growth commit guard refuses
# to persist a compression that grows the transcript.
input_msgs = [
{
"role": "user" if i % 2 == 0 else "assistant",
"content": f"m{i} " + "x" * 400,
}
for i in range(20)
]
compressed, _ = agent._compress_context(
input_msgs, "sys", approx_tokens=120_000
)
assert len(compressed) == 3
tail = compressed[-1]
assert tail["role"] == "user"
assert isinstance(tail["content"], list)
assert tail["content"][: len(original_parts)] == original_parts
assert any(
isinstance(part, dict) and "inspect image" in (part.get("text") or "")
for part in tail["content"]
)
assert not any(
previous.get("role") == current.get("role") == "user"
for previous, current in zip(compressed, compressed[1:])
)
db_msgs = db.get_messages(agent.session_id)
persisted_tail = db_msgs[-1]
assert persisted_tail["role"] == "user"
assert persisted_tail["content"][: len(original_parts)] == original_parts
assert any(
isinstance(part, dict) and "inspect image" in (part.get("text") or "")
for part in persisted_tail["content"]
)
assert not any(
previous.get("role") == current.get("role") == "user"
for previous, current in zip(db_msgs, db_msgs[1:])
)
class TestTodoSnapshotScaffoldingTails:
"""Scaffolding tails must never absorb the todo snapshot (#69292)."""
@staticmethod
def _agent_with_todo(db: SessionDB, session_id: str, tail: dict):
db.create_session(session_id, source="cli")
agent = _build_agent_with_db(db, session_id, platform="cli")
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "assistant", "content": "acknowledged"},
tail,
]
agent._todo_store.write(
[{"id": "t1", "content": "task A", "status": "pending"}]
)
return agent
def test_previously_merged_snapshot_is_stripped_before_reinjection(
self, tmp_path: Path
):
from tools.todo_tool import TODO_INJECTION_HEADER
previously_merged = (
"please fix the login bug\n\n"
f"{TODO_INJECTION_HEADER}\n- [ ] t0. old finished task (pending)"
)
db = SessionDB(db_path=tmp_path / "state.db")
agent = self._agent_with_todo(
db,
"PARENT_TODO_RESTRIP",
{
"role": "user",
"content": previously_merged,
"api_content": "stale wire copy containing the old task",
},
)
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
tail = compressed[-1]
assert tail["role"] == "user"
assert "please fix the login bug" in tail["content"]
assert "task A" in tail["content"]
assert "old finished task" not in tail["content"]
assert tail["content"].count(TODO_INJECTION_HEADER) == 1
assert "api_content" not in tail
assert not any(
previous.get("role") == current.get("role") == "user"
for previous, current in zip(compressed, compressed[1:])
)
def test_empty_todo_store_injects_nothing(self, tmp_path: Path):
from tools.todo_tool import TODO_INJECTION_HEADER
db = SessionDB(db_path=tmp_path / "state.db")
session_id = "PARENT_TODO_EMPTY"
db.create_session(session_id, source="cli")
agent = _build_agent_with_db(db, session_id, platform="cli")
expected = [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "assistant", "content": "acknowledged"},
{"role": "user", "content": "tail"},
]
agent.context_compressor.compress.return_value = [
dict(message) for message in expected
]
agent._todo_store.write(
[{"id": "t1", "content": "done thing", "status": "completed"}]
)
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
assert [
{
k: v
for k, v in m.items()
if k not in {"_row_id", _DB_PERSISTED_MARKER}
}
for m in compressed
] == expected
assert not any(
TODO_INJECTION_HEADER in str(message.get("content") or "")
for message in compressed
)
def test_empty_todo_store_removes_previous_compaction_snapshot(
self, tmp_path: Path
):
"""Completed items make the store authoritative and clear old work."""
from tools.todo_tool import TODO_INJECTION_HEADER
db = SessionDB(db_path=tmp_path / "state.db")
session_id = "PARENT_TODO_CLEARED"
db.create_session(session_id, source="cli")
agent = _build_agent_with_db(db, session_id, platform="cli")
stale_task = "- [ ] stale-task. This task was already cleared"
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "assistant", "content": "acknowledged"},
{
"role": "user",
"content": (
"Keep this user context.\n\n"
f"{TODO_INJECTION_HEADER}\n{stale_task}"
),
"api_content": "stale wire copy containing the old snapshot",
},
]
agent._todo_store.write(
[{"id": "done", "content": "done thing", "status": "completed"}]
)
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
combined = "\n".join(str(m.get("content") or "") for m in compressed)
assert "Keep this user context." in combined
assert TODO_INJECTION_HEADER not in combined
assert stale_task not in combined
retained = next(
message
for message in compressed
if "Keep this user context." in str(message.get("content") or "")
)
assert "api_content" not in retained
def test_cancelled_only_store_is_authoritative(self, tmp_path: Path):
"""Cancelled work retires the old snapshot just like completed work."""
from tools.todo_tool import TODO_INJECTION_HEADER
db = SessionDB(db_path=tmp_path / "state.db")
session_id = "PARENT_TODO_CANCELLED"
db.create_session(session_id, source="cli")
agent = _build_agent_with_db(db, session_id, platform="cli")
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "Keep the request"},
{"role": "assistant", "content": "acknowledged"},
{
"role": "user",
"content": f"{TODO_INJECTION_HEADER}\n- [ ] obsolete task",
"_todo_snapshot_synthetic": True,
},
]
agent._todo_store.write(
[{"id": "nope", "content": "obsolete task", "status": "cancelled"}]
)
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
assert [message.get("role") for message in compressed] == [
"user",
"assistant",
]
assert all(
TODO_INJECTION_HEADER not in str(message.get("content") or "")
for message in compressed
)
def test_structured_snapshot_only_tail_is_removed(self, tmp_path: Path):
"""A flagged list row is removable only when no other part remains."""
from tools.todo_tool import TODO_INJECTION_HEADER
db = SessionDB(db_path=tmp_path / "state.db")
session_id = "PARENT_TODO_STRUCTURED_ONLY"
db.create_session(session_id, source="cli")
agent = _build_agent_with_db(db, session_id, platform="cli")
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "Keep the request"},
{"role": "assistant", "content": "acknowledged"},
{
"role": "user",
"content": [
{
"type": "text",
"text": f"{TODO_INJECTION_HEADER}\n- [ ] stale task",
}
],
"_todo_snapshot_synthetic": True,
},
]
agent._todo_store.write(
[{"id": "done", "content": "stale task", "status": "completed"}]
)
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
assert [message.get("role") for message in compressed] == [
"user",
"assistant",
]
def test_non_tail_snapshot_deletion_repairs_assistant_alternation(
self, tmp_path: Path
):
from tools.todo_tool import TODO_INJECTION_HEADER
db = SessionDB(db_path=tmp_path / "state.db")
session_id = "PARENT_TODO_MIDDLE"
db.create_session(session_id, source="cli")
agent = _build_agent_with_db(db, session_id, platform="cli")
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "Keep the request"},
{
"role": "assistant",
"content": "before snapshot",
"api_content": "stale assistant wire copy",
},
{
"role": "user",
"content": f"{TODO_INJECTION_HEADER}\n- [ ] stale task",
"_todo_snapshot_synthetic": True,
},
{"role": "assistant", "content": "after snapshot"},
{"role": "user", "content": "new request"},
]
agent._todo_store.write(
[{"id": "done", "content": "stale task", "status": "completed"}]
)
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
assert [message.get("role") for message in compressed] == [
"user",
"assistant",
"user",
]
repaired = compressed[1]
assert "before snapshot" in repaired["content"]
assert "after snapshot" in repaired["content"]
assert "api_content" not in repaired
assert not any(
previous.get("role") == current.get("role")
for previous, current in zip(compressed, compressed[1:])
)
def test_multimodal_content_survives_and_synthetic_provenance_clears(
self, tmp_path: Path
):
from tools.todo_tool import TODO_INJECTION_HEADER
db = SessionDB(db_path=tmp_path / "state.db")
session_id = "PARENT_TODO_MULTIMODAL_RETIRE"
db.create_session(session_id, source="cli")
agent = _build_agent_with_db(db, session_id, platform="cli")
surviving_parts = [
{"type": "text", "text": "Keep this caption"},
{
"type": "image_url",
"image_url": {"url": "https://example.com/context.png"},
},
{"type": "input_audio", "input_audio": {"data": "audio-data"}},
]
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "summary"},
{"role": "assistant", "content": "acknowledged"},
{
"role": "user",
"content": surviving_parts
+ [
{
"type": "text",
"text": f"{TODO_INJECTION_HEADER}\n- [ ] stale task",
}
],
"api_content": "stale wire copy containing the snapshot",
"_todo_snapshot_synthetic": True,
"unrelated_metadata": "keep-me",
},
]
agent._todo_store.write(
[{"id": "done", "content": "stale task", "status": "completed"}]
)
input_msgs = [
{
"role": "user" if index % 2 == 0 else "assistant",
"content": f"message {index} " + "x" * 1000,
}
for index in range(40)
]
compressed, _ = agent._compress_context(
input_msgs, "sys", approx_tokens=120_000
)
retained = next(
message for message in compressed if isinstance(message.get("content"), list)
)
assert retained["content"] == surviving_parts
assert retained["unrelated_metadata"] == "keep-me"
assert "api_content" not in retained
assert "_todo_snapshot_synthetic" not in retained
@pytest.mark.parametrize("authority_mode", ["missing", "raises"])
def test_unknown_store_authority_preserves_snapshot(
self, tmp_path: Path, authority_mode: str
):
"""Legacy or broken stores fail conservative, never erasing pending work."""
from tools.todo_tool import TODO_INJECTION_HEADER
db = SessionDB(db_path=tmp_path / "state.db")
session_id = f"PARENT_TODO_COMPAT_{authority_mode.upper()}"
db.create_session(session_id, source="telegram")
agent = _build_agent_with_db(db, session_id, platform="telegram")
pending_task = "- [ ] pending-task. Preserve conservatively"
agent.context_compressor.compress.return_value = [
{"role": "user", "content": "Keep the request"},
{"role": "assistant", "content": "acknowledged"},
{
"role": "user",
"content": f"{TODO_INJECTION_HEADER}\n{pending_task}",
"_todo_snapshot_synthetic": True,
},
]
class LegacyStore:
def format_for_injection(self):
return None
store = LegacyStore()
if authority_mode == "raises":
store.has_items = MagicMock(side_effect=RuntimeError("store unavailable"))
agent._todo_store = store
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
combined = "\n".join(str(message.get("content") or "") for message in compressed)
assert TODO_INJECTION_HEADER in combined
assert pending_task in combined
def test_unhydrated_empty_todo_store_preserves_pending_snapshot(
self, tmp_path: Path
):
"""A fresh empty store must not erase pending work retained by compression."""
from tools.todo_tool import TODO_INJECTION_HEADER
db = SessionDB(db_path=tmp_path / "state.db")
session_id = "PARENT_TODO_UNHYDRATED"
db.create_session(session_id, source="telegram")
agent = _build_agent_with_db(db, session_id, platform="telegram")
pending_task = "- [ ] pending-task. Continue after the next compaction"
getattr(agent, "context_compressor").compress.return_value = [
{"role": "user", "content": "[CONTEXT COMPACTION] summary"},
{"role": "assistant", "content": "acknowledged"},
{
"role": "user",
"content": f"{TODO_INJECTION_HEADER}\n{pending_task}",
"_todo_snapshot_synthetic": True,
},
]
compressed, _ = agent._compress_context(
_msgs(), "sys", approx_tokens=120_000
)
combined = "\n".join(str(m.get("content") or "") for m in compressed)
assert TODO_INJECTION_HEADER in combined
assert pending_task in combined
class TestArchivedParentActivityLabelsCleared:
def test_parent_labels_cleared_after_rotation_child_lineage_intact(
self, tmp_path: Path
):
"""Round-2 #4: the terminal heartbeat stamp must not stay on the parent.
The compression activity heartbeat force-persists "context compression
completed" against the PARENT id (agent.session_id at stamp time).
After the out-of-place rotation the parent is archived; its activity
labels must be cleared so it doesn't advertise a fresh
last_activity_at + terminal label forever, while the child keeps its
lineage.
"""
from agent.session_activity import ActivityProvenance
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ACTIVITY_LABELS"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent)
agent._compress_context(_msgs(), "sys", approx_tokens=120_000)
child = agent.session_id
assert child != parent # rotation happened
# Child lineage intact.
child_row = db.get_session(child)
assert child_row is not None
assert child_row.get("parent_session_id") == parent
# Parent archived with cleared activity labels.
parent_row = db.get_session(parent)
assert parent_row is not None
assert parent_row.get("ended_at") is not None
assert not parent_row.get("last_activity_description"), (
"archived compression parent kept a stale activity description "
f"({parent_row.get('last_activity_description')!r})"
)
prov = parent_row.get("last_activity_provenance")
assert not prov or prov == ActivityProvenance.UNKNOWN.value, (
f"archived parent kept terminal provenance {prov!r}"
)
class TestAbortedRotationDoesNotGrowParent:
"""#88197 — a rotation that cannot publish must not have already written.
The rotation flushes its un-persisted current-turn transcript to the parent
(#47202) and only then calls ``publish_compression_child``. The abort
handler rolls back memory but not that flush, so every failed rotation
leaves the parent transcript longer than it found it. When the failure is
STICKY -- a parent row stamped ``ended_at`` by something that ended the
process rather than the conversation, e.g. the TUI gateway's
``_shutdown_sessions`` stamping ``end_reason='tui_shutdown'`` while the
agent keeps running -- every subsequent auto-compaction repeats it, and the
session grows instead of shrinking until the provider rejects the request.
"""
@staticmethod
def _durable_len(db: SessionDB, session_id: str) -> int:
return len(db.get_messages_as_conversation(session_id))
def test_automatic_stamp_no_longer_wedges_rotation(self, tmp_path: Path):
"""Flipped by the #88197 wedge fix: an AUTOMATIC stamp
(``tui_shutdown`` — is_automatic_end_reason) is stale by construction
for a live rotating writer, so publish now clears it in-transaction
and the rotation COMMITS instead of aborting forever. The abort
contract below moves to deliberate boundaries."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_AUTOMATIC_STAMP_HEALS"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent)
# The lie at the heart of #88197: the row says ended, the agent is live.
db.end_session(parent, "tui_shutdown")
assert db.get_session(parent)["ended_at"] is not None
returned, _sp = agent._compress_context(_msgs(), "sys", approx_tokens=120_000)
# Rotation went through — no abort loop, no repeated flush growth.
assert agent.session_id != parent
parent_row = db.get_session(parent)
assert parent_row["end_reason"] == "compression", (
"parent must close with its TRUE boundary, not the stale stamp"
)
child_row = db.get_session(agent.session_id)
assert child_row is not None
assert child_row["parent_session_id"] == parent
def test_deliberately_ended_parent_aborts_before_the_prepublish_flush(
self, tmp_path: Path
):
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_ENDED_NO_GROWTH"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent)
# A DELIBERATE boundary (another path owns lineage): the guard must
# still refuse BEFORE the #47202 flush so aborted attempts cannot
# grow the parent (#88411's contract, now scoped to non-automatic
# reasons — automatic stamps rotate through, see the test above).
db.end_session(parent, "session_reset")
assert db.get_session(parent)["ended_at"] is not None
before = self._durable_len(db, parent)
# Three consecutive auto-compactions, as the reported incident saw.
for attempt in range(1, 4):
original = _msgs()
returned, _sp = agent._compress_context(
original, "sys", approx_tokens=120_000
)
assert self._durable_len(db, parent) == before, (
f"attempt {attempt} appended to the parent it could not "
"publish; repeated attempts grow the transcript compression "
"exists to shrink"
)
# Rotation refused: the agent stays on the parent with its
# transcript intact, same contract as any other publish failure.
assert agent.session_id == parent
assert returned is original
assert [(m["role"], m["content"]) for m in returned] == [
(m["role"], m["content"]) for m in _msgs()
]
assert db.find_live_compression_child(parent) is None
def test_live_parent_still_gets_the_prepublish_flush(self, tmp_path: Path):
"""The guard must not cost a real rotation its #47202 tail."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_LIVE_FLUSH"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent)
agent._compress_context(_msgs(), "sys", approx_tokens=120_000)
assert agent.session_id != parent # rotation happened
# The current-turn messages survive in the preserved parent transcript.
assert self._durable_len(db, parent) >= len(_msgs())
def test_unreadable_parent_row_fails_open(self, tmp_path: Path):
"""A guard that cannot read the row must not become a way to lose
compression -- an unreadable parent rotates exactly as before."""
db = SessionDB(db_path=tmp_path / "state.db")
parent = "PARENT_UNREADABLE_ROW"
db.create_session(parent, source="cli")
agent = _build_agent_with_db(db, parent)
real_get_session = db.get_session
calls = {"n": 0}
def _flaky_get_session(session_id: str):
if session_id == parent and calls["n"] == 0:
calls["n"] += 1
raise RuntimeError("simulated read failure")
return real_get_session(session_id)
with patch.object(db, "get_session", side_effect=_flaky_get_session):
agent._compress_context(_msgs(), "sys", approx_tokens=120_000)
assert calls["n"] == 1, "the pre-flush guard never read the parent row"
assert agent.session_id != parent # rotation still happened
Reference in New Issue View Git Blame Copy Permalink