refactor: deduplicate PowerShell script constants between Windows and WSL paths

Move _PS_CHECK_IMAGE and _PS_EXTRACT_IMAGE above both the native Windows and WSL2 sections so both can share them. Removes the duplicate _WIN_PS_CHECK / _WIN_PS_EXTRACT constants.
feat(clipboard): add native Windows image paste support
2026-04-07 12:22:59 -07:00 · 2026-04-07 12:21:36 -07:00
143 changed files with 355 additions and 795 deletions
@@ -19,9 +19,6 @@ jobs:
      - name: Checkout code
        uses: actions/checkout@v4

-      - name: Install system dependencies
-        run: sudo apt-get update && sudo apt-get install -y ripgrep
-
      - name: Install uv
        uses: astral-sh/setup-uv@v5

@@ -16,7 +16,6 @@ import logging
 from typing import Any, Dict, List

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -93,7 +92,7 @@ class BuiltinMemoryProvider(MemoryProvider):

    def handle_tool_call(self, tool_name: str, args: Dict[str, Any], **kwargs) -> str:
        """Not used — the memory tool is intercepted in run_agent.py."""
-        return tool_error("Built-in memory tool is handled by the agent loop")
+        return json.dumps({"error": "Built-in memory tool is handled by the agent loop"})

    def shutdown(self) -> None:
        """No cleanup needed — files are saved on every write."""
@@ -34,7 +34,6 @@ import re
 from typing import Any, Dict, List, Optional

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -250,7 +249,7 @@ class MemoryManager:
        """
        provider = self._tool_to_provider.get(tool_name)
        if provider is None:
-            return tool_error(f"No memory provider handles tool '{tool_name}'")
+            return json.dumps({"error": f"No memory provider handles tool '{tool_name}'"})
        try:
            return provider.handle_tool_call(tool_name, args, **kwargs)
        except Exception as e:
@@ -258,7 +257,7 @@ class MemoryManager:
                "Memory provider '%s' handle_tool_call(%s) failed: %s",
                provider.name, tool_name, e,
            )
-            return tool_error(f"Memory tool '{tool_name}' failed: {e}")
+            return json.dumps({"error": f"Memory tool '{tool_name}' failed: {e}"})

    # -- Lifecycle hooks -----------------------------------------------------

@@ -158,44 +158,6 @@ def _resolve_delivery_target(job: dict) -> Optional[dict]:
    }


-# Media extension sets — keep in sync with gateway/platforms/base.py:_process_message_background
-_AUDIO_EXTS = frozenset({'.ogg', '.opus', '.mp3', '.wav', '.m4a'})
-_VIDEO_EXTS = frozenset({'.mp4', '.mov', '.avi', '.mkv', '.webm', '.3gp'})
-_IMAGE_EXTS = frozenset({'.jpg', '.jpeg', '.png', '.webp', '.gif'})
-
-
-def _send_media_via_adapter(adapter, chat_id: str, media_files: list, metadata: dict | None, loop, job: dict) -> None:
-    """Send extracted MEDIA files as native platform attachments via a live adapter.
-
-    Routes each file to the appropriate adapter method (send_voice, send_image_file,
-    send_video, send_document) based on file extension — mirroring the routing logic
-    in ``BasePlatformAdapter._process_message_background``.
-    """
-    from pathlib import Path
-
-    for media_path, _is_voice in media_files:
-        try:
-            ext = Path(media_path).suffix.lower()
-            if ext in _AUDIO_EXTS:
-                coro = adapter.send_voice(chat_id=chat_id, audio_path=media_path, metadata=metadata)
-            elif ext in _VIDEO_EXTS:
-                coro = adapter.send_video(chat_id=chat_id, video_path=media_path, metadata=metadata)
-            elif ext in _IMAGE_EXTS:
-                coro = adapter.send_image_file(chat_id=chat_id, image_path=media_path, metadata=metadata)
-            else:
-                coro = adapter.send_document(chat_id=chat_id, file_path=media_path, metadata=metadata)
-
-            future = asyncio.run_coroutine_threadsafe(coro, loop)
-            result = future.result(timeout=30)
-            if result and not getattr(result, "success", True):
-                logger.warning(
-                    "Job '%s': media send failed for %s: %s",
-                    job.get("id", "?"), media_path, getattr(result, "error", "unknown"),
-                )
-        except Exception as e:
-            logger.warning("Job '%s': failed to send media %s: %s", job.get("id", "?"), media_path, e)
-
-
 def _deliver_result(job: dict, content: str, adapters=None, loop=None) -> None:
    """
    Deliver job output to the configured target (origin chat, specific platform, etc.).
@@ -284,28 +246,18 @@ def _deliver_result(job: dict, content: str, adapters=None, loop=None) -> None:
    if runtime_adapter is not None and loop is not None and getattr(loop, "is_running", lambda: False)():
        send_metadata = {"thread_id": thread_id} if thread_id else None
        try:
-            # Send cleaned text (MEDIA tags stripped) — not the raw content
-            text_to_send = cleaned_delivery_content.strip()
-            adapter_ok = True
-            if text_to_send:
-                future = asyncio.run_coroutine_threadsafe(
-                    runtime_adapter.send(chat_id, text_to_send, metadata=send_metadata),
-                    loop,
+            future = asyncio.run_coroutine_threadsafe(
+                runtime_adapter.send(chat_id, delivery_content, metadata=send_metadata),
+                loop,
+            )
+            send_result = future.result(timeout=60)
+            if send_result and not getattr(send_result, "success", True):
+                err = getattr(send_result, "error", "unknown")
+                logger.warning(
+                    "Job '%s': live adapter send to %s:%s failed (%s), falling back to standalone",
+                    job["id"], platform_name, chat_id, err,
                )
-                send_result = future.result(timeout=60)
-                if send_result and not getattr(send_result, "success", True):
-                    err = getattr(send_result, "error", "unknown")
-                    logger.warning(
-                        "Job '%s': live adapter send to %s:%s failed (%s), falling back to standalone",
-                        job["id"], platform_name, chat_id, err,
-                    )
-                    adapter_ok = False  # fall through to standalone path
-
-            # Send extracted media files as native attachments via the live adapter
-            if adapter_ok and media_files:
-                _send_media_via_adapter(runtime_adapter, chat_id, media_files, send_metadata, loop, job)
-
-            if adapter_ok:
+            else:
                logger.info("Job '%s': delivered to %s:%s via live adapter", job["id"], platform_name, chat_id)
                return
        except Exception as e:
@@ -1881,24 +1881,6 @@ def _normalize_max_turns_config(config: Dict[str, Any]) -> Dict[str, Any]:



-def read_raw_config() -> Dict[str, Any]:
-    """Read ~/.hermes/config.yaml as-is, without merging defaults or migrating.
-
-    Returns the raw YAML dict, or ``{}`` if the file doesn't exist or can't
-    be parsed.  Use this for lightweight config reads where you just need a
-    single value and don't want the overhead of ``load_config()``'s deep-merge
-    + migration pipeline.
-    """
-    try:
-        config_path = get_config_path()
-        if config_path.exists():
-            with open(config_path, encoding="utf-8") as f:
-                return yaml.safe_load(f) or {}
-    except Exception:
-        pass
-    return {}
-
-
 def load_config() -> Dict[str, Any]:
    """Load configuration from ~/.hermes/config.yaml."""
    import copy
@@ -27,7 +27,6 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -321,7 +320,7 @@ class ByteRoverMemoryProvider(MemoryProvider):
            return self._tool_curate(args)
        elif tool_name == "brv_status":
            return self._tool_status()
-        return tool_error(f"Unknown tool: {tool_name}")
+        return json.dumps({"error": f"Unknown tool: {tool_name}"})

    def shutdown(self) -> None:
        if self._sync_thread and self._sync_thread.is_alive():
@@ -332,7 +331,7 @@ class ByteRoverMemoryProvider(MemoryProvider):
    def _tool_query(self, args: dict) -> str:
        query = args.get("query", "")
        if not query:
-            return tool_error("query is required")
+            return json.dumps({"error": "query is required"})

        result = _run_brv(
            ["query", "--", query.strip()[:5000]],
@@ -340,7 +339,7 @@ class ByteRoverMemoryProvider(MemoryProvider):
        )

        if not result["success"]:
-            return tool_error(result.get("error", "Query failed"))
+            return json.dumps({"error": result.get("error", "Query failed")})

        output = result.get("output", "").strip()
        if not output or len(output) < _MIN_OUTPUT_LEN:
@@ -355,7 +354,7 @@ class ByteRoverMemoryProvider(MemoryProvider):
    def _tool_curate(self, args: dict) -> str:
        content = args.get("content", "")
        if not content:
-            return tool_error("content is required")
+            return json.dumps({"error": "content is required"})

        result = _run_brv(
            ["curate", "--", content],
@@ -363,14 +362,14 @@ class ByteRoverMemoryProvider(MemoryProvider):
        )

        if not result["success"]:
-            return tool_error(result.get("error", "Curate failed"))
+            return json.dumps({"error": result.get("error", "Curate failed")})

        return json.dumps({"result": "Memory curated successfully."})

    def _tool_status(self) -> str:
        result = _run_brv(["status"], timeout=15, cwd=self._cwd)
        if not result["success"]:
-            return tool_error(result.get("error", "Status check failed"))
+            return json.dumps({"error": result.get("error", "Status check failed")})
        return json.dumps({"status": result.get("output", "")})


@@ -26,7 +26,6 @@ import threading
 from typing import Any, Dict, List

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -434,12 +433,12 @@ class HindsightMemoryProvider(MemoryProvider):
            client = self._get_client()
        except Exception as e:
            logger.warning("Hindsight client init failed: %s", e)
-            return tool_error(f"Hindsight client unavailable: {e}")
+            return json.dumps({"error": f"Hindsight client unavailable: {e}"})

        if tool_name == "hindsight_retain":
            content = args.get("content", "")
            if not content:
-                return tool_error("Missing required parameter: content")
+                return json.dumps({"error": "Missing required parameter: content"})
            context = args.get("context")
            try:
                _run_sync(client.aretain(
@@ -448,12 +447,12 @@ class HindsightMemoryProvider(MemoryProvider):
                return json.dumps({"result": "Memory stored successfully."})
            except Exception as e:
                logger.warning("hindsight_retain failed: %s", e)
-                return tool_error(f"Failed to store memory: {e}")
+                return json.dumps({"error": f"Failed to store memory: {e}"})

        elif tool_name == "hindsight_recall":
            query = args.get("query", "")
            if not query:
-                return tool_error("Missing required parameter: query")
+                return json.dumps({"error": "Missing required parameter: query"})
            try:
                resp = _run_sync(client.arecall(
                    bank_id=self._bank_id, query=query, budget=self._budget
@@ -464,12 +463,12 @@ class HindsightMemoryProvider(MemoryProvider):
                return json.dumps({"result": "\n".join(lines)})
            except Exception as e:
                logger.warning("hindsight_recall failed: %s", e)
-                return tool_error(f"Failed to search memory: {e}")
+                return json.dumps({"error": f"Failed to search memory: {e}"})

        elif tool_name == "hindsight_reflect":
            query = args.get("query", "")
            if not query:
-                return tool_error("Missing required parameter: query")
+                return json.dumps({"error": "Missing required parameter: query"})
            try:
                resp = _run_sync(client.areflect(
                    bank_id=self._bank_id, query=query, budget=self._budget
@@ -477,9 +476,9 @@ class HindsightMemoryProvider(MemoryProvider):
                return json.dumps({"result": resp.text or "No relevant memories found."})
            except Exception as e:
                logger.warning("hindsight_reflect failed: %s", e)
-                return tool_error(f"Failed to reflect: {e}")
+                return json.dumps({"error": f"Failed to reflect: {e}"})

-        return tool_error(f"Unknown tool: {tool_name}")
+        return json.dumps({"error": f"Unknown tool: {tool_name}"})

    def shutdown(self) -> None:
        global _loop, _loop_thread
@@ -23,7 +23,6 @@ import re
 from typing import Any, Dict, List

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error
 from .store import MemoryStore
 from .retrieval import FactRetriever

@@ -231,7 +230,7 @@ class HolographicMemoryProvider(MemoryProvider):
            return self._handle_fact_store(args)
        elif tool_name == "fact_feedback":
            return self._handle_fact_feedback(args)
-        return tool_error(f"Unknown tool: {tool_name}")
+        return json.dumps({"error": f"Unknown tool: {tool_name}"})

    def on_session_end(self, messages: List[Dict[str, Any]]) -> None:
        if not self._config.get("auto_extract", False):
@@ -297,7 +296,7 @@ class HolographicMemoryProvider(MemoryProvider):
            elif action == "reason":
                entities = args.get("entities", [])
                if not entities:
-                    return tool_error("reason requires 'entities' list")
+                    return json.dumps({"error": "reason requires 'entities' list"})
                results = retriever.reason(
                    entities,
                    category=args.get("category"),
@@ -335,12 +334,12 @@ class HolographicMemoryProvider(MemoryProvider):
                return json.dumps({"facts": facts, "count": len(facts)})

            else:
-                return tool_error(f"Unknown action: {action}")
+                return json.dumps({"error": f"Unknown action: {action}"})

        except KeyError as exc:
-            return tool_error(f"Missing required argument: {exc}")
+            return json.dumps({"error": f"Missing required argument: {exc}"})
        except Exception as exc:
-            return tool_error(str(exc))
+            return json.dumps({"error": str(exc)})

    def _handle_fact_feedback(self, args: dict) -> str:
        try:
@@ -349,9 +348,9 @@ class HolographicMemoryProvider(MemoryProvider):
            result = self._store.record_feedback(fact_id, helpful=helpful)
            return json.dumps(result)
        except KeyError as exc:
-            return tool_error(f"Missing required argument: {exc}")
+            return json.dumps({"error": f"Missing required argument: {exc}"})
        except Exception as exc:
-            return tool_error(str(exc))
+            return json.dumps({"error": str(exc)})

    # -- Auto-extraction (on_session_end) ------------------------------------

@@ -21,7 +21,6 @@ import threading
 from typing import Any, Dict, List, Optional

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -639,15 +638,15 @@ class HonchoMemoryProvider(MemoryProvider):
    def handle_tool_call(self, tool_name: str, args: dict, **kwargs) -> str:
        """Handle a Honcho tool call, with lazy session init for tools-only mode."""
        if self._cron_skipped:
-            return tool_error("Honcho is not active (cron context).")
+            return json.dumps({"error": "Honcho is not active (cron context)."})

        # Port #1957: ensure session is initialized for tools-only mode
        if not self._session_initialized:
            if not self._ensure_session():
-                return tool_error("Honcho session could not be initialized.")
+                return json.dumps({"error": "Honcho session could not be initialized."})

        if not self._manager or not self._session_key:
-            return tool_error("Honcho is not active for this session.")
+            return json.dumps({"error": "Honcho is not active for this session."})

        try:
            if tool_name == "honcho_profile":
@@ -659,7 +658,7 @@ class HonchoMemoryProvider(MemoryProvider):
            elif tool_name == "honcho_search":
                query = args.get("query", "")
                if not query:
-                    return tool_error("Missing required parameter: query")
+                    return json.dumps({"error": "Missing required parameter: query"})
                max_tokens = min(int(args.get("max_tokens", 800)), 2000)
                result = self._manager.search_context(
                    self._session_key, query, max_tokens=max_tokens
@@ -671,7 +670,7 @@ class HonchoMemoryProvider(MemoryProvider):
            elif tool_name == "honcho_context":
                query = args.get("query", "")
                if not query:
-                    return tool_error("Missing required parameter: query")
+                    return json.dumps({"error": "Missing required parameter: query"})
                peer = args.get("peer", "user")
                result = self._manager.dialectic_query(
                    self._session_key, query, peer=peer
@@ -681,17 +680,17 @@ class HonchoMemoryProvider(MemoryProvider):
            elif tool_name == "honcho_conclude":
                conclusion = args.get("conclusion", "")
                if not conclusion:
-                    return tool_error("Missing required parameter: conclusion")
+                    return json.dumps({"error": "Missing required parameter: conclusion"})
                ok = self._manager.create_conclusion(self._session_key, conclusion)
                if ok:
                    return json.dumps({"result": f"Conclusion saved: {conclusion}"})
-                return tool_error("Failed to save conclusion.")
+                return json.dumps({"error": "Failed to save conclusion."})

-            return tool_error(f"Unknown tool: {tool_name}")
+            return json.dumps({"error": f"Unknown tool: {tool_name}"})

        except Exception as e:
            logger.error("Honcho tool %s failed: %s", tool_name, e)
-            return tool_error(f"Honcho {tool_name} failed: {e}")
+            return json.dumps({"error": f"Honcho {tool_name} failed: {e}"})

    def shutdown(self) -> None:
        for t in (self._prefetch_thread, self._sync_thread):
@@ -23,7 +23,6 @@ import time
 from typing import Any, Dict, List

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -306,7 +305,7 @@ class Mem0MemoryProvider(MemoryProvider):
        try:
            client = self._get_client()
        except Exception as e:
-            return tool_error(str(e))
+            return json.dumps({"error": str(e)})

        if tool_name == "mem0_profile":
            try:
@@ -318,12 +317,12 @@ class Mem0MemoryProvider(MemoryProvider):
                return json.dumps({"result": "\n".join(lines), "count": len(lines)})
            except Exception as e:
                self._record_failure()
-                return tool_error(f"Failed to fetch profile: {e}")
+                return json.dumps({"error": f"Failed to fetch profile: {e}"})

        elif tool_name == "mem0_search":
            query = args.get("query", "")
            if not query:
-                return tool_error("Missing required parameter: query")
+                return json.dumps({"error": "Missing required parameter: query"})
            rerank = args.get("rerank", False)
            top_k = min(int(args.get("top_k", 10)), 50)
            try:
@@ -340,12 +339,12 @@ class Mem0MemoryProvider(MemoryProvider):
                return json.dumps({"results": items, "count": len(items)})
            except Exception as e:
                self._record_failure()
-                return tool_error(f"Search failed: {e}")
+                return json.dumps({"error": f"Search failed: {e}"})

        elif tool_name == "mem0_conclude":
            conclusion = args.get("conclusion", "")
            if not conclusion:
-                return tool_error("Missing required parameter: conclusion")
+                return json.dumps({"error": "Missing required parameter: conclusion"})
            try:
                client.add(
                    [{"role": "user", "content": conclusion}],
@@ -356,9 +355,9 @@ class Mem0MemoryProvider(MemoryProvider):
                return json.dumps({"result": "Fact stored."})
            except Exception as e:
                self._record_failure()
-                return tool_error(f"Failed to store: {e}")
+                return json.dumps({"error": f"Failed to store: {e}"})

-        return tool_error(f"Unknown tool: {tool_name}")
+        return json.dumps({"error": f"Unknown tool: {tool_name}"})

    def shutdown(self) -> None:
        for t in (self._prefetch_thread, self._sync_thread):
@@ -31,7 +31,6 @@ import threading
 from typing import Any, Dict, List, Optional

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -462,7 +461,7 @@ class OpenVikingMemoryProvider(MemoryProvider):

    def handle_tool_call(self, tool_name: str, args: dict, **kwargs) -> str:
        if not self._client:
-            return tool_error("OpenViking server not connected")
+            return json.dumps({"error": "OpenViking server not connected"})

        try:
            if tool_name == "viking_search":
@@ -475,9 +474,9 @@ class OpenVikingMemoryProvider(MemoryProvider):
                return self._tool_remember(args)
            elif tool_name == "viking_add_resource":
                return self._tool_add_resource(args)
-            return tool_error(f"Unknown tool: {tool_name}")
+            return json.dumps({"error": f"Unknown tool: {tool_name}"})
        except Exception as e:
-            return tool_error(str(e))
+            return json.dumps({"error": str(e)})

    def shutdown(self) -> None:
        # Wait for background threads to finish
@@ -494,7 +493,7 @@ class OpenVikingMemoryProvider(MemoryProvider):
    def _tool_search(self, args: dict) -> str:
        query = args.get("query", "")
        if not query:
-            return tool_error("query is required")
+            return json.dumps({"error": "query is required"})

        payload: Dict[str, Any] = {"query": query}
        mode = args.get("mode", "auto")
@@ -531,7 +530,7 @@ class OpenVikingMemoryProvider(MemoryProvider):
    def _tool_read(self, args: dict) -> str:
        uri = args.get("uri", "")
        if not uri:
-            return tool_error("uri is required")
+            return json.dumps({"error": "uri is required"})

        level = args.get("level", "overview")
        # Map our level names to OpenViking GET endpoints
@@ -583,7 +582,7 @@ class OpenVikingMemoryProvider(MemoryProvider):
    def _tool_remember(self, args: dict) -> str:
        content = args.get("content", "")
        if not content:
-            return tool_error("content is required")
+            return json.dumps({"error": "content is required"})

        # Store as a session message that will be extracted during commit.
        # The category hint helps OpenViking's extraction classify correctly.
@@ -607,7 +606,7 @@ class OpenVikingMemoryProvider(MemoryProvider):
    def _tool_add_resource(self, args: dict) -> str:
        url = args.get("url", "")
        if not url:
-            return tool_error("url is required")
+            return json.dumps({"error": "url is required"})

        payload: Dict[str, Any] = {"path": url}
        if args.get("reason"):
@@ -34,7 +34,6 @@ from typing import Any, Dict, List
 from urllib.parse import quote

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -650,11 +649,11 @@ class RetainDBMemoryProvider(MemoryProvider):

    def handle_tool_call(self, tool_name: str, args: dict, **kwargs) -> str:
        if not self._client:
-            return tool_error("RetainDB not initialized")
+            return json.dumps({"error": "RetainDB not initialized"})
        try:
            return json.dumps(self._dispatch(tool_name, args))
        except Exception as exc:
-            return tool_error(str(exc))
+            return json.dumps({"error": str(exc)})

    def _dispatch(self, tool_name: str, args: dict) -> Any:
        c = self._client
@@ -18,7 +18,6 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional

 from agent.memory_provider import MemoryProvider
-from tools.registry import tool_error

 logger = logging.getLogger(__name__)

@@ -588,7 +587,7 @@ class SupermemoryMemoryProvider(MemoryProvider):
    def _tool_store(self, args: dict) -> str:
        content = str(args.get("content") or "").strip()
        if not content:
-            return tool_error("content is required")
+            return json.dumps({"error": "content is required"})
        metadata = args.get("metadata") or {}
        if not isinstance(metadata, dict):
            metadata = {}
@@ -599,12 +598,12 @@ class SupermemoryMemoryProvider(MemoryProvider):
            preview = content[:80] + ("..." if len(content) > 80 else "")
            return json.dumps({"saved": True, "id": result.get("id", ""), "preview": preview})
        except Exception as exc:
-            return tool_error(f"Failed to store memory: {exc}")
+            return json.dumps({"error": f"Failed to store memory: {exc}"})

    def _tool_search(self, args: dict) -> str:
        query = str(args.get("query") or "").strip()
        if not query:
-            return tool_error("query is required")
+            return json.dumps({"error": "query is required"})
        try:
            limit = max(1, min(20, int(args.get("limit", 5) or 5)))
        except Exception:
@@ -622,20 +621,20 @@ class SupermemoryMemoryProvider(MemoryProvider):
                formatted.append(entry)
            return json.dumps({"results": formatted, "count": len(formatted)})
        except Exception as exc:
-            return tool_error(f"Search failed: {exc}")
+            return json.dumps({"error": f"Search failed: {exc}"})

    def _tool_forget(self, args: dict) -> str:
        memory_id = str(args.get("id") or "").strip()
        query = str(args.get("query") or "").strip()
        if not memory_id and not query:
-            return tool_error("Provide either id or query")
+            return json.dumps({"error": "Provide either id or query"})
        try:
            if memory_id:
                self._client.forget_memory(memory_id)
                return json.dumps({"forgotten": True, "id": memory_id})
            return json.dumps(self._client.forget_by_query(query))
        except Exception as exc:
-            return tool_error(f"Forget failed: {exc}")
+            return json.dumps({"error": f"Forget failed: {exc}"})

    def _tool_profile(self, args: dict) -> str:
        query = str(args.get("query") or "").strip() or None
@@ -652,11 +651,11 @@ class SupermemoryMemoryProvider(MemoryProvider):
                "dynamic_count": len(profile["dynamic"]),
            })
        except Exception as exc:
-            return tool_error(f"Profile failed: {exc}")
+            return json.dumps({"error": f"Profile failed: {exc}"})

    def handle_tool_call(self, tool_name: str, args: Dict[str, Any], **kwargs) -> str:
        if not self._active or not self._client:
-            return tool_error("Supermemory is not configured")
+            return json.dumps({"error": "Supermemory is not configured"})
        if tool_name == "supermemory_store":
            return self._tool_store(args)
        if tool_name == "supermemory_search":
@@ -665,7 +664,7 @@ class SupermemoryMemoryProvider(MemoryProvider):
            return self._tool_forget(args)
        if tool_name == "supermemory_profile":
            return self._tool_profile(args)
-        return tool_error(f"Unknown tool: {tool_name}")
+        return json.dumps({"error": f"Unknown tool: {tool_name}"})


 def register(ctx):
@@ -5741,7 +5741,6 @@ class AIAgent:
                api_msg.pop("reasoning", None)
                api_msg.pop("finish_reason", None)
                api_msg.pop("_flush_sentinel", None)
-                api_msg.pop("_thinking_prefill", None)
                if _needs_sanitize:
                    self._sanitize_tool_calls_for_strict_api(api_msg)
                api_messages.append(api_msg)
@@ -6665,7 +6664,7 @@ class AIAgent:
            api_messages = []
            for msg in messages:
                api_msg = msg.copy()
-                for internal_field in ("reasoning", "finish_reason", "_thinking_prefill"):
+                for internal_field in ("reasoning", "finish_reason"):
                    api_msg.pop(internal_field, None)
                if _needs_sanitize:
                    self._sanitize_tool_calls_for_strict_api(api_msg)
@@ -6857,7 +6856,6 @@ class AIAgent:
        self._empty_content_retries = 0
        self._incomplete_scratchpad_retries = 0
        self._codex_incomplete_retries = 0
-        self._thinking_prefill_retries = 0
        self._last_content_with_tools = None
        self._mute_post_response = False
        self._surrogate_sanitized = False
@@ -7203,8 +7201,6 @@ class AIAgent:
                # Remove finish_reason - not accepted by strict APIs (e.g. Mistral)
                if "finish_reason" in api_msg:
                    api_msg.pop("finish_reason")
-                # Strip internal thinking-prefill marker
-                api_msg.pop("_thinking_prefill", None)
                # Strip Codex Responses API fields (call_id, response_item_id) for
                # strict providers like Mistral, Fireworks, etc. that reject unknown fields.
                # Uses new dicts so the internal messages list retains the fields
@@ -8739,15 +8735,6 @@ class AIAgent:
                            if clean:
                                self._vprint(f"  ┊ 💬 {clean}")
                    
-                    # Pop thinking-only prefill message(s) before appending
-                    # (tool-call path — same rationale as the final-response path).
-                    while (
-                        messages
-                        and isinstance(messages[-1], dict)
-                        and messages[-1].get("_thinking_prefill")
-                    ):
-                        messages.pop()
-
                    messages.append(assistant_msg)

                    # Close any open streaming display (response box, reasoning
@@ -8861,36 +8848,11 @@ class AIAgent:
                            self._response_was_previewed = True
                            break

-                        # ── Thinking-only prefill continuation ──────────
-                        # The model produced structured reasoning (via API
-                        # fields) but no visible text content.  Rather than
-                        # giving up, append the assistant message as-is and
-                        # continue — the model will see its own reasoning
-                        # on the next turn and produce the text portion.
-                        # Inspired by clawdbot's "incomplete-text" recovery.
-                        _has_structured = bool(
-                            getattr(assistant_message, "reasoning", None)
-                            or getattr(assistant_message, "reasoning_content", None)
-                            or getattr(assistant_message, "reasoning_details", None)
-                        )
-                        if _has_structured and self._thinking_prefill_retries < 2:
-                            self._thinking_prefill_retries += 1
-                            self._vprint(
-                                f"{self.log_prefix}↻ Thinking-only response — "
-                                f"prefilling to continue "
-                                f"({self._thinking_prefill_retries}/2)"
-                            )
-                            interim_msg = self._build_assistant_message(
-                                assistant_message, "incomplete"
-                            )
-                            interim_msg["_thinking_prefill"] = True
-                            messages.append(interim_msg)
-                            self._session_messages = messages
-                            self._save_session_log(messages)
-                            continue
-
-                        # Exhausted prefill attempts or no structured
-                        # reasoning — fall through to "(empty)" terminal.
+                        # Reasoning-only response: the model produced thinking
+                        # but no visible content.  This is a valid response —
+                        # keep reasoning in its own field and set content to
+                        # "(empty)" so every provider accepts the message.
+                        # No retries needed.
                        reasoning_text = self._extract_reasoning(assistant_message)
                        assistant_msg = self._build_assistant_message(assistant_message, finish_reason)
                        assistant_msg["content"] = "(empty)"
@@ -8909,7 +8871,6 @@ class AIAgent:
                    if hasattr(self, '_empty_content_retries'):
                        self._empty_content_retries = 0
                    self._last_empty_content_signature = None
-                    self._thinking_prefill_retries = 0

                    if (
                        self.api_mode == "codex_responses"
@@ -8948,18 +8909,7 @@ class AIAgent:
                    final_response = self._strip_think_blocks(final_response).strip()
                    
                    final_msg = self._build_assistant_message(assistant_message, finish_reason)
-
-                    # Pop thinking-only prefill message(s) before appending
-                    # the final response.  This avoids consecutive assistant
-                    # messages which break strict-alternation providers
-                    # (Anthropic Messages API) and keeps history clean.
-                    while (
-                        messages
-                        and isinstance(messages[-1], dict)
-                        and messages[-1].get("_thinking_prefill")
-                    ):
-                        messages.pop()
-
+                    
                    messages.append(final_msg)
                    
                    if not self.quiet_mode:
@@ -7,7 +7,7 @@ from unittest.mock import AsyncMock, patch, MagicMock

 import pytest

-from cron.scheduler import _resolve_origin, _resolve_delivery_target, _deliver_result, _send_media_via_adapter, run_job, SILENT_MARKER, _build_job_prompt
+from cron.scheduler import _resolve_origin, _resolve_delivery_target, _deliver_result, run_job, SILENT_MARKER, _build_job_prompt


 class TestResolveOrigin:
@@ -277,188 +277,6 @@ class TestDeliverResultWrapping:
        # Media files should be forwarded separately
        assert kwargs["media_files"] == [("/tmp/test-voice.ogg", False)]

-    def test_live_adapter_sends_media_as_attachments(self):
-        """When a live adapter is available, MEDIA files should be sent as native
-        platform attachments (e.g., Discord voice, Telegram audio) rather than
-        as literal 'MEDIA:/path' text."""
-        from gateway.config import Platform
-        from concurrent.futures import Future
-
-        adapter = AsyncMock()
-        adapter.send.return_value = MagicMock(success=True)
-        adapter.send_voice.return_value = MagicMock(success=True)
-
-        pconfig = MagicMock()
-        pconfig.enabled = True
-        mock_cfg = MagicMock()
-        mock_cfg.platforms = {Platform.DISCORD: pconfig}
-
-        loop = MagicMock()
-        loop.is_running.return_value = True
-
-        # run_coroutine_threadsafe returns concurrent.futures.Future (has timeout kwarg)
-        def fake_run_coro(coro, _loop):
-            future = Future()
-            future.set_result(MagicMock(success=True))
-            coro.close()
-            return future
-
-        job = {
-            "id": "tts-job",
-            "deliver": "origin",
-            "origin": {"platform": "discord", "chat_id": "9876"},
-        }
-
-        with patch("gateway.config.load_gateway_config", return_value=mock_cfg), \
-             patch("cron.scheduler.load_config", return_value={"cron": {"wrap_response": False}}), \
-             patch("asyncio.run_coroutine_threadsafe", side_effect=fake_run_coro):
-            _deliver_result(
-                job,
-                "Here is TTS\nMEDIA:/tmp/cron-voice.mp3",
-                adapters={Platform.DISCORD: adapter},
-                loop=loop,
-            )
-
-        # Text should be sent without the MEDIA tag
-        adapter.send.assert_called_once()
-        text_sent = adapter.send.call_args[0][1]
-        assert "MEDIA:" not in text_sent
-        assert "Here is TTS" in text_sent
-
-        # Audio file should be sent as a voice attachment
-        adapter.send_voice.assert_called_once()
-        voice_call = adapter.send_voice.call_args
-        assert voice_call[1]["audio_path"] == "/tmp/cron-voice.mp3"
-
-    def test_live_adapter_routes_image_to_send_image_file(self):
-        """Image MEDIA files should be routed to send_image_file, not send_voice."""
-        from gateway.config import Platform
-        from concurrent.futures import Future
-
-        adapter = AsyncMock()
-        adapter.send.return_value = MagicMock(success=True)
-        adapter.send_image_file.return_value = MagicMock(success=True)
-
-        pconfig = MagicMock()
-        pconfig.enabled = True
-        mock_cfg = MagicMock()
-        mock_cfg.platforms = {Platform.DISCORD: pconfig}
-
-        loop = MagicMock()
-        loop.is_running.return_value = True
-
-        def fake_run_coro(coro, _loop):
-            future = Future()
-            future.set_result(MagicMock(success=True))
-            coro.close()
-            return future
-
-        job = {
-            "id": "img-job",
-            "deliver": "origin",
-            "origin": {"platform": "discord", "chat_id": "1234"},
-        }
-
-        with patch("gateway.config.load_gateway_config", return_value=mock_cfg), \
-             patch("cron.scheduler.load_config", return_value={"cron": {"wrap_response": False}}), \
-             patch("asyncio.run_coroutine_threadsafe", side_effect=fake_run_coro):
-            _deliver_result(
-                job,
-                "Chart attached\nMEDIA:/tmp/chart.png",
-                adapters={Platform.DISCORD: adapter},
-                loop=loop,
-            )
-
-        adapter.send_image_file.assert_called_once()
-        assert adapter.send_image_file.call_args[1]["image_path"] == "/tmp/chart.png"
-        adapter.send_voice.assert_not_called()
-
-    def test_live_adapter_media_only_no_text(self):
-        """When content is ONLY a MEDIA tag with no text, media should still be sent."""
-        from gateway.config import Platform
-        from concurrent.futures import Future
-
-        adapter = AsyncMock()
-        adapter.send_voice.return_value = MagicMock(success=True)
-
-        pconfig = MagicMock()
-        pconfig.enabled = True
-        mock_cfg = MagicMock()
-        mock_cfg.platforms = {Platform.TELEGRAM: pconfig}
-
-        loop = MagicMock()
-        loop.is_running.return_value = True
-
-        def fake_run_coro(coro, _loop):
-            future = Future()
-            future.set_result(MagicMock(success=True))
-            coro.close()
-            return future
-
-        job = {
-            "id": "voice-only",
-            "deliver": "origin",
-            "origin": {"platform": "telegram", "chat_id": "999"},
-        }
-
-        with patch("gateway.config.load_gateway_config", return_value=mock_cfg), \
-             patch("cron.scheduler.load_config", return_value={"cron": {"wrap_response": False}}), \
-             patch("asyncio.run_coroutine_threadsafe", side_effect=fake_run_coro):
-            _deliver_result(
-                job,
-                "MEDIA:/tmp/voice.ogg",
-                adapters={Platform.TELEGRAM: adapter},
-                loop=loop,
-            )
-
-        # Text send should NOT be called (no text after stripping MEDIA tag)
-        adapter.send.assert_not_called()
-        # Audio should still be delivered
-        adapter.send_voice.assert_called_once()
-
-    def test_live_adapter_sends_cleaned_text_not_raw(self):
-        """The live adapter path must send cleaned text (MEDIA tags stripped),
-        not the raw delivery_content with embedded MEDIA: tags."""
-        from gateway.config import Platform
-        from concurrent.futures import Future
-
-        adapter = AsyncMock()
-        adapter.send.return_value = MagicMock(success=True)
-
-        pconfig = MagicMock()
-        pconfig.enabled = True
-        mock_cfg = MagicMock()
-        mock_cfg.platforms = {Platform.TELEGRAM: pconfig}
-
-        loop = MagicMock()
-        loop.is_running.return_value = True
-
-        def fake_run_coro(coro, _loop):
-            future = Future()
-            future.set_result(MagicMock(success=True))
-            coro.close()
-            return future
-
-        job = {
-            "id": "img-job",
-            "deliver": "origin",
-            "origin": {"platform": "telegram", "chat_id": "555"},
-        }
-
-        with patch("gateway.config.load_gateway_config", return_value=mock_cfg), \
-             patch("cron.scheduler.load_config", return_value={"cron": {"wrap_response": False}}), \
-             patch("asyncio.run_coroutine_threadsafe", side_effect=fake_run_coro):
-            _deliver_result(
-                job,
-                "Report\nMEDIA:/tmp/chart.png",
-                adapters={Platform.TELEGRAM: adapter},
-                loop=loop,
-            )
-
-        text_sent = adapter.send.call_args[0][1]
-        assert "MEDIA:" not in text_sent
-        assert "Report" in text_sent
-
    def test_no_mirror_to_session_call(self):
        """Cron deliveries should NOT mirror into the gateway session."""
        from gateway.config import Platform
@@ -1044,57 +862,3 @@ class TestTickAdvanceBeforeRun:
        adv_mock.assert_called_once_with("test-advance")
        # advance must happen before run
        assert call_order == [("advance", "test-advance"), ("run", "test-advance")]
-
-
-class TestSendMediaViaAdapter:
-    """Unit tests for _send_media_via_adapter — routes files to typed adapter methods."""
-
-    @staticmethod
-    def _run_with_loop(adapter, chat_id, media_files, metadata, job):
-        """Helper: run _send_media_via_adapter with a real running event loop."""
-        import asyncio
-        import threading
-
-        loop = asyncio.new_event_loop()
-        t = threading.Thread(target=loop.run_forever, daemon=True)
-        t.start()
-        try:
-            _send_media_via_adapter(adapter, chat_id, media_files, metadata, loop, job)
-        finally:
-            loop.call_soon_threadsafe(loop.stop)
-            t.join(timeout=5)
-            loop.close()
-
-    def test_video_dispatched_to_send_video(self):
-        adapter = MagicMock()
-        adapter.send_video = AsyncMock()
-        media_files = [("/tmp/clip.mp4", False)]
-        self._run_with_loop(adapter, "123", media_files, None, {"id": "j1"})
-        adapter.send_video.assert_called_once()
-        assert adapter.send_video.call_args[1]["video_path"] == "/tmp/clip.mp4"
-
-    def test_unknown_ext_dispatched_to_send_document(self):
-        adapter = MagicMock()
-        adapter.send_document = AsyncMock()
-        media_files = [("/tmp/report.pdf", False)]
-        self._run_with_loop(adapter, "123", media_files, None, {"id": "j2"})
-        adapter.send_document.assert_called_once()
-        assert adapter.send_document.call_args[1]["file_path"] == "/tmp/report.pdf"
-
-    def test_multiple_media_files_all_delivered(self):
-        adapter = MagicMock()
-        adapter.send_voice = AsyncMock()
-        adapter.send_image_file = AsyncMock()
-        media_files = [("/tmp/voice.mp3", False), ("/tmp/photo.jpg", False)]
-        self._run_with_loop(adapter, "123", media_files, None, {"id": "j3"})
-        adapter.send_voice.assert_called_once()
-        adapter.send_image_file.assert_called_once()
-
-    def test_single_failure_does_not_block_others(self):
-        adapter = MagicMock()
-        adapter.send_voice = AsyncMock(side_effect=RuntimeError("network error"))
-        adapter.send_image_file = AsyncMock()
-        media_files = [("/tmp/voice.ogg", False), ("/tmp/photo.png", False)]
-        self._run_with_loop(adapter, "123", media_files, None, {"id": "j4"})
-        adapter.send_voice.assert_called_once()
-        adapter.send_image_file.assert_called_once()
@@ -33,15 +33,8 @@ def _ensure_telegram_mock():
    mod.constants.ChatType.GROUP = "group"
    mod.constants.ChatType.SUPERGROUP = "supergroup"
    mod.constants.ChatType.CHANNEL = "channel"
-    # Provide real exception classes so ``except (NetworkError, ...)`` in
-    # connect() doesn't blow up under xdist when this mock leaks.
-    mod.error.NetworkError = type("NetworkError", (OSError,), {})
-    mod.error.TimedOut = type("TimedOut", (OSError,), {})
-    mod.error.BadRequest = type("BadRequest", (Exception,), {})
-
-    for name in ("telegram", "telegram.ext", "telegram.constants", "telegram.request"):
+    for name in ("telegram", "telegram.ext", "telegram.constants", "telegram.request", "telegram.error"):
        sys.modules.setdefault(name, mod)
-    sys.modules.setdefault("telegram.error", mod.error)


 _ensure_telegram_mock()
@@ -20,16 +20,8 @@ def _ensure_telegram_mock():
    telegram_mod.constants.ChatType.CHANNEL = "channel"
    telegram_mod.constants.ChatType.PRIVATE = "private"

-    # Provide real exception classes so ``except (NetworkError, ...)`` in
-    # connect() doesn't blow up with "catching classes that do not inherit
-    # from BaseException" when another xdist worker pollutes sys.modules.
-    telegram_mod.error.NetworkError = type("NetworkError", (OSError,), {})
-    telegram_mod.error.TimedOut = type("TimedOut", (OSError,), {})
-    telegram_mod.error.BadRequest = type("BadRequest", (Exception,), {})
-
    for name in ("telegram", "telegram.ext", "telegram.constants", "telegram.request"):
        sys.modules.setdefault(name, telegram_mod)
-    sys.modules.setdefault("telegram.error", telegram_mod.error)


 _ensure_telegram_mock()
@@ -15,7 +15,7 @@ def test_version_string_no_v_prefix():
    assert not __version__.startswith("v"), f"__version__ should not start with 'v', got {__version__!r}"


-def test_check_for_updates_uses_cache(tmp_path, monkeypatch):
+def test_check_for_updates_uses_cache(tmp_path):
    """When cache is fresh, check_for_updates should return cached value without calling git."""
    from hermes_cli.banner import check_for_updates

@@ -27,15 +27,15 @@ def test_check_for_updates_uses_cache(tmp_path, monkeypatch):
    cache_file = tmp_path / ".update_check"
    cache_file.write_text(json.dumps({"ts": time.time(), "behind": 3}))

-    monkeypatch.setenv("HERMES_HOME", str(tmp_path))
-    with patch("hermes_cli.banner.subprocess.run") as mock_run:
-        result = check_for_updates()
+    with patch("hermes_cli.banner.os.getenv", return_value=str(tmp_path)):
+        with patch("hermes_cli.banner.subprocess.run") as mock_run:
+            result = check_for_updates()

    assert result == 3
    mock_run.assert_not_called()


-def test_check_for_updates_expired_cache(tmp_path, monkeypatch):
+def test_check_for_updates_expired_cache(tmp_path):
    """When cache is expired, check_for_updates should call git fetch."""
    from hermes_cli.banner import check_for_updates

@@ -49,15 +49,15 @@ def test_check_for_updates_expired_cache(tmp_path, monkeypatch):

    mock_result = MagicMock(returncode=0, stdout="5\n")

-    monkeypatch.setenv("HERMES_HOME", str(tmp_path))
-    with patch("hermes_cli.banner.subprocess.run", return_value=mock_result) as mock_run:
-        result = check_for_updates()
+    with patch("hermes_cli.banner.os.getenv", return_value=str(tmp_path)):
+        with patch("hermes_cli.banner.subprocess.run", return_value=mock_result) as mock_run:
+            result = check_for_updates()

    assert result == 5
    assert mock_run.call_count == 2  # git fetch + git rev-list


-def test_check_for_updates_no_git_dir(tmp_path, monkeypatch):
+def test_check_for_updates_no_git_dir(tmp_path):
    """Returns None when .git directory doesn't exist anywhere."""
    import hermes_cli.banner as banner

@@ -66,15 +66,19 @@ def test_check_for_updates_no_git_dir(tmp_path, monkeypatch):
    fake_banner.parent.mkdir(parents=True, exist_ok=True)
    fake_banner.touch()

-    monkeypatch.setattr(banner, "__file__", str(fake_banner))
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path))
-    with patch("hermes_cli.banner.subprocess.run") as mock_run:
-        result = banner.check_for_updates()
-    assert result is None
-    mock_run.assert_not_called()
+    original = banner.__file__
+    try:
+        banner.__file__ = str(fake_banner)
+        with patch("hermes_cli.banner.os.getenv", return_value=str(tmp_path)):
+            with patch("hermes_cli.banner.subprocess.run") as mock_run:
+                result = banner.check_for_updates()
+        assert result is None
+        mock_run.assert_not_called()
+    finally:
+        banner.__file__ = original


-def test_check_for_updates_fallback_to_project_root(tmp_path, monkeypatch):
+def test_check_for_updates_fallback_to_project_root():
    """Dev install: falls back to Path(__file__).parent.parent when HERMES_HOME has no git repo."""
    import hermes_cli.banner as banner

@@ -83,12 +87,14 @@ def test_check_for_updates_fallback_to_project_root(tmp_path, monkeypatch):
        pytest.skip("Not running from a git checkout")

    # Point HERMES_HOME at a temp dir with no hermes-agent/.git
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path))
-    with patch("hermes_cli.banner.subprocess.run") as mock_run:
-        mock_run.return_value = MagicMock(returncode=0, stdout="0\n")
-        result = banner.check_for_updates()
-    # Should have fallen back to project root and run git commands
-    assert mock_run.call_count >= 1
+    import tempfile
+    with tempfile.TemporaryDirectory() as td:
+        with patch("hermes_cli.banner.os.getenv", return_value=td):
+            with patch("hermes_cli.banner.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0, stdout="0\n")
+                result = banner.check_for_updates()
+        # Should have fallen back to project root and run git commands
+        assert mock_run.call_count >= 1


 def test_prefetch_non_blocking():
@@ -16,7 +16,7 @@ from unittest.mock import MagicMock
 import pytest

 # Ensure repo root is importable
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))

 try:
    from environments.agent_loop import (
@@ -31,7 +31,7 @@ import pytest
 # pytestmark removed — tests skip gracefully via OPENROUTER_API_KEY check on line 59

 # Ensure repo root is importable
-_repo_root = Path(__file__).resolve().parent.parent.parent
+_repo_root = Path(__file__).resolve().parent.parent
 if str(_repo_root) not in sys.path:
    sys.path.insert(0, str(_repo_root))

@@ -30,7 +30,7 @@ import pytest
 import requests

 # Ensure repo root is importable
-_repo_root = Path(__file__).resolve().parent.parent.parent
+_repo_root = Path(__file__).resolve().parent.parent
 if str(_repo_root) not in sys.path:
    sys.path.insert(0, str(_repo_root))

@@ -13,7 +13,7 @@ from unittest.mock import patch, MagicMock
 import pytest
 import yaml

-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))


 def _run_auxiliary_bridge(config_dict, monkeypatch):
@@ -199,7 +199,7 @@ class TestGatewayBridgeCodeParity:

    def test_gateway_has_auxiliary_bridge(self):
        """The gateway config bridge must include auxiliary.* bridging."""
-        gateway_path = Path(__file__).parent.parent.parent / "gateway" / "run.py"
+        gateway_path = Path(__file__).parent.parent / "gateway" / "run.py"
        content = gateway_path.read_text()
        # Check for key patterns that indicate the bridge is present
        assert "AUXILIARY_VISION_PROVIDER" in content
@@ -213,7 +213,7 @@ class TestGatewayBridgeCodeParity:

    def test_gateway_no_compression_env_bridge(self):
        """Gateway should NOT bridge compression config to env vars (config-only)."""
-        gateway_path = Path(__file__).parent.parent.parent / "gateway" / "run.py"
+        gateway_path = Path(__file__).parent.parent / "gateway" / "run.py"
        content = gateway_path.read_text()
        assert "CONTEXT_COMPRESSION_PROVIDER" not in content
        assert "CONTEXT_COMPRESSION_MODEL" not in content
@@ -330,7 +330,7 @@ def test_model_flow_nous_prints_subscription_guidance_without_mutating_explicit_
        "hermes_cli.auth.fetch_nous_models",
        lambda *args, **kwargs: ["claude-opus-4-6"],
    )
-    monkeypatch.setattr("hermes_cli.auth._prompt_model_selection", lambda model_ids, current_model="", pricing=None, **kw: "claude-opus-4-6")
+    monkeypatch.setattr("hermes_cli.auth._prompt_model_selection", lambda model_ids, current_model="", pricing=None: "claude-opus-4-6")
    monkeypatch.setattr("hermes_cli.auth._save_model_choice", lambda model: None)
    monkeypatch.setattr("hermes_cli.auth._update_config_for_provider", lambda provider, url: None)
    monkeypatch.setattr(
@@ -368,7 +368,7 @@ def test_model_flow_nous_applies_managed_tts_default_when_unconfigured(monkeypat
        "hermes_cli.auth.fetch_nous_models",
        lambda *args, **kwargs: ["claude-opus-4-6"],
    )
-    monkeypatch.setattr("hermes_cli.auth._prompt_model_selection", lambda model_ids, current_model="", pricing=None, **kw: "claude-opus-4-6")
+    monkeypatch.setattr("hermes_cli.auth._prompt_model_selection", lambda model_ids, current_model="", pricing=None: "claude-opus-4-6")
    monkeypatch.setattr("hermes_cli.auth._save_model_choice", lambda model: None)
    monkeypatch.setattr("hermes_cli.auth._update_config_for_provider", lambda provider, url: None)
    monkeypatch.setattr(
@@ -1,6 +1,6 @@
 """Regression tests for CLI /retry history replacement semantics."""

-from tests.cli.test_cli_init import _make_cli
+from tests.test_cli_init import _make_cli


 def test_retry_last_truncates_history_before_requeueing_message():
@@ -23,7 +23,7 @@ logging.basicConfig(level=logging.DEBUG, stream=sys.stderr,
                    format="%(asctime)s [%(threadName)s] %(message)s")
 log = logging.getLogger("interrupt_test")

-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 from unittest.mock import MagicMock, patch
 from run_agent import AIAgent, IterationBudget
@@ -122,7 +122,7 @@ class TestSourceLinesAreClamped:
    @staticmethod
    def _read_file(rel_path: str) -> str:
        import os
-        base = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+        base = os.path.dirname(os.path.dirname(__file__))
        with open(os.path.join(base, rel_path)) as f:
            return f.read()

--- a/Show More
+++ b/Show More