fix(telegram): escape chunk indicators in MarkdownV2

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.py

@@ -1414,7 +1414,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 +1428,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 +3285,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 +3357,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."""

gateway/run.py

@@ -3856,8 +3856,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:

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", ""),
     )

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/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_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_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"

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/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/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

@@ -464,7 +464,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

@@ -1317,5 +1317,4 @@ registry.register(
     schema=TERMINAL_SCHEMA,
     handler=_handle_terminal,
     check_fn=check_terminal_requirements,
-    emoji="💻",
 )

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="📄",
 )