feat: Codex-style handoff prefix for compressed context summaries

Replace the old '[CONTEXT SUMMARY]:' prefix on compressed summaries with a Codex-inspired handoff framing that tells the model what happened and how to use the summary. What changes: 1. New SUMMARY_PREFIX constant — the text prepended to every compressed summary: [CONTEXT COMPACTION] An earlier part of this conversation was summarized to preserve context space. Below is the summary — use it to build on the work already done and avoid duplicating effort: 2. _with_summary_prefix() helper — normalizes model output by stripping any legacy '[CONTEXT SUMMARY]:' prefix the summarization model may have produced, then prepends the new SUMMARY_PREFIX. 3. System message annotation updated — the note appended to the system prompt on first compression now says 'compacted into a handoff summary' and instructs 'build on that summary rather than re-doing work' instead of the old generic note. Why this is better: The old prefix ('[CONTEXT SUMMARY]: <raw text>') gave the model no context about what the summary is or how to use it. The new prefix explicitly frames it as a context compaction event and instructs the model to build on prior work rather than re-doing it. This reduces redundant tool calls and file re-reads after compression. What does NOT change: - The compression algorithm (positional protection, boundary alignment) - The role alternation logic (summary role adapts to avoid consecutive same-role messages) - The summarization model or trigger thresholds - LEGACY_SUMMARY_PREFIX is exported for backward compatibility Inspired by PR #776 by @kshitijk4poor and the research in #499.
refactor(slack): replace print statements with structured logging
2026-07-11 21:02:12 +08:00 · 2026-03-11 05:41:05 -07:00 · 2026-03-11 05:34:43 -07:00
14 changed files with 109 additions and 598 deletions
--- a/agent/context_compressor.py
+++ b/agent/context_compressor.py
@@ -17,6 +17,13 @@ from agent.model_metadata import (

 logger = logging.getLogger(__name__)

+SUMMARY_PREFIX = (
+    "[CONTEXT COMPACTION] An earlier part of this conversation was "
+    "summarized to preserve context space. Below is the summary — use it "
+    "to build on the work already done and avoid duplicating effort:"
+)
+LEGACY_SUMMARY_PREFIX = "[CONTEXT SUMMARY]:"
+

 class ContextCompressor:
    """Compresses conversation context when approaching the model's context limit.
@@ -166,9 +173,19 @@ Write only the summary, starting with "[CONTEXT SUMMARY]:" prefix."""
                raise

        summary = response.choices[0].message.content.strip()
-        if not summary.startswith("[CONTEXT SUMMARY]:"):
-            summary = "[CONTEXT SUMMARY]: " + summary
-        return summary
+        return self._with_summary_prefix(summary)
+
+    @staticmethod
+    def _with_summary_prefix(summary: str) -> str:
+        """Normalize the summary prefix to the current standard.
+
+        Strips any legacy ``[CONTEXT SUMMARY]:`` prefix the model may have
+        produced and prepends the current ``SUMMARY_PREFIX`` handoff text.
+        """
+        text = (summary or "").strip()
+        if text.startswith(LEGACY_SUMMARY_PREFIX):
+            text = text[len(LEGACY_SUMMARY_PREFIX):].lstrip()
+        return f"{SUMMARY_PREFIX}\n{text}"

    def _get_fallback_client(self):
        """Try to build a fallback client from the main model's endpoint config.
@@ -338,7 +355,7 @@ Write only the summary, starting with "[CONTEXT SUMMARY]:" prefix."""
        for i in range(compress_start):
            msg = messages[i].copy()
            if i == 0 and msg.get("role") == "system" and self.compression_count == 0:
-                msg["content"] = (msg.get("content") or "") + "\n\n[Note: Some earlier conversation turns may be summarized to preserve context space.]"
+                msg["content"] = (msg.get("content") or "") + "\n\n[Note: Some earlier conversation turns have been compacted into a handoff summary to preserve context space. Build on that summary rather than re-doing work.]"
            compressed.append(msg)

        if summary:
--- a/cli-config.yaml.example
+++ b/cli-config.yaml.example
@@ -670,11 +670,6 @@ display:
  # Works over SSH. Most terminals can be configured to flash the taskbar or play a sound.
  bell_on_complete: false

-  # Show model reasoning/thinking before each response.
-  # When enabled, a dim box shows the model's thought process above the response.
-  # Toggle at runtime with /reasoning show or /reasoning hide.
-  show_reasoning: false
-
  # ───────────────────────────────────────────────────────────────────────────
  # Skin / Theme
  # ───────────────────────────────────────────────────────────────────────────
--- a/cli.py
+++ b/cli.py
@@ -205,7 +205,6 @@ def load_cli_config() -> Dict[str, Any]:
        "display": {
            "compact": False,
            "resume_display": "full",
-            "show_reasoning": False,
            "skin": "default",
        },
        "clarify": {
@@ -1122,8 +1121,6 @@ class HermesCLI:
        self.resume_display = CLI_CONFIG["display"].get("resume_display", "full")
        # bell_on_complete: play terminal bell (\a) when agent finishes a response
        self.bell_on_complete = CLI_CONFIG["display"].get("bell_on_complete", False)
-        # show_reasoning: display model thinking/reasoning before the response
-        self.show_reasoning = CLI_CONFIG["display"].get("show_reasoning", False)
        self.verbose = verbose if verbose is not None else (self.tool_progress_mode == "verbose")
        
        # Configuration - priority: CLI args > env vars > config file
@@ -1498,7 +1495,6 @@ class HermesCLI:
                platform="cli",
                session_db=self._session_db,
                clarify_callback=self._clarify_callback,
-                reasoning_callback=self._on_reasoning if self.show_reasoning else None,
                honcho_session_key=self.session_id,
                fallback_model=self._fallback_model,
                thinking_callback=self._on_thinking,
@@ -2852,8 +2848,6 @@ class HermesCLI:
            self._show_gateway_status()
        elif cmd_lower == "/verbose":
            self._toggle_verbose()
-        elif cmd_lower.startswith("/reasoning"):
-            self._handle_reasoning_command(cmd_original)
        elif cmd_lower == "/compress":
            self._manual_compress()
        elif cmd_lower == "/usage":
@@ -3079,75 +3073,6 @@ class HermesCLI:
        }
        self.console.print(labels.get(self.tool_progress_mode, ""))

-    def _handle_reasoning_command(self, cmd: str):
-        """Handle /reasoning — manage effort level and display toggle.
-
-        Usage:
-            /reasoning              Show current effort level and display state
-            /reasoning <level>      Set reasoning effort (none, low, medium, high, xhigh)
-            /reasoning show|on      Show model thinking/reasoning in output
-            /reasoning hide|off     Hide model thinking/reasoning from output
-        """
-        parts = cmd.strip().split(maxsplit=1)
-
-        if len(parts) < 2:
-            # Show current state
-            rc = self.reasoning_config
-            if rc is None:
-                level = "medium (default)"
-            elif rc.get("enabled") is False:
-                level = "none (disabled)"
-            else:
-                level = rc.get("effort", "medium")
-            display_state = "on" if self.show_reasoning else "off"
-            _cprint(f"  {_GOLD}Reasoning effort: {level}{_RST}")
-            _cprint(f"  {_GOLD}Reasoning display: {display_state}{_RST}")
-            _cprint(f"  {_DIM}Usage: /reasoning <none|low|medium|high|xhigh|show|hide>{_RST}")
-            return
-
-        arg = parts[1].strip().lower()
-
-        # Display toggle
-        if arg in ("show", "on"):
-            self.show_reasoning = True
-            if self.agent:
-                self.agent.reasoning_callback = self._on_reasoning
-            _cprint(f"  {_GOLD}Reasoning display: ON{_RST}")
-            _cprint(f"  {_DIM}Model thinking will be shown during and after each response.{_RST}")
-            return
-        if arg in ("hide", "off"):
-            self.show_reasoning = False
-            if self.agent:
-                self.agent.reasoning_callback = None
-            _cprint(f"  {_GOLD}Reasoning display: OFF{_RST}")
-            return
-
-        # Effort level change
-        parsed = _parse_reasoning_config(arg)
-        if parsed is None:
-            _cprint(f"  {_DIM}(._.) Unknown argument: {arg}{_RST}")
-            _cprint(f"  {_DIM}Valid levels: none, low, minimal, medium, high, xhigh{_RST}")
-            _cprint(f"  {_DIM}Display:      show, hide{_RST}")
-            return
-
-        self.reasoning_config = parsed
-        self.agent = None  # Force agent re-init with new reasoning config
-
-        if save_config_value("agent.reasoning_effort", arg):
-            _cprint(f"  {_GOLD}Reasoning effort set to '{arg}' (saved to config){_RST}")
-        else:
-            _cprint(f"  {_GOLD}Reasoning effort set to '{arg}' (session only){_RST}")
-
-    def _on_reasoning(self, reasoning_text: str):
-        """Callback for intermediate reasoning display during tool-call loops."""
-        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}")
-
    def _manual_compress(self):
        """Manually trigger context compression on the current conversation."""
        if not self.conversation_history or len(self.conversation_history) < 4:
