fix: add /browser to COMMAND_REGISTRY so it shows in help and autocomplete

The /browser command handler existed in cli.py but was never added to
COMMAND_REGISTRY after the centralized command registry refactor. This
meant:
- /browser didn't appear in /help
- No tab-completion or subcommand suggestions
- Dispatch used _base_word fallback instead of canonical resolution

Added CommandDef with connect/disconnect/status subcommands and
switched dispatch to use canonical instead of _base_word.

.env.example

@@ -234,13 +234,6 @@ VOICE_TOOLS_OPENAI_KEY=
 # EMAIL_ALLOWED_USERS=your@email.com
 # EMAIL_HOME_ADDRESS=your@email.com
 
-# --- OpenAI-compatible HTTP Server ---
-# Enables any OpenAI-compatible frontend (Open WebUI, LobeChat, etc.) to connect.
-# HTTP_SERVER_ENABLED=true
-# HTTP_SERVER_KEY=your-secret-key     # Bearer token auth (omit for local-only use)
-# HTTP_SERVER_PORT=8642               # Default port
-# HTTP_SERVER_HOST=127.0.0.1          # Default: localhost only. 0.0.0.0 for network access.
-
 # Gateway-wide: allow ALL users without an allowlist (default: false = deny)
 # Only set to true if you intentionally want open access.
 # GATEWAY_ALLOW_ALL_USERS=false
@@ -287,7 +280,7 @@ TINKER_API_KEY=
 # Get at: https://wandb.ai/authorize
 WANDB_API_KEY=
 
-# RL HTTP Server URL (default: http://localhost:8080)
+# RL API Server URL (default: http://localhost:8080)
 # Change if running the rl-server on a different host/port
 # RL_API_URL=http://localhost:8080
 

AGENTS.md

@@ -364,7 +364,7 @@ Rendering bugs in tmux/iTerm2 — ghosting on scroll. Use `curses` (stdlib) inst
 Leaks as literal `?[K` text under `prompt_toolkit`'s `patch_stdout`. Use space-padding: `f"\r{line}{' ' * pad}"`.
 
 ### `_last_resolved_tool_names` is a process-global in `model_tools.py`
-When subagents overwrite this global, `execute_code` calls after delegation may fail with missing tool imports. Known bug.
+`_run_single_child()` in `delegate_tool.py` saves and restores this global around subagent execution. If you add new code that reads this global, be aware it may be temporarily stale during child agent runs.
 
 ### Tests must not write to `~/.hermes/`
 The `_isolate_hermes_home` autouse fixture in `tests/conftest.py` redirects `HERMES_HOME` to a temp dir. Never hardcode `~/.hermes/` paths in tests.

agent/context_compressor.py

@@ -311,6 +311,7 @@ Write only the summary body. Do not include any preamble or prefix; the system w
                 )
             compressed.append(msg)
 
+        _merge_summary_into_tail = False
         if summary:
             last_head_role = messages[compress_start - 1].get("role", "user") if compress_start > 0 else "user"
             first_tail_role = messages[compress_end].get("role", "user") if compress_end < n_messages else "user"
@@ -326,13 +327,25 @@ Write only the summary body. Do not include any preamble or prefix; the system w
                 flipped = "assistant" if summary_role == "user" else "user"
                 if flipped != last_head_role:
                     summary_role = flipped
-            compressed.append({"role": summary_role, "content": summary})
+                else:
+                    # Both roles would create consecutive same-role messages
+                    # (e.g. head=assistant, tail=user — neither role works).
+                    # Merge the summary into the first tail message instead
+                    # of inserting a standalone message that breaks alternation.
+                    _merge_summary_into_tail = True
+            if not _merge_summary_into_tail:
+                compressed.append({"role": summary_role, "content": summary})
         else:
             if not self.quiet_mode:
                 print("   ⚠️  No summary model available — middle turns dropped without summary")
 
         for i in range(compress_end, n_messages):
-            compressed.append(messages[i].copy())
+            msg = messages[i].copy()
+            if _merge_summary_into_tail and i == compress_end:
+                original = msg.get("content") or ""
+                msg["content"] = summary + "\n\n" + original
+                _merge_summary_into_tail = False
+            compressed.append(msg)
 
         self.compression_count += 1
 

cli.py

@@ -219,7 +219,6 @@ def load_cli_config() -> Dict[str, Any]:
             "streaming": False,
 
             "skin": "default",
-            "theme_mode": "auto",
         },
         "clarify": {
             "timeout": 120,  # Seconds to wait for a clarify answer before auto-proceeding
@@ -3272,7 +3271,7 @@ class HermesCLI:
             print("  To start the gateway:")
             print("    python cli.py --gateway")
             print()
-            print("  Configuration file: ~/.hermes/gateway.json")
+            print("  Configuration file: ~/.hermes/config.yaml")
             print()
             
         except Exception as e:
@@ -3282,7 +3281,7 @@ class HermesCLI:
             print("    1. Set environment variables:")
             print("       TELEGRAM_BOT_TOKEN=your_token")
             print("       DISCORD_BOT_TOKEN=your_token")
-            print("    2. Or create ~/.hermes/gateway.json")
+            print("    2. Or configure settings in ~/.hermes/config.yaml")
             print()
     
     def process_command(self, command: str) -> bool:
@@ -3561,7 +3560,7 @@ class HermesCLI:
         elif canonical == "reload-mcp":
             with self._busy_command(self._slow_command_status(cmd_original)):
                 self._reload_mcp()
-        elif _base_word == "browser":
+        elif canonical == "browser":
             self._handle_browser_command(cmd_original)
         elif canonical == "plugins":
             try:

gateway/config.py

@@ -45,8 +45,8 @@ class Platform(Enum):
     HOMEASSISTANT = "homeassistant"
     EMAIL = "email"
     SMS = "sms"
-    HTTP_SERVER = "http_server"
     DINGTALK = "dingtalk"
+    API_SERVER = "api_server"
 
 
 @dataclass
@@ -239,8 +239,8 @@ class GatewayConfig:
             # SMS uses api_key (Twilio auth token) — SID checked via env
             elif platform == Platform.SMS and os.getenv("TWILIO_ACCOUNT_SID"):
                 connected.append(platform)
-            # HTTP Server uses enabled flag only (no token needed)
-            elif platform == Platform.HTTP_SERVER:
+            # API Server uses enabled flag only (no token needed)
+            elif platform == Platform.API_SERVER:
                 connected.append(platform)
         return connected
     
@@ -350,65 +350,73 @@ class GatewayConfig:
 def load_gateway_config() -> GatewayConfig:
     """
     Load gateway configuration from multiple sources.
-    
+
     Priority (highest to lowest):
     1. Environment variables
-    2. ~/.hermes/gateway.json
-    3. cli-config.yaml gateway section
-    4. Defaults
+    2. ~/.hermes/config.yaml (primary user-facing config)
+    3. ~/.hermes/gateway.json (legacy — provides defaults under config.yaml)
+    4. Built-in defaults
     """
-    config = GatewayConfig()
-    
-    # Try loading from ~/.hermes/gateway.json
     _home = get_hermes_home()
-    gateway_config_path = _home / "gateway.json"
-    if gateway_config_path.exists():
-        try:
-            with open(gateway_config_path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-                config = GatewayConfig.from_dict(data)
-        except Exception as e:
-            print(f"[gateway] Warning: Failed to load {gateway_config_path}: {e}")
+    gw_data: dict = {}
 
-    # Bridge session_reset from config.yaml (the user-facing config file)
-    # into the gateway config. config.yaml takes precedence over gateway.json
-    # for session reset policy since that's where hermes setup writes it.
+    # Legacy fallback: gateway.json provides the base layer.
+    # config.yaml keys always win when both specify the same setting.
+    gateway_json_path = _home / "gateway.json"
+    if gateway_json_path.exists():
+        try:
+            with open(gateway_json_path, "r", encoding="utf-8") as f:
+                gw_data = json.load(f) or {}
+            logger.info(
+                "Loaded legacy %s — consider moving settings to config.yaml",
+                gateway_json_path,
+            )
+        except Exception as e:
+            logger.warning("Failed to load %s: %s", gateway_json_path, e)
+
+    # Primary source: config.yaml
     try:
         import yaml
         config_yaml_path = _home / "config.yaml"
         if config_yaml_path.exists():
             with open(config_yaml_path, encoding="utf-8") as f:
                 yaml_cfg = yaml.safe_load(f) or {}
+
+            # Map config.yaml keys → GatewayConfig.from_dict() schema.
+            # Each key overwrites whatever gateway.json may have set.
             sr = yaml_cfg.get("session_reset")
             if sr and isinstance(sr, dict):
-                config.default_reset_policy = SessionResetPolicy.from_dict(sr)
+                gw_data["default_reset_policy"] = sr
 
-            # Bridge quick commands from config.yaml into gateway runtime config.
-            # config.yaml is the user-facing config source, so when present it
-            # should override gateway.json for this setting.
             qc = yaml_cfg.get("quick_commands")
             if qc is not None:
                 if isinstance(qc, dict):
-                    config.quick_commands = qc
+                    gw_data["quick_commands"] = qc
                 else:
-                    logger.warning("Ignoring invalid quick_commands in config.yaml (expected mapping, got %s)", type(qc).__name__)
+                    logger.warning(
+                        "Ignoring invalid quick_commands in config.yaml "
+                        "(expected mapping, got %s)",
+                        type(qc).__name__,
+                    )
 
-            # Bridge STT enable/disable from config.yaml into gateway runtime.
-            # This keeps the gateway aligned with the user-facing config source.
             stt_cfg = yaml_cfg.get("stt")
-            if isinstance(stt_cfg, dict) and "enabled" in stt_cfg:
-                config.stt_enabled = _coerce_bool(stt_cfg.get("enabled"), True)
+            if isinstance(stt_cfg, dict):
+                gw_data["stt"] = stt_cfg
 
-            # Bridge group session isolation from config.yaml into gateway runtime.
-            # Secure default is per-user isolation in shared chats.
             if "group_sessions_per_user" in yaml_cfg:
-                config.group_sessions_per_user = _coerce_bool(
-                    yaml_cfg.get("group_sessions_per_user"),
-                    True,
-                )
+                gw_data["group_sessions_per_user"] = yaml_cfg["group_sessions_per_user"]
 
-            # Bridge discord settings from config.yaml to env vars
-            # (env vars take precedence — only set if not already defined)
+            streaming_cfg = yaml_cfg.get("streaming")
+            if isinstance(streaming_cfg, dict):
+                gw_data["streaming"] = streaming_cfg
+
+            if "reset_triggers" in yaml_cfg:
+                gw_data["reset_triggers"] = yaml_cfg["reset_triggers"]
+
+            if "always_log_local" in yaml_cfg:
+                gw_data["always_log_local"] = yaml_cfg["always_log_local"]
+
+            # Discord settings → env vars (env vars take precedence)
             discord_cfg = yaml_cfg.get("discord", {})
             if isinstance(discord_cfg, dict):
                 if "require_mention" in discord_cfg and not os.getenv("DISCORD_REQUIRE_MENTION"):
@@ -420,9 +428,18 @@ def load_gateway_config() -> GatewayConfig:
                     os.environ["DISCORD_FREE_RESPONSE_CHANNELS"] = str(frc)
                 if "auto_thread" in discord_cfg and not os.getenv("DISCORD_AUTO_THREAD"):
                     os.environ["DISCORD_AUTO_THREAD"] = str(discord_cfg["auto_thread"]).lower()
+
+            # Bridge whatsapp settings from config.yaml into platform config
+            whatsapp_cfg = yaml_cfg.get("whatsapp", {})
+            if isinstance(whatsapp_cfg, dict) and "reply_prefix" in whatsapp_cfg:
+                if Platform.WHATSAPP not in config.platforms:
+                    config.platforms[Platform.WHATSAPP] = PlatformConfig()
+                config.platforms[Platform.WHATSAPP].extra["reply_prefix"] = whatsapp_cfg["reply_prefix"]
     except Exception:
         pass
 
+    config = GatewayConfig.from_dict(gw_data)
+
     # Override with environment variables
     _apply_env_overrides(config)
     
@@ -638,24 +655,24 @@ def _apply_env_overrides(config: GatewayConfig) -> None:
                 name=os.getenv("SMS_HOME_CHANNEL_NAME", "Home"),
             )
 
-    # HTTP Server
-    http_server_enabled = os.getenv("HTTP_SERVER_ENABLED", "").lower() in ("true", "1", "yes")
-    http_server_key = os.getenv("HTTP_SERVER_KEY", "")
-    http_server_port = os.getenv("HTTP_SERVER_PORT")
-    http_server_host = os.getenv("HTTP_SERVER_HOST")
-    if http_server_enabled or http_server_key:
-        if Platform.HTTP_SERVER not in config.platforms:
-            config.platforms[Platform.HTTP_SERVER] = PlatformConfig()
-        config.platforms[Platform.HTTP_SERVER].enabled = True
-        if http_server_key:
-            config.platforms[Platform.HTTP_SERVER].extra["key"] = http_server_key
-        if http_server_port:
+    # API Server
+    api_server_enabled = os.getenv("API_SERVER_ENABLED", "").lower() in ("true", "1", "yes")
+    api_server_key = os.getenv("API_SERVER_KEY", "")
+    api_server_port = os.getenv("API_SERVER_PORT")
+    api_server_host = os.getenv("API_SERVER_HOST")
+    if api_server_enabled or api_server_key:
+        if Platform.API_SERVER not in config.platforms:
+            config.platforms[Platform.API_SERVER] = PlatformConfig()
+        config.platforms[Platform.API_SERVER].enabled = True
+        if api_server_key:
+            config.platforms[Platform.API_SERVER].extra["key"] = api_server_key
+        if api_server_port:
             try:
-                config.platforms[Platform.HTTP_SERVER].extra["port"] = int(http_server_port)
+                config.platforms[Platform.API_SERVER].extra["port"] = int(api_server_port)
             except ValueError:
                 pass
-        if http_server_host:
-            config.platforms[Platform.HTTP_SERVER].extra["host"] = http_server_host
+        if api_server_host:
+            config.platforms[Platform.API_SERVER].extra["host"] = api_server_host
 
     # Session settings
     idle_minutes = os.getenv("SESSION_IDLE_MINUTES")
@@ -673,10 +690,4 @@ def _apply_env_overrides(config: GatewayConfig) -> None:
             pass
 
 
-def save_gateway_config(config: GatewayConfig) -> None:
-    """Save gateway configuration to ~/.hermes/gateway.json."""
-    gateway_config_path = get_hermes_home() / "gateway.json"
-    gateway_config_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    with open(gateway_config_path, "w", encoding="utf-8") as f:
-        json.dump(config.to_dict(), f, indent=2)
+

gateway/platforms/api_server.py

@@ -1,5 +1,5 @@
 """
-OpenAI-compatible HTTP server platform adapter.
+OpenAI-compatible API server platform adapter.
 
 Exposes an HTTP server with endpoints:
 - POST /v1/chat/completions        — OpenAI Chat Completions format (stateless)
@@ -9,8 +9,9 @@ Exposes an HTTP server with endpoints:
 - GET  /v1/models                  — lists hermes-agent as an available model
 - GET  /health                     — health check
 
-Any OpenAI-compatible frontend (Open WebUI, LobeChat, etc.) can connect
-to hermes-agent through this adapter.
+Any OpenAI-compatible frontend (Open WebUI, LobeChat, LibreChat,
+AnythingLLM, NextChat, ChatBox, etc.) can connect to hermes-agent
+through this adapter by pointing at http://localhost:8642/v1.
 
 Requires:
 - aiohttp (already available in the gateway)
@@ -26,19 +27,15 @@ import uuid
 from typing import Any, Dict, List, Optional
 
 try:
-    import aiohttp
     from aiohttp import web
     AIOHTTP_AVAILABLE = True
 except ImportError:
     AIOHTTP_AVAILABLE = False
-    aiohttp = None  # type: ignore[assignment]
     web = None  # type: ignore[assignment]
 
 from gateway.config import Platform, PlatformConfig
 from gateway.platforms.base import (
     BasePlatformAdapter,
-    MessageEvent,
-    MessageType,
     SendResult,
 )
 
@@ -50,8 +47,8 @@ DEFAULT_PORT = 8642
 MAX_STORED_RESPONSES = 100
 
 
-def check_http_server_requirements() -> bool:
-    """Check if HTTP server dependencies are available."""
+def check_api_server_requirements() -> bool:
+    """Check if API server dependencies are available."""
     return AIOHTTP_AVAILABLE
 
 
@@ -118,25 +115,25 @@ else:
     cors_middleware = None  # type: ignore[assignment]
 
 
-class HTTPServerAdapter(BasePlatformAdapter):
+class APIServerAdapter(BasePlatformAdapter):
     """
-    OpenAI-compatible HTTP HTTP server adapter.
+    OpenAI-compatible HTTP API server adapter.
 
     Runs an aiohttp web server that accepts OpenAI-format requests
-    and routes them through hermes-agent\'s AIAgent.
+    and routes them through hermes-agent's AIAgent.
     """
 
     def __init__(self, config: PlatformConfig):
-        super().__init__(config, Platform.HTTP_SERVER)
+        super().__init__(config, Platform.API_SERVER)
         extra = config.extra or {}
-        self._host: str = extra.get("host", os.getenv("HTTP_SERVER_HOST", DEFAULT_HOST))
-        self._port: int = int(extra.get("port", os.getenv("HTTP_SERVER_PORT", str(DEFAULT_PORT))))
-        self._api_key: str = extra.get("key", os.getenv("HTTP_SERVER_KEY", ""))
+        self._host: str = extra.get("host", os.getenv("API_SERVER_HOST", DEFAULT_HOST))
+        self._port: int = int(extra.get("port", os.getenv("API_SERVER_PORT", str(DEFAULT_PORT))))
+        self._api_key: str = extra.get("key", os.getenv("API_SERVER_KEY", ""))
         self._app: Optional["web.Application"] = None
         self._runner: Optional["web.AppRunner"] = None
         self._site: Optional["web.TCPSite"] = None
         self._response_store = ResponseStore()
-        # Conversation name -> latest response_id mapping
+        # Conversation name → latest response_id mapping
         self._conversations: Dict[str, str] = {}
 
     # ------------------------------------------------------------------
@@ -175,7 +172,7 @@ class HTTPServerAdapter(BasePlatformAdapter):
         stream_delta_callback=None,
     ) -> Any:
         """
-        Create an AIAgent instance using the gateway\'s runtime config.
+        Create an AIAgent instance using the gateway's runtime config.
 
         Uses _resolve_runtime_agent_kwargs() to pick up model, api_key,
         base_url, etc. from config.yaml / env vars.
@@ -196,7 +193,7 @@ class HTTPServerAdapter(BasePlatformAdapter):
             verbose_logging=False,
             ephemeral_system_prompt=ephemeral_system_prompt or None,
             session_id=session_id,
-            platform="http_server",
+            platform="api_server",
             stream_delta_callback=stream_delta_callback,
         )
         return agent
