fix(docker): require explicit env allowlist for container creds

AGENTS.md

@@ -235,7 +235,6 @@ hermes_cli/skin_engine.py    # SkinConfig dataclass, built-in skins, YAML loader
 | Spinner verbs | `spinner.thinking_verbs` | `display.py` |
 | Spinner wings (optional) | `spinner.wings` | `display.py` |
 | Tool output prefix | `tool_prefix` | `display.py` |
-| Per-tool emojis | `tool_emojis` | `display.py` → `get_tool_emoji()` |
 | Agent name | `branding.agent_name` | `banner.py`, `cli.py` |
 | Welcome message | `branding.welcome` | `cli.py` |
 | Response box label | `branding.response_label` | `cli.py` |

agent/display.py

@@ -59,32 +59,6 @@ def get_skin_tool_prefix() -> str:
     return "┊"
 
 
-def get_tool_emoji(tool_name: str, default: str = "⚡") -> str:
-    """Get the display emoji for a tool.
-
-    Resolution order:
-    1. Active skin's ``tool_emojis`` overrides (if a skin is loaded)
-    2. Tool registry's per-tool ``emoji`` field
-    3. *default* fallback
-    """
-    # 1. Skin override
-    skin = _get_skin()
-    if skin and skin.tool_emojis:
-        override = skin.tool_emojis.get(tool_name)
-        if override:
-            return override
-    # 2. Registry default
-    try:
-        from tools.registry import registry
-        emoji = registry.get_emoji(tool_name, default="")
-        if emoji:
-            return emoji
-    except Exception:
-        pass
-    # 3. Hardcoded fallback
-    return default
-
-
 # =========================================================================
 # Tool preview (one-line summary of a tool call's primary argument)
 # =========================================================================

cli-config.yaml.example

@@ -107,6 +107,12 @@ terminal:
 #   timeout: 180
 #   lifetime_seconds: 300
 #   docker_image: "nikolaik/python-nodejs:python3.11-nodejs20"
+#   # Optional: explicitly forward selected env vars into Docker.
+#   # These values come from your current shell first, then ~/.hermes/.env.
+#   # Warning: anything forwarded here is visible to commands run in the container.
+#   docker_forward_env:
+#     - "GITHUB_TOKEN"
+#     - "NPM_TOKEN"
 
 # -----------------------------------------------------------------------------
 # OPTION 4: Singularity/Apptainer container

cli.py

@@ -158,6 +158,7 @@ def load_cli_config() -> Dict[str, Any]:
             "timeout": 60,
             "lifetime_seconds": 300,
             "docker_image": "python:3.11",
+            "docker_forward_env": [],
             "singularity_image": "docker://python:3.11",
             "modal_image": "python:3.11",
             "daytona_image": "nikolaik/python-nodejs:python3.11-nodejs20",
@@ -313,6 +314,7 @@ def load_cli_config() -> Dict[str, Any]:
         "timeout": "TERMINAL_TIMEOUT",
         "lifetime_seconds": "TERMINAL_LIFETIME_SECONDS",
         "docker_image": "TERMINAL_DOCKER_IMAGE",
+        "docker_forward_env": "TERMINAL_DOCKER_FORWARD_ENV",
         "singularity_image": "TERMINAL_SINGULARITY_IMAGE",
         "modal_image": "TERMINAL_MODAL_IMAGE",
         "daytona_image": "TERMINAL_DAYTONA_IMAGE",
@@ -1414,7 +1416,7 @@ class HermesCLI:
                 max_iterations=self.max_turns,
                 enabled_toolsets=self.enabled_toolsets,
                 verbose_logging=self.verbose,
-                quiet_mode=not self.verbose,
+                quiet_mode=True,
                 ephemeral_system_prompt=self.system_prompt if self.system_prompt else None,
                 prefill_messages=self.prefill_messages or None,
                 reasoning_config=self.reasoning_config,
@@ -1428,7 +1430,7 @@ class HermesCLI:
                 platform="cli",
                 session_db=self._session_db,
                 clarify_callback=self._clarify_callback,
-                reasoning_callback=self._on_reasoning if (self.show_reasoning or self.verbose) else None,
+                reasoning_callback=self._on_reasoning if self.show_reasoning else None,
                 honcho_session_key=None,  # resolved by run_agent via config sessions map / title
                 fallback_model=self._fallback_model,
                 thinking_callback=self._on_thinking,
@@ -3285,17 +3287,12 @@ class HermesCLI:
         if self.agent:
             self.agent.verbose_logging = self.verbose
             self.agent.quiet_mode = not self.verbose
-            # Auto-enable reasoning display in verbose mode
-            if self.verbose:
-                self.agent.reasoning_callback = self._on_reasoning
-            elif not self.show_reasoning:
-                self.agent.reasoning_callback = None
 
         labels = {
             "off": "[dim]Tool progress: OFF[/] — silent mode, just the final response.",
             "new": "[yellow]Tool progress: NEW[/] — show each new tool (skip repeats).",
             "all": "[green]Tool progress: ALL[/] — show every tool call.",
-            "verbose": "[bold green]Tool progress: VERBOSE[/] — full args, results, think blocks, and debug logs.",
+            "verbose": "[bold green]Tool progress: VERBOSE[/] — full args, results, and debug logs.",
         }
         self.console.print(labels.get(self.tool_progress_mode, ""))
 
@@ -3362,17 +3359,13 @@ class HermesCLI:
 
     def _on_reasoning(self, reasoning_text: str):
         """Callback for intermediate reasoning display during tool-call loops."""
-        if self.verbose:
-            # Verbose mode: show full reasoning text
-            _cprint(f"  {_DIM}[thinking] {reasoning_text.strip()}{_RST}")
+        lines = reasoning_text.strip().splitlines()
+        if len(lines) > 5:
+            preview = "\n".join(lines[:5])
+            preview += f"\n  ... ({len(lines) - 5} more lines)"
         else:
-            lines = reasoning_text.strip().splitlines()
-            if len(lines) > 5:
-                preview = "\n".join(lines[:5])
-                preview += f"\n  ... ({len(lines) - 5} more lines)"
-            else:
-                preview = reasoning_text.strip()
-            _cprint(f"  {_DIM}[thinking] {preview}{_RST}")
+            preview = reasoning_text.strip()
+        _cprint(f"  {_DIM}[thinking] {preview}{_RST}")
 
     def _manual_compress(self):
         """Manually trigger context compression on the current conversation."""
@@ -3493,56 +3486,6 @@ class HermesCLI:
         except Exception as e:
             print(f"  Error generating insights: {e}")
 
-    def _check_config_mcp_changes(self) -> None:
-        """Detect mcp_servers changes in config.yaml and auto-reload MCP connections.
-
-        Called from process_loop every CONFIG_WATCH_INTERVAL seconds.
-        Compares config.yaml mtime + mcp_servers section against the last
-        known state.  When a change is detected, triggers _reload_mcp() and
-        informs the user so they know the tool list has been refreshed.
-        """
-        import time
-        import yaml as _yaml
-
-        CONFIG_WATCH_INTERVAL = 5.0  # seconds between config.yaml stat() calls
-
-        now = time.monotonic()
-        if now - self._last_config_check < CONFIG_WATCH_INTERVAL:
-            return
-        self._last_config_check = now
-
-        from hermes_cli.config import get_config_path as _get_config_path
-        cfg_path = _get_config_path()
-        if not cfg_path.exists():
-            return
-
-        try:
-            mtime = cfg_path.stat().st_mtime
-        except OSError:
-            return
-
-        if mtime == self._config_mtime:
-            return  # File unchanged — fast path
-
-        # File changed — check whether mcp_servers section changed
-        self._config_mtime = mtime
-        try:
-            with open(cfg_path, encoding="utf-8") as f:
-                new_cfg = _yaml.safe_load(f) or {}
-        except Exception:
-            return
-
-        new_mcp = new_cfg.get("mcp_servers") or {}
-        if new_mcp == self._config_mcp_servers:
-            return  # mcp_servers unchanged (some other section was edited)
-
-        self._config_mcp_servers = new_mcp
-        # Notify user and reload
-        print()
-        print("🔄 MCP server config changed — reloading connections...")
-        with self._busy_command(self._slow_command_status("/reload-mcp")):
-            self._reload_mcp()
-
     def _reload_mcp(self):
         """Reload MCP servers: disconnect all, re-read config.yaml, reconnect.
 
@@ -4808,12 +4751,6 @@ class HermesCLI:
         self._interrupt_queue = queue.Queue()   # For messages typed while agent is running
         self._should_exit = False
         self._last_ctrl_c_time = 0  # Track double Ctrl+C for force exit
-        # Config file watcher — detect mcp_servers changes and auto-reload
-        from hermes_cli.config import get_config_path as _get_config_path
-        _cfg_path = _get_config_path()
-        self._config_mtime: float = _cfg_path.stat().st_mtime if _cfg_path.exists() else 0.0
-        self._config_mcp_servers: dict = self.config.get("mcp_servers") or {}
-        self._last_config_check: float = 0.0  # monotonic time of last check
 
         # Clarify tool state: interactive question/answer with the user.
         # When the agent calls the clarify tool, _clarify_state is set and
@@ -4862,7 +4799,7 @@ class HermesCLI:
         # Ensure tirith security scanner is available (downloads if needed)
         try:
             from tools.tirith_security import ensure_installed
-            ensure_installed(log_failures=False)
+            ensure_installed()
         except Exception:
             pass  # Non-fatal — fail-open at scan time if unavailable
         
@@ -5747,9 +5684,6 @@ class HermesCLI:
                     try:
                         user_input = self._pending_input.get(timeout=0.1)
                     except queue.Empty:
-                        # Periodic config watcher — auto-reload MCP on mcp_servers change
-                        if not self._agent_running:
-                            self._check_config_mcp_changes()
                         continue
                     
                     if not user_input:

gateway/platforms/telegram.py

@@ -322,14 +322,6 @@ class TelegramAdapter(BasePlatformAdapter):
             # Format and split message if needed
             formatted = self.format_message(content)
             chunks = self.truncate_message(formatted, self.MAX_MESSAGE_LENGTH)
-            if len(chunks) > 1:
-                # truncate_message appends a raw " (1/2)" suffix. Escape the
-                # MarkdownV2-special parentheses so Telegram doesn't reject the
-                # chunk and fall back to plain text.
-                chunks = [
-                    re.sub(r" \((\d+)/(\d+)\)$", r" \\(\1/\2\\)", chunk)
-                    for chunk in chunks
-                ]
             
             message_ids = []
             thread_id = metadata.get("thread_id") if metadata else None

gateway/run.py

@@ -64,6 +64,7 @@ if _config_path.exists():
                 "timeout": "TERMINAL_TIMEOUT",
                 "lifetime_seconds": "TERMINAL_LIFETIME_SECONDS",
                 "docker_image": "TERMINAL_DOCKER_IMAGE",
+                "docker_forward_env": "TERMINAL_DOCKER_FORWARD_ENV",
                 "singularity_image": "TERMINAL_SINGULARITY_IMAGE",
                 "modal_image": "TERMINAL_MODAL_IMAGE",
                 "daytona_image": "TERMINAL_DAYTONA_IMAGE",
@@ -305,7 +306,7 @@ class GatewayRunner:
         # Ensure tirith security scanner is available (downloads if needed)
         try:
             from tools.tirith_security import ensure_installed
-            ensure_installed(log_failures=False)
+            ensure_installed()
         except Exception:
             pass  # Non-fatal — fail-open at scan time if unavailable
         
@@ -1114,9 +1115,6 @@ class GatewayRunner:
         # let the adapter-level batching/queueing logic absorb them.
         _quick_key = build_session_key(source)
         if _quick_key in self._running_agents:
-            if event.get_command() == "status":
-                return await self._handle_status_command(event)
-
             if event.message_type == MessageType.PHOTO:
                 logger.debug("PRIORITY photo follow-up for session %s — queueing without interrupt", _quick_key[:20])
                 adapter = self.adapters.get(source.platform)
@@ -1825,8 +1823,6 @@ class GatewayRunner:
             # Update session with actual prompt token count and model from the agent
             self.session_store.update_session(
                 session_entry.session_key,
-                input_tokens=agent_result.get("input_tokens", 0),
-                output_tokens=agent_result.get("output_tokens", 0),
                 last_prompt_tokens=agent_result.get("last_prompt_tokens", 0),
                 model=agent_result.get("model"),
             )
@@ -3856,8 +3852,45 @@ class GatewayRunner:
             last_tool[0] = tool_name
             
             # Build progress message with primary argument preview
-            from agent.display import get_tool_emoji
-            emoji = get_tool_emoji(tool_name, default="⚙️")
+            tool_emojis = {
+                "terminal": "💻",
+                "process": "⚙️",
+                "web_search": "🔍",
+                "web_extract": "📄",
+                "read_file": "📖",
+                "write_file": "✍️",
+                "patch": "🔧",
+                "search": "🔎",
+                "search_files": "🔎",
+                "list_directory": "📂",
+                "image_generate": "🎨",
+                "text_to_speech": "🔊",
+                "browser_navigate": "🌐",
+                "browser_click": "👆",
+                "browser_type": "⌨️",
+                "browser_snapshot": "📸",
+                "browser_scroll": "📜",
+                "browser_back": "◀️",
+                "browser_press": "⌨️",
+                "browser_close": "🚪",
+                "browser_get_images": "🖼️",
+                "browser_vision": "👁️",
+                "moa_query": "🧠",
+                "mixture_of_agents": "🧠",
+                "vision_analyze": "👁️",
+                "skill_view": "📚",
+                "skills_list": "📋",
+                "todo": "📋",
+                "memory": "🧠",
+                "session_search": "🔍",
+                "send_message": "📨",
+                "cronjob": "⏰",
+                "execute_code": "🐍",
+                "delegate_task": "🔀",
+                "clarify": "❓",
+                "skill_manage": "📝",
+            }
+            emoji = tool_emojis.get(tool_name, "⚙️")
             
             # Verbose mode: show detailed arguments
             if progress_mode == "verbose" and args:
@@ -4139,15 +4172,11 @@ class GatewayRunner:
             # Return final response, or a message if something went wrong
             final_response = result.get("final_response")
 
-            # Extract actual token counts from the agent instance used for this run
+            # Extract last actual prompt token count from the agent's compressor
             _last_prompt_toks = 0
-            _input_toks = 0
-            _output_toks = 0
             _agent = agent_holder[0]
             if _agent and hasattr(_agent, "context_compressor"):
                 _last_prompt_toks = getattr(_agent.context_compressor, "last_prompt_tokens", 0)
-                _input_toks = getattr(_agent, "session_prompt_tokens", 0)
-                _output_toks = getattr(_agent, "session_completion_tokens", 0)
             _resolved_model = getattr(_agent, "model", None) if _agent else None
 
             if not final_response:
@@ -4159,8 +4188,6 @@ class GatewayRunner:
                     "tools": tools_holder[0] or [],
                     "history_offset": len(agent_history),
                     "last_prompt_tokens": _last_prompt_toks,
-                    "input_tokens": _input_toks,
-                    "output_tokens": _output_toks,
                     "model": _resolved_model,
                 }
             
@@ -4224,8 +4251,6 @@ class GatewayRunner:
                 "tools": tools_holder[0] or [],
                 "history_offset": len(agent_history),
                 "last_prompt_tokens": _last_prompt_toks,
-                "input_tokens": _input_toks,
-                "output_tokens": _output_toks,
                 "model": _resolved_model,
                 "session_id": effective_session_id,
             }

hermes_cli/config.py

@@ -106,6 +106,7 @@ DEFAULT_CONFIG = {
         "cwd": ".",  # Use current directory
         "timeout": 180,
         "docker_image": "nikolaik/python-nodejs:python3.11-nodejs20",
+        "docker_forward_env": [],
         "singularity_image": "docker://nikolaik/python-nodejs:python3.11-nodejs20",
         "modal_image": "nikolaik/python-nodejs:python3.11-nodejs20",
         "daytona_image": "nikolaik/python-nodejs:python3.11-nodejs20",
@@ -302,7 +303,7 @@ DEFAULT_CONFIG = {
     },
 
     # Config schema version - bump this when adding new required fields
-    "_config_version": 8,
+    "_config_version": 9,
 }
 
 # =============================================================================

hermes_cli/main.py

@@ -1112,32 +1112,8 @@ def _model_flow_custom(config):
 
     effective_key = api_key or current_key
 
-    from hermes_cli.models import probe_api_models
-
-    probe = probe_api_models(effective_key, effective_url)
-    if probe.get("used_fallback") and probe.get("resolved_base_url"):
-        print(
-            f"Warning: endpoint verification worked at {probe['resolved_base_url']}/models, "
-            f"not the exact URL you entered. Saving the working base URL instead."
-        )
-        effective_url = probe["resolved_base_url"]
-        if base_url:
-            base_url = effective_url
-    elif probe.get("models") is not None:
-        print(
-            f"Verified endpoint via {probe.get('probed_url')} "
-            f"({len(probe.get('models') or [])} model(s) visible)"
-        )
-    else:
-        print(
-            f"Warning: could not verify this endpoint via {probe.get('probed_url')}. "
-            f"Hermes will still save it."
-        )
-        if probe.get("suggested_base_url"):
-            print(f"  If this server expects /v1, try base URL: {probe['suggested_base_url']}")
-
     if base_url:
-        save_env_value("OPENAI_BASE_URL", effective_url)
+        save_env_value("OPENAI_BASE_URL", base_url)
     if api_key:
         save_env_value("OPENAI_API_KEY", api_key)
 

hermes_cli/models.py

@@ -308,62 +308,6 @@ def _fetch_anthropic_models(timeout: float = 5.0) -> Optional[list[str]]:
         return None
 
 
-def probe_api_models(
-    api_key: Optional[str],
-    base_url: Optional[str],
-    timeout: float = 5.0,
-) -> dict[str, Any]:
-    """Probe an OpenAI-compatible ``/models`` endpoint with light URL heuristics."""
-    normalized = (base_url or "").strip().rstrip("/")
-    if not normalized:
-        return {
-            "models": None,
-            "probed_url": None,
-            "resolved_base_url": "",
-            "suggested_base_url": None,
-            "used_fallback": False,
-        }
-
-    if normalized.endswith("/v1"):
-        alternate_base = normalized[:-3].rstrip("/")
-    else:
-        alternate_base = normalized + "/v1"
-
-    candidates: list[tuple[str, bool]] = [(normalized, False)]
-    if alternate_base and alternate_base != normalized:
-        candidates.append((alternate_base, True))
-
-    tried: list[str] = []
-    headers: dict[str, str] = {}
-    if api_key:
-        headers["Authorization"] = f"Bearer {api_key}"
-
-    for candidate_base, is_fallback in candidates:
-        url = candidate_base.rstrip("/") + "/models"
-        tried.append(url)
-        req = urllib.request.Request(url, headers=headers)
-        try:
-            with urllib.request.urlopen(req, timeout=timeout) as resp:
-                data = json.loads(resp.read().decode())
-                return {
-                    "models": [m.get("id", "") for m in data.get("data", [])],
-                    "probed_url": url,
-                    "resolved_base_url": candidate_base.rstrip("/"),
-                    "suggested_base_url": alternate_base if alternate_base != candidate_base else normalized,
-                    "used_fallback": is_fallback,
-                }
-        except Exception:
-            continue
-
-    return {
-        "models": None,
-        "probed_url": tried[-1] if tried else normalized.rstrip("/") + "/models",
-        "resolved_base_url": normalized,
-        "suggested_base_url": alternate_base if alternate_base != normalized else None,
-        "used_fallback": False,
-    }
-
-
 def fetch_api_models(
     api_key: Optional[str],
     base_url: Optional[str],
@@ -374,7 +318,22 @@ def fetch_api_models(
     Returns a list of model ID strings, or ``None`` if the endpoint could not
     be reached (network error, timeout, auth failure, etc.).
     """