@@ -3617,24 +3542,6 @@ class HermesCLI:
                if response and pending_message:
                    response = response + "\n\n---\n_[Interrupted - processing new message]_"
            
-            # Display reasoning (thinking) box if enabled and available
-            if self.show_reasoning and result:
-                reasoning = result.get("last_reasoning")
-                if reasoning:
-                    w = shutil.get_terminal_size().columns
-                    r_label = " Reasoning "
-                    r_fill = w - 2 - len(r_label)
-                    r_top = f"{_DIM}┌─{r_label}{'─' * max(r_fill - 1, 0)}┐{_RST}"
-                    r_bot = f"{_DIM}└{'─' * (w - 2)}┘{_RST}"
-                    # Collapse long reasoning: show first 10 lines
-                    lines = reasoning.strip().splitlines()
-                    if len(lines) > 10:
-                        display_reasoning = "\n".join(lines[:10])
-                        display_reasoning += f"\n{_DIM}  ... ({len(lines) - 10} more lines){_RST}"
-                    else:
-                        display_reasoning = reasoning.strip()
-                    _cprint(f"\n{r_top}\n{_DIM}{display_reasoning}{_RST}\n{r_bot}")
-
            if response:
                # Use a Rich Panel for the response box — adapts to terminal
                # width at render time instead of hard-coding border length.
