feat: marathon session limits — cap, checkpoint, rotate (#326)

- Add max_messages (default 200) to SessionResetPolicy
- Track message_count in SessionEntry
- Add 'message_limit' reset reason to _should_reset
- Auto-checkpoint filesystem before session rotation
- Inject near-limit warnings into agent ephemeral prompt
- Auto-rotate sessions when message cap is hit
- Add get_message_limit_info() and reset_message_count() APIs
- 24 new tests covering all limit behaviors

Evidence: 170 sessions exceed 100 msgs, longest 1,643 msgs (40h).
Marathon sessions show 45-84% error rates from tool fixation.
Cap + checkpoint + restart breaks the death spiral.

gateway/config.py

@@ -107,6 +107,7 @@ class SessionResetPolicy:
     mode: str = "both"  # "daily", "idle", "both", or "none"
     at_hour: int = 4  # Hour for daily reset (0-23, local time)
     idle_minutes: int = 1440  # Minutes of inactivity before reset (24 hours)
+    max_messages: int = 200  # Max messages per session before forced checkpoint+restart (0 = unlimited)
     notify: bool = True  # Send a notification to the user when auto-reset occurs
     notify_exclude_platforms: tuple = ("api_server", "webhook")  # Platforms that don't get reset notifications
     
@@ -115,6 +116,7 @@ class SessionResetPolicy:
             "mode": self.mode,
             "at_hour": self.at_hour,
             "idle_minutes": self.idle_minutes,
+            "max_messages": self.max_messages,
             "notify": self.notify,
             "notify_exclude_platforms": list(self.notify_exclude_platforms),
         }
@@ -125,12 +127,14 @@ class SessionResetPolicy:
         mode = data.get("mode")
         at_hour = data.get("at_hour")
         idle_minutes = data.get("idle_minutes")
+        max_messages = data.get("max_messages")
         notify = data.get("notify")
         exclude = data.get("notify_exclude_platforms")
         return cls(
             mode=mode if mode is not None else "both",
             at_hour=at_hour if at_hour is not None else 4,
             idle_minutes=idle_minutes if idle_minutes is not None else 1440,
+            max_messages=max_messages if max_messages is not None else 200,
             notify=notify if notify is not None else True,
             notify_exclude_platforms=tuple(exclude) if exclude is not None else ("api_server", "webhook"),
         )

gateway/run.py

@@ -2343,6 +2343,13 @@ class GatewayRunner:
             reset_reason = getattr(session_entry, 'auto_reset_reason', None) or 'idle'
             if reset_reason == "daily":
                 context_note = "[System note: The user's session was automatically reset by the daily schedule. This is a fresh conversation with no prior context.]"
+            elif reset_reason == "message_limit":
+                context_note = (
+                    "[System note: The user's previous session reached the message limit "
+                    "and was automatically checkpointed and rotated. This is a fresh session. "
+                    "The prior conversation context was preserved via checkpoint. "
+                    "If the user references something from before, you can search session history.]"
+                )
             else:
                 context_note = "[System note: The user's previous session expired due to inactivity. This is a fresh conversation with no prior context.]"
             context_prompt = context_note + "\n\n" + context_prompt
@@ -2368,16 +2375,18 @@ class GatewayRunner:
                     if adapter:
                         if reset_reason == "daily":
                             reason_text = f"daily schedule at {policy.at_hour}:00"
+                        elif reset_reason == "message_limit":
+                            reason_text = f"reached {policy.max_messages} message limit"
                         else:
                             hours = policy.idle_minutes // 60
                             mins = policy.idle_minutes % 60
                             duration = f"{hours}h" if not mins else f"{hours}h {mins}m" if hours else f"{mins}m"
                             reason_text = f"inactive for {duration}"
                         notice = (
-                            f"◐ Session automatically reset ({reason_text}). "
-                            f"Conversation history cleared.\n"
+                            f"◐ Session automatically rotated ({reason_text}). "
+                            f"Conversation was checkpointed before rotation.\n"
                             f"Use /resume to browse and restore a previous session.\n"
-                            f"Adjust reset timing in config.yaml under session_reset."
+                            f"Adjust limits in config.yaml under session_reset."
                         )
                         try:
                             session_info = self._format_session_info()