-    return probe_api_models(api_key, base_url, timeout=timeout).get("models")
+    if not base_url:
+        return None
+
+    url = base_url.rstrip("/") + "/models"
+    headers: dict[str, str] = {}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    req = urllib.request.Request(url, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            data = json.loads(resp.read().decode())
+            # Standard OpenAI format: {"data": [{"id": "model-name", ...}, ...]}
+            return [m.get("id", "") for m in data.get("data", [])]
+    except Exception:
+        return None
 
 
 def validate_requested_model(
@@ -417,53 +376,13 @@ def validate_requested_model(
             "message": "Model names cannot contain spaces.",
         }
 
+    # Custom endpoints can serve any model — skip validation
     if normalized == "custom":
-        probe = probe_api_models(api_key, base_url)
-        api_models = probe.get("models")
-        if api_models is not None:
-            if requested in set(api_models):
-                return {
-                    "accepted": True,
-                    "persist": True,
-                    "recognized": True,
-                    "message": None,
-                }
-
-            suggestions = get_close_matches(requested, api_models, n=3, cutoff=0.5)
-            suggestion_text = ""
-            if suggestions:
-                suggestion_text = "\n  Similar models: " + ", ".join(f"`{s}`" for s in suggestions)
-
-            message = (
-                f"Note: `{requested}` was not found in this custom endpoint's model listing "
-                f"({probe.get('probed_url')}). It may still work if the server supports hidden or aliased models."
-                f"{suggestion_text}"
-            )
-            if probe.get("used_fallback"):
-                message += (
-                    f"\n  Endpoint verification succeeded after trying `{probe.get('resolved_base_url')}`. "
-                    f"Consider saving that as your base URL."
-                )
-
-            return {
-                "accepted": True,
-                "persist": True,
-                "recognized": False,
-                "message": message,
-            }
-
-        message = (
-            f"Note: could not reach this custom endpoint's model listing at `{probe.get('probed_url')}`. "
-            f"Hermes will still save `{requested}`, but the endpoint should expose `/models` for verification."
-        )
-        if probe.get("suggested_base_url"):
-            message += f"\n  If this server expects `/v1`, try base URL: `{probe.get('suggested_base_url')}`"
-
         return {
             "accepted": True,
             "persist": True,
             "recognized": False,
-            "message": message,
+            "message": None,
         }
 
     # Probe the live API to check if the model actually exists

hermes_cli/setup.py

@@ -227,86 +227,54 @@ def prompt(question: str, default: str = None, password: bool = False) -> str:
         sys.exit(1)
 
 
-def _curses_prompt_choice(question: str, choices: list, default: int = 0) -> int:
-    """Single-select menu using curses to avoid simple_term_menu rendering bugs."""
-    try:
-        import curses
-        result_holder = [default]
-
-        def _curses_menu(stdscr):
-            curses.curs_set(0)
-            if curses.has_colors():
-                curses.start_color()
-                curses.use_default_colors()
-                curses.init_pair(1, curses.COLOR_GREEN, -1)
-                curses.init_pair(2, curses.COLOR_YELLOW, -1)
-            cursor = default
-
-            while True:
-                stdscr.clear()
-                max_y, max_x = stdscr.getmaxyx()
-                try:
-                    stdscr.addnstr(
-                        0,
-                        0,
-                        question,
-                        max_x - 1,
-                        curses.A_BOLD | (curses.color_pair(2) if curses.has_colors() else 0),
-                    )
-                except curses.error:
-                    pass
-
-                for i, choice in enumerate(choices):
-                    y = i + 2
-                    if y >= max_y - 1:
-                        break
-                    arrow = "→" if i == cursor else " "
-                    line = f" {arrow}  {choice}"
-                    attr = curses.A_NORMAL
-                    if i == cursor:
-                        attr = curses.A_BOLD
-                        if curses.has_colors():
-                            attr |= curses.color_pair(1)
-                    try:
-                        stdscr.addnstr(y, 0, line, max_x - 1, attr)
-                    except curses.error:
-                        pass
-
-                stdscr.refresh()
-                key = stdscr.getch()
-                if key in (curses.KEY_UP, ord("k")):
-                    cursor = (cursor - 1) % len(choices)
-                elif key in (curses.KEY_DOWN, ord("j")):
-                    cursor = (cursor + 1) % len(choices)
-                elif key in (curses.KEY_ENTER, 10, 13):
-                    result_holder[0] = cursor
-                    return
-                elif key in (27, ord("q")):
-                    return
-
-        curses.wrapper(_curses_menu)
-        return result_holder[0]
-    except Exception:
-        return -1
-
-
-
 def prompt_choice(question: str, choices: list, default: int = 0) -> int:
     """Prompt for a choice from a list with arrow key navigation.
 
     Escape keeps the current default (skips the question).
     Ctrl+C exits the wizard.
     """
-    idx = _curses_prompt_choice(question, choices, default)
-    if idx >= 0:
-        if idx == default:
-            print_info("  Skipped (keeping current)")
+    print(color(question, Colors.YELLOW))
+
+    # Try to use interactive menu if available
+    try:
+        from simple_term_menu import TerminalMenu
+        import re
+
+        # Strip emoji characters — simple_term_menu miscalculates visual
+        # width of emojis, causing duplicated/garbled lines on redraw.
+        _emoji_re = re.compile(
+            "[\U0001f300-\U0001f9ff\U00002600-\U000027bf\U0000fe00-\U0000fe0f"
+            "\U0001fa00-\U0001fa6f\U0001fa70-\U0001faff\u200d]+",
+            flags=re.UNICODE,
+        )
+        menu_choices = [f"  {_emoji_re.sub('', choice).strip()}" for choice in choices]
+
+        print_info("  ↑/↓ Navigate  Enter Select  Esc Skip  Ctrl+C Exit")
+
+        terminal_menu = TerminalMenu(
+            menu_choices,
+            cursor_index=default,
+            menu_cursor="→ ",
+            menu_cursor_style=("fg_green", "bold"),
+            menu_highlight_style=("fg_green",),
+            cycle_cursor=True,
+            clear_screen=False,
+        )
+
+        idx = terminal_menu.show()
+        if idx is None:  # User pressed Escape — keep current value
+            print_info(f"  Skipped (keeping current)")
             print()
             return default
-        print()
+        print()  # Add newline after selection
         return idx
 
-    print(color(question, Colors.YELLOW))
+    except (ImportError, NotImplementedError):
+        pass
+    except Exception as e:
+        print(f"  (Interactive menu unavailable: {e})")
+
+    # Fallback to number-based selection (simple_term_menu doesn't support Windows)
     for i, choice in enumerate(choices):
         marker = "●" if i == default else "○"
         if i == default:
@@ -376,15 +344,84 @@ def prompt_checklist(title: str, items: list, pre_selected: list = None) -> list
     if pre_selected is None:
         pre_selected = []
 
-    from hermes_cli.curses_ui import curses_checklist
+    print(color(title, Colors.YELLOW))
+    print_info("  SPACE Toggle  ENTER Confirm  ESC Skip  Ctrl+C Exit")
+    print()
 
-    chosen = curses_checklist(
-        title,
-        items,
-        set(pre_selected),
-        cancel_returns=set(pre_selected),
-    )
-    return sorted(chosen)
+    try:
+        from simple_term_menu import TerminalMenu
+        import re
+
+        # Strip emoji characters from menu labels — simple_term_menu miscalculates
+        # visual width of emojis on macOS, causing duplicated/garbled lines.
+        _emoji_re = re.compile(
+            "[\U0001f300-\U0001f9ff\U00002600-\U000027bf\U0000fe00-\U0000fe0f"
+            "\U0001fa00-\U0001fa6f\U0001fa70-\U0001faff\u200d]+",
+            flags=re.UNICODE,
+        )
+        menu_items = [f"  {_emoji_re.sub('', item).strip()}" for item in items]
+
+        # Map pre-selected indices to the actual menu entry strings
+        preselected = [menu_items[i] for i in pre_selected if i < len(menu_items)]
+
+        terminal_menu = TerminalMenu(
+            menu_items,
+            multi_select=True,
+            show_multi_select_hint=False,
+            multi_select_cursor="[✓] ",
+            multi_select_select_on_accept=False,
+            multi_select_empty_ok=True,
+            preselected_entries=preselected if preselected else None,
+            menu_cursor="→ ",
+            menu_cursor_style=("fg_green", "bold"),
+            menu_highlight_style=("fg_green",),
+            cycle_cursor=True,
+            clear_screen=False,
+        )
+
+        terminal_menu.show()
+
+        if terminal_menu.chosen_menu_entries is None:
+            print_info("  Skipped (keeping current)")
+            return list(pre_selected)
+
+        selected = list(terminal_menu.chosen_menu_indices or [])
+        return selected
+
+    except (ImportError, NotImplementedError):
+        # Fallback: numbered toggle interface (simple_term_menu doesn't support Windows)
+        selected = set(pre_selected)
+
+        while True:
+            for i, item in enumerate(items):
+                marker = color("[✓]", Colors.GREEN) if i in selected else "[ ]"
+                print(f"  {marker} {i + 1}. {item}")
+            print()
+
+            try:
+                value = input(
+                    color("  Toggle # (or Enter to confirm): ", Colors.DIM)
+                ).strip()
+                if not value:
+                    break
+                idx = int(value) - 1
+                if 0 <= idx < len(items):
+                    if idx in selected:
+                        selected.discard(idx)
+                    else:
+                        selected.add(idx)
+                else:
+                    print_error(f"Enter a number between 1 and {len(items)}")
+            except ValueError:
+                print_error("Enter a number")
+            except (KeyboardInterrupt, EOFError):
+                print()
+                return []
+
+            # Clear and redraw (simple approach)
+            print()
+
+        return sorted(selected)
 
 
 def _prompt_api_key(var: dict):
@@ -896,35 +933,11 @@ def setup_model_provider(config: dict):
 
         base_url = prompt(
             "  API base URL (e.g., https://api.example.com/v1)", current_url
-        ).strip()
+        )
         api_key = prompt("  API key", password=True)
         model_name = prompt("  Model name (e.g., gpt-4, claude-3-opus)", current_model)
 
         if base_url:
-            from hermes_cli.models import probe_api_models
-
-            probe = probe_api_models(api_key, base_url)
-            if probe.get("used_fallback") and probe.get("resolved_base_url"):
-                print_warning(
-                    f"Endpoint verification worked at {probe['resolved_base_url']}/models, "
-                    f"not the exact URL you entered. Saving the working base URL instead."
-                )
-                base_url = probe["resolved_base_url"]
-            elif probe.get("models") is not None:
-                print_success(
-                    f"Verified endpoint via {probe.get('probed_url')} "
-                    f"({len(probe.get('models') or [])} model(s) visible)"
-                )
-            else:
-                print_warning(
-                    f"Could not verify this endpoint via {probe.get('probed_url')}. "
-                    f"Hermes will still save it."
-                )
-                if probe.get("suggested_base_url"):
-                    print_info(
-                        f"  If this server expects /v1, try base URL: {probe['suggested_base_url']}"
-                    )
-
             save_env_value("OPENAI_BASE_URL", base_url)
         if api_key:
             save_env_value("OPENAI_API_KEY", api_key)

hermes_cli/skin_engine.py

@@ -60,12 +60,6 @@ All fields are optional. Missing values inherit from the ``default`` skin.
     # Tool prefix: character for tool output lines (default: ┊)
     tool_prefix: "┊"
 
-    # Tool emojis: override the default emoji for any tool (used in spinners & progress)
-    tool_emojis:
-      terminal: "⚔"           # Override terminal tool emoji
-      web_search: "🔮"        # Override web_search tool emoji
-      # Any tool not listed here uses its registry default
-
 USAGE
 =====
 
@@ -117,7 +111,6 @@ class SkinConfig:
     spinner: Dict[str, Any] = field(default_factory=dict)
     branding: Dict[str, str] = field(default_factory=dict)
     tool_prefix: str = "┊"
-    tool_emojis: Dict[str, str] = field(default_factory=dict)  # per-tool emoji overrides
     banner_logo: str = ""    # Rich-markup ASCII art logo (replaces HERMES_AGENT_LOGO)
     banner_hero: str = ""    # Rich-markup hero art (replaces HERMES_CADUCEUS)
 
@@ -548,7 +541,6 @@ def _build_skin_config(data: Dict[str, Any]) -> SkinConfig:
         spinner=spinner,
         branding=branding,
         tool_prefix=data.get("tool_prefix", default.get("tool_prefix", "┊")),
-        tool_emojis=data.get("tool_emojis", {}),
         banner_logo=data.get("banner_logo", ""),
         banner_hero=data.get("banner_hero", ""),
     )