--- a/gateway/platforms/slack.py
+++ b/gateway/platforms/slack.py
@@ -9,6 +9,7 @@ Uses slack-bolt (Python) with Socket Mode for:
 """

 import asyncio
+import logging
 import os
 import re
 from typing import Dict, List, Optional, Any
@@ -41,6 +42,9 @@ from gateway.platforms.base import (
 )


+logger = logging.getLogger(__name__)
+
+
 def check_slack_requirements() -> bool:
    """Check if Slack dependencies are available."""
    return SLACK_AVAILABLE
@@ -73,17 +77,19 @@ class SlackAdapter(BasePlatformAdapter):
    async def connect(self) -> bool:
        """Connect to Slack via Socket Mode."""
        if not SLACK_AVAILABLE:
-            print("[Slack] slack-bolt not installed. Run: pip install slack-bolt")
+            logger.error(
+                "[Slack] slack-bolt not installed. Run: pip install slack-bolt",
+            )
            return False

        bot_token = self.config.token
        app_token = os.getenv("SLACK_APP_TOKEN")

        if not bot_token:
-            print("[Slack] SLACK_BOT_TOKEN not set")
+            logger.error("[Slack] SLACK_BOT_TOKEN not set")
            return False
        if not app_token:
-            print("[Slack] SLACK_APP_TOKEN not set")
+            logger.error("[Slack] SLACK_APP_TOKEN not set")
            return False

        try:
@@ -117,19 +123,22 @@ class SlackAdapter(BasePlatformAdapter):
            asyncio.create_task(self._handler.start_async())

            self._running = True
-            print(f"[Slack] Connected as @{bot_name} (Socket Mode)")
+            logger.info("[Slack] Connected as @%s (Socket Mode)", bot_name)
            return True

-        except Exception as e:
-            print(f"[Slack] Connection failed: {e}")
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.error("[Slack] Connection failed: %s", e, exc_info=True)
            return False

    async def disconnect(self) -> None:
        """Disconnect from Slack."""
        if self._handler:
-            await self._handler.close_async()
+            try:
+                await self._handler.close_async()
+            except Exception as e:  # pragma: no cover - defensive logging
+                logger.warning("[Slack] Error while closing Socket Mode handler: %s", e, exc_info=True)
        self._running = False
-        print("[Slack] Disconnected")
+        logger.info("[Slack] Disconnected")

    async def send(
        self,
@@ -162,8 +171,8 @@ class SlackAdapter(BasePlatformAdapter):
                raw_response=result,
            )

-        except Exception as e:
-            print(f"[Slack] Send error: {e}")
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.error("[Slack] Send error: %s", e, exc_info=True)
            return SendResult(success=False, error=str(e))

    async def edit_message(
@@ -182,7 +191,14 @@ class SlackAdapter(BasePlatformAdapter):
                text=content,
            )
            return SendResult(success=True, message_id=message_id)
-        except Exception as e:
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.error(
+                "[Slack] Failed to edit message %s in channel %s: %s",
+                message_id,
+                chat_id,
+                e,
+                exc_info=True,
+            )
            return SendResult(success=False, error=str(e))

    async def send_typing(self, chat_id: str, metadata=None) -> None:
@@ -214,8 +230,14 @@ class SlackAdapter(BasePlatformAdapter):
            )
            return SendResult(success=True, raw_response=result)

-        except Exception as e:
-            print(f"[{self.name}] Failed to send local image: {e}")
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.error(
+                "[%s] Failed to send local Slack image %s: %s",
+                self.name,
+                image_path,
+                e,
+                exc_info=True,
+            )
            return await super().send_image_file(chat_id, image_path, caption, reply_to)

    async def send_image(
@@ -247,7 +269,13 @@ class SlackAdapter(BasePlatformAdapter):

            return SendResult(success=True, raw_response=result)

-        except Exception as e:
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.warning(
+                "[Slack] Failed to upload image from URL %s, falling back to text: %s",
+                image_url,
+                e,
+                exc_info=True,
+            )
            # Fall back to sending the URL as text
            text = f"{caption}\n{image_url}" if caption else image_url
            return await self.send(chat_id=chat_id, content=text, reply_to=reply_to)
@@ -273,7 +301,13 @@ class SlackAdapter(BasePlatformAdapter):
            )
            return SendResult(success=True, raw_response=result)

-        except Exception as e:
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.error(
+                "[Slack] Failed to send audio file %s: %s",
+                audio_path,
+                e,
+                exc_info=True,
+            )
            return SendResult(success=False, error=str(e))

    async def send_video(
@@ -300,8 +334,14 @@ class SlackAdapter(BasePlatformAdapter):
            )
            return SendResult(success=True, raw_response=result)

-        except Exception as e:
-            print(f"[{self.name}] Failed to send video: {e}")
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.error(
+                "[%s] Failed to send video %s: %s",
+                self.name,
+                video_path,
+                e,
+                exc_info=True,
+            )
            return await super().send_video(chat_id, video_path, caption, reply_to)

    async def send_document(
@@ -331,8 +371,14 @@ class SlackAdapter(BasePlatformAdapter):
            )
            return SendResult(success=True, raw_response=result)

-        except Exception as e:
-            print(f"[{self.name}] Failed to send document: {e}")
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.error(
+                "[%s] Failed to send document %s: %s",
+                self.name,
+                file_path,
+                e,
+                exc_info=True,
+            )
            return await super().send_document(chat_id, file_path, caption, file_name, reply_to)

    async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
@@ -348,7 +394,13 @@ class SlackAdapter(BasePlatformAdapter):
                "name": channel.get("name", chat_id),
                "type": "dm" if is_dm else "group",
            }
-        except Exception:
+        except Exception as e:  # pragma: no cover - defensive logging
+            logger.error(
+                "[Slack] Failed to fetch chat info for %s: %s",
+                chat_id,
+                e,
+                exc_info=True,
+            )
            return {"name": chat_id, "type": "unknown"}

    # ----- Internal handlers -----
@@ -403,8 +455,8 @@ class SlackAdapter(BasePlatformAdapter):
                    media_urls.append(cached)
                    media_types.append(mimetype)
                    msg_type = MessageType.PHOTO
-                except Exception as e:
-                    print(f"[Slack] Failed to cache image: {e}", flush=True)
+                except Exception as e:  # pragma: no cover - defensive logging
+                    logger.warning("[Slack] Failed to cache image from %s: %s", url, e, exc_info=True)
            elif mimetype.startswith("audio/") and url:
                try:
                    ext = "." + mimetype.split("/")[-1].split(";")[0]
@@ -414,8 +466,8 @@ class SlackAdapter(BasePlatformAdapter):
                    media_urls.append(cached)
                    media_types.append(mimetype)
                    msg_type = MessageType.VOICE
-                except Exception as e:
-                    print(f"[Slack] Failed to cache audio: {e}", flush=True)
+                except Exception as e:  # pragma: no cover - defensive logging
+                    logger.warning("[Slack] Failed to cache audio from %s: %s", url, e, exc_info=True)
            elif url:
                # Try to handle as a document attachment
                try:
@@ -437,7 +489,7 @@ class SlackAdapter(BasePlatformAdapter):
                    file_size = f.get("size", 0)
                    MAX_DOC_BYTES = 20 * 1024 * 1024
                    if not file_size or file_size > MAX_DOC_BYTES:
-                        print(f"[Slack] Document too large or unknown size: {file_size}", flush=True)
+                        logger.warning("[Slack] Document too large or unknown size: %s", file_size)
                        continue

                    # Download and cache
@@ -449,7 +501,7 @@ class SlackAdapter(BasePlatformAdapter):
                    media_urls.append(cached_path)
                    media_types.append(doc_mime)
                    msg_type = MessageType.DOCUMENT
-                    print(f"[Slack] Cached user document: {cached_path}", flush=True)
+                    logger.debug("[Slack] Cached user document: %s", cached_path)

                    # Inject text content for .txt/.md files (capped at 100 KB)
                    MAX_TEXT_INJECT_BYTES = 100 * 1024
@@ -466,8 +518,8 @@ class SlackAdapter(BasePlatformAdapter):
                        except UnicodeDecodeError:
                            pass  # Binary content, skip injection

-                except Exception as e:
-                    print(f"[Slack] Failed to cache document: {e}", flush=True)
+                except Exception as e:  # pragma: no cover - defensive logging
+                    logger.warning("[Slack] Failed to cache document from %s: %s", url, e, exc_info=True)

        # Build source
        source = self.build_source(
--- a/hermes_cli/commands.py
+++ b/hermes_cli/commands.py
@@ -35,7 +35,6 @@ COMMANDS_BY_CATEGORY = {
        "/prompt": "View/set custom system prompt",
        "/personality": "Set a predefined personality",
        "/verbose": "Cycle tool progress display: off → new → all → verbose",
-        "/reasoning": "Manage reasoning effort and display (usage: /reasoning [level|show|hide])",
        "/skin": "Show or change the display skin/theme",
    },
    "Tools & Skills": {
--- a/hermes_cli/config.py
+++ b/hermes_cli/config.py
@@ -143,7 +143,6 @@ DEFAULT_CONFIG = {
        "personality": "kawaii",
        "resume_display": "full",
        "bell_on_complete": False,
-        "show_reasoning": False,
        "skin": "default",
    },
    
@@ -1026,14 +1025,6 @@ def show_config():
    print(f"  Max turns:    {config.get('agent', {}).get('max_turns', DEFAULT_CONFIG['agent']['max_turns'])}")
    print(f"  Toolsets:     {', '.join(config.get('toolsets', ['all']))}")
    
-    # Display
-    print()
-    print(color("◆ Display", Colors.CYAN, Colors.BOLD))
-    display = config.get('display', {})
-    print(f"  Personality:  {display.get('personality', 'kawaii')}")
-    print(f"  Reasoning:    {'on' if display.get('show_reasoning', False) else 'off'}")
-    print(f"  Bell:         {'on' if display.get('bell_on_complete', False) else 'off'}")
-
    # Terminal
    print()
    print(color("◆ Terminal", Colors.CYAN, Colors.BOLD))
--- a/run_agent.py
+++ b/run_agent.py
@@ -173,7 +173,6 @@ class AIAgent:
        session_id: str = None,
        tool_progress_callback: callable = None,
        thinking_callback: callable = None,
-        reasoning_callback: callable = None,
        clarify_callback: callable = None,
        step_callback: callable = None,
        max_tokens: int = None,
@@ -261,7 +260,6 @@ class AIAgent:

        self.tool_progress_callback = tool_progress_callback
        self.thinking_callback = thinking_callback
-        self.reasoning_callback = reasoning_callback
        self.clarify_callback = clarify_callback
        self.step_callback = step_callback
        self._last_reported_tool = None  # Track for "new tool" mode
@@ -2422,12 +2420,6 @@ class AIAgent:
            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:
-                self.reasoning_callback(reasoning_text)
-            except Exception:
-                pass
-
        msg = {
            "role": "assistant",
            "content": assistant_message.content or "",
@@ -4478,17 +4470,9 @@ class AIAgent:
        if final_response and not interrupted:
            self._honcho_sync(original_user_message, final_response)

-        # Extract reasoning from the last assistant message (if any)
-        last_reasoning = None
-        for msg in reversed(messages):
-            if msg.get("role") == "assistant" and msg.get("reasoning"):
-                last_reasoning = msg["reasoning"]
-                break
-
        # Build result with interrupt info if applicable
        result = {
            "final_response": final_response,
-            "last_reasoning": last_reasoning,
            "messages": messages,
            "api_calls": api_call_count,
            "completed": completed,
--- a/tests/agent/test_context_compressor.py
+++ b/tests/agent/test_context_compressor.py
@@ -3,7 +3,7 @@
 import pytest
 from unittest.mock import patch, MagicMock

-from agent.context_compressor import ContextCompressor
+from agent.context_compressor import ContextCompressor, SUMMARY_PREFIX


@pytest.fixture()
@@ -141,7 +141,7 @@ class TestGenerateSummaryNoneContent:

        summary = c._generate_summary(messages)
        assert isinstance(summary, str)
-        assert "CONTEXT SUMMARY" in summary
+        assert summary.startswith(SUMMARY_PREFIX)

    def test_none_content_in_system_message_compress(self):
        """System message with content=None should not crash during compress."""
@@ -174,7 +174,7 @@ class TestCompressWithClient:

        # Should have summary message in the middle
        contents = [m.get("content", "") for m in result]
-        assert any("CONTEXT SUMMARY" in c for c in contents)
+        assert any(c.startswith(SUMMARY_PREFIX) for c in contents)
        assert len(result) < len(msgs)

    def test_summarization_does_not_split_tool_call_pairs(self):
@@ -246,7 +246,7 @@ class TestCompressWithClient:
            {"role": "assistant", "content": "msg 5"},
        ]
        result = c.compress(msgs)
-        summary_msg = [m for m in result if "CONTEXT SUMMARY" in (m.get("content") or "")]
+        summary_msg = [m for m in result if (m.get("content") or "").startswith(SUMMARY_PREFIX)]
        assert len(summary_msg) == 1
        assert summary_msg[0]["role"] == "user"

@@ -274,7 +274,7 @@ class TestCompressWithClient:
            {"role": "assistant", "content": "msg 7"},
        ]
        result = c.compress(msgs)
-        summary_msg = [m for m in result if "CONTEXT SUMMARY" in (m.get("content") or "")]
+        summary_msg = [m for m in result if (m.get("content") or "").startswith(SUMMARY_PREFIX)]
        assert len(summary_msg) == 1
        assert summary_msg[0]["role"] == "assistant"

--- a/tests/hermes_cli/test_commands.py
+++ b/tests/hermes_cli/test_commands.py
@@ -11,7 +11,7 @@ EXPECTED_COMMANDS = {
    "/help", "/tools", "/toolsets", "/model", "/provider", "/prompt",
    "/personality", "/clear", "/history", "/new", "/reset", "/retry",
    "/undo", "/save", "/config", "/cron", "/skills", "/platforms",
-    "/verbose", "/reasoning", "/compress", "/title", "/usage", "/insights", "/paste",
+    "/verbose", "/compress", "/title", "/usage", "/insights", "/paste",
    "/reload-mcp", "/rollback", "/background", "/skin", "/quit",
 }

--- a/tests/test_413_compression.py
+++ b/tests/test_413_compression.py
@@ -12,6 +12,7 @@ from unittest.mock import MagicMock, patch

 import pytest

+from agent.context_compressor import SUMMARY_PREFIX
 from run_agent import AIAgent


@@ -335,7 +336,7 @@ class TestPreflightCompression:
            # Simulate compression reducing messages
            mock_compress.return_value = (
                [
-                    {"role": "user", "content": "[CONTEXT SUMMARY]: Previous conversation"},
+                    {"role": "user", "content": f"{SUMMARY_PREFIX}\nPrevious conversation"},
                    {"role": "user", "content": "hello"},
                ],
                "new system prompt",
--- a/tests/test_reasoning_command.py
+++ b/tests/test_reasoning_command.py
@@ -1,422 +0,0 @@
-"""Tests for the combined /reasoning command.
-
-Covers both reasoning effort level management and reasoning display toggle,
-plus the reasoning extraction and display pipeline from run_agent through CLI.
-
-Combines functionality from:
- PR #789 (Aum08Desai): reasoning effort level management
- PR #790 (0xbyt4): reasoning display toggle and rendering
-"""
-
-import unittest
-from types import SimpleNamespace
-from unittest.mock import MagicMock, patch
-
-
-# ---------------------------------------------------------------------------
-# Effort level parsing
-# ---------------------------------------------------------------------------
-
-class TestParseReasoningConfig(unittest.TestCase):
-    """Verify _parse_reasoning_config handles all effort levels."""
-
-    def _parse(self, effort):
-        from cli import _parse_reasoning_config
-        return _parse_reasoning_config(effort)
-
-    def test_none_disables(self):
-        result = self._parse("none")
-        self.assertEqual(result, {"enabled": False})
-
-    def test_valid_levels(self):
-        for level in ("low", "medium", "high", "xhigh", "minimal"):
-            result = self._parse(level)
-            self.assertIsNotNone(result)
-            self.assertTrue(result.get("enabled"))
-            self.assertEqual(result["effort"], level)
-
-    def test_empty_returns_none(self):
-        self.assertIsNone(self._parse(""))
-        self.assertIsNone(self._parse("  "))
-
-    def test_unknown_returns_none(self):
-        self.assertIsNone(self._parse("ultra"))
-        self.assertIsNone(self._parse("turbo"))
-
-    def test_case_insensitive(self):
-        result = self._parse("HIGH")
-        self.assertIsNotNone(result)
-        self.assertEqual(result["effort"], "high")
-
-
-# ---------------------------------------------------------------------------
-# /reasoning command handler (combined effort + display)
-# ---------------------------------------------------------------------------
-
-class TestHandleReasoningCommand(unittest.TestCase):
-    """Test the combined _handle_reasoning_command method."""
-
-    def _make_cli(self, reasoning_config=None, show_reasoning=False):
-        """Create a minimal CLI stub with the reasoning attributes."""
-        stub = SimpleNamespace(
-            reasoning_config=reasoning_config,
-            show_reasoning=show_reasoning,
-            agent=MagicMock(),
-        )
-        return stub
-
-    def test_show_enables_display(self):
-        stub = self._make_cli(show_reasoning=False)
-        # Simulate /reasoning show
-        arg = "show"
-        if arg in ("show", "on"):
-            stub.show_reasoning = True
-            stub.agent.reasoning_callback = lambda x: None
-        self.assertTrue(stub.show_reasoning)
-
-    def test_hide_disables_display(self):
-        stub = self._make_cli(show_reasoning=True)
-        # Simulate /reasoning hide
-        arg = "hide"
-        if arg in ("hide", "off"):
-            stub.show_reasoning = False
-            stub.agent.reasoning_callback = None
-        self.assertFalse(stub.show_reasoning)
-        self.assertIsNone(stub.agent.reasoning_callback)
-
-    def test_on_enables_display(self):
-        stub = self._make_cli(show_reasoning=False)
-        arg = "on"
-        if arg in ("show", "on"):
-            stub.show_reasoning = True
-        self.assertTrue(stub.show_reasoning)
-
-    def test_off_disables_display(self):
-        stub = self._make_cli(show_reasoning=True)
-        arg = "off"
-        if arg in ("hide", "off"):
-            stub.show_reasoning = False
-        self.assertFalse(stub.show_reasoning)
-
-    def test_effort_level_sets_config(self):
-        """Setting an effort level should update reasoning_config."""
-        from cli import _parse_reasoning_config
-        stub = self._make_cli()
-        arg = "high"
-        parsed = _parse_reasoning_config(arg)
-        stub.reasoning_config = parsed
-        self.assertEqual(stub.reasoning_config, {"enabled": True, "effort": "high"})
-
-    def test_effort_none_disables_reasoning(self):
-        from cli import _parse_reasoning_config
-        stub = self._make_cli()
-        parsed = _parse_reasoning_config("none")
-        stub.reasoning_config = parsed
-        self.assertEqual(stub.reasoning_config, {"enabled": False})
-
-    def test_invalid_argument_rejected(self):
-        """Invalid arguments should be rejected (parsed returns None)."""
-        from cli import _parse_reasoning_config
-        parsed = _parse_reasoning_config("turbo")
-        self.assertIsNone(parsed)
-
-    def test_no_args_shows_status(self):
-        """With no args, should show current state (no crash)."""
-        stub = self._make_cli(reasoning_config=None, show_reasoning=False)
-        rc = stub.reasoning_config
-        if rc is None:
-            level = "medium (default)"
-        elif rc.get("enabled") is False:
-            level = "none (disabled)"
-        else:
-            level = rc.get("effort", "medium")
-        display_state = "on" if stub.show_reasoning else "off"
-        self.assertEqual(level, "medium (default)")
-        self.assertEqual(display_state, "off")
-
-    def test_status_with_disabled_reasoning(self):
-        stub = self._make_cli(reasoning_config={"enabled": False}, show_reasoning=True)
-        rc = stub.reasoning_config
-        if rc is None:
-            level = "medium (default)"
-        elif rc.get("enabled") is False:
-            level = "none (disabled)"
-        else:
-            level = rc.get("effort", "medium")
-        self.assertEqual(level, "none (disabled)")
-
-    def test_status_with_explicit_level(self):
-        stub = self._make_cli(
-            reasoning_config={"enabled": True, "effort": "xhigh"},
-            show_reasoning=True,
-        )
-        rc = stub.reasoning_config
-        level = rc.get("effort", "medium")
-        self.assertEqual(level, "xhigh")
-
-
-# ---------------------------------------------------------------------------
-# Reasoning extraction and result dict
-# ---------------------------------------------------------------------------
-
-class TestLastReasoningInResult(unittest.TestCase):
-    """Verify reasoning extraction from the messages list."""
-
-    def _build_messages(self, reasoning=None):
-        return [
-            {"role": "user", "content": "hello"},
-            {
-                "role": "assistant",
-                "content": "Hi there!",
-                "reasoning": reasoning,
-                "finish_reason": "stop",
-            },
-        ]
-
-    def test_reasoning_present(self):
-        messages = self._build_messages(reasoning="Let me think...")
-        last_reasoning = None
-        for msg in reversed(messages):
-            if msg.get("role") == "assistant" and msg.get("reasoning"):
-                last_reasoning = msg["reasoning"]
-                break
-        self.assertEqual(last_reasoning, "Let me think...")
-
-    def test_reasoning_none(self):
-        messages = self._build_messages(reasoning=None)
-        last_reasoning = None
-        for msg in reversed(messages):
-            if msg.get("role") == "assistant" and msg.get("reasoning"):
-                last_reasoning = msg["reasoning"]
-                break
-        self.assertIsNone(last_reasoning)
-
-    def test_picks_last_assistant(self):
-        messages = [
-            {"role": "user", "content": "hello"},
-            {"role": "assistant", "content": "...", "reasoning": "first thought"},
-            {"role": "tool", "content": "result"},
-            {"role": "assistant", "content": "done!", "reasoning": "final thought"},
-        ]
-        last_reasoning = None
-        for msg in reversed(messages):
-            if msg.get("role") == "assistant" and msg.get("reasoning"):
-                last_reasoning = msg["reasoning"]
-                break
-        self.assertEqual(last_reasoning, "final thought")
-
-    def test_empty_reasoning_treated_as_none(self):
-        messages = self._build_messages(reasoning="")
-        last_reasoning = None
-        for msg in reversed(messages):
-            if msg.get("role") == "assistant" and msg.get("reasoning"):
-                last_reasoning = msg["reasoning"]
-                break
-        self.assertIsNone(last_reasoning)
-
-
-# ---------------------------------------------------------------------------
-# Reasoning display collapse
-# ---------------------------------------------------------------------------
-
-class TestReasoningCollapse(unittest.TestCase):
-    """Verify long reasoning is collapsed to 10 lines in the box."""
-
-    def test_short_reasoning_not_collapsed(self):
-        reasoning = "\n".join(f"Line {i}" for i in range(5))
-        lines = reasoning.strip().splitlines()
-        self.assertLessEqual(len(lines), 10)
-
-    def test_long_reasoning_collapsed(self):
-        reasoning = "\n".join(f"Line {i}" for i in range(25))
-        lines = reasoning.strip().splitlines()
-        self.assertTrue(len(lines) > 10)
-        if len(lines) > 10:
-            display = "\n".join(lines[:10])
-            display += f"\n  ... ({len(lines) - 10} more lines)"
-        display_lines = display.splitlines()
-        self.assertEqual(len(display_lines), 11)
-        self.assertIn("15 more lines", display_lines[-1])
-
-    def test_exactly_10_lines_not_collapsed(self):
-        reasoning = "\n".join(f"Line {i}" for i in range(10))
-        lines = reasoning.strip().splitlines()
-        self.assertEqual(len(lines), 10)
-        self.assertFalse(len(lines) > 10)
-
-    def test_intermediate_callback_collapses_to_5(self):
-        """_on_reasoning shows max 5 lines."""
-        reasoning = "\n".join(f"Step {i}" for i in range(12))
-        lines = reasoning.strip().splitlines()
-        if len(lines) > 5:
-            preview = "\n".join(lines[:5])
-            preview += f"\n  ... ({len(lines) - 5} more lines)"
-        else:
-            preview = reasoning.strip()
-        preview_lines = preview.splitlines()
-        self.assertEqual(len(preview_lines), 6)
-        self.assertIn("7 more lines", preview_lines[-1])
-
-
-# ---------------------------------------------------------------------------
-# Reasoning callback
-# ---------------------------------------------------------------------------
-
-class TestReasoningCallback(unittest.TestCase):
-    """Verify reasoning_callback invocation."""
-
-    def test_callback_invoked_with_reasoning(self):
-        captured = []
-        agent = MagicMock()
-        agent.reasoning_callback = lambda t: captured.append(t)
-        agent._extract_reasoning = MagicMock(return_value="deep thought")
-
-        reasoning_text = agent._extract_reasoning(MagicMock())
-        if reasoning_text and agent.reasoning_callback:
-            agent.reasoning_callback(reasoning_text)
-        self.assertEqual(captured, ["deep thought"])
-
-    def test_callback_not_invoked_without_reasoning(self):
-        captured = []
-        agent = MagicMock()
-        agent.reasoning_callback = lambda t: captured.append(t)
-        agent._extract_reasoning = MagicMock(return_value=None)
-
-        reasoning_text = agent._extract_reasoning(MagicMock())
-        if reasoning_text and agent.reasoning_callback:
-            agent.reasoning_callback(reasoning_text)
-        self.assertEqual(captured, [])
-
-    def test_callback_none_does_not_crash(self):
-        reasoning_text = "some thought"
-        callback = None
-        if reasoning_text and callback:
-            callback(reasoning_text)
-        # No exception = pass
-
-
-# ---------------------------------------------------------------------------
-# Real provider format extraction
-# ---------------------------------------------------------------------------
-
-class TestExtractReasoningFormats(unittest.TestCase):
-    """Test _extract_reasoning with real provider response formats."""
-
-    def _get_extractor(self):
-        from run_agent import AIAgent
-        return AIAgent._extract_reasoning
-
-    def test_openrouter_reasoning_details(self):
-        extract = self._get_extractor()
-        msg = SimpleNamespace(
-            reasoning=None,
-            reasoning_content=None,
-            reasoning_details=[
-                {"type": "reasoning.summary", "summary": "Analyzing Python lists."},
-            ],
-        )
-        result = extract(None, msg)
-        self.assertIn("Python lists", result)
-
-    def test_deepseek_reasoning_field(self):
-        extract = self._get_extractor()
-        msg = SimpleNamespace(
-            reasoning="Solving step by step.\nx + y = 8.",
-            reasoning_content=None,
-        )
-        result = extract(None, msg)
-        self.assertIn("x + y = 8", result)
-
-    def test_moonshot_reasoning_content(self):
-        extract = self._get_extractor()
-        msg = SimpleNamespace(
-            reasoning_content="Explaining async/await.",
-        )
-        result = extract(None, msg)
-        self.assertIn("async/await", result)
-
-    def test_no_reasoning_returns_none(self):
-        extract = self._get_extractor()
-        msg = SimpleNamespace(content="Hello!")
-        result = extract(None, msg)
-        self.assertIsNone(result)
-
-
-# ---------------------------------------------------------------------------
-# Config defaults
-# ---------------------------------------------------------------------------
-
-class TestConfigDefault(unittest.TestCase):
-    """Verify config default for show_reasoning."""
-
-    def test_default_config_has_show_reasoning(self):
-        from hermes_cli.config import DEFAULT_CONFIG
-        display = DEFAULT_CONFIG.get("display", {})
-        self.assertIn("show_reasoning", display)
-        self.assertFalse(display["show_reasoning"])
-
-
-class TestCommandRegistered(unittest.TestCase):
-    """Verify /reasoning is in the COMMANDS dict."""
-
-    def test_reasoning_in_commands(self):
-        from hermes_cli.commands import COMMANDS
-        self.assertIn("/reasoning", COMMANDS)
-
-
-# ---------------------------------------------------------------------------
-# End-to-end pipeline
-# ---------------------------------------------------------------------------
-
-class TestEndToEndPipeline(unittest.TestCase):
-    """Simulate the full pipeline: extraction -> result dict -> display."""
-
-    def test_openrouter_claude_pipeline(self):
-        from run_agent import AIAgent
-
-        api_message = SimpleNamespace(
-            role="assistant",
-            content="Lists support append().",
-            tool_calls=None,
-            reasoning=None,
-            reasoning_content=None,
-            reasoning_details=[
-                {"type": "reasoning.summary", "summary": "Python list methods."},
-            ],
-        )
-
-        reasoning = AIAgent._extract_reasoning(None, api_message)
-        self.assertIsNotNone(reasoning)
-
-        messages = [
-            {"role": "user", "content": "How do I add items?"},
-            {"role": "assistant", "content": api_message.content, "reasoning": reasoning},
-        ]
-
-        last_reasoning = None
-        for msg in reversed(messages):
-            if msg.get("role") == "assistant" and msg.get("reasoning"):
-                last_reasoning = msg["reasoning"]
-                break
-
-        result = {
-            "final_response": api_message.content,
-            "last_reasoning": last_reasoning,
-        }
-
-        self.assertIn("last_reasoning", result)
-        self.assertIn("Python list methods", result["last_reasoning"])
-
-    def test_no_reasoning_model_pipeline(self):
-        from run_agent import AIAgent
-
-        api_message = SimpleNamespace(content="Paris.", tool_calls=None)
-        reasoning = AIAgent._extract_reasoning(None, api_message)
-        self.assertIsNone(reasoning)
-
-        result = {"final_response": api_message.content, "last_reasoning": reasoning}
-        self.assertIsNone(result["last_reasoning"])
-
-
-if __name__ == "__main__":
-    unittest.main()
--- a/website/docs/reference/cli-commands.md
+++ b/website/docs/reference/cli-commands.md
@@ -147,7 +147,6 @@ Type `/` in the interactive CLI to see an autocomplete dropdown.
 | `/config` | Show current configuration |
 | `/prompt [text]` | View/set custom system prompt |
 | `/personality [name]` | Set a predefined personality |
-| `/reasoning [arg]` | Manage reasoning effort and display. Args: effort level (`none`, `low`, `medium`, `high`, `xhigh`) or display toggle (`show`, `hide`). No args shows current state. |

 ### Conversation

--- a/website/docs/user-guide/cli.md
+++ b/website/docs/user-guide/cli.md
@@ -104,7 +104,6 @@ Type `/` to see an autocomplete dropdown of all available commands.
 | `/config` | Show current configuration |
 | `/prompt [text]` | View/set/clear custom system prompt |
 | `/personality [name]` | Set a predefined personality |
-| `/reasoning [arg]` | Manage reasoning effort (`none`/`low`/`medium`/`high`/`xhigh`) and display (`show`/`hide`) |

 ### Conversation Management

--- a/website/docs/user-guide/configuration.md
+++ b/website/docs/user-guide/configuration.md
@@ -608,16 +608,6 @@ agent:

 When unset (default), reasoning effort defaults to "medium" — a balanced level that works well for most tasks. Setting a value overrides it — higher reasoning effort gives better results on complex tasks at the cost of more tokens and latency.

-You can also change the reasoning effort at runtime with the `/reasoning` command:
-
-```
-/reasoning           # Show current effort level and display state
-/reasoning high      # Set reasoning effort to high
-/reasoning none      # Disable reasoning
-/reasoning show      # Show model thinking above each response
-/reasoning hide      # Hide model thinking
-```
-
 ## TTS Configuration

 ```yaml
@@ -642,7 +632,6 @@ display:
  compact: false         # Compact output mode (less whitespace)
  resume_display: full   # full (show previous messages on resume) | minimal (one-liner only)
  bell_on_complete: false  # Play terminal bell when agent finishes (great for long tasks)
-  show_reasoning: false    # Show model reasoning/thinking above each response (toggle with /reasoning show|hide)
 ```

 | Mode | What you see |