fix: update tests for unified spawn-per-call execution model

- Docker env tests: verify _build_init_env_args() instead of per-execute
  Popen flags (env forwarding is now init-time only)
- Docker: preserve explicit forward_env bypass of blocklist from main
- Daytona tests: adapt to SDK-native timeout, _ThreadedProcessHandle,
  base.py interrupt handling, HERMES_STDIN_ heredoc prefix
- Modal tests: fix _load_module to include _ThreadedProcessHandle stub,
  check ensurepip in _resolve_modal_image instead of __init__
- SSH tests: mock time.sleep on base module instead of removed ssh import
- Add missing BaseEnvironment attributes to __new__()-based test fixtures

.github/workflows/docker-publish.yml

@@ -8,9 +8,6 @@ on:
   release:
     types: [published]
 
-permissions:
-  contents: read
-
 concurrency:
   group: docker-${{ github.ref }}
   cancel-in-progress: true
@@ -20,29 +17,22 @@ jobs:
     # Only run on the upstream repository, not on forks
     if: github.repository == 'NousResearch/hermes-agent'
     runs-on: ubuntu-latest
-    timeout-minutes: 60
+    timeout-minutes: 30
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
         with:
           submodules: recursive
 
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 
-      # Build amd64 only so we can `load` the image for smoke testing.
-      # `load: true` cannot export a multi-arch manifest to the local daemon.
-      # The multi-arch build follows on push to main / release.
-      - name: Build image (amd64, smoke test)
+      - name: Build image
         uses: docker/build-push-action@v6
         with:
           context: .
           file: Dockerfile
           load: true
-          platforms: linux/amd64
           tags: nousresearch/hermes-agent:test
           cache-from: type=gha
           cache-to: type=gha,mode=max
@@ -61,28 +51,26 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Push multi-arch image (main branch)
+      - name: Push image (main branch)
         if: github.event_name == 'push' && github.ref == 'refs/heads/main'
         uses: docker/build-push-action@v6
         with:
           context: .
           file: Dockerfile
           push: true
-          platforms: linux/amd64,linux/arm64
           tags: |
             nousresearch/hermes-agent:latest
             nousresearch/hermes-agent:${{ github.sha }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
 
-      - name: Push multi-arch image (release)
+      - name: Push image (release)
         if: github.event_name == 'release'
         uses: docker/build-push-action@v6
         with:
           context: .
           file: Dockerfile
           push: true
-          platforms: linux/amd64,linux/arm64
           tags: |
             nousresearch/hermes-agent:latest
             nousresearch/hermes-agent:${{ github.event.release.tag_name }}

agent/auxiliary_client.py

@@ -629,19 +629,11 @@ def _nous_base_url() -> str:
 
 
 def _read_codex_access_token() -> Optional[str]:
-    """Read a valid, non-expired Codex OAuth access token from Hermes auth store.
-
-    If a credential pool exists but currently has no selectable runtime entry
-    (for example all pool slots are marked exhausted), fall back to the
-    profile's auth.json token instead of hard-failing. This keeps explicit
-    fallback-to-Codex working when the pool state is stale but the stored OAuth
-    token is still valid.
-    """
+    """Read a valid, non-expired Codex OAuth access token from Hermes auth store."""
     pool_present, entry = _select_pool_entry("openai-codex")
     if pool_present:
         token = _pool_runtime_api_key(entry)
-        if token:
-            return token
+        return token or None
 
     try:
         from hermes_cli.auth import _read_codex_tokens
@@ -902,13 +894,9 @@ def _try_codex() -> Tuple[Optional[Any], Optional[str]]:
     pool_present, entry = _select_pool_entry("openai-codex")
     if pool_present:
         codex_token = _pool_runtime_api_key(entry)
-        if codex_token:
-            base_url = _pool_runtime_base_url(entry, _CODEX_AUX_BASE_URL) or _CODEX_AUX_BASE_URL
-        else:
-            codex_token = _read_codex_access_token()
-            if not codex_token:
-                return None, None
-            base_url = _CODEX_AUX_BASE_URL
+        if not codex_token:
+            return None, None
+        base_url = _pool_runtime_base_url(entry, _CODEX_AUX_BASE_URL) or _CODEX_AUX_BASE_URL
     else:
         codex_token = _read_codex_access_token()
         if not codex_token:

agent/context_compressor.py

@@ -154,15 +154,12 @@ class ContextCompressor:
 
     def _prune_old_tool_results(
         self, messages: List[Dict[str, Any]], protect_tail_count: int,
-        protect_tail_tokens: int | None = None,
     ) -> tuple[List[Dict[str, Any]], int]:
         """Replace old tool result contents with a short placeholder.
 
-        Walks backward from the end, protecting the most recent messages that
-        fall within ``protect_tail_tokens`` (when provided) OR the last
-        ``protect_tail_count`` messages (backward-compatible default).
-        When both are given, the token budget takes priority and the message
-        count acts as a hard minimum floor.
+        Walks backward from the end, protecting the most recent
+        ``protect_tail_count`` messages. Older tool results get their
+        content replaced with a placeholder string.
 
         Returns (pruned_messages, pruned_count).
         """
@@ -171,29 +168,7 @@ class ContextCompressor:
 
         result = [m.copy() for m in messages]
         pruned = 0
-
-        # Determine the prune boundary
-        if protect_tail_tokens is not None and protect_tail_tokens > 0:
-            # Token-budget approach: walk backward accumulating tokens
-            accumulated = 0
-            boundary = len(result)
-            min_protect = min(protect_tail_count, len(result) - 1)
-            for i in range(len(result) - 1, -1, -1):
-                msg = result[i]
-                content_len = len(msg.get("content") or "")
-                msg_tokens = content_len // _CHARS_PER_TOKEN + 10
-                for tc in msg.get("tool_calls") or []:
-                    if isinstance(tc, dict):
-                        args = tc.get("function", {}).get("arguments", "")
-                        msg_tokens += len(args) // _CHARS_PER_TOKEN
-                if accumulated + msg_tokens > protect_tail_tokens and (len(result) - i) >= min_protect:
-                    boundary = i
-                    break
-                accumulated += msg_tokens
-                boundary = i
-            prune_boundary = max(boundary, len(result) - min_protect)
-        else:
-            prune_boundary = len(result) - protect_tail_count
+        prune_boundary = len(result) - protect_tail_count
 
         for i in range(prune_boundary):
             msg = result[i]
@@ -224,39 +199,30 @@ class ContextCompressor:
         budget = int(content_tokens * _SUMMARY_RATIO)
         return max(_MIN_SUMMARY_TOKENS, min(budget, self.max_summary_tokens))
 
-    # Truncation limits for the summarizer input.  These bound how much of
-    # each message the summary model sees — the budget is the *summary*
-    # model's context window, not the main model's.
-    _CONTENT_MAX = 6000       # total chars per message body
-    _CONTENT_HEAD = 4000      # chars kept from the start
-    _CONTENT_TAIL = 1500      # chars kept from the end
-    _TOOL_ARGS_MAX = 1500     # tool call argument chars
-    _TOOL_ARGS_HEAD = 1200    # kept from the start of tool args
-
     def _serialize_for_summary(self, turns: List[Dict[str, Any]]) -> str:
         """Serialize conversation turns into labeled text for the summarizer.
 
-        Includes tool call arguments and result content (up to
-        ``_CONTENT_MAX`` chars per message) so the summarizer can preserve
-        specific details like file paths, commands, and outputs.
+        Includes tool call arguments and result content (up to 3000 chars
+        per message) so the summarizer can preserve specific details like
+        file paths, commands, and outputs.
         """
         parts = []
         for msg in turns:
             role = msg.get("role", "unknown")
             content = msg.get("content") or ""
 
-            # Tool results: keep enough content for the summarizer
+            # Tool results: keep more content than before (3000 chars)
             if role == "tool":
                 tool_id = msg.get("tool_call_id", "")
-                if len(content) > self._CONTENT_MAX:
-                    content = content[:self._CONTENT_HEAD] + "\n...[truncated]...\n" + content[-self._CONTENT_TAIL:]
+                if len(content) > 3000:
+                    content = content[:2000] + "\n...[truncated]...\n" + content[-800:]
                 parts.append(f"[TOOL RESULT {tool_id}]: {content}")
                 continue
 
             # Assistant messages: include tool call names AND arguments
             if role == "assistant":
-                if len(content) > self._CONTENT_MAX:
-                    content = content[:self._CONTENT_HEAD] + "\n...[truncated]...\n" + content[-self._CONTENT_TAIL:]
+                if len(content) > 3000:
+                    content = content[:2000] + "\n...[truncated]...\n" + content[-800:]
                 tool_calls = msg.get("tool_calls", [])
                 if tool_calls:
                     tc_parts = []
@@ -266,8 +232,8 @@ class ContextCompressor:
                             name = fn.get("name", "?")
                             args = fn.get("arguments", "")
                             # Truncate long arguments but keep enough for context
-                            if len(args) > self._TOOL_ARGS_MAX:
-                                args = args[:self._TOOL_ARGS_HEAD] + "..."
+                            if len(args) > 500:
+                                args = args[:400] + "..."
                             tc_parts.append(f"  {name}({args})")
                         else:
                             fn = getattr(tc, "function", None)
@@ -278,8 +244,8 @@ class ContextCompressor:
                 continue
 
             # User and other roles
-            if len(content) > self._CONTENT_MAX:
-                content = content[:self._CONTENT_HEAD] + "\n...[truncated]...\n" + content[-self._CONTENT_TAIL:]
+            if len(content) > 3000:
+                content = content[:2000] + "\n...[truncated]...\n" + content[-800:]
             parts.append(f"[{role.upper()}]: {content}")
 
         return "\n\n".join(parts)
@@ -344,9 +310,6 @@ Update the summary using this exact structure. PRESERVE all existing information
 ## Critical Context
 [Any specific values, error messages, configuration details, or data that would be lost without explicit preservation]
 
-## Tools & Patterns
-[Which tools were used, how they were used effectively, and any tool-specific discoveries. Accumulate across compactions.]
-
 Target ~{summary_budget} tokens. Be specific — include file paths, command outputs, error messages, and concrete values rather than vague descriptions.
 
 Write only the summary body. Do not include any preamble or prefix."""
@@ -385,9 +348,6 @@ Use this exact structure:
 ## Critical Context
 [Any specific values, error messages, configuration details, or data that would be lost without explicit preservation]
 
-## Tools & Patterns
-[Which tools were used, how they were used effectively, and any tool-specific discoveries (e.g., preferred flags, working invocations, successful command patterns)]
-
 Target ~{summary_budget} tokens. Be specific — include file paths, command outputs, error messages, and concrete values rather than vague descriptions. The goal is to prevent the next assistant from repeating work or losing important details.
 
 Write only the summary body. Do not include any preamble or prefix."""
@@ -558,20 +518,13 @@ Write only the summary body. Do not include any preamble or prefix."""
         derived from ``summary_target_ratio * context_length``, so it
         scales automatically with the model's context window.
 
-        Token budget is the primary criterion.  A hard minimum of 3 messages
-        is always protected, but the budget is allowed to exceed by up to
-        1.5x to avoid cutting inside an oversized message (tool output, file
-        read, etc.).  If even the minimum 3 messages exceed 1.5x the budget
-        the cut is placed right after the head so compression still runs.
-
-        Never cuts inside a tool_call/result group.
+        Never cuts inside a tool_call/result group. Falls back to the old
+        ``protect_last_n`` if the budget would protect fewer messages.
         """
         if token_budget is None:
             token_budget = self.tail_token_budget
         n = len(messages)
-        # Hard minimum: always keep at least 3 messages in the tail
-        min_tail = min(3, n - head_end - 1) if n - head_end > 1 else 0
-        soft_ceiling = int(token_budget * 1.5)
+        min_tail = self.protect_last_n
         accumulated = 0
         cut_idx = n  # start from beyond the end
 
@@ -584,21 +537,21 @@ Write only the summary body. Do not include any preamble or prefix."""
                 if isinstance(tc, dict):
                     args = tc.get("function", {}).get("arguments", "")
                     msg_tokens += len(args) // _CHARS_PER_TOKEN
-            # Stop once we exceed the soft ceiling (unless we haven't hit min_tail yet)
-            if accumulated + msg_tokens > soft_ceiling and (n - i) >= min_tail:
+            if accumulated + msg_tokens > token_budget and (n - i) >= min_tail:
                 break
             accumulated += msg_tokens
             cut_idx = i
 
-        # Ensure we protect at least min_tail messages
+        # Ensure we protect at least protect_last_n messages
         fallback_cut = n - min_tail
         if cut_idx > fallback_cut:
             cut_idx = fallback_cut
 
         # If the token budget would protect everything (small conversations),
-        # force a cut after the head so compression can still remove middle turns.
+        # fall back to the fixed protect_last_n approach so compression can
+        # still remove middle turns.
         if cut_idx <= head_end:
-            cut_idx = max(fallback_cut, head_end + 1)
+            cut_idx = fallback_cut
 
         # Align to avoid splitting tool groups
         cut_idx = self._align_boundary_backward(messages, cut_idx)
@@ -623,13 +576,12 @@ Write only the summary body. Do not include any preamble or prefix."""
         up so the API never receives mismatched IDs.
         """
         n_messages = len(messages)
-        # Only need head + 3 tail messages minimum (token budget decides the real tail size)
-        _min_for_compress = self.protect_first_n + 3 + 1
-        if n_messages <= _min_for_compress:
+        if n_messages <= self.protect_first_n + self.protect_last_n + 1:
             if not self.quiet_mode:
                 logger.warning(
                     "Cannot compress: only %d messages (need > %d)",
-                    n_messages, _min_for_compress,
+                    n_messages,
+                    self.protect_first_n + self.protect_last_n + 1,
                 )
             return messages
 
@@ -637,8 +589,7 @@ Write only the summary body. Do not include any preamble or prefix."""
 
         # Phase 1: Prune old tool results (cheap, no LLM call)
         messages, pruned_count = self._prune_old_tool_results(
-            messages, protect_tail_count=self.protect_last_n,
-            protect_tail_tokens=self.tail_token_budget,
+            messages, protect_tail_count=self.protect_last_n * 3,
         )
         if pruned_count and not self.quiet_mode:
             logger.info("Pre-compression: pruned %d old tool result(s)", pruned_count)

agent/credential_pool.py

@@ -64,10 +64,10 @@ SUPPORTED_POOL_STRATEGIES = {
 }
 
 # Cooldown before retrying an exhausted credential.
-# 429 (rate-limited) and 402 (billing/quota) both cool down after 1 hour.
-# Provider-supplied reset_at timestamps override these defaults.
+# 429 (rate-limited) cools down faster since quotas reset frequently.
+# 402 (billing/quota) and other codes use a longer default.
 EXHAUSTED_TTL_429_SECONDS = 60 * 60          # 1 hour
-EXHAUSTED_TTL_DEFAULT_SECONDS = 60 * 60      # 1 hour
+EXHAUSTED_TTL_DEFAULT_SECONDS = 24 * 60 * 60 # 24 hours
 
 # Pool key prefix for custom OpenAI-compatible endpoints.
 # Custom endpoints all share provider='custom' but are keyed by their

agent/model_metadata.py

@@ -197,7 +197,6 @@ _URL_TO_PROVIDER: Dict[str, str] = {
     "api.githubcopilot.com": "copilot",
     "models.github.ai": "copilot",
     "api.fireworks.ai": "fireworks",
-    "opencode.ai": "opencode-go",
 }
 
 

agent/prompt_builder.py

@@ -349,13 +349,6 @@ PLATFORM_HINTS = {
         "only — no markdown, no formatting. SMS messages are limited to ~1600 "
         "characters, so be brief and direct."
     ),
-    "bluebubbles": (
-        "You are chatting via iMessage (BlueBubbles). iMessage does not render "
-        "markdown formatting — use plain text. Keep responses concise as they "
-        "appear as text messages. You can send media files natively: include "
-        "MEDIA:/absolute/path/to/file in your response. Images (.jpg, .png, "
-        ".heic) appear as photos and other files arrive as attachments."
-    ),
 }
 
 CONTEXT_FILE_MAX_CHARS = 20_000

cli-config.yaml.example

@@ -445,16 +445,6 @@ agent:
   # Higher = more room for complex tasks, but costs more tokens
   # Recommended: 20-30 for focused tasks, 50-100 for open exploration
   max_turns: 60
-
-  # Inactivity timeout for gateway agent runs (seconds, 0 = unlimited).
-  # The agent can run indefinitely when actively calling tools or receiving
-  # API responses.  Only fires after the agent has been idle for this duration.
-  # gateway_timeout: 1800
-
-  # Staged warning: send a warning before escalating to full timeout.
-  # Fires once per run when inactivity reaches this threshold (seconds).
-  # Set to 0 to disable the warning.
-  # gateway_timeout_warning: 900
   
   # Enable verbose logging
   verbose: false

cron/scheduler.py

@@ -44,7 +44,7 @@ logger = logging.getLogger(__name__)
 _KNOWN_DELIVERY_PLATFORMS = frozenset({
     "telegram", "discord", "slack", "whatsapp", "signal",
     "matrix", "mattermost", "homeassistant", "dingtalk", "feishu",
-    "wecom", "sms", "email", "webhook", "bluebubbles",
+    "wecom", "sms", "email", "webhook",
 })
 
 from cron.jobs import get_due_jobs, mark_job_run, save_job_output, advance_next_run
@@ -91,7 +91,7 @@ def _resolve_delivery_target(job: dict) -> Optional[dict]:
             }
         # Origin missing (e.g. job created via API/script) — try each
         # platform's home channel as a fallback instead of silently dropping.
-        for platform_name in ("matrix", "telegram", "discord", "slack", "bluebubbles"):
+        for platform_name in ("matrix", "telegram", "discord", "slack"):
             chat_id = os.getenv(f"{platform_name.upper()}_HOME_CHANNEL", "")
             if chat_id:
                 logger.info(
@@ -236,7 +236,6 @@ def _deliver_result(job: dict, content: str, adapters=None, loop=None) -> Option
         "wecom": Platform.WECOM,
         "email": Platform.EMAIL,
         "sms": Platform.SMS,
-        "bluebubbles": Platform.BLUEBUBBLES,
     }
     platform = platform_map.get(platform_name.lower())
     if not platform:

gateway/channel_directory.py

@@ -77,7 +77,7 @@ def build_channel_directory(adapters: Dict[Any, Any]) -> Dict[str, Any]:
             logger.warning("Channel directory: failed to build %s: %s", platform.value, e)
 
     # Telegram, WhatsApp & Signal can't enumerate chats -- pull from session history
-    for plat_name in ("telegram", "whatsapp", "signal", "email", "sms", "bluebubbles"):
+    for plat_name in ("telegram", "whatsapp", "signal", "email", "sms"):
         if plat_name not in platforms:
             platforms[plat_name] = _build_from_sessions(plat_name)
 

gateway/config.py

@@ -63,7 +63,6 @@ class Platform(Enum):
     WEBHOOK = "webhook"
     FEISHU = "feishu"
     WECOM = "wecom"
-    BLUEBUBBLES = "bluebubbles"
 
 
 @dataclass
@@ -288,9 +287,6 @@ class GatewayConfig:
             # WeCom uses extra dict for bot credentials
             elif platform == Platform.WECOM and config.extra.get("bot_id"):
                 connected.append(platform)
-            # BlueBubbles uses extra dict for local server config
-            elif platform == Platform.BLUEBUBBLES and config.extra.get("server_url") and config.extra.get("password"):
-                connected.append(platform)
         return connected
     
     def get_home_channel(self, platform: Platform) -> Optional[HomeChannel]:
@@ -716,13 +712,6 @@ def _apply_env_overrides(config: GatewayConfig) -> None:
             name=os.getenv("DISCORD_HOME_CHANNEL_NAME", "Home"),
         )
     
-    # Reply threading mode for Discord (off/first/all)
-    discord_reply_mode = os.getenv("DISCORD_REPLY_TO_MODE", "").lower()
-    if discord_reply_mode in ("off", "first", "all"):
-        if Platform.DISCORD not in config.platforms:
-            config.platforms[Platform.DISCORD] = PlatformConfig()
-        config.platforms[Platform.DISCORD].reply_to_mode = discord_reply_mode
-    
     # WhatsApp (typically uses different auth mechanism)
     whatsapp_enabled = os.getenv("WHATSAPP_ENABLED", "").lower() in ("true", "1", "yes")
     if whatsapp_enabled:
@@ -952,29 +941,6 @@ def _apply_env_overrides(config: GatewayConfig) -> None:
                 name=os.getenv("WECOM_HOME_CHANNEL_NAME", "Home"),
             )
 
-    # BlueBubbles (iMessage)
-    bluebubbles_server_url = os.getenv("BLUEBUBBLES_SERVER_URL")
-    bluebubbles_password = os.getenv("BLUEBUBBLES_PASSWORD")
-    if bluebubbles_server_url and bluebubbles_password:
-        if Platform.BLUEBUBBLES not in config.platforms:
-            config.platforms[Platform.BLUEBUBBLES] = PlatformConfig()
-        config.platforms[Platform.BLUEBUBBLES].enabled = True
-        config.platforms[Platform.BLUEBUBBLES].extra.update({
-            "server_url": bluebubbles_server_url.rstrip("/"),
-            "password": bluebubbles_password,
-            "webhook_host": os.getenv("BLUEBUBBLES_WEBHOOK_HOST", "127.0.0.1"),
-            "webhook_port": int(os.getenv("BLUEBUBBLES_WEBHOOK_PORT", "8645")),
-            "webhook_path": os.getenv("BLUEBUBBLES_WEBHOOK_PATH", "/bluebubbles-webhook"),
-            "send_read_receipts": os.getenv("BLUEBUBBLES_SEND_READ_RECEIPTS", "true").lower() in ("true", "1", "yes"),
-        })
-    bluebubbles_home = os.getenv("BLUEBUBBLES_HOME_CHANNEL")
-    if bluebubbles_home and Platform.BLUEBUBBLES in config.platforms:
-        config.platforms[Platform.BLUEBUBBLES].home_channel = HomeChannel(
-            platform=Platform.BLUEBUBBLES,
-            chat_id=bluebubbles_home,
-            name=os.getenv("BLUEBUBBLES_HOME_CHANNEL_NAME", "Home"),
-        )
-
     # Session settings
     idle_minutes = os.getenv("SESSION_IDLE_MINUTES")
     if idle_minutes:

gateway/platforms/base.py