honcho_integration/session.py

@@ -927,11 +927,6 @@ class HonchoSessionManager:
             return False
 
         assistant_peer = self._get_or_create_peer(session.assistant_peer_id)
-        honcho_session = self._sessions_cache.get(session.honcho_session_id)
-        if not honcho_session:
-            logger.warning("No Honcho session cached for '%s', skipping AI seed", session_key)
-            return False
-
         try:
             wrapped = (
                 f"<ai_identity_seed>\n"
@@ -940,7 +935,7 @@ class HonchoSessionManager:
                 f"{content.strip()}\n"
                 f"</ai_identity_seed>"
             )
-            honcho_session.add_messages([assistant_peer.message(wrapped)])
+            assistant_peer.add_message("assistant", wrapped)
             logger.info("Seeded AI identity from '%s' into %s", source, session_key)
             return True
         except Exception as e:

run_agent.py

@@ -90,7 +90,6 @@ from agent.display import (
     KawaiiSpinner, build_tool_preview as _build_tool_preview,
     get_cute_tool_message as _get_cute_tool_message_impl,
     _detect_tool_failure,
-    get_tool_emoji as _get_tool_emoji,
 )
 from agent.trajectory import (
     convert_scratchpad_to_think, has_incomplete_scratchpad,
@@ -3302,7 +3301,8 @@ class AIAgent:
             extra_body["provider"] = provider_preferences
         _is_nous = "nousresearch" in self.base_url.lower()
 
-        if self._supports_reasoning_extra_body():
+        _is_mistral = "api.mistral.ai" in self.base_url.lower()
+        if (_is_openrouter or _is_nous) and not _is_mistral:
             if self.reasoning_config is not None:
                 rc = dict(self.reasoning_config)
                 # Nous Portal requires reasoning enabled — don't send
@@ -3326,32 +3326,6 @@ class AIAgent:
 
         return api_kwargs
 
-    def _supports_reasoning_extra_body(self) -> bool:
-        """Return True when reasoning extra_body is safe to send for this route/model.
-
-        OpenRouter forwards unknown extra_body fields to upstream providers.
-        Some providers/routes reject `reasoning` with 400s, so gate it to
-        known reasoning-capable model families and direct Nous Portal.
-        """
-        base_url = (self.base_url or "").lower()
-        if "nousresearch" in base_url:
-            return True
-        if "openrouter" not in base_url:
-            return False
-        if "api.mistral.ai" in base_url:
-            return False
-
-        model = (self.model or "").lower()
-        reasoning_model_prefixes = (
-            "deepseek/",
-            "anthropic/",
-            "openai/",
-            "x-ai/",
-            "google/gemini-2",
-            "qwen/qwen3",
-        )
-        return any(model.startswith(prefix) for prefix in reasoning_model_prefixes)
-
     def _build_assistant_message(self, assistant_message, finish_reason: str) -> dict:
         """Build a normalized assistant message dict from an API response message.
 
@@ -3371,7 +3345,8 @@ class AIAgent:
                 reasoning_text = combined or None
 
         if reasoning_text and self.verbose_logging:
-            logging.debug(f"Captured reasoning ({len(reasoning_text)} chars): {reasoning_text}")
+            preview = reasoning_text[:100] + "..." if len(reasoning_text) > 100 else reasoning_text
+            logging.debug(f"Captured reasoning ({len(reasoning_text)} chars): {preview}")
 
         if reasoning_text and self.reasoning_callback:
             try:
@@ -3848,12 +3823,8 @@ class AIAgent:
             print(f"  ⚡ Concurrent: {num_tools} tool calls — {tool_names_str}")
             for i, (tc, name, args) in enumerate(parsed_calls, 1):
                 args_str = json.dumps(args, ensure_ascii=False)
-                if self.verbose_logging:
-                    print(f"  📞 Tool {i}: {name}({list(args.keys())})")
-                    print(f"     Args: {args_str}")
-                else:
-                    args_preview = args_str[:self.log_prefix_chars] + "..." if len(args_str) > self.log_prefix_chars else args_str
-                    print(f"  📞 Tool {i}: {name}({list(args.keys())}) - {args_preview}")
+                args_preview = args_str[:self.log_prefix_chars] + "..." if len(args_str) > self.log_prefix_chars else args_str
+                print(f"  📞 Tool {i}: {name}({list(args.keys())}) - {args_preview}")
 
         for _, name, args in parsed_calls:
             if self.tool_progress_callback:
@@ -3918,20 +3889,17 @@ class AIAgent:
                     logger.warning("Tool %s returned error (%.2fs): %s", function_name, tool_duration, result_preview)
 
                 if self.verbose_logging:
+                    result_preview = function_result[:200] if len(function_result) > 200 else function_result
                     logging.debug(f"Tool {function_name} completed in {tool_duration:.2f}s")
-                    logging.debug(f"Tool result ({len(function_result)} chars): {function_result}")
+                    logging.debug(f"Tool result preview: {result_preview}...")
 
             # Print cute message per tool
             if self.quiet_mode:
                 cute_msg = _get_cute_tool_message_impl(name, args, tool_duration, result=function_result)
                 print(f"  {cute_msg}")
             elif not self.quiet_mode:
-                if self.verbose_logging:
-                    print(f"  ✅ Tool {i+1} completed in {tool_duration:.2f}s")
-                    print(f"     Result: {function_result}")
-                else:
-                    response_preview = function_result[:self.log_prefix_chars] + "..." if len(function_result) > self.log_prefix_chars else function_result
-                    print(f"  ✅ Tool {i+1} completed in {tool_duration:.2f}s - {response_preview}")
+                response_preview = function_result[:self.log_prefix_chars] + "..." if len(function_result) > self.log_prefix_chars else function_result
+                print(f"  ✅ Tool {i+1} completed in {tool_duration:.2f}s - {response_preview}")
 
             # Truncate oversized results
             MAX_TOOL_RESULT_CHARS = 100_000
@@ -4007,12 +3975,8 @@ class AIAgent:
 
             if not self.quiet_mode:
                 args_str = json.dumps(function_args, ensure_ascii=False)
-                if self.verbose_logging:
-                    print(f"  📞 Tool {i}: {function_name}({list(function_args.keys())})")
-                    print(f"     Args: {args_str}")
-                else:
-                    args_preview = args_str[:self.log_prefix_chars] + "..." if len(args_str) > self.log_prefix_chars else args_str
-                    print(f"  📞 Tool {i}: {function_name}({list(function_args.keys())}) - {args_preview}")
+                args_preview = args_str[:self.log_prefix_chars] + "..." if len(args_str) > self.log_prefix_chars else args_str
+                print(f"  📞 Tool {i}: {function_name}({list(function_args.keys())}) - {args_preview}")
 
             if self.tool_progress_callback:
                 try:
@@ -4121,7 +4085,23 @@ class AIAgent:
                         self._vprint(f"  {cute_msg}")
             elif self.quiet_mode and self._stream_callback is None:
                 face = random.choice(KawaiiSpinner.KAWAII_WAITING)
-                emoji = _get_tool_emoji(function_name)
+                tool_emoji_map = {
+                    'web_search': '🔍', 'web_extract': '📄', 'web_crawl': '🕸️',
+                    'terminal': '💻', 'process': '⚙️',
+                    'read_file': '📖', 'write_file': '✍️', 'patch': '🔧', 'search_files': '🔎',
+                    'browser_navigate': '🌐', 'browser_snapshot': '📸',
+                    'browser_click': '👆', 'browser_type': '⌨️',
+                    'browser_scroll': '📜', 'browser_back': '◀️',
+                    'browser_press': '⌨️', 'browser_close': '🚪',
+                    'browser_get_images': '🖼️', 'browser_vision': '👁️',
+                    'image_generate': '🎨', 'text_to_speech': '🔊',
+                    'vision_analyze': '👁️', 'mixture_of_agents': '🧠',
+                    'skills_list': '📚', 'skill_view': '📚',
+                    'cronjob': '⏰',
+                    'send_message': '📨', 'todo': '📋', 'memory': '🧠', 'session_search': '🔍',
+                    'clarify': '❓', 'execute_code': '🐍', 'delegate_task': '🔀',
+                }
+                emoji = tool_emoji_map.get(function_name, '⚡')
                 preview = _build_tool_preview(function_name, function_args) or function_name
                 if len(preview) > 30:
                     preview = preview[:27] + "..."
@@ -4152,9 +4132,7 @@ class AIAgent:
                     logger.error("handle_function_call raised for %s: %s", function_name, tool_error, exc_info=True)
                 tool_duration = time.time() - tool_start_time
 
-            result_preview = function_result if self.verbose_logging else (
-                function_result[:200] if len(function_result) > 200 else function_result
-            )
+            result_preview = function_result[:200] if len(function_result) > 200 else function_result
 
             # Log tool errors to the persistent error log so [error] tags
             # in the UI always have a corresponding detailed entry on disk.
@@ -4164,7 +4142,7 @@ class AIAgent:
 
             if self.verbose_logging:
                 logging.debug(f"Tool {function_name} completed in {tool_duration:.2f}s")
-                logging.debug(f"Tool result ({len(function_result)} chars): {function_result}")
+                logging.debug(f"Tool result preview: {result_preview}...")
 
             # Guard against tools returning absurdly large content that would
             # blow up the context window. 100K chars ≈ 25K tokens — generous
@@ -4187,12 +4165,8 @@ class AIAgent:
             messages.append(tool_msg)
 
             if not self.quiet_mode:
-                if self.verbose_logging:
-                    print(f"  ✅ Tool {i} completed in {tool_duration:.2f}s")
-                    print(f"     Result: {function_result}")
-                else:
-                    response_preview = function_result[:self.log_prefix_chars] + "..." if len(function_result) > self.log_prefix_chars else function_result
-                    print(f"  ✅ Tool {i} completed in {tool_duration:.2f}s - {response_preview}")
+                response_preview = function_result[:self.log_prefix_chars] + "..." if len(function_result) > self.log_prefix_chars else function_result
+                print(f"  ✅ Tool {i} completed in {tool_duration:.2f}s - {response_preview}")
 
             if self._interrupt_requested and i < len(assistant_message.tool_calls):
                 remaining = len(assistant_message.tool_calls) - i
@@ -4290,8 +4264,9 @@ class AIAgent:
                     api_messages.insert(sys_offset + idx, pfm.copy())
 
             summary_extra_body = {}
+            _is_openrouter = "openrouter" in self.base_url.lower()
             _is_nous = "nousresearch" in self.base_url.lower()
-            if self._supports_reasoning_extra_body():
+            if _is_openrouter or _is_nous:
                 if self.reasoning_config is not None:
                     summary_extra_body["reasoning"] = self.reasoning_config
                 else:
@@ -5443,10 +5418,7 @@ class AIAgent:
 
                 # Handle assistant response
                 if assistant_message.content and not self.quiet_mode:
-                    if self.verbose_logging:
-                        self._vprint(f"{self.log_prefix}🤖 Assistant: {assistant_message.content}")
-                    else:
-                        self._vprint(f"{self.log_prefix}🤖 Assistant: {assistant_message.content[:100]}{'...' if len(assistant_message.content) > 100 else ''}")
+                    self._vprint(f"{self.log_prefix}🤖 Assistant: {assistant_message.content[:100]}{'...' if len(assistant_message.content) > 100 else ''}")
 
                 # Notify progress callback of model's thinking (used by subagent
                 # delegation to relay the child's reasoning to the parent display).

tests/agent/test_display_emoji.py

@@ -1,123 +0,0 @@
-"""Tests for get_tool_emoji in agent/display.py — skin + registry integration."""
-
-from unittest.mock import patch as mock_patch, MagicMock
-
-from agent.display import get_tool_emoji
-
-
-class TestGetToolEmoji:
-    """Verify the skin → registry → fallback resolution chain."""
-
-    def test_returns_registry_emoji_when_no_skin(self):
-        """Registry-registered emoji is used when no skin is active."""
-        mock_registry = MagicMock()
-        mock_registry.get_emoji.return_value = "🎨"
-        with mock_patch("agent.display._get_skin", return_value=None), \
-             mock_patch("agent.display.registry", mock_registry, create=True):
-            # Need to patch the import inside get_tool_emoji
-            pass
-        # Direct test: patch the lazy import path
-        with mock_patch("agent.display._get_skin", return_value=None):
-            # get_tool_emoji will try to import registry — mock that
-            mock_reg = MagicMock()
-            mock_reg.get_emoji.return_value = "📖"
-            with mock_patch.dict("sys.modules", {}):
-                import sys
-                # Patch tools.registry module
-                mock_module = MagicMock()
-                mock_module.registry = mock_reg
-                with mock_patch.dict(sys.modules, {"tools.registry": mock_module}):
-                    result = get_tool_emoji("read_file")
-                    assert result == "📖"
-
-    def test_skin_override_takes_precedence(self):
-        """Skin tool_emojis override registry defaults."""
-        skin = MagicMock()
-        skin.tool_emojis = {"terminal": "⚔"}
-        with mock_patch("agent.display._get_skin", return_value=skin):
-            result = get_tool_emoji("terminal")
-            assert result == "⚔"
-
-    def test_skin_empty_dict_falls_through(self):
-        """Empty skin tool_emojis falls through to registry."""
-        skin = MagicMock()
-        skin.tool_emojis = {}
-        mock_reg = MagicMock()
-        mock_reg.get_emoji.return_value = "💻"
-        import sys
-        mock_module = MagicMock()
-        mock_module.registry = mock_reg
-        with mock_patch("agent.display._get_skin", return_value=skin), \
-             mock_patch.dict(sys.modules, {"tools.registry": mock_module}):
-            result = get_tool_emoji("terminal")
-            assert result == "💻"
-
-    def test_fallback_default(self):
-        """When neither skin nor registry has an emoji, use the default."""
-        skin = MagicMock()
-        skin.tool_emojis = {}
-        mock_reg = MagicMock()
-        mock_reg.get_emoji.return_value = ""
-        import sys
-        mock_module = MagicMock()
-        mock_module.registry = mock_reg
-        with mock_patch("agent.display._get_skin", return_value=skin), \
-             mock_patch.dict(sys.modules, {"tools.registry": mock_module}):
-            result = get_tool_emoji("unknown_tool")
-            assert result == "⚡"
-
-    def test_custom_default(self):
-        """Custom default is returned when nothing matches."""
-        with mock_patch("agent.display._get_skin", return_value=None):
-            mock_reg = MagicMock()
-            mock_reg.get_emoji.return_value = ""
-            import sys
-            mock_module = MagicMock()
-            mock_module.registry = mock_reg
-            with mock_patch.dict(sys.modules, {"tools.registry": mock_module}):
-                result = get_tool_emoji("x", default="⚙️")
-                assert result == "⚙️"
-
-    def test_skin_override_only_for_matching_tool(self):
-        """Skin override for one tool doesn't affect others."""
-        skin = MagicMock()
-        skin.tool_emojis = {"terminal": "⚔"}
-        mock_reg = MagicMock()
-        mock_reg.get_emoji.return_value = "🔍"
-        import sys
-        mock_module = MagicMock()
-        mock_module.registry = mock_reg
-        with mock_patch("agent.display._get_skin", return_value=skin), \
-             mock_patch.dict(sys.modules, {"tools.registry": mock_module}):
-            assert get_tool_emoji("terminal") == "⚔"  # skin override
-            assert get_tool_emoji("web_search") == "🔍"  # registry fallback
-
-
-class TestSkinConfigToolEmojis:
-    """Verify SkinConfig handles tool_emojis field correctly."""
-
-    def test_skin_config_has_tool_emojis_field(self):
-        from hermes_cli.skin_engine import SkinConfig
-        skin = SkinConfig(name="test")
-        assert skin.tool_emojis == {}
-
-    def test_skin_config_accepts_tool_emojis(self):
-        from hermes_cli.skin_engine import SkinConfig
-        emojis = {"terminal": "⚔", "web_search": "🔮"}
-        skin = SkinConfig(name="test", tool_emojis=emojis)
-        assert skin.tool_emojis == emojis
-
-    def test_build_skin_config_includes_tool_emojis(self):
-        from hermes_cli.skin_engine import _build_skin_config
-        data = {
-            "name": "custom",
-            "tool_emojis": {"terminal": "🗡️", "patch": "⚒️"},
-        }
-        skin = _build_skin_config(data)
-        assert skin.tool_emojis == {"terminal": "🗡️", "patch": "⚒️"}
-
-    def test_build_skin_config_empty_tool_emojis_default(self):
-        from hermes_cli.skin_engine import _build_skin_config
-        data = {"name": "minimal"}
-        skin = _build_skin_config(data)
-        assert skin.tool_emojis == {}

tests/gateway/test_status_command.py

@@ -1,133 +0,0 @@
-"""Tests for gateway /status behavior and token persistence."""
-
-from datetime import datetime
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from gateway.config import GatewayConfig, Platform, PlatformConfig
-from gateway.platforms.base import MessageEvent
-from gateway.session import SessionEntry, SessionSource, build_session_key
-
-
-def _make_source() -> SessionSource:
-    return SessionSource(
-        platform=Platform.TELEGRAM,
-        user_id="u1",
-        chat_id="c1",
-        user_name="tester",
-        chat_type="dm",
-    )
-
-
-def _make_event(text: str) -> MessageEvent:
-    return MessageEvent(
-        text=text,
-        source=_make_source(),
-        message_id="m1",
-    )
-
-
-def _make_runner(session_entry: SessionEntry):
-    from gateway.run import GatewayRunner
-
-    runner = object.__new__(GatewayRunner)
-    runner.config = GatewayConfig(
-        platforms={Platform.TELEGRAM: PlatformConfig(enabled=True, token="***")}
-    )
-    adapter = MagicMock()
-    adapter.send = AsyncMock()
-    runner.adapters = {Platform.TELEGRAM: adapter}
-    runner._voice_mode = {}
-    runner.hooks = SimpleNamespace(emit=AsyncMock(), loaded_hooks=False)
-    runner.session_store = MagicMock()
-    runner.session_store.get_or_create_session.return_value = session_entry
-    runner.session_store.load_transcript.return_value = []
-    runner.session_store.has_any_sessions.return_value = True
-    runner.session_store.append_to_transcript = MagicMock()
-    runner.session_store.rewrite_transcript = MagicMock()
-    runner.session_store.update_session = MagicMock()
-    runner._running_agents = {}
-    runner._pending_messages = {}
-    runner._pending_approvals = {}
-    runner._session_db = None
-    runner._reasoning_config = None
-    runner._provider_routing = {}
-    runner._fallback_model = None
-    runner._show_reasoning = False
-    runner._is_user_authorized = lambda _source: True
-    runner._set_session_env = lambda _context: None
-    runner._should_send_voice_reply = lambda *_args, **_kwargs: False
-    runner._send_voice_reply = AsyncMock()
-    runner._capture_gateway_honcho_if_configured = lambda *args, **kwargs: None
-    runner._emit_gateway_run_progress = AsyncMock()
-    return runner
-
-
-@pytest.mark.asyncio
-async def test_status_command_reports_running_agent_without_interrupt(monkeypatch):
-    session_entry = SessionEntry(
-        session_key=build_session_key(_make_source()),
-        session_id="sess-1",
-        created_at=datetime.now(),
-        updated_at=datetime.now(),
-        platform=Platform.TELEGRAM,
-        chat_type="dm",
-        total_tokens=321,
-    )
-    runner = _make_runner(session_entry)
-    running_agent = MagicMock()
-    runner._running_agents[build_session_key(_make_source())] = running_agent
-
-    result = await runner._handle_message(_make_event("/status"))
-
-    assert "**Tokens:** 321" in result
-    assert "**Agent Running:** Yes ⚡" in result
-    running_agent.interrupt.assert_not_called()
-    assert runner._pending_messages == {}
-
-
-@pytest.mark.asyncio
-async def test_handle_message_persists_agent_token_counts(monkeypatch):
-    import gateway.run as gateway_run
-
-    session_entry = SessionEntry(
-        session_key=build_session_key(_make_source()),
-        session_id="sess-1",
-        created_at=datetime.now(),
-        updated_at=datetime.now(),
-        platform=Platform.TELEGRAM,
-        chat_type="dm",
-    )
-    runner = _make_runner(session_entry)
-    runner.session_store.load_transcript.return_value = [{"role": "user", "content": "earlier"}]
-    runner._run_agent = AsyncMock(
-        return_value={
-            "final_response": "ok",
-            "messages": [],
-            "tools": [],
-            "history_offset": 0,
-            "last_prompt_tokens": 80,
-            "input_tokens": 120,
-            "output_tokens": 45,
-            "model": "openai/test-model",
-        }
-    )
-
-    monkeypatch.setattr(gateway_run, "_resolve_runtime_agent_kwargs", lambda: {"api_key": "***"})
-    monkeypatch.setattr(
-        "agent.model_metadata.get_model_context_length",
-        lambda *_args, **_kwargs: 100000,
-    )
-
-    result = await runner._handle_message(_make_event("hello"))
-
-    assert result == "ok"
-    runner.session_store.update_session.assert_called_once_with(
-        session_entry.session_key,
-        input_tokens=120,
-        output_tokens=45,
-        last_prompt_tokens=80,
-        model="openai/test-model",
-    )

tests/gateway/test_telegram_format.py

@@ -7,7 +7,7 @@ or corrupt user-visible content.
 
 import re
 import sys
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -392,27 +392,3 @@ class TestStripMdv2:
 
     def test_empty_string(self):
         assert _strip_mdv2("") == ""
-
-
-@pytest.mark.asyncio
-async def test_send_escapes_chunk_indicator_for_markdownv2(adapter):
-    adapter.MAX_MESSAGE_LENGTH = 80
-    adapter._bot = MagicMock()
-
-    sent_texts = []
-
-    async def _fake_send_message(**kwargs):
-        sent_texts.append(kwargs["text"])
-        msg = MagicMock()
-        msg.message_id = len(sent_texts)
-        return msg
-
-    adapter._bot.send_message = AsyncMock(side_effect=_fake_send_message)
-
-    content = ("**bold** chunk content " * 12).strip()
-    result = await adapter.send("123", content)
-
-    assert result.success is True
-    assert len(sent_texts) > 1
-    assert re.search(r" \\\([0-9]+/[0-9]+\\\)$", sent_texts[0])
-    assert re.search(r" \\\([0-9]+/[0-9]+\\\)$", sent_texts[-1])

tests/hermes_cli/test_model_validation.py

@@ -7,7 +7,6 @@ from hermes_cli.models import (
     fetch_api_models,
     normalize_provider,
     parse_model_input,
-    probe_api_models,
     provider_label,
     provider_model_ids,
     validate_requested_model,
@@ -27,15 +26,7 @@ FAKE_API_MODELS = [
 
 def _validate(model, provider="openrouter", api_models=FAKE_API_MODELS, **kw):
     """Shortcut: call validate_requested_model with mocked API."""
-    probe_payload = {
-        "models": api_models,
-        "probed_url": "http://localhost:11434/v1/models",
-        "resolved_base_url": kw.get("base_url", "") or "http://localhost:11434/v1",
-        "suggested_base_url": None,
-        "used_fallback": False,
-    }
-    with patch("hermes_cli.models.fetch_api_models", return_value=api_models), \
-         patch("hermes_cli.models.probe_api_models", return_value=probe_payload):
+    with patch("hermes_cli.models.fetch_api_models", return_value=api_models):
         return validate_requested_model(model, provider, **kw)
 
 
@@ -156,33 +147,6 @@ class TestFetchApiModels:
         with patch("hermes_cli.models.urllib.request.urlopen", side_effect=Exception("timeout")):
             assert fetch_api_models("key", "https://example.com/v1") is None
 
-    def test_probe_api_models_tries_v1_fallback(self):
-        class _Resp:
-            def __enter__(self):
-                return self
-
-            def __exit__(self, exc_type, exc, tb):
-                return False
-
-            def read(self):
-                return b'{"data": [{"id": "local-model"}]}'
-
-        calls = []
-
-        def _fake_urlopen(req, timeout=5.0):
-            calls.append(req.full_url)
-            if req.full_url.endswith("/v1/models"):
-                return _Resp()
-            raise Exception("404")
-
-        with patch("hermes_cli.models.urllib.request.urlopen", side_effect=_fake_urlopen):
-            probe = probe_api_models("key", "http://localhost:8000")
-
-        assert calls == ["http://localhost:8000/models", "http://localhost:8000/v1/models"]
-        assert probe["models"] == ["local-model"]
-        assert probe["resolved_base_url"] == "http://localhost:8000/v1"
-        assert probe["used_fallback"] is True
-
 
 # -- validate — format checks -----------------------------------------------
 
@@ -227,7 +191,6 @@ class TestValidateApiFound:
         )
         assert result["accepted"] is True
         assert result["persist"] is True
-        assert result["recognized"] is True
 
 
 # -- validate — API not found ------------------------------------------------
@@ -269,26 +232,3 @@ class TestValidateApiFallback:
         result = _validate("some-model", provider="totally-unknown", api_models=None)
         assert result["accepted"] is True
         assert result["persist"] is True
-
-    def test_custom_endpoint_warns_with_probed_url_and_v1_hint(self):
-        with patch(
-            "hermes_cli.models.probe_api_models",
-            return_value={
-                "models": None,
-                "probed_url": "http://localhost:8000/v1/models",
-                "resolved_base_url": "http://localhost:8000",
-                "suggested_base_url": "http://localhost:8000/v1",
-                "used_fallback": False,
-            },
-        ):
-            result = validate_requested_model(
-                "qwen3",
-                "custom",
-                api_key="local-key",
-                base_url="http://localhost:8000",
-            )
-
-        assert result["accepted"] is True
-        assert result["persist"] is True
-        assert "http://localhost:8000/v1/models" in result["message"]
-        assert "http://localhost:8000/v1" in result["message"]

tests/hermes_cli/test_setup_model_provider.py

@@ -75,58 +75,6 @@ def test_setup_keep_current_custom_from_config_does_not_fall_through(tmp_path, m
     assert calls["count"] == 1
 
 
-def test_setup_custom_endpoint_saves_working_v1_base_url(tmp_path, monkeypatch):
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path))
-    _clear_provider_env(monkeypatch)
-
-    config = load_config()
-
-    def fake_prompt_choice(question, choices, default=0):
-        if question == "Select your inference provider:":
-            return 3  # Custom endpoint
-        if question == "Configure vision:":
-            return len(choices) - 1  # Skip
-        raise AssertionError(f"Unexpected prompt_choice call: {question}")
-
-    def fake_prompt(message, current=None, **kwargs):
-        if "API base URL" in message:
-            return "http://localhost:8000"
-        if "API key" in message:
-            return "local-key"
-        if "Model name" in message:
-            return "llm"
-        return ""
-
-    monkeypatch.setattr("hermes_cli.setup.prompt_choice", fake_prompt_choice)
-    monkeypatch.setattr("hermes_cli.setup.prompt", fake_prompt)
-    monkeypatch.setattr("hermes_cli.setup.prompt_yes_no", lambda *args, **kwargs: False)
-    monkeypatch.setattr("hermes_cli.auth.get_active_provider", lambda: None)
-    monkeypatch.setattr("hermes_cli.auth.detect_external_credentials", lambda: [])
-    monkeypatch.setattr("agent.auxiliary_client.get_available_vision_backends", lambda: [])
-    monkeypatch.setattr(
-        "hermes_cli.models.probe_api_models",
-        lambda api_key, base_url: {
-            "models": ["llm"],
-            "probed_url": "http://localhost:8000/v1/models",
-            "resolved_base_url": "http://localhost:8000/v1",
-            "suggested_base_url": "http://localhost:8000/v1",
-            "used_fallback": True,
-        },
-    )
-
-    setup_model_provider(config)
-    save_config(config)
-
-    env = _read_env(tmp_path)
-    reloaded = load_config()
-
-    assert env.get("OPENAI_BASE_URL") == "http://localhost:8000/v1"
-    assert env.get("OPENAI_API_KEY") == "local-key"
-    assert reloaded["model"]["provider"] == "custom"
-    assert reloaded["model"]["base_url"] == "http://localhost:8000/v1"
-    assert reloaded["model"]["default"] == "llm"
-
-
 def test_setup_keep_current_config_provider_uses_provider_specific_model_menu(tmp_path, monkeypatch):
     """Keep-current should respect config-backed providers, not fall back to OpenRouter."""
     monkeypatch.setenv("HERMES_HOME", str(tmp_path))

tests/hermes_cli/test_setup_prompt_menus.py

@@ -1,29 +0,0 @@
-from hermes_cli import setup as setup_mod
-
-
-def test_prompt_choice_uses_curses_helper(monkeypatch):
-    monkeypatch.setattr(setup_mod, "_curses_prompt_choice", lambda question, choices, default=0: 1)
-
-    idx = setup_mod.prompt_choice("Pick one", ["a", "b", "c"], default=0)
-
-    assert idx == 1
-
-
-def test_prompt_choice_falls_back_to_numbered_input(monkeypatch):
-    monkeypatch.setattr(setup_mod, "_curses_prompt_choice", lambda question, choices, default=0: -1)
-    monkeypatch.setattr("builtins.input", lambda _prompt="": "2")
-
-    idx = setup_mod.prompt_choice("Pick one", ["a", "b", "c"], default=0)
-
-    assert idx == 1
-
-
-def test_prompt_checklist_uses_shared_curses_checklist(monkeypatch):
-    monkeypatch.setattr(
-        "hermes_cli.curses_ui.curses_checklist",
-        lambda title, items, selected, cancel_returns=None: {0, 2},
-    )
-
-    selected = setup_mod.prompt_checklist("Pick tools", ["one", "two", "three"], pre_selected=[1])
-
-    assert selected == [0, 2]

tests/test_atomic_json_write.py

@@ -68,22 +68,6 @@ class TestAtomicJsonWrite:
         tmp_files = [f for f in tmp_path.iterdir() if ".tmp" in f.name]
         assert len(tmp_files) == 0
 
-    def test_cleans_up_temp_file_on_baseexception(self, tmp_path):
-        class SimulatedAbort(BaseException):
-            pass
-
-        target = tmp_path / "data.json"
-        original = {"preserved": True}
-        target.write_text(json.dumps(original), encoding="utf-8")
-
-        with patch("utils.json.dump", side_effect=SimulatedAbort):
-            with pytest.raises(SimulatedAbort):
-                atomic_json_write(target, {"new": True})
-
-        tmp_files = [f for f in tmp_path.iterdir() if ".tmp" in f.name]
-        assert len(tmp_files) == 0
-        assert json.loads(target.read_text(encoding="utf-8")) == original
-
     def test_accepts_string_path(self, tmp_path):
         target = str(tmp_path / "string_path.json")
         atomic_json_write(target, {"string": True})

tests/test_atomic_yaml_write.py

@@ -1,44 +0,0 @@
-"""Tests for utils.atomic_yaml_write — crash-safe YAML file writes."""
-
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-import yaml
-
-from utils import atomic_yaml_write
-
-
-class TestAtomicYamlWrite:
-    def test_writes_valid_yaml(self, tmp_path):
-        target = tmp_path / "data.yaml"
-        data = {"key": "value", "nested": {"a": 1}}
-
-        atomic_yaml_write(target, data)
-
-        assert yaml.safe_load(target.read_text(encoding="utf-8")) == data
-
-    def test_cleans_up_temp_file_on_baseexception(self, tmp_path):
-        class SimulatedAbort(BaseException):
-            pass
-
-        target = tmp_path / "data.yaml"
-        original = {"preserved": True}
-        target.write_text(yaml.safe_dump(original), encoding="utf-8")
-
-        with patch("utils.yaml.dump", side_effect=SimulatedAbort):
-            with pytest.raises(SimulatedAbort):
-                atomic_yaml_write(target, {"new": True})
-
-        tmp_files = [f for f in tmp_path.iterdir() if ".tmp" in f.name]
-        assert len(tmp_files) == 0
-        assert yaml.safe_load(target.read_text(encoding="utf-8")) == original
-
-    def test_appends_extra_content(self, tmp_path):
-        target = tmp_path / "data.yaml"
-
-        atomic_yaml_write(target, {"key": "value"}, extra_content="\n# comment\n")
-
-        text = target.read_text(encoding="utf-8")
-        assert "key: value" in text
-        assert "# comment" in text

tests/test_cli_mcp_config_watch.py

@@ -1,103 +0,0 @@
-"""Tests for automatic MCP reload when config.yaml mcp_servers section changes."""
-import time
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-
-def _make_cli(tmp_path, mcp_servers=None):
-    """Create a minimal HermesCLI instance with mocked config."""
-    import cli as cli_mod
-    obj = object.__new__(cli_mod.HermesCLI)
-    obj.config = {"mcp_servers": mcp_servers or {}}
-    obj._agent_running = False
-    obj._last_config_check = 0.0
-    obj._config_mcp_servers = mcp_servers or {}
-
-    cfg_file = tmp_path / "config.yaml"
-    cfg_file.write_text("mcp_servers: {}\n")
-    obj._config_mtime = cfg_file.stat().st_mtime
-
-    obj._reload_mcp = MagicMock()
-    obj._busy_command = MagicMock()
-    obj._busy_command.return_value.__enter__ = MagicMock(return_value=None)
-    obj._busy_command.return_value.__exit__ = MagicMock(return_value=False)
-    obj._slow_command_status = MagicMock(return_value="reloading...")
-
-    return obj, cfg_file
-
-
-class TestMCPConfigWatch:
-
-    def test_no_change_does_not_reload(self, tmp_path):
-        """If mtime and mcp_servers unchanged, _reload_mcp is NOT called."""
-        obj, cfg_file = _make_cli(tmp_path)
-
-        with patch("hermes_cli.config.get_config_path", return_value=cfg_file):
-            obj._check_config_mcp_changes()
-
-        obj._reload_mcp.assert_not_called()
-
-    def test_mtime_change_with_same_mcp_servers_does_not_reload(self, tmp_path):
-        """If file mtime changes but mcp_servers is identical, no reload."""
-        import yaml
-        obj, cfg_file = _make_cli(tmp_path, mcp_servers={"fs": {"command": "npx"}})
-
-        # Write same mcp_servers but touch the file
-        cfg_file.write_text(yaml.dump({"mcp_servers": {"fs": {"command": "npx"}}}))
-        # Force mtime to appear changed
-        obj._config_mtime = 0.0
-
-        with patch("hermes_cli.config.get_config_path", return_value=cfg_file):
-            obj._check_config_mcp_changes()
-
-        obj._reload_mcp.assert_not_called()
-
-    def test_new_mcp_server_triggers_reload(self, tmp_path):
-        """Adding a new MCP server to config triggers auto-reload."""
-        import yaml
-        obj, cfg_file = _make_cli(tmp_path, mcp_servers={})
-
-        # Simulate user adding a new MCP server to config.yaml
-        cfg_file.write_text(yaml.dump({"mcp_servers": {"github": {"url": "https://mcp.github.com"}}}))
-        obj._config_mtime = 0.0  # force stale mtime
-
-        with patch("hermes_cli.config.get_config_path", return_value=cfg_file):
-            obj._check_config_mcp_changes()
-
-        obj._reload_mcp.assert_called_once()
-
-    def test_removed_mcp_server_triggers_reload(self, tmp_path):
-        """Removing an MCP server from config triggers auto-reload."""
-        import yaml
-        obj, cfg_file = _make_cli(tmp_path, mcp_servers={"github": {"url": "https://mcp.github.com"}})
-
-        # Simulate user removing the server
-        cfg_file.write_text(yaml.dump({"mcp_servers": {}}))
-        obj._config_mtime = 0.0
-
-        with patch("hermes_cli.config.get_config_path", return_value=cfg_file):
-            obj._check_config_mcp_changes()
-
-        obj._reload_mcp.assert_called_once()
-
-    def test_interval_throttle_skips_check(self, tmp_path):
-        """If called within CONFIG_WATCH_INTERVAL, stat() is skipped."""
-        obj, cfg_file = _make_cli(tmp_path)
-        obj._last_config_check = time.monotonic()  # just checked
-
-        with patch("hermes_cli.config.get_config_path", return_value=cfg_file), \
-             patch.object(Path, "stat") as mock_stat:
-            obj._check_config_mcp_changes()
-            mock_stat.assert_not_called()
-
-        obj._reload_mcp.assert_not_called()
-
-    def test_missing_config_file_does_not_crash(self, tmp_path):
-        """If config.yaml doesn't exist, _check_config_mcp_changes is a no-op."""
-        obj, cfg_file = _make_cli(tmp_path)
-        missing = tmp_path / "nonexistent.yaml"
-
-        with patch("hermes_cli.config.get_config_path", return_value=missing):
-            obj._check_config_mcp_changes()  # should not raise
-
-        obj._reload_mcp.assert_not_called()

tests/test_cli_provider_resolution.py

@@ -336,42 +336,4 @@ def test_cmd_model_falls_back_to_auto_on_invalid_provider(monkeypatch, capsys):
 
     assert "Warning:" in output
     assert "falling back to auto provider detection" in output.lower()
-    assert "No change." in output
-
-
-def test_model_flow_custom_saves_verified_v1_base_url(monkeypatch, capsys):
-    monkeypatch.setattr(
-        "hermes_cli.config.get_env_value",
-        lambda key: "" if key in {"OPENAI_BASE_URL", "OPENAI_API_KEY"} else "",
-    )
-    saved_env = {}
-    monkeypatch.setattr("hermes_cli.config.save_env_value", lambda key, value: saved_env.__setitem__(key, value))
-    monkeypatch.setattr("hermes_cli.auth._save_model_choice", lambda model: saved_env.__setitem__("MODEL", model))
-    monkeypatch.setattr("hermes_cli.auth.deactivate_provider", lambda: None)
-    monkeypatch.setattr("hermes_cli.main._save_custom_provider", lambda *args, **kwargs: None)
-    monkeypatch.setattr(
-        "hermes_cli.models.probe_api_models",
-        lambda api_key, base_url: {
-            "models": ["llm"],
-            "probed_url": "http://localhost:8000/v1/models",
-            "resolved_base_url": "http://localhost:8000/v1",
-            "suggested_base_url": "http://localhost:8000/v1",
-            "used_fallback": True,
-        },
-    )
-    monkeypatch.setattr(
-        "hermes_cli.config.load_config",
-        lambda: {"model": {"default": "", "provider": "custom", "base_url": ""}},
-    )
-    monkeypatch.setattr("hermes_cli.config.save_config", lambda cfg: None)
-
-    answers = iter(["http://localhost:8000", "local-key", "llm"])
-    monkeypatch.setattr("builtins.input", lambda _prompt="": next(answers))
-
-    hermes_main._model_flow_custom({})
-    output = capsys.readouterr().out
-
-    assert "Saving the working base URL instead" in output
-    assert saved_env["OPENAI_BASE_URL"] == "http://localhost:8000/v1"
-    assert saved_env["OPENAI_API_KEY"] == "local-key"
-    assert saved_env["MODEL"] == "llm"
+    assert "No change." in output

tests/test_run_agent.py

@@ -612,25 +612,6 @@ class TestBuildApiKwargs:
         kwargs = agent._build_api_kwargs(messages)
         assert kwargs["extra_body"]["reasoning"] == {"enabled": False}
 
-    def test_reasoning_not_sent_for_unsupported_openrouter_model(self, agent):
-        agent.model = "minimax/minimax-m2.5"
-        messages = [{"role": "user", "content": "hi"}]
-        kwargs = agent._build_api_kwargs(messages)
-        assert "reasoning" not in kwargs.get("extra_body", {})
-
-    def test_reasoning_sent_for_supported_openrouter_model(self, agent):
-        agent.model = "qwen/qwen3.5-plus-02-15"
-        messages = [{"role": "user", "content": "hi"}]
-        kwargs = agent._build_api_kwargs(messages)
-        assert kwargs["extra_body"]["reasoning"]["effort"] == "medium"
-
-    def test_reasoning_sent_for_nous_route(self, agent):
-        agent.base_url = "https://inference-api.nousresearch.com/v1"
-        agent.model = "minimax/minimax-m2.5"
-        messages = [{"role": "user", "content": "hi"}]
-        kwargs = agent._build_api_kwargs(messages)
-        assert kwargs["extra_body"]["reasoning"]["effort"] == "medium"
-
     def test_max_tokens_injected(self, agent):
         agent.max_tokens = 4096
         messages = [{"role": "user", "content": "hi"}]
@@ -961,19 +942,6 @@ class TestHandleMaxIterations:
         assert "error" in result.lower()
         assert "API down" in result
 
-    def test_summary_skips_reasoning_for_unsupported_openrouter_model(self, agent):
-        agent.model = "minimax/minimax-m2.5"
-        resp = _mock_response(content="Summary")
-        agent.client.chat.completions.create.return_value = resp
-        agent._cached_system_prompt = "You are helpful."
-        messages = [{"role": "user", "content": "do stuff"}]
-
-        result = agent._handle_max_iterations(messages, 60)
-
-        assert result == "Summary"
-        kwargs = agent.client.chat.completions.create.call_args.kwargs
-        assert "reasoning" not in kwargs.get("extra_body", {})
-
 
 class TestRunConversation:
     """Tests for the main run_conversation method.

tests/tools/test_checkpoint_manager.py

@@ -1,10 +1,8 @@
 """Tests for tools/checkpoint_manager.py — CheckpointManager."""
 
-import logging
 import os
 import json
 import shutil
-import subprocess
 import pytest
 from pathlib import Path
 from unittest.mock import patch
@@ -145,12 +143,6 @@ class TestTakeCheckpoint:
         result = mgr.ensure_checkpoint(str(work_dir), "initial")
         assert result is True
 
-    def test_successful_checkpoint_does_not_log_expected_diff_exit(self, mgr, work_dir, caplog):
-        with caplog.at_level(logging.ERROR, logger="tools.checkpoint_manager"):
-            result = mgr.ensure_checkpoint(str(work_dir), "initial")
-        assert result is True
-        assert not any("diff --cached --quiet" in r.getMessage() for r in caplog.records)
-
     def test_dedup_same_turn(self, mgr, work_dir):
         r1 = mgr.ensure_checkpoint(str(work_dir), "first")
         r2 = mgr.ensure_checkpoint(str(work_dir), "second")
@@ -383,26 +375,6 @@ class TestErrorResilience:
         result = mgr.ensure_checkpoint(str(work_dir), "test")
         assert result is False
 
-    def test_run_git_allows_expected_nonzero_without_error_log(self, tmp_path, caplog):
-        completed = subprocess.CompletedProcess(
-            args=["git", "diff", "--cached", "--quiet"],
-            returncode=1,
-            stdout="",
-            stderr="",
-        )
-        with patch("tools.checkpoint_manager.subprocess.run", return_value=completed):
-            with caplog.at_level(logging.ERROR, logger="tools.checkpoint_manager"):
-                ok, stdout, stderr = _run_git(
-                    ["diff", "--cached", "--quiet"],
-                    tmp_path / "shadow",
-                    str(tmp_path / "work"),
-                    allowed_returncodes={1},
-                )
-        assert ok is False
-        assert stdout == ""
-        assert stderr == ""
-        assert not caplog.records
-
     def test_checkpoint_failure_does_not_raise(self, mgr, work_dir, monkeypatch):
         """Checkpoint failures should never raise — they're silently logged."""
         def broken_run_git(*args, **kwargs):

tests/tools/test_docker_environment.py

@@ -1,4 +1,5 @@
 import logging
+from io import StringIO
 import subprocess
 
 import pytest
@@ -86,3 +87,64 @@ def test_ensure_docker_available_uses_resolved_executable(monkeypatch):
         })
     ]
 
