"""Hermes chat sessions contracts.""" from __future__ import annotations from test_hermes_chat_support import ( HERMES, Path, importlib, json, pytest, sqlite3, ) def test_telegram_api_session_migration_is_bounded_and_idempotent(tmp_path: Path): """Only named Telegram conversations receive presentation metadata.""" module_path = HERMES / "scripts" / "migrate_telegram_api_sessions.py" spec = importlib.util.spec_from_file_location("migrate_telegram_sessions", module_path) assert spec and spec.loader module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) state = tmp_path / "state.db" responses = tmp_path / "response_store.db" with sqlite3.connect(state) as connection: connection.execute( """CREATE TABLE sessions ( id TEXT PRIMARY KEY, source TEXT, session_key TEXT, chat_type TEXT, display_name TEXT, origin_json TEXT, title TEXT )""" ) connection.executemany( "INSERT INTO sessions (id, source) VALUES (?, ?)", (("telegram-session", "api_server"), ("other-session", "api_server")), ) with sqlite3.connect(responses) as connection: connection.execute( "CREATE TABLE conversations (name TEXT PRIMARY KEY, response_id TEXT NOT NULL)" ) connection.execute( "CREATE TABLE responses (response_id TEXT PRIMARY KEY, data TEXT NOT NULL, accessed_at REAL NOT NULL)" ) connection.executemany( "INSERT INTO responses VALUES (?, ?, 0)", ( ("telegram-response", json.dumps({"session_id": "telegram-session"})), ("other-response", json.dumps({"session_id": "other-session"})), ), ) connection.executemany( "INSERT INTO conversations VALUES (?, ?)", (("telegram", "telegram-response"), ("unrelated", "other-response")), ) assert module.migrate(state, responses) == 1 assert module.migrate(state, responses) == 0 with sqlite3.connect(state) as connection: telegram = connection.execute( "SELECT session_key, chat_type, display_name, origin_json, title " "FROM sessions WHERE id = 'telegram-session'" ).fetchone() other = connection.execute( "SELECT session_key, title FROM sessions WHERE id = 'other-session'" ).fetchone() assert telegram[:3] == ("telegram", "private", "Telegram") assert json.loads(telegram[3]) == { "platform": "telegram", "session_key": "telegram", } assert telegram[4] == "Telegram · General" assert other == (None, None) def test_web_session_activity_patch_projects_bounded_events(tmp_path: Path): """The DOM transcript includes events without polluting agent history.""" module_path = HERMES / "scripts" / "patch_web_session_activity.py" spec = importlib.util.spec_from_file_location("patch_web_activity", module_path) assert spec and spec.loader module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) source = tmp_path / "web_server.py" destination = tmp_path / "patched.py" source.write_text( "prefix\n" + module.LATEST_ROWS_BEFORE + module.LATEST_SELECTION_BEFORE + module.HELPER_MARKER + " db = object()\n" + module.MESSAGES_BEFORE + "suffix\n", encoding="utf-8", ) module.patch(source, destination) patched = destination.read_text(encoding="utf-8") assert "def _run_activity_messages(" in patched assert 'root = get_hermes_home() / "run-activity"' in patched assert "path.stat().st_size > 600_000" in patched assert "entries[-1_000:]" in patched assert "*_run_activity_messages(sid)" in patched assert "messages.sort(" in patched assert "limit: Optional[int] = None" in patched assert "total_messages = len(messages)" in patched assert "min(int(limit), 10_000)" in patched assert '"total_messages": total_messages' in patched assert "SELECT id, parent_session_id, started_at, ended_at" in patched assert "newest still-open member of the lineage" in patched assert "immediate objective parent" in patched assert "mixes unrelated workstreams" in patched assert "orphaned children" in patched assert 'item[0].get("ended_at") is None' in patched def test_web_session_lineage_returns_to_resumed_parent(): """An ended reviewer must not strand the live view away from its parent.""" module_path = HERMES / "scripts" / "patch_web_session_activity.py" spec = importlib.util.spec_from_file_location("patch_web_lineage", module_path) assert spec and spec.loader module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) namespace: dict[str, object] = {} exec( "def select_active(sid, db, rows):\n" + module.LATEST_SELECTION_AFTER, namespace, ) class FakeDB: def get_session(self, session_id): return next((row for row in rows if row["id"] == session_id), None) rows = [ { "id": "umbrella", "parent_session_id": None, "started_at": 0.0, "ended_at": None, }, { "id": "root", "parent_session_id": "umbrella", "started_at": 1.0, "ended_at": None, }, { "id": "review-1", "parent_session_id": "root", "started_at": 2.0, "ended_at": 3.0, }, { "id": "review-2", "parent_session_id": "root", "started_at": 4.0, "ended_at": None, }, ] select_active = namespace["select_active"] assert select_active("root", FakeDB(), rows) == ( "review-2", ["root", "review-2"], ) assert select_active("review-1", FakeDB(), rows) == ( "review-2", ["root", "review-2"], ) rows[2]["ended_at"] = 5.0 rows[3]["ended_at"] = 5.0 assert select_active("root", FakeDB(), rows) == ("root", ["root"]) rows[1]["ended_at"] = 9.0 rows.append( { "id": "orphaned-review", "parent_session_id": "root", "started_at": 6.0, "ended_at": None, } ) rows.append( { "id": "accepted-review", "parent_session_id": "root", "started_at": 7.0, "ended_at": 8.0, } ) assert select_active("review-1", FakeDB(), rows) == ( "accepted-review", ["root", "accepted-review"], ) def test_api_activity_patch_coalesces_streaming_heartbeats( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ): """Token callbacks stay bounded while every tool transition is retained.""" module_path = HERMES / "scripts" / "patch_api_server_sessions.py" spec = importlib.util.spec_from_file_location("patch_api_activity", module_path) assert spec and spec.loader module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) activity_body = module.EVENT_CALLBACK_SIGNATURE_AFTER.split( " def _make_run_event_callback(", 1 )[0] namespace: dict[str, object] = {} exec( "import hashlib, json, logging, os, time\n" "from pathlib import Path\n" "logger = logging.getLogger(__name__)\n" "def redact_sensitive_text(value): return value\n" "class ActivityRecorder:\n" + activity_body, namespace, ) recorder = namespace["ActivityRecorder"]() monkeypatch.setenv("HERMES_HOME", str(tmp_path)) recorder._record_run_activity("session", "_thinking") recorder._record_run_activity("session", "reasoning.available") recorder._record_run_activity("session", "subagent.thinking") recorder._record_run_activity("session", "tool.started", tool_name="terminal") recorder._record_run_activity("session", "tool.completed", tool_name="terminal") journals = list((tmp_path / "run-activity").glob("*.jsonl")) assert len(journals) == 1 entries = [json.loads(line) for line in journals[0].read_text().splitlines()] assert [entry["activity_event"] for entry in entries] == [ "_thinking", "tool.started", "tool.completed", ] def test_legacy_api_sessions_are_nested_idempotently(tmp_path: Path): """Known standalone API workers move under Cassandra without data loss.""" module_path = HERMES / "scripts" / "migrate_api_session_lineage.py" spec = importlib.util.spec_from_file_location("migrate_api_sessions", module_path) assert spec and spec.loader module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) database = tmp_path / "state.db" with sqlite3.connect(database) as connection: connection.execute( "CREATE TABLE sessions (id TEXT PRIMARY KEY, source TEXT, " "parent_session_id TEXT, title TEXT, transcript TEXT, archived INTEGER DEFAULT 0)" ) connection.execute( "INSERT INTO sessions (id, source, parent_session_id, title, transcript) " "VALUES (?, 'tui', NULL, 'Cassandra', 'parent-data')", (module.LEGACY_CASSANDRA_PARENT,), ) worker_id = next(iter(module.LEGACY_CASSANDRA_WORKERS)) connection.execute( "INSERT INTO sessions (id, source, parent_session_id, title, transcript) " "VALUES (?, 'api_server', NULL, 'old', 'keep-me')", (worker_id,), ) connection.executemany( "INSERT INTO sessions (id, source, parent_session_id, title, transcript) " "VALUES (?, 'api_server', NULL, 'old smoke', 'keep-smoke')", ((orphan_id,) for orphan_id in module.LEGACY_ORPHANED_SMOKE_SESSIONS), ) assert module.migrate(database) == 1 + len(module.LEGACY_ORPHANED_SMOKE_SESSIONS) assert module.migrate(database) == 0 with sqlite3.connect(database) as connection: row = connection.execute( "SELECT parent_session_id, title, transcript FROM sessions WHERE id = ?", (worker_id,), ).fetchone() assert row == ( module.LEGACY_CASSANDRA_PARENT, module.LEGACY_CASSANDRA_WORKERS[worker_id], "keep-me", ) with sqlite3.connect(database) as connection: orphans = connection.execute( "SELECT id, archived, title, transcript FROM sessions " "WHERE id IN ({}) ORDER BY id".format( ",".join("?" for _ in module.LEGACY_ORPHANED_SMOKE_SESSIONS) ), tuple(module.LEGACY_ORPHANED_SMOKE_SESSIONS), ).fetchall() assert orphans == sorted( ( orphan_id, 1, module.LEGACY_ORPHANED_SMOKE_SESSIONS[orphan_id], "keep-smoke", ) for orphan_id in module.LEGACY_ORPHANED_SMOKE_SESSIONS ) def test_automated_triage_sessions_are_grouped_without_touching_interactive_runs(tmp_path: Path): """Only the stable Ariadne contract moves below the triage parent.""" module_path = HERMES / "scripts" / "migrate_api_session_lineage.py" spec = importlib.util.spec_from_file_location("migrate_triage_sessions", module_path) assert spec and spec.loader module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) database = tmp_path / "state.db" with sqlite3.connect(database) as connection: connection.execute( "CREATE TABLE sessions (id TEXT PRIMARY KEY, source TEXT, " "parent_session_id TEXT, title TEXT, started_at REAL, archived INTEGER DEFAULT 0)" ) connection.execute( "CREATE TABLE messages (session_id TEXT, role TEXT, content TEXT)" ) connection.executemany( "INSERT INTO sessions (id, source, started_at) VALUES (?, 'api_server', ?)", (("triage-run", 1.0), ("jenkins-run", 1.5), ("interactive-run", 2.0)), ) connection.executemany( "INSERT INTO messages (session_id, role, content) VALUES (?, 'user', ?)", ( ( "triage-run", module.TRIAGE_MESSAGE_PREFIXES[0] + " Fix for incident sonar/bstein_home/python:S2208/finding-key.", ), ( "jenkins-run", module.TRIAGE_MESSAGE_PREFIXES[1] + "\nAnalyze incident soteria/291 for the Jenkins job soteria.", ), ("interactive-run", "Please explain this alert to me."), ), ) assert module.migrate(database, group_triage=True) == 2 assert module.migrate(database, group_triage=True) == 0 with sqlite3.connect(database) as connection: parent = connection.execute( "SELECT title FROM sessions WHERE id = ?", (module.TRIAGE_PARENT,) ).fetchone() triage = connection.execute( "SELECT parent_session_id, title FROM sessions WHERE id = 'triage-run'" ).fetchone() interactive = connection.execute( "SELECT parent_session_id FROM sessions WHERE id = 'interactive-run'" ).fetchone() jenkins = connection.execute( "SELECT parent_session_id, title FROM sessions WHERE id = 'jenkins-run'" ).fetchone() assert parent == (module.TRIAGE_PARENT_TITLE,) assert triage == ( module.TRIAGE_PARENT, "Sonar · bstein_home · python:S2208 · iage-run", ) assert interactive == (None,) assert jenkins == ( module.TRIAGE_PARENT, "Sonar · soteria/291 · kins-run", ) def test_stale_parent_linked_api_workers_close_on_startup(tmp_path: Path): """A previous gateway lifetime cannot leave phantom active workers.""" module_path = HERMES / "scripts" / "migrate_api_session_lineage.py" spec = importlib.util.spec_from_file_location("close_stale_api_workers", module_path) assert spec and spec.loader module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) database = tmp_path / "state.db" with sqlite3.connect(database) as connection: connection.execute( "CREATE TABLE sessions (id TEXT PRIMARY KEY, source TEXT, " "parent_session_id TEXT, title TEXT, started_at REAL, ended_at REAL, " "end_reason TEXT, archived INTEGER DEFAULT 0)" ) connection.executemany( "INSERT INTO sessions " "(id, source, parent_session_id, started_at, ended_at, end_reason) " "VALUES (?, ?, ?, 1, ?, ?)", ( ("stale", "api_server", "parent", None, None), ("root", "api_server", None, None, None), ("finished", "api_server", "parent", 2.0, "api_run_completed"), ("interactive", "tui", "parent", None, None), ), ) assert module.migrate(database) == 1 assert module.migrate(database) == 0 with sqlite3.connect(database) as connection: rows = connection.execute( "SELECT id, ended_at, end_reason FROM sessions ORDER BY id" ).fetchall() by_id = {row[0]: row[1:] for row in rows} assert by_id["stale"][0] is not None assert by_id["stale"][1] == "api_run_recovered_stale" assert by_id["root"] == (None, None) assert by_id["finished"] == (2.0, "api_run_completed") assert by_id["interactive"] == (None, None)