@@ -298,7 +298,6 @@ SUPPORTED_DOCUMENT_TYPES = {
     ".pdf": "application/pdf",
     ".md": "text/markdown",
     ".txt": "text/plain",
-    ".log": "text/plain",
     ".zip": "application/zip",
     ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
     ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
@@ -408,10 +407,6 @@ class MessageEvent:
     # Auto-loaded skill for topic/channel bindings (e.g., Telegram DM Topics)
     auto_skill: Optional[str] = None
     
-    # Internal flag — set for synthetic events (e.g. background process
-    # completion notifications) that must bypass user authorization checks.
-    internal: bool = False
-
     # Timestamps
     timestamp: datetime = field(default_factory=datetime.now)
     

gateway/platforms/bluebubbles.py

@@ -1,828 +0,0 @@
-"""BlueBubbles iMessage platform adapter.
-
-Uses the local BlueBubbles macOS server for outbound REST sends and inbound
-webhooks.  Supports text messaging, media attachments (images, voice, video,
-documents), tapback reactions, typing indicators, and read receipts.
-
-Architecture based on PR #5869 (benjaminsehl) with inbound attachment
-downloading from PR #4588 (YuhangLin).
-"""
-
-import asyncio
-import json
-import logging
-import os
-import re
-import uuid
-from datetime import datetime
-from typing import Any, Dict, List, Optional
-from urllib.parse import quote
-
-import httpx
-
-from gateway.config import Platform, PlatformConfig
-from gateway.platforms.base import (
-    BasePlatformAdapter,
-    MessageEvent,
-    MessageType,
-    SendResult,
-    cache_image_from_bytes,
-    cache_audio_from_bytes,
-    cache_document_from_bytes,
-)
-
-logger = logging.getLogger(__name__)
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-
-DEFAULT_WEBHOOK_HOST = "127.0.0.1"
-DEFAULT_WEBHOOK_PORT = 8645
-DEFAULT_WEBHOOK_PATH = "/bluebubbles-webhook"
-MAX_TEXT_LENGTH = 4000
-
-# Tapback reaction codes (BlueBubbles associatedMessageType values)
-_TAPBACK_ADDED = {
-    2000: "love", 2001: "like", 2002: "dislike",
-    2003: "laugh", 2004: "emphasize", 2005: "question",
-}
-_TAPBACK_REMOVED = {
-    3000: "love", 3001: "like", 3002: "dislike",
-    3003: "laugh", 3004: "emphasize", 3005: "question",
-}
-
-# Webhook event types that carry user messages
-_MESSAGE_EVENTS = {"new-message", "message", "updated-message"}
-
-# Log redaction patterns
-_PHONE_RE = re.compile(r"\+?\d{7,15}")
-_EMAIL_RE = re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+")
-
-
-def _redact(text: str) -> str:
-    """Redact phone numbers and emails from log output."""
-    text = _PHONE_RE.sub("[REDACTED]", text)
-    text = _EMAIL_RE.sub("[REDACTED]", text)
-    return text
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def check_bluebubbles_requirements() -> bool:
-    try:
-        import aiohttp  # noqa: F401
-        import httpx as _httpx  # noqa: F401
-    except ImportError:
-        return False
-    return True
-
-
-def _normalize_server_url(raw: str) -> str:
-    value = (raw or "").strip()
-    if not value:
-        return ""
-    if not re.match(r"^https?://", value, flags=re.I):
-        value = f"http://{value}"
-    return value.rstrip("/")
-
-
-def _strip_markdown(text: str) -> str:
-    """Strip common markdown formatting for iMessage plain-text delivery."""
-    text = re.sub(r"\*\*(.+?)\*\*", r"\1", text, flags=re.DOTALL)
-    text = re.sub(r"\*(.+?)\*", r"\1", text, flags=re.DOTALL)
-    text = re.sub(r"__(.+?)__", r"\1", text, flags=re.DOTALL)
-    text = re.sub(r"_(.+?)_", r"\1", text, flags=re.DOTALL)
-    text = re.sub(r"```[a-zA-Z0-9_+-]*\n?", "", text)
-    text = re.sub(r"`(.+?)`", r"\1", text)
-    text = re.sub(r"^#{1,6}\s+", "", text, flags=re.MULTILINE)
-    text = re.sub(r"\[([^\]]+)\]\(([^\)]+)\)", r"\1", text)
-    text = re.sub(r"\n{3,}", "\n\n", text)
-    return text.strip()
-
-
-# ---------------------------------------------------------------------------
-# Adapter
-# ---------------------------------------------------------------------------
-
-class BlueBubblesAdapter(BasePlatformAdapter):
-    platform = Platform.BLUEBUBBLES
-    MAX_MESSAGE_LENGTH = MAX_TEXT_LENGTH
-
-    def __init__(self, config: PlatformConfig):
-        super().__init__(config, Platform.BLUEBUBBLES)
-        extra = config.extra or {}
-        self.server_url = _normalize_server_url(
-            extra.get("server_url") or os.getenv("BLUEBUBBLES_SERVER_URL", "")
-        )
-        self.password = extra.get("password") or os.getenv("BLUEBUBBLES_PASSWORD", "")
-        self.webhook_host = (
-            extra.get("webhook_host")
-            or os.getenv("BLUEBUBBLES_WEBHOOK_HOST", DEFAULT_WEBHOOK_HOST)
-        )
-        self.webhook_port = int(
-            extra.get("webhook_port")
-            or os.getenv("BLUEBUBBLES_WEBHOOK_PORT", str(DEFAULT_WEBHOOK_PORT))
-        )
-        self.webhook_path = (
-            extra.get("webhook_path")
-            or os.getenv("BLUEBUBBLES_WEBHOOK_PATH", DEFAULT_WEBHOOK_PATH)
-        )
-        if not str(self.webhook_path).startswith("/"):
-            self.webhook_path = f"/{self.webhook_path}"
-        self.send_read_receipts = bool(extra.get("send_read_receipts", True))
-        self.client: Optional[httpx.AsyncClient] = None
-        self._runner = None
-        self._private_api_enabled: Optional[bool] = None
-        self._helper_connected: bool = False
-        self._guid_cache: Dict[str, str] = {}
-
-    # ------------------------------------------------------------------
-    # API helpers
-    # ------------------------------------------------------------------
-
-    def _api_url(self, path: str) -> str:
-        sep = "&" if "?" in path else "?"
-        return f"{self.server_url}{path}{sep}password={quote(self.password, safe='')}"
-
-    async def _api_get(self, path: str) -> Dict[str, Any]:
-        assert self.client is not None
-        res = await self.client.get(self._api_url(path))
-        res.raise_for_status()
-        return res.json()
-
-    async def _api_post(self, path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        assert self.client is not None
-        res = await self.client.post(self._api_url(path), json=payload)
-        res.raise_for_status()
-        return res.json()
-
-    # ------------------------------------------------------------------
-    # Lifecycle
-    # ------------------------------------------------------------------
-
-    async def connect(self) -> bool:
-        if not self.server_url or not self.password:
-            logger.error(
-                "[bluebubbles] BLUEBUBBLES_SERVER_URL and BLUEBUBBLES_PASSWORD are required"
-            )
-            return False
-        from aiohttp import web
-
-        self.client = httpx.AsyncClient(timeout=30.0)
-        try:
-            await self._api_get("/api/v1/ping")
-            info = await self._api_get("/api/v1/server/info")
-            server_data = (info or {}).get("data", {})
-            self._private_api_enabled = bool(server_data.get("private_api"))
-            self._helper_connected = bool(server_data.get("helper_connected"))
-            logger.info(
-                "[bluebubbles] connected to %s (private_api=%s, helper=%s)",
-                self.server_url,
-                self._private_api_enabled,
-                self._helper_connected,
-            )
-        except Exception as exc:
-            logger.error(
-                "[bluebubbles] cannot reach server at %s: %s", self.server_url, exc
-            )
-            if self.client:
-                await self.client.aclose()
-                self.client = None
-            return False
-
-        app = web.Application()
-        app.router.add_get("/health", lambda _: web.Response(text="ok"))
-        app.router.add_post(self.webhook_path, self._handle_webhook)
-        self._runner = web.AppRunner(app)
-        await self._runner.setup()
-        site = web.TCPSite(self._runner, self.webhook_host, self.webhook_port)
-        await site.start()
-        self._mark_connected()
-        logger.info(
-            "[bluebubbles] webhook listening on http://%s:%s%s",
-            self.webhook_host,
-            self.webhook_port,
-            self.webhook_path,
-        )
-        return True
-
-    async def disconnect(self) -> None:
-        if self.client:
-            await self.client.aclose()
-            self.client = None
-        if self._runner:
-            await self._runner.cleanup()
-            self._runner = None
-        self._mark_disconnected()
-
-    # ------------------------------------------------------------------
-    # Chat GUID resolution
-    # ------------------------------------------------------------------
-
-    async def _resolve_chat_guid(self, target: str) -> Optional[str]:
-        """Resolve an email/phone to a BlueBubbles chat GUID.
-
-        If *target* already contains a semicolon (raw GUID format like
-        ``iMessage;-;user@example.com``), it is returned as-is.  Otherwise
-        the adapter queries the BlueBubbles chat list and matches on
-        ``chatIdentifier`` or participant address.
-        """
-        target = (target or "").strip()
-        if not target:
-            return None
-        # Already a raw GUID
-        if ";" in target:
-            return target
-        if target in self._guid_cache:
-            return self._guid_cache[target]
-        try:
-            payload = await self._api_post(
-                "/api/v1/chat/query",
-                {"limit": 100, "offset": 0, "with": ["participants"]},
-            )
-            for chat in payload.get("data", []) or []:
-                guid = chat.get("guid") or chat.get("chatGuid")
-                identifier = chat.get("chatIdentifier") or chat.get("identifier")
-                if identifier == target:
-                    if guid:
-                        self._guid_cache[target] = guid
-                    return guid
-                for part in chat.get("participants", []) or []:
-                    if (part.get("address") or "").strip() == target and guid:
-                        self._guid_cache[target] = guid
-                        return guid
-        except Exception:
-            pass
-        return None
-
-    async def _create_chat_for_handle(
-        self, address: str, message: str
-    ) -> SendResult:
-        """Create a new chat by sending the first message to *address*."""
-        payload = {
-            "addresses": [address],
-            "message": message,
-            "tempGuid": f"temp-{datetime.utcnow().timestamp()}",
-        }
-        try:
-            res = await self._api_post("/api/v1/chat/new", payload)
-            data = res.get("data") or {}
-            msg_id = data.get("guid") or data.get("messageGuid") or "ok"
-            return SendResult(success=True, message_id=str(msg_id), raw_response=res)
-        except Exception as exc:
-            return SendResult(success=False, error=str(exc))
-
-    # ------------------------------------------------------------------
-    # Text sending
-    # ------------------------------------------------------------------
-
-    async def send(
-        self,
-        chat_id: str,
-        content: str,
-        reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> SendResult:
-        text = _strip_markdown(content or "")
-        if not text:
-            return SendResult(success=False, error="BlueBubbles send requires text")
-        chunks = self.truncate_message(text, max_length=self.MAX_MESSAGE_LENGTH)
-        last = SendResult(success=True)
-        for chunk in chunks:
-            guid = await self._resolve_chat_guid(chat_id)
-            if not guid:
-                # If the target looks like an address, try creating a new chat
-                if self._private_api_enabled and (
-                    "@" in chat_id or re.match(r"^\+\d+", chat_id)
-                ):
-                    return await self._create_chat_for_handle(chat_id, chunk)
-                return SendResult(
-                    success=False,
-                    error=f"BlueBubbles chat not found for target: {chat_id}",
-                )
-            payload: Dict[str, Any] = {
-                "chatGuid": guid,
-                "tempGuid": f"temp-{datetime.utcnow().timestamp()}",
-                "message": chunk,
-            }
-            if reply_to and self._private_api_enabled and self._helper_connected:
-                payload["method"] = "private-api"
-                payload["selectedMessageGuid"] = reply_to
-                payload["partIndex"] = 0
-            try:
-                res = await self._api_post("/api/v1/message/text", payload)
-                data = res.get("data") or {}
-                msg_id = data.get("guid") or data.get("messageGuid") or "ok"
-                last = SendResult(
-                    success=True, message_id=str(msg_id), raw_response=res
-                )
-            except Exception as exc:
-                return SendResult(success=False, error=str(exc))
-        return last
-
-    # ------------------------------------------------------------------
-    # Media sending (outbound)
-    # ------------------------------------------------------------------
-
-    async def _send_attachment(
-        self,
-        chat_id: str,
-        file_path: str,
-        filename: Optional[str] = None,
-        caption: Optional[str] = None,
-        is_audio_message: bool = False,
-    ) -> SendResult:
-        """Send a file attachment via BlueBubbles multipart upload."""
-        if not self.client:
-            return SendResult(success=False, error="Not connected")
-        if not os.path.isfile(file_path):
-            return SendResult(success=False, error=f"File not found: {file_path}")
-
-        guid = await self._resolve_chat_guid(chat_id)
-        if not guid:
-            return SendResult(success=False, error=f"Chat not found: {chat_id}")
-
-        fname = filename or os.path.basename(file_path)
-        try:
-            with open(file_path, "rb") as f:
-                files = {"attachment": (fname, f, "application/octet-stream")}
-                data: Dict[str, str] = {
-                    "chatGuid": guid,
-                    "name": fname,
-                    "tempGuid": uuid.uuid4().hex,
-                }
-                if is_audio_message:
-                    data["isAudioMessage"] = "true"
-                res = await self.client.post(
-                    self._api_url("/api/v1/message/attachment"),
-                    files=files,
-                    data=data,
-                    timeout=120,
-                )
-                res.raise_for_status()
-                result = res.json()
-
-            if caption:
-                await self.send(chat_id, caption)
-
-            if result.get("status") == 200:
-                rdata = result.get("data") or {}
-                msg_id = rdata.get("guid") if isinstance(rdata, dict) else None
-                return SendResult(
-                    success=True, message_id=msg_id, raw_response=result
-                )
-            return SendResult(
-                success=False,
-                error=result.get("message", "Attachment upload failed"),
-            )
-        except Exception as e:
-            return SendResult(success=False, error=str(e))
-
-    async def send_image(
-        self,
-        chat_id: str,
-        image_url: str,
-        caption: Optional[str] = None,
-        reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> SendResult:
-        try:
-            from gateway.platforms.base import cache_image_from_url
-
-            local_path = await cache_image_from_url(image_url)
-            return await self._send_attachment(chat_id, local_path, caption=caption)
-        except Exception:
-            return await super().send_image(chat_id, image_url, caption, reply_to)
-
-    async def send_image_file(
-        self,
-        chat_id: str,
-        image_path: str,
-        caption: Optional[str] = None,
-        reply_to: Optional[str] = None,
-        **kwargs,
-    ) -> SendResult:
-        return await self._send_attachment(chat_id, image_path, caption=caption)
-
-    async def send_voice(
-        self,
-        chat_id: str,
-        audio_path: str,
-        caption: Optional[str] = None,
-        reply_to: Optional[str] = None,
-        **kwargs,
-    ) -> SendResult:
-        return await self._send_attachment(
-            chat_id, audio_path, caption=caption, is_audio_message=True
-        )
-
-    async def send_video(
-        self,
-        chat_id: str,
-        video_path: str,
-        caption: Optional[str] = None,
-        reply_to: Optional[str] = None,
-        **kwargs,
-    ) -> SendResult:
-        return await self._send_attachment(chat_id, video_path, caption=caption)
-
-    async def send_document(
-        self,
-        chat_id: str,
-        file_path: str,
-        caption: Optional[str] = None,
-        file_name: Optional[str] = None,
-        reply_to: Optional[str] = None,
-        **kwargs,
-    ) -> SendResult:
-        return await self._send_attachment(
-            chat_id, file_path, filename=file_name, caption=caption
-        )
-
-    async def send_animation(
-        self,
-        chat_id: str,
-        animation_url: str,
-        caption: Optional[str] = None,
-        reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> SendResult:
-        return await self.send_image(
-            chat_id, animation_url, caption, reply_to, metadata
-        )
-
-    # ------------------------------------------------------------------
-    # Typing indicators
-    # ------------------------------------------------------------------
-
-    async def send_typing(self, chat_id: str, metadata=None) -> None:
-        if not self._private_api_enabled or not self._helper_connected or not self.client:
-            return
-        try:
-            guid = await self._resolve_chat_guid(chat_id)
-            if guid:
-                encoded = quote(guid, safe="")
-                await self.client.post(
-                    self._api_url(f"/api/v1/chat/{encoded}/typing"), timeout=5
-                )
-        except Exception:
-            pass
-
-    async def stop_typing(self, chat_id: str) -> None:
-        if not self._private_api_enabled or not self._helper_connected or not self.client:
-            return
-        try:
-            guid = await self._resolve_chat_guid(chat_id)
-            if guid:
-                encoded = quote(guid, safe="")
-                await self.client.delete(
-                    self._api_url(f"/api/v1/chat/{encoded}/typing"), timeout=5
-                )
-        except Exception:
-            pass
-
-    # ------------------------------------------------------------------
-    # Read receipts
-    # ------------------------------------------------------------------
-
-    async def mark_read(self, chat_id: str) -> bool:
-        if not self._private_api_enabled or not self._helper_connected or not self.client:
-            return False
-        try:
-            guid = await self._resolve_chat_guid(chat_id)
-            if guid:
-                encoded = quote(guid, safe="")
-                await self.client.post(
-                    self._api_url(f"/api/v1/chat/{encoded}/read"), timeout=5
-                )
-                return True
-        except Exception:
-            pass
-        return False
-
-    # ------------------------------------------------------------------
-    # Tapback reactions
-    # ------------------------------------------------------------------
-
-    async def send_reaction(
-        self,
-        chat_id: str,
-        message_guid: str,
-        reaction: str,
-        part_index: int = 0,
-    ) -> SendResult:
-        """Send a tapback reaction (requires Private API helper)."""
-        if not self._private_api_enabled or not self._helper_connected:
-            return SendResult(
-                success=False, error="Private API helper not connected"
-            )
-        guid = await self._resolve_chat_guid(chat_id)
-        if not guid:
-            return SendResult(success=False, error=f"Chat not found: {chat_id}")
-        try:
-            res = await self._api_post(
-                "/api/v1/message/react",
-                {
-                    "chatGuid": guid,
-                    "selectedMessageGuid": message_guid,
-                    "reaction": reaction,
-                    "partIndex": part_index,
-                },
-            )
-            return SendResult(success=True, raw_response=res)
-        except Exception as exc:
-            return SendResult(success=False, error=str(exc))
-
-    # ------------------------------------------------------------------
-    # Chat info
-    # ------------------------------------------------------------------
-
-    async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
-        is_group = ";+;" in (chat_id or "")
-        info: Dict[str, Any] = {
-            "name": chat_id,
-            "type": "group" if is_group else "dm",
-        }
-        try:
-            guid = await self._resolve_chat_guid(chat_id)
-            if guid:
-                encoded = quote(guid, safe="")
-                res = await self._api_get(
-                    f"/api/v1/chat/{encoded}?with=participants"
-                )
-                data = (res or {}).get("data", {})
-                display_name = (
-                    data.get("displayName")
-                    or data.get("chatIdentifier")
-                    or chat_id
-                )
-                participants = []
-                for p in data.get("participants", []) or []:
-                    addr = (p.get("address") or "").strip()
-                    if addr:
-                        participants.append(addr)
-                info["name"] = display_name
-                if participants:
-                    info["participants"] = participants
-        except Exception:
-            pass
-        return info
-
-    def format_message(self, content: str) -> str:
-        return _strip_markdown(content)
-
-    # ------------------------------------------------------------------
-    # Inbound attachment downloading (from #4588)
-    # ------------------------------------------------------------------
-
-    async def _download_attachment(
-        self, att_guid: str, att_meta: Dict[str, Any]
-    ) -> Optional[str]:
-        """Download an attachment from BlueBubbles and cache it locally.
-
-        Returns the local file path on success, None on failure.
-        """
-        if not self.client:
-            return None
-        try:
-            encoded = quote(att_guid, safe="")
-            resp = await self.client.get(
-                self._api_url(f"/api/v1/attachment/{encoded}/download"),
-                timeout=60,
-                follow_redirects=True,
-            )
-            resp.raise_for_status()
-            data = resp.content
-
-            mime = (att_meta.get("mimeType") or "").lower()
-            transfer_name = att_meta.get("transferName", "")
-
-            if mime.startswith("image/"):
-                ext_map = {
-                    "image/jpeg": ".jpg",
-                    "image/png": ".png",
-                    "image/gif": ".gif",
-                    "image/webp": ".webp",
-                    "image/heic": ".jpg",
-                    "image/heif": ".jpg",
-                    "image/tiff": ".jpg",
-                }
-                ext = ext_map.get(mime, ".jpg")
-                return cache_image_from_bytes(data, ext)
-
-            if mime.startswith("audio/"):
-                ext_map = {
-                    "audio/mp3": ".mp3",
-                    "audio/mpeg": ".mp3",
-                    "audio/ogg": ".ogg",
-                    "audio/wav": ".wav",
-                    "audio/x-caf": ".mp3",
-                    "audio/mp4": ".m4a",
-                    "audio/aac": ".m4a",
-                }
-                ext = ext_map.get(mime, ".mp3")
-                return cache_audio_from_bytes(data, ext)
-
-            # Videos, documents, and everything else
-            filename = transfer_name or f"file_{uuid.uuid4().hex[:8]}"
-            return cache_document_from_bytes(data, filename)
-
-        except Exception as exc:
-            logger.warning(
-                "[bluebubbles] failed to download attachment %s: %s",
-                _redact(att_guid),
-                exc,
-            )
-            return None
-
-    # ------------------------------------------------------------------
-    # Webhook handling
-    # ------------------------------------------------------------------
-
-    def _extract_payload_record(
-        self, payload: Dict[str, Any]
-    ) -> Optional[Dict[str, Any]]:
-        data = payload.get("data")
-        if isinstance(data, dict):
-            return data
-        if isinstance(data, list):
-            for item in data:
-                if isinstance(item, dict):
-                    return item
-        if isinstance(payload.get("message"), dict):
-            return payload.get("message")
-        return payload if isinstance(payload, dict) else None
-
-    @staticmethod
-    def _value(*candidates: Any) -> Optional[str]:
-        for candidate in candidates:
-            if isinstance(candidate, str) and candidate.strip():
-                return candidate.strip()
-        return None
-
-    async def _handle_webhook(self, request):
-        from aiohttp import web
-
-        token = (
-            request.query.get("password")
-            or request.query.get("guid")
-            or request.headers.get("x-password")
-            or request.headers.get("x-guid")
-            or request.headers.get("x-bluebubbles-guid")
-        )
-        if token != self.password:
-            return web.json_response({"error": "unauthorized"}, status=401)
-        try:
-            raw = await request.read()
-            body = raw.decode("utf-8", errors="replace")
-            try:
-                payload = json.loads(body)
-            except Exception:
-                from urllib.parse import parse_qs
-
-                form = parse_qs(body)
-                payload_str = (
-                    form.get("payload")
-                    or form.get("data")
-                    or form.get("message")
-                    or [""]
-                )[0]
-                payload = json.loads(payload_str) if payload_str else {}
-        except Exception as exc:
-            logger.error("[bluebubbles] webhook parse error: %s", exc)
-            return web.json_response({"error": "invalid payload"}, status=400)
-
-        event_type = self._value(payload.get("type"), payload.get("event")) or ""
-        # Only process message events; silently acknowledge everything else
-        if event_type and event_type not in _MESSAGE_EVENTS:
-            return web.Response(text="ok")
-
-        record = self._extract_payload_record(payload) or {}
-        is_from_me = bool(
-            record.get("isFromMe")
-            or record.get("fromMe")
-            or record.get("is_from_me")
-        )
-        if is_from_me:
-            return web.Response(text="ok")
-
-        # Skip tapback reactions delivered as messages
-        assoc_type = record.get("associatedMessageType")
-        if isinstance(assoc_type, int) and assoc_type in {
-            **_TAPBACK_ADDED,
-            **_TAPBACK_REMOVED,
-        }:
-            return web.Response(text="ok")
-
-        text = (
-            self._value(
-                record.get("text"), record.get("message"), record.get("body")
-            )
-            or ""
-        )
-
-        # --- Inbound attachment handling ---
-        attachments = record.get("attachments") or []
-        media_urls: List[str] = []
-        media_types: List[str] = []
-        msg_type = MessageType.TEXT
-
-        for att in attachments:
-            att_guid = att.get("guid", "")
-            if not att_guid:
-                continue
-            cached = await self._download_attachment(att_guid, att)
-            if cached:
-                mime = (att.get("mimeType") or "").lower()
-                media_urls.append(cached)
-                media_types.append(mime)
-                if mime.startswith("image/"):
-                    msg_type = MessageType.PHOTO
-                elif mime.startswith("audio/") or (att.get("uti") or "").endswith(
-                    "caf"
-                ):
-                    msg_type = MessageType.VOICE
-                elif mime.startswith("video/"):
-                    msg_type = MessageType.VIDEO
-                else:
-                    msg_type = MessageType.DOCUMENT
-
-        # With multiple attachments, prefer PHOTO if any images present
-        if len(media_urls) > 1:
-            mime_prefixes = {(m or "").split("/")[0] for m in media_types}
-            if "image" in mime_prefixes:
-                msg_type = MessageType.PHOTO
-
-        if not text and media_urls:
-            text = "(attachment)"
-        # --- End attachment handling ---
-
-        chat_guid = self._value(
-            record.get("chatGuid"),
-            payload.get("chatGuid"),
-            record.get("chat_guid"),
-            payload.get("chat_guid"),
-            payload.get("guid"),
-        )
-        chat_identifier = self._value(
-            record.get("chatIdentifier"),
-            record.get("identifier"),
-            payload.get("chatIdentifier"),
-            payload.get("identifier"),
-        )
-        sender = (
-            self._value(
-                record.get("handle", {}).get("address")
-                if isinstance(record.get("handle"), dict)
-                else None,
-                record.get("sender"),
-                record.get("from"),
-                record.get("address"),
-            )
-            or chat_identifier
-            or chat_guid
-        )
-        if not (chat_guid or chat_identifier) and sender:
-            chat_identifier = sender
-        if not sender or not (chat_guid or chat_identifier) or not text:
-            return web.json_response({"error": "missing message fields"}, status=400)
-
-        session_chat_id = chat_guid or chat_identifier
-        is_group = bool(record.get("isGroup")) or (";+;" in (chat_guid or ""))
-        source = self.build_source(
-            chat_id=session_chat_id,
-            chat_name=chat_identifier or sender,
-            chat_type="group" if is_group else "dm",
-            user_id=sender,
-            user_name=sender,
-            chat_id_alt=chat_identifier,
-        )
-        event = MessageEvent(
-            text=text,
-            message_type=msg_type,
-            source=source,
-            raw_message=payload,
-            message_id=self._value(
-                record.get("guid"),
-                record.get("messageGuid"),
-                record.get("id"),
-            ),
-            reply_to_message_id=self._value(
-                record.get("threadOriginatorGuid"),
-                record.get("associatedMessageGuid"),
-            ),
-            media_urls=media_urls,
-            media_types=media_types,
-        )
-        task = asyncio.create_task(self.handle_message(event))
-        self._background_tasks.add(task)
-        task.add_done_callback(self._background_tasks.discard)
-
-        # Fire-and-forget read receipt
-        if self.send_read_receipts and session_chat_id:
-            asyncio.create_task(self.mark_read(session_chat_id))
-
-        return web.Response(text="ok")

gateway/platforms/discord.py

@@ -455,9 +455,6 @@ class DiscordAdapter(BasePlatformAdapter):
         self._seen_messages: Dict[str, float] = {}
         self._SEEN_TTL = 300   # 5 minutes
         self._SEEN_MAX = 2000  # prune threshold
-        # Reply threading mode: "off" (no replies), "first" (reply on first
-        # chunk only, default), "all" (reply-reference on every chunk).
-        self._reply_to_mode: str = getattr(config, 'reply_to_mode', 'first') or 'first'
 
     async def connect(self) -> bool:
         """Connect to Discord and start receiving events."""
@@ -777,7 +774,7 @@ class DiscordAdapter(BasePlatformAdapter):
             message_ids = []
             reference = None
 
-            if reply_to and self._reply_to_mode != "off":
+            if reply_to:
                 try:
                     ref_msg = await channel.fetch_message(int(reply_to))
                     reference = ref_msg
@@ -785,10 +782,7 @@ class DiscordAdapter(BasePlatformAdapter):
                     logger.debug("Could not fetch reply-to message: %s", e)
 
             for i, chunk in enumerate(chunks):
-                if self._reply_to_mode == "all":
-                    chunk_reference = reference
-                else:  # "first" (default) or "off"
-                    chunk_reference = reference if i == 0 else None
+                chunk_reference = reference if i == 0 else None
                 try:
                     msg = await channel.send(
                         content=chunk,
@@ -1767,9 +1761,8 @@ class DiscordAdapter(BasePlatformAdapter):
             if hasattr(interaction.channel, "guild") and interaction.channel.guild:
                 chat_name = f"{interaction.channel.guild.name} / #{chat_name}"
 
-        # Get channel topic (if available).
-        # For forum threads, inherit the parent forum's topic.
-        chat_topic = self._get_effective_topic(interaction.channel, is_thread=is_thread)
+        # Get channel topic (if available)
+        chat_topic = getattr(interaction.channel, "topic", None)
 
         source = self.build_source(
             chat_id=str(interaction.channel_id),
@@ -1843,10 +1836,6 @@ class DiscordAdapter(BasePlatformAdapter):
 
         chat_name = f"{guild_name} / {thread_name}" if guild_name else thread_name
 
-        # Inherit forum topic when the thread was created inside a forum channel.
-        _chan = getattr(interaction, "channel", None)
-        chat_topic = self._get_effective_topic(_chan, is_thread=True) if _chan else None
-
         source = self.build_source(
             chat_id=thread_id,
             chat_name=chat_name,
@@ -1854,7 +1843,6 @@ class DiscordAdapter(BasePlatformAdapter):
             user_id=str(interaction.user.id),
             user_name=interaction.user.display_name,
             thread_id=thread_id,
-            chat_topic=chat_topic,
         )
 
         event = MessageEvent(
@@ -2140,15 +2128,6 @@ class DiscordAdapter(BasePlatformAdapter):
                 return True
         return False
 
-    def _get_effective_topic(self, channel: Any, is_thread: bool = False) -> Optional[str]:
-        """Return the channel topic, falling back to the parent forum's topic for forum threads."""
-        topic = getattr(channel, "topic", None)
-        if not topic and is_thread:
-            parent = getattr(channel, "parent", None)
-            if parent and self._is_forum_parent(parent):
-                topic = getattr(parent, "topic", None)
-        return topic
-
     def _format_thread_chat_name(self, thread: Any) -> str:
         """Build a readable chat name for thread-like Discord channels, including forum context when available."""
         thread_name = getattr(thread, "name", None) or str(getattr(thread, "id", "thread"))
@@ -2316,10 +2295,8 @@ class DiscordAdapter(BasePlatformAdapter):
             if hasattr(message.channel, "guild") and message.channel.guild:
                 chat_name = f"{message.channel.guild.name} / #{chat_name}"
 
-        # Get channel topic (if available - TextChannels have topics, DMs/threads don't).
-        # For threads whose parent is a forum channel, inherit the parent's topic
-        # so forum descriptions (e.g. project instructions) appear in the session context.
-        chat_topic = self._get_effective_topic(message.channel, is_thread=is_thread)
+        # Get channel topic (if available - TextChannels have topics, DMs/threads don't)
+        chat_topic = getattr(message.channel, "topic", None)
 
         # Build source
         source = self.build_source(
@@ -2382,7 +2359,7 @@ class DiscordAdapter(BasePlatformAdapter):
                         ext or "unknown", content_type,
                     )
                 else:
-                    MAX_DOC_BYTES = 32 * 1024 * 1024
+                    MAX_DOC_BYTES = 20 * 1024 * 1024
                     if att.size and att.size > MAX_DOC_BYTES:
                         logger.warning(
                             "[Discord] Document too large (%s bytes), skipping: %s",
@@ -2406,9 +2383,9 @@ class DiscordAdapter(BasePlatformAdapter):
                             media_urls.append(cached_path)
                             media_types.append(doc_mime)
                             logger.info("[Discord] Cached user document: %s", cached_path)
-                            # Inject text content for plain-text documents (capped at 100 KB)
+                            # Inject text content for .txt/.md files (capped at 100 KB)
                             MAX_TEXT_INJECT_BYTES = 100 * 1024
-                            if ext in (".md", ".txt", ".log") and len(raw_bytes) <= MAX_TEXT_INJECT_BYTES:
+                            if ext in (".md", ".txt") and len(raw_bytes) <= MAX_TEXT_INJECT_BYTES:
                                 try:
                                     text_content = raw_bytes.decode("utf-8")
                                     display_name = att.filename or f"document{ext}"

gateway/platforms/signal.py

@@ -647,11 +647,7 @@ class SignalAdapter(BasePlatformAdapter):
 
         if result is not None:
             self._track_sent_timestamp(result)
-            # Use the timestamp from the RPC result as a pseudo message_id.
-            # Signal doesn't have real message IDs, but the stream consumer
-            # needs a truthy value to follow its edit→fallback path correctly.
-            _msg_id = str(result.get("timestamp", "")) if isinstance(result, dict) else None
-            return SendResult(success=True, message_id=_msg_id or None)
+            return SendResult(success=True)
         return SendResult(success=False, error="RPC send failed")
 
     def _track_sent_timestamp(self, rpc_result) -> None:
@@ -841,11 +837,6 @@ class SignalAdapter(BasePlatformAdapter):
             except asyncio.CancelledError:
                 pass
 
-    async def stop_typing(self, chat_id: str) -> None:
-        """Public interface for stopping typing — called by base adapter's
-        _keep_typing finally block to clean up platform-level typing tasks."""
-        await self._stop_typing_indicator(chat_id)
-
     # ------------------------------------------------------------------
     # Chat Info
     # ------------------------------------------------------------------

gateway/platforms/slack.py

@@ -14,7 +14,7 @@ import logging
 import os
 import re
 import time
-from typing import Dict, Optional, Any, Tuple
+from typing import Dict, Optional, Any
 
 try:
     from slack_bolt.async_app import AsyncApp
@@ -95,12 +95,6 @@ class SlackAdapter(BasePlatformAdapter):
         # respond to ALL subsequent messages in that thread automatically.
         self._mentioned_threads: set = set()
         self._MENTIONED_THREADS_MAX = 5000
-        # Assistant thread metadata keyed by (channel_id, thread_ts). Slack's
-        # AI Assistant lifecycle events can arrive before/alongside message
-        # events, and they carry the user/thread identity needed for stable
-        # session + memory scoping.
-        self._assistant_threads: Dict[Tuple[str, str], Dict[str, str]] = {}
-        self._ASSISTANT_THREADS_MAX = 5000
 
     async def connect(self) -> bool:
         """Connect to Slack via Socket Mode."""
@@ -187,14 +181,6 @@ class SlackAdapter(BasePlatformAdapter):
             async def handle_app_mention(event, say):
                 pass
 
-            @self._app.event("assistant_thread_started")
-            async def handle_assistant_thread_started(event, say):
-                await self._handle_assistant_thread_lifecycle_event(event)
-
-            @self._app.event("assistant_thread_context_changed")
-            async def handle_assistant_thread_context_changed(event, say):
-                await self._handle_assistant_thread_lifecycle_event(event)
-
             # Register slash command handler
             @self._app.command("/hermes")
             async def handle_hermes_command(ack, command):
@@ -769,135 +755,6 @@ class SlackAdapter(BasePlatformAdapter):
 
     # ----- Internal handlers -----
 
-    def _assistant_thread_key(self, channel_id: str, thread_ts: str) -> Optional[Tuple[str, str]]:
-        """Return a stable cache key for Slack assistant thread metadata."""
-        if not channel_id or not thread_ts:
-            return None
-        return (str(channel_id), str(thread_ts))
-
-    def _extract_assistant_thread_metadata(self, event: dict) -> Dict[str, str]:
-        """Extract Slack Assistant thread identity data from an event payload."""
-        assistant_thread = event.get("assistant_thread") or {}
-        context = assistant_thread.get("context") or event.get("context") or {}
-
-        channel_id = (
-            assistant_thread.get("channel_id")
-            or event.get("channel")
-            or context.get("channel_id")
-            or ""
-        )
-        thread_ts = (
-            assistant_thread.get("thread_ts")
-            or event.get("thread_ts")
-            or event.get("message_ts")
-            or ""
-        )
-        user_id = (
-            assistant_thread.get("user_id")
-            or event.get("user")
-            or context.get("user_id")
-            or ""
-        )
-        team_id = (
-            event.get("team")
-            or event.get("team_id")
-            or assistant_thread.get("team_id")
-            or ""
-        )
-        context_channel_id = context.get("channel_id") or ""
-
-        return {
-            "channel_id": str(channel_id) if channel_id else "",
-            "thread_ts": str(thread_ts) if thread_ts else "",
-            "user_id": str(user_id) if user_id else "",
-            "team_id": str(team_id) if team_id else "",
-            "context_channel_id": str(context_channel_id) if context_channel_id else "",
-        }
-
-    def _cache_assistant_thread_metadata(self, metadata: Dict[str, str]) -> None:
-        """Remember assistant thread identity data for later message events."""
-        channel_id = metadata.get("channel_id", "")
-        thread_ts = metadata.get("thread_ts", "")
-        key = self._assistant_thread_key(channel_id, thread_ts)
-        if not key:
-            return
-
-        existing = self._assistant_threads.get(key, {})
-        merged = dict(existing)
-        merged.update({k: v for k, v in metadata.items() if v})
-        self._assistant_threads[key] = merged
-
-        # Evict oldest entries when the cache exceeds the limit
-        if len(self._assistant_threads) > self._ASSISTANT_THREADS_MAX:
-            excess = len(self._assistant_threads) - self._ASSISTANT_THREADS_MAX // 2
-            for old_key in list(self._assistant_threads)[:excess]:
-                del self._assistant_threads[old_key]
-
-        team_id = merged.get("team_id", "")
-        if team_id and channel_id:
-            self._channel_team[channel_id] = team_id
-
-    def _lookup_assistant_thread_metadata(
-        self,
-        event: dict,
-        channel_id: str = "",
-        thread_ts: str = "",
-    ) -> Dict[str, str]:
-        """Load cached assistant-thread metadata that matches the current event."""
-        metadata = self._extract_assistant_thread_metadata(event)
-        if channel_id and not metadata.get("channel_id"):
-            metadata["channel_id"] = channel_id
-        if thread_ts and not metadata.get("thread_ts"):
-            metadata["thread_ts"] = thread_ts
-
-        key = self._assistant_thread_key(
-            metadata.get("channel_id", ""),
-            metadata.get("thread_ts", ""),
-        )
-        cached = self._assistant_threads.get(key, {}) if key else {}
-        if cached:
-            merged = dict(cached)
-            merged.update({k: v for k, v in metadata.items() if v})
-            return merged
-        return metadata
-
-    def _seed_assistant_thread_session(self, metadata: Dict[str, str]) -> None:
-        """Prime the session store so assistant threads get stable user scoping."""
-        session_store = getattr(self, "_session_store", None)
-        if not session_store:
-            return
-
-        channel_id = metadata.get("channel_id", "")
-        thread_ts = metadata.get("thread_ts", "")
-        user_id = metadata.get("user_id", "")
-        if not channel_id or not thread_ts or not user_id:
-            return
-
-        source = self.build_source(
-            chat_id=channel_id,
-            chat_name=channel_id,
-            chat_type="dm",
-            user_id=user_id,
-            thread_id=thread_ts,
-            chat_topic=metadata.get("context_channel_id") or None,
-        )
-
-        try:
-            session_store.get_or_create_session(source)
-        except Exception:
-            logger.debug(
-                "[Slack] Failed to seed assistant thread session for %s/%s",
-                channel_id,
-                thread_ts,
-                exc_info=True,
-            )
-
-    async def _handle_assistant_thread_lifecycle_event(self, event: dict) -> None:
-        """Handle Slack Assistant lifecycle events that carry user/thread identity."""
-        metadata = self._extract_assistant_thread_metadata(event)
-        self._cache_assistant_thread_metadata(metadata)
-        self._seed_assistant_thread_session(metadata)
-
     async def _handle_slack_message(self, event: dict) -> None:
         """Handle an incoming Slack message event."""
         # Dedup: Slack Socket Mode can redeliver events after reconnects (#4777)
@@ -924,21 +781,10 @@ class SlackAdapter(BasePlatformAdapter):
             return
 
         text = event.get("text", "")
+        user_id = event.get("user", "")
         channel_id = event.get("channel", "")
         ts = event.get("ts", "")
-        assistant_meta = self._lookup_assistant_thread_metadata(
-            event,
-            channel_id=channel_id,
-            thread_ts=event.get("thread_ts", ""),
-        )
-        user_id = event.get("user") or assistant_meta.get("user_id", "")
-        if not channel_id:
-            channel_id = assistant_meta.get("channel_id", "")
-        team_id = (
-            event.get("team")
-            or event.get("team_id")
-            or assistant_meta.get("team_id", "")
-        )
+        team_id = event.get("team", "")
 
         # Track which workspace owns this channel
         if team_id and channel_id:
@@ -946,8 +792,6 @@ class SlackAdapter(BasePlatformAdapter):
 
         # Determine if this is a DM or channel message
         channel_type = event.get("channel_type", "")
-        if not channel_type and channel_id.startswith("D"):
-            channel_type = "im"
         is_dm = channel_type == "im"
 
         # Build thread_ts for session keying.
@@ -956,7 +800,7 @@ class SlackAdapter(BasePlatformAdapter):
         # In DMs: only use the real thread_ts — top-level DMs should share
         #   one continuous session, threaded DMs get their own session.
         if is_dm:
-            thread_ts = event.get("thread_ts") or assistant_meta.get("thread_ts")  # None for top-level DMs
+            thread_ts = event.get("thread_ts")  # None for top-level DMs
         else:
             thread_ts = event.get("thread_ts") or ts  # ts fallback for channels
 

gateway/run.py

@@ -184,8 +184,6 @@ if _config_path.exists():
             # Env var from .env takes precedence (already in os.environ).
             if "gateway_timeout" in _agent_cfg and "HERMES_AGENT_TIMEOUT" not in os.environ:
                 os.environ["HERMES_AGENT_TIMEOUT"] = str(_agent_cfg["gateway_timeout"])
-            if "gateway_timeout_warning" in _agent_cfg and "HERMES_AGENT_TIMEOUT_WARNING" not in os.environ:
-                os.environ["HERMES_AGENT_TIMEOUT_WARNING"] = str(_agent_cfg["gateway_timeout_warning"])
         # Timezone: bridge config.yaml → HERMES_TIMEZONE env var.
         # HERMES_TIMEZONE from .env takes precedence (already in os.environ).
         _tz_cfg = _cfg.get("timezone", "")
@@ -1075,7 +1073,6 @@ class GatewayRunner:
                        "MATRIX_ALLOWED_USERS", "DINGTALK_ALLOWED_USERS",
                        "FEISHU_ALLOWED_USERS",
                        "WECOM_ALLOWED_USERS",
-                       "BLUEBUBBLES_ALLOWED_USERS",
                        "GATEWAY_ALLOWED_USERS")
         )
         _allow_all = os.getenv("GATEWAY_ALLOW_ALL_USERS", "").lower() in ("true", "1", "yes") or any(
@@ -1086,8 +1083,7 @@ class GatewayRunner:
                        "SMS_ALLOW_ALL_USERS", "MATTERMOST_ALLOW_ALL_USERS",
                        "MATRIX_ALLOW_ALL_USERS", "DINGTALK_ALLOW_ALL_USERS",
                        "FEISHU_ALLOW_ALL_USERS",
-                       "WECOM_ALLOW_ALL_USERS",
-                       "BLUEBUBBLES_ALLOW_ALL_USERS")
+                       "WECOM_ALLOW_ALL_USERS")
         )
         if not _any_allowlist and not _allow_all:
             logger.warning(
@@ -1658,13 +1654,6 @@ class GatewayRunner:
             adapter.gateway_runner = self  # For cross-platform delivery
             return adapter
 
-        elif platform == Platform.BLUEBUBBLES:
-            from gateway.platforms.bluebubbles import BlueBubblesAdapter, check_bluebubbles_requirements
-            if not check_bluebubbles_requirements():
-                logger.warning("BlueBubbles: aiohttp/httpx missing or BLUEBUBBLES_SERVER_URL/BLUEBUBBLES_PASSWORD not configured")
-                return None
-            return BlueBubblesAdapter(config)
-
         return None
     
     def _is_user_authorized(self, source: SessionSource) -> bool:
@@ -1703,7 +1692,6 @@ class GatewayRunner:
             Platform.DINGTALK: "DINGTALK_ALLOWED_USERS",
             Platform.FEISHU: "FEISHU_ALLOWED_USERS",
             Platform.WECOM: "WECOM_ALLOWED_USERS",
-            Platform.BLUEBUBBLES: "BLUEBUBBLES_ALLOWED_USERS",
         }
         platform_allow_all_map = {
             Platform.TELEGRAM: "TELEGRAM_ALLOW_ALL_USERS",
@@ -1718,7 +1706,6 @@ class GatewayRunner:
             Platform.DINGTALK: "DINGTALK_ALLOW_ALL_USERS",
             Platform.FEISHU: "FEISHU_ALLOW_ALL_USERS",
             Platform.WECOM: "WECOM_ALLOW_ALL_USERS",
-            Platform.BLUEBUBBLES: "BLUEBUBBLES_ALLOW_ALL_USERS",
         }
 
         # Per-platform allow-all flag (e.g., DISCORD_ALLOW_ALL_USERS=true)
@@ -1792,11 +1779,8 @@ class GatewayRunner:
         """
         source = event.source
 
-        # Internal events (e.g. background-process completion notifications)
-        # are system-generated and must skip user authorization.
-        if getattr(event, "internal", False):
-            pass
-        elif not self._is_user_authorized(source):
+        # Check if user is authorized
+        if not self._is_user_authorized(source):
             logger.warning("Unauthorized user: %s (%s) on %s", source.user_id, source.user_name, source.platform.value)
             # In DMs: offer pairing code. In groups: silently ignore.
             if source.chat_type == "dm" and self._get_unauthorized_dm_behavior(source.platform) == "pair":
@@ -5534,7 +5518,7 @@ class GatewayRunner:
         Platform.TELEGRAM, Platform.DISCORD, Platform.SLACK, Platform.WHATSAPP,
         Platform.SIGNAL, Platform.MATTERMOST, Platform.MATRIX,
         Platform.HOMEASSISTANT, Platform.EMAIL, Platform.SMS, Platform.DINGTALK,
-        Platform.FEISHU, Platform.WECOM, Platform.BLUEBUBBLES, Platform.LOCAL,
+        Platform.FEISHU, Platform.WECOM, Platform.LOCAL,
     })
 
     async def _handle_update_command(self, event: MessageEvent) -> str:
@@ -6174,7 +6158,6 @@ class GatewayRunner:
                                 text=synth_text,
                                 message_type=MessageType.TEXT,
                                 source=_source,
-                                internal=True,
                             )
                             logger.info(
                                 "Process %s finished — injecting agent notification for session %s",
@@ -6325,15 +6308,7 @@ class GatewayRunner:
         # Falls back to env vars for backward compatibility.
         # YAML 1.1 parses bare `off` as boolean False — normalise before
         # the `or` chain so it doesn't silently fall through to "all".
-        #
-        # Per-platform overrides (display.tool_progress_overrides) take
-        # priority over the global setting — e.g. Signal users can set
-        # tool_progress to "off" while keeping Telegram on "all".
-        _display_cfg = user_config.get("display", {})
-        _overrides = _display_cfg.get("tool_progress_overrides", {})
-        _raw_tp = _overrides.get(platform_key)
-        if _raw_tp is None:
-            _raw_tp = _display_cfg.get("tool_progress")
+        _raw_tp = user_config.get("display", {}).get("tool_progress")
         if _raw_tp is False:
             _raw_tp = "off"
         progress_mode = (
@@ -6437,18 +6412,6 @@ class GatewayRunner:
             if not adapter:
                 return
 
-            # Skip tool progress for platforms that don't support message
-            # editing (e.g. iMessage/BlueBubbles) — each progress update
-            # would become a separate message bubble, which is noisy.
-            from gateway.platforms.base import BasePlatformAdapter as _BaseAdapter
-            if type(adapter).edit_message is _BaseAdapter.edit_message:
-                while not progress_queue.empty():
-                    try:
-                        progress_queue.get_nowait()
-                    except Exception:
-                        break
-                return
-
             progress_lines = []      # Accumulated tool lines
             progress_msg_id = None   # ID of the progress message to edit
             can_edit = True          # False once an edit fails (platform doesn't support it)
@@ -7143,9 +7106,6 @@ class GatewayRunner:
             # Default 1800s (30 min inactivity).  0 = unlimited.
             _agent_timeout_raw = float(os.getenv("HERMES_AGENT_TIMEOUT", 1800))
             _agent_timeout = _agent_timeout_raw if _agent_timeout_raw > 0 else None
-            _agent_warning_raw = float(os.getenv("HERMES_AGENT_TIMEOUT_WARNING", 900))
-            _agent_warning = _agent_warning_raw if _agent_warning_raw > 0 else None
-            _warning_fired = False
             loop = asyncio.get_event_loop()
             _executor_task = asyncio.ensure_future(
                 loop.run_in_executor(None, run_sync)
@@ -7178,25 +7138,6 @@ class GatewayRunner:
                             _idle_secs = _act.get("seconds_since_activity", 0.0)
                         except Exception:
                             pass
-                    # Staged warning: fire once before escalating to full timeout.
-                    if (not _warning_fired and _agent_warning is not None
-                            and _idle_secs >= _agent_warning):
-                        _warning_fired = True
-                        _warn_adapter = self.adapters.get(source.platform)
-                        if _warn_adapter:
-                            _elapsed_warn = int(_agent_warning // 60) or 1
-                            _remaining_mins = int((_agent_timeout - _agent_warning) // 60) or 1
-                            try:
-                                await _warn_adapter.send(
-                                    source.chat_id,
-                                    f"⚠️ No activity for {_elapsed_warn} min. "
-                                    f"If the agent does not respond soon, it will "
-                                    f"be timed out in {_remaining_mins} min. "
-                                    f"You can continue waiting or use /reset.",
-                                    metadata=_status_thread_metadata,
-                                )
-                            except Exception as _warn_err:
-                                logger.debug("Inactivity warning send error: %s", _warn_err)
                     if _idle_secs >= _agent_timeout:
                         _inactivity_timeout = True
                         break

gateway/session.py

@@ -193,7 +193,6 @@ _PII_SAFE_PLATFORMS = frozenset({
     Platform.WHATSAPP,
     Platform.SIGNAL,
     Platform.TELEGRAM,
-    Platform.BLUEBUBBLES,
 })
 """Platforms where user IDs can be safely redacted (no in-message mention system
 that requires raw IDs).  Discord is excluded because mentions use ``<@user_id>``

gateway/stream_consumer.py

@@ -353,17 +353,6 @@ class GatewayStreamConsumer:
                     self._message_id = result.message_id
                     self._already_sent = True
                     self._last_sent_text = text
-                elif result.success:
-                    # Platform accepted the message but returned no message_id
-                    # (e.g. Signal).  Can't edit without an ID — switch to
-                    # fallback mode: suppress intermediate deltas, send only
-                    # the missing tail once the final response is ready.
-                    self._already_sent = True
-                    self._edit_supported = False
-                    self._fallback_prefix = self._clean_for_display(text)
-                    self._fallback_final_send = True
-                    # Sentinel prevents re-entering this branch on every delta
-                    self._message_id = "__no_edit__"
                 else:
                     # Initial send failed — disable streaming for this session
                     self._edit_supported = False

hermes_cli/banner.py

@@ -295,16 +295,10 @@ def _format_context_length(tokens: int) -> str:
     """Format a token count for display (e.g. 128000 → '128K', 1048576 → '1M')."""
     if tokens >= 1_000_000:
         val = tokens / 1_000_000
-        rounded = round(val)
-        if abs(val - rounded) < 0.05:
-            return f"{rounded}M"
-        return f"{val:.1f}M"
+        return f"{val:g}M"
     elif tokens >= 1_000:
         val = tokens / 1_000
-        rounded = round(val)
-        if abs(val - rounded) < 0.05:
-            return f"{rounded}K"
-        return f"{val:.1f}K"
+        return f"{val:g}K"
     return str(tokens)
 
 

hermes_cli/config.py

@@ -39,7 +39,6 @@ _EXTRA_ENV_KEYS = frozenset({
     "DINGTALK_CLIENT_ID", "DINGTALK_CLIENT_SECRET",
     "FEISHU_APP_ID", "FEISHU_APP_SECRET", "FEISHU_ENCRYPT_KEY", "FEISHU_VERIFICATION_TOKEN",
     "WECOM_BOT_ID", "WECOM_SECRET",
-    "BLUEBUBBLES_SERVER_URL", "BLUEBUBBLES_PASSWORD",
     "TERMINAL_ENV", "TERMINAL_SSH_KEY", "TERMINAL_SSH_PORT",
     "WHATSAPP_MODE", "WHATSAPP_ENABLED",
     "MATTERMOST_HOME_CHANNEL", "MATTERMOST_REPLY_MODE",
@@ -231,10 +230,6 @@ DEFAULT_CONFIG = {
         # (force on/off for all models), or a list of model-name substrings
         # to match (e.g. ["gpt", "codex", "gemini", "qwen"]).
         "tool_use_enforcement": "auto",
-        # Staged inactivity warning: send a warning to the user at this
-        # threshold before escalating to a full timeout.  The warning fires
-        # once per run and does not interrupt the agent.  0 = disable warning.
-        "gateway_timeout_warning": 900,
     },
     
     "terminal": {
@@ -397,7 +392,6 @@ DEFAULT_CONFIG = {
         "show_cost": False,       # Show $ cost in the status bar (off by default)
         "skin": "default",
         "tool_progress_command": False,  # Enable /verbose command in messaging gateway
-        "tool_progress_overrides": {},  # Per-platform overrides: {"signal": "off", "telegram": "all"}
         "tool_preview_length": 0,  # Max chars for tool call previews (0 = no limit, show full paths/commands)
     },
 
@@ -1005,13 +999,6 @@ OPTIONAL_ENV_VARS = {
         "password": False,
         "category": "messaging",
     },
-    "DISCORD_REPLY_TO_MODE": {
-        "description": "Discord reply threading mode: 'off' (no reply references), 'first' (reply on first message only, default), 'all' (reply on every chunk)",
-        "prompt": "Discord reply mode (off/first/all)",
-        "url": None,
-        "password": False,
-        "category": "messaging",
-    },
     "SLACK_BOT_TOKEN": {
         "description": "Slack bot token (xoxb-). Get from OAuth & Permissions after installing your app. "
                        "Required scopes: chat:write, app_mentions:read, channels:history, groups:history, "
@@ -1125,27 +1112,6 @@ OPTIONAL_ENV_VARS = {
         "category": "messaging",
         "advanced": True,
     },
-    "BLUEBUBBLES_SERVER_URL": {
-        "description": "BlueBubbles server URL for iMessage integration (e.g. http://192.168.1.10:1234)",
-        "prompt": "BlueBubbles server URL",
-        "url": "https://bluebubbles.app/",
-        "password": False,
-        "category": "messaging",
-    },
-    "BLUEBUBBLES_PASSWORD": {
-        "description": "BlueBubbles server password (from BlueBubbles Server → Settings → API)",
-        "prompt": "BlueBubbles server password",
-        "url": None,
-        "password": True,
-        "category": "messaging",
-    },
-    "BLUEBUBBLES_ALLOWED_USERS": {
-        "description": "Comma-separated iMessage addresses (email or phone) allowed to use the bot",
-        "prompt": "Allowed iMessage addresses (comma-separated)",
-        "url": None,
-        "password": False,
-        "category": "messaging",
-    },
     "GATEWAY_ALLOW_ALL_USERS": {
         "description": "Allow all users to interact with messaging bots (true/false). Default: false.",
         "prompt": "Allow all users (true/false)",

hermes_cli/gateway.py

@@ -1588,34 +1588,6 @@ _PLATFORMS = [
              "help": "Chat ID for scheduled results and notifications."},
         ],
     },
-    {
-        "key": "bluebubbles",
-        "label": "BlueBubbles (iMessage)",
-        "emoji": "💬",
-        "token_var": "BLUEBUBBLES_SERVER_URL",
-        "setup_instructions": [
-            "1. Install BlueBubbles on a Mac that will act as your iMessage server:",
-            "   https://bluebubbles.app/",
-            "2. Complete the BlueBubbles setup wizard — sign in with your Apple ID",
-            "3. In BlueBubbles Settings → API, note the Server URL and password",
-            "4. The server URL is typically http://<your-mac-ip>:1234",
-            "5. Hermes connects via the BlueBubbles REST API and receives",
-            "   incoming messages via a local webhook",
-            "6. To authorize users, use DM pairing: hermes pairing generate bluebubbles",
-            "   Share the code — the user sends it via iMessage to get approved",
-        ],
-        "vars": [
-            {"name": "BLUEBUBBLES_SERVER_URL", "prompt": "BlueBubbles server URL (e.g. http://192.168.1.10:1234)", "password": False,
-             "help": "The URL shown in BlueBubbles Settings → API."},
-            {"name": "BLUEBUBBLES_PASSWORD", "prompt": "BlueBubbles server password", "password": True,
-             "help": "The password shown in BlueBubbles Settings → API."},
-            {"name": "BLUEBUBBLES_ALLOWED_USERS", "prompt": "Pre-authorized phone numbers or iMessage IDs (comma-separated, or leave empty for DM pairing)", "password": False,
-             "is_allowlist": True,
-             "help": "Optional — pre-authorize specific users. Leave empty to use DM pairing instead (recommended)."},
-            {"name": "BLUEBUBBLES_HOME_CHANNEL", "prompt": "Home channel (phone number or iMessage ID for cron/notifications, or empty)", "password": False,
-             "help": "Phone number or Apple ID to deliver cron results and notifications to."},
-        ],
-    },
 ]
 
 

hermes_cli/main.py

@@ -1474,11 +1474,7 @@ def _model_flow_custom(config):
             f"Hermes will still save it."
         )
         if probe.get("suggested_base_url"):
-            suggested = probe["suggested_base_url"]
-            if suggested.endswith("/v1"):
-                print(f"  If this server expects /v1 in the path, try base URL: {suggested}")
-            else:
-                print(f"  If /v1 should not be in the base URL, try: {suggested}")
+            print(f"  If this server expects /v1, try base URL: {probe['suggested_base_url']}")
 
     # Select model — use probe results when available, fall back to manual input
     model_name = ""

hermes_cli/model_switch.py

@@ -537,11 +537,8 @@ def switch_model(
                     )
             else:
                 # --- Step c: On aggregator, convert vendor:model to vendor/model ---
-                # Only convert when there's no slash — a slash means the name
-                # is already in vendor/model format and the colon is a variant
-                # tag (:free, :extended, :fast) that must be preserved.
                 colon_pos = raw_input.find(":")
-                if colon_pos > 0 and "/" not in raw_input and is_aggregator(current_provider):
+                if colon_pos > 0 and is_aggregator(current_provider):
                     left = raw_input[:colon_pos].strip().lower()
                     right = raw_input[colon_pos + 1:].strip()
                     if left and right:

hermes_cli/models.py

@@ -1532,7 +1532,7 @@ def probe_api_models(
 
     return {
         "models": None,
-        "probed_url": tried[0] if tried else normalized.rstrip("/") + "/models",
+        "probed_url": tried[-1] if tried else normalized.rstrip("/") + "/models",
         "resolved_base_url": normalized,
         "suggested_base_url": alternate_base if alternate_base != normalized else None,
         "used_fallback": False,

hermes_cli/setup.py

@@ -2167,71 +2167,6 @@ def _setup_whatsapp():
         print_info("or personal self-chat) and pair via QR code.")
 
 
-def _setup_bluebubbles():
-    """Configure BlueBubbles iMessage gateway."""
-    print_header("BlueBubbles (iMessage)")
-    existing = get_env_value("BLUEBUBBLES_SERVER_URL")
-    if existing:
-        print_info("BlueBubbles: already configured")
-        if not prompt_yes_no("Reconfigure BlueBubbles?", False):
-            return
-
-    print_info("Connects Hermes to iMessage via BlueBubbles — a free, open-source")
-    print_info("macOS server that bridges iMessage to any device.")
-    print_info("   Requires a Mac running BlueBubbles Server v1.0.0+")
-    print_info("   Download: https://bluebubbles.app/")
-    print()
-    print_info("In BlueBubbles Server → Settings → API, note your Server URL and Password.")
-    print()
-
-    server_url = prompt("BlueBubbles server URL (e.g. http://192.168.1.10:1234)")
-    if not server_url:
-        print_warning("Server URL is required — skipping BlueBubbles setup")
-        return
-    save_env_value("BLUEBUBBLES_SERVER_URL", server_url.rstrip("/"))
-
-    password = prompt("BlueBubbles server password", password=True)
-    if not password:
-        print_warning("Password is required — skipping BlueBubbles setup")
-        return
-    save_env_value("BLUEBUBBLES_PASSWORD", password)
-    print_success("BlueBubbles credentials saved")
-
-    print()
-    print_info("🔒 Security: Restrict who can message your bot")
-    print_info("   Use iMessage addresses: email (user@icloud.com) or phone (+15551234567)")
-    print()
-    allowed_users = prompt("Allowed iMessage addresses (comma-separated, leave empty for open access)")
-    if allowed_users:
-        save_env_value("BLUEBUBBLES_ALLOWED_USERS", allowed_users.replace(" ", ""))
-        print_success("BlueBubbles allowlist configured")
-    else:
-        print_info("⚠️  No allowlist set — anyone who can iMessage you can use the bot!")
-
-    print()
-    print_info("📬 Home Channel: phone or email for cron job delivery and notifications.")
-    print_info("   You can also set this later with /set-home in your iMessage chat.")
-    home_channel = prompt("Home channel address (leave empty to set later)")
-    if home_channel:
-        save_env_value("BLUEBUBBLES_HOME_CHANNEL", home_channel)
-
-    print()
-    print_info("Advanced settings (defaults are fine for most setups):")
-    if prompt_yes_no("Configure webhook listener settings?", False):
-        webhook_port = prompt("Webhook listener port (default: 8645)")
-        if webhook_port:
-            try:
-                save_env_value("BLUEBUBBLES_WEBHOOK_PORT", str(int(webhook_port)))
-                print_success(f"Webhook port set to {webhook_port}")
-            except ValueError:
-                print_warning("Invalid port number, using default 8645")
-
-    print()
-    print_info("Requires the BlueBubbles Private API helper for typing indicators,")
-    print_info("read receipts, and tapback reactions. Basic messaging works without it.")
-    print_info("   Install: https://docs.bluebubbles.app/helper-bundle/installation")
-
-
 def _setup_webhooks():
     """Configure webhook integration."""
     print_header("Webhooks")
@@ -2286,7 +2221,6 @@ _GATEWAY_PLATFORMS = [
     ("Matrix", "MATRIX_ACCESS_TOKEN", _setup_matrix),
     ("Mattermost", "MATTERMOST_TOKEN", _setup_mattermost),
     ("WhatsApp", "WHATSAPP_ENABLED", _setup_whatsapp),
-    ("BlueBubbles (iMessage)", "BLUEBUBBLES_SERVER_URL", _setup_bluebubbles),
     ("Webhooks (GitHub, GitLab, etc.)", "WEBHOOK_ENABLED", _setup_webhooks),
 ]
 
@@ -2330,7 +2264,6 @@ def setup_gateway(config: dict):
         or get_env_value("MATRIX_ACCESS_TOKEN")
         or get_env_value("MATRIX_PASSWORD")
         or get_env_value("WHATSAPP_ENABLED")
-        or get_env_value("BLUEBUBBLES_SERVER_URL")
         or get_env_value("WEBHOOK_ENABLED")
     )
     if any_messaging:
@@ -2350,8 +2283,6 @@ def setup_gateway(config: dict):
             missing_home.append("Discord")
         if get_env_value("SLACK_BOT_TOKEN") and not get_env_value("SLACK_HOME_CHANNEL"):
             missing_home.append("Slack")
-        if get_env_value("BLUEBUBBLES_SERVER_URL") and not get_env_value("BLUEBUBBLES_HOME_CHANNEL"):
-            missing_home.append("BlueBubbles")
 
         if missing_home:
             print()
@@ -2522,8 +2453,6 @@ def _get_section_config_summary(config: dict, section_key: str) -> Optional[str]
             platforms.append("WhatsApp")
         if get_env_value("SIGNAL_ACCOUNT"):
             platforms.append("Signal")
-        if get_env_value("BLUEBUBBLES_SERVER_URL"):
-            platforms.append("BlueBubbles")
         if platforms:
             return ", ".join(platforms)
         return None  # No platforms configured — section must run

hermes_cli/skills_config.py

@@ -23,7 +23,6 @@ PLATFORMS = {
     "slack":    "💼 Slack",
     "whatsapp": "📱 WhatsApp",
     "signal":   "📡 Signal",
-    "bluebubbles": "💬 BlueBubbles",
     "email":    "📧 Email",
     "homeassistant": "🏠 Home Assistant",
     "mattermost": "💬 Mattermost",

hermes_cli/status.py

@@ -302,7 +302,6 @@ def show_status(args):
         "DingTalk": ("DINGTALK_CLIENT_ID", None),
         "Feishu": ("FEISHU_APP_ID", "FEISHU_HOME_CHANNEL"),
         "WeCom": ("WECOM_BOT_ID", "WECOM_HOME_CHANNEL"),
-        "BlueBubbles": ("BLUEBUBBLES_SERVER_URL", "BLUEBUBBLES_HOME_CHANNEL"),
     }
     
     for name, (token_var, home_var) in platforms.items():

hermes_cli/tools_config.py

@@ -126,7 +126,6 @@ PLATFORMS = {
     "slack":    {"label": "💼 Slack",      "default_toolset": "hermes-slack"},
     "whatsapp": {"label": "📱 WhatsApp",   "default_toolset": "hermes-whatsapp"},
     "signal":   {"label": "📡 Signal",     "default_toolset": "hermes-signal"},
-    "bluebubbles": {"label": "💙 BlueBubbles", "default_toolset": "hermes-bluebubbles"},
     "homeassistant": {"label": "🏠 Home Assistant", "default_toolset": "hermes-homeassistant"},
     "email":    {"label": "📧 Email",      "default_toolset": "hermes-email"},
     "matrix":   {"label": "💬 Matrix",     "default_toolset": "hermes-matrix"},

hermes_state.py

@@ -1235,10 +1235,10 @@ class SessionDB:
         self._execute_write(_do)
 
     def delete_session(self, session_id: str) -> bool:
-        """Delete a session and all its messages.
+        """Delete a session, its child sessions, and all their messages.
 
-        Child sessions are orphaned (parent_session_id set to NULL) rather
-        than cascade-deleted, so they remain accessible independently.
+        Child sessions (subagent runs, compression continuations) are deleted
+        first to satisfy the ``parent_session_id`` foreign key constraint.
         Returns True if the session was found and deleted.
         """
         def _do(conn):
@@ -1247,12 +1247,15 @@ class SessionDB:
             )
             if cursor.fetchone()[0] == 0:
                 return False
-            # Orphan child sessions so FK constraint is satisfied
-            conn.execute(
-                "UPDATE sessions SET parent_session_id = NULL "
-                "WHERE parent_session_id = ?",
+            # Delete child sessions first (FK constraint)
+            child_ids = [r[0] for r in conn.execute(
+                "SELECT id FROM sessions WHERE parent_session_id = ?",
                 (session_id,),
-            )
+            ).fetchall()]
+            for cid in child_ids:
+                conn.execute("DELETE FROM messages WHERE session_id = ?", (cid,))
+                conn.execute("DELETE FROM sessions WHERE id = ?", (cid,))
+            # Delete the session itself
             conn.execute("DELETE FROM messages WHERE session_id = ?", (session_id,))
             conn.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
             return True
@@ -1261,9 +1264,9 @@ class SessionDB:
     def prune_sessions(self, older_than_days: int = 90, source: str = None) -> int:
         """Delete sessions older than N days. Returns count of deleted sessions.
 
-        Only prunes ended sessions (not active ones).  Child sessions outside
-        the prune window are orphaned (parent_session_id set to NULL) rather
-        than cascade-deleted.
+        Only prunes ended sessions (not active ones).  Child sessions whose
+        parents are being pruned are deleted first to satisfy the
+        ``parent_session_id`` foreign key constraint.
         """
         cutoff = time.time() - (older_than_days * 86400)
 
@@ -1281,16 +1284,17 @@ class SessionDB:
                 )
             session_ids = set(row["id"] for row in cursor.fetchall())
 
-            if not session_ids:
-                return 0
-
-            # Orphan any sessions whose parent is about to be deleted
-            placeholders = ",".join("?" * len(session_ids))
-            conn.execute(
-                f"UPDATE sessions SET parent_session_id = NULL "
-                f"WHERE parent_session_id IN ({placeholders})",
-                list(session_ids),
-            )
+            # Delete children first whose parents are in the prune set
+            # (avoids FK constraint errors)
+            for sid in list(session_ids):
+                child_ids = [r[0] for r in conn.execute(
+                    "SELECT id FROM sessions WHERE parent_session_id = ?",
+                    (sid,),
+                ).fetchall()]
+                for cid in child_ids:
+                    conn.execute("DELETE FROM messages WHERE session_id = ?", (cid,))
+                    conn.execute("DELETE FROM sessions WHERE id = ?", (cid,))
+                    session_ids.discard(cid)  # don't double-delete
 
             for sid in session_ids:
                 conn.execute("DELETE FROM messages WHERE session_id = ?", (sid,))

optional-skills/migration/openclaw-migration/scripts/openclaw_to_hermes.py

@@ -1803,34 +1803,30 @@ class Migrator:
     def migrate_cron_jobs(self, config: Optional[Dict[str, Any]] = None) -> None:
         config = config or self.load_openclaw_config()
         cron = config.get("cron") or {}
+        if not cron:
+            self.record("cron-jobs", None, None, "skipped", "No cron configuration found")
+            return
+
+        # Archive the full cron config
+        if self.archive_dir and self.execute:
+            self.archive_dir.mkdir(parents=True, exist_ok=True)
+            dest = self.archive_dir / "cron-config.json"
+            dest.write_text(json.dumps(cron, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+            self.record("cron-jobs", "openclaw.json cron.*", str(dest), "archived",
+                        "Cron config archived. Use 'hermes cron' to recreate jobs manually.")
+        else:
+            self.record("cron-jobs", "openclaw.json cron.*", "archive/cron-config.json",
+                        "archived", "Would archive cron config")
+
+        # Also check for cron store files
         cron_store = self.source_root / "cron"
-        found_any = False
-
-        # Archive the full cron config when present
-        if cron:
-            found_any = True
-            if self.archive_dir and self.execute:
-                self.archive_dir.mkdir(parents=True, exist_ok=True)
-                dest = self.archive_dir / "cron-config.json"
-                dest.write_text(json.dumps(cron, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
-                self.record("cron-jobs", "openclaw.json cron.*", str(dest), "archived",
-                            "Cron config archived. Use 'hermes cron' to recreate jobs manually.")
-            else:
-                self.record("cron-jobs", "openclaw.json cron.*", "archive/cron-config.json",
-                            "archived", "Would archive cron config")
-
-        # Also check for cron store files even when config.cron is missing
         if cron_store.is_dir() and self.archive_dir:
-            found_any = True
             dest_cron = self.archive_dir / "cron-store"
             if self.execute:
                 shutil.copytree(cron_store, dest_cron, dirs_exist_ok=True)
             self.record("cron-jobs", str(cron_store), str(dest_cron), "archived",
                         "Cron job store archived")
 
-        if not found_any:
-            self.record("cron-jobs", None, None, "skipped", "No cron configuration found")
-
     # ── Hooks ─────────────────────────────────────────────────
     def migrate_hooks_config(self, config: Optional[Dict[str, Any]] = None) -> None:
         config = config or self.load_openclaw_config()
@@ -2458,15 +2454,6 @@ class Migrator:
                 notes.append(f"- **{item.kind}**: {item.reason}")
             notes.append("")
 
-        has_cron_config_archive = any(
-            i.kind == "cron-jobs" and i.status == "archived" and i.destination and i.destination.endswith("cron-config.json")
-            for i in self.items
-        )
-        has_cron_store_archive = any(
-            i.kind == "cron-jobs" and i.status == "archived" and i.destination and i.destination.endswith("cron-store")
-            for i in self.items
-        )
-
         notes.extend([
             "## IMPORTANT: Archive the OpenClaw Directory",
             "",
@@ -2488,14 +2475,7 @@ class Migrator:
             "- Run `hermes claw cleanup` to archive the OpenClaw directory (prevents state confusion)",
             "- Run `hermes setup` to configure any remaining settings",
             "- Run `hermes mcp list` to verify MCP servers were imported correctly",
-        ])
-
-        if has_cron_config_archive:
-            notes.append("- Run `hermes cron` to recreate scheduled tasks (see archive/cron-config.json)")
-        elif has_cron_store_archive:
-            notes.append("- Run `hermes cron` to recreate scheduled tasks (see archived cron-store)")
-
-        notes.extend([
+            "- Run `hermes cron` to recreate scheduled tasks (see archive/cron-config.json)",
             "- Run `hermes gateway install` if you need the gateway service",
             "- Review `~/.hermes/config.yaml` for any adjustments",
             "",

plugins/memory/hindsight/README.md

@@ -1,12 +1,11 @@
 # Hindsight Memory Provider
 
-Long-term memory with knowledge graph, entity resolution, and multi-strategy retrieval. Supports cloud, local embedded, and local external modes.
+Long-term memory with knowledge graph, entity resolution, and multi-strategy retrieval. Supports cloud and local (embedded) modes.
 
 ## Requirements
 
 - **Cloud:** API key from [ui.hindsight.vectorize.io](https://ui.hindsight.vectorize.io)
-- **Local Embedded:** API key for a supported LLM provider (OpenAI, Anthropic, Gemini, Groq, OpenRouter, MiniMax, Ollama, or any OpenAI-compatible endpoint). Embeddings and reranking run locally — no additional API keys needed.
-- **Local External:** A running Hindsight instance (Docker or self-hosted) reachable over HTTP.
+- **Local:** API key for a supported LLM provider (OpenAI, Anthropic, Gemini, Groq, MiniMax, or Ollama). Embeddings and reranking run locally — no additional API keys needed.
 
 ## Setup
 
@@ -22,28 +21,17 @@ hermes config set memory.provider hindsight
 echo "HINDSIGHT_API_KEY=your-key" >> ~/.hermes/.env
 ```
 
-### Cloud
+### Cloud Mode
 
 Connects to the Hindsight Cloud API. Requires an API key from [ui.hindsight.vectorize.io](https://ui.hindsight.vectorize.io).
 
-### Local Embedded
+### Local Mode
 
-Hermes spins up a local Hindsight daemon with built-in PostgreSQL. Requires an LLM API key for memory extraction and synthesis. The daemon starts automatically in the background on first use and stops after 5 minutes of inactivity.
-
-Supports any OpenAI-compatible LLM endpoint (llama.cpp, vLLM, LM Studio, etc.) — pick `openai_compatible` as the provider and enter the base URL.
+Runs an embedded Hindsight server with built-in PostgreSQL. Requires an LLM API key (e.g. Groq, OpenAI, Anthropic) for memory extraction and synthesis. The daemon starts automatically in the background on first use and stops after 5 minutes of inactivity.
 
 Daemon startup logs: `~/.hermes/logs/hindsight-embed.log`
 Daemon runtime logs: `~/.hindsight/profiles/<profile>.log`
 
-To open the Hindsight web UI (local embedded mode only):
-```bash
-hindsight-embed -p hermes ui start
-```
-
-### Local External
-
-Points the plugin at an existing Hindsight instance you're already running (Docker, self-hosted, etc.). No daemon management — just a URL and an optional API key.
-
 ## Config
 
 Config file: `~/.hermes/hindsight/config.json`
@@ -52,58 +40,40 @@ Config file: `~/.hermes/hindsight/config.json`
 
 | Key | Default | Description |
 |-----|---------|-------------|
-| `mode` | `cloud` | `cloud`, `local_embedded`, or `local_external` |
-| `api_url` | `https://api.hindsight.vectorize.io` | API URL (cloud and local_external modes) |
+| `mode` | `cloud` | `cloud` or `local` |
+| `api_url` | `https://api.hindsight.vectorize.io` | API URL (cloud mode) |
+| `api_url` | `http://localhost:8888` | API URL (local mode, unused — daemon manages its own port) |
 
-### Memory Bank
+### Memory
 
 | Key | Default | Description |
 |-----|---------|-------------|
 | `bank_id` | `hermes` | Memory bank name |
-| `bank_mission` | — | Reflect mission (identity/framing for reflect reasoning). Applied via Banks API. |
-| `bank_retain_mission` | — | Retain mission (steers what gets extracted). Applied via Banks API. |
-
-### Recall
-
-| Key | Default | Description |
-|-----|---------|-------------|
-| `recall_budget` | `mid` | Recall thoroughness: `low` / `mid` / `high` |
-| `recall_prefetch_method` | `recall` | Auto-recall method: `recall` (raw facts) or `reflect` (LLM synthesis) |
-| `recall_max_tokens` | `4096` | Maximum tokens for recall results |
-| `recall_max_input_chars` | `800` | Maximum input query length for auto-recall |
-| `recall_prompt_preamble` | — | Custom preamble for recalled memories in context |
-| `recall_tags` | — | Tags to filter when searching memories |
-| `recall_tags_match` | `any` | Tag matching mode: `any` / `all` / `any_strict` / `all_strict` |
-| `auto_recall` | `true` | Automatically recall memories before each turn |
-
-### Retain
-
-| Key | Default | Description |
-|-----|---------|-------------|
-| `auto_retain` | `true` | Automatically retain conversation turns |
-| `retain_async` | `true` | Process retain asynchronously on the Hindsight server |
-| `retain_every_n_turns` | `1` | Retain every N turns (1 = every turn) |
-| `retain_context` | `conversation between Hermes Agent and the User` | Context label for retained memories |
-| `tags` | — | Tags applied when storing memories |
+| `budget` | `mid` | Recall thoroughness: `low` / `mid` / `high` |
 
 ### Integration
 
 | Key | Default | Description |
 |-----|---------|-------------|
 | `memory_mode` | `hybrid` | How memories are integrated into the agent |
+| `prefetch_method` | `recall` | Method for automatic context injection |
 
 **memory_mode:**
 - `hybrid` — automatic context injection + tools available to the LLM
 - `context` — automatic injection only, no tools exposed
 - `tools` — tools only, no automatic injection
 
-### Local Embedded LLM
+**prefetch_method:**
+- `recall` — injects raw memory facts (fast)
+- `reflect` — injects LLM-synthesized summary (slower, more coherent)
+
+### Local Mode LLM
 
 | Key | Default | Description |
 |-----|---------|-------------|
-| `llm_provider` | `openai` | `openai`, `anthropic`, `gemini`, `groq`, `openrouter`, `minimax`, `ollama`, `lmstudio`, `openai_compatible` |
-| `llm_model` | per-provider | Model name (e.g. `gpt-4o-mini`, `qwen/qwen3.5-9b`) |
-| `llm_base_url` | — | Endpoint URL for `openai_compatible` (e.g. `http://192.168.1.10:8080/v1`) |
+| `llm_provider` | `openai` | LLM provider: `openai`, `anthropic`, `gemini`, `groq`, `minimax`, `ollama` |
+| `llm_model` | per-provider | Model name (e.g. `gpt-4o-mini`, `openai/gpt-oss-120b`) |
+| `llm_base_url` | — | LLM Base URL override (e.g. `https://openrouter.ai/api/v1`) |
 
 The LLM API key is stored in `~/.hermes/.env` as `HINDSIGHT_LLM_API_KEY`.
 
@@ -127,8 +97,4 @@ Available in `hybrid` and `tools` memory modes:
 | `HINDSIGHT_API_URL` | Override API endpoint |
 | `HINDSIGHT_BANK_ID` | Override bank name |
 | `HINDSIGHT_BUDGET` | Override recall budget |
-| `HINDSIGHT_MODE` | Override mode (`cloud`, `local_embedded`, `local_external`) |
-
-## Client Version
-
-Requires `hindsight-client >= 0.4.22`. The plugin auto-upgrades on session start if an older version is detected.
+| `HINDSIGHT_MODE` | Override mode (`cloud` / `local`) |

plugins/memory/hindsight/__init__.py

@@ -28,25 +28,21 @@ from hermes_constants import get_hermes_home
 from typing import Any, Dict, List
 
 from agent.memory_provider import MemoryProvider
-from hermes_constants import get_hermes_home
 from tools.registry import tool_error
 
 logger = logging.getLogger(__name__)
 
 _DEFAULT_API_URL = "https://api.hindsight.vectorize.io"
 _DEFAULT_LOCAL_URL = "http://localhost:8888"
-_MIN_CLIENT_VERSION = "0.4.22"
 _VALID_BUDGETS = {"low", "mid", "high"}
 _PROVIDER_DEFAULT_MODELS = {
     "openai": "gpt-4o-mini",
     "anthropic": "claude-haiku-4-5",
     "gemini": "gemini-2.5-flash",
     "groq": "openai/gpt-oss-120b",
-    "openrouter": "qwen/qwen3.5-9b",
     "minimax": "MiniMax-M2.7",
     "ollama": "gemma3:12b",
     "lmstudio": "local-model",
-    "openai_compatible": "your-model-name",
 }
 
 
@@ -192,7 +188,6 @@ class HindsightMemoryProvider(MemoryProvider):
         self._bank_id = "hermes"
         self._budget = "mid"
         self._mode = "cloud"
-        self._llm_base_url = ""
         self._memory_mode = "hybrid"  # "context", "tools", or "hybrid"
         self._prefetch_method = "recall"  # "recall" or "reflect"
         self._client = None
@@ -200,31 +195,6 @@ class HindsightMemoryProvider(MemoryProvider):
         self._prefetch_lock = threading.Lock()
         self._prefetch_thread = None
         self._sync_thread = None
-        self._session_id = ""
-
-        # Tags
-        self._tags: list[str] | None = None
-        self._recall_tags: list[str] | None = None
-        self._recall_tags_match = "any"
-
-        # Retain controls
-        self._auto_retain = True
-        self._retain_every_n_turns = 1
-        self._retain_context = "conversation between Hermes Agent and the User"
-        self._turn_counter = 0
-        self._session_turns: list[str] = []  # accumulates ALL turns for the session
-
-        # Recall controls
-        self._auto_recall = True
-        self._recall_max_tokens = 4096
-        self._recall_types: list[str] | None = None
-        self._recall_prompt_preamble = ""
-        self._recall_max_input_chars = 800
-
-        # Bank
-        self._bank_mission = ""
-        self._bank_retain_mission: str | None = None
-        self._retain_async = True
 
     @property
     def name(self) -> str:
@@ -234,7 +204,7 @@ class HindsightMemoryProvider(MemoryProvider):
         try:
             cfg = _load_config()
             mode = cfg.get("mode", "cloud")
-            if mode in ("local", "local_embedded", "local_external"):
+            if mode == "local":
                 return True
             has_key = bool(cfg.get("apiKey") or os.environ.get("HINDSIGHT_API_KEY", ""))
             has_url = bool(cfg.get("api_url") or os.environ.get("HINDSIGHT_API_URL", ""))
@@ -258,306 +228,73 @@ class HindsightMemoryProvider(MemoryProvider):
         existing.update(values)
         config_path.write_text(json.dumps(existing, indent=2))
 
-    def post_setup(self, hermes_home: str, config: dict) -> None:
-        """Custom setup wizard — installs only the deps needed for the selected mode."""
-        import getpass
-        import subprocess
-        import shutil
-        import sys
-        from pathlib import Path
-
-        from hermes_cli.config import save_config
-
-        from hermes_cli.memory_setup import _curses_select
-
-        print("\n  Configuring Hindsight memory:\n")
-
-        # Step 1: Mode selection
-        mode_items = [
-            ("Cloud", "Hindsight Cloud API (lightweight, just needs an API key)"),
-            ("Local Embedded", "Run Hindsight locally (downloads ~200MB, needs LLM key)"),
-            ("Local External", "Connect to an existing Hindsight instance"),
-        ]
-        mode_idx = _curses_select("  Select mode", mode_items, default=0)
-        mode = ["cloud", "local_embedded", "local_external"][mode_idx]
-
-        provider_config: dict = {"mode": mode}
-        env_writes: dict = {}
-
-        # Step 2: Install/upgrade deps for selected mode
-        _MIN_CLIENT_VERSION = "0.4.22"
-        cloud_dep = f"hindsight-client>={_MIN_CLIENT_VERSION}"
-        local_dep = "hindsight-all"
-        if mode == "local_embedded":
-            deps_to_install = [local_dep]
-        elif mode == "local_external":
-            deps_to_install = [cloud_dep]
-        else:
-            deps_to_install = [cloud_dep]
-
-        print(f"\n  Checking dependencies...")
-        uv_path = shutil.which("uv")
-        if not uv_path:
-            print("  ⚠ uv not found — install it: curl -LsSf https://astral.sh/uv/install.sh | sh")
-            print(f"  Then run manually: uv pip install --python {sys.executable} {' '.join(deps_to_install)}")
-        else:
-            try:
-                subprocess.run(
-                    [uv_path, "pip", "install", "--python", sys.executable, "--quiet", "--upgrade"] + deps_to_install,
-                    check=True, timeout=120, capture_output=True,
-                )
-                print(f"  ✓ Dependencies up to date")
-            except Exception as e:
-                print(f"  ⚠ Install failed: {e}")
-                print(f"  Run manually: uv pip install --python {sys.executable} {' '.join(deps_to_install)}")
-
-        # Step 3: Mode-specific config
-        if mode == "cloud":
-            print(f"\n  Get your API key at https://ui.hindsight.vectorize.io\n")
-            existing_key = os.environ.get("HINDSIGHT_API_KEY", "")
-            if existing_key:
-                masked = f"...{existing_key[-4:]}" if len(existing_key) > 4 else "set"
-                sys.stdout.write(f"  API key (current: {masked}, blank to keep): ")
-                sys.stdout.flush()
-                api_key = getpass.getpass(prompt="") if sys.stdin.isatty() else sys.stdin.readline().strip()
-            else:
-                sys.stdout.write("  API key: ")
-                sys.stdout.flush()
-                api_key = getpass.getpass(prompt="") if sys.stdin.isatty() else sys.stdin.readline().strip()
-            if api_key:
-                env_writes["HINDSIGHT_API_KEY"] = api_key
-
-            val = input(f"  API URL [{_DEFAULT_API_URL}]: ").strip()
-            if val:
-                provider_config["api_url"] = val
-
-        elif mode == "local_external":
-            val = input(f"  Hindsight API URL [{_DEFAULT_LOCAL_URL}]: ").strip()
-            provider_config["api_url"] = val or _DEFAULT_LOCAL_URL
-
-            sys.stdout.write("  API key (optional, blank to skip): ")
-            sys.stdout.flush()
-            api_key = getpass.getpass(prompt="") if sys.stdin.isatty() else sys.stdin.readline().strip()
-            if api_key:
-                env_writes["HINDSIGHT_API_KEY"] = api_key
-
-        else:  # local_embedded
-            providers_list = list(_PROVIDER_DEFAULT_MODELS.keys())
-            llm_items = [
-                (p, f"default model: {_PROVIDER_DEFAULT_MODELS[p]}")
-                for p in providers_list
-            ]
-            llm_idx = _curses_select("  Select LLM provider", llm_items, default=0)
-            llm_provider = providers_list[llm_idx]
-
-            provider_config["llm_provider"] = llm_provider
-
-            if llm_provider == "openai_compatible":
-                val = input("  LLM endpoint URL (e.g. http://192.168.1.10:8080/v1): ").strip()
-                if val:
-                    provider_config["llm_base_url"] = val
-            elif llm_provider == "openrouter":
-                provider_config["llm_base_url"] = "https://openrouter.ai/api/v1"
-
-            default_model = _PROVIDER_DEFAULT_MODELS.get(llm_provider, "gpt-4o-mini")
-            val = input(f"  LLM model [{default_model}]: ").strip()
-            provider_config["llm_model"] = val or default_model
-
-            sys.stdout.write("  LLM API key: ")
-            sys.stdout.flush()
-            llm_key = getpass.getpass(prompt="") if sys.stdin.isatty() else sys.stdin.readline().strip()
-            if llm_key:
-                env_writes["HINDSIGHT_LLM_API_KEY"] = llm_key
-
-        # Step 4: Save everything
-        provider_config["bank_id"] = "hermes"
-        provider_config["recall_budget"] = "mid"
-        bank_id = "hermes"
-        config["memory"]["provider"] = "hindsight"
-        save_config(config)
-
-        self.save_config(provider_config, hermes_home)
-
-        if env_writes:
-            env_path = Path(hermes_home) / ".env"
-            env_path.parent.mkdir(parents=True, exist_ok=True)
-            existing_lines = []
-            if env_path.exists():
-                existing_lines = env_path.read_text().splitlines()
-            updated_keys = set()
-            new_lines = []
-            for line in existing_lines:
-                key_match = line.split("=", 1)[0].strip() if "=" in line and not line.startswith("#") else None
-                if key_match and key_match in env_writes:
-                    new_lines.append(f"{key_match}={env_writes[key_match]}")
-                    updated_keys.add(key_match)
-                else:
-                    new_lines.append(line)
-            for k, v in env_writes.items():
-                if k not in updated_keys:
-                    new_lines.append(f"{k}={v}")
-            env_path.write_text("\n".join(new_lines) + "\n")
-
-        print(f"\n  ✓ Hindsight memory configured ({mode} mode)")
-        if env_writes:
-            print(f"  API keys saved to .env")
-        print(f"\n  Start a new session to activate.\n")
-
     def get_config_schema(self):
         return [
-            {"key": "mode", "description": "Connection mode", "default": "cloud", "choices": ["cloud", "local_embedded", "local_external"]},
-            # Cloud mode
-            {"key": "api_url", "description": "Hindsight Cloud API URL", "default": _DEFAULT_API_URL, "when": {"mode": "cloud"}},
+            {"key": "mode", "description": "Cloud API or local embedded mode", "default": "cloud", "choices": ["cloud", "local"]},
+            {"key": "api_url", "description": "Hindsight API URL", "default": _DEFAULT_API_URL, "when": {"mode": "cloud"}},
             {"key": "api_key", "description": "Hindsight Cloud API key", "secret": True, "env_var": "HINDSIGHT_API_KEY", "url": "https://ui.hindsight.vectorize.io", "when": {"mode": "cloud"}},
-            # Local external mode
-            {"key": "api_url", "description": "Hindsight API URL", "default": _DEFAULT_LOCAL_URL, "when": {"mode": "local_external"}},
-            {"key": "api_key", "description": "API key (optional)", "secret": True, "env_var": "HINDSIGHT_API_KEY", "when": {"mode": "local_external"}},
-            # Local embedded mode
-            {"key": "llm_provider", "description": "LLM provider", "default": "openai", "choices": ["openai", "anthropic", "gemini", "groq", "openrouter", "minimax", "ollama", "lmstudio", "openai_compatible"], "when": {"mode": "local_embedded"}},
-            {"key": "llm_base_url", "description": "Endpoint URL (e.g. http://192.168.1.10:8080/v1)", "default": "", "when": {"mode": "local_embedded", "llm_provider": "openai_compatible"}},
-            {"key": "llm_api_key", "description": "LLM API key (optional for openai_compatible)", "secret": True, "env_var": "HINDSIGHT_LLM_API_KEY", "when": {"mode": "local_embedded"}},
-            {"key": "llm_model", "description": "LLM model", "default": "gpt-4o-mini", "default_from": {"field": "llm_provider", "map": _PROVIDER_DEFAULT_MODELS}, "when": {"mode": "local_embedded"}},
+            {"key": "llm_provider", "description": "LLM provider for local mode", "default": "openai", "choices": ["openai", "anthropic", "gemini", "groq", "minimax", "ollama"], "when": {"mode": "local"}},
+            {"key": "llm_api_key", "description": "LLM API key for local Hindsight", "secret": True, "env_var": "HINDSIGHT_LLM_API_KEY", "when": {"mode": "local"}},
+            {"key": "llm_base_url", "description": "LLM Base URL (e.g. for OpenRouter)", "default": "", "env_var": "HINDSIGHT_API_LLM_BASE_URL", "when": {"mode": "local"}},
+            {"key": "llm_model", "description": "LLM model for local mode", "default": "gpt-4o-mini", "default_from": {"field": "llm_provider", "map": _PROVIDER_DEFAULT_MODELS}, "when": {"mode": "local"}},
             {"key": "bank_id", "description": "Memory bank name", "default": "hermes"},
-            {"key": "bank_mission", "description": "Mission/purpose description for the memory bank"},
-            {"key": "bank_retain_mission", "description": "Custom extraction prompt for memory retention"},
-            {"key": "recall_budget", "description": "Recall thoroughness", "default": "mid", "choices": ["low", "mid", "high"]},
+            {"key": "budget", "description": "Recall thoroughness", "default": "mid", "choices": ["low", "mid", "high"]},
             {"key": "memory_mode", "description": "Memory integration mode", "default": "hybrid", "choices": ["hybrid", "context", "tools"]},
-            {"key": "recall_prefetch_method", "description": "Auto-recall method", "default": "recall", "choices": ["recall", "reflect"]},
-            {"key": "tags", "description": "Tags applied when storing memories (comma-separated)", "default": ""},
-            {"key": "recall_tags", "description": "Tags to filter when searching memories (comma-separated)", "default": ""},
-            {"key": "recall_tags_match", "description": "Tag matching mode for recall", "default": "any", "choices": ["any", "all", "any_strict", "all_strict"]},
-            {"key": "auto_recall", "description": "Automatically recall memories before each turn", "default": True},
-            {"key": "auto_retain", "description": "Automatically retain conversation turns", "default": True},
-            {"key": "retain_every_n_turns", "description": "Retain every N turns (1 = every turn)", "default": 1},
-            {"key": "retain_async","description": "Process retain asynchronously on the Hindsight server", "default": True},
-            {"key": "retain_context", "description": "Context label for retained memories", "default": "conversation between Hermes Agent and the User"},
-            {"key": "recall_max_tokens", "description": "Maximum tokens for recall results", "default": 4096},
-            {"key": "recall_max_input_chars", "description": "Maximum input query length for auto-recall", "default": 800},
-            {"key": "recall_prompt_preamble", "description": "Custom preamble for recalled memories in context"},
+            {"key": "prefetch_method", "description": "Auto-recall method", "default": "recall", "choices": ["recall", "reflect"]},
         ]
 
     def _get_client(self):
         """Return the cached Hindsight client (created once, reused)."""
         if self._client is None:
-            if self._mode == "local_embedded":
+            if self._mode == "local":
                 from hindsight import HindsightEmbedded
+                # Disable __del__ on the class to prevent "attached to a
+                # different loop" errors during GC — we handle cleanup in
+                # shutdown() instead.
                 HindsightEmbedded.__del__ = lambda self: None
-                llm_provider = self._config.get("llm_provider", "")
-                if llm_provider in ("openai_compatible", "openrouter"):
-                    llm_provider = "openai"
-                logger.debug("Creating HindsightEmbedded client (profile=%s, provider=%s)",
-                             self._config.get("profile", "hermes"), llm_provider)
                 kwargs = dict(
                     profile=self._config.get("profile", "hermes"),
-                    llm_provider=llm_provider,
-                    llm_api_key=self._config.get("llmApiKey") or self._config.get("llm_api_key") or os.environ.get("HINDSIGHT_LLM_API_KEY", ""),
+                    llm_provider=self._config.get("llm_provider", ""),
+                    llm_api_key=self._config.get("llm_api_key") or os.environ.get("HINDSIGHT_LLM_API_KEY", ""),
                     llm_model=self._config.get("llm_model", ""),
                 )
-                if self._llm_base_url:
-                    kwargs["llm_base_url"] = self._llm_base_url
+                base_url = self._config.get("llm_base_url") or os.environ.get("HINDSIGHT_API_LLM_BASE_URL", "")
+                if base_url:
+                    kwargs["llm_base_url"] = base_url
                 self._client = HindsightEmbedded(**kwargs)
             else:
                 from hindsight_client import Hindsight
                 kwargs = {"base_url": self._api_url, "timeout": 30.0}
                 if self._api_key:
                     kwargs["api_key"] = self._api_key
-                logger.debug("Creating Hindsight cloud client (url=%s, has_key=%s)",
-                             self._api_url, bool(self._api_key))
                 self._client = Hindsight(**kwargs)
         return self._client
 
     def initialize(self, session_id: str, **kwargs) -> None:
-        self._session_id = session_id
-
-        # Check client version and auto-upgrade if needed
-        try:
-            from importlib.metadata import version as pkg_version
-            from packaging.version import Version
-            installed = pkg_version("hindsight-client")
-            if Version(installed) < Version(_MIN_CLIENT_VERSION):
-                logger.warning("hindsight-client %s is outdated (need >=%s), attempting upgrade...",
-                               installed, _MIN_CLIENT_VERSION)
-                import shutil, subprocess, sys
-                uv_path = shutil.which("uv")
-                if uv_path:
-                    try:
-                        subprocess.run(
-                            [uv_path, "pip", "install", "--python", sys.executable,
-                             "--quiet", "--upgrade", f"hindsight-client>={_MIN_CLIENT_VERSION}"],
-                            check=True, timeout=120, capture_output=True,
-                        )
-                        logger.info("hindsight-client upgraded to >=%s", _MIN_CLIENT_VERSION)
-                    except Exception as e:
-                        logger.warning("Auto-upgrade failed: %s. Run: uv pip install 'hindsight-client>=%s'",
-                                       e, _MIN_CLIENT_VERSION)
-                else:
-                    logger.warning("uv not found. Run: pip install 'hindsight-client>=%s'", _MIN_CLIENT_VERSION)
-        except Exception:
-            pass  # packaging not available or other issue — proceed anyway
-
         self._config = _load_config()
         self._mode = self._config.get("mode", "cloud")
-        # "local" is a legacy alias for "local_embedded"
-        if self._mode == "local":
-            self._mode = "local_embedded"
-        self._api_key = self._config.get("apiKey") or self._config.get("api_key") or os.environ.get("HINDSIGHT_API_KEY", "")
-        default_url = _DEFAULT_LOCAL_URL if self._mode in ("local_embedded", "local_external") else _DEFAULT_API_URL
+        self._api_key = self._config.get("apiKey") or os.environ.get("HINDSIGHT_API_KEY", "")
+        default_url = _DEFAULT_LOCAL_URL if self._mode == "local" else _DEFAULT_API_URL
         self._api_url = self._config.get("api_url") or os.environ.get("HINDSIGHT_API_URL", default_url)
-        self._llm_base_url = self._config.get("llm_base_url", "")
 
         banks = self._config.get("banks", {}).get("hermes", {})
         self._bank_id = self._config.get("bank_id") or banks.get("bankId", "hermes")
-        budget = self._config.get("recall_budget") or self._config.get("budget") or banks.get("budget", "mid")
+        budget = self._config.get("budget") or banks.get("budget", "mid")
         self._budget = budget if budget in _VALID_BUDGETS else "mid"
 
         memory_mode = self._config.get("memory_mode", "hybrid")
         self._memory_mode = memory_mode if memory_mode in ("context", "tools", "hybrid") else "hybrid"
 
-        prefetch_method = self._config.get("recall_prefetch_method", "recall")
+        prefetch_method = self._config.get("prefetch_method", "recall")
         self._prefetch_method = prefetch_method if prefetch_method in ("recall", "reflect") else "recall"
 
-        # Bank options
-        self._bank_mission = self._config.get("bank_mission", "")
-        self._bank_retain_mission = self._config.get("bank_retain_mission") or None
-
-        # Tags
-        self._tags = self._config.get("tags") or None
-        self._recall_tags = self._config.get("recall_tags") or None
-        self._recall_tags_match = self._config.get("recall_tags_match", "any")
-
-        # Retain controls
-        self._auto_retain = self._config.get("auto_retain", True)
-        self._retain_every_n_turns = max(1, int(self._config.get("retain_every_n_turns", 1)))
-        self._retain_context = self._config.get("retain_context", "conversation between Hermes Agent and the User")
-
-        # Recall controls
-        self._auto_recall = self._config.get("auto_recall", True)
-        self._recall_max_tokens = int(self._config.get("recall_max_tokens", 4096))
-        self._recall_types = self._config.get("recall_types") or None
-        self._recall_prompt_preamble = self._config.get("recall_prompt_preamble", "")
-        self._recall_max_input_chars = int(self._config.get("recall_max_input_chars", 800))
-        self._retain_async = self._config.get("retain_async", True)
-
-        _client_version = "unknown"
-        try:
-            from importlib.metadata import version as pkg_version
-            _client_version = pkg_version("hindsight-client")
-        except Exception:
-            pass
-        logger.info("Hindsight initialized: mode=%s, api_url=%s, bank=%s, budget=%s, memory_mode=%s, prefetch_method=%s, client=%s",
-                     self._mode, self._api_url, self._bank_id, self._budget, self._memory_mode, self._prefetch_method, _client_version)
-        logger.debug("Hindsight config: auto_retain=%s, auto_recall=%s, retain_every_n=%d, "
-                     "retain_async=%s, retain_context=%s, "
-                     "recall_max_tokens=%d, recall_max_input_chars=%d, tags=%s, recall_tags=%s",
-                     self._auto_retain, self._auto_recall, self._retain_every_n_turns,
-                     self._retain_async, self._retain_context,
-                     self._recall_max_tokens, self._recall_max_input_chars,
-                     self._tags, self._recall_tags)
+        logger.info("Hindsight initialized: mode=%s, api_url=%s, bank=%s, budget=%s, memory_mode=%s, prefetch_method=%s",
+                     self._mode, self._api_url, self._bank_id, self._budget, self._memory_mode, self._prefetch_method)
 
         # For local mode, start the embedded daemon in the background so it
         # doesn't block the chat. Redirect stdout/stderr to a log file to
         # prevent rich startup output from spamming the terminal.
-        if self._mode == "local_embedded":
+        if self._mode == "local":
             def _start_daemon():
                 import traceback
                 log_dir = get_hermes_home() / "logs"
@@ -583,8 +320,6 @@ class HindsightMemoryProvider(MemoryProvider):
                     current_provider = self._config.get("llm_provider", "")
                     current_model = self._config.get("llm_model", "")
                     current_base_url = self._config.get("llm_base_url") or os.environ.get("HINDSIGHT_API_LLM_BASE_URL", "")
-                    # Map openai_compatible/openrouter → openai for the daemon (OpenAI wire format)
-                    daemon_provider = "openai" if current_provider in ("openai_compatible", "openrouter") else current_provider
 
                     # Read saved profile config
                     saved = {}
@@ -595,7 +330,7 @@ class HindsightMemoryProvider(MemoryProvider):
                                 saved[k.strip()] = v.strip()
 
                     config_changed = (
-                        saved.get("HINDSIGHT_API_LLM_PROVIDER") != daemon_provider or
+                        saved.get("HINDSIGHT_API_LLM_PROVIDER") != current_provider or
                         saved.get("HINDSIGHT_API_LLM_MODEL") != current_model or
                         saved.get("HINDSIGHT_API_LLM_API_KEY") != current_key or
                         saved.get("HINDSIGHT_API_LLM_BASE_URL", "") != current_base_url
@@ -605,7 +340,7 @@ class HindsightMemoryProvider(MemoryProvider):
                         # Write updated profile .env
                         profile_env.parent.mkdir(parents=True, exist_ok=True)
                         env_lines = (
-                            f"HINDSIGHT_API_LLM_PROVIDER={daemon_provider}\n"
+                            f"HINDSIGHT_API_LLM_PROVIDER={current_provider}\n"
                             f"HINDSIGHT_API_LLM_API_KEY={current_key}\n"
                             f"HINDSIGHT_API_LLM_MODEL={current_model}\n"
                             f"HINDSIGHT_API_LOG_LEVEL=info\n"
@@ -653,118 +388,47 @@ class HindsightMemoryProvider(MemoryProvider):
 
     def prefetch(self, query: str, *, session_id: str = "") -> str:
         if self._prefetch_thread and self._prefetch_thread.is_alive():
-            logger.debug("Prefetch: waiting for background thread to complete")
             self._prefetch_thread.join(timeout=3.0)
         with self._prefetch_lock:
             result = self._prefetch_result
             self._prefetch_result = ""
         if not result:
-            logger.debug("Prefetch: no results available")
             return ""
-        logger.debug("Prefetch: returning %d chars of context", len(result))
-        header = self._recall_prompt_preamble or (
-            "# Hindsight Memory (persistent cross-session context)\n"
-            "Use this to answer questions about the user and prior sessions. "
-            "Do not call tools to look up information that is already present here."
-        )
-        return f"{header}\n\n{result}"
+        return f"## Hindsight Memory\n{result}"
 
     def queue_prefetch(self, query: str, *, session_id: str = "") -> None:
         if self._memory_mode == "tools":
-            logger.debug("Prefetch: skipped (tools-only mode)")
             return
-        if not self._auto_recall:
-            logger.debug("Prefetch: skipped (auto_recall disabled)")
-            return
-        # Truncate query to max chars
-        if self._recall_max_input_chars and len(query) > self._recall_max_input_chars:
-            query = query[:self._recall_max_input_chars]
-
         def _run():
             try:
                 client = self._get_client()
                 if self._prefetch_method == "reflect":
-                    logger.debug("Prefetch: calling reflect (bank=%s, query_len=%d)", self._bank_id, len(query))
                     resp = _run_sync(client.areflect(bank_id=self._bank_id, query=query, budget=self._budget))
                     text = resp.text or ""
                 else:
-                    recall_kwargs: dict = {
-                        "bank_id": self._bank_id, "query": query,
-                        "budget": self._budget, "max_tokens": self._recall_max_tokens,
-                    }
-                    if self._recall_tags:
-                        recall_kwargs["tags"] = self._recall_tags
-                        recall_kwargs["tags_match"] = self._recall_tags_match
-                    if self._recall_types:
-                        recall_kwargs["types"] = self._recall_types
-                    logger.debug("Prefetch: calling recall (bank=%s, query_len=%d, budget=%s)",
-                                 self._bank_id, len(query), self._budget)
-                    resp = _run_sync(client.arecall(**recall_kwargs))
-                    num_results = len(resp.results) if resp.results else 0
-                    logger.debug("Prefetch: recall returned %d results", num_results)
-                    text = "\n".join(f"- {r.text}" for r in resp.results if r.text) if resp.results else ""
+                    resp = _run_sync(client.arecall(bank_id=self._bank_id, query=query, budget=self._budget))
+                    text = "\n".join(r.text for r in resp.results if r.text) if resp.results else ""
                 if text:
                     with self._prefetch_lock:
                         self._prefetch_result = text
             except Exception as e:
-                logger.debug("Hindsight prefetch failed: %s", e, exc_info=True)
+                logger.debug("Hindsight prefetch failed: %s", e)
 
         self._prefetch_thread = threading.Thread(target=_run, daemon=True, name="hindsight-prefetch")
         self._prefetch_thread.start()
 
     def sync_turn(self, user_content: str, assistant_content: str, *, session_id: str = "") -> None:
-        """Retain conversation turn in background (non-blocking).
-
-        Respects retain_every_n_turns for batching.
-        """
-        if not self._auto_retain:
-            logger.debug("sync_turn: skipped (auto_retain disabled)")
-            return
-
-        from datetime import datetime, timezone
-        now = datetime.now(timezone.utc).isoformat()
-
-        messages = [
-            {"role": "user", "content": user_content, "timestamp": now},
-            {"role": "assistant", "content": assistant_content, "timestamp": now},
-        ]
-
-        turn = json.dumps(messages)
-        self._session_turns.append(turn)
-        self._turn_counter += 1
-
-        # Only retain every N turns
-        if self._turn_counter % self._retain_every_n_turns != 0:
-            logger.debug("sync_turn: buffered turn %d (will retain at turn %d)",
-                         self._turn_counter, self._turn_counter + (self._retain_every_n_turns - self._turn_counter % self._retain_every_n_turns))
-            return
-
-        logger.debug("sync_turn: retaining %d turns, total session content %d chars",
-                     len(self._session_turns), sum(len(t) for t in self._session_turns))
-        # Send the ENTIRE session as a single JSON array (document_id deduplicates).
-        # Each element in _session_turns is a JSON string of that turn's messages.
-        content = "[" + ",".join(self._session_turns) + "]"
+        """Retain conversation turn in background (non-blocking)."""
+        combined = f"User: {user_content}\nAssistant: {assistant_content}"
 
         def _sync():
             try:
                 client = self._get_client()
-                item: dict = {
-                    "content": content,
-                    "context": self._retain_context,
-                }
-                if self._tags:
-                    item["tags"] = self._tags
-                logger.debug("Hindsight retain: bank=%s, doc=%s, async=%s, content_len=%d, num_turns=%d",
-                             self._bank_id, self._session_id, self._retain_async, len(content), len(self._session_turns))
-                _run_sync(client.aretain_batch(
-                    bank_id=self._bank_id,
-                    items=[item],
-                    document_id=self._session_id,
-                    retain_async=self._retain_async,
+                _run_sync(client.aretain(
+                    bank_id=self._bank_id, content=combined, context="conversation"
                 ))
-                logger.debug("Hindsight retain succeeded")
             except Exception as e:
-                logger.warning("Hindsight sync failed: %s", e, exc_info=True)
+                logger.warning("Hindsight sync failed: %s", e)
 
         if self._sync_thread and self._sync_thread.is_alive():
             self._sync_thread.join(timeout=5.0)
@@ -789,18 +453,12 @@ class HindsightMemoryProvider(MemoryProvider):
                 return tool_error("Missing required parameter: content")
             context = args.get("context")
             try:
-                retain_kwargs: dict = {
-                    "bank_id": self._bank_id, "content": content, "context": context,
-                }
-                if self._tags:
-                    retain_kwargs["tags"] = self._tags
-                logger.debug("Tool hindsight_retain: bank=%s, content_len=%d, context=%s",
-                             self._bank_id, len(content), context)
-                _run_sync(client.aretain(**retain_kwargs))
-                logger.debug("Tool hindsight_retain: success")
+                _run_sync(client.aretain(
+                    bank_id=self._bank_id, content=content, context=context
+                ))
                 return json.dumps({"result": "Memory stored successfully."})
             except Exception as e:
-                logger.warning("hindsight_retain failed: %s", e, exc_info=True)
+                logger.warning("hindsight_retain failed: %s", e)
                 return tool_error(f"Failed to store memory: {e}")
 
         elif tool_name == "hindsight_recall":
@@ -808,26 +466,15 @@ class HindsightMemoryProvider(MemoryProvider):
             if not query:
                 return tool_error("Missing required parameter: query")
             try:
-                recall_kwargs: dict = {
-                    "bank_id": self._bank_id, "query": query, "budget": self._budget,
-                    "max_tokens": self._recall_max_tokens,
-                }
-                if self._recall_tags:
-                    recall_kwargs["tags"] = self._recall_tags
-                    recall_kwargs["tags_match"] = self._recall_tags_match
-                if self._recall_types:
-                    recall_kwargs["types"] = self._recall_types
-                logger.debug("Tool hindsight_recall: bank=%s, query_len=%d, budget=%s",
-                             self._bank_id, len(query), self._budget)
-                resp = _run_sync(client.arecall(**recall_kwargs))
-                num_results = len(resp.results) if resp.results else 0
-                logger.debug("Tool hindsight_recall: %d results", num_results)
+                resp = _run_sync(client.arecall(
+                    bank_id=self._bank_id, query=query, budget=self._budget
+                ))
                 if not resp.results:
                     return json.dumps({"result": "No relevant memories found."})
                 lines = [f"{i}. {r.text}" for i, r in enumerate(resp.results, 1)]
                 return json.dumps({"result": "\n".join(lines)})
             except Exception as e:
-                logger.warning("hindsight_recall failed: %s", e, exc_info=True)
+                logger.warning("hindsight_recall failed: %s", e)
                 return tool_error(f"Failed to search memory: {e}")
 
         elif tool_name == "hindsight_reflect":
@@ -835,28 +482,24 @@ class HindsightMemoryProvider(MemoryProvider):
             if not query:
                 return tool_error("Missing required parameter: query")
             try:
-                logger.debug("Tool hindsight_reflect: bank=%s, query_len=%d, budget=%s",
-                             self._bank_id, len(query), self._budget)
                 resp = _run_sync(client.areflect(
                     bank_id=self._bank_id, query=query, budget=self._budget
                 ))
-                logger.debug("Tool hindsight_reflect: response_len=%d", len(resp.text or ""))
                 return json.dumps({"result": resp.text or "No relevant memories found."})
             except Exception as e:
-                logger.warning("hindsight_reflect failed: %s", e, exc_info=True)
+                logger.warning("hindsight_reflect failed: %s", e)
                 return tool_error(f"Failed to reflect: {e}")
 
         return tool_error(f"Unknown tool: {tool_name}")
 
     def shutdown(self) -> None:
-        logger.debug("Hindsight shutdown: waiting for background threads")
         global _loop, _loop_thread
         for t in (self._prefetch_thread, self._sync_thread):
             if t and t.is_alive():
                 t.join(timeout=5.0)
         if self._client is not None:
             try:
-                if self._mode == "local_embedded":
+                if self._mode == "local":
                     # Use the public close() API. The RuntimeError from
                     # aiohttp's "attached to a different loop" is expected
                     # and harmless — the daemon keeps running independently.

plugins/memory/hindsight/plugin.yaml

@@ -2,7 +2,9 @@ name: hindsight
 version: 1.0.0
 description: "Hindsight — long-term memory with knowledge graph, entity resolution, and multi-strategy retrieval."
 pip_dependencies:
-  - "hindsight-client>=0.4.22"
-requires_env: []
+  - hindsight-client
+  - hindsight-all
+requires_env:
+  - HINDSIGHT_API_KEY
 hooks:
   - on_session_end

run_agent.py

@@ -66,7 +66,7 @@ from model_tools import (
     handle_function_call,
     check_toolset_requirements,
 )
-from tools.terminal_tool import cleanup_vm, get_active_env, is_persistent_env
+from tools.terminal_tool import cleanup_vm, get_active_env
 from tools.tool_result_storage import maybe_persist_tool_result, enforce_turn_budget
 from tools.interrupt import set_interrupt as _set_interrupt
 from tools.browser_tool import cleanup_browser
@@ -442,13 +442,6 @@ class AIAgent:
     for AI models that support function calling.
     """
 
-    # ── Class-level context pressure dedup (survives across instances) ──
-    # The gateway creates a new AIAgent per message, so instance-level flags
-    # reset every time.  This dict tracks {session_id: (warn_level, timestamp)}
-    # to suppress duplicate warnings within a cooldown window.
-    _context_pressure_last_warned: dict = {}
-    _CONTEXT_PRESSURE_COOLDOWN = 300  # seconds between re-warning same session
-
     @property
     def base_url(self) -> str:
         return self._base_url
@@ -680,8 +673,7 @@ class AIAgent:
         # Context pressure warnings: notify the USER (not the LLM) as context
         # fills up.  Purely informational — displayed in CLI output and sent via
         # status_callback for gateway platforms.  Does NOT inject into messages.
-        # Tiered: fires at 85% and again at 95% of compaction threshold.
-        self._context_pressure_warned_at = 0.0  # highest tier already shown
+        self._context_pressure_warned = False
 
         # Activity tracking — updated on each API call, tool execution, and
         # stream chunk.  Used by the gateway timeout handler to report what the
@@ -1695,25 +1687,9 @@ class AIAgent:
         return None
 
     def _cleanup_task_resources(self, task_id: str) -> None:
-        """Clean up VM and browser resources for a given task.
-
-        Skips ``cleanup_vm`` when the active terminal environment is marked
-        persistent (``persistent_filesystem=True``) so that long-lived sandbox
-        containers survive between turns. The idle reaper in
-        ``terminal_tool._cleanup_inactive_envs`` still tears them down once
-        ``terminal.lifetime_seconds`` is exceeded. Non-persistent backends are
-        torn down per-turn as before to prevent resource leakage (the original
-        intent of this hook for the Morph backend, see commit fbd3a2fd).
-        """
+        """Clean up VM and browser resources for a given task."""
         try:
-            if is_persistent_env(task_id):
-                if self.verbose_logging:
-                    logging.debug(
-                        f"Skipping per-turn cleanup_vm for persistent env {task_id}; "
-                        f"idle reaper will handle it."
-                    )
-            else:
-                cleanup_vm(task_id)
+            cleanup_vm(task_id)
         except Exception as e:
             if self.verbose_logging:
                 logging.warning(f"Failed to cleanup VM for task {task_id}: {e}")
@@ -4752,25 +4728,18 @@ class AIAgent:
                     self._close_request_openai_client(request_client, reason="stream_request_complete")
 
         _stream_stale_timeout_base = float(os.getenv("HERMES_STREAM_STALE_TIMEOUT", 180.0))
-        # Local providers (Ollama, oMLX, llama-cpp) can take 300+ seconds
-        # for prefill on large contexts.  Disable the stale detector unless
-        # the user explicitly set HERMES_STREAM_STALE_TIMEOUT.
-        if _stream_stale_timeout_base == 180.0 and self.base_url and is_local_endpoint(self.base_url):
-            _stream_stale_timeout = float("inf")
-            logger.debug("Local provider detected (%s) — stale stream timeout disabled", self.base_url)
+        # Scale the stale timeout for large contexts: slow models (like Opus)
+        # can legitimately think for minutes before producing the first token
+        # when the context is large.  Without this, the stale detector kills
+        # healthy connections during the model's thinking phase, producing
+        # spurious RemoteProtocolError ("peer closed connection").
+        _est_tokens = sum(len(str(v)) for v in api_kwargs.get("messages", [])) // 4
+        if _est_tokens > 100_000:
+            _stream_stale_timeout = max(_stream_stale_timeout_base, 300.0)
+        elif _est_tokens > 50_000:
+            _stream_stale_timeout = max(_stream_stale_timeout_base, 240.0)
         else:
-            # Scale the stale timeout for large contexts: slow models (like Opus)
-            # can legitimately think for minutes before producing the first token
-            # when the context is large.  Without this, the stale detector kills
-            # healthy connections during the model's thinking phase, producing
-            # spurious RemoteProtocolError ("peer closed connection").
-            _est_tokens = sum(len(str(v)) for v in api_kwargs.get("messages", [])) // 4
-            if _est_tokens > 100_000:
-                _stream_stale_timeout = max(_stream_stale_timeout_base, 300.0)
-            elif _est_tokens > 50_000:
-                _stream_stale_timeout = max(_stream_stale_timeout_base, 240.0)
-            else:
-                _stream_stale_timeout = _stream_stale_timeout_base
+            _stream_stale_timeout = _stream_stale_timeout_base
 
         t = threading.Thread(target=_call, daemon=True)
         t.start()
@@ -5895,7 +5864,7 @@ class AIAgent:
                     tools=[memory_tool_def],
                     temperature=0.3,
                     max_tokens=5120,
-                    # timeout resolved from auxiliary.flush_memories.timeout config
+                    timeout=30.0,
                 )
             except RuntimeError:
                 _aux_available = False
@@ -5927,10 +5896,7 @@ class AIAgent:
                     "temperature": 0.3,
                     **self._max_tokens_param(5120),
                 }
-                from agent.auxiliary_client import _get_task_timeout
-                response = self._ensure_primary_openai_client(reason="flush_memories").chat.completions.create(
-                    **api_kwargs, timeout=_get_task_timeout("flush_memories")
-                )
+                response = self._ensure_primary_openai_client(reason="flush_memories").chat.completions.create(**api_kwargs, timeout=30.0)
 
             # Extract tool calls from the response, handling all API formats
             tool_calls = []
@@ -6037,15 +6003,6 @@ class AIAgent:
             except Exception as e:
                 logger.warning("Session DB compression split failed — new session will NOT be indexed: %s", e)
 
-        # Warn on repeated compressions (quality degrades with each pass)
-        _cc = self.context_compressor.compression_count
-        if _cc >= 2:
-            self._vprint(
-                f"{self.log_prefix}⚠️  Session compressed {_cc} times — "
-                f"accuracy may degrade. Consider /new to start fresh.",
-                force=True,
-            )
-
         # Update token estimate after compaction so pressure calculations
         # use the post-compression count, not the stale pre-compression one.
         _compressed_est = (
@@ -6058,16 +6015,12 @@ class AIAgent:
         # Only reset the pressure warning if compression actually brought
         # us below the warning level (85% of threshold).  When compression
         # can't reduce enough (e.g. threshold is very low, or system prompt
-        # alone exceeds the warning level), keep the tier set to prevent
+        # alone exceeds the warning level), keep the flag set to prevent
         # spamming the user with repeated warnings every loop iteration.
         if self.context_compressor.threshold_tokens > 0:
             _post_progress = _compressed_est / self.context_compressor.threshold_tokens
             if _post_progress < 0.85:
-                self._context_pressure_warned_at = 0.0
-                # Clear class-level dedup for this session so a fresh
-                # warning cycle can start if context grows again.
-                _sid = self.session_id or "default"
-                AIAgent._context_pressure_last_warned.pop(_sid, None)
+                self._context_pressure_warned = False
 
         # Clear the file-read dedup cache.  After compression the original
         # read content is summarised away — if the model re-reads the same
@@ -9007,34 +8960,13 @@ class AIAgent:
                     # compaction fires, not the raw context window.
                     # Does not inject into messages — just prints to CLI output
                     # and fires status_callback for gateway platforms.
-                    # Tiered: 85% (orange) and 95% (red/critical).
                     if _compressor.threshold_tokens > 0:
                         _compaction_progress = _real_tokens / _compressor.threshold_tokens
-                        # Determine the warning tier for this progress level
-                        _warn_tier = 0.0
-                        if _compaction_progress >= 0.95:
-                            _warn_tier = 0.95
-                        elif _compaction_progress >= 0.85:
-                            _warn_tier = 0.85
-                        if _warn_tier > self._context_pressure_warned_at:
-                            # Class-level dedup: check if this session was already
-                            # warned at this tier within the cooldown window.
-                            _sid = self.session_id or "default"
-                            _last = AIAgent._context_pressure_last_warned.get(_sid)
-                            _now = time.time()
-                            if _last is None or _last[0] < _warn_tier or (_now - _last[1]) >= self._CONTEXT_PRESSURE_COOLDOWN:
-                                self._context_pressure_warned_at = _warn_tier
-                                AIAgent._context_pressure_last_warned[_sid] = (_warn_tier, _now)
-                                self._emit_context_pressure(_compaction_progress, _compressor)
-                                # Evict stale entries (older than 2x cooldown)
-                                _cutoff = _now - self._CONTEXT_PRESSURE_COOLDOWN * 2
-                                AIAgent._context_pressure_last_warned = {
-                                    k: v for k, v in AIAgent._context_pressure_last_warned.items()
-                                    if v[1] > _cutoff
-                                }
+                        if _compaction_progress >= 0.85 and not self._context_pressure_warned:
+                            self._context_pressure_warned = True
+                            self._emit_context_pressure(_compaction_progress, _compressor)
 
                     if self.compression_enabled and _compressor.should_compress(_real_tokens):
-                        self._safe_print("  ⟳ compacting context…")
                         messages, active_system_prompt = self._compress_context(
                             messages, system_message,
                             approx_tokens=self.context_compressor.last_prompt_tokens,
@@ -9109,27 +9041,8 @@ class AIAgent:
                             self._save_session_log(messages)
                             continue
 
-                        # ── Empty response retry (no reasoning) ──────
-                        # Model returned nothing — no content, no
-                        # structured reasoning, no tool calls.  Common
-                        # with open models (transient provider issues,
-                        # rate limits, sampling flukes).  Silently retry
-                        # up to 3 times before giving up.  Skip when
-                        # content has inline <think> tags (model chose
-                        # to reason, just no visible text).
-                        _truly_empty = not final_response.strip()
-                        if _truly_empty and not _has_structured and self._empty_content_retries < 3:
-                            self._empty_content_retries += 1
-                            self._vprint(
-                                f"{self.log_prefix}↻ Empty response (no content or reasoning) "
-                                f"— retrying ({self._empty_content_retries}/3)",
-                                force=True,
-                            )
-                            continue
-
-                        # Exhausted prefill attempts, empty retries, or
-                        # structured reasoning with no content —
-                        # fall through to "(empty)" terminal.
+                        # Exhausted prefill attempts or no structured
+                        # reasoning — fall through to "(empty)" terminal.
                         reasoning_text = self._extract_reasoning(assistant_message)
                         assistant_msg = self._build_assistant_message(assistant_message, finish_reason)
                         assistant_msg["content"] = "(empty)"
@@ -9139,7 +9052,7 @@ class AIAgent:
                             reasoning_preview = reasoning_text[:500] + "..." if len(reasoning_text) > 500 else reasoning_text
                             self._vprint(f"{self.log_prefix}ℹ️  Reasoning-only response (no visible content). Reasoning: {reasoning_preview}")
                         else:
-                            self._vprint(f"{self.log_prefix}ℹ️  Empty response (no content or reasoning) after 3 retries.")
+                            self._vprint(f"{self.log_prefix}ℹ️  Empty response (no content or reasoning).")
 
                         final_response = "(empty)"
                         break

tests/agent/test_auxiliary_client.py

@@ -77,20 +77,6 @@ class TestReadCodexAccessToken:
         result = _read_codex_access_token()
         assert result == "tok-123"
 
-    def test_pool_without_selected_entry_falls_back_to_auth_store(self, tmp_path, monkeypatch):
-        hermes_home = tmp_path / "hermes"
-        hermes_home.mkdir(parents=True, exist_ok=True)
-        monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-        valid_jwt = "eyJhbGciOiJSUzI1NiJ9.eyJleHAiOjk5OTk5OTk5OTl9.sig"
-        with patch("agent.auxiliary_client._select_pool_entry", return_value=(True, None)), \
-             patch("hermes_cli.auth._read_codex_tokens", return_value={
-                 "tokens": {"access_token": valid_jwt, "refresh_token": "refresh"}
-             }):
-            result = _read_codex_access_token()
-
-        assert result == valid_jwt
-
     def test_missing_returns_none(self, tmp_path, monkeypatch):
         hermes_home = tmp_path / "hermes"
         hermes_home.mkdir(parents=True, exist_ok=True)
@@ -252,24 +238,6 @@ class TestAnthropicOAuthFlag:
         assert mock_build.call_args.args[0] == "sk-ant-oat01-pooled"
 
 
-class TestTryCodex:
-    def test_pool_without_selected_entry_falls_back_to_auth_store(self):
-        with (
-            patch("agent.auxiliary_client._select_pool_entry", return_value=(True, None)),
-            patch("agent.auxiliary_client._read_codex_access_token", return_value="codex-auth-token"),
-            patch("agent.auxiliary_client.OpenAI") as mock_openai,
-        ):
-            mock_openai.return_value = MagicMock()
-            from agent.auxiliary_client import _try_codex
-
-            client, model = _try_codex()
-
-        assert client is not None
-        assert model == "gpt-5.2-codex"
-        assert mock_openai.call_args.kwargs["api_key"] == "codex-auth-token"
-        assert mock_openai.call_args.kwargs["base_url"] == "https://chatgpt.com/backend-api/codex"
-
-
 class TestExpiredCodexFallback:
     """Test that expired Codex tokens don't block the auto chain."""
 

tests/agent/test_context_compressor.py

@@ -324,10 +324,7 @@ class TestCompressWithClient:
         with patch("agent.context_compressor.get_model_context_length", return_value=100000):
             c = ContextCompressor(model="test", quiet_mode=True, protect_first_n=2, protect_last_n=2)
 
-        # Last head message (index 1) is "assistant" → summary should be "user".
-        # With min_tail=3, tail = last 3 messages (indices 5-7).
-        # head_last=assistant, tail_first=assistant → summary_role="user", no collision.
-        # Need 8 messages: min_for_compress = 2+3+1 = 6, must have > 6.
+        # Last head message (index 1) is "assistant" → summary should be "user"
         msgs = [
             {"role": "user", "content": "msg 0"},
             {"role": "assistant", "content": "msg 1"},
@@ -335,8 +332,6 @@ class TestCompressWithClient:
             {"role": "assistant", "content": "msg 3"},
             {"role": "user", "content": "msg 4"},
             {"role": "assistant", "content": "msg 5"},
-            {"role": "user", "content": "msg 6"},
-            {"role": "assistant", "content": "msg 7"},
         ]
         with patch("agent.context_compressor.call_llm", return_value=mock_response):
             result = c.compress(msgs)
@@ -465,10 +460,8 @@ class TestCompressWithClient:
             c = ContextCompressor(model="test", quiet_mode=True, protect_first_n=2, protect_last_n=2)
 
         # Head: [system, user]        → last head = user
-        # Tail: [assistant, user, assistant] → first tail = assistant
+        # Tail: [assistant, user]     → first tail = assistant
         # summary_role="assistant" collides with tail, "user" collides with head → merge
-        # With min_tail=3, tail = last 3 messages (indices 5-7).
-        # Need 8 messages: min_for_compress = 2+3+1 = 6, must have > 6.
         msgs = [
             {"role": "system", "content": "system prompt"},
             {"role": "user", "content": "msg 1"},
@@ -477,7 +470,6 @@ class TestCompressWithClient:
             {"role": "assistant", "content": "msg 4"},   # compressed
             {"role": "assistant", "content": "msg 5"},   # tail start
             {"role": "user", "content": "msg 6"},
-            {"role": "assistant", "content": "msg 7"},
         ]
         with patch("agent.context_compressor.call_llm", return_value=mock_response):
             result = c.compress(msgs)
@@ -489,7 +481,7 @@ class TestCompressWithClient:
             if r1 in ("user", "assistant") and r2 in ("user", "assistant"):
                 assert r1 != r2, f"consecutive {r1} at indices {i-1},{i}"
 
-        # The summary should be merged into the first tail message (assistant at index 5)
+        # The summary should be merged into the first tail message (assistant)
         first_tail = [m for m in result if "msg 5" in (m.get("content") or "")]
         assert len(first_tail) == 1
         assert "summary text" in first_tail[0]["content"]
@@ -504,18 +496,14 @@ class TestCompressWithClient:
         with patch("agent.context_compressor.get_model_context_length", return_value=100000):
             c = ContextCompressor(model="test", quiet_mode=True, protect_first_n=2, protect_last_n=2)
 
-        # Head=assistant, Tail=assistant → summary_role="user", no collision.
-        # With min_tail=3, tail = last 3 messages (indices 5-7).
-        # Need 8 messages: min_for_compress = 2+3+1 = 6, must have > 6.
+        # Head=assistant, Tail=assistant → summary_role="user", no collision
         msgs = [
             {"role": "user", "content": "msg 0"},
             {"role": "assistant", "content": "msg 1"},
             {"role": "user", "content": "msg 2"},
             {"role": "assistant", "content": "msg 3"},
-            {"role": "user", "content": "msg 4"},
-            {"role": "assistant", "content": "msg 5"},
-            {"role": "user", "content": "msg 6"},
-            {"role": "assistant", "content": "msg 7"},
+            {"role": "assistant", "content": "msg 4"},
+            {"role": "user", "content": "msg 5"},
         ]
         with patch("agent.context_compressor.call_llm", return_value=mock_response):
             result = c.compress(msgs)
@@ -612,158 +600,3 @@ class TestSummaryTargetRatio:
         with patch("agent.context_compressor.get_model_context_length", return_value=100_000):
             c = ContextCompressor(model="test", quiet_mode=True)
         assert c.protect_last_n == 20
-
-
-class TestTokenBudgetTailProtection:
-    """Tests for token-budget-based tail protection (PR #6240).
-
-    The core change: tail protection is now based on a token budget rather
-    than a fixed message count.  This prevents large tool outputs from
-    blocking compaction.
-    """
-
-    @pytest.fixture()
-    def budget_compressor(self):
-        """Compressor with known token budget for tail protection tests."""
-        with patch("agent.context_compressor.get_model_context_length", return_value=200_000):
-            c = ContextCompressor(
-                model="test/model",
-                threshold_percent=0.50,  # 100K threshold
-                protect_first_n=2,
-                protect_last_n=20,
-                quiet_mode=True,
-            )
-            return c
-
-    def test_large_tool_outputs_no_longer_block_compaction(self, budget_compressor):
-        """The motivating scenario: 20 messages with large tool outputs should
-        NOT prevent compaction.  With message-count tail protection they would
-        all be protected, leaving nothing to summarize."""
-        c = budget_compressor
-        messages = [
-            {"role": "user", "content": "Start task"},
-            {"role": "assistant", "content": "On it"},
-        ]
-        # Add 20 messages with large tool outputs (~5K chars each ≈ 1250 tokens)
-        for i in range(10):
-            messages.append({
-                "role": "assistant", "content": None,
-                "tool_calls": [{"function": {"name": f"tool_{i}", "arguments": "{}"}}],
-            })
-            messages.append({
-                "role": "tool", "content": "x" * 5000,
-                "tool_call_id": f"call_{i}",
-            })
-        # Add 3 recent small messages
-        messages.append({"role": "user", "content": "What's the status?"})
-        messages.append({"role": "assistant", "content": "Here's what I found..."})
-        messages.append({"role": "user", "content": "Continue"})
-
-        # The tail cut should NOT protect all 20 tool messages
-        head_end = c.protect_first_n
-        cut = c._find_tail_cut_by_tokens(messages, head_end)
-        tail_size = len(messages) - cut
-        # With token budget, the tail should be much smaller than 20+
-        assert tail_size < 20, f"Tail {tail_size} messages — large tool outputs are blocking compaction"
-        # But at least 3 (hard minimum)
-        assert tail_size >= 3
-
-    def test_min_tail_always_3_messages(self, budget_compressor):
-        """Even with a tiny token budget, at least 3 messages are protected."""
-        c = budget_compressor
-        # Override to a tiny budget
-        c.tail_token_budget = 10
-        messages = [
-            {"role": "user", "content": "hello"},
-            {"role": "assistant", "content": "hi"},
-            {"role": "user", "content": "do something"},
-            {"role": "assistant", "content": "working on it"},
-            {"role": "user", "content": "more work"},
-            {"role": "assistant", "content": "done"},
-            {"role": "user", "content": "thanks"},
-        ]
-        head_end = 2
-        cut = c._find_tail_cut_by_tokens(messages, head_end)
-        tail_size = len(messages) - cut
-        assert tail_size >= 3, f"Tail is only {tail_size} messages, min should be 3"
-
-    def test_soft_ceiling_allows_oversized_message(self, budget_compressor):
-        """The 1.5x soft ceiling allows an oversized message to be included
-        rather than splitting it."""
-        c = budget_compressor
-        # Set a small budget — 500 tokens
-        c.tail_token_budget = 500
-        messages = [
-            {"role": "user", "content": "hello"},
-            {"role": "assistant", "content": "hi"},
-            {"role": "user", "content": "read the file"},
-            # This message is ~600 tokens (> budget of 500, but < 1.5x = 750)
-            {"role": "assistant", "content": "a" * 2400},
-            {"role": "user", "content": "short"},
-            {"role": "assistant", "content": "short reply"},
-            {"role": "user", "content": "continue"},
-        ]
-        head_end = 2
-        cut = c._find_tail_cut_by_tokens(messages, head_end)
-        # The oversized message at index 3 should NOT be the cut point
-        # because 1.5x ceiling = 750 tokens and accumulated would be ~610
-        # (short msgs + oversized msg) which is < 750
-        tail_size = len(messages) - cut
-        assert tail_size >= 3
-
-    def test_small_conversation_still_compresses(self, budget_compressor):
-        """With the new min of 8 messages (head=2 + 3 + 1 guard + 2 middle),
-        a small but compressible conversation should still compress."""
-        c = budget_compressor
-        # 9 messages: head(2) + 4 middle + 3 tail = compressible
-        messages = []
-        for i in range(9):
-            role = "user" if i % 2 == 0 else "assistant"
-            messages.append({"role": role, "content": f"Message {i}"})
-
-        # Should not early-return (needs > protect_first_n + 3 + 1 = 6)
-        # Mock the summary generation to avoid real API call
-        with patch.object(c, "_generate_summary", return_value="Summary of conversation"):
-            result = c.compress(messages, current_tokens=90_000)
-        # Should have compressed (fewer messages than original)
-        assert len(result) < len(messages)
-
-    def test_prune_with_token_budget(self, budget_compressor):
-        """_prune_old_tool_results with protect_tail_tokens respects the budget."""
-        c = budget_compressor
-        messages = [
-            {"role": "user", "content": "start"},
-            {"role": "assistant", "content": None,
-             "tool_calls": [{"function": {"name": "read_file", "arguments": '{"path": "big.txt"}'}}]},
-            {"role": "tool", "content": "x" * 10000, "tool_call_id": "c1"},  # ~2500 tokens
-            {"role": "assistant", "content": None,
-             "tool_calls": [{"function": {"name": "read_file", "arguments": '{"path": "small.txt"}'}}]},
-            {"role": "tool", "content": "y" * 10000, "tool_call_id": "c2"},  # ~2500 tokens
-            {"role": "user", "content": "short recent message"},
-            {"role": "assistant", "content": "short reply"},
-        ]
-        # With a 1000-token budget, only the last couple messages should be protected
-        result, pruned = c._prune_old_tool_results(
-            messages, protect_tail_count=2, protect_tail_tokens=1000,
-        )
-        # At least one old tool result should have been pruned
-        assert pruned >= 1
-
-    def test_prune_without_token_budget_uses_message_count(self, budget_compressor):
-        """Without protect_tail_tokens, falls back to message-count behavior."""
-        c = budget_compressor
-        messages = [
-            {"role": "user", "content": "start"},
-            {"role": "assistant", "content": None,
-             "tool_calls": [{"function": {"name": "tool", "arguments": "{}"}}]},
-            {"role": "tool", "content": "x" * 5000, "tool_call_id": "c1"},
-            {"role": "user", "content": "recent"},
-            {"role": "assistant", "content": "reply"},
-        ]
-        # protect_tail_count=3 means last 3 messages protected
-        result, pruned = c._prune_old_tool_results(
-            messages, protect_tail_count=3,
-        )
-        # Tool at index 2 is outside the protected tail (last 3 = indices 2,3,4)
-        # so it might or might not be pruned depending on boundary
-        assert isinstance(pruned, int)

tests/agent/test_credential_pool.py

@@ -214,42 +214,6 @@ def test_exhausted_entry_resets_after_ttl(tmp_path, monkeypatch):
     assert entry.last_status == "ok"
 
 
-def test_exhausted_402_entry_resets_after_one_hour(tmp_path, monkeypatch):
-    """402-exhausted credentials recover after 1 hour, not 24."""
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes"))
-    _write_auth_store(
-        tmp_path,
-        {
-            "version": 1,
-            "credential_pool": {
-                "openrouter": [
-                    {
-                        "id": "cred-1",
-                        "label": "primary",
-                        "auth_type": "api_key",
-                        "priority": 0,
-                        "source": "manual",
-                        "access_token": "***",
-                        "base_url": "https://openrouter.ai/api/v1",
-                        "last_status": "exhausted",
-                        "last_status_at": time.time() - 3700,  # ~1h2m ago
-                        "last_error_code": 402,
-                    }
-                ]
-            },
-        },
-    )
-
-    from agent.credential_pool import load_pool
-
-    pool = load_pool("openrouter")
-    entry = pool.select()
-
-    assert entry is not None
-    assert entry.id == "cred-1"
-    assert entry.last_status == "ok"
-
-
 def test_explicit_reset_timestamp_overrides_default_429_ttl(tmp_path, monkeypatch):
     monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes"))
     _write_auth_store(

tests/gateway/test_bluebubbles.py

@@ -1,361 +0,0 @@
-"""Tests for the BlueBubbles iMessage gateway adapter."""
-import pytest
-
-from gateway.config import Platform, PlatformConfig
-
-
-def _make_adapter(monkeypatch, **extra):
-    monkeypatch.setenv("BLUEBUBBLES_SERVER_URL", "http://localhost:1234")
-    monkeypatch.setenv("BLUEBUBBLES_PASSWORD", "secret")
-    from gateway.platforms.bluebubbles import BlueBubblesAdapter
-
-    cfg = PlatformConfig(
-        enabled=True,
-        extra={
-            "server_url": "http://localhost:1234",
-            "password": "secret",
-            **extra,
-        },
-    )
-    return BlueBubblesAdapter(cfg)
-
-
-class TestBlueBubblesPlatformEnum:
-    def test_bluebubbles_enum_exists(self):
-        assert Platform.BLUEBUBBLES.value == "bluebubbles"
-
-
-class TestBlueBubblesConfigLoading:
-    def test_apply_env_overrides_bluebubbles(self, monkeypatch):
-        monkeypatch.setenv("BLUEBUBBLES_SERVER_URL", "http://localhost:1234")
-        monkeypatch.setenv("BLUEBUBBLES_PASSWORD", "secret")
-        monkeypatch.setenv("BLUEBUBBLES_WEBHOOK_PORT", "9999")
-        from gateway.config import GatewayConfig, _apply_env_overrides
-
-        config = GatewayConfig()
-        _apply_env_overrides(config)
-        assert Platform.BLUEBUBBLES in config.platforms
-        bc = config.platforms[Platform.BLUEBUBBLES]
-        assert bc.enabled is True
-        assert bc.extra["server_url"] == "http://localhost:1234"
-        assert bc.extra["password"] == "secret"
-        assert bc.extra["webhook_port"] == 9999
-
-    def test_connected_platforms_includes_bluebubbles(self, monkeypatch):
-        monkeypatch.setenv("BLUEBUBBLES_SERVER_URL", "http://localhost:1234")
-        monkeypatch.setenv("BLUEBUBBLES_PASSWORD", "secret")
-        from gateway.config import GatewayConfig, _apply_env_overrides
-
-        config = GatewayConfig()
-        _apply_env_overrides(config)
-        assert Platform.BLUEBUBBLES in config.get_connected_platforms()
-
-    def test_home_channel_set_from_env(self, monkeypatch):
-        monkeypatch.setenv("BLUEBUBBLES_SERVER_URL", "http://localhost:1234")
-        monkeypatch.setenv("BLUEBUBBLES_PASSWORD", "secret")
-        monkeypatch.setenv("BLUEBUBBLES_HOME_CHANNEL", "user@example.com")
-        from gateway.config import GatewayConfig, _apply_env_overrides
-
-        config = GatewayConfig()
-        _apply_env_overrides(config)
-        hc = config.platforms[Platform.BLUEBUBBLES].home_channel
-        assert hc is not None
-        assert hc.chat_id == "user@example.com"
-
-    def test_not_connected_without_password(self, monkeypatch):
-        monkeypatch.setenv("BLUEBUBBLES_SERVER_URL", "http://localhost:1234")
-        monkeypatch.delenv("BLUEBUBBLES_PASSWORD", raising=False)
-        from gateway.config import GatewayConfig, _apply_env_overrides
-
-        config = GatewayConfig()
-        _apply_env_overrides(config)
-        assert Platform.BLUEBUBBLES not in config.get_connected_platforms()
-
-
-class TestBlueBubblesHelpers:
-    def test_check_requirements(self, monkeypatch):
-        monkeypatch.setenv("BLUEBUBBLES_SERVER_URL", "http://localhost:1234")
-        monkeypatch.setenv("BLUEBUBBLES_PASSWORD", "secret")
-        from gateway.platforms.bluebubbles import check_bluebubbles_requirements
-
-        assert check_bluebubbles_requirements() is True
-
-    def test_format_message_strips_markdown(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        assert adapter.format_message("**Hello** `world`") == "Hello world"
-
-    def test_strip_markdown_headers(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        assert adapter.format_message("## Heading\ntext") == "Heading\ntext"
-
-    def test_strip_markdown_links(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        assert adapter.format_message("[click here](http://example.com)") == "click here"
-
-    def test_init_normalizes_webhook_path(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch, webhook_path="bluebubbles-webhook")
-        assert adapter.webhook_path == "/bluebubbles-webhook"
-
-    def test_init_preserves_leading_slash(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch, webhook_path="/my-hook")
-        assert adapter.webhook_path == "/my-hook"
-
-    def test_server_url_normalized(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch, server_url="http://localhost:1234/")
-        assert adapter.server_url == "http://localhost:1234"
-
-    def test_server_url_adds_scheme(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch, server_url="localhost:1234")
-        assert adapter.server_url == "http://localhost:1234"
-
-
-class TestBlueBubblesWebhookParsing:
-    def test_webhook_prefers_chat_guid_over_message_guid(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        payload = {
-            "guid": "MESSAGE-GUID",
-            "chatGuid": "iMessage;-;user@example.com",
-            "chatIdentifier": "user@example.com",
-        }
-        record = adapter._extract_payload_record(payload) or {}
-        chat_guid = adapter._value(
-            record.get("chatGuid"),
-            payload.get("chatGuid"),
-            record.get("chat_guid"),
-            payload.get("chat_guid"),
-            payload.get("guid"),
-        )
-        assert chat_guid == "iMessage;-;user@example.com"
-
-    def test_webhook_can_fall_back_to_sender_when_chat_fields_missing(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        payload = {
-            "data": {
-                "guid": "MESSAGE-GUID",
-                "text": "hello",
-                "handle": {"address": "user@example.com"},
-                "isFromMe": False,
-            }
-        }
-        record = adapter._extract_payload_record(payload) or {}
-        chat_guid = adapter._value(
-            record.get("chatGuid"),
-            payload.get("chatGuid"),
-            record.get("chat_guid"),
-            payload.get("chat_guid"),
-            payload.get("guid"),
-        )
-        chat_identifier = adapter._value(
-            record.get("chatIdentifier"),
-            record.get("identifier"),
-            payload.get("chatIdentifier"),
-            payload.get("identifier"),
-        )
-        sender = (
-            adapter._value(
-                record.get("handle", {}).get("address")
-                if isinstance(record.get("handle"), dict)
-                else None,
-                record.get("sender"),
-                record.get("from"),
-                record.get("address"),
-            )
-            or chat_identifier
-            or chat_guid
-        )
-        if not (chat_guid or chat_identifier) and sender:
-            chat_identifier = sender
-        assert chat_identifier == "user@example.com"
-
-    def test_extract_payload_record_accepts_list_data(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        payload = {
-            "type": "new-message",
-            "data": [
-                {
-                    "text": "hello",
-                    "chatGuid": "iMessage;-;user@example.com",
-                    "chatIdentifier": "user@example.com",
-                }
-            ],
-        }
-        record = adapter._extract_payload_record(payload)
-        assert record == payload["data"][0]
-
-    def test_extract_payload_record_dict_data(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        payload = {"data": {"text": "hello", "chatGuid": "iMessage;-;+1234"}}
-        record = adapter._extract_payload_record(payload)
-        assert record["text"] == "hello"
-
-    def test_extract_payload_record_fallback_to_message(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        payload = {"message": {"text": "hello"}}
-        record = adapter._extract_payload_record(payload)
-        assert record["text"] == "hello"
-
-
-class TestBlueBubblesGuidResolution:
-    def test_raw_guid_returned_as_is(self, monkeypatch):
-        """If target already contains ';' it's a raw GUID — return unchanged."""
-        adapter = _make_adapter(monkeypatch)
-        import asyncio
-
-        result = asyncio.get_event_loop().run_until_complete(
-            adapter._resolve_chat_guid("iMessage;-;user@example.com")
-        )
-        assert result == "iMessage;-;user@example.com"
-
-    def test_empty_target_returns_none(self, monkeypatch):
-        adapter = _make_adapter(monkeypatch)
-        import asyncio
-
-        result = asyncio.get_event_loop().run_until_complete(
-            adapter._resolve_chat_guid("")
-        )
-        assert result is None
-
-
-class TestBlueBubblesToolsetIntegration:
-    def test_toolset_exists(self):
-        from toolsets import TOOLSETS
-
-        assert "hermes-bluebubbles" in TOOLSETS
-
-    def test_toolset_in_gateway_composite(self):
-        from toolsets import TOOLSETS
-
-        gateway = TOOLSETS["hermes-gateway"]
-        assert "hermes-bluebubbles" in gateway["includes"]
-
-
-class TestBlueBubblesPromptHint:
-    def test_platform_hint_exists(self):
-        from agent.prompt_builder import PLATFORM_HINTS
-
-        assert "bluebubbles" in PLATFORM_HINTS
-        hint = PLATFORM_HINTS["bluebubbles"]
-        assert "iMessage" in hint
-        assert "plain text" in hint
-
-
-class TestBlueBubblesAttachmentDownload:
-    """Verify _download_attachment routes to the correct cache helper."""
-
-    def test_download_image_uses_image_cache(self, monkeypatch):
-        """Image MIME routes to cache_image_from_bytes."""
-        adapter = _make_adapter(monkeypatch)
-        import asyncio
-        import httpx
-
-        # Mock the HTTP client response
-        class MockResponse:
-            status_code = 200
-            content = b"\x89PNG\r\n\x1a\n"
-
-            def raise_for_status(self):
-                pass
-
-        async def mock_get(*args, **kwargs):
-            return MockResponse()
-
-        adapter.client = type("MockClient", (), {"get": mock_get})()
-
-        cached_path = None
-
-        def mock_cache_image(data, ext):
-            nonlocal cached_path
-            cached_path = f"/tmp/test_image{ext}"
-            return cached_path
-
-        monkeypatch.setattr(
-            "gateway.platforms.bluebubbles.cache_image_from_bytes",
-            mock_cache_image,
-        )
-
-        att_meta = {"mimeType": "image/png", "transferName": "photo.png"}
-        result = asyncio.get_event_loop().run_until_complete(
-            adapter._download_attachment("att-guid-123", att_meta)
-        )
-        assert result == "/tmp/test_image.png"
-
-    def test_download_audio_uses_audio_cache(self, monkeypatch):
-        """Audio MIME routes to cache_audio_from_bytes."""
-        adapter = _make_adapter(monkeypatch)
-        import asyncio
-
-        class MockResponse:
-            status_code = 200
-            content = b"fake-audio-data"
-
-            def raise_for_status(self):
-                pass
-
-        async def mock_get(*args, **kwargs):
-            return MockResponse()
-
-        adapter.client = type("MockClient", (), {"get": mock_get})()
-
-        cached_path = None
-
-        def mock_cache_audio(data, ext):
-            nonlocal cached_path
-            cached_path = f"/tmp/test_audio{ext}"
-            return cached_path
-
-        monkeypatch.setattr(
-            "gateway.platforms.bluebubbles.cache_audio_from_bytes",
-            mock_cache_audio,
-        )
-
-        att_meta = {"mimeType": "audio/mpeg", "transferName": "voice.mp3"}
-        result = asyncio.get_event_loop().run_until_complete(
-            adapter._download_attachment("att-guid-456", att_meta)
-        )
-        assert result == "/tmp/test_audio.mp3"
-
-    def test_download_document_uses_document_cache(self, monkeypatch):
-        """Non-image/audio MIME routes to cache_document_from_bytes."""
-        adapter = _make_adapter(monkeypatch)
-        import asyncio
-
-        class MockResponse:
-            status_code = 200
-            content = b"fake-doc-data"
-
-            def raise_for_status(self):
-                pass
-
-        async def mock_get(*args, **kwargs):
-            return MockResponse()
-
-        adapter.client = type("MockClient", (), {"get": mock_get})()
-
-        cached_path = None
-
-        def mock_cache_doc(data, filename):
-            nonlocal cached_path
-            cached_path = f"/tmp/{filename}"
-            return cached_path
-
-        monkeypatch.setattr(
-            "gateway.platforms.bluebubbles.cache_document_from_bytes",
-            mock_cache_doc,
-        )
-
-        att_meta = {"mimeType": "application/pdf", "transferName": "report.pdf"}
-        result = asyncio.get_event_loop().run_until_complete(
-            adapter._download_attachment("att-guid-789", att_meta)
-        )
-        assert result == "/tmp/report.pdf"
-
-    def test_download_returns_none_without_client(self, monkeypatch):
-        """No client → returns None gracefully."""
-        adapter = _make_adapter(monkeypatch)
-        adapter.client = None
-        import asyncio
-
-        result = asyncio.get_event_loop().run_until_complete(
-            adapter._download_attachment("att-guid", {"mimeType": "image/png"})
-        )
-        assert result is None

tests/gateway/test_discord_document_handling.py

@@ -209,31 +209,14 @@ class TestIncomingDocumentHandling:
         assert "[Content of readme.md]:" in event.text
         assert "# Title" in event.text
 
-    @pytest.mark.asyncio
-    async def test_log_content_injected(self, adapter):
-        """.log file under 100KB should be treated as text/plain and injected."""
-        file_content = b"BLE trace line 1\nBLE trace line 2"
-
-        with _mock_aiohttp_download(file_content):
-            msg = make_message(
-                attachments=[make_attachment(filename="btsnoop_hci.log", content_type="text/plain")],
-                content="please inspect this",
-            )
-            await adapter._handle_message(msg)
-
-        event = adapter.handle_message.call_args[0][0]
-        assert "[Content of btsnoop_hci.log]:" in event.text
-        assert "BLE trace line 1" in event.text
-        assert "please inspect this" in event.text
-
     @pytest.mark.asyncio
     async def test_oversized_document_skipped(self, adapter):
-        """A document over 32MB should be skipped — media_urls stays empty."""
+        """A document over 20MB should be skipped — media_urls stays empty."""
         msg = make_message([
             make_attachment(
                 filename="huge.pdf",
                 content_type="application/pdf",
-                size=33 * 1024 * 1024,
+                size=25 * 1024 * 1024,
             )
         ])
         await adapter._handle_message(msg)
@@ -243,24 +226,6 @@ class TestIncomingDocumentHandling:
         # handler must still be called
         adapter.handle_message.assert_called_once()
 
-    @pytest.mark.asyncio
-    async def test_mid_sized_zip_under_32mb_is_cached(self, adapter):
-        """A 25MB .zip should be accepted now that Discord documents allow up to 32MB."""
-        msg = make_message([
-            make_attachment(
-                filename="bugreport.zip",
-                content_type="application/zip",
-                size=25 * 1024 * 1024,
-            )
-        ])
-
-        with _mock_aiohttp_download(b"PK\x03\x04test"):
-            await adapter._handle_message(msg)
-
-        event = adapter.handle_message.call_args[0][0]
-        assert len(event.media_urls) == 1
-        assert event.media_types == ["application/zip"]
-
     @pytest.mark.asyncio
     async def test_zip_document_cached(self, adapter):
         """A .zip file should be cached as a supported document."""

tests/gateway/test_discord_reply_mode.py

@@ -1,277 +0,0 @@
-"""Tests for Discord reply_to_mode functionality.
-
-Covers the threading behavior control for multi-chunk replies:
-- "off": Never reply-reference to original message
-- "first": Only first chunk uses reply reference (default)
-- "all": All chunks reply-reference the original message
-"""
-import os
-import sys
-from types import SimpleNamespace
-from unittest.mock import MagicMock, AsyncMock, patch
-
-import pytest
-
-from gateway.config import PlatformConfig, GatewayConfig, Platform, _apply_env_overrides
-
-
-def _ensure_discord_mock():
-    """Install a mock discord module when discord.py isn't available."""
-    if "discord" in sys.modules and hasattr(sys.modules["discord"], "__file__"):
-        return
-
-    discord_mod = MagicMock()
-    discord_mod.Intents.default.return_value = MagicMock()
-    discord_mod.Client = MagicMock
-    discord_mod.File = MagicMock
-    discord_mod.DMChannel = type("DMChannel", (), {})
-    discord_mod.Thread = type("Thread", (), {})
-    discord_mod.ForumChannel = type("ForumChannel", (), {})
-    discord_mod.ui = SimpleNamespace(View=object, button=lambda *a, **k: (lambda fn: fn), Button=object)
-    discord_mod.ButtonStyle = SimpleNamespace(success=1, primary=2, secondary=2, danger=3, green=1, grey=2, blurple=2, red=3)
-    discord_mod.Color = SimpleNamespace(orange=lambda: 1, green=lambda: 2, blue=lambda: 3, red=lambda: 4, purple=lambda: 5)
-    discord_mod.Interaction = object
-    discord_mod.Embed = MagicMock
-    discord_mod.app_commands = SimpleNamespace(
-        describe=lambda **kwargs: (lambda fn: fn),
-        choices=lambda **kwargs: (lambda fn: fn),
-        Choice=lambda **kwargs: SimpleNamespace(**kwargs),
-    )
-
-    ext_mod = MagicMock()
-    commands_mod = MagicMock()
-    commands_mod.Bot = MagicMock
-    ext_mod.commands = commands_mod
-
-    sys.modules.setdefault("discord", discord_mod)
-    sys.modules.setdefault("discord.ext", ext_mod)
-    sys.modules.setdefault("discord.ext.commands", commands_mod)
-
-
-_ensure_discord_mock()
-
-from gateway.platforms.discord import DiscordAdapter  # noqa: E402
-
-
-@pytest.fixture()
-def adapter_factory():
-    """Factory to create DiscordAdapter with custom reply_to_mode."""
-    def create(reply_to_mode: str = "first"):
-        config = PlatformConfig(enabled=True, token="test-token", reply_to_mode=reply_to_mode)
-        return DiscordAdapter(config)
-    return create
-
-
-class TestReplyToModeConfig:
-    """Tests for reply_to_mode configuration loading."""
-
-    def test_default_mode_is_first(self, adapter_factory):
-        adapter = adapter_factory()
-        assert adapter._reply_to_mode == "first"
-
-    def test_off_mode(self, adapter_factory):
-        adapter = adapter_factory(reply_to_mode="off")
-        assert adapter._reply_to_mode == "off"
-
-    def test_first_mode(self, adapter_factory):
-        adapter = adapter_factory(reply_to_mode="first")
-        assert adapter._reply_to_mode == "first"
-
-    def test_all_mode(self, adapter_factory):
-        adapter = adapter_factory(reply_to_mode="all")
-        assert adapter._reply_to_mode == "all"
-
-    def test_invalid_mode_stored_as_is(self, adapter_factory):
-        """Invalid modes are stored but send() handles them gracefully."""
-        adapter = adapter_factory(reply_to_mode="invalid")
-        assert adapter._reply_to_mode == "invalid"
-
-    def test_none_mode_defaults_to_first(self):
-        config = PlatformConfig(enabled=True, token="test-token")
-        adapter = DiscordAdapter(config)
-        assert adapter._reply_to_mode == "first"
-
-    def test_empty_string_mode_defaults_to_first(self):
-        config = PlatformConfig(enabled=True, token="test-token", reply_to_mode="")
-        adapter = DiscordAdapter(config)
-        assert adapter._reply_to_mode == "first"
-
-
-def _make_discord_adapter(reply_to_mode: str = "first"):
-    """Create a DiscordAdapter with mocked client and channel for send() tests."""
-    config = PlatformConfig(enabled=True, token="test-token", reply_to_mode=reply_to_mode)
-    adapter = DiscordAdapter(config)
-
-    # Mock the Discord client and channel
-    mock_channel = AsyncMock()
-    ref_message = MagicMock()
-    mock_channel.fetch_message = AsyncMock(return_value=ref_message)
-
-    sent_msg = MagicMock()
-    sent_msg.id = 42
-    mock_channel.send = AsyncMock(return_value=sent_msg)
-
-    mock_client = MagicMock()
-    mock_client.get_channel = MagicMock(return_value=mock_channel)
-
-    adapter._client = mock_client
-    return adapter, mock_channel, ref_message
-
-
-class TestSendWithReplyToMode:
-    """Tests for send() method respecting reply_to_mode."""
-
-    @pytest.mark.asyncio
-    async def test_off_mode_no_reply_reference(self):
-        adapter, channel, ref_msg = _make_discord_adapter("off")
-        adapter.truncate_message = lambda content, max_len: ["chunk1", "chunk2", "chunk3"]
-
-        await adapter.send("12345", "test content", reply_to="999")
-
-        # Should never try to fetch the reference message
-        channel.fetch_message.assert_not_called()
-        # All chunks sent without reference
-        for call in channel.send.call_args_list:
-            assert call.kwargs.get("reference") is None
-
-    @pytest.mark.asyncio
-    async def test_first_mode_only_first_chunk_references(self):
-        adapter, channel, ref_msg = _make_discord_adapter("first")
-        adapter.truncate_message = lambda content, max_len: ["chunk1", "chunk2", "chunk3"]
-
-        await adapter.send("12345", "test content", reply_to="999")
-
-        # Should fetch the reference message
-        channel.fetch_message.assert_called_once_with(999)
-        calls = channel.send.call_args_list
-        assert len(calls) == 3
-        assert calls[0].kwargs.get("reference") is ref_msg
-        assert calls[1].kwargs.get("reference") is None
-        assert calls[2].kwargs.get("reference") is None
-
-    @pytest.mark.asyncio
-    async def test_all_mode_all_chunks_reference(self):
-        adapter, channel, ref_msg = _make_discord_adapter("all")
-        adapter.truncate_message = lambda content, max_len: ["chunk1", "chunk2", "chunk3"]
-
-        await adapter.send("12345", "test content", reply_to="999")
-
-        channel.fetch_message.assert_called_once_with(999)
-        calls = channel.send.call_args_list
-        assert len(calls) == 3
-        for call in calls:
-            assert call.kwargs.get("reference") is ref_msg
-
-    @pytest.mark.asyncio
-    async def test_no_reply_to_param_no_reference(self):
-        adapter, channel, ref_msg = _make_discord_adapter("all")
-        adapter.truncate_message = lambda content, max_len: ["chunk1", "chunk2"]
-
-        await adapter.send("12345", "test content", reply_to=None)
-
-        channel.fetch_message.assert_not_called()
-        for call in channel.send.call_args_list:
-            assert call.kwargs.get("reference") is None
-
-    @pytest.mark.asyncio
-    async def test_single_chunk_respects_first_mode(self):
-        adapter, channel, ref_msg = _make_discord_adapter("first")
-        adapter.truncate_message = lambda content, max_len: ["single chunk"]
-
-        await adapter.send("12345", "test", reply_to="999")
-
-        calls = channel.send.call_args_list
-        assert len(calls) == 1
-        assert calls[0].kwargs.get("reference") is ref_msg
-
-    @pytest.mark.asyncio
-    async def test_single_chunk_off_mode(self):
-        adapter, channel, ref_msg = _make_discord_adapter("off")
-        adapter.truncate_message = lambda content, max_len: ["single chunk"]
-
-        await adapter.send("12345", "test", reply_to="999")
-
-        channel.fetch_message.assert_not_called()
-        calls = channel.send.call_args_list
-        assert len(calls) == 1
-        assert calls[0].kwargs.get("reference") is None
-
-    @pytest.mark.asyncio
-    async def test_invalid_mode_falls_back_to_first_behavior(self):
-        """Invalid mode behaves like 'first' — only first chunk gets reference."""
-        adapter, channel, ref_msg = _make_discord_adapter("banana")
-        adapter.truncate_message = lambda content, max_len: ["chunk1", "chunk2"]
-
-        await adapter.send("12345", "test", reply_to="999")
-
-        calls = channel.send.call_args_list
-        assert len(calls) == 2
-        assert calls[0].kwargs.get("reference") is ref_msg
-        assert calls[1].kwargs.get("reference") is None
-
-
-class TestConfigSerialization:
-    """Tests for reply_to_mode serialization (shared with Telegram)."""
-
-    def test_to_dict_includes_reply_to_mode(self):
-        config = PlatformConfig(enabled=True, token="test", reply_to_mode="all")
-        result = config.to_dict()
-        assert result["reply_to_mode"] == "all"
-
-    def test_from_dict_loads_reply_to_mode(self):
-        data = {"enabled": True, "token": "***", "reply_to_mode": "off"}
-        config = PlatformConfig.from_dict(data)
-        assert config.reply_to_mode == "off"
-
-    def test_from_dict_defaults_to_first(self):
-        data = {"enabled": True, "token": "***"}
-        config = PlatformConfig.from_dict(data)
-        assert config.reply_to_mode == "first"
-
-
-class TestEnvVarOverride:
-    """Tests for DISCORD_REPLY_TO_MODE environment variable override."""
-
-    def _make_config(self):
-        config = GatewayConfig()
-        config.platforms[Platform.DISCORD] = PlatformConfig(enabled=True, token="test")
-        return config
-
-    def test_env_var_sets_off_mode(self):
-        config = self._make_config()
-        with patch.dict(os.environ, {"DISCORD_REPLY_TO_MODE": "off"}, clear=False):
-            _apply_env_overrides(config)
-        assert config.platforms[Platform.DISCORD].reply_to_mode == "off"
-
-    def test_env_var_sets_all_mode(self):
-        config = self._make_config()
-        with patch.dict(os.environ, {"DISCORD_REPLY_TO_MODE": "all"}, clear=False):
-            _apply_env_overrides(config)
-        assert config.platforms[Platform.DISCORD].reply_to_mode == "all"
-
-    def test_env_var_case_insensitive(self):
-        config = self._make_config()
-        with patch.dict(os.environ, {"DISCORD_REPLY_TO_MODE": "ALL"}, clear=False):
-            _apply_env_overrides(config)
-        assert config.platforms[Platform.DISCORD].reply_to_mode == "all"
-
-    def test_env_var_invalid_value_ignored(self):
-        config = self._make_config()
-        with patch.dict(os.environ, {"DISCORD_REPLY_TO_MODE": "banana"}, clear=False):
-            _apply_env_overrides(config)
-        assert config.platforms[Platform.DISCORD].reply_to_mode == "first"
-
-    def test_env_var_empty_value_ignored(self):
-        config = self._make_config()
-        with patch.dict(os.environ, {"DISCORD_REPLY_TO_MODE": ""}, clear=False):
-            _apply_env_overrides(config)
-        assert config.platforms[Platform.DISCORD].reply_to_mode == "first"
-
-    def test_env_var_creates_platform_config_if_missing(self):
-        """DISCORD_REPLY_TO_MODE creates PlatformConfig even without DISCORD_BOT_TOKEN."""
-        config = GatewayConfig()
-        assert Platform.DISCORD not in config.platforms
-        with patch.dict(os.environ, {"DISCORD_REPLY_TO_MODE": "off"}, clear=False):
-            _apply_env_overrides(config)
-        assert Platform.DISCORD in config.platforms
-        assert config.platforms[Platform.DISCORD].reply_to_mode == "off"

tests/gateway/test_gateway_inactivity_timeout.py

@@ -1,315 +0,0 @@
-"""Tests for staged inactivity timeout in gateway agent runs.
-
-Tests cover:
-- Warning fires once when inactivity reaches gateway_timeout_warning threshold
-- Warning does not fire when gateway_timeout is 0 (unlimited)
-- Warning fires only once per run, not on every poll
-- Full timeout still fires at gateway_timeout threshold
-- Warning respects HERMES_AGENT_TIMEOUT_WARNING env var
-- Warning disabled when gateway_timeout_warning is 0
-"""
-
-import concurrent.futures
-import os
-import sys
-import time
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-
-class FakeAgent:
-    """Mock agent with controllable activity summary for timeout tests."""
-
-    def __init__(self, idle_seconds=0.0, activity_desc="tool_call",
-                 current_tool=None, api_call_count=5, max_iterations=90):
-        self._idle_seconds = idle_seconds
-        self._activity_desc = activity_desc
-        self._current_tool = current_tool
-        self._api_call_count = api_call_count
-        self._max_iterations = max_iterations
-        self._interrupted = False
-        self._interrupt_msg = None
-
-    def get_activity_summary(self):
-        return {
-            "last_activity_ts": time.time() - self._idle_seconds,
-            "last_activity_desc": self._activity_desc,
-            "seconds_since_activity": self._idle_seconds,
-            "current_tool": self._current_tool,
-            "api_call_count": self._api_call_count,
-            "max_iterations": self._max_iterations,
-        }
-
-    def interrupt(self, msg):
-        self._interrupted = True
-        self._interrupt_msg = msg
-
-    def run_conversation(self, prompt):
-        return {"final_response": "Done", "messages": []}
-
-
-class SlowFakeAgent(FakeAgent):
-    """Agent that runs for a while, then goes idle."""
-
-    def __init__(self, run_duration=0.5, idle_after=None, **kwargs):
-        super().__init__(**kwargs)
-        self._run_duration = run_duration
-        self._idle_after = idle_after
-        self._start_time = None
-
-    def get_activity_summary(self):
-        summary = super().get_activity_summary()
-        if self._idle_after is not None and self._start_time:
-            elapsed = time.time() - self._start_time
-            if elapsed > self._idle_after:
-                idle_time = elapsed - self._idle_after
-                summary["seconds_since_activity"] = idle_time
-                summary["last_activity_desc"] = "api_call_streaming"
-            else:
-                summary["seconds_since_activity"] = 0.0
-        return summary
-
-    def run_conversation(self, prompt):
-        self._start_time = time.time()
-        time.sleep(self._run_duration)
-        return {"final_response": "Completed after work", "messages": []}
-
-
-class TestStagedInactivityWarning:
-    """Test the staged inactivity warning before full timeout."""
-
-    def test_warning_fires_once_before_timeout(self):
-        """Warning fires when inactivity reaches warning threshold."""
-        agent = SlowFakeAgent(
-            run_duration=10.0,
-            idle_after=0.1,
-            activity_desc="api_call_streaming",
-        )
-
-        _agent_timeout = 20.0
-        _agent_warning = 5.0
-        _POLL_INTERVAL = 0.1
-
-        pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-        future = pool.submit(agent.run_conversation, "test prompt")
-        _inactivity_timeout = False
-        _warning_fired = False
-        _warning_send_count = 0
-
-        while True:
-            done, _ = concurrent.futures.wait({future}, timeout=_POLL_INTERVAL)
-            if done:
-                result = future.result()
-                break
-            _idle_secs = 0.0
-            if hasattr(agent, "get_activity_summary"):
-                try:
-                    _act = agent.get_activity_summary()
-                    _idle_secs = _act.get("seconds_since_activity", 0.0)
-                except Exception:
-                    pass
-            if (not _warning_fired and _agent_warning > 0
-                    and _idle_secs >= _agent_warning):
-                _warning_fired = True
-                _warning_send_count += 1
-            if _idle_secs >= _agent_timeout:
-                _inactivity_timeout = True
-                break
-
-        pool.shutdown(wait=False, cancel_futures=True)
-
-        assert _warning_fired
-        assert _warning_send_count == 1
-        assert not _inactivity_timeout
-
-    def test_warning_disabled_when_zero(self):
-        """No warning fires when gateway_timeout_warning is 0."""
-        agent = SlowFakeAgent(
-            run_duration=5.0,
-            idle_after=0.1,
-        )
-
-        _agent_timeout = 20.0
-        _agent_warning = 0.0
-        _POLL_INTERVAL = 0.1
-
-        pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-        future = pool.submit(agent.run_conversation, "test")
-        _warning_fired = False
-
-        while True:
-            done, _ = concurrent.futures.wait({future}, timeout=_POLL_INTERVAL)
-            if done:
-                future.result()
-                break
-            _idle_secs = 0.0
-            if hasattr(agent, "get_activity_summary"):
-                try:
-                    _act = agent.get_activity_summary()
-                    _idle_secs = _act.get("seconds_since_activity", 0.0)
-                except Exception:
-                    pass
-            if (not _warning_fired and _agent_warning > 0
-                    and _idle_secs >= _agent_warning):
-                _warning_fired = True
-            if _idle_secs >= _agent_timeout:
-                break
-
-        pool.shutdown(wait=False, cancel_futures=True)
-        assert not _warning_fired
-
-    def test_warning_fires_only_once(self):
-        """Warning fires exactly once even if agent remains idle."""
-        agent = SlowFakeAgent(
-            run_duration=10.0,
-            idle_after=0.05,
-        )
-
-        _agent_timeout = 20.0
-        _agent_warning = 0.2
-        _POLL_INTERVAL = 0.05
-
-        pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-        future = pool.submit(agent.run_conversation, "test")
-        _warning_count = 0
-
-        while True:
-            done, _ = concurrent.futures.wait({future}, timeout=_POLL_INTERVAL)
-            if done:
-                future.result()
-                break
-            _idle_secs = 0.0
-            if hasattr(agent, "get_activity_summary"):
-                try:
-                    _act = agent.get_activity_summary()
-                    _idle_secs = _act.get("seconds_since_activity", 0.0)
-                except Exception:
-                    pass
-            if (not _warning_count and _agent_warning > 0
-                    and _idle_secs >= _agent_warning):
-                _warning_count += 1
-            if _idle_secs >= _agent_timeout:
-                break
-
-        pool.shutdown(wait=False, cancel_futures=True)
-        assert _warning_count == 1
-
-    def test_full_timeout_still_fires_after_warning(self):
-        """Full timeout fires even after warning was sent."""
-        agent = SlowFakeAgent(
-            run_duration=15.0,
-            idle_after=0.1,
-            activity_desc="waiting for provider response (streaming)",
-        )
-
-        _agent_timeout = 1.0
-        _agent_warning = 0.3
-        _POLL_INTERVAL = 0.05
-
-        pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-        future = pool.submit(agent.run_conversation, "test")
-        _inactivity_timeout = False
-        _warning_fired = False
-
-        while True:
-            done, _ = concurrent.futures.wait({future}, timeout=_POLL_INTERVAL)
-            if done:
-                future.result()
-                break
-            _idle_secs = 0.0
-            if hasattr(agent, "get_activity_summary"):
-                try:
-                    _act = agent.get_activity_summary()
-                    _idle_secs = _act.get("seconds_since_activity", 0.0)
-                except Exception:
-                    pass
-            if (not _warning_fired and _agent_warning > 0
-                    and _idle_secs >= _agent_warning):
-                _warning_fired = True
-            if _idle_secs >= _agent_timeout:
-                _inactivity_timeout = True
-                break
-
-        pool.shutdown(wait=False, cancel_futures=True)
-        assert _warning_fired
-        assert _inactivity_timeout
-
-    def test_warning_env_var_respected(self, monkeypatch):
-        """HERMES_AGENT_TIMEOUT_WARNING env var is parsed correctly."""
-        monkeypatch.setenv("HERMES_AGENT_TIMEOUT_WARNING", "600")
-        _warning = float(os.getenv("HERMES_AGENT_TIMEOUT_WARNING", 900))
-        assert _warning == 600.0
-
-    def test_warning_zero_means_disabled(self, monkeypatch):
-        """HERMES_AGENT_TIMEOUT_WARNING=0 disables the warning."""
-        monkeypatch.setenv("HERMES_AGENT_TIMEOUT_WARNING", "0")
-        _raw = float(os.getenv("HERMES_AGENT_TIMEOUT_WARNING", 900))
-        _warning = _raw if _raw > 0 else None
-        assert _warning is None
-
-    def test_unlimited_timeout_no_warning(self):
-        """When timeout is unlimited (0), no warning fires either."""
-        agent = SlowFakeAgent(
-            run_duration=0.5,
-            idle_after=0.0,
-        )
-
-        _agent_timeout = None
-        _agent_warning = 5.0
-        _POLL_INTERVAL = 0.05
-
-        pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-        future = pool.submit(agent.run_conversation, "test")
-
-        result = future.result(timeout=2.0)
-        pool.shutdown(wait=False)
-
-        assert result["final_response"] == "Completed after work"
-
-
-class TestWarningThresholdBelowTimeout:
-    """Test that warning threshold must be less than timeout threshold."""
-
-    def test_warning_at_half_timeout(self):
-        """Warning fires at half the timeout duration."""
-        agent = SlowFakeAgent(
-            run_duration=10.0,
-            idle_after=0.1,
-            activity_desc="receiving stream response",
-        )
-
-        _agent_timeout = 2.0
-        _agent_warning = 1.0
-        _POLL_INTERVAL = 0.05
-
-        pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-        future = pool.submit(agent.run_conversation, "test")
-        _warning_fired = False
-        _timeout_fired = False
-
-        while True:
-            done, _ = concurrent.futures.wait({future}, timeout=_POLL_INTERVAL)
-            if done:
-                future.result()
-                break
-            _idle_secs = 0.0
-            if hasattr(agent, "get_activity_summary"):
-                try:
-                    _act = agent.get_activity_summary()
-                    _idle_secs = _act.get("seconds_since_activity", 0.0)
-                except Exception:
-                    pass
-            if (not _warning_fired and _agent_warning > 0
-                    and _idle_secs >= _agent_warning):
-                _warning_fired = True
-            if _idle_secs >= _agent_timeout:
-                _timeout_fired = True
-                break
-
-        pool.shutdown(wait=False, cancel_futures=True)
-        assert _warning_fired
-        assert _timeout_fired

tests/gateway/test_internal_event_bypass_pairing.py

@@ -1,226 +0,0 @@
-"""Tests that internal synthetic events (e.g. background process completion)
-bypass user authorization and do not trigger DM pairing.
-
-Regression test for the bug where ``_run_process_watcher`` with
-``notify_on_complete=True`` injected a ``MessageEvent`` without ``user_id``,
-causing ``_is_user_authorized`` to reject it and the gateway to send a
-pairing code to the chat.
-"""
-
-import asyncio
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from gateway.config import GatewayConfig, Platform
-from gateway.platforms.base import MessageEvent
-from gateway.run import GatewayRunner
-from gateway.session import SessionSource
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-class _FakeRegistry:
-    """Return pre-canned sessions, then None once exhausted."""
-
-    def __init__(self, sessions):
-        self._sessions = list(sessions)
-
-    def get(self, session_id):
-        if self._sessions:
-            return self._sessions.pop(0)
-        return None
-
-
-def _build_runner(monkeypatch, tmp_path) -> GatewayRunner:
-    """Create a GatewayRunner with notifications set to 'all'."""
-    (tmp_path / "config.yaml").write_text(
-        "display:\n  background_process_notifications: all\n",
-        encoding="utf-8",
-    )
-
-    import gateway.run as gateway_run
-
-    monkeypatch.setattr(gateway_run, "_hermes_home", tmp_path)
-
-    runner = GatewayRunner(GatewayConfig())
-    adapter = SimpleNamespace(send=AsyncMock(), handle_message=AsyncMock())
-    runner.adapters[Platform.DISCORD] = adapter
-    return runner
-
-
-def _watcher_dict_with_notify():
-    return {
-        "session_id": "proc_test_internal",
-        "check_interval": 0,
-        "session_key": "agent:main:discord:dm:123",
-        "platform": "discord",
-        "chat_id": "123",
-        "thread_id": "",
-        "notify_on_complete": True,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Tests
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_notify_on_complete_sets_internal_flag(monkeypatch, tmp_path):
-    """Synthetic completion event must have internal=True."""
-    import tools.process_registry as pr_module
-
-    sessions = [
-        SimpleNamespace(
-            output_buffer="done\n", exited=True, exit_code=0, command="echo test"
-        ),
-    ]
-    monkeypatch.setattr(pr_module, "process_registry", _FakeRegistry(sessions))
-
-    async def _instant_sleep(*_a, **_kw):
-        pass
-    monkeypatch.setattr(asyncio, "sleep", _instant_sleep)
-
-    runner = _build_runner(monkeypatch, tmp_path)
-    adapter = runner.adapters[Platform.DISCORD]
-
-    await runner._run_process_watcher(_watcher_dict_with_notify())
-
-    assert adapter.handle_message.await_count == 1
-    event = adapter.handle_message.await_args.args[0]
-    assert isinstance(event, MessageEvent)
-    assert event.internal is True, "Synthetic completion event must be marked internal"
-
-
-@pytest.mark.asyncio
-async def test_internal_event_bypasses_authorization(monkeypatch, tmp_path):
-    """An internal event should skip _is_user_authorized entirely."""
-    import gateway.run as gateway_run
-
-    monkeypatch.setattr(gateway_run, "_hermes_home", tmp_path)
-    (tmp_path / "config.yaml").write_text("", encoding="utf-8")
-
-    runner = GatewayRunner(GatewayConfig())
-
-    # Create an internal event with no user_id (simulates the bug scenario)
-    source = SessionSource(
-        platform=Platform.DISCORD,
-        chat_id="123",
-        chat_type="dm",
-    )
-    event = MessageEvent(
-        text="[SYSTEM: Background process completed]",
-        source=source,
-        internal=True,
-    )
-
-    # Track if _is_user_authorized is called
-    auth_called = False
-    original_auth = GatewayRunner._is_user_authorized
-
-    def tracking_auth(self, src):
-        nonlocal auth_called
-        auth_called = True
-        return original_auth(self, src)
-
-    monkeypatch.setattr(GatewayRunner, "_is_user_authorized", tracking_auth)
-
-    # _handle_message will proceed past auth check and eventually fail on
-    # downstream logic. We just need to verify auth is skipped.
-    try:
-        await runner._handle_message(event)
-    except Exception:
-        pass  # Expected — downstream code needs more setup
-
-    assert not auth_called, (
-        "_is_user_authorized should NOT be called for internal events"
-    )
-
-
-@pytest.mark.asyncio
-async def test_internal_event_does_not_trigger_pairing(monkeypatch, tmp_path):
-    """An internal event with no user_id must not generate a pairing code."""
-    import gateway.run as gateway_run
-
-    monkeypatch.setattr(gateway_run, "_hermes_home", tmp_path)
-    (tmp_path / "config.yaml").write_text("", encoding="utf-8")
-
-    runner = GatewayRunner(GatewayConfig())
-    # Add adapter so pairing would have somewhere to send
-    adapter = SimpleNamespace(send=AsyncMock())
-    runner.adapters[Platform.DISCORD] = adapter
-
-    source = SessionSource(
-        platform=Platform.DISCORD,
-        chat_id="123",
-        chat_type="dm",  # DM would normally trigger pairing
-    )
-    event = MessageEvent(
-        text="[SYSTEM: Background process completed]",
-        source=source,
-        internal=True,
-    )
-
-    # Track pairing code generation
-    generate_called = False
-    original_generate = runner.pairing_store.generate_code
-
-    def tracking_generate(*args, **kwargs):
-        nonlocal generate_called
-        generate_called = True
-        return original_generate(*args, **kwargs)
-
-    runner.pairing_store.generate_code = tracking_generate
-
-    try:
-        await runner._handle_message(event)
-    except Exception:
-        pass  # Expected — downstream code needs more setup
-
-    assert not generate_called, (
-        "Pairing code should NOT be generated for internal events"
-    )
-
-
-@pytest.mark.asyncio
-async def test_non_internal_event_without_user_triggers_pairing(monkeypatch, tmp_path):
-    """Verify the normal (non-internal) path still triggers pairing for unknown users."""
-    import gateway.run as gateway_run
-
-    monkeypatch.setattr(gateway_run, "_hermes_home", tmp_path)
-    (tmp_path / "config.yaml").write_text("", encoding="utf-8")
-
-    # Clear env vars that could let all users through (loaded by
-    # module-level dotenv in gateway/run.py from the real ~/.hermes/.env).
-    monkeypatch.delenv("DISCORD_ALLOW_ALL_USERS", raising=False)
-    monkeypatch.delenv("DISCORD_ALLOWED_USERS", raising=False)
-    monkeypatch.delenv("GATEWAY_ALLOW_ALL_USERS", raising=False)
-    monkeypatch.delenv("GATEWAY_ALLOWED_USERS", raising=False)
-
-    runner = GatewayRunner(GatewayConfig())
-    adapter = SimpleNamespace(send=AsyncMock())
-    runner.adapters[Platform.DISCORD] = adapter
-
-    source = SessionSource(
-        platform=Platform.DISCORD,
-        chat_id="123",
-        chat_type="dm",
-        user_id="unknown_user_999",
-    )
-    # Normal event (not internal)
-    event = MessageEvent(
-        text="hello",
-        source=source,
-        internal=False,
-    )
-
-    result = await runner._handle_message(event)
-
-    # Should return None (unauthorized) and send pairing message
-    assert result is None
-    assert adapter.send.await_count == 1
-    sent_text = adapter.send.await_args.args[1]
-    assert "don't recognize you" in sent_text

tests/gateway/test_signal.py

@@ -707,66 +707,3 @@ class TestSignalSendDocumentViaHelper:
 
         assert result.success is False
         assert "/nonexistent.pdf" in result.error
-
-
-# ---------------------------------------------------------------------------
-# send() returns message_id from timestamp (#4647)
-# ---------------------------------------------------------------------------
-
-class TestSignalSendReturnsMessageId:
-    """Signal send() must return a timestamp-based message_id so the stream
-    consumer can follow its edit→fallback path correctly."""
-
-    @pytest.mark.asyncio
-    async def test_send_returns_timestamp_as_message_id(self, monkeypatch):
-        adapter = _make_signal_adapter(monkeypatch)
-        mock_rpc, _ = _stub_rpc({"timestamp": 1712345678000})
-        adapter._rpc = mock_rpc
-        adapter._stop_typing_indicator = AsyncMock()
-
-        result = await adapter.send(chat_id="+155****4567", content="hello")
-
-        assert result.success is True
-        assert result.message_id == "1712345678000"
-
-    @pytest.mark.asyncio
-    async def test_send_returns_none_message_id_when_no_timestamp(self, monkeypatch):
-        adapter = _make_signal_adapter(monkeypatch)
-        mock_rpc, _ = _stub_rpc({})  # No timestamp key
-        adapter._rpc = mock_rpc
-        adapter._stop_typing_indicator = AsyncMock()
-
-        result = await adapter.send(chat_id="+155****4567", content="hello")
-
-        assert result.success is True
-        assert result.message_id is None
-
-    @pytest.mark.asyncio
-    async def test_send_returns_none_message_id_for_non_dict(self, monkeypatch):
-        adapter = _make_signal_adapter(monkeypatch)
-        mock_rpc, _ = _stub_rpc("ok")  # Non-dict result
-        adapter._rpc = mock_rpc
-        adapter._stop_typing_indicator = AsyncMock()
-
-        result = await adapter.send(chat_id="+155****4567", content="hello")
-
-        assert result.success is True
-        assert result.message_id is None
-
-
-# ---------------------------------------------------------------------------
-# stop_typing() delegates to _stop_typing_indicator (#4647)
-# ---------------------------------------------------------------------------
-
-class TestSignalStopTyping:
-    """Signal must expose a public stop_typing() so base adapter's
-    _keep_typing finally block can clean up platform-level typing tasks."""
-
-    @pytest.mark.asyncio
-    async def test_stop_typing_calls_private_method(self, monkeypatch):
-        adapter = _make_signal_adapter(monkeypatch)
-        adapter._stop_typing_indicator = AsyncMock()
-
-        await adapter.stop_typing("+155****4567")
-
-        adapter._stop_typing_indicator.assert_awaited_once_with("+155****4567")

tests/gateway/test_slack.py

@@ -96,7 +96,7 @@ class TestAppMentionHandler:
     """Verify that the app_mention event handler is registered."""
 
     def test_app_mention_registered_on_connect(self):
-        """connect() should register message + assistant lifecycle handlers."""
+        """connect() should register both 'message' and 'app_mention' handlers."""
         config = PlatformConfig(enabled=True, token="xoxb-fake")
         adapter = SlackAdapter(config)
 
@@ -145,8 +145,6 @@ class TestAppMentionHandler:
 
         assert "message" in registered_events
         assert "app_mention" in registered_events
-        assert "assistant_thread_started" in registered_events
-        assert "assistant_thread_context_changed" in registered_events
         assert "/hermes" in registered_commands
 
 
@@ -842,114 +840,6 @@ class TestThreadReplyHandling:
         adapter.handle_message.assert_not_called()
 
 
-# ---------------------------------------------------------------------------
-# TestAssistantThreadLifecycle
-# ---------------------------------------------------------------------------
-
-
-class TestAssistantThreadLifecycle:
-    """Slack Assistant lifecycle events should seed session/user context."""
-
-    @pytest.fixture()
-    def mock_session_store(self):
-        store = MagicMock()
-        store._entries = {}
-        store._ensure_loaded = MagicMock()
-        store.config = MagicMock()
-        store.config.group_sessions_per_user = True
-        store.get_or_create_session = MagicMock()
-        return store
-
-    @pytest.fixture()
-    def assistant_adapter(self, mock_session_store):
-        config = PlatformConfig(enabled=True, token="***")
-        a = SlackAdapter(config)
-        a._app = MagicMock()
-        a._app.client = AsyncMock()
-        a._bot_user_id = "U_BOT"
-        a._team_bot_user_ids = {"T_TEAM": "U_BOT"}
-        a._running = True
-        a.handle_message = AsyncMock()
-        a.set_session_store(mock_session_store)
-        return a
-
-    @pytest.mark.asyncio
-    async def test_lifecycle_event_seeds_session_store(self, assistant_adapter, mock_session_store):
-        event = {
-            "type": "assistant_thread_started",
-            "team_id": "T_TEAM",
-            "assistant_thread": {
-                "channel_id": "D123",
-                "thread_ts": "171.000",
-                "user_id": "U_USER",
-                "context": {"channel_id": "C_ORIGIN"},
-            },
-        }
-
-        await assistant_adapter._handle_assistant_thread_lifecycle_event(event)
-
-        assert assistant_adapter._assistant_threads[("D123", "171.000")]["user_id"] == "U_USER"
-        mock_session_store.get_or_create_session.assert_called_once()
-        source = mock_session_store.get_or_create_session.call_args[0][0]
-        assert source.chat_id == "D123"
-        assert source.chat_type == "dm"
-        assert source.user_id == "U_USER"
-        assert source.thread_id == "171.000"
-        assert source.chat_topic == "C_ORIGIN"
-
-    @pytest.mark.asyncio
-    async def test_message_uses_cached_assistant_thread_identity(self, assistant_adapter):
-        assistant_adapter._assistant_threads[("D123", "171.000")] = {
-            "channel_id": "D123",
-            "thread_ts": "171.000",
-            "user_id": "U_USER",
-            "team_id": "T_TEAM",
-        }
-        assistant_adapter._app.client.users_info = AsyncMock(return_value={
-            "user": {"profile": {"display_name": "Tyler"}}
-        })
-        assistant_adapter._app.client.reactions_add = AsyncMock()
-        assistant_adapter._app.client.reactions_remove = AsyncMock()
-
-        event = {
-            "text": "hello from assistant dm",
-            "channel": "D123",
-            "channel_type": "im",
-            "thread_ts": "171.000",
-            "ts": "171.111",
-            "team": "T_TEAM",
-        }
-
-        await assistant_adapter._handle_slack_message(event)
-
-        msg_event = assistant_adapter.handle_message.call_args[0][0]
-        assert msg_event.source.user_id == "U_USER"
-        assert msg_event.source.thread_id == "171.000"
-        assert msg_event.source.user_name == "Tyler"
-
-    def test_assistant_threads_cache_eviction(self, assistant_adapter):
-        """Cache should evict oldest entries when exceeding the size limit."""
-        assistant_adapter._ASSISTANT_THREADS_MAX = 10
-        # Fill to the limit
-        for i in range(10):
-            assistant_adapter._cache_assistant_thread_metadata({
-                "channel_id": f"D{i}",
-                "thread_ts": f"{i}.000",
-                "user_id": f"U{i}",
-            })
-        assert len(assistant_adapter._assistant_threads) == 10
-
-        # Adding one more should trigger eviction (down to max // 2 = 5)
-        assistant_adapter._cache_assistant_thread_metadata({
-            "channel_id": "D999",
-            "thread_ts": "999.000",
-            "user_id": "U999",
-        })
-        assert len(assistant_adapter._assistant_threads) <= 10
-        # The newest entry must survive eviction
-        assert ("D999", "999.000") in assistant_adapter._assistant_threads
-
-
 # ---------------------------------------------------------------------------
 # TestUserNameResolution
 # ---------------------------------------------------------------------------

tests/gateway/test_stream_consumer.py

@@ -383,60 +383,6 @@ class TestSegmentBreakOnToolBoundary:
         sent_texts = [call[1]["content"] for call in adapter.send.call_args_list]
         assert sent_texts == ["Hello ▉", "Next segment"]
 
-    @pytest.mark.asyncio
-    async def test_no_message_id_enters_fallback_mode(self):
-        """Platform returns success but no message_id (Signal) — must not
-        re-send on every delta.  Should enter fallback mode and send only
-        the continuation at finish."""
-        adapter = MagicMock()
-        # First send succeeds but returns no message_id (Signal behavior)
-        send_result_no_id = SimpleNamespace(success=True, message_id=None)
-        # Fallback final send succeeds
-        send_result_final = SimpleNamespace(success=True, message_id="msg_final")
-        adapter.send = AsyncMock(side_effect=[send_result_no_id, send_result_final])
-        adapter.edit_message = AsyncMock(return_value=SimpleNamespace(success=True))
-        adapter.MAX_MESSAGE_LENGTH = 4096
-
-        config = StreamConsumerConfig(edit_interval=0.01, buffer_threshold=5)
-        consumer = GatewayStreamConsumer(adapter, "chat_123", config)
-
-        consumer.on_delta("Hello")
-        task = asyncio.create_task(consumer.run())
-        await asyncio.sleep(0.08)
-        consumer.on_delta(" world, this is a longer response.")
-        await asyncio.sleep(0.08)
-        consumer.finish()
-        await task
-
-        # Should send exactly 2 messages: initial chunk + fallback continuation
-        # NOT one message per delta
-        assert adapter.send.call_count == 2
-        assert consumer.already_sent
-        # edit_message should NOT have been called (no valid message_id to edit)
-        adapter.edit_message.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_no_message_id_single_delta_marks_already_sent(self):
-        """When the entire response fits in one delta and platform returns no
-        message_id, already_sent must still be True to prevent the gateway
-        from re-sending the full response."""
-        adapter = MagicMock()
-        send_result = SimpleNamespace(success=True, message_id=None)
-        adapter.send = AsyncMock(return_value=send_result)
-        adapter.MAX_MESSAGE_LENGTH = 4096
-
-        config = StreamConsumerConfig(edit_interval=0.01, buffer_threshold=5)
-        consumer = GatewayStreamConsumer(adapter, "chat_123", config)
-
-        consumer.on_delta("Short response.")
-        consumer.finish()
-
-        await consumer.run()
-
-        assert consumer.already_sent
-        # Only one send call (the initial message)
-        assert adapter.send.call_count == 1
-
     @pytest.mark.asyncio
     async def test_fallback_final_splits_long_continuation_without_dropping_text(self):
         """Long continuation tails should be chunked when fallback final-send runs."""

tests/hermes_cli/test_model_switch_variant_tags.py

@@ -1,70 +0,0 @@
-"""Tests for OpenRouter variant tag preservation in model switching.
-
-Regression test for GitHub PR #6088 / Discord report: OpenRouter model IDs
-with variant suffixes like ``:free``, ``:extended``, ``:fast`` were being
-mangled by the colon-to-slash conversion in model_switch.py Step c.
-
-The fix: Step c now skips colon→slash conversion when the model name already
-contains a forward slash (i.e. is already in ``vendor/model`` format), since
-the colon is a variant tag, not a vendor separator.
-"""
-import pytest
-from unittest.mock import patch
-
-from hermes_cli.model_switch import switch_model
-
-
-# Shared mock context — skip network calls, credential resolution, catalog lookups
-_MOCK_VALIDATION = {"accepted": True, "persist": True, "recognized": True, "message": None}
-
-
-def _run_switch(raw_input: str, current_provider: str = "openrouter") -> str:
-    """Run switch_model with mocked dependencies, return the resolved model name."""
-    with patch("hermes_cli.model_switch.resolve_alias", return_value=None), \
-         patch("hermes_cli.model_switch.list_provider_models", return_value=[]), \
-         patch("hermes_cli.runtime_provider.resolve_runtime_provider",
-               return_value={"api_key": "test", "base_url": "", "api_mode": "chat_completions"}), \
-         patch("hermes_cli.models.validate_requested_model", return_value=_MOCK_VALIDATION), \
-         patch("hermes_cli.model_switch.get_model_info", return_value=None), \
-         patch("hermes_cli.model_switch.get_model_capabilities", return_value=None), \
-         patch("hermes_cli.models.detect_provider_for_model", return_value=None):
-        result = switch_model(
-            raw_input=raw_input,
-            current_provider=current_provider,
-            current_model="anthropic/claude-sonnet-4.6",
-        )
-        assert result.success, f"switch_model failed: {result.error_message}"
-        return result.new_model
-
-
-class TestVariantTagPreservation:
-    """OpenRouter variant tags (:free, :extended, :fast) must survive model switching."""
-
-    @pytest.mark.parametrize("model,expected", [
-        ("nvidia/nemotron-3-super-120b-a12b:free", "nvidia/nemotron-3-super-120b-a12b:free"),
-        ("anthropic/claude-sonnet-4.6:extended", "anthropic/claude-sonnet-4.6:extended"),
-        ("meta-llama/llama-4-maverick:fast", "meta-llama/llama-4-maverick:fast"),
-    ])
-    def test_slash_format_preserves_variant_tag(self, model, expected):
-        """Models already in vendor/model:tag format must not have their tag mangled."""
-        assert _run_switch(model) == expected
-
-    def test_legacy_colon_format_converts_to_slash(self):
-        """Legacy vendor:model (no slash) should still be converted to vendor/model."""
-        result = _run_switch("nvidia:nemotron-3-super-120b-a12b")
-        assert result == "nvidia/nemotron-3-super-120b-a12b"
-
-    def test_legacy_colon_format_with_tag_converts_first_colon_only(self):
-        """vendor:model:free (no slash) → vendor/model:free — first colon becomes slash."""
-        result = _run_switch("nvidia:nemotron-3-super-120b-a12b:free")
-        assert result == "nvidia/nemotron-3-super-120b-a12b:free"
-
-    def test_bare_model_name_unaffected(self):
-        """Bare model names without colons or slashes should work normally."""
-        result = _run_switch("claude-sonnet-4.6")
-        assert result == "anthropic/claude-sonnet-4.6"
-
-    def test_already_correct_slug_no_tag(self):
-        """Standard vendor/model slugs without tags pass through unchanged."""
-        result = _run_switch("anthropic/claude-sonnet-4.6")
-        assert result == "anthropic/claude-sonnet-4.6"

tests/plugins/memory/test_hindsight_provider.py

@@ -1,598 +0,0 @@
-"""Tests for the Hindsight memory provider plugin.
-
-Tests cover config loading, tool handlers (tags, max_tokens, types),
-prefetch (auto_recall, preamble, query truncation), sync_turn (auto_retain,
-turn counting, tags), and schema completeness.
-"""
-
-import json
-import threading
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from plugins.memory.hindsight import (
-    HindsightMemoryProvider,
-    RECALL_SCHEMA,
-    REFLECT_SCHEMA,
-    RETAIN_SCHEMA,
-    _load_config,
-)
-
-
-# ---------------------------------------------------------------------------
-# Fixtures
-# ---------------------------------------------------------------------------
-
-
-@pytest.fixture(autouse=True)
-def _clean_env(monkeypatch):
-    """Ensure no stale env vars leak between tests."""
-    for key in (
-        "HINDSIGHT_API_KEY", "HINDSIGHT_API_URL", "HINDSIGHT_BANK_ID",
-        "HINDSIGHT_BUDGET", "HINDSIGHT_MODE", "HINDSIGHT_LLM_API_KEY",
-    ):
-        monkeypatch.delenv(key, raising=False)
-
-
-def _make_mock_client():
-    """Create a mock Hindsight client with async methods."""
-    client = MagicMock()
-    client.aretain = AsyncMock()
-    client.arecall = AsyncMock(
-        return_value=SimpleNamespace(
-            results=[
-                SimpleNamespace(text="Memory 1"),
-                SimpleNamespace(text="Memory 2"),
-            ]
-        )
-    )
-    client.areflect = AsyncMock(
-        return_value=SimpleNamespace(text="Synthesized answer")
-    )
-    client.aretain_batch = AsyncMock()
-    client.aclose = AsyncMock()
-    return client
-
-
-@pytest.fixture()
-def provider(tmp_path, monkeypatch):
-    """Create an initialized HindsightMemoryProvider with a mock client."""
-    config = {
-        "mode": "cloud",
-        "apiKey": "test-key",
-        "api_url": "http://localhost:9999",
-        "bank_id": "test-bank",
-        "budget": "mid",
-        "memory_mode": "hybrid",
-    }
-    config_path = tmp_path / "hindsight" / "config.json"
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    config_path.write_text(json.dumps(config))
-
-    monkeypatch.setattr(
-        "plugins.memory.hindsight.get_hermes_home", lambda: tmp_path
-    )
-
-    p = HindsightMemoryProvider()
-    p.initialize(session_id="test-session", hermes_home=str(tmp_path), platform="cli")
-    p._client = _make_mock_client()
-    return p
-
-
-@pytest.fixture()
-def provider_with_config(tmp_path, monkeypatch):
-    """Create a provider factory that accepts custom config overrides."""
-    def _make(**overrides):
-        config = {
-            "mode": "cloud",
-            "apiKey": "test-key",
-            "api_url": "http://localhost:9999",
-            "bank_id": "test-bank",
-            "budget": "mid",
-            "memory_mode": "hybrid",
-        }
-        config.update(overrides)
-        config_path = tmp_path / "hindsight" / "config.json"
-        config_path.parent.mkdir(parents=True, exist_ok=True)
-        config_path.write_text(json.dumps(config))
-
-        monkeypatch.setattr(
-            "plugins.memory.hindsight.get_hermes_home", lambda: tmp_path
-        )
-
-        p = HindsightMemoryProvider()
-        p.initialize(session_id="test-session", hermes_home=str(tmp_path), platform="cli")
-        p._client = _make_mock_client()
-        return p
-    return _make
-
-
-# ---------------------------------------------------------------------------
-# Schema tests
-# ---------------------------------------------------------------------------
-
-
-class TestSchemas:
-    def test_retain_schema_has_content(self):
-        assert RETAIN_SCHEMA["name"] == "hindsight_retain"
-        assert "content" in RETAIN_SCHEMA["parameters"]["properties"]
-        assert "content" in RETAIN_SCHEMA["parameters"]["required"]
-
-    def test_recall_schema_has_query(self):
-        assert RECALL_SCHEMA["name"] == "hindsight_recall"
-        assert "query" in RECALL_SCHEMA["parameters"]["properties"]
-        assert "query" in RECALL_SCHEMA["parameters"]["required"]
-
-    def test_reflect_schema_has_query(self):
-        assert REFLECT_SCHEMA["name"] == "hindsight_reflect"
-        assert "query" in REFLECT_SCHEMA["parameters"]["properties"]
-
-    def test_get_tool_schemas_returns_three(self, provider):
-        schemas = provider.get_tool_schemas()
-        assert len(schemas) == 3
-        names = {s["name"] for s in schemas}
-        assert names == {"hindsight_retain", "hindsight_recall", "hindsight_reflect"}
-
-    def test_context_mode_returns_no_tools(self, provider_with_config):
-        p = provider_with_config(memory_mode="context")
-        assert p.get_tool_schemas() == []
-
-
-# ---------------------------------------------------------------------------
-# Config tests
-# ---------------------------------------------------------------------------
-
-
-class TestConfig:
-    def test_default_values(self, provider):
-        assert provider._auto_retain is True
-        assert provider._auto_recall is True
-        assert provider._retain_every_n_turns == 1
-        assert provider._recall_max_tokens == 4096
-        assert provider._recall_max_input_chars == 800
-        assert provider._tags is None
-        assert provider._recall_tags is None
-        assert provider._bank_mission == ""
-        assert provider._bank_retain_mission is None
-        assert provider._retain_context == "conversation between Hermes Agent and the User"
-
-    def test_custom_config_values(self, provider_with_config):
-        p = provider_with_config(
-            tags=["tag1", "tag2"],
-            recall_tags=["recall-tag"],
-            recall_tags_match="all",
-            auto_retain=False,
-            auto_recall=False,
-            retain_every_n_turns=3,
-            retain_context="custom-ctx",
-            bank_retain_mission="Extract key facts",
-            recall_max_tokens=2048,
-            recall_types=["world", "experience"],
-            recall_prompt_preamble="Custom preamble:",
-            recall_max_input_chars=500,
-            bank_mission="Test agent mission",
-        )
-        assert p._tags == ["tag1", "tag2"]
-        assert p._recall_tags == ["recall-tag"]
-        assert p._recall_tags_match == "all"
-        assert p._auto_retain is False
-        assert p._auto_recall is False
-        assert p._retain_every_n_turns == 3
-        assert p._retain_context == "custom-ctx"
-        assert p._bank_retain_mission == "Extract key facts"
-        assert p._recall_max_tokens == 2048
-        assert p._recall_types == ["world", "experience"]
-        assert p._recall_prompt_preamble == "Custom preamble:"
-        assert p._recall_max_input_chars == 500
-        assert p._bank_mission == "Test agent mission"
-
-    def test_config_from_env_fallback(self, tmp_path, monkeypatch):
-        """When no config file exists, falls back to env vars."""
-        monkeypatch.setattr(
-            "plugins.memory.hindsight.get_hermes_home",
-            lambda: tmp_path / "nonexistent",
-        )
-        monkeypatch.setenv("HINDSIGHT_MODE", "cloud")
-        monkeypatch.setenv("HINDSIGHT_API_KEY", "env-key")
-        monkeypatch.setenv("HINDSIGHT_BANK_ID", "env-bank")
-        monkeypatch.setenv("HINDSIGHT_BUDGET", "high")
-
-        cfg = _load_config()
-        assert cfg["apiKey"] == "env-key"
-        assert cfg["banks"]["hermes"]["bankId"] == "env-bank"
-        assert cfg["banks"]["hermes"]["budget"] == "high"
-
-
-# ---------------------------------------------------------------------------
-# Tool handler tests
-# ---------------------------------------------------------------------------
-
-
-class TestToolHandlers:
-    def test_retain_success(self, provider):
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_retain", {"content": "user likes dark mode"}
-        ))
-        assert result["result"] == "Memory stored successfully."
-        provider._client.aretain.assert_called_once()
-        call_kwargs = provider._client.aretain.call_args.kwargs
-        assert call_kwargs["bank_id"] == "test-bank"
-        assert call_kwargs["content"] == "user likes dark mode"
-
-    def test_retain_with_tags(self, provider_with_config):
-        p = provider_with_config(tags=["pref", "ui"])
-        p.handle_tool_call("hindsight_retain", {"content": "likes dark mode"})
-        call_kwargs = p._client.aretain.call_args.kwargs
-        assert call_kwargs["tags"] == ["pref", "ui"]
-
-    def test_retain_without_tags(self, provider):
-        provider.handle_tool_call("hindsight_retain", {"content": "hello"})
-        call_kwargs = provider._client.aretain.call_args.kwargs
-        assert "tags" not in call_kwargs
-
-    def test_retain_missing_content(self, provider):
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_retain", {}
-        ))
-        assert "error" in result
-
-    def test_recall_success(self, provider):
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_recall", {"query": "dark mode"}
-        ))
-        assert "Memory 1" in result["result"]
-        assert "Memory 2" in result["result"]
-
-    def test_recall_passes_max_tokens(self, provider_with_config):
-        p = provider_with_config(recall_max_tokens=2048)
-        p.handle_tool_call("hindsight_recall", {"query": "test"})
-        call_kwargs = p._client.arecall.call_args.kwargs
-        assert call_kwargs["max_tokens"] == 2048
-
-    def test_recall_passes_tags(self, provider_with_config):
-        p = provider_with_config(recall_tags=["tag1"], recall_tags_match="all")
-        p.handle_tool_call("hindsight_recall", {"query": "test"})
-        call_kwargs = p._client.arecall.call_args.kwargs
-        assert call_kwargs["tags"] == ["tag1"]
-        assert call_kwargs["tags_match"] == "all"
-
-    def test_recall_passes_types(self, provider_with_config):
-        p = provider_with_config(recall_types=["world", "experience"])
-        p.handle_tool_call("hindsight_recall", {"query": "test"})
-        call_kwargs = p._client.arecall.call_args.kwargs
-        assert call_kwargs["types"] == ["world", "experience"]
-
-    def test_recall_no_results(self, provider):
-        provider._client.arecall.return_value = SimpleNamespace(results=[])
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_recall", {"query": "test"}
-        ))
-        assert result["result"] == "No relevant memories found."
-
-    def test_recall_missing_query(self, provider):
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_recall", {}
-        ))
-        assert "error" in result
-
-    def test_reflect_success(self, provider):
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_reflect", {"query": "summarize"}
-        ))
-        assert result["result"] == "Synthesized answer"
-
-    def test_reflect_missing_query(self, provider):
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_reflect", {}
-        ))
-        assert "error" in result
-
-    def test_unknown_tool(self, provider):
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_unknown", {}
-        ))
-        assert "error" in result
-
-    def test_retain_error_handling(self, provider):
-        provider._client.aretain.side_effect = RuntimeError("connection failed")
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_retain", {"content": "test"}
-        ))
-        assert "error" in result
-        assert "connection failed" in result["error"]
-
-    def test_recall_error_handling(self, provider):
-        provider._client.arecall.side_effect = RuntimeError("timeout")
-        result = json.loads(provider.handle_tool_call(
-            "hindsight_recall", {"query": "test"}
-        ))
-        assert "error" in result
-
-
-# ---------------------------------------------------------------------------
-# Prefetch tests
-# ---------------------------------------------------------------------------
-
-
-class TestPrefetch:
-    def test_prefetch_returns_empty_when_no_result(self, provider):
-        assert provider.prefetch("test") == ""
-
-    def test_prefetch_default_preamble(self, provider):
-        provider._prefetch_result = "- some memory"
-        result = provider.prefetch("test")
-        assert "Hindsight Memory" in result
-        assert "- some memory" in result
-
-    def test_prefetch_custom_preamble(self, provider_with_config):
-        p = provider_with_config(recall_prompt_preamble="Custom header:")
-        p._prefetch_result = "- memory line"
-        result = p.prefetch("test")
-        assert result.startswith("Custom header:")
-        assert "- memory line" in result
-
-    def test_queue_prefetch_skipped_in_tools_mode(self, provider_with_config):
-        p = provider_with_config(memory_mode="tools")
-        p.queue_prefetch("test")
-        # Should not start a thread
-        assert p._prefetch_thread is None
-
-    def test_queue_prefetch_skipped_when_auto_recall_off(self, provider_with_config):
-        p = provider_with_config(auto_recall=False)
-        p.queue_prefetch("test")
-        assert p._prefetch_thread is None
-
-    def test_queue_prefetch_truncates_query(self, provider_with_config):
-        p = provider_with_config(recall_max_input_chars=10)
-        # Mock _run_sync to capture the query
-        original_query = None
-
-        def _capture_recall(**kwargs):
-            nonlocal original_query
-            original_query = kwargs.get("query", "")
-            return SimpleNamespace(results=[])
-
-        p._client.arecall = AsyncMock(side_effect=_capture_recall)
-
-        long_query = "a" * 100
-        p.queue_prefetch(long_query)
-        if p._prefetch_thread:
-            p._prefetch_thread.join(timeout=5.0)
-
-        # The query passed to arecall should be truncated
-        if original_query is not None:
-            assert len(original_query) <= 10
-
-    def test_queue_prefetch_passes_recall_params(self, provider_with_config):
-        p = provider_with_config(
-            recall_tags=["t1"],
-            recall_tags_match="all",
-            recall_max_tokens=1024,
-            recall_types=["world"],
-        )
-        p.queue_prefetch("test query")
-        if p._prefetch_thread:
-            p._prefetch_thread.join(timeout=5.0)
-
-        call_kwargs = p._client.arecall.call_args.kwargs
-        assert call_kwargs["max_tokens"] == 1024
-        assert call_kwargs["tags"] == ["t1"]
-        assert call_kwargs["tags_match"] == "all"
-        assert call_kwargs["types"] == ["world"]
-
-
-# ---------------------------------------------------------------------------
-# sync_turn tests
-# ---------------------------------------------------------------------------
-
-
-class TestSyncTurn:
-    def _get_retain_kwargs(self, provider):
-        """Helper to get the kwargs from the aretain_batch call."""
-        return provider._client.aretain_batch.call_args.kwargs
-
-    def _get_retain_content(self, provider):
-        """Helper to get the raw content string from the first item."""
-        kwargs = self._get_retain_kwargs(provider)
-        return kwargs["items"][0]["content"]
-
-    def _get_retain_messages(self, provider):
-        """Helper to parse the first turn's messages from retained content.
-
-        Content is a JSON array of turns: [[msgs...], [msgs...], ...]
-        For single-turn tests, returns the first turn's messages.
-        """
-        content = self._get_retain_content(provider)
-        turns = json.loads(content)
-        return turns[0] if len(turns) == 1 else turns
-
-    def test_sync_turn_retains(self, provider):
-        provider.sync_turn("hello", "hi there")
-        if provider._sync_thread:
-            provider._sync_thread.join(timeout=5.0)
-        provider._client.aretain_batch.assert_called_once()
-        messages = self._get_retain_messages(provider)
-        assert len(messages) == 2
-        assert messages[0]["role"] == "user"
-        assert messages[0]["content"] == "hello"
-        assert "timestamp" in messages[0]
-        assert messages[1]["role"] == "assistant"
-        assert messages[1]["content"] == "hi there"
-        assert "timestamp" in messages[1]
-
-    def test_sync_turn_skipped_when_auto_retain_off(self, provider_with_config):
-        p = provider_with_config(auto_retain=False)
-        p.sync_turn("hello", "hi")
-        assert p._sync_thread is None
-        p._client.aretain_batch.assert_not_called()
-
-    def test_sync_turn_with_tags(self, provider_with_config):
-        p = provider_with_config(tags=["conv", "session1"])
-        p.sync_turn("hello", "hi")
-        if p._sync_thread:
-            p._sync_thread.join(timeout=5.0)
-        item = p._client.aretain_batch.call_args.kwargs["items"][0]
-        assert item["tags"] == ["conv", "session1"]
-
-    def test_sync_turn_uses_aretain_batch(self, provider):
-        """sync_turn should use aretain_batch with retain_async."""
-        provider.sync_turn("hello", "hi")
-        if provider._sync_thread:
-            provider._sync_thread.join(timeout=5.0)
-        provider._client.aretain_batch.assert_called_once()
-        call_kwargs = provider._client.aretain_batch.call_args.kwargs
-        assert call_kwargs["document_id"] == "test-session"
-        assert call_kwargs["retain_async"] is True
-        assert len(call_kwargs["items"]) == 1
-        assert call_kwargs["items"][0]["context"] == "conversation between Hermes Agent and the User"
-
-    def test_sync_turn_custom_context(self, provider_with_config):
-        p = provider_with_config(retain_context="my-agent")
-        p.sync_turn("hello", "hi")
-        if p._sync_thread:
-            p._sync_thread.join(timeout=5.0)
-        item = p._client.aretain_batch.call_args.kwargs["items"][0]
-        assert item["context"] == "my-agent"
-
-    def test_sync_turn_every_n_turns(self, provider_with_config):
-        """With retain_every_n_turns=3, only retains on every 3rd turn."""
-        p = provider_with_config(retain_every_n_turns=3)
-
-        p.sync_turn("turn1-user", "turn1-asst")
-        assert p._sync_thread is None  # not retained yet
-
-        p.sync_turn("turn2-user", "turn2-asst")
-        assert p._sync_thread is None  # not retained yet
-
-        p.sync_turn("turn3-user", "turn3-asst")
-        assert p._sync_thread is not None  # retained!
-        p._sync_thread.join(timeout=5.0)
-
-        p._client.aretain_batch.assert_called_once()
-        content = p._client.aretain_batch.call_args.kwargs["items"][0]["content"]
-        # Should contain all 3 turns
-        assert "turn1-user" in content
-        assert "turn2-user" in content
-        assert "turn3-user" in content
-
-    def test_sync_turn_accumulates_full_session(self, provider_with_config):
-        """Each retain sends the ENTIRE session, not just the latest batch."""
-        p = provider_with_config(retain_every_n_turns=2)
-
-        p.sync_turn("turn1-user", "turn1-asst")
-        p.sync_turn("turn2-user", "turn2-asst")
-        if p._sync_thread:
-            p._sync_thread.join(timeout=5.0)
-
-        p._client.aretain_batch.reset_mock()
-
-        p.sync_turn("turn3-user", "turn3-asst")
-        p.sync_turn("turn4-user", "turn4-asst")
-        if p._sync_thread:
-            p._sync_thread.join(timeout=5.0)
-
-        content = p._client.aretain_batch.call_args.kwargs["items"][0]["content"]
-        # Should contain ALL turns from the session
-        assert "turn1-user" in content
-        assert "turn2-user" in content
-        assert "turn3-user" in content
-        assert "turn4-user" in content
-
-    def test_sync_turn_passes_document_id(self, provider):
-        """sync_turn should pass session_id as document_id for dedup."""
-        provider.sync_turn("hello", "hi")
-        if provider._sync_thread:
-            provider._sync_thread.join(timeout=5.0)
-        call_kwargs = provider._client.aretain_batch.call_args.kwargs
-        assert call_kwargs["document_id"] == "test-session"
-
-    def test_sync_turn_error_does_not_raise(self, provider):
-        """Errors in sync_turn should be swallowed (non-blocking)."""
-        provider._client.aretain_batch.side_effect = RuntimeError("network error")
-        provider.sync_turn("hello", "hi")
-        if provider._sync_thread:
-            provider._sync_thread.join(timeout=5.0)
-        # Should not raise
-
-
-# ---------------------------------------------------------------------------
-# System prompt tests
-# ---------------------------------------------------------------------------
-
-
-class TestSystemPrompt:
-    def test_hybrid_mode_prompt(self, provider):
-        block = provider.system_prompt_block()
-        assert "Hindsight Memory" in block
-        assert "hindsight_recall" in block
-        assert "automatically injected" in block
-
-    def test_context_mode_prompt(self, provider_with_config):
-        p = provider_with_config(memory_mode="context")
-        block = p.system_prompt_block()
-        assert "context mode" in block
-        assert "hindsight_recall" not in block
-
-    def test_tools_mode_prompt(self, provider_with_config):
-        p = provider_with_config(memory_mode="tools")
-        block = p.system_prompt_block()
-        assert "tools mode" in block
-        assert "hindsight_recall" in block
-
-
-# ---------------------------------------------------------------------------
-# Config schema tests
-# ---------------------------------------------------------------------------
-
-
-class TestConfigSchema:
-    def test_schema_has_all_new_fields(self, provider):
-        schema = provider.get_config_schema()
-        keys = {f["key"] for f in schema}
-        expected_keys = {
-            "mode", "api_url", "api_key", "llm_provider", "llm_api_key",
-            "llm_model", "bank_id", "bank_mission", "bank_retain_mission",
-            "recall_budget", "memory_mode", "recall_prefetch_method",
-            "tags", "recall_tags", "recall_tags_match",
-            "auto_recall", "auto_retain",
-            "retain_every_n_turns", "retain_async",
-            "retain_context",
-            "recall_max_tokens", "recall_max_input_chars",
-            "recall_prompt_preamble",
-        }
-        assert expected_keys.issubset(keys), f"Missing: {expected_keys - keys}"
-
-
-# ---------------------------------------------------------------------------
-# Availability tests
-# ---------------------------------------------------------------------------
-
-
-class TestAvailability:
-    def test_available_with_api_key(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(
-            "plugins.memory.hindsight.get_hermes_home",
-            lambda: tmp_path / "nonexistent",
-        )
-        monkeypatch.setenv("HINDSIGHT_API_KEY", "test-key")
-        p = HindsightMemoryProvider()
-        assert p.is_available()
-
-    def test_not_available_without_config(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(
-            "plugins.memory.hindsight.get_hermes_home",
-            lambda: tmp_path / "nonexistent",
-        )
-        p = HindsightMemoryProvider()
-        assert not p.is_available()
-
-    def test_available_in_local_mode(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(
-            "plugins.memory.hindsight.get_hermes_home",
-            lambda: tmp_path / "nonexistent",
-        )
-        monkeypatch.setenv("HINDSIGHT_MODE", "local")
-        p = HindsightMemoryProvider()
-        assert p.is_available()

tests/run_agent/test_context_pressure.py

@@ -150,8 +150,8 @@ def agent():
 class TestContextPressureFlags:
     """Context pressure warning flag tracking on AIAgent."""
 
-    def test_flag_initialized_zero(self, agent):
-        assert agent._context_pressure_warned_at == 0.0
+    def test_flag_initialized_false(self, agent):
+        assert agent._context_pressure_warned is False
 
     def test_emit_calls_status_callback(self, agent):
         """status_callback should be invoked with event type and message."""
@@ -210,7 +210,7 @@ class TestContextPressureFlags:
 
     def test_flag_reset_on_compression(self, agent):
         """After _compress_context, context pressure flag should reset."""
-        agent._context_pressure_warned_at = 0.85
+        agent._context_pressure_warned = True
         agent.compression_enabled = True
 
         agent.context_compressor = MagicMock()
@@ -219,7 +219,6 @@ class TestContextPressureFlags:
         ]
         agent.context_compressor.context_length = 200_000
         agent.context_compressor.threshold_tokens = 100_000
-        agent.context_compressor.compression_count = 1
 
         agent._todo_store = MagicMock()
         agent._todo_store.format_for_injection.return_value = None
@@ -234,7 +233,7 @@ class TestContextPressureFlags:
         ]
         agent._compress_context(messages, "system prompt")
 
-        assert agent._context_pressure_warned_at == 0.0
+        assert agent._context_pressure_warned is False
 
     def test_emit_callback_error_handled(self, agent):
         """If status_callback raises, it should be caught gracefully."""
@@ -247,115 +246,3 @@ class TestContextPressureFlags:
 
         # Should not raise
         agent._emit_context_pressure(0.85, compressor)
-
-    def test_tiered_reemits_at_95(self, agent):
-        """Warning fires at 85%, then fires again when crossing 95%."""
-        agent._context_pressure_warned_at = 0.85
-        # Simulate crossing 95%: the tier (0.95) > warned_at (0.85)
-        assert 0.95 > agent._context_pressure_warned_at
-        # After emission at 95%, the tier should update
-        agent._context_pressure_warned_at = 0.95
-        assert agent._context_pressure_warned_at == 0.95
-
-    def test_tiered_no_double_emit_at_same_level(self, agent):
-        """Once warned at 85%, further 85%+ readings don't re-warn."""
-        agent._context_pressure_warned_at = 0.85
-        # At 88%, tier is 0.85, which is NOT > warned_at (0.85)
-        _warn_tier = 0.85 if 0.88 >= 0.85 else 0.0
-        assert not (_warn_tier > agent._context_pressure_warned_at)
-
-    def test_flag_not_reset_when_compression_insufficient(self, agent):
-        """When compression can't drop below 85%, keep the flag set."""
-        agent._context_pressure_warned_at = 0.85
-        agent.compression_enabled = True
-
-        agent.context_compressor = MagicMock()
-        agent.context_compressor.compress.return_value = [
-            {"role": "user", "content": "Summary of conversation so far."}
-        ]
-        agent.context_compressor.context_length = 200
-        # Use a small threshold so the tiny compressed output still
-        # represents >= 85% of it (prevents flag reset).
-        agent.context_compressor.threshold_tokens = 10
-        agent.context_compressor.compression_count = 1
-        agent.context_compressor.last_prompt_tokens = 0
-
-        agent._todo_store = MagicMock()
-        agent._todo_store.format_for_injection.return_value = None
-        agent._build_system_prompt = MagicMock(return_value="system prompt")
-        agent._cached_system_prompt = "old system prompt"
-        agent._session_db = None
-
-        messages = [
-            {"role": "user", "content": "hello"},
-            {"role": "assistant", "content": "hi there"},
-        ]
-        agent._compress_context(messages, "system prompt")
-
-        # Post-compression is ~90% of threshold — flag should NOT reset
-        assert agent._context_pressure_warned_at == 0.85
-
-
-class TestContextPressureGatewayDedup:
-    """Class-level dedup prevents warning spam across AIAgent instances."""
-
-    def setup_method(self):
-        """Clear class-level dedup state between tests."""
-        AIAgent._context_pressure_last_warned.clear()
-
-    def test_second_instance_within_cooldown_suppressed(self):
-        """Same session, same tier, within cooldown — should be suppressed."""
-        import time
-        sid = "test_session_dedup"
-        # Simulate first warning
-        AIAgent._context_pressure_last_warned[sid] = (0.85, time.time())
-        # Second instance checking same tier within cooldown
-        _last = AIAgent._context_pressure_last_warned.get(sid)
-        _should_warn = _last is None or _last[0] < 0.85 or (time.time() - _last[1]) >= AIAgent._CONTEXT_PRESSURE_COOLDOWN
-        assert not _should_warn
-
-    def test_higher_tier_fires_despite_cooldown(self):
-        """Same session, higher tier — should fire even within cooldown."""
-        import time
-        sid = "test_session_tier"
-        AIAgent._context_pressure_last_warned[sid] = (0.85, time.time())
-        _last = AIAgent._context_pressure_last_warned.get(sid)
-        # 0.95 > 0.85 stored tier → should warn
-        _should_warn = _last is None or _last[0] < 0.95 or (time.time() - _last[1]) >= AIAgent._CONTEXT_PRESSURE_COOLDOWN
-        assert _should_warn
-
-    def test_warning_fires_after_cooldown_expires(self):
-        """Same session, same tier, after cooldown — should fire again."""
-        import time
-        sid = "test_session_expired"
-        # Set a timestamp far in the past
-        AIAgent._context_pressure_last_warned[sid] = (0.85, time.time() - AIAgent._CONTEXT_PRESSURE_COOLDOWN - 1)
-        _last = AIAgent._context_pressure_last_warned.get(sid)
-        _should_warn = _last is None or _last[0] < 0.85 or (time.time() - _last[1]) >= AIAgent._CONTEXT_PRESSURE_COOLDOWN
-        assert _should_warn
-
-    def test_compression_clears_dedup(self):
-        """After compression drops below 85%, dedup entry should be cleared."""
-        import time
-        sid = "test_session_clear"
-        AIAgent._context_pressure_last_warned[sid] = (0.85, time.time())
-        assert sid in AIAgent._context_pressure_last_warned
-        # Simulate what _compress_context does on reset
-        AIAgent._context_pressure_last_warned.pop(sid, None)
-        assert sid not in AIAgent._context_pressure_last_warned
-
-    def test_eviction_removes_stale_entries(self):
-        """Stale entries older than 2x cooldown should be evicted."""
-        import time
-        _now = time.time()
-        AIAgent._context_pressure_last_warned = {
-            "fresh": (0.85, _now),
-            "stale": (0.85, _now - AIAgent._CONTEXT_PRESSURE_COOLDOWN * 3),
-        }
-        _cutoff = _now - AIAgent._CONTEXT_PRESSURE_COOLDOWN * 2
-        AIAgent._context_pressure_last_warned = {
-            k: v for k, v in AIAgent._context_pressure_last_warned.items()
-            if v[1] > _cutoff
-        }
-        assert "fresh" in AIAgent._context_pressure_last_warned
-        assert "stale" not in AIAgent._context_pressure_last_warned

tests/run_agent/test_flush_memories_codex.py

@@ -91,61 +91,6 @@ def _chat_response_with_memory_call():
     )
 
 