+
+class _FakePopen:
+    def __init__(self, cmd, **kwargs):
+        self.cmd = cmd
+        self.kwargs = kwargs
+        self.stdout = StringIO("")
+        self.stdin = None
+        self.returncode = 0
+
+    def poll(self):
+        return self.returncode
+
+
+def _make_execute_only_env(forward_env=None):
+    env = docker_env.DockerEnvironment.__new__(docker_env.DockerEnvironment)
+    env.cwd = "/root"
+    env.timeout = 60
+    env._forward_env = forward_env or []
+    env._prepare_command = lambda command: (command, None)
+    env._timeout_result = lambda timeout: {"output": f"timed out after {timeout}", "returncode": 124}
+    env._inner = type("Inner", (), {
+        "container_id": "test-container",
+        "config": type("Cfg", (), {"executable": "/usr/bin/docker", "env": {}})(),
+    })()
+    return env
+
+
+def test_execute_uses_hermes_dotenv_for_allowlisted_env(monkeypatch):
+    env = _make_execute_only_env(["GITHUB_TOKEN"])
+    popen_calls = []
+
+    def _fake_popen(cmd, **kwargs):
+        popen_calls.append(cmd)
+        return _FakePopen(cmd, **kwargs)
+
+    monkeypatch.delenv("GITHUB_TOKEN", raising=False)
+    monkeypatch.setattr(docker_env, "_load_hermes_env_vars", lambda: {"GITHUB_TOKEN": "value_from_dotenv"})
+    monkeypatch.setattr(docker_env.subprocess, "Popen", _fake_popen)
+
+    result = env.execute("echo hi")
+
+    assert result["returncode"] == 0
+    assert "GITHUB_TOKEN=value_from_dotenv" in popen_calls[0]
+
+
+def test_execute_prefers_shell_env_over_hermes_dotenv(monkeypatch):
+    env = _make_execute_only_env(["GITHUB_TOKEN"])
+    popen_calls = []
+
+    def _fake_popen(cmd, **kwargs):
+        popen_calls.append(cmd)
+        return _FakePopen(cmd, **kwargs)
+
+    monkeypatch.setenv("GITHUB_TOKEN", "value_from_shell")
+    monkeypatch.setattr(docker_env, "_load_hermes_env_vars", lambda: {"GITHUB_TOKEN": "value_from_dotenv"})
+    monkeypatch.setattr(docker_env.subprocess, "Popen", _fake_popen)
+
+    env.execute("echo hi")
+
+    assert "GITHUB_TOKEN=value_from_shell" in popen_calls[0]
+    assert "GITHUB_TOKEN=value_from_dotenv" not in popen_calls[0]