@@ -3073,6 +3082,51 @@ class GatewayRunner:
                 last_prompt_tokens=agent_result.get("last_prompt_tokens", 0),
             )
 
+            # Marathon session limit (#326): check if we hit the message cap
+            # after this turn. If so, auto-checkpoint and rotate the session.
+            try:
+                _post_limit = self.session_store.get_message_limit_info(session_key)
+                if _post_limit["at_limit"] and _post_limit["max_messages"] > 0:
+                    logger.info(
+                        "[Marathon] Session %s hit message limit (%d/%d). "
+                        "Auto-checkpointing and rotating.",
+                        session_key, _post_limit["message_count"], _post_limit["max_messages"],
+                    )
+                    # Attempt filesystem checkpoint before rotation
+                    try:
+                        from tools.checkpoint_manager import CheckpointManager
+                        _cp_cfg_path = _hermes_home / "config.yaml"
+                        if _cp_cfg_path.exists():
+                            import yaml as _cp_yaml
+                            with open(_cp_cfg_path, encoding="utf-8") as _cpf:
+                                _cp_data = _cp_yaml.safe_load(_cpf) or {}
+                            _cp_settings = _cp_data.get("checkpoints", {})
+                            if _cp_settings.get("enabled"):
+                                _cwd = _cp_settings.get("working_dir") or os.getcwd()
+                                mgr = CheckpointManager(
+                                    max_checkpoints=_cp_settings.get("max_checkpoints", 20),
+                                )
+                                cp = mgr.create_checkpoint(
+                                    str(_cwd),
+                                    label=f"marathon-limit-{session_entry.session_id[:8]}",
+                                )
+                                if cp:
+                                    logger.info("[Marathon] Checkpoint created: %s", cp.label)
+                    except Exception as cp_err:
+                        logger.debug("[Marathon] Checkpoint creation failed (non-fatal): %s", cp_err)
+
+                    # Rotate session: reset creates a new session ID
+                    new_entry = self.session_store.reset_session(session_key)
+                    if new_entry:
+                        logger.info(
+                            "[Marathon] Session rotated: %s -> %s",
+                            session_entry.session_id, new_entry.session_id,
+                        )
+                        # Reset message count for the new session
+                        self.session_store.reset_message_count(session_key)
+            except Exception as rot_err:
+                logger.debug("[Marathon] Post-turn rotation check failed (non-fatal): %s", rot_err)
+
             # Auto voice reply: send TTS audio before the text response
             _already_sent = bool(agent_result.get("already_sent"))
             if self._should_send_voice_reply(event, response, agent_messages, already_sent=_already_sent):
@@ -6538,6 +6592,29 @@ class GatewayRunner:
             if self._ephemeral_system_prompt:
                 combined_ephemeral = (combined_ephemeral + "\n\n" + self._ephemeral_system_prompt).strip()
 
+            # Marathon session limit warning (#326): inject near-limit warning
+            # into ephemeral prompt so the agent knows to wrap up.
+            try:
+                _limit_info = self.session_store.get_message_limit_info(session_key)
+                if _limit_info["near_limit"] and not _limit_info["at_limit"]:
+                    _remaining = _limit_info["remaining"]
+                    _limit_warn = (
+                        f"[SESSION LIMIT: This session has {_limit_info['message_count']} messages. "
+                        f"Only {_remaining} message(s) remain before automatic session rotation at "
+                        f"{_limit_info['max_messages']} messages. Start wrapping up your work and "
+                        f"provide a summary. Save any important state before the session rotates.]"
+                    )
+                    combined_ephemeral = (combined_ephemeral + "\n\n" + _limit_warn).strip()
+                elif _limit_info["at_limit"]:
+                    _limit_warn = (
+                        f"[SESSION LIMIT REACHED: This session has hit the {_limit_info['max_messages']} "
+                        f"message limit. This is your FINAL response. Summarize what was accomplished "
+                        f"and provide any critical next steps. The session will rotate after this turn.]"
+                    )
+                    combined_ephemeral = (combined_ephemeral + "\n\n" + _limit_warn).strip()
+            except Exception:
+                pass  # Non-fatal: limit warning is advisory only
+
             # Re-read .env and config for fresh credentials (gateway is long-lived,
             # keys may change without restart).
             try:

gateway/session.py

@@ -383,6 +383,11 @@ class SessionEntry:
     # survives gateway restarts (the old in-memory _pre_flushed_sessions
     # set was lost on restart, causing redundant re-flushes).
     memory_flushed: bool = False
+
+    # Marathon session limit tracking (#326).
+    # Counts total messages (user + assistant + tool) in this session.
+    # Used to trigger checkpoint+restart at max_messages threshold.
+    message_count: int = 0
     
     def to_dict(self) -> Dict[str, Any]:
         result = {
@@ -402,6 +407,7 @@ class SessionEntry:
             "estimated_cost_usd": self.estimated_cost_usd,
             "cost_status": self.cost_status,
             "memory_flushed": self.memory_flushed,
+            "message_count": self.message_count,
         }
         if self.origin:
             result["origin"] = self.origin.to_dict()
@@ -438,6 +444,7 @@ class SessionEntry:
             estimated_cost_usd=data.get("estimated_cost_usd", 0.0),
             cost_status=data.get("cost_status", "unknown"),
             memory_flushed=data.get("memory_flushed", False),
+            message_count=data.get("message_count", 0),
         )
 
 
@@ -626,10 +633,10 @@ class SessionStore:
     def _should_reset(self, entry: SessionEntry, source: SessionSource) -> Optional[str]:
         """
         Check if a session should be reset based on policy.
-        
-        Returns the reset reason ("idle" or "daily") if a reset is needed,
-        or None if the session is still valid.
-        
+
+        Returns the reset reason ("idle", "daily", or "message_limit") if a reset
+        is needed, or None if the session is still valid.
+
         Sessions with active background processes are never reset.
         """
         if self._has_active_processes_fn:
@@ -641,30 +648,37 @@ class SessionStore:
             platform=source.platform,
             session_type=source.chat_type
         )
-        
+
         if policy.mode == "none":
+            # Even with mode=none, enforce message_limit if set
+            if policy.max_messages > 0 and entry.message_count >= policy.max_messages:
+                return "message_limit"
             return None
-        
+
         now = _now()
-        
+
         if policy.mode in ("idle", "both"):
             idle_deadline = entry.updated_at + timedelta(minutes=policy.idle_minutes)
             if now > idle_deadline:
                 return "idle"
-        
+
         if policy.mode in ("daily", "both"):
             today_reset = now.replace(
-                hour=policy.at_hour, 
-                minute=0, 
-                second=0, 
+                hour=policy.at_hour,
+                minute=0,
+                second=0,
                 microsecond=0
             )
             if now.hour < policy.at_hour:
                 today_reset -= timedelta(days=1)
-            
+
             if entry.updated_at < today_reset:
                 return "daily"
-        
+
+        # Marathon session limit (#326): force checkpoint+restart at max_messages
+        if policy.max_messages > 0 and entry.message_count >= policy.max_messages:
+            return "message_limit"
+
         return None
     
     def has_any_sessions(self) -> bool:
@@ -822,6 +836,70 @@ class SessionStore:
                     entry.last_prompt_tokens = last_prompt_tokens
                 self._save()
 