@@ -290,10 +287,10 @@ class HTTPServerAdapter(BasePlatformAdapter):
 
         if stream:
             import queue as _q
-            _stream_q = _q.Queue()
+            _stream_q: _q.Queue = _q.Queue()
 
-            def _on_api_token(delta):
-                _stream_q.put(delta)  # None = done
+            def _on_delta(delta):
+                _stream_q.put(delta)
 
             # Start agent in background
             agent_task = asyncio.ensure_future(self._run_agent(
@@ -301,10 +298,10 @@ class HTTPServerAdapter(BasePlatformAdapter):
                 conversation_history=history,
                 ephemeral_system_prompt=system_prompt,
                 session_id=session_id,
-                stream_delta_callback=_on_api_token,
+                stream_delta_callback=_on_delta,
             ))
 
-            return await self._write_real_sse_chat_completion(
+            return await self._write_sse_chat_completion(
                 request, completion_id, model_name, created, _stream_q, agent_task
             )
 
@@ -351,11 +348,11 @@ class HTTPServerAdapter(BasePlatformAdapter):
 
         return web.json_response(response_data)
 
-    async def _write_real_sse_chat_completion(
+    async def _write_sse_chat_completion(
         self, request: "web.Request", completion_id: str, model: str,
         created: int, stream_q, agent_task,
     ) -> "web.StreamResponse":
-        """Write real streaming SSE from agent\'s stream_delta_callback queue."""
+        """Write real streaming SSE from agent's stream_delta_callback queue."""
         import queue as _q
 
         response = web.StreamResponse(
@@ -379,10 +376,24 @@ class HTTPServerAdapter(BasePlatformAdapter):
                 delta = await loop.run_in_executor(None, lambda: stream_q.get(timeout=0.5))
             except _q.Empty:
                 if agent_task.done():
+                    # Drain any remaining items
+                    while True:
+                        try:
+                            delta = stream_q.get_nowait()
+                            if delta is None:
+                                break
+                            content_chunk = {
+                                "id": completion_id, "object": "chat.completion.chunk",
+                                "created": created, "model": model,
+                                "choices": [{"index": 0, "delta": {"content": delta}, "finish_reason": None}],
+                            }
+                            await response.write(f"data: {json.dumps(content_chunk)}\n\n".encode())
+                        except _q.Empty:
+                            break
                     break
                 continue
 
-            if delta is None:  # End of stream
+            if delta is None:  # End of stream sentinel
                 break
 
             content_chunk = {
@@ -626,12 +637,12 @@ class HTTPServerAdapter(BasePlatformAdapter):
     @staticmethod
     def _extract_output_items(result: Dict[str, Any]) -> List[Dict[str, Any]]:
         """
-        Build the full output item array from the agent\'s messages.
+        Build the full output item array from the agent's messages.
 
         Walks *result["messages"]* and emits:
         - ``function_call`` items for each tool_call on assistant messages
         - ``function_call_output`` items for each tool-role message
-        - a final ``message`` item with the assistant\'s text reply
+        - a final ``message`` item with the assistant's text reply
         """
         items: List[Dict[str, Any]] = []
         messages = result.get("messages", [])
@@ -734,20 +745,20 @@ class HTTPServerAdapter(BasePlatformAdapter):
             self._site = web.TCPSite(self._runner, self._host, self._port)
             await self._site.start()
 
-            self._running = True
+            self._mark_connected()
             logger.info(
-                "[%s] HTTP server listening on http://%s:%d",
+                "[%s] API server listening on http://%s:%d",
                 self.name, self._host, self._port,
             )
             return True
 
         except Exception as e:
-            logger.error("[%s] Failed to start HTTP server: %s", self.name, e)
+            logger.error("[%s] Failed to start API server: %s", self.name, e)
             return False
 
     async def disconnect(self) -> None:
         """Stop the aiohttp web server."""
-        self._running = False
+        self._mark_disconnected()
         if self._site:
             await self._site.stop()
             self._site = None
@@ -755,7 +766,7 @@ class HTTPServerAdapter(BasePlatformAdapter):
             await self._runner.cleanup()
             self._runner = None
         self._app = None
-        logger.info("[%s] HTTP server stopped", self.name)
+        logger.info("[%s] API server stopped", self.name)
 
     async def send(
         self,
@@ -767,12 +778,12 @@ class HTTPServerAdapter(BasePlatformAdapter):
         """
         Not used — HTTP request/response cycle handles delivery directly.
         """
-        return SendResult(success=False, error="HTTP server uses HTTP request/response, not send()")
+        return SendResult(success=False, error="API server uses HTTP request/response, not send()")
 
     async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
-        """Return basic info about the HTTP server."""
+        """Return basic info about the API server."""
         return {
-            "name": "HTTP Server",
+            "name": "API Server",
             "type": "api",
             "host": self._host,
             "port": self._port,

gateway/platforms/telegram.py

@@ -414,7 +414,10 @@ class TelegramAdapter(BasePlatformAdapter):
                     text=formatted,
                     parse_mode=ParseMode.MARKDOWN_V2,
                 )
-            except Exception:
+            except Exception as fmt_err:
+                # "Message is not modified" is a no-op, not an error
+                if "not modified" in str(fmt_err).lower():
+                    return SendResult(success=True, message_id=message_id)
                 # Fallback: retry without markdown formatting
                 await self._bot.edit_message_text(
                     chat_id=int(chat_id),
@@ -423,6 +426,46 @@ class TelegramAdapter(BasePlatformAdapter):
                 )
             return SendResult(success=True, message_id=message_id)
         except Exception as e:
+            err_str = str(e).lower()
+            # "Message is not modified" — content identical, treat as success
+            if "not modified" in err_str:
+                return SendResult(success=True, message_id=message_id)
+            # Message too long — content exceeded 4096 chars (e.g. during
+            # streaming).  Truncate and succeed so the stream consumer can
+            # split the overflow into a new message instead of dying.
+            if "message_too_long" in err_str or "too long" in err_str:
+                truncated = content[: self.MAX_MESSAGE_LENGTH - 20] + "…"
+                try:
+                    await self._bot.edit_message_text(
+                        chat_id=int(chat_id),
+                        message_id=int(message_id),
+                        text=truncated,
+                    )
+                except Exception:
+                    pass  # best-effort truncation
+                return SendResult(success=True, message_id=message_id)
+            # Flood control / RetryAfter — back off and retry once
+            retry_after = getattr(e, "retry_after", None)
+            if retry_after is not None or "retry after" in err_str:
+                wait = retry_after if retry_after else 1.0
+                logger.warning(
+                    "[%s] Telegram flood control, waiting %.1fs",
+                    self.name, wait,
+                )
+                await asyncio.sleep(wait)
+                try:
+                    await self._bot.edit_message_text(
+                        chat_id=int(chat_id),
+                        message_id=int(message_id),
+                        text=content,
+                    )
+                    return SendResult(success=True, message_id=message_id)
+                except Exception as retry_err:
+                    logger.error(
+                        "[%s] Edit retry failed after flood wait: %s",
+                        self.name, retry_err,
+                    )
+                    return SendResult(success=False, error=str(retry_err))
             logger.error(
                 "[%s] Failed to edit Telegram message %s: %s",
                 self.name,

gateway/platforms/whatsapp.py

@@ -136,6 +136,7 @@ class WhatsAppAdapter(BasePlatformAdapter):
             "session_path",
             get_hermes_home() / "whatsapp" / "session"
         ))
+        self._reply_prefix: Optional[str] = config.extra.get("reply_prefix")
         self._message_queue: asyncio.Queue = asyncio.Queue()
         self._bridge_log_fh = None
         self._bridge_log: Optional[Path] = None
@@ -193,6 +194,14 @@ class WhatsAppAdapter(BasePlatformAdapter):
             self._bridge_log = self._session_path.parent / "bridge.log"
             bridge_log_fh = open(self._bridge_log, "a")
             self._bridge_log_fh = bridge_log_fh
+
+            # Build bridge subprocess environment.
+            # Pass WHATSAPP_REPLY_PREFIX from config.yaml so the Node bridge
+            # can use it without the user needing to set a separate env var.
+            bridge_env = os.environ.copy()
+            if self._reply_prefix is not None:
+                bridge_env["WHATSAPP_REPLY_PREFIX"] = self._reply_prefix
+
             self._bridge_process = subprocess.Popen(
                 [
                     "node",
@@ -204,6 +213,7 @@ class WhatsAppAdapter(BasePlatformAdapter):
                 stdout=bridge_log_fh,
                 stderr=bridge_log_fh,
                 preexec_fn=None if _IS_WINDOWS else os.setsid,
+                env=bridge_env,
             )
             
             # Wait for the bridge to connect to WhatsApp.

gateway/run.py

@@ -1162,12 +1162,12 @@ class GatewayRunner:
                 return None
             return MatrixAdapter(config)
 
-        elif platform == Platform.HTTP_SERVER:
-            from gateway.platforms.http_server import HTTPServerAdapter, check_http_server_requirements
-            if not check_http_server_requirements():
-                logger.warning("HTTP Server: aiohttp not installed")
+        elif platform == Platform.API_SERVER:
+            from gateway.platforms.api_server import APIServerAdapter, check_api_server_requirements
+            if not check_api_server_requirements():
+                logger.warning("API Server: aiohttp not installed")
                 return None
-            return HTTPServerAdapter(config)
+            return APIServerAdapter(config)
 
         return None
     

gateway/session.py

@@ -944,7 +944,13 @@ class SessionStore:
             for line in f:
                 line = line.strip()
                 if line:
-                    messages.append(json.loads(line))
+                    try:
+                        messages.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        logger.warning(
+                            "Skipping corrupt line in transcript %s: %s",
+                            session_id, line[:120],
+                        )
         
         return messages
 

gateway/stream_consumer.py

@@ -68,6 +68,7 @@ class GatewayStreamConsumer:
         self._already_sent = False
         self._edit_supported = True  # Disabled on first edit failure (Signal/Email/HA)
         self._last_edit_time = 0.0
+        self._last_sent_text = ""   # Track last-sent text to skip redundant edits
 
     @property
     def already_sent(self) -> bool:
@@ -86,6 +87,10 @@ class GatewayStreamConsumer:
 
     async def run(self) -> None:
         """Async task that drains the queue and edits the platform message."""
+        # Platform message length limit — leave room for cursor + formatting
+        _raw_limit = getattr(self.adapter, "MAX_MESSAGE_LENGTH", 4096)
+        _safe_limit = max(500, _raw_limit - len(self.cfg.cursor) - 100)
+
         try:
             while True:
                 # Drain all available items from the queue
@@ -111,6 +116,21 @@ class GatewayStreamConsumer:
                 )
 
                 if should_edit and self._accumulated:
+                    # Split overflow: if accumulated text exceeds the platform
+                    # limit, finalize the current message and start a new one.
+                    while (
+                        len(self._accumulated) > _safe_limit
+                        and self._message_id is not None
+                    ):
+                        split_at = self._accumulated.rfind("\n", 0, _safe_limit)
+                        if split_at < _safe_limit // 2:
+                            split_at = _safe_limit
+                        chunk = self._accumulated[:split_at]
+                        await self._send_or_edit(chunk)
+                        self._accumulated = self._accumulated[split_at:].lstrip("\n")
+                        self._message_id = None
+                        self._last_sent_text = ""
+
                     display_text = self._accumulated
                     if not got_done:
                         display_text += self.cfg.cursor
@@ -141,6 +161,9 @@ class GatewayStreamConsumer:
         try:
             if self._message_id is not None:
                 if self._edit_supported:
+                    # Skip if text is identical to what we last sent
+                    if text == self._last_sent_text:
+                        return
                     # Edit existing message
                     result = await self.adapter.edit_message(
                         chat_id=self.chat_id,
@@ -149,6 +172,7 @@ class GatewayStreamConsumer:
                     )
                     if result.success:
                         self._already_sent = True
+                        self._last_sent_text = text
                     else:
                         # Edit not supported by this adapter — stop streaming,
                         # let the normal send path handle the final response.
@@ -170,6 +194,7 @@ class GatewayStreamConsumer:
                 if result.success and result.message_id:
                     self._message_id = result.message_id
                     self._already_sent = True
+                    self._last_sent_text = text
                 else:
                     # Initial send failed — disable streaming for this session
                     self._edit_supported = False

hermes_cli/colors.py

@@ -1,6 +1,5 @@
 """Shared ANSI color utilities for Hermes CLI modules."""
 
-import os
 import sys
 
 
@@ -21,123 +20,3 @@ def color(text: str, *codes) -> str:
     if not sys.stdout.isatty():
         return text
     return "".join(codes) + text + Colors.RESET
-
-
-# =============================================================================
-# Terminal background detection (light vs dark)
-# =============================================================================
-
-
-def _detect_via_colorfgbg() -> str:
-    """Check the COLORFGBG environment variable.
-
-    Some terminals (rxvt, xterm, iTerm2) set COLORFGBG to ``<fg>;<bg>``
-    where bg >= 8 usually means a dark background.
-    Returns "light", "dark", or "unknown".
-    """
-    val = os.environ.get("COLORFGBG", "")
-    if not val:
-        return "unknown"
-    parts = val.split(";")
-    try:
-        bg = int(parts[-1])
-    except (ValueError, IndexError):
-        return "unknown"
-    # Standard terminal colors 0-6 are dark, 7+ are light.
-    # bg < 7 → dark background; bg >= 7 → light background.
-    if bg >= 7:
-        return "light"
-    return "dark"
-
-
-def _detect_via_macos_appearance() -> str:
-    """Check macOS AppleInterfaceStyle via ``defaults read``.
-
-    Returns "light", "dark", or "unknown".
-    """
-    if sys.platform != "darwin":
-        return "unknown"
-    try:
-        import subprocess
-        result = subprocess.run(
-            ["defaults", "read", "-g", "AppleInterfaceStyle"],
-            capture_output=True, text=True, timeout=2,
-        )
-        if result.returncode == 0 and "dark" in result.stdout.lower():
-            return "dark"
-        # If the key doesn't exist, macOS is in light mode.
-        return "light"
-    except Exception:
-        return "unknown"
-
-
-def _detect_via_osc11() -> str:
-    """Query the terminal background colour via the OSC 11 escape sequence.
-
-    Writes ``\\e]11;?\\a`` and reads the response to determine luminance.
-    Only works when stdin/stdout are connected to a real TTY (not piped).
-    Returns "light", "dark", or "unknown".
-    """
-    if sys.platform == "win32":
-        return "unknown"
-    if not (sys.stdin.isatty() and sys.stdout.isatty()):
-        return "unknown"
-    try:
-        import select
-        import termios
-        import tty
-
-        fd = sys.stdin.fileno()
-        old_attrs = termios.tcgetattr(fd)
-        try:
-            tty.setraw(fd)
-            # Send OSC 11 query
-            sys.stdout.write("\x1b]11;?\x07")
-            sys.stdout.flush()
-            # Wait briefly for response
-            if not select.select([fd], [], [], 0.1)[0]:
-                return "unknown"
-            response = b""
-            while select.select([fd], [], [], 0.05)[0]:
-                response += os.read(fd, 128)
-        finally:
-            termios.tcsetattr(fd, termios.TCSADRAIN, old_attrs)
-
-        # Parse response: \x1b]11;rgb:RRRR/GGGG/BBBB\x07  (or \x1b\\)
-        text = response.decode("latin-1", errors="replace")
-        if "rgb:" not in text:
-            return "unknown"
-        rgb_part = text.split("rgb:")[-1].split("\x07")[0].split("\x1b")[0]
-        channels = rgb_part.split("/")
-        if len(channels) < 3:
-            return "unknown"
-        # Each channel is 2 or 4 hex digits; normalise to 0-255
-        vals = []
-        for ch in channels[:3]:
-            ch = ch.strip()
-            if len(ch) <= 2:
-                vals.append(int(ch, 16))
-            else:
-                vals.append(int(ch[:2], 16))  # take high byte
-        # Perceived luminance (ITU-R BT.601)
-        luminance = 0.299 * vals[0] + 0.587 * vals[1] + 0.114 * vals[2]
-        return "light" if luminance > 128 else "dark"
-    except Exception:
-        return "unknown"
-
-
-def detect_terminal_background() -> str:
-    """Detect whether the terminal has a light or dark background.
-
-    Tries three strategies in order:
-    1. COLORFGBG environment variable
-    2. macOS appearance setting
-    3. OSC 11 escape sequence query
-
-    Returns "light", "dark", or "unknown" if detection fails.
-    """
-    for detector in (_detect_via_colorfgbg, _detect_via_macos_appearance, _detect_via_osc11):
-        result = detector()
-        if result != "unknown":
-            return result
-    return "unknown"

hermes_cli/commands.py

@@ -104,6 +104,9 @@ COMMAND_REGISTRY: list[CommandDef] = [
                subcommands=("list", "add", "create", "edit", "pause", "resume", "run", "remove")),
     CommandDef("reload-mcp", "Reload MCP servers from config", "Tools & Skills",
                aliases=("reload_mcp",)),
+    CommandDef("browser", "Connect browser tools to your live Chrome via CDP", "Tools & Skills",
+               cli_only=True, args_hint="[connect|disconnect|status]",
+               subcommands=("connect", "disconnect", "status")),
     CommandDef("plugins", "List installed plugins and their status",
                "Tools & Skills", cli_only=True),
 

hermes_cli/config.py

@@ -236,7 +236,6 @@ DEFAULT_CONFIG = {
         "streaming": False,
         "show_cost": False,       # Show $ cost in the status bar (off by default)
         "skin": "default",
-        "theme_mode": "auto",
     },
 
     # Privacy settings
@@ -333,6 +332,14 @@ DEFAULT_CONFIG = {
         "auto_thread": True,           # Auto-create threads on @mention in channels (like Slack)
     },
 
+    # WhatsApp platform settings (gateway mode)
+    "whatsapp": {
+        # Reply prefix prepended to every outgoing WhatsApp message.
+        # Default (None) uses the built-in "⚕ *Hermes Agent*" header.
+        # Set to "" (empty string) to disable the header entirely.
+        # Supports \n for newlines, e.g. "🤖 *My Bot*\n──────\n"
+    },
+
     # Approval mode for dangerous commands:
     #   manual — always prompt the user (default)
     #   smart  — use auxiliary LLM to auto-approve low-risk commands, prompt for high-risk
@@ -365,7 +372,7 @@ DEFAULT_CONFIG = {
     },
 
     # Config schema version - bump this when adding new required fields
-    "_config_version": 9,
+    "_config_version": 10,
 }
 
 # =============================================================================
@@ -768,33 +775,33 @@ OPTIONAL_ENV_VARS = {
         "category": "messaging",
         "advanced": True,
     },
-
-    # ── HTTP Server ──
-    "HTTP_SERVER_ENABLED": {
-        "description": "Enable the OpenAI-compatible HTTP server in the gateway (true/false)",
-        "prompt": "Enable HTTP server (true/false)",
-        "url": None,
-        "password": False,
-        "category": "messaging",
-    },
-    "HTTP_SERVER_KEY": {
-        "description": "Bearer token for HTTP server authentication. Leave empty for local-only use.",
-        "prompt": "HTTP server auth key",
-        "url": None,
-        "password": True,
-        "category": "messaging",
-    },
-    "HTTP_SERVER_PORT": {
-        "description": "HTTP server port (default: 8642)",
-        "prompt": "HTTP server port",
+    "API_SERVER_ENABLED": {
+        "description": "Enable the OpenAI-compatible API server (true/false). Allows frontends like Open WebUI, LobeChat, etc. to connect.",
+        "prompt": "Enable API server (true/false)",
         "url": None,
         "password": False,
         "category": "messaging",
         "advanced": True,
     },
-    "HTTP_SERVER_HOST": {
-        "description": "HTTP server bind address (default: 127.0.0.1). Use 0.0.0.0 for network access.",
-        "prompt": "HTTP server host",
+    "API_SERVER_KEY": {
+        "description": "Bearer token for API server authentication. If empty, all requests are allowed (local use only).",
+        "prompt": "API server auth key (optional)",
+        "url": None,
+        "password": True,
+        "category": "messaging",
+        "advanced": True,
+    },
+    "API_SERVER_PORT": {
+        "description": "Port for the API server (default: 8642).",
+        "prompt": "API server port",
+        "url": None,
+        "password": False,
+        "category": "messaging",
+        "advanced": True,
+    },
+    "API_SERVER_HOST": {
+        "description": "Host/bind address for the API server (default: 127.0.0.1). Use 0.0.0.0 for network access — requires API_SERVER_KEY for security.",
+        "prompt": "API server host",
         "url": None,
         "password": False,
         "category": "messaging",

hermes_cli/gateway.py

@@ -6,6 +6,7 @@ Handles: hermes gateway [run|start|stop|restart|status|install|uninstall|setup]
 
 import asyncio
 import os
+import shutil
 import signal
 import subprocess
 import sys
@@ -401,8 +402,14 @@ def generate_systemd_unit(system: bool = False, run_as_user: str | None = None)
     venv_bin = str(PROJECT_ROOT / "venv" / "bin")
     node_bin = str(PROJECT_ROOT / "node_modules" / ".bin")
 
-    # Build a PATH that includes the venv, node_modules, and standard system dirs
-    sane_path = f"{venv_bin}:{node_bin}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+    path_entries = [venv_bin, node_bin]
+    resolved_node = shutil.which("node")
+    if resolved_node:
+        resolved_node_dir = str(Path(resolved_node).resolve().parent)
+        if resolved_node_dir not in path_entries:
+            path_entries.append(resolved_node_dir)
+    path_entries.extend(["/usr/local/sbin", "/usr/local/bin", "/usr/sbin", "/usr/bin", "/sbin", "/bin"])
+    sane_path = ":".join(path_entries)
 
     hermes_home = str(Path(os.getenv("HERMES_HOME", Path.home() / ".hermes")).resolve())
 

hermes_cli/setup.py

@@ -1360,12 +1360,12 @@ def setup_model_provider(config: dict):
         if existing_key:
             print_info(f"Current: {existing_key[:8]}... (configured)")
             if prompt_yes_no("Update API key?", False):
-                api_key = prompt_text("OpenCode Zen API key", password=True)
+                api_key = prompt("  OpenCode Zen API key", password=True)
                 if api_key:
                     save_env_value("OPENCODE_ZEN_API_KEY", api_key)
                     print_success("OpenCode Zen API key updated")
         else:
-            api_key = prompt_text("OpenCode Zen API key", password=True)
+            api_key = prompt("  OpenCode Zen API key", password=True)
             if api_key:
                 save_env_value("OPENCODE_ZEN_API_KEY", api_key)
                 print_success("OpenCode Zen API key saved")
@@ -1393,12 +1393,12 @@ def setup_model_provider(config: dict):
         if existing_key:
             print_info(f"Current: {existing_key[:8]}... (configured)")
             if prompt_yes_no("Update API key?", False):
-                api_key = prompt_text("OpenCode Go API key", password=True)
+                api_key = prompt("  OpenCode Go API key", password=True)
                 if api_key:
                     save_env_value("OPENCODE_GO_API_KEY", api_key)
                     print_success("OpenCode Go API key updated")
         else:
-            api_key = prompt_text("OpenCode Go API key", password=True)
+            api_key = prompt("  OpenCode Go API key", password=True)
             if api_key:
                 save_env_value("OPENCODE_GO_API_KEY", api_key)
                 print_success("OpenCode Go API key saved")

hermes_cli/skin_engine.py

@@ -114,7 +114,6 @@ class SkinConfig:
     name: str
     description: str = ""
     colors: Dict[str, str] = field(default_factory=dict)
-    colors_light: Dict[str, str] = field(default_factory=dict)
     spinner: Dict[str, Any] = field(default_factory=dict)
     branding: Dict[str, str] = field(default_factory=dict)
     tool_prefix: str = "┊"
@@ -123,12 +122,7 @@ class SkinConfig:
     banner_hero: str = ""    # Rich-markup hero art (replaces HERMES_CADUCEUS)
 
     def get_color(self, key: str, fallback: str = "") -> str:
-        """Get a color value with fallback.
-
-        In light theme mode, returns the light override if available.
-        """
-        if get_theme_mode() == "light" and key in self.colors_light:
-            return self.colors_light[key]
+        """Get a color value with fallback."""
         return self.colors.get(key, fallback)
 
     def get_spinner_list(self, key: str) -> List[str]:
@@ -174,21 +168,6 @@ _BUILTIN_SKINS: Dict[str, Dict[str, Any]] = {
             "session_label": "#DAA520",
             "session_border": "#8B8682",
         },
-        "colors_light": {
-            "banner_border": "#7A5A00",
-            "banner_title": "#6B4C00",
-            "banner_accent": "#7A5500",
-            "banner_dim": "#8B7355",
-            "banner_text": "#3D2B00",
-            "prompt": "#3D2B00",
-            "ui_accent": "#7A5500",
-            "ui_label": "#01579B",
-            "ui_ok": "#1B5E20",
-            "input_rule": "#7A5A00",
-            "response_border": "#6B4C00",
-            "session_label": "#5C4300",
-            "session_border": "#8B7355",
-        },
         "spinner": {
             # Empty = use hardcoded defaults in display.py
         },
@@ -222,21 +201,6 @@ _BUILTIN_SKINS: Dict[str, Dict[str, Any]] = {
             "session_label": "#C7A96B",
             "session_border": "#6E584B",
         },
-        "colors_light": {
-            "banner_border": "#6B1010",
-            "banner_title": "#5C4300",
-            "banner_accent": "#8B1A1A",
-            "banner_dim": "#5C4030",
-            "banner_text": "#3A1800",
-            "prompt": "#3A1800",
-            "ui_accent": "#8B1A1A",
-            "ui_label": "#5C4300",
-            "ui_ok": "#1B5E20",
-            "input_rule": "#6B1010",
-            "response_border": "#7A1515",
-            "session_label": "#5C4300",
-            "session_border": "#5C4A3A",
-        },
         "spinner": {
             "waiting_faces": ["(⚔)", "(⛨)", "(▲)", "(<>)", "(/)"],
             "thinking_faces": ["(⚔)", "(⛨)", "(▲)", "(⌁)", "(<>)"],
@@ -301,22 +265,6 @@ _BUILTIN_SKINS: Dict[str, Dict[str, Any]] = {
             "session_label": "#888888",
             "session_border": "#555555",
         },
-        "colors_light": {
-            "banner_border": "#333333",
-            "banner_title": "#222222",
-            "banner_accent": "#333333",
-            "banner_dim": "#555555",
-            "banner_text": "#333333",
-            "prompt": "#222222",
-            "ui_accent": "#333333",
-            "ui_label": "#444444",
-            "ui_ok": "#444444",
-            "ui_error": "#333333",
-            "input_rule": "#333333",
-            "response_border": "#444444",
-            "session_label": "#444444",
-            "session_border": "#666666",
-        },
         "spinner": {},
         "branding": {
             "agent_name": "Hermes Agent",
@@ -348,21 +296,6 @@ _BUILTIN_SKINS: Dict[str, Dict[str, Any]] = {
             "session_label": "#7eb8f6",
             "session_border": "#4b5563",
         },
-        "colors_light": {
-            "banner_border": "#1A3A7A",
-            "banner_title": "#1A3570",
-            "banner_accent": "#1E4090",
-            "banner_dim": "#3B4555",
-            "banner_text": "#1A2A50",
-            "prompt": "#1A2A50",
-            "ui_accent": "#1A3570",
-            "ui_label": "#1E3A80",
-            "ui_ok": "#1B5E20",
-            "input_rule": "#1A3A7A",
-            "response_border": "#2A4FA0",
-            "session_label": "#1A3570",
-            "session_border": "#5A6070",
-        },
         "spinner": {},
         "branding": {
             "agent_name": "Hermes Agent",
@@ -394,21 +327,6 @@ _BUILTIN_SKINS: Dict[str, Dict[str, Any]] = {
             "session_label": "#A9DFFF",
             "session_border": "#496884",
         },
-        "colors_light": {
-            "banner_border": "#0D3060",
-            "banner_title": "#0D3060",
-            "banner_accent": "#154080",
-            "banner_dim": "#2A4565",
-            "banner_text": "#0A2850",
-            "prompt": "#0A2850",
-            "ui_accent": "#0D3060",
-            "ui_label": "#0D3060",
-            "ui_ok": "#1B5E20",
-            "input_rule": "#0D3060",
-            "response_border": "#1A5090",
-            "session_label": "#0D3060",
-            "session_border": "#3A5575",
-        },
         "spinner": {
             "waiting_faces": ["(≈)", "(Ψ)", "(∿)", "(◌)", "(◠)"],
             "thinking_faces": ["(Ψ)", "(∿)", "(≈)", "(⌁)", "(◌)"],
@@ -473,23 +391,6 @@ _BUILTIN_SKINS: Dict[str, Dict[str, Any]] = {
             "session_label": "#919191",
             "session_border": "#656565",
         },
-        "colors_light": {
-            "banner_border": "#666666",
-            "banner_title": "#222222",
-            "banner_accent": "#333333",
-            "banner_dim": "#555555",
-            "banner_text": "#333333",
-            "prompt": "#222222",
-            "ui_accent": "#333333",
-            "ui_label": "#444444",
-            "ui_ok": "#444444",
-            "ui_error": "#333333",
-            "ui_warn": "#444444",
-            "input_rule": "#666666",
-            "response_border": "#555555",
-            "session_label": "#444444",
-            "session_border": "#777777",
-        },
         "spinner": {
             "waiting_faces": ["(◉)", "(◌)", "(◬)", "(⬤)", "(::)"],
             "thinking_faces": ["(◉)", "(◬)", "(◌)", "(○)", "(●)"],
@@ -555,21 +456,6 @@ _BUILTIN_SKINS: Dict[str, Dict[str, Any]] = {
             "session_label": "#FFD39A",
             "session_border": "#6C4724",
         },
-        "colors_light": {
-            "banner_border": "#7A3511",
-            "banner_title": "#5C2D00",
-            "banner_accent": "#8B4000",
-            "banner_dim": "#5A3A1A",
-            "banner_text": "#3A1E00",
-            "prompt": "#3A1E00",
-            "ui_accent": "#8B4000",
-            "ui_label": "#5C2D00",
-            "ui_ok": "#1B5E20",
-            "input_rule": "#7A3511",
-            "response_border": "#8B4513",
-            "session_label": "#5C2D00",
-            "session_border": "#6B5540",
-        },
         "spinner": {
             "waiting_faces": ["(✦)", "(▲)", "(◇)", "(<>)", "(🔥)"],
             "thinking_faces": ["(✦)", "(▲)", "(◇)", "(⌁)", "(🔥)"],
@@ -623,8 +509,6 @@ _BUILTIN_SKINS: Dict[str, Dict[str, Any]] = {
 
 _active_skin: Optional[SkinConfig] = None
 _active_skin_name: str = "default"
-_theme_mode: str = "auto"
-_resolved_theme_mode: Optional[str] = None
 
 
 def _skins_dir() -> Path:
@@ -652,8 +536,6 @@ def _build_skin_config(data: Dict[str, Any]) -> SkinConfig:
     default = _BUILTIN_SKINS["default"]
     colors = dict(default.get("colors", {}))
     colors.update(data.get("colors", {}))
-    colors_light = dict(default.get("colors_light", {}))
-    colors_light.update(data.get("colors_light", {}))
     spinner = dict(default.get("spinner", {}))
     spinner.update(data.get("spinner", {}))
     branding = dict(default.get("branding", {}))
@@ -663,7 +545,6 @@ def _build_skin_config(data: Dict[str, Any]) -> SkinConfig:
         name=data.get("name", "unknown"),
         description=data.get("description", ""),
         colors=colors,
-        colors_light=colors_light,
         spinner=spinner,
         branding=branding,
         tool_prefix=data.get("tool_prefix", default.get("tool_prefix", "┊")),
@@ -744,39 +625,6 @@ def get_active_skin_name() -> str:
     return _active_skin_name
 
 
-def get_theme_mode() -> str:
-    """Return the resolved theme mode: "light" or "dark".
-
-    When ``_theme_mode`` is ``"auto"``, detection is attempted once and cached.
-    If detection returns ``"unknown"``, defaults to ``"dark"``.
-    """
-    global _resolved_theme_mode
-    if _theme_mode in ("light", "dark"):
-        return _theme_mode
-    # Auto mode — detect and cache
-    if _resolved_theme_mode is None:
-        try:
-            from hermes_cli.colors import detect_terminal_background
-            detected = detect_terminal_background()
-        except Exception:
-            detected = "unknown"
-        _resolved_theme_mode = detected if detected in ("light", "dark") else "dark"
-    return _resolved_theme_mode
-
-
-def set_theme_mode(mode: str) -> None:
-    """Set the theme mode to "light", "dark", or "auto"."""
-    global _theme_mode, _resolved_theme_mode
-    _theme_mode = mode
-    # Reset cached detection so it re-runs on next get_theme_mode() if auto
-    _resolved_theme_mode = None
-
-
-def get_theme_mode_setting() -> str:
-    """Return the raw theme mode setting (may be "auto", "light", or "dark")."""
-    return _theme_mode
-
-
 def init_skin_from_config(config: dict) -> None:
     """Initialize the active skin from CLI config at startup.
 
@@ -789,13 +637,6 @@ def init_skin_from_config(config: dict) -> None:
     else:
         set_active_skin("default")
 
-    # Theme mode
-    theme_mode = display.get("theme_mode", "auto")
-    if isinstance(theme_mode, str) and theme_mode.strip():
-        set_theme_mode(theme_mode.strip())
-    else:
-        set_theme_mode("auto")
-
 
 # =============================================================================
 # Convenience helpers for CLI modules
@@ -849,14 +690,6 @@ def get_prompt_toolkit_style_overrides() -> Dict[str, str]:
     warn = skin.get_color("ui_warn", "#FF8C00")
     error = skin.get_color("ui_error", "#FF6B6B")
 
-    # Use lighter background colours for completion menus in light mode
-    if get_theme_mode() == "light":
-        menu_bg = "bg:#e8e8e8"
-        menu_sel_bg = "bg:#d0d0d0"
-    else:
-        menu_bg = "bg:#1a1a2e"
-        menu_sel_bg = "bg:#333355"
-
     return {
         "input-area": prompt,
         "placeholder": f"{dim} italic",
@@ -865,11 +698,11 @@ def get_prompt_toolkit_style_overrides() -> Dict[str, str]:
         "hint": f"{dim} italic",
         "input-rule": input_rule,
         "image-badge": f"{label} bold",
-        "completion-menu": f"{menu_bg} {text}",
-        "completion-menu.completion": f"{menu_bg} {text}",
-        "completion-menu.completion.current": f"{menu_sel_bg} {title}",
-        "completion-menu.meta.completion": f"{menu_bg} {dim}",
-        "completion-menu.meta.completion.current": f"{menu_sel_bg} {label}",
+        "completion-menu": f"bg:#1a1a2e {text}",
+        "completion-menu.completion": f"bg:#1a1a2e {text}",
+        "completion-menu.completion.current": f"bg:#333355 {title}",
+        "completion-menu.meta.completion": f"bg:#1a1a2e {dim}",
+        "completion-menu.meta.completion.current": f"bg:#333355 {label}",
         "clarify-border": input_rule,
         "clarify-title": f"{title} bold",
         "clarify-question": f"{text} bold",

hermes_state.py

@@ -689,21 +689,45 @@ class SessionDB:
         ``NOT``) have special meaning.  Passing raw user input directly to
         MATCH can cause ``sqlite3.OperationalError``.
 
-        Strategy: strip characters that are only meaningful as FTS5 operators
-        and would otherwise cause syntax errors.  This preserves normal keyword
-        search while preventing crashes on inputs like ``C++``, ``"unterminated``,
-        or ``hello AND``.
+        Strategy:
+        - Preserve properly paired quoted phrases (``"exact phrase"``)
+        - Strip unmatched FTS5-special characters that would cause errors
+        - Wrap unquoted hyphenated terms in quotes so FTS5 matches them
+          as exact phrases instead of splitting on the hyphen
         """
-        # Remove FTS5-special characters that are not useful in keyword search
-        sanitized = re.sub(r'[+{}()"^]', " ", query)
-        # Collapse repeated * (e.g. "***") into a single one, and remove
-        # leading * (prefix-only matching requires at least one char before *)
+        # Step 1: Extract balanced double-quoted phrases and protect them
+        # from further processing via numbered placeholders.
+        _quoted_parts: list = []
+
+        def _preserve_quoted(m: re.Match) -> str:
+            _quoted_parts.append(m.group(0))
+            return f"\x00Q{len(_quoted_parts) - 1}\x00"
+
+        sanitized = re.sub(r'"[^"]*"', _preserve_quoted, query)
+
+        # Step 2: Strip remaining (unmatched) FTS5-special characters
+        sanitized = re.sub(r'[+{}()\"^]', " ", sanitized)
+
+        # Step 3: Collapse repeated * (e.g. "***") into a single one,
+        # and remove leading * (prefix-only needs at least one char before *)
         sanitized = re.sub(r"\*+", "*", sanitized)
         sanitized = re.sub(r"(^|\s)\*", r"\1", sanitized)
-        # Remove dangling boolean operators at start/end that would cause
-        # syntax errors (e.g. "hello AND" or "OR world")
+
+        # Step 4: Remove dangling boolean operators at start/end that would
+        # cause syntax errors (e.g. "hello AND" or "OR world")
         sanitized = re.sub(r"(?i)^(AND|OR|NOT)\b\s*", "", sanitized.strip())
         sanitized = re.sub(r"(?i)\s+(AND|OR|NOT)\s*$", "", sanitized.strip())
+
+        # Step 5: Wrap unquoted hyphenated terms (e.g. ``chat-send``) in
+        # double quotes.  FTS5's tokenizer splits on hyphens, turning
+        # ``chat-send`` into ``chat AND send``.  Quoting preserves the
+        # intended phrase match.
+        sanitized = re.sub(r"\b(\w+(?:-\w+)+)\b", r'"\1"', sanitized)
+
+        # Step 6: Restore preserved quoted phrases
+        for i, quoted in enumerate(_quoted_parts):
+            sanitized = sanitized.replace(f"\x00Q{i}\x00", quoted)
+
         return sanitized.strip()
 
     def search_messages(

scripts/whatsapp-bridge/bridge.js

@@ -44,6 +44,14 @@ const SESSION_DIR = getArg('session', path.join(process.env.HOME || '~', '.herme
 const PAIR_ONLY = args.includes('--pair-only');
 const WHATSAPP_MODE = getArg('mode', process.env.WHATSAPP_MODE || 'self-chat'); // "bot" or "self-chat"
 const ALLOWED_USERS = (process.env.WHATSAPP_ALLOWED_USERS || '').split(',').map(s => s.trim()).filter(Boolean);
+const DEFAULT_REPLY_PREFIX = '⚕ *Hermes Agent*\n────────────\n';
+const REPLY_PREFIX = process.env.WHATSAPP_REPLY_PREFIX === undefined
+  ? DEFAULT_REPLY_PREFIX
+  : process.env.WHATSAPP_REPLY_PREFIX.replace(/\\n/g, '\n');
+
+function formatOutgoingMessage(message) {
+  return REPLY_PREFIX ? `${REPLY_PREFIX}${message}` : message;
+}
 
 mkdirSync(SESSION_DIR, { recursive: true });
 
@@ -188,7 +196,7 @@ async function startSocket() {
       }
 
       // Ignore Hermes' own reply messages in self-chat mode to avoid loops.
-      if (msg.key.fromMe && (body.startsWith('⚕ *Hermes Agent*') || recentlySentIds.has(msg.key.id))) {
+      if (msg.key.fromMe && ((REPLY_PREFIX && body.startsWith(REPLY_PREFIX)) || recentlySentIds.has(msg.key.id))) {
         if (WHATSAPP_DEBUG) {
           try { console.log(JSON.stringify({ event: 'ignored', reason: 'agent_echo', chatId, messageId: msg.key.id })); } catch {}
         }
@@ -251,10 +259,7 @@ app.post('/send', async (req, res) => {
   }
 
   try {
-    // Prefix responses so the user can distinguish agent replies from their
-    // own messages (especially in self-chat / "Message Yourself").
-    const prefixed = `⚕ *Hermes Agent*\n────────────\n${message}`;
-    const sent = await sock.sendMessage(chatId, { text: prefixed });
+    const sent = await sock.sendMessage(chatId, { text: formatOutgoingMessage(message) });
 
     // Track sent message ID to prevent echo-back loops
     if (sent?.key?.id) {
@@ -282,9 +287,8 @@ app.post('/edit', async (req, res) => {
   }
 
   try {
-    const prefixed = `⚕ *Hermes Agent*\n────────────\n${message}`;
     const key = { id: messageId, fromMe: true, remoteJid: chatId };
-    await sock.sendMessage(chatId, { text: prefixed, edit: key });
+    await sock.sendMessage(chatId, { text: formatOutgoingMessage(message), edit: key });
     res.json({ success: true });
   } catch (err) {
     res.status(500).json({ error: err.message });

tests/agent/test_context_compressor.py

@@ -111,7 +111,11 @@ class TestCompress:
         # First 2 messages should be preserved (protect_first_n=2)
         # Last 2 messages should be preserved (protect_last_n=2)
         assert result[-1]["content"] == msgs[-1]["content"]
-        assert result[-2]["content"] == msgs[-2]["content"]
+        # The second-to-last tail message may have the summary merged
+        # into it when a double-collision prevents a standalone summary
+        # (head=assistant, tail=user in this fixture).  Verify the
+        # original content is present in either case.
+        assert msgs[-2]["content"] in result[-2]["content"]
 
 
 class TestGenerateSummaryNoneContent:
@@ -329,6 +333,146 @@ class TestCompressWithClient:
         assert len(summary_msg) == 1
         assert summary_msg[0]["role"] == "assistant"
 
+    def test_summary_role_flips_to_avoid_tail_collision(self):
+        """When summary role collides with the first tail message but flipping
+        doesn't collide with head, the role should be flipped."""
+        mock_response = MagicMock()
+        mock_response.choices = [MagicMock()]
+        mock_response.choices[0].message.content = "summary text"
+
+        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 ends with tool (index 1), tail starts with user (index 6).
+        # Default: tool → summary_role="user" → collides with tail.
+        # Flip to "assistant" → tool→assistant is fine.
+        msgs = [
+            {"role": "user", "content": "msg 0"},
+            {"role": "assistant", "content": "", "tool_calls": [
+                {"id": "call_1", "type": "function", "function": {"name": "t", "arguments": "{}"}},
+            ]},
+            {"role": "tool", "tool_call_id": "call_1", "content": "result 1"},
+            {"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)
+        # Verify no consecutive user or assistant messages
+        for i in range(1, len(result)):
+            r1 = result[i - 1].get("role")
+            r2 = result[i].get("role")
+            if r1 in ("user", "assistant") and r2 in ("user", "assistant"):
+                assert r1 != r2, f"consecutive {r1} at indices {i-1},{i}"
+
+    def test_double_collision_merges_summary_into_tail(self):
+        """When neither role avoids collision with both neighbors, the summary
+        should be merged into the first tail message rather than creating a
+        standalone message that breaks role alternation.
+
+        Common scenario: head ends with 'assistant', tail starts with 'user'.
+        summary='user' collides with tail, summary='assistant' collides with head.
+        """
+        mock_response = MagicMock()
+        mock_response.choices = [MagicMock()]
+        mock_response.choices[0].message.content = "summary text"
+
+        with patch("agent.context_compressor.get_model_context_length", return_value=100000):
+            c = ContextCompressor(model="test", quiet_mode=True, protect_first_n=3, protect_last_n=3)
+
+        # Head: [system, user, assistant]  →  last head = assistant
+        # Tail: [user, assistant, user]    →  first tail = user
+        # summary_role="user" collides with tail, "assistant" collides with head → merge
+        msgs = [
+            {"role": "system", "content": "system prompt"},
+            {"role": "user", "content": "msg 1"},
+            {"role": "assistant", "content": "msg 2"},
+            {"role": "user", "content": "msg 3"},      # compressed
+            {"role": "assistant", "content": "msg 4"},  # compressed
+            {"role": "user", "content": "msg 5"},       # compressed
+            {"role": "user", "content": "msg 6"},       # tail start
+            {"role": "assistant", "content": "msg 7"},
+            {"role": "user", "content": "msg 8"},
+        ]
+        with patch("agent.context_compressor.call_llm", return_value=mock_response):
+            result = c.compress(msgs)
+
+        # Verify no consecutive user or assistant messages
+        for i in range(1, len(result)):
+            r1 = result[i - 1].get("role")
+            r2 = result[i].get("role")
+            if r1 in ("user", "assistant") and r2 in ("user", "assistant"):
+                assert r1 != r2, f"consecutive {r1} at indices {i-1},{i}"
+
+        # The summary text should be merged into the first tail message
+        first_tail = [m for m in result if "msg 6" in (m.get("content") or "")]
+        assert len(first_tail) == 1
+        assert "summary text" in first_tail[0]["content"]
+
+    def test_double_collision_user_head_assistant_tail(self):
+        """Reverse double collision: head ends with 'user', tail starts with 'assistant'.
+        summary='assistant' collides with tail, 'user' collides with head → merge."""
+        mock_response = MagicMock()
+        mock_response.choices = [MagicMock()]
+        mock_response.choices[0].message.content = "summary text"
+
+        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: [system, user]        → last head = user
+        # Tail: [assistant, user]     → first tail = assistant
+        # summary_role="assistant" collides with tail, "user" collides with head → merge
+        msgs = [
+            {"role": "system", "content": "system prompt"},
+            {"role": "user", "content": "msg 1"},
+            {"role": "assistant", "content": "msg 2"},   # compressed
+            {"role": "user", "content": "msg 3"},        # compressed
+            {"role": "assistant", "content": "msg 4"},   # compressed
+            {"role": "assistant", "content": "msg 5"},   # tail start
+            {"role": "user", "content": "msg 6"},
+        ]
+        with patch("agent.context_compressor.call_llm", return_value=mock_response):
+            result = c.compress(msgs)
+
+        # Verify no consecutive user or assistant messages
+        for i in range(1, len(result)):
+            r1 = result[i - 1].get("role")
+            r2 = result[i].get("role")
+            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)
+        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"]
+
+    def test_no_collision_scenarios_still_work(self):
+        """Verify that the common no-collision cases (head=assistant/tail=assistant,
+        head=user/tail=user) still produce a standalone summary message."""
+        mock_response = MagicMock()
+        mock_response.choices = [MagicMock()]
+        mock_response.choices[0].message.content = "summary text"
+
+        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
+        msgs = [
+            {"role": "user", "content": "msg 0"},
+            {"role": "assistant", "content": "msg 1"},
+            {"role": "user", "content": "msg 2"},
+            {"role": "assistant", "content": "msg 3"},
+            {"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)
+        summary_msgs = [m for m in result if (m.get("content") or "").startswith(SUMMARY_PREFIX)]
+        assert len(summary_msgs) == 1, "should have a standalone summary message"
+        assert summary_msgs[0]["role"] == "user"
+
     def test_summarization_does_not_start_tail_with_tool_outputs(self):
         mock_response = MagicMock()
         mock_response.choices = [MagicMock()]

tests/gateway/test_api_server.py

@@ -1,5 +1,5 @@
 """
-Tests for the OpenAI-compatible HTTP server gateway adapter.
+Tests for the OpenAI-compatible API server gateway adapter.
 
 Tests cover:
 - Chat Completions endpoint (request parsing, response format)
@@ -22,27 +22,27 @@ from aiohttp import web
 from aiohttp.test_utils import AioHTTPTestCase, TestClient, TestServer
 
 from gateway.config import GatewayConfig, Platform, PlatformConfig
-from gateway.platforms.http_server import (
-    HTTPServerAdapter,
+from gateway.platforms.api_server import (
+    APIServerAdapter,
     ResponseStore,
     _CORS_HEADERS,
-    check_http_server_requirements,
+    check_api_server_requirements,
     cors_middleware,
 )
 
 
 # ---------------------------------------------------------------------------
-# check_http_server_requirements
+# check_api_server_requirements
 # ---------------------------------------------------------------------------
 
 
 class TestCheckRequirements:
     def test_returns_true_when_aiohttp_available(self):
-        assert check_http_server_requirements() is True
+        assert check_api_server_requirements() is True
 
-    @patch("gateway.platforms.http_server.AIOHTTP_AVAILABLE", False)
+    @patch("gateway.platforms.api_server.AIOHTTP_AVAILABLE", False)
     def test_returns_false_without_aiohttp(self):
-        assert check_http_server_requirements() is False
+        assert check_api_server_requirements() is False
 
 
 # ---------------------------------------------------------------------------
@@ -110,28 +110,28 @@ class TestResponseStore:
 class TestAdapterInit:
     def test_default_config(self):
         config = PlatformConfig(enabled=True)
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         assert adapter._host == "127.0.0.1"
         assert adapter._port == 8642
         assert adapter._api_key == ""
-        assert adapter.platform == Platform.HTTP_SERVER
+        assert adapter.platform == Platform.API_SERVER
 
     def test_custom_config_from_extra(self):
         config = PlatformConfig(
             enabled=True,
             extra={"host": "0.0.0.0", "port": 9999, "key": "sk-test"},
         )
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         assert adapter._host == "0.0.0.0"
         assert adapter._port == 9999
         assert adapter._api_key == "sk-test"
 
     def test_config_from_env(self, monkeypatch):
-        monkeypatch.setenv("HTTP_SERVER_HOST", "10.0.0.1")
-        monkeypatch.setenv("HTTP_SERVER_PORT", "7777")
-        monkeypatch.setenv("HTTP_SERVER_KEY", "sk-env")
+        monkeypatch.setenv("API_SERVER_HOST", "10.0.0.1")
+        monkeypatch.setenv("API_SERVER_PORT", "7777")
+        monkeypatch.setenv("API_SERVER_KEY", "sk-env")
         config = PlatformConfig(enabled=True)
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         assert adapter._host == "10.0.0.1"
         assert adapter._port == 7777
         assert adapter._api_key == "sk-env"
@@ -145,21 +145,21 @@ class TestAdapterInit:
 class TestAuth:
     def test_no_key_configured_allows_all(self):
         config = PlatformConfig(enabled=True)
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         mock_request = MagicMock()
         mock_request.headers = {}
         assert adapter._check_auth(mock_request) is None
 
     def test_valid_key_passes(self):
         config = PlatformConfig(enabled=True, extra={"key": "sk-test123"})
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         mock_request = MagicMock()
         mock_request.headers = {"Authorization": "Bearer sk-test123"}
         assert adapter._check_auth(mock_request) is None
 
     def test_invalid_key_returns_401(self):
         config = PlatformConfig(enabled=True, extra={"key": "sk-test123"})
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         mock_request = MagicMock()
         mock_request.headers = {"Authorization": "Bearer wrong-key"}
         result = adapter._check_auth(mock_request)
@@ -168,7 +168,7 @@ class TestAuth:
 
     def test_missing_auth_header_returns_401(self):
         config = PlatformConfig(enabled=True, extra={"key": "sk-test123"})
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         mock_request = MagicMock()
         mock_request.headers = {}
         result = adapter._check_auth(mock_request)
@@ -177,7 +177,7 @@ class TestAuth:
 
     def test_malformed_auth_header_returns_401(self):
         config = PlatformConfig(enabled=True, extra={"key": "sk-test123"})
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         mock_request = MagicMock()
         mock_request.headers = {"Authorization": "Basic dXNlcjpwYXNz"}
         result = adapter._check_auth(mock_request)
@@ -190,16 +190,16 @@ class TestAuth:
 # ---------------------------------------------------------------------------
 
 
-def _make_adapter(api_key: str = "") -> HTTPServerAdapter:
+def _make_adapter(api_key: str = "") -> APIServerAdapter:
     """Create an adapter with optional API key."""
     extra = {}
     if api_key:
         extra["key"] = api_key
     config = PlatformConfig(enabled=True, extra=extra)
-    return HTTPServerAdapter(config)
+    return APIServerAdapter(config)
 
 
-def _create_app(adapter: HTTPServerAdapter) -> web.Application:
+def _create_app(adapter: APIServerAdapter) -> web.Application:
     """Create the aiohttp app from the adapter (without starting the full server)."""
     app = web.Application(middlewares=[cors_middleware])
     app.router.add_get("/health", adapter._handle_health)
@@ -762,43 +762,43 @@ class TestEndpointAuth:
 
 
 class TestConfigIntegration:
-    def test_platform_enum_has_http_server(self):
-        assert Platform.HTTP_SERVER.value == "http_server"
+    def test_platform_enum_has_api_server(self):
+        assert Platform.API_SERVER.value == "api_server"
 
-    def test_env_override_enables_http_server(self, monkeypatch):
-        monkeypatch.setenv("HTTP_SERVER_ENABLED", "true")
+    def test_env_override_enables_api_server(self, monkeypatch):
+        monkeypatch.setenv("API_SERVER_ENABLED", "true")
         from gateway.config import load_gateway_config
         config = load_gateway_config()
-        assert Platform.HTTP_SERVER in config.platforms
-        assert config.platforms[Platform.HTTP_SERVER].enabled is True
+        assert Platform.API_SERVER in config.platforms
+        assert config.platforms[Platform.API_SERVER].enabled is True
 
     def test_env_override_with_key(self, monkeypatch):
-        monkeypatch.setenv("HTTP_SERVER_KEY", "sk-mykey")
+        monkeypatch.setenv("API_SERVER_KEY", "sk-mykey")
         from gateway.config import load_gateway_config
         config = load_gateway_config()
-        assert Platform.HTTP_SERVER in config.platforms
-        assert config.platforms[Platform.HTTP_SERVER].extra.get("key") == "sk-mykey"
+        assert Platform.API_SERVER in config.platforms
+        assert config.platforms[Platform.API_SERVER].extra.get("key") == "sk-mykey"
 
     def test_env_override_port_and_host(self, monkeypatch):
-        monkeypatch.setenv("HTTP_SERVER_ENABLED", "true")
-        monkeypatch.setenv("HTTP_SERVER_PORT", "9999")
-        monkeypatch.setenv("HTTP_SERVER_HOST", "0.0.0.0")
+        monkeypatch.setenv("API_SERVER_ENABLED", "true")
+        monkeypatch.setenv("API_SERVER_PORT", "9999")
+        monkeypatch.setenv("API_SERVER_HOST", "0.0.0.0")
         from gateway.config import load_gateway_config
         config = load_gateway_config()
-        assert config.platforms[Platform.HTTP_SERVER].extra.get("port") == 9999
-        assert config.platforms[Platform.HTTP_SERVER].extra.get("host") == "0.0.0.0"
+        assert config.platforms[Platform.API_SERVER].extra.get("port") == 9999
+        assert config.platforms[Platform.API_SERVER].extra.get("host") == "0.0.0.0"
 
-    def test_http_server_in_connected_platforms(self):
+    def test_api_server_in_connected_platforms(self):
         config = GatewayConfig()
-        config.platforms[Platform.HTTP_SERVER] = PlatformConfig(enabled=True)
+        config.platforms[Platform.API_SERVER] = PlatformConfig(enabled=True)
         connected = config.get_connected_platforms()
-        assert Platform.HTTP_SERVER in connected
+        assert Platform.API_SERVER in connected
 
-    def test_http_server_not_in_connected_when_disabled(self):
+    def test_api_server_not_in_connected_when_disabled(self):
         config = GatewayConfig()
-        config.platforms[Platform.HTTP_SERVER] = PlatformConfig(enabled=False)
+        config.platforms[Platform.API_SERVER] = PlatformConfig(enabled=False)
         connected = config.get_connected_platforms()
-        assert Platform.HTTP_SERVER not in connected
+        assert Platform.API_SERVER not in connected
 
 
 # ---------------------------------------------------------------------------
@@ -843,7 +843,7 @@ class TestSendMethod:
     @pytest.mark.asyncio
     async def test_send_returns_not_supported(self):
         config = PlatformConfig(enabled=True)
-        adapter = HTTPServerAdapter(config)
+        adapter = APIServerAdapter(config)
         result = await adapter.send("chat1", "hello")
         assert result.success is False
         assert "HTTP request/response" in result.error

tests/gateway/test_session.py

@@ -336,6 +336,56 @@ class TestSessionStoreRewriteTranscript:
         assert reloaded == []
 
 
+class TestLoadTranscriptCorruptLines:
+    """Regression: corrupt JSONL lines (e.g. from mid-write crash) must be
+    skipped instead of crashing the entire transcript load.  GH-1193."""
+
+    @pytest.fixture()
+    def store(self, tmp_path):
+        config = GatewayConfig()
+        with patch("gateway.session.SessionStore._ensure_loaded"):
+            s = SessionStore(sessions_dir=tmp_path, config=config)
+        s._db = None
+        s._loaded = True
+        return s
+
+    def test_corrupt_line_skipped(self, store, tmp_path):
+        session_id = "corrupt_test"
+        transcript_path = store.get_transcript_path(session_id)
+        transcript_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(transcript_path, "w") as f:
+            f.write('{"role": "user", "content": "hello"}\n')
+            f.write('{"role": "assistant", "content": "hi th')  # truncated
+            f.write("\n")
+            f.write('{"role": "user", "content": "goodbye"}\n')
+
+        messages = store.load_transcript(session_id)
+        assert len(messages) == 2
+        assert messages[0]["content"] == "hello"
+        assert messages[1]["content"] == "goodbye"
+
+    def test_all_lines_corrupt_returns_empty(self, store, tmp_path):
+        session_id = "all_corrupt"
+        transcript_path = store.get_transcript_path(session_id)
+        transcript_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(transcript_path, "w") as f:
+            f.write("not json at all\n")
+            f.write("{truncated\n")
+
+        messages = store.load_transcript(session_id)
+        assert messages == []
+
+    def test_valid_transcript_unaffected(self, store, tmp_path):
+        session_id = "valid_test"
+        store.append_to_transcript(session_id, {"role": "user", "content": "a"})
+        store.append_to_transcript(session_id, {"role": "assistant", "content": "b"})
+
+        messages = store.load_transcript(session_id)
+        assert len(messages) == 2
+        assert messages[0]["content"] == "a"
+        assert messages[1]["content"] == "b"
+
+
 class TestWhatsAppDMSessionKeyConsistency:
     """Regression: all session-key construction must go through build_session_key
     so DMs are isolated by chat_id across platforms."""

tests/gateway/test_whatsapp_connect.py

@@ -51,6 +51,7 @@ def _make_adapter():
     adapter._bridge_log_fh = None
     adapter._bridge_log = None
     adapter._bridge_process = None
+    adapter._reply_prefix = None
     adapter._running = False
     adapter._message_queue = asyncio.Queue()
     return adapter

tests/gateway/test_whatsapp_reply_prefix.py

@@ -0,0 +1,121 @@
+"""Tests for WhatsApp reply_prefix config.yaml support.
+
+Covers:
+- config.yaml whatsapp.reply_prefix bridging into PlatformConfig.extra
+- WhatsAppAdapter reading reply_prefix from config.extra
+- Bridge subprocess receiving WHATSAPP_REPLY_PREFIX env var
+- Config version covers all ENV_VARS_BY_VERSION keys (regression guard)
+"""
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from gateway.config import GatewayConfig, Platform, PlatformConfig
+
+
+# ---------------------------------------------------------------------------
+# Config bridging from config.yaml
+# ---------------------------------------------------------------------------
+
+
+class TestConfigYamlBridging:
+    """Test that whatsapp.reply_prefix in config.yaml flows into PlatformConfig."""
+
+    def test_reply_prefix_bridged_from_yaml(self, tmp_path):
+        """whatsapp.reply_prefix in config.yaml sets PlatformConfig.extra."""
+        config_yaml = tmp_path / "config.yaml"
+        config_yaml.write_text('whatsapp:\n  reply_prefix: "Custom Bot"\n')
+
+        with patch("gateway.config.get_hermes_home", return_value=tmp_path):
+            from gateway.config import load_gateway_config
+            # Need to also patch WHATSAPP_ENABLED so the platform exists
+            with patch.dict("os.environ", {"WHATSAPP_ENABLED": "true"}, clear=False):
+                config = load_gateway_config()
+
+        wa_config = config.platforms.get(Platform.WHATSAPP)
+        assert wa_config is not None
+        assert wa_config.extra.get("reply_prefix") == "Custom Bot"
+
+    def test_empty_reply_prefix_bridged(self, tmp_path):
+        """Empty string reply_prefix disables the header."""
+        config_yaml = tmp_path / "config.yaml"
+        config_yaml.write_text('whatsapp:\n  reply_prefix: ""\n')
+
+        with patch("gateway.config.get_hermes_home", return_value=tmp_path):
+            from gateway.config import load_gateway_config
+            with patch.dict("os.environ", {"WHATSAPP_ENABLED": "true"}, clear=False):
+                config = load_gateway_config()
+
+        wa_config = config.platforms.get(Platform.WHATSAPP)
+        assert wa_config is not None
+        assert wa_config.extra.get("reply_prefix") == ""
+
+    def test_no_whatsapp_section_no_extra(self, tmp_path):
+        """Without whatsapp section, no reply_prefix is set."""
+        config_yaml = tmp_path / "config.yaml"
+        config_yaml.write_text("timezone: UTC\n")
+
+        with patch("gateway.config.get_hermes_home", return_value=tmp_path):
+            from gateway.config import load_gateway_config
+            with patch.dict("os.environ", {"WHATSAPP_ENABLED": "true"}, clear=False):
+                config = load_gateway_config()
+
+        wa_config = config.platforms.get(Platform.WHATSAPP)
+        assert wa_config is not None
+        assert "reply_prefix" not in wa_config.extra
+
+    def test_whatsapp_section_without_reply_prefix(self, tmp_path):
+        """whatsapp section present but without reply_prefix key."""
+        config_yaml = tmp_path / "config.yaml"
+        config_yaml.write_text("whatsapp:\n  other_setting: true\n")
+
+        with patch("gateway.config.get_hermes_home", return_value=tmp_path):
+            from gateway.config import load_gateway_config
+            with patch.dict("os.environ", {"WHATSAPP_ENABLED": "true"}, clear=False):
+                config = load_gateway_config()
+
+        wa_config = config.platforms.get(Platform.WHATSAPP)
+        assert "reply_prefix" not in wa_config.extra
+
+
+# ---------------------------------------------------------------------------
+# WhatsAppAdapter __init__
+# ---------------------------------------------------------------------------
+
+
+class TestAdapterInit:
+    """Test that WhatsAppAdapter reads reply_prefix from config.extra."""
+
+    def test_reply_prefix_from_extra(self):
+        from gateway.platforms.whatsapp import WhatsAppAdapter
+        config = PlatformConfig(enabled=True, extra={"reply_prefix": "Bot\\n"})
+        adapter = WhatsAppAdapter(config)
+        assert adapter._reply_prefix == "Bot\\n"
+
+    def test_reply_prefix_default_none(self):
+        from gateway.platforms.whatsapp import WhatsAppAdapter
+        config = PlatformConfig(enabled=True)
+        adapter = WhatsAppAdapter(config)
+        assert adapter._reply_prefix is None
+
+    def test_reply_prefix_empty_string(self):
+        from gateway.platforms.whatsapp import WhatsAppAdapter
+        config = PlatformConfig(enabled=True, extra={"reply_prefix": ""})
+        adapter = WhatsAppAdapter(config)
+        assert adapter._reply_prefix == ""
+
+
+# ---------------------------------------------------------------------------
+# Config version regression guard
+# ---------------------------------------------------------------------------
+
+
+class TestConfigVersionCoverage:
+    """Ensure _config_version covers all ENV_VARS_BY_VERSION keys."""
+
+    def test_default_config_version_covers_env_var_versions(self):
+        """_config_version must be >= the highest ENV_VARS_BY_VERSION key."""
+        from hermes_cli.config import DEFAULT_CONFIG, ENV_VARS_BY_VERSION
+        assert DEFAULT_CONFIG["_config_version"] >= max(ENV_VARS_BY_VERSION)

tests/hermes_cli/test_gateway_service.py

@@ -85,6 +85,13 @@ class TestGeneratedSystemdUnits:
         assert "ExecStop=" not in unit
         assert "TimeoutStopSec=60" in unit
 
+    def test_user_unit_includes_resolved_node_directory_in_path(self, monkeypatch):
+        monkeypatch.setattr(gateway_cli.shutil, "which", lambda cmd: "/home/test/.nvm/versions/node/v24.14.0/bin/node" if cmd == "node" else None)
+
+        unit = gateway_cli.generate_systemd_unit(system=False)
+
+        assert "/home/test/.nvm/versions/node/v24.14.0/bin" in unit
+
     def test_system_unit_avoids_recursive_execstop_and_uses_extended_stop_timeout(self):
         unit = gateway_cli.generate_systemd_unit(system=True)
 

tests/hermes_cli/test_skin_engine.py

@@ -13,13 +13,9 @@ def reset_skin_state():
     from hermes_cli import skin_engine
     skin_engine._active_skin = None
     skin_engine._active_skin_name = "default"
-    skin_engine._theme_mode = "auto"
-    skin_engine._resolved_theme_mode = None
     yield
     skin_engine._active_skin = None
     skin_engine._active_skin_name = "default"
-    skin_engine._theme_mode = "auto"
-    skin_engine._resolved_theme_mode = None
 
 
 class TestSkinConfig:
@@ -316,65 +312,3 @@ class TestCliBrandingHelpers:
         assert overrides["clarify-title"] == f"{skin.get_color('banner_title')} bold"
         assert overrides["sudo-prompt"] == f"{skin.get_color('ui_error')} bold"
         assert overrides["approval-title"] == f"{skin.get_color('ui_warn')} bold"
-
-
-class TestThemeMode:
-    def test_get_theme_mode_defaults_to_dark_on_unknown(self):
-        from hermes_cli.skin_engine import get_theme_mode, set_theme_mode
-
-        set_theme_mode("auto")
-        # In a test env, detection returns "unknown" → defaults to "dark"
-        with patch("hermes_cli.colors.detect_terminal_background", return_value="unknown"):
-            from hermes_cli import skin_engine
-            skin_engine._resolved_theme_mode = None  # force re-detection
-            assert get_theme_mode() == "dark"
-
-    def test_set_theme_mode_light(self):
-        from hermes_cli.skin_engine import get_theme_mode, set_theme_mode
-
-        set_theme_mode("light")
-        assert get_theme_mode() == "light"
-
-    def test_set_theme_mode_dark(self):
-        from hermes_cli.skin_engine import get_theme_mode, set_theme_mode
-
-        set_theme_mode("dark")
-        assert get_theme_mode() == "dark"
-
-    def test_get_color_respects_light_mode(self):
-        from hermes_cli.skin_engine import SkinConfig, set_theme_mode
-
-        skin = SkinConfig(
-            name="test",
-            colors={"banner_title": "#FFD700", "prompt": "#FFF8DC"},
-            colors_light={"banner_title": "#6B4C00"},
-        )
-        set_theme_mode("light")
-        assert skin.get_color("banner_title") == "#6B4C00"
-        # Key not in colors_light falls back to colors
-        assert skin.get_color("prompt") == "#FFF8DC"
-
-    def test_get_color_falls_back_in_dark_mode(self):
-        from hermes_cli.skin_engine import SkinConfig, set_theme_mode
-
-        skin = SkinConfig(
-            name="test",
-            colors={"banner_title": "#FFD700", "prompt": "#FFF8DC"},
-            colors_light={"banner_title": "#6B4C00"},
-        )
-        set_theme_mode("dark")
-        assert skin.get_color("banner_title") == "#FFD700"
-        assert skin.get_color("prompt") == "#FFF8DC"
-
-    def test_init_skin_from_config_reads_theme_mode(self):
-        from hermes_cli.skin_engine import init_skin_from_config, get_theme_mode_setting
-
-        init_skin_from_config({"display": {"skin": "default", "theme_mode": "light"}})
-        assert get_theme_mode_setting() == "light"
-
-    def test_builtin_skins_have_colors_light(self):
-        from hermes_cli.skin_engine import _BUILTIN_SKINS, _build_skin_config
-
-        for name, data in _BUILTIN_SKINS.items():
-            skin = _build_skin_config(data)
-            assert len(skin.colors_light) > 0, f"Skin '{name}' has empty colors_light"

tests/test_hermes_state.py

@@ -261,6 +261,30 @@ class TestFTS5Search:
         # The word "C" appears in the content, so FTS5 should find it
         assert isinstance(results, list)
 
+    def test_search_hyphenated_term_does_not_crash(self, db):
+        """Hyphenated terms like 'chat-send' must not crash FTS5."""
+        db.create_session(session_id="s1", source="cli")
+        db.append_message("s1", role="user", content="Run the chat-send command")
+
+        results = db.search_messages("chat-send")
+        assert isinstance(results, list)
+        assert len(results) >= 1
+        assert any("chat-send" in (r.get("snippet") or r.get("content", "")).lower()
+                    for r in results)
+
+    def test_search_quoted_phrase_preserved(self, db):
+        """User-provided quoted phrases should be preserved for exact matching."""
+        db.create_session(session_id="s1", source="cli")
+        db.append_message("s1", role="user", content="docker networking is complex")
+        db.append_message("s1", role="assistant", content="networking docker tips")
+
+        # Quoted phrase should match only the exact order
+        results = db.search_messages('"docker networking"')
+        assert isinstance(results, list)
+        # Should find the user message (exact phrase) but may or may not find
+        # the assistant message depending on FTS5 phrase matching
+        assert len(results) >= 1
+
     def test_sanitize_fts5_query_strips_dangerous_chars(self):
         """Unit test for _sanitize_fts5_query static method."""
         from hermes_state import SessionDB
@@ -278,6 +302,43 @@ class TestFTS5Search:
         # Valid prefix kept
         assert s('deploy*') == 'deploy*'
 
+    def test_sanitize_fts5_preserves_quoted_phrases(self):
+        """Properly paired double-quoted phrases should be preserved."""
+        from hermes_state import SessionDB
+        s = SessionDB._sanitize_fts5_query
+        # Simple quoted phrase
+        assert s('"exact phrase"') == '"exact phrase"'
+        # Quoted phrase alongside unquoted terms
+        assert '"docker networking"' in s('"docker networking" setup')
+        # Multiple quoted phrases
+        result = s('"hello world" OR "foo bar"')
+        assert '"hello world"' in result
+        assert '"foo bar"' in result
+        # Unmatched quote still stripped
+        assert '"' not in s('"unterminated')
+
+    def test_sanitize_fts5_quotes_hyphenated_terms(self):
+        """Hyphenated terms should be wrapped in quotes for exact matching."""
+        from hermes_state import SessionDB
+        s = SessionDB._sanitize_fts5_query
+        # Simple hyphenated term
+        assert s('chat-send') == '"chat-send"'
+        # Multiple hyphens
+        assert s('docker-compose-up') == '"docker-compose-up"'
+        # Hyphenated term with other words
+        result = s('fix chat-send bug')
+        assert '"chat-send"' in result
+        assert 'fix' in result
+        assert 'bug' in result
+        # Multiple hyphenated terms with OR
+        result = s('chat-send OR deploy-prod')
+        assert '"chat-send"' in result
+        assert '"deploy-prod"' in result
+        # Already-quoted hyphenated term — no double quoting
+        assert s('"chat-send"') == '"chat-send"'
+        # Hyphenated inside a quoted phrase stays as-is
+        assert s('"my chat-send thing"') == '"my chat-send thing"'
+
 
 # =========================================================================
 # Session search and listing

tests/tools/test_delegate.py

@@ -249,6 +249,49 @@ class TestDelegateTask(unittest.TestCase):
             self.assertEqual(kwargs["api_mode"], parent.api_mode)
 
 
+class TestToolNamePreservation(unittest.TestCase):
+    """Verify _last_resolved_tool_names is restored after subagent runs."""
+
+    def test_global_tool_names_restored_after_delegation(self):
+        """The process-global _last_resolved_tool_names must be restored
+        after a subagent completes so the parent's execute_code sandbox
+        generates correct imports."""
+        import model_tools
+
+        parent = _make_mock_parent(depth=0)
+        original_tools = ["terminal", "read_file", "web_search", "execute_code", "delegate_task"]
+        model_tools._last_resolved_tool_names = list(original_tools)
+
+        with patch("run_agent.AIAgent") as MockAgent:
+            mock_child = MagicMock()
+            mock_child.run_conversation.return_value = {
+                "final_response": "done", "completed": True, "api_calls": 1,
+            }
+            MockAgent.return_value = mock_child
+
+            delegate_task(goal="Test tool preservation", parent_agent=parent)
+
+        self.assertEqual(model_tools._last_resolved_tool_names, original_tools)
+
+    def test_global_tool_names_restored_after_child_failure(self):
+        """Even when the child agent raises, the global must be restored."""
+        import model_tools
+
+        parent = _make_mock_parent(depth=0)
+        original_tools = ["terminal", "read_file", "web_search"]
+        model_tools._last_resolved_tool_names = list(original_tools)
+
+        with patch("run_agent.AIAgent") as MockAgent:
+            mock_child = MagicMock()
+            mock_child.run_conversation.side_effect = RuntimeError("boom")
+            MockAgent.return_value = mock_child
+
+            result = json.loads(delegate_task(goal="Crash test", parent_agent=parent))
+            self.assertEqual(result["results"][0]["status"], "error")
+
+        self.assertEqual(model_tools._last_resolved_tool_names, original_tools)
+
+
 class TestDelegateObservability(unittest.TestCase):
     """Tests for enriched metadata returned by _run_single_child."""
 

tests/tools/test_send_message_tool.py

@@ -398,6 +398,25 @@ class TestSendToPlatformChunking:
 # ---------------------------------------------------------------------------
 
 
+class TestSendToPlatformWhatsapp:
+    def test_whatsapp_routes_via_local_bridge_sender(self):
+        chat_id = "test-user@lid"
+        async_mock = AsyncMock(return_value={"success": True, "platform": "whatsapp", "chat_id": chat_id, "message_id": "abc123"})
+
+        with patch("tools.send_message_tool._send_whatsapp", async_mock):
+            result = asyncio.run(
+                _send_to_platform(
+                    Platform.WHATSAPP,
+                    SimpleNamespace(enabled=True, token=None, extra={"bridge_port": 3000}),
+                    chat_id,
+                    "hello from hermes",
+                )
+            )
+
+        assert result["success"] is True
+        async_mock.assert_awaited_once_with({"bridge_port": 3000}, chat_id, "hello from hermes")
+
+
 class TestSendTelegramHtmlDetection:
     """Verify that messages containing HTML tags are sent with parse_mode=HTML
     and that plain / markdown messages use MarkdownV2."""

tests/tools/test_transcription.py

@@ -26,13 +26,14 @@ class TestGetProvider:
             from tools.transcription_tools import _get_provider
             assert _get_provider({"provider": "local"}) == "local"
 
-    def test_local_fallback_to_openai(self, monkeypatch):
+    def test_explicit_local_no_cloud_fallback(self, monkeypatch):
+        """Explicit local provider must not silently fall back to cloud."""
         monkeypatch.setenv("VOICE_TOOLS_OPENAI_KEY", "sk-test")
         monkeypatch.delenv("GROQ_API_KEY", raising=False)
         with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
              patch("tools.transcription_tools._HAS_OPENAI", True):
             from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "local"}) == "openai"
+            assert _get_provider({"provider": "local"}) == "none"
 
     def test_local_nothing_available(self, monkeypatch):
         monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
@@ -47,12 +48,13 @@ class TestGetProvider:
             from tools.transcription_tools import _get_provider
             assert _get_provider({"provider": "openai"}) == "openai"
 
-    def test_openai_fallback_to_local(self, monkeypatch):
+    def test_explicit_openai_no_key_returns_none(self, monkeypatch):
+        """Explicit openai without key returns none — no cross-provider fallback."""
         monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
         with patch("tools.transcription_tools._HAS_FASTER_WHISPER", True), \
              patch("tools.transcription_tools._HAS_OPENAI", True):
             from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "openai"}) == "local"
+            assert _get_provider({"provider": "openai"}) == "none"
 
     def test_default_provider_is_local(self):
         with patch("tools.transcription_tools._HAS_FASTER_WHISPER", True):

tests/tools/test_transcription_tools.py

@@ -66,19 +66,12 @@ class TestGetProviderGroq:
             from tools.transcription_tools import _get_provider
             assert _get_provider({"provider": "groq"}) == "groq"
 
-    def test_groq_fallback_to_local(self, monkeypatch):
+    def test_groq_explicit_no_fallback(self, monkeypatch):
+        """Explicit groq with no key returns none — no cross-provider fallback."""
         monkeypatch.delenv("GROQ_API_KEY", raising=False)
         with patch("tools.transcription_tools._HAS_FASTER_WHISPER", True):
             from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "groq"}) == "local"
-
-    def test_groq_fallback_to_openai(self, monkeypatch):
-        monkeypatch.delenv("GROQ_API_KEY", raising=False)
-        monkeypatch.setenv("VOICE_TOOLS_OPENAI_KEY", "sk-test")
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
-             patch("tools.transcription_tools._HAS_OPENAI", True):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "groq"}) == "openai"
+            assert _get_provider({"provider": "groq"}) == "none"
 
     def test_groq_nothing_available(self, monkeypatch):
         monkeypatch.delenv("GROQ_API_KEY", raising=False)
@@ -90,36 +83,25 @@ class TestGetProviderGroq:
 
 
 class TestGetProviderFallbackPriority:
-    """Cross-provider fallback priority tests."""
+    """Auto-detect fallback priority and explicit provider behaviour."""
 
-    def test_local_fallback_prefers_groq_over_openai(self, monkeypatch):
-        """When local unavailable, groq (free) is preferred over openai (paid)."""
+    def test_auto_detect_prefers_local(self):
+        """Auto-detect prefers local over any cloud provider."""
+        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", True):
+            from tools.transcription_tools import _get_provider
+            assert _get_provider({}) == "local"
+
+    def test_auto_detect_prefers_groq_over_openai(self, monkeypatch):
+        """Auto-detect: groq (free) is preferred over openai (paid)."""
         monkeypatch.setenv("GROQ_API_KEY", "gsk-test")
         monkeypatch.setenv("VOICE_TOOLS_OPENAI_KEY", "sk-test")
         with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
              patch("tools.transcription_tools._HAS_OPENAI", True):
             from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "local"}) == "groq"
+            assert _get_provider({}) == "groq"
 
-    def test_local_fallback_to_groq_only(self, monkeypatch):
-        """When only groq key available, falls back to groq."""
-        monkeypatch.setenv("GROQ_API_KEY", "gsk-test")
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
-             patch("tools.transcription_tools._HAS_OPENAI", True):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "local"}) == "groq"
-
-    def test_openai_fallback_to_groq(self, monkeypatch):
-        """When openai key missing but groq available, falls back to groq."""
-        monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
-        monkeypatch.setenv("GROQ_API_KEY", "gsk-test")
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
-             patch("tools.transcription_tools._HAS_OPENAI", True):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "openai"}) == "groq"
-
-    def test_openai_nothing_available(self, monkeypatch):
-        """When no openai key and no local, returns none."""
+    def test_explicit_openai_no_key_returns_none(self, monkeypatch):
+        """Explicit openai with no key returns none — no cross-provider fallback."""
         monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
         monkeypatch.delenv("GROQ_API_KEY", raising=False)
         with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
@@ -136,18 +118,83 @@ class TestGetProviderFallbackPriority:
             from tools.transcription_tools import _get_provider
             assert _get_provider({}) == "local"
 
-    def test_openai_fallback_to_local_command(self, monkeypatch):
-        monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
-        monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+
+# ============================================================================
+# Explicit provider config respected  (GH-1774)
+# ============================================================================
+
+class TestExplicitProviderRespected:
+    """When stt.provider is explicitly set, that choice is authoritative.
+    No silent fallback to a different cloud provider."""
+
+    def test_explicit_local_no_fallback_to_openai(self, monkeypatch):
+        """GH-1774: provider=local must not silently fall back to openai
+        even when an OpenAI API key is set."""
+        monkeypatch.setenv("OPENAI_API_KEY", "sk-real-key-here")
         monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
+             patch("tools.transcription_tools._HAS_OPENAI", True):
+            from tools.transcription_tools import _get_provider
+            result = _get_provider({"provider": "local"})
+            assert result == "none", f"Expected 'none' but got {result!r}"
+
+    def test_explicit_local_no_fallback_to_groq(self, monkeypatch):
+        monkeypatch.setenv("GROQ_API_KEY", "gsk-test")
+        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
+             patch("tools.transcription_tools._HAS_OPENAI", True):
+            from tools.transcription_tools import _get_provider
+            result = _get_provider({"provider": "local"})
+            assert result == "none"
+
+    def test_explicit_local_uses_local_command_fallback(self, monkeypatch):
+        """Local-to-local_command fallback is fine — both are local."""
         monkeypatch.setenv(
             "HERMES_LOCAL_STT_COMMAND",
             "whisper {input_path} --output_dir {output_dir} --language {language}",
         )
+        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False):
+            from tools.transcription_tools import _get_provider
+            result = _get_provider({"provider": "local"})
+            assert result == "local_command"
+
+    def test_explicit_groq_no_fallback_to_openai(self, monkeypatch):
+        monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        monkeypatch.setenv("OPENAI_API_KEY", "sk-real-key")
         with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
              patch("tools.transcription_tools._HAS_OPENAI", True):
             from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "openai"}) == "local_command"
+            result = _get_provider({"provider": "groq"})
+            assert result == "none"
+
+    def test_explicit_openai_no_fallback_to_groq(self, monkeypatch):
+        monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+        monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
+        monkeypatch.setenv("GROQ_API_KEY", "gsk-test")
+        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
+             patch("tools.transcription_tools._HAS_OPENAI", True):
+            from tools.transcription_tools import _get_provider
+            result = _get_provider({"provider": "openai"})
+            assert result == "none"
+
+    def test_auto_detect_still_falls_back_to_cloud(self, monkeypatch):
+        """When no provider is explicitly set, auto-detect cloud fallback works."""
+        monkeypatch.setenv("OPENAI_API_KEY", "sk-real-key")
+        monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
+             patch("tools.transcription_tools._HAS_OPENAI", True):
+            from tools.transcription_tools import _get_provider
+            # Empty dict = no explicit provider, uses DEFAULT_PROVIDER auto-detect
+            result = _get_provider({})
+            assert result == "openai"
+
+    def test_auto_detect_prefers_groq_over_openai(self, monkeypatch):
+        monkeypatch.setenv("GROQ_API_KEY", "gsk-test")
+        monkeypatch.setenv("OPENAI_API_KEY", "sk-real-key")
+        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
+             patch("tools.transcription_tools._HAS_OPENAI", True):
+            from tools.transcription_tools import _get_provider
+            result = _get_provider({})
+            assert result == "groq"
 
 
 # ============================================================================
@@ -686,28 +733,19 @@ class TestTranscribeAudioDispatch:
         assert "faster-whisper" in result["error"]
         assert "GROQ_API_KEY" in result["error"]
 
-    def test_openai_provider_falls_back_to_local_command(self, monkeypatch, sample_ogg):
+    def test_explicit_openai_no_key_returns_error(self, monkeypatch, sample_ogg):
+        """Explicit provider=openai with no key returns an error, not a fallback."""
         monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
         monkeypatch.delenv("OPENAI_API_KEY", raising=False)
-        monkeypatch.setenv(
-            "HERMES_LOCAL_STT_COMMAND",
-            "whisper {input_path} --model {model} --output_dir {output_dir} --language {language}",
-        )
 
         with patch("tools.transcription_tools._load_stt_config", return_value={"provider": "openai"}), \
              patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
-             patch("tools.transcription_tools._HAS_OPENAI", True), \
-             patch("tools.transcription_tools._transcribe_local_command", return_value={
-                 "success": True,
-                 "transcript": "hello from fallback",
-                 "provider": "local_command",
-             }) as mock_local_command:
+             patch("tools.transcription_tools._HAS_OPENAI", True):
             from tools.transcription_tools import transcribe_audio
             result = transcribe_audio(sample_ogg)
 
-        assert result["success"] is True
-        assert result["transcript"] == "hello from fallback"
-        mock_local_command.assert_called_once_with(sample_ogg, "base")
+        assert result["success"] is False
+        assert "No STT provider" in result["error"]
 
     def test_invalid_file_short_circuits(self):
         from tools.transcription_tools import transcribe_audio

tools/delegate_tool.py

@@ -171,6 +171,11 @@ def _build_child_agent(
     model on OpenRouter while the parent runs on Nous Portal).
     """
     from run_agent import AIAgent
+    import model_tools
+
+    # Save the parent's resolved tool names before the child agent can
+    # overwrite the process-global via get_tool_definitions().
+    _saved_tool_names = list(model_tools._last_resolved_tool_names)
 
     # When no explicit toolsets given, inherit from parent's enabled toolsets
     # so disabled tools (e.g. web) don't leak to subagents.
@@ -365,6 +370,10 @@ def _run_single_child(
         }
 
     finally:
+        # Restore the parent's tool names so the process-global is correct
+        # for any subsequent execute_code calls or other consumers.
+        model_tools._last_resolved_tool_names = _saved_tool_names
+
         # Unregister child from interrupt propagation
         if hasattr(parent_agent, '_active_children'):
             try:

tools/send_message_tool.py

@@ -134,7 +134,7 @@ def _handle_send(args):
 
     pconfig = config.platforms.get(platform)
     if not pconfig or not pconfig.enabled:
-        return json.dumps({"error": f"Platform '{platform_name}' is not configured. Set up credentials in ~/.hermes/gateway.json or environment variables."})
+        return json.dumps({"error": f"Platform '{platform_name}' is not configured. Set up credentials in ~/.hermes/config.yaml or environment variables."})
 
     from gateway.platforms.base import BasePlatformAdapter
 
@@ -331,6 +331,8 @@ async def _send_to_platform(platform, pconfig, chat_id, message, thread_id=None,
             result = await _send_discord(pconfig.token, chat_id, chunk)
         elif platform == Platform.SLACK:
             result = await _send_slack(pconfig.token, chat_id, chunk)
+        elif platform == Platform.WHATSAPP:
+            result = await _send_whatsapp(pconfig.extra, chat_id, chunk)
         elif platform == Platform.SIGNAL:
             result = await _send_signal(pconfig.extra, chat_id, chunk)
         elif platform == Platform.EMAIL:
@@ -514,6 +516,34 @@ async def _send_slack(token, chat_id, message):
         return {"error": f"Slack send failed: {e}"}
 
 
+async def _send_whatsapp(extra, chat_id, message):
+    """Send via the local WhatsApp bridge HTTP API."""
+    try:
+        import aiohttp
+    except ImportError:
+        return {"error": "aiohttp not installed. Run: pip install aiohttp"}
+    try:
+        bridge_port = extra.get("bridge_port", 3000)
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"http://localhost:{bridge_port}/send",
+                json={"chatId": chat_id, "message": message},
+                timeout=aiohttp.ClientTimeout(total=30),
+            ) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    return {
+                        "success": True,
+                        "platform": "whatsapp",
+                        "chat_id": chat_id,
+                        "message_id": data.get("messageId"),
+                    }
+                body = await resp.text()
+                return {"error": f"WhatsApp bridge error ({resp.status}): {body}"}
+    except Exception as e:
+        return {"error": f"WhatsApp send failed: {e}"}
+
+
 async def _send_signal(extra, chat_id, message):
     """Send via signal-cli JSON-RPC API."""
     try:

tools/transcription_tools.py

@@ -164,76 +164,72 @@ def _normalize_local_command_model(model_name: Optional[str]) -> str:
 def _get_provider(stt_config: dict) -> str:
     """Determine which STT provider to use.
 
-    Priority:
-      1. Explicit config value  (``stt.provider``)
-      2. Auto-detect: local > groq (free) > openai (paid)
-      3. Disabled (returns "none")
+    When ``stt.provider`` is explicitly set in config, that choice is
+    honoured — no silent cloud fallback.  When no provider is configured,
+    auto-detect tries: local > groq (free) > openai (paid).
     """
     if not is_stt_enabled(stt_config):
         return "none"
 
+    explicit = "provider" in stt_config
     provider = stt_config.get("provider", DEFAULT_PROVIDER)
 
-    if provider == "local":
-        if _HAS_FASTER_WHISPER:
-            return "local"
-        if _has_local_command():
-            logger.info("faster-whisper not installed, falling back to local STT command")
-            return "local_command"
-        # Local requested but not available — fall back to groq, then openai
-        if _HAS_OPENAI and os.getenv("GROQ_API_KEY"):
-            logger.info("faster-whisper not installed, falling back to Groq Whisper API")
-            return "groq"
-        if _HAS_OPENAI and _resolve_openai_api_key():
-            logger.info("faster-whisper not installed, falling back to OpenAI Whisper API")
-            return "openai"
-        return "none"
+    # --- Explicit provider: respect the user's choice ----------------------
 
-    if provider == "local_command":
-        if _has_local_command():
-            return "local_command"
-        if _HAS_FASTER_WHISPER:
-            logger.info("Local STT command unavailable, falling back to local faster-whisper")
-            return "local"
-        if _HAS_OPENAI and os.getenv("GROQ_API_KEY"):
-            logger.info("Local STT command unavailable, falling back to Groq Whisper API")
-            return "groq"
-        if _HAS_OPENAI and _resolve_openai_api_key():
-            logger.info("Local STT command unavailable, falling back to OpenAI Whisper API")
-            return "openai"
-        return "none"
+    if explicit:
+        if provider == "local":
+            if _HAS_FASTER_WHISPER:
+                return "local"
+            if _has_local_command():
+                return "local_command"
+            logger.warning(
+                "STT provider 'local' configured but unavailable "
+                "(install faster-whisper or set HERMES_LOCAL_STT_COMMAND)"
+            )
+            return "none"
 
-    if provider == "groq":
-        if _HAS_OPENAI and os.getenv("GROQ_API_KEY"):
-            return "groq"
-        # Groq requested but no key — fall back
-        if _HAS_FASTER_WHISPER:
-            logger.info("GROQ_API_KEY not set, falling back to local faster-whisper")
-            return "local"
-        if _has_local_command():
-            logger.info("GROQ_API_KEY not set, falling back to local STT command")
-            return "local_command"
-        if _HAS_OPENAI and _resolve_openai_api_key():
-            logger.info("GROQ_API_KEY not set, falling back to OpenAI Whisper API")
-            return "openai"
-        return "none"
+        if provider == "local_command":
+            if _has_local_command():
+                return "local_command"
+            if _HAS_FASTER_WHISPER:
+                logger.info("Local STT command unavailable, using local faster-whisper")
+                return "local"
+            logger.warning(
+                "STT provider 'local_command' configured but unavailable"
+            )
+            return "none"
 
-    if provider == "openai":
-        if _HAS_OPENAI and _resolve_openai_api_key():
-            return "openai"
-        # OpenAI requested but no key — fall back
-        if _HAS_FASTER_WHISPER:
-            logger.info("OpenAI STT key not set, falling back to local faster-whisper")
-            return "local"
-        if _has_local_command():
-            logger.info("OpenAI STT key not set, falling back to local STT command")
-            return "local_command"
-        if _HAS_OPENAI and os.getenv("GROQ_API_KEY"):
-            logger.info("OpenAI STT key not set, falling back to Groq Whisper API")
-            return "groq"
-        return "none"
+        if provider == "groq":
+            if _HAS_OPENAI and os.getenv("GROQ_API_KEY"):
+                return "groq"
+            logger.warning(
+                "STT provider 'groq' configured but GROQ_API_KEY not set"
+            )
+            return "none"
 
-    return provider  # Unknown — let it fail downstream
+        if provider == "openai":
+            if _HAS_OPENAI and _resolve_openai_api_key():
+                return "openai"
+            logger.warning(
+                "STT provider 'openai' configured but no API key available"
+            )
+            return "none"
+
+        return provider  # Unknown — let it fail downstream
+
+    # --- Auto-detect (no explicit provider): local > groq > openai ---------
+
+    if _HAS_FASTER_WHISPER:
+        return "local"
+    if _has_local_command():
+        return "local_command"
+    if _HAS_OPENAI and os.getenv("GROQ_API_KEY"):
+        logger.info("No local STT available, using Groq Whisper API")
+        return "groq"
+    if _HAS_OPENAI and _resolve_openai_api_key():
+        logger.info("No local STT available, using OpenAI Whisper API")
+        return "openai"
+    return "none"
 
 # ---------------------------------------------------------------------------
 # Shared validation

toolsets.py

@@ -304,16 +304,10 @@ TOOLSETS = {
         "includes": []
     },
 
-    "hermes-http_server": {
-        "description": "HTTP server toolset - interact with Hermes via OpenAI-compatible HTTP API",
-        "tools": _HERMES_CORE_TOOLS,
-        "includes": []
-    },
-
     "hermes-gateway": {
         "description": "Gateway toolset - union of all messaging platform tools",
         "tools": [],
-        "includes": ["hermes-telegram", "hermes-discord", "hermes-whatsapp", "hermes-slack", "hermes-signal", "hermes-homeassistant", "hermes-email", "hermes-sms", "hermes-http_server"]
+        "includes": ["hermes-telegram", "hermes-discord", "hermes-whatsapp", "hermes-slack", "hermes-signal", "hermes-homeassistant", "hermes-email", "hermes-sms"]
     }
 }
 

website/docs/reference/environment-variables.md

@@ -192,6 +192,10 @@ For native Anthropic auth, Hermes prefers Claude Code's own credential files whe
 | `MATRIX_ENCRYPTION` | Enable end-to-end encryption (`true`/`false`, default: `false`) |
 | `HASS_TOKEN` | Home Assistant Long-Lived Access Token (enables HA platform + tools) |
 | `HASS_URL` | Home Assistant URL (default: `http://homeassistant.local:8123`) |
+| `API_SERVER_ENABLED` | Enable the OpenAI-compatible API server (`true`/`false`). Runs alongside other platforms. |
+| `API_SERVER_KEY` | Bearer token for API server authentication. If empty, all requests are allowed (local-only use). |
+| `API_SERVER_PORT` | Port for the API server (default: `8642`) |
+| `API_SERVER_HOST` | Host/bind address for the API server (default: `127.0.0.1`). Use `0.0.0.0` for network access — set `API_SERVER_KEY` for security. |
 | `MESSAGING_CWD` | Working directory for terminal commands in messaging mode (default: `~`) |
 | `GATEWAY_ALLOWED_USERS` | Comma-separated user IDs allowed across all platforms |
 | `GATEWAY_ALLOW_ALL_USERS` | Allow all users without allowlists (`true`/`false`, default: `false`) |

website/docs/user-guide/features/api-server.md

@@ -1,23 +1,23 @@
 ---
 sidebar_position: 14
-title: "HTTP Server"
+title: "API Server"
 description: "Expose hermes-agent as an OpenAI-compatible API for any frontend"
 ---
 
-# HTTP Server
+# API Server
 
-The HTTP server exposes hermes-agent as an OpenAI-compatible HTTP endpoint. Any frontend that speaks the OpenAI format — Open WebUI, LobeChat, LibreChat, NextChat, ChatBox, and hundreds more — can connect to hermes-agent and use it as a backend.
+The API server exposes hermes-agent as an OpenAI-compatible HTTP endpoint. Any frontend that speaks the OpenAI format — Open WebUI, LobeChat, LibreChat, NextChat, ChatBox, and hundreds more — can connect to hermes-agent and use it as a backend.
 
 Your agent handles requests with its full toolset (terminal, file operations, web search, memory, skills) and returns the final response. Tool calls execute invisibly server-side.
 
 ## Quick Start
 
-### 1. Enable the HTTP server
+### 1. Enable the API server
 
 Add to `~/.hermes/.env`:
 
 ```bash
-HTTP_SERVER_ENABLED=true
+API_SERVER_ENABLED=true
 ```
 
 ### 2. Start the gateway
@@ -29,7 +29,7 @@ hermes gateway
 You'll see:
 
 ```
-[HTTP Server] HTTP server listening on http://127.0.0.1:8642
+[API Server] API server listening on http://127.0.0.1:8642
 ```
 
 ### 3. Connect a frontend
@@ -136,11 +136,11 @@ Use the `conversation` parameter instead of tracking response IDs:
 
 The server automatically chains to the latest response in that conversation. Like the `/title` command for gateway sessions.
 
-### GET /v1/responses/{id}
+### GET /v1/responses/\{id\}
 
 Retrieve a previously stored response by ID.
 
-### DELETE /v1/responses/{id}
+### DELETE /v1/responses/\{id\}
 
 Delete a stored response.
 
@@ -168,10 +168,10 @@ Bearer token auth via the `Authorization` header:
 Authorization: Bearer ***
 ```
 
-Configure the key via `HTTP_SERVER_KEY` env var. If no key is set, all requests are allowed (for local-only use).
+Configure the key via `API_SERVER_KEY` env var. If no key is set, all requests are allowed (for local-only use).
 
 :::warning Security
-The HTTP server gives full access to hermes-agent's toolset, **including terminal commands**. If you change the bind address to `0.0.0.0` (network-accessible), **always set `HTTP_SERVER_KEY`** — without it, anyone on your network can execute arbitrary commands on your machine.
+The API server gives full access to hermes-agent's toolset, **including terminal commands**. If you change the bind address to `0.0.0.0` (network-accessible), **always set `API_SERVER_KEY`** — without it, anyone on your network can execute arbitrary commands on your machine.
 
 The default bind address (`127.0.0.1`) is safe for local-only use.
 :::
@@ -182,10 +182,10 @@ The default bind address (`127.0.0.1`) is safe for local-only use.
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `HTTP_SERVER_ENABLED` | `false` | Enable the HTTP server |
-| `HTTP_SERVER_PORT` | `8642` | HTTP server port |
-| `HTTP_SERVER_HOST` | `127.0.0.1` | Bind address (localhost only by default) |
-| `HTTP_SERVER_KEY` | _(none)_ | Bearer token for auth |
+| `API_SERVER_ENABLED` | `false` | Enable the API server |
+| `API_SERVER_PORT` | `8642` | HTTP server port |
+| `API_SERVER_HOST` | `127.0.0.1` | Bind address (localhost only by default) |
+| `API_SERVER_KEY` | _(none)_ | Bearer token for auth |
 
 ### config.yaml
 
@@ -196,7 +196,7 @@ The default bind address (`127.0.0.1`) is safe for local-only use.
 
 ## CORS
 
-The HTTP server includes CORS headers on all responses (`Access-Control-Allow-Origin: *`), so browser-based frontends can connect directly.
+The API server includes CORS headers on all responses (`Access-Control-Allow-Origin: *`), so browser-based frontends can connect directly.
 
 ## Compatible Frontends
 

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

@@ -1,7 +1,7 @@
 ---
 sidebar_position: 1
 title: "Messaging Gateway"
-description: "Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal, SMS, Email, Home Assistant, Mattermost, Matrix, DingTalk, or any OpenAI-compatible frontend — architecture and setup overview"
+description: "Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal, SMS, Email, Home Assistant, Mattermost, Matrix, DingTalk, or any OpenAI-compatible frontend via the API server — architecture and setup overview"
 ---
 
 # Messaging Gateway
@@ -27,6 +27,7 @@ flowchart TB
             mm[Mattermost]
             mx[Matrix]
             dt[DingTalk]
+            api["API Server<br/>(OpenAI-compatible)"]
         end
 
         store["Session store<br/>per chat"]
@@ -45,6 +46,7 @@ flowchart TB
     mm --> store
     mx --> store
     dt --> store
+    api --> store
     store --> agent
     cron --> store
 ```
@@ -306,7 +308,7 @@ Each platform has its own toolset:
 | Mattermost | `hermes-mattermost` | Full tools including terminal |
 | Matrix | `hermes-matrix` | Full tools including terminal |
 | DingTalk | `hermes-dingtalk` | Full tools including terminal |
-| HTTP Server | `hermes-http_server` | Full tools including terminal |
+| API Server | `hermes` (default) | Full tools including terminal |
 
 ## Next Steps
 
@@ -321,5 +323,4 @@ Each platform has its own toolset:
 - [Mattermost Setup](mattermost.md)
 - [Matrix Setup](matrix.md)
 - [DingTalk Setup](dingtalk.md)
-- [Open WebUI Setup](open-webui.md)
-- [HTTP Server](../features/http-server.md)
+- [Open WebUI + API Server](open-webui.md)

website/docs/user-guide/messaging/open-webui.md

@@ -1,35 +1,35 @@
 ---
 sidebar_position: 8
 title: "Open WebUI"
-description: "Connect Open WebUI to Hermes Agent via the OpenAI-compatible HTTP server"
+description: "Connect Open WebUI to Hermes Agent via the OpenAI-compatible API server"
 ---
 
 # Open WebUI Integration
 
-[Open WebUI](https://github.com/open-webui/open-webui) (126k★) is the most popular self-hosted chat interface for AI. With Hermes Agent's built-in HTTP server, you can use Open WebUI as a polished web frontend for your agent — complete with conversation management, user accounts, and a modern chat interface.
+[Open WebUI](https://github.com/open-webui/open-webui) (126k★) is the most popular self-hosted chat interface for AI. With Hermes Agent's built-in API server, you can use Open WebUI as a polished web frontend for your agent — complete with conversation management, user accounts, and a modern chat interface.
 
 ## Architecture
 
 ```
 ┌──────────────────┐    POST /v1/chat/completions    ┌──────────────────────┐
 │   Open WebUI     │ ──────────────────────────────► │  hermes-agent        │
-│   (browser UI)   │    SSE streaming response       │  gateway HTTP server  │
+│   (browser UI)   │    SSE streaming response       │  gateway API server  │
 │   port 3000      │ ◄────────────────────────────── │  port 8642           │
 └──────────────────┘                                  └──────────────────────┘
 ```
 
-Open WebUI connects to Hermes Agent's HTTP server just like it would connect to OpenAI. Your agent handles the requests with its full toolset — terminal, file operations, web search, memory, skills — and returns the final response.
+Open WebUI connects to Hermes Agent's API server just like it would connect to OpenAI. Your agent handles the requests with its full toolset — terminal, file operations, web search, memory, skills — and returns the final response.
 
 ## Quick Setup
 
-### 1. Enable the HTTP server
+### 1. Enable the API server
 
 Add to `~/.hermes/.env`:
 
 ```bash
-HTTP_SERVER_ENABLED=true
+API_SERVER_ENABLED=true
 # Optional: set a key for auth (recommended if accessible beyond localhost)
-# HTTP_SERVER_KEY=your-secret-key
+# API_SERVER_KEY=your-secret-key
 ```
 
 ### 2. Start Hermes Agent gateway
@@ -41,7 +41,7 @@ hermes gateway
 You should see:
 
 ```
-[HTTP Server] HTTP server listening on http://127.0.0.1:8642
+[API Server] API server listening on http://127.0.0.1:8642
 ```
 
 ### 3. Start Open WebUI
@@ -57,7 +57,7 @@ docker run -d -p 3000:8080 \
   ghcr.io/open-webui/open-webui:main
 ```
 
-If you set an `HTTP_SERVER_KEY`, use it instead of `not-needed`:
+If you set an `API_SERVER_KEY`, use it instead of `not-needed`:
 
 ```bash
 -e OPENAI_API_KEY=your-secret-key
@@ -160,21 +160,21 @@ Your agent has access to all the same tools and capabilities as when using the C
 
 ## Configuration Reference
 
-### Hermes Agent (HTTP server)
+### Hermes Agent (API server)
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `HTTP_SERVER_ENABLED` | `false` | Enable the HTTP server |
-| `HTTP_SERVER_PORT` | `8642` | HTTP server port |
-| `HTTP_SERVER_HOST` | `127.0.0.1` | Bind address |
-| `HTTP_SERVER_KEY` | _(none)_ | Bearer token for auth. No key = allow all. |
+| `API_SERVER_ENABLED` | `false` | Enable the API server |
+| `API_SERVER_PORT` | `8642` | HTTP server port |
+| `API_SERVER_HOST` | `127.0.0.1` | Bind address |
+| `API_SERVER_KEY` | _(none)_ | Bearer token for auth. No key = allow all. |
 
 ### Open WebUI
 
 | Variable | Description |
 |----------|-------------|
 | `OPENAI_API_BASE_URL` | Hermes Agent's API URL (include `/v1`) |
-| `OPENAI_API_KEY` | Must be non-empty. Match your `HTTP_SERVER_KEY`. |
+| `OPENAI_API_KEY` | Must be non-empty. Match your `API_SERVER_KEY`. |
 
 ## Troubleshooting
 
@@ -195,7 +195,7 @@ Hermes Agent may be executing multiple tool calls (reading files, running comman
 
 ### "Invalid API key" errors
 
-Make sure your `OPENAI_API_KEY` in Open WebUI matches the `HTTP_SERVER_KEY` in Hermes Agent. If no key is configured on the Hermes side, any non-empty value works.
+Make sure your `OPENAI_API_KEY` in Open WebUI matches the `API_SERVER_KEY` in Hermes Agent. If no key is configured on the Hermes side, any non-empty value works.
 
 ## Linux Docker (no Docker Desktop)
 

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

@@ -140,7 +140,14 @@ Hermes supports voice on WhatsApp:
 
 - **Incoming:** Voice messages (`.ogg` opus) are automatically transcribed using the configured STT provider: local `faster-whisper`, Groq Whisper (`GROQ_API_KEY`), or OpenAI Whisper (`VOICE_TOOLS_OPENAI_KEY`)
 - **Outgoing:** TTS responses are sent as MP3 audio file attachments
-- Agent responses are prefixed with "⚕ **Hermes Agent**" for easy identification
+- Agent responses are prefixed with "⚕ **Hermes Agent**" by default. You can customize or disable this in `config.yaml`:
+
+```yaml
+# ~/.hermes/config.yaml
+whatsapp:
+  reply_prefix: ""                          # Empty string disables the header
+  # reply_prefix: "🤖 *My Bot*\n──────\n"  # Custom prefix (supports \n for newlines)
+```
 
 ---
 

website/sidebars.ts

@@ -51,6 +51,7 @@ const sidebars: SidebarsConfig = {
             'user-guide/messaging/mattermost',
             'user-guide/messaging/matrix',
             'user-guide/messaging/dingtalk',
+            'user-guide/messaging/open-webui',
           ],
         },
         {
@@ -90,6 +91,7 @@ const sidebars: SidebarsConfig = {
           type: 'category',
           label: 'Integrations',
           items: [
+            'user-guide/features/api-server',
             'user-guide/features/acp',
             'user-guide/features/mcp',
             'user-guide/features/honcho',