tests/tools/test_file_tools.py

@@ -5,7 +5,6 @@ handling without requiring a running terminal environment.
 """
 
 import json
-import logging
 from unittest.mock import MagicMock, patch
 
 from tools.file_tools import (
@@ -88,26 +87,13 @@ class TestWriteFileHandler:
         mock_ops.write_file.assert_called_once_with("/tmp/out.txt", "hello world!\n")
 
     @patch("tools.file_tools._get_file_ops")
-    def test_permission_error_returns_error_json_without_error_log(self, mock_get, caplog):
+    def test_exception_returns_error_json(self, mock_get):
         mock_get.side_effect = PermissionError("read-only filesystem")
 
         from tools.file_tools import write_file_tool
-        with caplog.at_level(logging.DEBUG, logger="tools.file_tools"):
-            result = json.loads(write_file_tool("/tmp/out.txt", "data"))
+        result = json.loads(write_file_tool("/tmp/out.txt", "data"))
         assert "error" in result
         assert "read-only" in result["error"]
-        assert any("write_file expected denial" in r.getMessage() for r in caplog.records)
-        assert not any(r.levelno >= logging.ERROR for r in caplog.records)
-
-    @patch("tools.file_tools._get_file_ops")
-    def test_unexpected_exception_still_logs_error(self, mock_get, caplog):
-        mock_get.side_effect = RuntimeError("boom")
-
-        from tools.file_tools import write_file_tool
-        with caplog.at_level(logging.ERROR, logger="tools.file_tools"):
-            result = json.loads(write_file_tool("/tmp/out.txt", "data"))
-        assert result["error"] == "boom"
-        assert any("write_file error" in r.getMessage() for r in caplog.records)
 
 
 class TestPatchHandler:

tests/tools/test_parse_env_var.py

@@ -30,6 +30,28 @@ class TestParseEnvVar:
             result = _parse_env_var("TERMINAL_DOCKER_VOLUMES", "[]", json.loads, "valid JSON")
             assert result == ["/host:/container"]
 
+    def test_get_env_config_parses_docker_forward_env_json(self):
+        with patch.dict("os.environ", {
+            "TERMINAL_ENV": "docker",
+            "TERMINAL_DOCKER_FORWARD_ENV": '["GITHUB_TOKEN", "NPM_TOKEN"]',
+        }, clear=False):
+            config = _tt_mod._get_env_config()
+            assert config["docker_forward_env"] == ["GITHUB_TOKEN", "NPM_TOKEN"]
+
+    def test_create_environment_passes_docker_forward_env(self):
+        fake_env = object()
+        with patch.object(_tt_mod, "_DockerEnvironment", return_value=fake_env) as mock_docker:
+            result = _tt_mod._create_environment(
+                "docker",
+                image="python:3.11",
+                cwd="/root",
+                timeout=180,
+                container_config={"docker_forward_env": ["GITHUB_TOKEN"]},
+            )
+
+        assert result is fake_env
+        assert mock_docker.call_args.kwargs["forward_env"] == ["GITHUB_TOKEN"]
+
     def test_falls_back_to_default(self):
         with patch.dict("os.environ", {}, clear=False):
             # Remove the var if it exists, rely on default

tests/tools/test_registry.py

@@ -232,48 +232,6 @@ class TestCheckFnExceptionHandling:
         assert any(u["name"] == "crashes" for u in unavailable)
 
 
-class TestEmojiMetadata:
-    """Verify per-tool emoji registration and lookup."""
-
-    def test_emoji_stored_on_entry(self):
-        reg = ToolRegistry()
-        reg.register(
-            name="t", toolset="s", schema=_make_schema(),
-            handler=_dummy_handler, emoji="🔥",
-        )
-        assert reg._tools["t"].emoji == "🔥"
-
-    def test_get_emoji_returns_registered(self):
-        reg = ToolRegistry()
-        reg.register(
-            name="t", toolset="s", schema=_make_schema(),
-            handler=_dummy_handler, emoji="🎯",
-        )
-        assert reg.get_emoji("t") == "🎯"
-
-    def test_get_emoji_returns_default_when_unset(self):
-        reg = ToolRegistry()
-        reg.register(
-            name="t", toolset="s", schema=_make_schema(),
-            handler=_dummy_handler,
-        )
-        assert reg.get_emoji("t") == "⚡"
-        assert reg.get_emoji("t", default="🔧") == "🔧"
-
-    def test_get_emoji_returns_default_for_unknown_tool(self):
-        reg = ToolRegistry()
-        assert reg.get_emoji("nonexistent") == "⚡"
-        assert reg.get_emoji("nonexistent", default="❓") == "❓"
-
-    def test_emoji_empty_string_treated_as_unset(self):
-        reg = ToolRegistry()
-        reg.register(
-            name="t", toolset="s", schema=_make_schema(),
-            handler=_dummy_handler, emoji="",
-        )
-        assert reg.get_emoji("t") == "⚡"
-
-
 class TestSecretCaptureResultContract:
     def test_secret_request_result_does_not_include_secret_value(self):
         result = {

tests/tools/test_ssh_environment.py

@@ -1,39 +0,0 @@
-import pytest
-
-from tools.environments import ssh as ssh_env
-
-
-def test_ensure_ssh_available_raises_clear_error_when_missing(monkeypatch):
-    monkeypatch.setattr(ssh_env.shutil, "which", lambda _name: None)
-
-    with pytest.raises(RuntimeError, match="SSH is not installed or not in PATH"):
-        ssh_env._ensure_ssh_available()
-
-
-def test_ssh_environment_checks_availability_before_connect(monkeypatch):
-    monkeypatch.setattr(ssh_env.shutil, "which", lambda _name: None)
-    monkeypatch.setattr(
-        ssh_env.SSHEnvironment,
-        "_establish_connection",
-        lambda self: pytest.fail("_establish_connection should not run when ssh is missing"),
-    )
-
-    with pytest.raises(RuntimeError, match="openssh-client"):
-        ssh_env.SSHEnvironment(host="example.com", user="alice")
-
-
-def test_ssh_environment_connects_when_ssh_exists(monkeypatch):
-    called = {"count": 0}
-
-    monkeypatch.setattr(ssh_env.shutil, "which", lambda _name: "/usr/bin/ssh")
-
-    def _fake_establish(self):
-        called["count"] += 1
-
-    monkeypatch.setattr(ssh_env.SSHEnvironment, "_establish_connection", _fake_establish)
-
-    env = ssh_env.SSHEnvironment(host="example.com", user="alice")
-
-    assert called["count"] == 1
-    assert env.host == "example.com"
-    assert env.user == "alice"

tests/tools/test_tirith_security.py

@@ -315,23 +315,6 @@ class TestEnsureInstalled:
             mock_thread.start.assert_called_once()
         _tirith_mod._resolved_path = None
 
-    @patch("tools.tirith_security._load_security_config")
-    def test_startup_prefetch_can_suppress_install_failure_logs(self, mock_cfg):
-        mock_cfg.return_value = {"tirith_enabled": True, "tirith_path": "tirith",
-                                 "tirith_timeout": 5, "tirith_fail_open": True}
-        _tirith_mod._resolved_path = None
-        with patch("tools.tirith_security.shutil.which", return_value=None), \
-             patch("tools.tirith_security._hermes_bin_dir", return_value="/nonexistent"), \
-             patch("tools.tirith_security._is_install_failed_on_disk", return_value=False), \
-             patch("tools.tirith_security.threading.Thread") as MockThread:
-            mock_thread = MagicMock()
-            MockThread.return_value = mock_thread
-            result = ensure_installed(log_failures=False)
-            assert result is None
-            assert MockThread.call_args.kwargs["kwargs"] == {"log_failures": False}
-            mock_thread.start.assert_called_once()
-        _tirith_mod._resolved_path = None
-
 
 # ---------------------------------------------------------------------------
 # Failed download caches the miss (Finding #1)
@@ -533,22 +516,6 @@ class TestCosignVerification:
         assert path is None
         assert reason == "cosign_missing"
 
-    @patch("tools.tirith_security.logger.debug")
-    @patch("tools.tirith_security.logger.warning")
-    @patch("tools.tirith_security.shutil.which", return_value=None)
-    @patch("tools.tirith_security._download_file")
-    @patch("tools.tirith_security._detect_target", return_value="aarch64-apple-darwin")
-    def test_install_quiet_mode_downgrades_cosign_missing_log(self, mock_target, mock_dl,
-                                                              mock_which, mock_warning,
-                                                              mock_debug):
-        """Startup prefetch should not surface cosign-missing as a warning."""
-        from tools.tirith_security import _install_tirith
-        path, reason = _install_tirith(log_failures=False)
-        assert path is None
-        assert reason == "cosign_missing"
-        mock_warning.assert_not_called()
-        mock_debug.assert_called()
-
     @patch("tools.tirith_security._verify_cosign", return_value=None)
     @patch("tools.tirith_security.shutil.which", return_value="/usr/local/bin/cosign")
     @patch("tools.tirith_security._download_file")

tools/browser_tool.py

@@ -1833,7 +1833,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_navigate"],
     handler=lambda args, **kw: browser_navigate(url=args.get("url", ""), task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="🌐",
 )
 registry.register(
     name="browser_snapshot",
@@ -1842,7 +1841,6 @@ registry.register(
     handler=lambda args, **kw: browser_snapshot(
         full=args.get("full", False), task_id=kw.get("task_id"), user_task=kw.get("user_task")),
     check_fn=check_browser_requirements,
-    emoji="📸",
 )
 registry.register(
     name="browser_click",
@@ -1850,7 +1848,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_click"],
     handler=lambda args, **kw: browser_click(**args, task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="👆",
 )
 registry.register(
     name="browser_type",
@@ -1858,7 +1855,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_type"],
     handler=lambda args, **kw: browser_type(**args, task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="⌨️",
 )
 registry.register(
     name="browser_scroll",
@@ -1866,7 +1862,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_scroll"],
     handler=lambda args, **kw: browser_scroll(**args, task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="📜",
 )
 registry.register(
     name="browser_back",
@@ -1874,7 +1869,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_back"],
     handler=lambda args, **kw: browser_back(task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="◀️",
 )
 registry.register(
     name="browser_press",
@@ -1882,7 +1876,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_press"],
     handler=lambda args, **kw: browser_press(key=args.get("key", ""), task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="⌨️",
 )
 registry.register(
     name="browser_close",
@@ -1890,7 +1883,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_close"],
     handler=lambda args, **kw: browser_close(task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="🚪",
 )
 registry.register(
     name="browser_get_images",
@@ -1898,7 +1890,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_get_images"],
     handler=lambda args, **kw: browser_get_images(task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="🖼️",
 )
 registry.register(
     name="browser_vision",
@@ -1906,7 +1897,6 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_vision"],
     handler=lambda args, **kw: browser_vision(question=args.get("question", ""), annotate=args.get("annotate", False), task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="👁️",
 )
 registry.register(
     name="browser_console",
@@ -1914,5 +1904,4 @@ registry.register(
     schema=_BROWSER_SCHEMA_MAP["browser_console"],
     handler=lambda args, **kw: browser_console(clear=args.get("clear", False), task_id=kw.get("task_id")),
     check_fn=check_browser_requirements,
-    emoji="🖥️",
 )

tools/checkpoint_manager.py

@@ -92,17 +92,10 @@ def _run_git(
     shadow_repo: Path,
     working_dir: str,
     timeout: int = _GIT_TIMEOUT,
-    allowed_returncodes: Optional[Set[int]] = None,
 ) -> tuple:
-    """Run a git command against the shadow repo.  Returns (ok, stdout, stderr).
-
-    ``allowed_returncodes`` suppresses error logging for known/expected non-zero
-    exits while preserving the normal ``ok = (returncode == 0)`` contract.
-    Example: ``git diff --cached --quiet`` returns 1 when changes exist.
-    """
+    """Run a git command against the shadow repo.  Returns (ok, stdout, stderr)."""
     env = _git_env(shadow_repo, working_dir)
     cmd = ["git"] + list(args)
-    allowed_returncodes = allowed_returncodes or set()
     try:
         result = subprocess.run(
             cmd,
@@ -115,7 +108,7 @@ def _run_git(
         ok = result.returncode == 0
         stdout = result.stdout.strip()
         stderr = result.stderr.strip()
-        if not ok and result.returncode not in allowed_returncodes:
+        if not ok:
             logger.error(
                 "Git command failed: %s (rc=%d) stderr=%s",
                 " ".join(cmd), result.returncode, stderr,
@@ -388,10 +381,7 @@ class CheckpointManager:
 
         # Check if there's anything to commit
         ok_diff, diff_out, _ = _run_git(
-            ["diff", "--cached", "--quiet"],
-            shadow,
-            working_dir,
-            allowed_returncodes={1},
+            ["diff", "--cached", "--quiet"], shadow, working_dir,
         )
         if ok_diff:
             # No changes to commit

tools/clarify_tool.py

@@ -137,5 +137,4 @@ registry.register(
         choices=args.get("choices"),
         callback=kw.get("callback")),
     check_fn=check_clarify_requirements,
-    emoji="❓",
 )

tools/code_execution_tool.py

@@ -776,5 +776,4 @@ registry.register(
         task_id=kw.get("task_id"),
         enabled_tools=kw.get("enabled_tools")),
     check_fn=check_sandbox_requirements,
-    emoji="🐍",
 )

tools/cronjob_tools.py

@@ -458,5 +458,4 @@ registry.register(
         task_id=kw.get("task_id"),
     ),
     check_fn=check_cronjob_requirements,
-    emoji="⏰",
 )

tools/delegate_tool.py

@@ -116,8 +116,15 @@ def _build_child_progress_callback(task_index: int, parent_agent, task_count: in
         # Regular tool call event
         if spinner:
             short = (preview[:35] + "...") if preview and len(preview) > 35 else (preview or "")
-            from agent.display import get_tool_emoji
-            emoji = get_tool_emoji(tool_name)
+            tool_emojis = {
+                "terminal": "💻", "web_search": "🔍", "web_extract": "📄",
+                "read_file": "📖", "write_file": "✍️", "patch": "🔧",
+                "search_files": "🔎", "list_directory": "📂",
+                "browser_navigate": "🌐", "browser_click": "👆",
+                "text_to_speech": "🔊", "image_generate": "🎨",
+                "vision_analyze": "👁️", "process": "⚙️",
+            }
+            emoji = tool_emojis.get(tool_name, "⚡")
             line = f" {prefix}├─ {emoji} {tool_name}"
             if short:
                 line += f"  \"{short}\""
@@ -751,5 +758,4 @@ registry.register(
         max_iterations=args.get("max_iterations"),
         parent_agent=kw.get("parent_agent")),
     check_fn=check_delegate_requirements,
-    emoji="🔀",
 )

tools/environments/docker.py

@@ -7,6 +7,7 @@ persistence via bind mounts.
 
 import logging
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -30,6 +31,42 @@ _DOCKER_SEARCH_PATHS = [
 ]
 
 _docker_executable: Optional[str] = None  # resolved once, cached
+_ENV_VAR_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def _normalize_forward_env_names(forward_env: list[str] | None) -> list[str]:
+    """Return a deduplicated list of valid environment variable names."""
+    normalized: list[str] = []
+    seen: set[str] = set()
+
+    for item in forward_env or []:
+        if not isinstance(item, str):
+            logger.warning("Ignoring non-string docker_forward_env entry: %r", item)
+            continue
+
+        key = item.strip()
+        if not key:
+            continue
+        if not _ENV_VAR_NAME_RE.match(key):
+            logger.warning("Ignoring invalid docker_forward_env entry: %r", item)
+            continue
+        if key in seen:
+            continue
+
+        seen.add(key)
+        normalized.append(key)
+
+    return normalized
+
+
+def _load_hermes_env_vars() -> dict[str, str]:
+    """Load ~/.hermes/.env values without failing Docker command execution."""
+    try:
+        from hermes_cli.config import load_env
+
+        return load_env() or {}
+    except Exception:
+        return {}
 
 
 def find_docker() -> Optional[str]:
@@ -171,6 +208,7 @@ class DockerEnvironment(BaseEnvironment):
         persistent_filesystem: bool = False,
         task_id: str = "default",
         volumes: list = None,
+        forward_env: list[str] | None = None,
         network: bool = True,
     ):
         if cwd == "~":
@@ -179,6 +217,7 @@ class DockerEnvironment(BaseEnvironment):
         self._base_image = image
         self._persistent = persistent_filesystem
         self._task_id = task_id
+        self._forward_env = _normalize_forward_env_names(forward_env)
         self._container_id: Optional[str] = None
         logger.info(f"DockerEnvironment volumes: {volumes}")
         # Ensure volumes is a list (config.yaml could be malformed)
@@ -330,8 +369,12 @@ class DockerEnvironment(BaseEnvironment):
         if effective_stdin is not None:
             cmd.append("-i")
         cmd.extend(["-w", work_dir])
-        for key in self._inner.config.forward_env:
-            if (value := os.getenv(key)) is not None:
+        hermes_env = _load_hermes_env_vars() if self._forward_env else {}
+        for key in self._forward_env:
+            value = os.getenv(key)
+            if value is None:
+                value = hermes_env.get(key)
+            if value is not None:
                 cmd.extend(["-e", f"{key}={value}"])
         for key, value in self._inner.config.env.items():
             cmd.extend(["-e", f"{key}={value}"])

tools/environments/ssh.py

@@ -1,7 +1,6 @@
 """SSH remote execution environment with ControlMaster connection persistence."""
 
 import logging
-import shutil
 import subprocess
 import tempfile
 import threading
@@ -14,14 +13,6 @@ from tools.interrupt import is_interrupted
 logger = logging.getLogger(__name__)
 
 
-def _ensure_ssh_available() -> None:
-    """Fail fast with a clear error when the SSH client is unavailable."""
-    if not shutil.which("ssh"):
-        raise RuntimeError(
-            "SSH is not installed or not in PATH. Install OpenSSH client: apt install openssh-client"
-        )
-
-
 class SSHEnvironment(BaseEnvironment):
     """Run commands on a remote machine over SSH.
 