+    def get_message_count(self, session_key: str) -> int:
+        """Get the current message count for a session.
+
+        Returns the locally-tracked count from SessionEntry. Falls back to
+        DB query if the entry is not in memory.
+        """
+        with self._lock:
+            self._ensure_loaded_locked()
+            entry = self._entries.get(session_key)
+            if entry:
+                return entry.message_count
+
+        # Fallback: query DB directly
+        if self._db:
+            try:
+                return self._db.message_count(entry.session_id) if entry else 0
+            except Exception:
+                pass
+        return 0
+
+    def get_message_limit_info(self, session_key: str) -> Dict[str, Any]:
+        """Get message count and limit info for a session.
+
+        Returns dict with: message_count, max_messages, remaining, near_limit,
+        at_limit, and threshold (fraction of limit used).
+        """
+        with self._lock:
+            self._ensure_loaded_locked()
+            entry = self._entries.get(session_key)
+
+        if not entry:
+            return {"message_count": 0, "max_messages": 0, "remaining": 0,
+                    "near_limit": False, "at_limit": False, "threshold": 0.0}
+
+        policy = self.config.get_reset_policy(
+            platform=entry.platform,
+            session_type=entry.chat_type,
+        )
+        max_msgs = policy.max_messages
+        count = entry.message_count
+        remaining = max(0, max_msgs - count) if max_msgs > 0 else float("inf")
+        threshold = count / max_msgs if max_msgs > 0 else 0.0
+
+        return {
+            "message_count": count,
+            "max_messages": max_msgs,
+            "remaining": remaining,
+            "near_limit": max_msgs > 0 and count >= int(max_msgs * 0.85),
+            "at_limit": max_msgs > 0 and count >= max_msgs,
+            "threshold": threshold,
+        }
+
+    def reset_message_count(self, session_key: str) -> None:
+        """Reset the message count to zero for a session.
+
+        Called after a session rotation to start fresh counting.
+        """
+        with self._lock:
+            self._ensure_loaded_locked()
+            entry = self._entries.get(session_key)
+            if entry:
+                entry.message_count = 0
+                self._save()
+
     def reset_session(self, session_key: str) -> Optional[SessionEntry]:
         """Force reset a session, creating a new session ID."""
         db_end_session_id = None
@@ -849,6 +927,7 @@ class SessionStore:
                 display_name=old_entry.display_name,
                 platform=old_entry.platform,
                 chat_type=old_entry.chat_type,
+                message_count=0,  # Fresh count after rotation (#326)
             )
 
             self._entries[session_key] = new_entry
@@ -942,12 +1021,18 @@ class SessionStore:
     def append_to_transcript(self, session_id: str, message: Dict[str, Any], skip_db: bool = False) -> None:
         """Append a message to a session's transcript (SQLite + legacy JSONL).
 
+        Also increments the session's message_count for marathon session
+        limit tracking (#326).
+
         Args:
             skip_db: When True, only write to JSONL and skip the SQLite write.
                      Used when the agent already persisted messages to SQLite
                      via its own _flush_messages_to_session_db(), preventing
                      the duplicate-write bug (#860).
         """
+        # Skip counting session_meta entries (tool defs, metadata)
+        is_meta = message.get("role") == "session_meta"
+
         # Write to SQLite (unless the agent already handled it)
         if self._db and not skip_db:
             try:
@@ -961,11 +1046,20 @@ class SessionStore:
                 )
             except Exception as e:
                 logger.debug("Session DB operation failed: %s", e)
-        
+
         # Also write legacy JSONL (keeps existing tooling working during transition)
         transcript_path = self.get_transcript_path(session_id)
         with open(transcript_path, "a", encoding="utf-8") as f:
             f.write(json.dumps(message, ensure_ascii=False) + "\n")