-class TestFlushMemoriesRespectsConfigTimeout:
-    """flush_memories() must NOT hardcode timeout=30.0 — it should defer
-    to the config value via auxiliary.flush_memories.timeout."""
-
-    def test_auxiliary_path_omits_explicit_timeout(self, monkeypatch):
-        """When calling _call_llm, timeout should NOT be passed so that
-        _get_task_timeout('flush_memories') reads from config."""
-        agent = _make_agent(monkeypatch, api_mode="chat_completions", provider="openrouter")
-
-        mock_response = _chat_response_with_memory_call()
-
-        with patch("agent.auxiliary_client.call_llm", return_value=mock_response) as mock_call:
-            messages = [
-                {"role": "user", "content": "Hello"},
-                {"role": "assistant", "content": "Hi"},
-                {"role": "user", "content": "Note this"},
-            ]
-            with patch("tools.memory_tool.memory_tool", return_value="Saved."):
-                agent.flush_memories(messages)
-
-        mock_call.assert_called_once()
-        call_kwargs = mock_call.call_args
-        # timeout must NOT be explicitly passed (so _get_task_timeout resolves it)
-        assert "timeout" not in call_kwargs.kwargs, (
-            "flush_memories should not pass explicit timeout to _call_llm; "
-            "let _get_task_timeout('flush_memories') resolve from config"
-        )
-
-    def test_fallback_path_uses_config_timeout(self, monkeypatch):
-        """When auxiliary client is unavailable and we fall back to direct
-        OpenAI client, timeout should come from _get_task_timeout, not hardcoded."""
-        agent = _make_agent(monkeypatch, api_mode="chat_completions", provider="openrouter")
-        agent.client = MagicMock()
-        agent.client.chat.completions.create.return_value = _chat_response_with_memory_call()
-
-        custom_timeout = 180.0
-
-        with patch("agent.auxiliary_client.call_llm", side_effect=RuntimeError("no provider")), \
-             patch("agent.auxiliary_client._get_task_timeout", return_value=custom_timeout) as mock_gtt, \
-             patch("tools.memory_tool.memory_tool", return_value="Saved."):
-            messages = [
-                {"role": "user", "content": "Hello"},
-                {"role": "assistant", "content": "Hi"},
-                {"role": "user", "content": "Save this"},
-            ]
-            agent.flush_memories(messages)
-
-        mock_gtt.assert_called_once_with("flush_memories")
-        agent.client.chat.completions.create.assert_called_once()
-        call_kwargs = agent.client.chat.completions.create.call_args
-        assert call_kwargs.kwargs.get("timeout") == custom_timeout, (
-            f"Expected timeout={custom_timeout} from config, got {call_kwargs.kwargs.get('timeout')}"
-        )
-
-
 class TestFlushMemoriesUsesAuxiliaryClient:
     """When an auxiliary client is available, flush_memories should use it
     instead of self.client -- especially critical in Codex mode."""