@@ -44,7 +35,6 @@ class SSHEnvironment(BaseEnvironment):
         self.control_dir = Path(tempfile.gettempdir()) / "hermes-ssh"
         self.control_dir.mkdir(parents=True, exist_ok=True)
         self.control_socket = self.control_dir / f"{user}@{host}:{port}.sock"
-        _ensure_ssh_available()
         self._establish_connection()
 
     def _build_ssh_command(self, extra_args: list = None) -> list:

tools/file_tools.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 """File Tools Module - LLM agent file manipulation tools."""
 
-import errno
 import json
 import logging
 import os
@@ -12,18 +11,6 @@ from agent.redact import redact_sensitive_text
 
 logger = logging.getLogger(__name__)
 
-_EXPECTED_WRITE_ERRNOS = {errno.EACCES, errno.EPERM, errno.EROFS}
-
-
-def _is_expected_write_exception(exc: Exception) -> bool:
-    """Return True for expected write denials that should not hit error logs."""
-    if isinstance(exc, PermissionError):
-        return True
-    if isinstance(exc, OSError) and exc.errno in _EXPECTED_WRITE_ERRNOS:
-        return True
-    return False
-
-
 _file_ops_lock = threading.Lock()
 _file_ops_cache: dict = {}
 
@@ -251,10 +238,7 @@ def write_file_tool(path: str, content: str, task_id: str = "default") -> str:
         result = file_ops.write_file(path, content)
         return json.dumps(result.to_dict(), ensure_ascii=False)
     except Exception as e:
-        if _is_expected_write_exception(e):
-            logger.debug("write_file expected denial: %s: %s", type(e).__name__, e)
-        else:
-            logger.error("write_file error: %s: %s", type(e).__name__, e, exc_info=True)
+        logger.error("write_file error: %s: %s", type(e).__name__, e)
         return json.dumps({"error": str(e)}, ensure_ascii=False)
 
 
@@ -464,7 +448,7 @@ def _handle_search_files(args, **kw):
         output_mode=args.get("output_mode", "content"), context=args.get("context", 0), task_id=tid)
 
 
-registry.register(name="read_file", toolset="file", schema=READ_FILE_SCHEMA, handler=_handle_read_file, check_fn=_check_file_reqs, emoji="📖")
-registry.register(name="write_file", toolset="file", schema=WRITE_FILE_SCHEMA, handler=_handle_write_file, check_fn=_check_file_reqs, emoji="✍️")
-registry.register(name="patch", toolset="file", schema=PATCH_SCHEMA, handler=_handle_patch, check_fn=_check_file_reqs, emoji="🔧")
-registry.register(name="search_files", toolset="file", schema=SEARCH_FILES_SCHEMA, handler=_handle_search_files, check_fn=_check_file_reqs, emoji="🔎")
+registry.register(name="read_file", toolset="file", schema=READ_FILE_SCHEMA, handler=_handle_read_file, check_fn=_check_file_reqs)
+registry.register(name="write_file", toolset="file", schema=WRITE_FILE_SCHEMA, handler=_handle_write_file, check_fn=_check_file_reqs)
+registry.register(name="patch", toolset="file", schema=PATCH_SCHEMA, handler=_handle_patch, check_fn=_check_file_reqs)
+registry.register(name="search_files", toolset="file", schema=SEARCH_FILES_SCHEMA, handler=_handle_search_files, check_fn=_check_file_reqs)

tools/homeassistant_tool.py