+
+        # Increment message count for marathon session tracking (#326)
+        if not is_meta:
+            with self._lock:
+                for entry in self._entries.values():
+                    if entry.session_id == session_id:
+                        entry.message_count += 1
+                        self._save()
+                        break
     
     def rewrite_transcript(self, session_id: str, messages: List[Dict[str, Any]]) -> None:
         """Replace the entire transcript for a session with new messages.

tests/gateway/test_marathon_session_limits.py

@@ -0,0 +1,279 @@
+"""Tests for marathon session limits (#326)."""
+
+import json
+import os
+import tempfile
+from datetime import datetime, timedelta
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from gateway.config import (
+    GatewayConfig,
+    Platform,
+    PlatformConfig,
+    SessionResetPolicy,
+)
+from gateway.session import (
+    SessionEntry,
+    SessionSource,
+    SessionStore,
+)
+
+
+@pytest.fixture
+def tmp_sessions_dir(tmp_path):
+    d = tmp_path / "sessions"
+    d.mkdir()
+    return d
+
+
+@pytest.fixture
+def default_config():
+    return GatewayConfig()
+
+
+@pytest.fixture
+def store(tmp_sessions_dir, default_config):
+    return SessionStore(tmp_sessions_dir, default_config)
+
+
+def _make_source(platform=Platform.LOCAL, chat_id="test-chat"):
+    return SessionSource(
+        platform=platform,
+        chat_id=chat_id,
+        chat_type="dm",
+        user_id="test-user",
+        user_name="Test User",
+    )
+
+
+class TestSessionResetPolicyMaxMessages:
+    """Test max_messages field on SessionResetPolicy."""
+
+    def test_default_max_messages(self):
+        policy = SessionResetPolicy()
+        assert policy.max_messages == 200
+
+    def test_custom_max_messages(self):
+        policy = SessionResetPolicy(max_messages=500)
+        assert policy.max_messages == 500
+
+    def test_unlimited_when_zero(self):
+        policy = SessionResetPolicy(max_messages=0)
+        assert policy.max_messages == 0
+
+    def test_to_dict_includes_max_messages(self):
+        policy = SessionResetPolicy(max_messages=300)
+        d = policy.to_dict()
+        assert d["max_messages"] == 300
+
+    def test_from_dict_restores_max_messages(self):
+        data = {"mode": "idle", "max_messages": 150}
+        policy = SessionResetPolicy.from_dict(data)
+        assert policy.max_messages == 150
+
+    def test_from_dict_defaults_max_messages(self):
+        data = {"mode": "idle"}
+        policy = SessionResetPolicy.from_dict(data)
+        assert policy.max_messages == 200
+
+
+class TestSessionEntryMessageCount:
+    """Test message_count field on SessionEntry."""
+
+    def test_default_message_count(self):
+        entry = SessionEntry(
+            session_key="test",
+            session_id="20260101_000000_abc12345",
+            created_at=datetime.now(),
+            updated_at=datetime.now(),
+        )
+        assert entry.message_count == 0
+
+    def test_to_dict_includes_message_count(self):
+        entry = SessionEntry(
+            session_key="test",
+            session_id="20260101_000000_abc12345",
+            created_at=datetime.now(),
+            updated_at=datetime.now(),
+            message_count=42,
+        )
+        d = entry.to_dict()
+        assert d["message_count"] == 42
+
+    def test_from_dict_restores_message_count(self):
+        data = {
+            "session_key": "test",
+            "session_id": "20260101_000000_abc12345",
+            "created_at": "2026-01-01T00:00:00",
+            "updated_at": "2026-01-01T00:00:00",
+            "message_count": 99,
+        }
+        entry = SessionEntry.from_dict(data)
+        assert entry.message_count == 99
+
+
+class TestShouldResetMessageLimit:
+    """Test _should_reset returns 'message_limit' when message count exceeds cap."""
+
+    def test_reset_at_limit(self, store):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 200  # At default limit
+        result = store._should_reset(entry, source)
+        assert result == "message_limit"
+
+    def test_reset_over_limit(self, store):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 250
+        result = store._should_reset(entry, source)
+        assert result == "message_limit"
+
+    def test_no_reset_below_limit(self, store):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 100
+        result = store._should_reset(entry, source)
+        assert result is None
+
+    def test_no_reset_when_unlimited(self):
+        config = GatewayConfig()
+        config.default_reset_policy = SessionResetPolicy(
+            mode="none", max_messages=0
+        )
+        store = SessionStore(Path(tempfile.mkdtemp()), config)
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 9999
+        result = store._should_reset(entry, source)
+        assert result is None
+
+    def test_custom_limit(self):
+        config = GatewayConfig()
+        config.default_reset_policy = SessionResetPolicy(max_messages=50)
+        store = SessionStore(Path(tempfile.mkdtemp()), config)
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 50
+        result = store._should_reset(entry, source)
+        assert result == "message_limit"
+
+    def test_no_reset_just_under(self):
+        config = GatewayConfig()
+        config.default_reset_policy = SessionResetPolicy(max_messages=50)
+        store = SessionStore(Path(tempfile.mkdtemp()), config)
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 49
+        result = store._should_reset(entry, source)
+        assert result is None
+
+
+class TestAppendToTranscriptIncrementsCount:
+    """Test that append_to_transcript increments message_count."""
+
+    def test_increment_on_user_message(self, store, tmp_sessions_dir):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        assert entry.message_count == 0
+
+        store.append_to_transcript(
+            entry.session_id,
+            {"role": "user", "content": "hello"},
+        )
+        # Re-read entry
+        entry = store.get_or_create_session(source)
+        assert entry.message_count == 1
+
+    def test_increment_on_assistant_message(self, store, tmp_sessions_dir):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+
+        store.append_to_transcript(
+            entry.session_id,
+            {"role": "user", "content": "hello"},
+        )
+        store.append_to_transcript(
+            entry.session_id,
+            {"role": "assistant", "content": "hi there"},
+        )
+        entry = store.get_or_create_session(source)
+        assert entry.message_count == 2
+
+    def test_no_increment_on_session_meta(self, store, tmp_sessions_dir):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+
+        store.append_to_transcript(
+            entry.session_id,
+            {"role": "session_meta", "tools": []},
+        )
+        entry = store.get_or_create_session(source)
+        assert entry.message_count == 0
+
+
+class TestGetMessageLimitInfo:
+    """Test get_message_limit_info returns correct data."""
+
+    def test_at_limit(self, store):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 200
+        info = store.get_message_limit_info(entry.session_key)
+        assert info["message_count"] == 200
+        assert info["max_messages"] == 200
+        assert info["remaining"] == 0
+        assert info["near_limit"] is True
+        assert info["at_limit"] is True
+
+    def test_near_limit(self, store):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 180  # 90% of 200
+        info = store.get_message_limit_info(entry.session_key)
+        assert info["near_limit"] is True
+        assert info["at_limit"] is False
+        assert info["remaining"] == 20
+
+    def test_well_below_limit(self, store):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 50
+        info = store.get_message_limit_info(entry.session_key)
+        assert info["near_limit"] is False
+        assert info["at_limit"] is False
+        assert info["remaining"] == 150
+
+    def test_unknown_session(self, store):
+        info = store.get_message_limit_info("nonexistent")
+        assert info["message_count"] == 0
+        assert info["at_limit"] is False
+
+
+class TestResetMessageCount:
+    """Test reset_message_count resets to zero."""
+
+    def test_reset_count(self, store):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 150
+        store.reset_message_count(entry.session_key)
+        info = store.get_message_limit_info(entry.session_key)
+        assert info["message_count"] == 0
+
+
+class TestSessionRotationPreservesOrigin:
+    """Test that session rotation creates fresh entry with message_count=0."""
+
+    def test_reset_creates_fresh_count(self, store):
+        source = _make_source()
+        entry = store.get_or_create_session(source)
+        entry.message_count = 200
+
+        new_entry = store.reset_session(entry.session_key)
+        assert new_entry is not None
+        assert new_entry.message_count == 0
+        assert new_entry.session_id != entry.session_id