tests/run_agent/test_run_agent.py

@@ -1668,15 +1668,12 @@ class TestRunConversation:
             if roles[i] == "assistant" and roles[i + 1] == "assistant":
                 raise AssertionError("Consecutive assistant messages found in history")
 
-    def test_truly_empty_response_retries_3_times_then_empty(self, agent):
-        """Truly empty response (no content, no reasoning) retries 3 times then falls through to (empty)."""
+    def test_truly_empty_response_accepted_without_retry(self, agent):
+        """Truly empty response (no content, no reasoning) should still complete with (empty)."""
         self._setup_agent(agent)
         agent.base_url = "http://127.0.0.1:1234/v1"
         empty_resp = _mock_response(content=None, finish_reason="stop")
-        # 4 responses: 1 original + 3 nudge retries, all empty
-        agent.client.chat.completions.create.side_effect = [
-            empty_resp, empty_resp, empty_resp, empty_resp,
-        ]
+        agent.client.chat.completions.create.side_effect = [empty_resp]
         with (
             patch.object(agent, "_persist_session"),
             patch.object(agent, "_save_trajectory"),
@@ -1685,28 +1682,7 @@ class TestRunConversation:
             result = agent.run_conversation("answer me")
         assert result["completed"] is True
         assert result["final_response"] == "(empty)"
-        assert result["api_calls"] == 4  # 1 original + 3 retries
-
-    def test_truly_empty_response_succeeds_on_nudge(self, agent):
-        """Model produces content after being nudged for empty response."""
-        self._setup_agent(agent)
-        agent.base_url = "http://127.0.0.1:1234/v1"
-        empty_resp = _mock_response(content=None, finish_reason="stop")
-        content_resp = _mock_response(
-            content="Here is the actual answer.",
-            finish_reason="stop",
-        )
-        # 1 empty response, then model produces content on nudge
-        agent.client.chat.completions.create.side_effect = [empty_resp, content_resp]
-        with (
-            patch.object(agent, "_persist_session"),
-            patch.object(agent, "_save_trajectory"),
-            patch.object(agent, "_cleanup_task_resources"),
-        ):
-            result = agent.run_conversation("answer me")
-        assert result["completed"] is True
-        assert result["final_response"] == "Here is the actual answer."
-        assert result["api_calls"] == 2  # 1 original + 1 nudge retry
+        assert result["api_calls"] == 1  # no retries
 
     def test_nous_401_refreshes_after_remint_and_retries(self, agent):
         self._setup_agent(agent)

tests/skills/test_openclaw_migration.py

@@ -658,47 +658,6 @@ def test_workspace_agents_records_skip_when_missing(tmp_path: Path):
     assert wa_items[0]["status"] == "skipped"
 
 
-def test_cron_store_is_archived_without_config_cron_section(tmp_path: Path):
-    """Bug fix: archive cron store even when openclaw.json has no top-level cron config."""
-    mod = load_module()
-    source = tmp_path / ".openclaw"
-    target = tmp_path / ".hermes"
-    output_dir = target / "migration-report"
-    source.mkdir()
-    target.mkdir()
-
-    (source / "openclaw.json").write_text(json.dumps({"channels": {}}), encoding="utf-8")
-    (source / "cron").mkdir(parents=True)
-    (source / "cron" / "jobs.json").write_text(
-        json.dumps({"version": 1, "jobs": [{"id": "job-1", "name": "demo"}]}),
-        encoding="utf-8",
-    )
-
-    migrator = mod.Migrator(
-        source_root=source,
-        target_root=target,
-        execute=True,
-        workspace_target=None,
-        overwrite=False,
-        migrate_secrets=False,
-        output_dir=output_dir,
-        selected_options={"cron-jobs"},
-    )
-    report = migrator.migrate()
-
-    cron_items = [item for item in report["items"] if item["kind"] == "cron-jobs"]
-    archived_store = next(
-        (item for item in cron_items if item["destination"] and item["destination"].endswith("archive/cron-store")),
-        None,
-    )
-    assert archived_store is not None
-    assert Path(archived_store["destination"]).joinpath("jobs.json").exists()
-
-    notes_text = (output_dir / "MIGRATION_NOTES.md").read_text(encoding="utf-8")
-    assert "Run `hermes cron` to recreate scheduled tasks" in notes_text
-    assert "archive/cron-config.json" not in notes_text
-
-
 def test_skill_installs_cleanly_under_skills_guard():
     skills_guard = load_skills_guard()
     result = skills_guard.scan_skill(

tests/test_hermes_state.py

@@ -663,84 +663,6 @@ class TestPruneSessions:
         assert db.get_session("old_cli") is None
         assert db.get_session("old_tg") is not None
 
-    def test_prune_with_multilevel_chain(self, db):
-        """Pruning old sessions orphans newer children instead of crashing on FK."""
-        old_ts = time.time() - 200 * 86400
-        recent_ts = time.time() - 10 * 86400
-
-        # Chain: A (old) -> B (old) -> C (recent) -> D (recent)
-        db.create_session(session_id="A", source="cli")
-        db.end_session("A", end_reason="compressed")
-        db.create_session(session_id="B", source="cli", parent_session_id="A")
-        db.end_session("B", end_reason="compressed")
-        db.create_session(session_id="C", source="cli", parent_session_id="B")
-        db.end_session("C", end_reason="compressed")
-        db.create_session(session_id="D", source="cli", parent_session_id="C")
-        db.end_session("D", end_reason="done")
-
-        # Backdate A and B to be old; C and D stay recent
-        for sid, ts in [("A", old_ts), ("B", old_ts), ("C", recent_ts), ("D", recent_ts)]:
-            db._conn.execute(
-                "UPDATE sessions SET started_at = ? WHERE id = ?", (ts, sid)
-            )
-        db._conn.commit()
-
-        # Should not raise IntegrityError
-        pruned = db.prune_sessions(older_than_days=90)
-        assert pruned == 2  # only A and B
-        assert db.get_session("A") is None
-        assert db.get_session("B") is None
-        # C and D survive, C is orphaned (parent_session_id NULL)
-        c = db.get_session("C")
-        assert c is not None
-        assert c["parent_session_id"] is None
-        d = db.get_session("D")
-        assert d is not None
-        assert d["parent_session_id"] == "C"
-
-    def test_prune_entire_old_chain(self, db):
-        """All sessions in a chain are old — entire chain is pruned."""
-        old_ts = time.time() - 200 * 86400
-
-        db.create_session(session_id="X", source="cli")
-        db.end_session("X", end_reason="compressed")
-        db.create_session(session_id="Y", source="cli", parent_session_id="X")
-        db.end_session("Y", end_reason="compressed")
-        db.create_session(session_id="Z", source="cli", parent_session_id="Y")
-        db.end_session("Z", end_reason="done")
-
-        for sid in ("X", "Y", "Z"):
-            db._conn.execute(
-                "UPDATE sessions SET started_at = ? WHERE id = ?", (old_ts, sid)
-            )
-        db._conn.commit()
-
-        pruned = db.prune_sessions(older_than_days=90)
-        assert pruned == 3
-        for sid in ("X", "Y", "Z"):
-            assert db.get_session(sid) is None
-
-
-class TestDeleteSessionOrphansChildren:
-    def test_delete_orphans_children(self, db):
-        """Deleting a parent session orphans its children."""
-        db.create_session(session_id="parent", source="cli")
-        db.create_session(session_id="child", source="cli", parent_session_id="parent")
-        db.create_session(session_id="grandchild", source="cli", parent_session_id="child")
-
-        # Should not raise IntegrityError
-        result = db.delete_session("parent")
-        assert result is True
-        assert db.get_session("parent") is None
-        # Child is orphaned, not deleted
-        child = db.get_session("child")
-        assert child is not None
-        assert child["parent_session_id"] is None
-        # Grandchild is untouched
-        grandchild = db.get_session("grandchild")
-        assert grandchild is not None
-        assert grandchild["parent_session_id"] == "child"
-
 
 # =========================================================================
 # Schema and WAL mode

tests/tools/test_terminal_none_command_guard.py

@@ -1,21 +0,0 @@
-"""Regression tests for invalid/None terminal command handling."""
-
-import json
-
-from tools.terminal_tool import _transform_sudo_command, terminal_tool
-
-
-def test_transform_sudo_command_none_returns_cleanly():
-    transformed, sudo_stdin = _transform_sudo_command(None)
-
-    assert transformed is None
-    assert sudo_stdin is None
-
-
-def test_terminal_tool_none_command_returns_clean_error():
-    result = json.loads(terminal_tool(None))  # type: ignore[arg-type]
-
-    assert result["exit_code"] == -1
-    assert result["status"] == "error"
-    assert "expected string" in result["error"].lower()
-    assert "nonetype" in result["error"].lower()

tools/cronjob_tools.py

@@ -455,7 +455,7 @@ Important safety rule: cron-run sessions should not recursively schedule more cr
             },
             "deliver": {
                 "type": "string",
-                "description": "Delivery target: origin, local, telegram, discord, slack, whatsapp, signal, matrix, mattermost, homeassistant, dingtalk, feishu, wecom, email, sms, bluebubbles, or platform:chat_id or platform:chat_id:thread_id for Telegram topics. Examples: 'origin', 'local', 'telegram', 'telegram:-1001234567890:17585', 'discord:#engineering'"
+                "description": "Delivery target: origin, local, telegram, discord, slack, whatsapp, signal, matrix, mattermost, homeassistant, dingtalk, feishu, wecom, email, sms, or platform:chat_id or platform:chat_id:thread_id for Telegram topics. Examples: 'origin', 'local', 'telegram', 'telegram:-1001234567890:17585', 'discord:#engineering'"
             },
             "skills": {
                 "type": "array",

tools/send_message_tool.py

@@ -148,7 +148,6 @@ def _handle_send(args):
         "slack": Platform.SLACK,
         "whatsapp": Platform.WHATSAPP,
         "signal": Platform.SIGNAL,
-        "bluebubbles": Platform.BLUEBUBBLES,
         "matrix": Platform.MATRIX,
         "mattermost": Platform.MATTERMOST,
         "homeassistant": Platform.HOMEASSISTANT,
@@ -397,8 +396,6 @@ async def _send_to_platform(platform, pconfig, chat_id, message, thread_id=None,
             result = await _send_feishu(pconfig, chat_id, chunk, thread_id=thread_id)
         elif platform == Platform.WECOM:
             result = await _send_wecom(pconfig.extra, chat_id, chunk)
-        elif platform == Platform.BLUEBUBBLES:
-            result = await _send_bluebubbles(pconfig.extra, chat_id, chunk)
         else:
             result = {"error": f"Direct sending not yet implemented for {platform.value}"}
 
@@ -873,33 +870,6 @@ async def _send_wecom(extra, chat_id, message):
         return _error(f"WeCom send failed: {e}")
 
 
-async def _send_bluebubbles(extra, chat_id, message):
-    """Send via BlueBubbles iMessage server using the adapter's REST API."""
-    try:
-        from gateway.platforms.bluebubbles import BlueBubblesAdapter, check_bluebubbles_requirements
-        if not check_bluebubbles_requirements():
-            return {"error": "BlueBubbles requirements not met (need aiohttp + httpx)."}
-    except ImportError:
-        return {"error": "BlueBubbles adapter not available."}
-
-    try:
-        from gateway.config import PlatformConfig
-        pconfig = PlatformConfig(extra=extra)
-        adapter = BlueBubblesAdapter(pconfig)
-        connected = await adapter.connect()
-        if not connected:
-            return _error("BlueBubbles: failed to connect to server")
-        try:
-            result = await adapter.send(chat_id, message)
-            if not result.success:
-                return _error(f"BlueBubbles send failed: {result.error}")
-            return {"success": True, "platform": "bluebubbles", "chat_id": chat_id, "message_id": result.message_id}
-        finally:
-            await adapter.disconnect()
-    except Exception as e:
-        return _error(f"BlueBubbles send failed: {e}")
-
-
 async def _send_feishu(pconfig, chat_id, message, media_files=None, thread_id=None):
     """Send via Feishu/Lark using the adapter's send pipeline."""
     try:

tools/terminal_tool.py

@@ -327,19 +327,7 @@ def _prompt_for_sudo_password(timeout_seconds: int = 45) -> str:
             del os.environ["HERMES_SPINNER_PAUSE"]
 
 
-def _safe_command_preview(command: Any, limit: int = 200) -> str:
-    """Return a log-safe preview for possibly-invalid command values."""
-    if command is None:
-        return "<None>"
-    if isinstance(command, str):
-        return command[:limit]
-    try:
-        return repr(command)[:limit]
-    except Exception:
-        return f"<{type(command).__name__}>"
-
-
-def _transform_sudo_command(command: str | None) -> tuple[str | None, str | None]:
+def _transform_sudo_command(command: str) -> tuple[str, str | None]:
     """
     Transform sudo commands to use -S flag if SUDO_PASSWORD is available.
 
@@ -377,9 +365,6 @@ def _transform_sudo_command(command: str | None) -> tuple[str | None, str | None
     import re
 
     # Check if command even contains sudo
-    if command is None:
-        return None, None
-
     if not re.search(r'\bsudo\b', command):
         return command, None  # No sudo in command, nothing to do
 
@@ -829,23 +814,6 @@ def get_active_env(task_id: str):
         return _active_environments.get(task_id)
 
 
-def is_persistent_env(task_id: str) -> bool:
-    """Return True if the active environment for task_id is configured for
-    cross-turn persistence (``persistent_filesystem=True``).
-
-    Used by the agent loop to skip per-turn teardown for backends whose whole
-    point is to survive between turns (docker with ``container_persistent``,
-    daytona, modal, etc.). Non-persistent backends (e.g. Morph) still get torn
-    down at end-of-turn to prevent leakage. The idle reaper
-    (``_cleanup_inactive_envs``) handles persistent envs once they exceed
-    ``terminal.lifetime_seconds``.
-    """
-    env = get_active_env(task_id)
-    if env is None:
-        return False
-    return bool(getattr(env, "_persistent", False))
-
-
 def get_active_environments_info() -> Dict[str, Any]:
     """Get information about currently active environments."""
     info = {
@@ -1065,18 +1033,6 @@ def terminal_tool(
         # Note: force parameter is internal only, not exposed to model API
     """
     try:
-        if not isinstance(command, str):
-            logger.warning(
-                "Rejected invalid terminal command value: %s",
-                type(command).__name__,
-            )
-            return json.dumps({
-                "output": "",
-                "exit_code": -1,
-                "error": f"Invalid command: expected string, got {type(command).__name__}",
-                "status": "error",
-            }, ensure_ascii=False)
-
         # Get configuration
         config = _get_env_config()
         env_type = config["env_type"]
@@ -1234,7 +1190,7 @@ def terminal_tool(
             workdir_error = _validate_workdir(workdir)
             if workdir_error:
                 logger.warning("Blocked dangerous workdir: %s (command: %s)",
-                               workdir[:200], _safe_command_preview(command))
+                               workdir[:200], command[:200])
                 return json.dumps({
                     "output": "",
                     "exit_code": -1,
@@ -1374,12 +1330,12 @@ def terminal_tool(
                         retry_count += 1
                         wait_time = 2 ** retry_count
                         logger.warning("Execution error, retrying in %ds (attempt %d/%d) - Command: %s - Error: %s: %s - Task: %s, Backend: %s",
-                                       wait_time, retry_count, max_retries, _safe_command_preview(command), type(e).__name__, e, effective_task_id, env_type)
+                                       wait_time, retry_count, max_retries, command[:200], type(e).__name__, e, effective_task_id, env_type)
                         time.sleep(wait_time)
                         continue
                     
                     logger.error("Execution failed after %d retries - Command: %s - Error: %s: %s - Task: %s, Backend: %s",
-                                 max_retries, _safe_command_preview(command), type(e).__name__, e, effective_task_id, env_type)
+                                 max_retries, command[:200], type(e).__name__, e, effective_task_id, env_type)
                     return json.dumps({
                         "output": "",
                         "exit_code": -1,

toolsets.py

@@ -311,12 +311,6 @@ TOOLSETS = {
         "includes": []
     },
 
-    "hermes-bluebubbles": {
-        "description": "BlueBubbles iMessage bot toolset - Apple iMessage via local BlueBubbles server",
-        "tools": _HERMES_CORE_TOOLS,
-        "includes": []
-    },
-
     "hermes-homeassistant": {
         "description": "Home Assistant bot toolset - smart home event monitoring and control",
         "tools": _HERMES_CORE_TOOLS,
@@ -374,7 +368,7 @@ TOOLSETS = {
     "hermes-gateway": {
         "description": "Gateway toolset - union of all messaging platform tools",
         "tools": [],
-        "includes": ["hermes-telegram", "hermes-discord", "hermes-whatsapp", "hermes-slack", "hermes-signal", "hermes-bluebubbles", "hermes-homeassistant", "hermes-email", "hermes-sms", "hermes-mattermost", "hermes-matrix", "hermes-dingtalk", "hermes-feishu", "hermes-wecom", "hermes-webhook"]
+        "includes": ["hermes-telegram", "hermes-discord", "hermes-whatsapp", "hermes-slack", "hermes-signal", "hermes-homeassistant", "hermes-email", "hermes-sms", "hermes-mattermost", "hermes-matrix", "hermes-dingtalk", "hermes-feishu", "hermes-wecom", "hermes-webhook"]
     }
 }
 

website/docs/developer-guide/architecture.md

@@ -116,9 +116,9 @@ hermes-agent/
 │   ├── mirror.py             # Cross-session message mirroring
 │   ├── status.py             # Token locks, profile-scoped process tracking
 │   ├── builtin_hooks/        # Always-registered hooks
-│   └── platforms/            # 15 adapters: telegram, discord, slack, whatsapp,
+│   └── platforms/            # 14 adapters: telegram, discord, slack, whatsapp,
 │                             #   signal, matrix, mattermost, email, sms,
-│                             #   dingtalk, feishu, wecom, bluebubbles, homeassistant, webhook
+│                             #   dingtalk, feishu, wecom, homeassistant, webhook
 │
 ├── acp_adapter/              # ACP server (VS Code / Zed / JetBrains)
 ├── cron/                     # Scheduler (jobs.py, scheduler.py)

website/docs/developer-guide/cron-internals.md

@@ -153,7 +153,6 @@ Cron job results can be delivered to any supported platform:
 | DingTalk | `dingtalk` | Deliver to DingTalk |
 | Feishu | `feishu` | Deliver to Feishu |
 | WeCom | `wecom` | Deliver to WeCom |
-| BlueBubbles | `bluebubbles` | Deliver to iMessage via BlueBubbles |
 
 For Telegram topics, use the format `telegram:<chat_id>:<thread_id>` (e.g., `telegram:-1001234567890:17585`).
 

website/docs/developer-guide/gateway-internals.md

@@ -160,7 +160,6 @@ gateway/platforms/
 ├── dingtalk.py          # DingTalk WebSocket
 ├── feishu.py            # Feishu/Lark WebSocket or webhook
 ├── wecom.py             # WeCom (WeChat Work) callback
-├── bluebubbles.py       # Apple iMessage via BlueBubbles macOS server
 ├── webhook.py           # Inbound/outbound webhook adapter
 ├── api_server.py        # REST API server adapter
 └── homeassistant.py     # Home Assistant conversation integration

website/docs/index.md

@@ -46,7 +46,7 @@ It's not a coding copilot tethered to an IDE or a chatbot wrapper around a singl
 
 - **A closed learning loop** — Agent-curated memory with periodic nudges, autonomous skill creation, skill self-improvement during use, FTS5 cross-session recall with LLM summarization, and [Honcho](https://github.com/plastic-labs/honcho) dialectic user modeling
 - **Runs anywhere, not just your laptop** — 6 terminal backends: local, Docker, SSH, Daytona, Singularity, Modal. Daytona and Modal offer serverless persistence — your environment hibernates when idle, costing nearly nothing
-- **Lives where you do** — CLI, Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, DingTalk, Feishu, WeCom, BlueBubbles, Home Assistant — 15+ platforms from one gateway
+- **Lives where you do** — CLI, Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, DingTalk, Feishu, WeCom, Home Assistant — 14+ platforms from one gateway
 - **Built by model trainers** — Created by [Nous Research](https://nousresearch.com), the lab behind Hermes, Nomos, and Psyche. Works with [Nous Portal](https://portal.nousresearch.com), [OpenRouter](https://openrouter.ai), OpenAI, or any endpoint
 - **Scheduled automations** — Built-in cron with delivery to any platform
 - **Delegates & parallelizes** — Spawn isolated subagents for parallel workstreams. Programmatic Tool Calling via `execute_code` collapses multi-step pipelines into single inference calls

website/docs/integrations/index.md

@@ -80,9 +80,9 @@ Speech-to-text supports three providers: local Whisper (free, runs on-device), G
 
 ## Messaging Platforms
 
-Hermes runs as a gateway bot on 15+ messaging platforms, all configured through the same `gateway` subsystem:
+Hermes runs as a gateway bot on 14+ messaging platforms, all configured through the same `gateway` subsystem:
 
-- **[Telegram](/docs/user-guide/messaging/telegram)**, **[Discord](/docs/user-guide/messaging/discord)**, **[Slack](/docs/user-guide/messaging/slack)**, **[WhatsApp](/docs/user-guide/messaging/whatsapp)**, **[Signal](/docs/user-guide/messaging/signal)**, **[Matrix](/docs/user-guide/messaging/matrix)**, **[Mattermost](/docs/user-guide/messaging/mattermost)**, **[Email](/docs/user-guide/messaging/email)**, **[SMS](/docs/user-guide/messaging/sms)**, **[DingTalk](/docs/user-guide/messaging/dingtalk)**, **[Feishu/Lark](/docs/user-guide/messaging/feishu)**, **[WeCom](/docs/user-guide/messaging/wecom)**, **[BlueBubbles](/docs/user-guide/messaging/bluebubbles)**, **[Home Assistant](/docs/user-guide/messaging/homeassistant)**, **[Webhooks](/docs/user-guide/messaging/webhooks)**
+- **[Telegram](/docs/user-guide/messaging/telegram)**, **[Discord](/docs/user-guide/messaging/discord)**, **[Slack](/docs/user-guide/messaging/slack)**, **[WhatsApp](/docs/user-guide/messaging/whatsapp)**, **[Signal](/docs/user-guide/messaging/signal)**, **[Matrix](/docs/user-guide/messaging/matrix)**, **[Mattermost](/docs/user-guide/messaging/mattermost)**, **[Email](/docs/user-guide/messaging/email)**, **[SMS](/docs/user-guide/messaging/sms)**, **[DingTalk](/docs/user-guide/messaging/dingtalk)**, **[Feishu/Lark](/docs/user-guide/messaging/feishu)**, **[WeCom](/docs/user-guide/messaging/wecom)**, **[Home Assistant](/docs/user-guide/messaging/homeassistant)**, **[Webhooks](/docs/user-guide/messaging/webhooks)**
 
 See the [Messaging Gateway overview](/docs/user-guide/messaging) for the platform comparison table and setup guide.
 

website/docs/reference/environment-variables.md

@@ -175,7 +175,6 @@ For cloud sandbox backends, persistence is filesystem-oriented. `TERMINAL_LIFETI
 | `DISCORD_REACTIONS` | Enable emoji reactions on messages during processing (default: `true`) |
 | `DISCORD_IGNORED_CHANNELS` | Comma-separated channel IDs where the bot never responds |
 | `DISCORD_NO_THREAD_CHANNELS` | Comma-separated channel IDs where bot responds without auto-threading |
-| `DISCORD_REPLY_TO_MODE` | Reply-reference behavior: `off`, `first` (default), or `all` |
 | `SLACK_BOT_TOKEN` | Slack bot token (`xoxb-...`) |
 | `SLACK_APP_TOKEN` | Slack app-level token (`xapp-...`, required for Socket Mode) |
 | `SLACK_ALLOWED_USERS` | Comma-separated Slack user IDs |
@@ -228,13 +227,6 @@ For cloud sandbox backends, persistence is filesystem-oriented. `TERMINAL_LIFETI
 | `WECOM_WEBSOCKET_URL` | Custom WebSocket URL (default: `wss://openws.work.weixin.qq.com`) |
 | `WECOM_ALLOWED_USERS` | Comma-separated WeCom user IDs allowed to message the bot |
 | `WECOM_HOME_CHANNEL` | WeCom chat ID for cron delivery and notifications |
-| `BLUEBUBBLES_SERVER_URL` | BlueBubbles server URL (e.g. `http://192.168.1.10:1234`) |
-| `BLUEBUBBLES_PASSWORD` | BlueBubbles server password |
-| `BLUEBUBBLES_WEBHOOK_HOST` | Webhook listener bind address (default: `127.0.0.1`) |
-| `BLUEBUBBLES_WEBHOOK_PORT` | Webhook listener port (default: `8645`) |
-| `BLUEBUBBLES_HOME_CHANNEL` | Phone/email for cron/notification delivery |
-| `BLUEBUBBLES_ALLOWED_USERS` | Comma-separated authorized users |
-| `BLUEBUBBLES_ALLOW_ALL_USERS` | Allow all users (`true`/`false`) |
 | `MATTERMOST_URL` | Mattermost server URL (e.g. `https://mm.example.com`) |
 | `MATTERMOST_TOKEN` | Bot token or personal access token for Mattermost |
 | `MATTERMOST_ALLOWED_USERS` | Comma-separated Mattermost user IDs allowed to message the bot |

website/docs/reference/toolsets-reference.md

@@ -103,7 +103,6 @@ Platform toolsets define the complete tool configuration for a deployment target
 | `hermes-dingtalk` | Same as `hermes-cli`. |
 | `hermes-feishu` | Same as `hermes-cli`. |
 | `hermes-wecom` | Same as `hermes-cli`. |
-| `hermes-bluebubbles` | Same as `hermes-cli`. |
 | `hermes-homeassistant` | Same as `hermes-cli`. |
 | `hermes-webhook` | Same as `hermes-cli`. |
 | `hermes-gateway` | Union of all messaging platform toolsets. Used internally when the gateway needs the broadest possible tool set. |

website/docs/user-guide/configuration.md

@@ -809,7 +809,6 @@ This controls both the `text_to_speech` tool and spoken replies in voice mode (`
 display:
   tool_progress: all      # off | new | all | verbose
   tool_progress_command: false  # Enable /verbose slash command in messaging gateway
-  tool_progress_overrides: {}  # Per-platform overrides (see below)
   skin: default           # Built-in or custom CLI skin (see user-guide/features/skins)
   personality: "kawaii"  # Legacy cosmetic field still surfaced in some summaries
   compact: false          # Compact output mode (less whitespace)
@@ -830,21 +829,6 @@ display:
 
 In the CLI, cycle through these modes with `/verbose`. To use `/verbose` in messaging platforms (Telegram, Discord, Slack, etc.), set `tool_progress_command: true` in the `display` section above. The command will then cycle the mode and save to config.
 
-### Per-platform progress overrides
-
-Different platforms have different verbosity needs. For example, Signal can't edit messages, so each progress update becomes a separate message — noisy. Use `tool_progress_overrides` to set per-platform modes:
-
-```yaml
-display:
-  tool_progress: all          # global default
-  tool_progress_overrides:
-    signal: 'off'             # silence progress on Signal
-    telegram: verbose         # detailed progress on Telegram
-    slack: 'off'              # quiet in shared Slack workspace
-```
-
-Platforms without an override fall back to the global `tool_progress` value. Valid platform keys: `telegram`, `discord`, `slack`, `signal`, `whatsapp`, `matrix`, `mattermost`, `email`, `sms`, `homeassistant`, `dingtalk`, `feishu`, `wecom`, `bluebubbles`.
-
 ## Privacy
 
 ```yaml

website/docs/user-guide/features/cron.md

@@ -202,7 +202,6 @@ When scheduling jobs, you specify where the output goes:
 | `"dingtalk"` | DingTalk | |
 | `"feishu"` | Feishu/Lark | |
 | `"wecom"` | WeCom | |
-| `"bluebubbles"` | BlueBubbles (iMessage) | |
 
 The agent's final response is automatically delivered. You do not need to call `send_message` in the cron prompt.
 

website/docs/user-guide/features/memory-providers.md

@@ -263,12 +263,12 @@ echo "MEM0_API_KEY=your-key" >> ~/.hermes/.env
 
 ### Hindsight
 
-Long-term memory with knowledge graph, entity resolution, and multi-strategy retrieval. The `hindsight_reflect` tool provides cross-memory synthesis that no other provider offers. Automatically retains full conversation turns (including tool calls) with session-level document tracking.
+Long-term memory with knowledge graph, entity resolution, and multi-strategy retrieval. The `hindsight_reflect` tool provides cross-memory synthesis that no other provider offers.
 
 | | |
 |---|---|
 | **Best for** | Knowledge graph-based recall with entity relationships |
-| **Requires** | Cloud: API key from [ui.hindsight.vectorize.io](https://ui.hindsight.vectorize.io). Local: LLM API key (OpenAI, Groq, OpenRouter, etc.) |
+| **Requires** | Cloud: `pip install hindsight-client` + API key. Local: `pip install hindsight` + LLM key |
 | **Data storage** | Hindsight Cloud or local embedded PostgreSQL |
 | **Cost** | Hindsight pricing (cloud) or free (local) |
 
@@ -282,25 +282,13 @@ hermes config set memory.provider hindsight
 echo "HINDSIGHT_API_KEY=your-key" >> ~/.hermes/.env
 ```
 
-The setup wizard installs dependencies automatically and only installs what's needed for the selected mode (`hindsight-client` for cloud, `hindsight-all` for local). Requires `hindsight-client >= 0.4.22` (auto-upgraded on session start if outdated).
-
-**Local mode UI:** `hindsight-embed -p hermes ui start`
-
 **Config:** `$HERMES_HOME/hindsight/config.json`
 
 | Key | Default | Description |
 |-----|---------|-------------|
 | `mode` | `cloud` | `cloud` or `local` |
 | `bank_id` | `hermes` | Memory bank identifier |
-| `recall_budget` | `mid` | Recall thoroughness: `low` / `mid` / `high` |
-| `memory_mode` | `hybrid` | `hybrid` (context + tools), `context` (auto-inject only), `tools` (tools only) |
-| `auto_retain` | `true` | Automatically retain conversation turns |
-| `auto_recall` | `true` | Automatically recall memories before each turn |
-| `retain_async` | `true` | Process retain asynchronously on the server |
-| `tags` | — | Tags applied when storing memories |
-| `recall_tags` | — | Tags to filter on recall |
-
-See [plugin README](https://github.com/NousResearch/hermes-agent/blob/main/plugins/memory/hindsight/README.md) for the full configuration reference.
+| `budget` | `mid` | Recall thoroughness: `low` / `mid` / `high` |
 
 ---
 

website/docs/user-guide/messaging/bluebubbles.md

@@ -1,141 +0,0 @@
-# BlueBubbles (iMessage)
-
-Connect Hermes to Apple iMessage via [BlueBubbles](https://bluebubbles.app/) — a free, open-source macOS server that bridges iMessage to any device.
-
-## Prerequisites
-
-- A **Mac** (always on) running [BlueBubbles Server](https://bluebubbles.app/)
-- Apple ID signed into Messages.app on that Mac
-- BlueBubbles Server v1.0.0+ (webhooks require this version)
-- Network connectivity between Hermes and the BlueBubbles server
-
-## Setup
-
-### 1. Install BlueBubbles Server
-
-Download and install from [bluebubbles.app](https://bluebubbles.app/). Complete the setup wizard — sign in with your Apple ID and configure a connection method (local network, Ngrok, Cloudflare, or Dynamic DNS).
-
-### 2. Get your Server URL and Password
-
-In BlueBubbles Server → **Settings → API**, note:
-- **Server URL** (e.g., `http://192.168.1.10:1234`)
-- **Server Password**
-
-### 3. Configure Hermes
-
-Run the setup wizard:
-
-```bash
-hermes gateway setup
-```
-
-Select **BlueBubbles (iMessage)** and enter your server URL and password.
-
-Or set environment variables directly in `~/.hermes/.env`:
-
-```bash
-BLUEBUBBLES_SERVER_URL=http://192.168.1.10:1234
-BLUEBUBBLES_PASSWORD=your-server-password
-```
-
-### 4. Authorize Users
-
-Choose one approach:
-
-**DM Pairing (recommended):**
-```bash
-hermes pairing generate bluebubbles
-```
-Share the pairing code — the user sends it via iMessage to get approved.
-
-**Pre-authorize specific users:**
-```bash
-BLUEBUBBLES_ALLOWED_USERS=user@icloud.com,+15551234567
-```
-
-**Open access:**
-```bash
-BLUEBUBBLES_ALLOW_ALL_USERS=true
-```
-
-### 5. Start the Gateway
-
-```bash
-hermes gateway run
-```
-
-Hermes will connect to your BlueBubbles server, register a webhook, and start listening for iMessage messages.
-
-## How It Works
-
-```
-iMessage → Messages.app → BlueBubbles Server → Webhook → Hermes
-Hermes → BlueBubbles REST API → Messages.app → iMessage
-```
-
-- **Inbound:** BlueBubbles sends webhook events to a local listener when new messages arrive. No polling — instant delivery.
-- **Outbound:** Hermes sends messages via the BlueBubbles REST API.
-- **Media:** Images, voice messages, videos, and documents are supported in both directions. Inbound attachments are downloaded and cached locally for the agent to process.
-
-## Environment Variables
-
-| Variable | Required | Default | Description |
-|----------|----------|---------|-------------|
-| `BLUEBUBBLES_SERVER_URL` | Yes | — | BlueBubbles server URL |
-| `BLUEBUBBLES_PASSWORD` | Yes | — | Server password |
-| `BLUEBUBBLES_WEBHOOK_HOST` | No | `127.0.0.1` | Webhook listener bind address |
-| `BLUEBUBBLES_WEBHOOK_PORT` | No | `8645` | Webhook listener port |
-| `BLUEBUBBLES_WEBHOOK_PATH` | No | `/bluebubbles-webhook` | Webhook URL path |
-| `BLUEBUBBLES_HOME_CHANNEL` | No | — | Phone/email for cron delivery |
-| `BLUEBUBBLES_ALLOWED_USERS` | No | — | Comma-separated authorized users |
-| `BLUEBUBBLES_ALLOW_ALL_USERS` | No | `false` | Allow all users |
-| `BLUEBUBBLES_SEND_READ_RECEIPTS` | No | `true` | Auto-mark messages as read |
-
-## Features
-
-### Text Messaging
-Send and receive iMessages. Markdown is automatically stripped for clean plain-text delivery.
-
-### Rich Media
-- **Images:** Photos appear natively in the iMessage conversation
-- **Voice messages:** Audio files sent as iMessage voice messages
-- **Videos:** Video attachments
-- **Documents:** Files sent as iMessage attachments
-
-### Tapback Reactions
-Love, like, dislike, laugh, emphasize, and question reactions. Requires the BlueBubbles [Private API helper](https://docs.bluebubbles.app/helper-bundle/installation).
-
-### Typing Indicators
-Shows "typing..." in the iMessage conversation while the agent is processing. Requires Private API.
-
-### Read Receipts
-Automatically marks messages as read after processing. Requires Private API.
-
-### Chat Addressing
-You can address chats by email or phone number — Hermes resolves them to BlueBubbles chat GUIDs automatically. No need to use raw GUID format.
-
-## Private API
-
-Some features require the BlueBubbles [Private API helper](https://docs.bluebubbles.app/helper-bundle/installation):
-- Tapback reactions
-- Typing indicators
-- Read receipts
-- Creating new chats by address
-
-Without the Private API, basic text messaging and media still work.
-
-## Troubleshooting
-
-### "Cannot reach server"
-- Verify the server URL is correct and the Mac is on
-- Check that BlueBubbles Server is running
-- Ensure network connectivity (firewall, port forwarding)
-
-### Messages not arriving
-- Check that the webhook is registered in BlueBubbles Server → Settings → API → Webhooks
-- Verify the webhook URL is reachable from the Mac
-- Check `hermes gateway logs` for webhook errors
-
-### "Private API helper not connected"
-- Install the Private API helper: [docs.bluebubbles.app](https://docs.bluebubbles.app/helper-bundle/installation)
-- Basic messaging works without it — only reactions, typing, and read receipts require it

website/docs/user-guide/messaging/discord.md

@@ -282,7 +282,6 @@ Discord behavior is controlled through two files: **`~/.hermes/.env`** for crede
 | `DISCORD_REACTIONS` | No | `true` | When `true`, the bot adds emoji reactions to messages during processing (👀 when starting, ✅ on success, ❌ on error). Set to `false` to disable reactions entirely. |
 | `DISCORD_IGNORED_CHANNELS` | No | — | Comma-separated channel IDs where the bot **never** responds, even when `@mentioned`. Takes priority over all other channel settings. |
 | `DISCORD_NO_THREAD_CHANNELS` | No | — | Comma-separated channel IDs where the bot responds directly in the channel instead of creating a thread. Only relevant when `DISCORD_AUTO_THREAD` is `true`. |
-| `DISCORD_REPLY_TO_MODE` | No | `"first"` | Controls reply-reference behavior: `"off"` — never reply to the original message, `"first"` — reply-reference on the first message chunk only (default), `"all"` — reply-reference on every chunk. |
 
 ### Config File (`config.yaml`)
 

website/docs/user-guide/messaging/index.md

@@ -6,7 +6,7 @@ description: "Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal,
 
 # Messaging Gateway
 
-Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal, SMS, Email, Home Assistant, Mattermost, Matrix, DingTalk, Feishu/Lark, WeCom, BlueBubbles (iMessage), or your browser. The gateway is a single background process that connects to all your configured platforms, handles sessions, runs cron jobs, and delivers voice messages.
+Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal, SMS, Email, Home Assistant, Mattermost, Matrix, DingTalk, Feishu/Lark, WeCom, or your browser. The gateway is a single background process that connects to all your configured platforms, handles sessions, runs cron jobs, and delivers voice messages.
 
 For the full voice feature set — including CLI microphone mode, spoken replies in messaging, and Discord voice-channel conversations — see [Voice Mode](/docs/user-guide/features/voice-mode) and [Use Voice Mode with Hermes](/docs/guides/use-voice-mode-with-hermes).
 
@@ -27,7 +27,6 @@ For the full voice feature set — including CLI microphone mode, spoken replies
 | DingTalk | — | — | — | — | — | ✅ | ✅ |
 | Feishu/Lark | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | WeCom | ✅ | ✅ | ✅ | — | — | ✅ | ✅ |
-| BlueBubbles | — | ✅ | ✅ | — | ✅ | ✅ | — |
 
 **Voice** = TTS audio replies and/or voice message transcription. **Images** = send/receive images. **Files** = send/receive file attachments. **Threads** = threaded conversations. **Reactions** = emoji reactions on messages. **Typing** = typing indicator while processing. **Streaming** = progressive message updates via editing.
 
@@ -50,7 +49,6 @@ flowchart TB
             dt[DingTalk]
     fs[Feishu/Lark]
     wc[WeCom]
-    bb[BlueBubbles]
             api["API Server<br/>(OpenAI-compatible)"]
             wh[Webhooks]
         end
@@ -354,7 +352,6 @@ Each platform has its own toolset:
 | DingTalk | `hermes-dingtalk` | Full tools including terminal |
 | Feishu/Lark | `hermes-feishu` | Full tools including terminal |
 | WeCom | `hermes-wecom` | Full tools including terminal |
-| BlueBubbles | `hermes-bluebubbles` | Full tools including terminal |
 | API Server | `hermes` (default) | Full tools including terminal |
 | Webhooks | `hermes-webhook` | Full tools including terminal |
 
@@ -373,6 +370,5 @@ Each platform has its own toolset:
 - [DingTalk Setup](dingtalk.md)
 - [Feishu/Lark Setup](feishu.md)
 - [WeCom Setup](wecom.md)
-- [BlueBubbles Setup (iMessage)](bluebubbles.md)
 - [Open WebUI + API Server](open-webui.md)
 - [Webhooks](webhooks.md)

website/docs/user-guide/sessions.md

@@ -44,7 +44,6 @@ Each session is tagged with its source platform:
 | `dingtalk` | DingTalk messenger |
 | `feishu` | Feishu/Lark messenger |
 | `wecom` | WeCom (WeChat Work) |
-| `bluebubbles` | Apple iMessage via BlueBubbles macOS server |
 | `homeassistant` | Home Assistant conversation |
 | `webhook` | Incoming webhooks |
 | `api-server` | API server requests |

website/sidebars.ts

@@ -107,7 +107,6 @@ const sidebars: SidebarsConfig = {
         'user-guide/messaging/dingtalk',
         'user-guide/messaging/feishu',
         'user-guide/messaging/wecom',
-        'user-guide/messaging/bluebubbles',
         'user-guide/messaging/open-webui',
         'user-guide/messaging/webhooks',
       ],