@@ -459,7 +459,6 @@ registry.register(
     schema=HA_LIST_ENTITIES_SCHEMA,
     handler=_handle_list_entities,
     check_fn=_check_ha_available,
-    emoji="🏠",
 )
 
 registry.register(
@@ -468,7 +467,6 @@ registry.register(
     schema=HA_GET_STATE_SCHEMA,
     handler=_handle_get_state,
     check_fn=_check_ha_available,
-    emoji="🏠",
 )
 
 registry.register(
@@ -477,7 +475,6 @@ registry.register(
     schema=HA_LIST_SERVICES_SCHEMA,
     handler=_handle_list_services,
     check_fn=_check_ha_available,
-    emoji="🏠",
 )
 
 registry.register(
@@ -486,5 +483,4 @@ registry.register(
     schema=HA_CALL_SERVICE_SCHEMA,
     handler=_handle_call_service,
     check_fn=_check_ha_available,
-    emoji="🏠",
 )

tools/honcho_tools.py

@@ -222,7 +222,6 @@ registry.register(
     schema=_PROFILE_SCHEMA,
     handler=_handle_honcho_profile,
     check_fn=_check_honcho_available,
-    emoji="🔮",
 )
 
 registry.register(
@@ -231,7 +230,6 @@ registry.register(
     schema=_SEARCH_SCHEMA,
     handler=_handle_honcho_search,
     check_fn=_check_honcho_available,
-    emoji="🔮",
 )
 
 registry.register(
@@ -240,7 +238,6 @@ registry.register(
     schema=_QUERY_SCHEMA,
     handler=_handle_honcho_context,
     check_fn=_check_honcho_available,
-    emoji="🔮",
 )
 
 registry.register(
@@ -249,5 +246,4 @@ registry.register(
     schema=_CONCLUDE_SCHEMA,
     handler=_handle_honcho_conclude,
     check_fn=_check_honcho_available,
-    emoji="🔮",
 )

tools/image_generation_tool.py

@@ -558,5 +558,4 @@ registry.register(
     check_fn=check_image_generation_requirements,
     requires_env=["FAL_KEY"],
     is_async=False,  # Switched to sync fal_client API to fix "Event loop is closed" in gateway
-    emoji="🎨",
 )

tools/memory_tool.py

@@ -496,7 +496,6 @@ registry.register(
         old_text=args.get("old_text"),
         store=kw.get("store")),
     check_fn=check_memory_requirements,
-    emoji="🧠",
 )
 
 

tools/mixture_of_agents_tool.py

@@ -544,5 +544,4 @@ registry.register(
     check_fn=check_moa_requirements,
     requires_env=["OPENROUTER_API_KEY"],
     is_async=True,
-    emoji="🧠",
 )

tools/process_registry.py

@@ -858,5 +858,4 @@ registry.register(
     toolset="terminal",
     schema=PROCESS_SCHEMA,
     handler=_handle_process,
-    emoji="⚙️",
 )

tools/registry.py

@@ -26,11 +26,11 @@ class ToolEntry:
 
     __slots__ = (
         "name", "toolset", "schema", "handler", "check_fn",
-        "requires_env", "is_async", "description", "emoji",
+        "requires_env", "is_async", "description",
     )
 
     def __init__(self, name, toolset, schema, handler, check_fn,
-                 requires_env, is_async, description, emoji):
+                 requires_env, is_async, description):
         self.name = name
         self.toolset = toolset
         self.schema = schema
@@ -39,7 +39,6 @@ class ToolEntry:
         self.requires_env = requires_env
         self.is_async = is_async
         self.description = description
-        self.emoji = emoji
 
 
 class ToolRegistry:
@@ -63,7 +62,6 @@ class ToolRegistry:
         requires_env: list = None,
         is_async: bool = False,
         description: str = "",
-        emoji: str = "",
     ):
         """Register a tool.  Called at module-import time by each tool file."""
         self._tools[name] = ToolEntry(
@@ -75,7 +73,6 @@ class ToolRegistry:
             requires_env=requires_env or [],
             is_async=is_async,
             description=description or schema.get("description", ""),
-            emoji=emoji,
         )
         if check_fn and toolset not in self._toolset_checks:
             self._toolset_checks[toolset] = check_fn
@@ -144,11 +141,6 @@ class ToolRegistry:
         entry = self._tools.get(name)
         return entry.toolset if entry else None
 
-    def get_emoji(self, name: str, default: str = "⚡") -> str:
-        """Return the emoji for a tool, or *default* if unset."""
-        entry = self._tools.get(name)
-        return (entry.emoji if entry and entry.emoji else default)
-
     def get_tool_to_toolset_map(self) -> Dict[str, str]:
         """Return ``{tool_name: toolset_name}`` for every registered tool."""
         return {name: e.toolset for name, e in self._tools.items()}

tools/rl_training_tool.py

@@ -1374,24 +1374,24 @@ RL_TEST_INFERENCE_SCHEMA = {"name": "rl_test_inference", "description": "Quick i
 
 _rl_env = ["TINKER_API_KEY", "WANDB_API_KEY"]
 
-registry.register(name="rl_list_environments", emoji="🧪", toolset="rl", schema=RL_LIST_ENVIRONMENTS_SCHEMA,
+registry.register(name="rl_list_environments", toolset="rl", schema=RL_LIST_ENVIRONMENTS_SCHEMA,
     handler=lambda args, **kw: rl_list_environments(), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_select_environment", emoji="🧪", toolset="rl", schema=RL_SELECT_ENVIRONMENT_SCHEMA,
+registry.register(name="rl_select_environment", toolset="rl", schema=RL_SELECT_ENVIRONMENT_SCHEMA,
     handler=lambda args, **kw: rl_select_environment(name=args.get("name", "")), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_get_current_config", emoji="🧪", toolset="rl", schema=RL_GET_CURRENT_CONFIG_SCHEMA,
+registry.register(name="rl_get_current_config", toolset="rl", schema=RL_GET_CURRENT_CONFIG_SCHEMA,
     handler=lambda args, **kw: rl_get_current_config(), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_edit_config", emoji="🧪", toolset="rl", schema=RL_EDIT_CONFIG_SCHEMA,
+registry.register(name="rl_edit_config", toolset="rl", schema=RL_EDIT_CONFIG_SCHEMA,
     handler=lambda args, **kw: rl_edit_config(field=args.get("field", ""), value=args.get("value")), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_start_training", emoji="🧪", toolset="rl", schema=RL_START_TRAINING_SCHEMA,
+registry.register(name="rl_start_training", toolset="rl", schema=RL_START_TRAINING_SCHEMA,
     handler=lambda args, **kw: rl_start_training(), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_check_status", emoji="🧪", toolset="rl", schema=RL_CHECK_STATUS_SCHEMA,
+registry.register(name="rl_check_status", toolset="rl", schema=RL_CHECK_STATUS_SCHEMA,
     handler=lambda args, **kw: rl_check_status(run_id=args.get("run_id", "")), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_stop_training", emoji="🧪", toolset="rl", schema=RL_STOP_TRAINING_SCHEMA,
+registry.register(name="rl_stop_training", toolset="rl", schema=RL_STOP_TRAINING_SCHEMA,
     handler=lambda args, **kw: rl_stop_training(run_id=args.get("run_id", "")), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_get_results", emoji="🧪", toolset="rl", schema=RL_GET_RESULTS_SCHEMA,
+registry.register(name="rl_get_results", toolset="rl", schema=RL_GET_RESULTS_SCHEMA,
     handler=lambda args, **kw: rl_get_results(run_id=args.get("run_id", "")), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_list_runs", emoji="🧪", toolset="rl", schema=RL_LIST_RUNS_SCHEMA,
+registry.register(name="rl_list_runs", toolset="rl", schema=RL_LIST_RUNS_SCHEMA,
     handler=lambda args, **kw: rl_list_runs(), check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)
-registry.register(name="rl_test_inference", emoji="🧪", toolset="rl", schema=RL_TEST_INFERENCE_SCHEMA,
+registry.register(name="rl_test_inference", toolset="rl", schema=RL_TEST_INFERENCE_SCHEMA,
     handler=lambda args, **kw: rl_test_inference(num_steps=args.get("num_steps", 3), group_size=args.get("group_size", 16), models=args.get("models")),
     check_fn=check_rl_api_keys, requires_env=_rl_env, is_async=True)

tools/send_message_tool.py

@@ -512,5 +512,4 @@ registry.register(
     schema=SEND_MESSAGE_SCHEMA,
     handler=send_message_tool,
     check_fn=_check_send_message,
-    emoji="📨",
 )

tools/session_search_tool.py

@@ -385,5 +385,4 @@ registry.register(
         db=kw.get("db"),
         current_session_id=kw.get("current_session_id")),
     check_fn=check_session_search_requirements,
-    emoji="🔍",
 )

tools/skill_manager_tool.py

@@ -653,5 +653,4 @@ registry.register(
         old_string=args.get("old_string"),
         new_string=args.get("new_string"),
         replace_all=args.get("replace_all", False)),
-    emoji="📝",
 )

tools/skills_tool.py

@@ -1261,7 +1261,6 @@ registry.register(
         category=args.get("category"), task_id=kw.get("task_id")
     ),
     check_fn=check_skills_requirements,
-    emoji="📚",
 )
 registry.register(
     name="skill_view",
@@ -1271,5 +1270,4 @@ registry.register(
         args.get("name", ""), file_path=args.get("file_path"), task_id=kw.get("task_id")
     ),
     check_fn=check_skills_requirements,
-    emoji="📚",
 )

tools/terminal_tool.py

@@ -492,6 +492,7 @@ def _get_env_config() -> Dict[str, Any]:
     return {
         "env_type": env_type,
         "docker_image": os.getenv("TERMINAL_DOCKER_IMAGE", default_image),
+        "docker_forward_env": _parse_env_var("TERMINAL_DOCKER_FORWARD_ENV", "[]", json.loads, "valid JSON"),
         "singularity_image": os.getenv("TERMINAL_SINGULARITY_IMAGE", f"docker://{default_image}"),
         "modal_image": os.getenv("TERMINAL_MODAL_IMAGE", default_image),
         "daytona_image": os.getenv("TERMINAL_DAYTONA_IMAGE", default_image),
@@ -536,6 +537,7 @@ def _create_environment(env_type: str, image: str, cwd: str, timeout: int,
     disk = cc.get("container_disk", 51200)
     persistent = cc.get("container_persistent", True)
     volumes = cc.get("docker_volumes", [])
+    docker_forward_env = cc.get("docker_forward_env", [])
 
     if env_type == "local":
         return _LocalEnvironment(cwd=cwd, timeout=timeout)
@@ -546,6 +548,7 @@ def _create_environment(env_type: str, image: str, cwd: str, timeout: int,
             cpu=cpu, memory=memory, disk=disk,
             persistent_filesystem=persistent, task_id=task_id,
             volumes=volumes,
+            forward_env=docker_forward_env,
         )
     
     elif env_type == "singularity":
@@ -1317,5 +1320,4 @@ registry.register(
     schema=TERMINAL_SCHEMA,
     handler=_handle_terminal,
     check_fn=check_terminal_requirements,
-    emoji="💻",
 )

tools/tirith_security.py

@@ -279,7 +279,7 @@ def _verify_checksum(archive_path: str, checksums_path: str, archive_name: str)
     return True
 
 
-def _install_tirith(*, log_failures: bool = True) -> tuple[str | None, str]:
+def _install_tirith() -> tuple[str | None, str]:
     """Download and install tirith to $HERMES_HOME/bin/tirith.
 
     Verifies provenance via cosign and SHA-256 checksum.
@@ -287,8 +287,6 @@ def _install_tirith(*, log_failures: bool = True) -> tuple[str | None, str]:
     failure_reason is a short tag used by the disk marker to decide if the
     failure is retryable (e.g. "cosign_missing" clears when cosign appears).
     """
-    log = logger.warning if log_failures else logger.debug
-
     target = _detect_target()
     if not target:
         logger.info("tirith auto-install: unsupported platform %s/%s",
@@ -311,7 +309,7 @@ def _install_tirith(*, log_failures: bool = True) -> tuple[str | None, str]:
             _download_file(f"{base_url}/{archive_name}", archive_path)
             _download_file(f"{base_url}/checksums.txt", checksums_path)
         except Exception as exc:
-            log("tirith download failed: %s", exc)
+            logger.warning("tirith download failed: %s", exc)
             return None, "download_failed"
 
         # Cosign provenance verification is mandatory for auto-install.
@@ -322,25 +320,25 @@ def _install_tirith(*, log_failures: bool = True) -> tuple[str | None, str]:
             _download_file(f"{base_url}/checksums.txt.sig", sig_path)
             _download_file(f"{base_url}/checksums.txt.pem", cert_path)
         except Exception as exc:
-            log("tirith install skipped: cosign artifacts unavailable (%s). "
-                "Install tirith manually or install cosign for auto-install.", exc)
+            logger.warning("tirith install skipped: cosign artifacts unavailable (%s). "
+                          "Install tirith manually or install cosign for auto-install.", exc)
             return None, "cosign_artifacts_unavailable"
 
         # Check cosign availability before attempting verification so we can
         # distinguish "not installed" (retryable) from "installed but broken."
         if not shutil.which("cosign"):
-            log("tirith install skipped: cosign not found on PATH. "
-                "Install cosign for auto-install, or install tirith manually.")
+            logger.warning("tirith install skipped: cosign not found on PATH. "
+                          "Install cosign for auto-install, or install tirith manually.")
             return None, "cosign_missing"
 
         cosign_result = _verify_cosign(checksums_path, sig_path, cert_path)
         if cosign_result is not True:
             # False = verification rejected, None = execution failure (timeout/OSError)
             if cosign_result is None:
-                log("tirith install aborted: cosign execution failed")
+                logger.warning("tirith install aborted: cosign execution failed")
                 return None, "cosign_exec_failed"
             else:
-                log("tirith install aborted: cosign provenance verification failed")
+                logger.warning("tirith install aborted: cosign provenance verification failed")
                 return None, "cosign_verification_failed"
 
         if not _verify_checksum(archive_path, checksums_path, archive_name):
@@ -356,7 +354,7 @@ def _install_tirith(*, log_failures: bool = True) -> tuple[str | None, str]:
                     tar.extract(member, tmpdir)
                     break
             else:
-                log("tirith binary not found in archive")
+                logger.warning("tirith binary not found in archive")
                 return None, "binary_not_in_archive"
 
         src = os.path.join(tmpdir, "tirith")
@@ -475,7 +473,7 @@ def _resolve_tirith_path(configured_path: str) -> str:
     return expanded
 
 
-def _background_install(*, log_failures: bool = True):
+def _background_install():
     """Background thread target: download and install tirith."""
     global _resolved_path, _install_failure_reason
     with _install_lock:
@@ -496,7 +494,7 @@ def _background_install(*, log_failures: bool = True):
             _install_failure_reason = ""
             return
 
-        installed, reason = _install_tirith(log_failures=log_failures)
+        installed, reason = _install_tirith()
         if installed:
             _resolved_path = installed
             _install_failure_reason = ""
@@ -507,7 +505,7 @@ def _background_install(*, log_failures: bool = True):
             _mark_install_failed(reason)
 
 
-def ensure_installed(*, log_failures: bool = True):
+def ensure_installed():
     """Ensure tirith is available, downloading in background if needed.
 
     Quick PATH/local checks are synchronous; network download runs in a
@@ -580,10 +578,7 @@ def ensure_installed(*, log_failures: bool = True):
     # Need to download — launch background thread so startup doesn't block
     if _install_thread is None or not _install_thread.is_alive():
         _install_thread = threading.Thread(
-            target=_background_install,
-            kwargs={"log_failures": log_failures},
-            daemon=True,
-        )
+            target=_background_install, daemon=True)
         _install_thread.start()
 
     return None  # Not available yet; commands will fail-open until ready

tools/todo_tool.py

@@ -264,5 +264,4 @@ registry.register(
     handler=lambda args, **kw: todo_tool(
         todos=args.get("todos"), merge=args.get("merge", False), store=kw.get("store")),
     check_fn=check_todo_requirements,
-    emoji="📋",
 )

tools/tts_tool.py

@@ -743,5 +743,4 @@ registry.register(
         text=args.get("text", ""),
         output_path=args.get("output_path")),
     check_fn=check_tts_requirements,
-    emoji="🔊",
 )

tools/vision_tools.py

@@ -493,5 +493,4 @@ registry.register(
     handler=_handle_vision_analyze,
     check_fn=check_vision_requirements,
     is_async=True,
-    emoji="👁️",
 )

tools/web_tools.py

@@ -1258,7 +1258,6 @@ registry.register(
     handler=lambda args, **kw: web_search_tool(args.get("query", ""), limit=5),
     check_fn=check_firecrawl_api_key,
     requires_env=["FIRECRAWL_API_KEY"],
-    emoji="🔍",
 )
 registry.register(
     name="web_extract",
@@ -1269,5 +1268,4 @@ registry.register(
     check_fn=check_firecrawl_api_key,
     requires_env=["FIRECRAWL_API_KEY"],
     is_async=True,
-    emoji="📄",
 )

utils.py

@@ -50,8 +50,6 @@ def atomic_json_write(
             os.fsync(f.fileno())
         os.replace(tmp_path, path)
     except BaseException:
-        # Intentionally catch BaseException so temp-file cleanup still runs for
-        # KeyboardInterrupt/SystemExit before re-raising the original signal.
         try:
             os.unlink(tmp_path)
         except OSError:
@@ -98,8 +96,6 @@ def atomic_yaml_write(
             os.fsync(f.fileno())
         os.replace(tmp_path, path)
     except BaseException:
-        # Match atomic_json_write: cleanup must also happen for process-level
-        # interruptions before we re-raise them.
         try:
             os.unlink(tmp_path)
         except OSError:

website/docs/reference/environment-variables.md

@@ -76,6 +76,7 @@ For native Anthropic auth, Hermes prefers Claude Code's own credential files whe
 |----------|-------------|
 | `TERMINAL_ENV` | Backend: `local`, `docker`, `ssh`, `singularity`, `modal`, `daytona` |
 | `TERMINAL_DOCKER_IMAGE` | Docker image (default: `python:3.11`) |
+| `TERMINAL_DOCKER_FORWARD_ENV` | JSON array of env var names to explicitly forward into Docker terminal sessions |
 | `TERMINAL_DOCKER_VOLUMES` | Additional Docker volume mounts (comma-separated `host:container` pairs) |
 | `TERMINAL_SINGULARITY_IMAGE` | Singularity image or `.sif` path |
 | `TERMINAL_MODAL_IMAGE` | Modal container image |

website/docs/user-guide/configuration.md

@@ -453,6 +453,8 @@ terminal:
 
   # Docker-specific settings
   docker_image: "nikolaik/python-nodejs:python3.11-nodejs20"
+  docker_forward_env:              # Optional explicit allowlist for env passthrough
+    - "GITHUB_TOKEN"
   docker_volumes:                    # Share host directories with the container
     - "/home/user/projects:/workspace/projects"
     - "/home/user/data:/data:ro"     # :ro for read-only
@@ -517,6 +519,24 @@ This is useful for:
 
 Can also be set via environment variable: `TERMINAL_DOCKER_VOLUMES='["/host:/container"]'` (JSON array).
 
+### Docker Credential Forwarding
+
+By default, Docker terminal sessions do not inherit arbitrary host credentials. If you need a specific token inside the container, add it to `terminal.docker_forward_env`.
+
+```yaml
+terminal:
+  backend: docker
+  docker_forward_env:
+    - "GITHUB_TOKEN"
+    - "NPM_TOKEN"
+```
+
+Hermes resolves each listed variable from your current shell first, then falls back to `~/.hermes/.env` if it was saved with `hermes config set`.
+
+:::warning
+Anything listed in `docker_forward_env` becomes visible to commands run inside the container. Only forward credentials you are comfortable exposing to the terminal session.
+:::
+
 See [Code Execution](features/code-execution.md) and the [Terminal section of the README](features/tools.md) for details on each backend.
 
 ## Memory Configuration

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

@@ -135,6 +135,8 @@ All container backends run with security hardening:
 - Full namespace isolation
 - Persistent workspace via volumes, not writable root layer
 
+Docker can optionally receive an explicit env allowlist via `terminal.docker_forward_env`, but forwarded variables are visible to commands inside the container and should be treated as exposed to that session.
+
 ## Background Process Management
 
 Start background processes and manage them:

website/docs/user-guide/security.md

@@ -212,6 +212,7 @@ Container resources are configurable in `~/.hermes/config.yaml`:
 terminal:
   backend: docker
   docker_image: "nikolaik/python-nodejs:python3.11-nodejs20"
+  docker_forward_env: []  # Explicit allowlist only; empty keeps secrets out of the container
   container_cpu: 1        # CPU cores
   container_memory: 5120  # MB (default 5GB)
   container_disk: 51200   # MB (default 50GB, requires overlay2 on XFS)
@@ -227,6 +228,10 @@ terminal:
 For production gateway deployments, use `docker`, `modal`, or `daytona` backend to isolate agent commands from your host system. This eliminates the need for dangerous command approval entirely.
 :::
 
+:::warning
+If you add names to `terminal.docker_forward_env`, those variables are intentionally injected into the container for terminal commands. This is useful for task-specific credentials like `GITHUB_TOKEN`, but it also means code running in the container can read and exfiltrate them.
+:::
+
 ## Terminal Backend Security Comparison
 
 | Backend | Isolation | Dangerous Cmd Check | Best For |